QUnit.test('Set#delete', assert => {
assert.isFunction(Set.prototype.delete);
const array = [];
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.strictEqual(set.size, 5);
assert.strictEqual(set.delete(NaN), true);
assert.strictEqual(set.size, 4);
assert.strictEqual(set.delete(4), false);
assert.strictEqual(set.size, 4);
set.delete([]);
assert.strictEqual(set.size, 4);
set.delete(array);
assert.strictEqual(set.size, 3);
const frozen = freeze({});
set.add(frozen);
assert.strictEqual(set.size, 4);
set.delete(frozen);
assert.strictEqual(set.size, 3);
});
QUnit.test('Map#delete', assert => {
assert.isFunction(Map.prototype.delete);
const object = {};
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
assert.strictEqual(map.size, 5);
assert.ok(map.delete(NaN));
assert.strictEqual(map.size, 4);
assert.ok(!map.delete(4));
assert.strictEqual(map.size, 4);
map.delete([]);
assert.strictEqual(map.size, 4);
map.delete(object);
assert.strictEqual(map.size, 3);
const frozen = freeze({});
map.set(frozen, 42);
assert.strictEqual(map.size, 4);
map.delete(frozen);
assert.strictEqual(map.size, 3);
});
QUnit.test('Set#clear', assert => {
assert.isFunction(Set.prototype.clear);
let set = new Set();
set.clear();
assert.strictEqual(set.size, 0);
set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.clear();
assert.strictEqual(set.size, 0);
assert.ok(!set.has(1));
assert.ok(!set.has(2));
assert.ok(!set.has(3));
const frozen = freeze({});
set = new Set();
set.add(1);
set.add(frozen);
set.clear();
assert.strictEqual(set.size, 0, 'Support frozen objects');
assert.ok(!set.has(1));
assert.ok(!set.has(frozen));
});
QUnit.test('Map#set', assert => {
assert.isFunction(Map.prototype.set);
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(object, object);
assert.ok(map.size === 5);
const chain = map.set(7, 2);
assert.strictEqual(chain, map);
map.set(7, 2);
assert.strictEqual(map.size, 6);
assert.strictEqual(map.get(7), 2);
assert.strictEqual(map.get(NaN), 1);
map.set(NaN, 42);
assert.strictEqual(map.size, 6);
assert.strictEqual(map.get(NaN), 42);
map.set({}, 11);
assert.strictEqual(map.size, 7);
assert.strictEqual(map.get(object), object);
map.set(object, 27);
assert.strictEqual(map.size, 7);
assert.strictEqual(map.get(object), 27);
map = new Map();
map.set(NaN, 2);
map.set(NaN, 3);
map.set(NaN, 4);
assert.strictEqual(map.size, 1);
const frozen = freeze({});
map = new Map().set(frozen, 42);
assert.strictEqual(map.get(frozen), 42);
});
QUnit.test('Set#add', assert => {
assert.isFunction(Set.prototype.add);
const array = [];
let set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.strictEqual(set.size, 5);
const chain = set.add(NaN);
assert.strictEqual(chain, set);
assert.strictEqual(set.size, 5);
set.add(2);
assert.strictEqual(set.size, 5);
set.add(array);
assert.strictEqual(set.size, 5);
set.add([]);
assert.strictEqual(set.size, 6);
set.add(4);
assert.strictEqual(set.size, 7);
const frozen = freeze({});
set = new Set();
set.add(frozen);
assert.ok(set.has(frozen));
});
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.ok('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.ok('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.ok('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.ok('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.ok(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.strictEqual(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.strictEqual(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.strictEqual(weakmap.has(frozen), true, 'works with frozen objects, #1');
assert.strictEqual(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.strictEqual(weakmap.has(frozen), false, 'works with frozen objects, #3');
assert.strictEqual(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch (e) { /* empty */ }
assert.ok(done, '.return #throw');
assert.ok(!('clear' in WeakMap.prototype), 'should not contains `.clear` method');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakMap(array);
assert.ok(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.ok(weakmap.set({}, 42) === weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
});
QUnit.test('Map', assert => {
assert.isFunction(Map);
assert.ok('clear' in Map.prototype, 'clear in Map.prototype');
assert.ok('delete' in Map.prototype, 'delete in Map.prototype');
assert.ok('forEach' in Map.prototype, 'forEach in Map.prototype');
assert.ok('get' in Map.prototype, 'get in Map.prototype');
assert.ok('has' in Map.prototype, 'has in Map.prototype');
assert.ok('set' in Map.prototype, 'set in Map.prototype');
assert.ok(new Map() instanceof Map, 'new Map instanceof Map');
assert.strictEqual(new Map(createIterable([[1, 1], [2, 2], [3, 3]])).size, 3, 'Init from iterable');
assert.strictEqual(new Map([[freeze({}), 1], [2, 3]]).size, 2, 'Support frozen objects');
let done = false;
try {
new Map(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch (e) { /* empty */ }
assert.ok(done, '.return #throw');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new Map(array);
assert.ok(done);
const object = {};
new Map().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Map);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Map, 'correct subclassing with native classes #2');
assert.strictEqual(new Subclass().set(1, 2).get(1), 2, 'correct subclassing with native classes #3');
}
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
const weakmap = new WeakMap();
assert.strictEqual(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.strictEqual(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.strictEqual(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
const weakmap = new WeakMap();
assert.ok(!weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.ok(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.ok(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('Map#clear', assert => {
assert.isFunction(Map.prototype.clear);
let map = new Map();
map.clear();
assert.strictEqual(map.size, 0);
map = new Map().set(1, 2).set(2, 3).set(1, 4);
map.clear();
assert.strictEqual(map.size, 0);
assert.ok(!map.has(1));
assert.ok(!map.has(2));
const frozen = freeze({});
map = new Map().set(1, 2).set(frozen, 3);
map.clear();
assert.strictEqual(map.size, 0, 'Support frozen objects');
assert.ok(!map.has(1));
assert.ok(!map.has(frozen));
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.ok(weakmap.has(a) && weakmap.has(b), 'WeakMap has values before .delete()');
weakmap.delete(a);
assert.ok(!weakmap.has(a) && weakmap.has(b), 'WeakMap hasn`t value after .delete()');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.ok(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('Map#has', assert => {
assert.isFunction(Map.prototype.has);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.ok(map.has(NaN));
assert.ok(map.has(object));
assert.ok(map.has(2));
assert.ok(map.has(frozen));
assert.ok(!map.has(4));
assert.ok(!map.has({}));
});
QUnit.test('Map#get', assert => {
assert.isFunction(Map.prototype.get);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.strictEqual(map.get(NaN), 1);
assert.strictEqual(map.get(4), undefined);
assert.strictEqual(map.get({}), undefined);
assert.strictEqual(map.get(object), object);
assert.strictEqual(map.get(frozen), 42);
assert.strictEqual(map.get(2), 5);
});
QUnit.test('Set#has', assert => {
assert.isFunction(Set.prototype.has);
const array = [];
const frozen = freeze({});
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(frozen);
set.add(array);
assert.ok(set.has(NaN));
assert.ok(set.has(array));
assert.ok(set.has(frozen));
assert.ok(set.has(2));
assert.ok(!set.has(4));
assert.ok(!set.has([]));
});
QUnit.test('Object.freeze', assert => {
assert.isFunction(freeze);
assert.arity(freeze, 1);
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => freeze(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(freeze(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in freeze({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(freeze({})), []);
assert.arrayEqual(getOwnPropertyNames(freeze({})), []);
assert.arrayEqual(getOwnPropertySymbols(freeze({})), []);
assert.arrayEqual(ownKeys(freeze({})), []);
});
assert.notThrows(() => freeze(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
QUnit.test('Set', assert => {
assert.isFunction(Set);
assert.ok('add' in Set.prototype, 'add in Set.prototype');
assert.ok('clear' in Set.prototype, 'clear in Set.prototype');
assert.ok('delete' in Set.prototype, 'delete in Set.prototype');
assert.ok('forEach' in Set.prototype, 'forEach in Set.prototype');
assert.ok('has' in Set.prototype, 'has in Set.prototype');
assert.ok(new Set() instanceof Set, 'new Set instanceof Set');
const set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
assert.strictEqual(set.size, 3);
const result = [];
set.forEach(val => {
result.push(val);
});
assert.deepEqual(result, [1, 2, 3]);
assert.strictEqual(new Set(createIterable([1, 2, 3])).size, 3, 'Init from iterable');
assert.strictEqual(new Set([freeze({}), 1]).size, 2, 'Support frozen objects');
assert.strictEqual(new Set([NaN, NaN, NaN]).size, 1);
assert.deepEqual(from(new Set([3, 4]).add(2).add(1)), [3, 4, 2, 1]);
let done = false;
const { add } = Set.prototype;
Set.prototype.add = function () {
throw new Error();
};
try {
new Set(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch (error) { /* empty */ }
Set.prototype.add = add;
assert.ok(done, '.return #throw');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new Set(array);
assert.ok(done);
const object = {};
new Set().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in results) keys.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Set);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Set, 'correct subclassing with native classes #2');
assert.ok(new Subclass().add(2).has(2), 'correct subclassing with native classes #3');
}
});