Lines Matching refs:Array
28 // Check that splicing array of holes keeps it as array of holes
31 var array = new Array(10);
32 var spliced = array.splice(1, 1, 'one', 'two');
36 assertEquals(11, array.length);
37 assertFalse(0 in array, "0 in array");
38 assertTrue(1 in array);
39 assertTrue(2 in array);
40 assertFalse(3 in array, "3 in array");
45 // Check various variants of empty array's splicing.
56 // Check that even if result array is empty, receiver gets sliced.
68 var array;
70 array = [1, 2, 3]
71 assertEquals([], array.splice());
72 assertEquals([1, 2, 3], array);
78 array = [1, 2, 3]
79 assertEquals([1, 2, 3], array.splice(0));
80 assertEquals([], array);
82 array = [1, 2, 3]
83 assertEquals([1, 2, 3], array.splice(undefined));
84 assertEquals([], array);
86 array = [1, 2, 3]
87 assertEquals([1, 2, 3], array.splice("foobar"));
88 assertEquals([], array);
90 array = [1, 2, 3]
91 assertEquals([], array.splice(undefined, undefined));
92 assertEquals([1, 2, 3], array);
94 array = [1, 2, 3]
95 assertEquals([], array.splice("foobar", undefined));
96 assertEquals([1, 2, 3], array);
98 array = [1, 2, 3]
99 assertEquals([], array.splice(undefined, "foobar"));
100 assertEquals([1, 2, 3], array);
102 array = [1, 2, 3]
103 assertEquals([], array.splice("foobar", "foobar"));
104 assertEquals([1, 2, 3], array);
111 var array, spliced;
113 array = [1, 2, 3, 4, 5, 6, 7];
114 spliced = array.splice(-100);
115 assertEquals([], array);
118 array = [1, 2, 3, 4, 5, 6, 7];
119 spliced = array.splice(-1e100);
120 assertEquals([], array);
123 array = [1, 2, 3, 4, 5, 6, 7];
124 spliced = array.splice(-3);
125 assertEquals([1, 2, 3, 4], array);
128 array = [1, 2, 3, 4, 5, 6, 7];
129 spliced = array.splice(-3.999999);
130 assertEquals([1, 2, 3, 4], array);
133 array = [1, 2, 3, 4, 5, 6, 7];
134 spliced = array.splice(-3.000001);
135 assertEquals([1, 2, 3, 4], array);
138 array = [1, 2, 3, 4, 5, 6, 7];
139 spliced = array.splice(4);
140 assertEquals([1, 2, 3, 4], array);
143 array = [1, 2, 3, 4, 5, 6, 7];
144 spliced = array.splice(4.999999);
145 assertEquals([1, 2, 3, 4], array);
148 array = [1, 2, 3, 4, 5, 6, 7];
149 spliced = array.splice(4.000001);
150 assertEquals([1, 2, 3, 4], array);
153 array = [1, 2, 3, 4, 5, 6, 7];
154 spliced = array.splice(6);
155 assertEquals([1, 2, 3, 4, 5, 6], array);
158 array = [1, 2, 3, 4, 5, 6, 7];
159 spliced = array.splice(7);
160 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
163 array = [1, 2, 3, 4, 5, 6, 7];
164 spliced = array.splice(8);
165 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
168 array = [1, 2, 3, 4, 5, 6, 7];
169 spliced = array.splice(100);
170 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
173 array = [1, 2, 3, 4, 5, 6, 7];
174 spliced = array.splice(1e100);
175 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
178 array = [1, 2, 3, 4, 5, 6, 7];
179 spliced = array.splice(0, -100);
180 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
183 array = [1, 2, 3, 4, 5, 6, 7];
184 spliced = array.splice(0, -1e100);
185 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
188 array = [1, 2, 3, 4, 5, 6, 7];
189 spliced = array.splice(0, -3);
190 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
193 array = [1, 2, 3, 4, 5, 6, 7];
194 spliced = array.splice(0, -3.999999);
195 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
198 array = [1, 2, 3, 4, 5, 6, 7];
199 spliced = array.splice(0, -3.000001);
200 assertEquals([1, 2, 3, 4, 5, 6, 7], array);
203 array = [1, 2, 3, 4, 5, 6, 7];
204 spliced = array.splice(0, 4);
205 assertEquals([5, 6, 7], array);
208 array = [1, 2, 3, 4, 5, 6, 7];
209 spliced = array.splice(0, 4.999999);
210 assertEquals([5, 6, 7], array);
213 array = [1, 2, 3, 4, 5, 6, 7];
214 spliced = array.splice(0, 4.000001);
215 assertEquals([5, 6, 7], array);
218 array = [1, 2, 3, 4, 5, 6, 7];
219 spliced = array.splice(0, 6);
220 assertEquals([7], array);
223 array = [1, 2, 3, 4, 5, 6, 7];
224 spliced = array.splice(0, 7);
225 assertEquals([], array);
228 array = [1, 2, 3, 4, 5, 6, 7];
229 spliced = array.splice(0, 8);
230 assertEquals([], array);
233 array = [1, 2, 3, 4, 5, 6, 7];
234 spliced = array.splice(0, 100);
235 assertEquals([], array);
238 array = [1, 2, 3, 4, 5, 6, 7];
239 spliced = array.splice(0, 1e100);
240 assertEquals([], array);
261 array = [1, 2, 3];
262 array.splice(0, 3, obj);
263 assertEquals(1, array.length);
266 array = [1, 2, 3];
267 spliced = array.splice({valueOf: function() { return 1; }},
271 assertEquals([1, 'one', 'two'], array);
276 // Nasty: modify the array in ToInteger.
278 var array = [];
282 bad_start = { valueOf: function() { array.push(2*i); return -1; } };
283 bad_count = { valueOf: function() { array.push(2*i + 1); return 1; } };
284 spliced = array.splice(bad_start, bad_count);
288 array.push(2*i); array.push(2*i + 1);
291 assertEquals([0, 1], array);
293 // When we start splice, array is [0 .. 2*i - 1], so we get
294 // as a result [2*i], this element is removed from the array,
297 assertEquals(2 * i, array[i]);
298 assertEquals(2 * i + 1, array[i + 1]);
307 new Array(Math.pow(2, 32) - 3).splice(-1, 0, 1, 2, 3, 4, 5);
315 var array = new Array(bigNum);
316 array.splice(-1, 0, 1, 2, 3, 4, 5, 6, 7);
317 assertEquals(bigNum + 7, array.length);
338 // Array.prototype.
343 var array = [1, 2, 3, 4];
344 Array.prototype[3] = 'foo'; // To force JS builtin.
346 var spliced = array.splice();
349 assertEquals([1, 2, 3, 4], array);
353 // Now check the case with array of holes and some elements on prototype.
361 var array = new Array(len);
365 array.__proto__ = array_proto;
367 var spliced = array.splice(2, 2, 'one', undefined, 'two');
369 // Second hole (at index 3) of array turns into
370 // value of Array.prototype[3] while copying.
372 assertEquals([, , 'one', undefined, 'two', , , at7, at7, ,], array);
374 // ... but array[3] and array[7] is actually a hole:
376 assertEquals(undefined, array[3]);
378 assertEquals(undefined, array[7]);
381 assertFalse(array.hasOwnProperty(0), "array.hasOwnProperty(0)");
382 assertFalse(array.hasOwnProperty(1), "array.hasOwnProperty(1)");
383 assertTrue(array.hasOwnProperty(2));
384 assertTrue(array.hasOwnProperty(3));
385 assertTrue(array.hasOwnProperty(4));
386 assertFalse(array.hasOwnProperty(5), "array.hasOwnProperty(5)");
387 assertFalse(array.hasOwnProperty(6), "array.hasOwnProperty(6)");
388 assertFalse(array.hasOwnProperty(7), "array.hasOwnProperty(7)");
389 assertTrue(array.hasOwnProperty(8));
390 assertFalse(array.hasOwnProperty(9), "array.hasOwnProperty(9)");
393 assertFalse(array.hasOwnProperty(10), "array.hasOwnProperty(10)");
394 assertFalse(array.hasOwnProperty(15), "array.hasOwnProperty(15)");
395 assertFalse(array.hasOwnProperty(31), "array.hasOwnProperty(31)");
396 assertFalse(array.hasOwnProperty(63), "array.hasOwnProperty(63)");
397 assertFalse(array.hasOwnProperty(Math.pow(2, 32) - 2),
398 "array.hasOwnProperty(Math.pow(2, 32) - 2)");
402 // Now check the case with array of holes and some elements on prototype.
410 var array = new Array(len);
411 Array.prototype[3] = at3;
412 Array.prototype[7] = at7;
414 var spliced = array.splice(2, 2, 'one', undefined, 'two');
416 // Second hole (at index 3) of array turns into
417 // value of Array.prototype[3] while copying.
419 assertEquals([, , 'one', undefined, 'two', , , at7, at7, ,], array);
421 // ... but array[3] and array[7] is actually a hole:
422 assertTrue(delete Array.prototype[3]);
423 assertEquals(undefined, array[3]);
424 assertTrue(delete Array.prototype[7]);
425 assertEquals(undefined, array[7]);
428 assertFalse(array.hasOwnProperty(0), "array.hasOwnProperty(0)");
429 assertFalse(array.hasOwnProperty(1), "array.hasOwnProperty(1)");
430 assertTrue(array.hasOwnProperty(2));
431 assertTrue(array.hasOwnProperty(3));
432 assertTrue(array.hasOwnProperty(4));
433 assertFalse(array.hasOwnProperty(5), "array.hasOwnProperty(5)");
434 assertFalse(array.hasOwnProperty(6), "array.hasOwnProperty(6)");
435 assertFalse(array.hasOwnProperty(7), "array.hasOwnProperty(7)");
436 assertTrue(array.hasOwnProperty(8));
437 assertFalse(array.hasOwnProperty(9), "array.hasOwnProperty(9)");
440 assertFalse(array.hasOwnProperty(10), "array.hasOwnProperty(10)");
441 assertFalse(array.hasOwnProperty(15), "array.hasOwnProperty(15)");
442 assertFalse(array.hasOwnProperty(31), "array.hasOwnProperty(31)");
443 assertFalse(array.hasOwnProperty(63), "array.hasOwnProperty(63)");
444 assertFalse(array.hasOwnProperty(Math.pow(2, 32) - 2),
445 "array.hasOwnProperty(Math.pow(2, 32) - 2)");
