AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
8616be0c94
v8/test/mjsunit/es6/array-concat.js

897 lines
26 KiB
JavaScript
Raw Blame History

// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
(function testArrayConcatArity() {
"use strict";
assertEquals(1, Array.prototype.concat.length);
})();
(function testArrayConcatNoPrototype() {
"use strict";
assertEquals(void 0, Array.prototype.concat.prototype);
})();
(function testArrayConcatDescriptor() {
"use strict";
var desc = Object.getOwnPropertyDescriptor(Array.prototype, 'concat');
assertEquals(false, desc.enumerable);
})();
(function testNonConcatSpreadableArray() {
"use strict"
var array = [1, 2, 3];
assertEquals(array, [].concat(array));
assertEquals(array, array.concat([]));
array[Symbol.isConcatSpreadable] = false;
assertEquals([[1,2,3]], [].concat(array));
assertEquals([[1,2,3]], array.concat([]));
})();
(function testConcatArrayLike() {
"use strict";
var obj = {
"length": 6,
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
var obj2 = { length: 3, "0": "0", "1": "1", "2": "2" };
var arr = ["X", "Y", "Z"];
assertEquals([void 0, "A", void 0, "B", void 0, "C",
{ "length": 3, "0": "0", "1": "1", "2": "2" },
"X", "Y", "Z"], Array.prototype.concat.call(obj, obj2, arr));
})();
(function testConcatArrayLikeStringLength() {
"use strict";
var obj = {
"length": "6",
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
var obj2 = { length: 3, "0": "0", "1": "1", "2": "2" };
var arr = ["X", "Y", "Z"];
assertEquals([void 0, "A", void 0, "B", void 0, "C",
{ "length": 3, "0": "0", "1": "1", "2": "2" },
"X", "Y", "Z"], Array.prototype.concat.call(obj, obj2, arr));
})();
(function testConcatArrayLikeNegativeLength() {
"use strict";
var obj = {
"length": -6,
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
assertEquals([], [].concat(obj));
obj.length = -6.7;
assertEquals([], [].concat(obj));
obj.length = "-6";
assertEquals([], [].concat(obj));
})();
(function testConcatArrayLikeToLengthThrows() {
"use strict";
var obj = {
"length": {valueOf: null, toString: null},
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
var obj2 = { length: 3, "0": "0", "1": "1", "2": "2" };
var arr = ["X", "Y", "Z"];
assertThrows(function() {
Array.prototype.concat.call(obj, obj2, arr);
}, TypeError);
})();
(function testConcatArrayLikePrimitiveNonNumberLength() {
"use strict";
var obj = {
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
obj.length = {toString: function() { return "SIX"; }, valueOf: null };
assertEquals([], [].concat(obj));
obj.length = {toString: null, valueOf: function() { return "SIX"; } };
assertEquals([], [].concat(obj));
})();
(function testConcatArrayLikeLengthToStringThrows() {
"use strict";
function MyError() {}
var obj = {
"length": { toString: function() {
throw new MyError();
}, valueOf: null
},
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
assertThrows(function() {
[].concat(obj);
}, MyError);
})();
(function testConcatArrayLikeLengthValueOfThrows() {
"use strict";
function MyError() {}
var obj = {
"length": { valueOf: function() {
throw new MyError();
}, toString: null
},
"1": "A",
"3": "B",
"5": "C"
};
obj[Symbol.isConcatSpreadable] = true;
assertThrows(function() {
[].concat(obj);
}, MyError);
})();
(function testConcatHoleyArray() {
"use strict";
var arr = [];
arr[4] = "Item 4";
arr[8] = "Item 8";
var arr2 = [".", "!", "?"];
assertEquals([void 0, void 0, void 0, void 0, "Item 4", void 0, void 0,
void 0, "Item 8", ".", "!", "?"], arr.concat(arr2));
})();
(function testIsConcatSpreadableGetterThrows() {
"use strict";
function MyError() {}
var obj = {};
Object.defineProperty(obj, Symbol.isConcatSpreadable, {
get: function() { throw new MyError(); }
});
assertThrows(function() {
[].concat(obj);
}, MyError);
assertThrows(function() {
Array.prototype.concat.call(obj, 1, 2, 3);
}, MyError);
})();
(function testConcatLengthThrows() {
"use strict";
function MyError() {}
var obj = {};
obj[Symbol.isConcatSpreadable] = true;
Object.defineProperty(obj, "length", {
get: function() { throw new MyError(); }
});
assertThrows(function() {
[].concat(obj);
}, MyError);
assertThrows(function() {
Array.prototype.concat.call(obj, 1, 2, 3);
}, MyError);
})();
(function testConcatArraySubclass() {
"use strict";
// If @@isConcatSpreadable is not used, the value of IsArray(O)
// is used to determine the spreadable property.
class A extends Array {}
var obj = [].concat(new A(1, 2, 3), new A(4, 5, 6), new A(7, 8, 9));
assertEquals(9, obj.length);
for (var i = 0; i < obj.length; ++i) {
assertEquals(i + 1, obj[i]);
}
// TODO(caitp): when concat is called on instances of classes which extend
// Array, they should:
//
// - return an instance of the class, rather than an Array instance (if from
// same Realm)
// - always treat such classes as concat-spreadable
})();
(function testConcatArraySubclassOptOut() {
"use strict";
class A extends Array {
get [Symbol.isConcatSpreadable]() { return false; }
}
var obj = [].concat(new A(1, 2, 3), new A(4, 5, 6), new A(7, 8, 9));
assertEquals(3, obj.length);
assertEquals(3, obj[0].length);
assertEquals(3, obj[1].length);
assertEquals(3, obj[2].length);
})();
(function testConcatNonArray() {
"use strict";
class NonArray {
constructor() { Array.apply(this, arguments); }
};
var obj = new NonArray(1,2,3);
var result = Array.prototype.concat.call(obj, 4, 5, 6);
assertEquals(Array, result.constructor);
assertEquals([obj,4,5,6], result);
assertFalse(result instanceof NonArray);
})();
function testConcatTypedArray(type, elems, modulo) {
"use strict";
var items = new Array(elems);
var ta_by_len = new type(elems);
for (var i = 0; i < elems; ++i) {
ta_by_len[i] = items[i] = modulo === false ? i : elems % modulo;
}
var ta = new type(items);
assertEquals([ta, ta], [].concat(ta, ta));
ta[Symbol.isConcatSpreadable] = true;
assertEquals(items, [].concat(ta));
assertEquals([ta_by_len, ta_by_len], [].concat(ta_by_len, ta_by_len));
ta_by_len[Symbol.isConcatSpreadable] = true;
assertEquals(items, [].concat(ta_by_len));
// TypedArray with fake `length`.
ta = new type(1);
var defValue = ta[0];
var expected = new Array(4000);
expected[0] = defValue;
Object.defineProperty(ta, "length", { value: 4000 });
ta[Symbol.isConcatSpreadable] = true;
assertEquals(expected, [].concat(ta));
}
(function testConcatSmallTypedArray() {
var length = 1;
testConcatTypedArray(Uint8Array, length, Math.pow(2, 8));
testConcatTypedArray(Uint16Array, length, Math.pow(2, 16));
testConcatTypedArray(Uint32Array, length, Math.pow(2, 32));
testConcatTypedArray(Float32Array, length, false);
testConcatTypedArray(Float64Array, length, false);
})();
(function testConcatLargeTypedArray() {
var length = 4000;
testConcatTypedArray(Uint8Array, length, Math.pow(2, 8));
testConcatTypedArray(Uint16Array, length, Math.pow(2, 16));
testConcatTypedArray(Uint32Array, length, Math.pow(2, 32));
testConcatTypedArray(Float32Array, length, false);
testConcatTypedArray(Float64Array, length, false);
})();
(function testConcatStrictArguments() {
var args = (function(a, b, c) { "use strict"; return arguments; })(1,2,3);
args[Symbol.isConcatSpreadable] = true;
assertEquals([1, 2, 3, 1, 2, 3], [].concat(args, args));
Object.defineProperty(args, "length", { value: 6 });
assertEquals([1, 2, 3, void 0, void 0, void 0], [].concat(args));
})();
(function testConcatSloppyArguments() {
var args = (function(a, b, c) { return arguments; })(1,2,3);
args[Symbol.isConcatSpreadable] = true;
assertEquals([1, 2, 3, 1, 2, 3], [].concat(args, args));
Object.defineProperty(args, "length", { value: 6 });
assertEquals([1, 2, 3, void 0, void 0, void 0], [].concat(args));
})();
(function testConcatSloppyArgumentsWithDupes() {
var args = (function(a, a, a) { return arguments; })(1,2,3);
args[Symbol.isConcatSpreadable] = true;
assertEquals([1, 2, 3, 1, 2, 3], [].concat(args, args));
Object.defineProperty(args, "length", { value: 6 });
assertEquals([1, 2, 3, void 0, void 0, void 0], [].concat(args));
})();
(function testConcatSloppyArgumentsThrows() {
function MyError() {}
var args = (function(a) { return arguments; })(1,2,3);
Object.defineProperty(args, 0, {
get: function() { throw new MyError(); }
});
args[Symbol.isConcatSpreadable] = true;
assertThrows(function() {
return [].concat(args, args);
}, MyError);
})();
(function testConcatHoleySloppyArguments() {
var args = (function(a) { return arguments; })(1,2,3);
delete args[1];
args[Symbol.isConcatSpreadable] = true;
assertEquals([1, void 0, 3, 1, void 0, 3], [].concat(args, args));
})();
(function testConcatSpreadableStringWrapper() {
"use strict";
var str1 = new String("yuck\uD83D\uDCA9")
// String wrapper objects are not concat-spreadable by default
assertEquals([str1], [].concat(str1));
// String wrapper objects may be individually concat-spreadable
str1[Symbol.isConcatSpreadable] = true;
assertEquals(["y", "u", "c", "k", "\uD83D", "\uDCA9"],
[].concat(str1));
String.prototype[Symbol.isConcatSpreadable] = true;
// String wrapper objects may be concat-spreadable
assertEquals(["y", "u", "c", "k", "\uD83D", "\uDCA9"],
[].concat(new String("yuck\uD83D\uDCA9")));
// String values are never concat-spreadable
assertEquals(["yuck\uD83D\uDCA9"], [].concat("yuck\uD83D\uDCA9"));
delete String.prototype[Symbol.isConcatSpreadable];
})();
(function testConcatSpreadableBooleanWrapper() {
"use strict";
var bool = new Boolean(true)
// Boolean wrapper objects are not concat-spreadable by default
assertEquals([bool], [].concat(bool));
// Boolean wrapper objects may be individually concat-spreadable
bool[Symbol.isConcatSpreadable] = true;
bool.length = 3;
bool[0] = 1, bool[1] = 2, bool[2] = 3;
assertEquals([1, 2, 3], [].concat(bool));
Boolean.prototype[Symbol.isConcatSpreadable] = true;
// Boolean wrapper objects may be concat-spreadable
assertEquals([], [].concat(new Boolean(true)));
Boolean.prototype[0] = 1;
Boolean.prototype[1] = 2;
Boolean.prototype[2] = 3;
Boolean.prototype.length = 3;
assertEquals([1,2,3], [].concat(new Boolean(true)));
// Boolean values are never concat-spreadable
assertEquals([true], [].concat(true));
delete Boolean.prototype[Symbol.isConcatSpreadable];
delete Boolean.prototype[0];
delete Boolean.prototype[1];
delete Boolean.prototype[2];
delete Boolean.prototype.length;
})();
(function testConcatSpreadableNumberWrapper() {
"use strict";
var num = new Number(true)
// Number wrapper objects are not concat-spreadable by default
assertEquals([num], [].concat(num));
// Number wrapper objects may be individually concat-spreadable
num[Symbol.isConcatSpreadable] = true;
num.length = 3;
num[0] = 1, num[1] = 2, num[2] = 3;
assertEquals([1, 2, 3], [].concat(num));
Number.prototype[Symbol.isConcatSpreadable] = true;
// Number wrapper objects may be concat-spreadable
assertEquals([], [].concat(new Number(123)));
Number.prototype[0] = 1;
Number.prototype[1] = 2;
Number.prototype[2] = 3;
Number.prototype.length = 3;
assertEquals([1,2,3], [].concat(new Number(123)));
// Number values are never concat-spreadable
assertEquals([true], [].concat(true));
delete Number.prototype[Symbol.isConcatSpreadable];
delete Number.prototype[0];
delete Number.prototype[1];
delete Number.prototype[2];
delete Number.prototype.length;
})();
(function testConcatSpreadableFunction() {
"use strict";
var fn = function(a, b, c) {}
// Functions are not concat-spreadable by default
assertEquals([fn], [].concat(fn));
// Functions may be individually concat-spreadable
fn[Symbol.isConcatSpreadable] = true;
fn[0] = 1, fn[1] = 2, fn[2] = 3;
assertEquals([1, 2, 3], [].concat(fn));
Function.prototype[Symbol.isConcatSpreadable] = true;
// Functions may be concat-spreadable
assertEquals([void 0, void 0, void 0], [].concat(function(a,b,c) {}));
Function.prototype[0] = 1;
Function.prototype[1] = 2;
Function.prototype[2] = 3;
assertEquals([1,2,3], [].concat(function(a, b, c) {}));
delete Function.prototype[Symbol.isConcatSpreadable];
delete Function.prototype[0];
delete Function.prototype[1];
delete Function.prototype[2];
})();
(function testConcatSpreadableRegExp() {
"use strict";
var re = /abc/;
// RegExps are not concat-spreadable by default
assertEquals([re], [].concat(re));
// RegExps may be individually concat-spreadable
re[Symbol.isConcatSpreadable] = true;
re[0] = 1, re[1] = 2, re[2] = 3, re.length = 3;
assertEquals([1, 2, 3], [].concat(re));
// RegExps may be concat-spreadable
RegExp.prototype[Symbol.isConcatSpreadable] = true;
RegExp.prototype.length = 3;
assertEquals([void 0, void 0, void 0], [].concat(/abc/));
RegExp.prototype[0] = 1;
RegExp.prototype[1] = 2;
RegExp.prototype[2] = 3;
assertEquals([1,2,3], [].concat(/abc/));
delete RegExp.prototype[Symbol.isConcatSpreadable];
delete RegExp.prototype[0];
delete RegExp.prototype[1];
delete RegExp.prototype[2];
delete RegExp.prototype.length;
})();
(function testArrayConcatSpreadableSparseObject() {
"use strict";
var obj = { length: 5 };
obj[Symbol.isConcatSpreadable] = true;
assertEquals([void 0, void 0, void 0, void 0, void 0], [].concat(obj));
obj.length = 4000;
assertEquals(new Array(4000), [].concat(obj));
})();
// ES5 tests
(function testArrayConcatES5() {
"use strict";
var poses;
var pos;
poses = [140, 4000000000];
while (pos = poses.shift()) {
var a = new Array(pos);
var array_proto = [];
a.__proto__ = array_proto;
assertEquals(pos, a.length);
a.push('foo');
assertEquals(pos + 1, a.length);
var b = ['bar'];
var c = a.concat(b);
assertEquals(pos + 2, c.length);
assertEquals("undefined", typeof(c[pos - 1]));
assertEquals("foo", c[pos]);
assertEquals("bar", c[pos + 1]);
// Can we fool the system by putting a number in a string?
var onetwofour = "124";
a[onetwofour] = 'doo';
assertEquals(a[124], 'doo');
c = a.concat(b);
assertEquals(c[124], 'doo');
// If we put a number in the prototype, then the spec says it should be
// copied on concat.
array_proto["123"] = 'baz';
assertEquals(a[123], 'baz');
c = a.concat(b);
assertEquals(pos + 2, c.length);
assertEquals("baz", c[123]);
assertEquals("undefined", typeof(c[pos - 1]));
assertEquals("foo", c[pos]);
assertEquals("bar", c[pos + 1]);
// When we take the number off the prototype it disappears from a, but
// the concat put it in c itself.
array_proto["123"] = undefined;
assertEquals("undefined", typeof(a[123]));
assertEquals("baz", c[123]);
// If the element of prototype is shadowed, the element on the instance
// should be copied, but not the one on the prototype.
array_proto[123] = 'baz';
a[123] = 'xyz';
assertEquals('xyz', a[123]);
c = a.concat(b);
assertEquals('xyz', c[123]);
// Non-numeric properties on the prototype or the array shouldn't get
// copied.
array_proto.moe = 'joe';
a.ben = 'jerry';
assertEquals(a["moe"], 'joe');
assertEquals(a["ben"], 'jerry');
c = a.concat(b);
// ben was not copied
assertEquals("undefined", typeof(c.ben));
// When we take moe off the prototype it disappears from all arrays.
array_proto.moe = undefined;
assertEquals("undefined", typeof(c.moe));
// Negative indices don't get concated.
a[-1] = 'minus1';
assertEquals("minus1", a[-1]);
assertEquals("undefined", typeof(a[0xffffffff]));
c = a.concat(b);
assertEquals("undefined", typeof(c[-1]));
assertEquals("undefined", typeof(c[0xffffffff]));
assertEquals(c.length, a.length + 1);
}
poses = [140, 4000000000];
while (pos = poses.shift()) {
var a = new Array(pos);
assertEquals(pos, a.length);
a.push('foo');
assertEquals(pos + 1, a.length);
var b = ['bar'];
var c = a.concat(b);
assertEquals(pos + 2, c.length);
assertEquals("undefined", typeof(c[pos - 1]));
assertEquals("foo", c[pos]);
assertEquals("bar", c[pos + 1]);
// Can we fool the system by putting a number in a string?
var onetwofour = "124";
a[onetwofour] = 'doo';
assertEquals(a[124], 'doo');
c = a.concat(b);
assertEquals(c[124], 'doo');
// If we put a number in the prototype, then the spec says it should be
// copied on concat.
Array.prototype["123"] = 'baz';
assertEquals(a[123], 'baz');
c = a.concat(b);
assertEquals(pos + 2, c.length);
assertEquals("baz", c[123]);
assertEquals("undefined", typeof(c[pos - 1]));
assertEquals("foo", c[pos]);
assertEquals("bar", c[pos + 1]);
// When we take the number off the prototype it disappears from a, but
// the concat put it in c itself.
Array.prototype["123"] = undefined;
assertEquals("undefined", typeof(a[123]));
assertEquals("baz", c[123]);
// If the element of prototype is shadowed, the element on the instance
// should be copied, but not the one on the prototype.
Array.prototype[123] = 'baz';
a[123] = 'xyz';
assertEquals('xyz', a[123]);
c = a.concat(b);
assertEquals('xyz', c[123]);
// Non-numeric properties on the prototype or the array shouldn't get
// copied.
Array.prototype.moe = 'joe';
a.ben = 'jerry';
assertEquals(a["moe"], 'joe');
assertEquals(a["ben"], 'jerry');
c = a.concat(b);
// ben was not copied
assertEquals("undefined", typeof(c.ben));
// moe was not copied, but we can see it through the prototype
assertEquals("joe", c.moe);
// When we take moe off the prototype it disappears from all arrays.
Array.prototype.moe = undefined;
assertEquals("undefined", typeof(c.moe));
// Negative indices don't get concated.
a[-1] = 'minus1';
assertEquals("minus1", a[-1]);
assertEquals("undefined", typeof(a[0xffffffff]));
c = a.concat(b);
assertEquals("undefined", typeof(c[-1]));
assertEquals("undefined", typeof(c[0xffffffff]));
assertEquals(c.length, a.length + 1);
}
a = [];
c = a.concat('Hello');
assertEquals(1, c.length);
assertEquals("Hello", c[0]);
assertEquals("Hello", c.toString());
// Check that concat preserves holes.
var holey = [void 0,'a',,'c'].concat(['d',,'f',[0,,2],void 0])
assertEquals(9, holey.length); // hole in embedded array is ignored
for (var i = 0; i < holey.length; i++) {
if (i == 2 || i == 5) {
assertFalse(i in holey);
} else {
assertTrue(i in holey);
}
}
// Polluted prototype from prior tests.
delete Array.prototype[123];
// Check that concat reads getters in the correct order.
var arr1 = [,2];
var arr2 = [1,3];
var r1 = [].concat(arr1, arr2); // [,2,1,3]
assertEquals([,2,1,3], r1);
// Make first array change length of second array.
Object.defineProperty(arr1, 0, {get: function() {
arr2.push("X");
return undefined;
}, configurable: true})
var r2 = [].concat(arr1, arr2); // [undefined,2,1,3,"X"]
assertEquals([undefined,2,1,3,"X"], r2);
// Make first array change length of second array massively.
arr2.length = 2;
Object.defineProperty(arr1, 0, {get: function() {
arr2[500000] = "X";
return undefined;
}, configurable: true})
var r3 = [].concat(arr1, arr2); // [undefined,2,1,3,"X"]
var expected = [undefined,2,1,3];
expected[500000 + 2] = "X";
assertEquals(expected, r3);
var arr3 = [];
var trace = [];
var expectedTrace = []
function mkGetter(i) { return function() { trace.push(i); }; }
arr3.length = 10000;
for (var i = 0; i < 100; i++) {
Object.defineProperty(arr3, i * i, {get: mkGetter(i)});
expectedTrace[i] = i;
expectedTrace[100 + i] = i;
}
var r4 = [0].concat(arr3, arr3);
assertEquals(1 + arr3.length * 2, r4.length);
assertEquals(expectedTrace, trace);
// Clean up.
delete Array.prototype[123];
delete Array.prototype["123"];
delete Array.prototype["moe"];
})();
////////////////////////////////////////////////////////////////////////////////
// Tests with proxies
// Note: concat does not currently support species so there is no difference
// between [].concat(foo) and Array.prototype.concat.apply(foo).
var log = [];
var logger = {};
var handler = new Proxy({}, logger);
logger.get = function(t, trap, r) {
return function(...args) {
log.push([trap, ...args]);
return Reflect[trap](...args);
}
};
(function testUnspreadableNonArrayLikeProxy() {
var target = {0: "a", 1: "b"};
var obj = new Proxy(target, handler);
log.length = 0;
assertEquals([obj], [].concat(obj));
assertEquals(1, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
log.length = 0;
assertEquals([obj], Array.prototype.concat.apply(obj));
assertEquals(1, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
})();
(function testSpreadableNonArrayLikeProxy() {
var target = {0: "a", 1: "b", [Symbol.isConcatSpreadable]: "truish"};
var obj = new Proxy(target, handler);
log.length = 0;
assertEquals([], [].concat(obj));
assertEquals(2, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
assertEquals(["get", target, "length", obj], log[1]);
log.length = 0;
assertEquals([], Array.prototype.concat.apply(obj));
assertEquals(2, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
assertEquals(["get", target, "length", obj], log[1]);
target.length = 3;
log.length = 0;
assertEquals(["a", "b", undefined], [].concat(obj));
assertEquals(7, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
assertEquals(["get", target, "length", obj], log[1]);
assertEquals(["has", target, "0"], log[2]);
assertEquals(["get", target, "0", obj], log[3]);
assertEquals(["has", target, "1"], log[4]);
assertEquals(["get", target, "1", obj], log[5]);
assertEquals(["has", target, "2"], log[6]);
log.length = 0;
assertEquals(["a", "b", undefined], Array.prototype.concat.apply(obj));
assertEquals(7, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
assertEquals(["get", target, "length", obj], log[1]);
assertEquals(["has", target, "0"], log[2]);
assertEquals(["get", target, "0", obj], log[3]);
assertEquals(["has", target, "1"], log[4]);
assertEquals(["get", target, "1", obj], log[5]);
assertEquals(["has", target, "2"], log[6]);
})();
(function testUnspreadableArrayLikeProxy() {
var target = ["a", "b"];
target[Symbol.isConcatSpreadable] = "";
var obj = new Proxy(target, handler);
log.length = 0;
assertEquals([obj], [].concat(obj));
assertEquals(1, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
log.length = 0;
assertEquals([obj], Array.prototype.concat.apply(obj));
assertEquals(2, log.length); // An extra read for the constructor
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, "constructor", obj], log[0]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[1]);
})();
(function testSpreadableArrayLikeProxy() {
var target = ["a", "b"];
target[Symbol.isConcatSpreadable] = undefined;
var obj = new Proxy(target, handler);
log.length = 0;
assertEquals(["a", "b"], [].concat(obj));
assertEquals(6, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[0]);
assertEquals(["get", target, "length", obj], log[1]);
assertEquals(["has", target, "0"], log[2]);
assertEquals(["get", target, "0", obj], log[3]);
assertEquals(["has", target, "1"], log[4]);
assertEquals(["get", target, "1", obj], log[5]);
log.length = 0;
assertEquals(["a", "b"], Array.prototype.concat.apply(obj));
assertEquals(7, log.length);
for (var i in log) assertSame(target, log[i][1]);
assertEquals(["get", target, "constructor", obj], log[0]);
assertEquals(["get", target, Symbol.isConcatSpreadable, obj], log[1]);
assertEquals(["get", target, "length", obj], log[2]);
assertEquals(["has", target, "0"], log[3]);
assertEquals(["get", target, "0", obj], log[4]);
assertEquals(["has", target, "1"], log[5]);
assertEquals(["get", target, "1", obj], log[6]);
})();
(function testSpreadableArrayLikeProxyWithNontrivialLength() {
var getTrap = function(t, key) {
if (key === "length") return {[Symbol.toPrimitive]() {return 3}};
if (key === "2") return "baz";
if (key === "3") return "bar";
};
var target = [];
var obj = new Proxy(target, {get: getTrap, has: () => true});
assertEquals([undefined, undefined, "baz"], [].concat(obj));
assertEquals([undefined, undefined, "baz"], Array.prototype.concat.apply(obj))
})();
(function testSpreadableArrayLikeProxyWithBogusLength() {
var getTrap = function(t, key) {
if (key === "length") return Symbol();
if (key === "2") return "baz";
if (key === "3") return "bar";
};
var target = [];
var obj = new Proxy(target, {get: getTrap, has: () => true});
assertThrows(() => [].concat(obj), TypeError);
assertThrows(() => Array.prototype.concat.apply(obj), TypeError);
})();
(function testConcatRevokedProxy() {
"use strict";
var target = [];
var handler = {
get(_, name) {
if (name === Symbol.isConcatSpreadable) {
p.revoke();
}
return target[name];
}
}
p = Proxy.revocable(target, handler);
target = {};
target.__proto__ = p.proxy;
assertThrows(function() { [].concat({ __proto__: p.proxy }); }, TypeError);
target = [];
var p = Proxy.revocable(target, handler);
assertThrows(function() { [].concat(p.proxy); }, TypeError);
})();
Reference in New Issue View Git Blame Copy Permalink