mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-08 19:04:45 +00:00
Bug 1108930 - Part 2: Call Set with new. r=evilpie
This commit is contained in:
Tooru Fujisawa
parent
396ef79ba6
commit
07f776a866
@ -82,7 +82,7 @@ const Census = {};
|
||||
function makeBasisChecker({compare, missing, extra}) {
|
||||
return function makeWalker(basis) {
|
||||
if (typeof basis === 'object') {
|
||||
var unvisited = Set(Object.getOwnPropertyNames(basis));
|
||||
var unvisited = new Set(Object.getOwnPropertyNames(basis));
|
||||
return {
|
||||
enter: prop => {
|
||||
unvisited.delete(prop);
|
||||
|
||||
@ -5,4 +5,5 @@
|
||||
//
|
||||
|
||||
Array.prototype.iterator = (function() { { while(0) function Uint8ClampedArray() { } } });
|
||||
assertEq(Set(["testing", "testing", 123]).size(), 2);
|
||||
var s = new Set(["testing", "testing", 123]);
|
||||
assertEq(s.size(), 2);
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
// |jit-test| error: TypeError
|
||||
var set = Set(['a']);
|
||||
var set = new Set(['a']);
|
||||
var n = 5;
|
||||
for (let v of set) {
|
||||
if (n === 0)
|
||||
break;
|
||||
let g = set(Set(0xffffffff, n), 1);
|
||||
let g = set(new Set(0xffffffff, n), 1);
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@ assertEqArray([...[undefined]], [undefined]);
|
||||
assertEqArray([...new Int32Array([1, 2, 3])], [1, 2, 3]);
|
||||
assertEqArray([..."abc"], ["a", "b", "c"]);
|
||||
assertEqArray([...[1, 2, 3][Symbol.iterator]()], [1, 2, 3]);
|
||||
assertEqArray([...Set([1, 2, 3])], [1, 2, 3]);
|
||||
assertEqArray([...new Set([1, 2, 3])], [1, 2, 3]);
|
||||
assertEqArray([...new Map([["a", "A"], ["b", "B"], ["c", "C"]])].map(([k, v]) => k + v), ["aA", "bB", "cC"]);
|
||||
let itr = {};
|
||||
itr[Symbol.iterator] = function () {
|
||||
|
||||
@ -25,7 +25,7 @@ try { // line0 + 1
|
||||
|
||||
// other iterable objects
|
||||
assertEq(eval(...["a + b"][Symbol.iterator]()), 11);
|
||||
assertEq(eval(...Set(["a + b"])), 11);
|
||||
assertEq(eval(...new Set(["a + b"])), 11);
|
||||
let itr = {};
|
||||
itr[Symbol.iterator] = function() {
|
||||
return {
|
||||
|
||||
@ -9,7 +9,7 @@ function checkCommon(f) {
|
||||
assertEqArray(f.apply(...[null, [1, 2, 3]]), [1, 2, 3]);
|
||||
|
||||
// other iterable objects
|
||||
assertEqArray(f.apply(...Set([null, [1, 2, 3]])), [1, 2, 3]);
|
||||
assertEqArray(f.apply(...new Set([null, [1, 2, 3]])), [1, 2, 3]);
|
||||
assertEqArray(f.apply(...[null, [1, 2, 3]][Symbol.iterator]()), [1, 2, 3]);
|
||||
let itr = {};
|
||||
itr[Symbol.iterator] = function() {
|
||||
|
||||
@ -22,7 +22,7 @@ function checkLength(f, makeFn) {
|
||||
assertEq(makeFn("...arg")(f, new Int32Array([1, 2, 3])), 3);
|
||||
assertEq(makeFn("...arg")(f, "abc"), 3);
|
||||
assertEq(makeFn("...arg")(f, [1, 2, 3][Symbol.iterator]()), 3);
|
||||
assertEq(makeFn("...arg")(f, Set([1, 2, 3])), 3);
|
||||
assertEq(makeFn("...arg")(f, new Set([1, 2, 3])), 3);
|
||||
assertEq(makeFn("...arg")(f, new Map([["a", "A"], ["b", "B"], ["c", "C"]])), 3);
|
||||
let itr = {};
|
||||
itr[Symbol.iterator] = function() {
|
||||
|
||||
@ -17,7 +17,7 @@ function checkCommon(f, makeFn) {
|
||||
assertEqArray(makeFn("...arg")(f, new Int32Array([1, 2, 3])), [1, 2, 3]);
|
||||
assertEqArray(makeFn("...arg")(f, "abc"), ["a", "b", "c"]);
|
||||
assertEqArray(makeFn("...arg")(f, [1, 2, 3][Symbol.iterator]()), [1, 2, 3]);
|
||||
assertEqArray(makeFn("...arg")(f, Set([1, 2, 3])), [1, 2, 3]);
|
||||
assertEqArray(makeFn("...arg")(f, new Set([1, 2, 3])), [1, 2, 3]);
|
||||
assertEqArray(makeFn("...arg")(f, new Map([["a", "A"], ["b", "B"], ["c", "C"]])).map(([k, v]) => k + v), ["aA", "bB", "cC"]);
|
||||
let itr = {};
|
||||
itr[Symbol.iterator] = function() {
|
||||
|
||||
@ -8,13 +8,13 @@ var g = newGlobal();
|
||||
|
||||
var iterator_fn = Map.prototype[Symbol.iterator];
|
||||
assertThrowsInstanceOf(function () { iterator_fn.call({}); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { iterator_fn.call(Set()); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { iterator_fn.call(new Set()); }, TypeError);
|
||||
var mapw = g.eval("new Map([['x', 1], ['y', 2]])");
|
||||
assertEqArray(iterator_fn.call(mapw).next().value, ["x", 1]);
|
||||
|
||||
var next_fn = (new Map())[Symbol.iterator]().next;
|
||||
assertThrowsInstanceOf(function () { next_fn.call({}); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { next_fn.call(Set()[Symbol.iterator]()); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { next_fn.call((new Set())[Symbol.iterator]()); }, TypeError);
|
||||
var iterw = mapw[Symbol.iterator]();
|
||||
assertEqArray(next_fn.call(iterw).value, ["x", 1]);
|
||||
assertEqArray(next_fn.call(iterw).value, ["y", 2]);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// set.add(v) increments set.size iff the set did not already contain v.
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
for (var i = 0; i < 10; i++) {
|
||||
assertEq(s.size, i);
|
||||
s.add(i);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Clearing an empty Set has no effect.
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
for (var i = 0; i < 2; i++) {
|
||||
s.clear();
|
||||
assertEq(s.size, 0);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Clearing a Set removes its elements; the Set remains usable afterwards.
|
||||
|
||||
var s = Set(["x", "y", "z", "z", "y"]);
|
||||
var s = new Set(["x", "y", "z", "z", "y"]);
|
||||
assertEq(s.size, 3);
|
||||
s.clear();
|
||||
assertEq(s.size, 0);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Clearing a Set with a nontrivial number of elements works.
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
for (var i = 0; i < 100; i++)
|
||||
s.add(i);
|
||||
assertEq(s.size, i);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Clearing a Set after deleting some entries works.
|
||||
|
||||
var s = Set(["a", "b", "c", "d"]);
|
||||
var s = new Set(["a", "b", "c", "d"]);
|
||||
for (var v of s)
|
||||
if (v !== "c")
|
||||
s.delete(v);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// Set.clear is unaffected by deleting/monkeypatching Set.prototype.{delete,iterator}.
|
||||
|
||||
var data = ["a", 1, {}];
|
||||
var s1 = Set(data), s2 = Set(data);
|
||||
var s1 = new Set(data), s2 = new Set(data);
|
||||
|
||||
delete Set.prototype.delete;
|
||||
delete Set.prototype.iterator;
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Clearing a Set doesn't affect expando properties.
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
s.x = 3;
|
||||
s.clear();
|
||||
assertEq(s.x, 3);
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
load(libdir + "referencesVia.js");
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
var obj = {};
|
||||
s.add(obj);
|
||||
assertEq(referencesVia(s, "key", obj), true);
|
||||
|
||||
@ -2,19 +2,19 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
var it = s[Symbol.iterator]();
|
||||
s.clear();
|
||||
assertIteratorDone(it, undefined);
|
||||
|
||||
s = Set(["a", "b", "c", "d"]);
|
||||
s = new Set(["a", "b", "c", "d"]);
|
||||
it = s[Symbol.iterator]();
|
||||
assertIteratorNext(it, "a");
|
||||
s.clear();
|
||||
assertIteratorDone(it, undefined);
|
||||
|
||||
var log = "";
|
||||
s = Set(["a", "b", "c", "d"]);
|
||||
s = new Set(["a", "b", "c", "d"]);
|
||||
for (var v of s) {
|
||||
log += v;
|
||||
if (v == "b")
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var s = Set(["a"]);
|
||||
var s = new Set(["a"]);
|
||||
var it = s[Symbol.iterator]();
|
||||
assertIteratorNext(it, "a");
|
||||
s.clear();
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
var it = s[Symbol.iterator]();
|
||||
assertIteratorDone(it, undefined); // close the iterator
|
||||
s.clear();
|
||||
|
||||
@ -1,7 +1,8 @@
|
||||
// The Set constructor creates an empty Set by default.
|
||||
|
||||
assertEq(Set().size, 0);
|
||||
assertEq((new Set).size, 0);
|
||||
assertEq(Set(undefined).size, 0);
|
||||
assertEq(new Set(undefined).size, 0);
|
||||
assertEq(new Set(null).size, 0);
|
||||
var s = new Set();
|
||||
assertEq(s.size, 0);
|
||||
s = new Set(undefined);
|
||||
assertEq(s.size, 0);
|
||||
s = new Set(null);
|
||||
assertEq(s.size, 0);
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
// The Set constructor can take an argument that is an array.
|
||||
|
||||
var s = Set([]);
|
||||
var s = new Set([]);
|
||||
assertEq(s.size, 0);
|
||||
assertEq(s.has(undefined), false);
|
||||
|
||||
s = Set(["one", "two", "three"]);
|
||||
s = new Set(["one", "two", "three"]);
|
||||
assertEq(s.size, 3);
|
||||
assertEq(s.has("one"), true);
|
||||
assertEq(s.has("eleventeen"), false);
|
||||
|
||||
var a = [{}, {}, {}];
|
||||
s = Set(a);
|
||||
s = new Set(a);
|
||||
assertEq(s.size, 3);
|
||||
for (let obj of a)
|
||||
assertEq(s.has(obj), true);
|
||||
|
||||
@ -1,11 +1,12 @@
|
||||
// The argument to Set may contain a value multiple times. Duplicates are discarded.
|
||||
|
||||
assertEq(Set(["testing", "testing", 123]).size, 2);
|
||||
var s = new Set(["testing", "testing", 123]);
|
||||
assertEq(s.size, 2);
|
||||
|
||||
var values = [undefined, null, false, NaN, 0, -0, 6.022e23, -Infinity, "", "xyzzy", {}, Math.sin];
|
||||
for (let v of values) {
|
||||
var a = [v, {}, {}, {}, v, {}, v, v];
|
||||
var s = Set(a);
|
||||
s = new Set(a);
|
||||
assertEq(s.size, 5);
|
||||
assertEq(s.has(v), true);
|
||||
}
|
||||
|
||||
@ -5,7 +5,7 @@ function hexData(n) {
|
||||
yield i.toString(16);
|
||||
}
|
||||
|
||||
var s = Set(hexData(256));
|
||||
var s = new Set(hexData(256));
|
||||
assertEq(s.size, 256);
|
||||
assertEq(s.has("0"), true);
|
||||
assertEq(s.has(0), false);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// The argument to Set can be a generator-expression.
|
||||
|
||||
var s = Set(k * k for (k of [1, 2, 3, 4]));
|
||||
var s = new Set(k * k for (k of [1, 2, 3, 4]));
|
||||
assertEq(s.size, 4);
|
||||
assertEq(s.has(1), true);
|
||||
assertEq(s.has(4), true);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// set.delete(v) decrements set.size iff the set contained v.
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
for (var i = 0; i < 10; i++)
|
||||
s.add(i);
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// for-of can be used to iterate over a Set twice.
|
||||
|
||||
var set = Set(['a', 'b', 'c']);
|
||||
var set = new Set(['a', 'b', 'c']);
|
||||
var log = '';
|
||||
|
||||
for (let i = 0; i < 2; i++) {
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Nested for-of loops can iterate over a Set.
|
||||
|
||||
var map = Set(['a', 'b']);
|
||||
var map = new Set(['a', 'b']);
|
||||
var log = '';
|
||||
for (let x of map) {
|
||||
log += x + ':'
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// Iterating over a set of objects yields those exact objects.
|
||||
|
||||
var arr = [{}, {}, {}, [], /xyz/, new Date];
|
||||
var set = Set(arr);
|
||||
var set = new Set(arr);
|
||||
assertEq(set.size, arr.length);
|
||||
|
||||
var i = 0;
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// set.iterator() is live: entries added during iteration are visited.
|
||||
|
||||
var set = Set([5]);
|
||||
var set = new Set([5]);
|
||||
var log = '';
|
||||
for (let x of set) {
|
||||
log += x + ';';
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var set = Set();
|
||||
var set = new Set();
|
||||
var iter0 = set[Symbol.iterator](), iter1 = set[Symbol.iterator]();
|
||||
assertIteratorDone(iter0, undefined); // closes iter0
|
||||
set.add("x");
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Removing and re-adding entries while an iterator is live causes the iterator to visit them again.
|
||||
|
||||
var set = Set(['a']);
|
||||
var set = new Set(['a']);
|
||||
var n = 5;
|
||||
for (let v of set) {
|
||||
assertEq(v, 'a');
|
||||
|
||||
@ -4,7 +4,7 @@ load(libdir + "referencesVia.js");
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var key = {};
|
||||
var set = Set([key]);
|
||||
var set = new Set([key]);
|
||||
var iter = set[Symbol.iterator]();
|
||||
referencesVia(iter, "**UNKNOWN SLOT 0**", set);
|
||||
referencesVia(set, "key", key);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// GC-ing during a for-of loop doesn't crash.
|
||||
|
||||
var i = 0;
|
||||
for (var x of Set(Object.getOwnPropertyNames(this))) {
|
||||
for (var x of new Set(Object.getOwnPropertyNames(this))) {
|
||||
gc();
|
||||
if (++i >= 20)
|
||||
break;
|
||||
|
||||
@ -1,20 +1,20 @@
|
||||
// GC in nested for-loops is safe.
|
||||
|
||||
var x;
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
for (x of new Set([1]))
|
||||
gc();
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Set iterators produces entries in the order they were inserted.
|
||||
|
||||
var set = Set();
|
||||
var set = new Set();
|
||||
var i;
|
||||
for (i = 7; i !== 1; i = i * 7 % 1117)
|
||||
set.add(i);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// for-of works on a cross-compartment wrapper of a Set.
|
||||
|
||||
var g = newGlobal();
|
||||
var mw = g.eval("Set(['a', 'b', 1, 2])");
|
||||
var mw = g.eval("new Set(['a', 'b', 1, 2])");
|
||||
var log = '';
|
||||
for (let x of mw)
|
||||
log += x;
|
||||
|
||||
@ -8,10 +8,10 @@ var g = newGlobal();
|
||||
var iterator_fn = Set.prototype[Symbol.iterator];
|
||||
assertThrowsInstanceOf(function () { iterator_fn.call({}); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { iterator_fn.call(new Map()); }, TypeError);
|
||||
var setw = g.eval("Set(['x', 'y'])");
|
||||
var setw = g.eval("new Set(['x', 'y'])");
|
||||
assertIteratorNext(iterator_fn.call(setw), "x");
|
||||
|
||||
var next_fn = Set()[Symbol.iterator]().next;
|
||||
var next_fn = (new Set())[Symbol.iterator]().next;
|
||||
assertThrowsInstanceOf(function () { next_fn.call({}); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { next_fn.call((new Map())[Symbol.iterator]()); }, TypeError);
|
||||
var iterw = setw[Symbol.iterator]();
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
// A set iterator can cope with removing the current entry.
|
||||
|
||||
function test(letters, toRemove) {
|
||||
var set = Set(letters);
|
||||
toRemove = Set(toRemove);
|
||||
var set = new Set(letters);
|
||||
toRemove = new Set(toRemove);
|
||||
|
||||
var leftovers = [x for (x of set) if (!toRemove.has(x))].join("");
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var set = Set("abcd");
|
||||
var set = new Set("abcd");
|
||||
var iter = set[Symbol.iterator]();
|
||||
var log = "";
|
||||
for (let x of iter) {
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var set = Set("abcd");
|
||||
var set = new Set("abcd");
|
||||
var iter = set[Symbol.iterator]();
|
||||
assertIteratorNext(iter, "a");
|
||||
assertIteratorNext(iter, "b");
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
// Make a set.
|
||||
var set = Set();
|
||||
var set = new Set();
|
||||
var SIZE = 7;
|
||||
for (var j = 0; j < SIZE; j++)
|
||||
set.add(j);
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
// entries to be skipped.
|
||||
|
||||
var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
||||
var set = Set(str);
|
||||
var set = new Set(str);
|
||||
|
||||
var log = '';
|
||||
var i = 0;
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var set = Set();
|
||||
var set = new Set();
|
||||
for (var i = 0; i < 32; i++)
|
||||
set.add(i);
|
||||
var iter = set[Symbol.iterator]();
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Each Set has its own size.
|
||||
|
||||
var s1 = Set(), s2 = Set();
|
||||
var s1 = new Set(), s2 = new Set();
|
||||
for (var i = 0; i < 30; i++)
|
||||
s1.add(i);
|
||||
assertEq(s1.size, 30);
|
||||
|
||||
@ -14,8 +14,7 @@ assertEq(Set.name, "Set");
|
||||
|
||||
assertEq(Object.getPrototypeOf(Set.prototype), Object.prototype);
|
||||
assertEq(Object.prototype.toString.call(Set.prototype), "[object Set]");
|
||||
assertEq(Object.prototype.toString.call(new Set), "[object Set]");
|
||||
assertEq(Object.prototype.toString.call(Set()), "[object Set]");
|
||||
assertEq(Object.prototype.toString.call(new Set()), "[object Set]");
|
||||
assertEq(Object.keys(Set.prototype).join(), "");
|
||||
assertEq(Set.prototype.constructor, Set);
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// set.keys(), .values(), and .entries() on an empty set produce empty iterators
|
||||
|
||||
var s = Set();
|
||||
var s = new Set();
|
||||
var ki = s.keys(), vi = s.values(), ei = s.entries();
|
||||
var p = Object.getPrototypeOf(ki);
|
||||
assertEq(Object.getPrototypeOf(vi), p);
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
load(libdir + "iteration.js");
|
||||
|
||||
var data = [1, 2, 3, 4];
|
||||
var s = Set(data);
|
||||
var s = new Set(data);
|
||||
|
||||
var ki = s.keys();
|
||||
assertIteratorNext(ki, 1);
|
||||
|
||||
@ -4,6 +4,6 @@ var ws = new WeakSet(list);
|
||||
assertEq(ws.has(Number), true);
|
||||
assertEq(ws.has(Function), true);
|
||||
|
||||
ws = new WeakSet(Set(list));
|
||||
ws = new WeakSet(new Set(list));
|
||||
assertEq(ws.has(Number), true);
|
||||
assertEq(ws.has(Function), true);
|
||||
|
||||
@ -17,6 +17,6 @@ var misc = [
|
||||
];
|
||||
|
||||
for (var v of misc) {
|
||||
assertThrowsInstanceOf(function () { Set(v); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { new Set(v); }, TypeError);
|
||||
assertThrowsInstanceOf(function () { new Map(v); }, TypeError);
|
||||
}
|
||||
@ -13,4 +13,4 @@ function test(obj, edgeName) {
|
||||
|
||||
test([key], "element[0]");
|
||||
test(new Map([[key, 'value']]), "key");
|
||||
test(Set([key]), "key");
|
||||
test(new Set([key]), "key");
|
||||
|
||||
@ -12,4 +12,4 @@ function test(obj0, obj1) {
|
||||
|
||||
test([], [1]);
|
||||
test(new Map(), new Map([[1, 1]]));
|
||||
test(Set(), Set([1]));
|
||||
test(new Set(), new Set([1]));
|
||||
|
||||
@ -4,7 +4,7 @@ load(libdir + "iteration.js");
|
||||
|
||||
var aproto = Object.getPrototypeOf(Array()[Symbol.iterator]());
|
||||
var mproto = Object.getPrototypeOf((new Map())[Symbol.iterator]());
|
||||
var sproto = Object.getPrototypeOf(Set()[Symbol.iterator]());
|
||||
var sproto = Object.getPrototypeOf((new Set())[Symbol.iterator]());
|
||||
assertEq(aproto !== mproto, true);
|
||||
assertEq(aproto !== sproto, true);
|
||||
assertEq(mproto !== sproto, true);
|
||||
|
||||
@ -9,7 +9,7 @@ function seq_scan(array, f) {}\
|
||||
function assertStructuralEq(e1, e2) {}\
|
||||
for (var i = 0, l = a.length; i < l; i++) {}\
|
||||
');");
|
||||
lfcode.push("for (var x of Set(Object.getOwnPropertyNames(this))) {}");
|
||||
lfcode.push("for (var x of new Set(Object.getOwnPropertyNames(this))) {}");
|
||||
var lfRunTypeId = -1;
|
||||
while (true) {
|
||||
var file = lfcode.shift(); if (file == undefined) { break; }
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
if (typeof schedulegc != 'undefined') {
|
||||
Function("\
|
||||
x = (function() { yield })();\
|
||||
Set(x);\
|
||||
new Set(x);\
|
||||
schedulegc(1);\
|
||||
print( /x/ );\
|
||||
for (p in x) {}\
|
||||
|
||||
@ -4,5 +4,5 @@
|
||||
*/
|
||||
|
||||
// Don't crash
|
||||
serialize(evalcx("Set(['x', 'y'])"));
|
||||
serialize(evalcx("new Set(['x', 'y'])"));
|
||||
serialize(evalcx("new Map([['x', 1]])"));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user