diff --git a/test/built-ins/Map/symbol-as-entry-key.js b/test/built-ins/Map/symbol-as-entry-key.js
deleted file mode 100644
index 84f762323c..0000000000
--- a/test/built-ins/Map/symbol-as-entry-key.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (C) 2013 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-/*---
-es6id: 19.4
-description: >
-    Symbol as Map key
-features: [Symbol]
----*/
-var map = new Map();
-var sym = Symbol();
-
-map.set(sym, 1);
-
-assert.sameValue(map.size, 1, "The value of `map.size` is `1`, after executing `map.set(sym, 1)`");
-assert.sameValue(map.has(sym), true, "`map.has(sym)` returns `true`");
-assert.sameValue(map.get(sym), 1, "`map.get(sym)` returns `1`");
-assert.sameValue(map.delete(sym), true, "`map.delete(sym)` returns `true`");
-assert.sameValue(map.size, 0, "The value of `map.size` is `0`");
diff --git a/test/built-ins/Map/valid-keys.js b/test/built-ins/Map/valid-keys.js
new file mode 100644
index 0000000000..3d417b6714
--- /dev/null
+++ b/test/built-ins/Map/valid-keys.js
@@ -0,0 +1,483 @@
+// Copyright (C) 2021 Rick Waldron. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-map.prototype.set
+description: Observing the expected behavior of valid keys
+info: |
+  Map.prototype.set ( key , value )
+
+  ...
+  Let p be the Record {[[key]]: key, [[value]]: value}.
+  Append p as the last element of entries.
+  ...
+
+features: [BigInt, Symbol, TypedArray, WeakRef]
+---*/
+
+
+const negativeZero = -0;
+const positiveZero = +0;
+const zero = 0;
+const one = 1;
+const twoRaisedToFiftyThreeMinusOne = 2 ** 53 - 1;
+const int32Array = new Int32Array([zero, one]);
+const uint32Array = new Uint32Array([zero, one]);
+const n = 100000000000000000000000000000000000000000000000000000000000000000000000000000000001n;
+const bigInt = BigInt('100000000000000000000000000000000000000000000000000000000000000000000000000000000001');
+const n1 = 1n;
+const n53 = 9007199254740991n;
+const fiftyThree = BigInt('9007199254740991');
+const bigInt64Array = new BigInt64Array([n1, n53]);
+const bigUint64Array = new BigUint64Array([n1, n53]);
+const symbol = Symbol('');
+const object = {};
+const array = {};
+const string = '';
+const booleanTrue = true;
+const booleanFalse = true;
+const functionExprValue = function() {};
+const arrowFunctionValue = () => {};
+const classValue = class {};
+const map = new Map();
+const set = new Set();
+const weakMap = new WeakMap();
+const weakRef = new WeakRef({});
+const weakSet = new WeakSet();
+const nullValue = null;
+const undefinedValue = undefined;
+let unassigned;
+
+{
+  const m = new Map([[negativeZero, negativeZero]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(negativeZero), true);
+  assert.sameValue(m.get(negativeZero), negativeZero);
+  m.delete(negativeZero);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(negativeZero), false);
+  m.set(negativeZero, negativeZero);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(negativeZero), true);
+  assert.sameValue(m.get(negativeZero), negativeZero);
+};
+
+{
+  const m = new Map([[positiveZero, positiveZero]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(positiveZero), true);
+  assert.sameValue(m.get(positiveZero), positiveZero);
+  m.delete(positiveZero);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(positiveZero), false);
+  m.set(positiveZero, positiveZero);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(positiveZero), true);
+  assert.sameValue(m.get(positiveZero), positiveZero);
+};
+
+{
+  const m = new Map([[zero, zero]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(zero), true);
+  assert.sameValue(m.get(zero), zero);
+  m.delete(zero);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(zero), false);
+  m.set(zero, zero);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(zero), true);
+  assert.sameValue(m.get(zero), zero);
+};
+
+{
+  const m = new Map([[one, one]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(one), true);
+  assert.sameValue(m.get(one), one);
+  m.delete(one);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(one), false);
+  m.set(one, one);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(one), true);
+  assert.sameValue(m.get(one), one);
+};
+
+{
+  const m = new Map([[twoRaisedToFiftyThreeMinusOne, twoRaisedToFiftyThreeMinusOne]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(twoRaisedToFiftyThreeMinusOne), true);
+  assert.sameValue(m.get(twoRaisedToFiftyThreeMinusOne), twoRaisedToFiftyThreeMinusOne);
+  m.delete(twoRaisedToFiftyThreeMinusOne);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(twoRaisedToFiftyThreeMinusOne), false);
+  m.set(twoRaisedToFiftyThreeMinusOne, twoRaisedToFiftyThreeMinusOne);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(twoRaisedToFiftyThreeMinusOne), true);
+  assert.sameValue(m.get(twoRaisedToFiftyThreeMinusOne), twoRaisedToFiftyThreeMinusOne);
+};
+
+{
+  const m = new Map([[int32Array, int32Array]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(int32Array), true);
+  assert.sameValue(m.get(int32Array), int32Array);
+  m.delete(int32Array);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(int32Array), false);
+  m.set(int32Array, int32Array);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(int32Array), true);
+  assert.sameValue(m.get(int32Array), int32Array);
+};
+
+{
+  const m = new Map([[uint32Array, uint32Array]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(uint32Array), true);
+  assert.sameValue(m.get(uint32Array), uint32Array);
+  m.delete(uint32Array);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(uint32Array), false);
+  m.set(uint32Array, uint32Array);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(uint32Array), true);
+  assert.sameValue(m.get(uint32Array), uint32Array);
+};
+
+{
+  const m = new Map([[n, n]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(n), true);
+  assert.sameValue(m.get(n), n);
+  m.delete(n);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(n), false);
+  m.set(n, n);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(n), true);
+  assert.sameValue(m.get(n), n);
+};
+
+{
+  const m = new Map([[bigInt, bigInt]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(bigInt), true);
+  assert.sameValue(m.get(bigInt), bigInt);
+  m.delete(bigInt);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(bigInt), false);
+  m.set(bigInt, bigInt);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(bigInt), true);
+  assert.sameValue(m.get(bigInt), bigInt);
+};
+
+{
+  const m = new Map([[n1, n1]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(n1), true);
+  assert.sameValue(m.get(n1), n1);
+  m.delete(n1);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(n1), false);
+  m.set(n1, n1);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(n1), true);
+  assert.sameValue(m.get(n1), n1);
+};
+
+{
+  const m = new Map([[n53, n53]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(n53), true);
+  assert.sameValue(m.get(n53), n53);
+  m.delete(n53);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(n53), false);
+  m.set(n53, n53);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(n53), true);
+  assert.sameValue(m.get(n53), n53);
+};
+
+{
+  const m = new Map([[fiftyThree, fiftyThree]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(fiftyThree), true);
+  assert.sameValue(m.get(fiftyThree), fiftyThree);
+  m.delete(fiftyThree);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(fiftyThree), false);
+  m.set(fiftyThree, fiftyThree);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(fiftyThree), true);
+  assert.sameValue(m.get(fiftyThree), fiftyThree);
+};
+
+{
+  const m = new Map([[bigInt64Array, bigInt64Array]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(bigInt64Array), true);
+  assert.sameValue(m.get(bigInt64Array), bigInt64Array);
+  m.delete(bigInt64Array);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(bigInt64Array), false);
+  m.set(bigInt64Array, bigInt64Array);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(bigInt64Array), true);
+  assert.sameValue(m.get(bigInt64Array), bigInt64Array);
+};
+
+{
+  const m = new Map([[bigUint64Array, bigUint64Array]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(bigUint64Array), true);
+  assert.sameValue(m.get(bigUint64Array), bigUint64Array);
+  m.delete(bigUint64Array);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(bigUint64Array), false);
+  m.set(bigUint64Array, bigUint64Array);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(bigUint64Array), true);
+  assert.sameValue(m.get(bigUint64Array), bigUint64Array);
+};
+
+{
+  const m = new Map([[symbol, symbol]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(symbol), true);
+  assert.sameValue(m.get(symbol), symbol);
+  m.delete(symbol);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(symbol), false);
+  m.set(symbol, symbol);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(symbol), true);
+  assert.sameValue(m.get(symbol), symbol);
+};
+
+{
+  const m = new Map([[object, object]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(object), true);
+  assert.sameValue(m.get(object), object);
+  m.delete(object);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(object), false);
+  m.set(object, object);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(object), true);
+  assert.sameValue(m.get(object), object);
+};
+
+{
+  const m = new Map([[array, array]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(array), true);
+  assert.sameValue(m.get(array), array);
+  m.delete(array);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(array), false);
+  m.set(array, array);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(array), true);
+  assert.sameValue(m.get(array), array);
+};
+
+{
+  const m = new Map([[string, string]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(string), true);
+  assert.sameValue(m.get(string), string);
+  m.delete(string);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(string), false);
+  m.set(string, string);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(string), true);
+  assert.sameValue(m.get(string), string);
+};
+
+{
+  const m = new Map([[booleanTrue, booleanTrue]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(booleanTrue), true);
+  assert.sameValue(m.get(booleanTrue), booleanTrue);
+  m.delete(booleanTrue);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(booleanTrue), false);
+  m.set(booleanTrue, booleanTrue);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(booleanTrue), true);
+  assert.sameValue(m.get(booleanTrue), booleanTrue);
+};
+
+{
+  const m = new Map([[booleanFalse, booleanFalse]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(booleanFalse), true);
+  assert.sameValue(m.get(booleanFalse), booleanFalse);
+  m.delete(booleanFalse);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(booleanFalse), false);
+  m.set(booleanFalse, booleanFalse);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(booleanFalse), true);
+  assert.sameValue(m.get(booleanFalse), booleanFalse);
+};
+
+{
+  const m = new Map([[functionExprValue, functionExprValue]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(functionExprValue), true);
+  assert.sameValue(m.get(functionExprValue), functionExprValue);
+  m.delete(functionExprValue);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(functionExprValue), false);
+  m.set(functionExprValue, functionExprValue);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(functionExprValue), true);
+  assert.sameValue(m.get(functionExprValue), functionExprValue);
+};
+
+{
+  const m = new Map([[arrowFunctionValue, arrowFunctionValue]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(arrowFunctionValue), true);
+  assert.sameValue(m.get(arrowFunctionValue), arrowFunctionValue);
+  m.delete(arrowFunctionValue);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(arrowFunctionValue), false);
+  m.set(arrowFunctionValue, arrowFunctionValue);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(arrowFunctionValue), true);
+  assert.sameValue(m.get(arrowFunctionValue), arrowFunctionValue);
+};
+
+{
+  const m = new Map([[classValue, classValue]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(classValue), true);
+  assert.sameValue(m.get(classValue), classValue);
+  m.delete(classValue);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(classValue), false);
+  m.set(classValue, classValue);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(classValue), true);
+  assert.sameValue(m.get(classValue), classValue);
+};
+
+{
+  const m = new Map([[map, map]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(map), true);
+  assert.sameValue(m.get(map), map);
+  m.delete(map);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(map), false);
+  m.set(map, map);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(map), true);
+  assert.sameValue(m.get(map), map);
+};
+
+{
+  const m = new Map([[set, set]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(set), true);
+  assert.sameValue(m.get(set), set);
+  m.delete(set);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(set), false);
+  m.set(set, set);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(set), true);
+  assert.sameValue(m.get(set), set);
+};
+
+{
+  const m = new Map([[weakMap, weakMap]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(weakMap), true);
+  assert.sameValue(m.get(weakMap), weakMap);
+  m.delete(weakMap);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(weakMap), false);
+  m.set(weakMap, weakMap);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(weakMap), true);
+  assert.sameValue(m.get(weakMap), weakMap);
+};
+
+{
+  const m = new Map([[weakRef, weakRef]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(weakRef), true);
+  assert.sameValue(m.get(weakRef), weakRef);
+  m.delete(weakRef);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(weakRef), false);
+  m.set(weakRef, weakRef);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(weakRef), true);
+  assert.sameValue(m.get(weakRef), weakRef);
+};
+
+{
+  const m = new Map([[weakSet, weakSet]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(weakSet), true);
+  assert.sameValue(m.get(weakSet), weakSet);
+  m.delete(weakSet);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(weakSet), false);
+  m.set(weakSet, weakSet);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(weakSet), true);
+  assert.sameValue(m.get(weakSet), weakSet);
+};
+
+{
+  const m = new Map([[nullValue, nullValue]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(nullValue), true);
+  assert.sameValue(m.get(nullValue), nullValue);
+  m.delete(nullValue);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(nullValue), false);
+  m.set(nullValue, nullValue);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(nullValue), true);
+  assert.sameValue(m.get(nullValue), nullValue);
+};
+
+{
+  const m = new Map([[undefinedValue, undefinedValue]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(undefinedValue), true);
+  assert.sameValue(m.get(undefinedValue), undefinedValue);
+  m.delete(undefinedValue);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(undefinedValue), false);
+  m.set(undefinedValue, undefinedValue);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(undefinedValue), true);
+  assert.sameValue(m.get(undefinedValue), undefinedValue);
+};
+
+{
+  const m = new Map([[unassigned, unassigned]]);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(unassigned), true);
+  assert.sameValue(m.get(unassigned), unassigned);
+  m.delete(unassigned);
+  assert.sameValue(m.size, 0);
+  assert.sameValue(m.has(unassigned), false);
+  m.set(unassigned, unassigned);
+  assert.sameValue(m.size, 1);
+  assert.sameValue(m.has(unassigned), true);
+  assert.sameValue(m.get(unassigned), unassigned);
+};
+
diff --git a/test/built-ins/Set/symbol-as-entry.js b/test/built-ins/Set/symbol-as-entry.js
deleted file mode 100644
index 2a53834720..0000000000
--- a/test/built-ins/Set/symbol-as-entry.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (C) 2013 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-/*---
-es6id: 19.4
-description: >
-    Symbol as Set entry
-features: [Symbol, Set]
----*/
-var set = new Set();
-var sym = Symbol();
-
-set.add(sym);
-
-assert.sameValue(set.size, 1, "The value of `set.size` is `1`, after executing `set.add(sym)`");
-assert.sameValue(set.has(sym), true, "`set.has(sym)` returns `true`");
-assert.sameValue(set.delete(sym), true, "`set.delete(sym)` returns `true`");
-assert.sameValue(set.size, 0, "The value of `set.size` is `0`");
diff --git a/test/built-ins/Set/valid-values.js b/test/built-ins/Set/valid-values.js
new file mode 100644
index 0000000000..7bedc9bc43
--- /dev/null
+++ b/test/built-ins/Set/valid-values.js
@@ -0,0 +1,387 @@
+// Copyright (C) 2021 Rick Waldron. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-set.prototype.add
+description: Observing the expected behavior of valid values
+info: |
+  Set.prototype.add ( value )
+
+  ...
+  For each element e of entries, do
+    If e is not empty and SameValueZero(e, value) is true, then
+    Return S.
+  If value is -0𝔽, set value to +0𝔽.
+  Append value as the last element of entries.
+  ...
+
+features: [BigInt, Symbol, TypedArray, WeakRef]
+---*/
+
+
+const negativeZero = -0;
+const positiveZero = +0;
+const zero = 0;
+const one = 1;
+const twoRaisedToFiftyThreeMinusOne = 2 ** 53 - 1;
+const int32Array = new Int32Array([zero, one]);
+const uint32Array = new Uint32Array([zero, one]);
+const n = 100000000000000000000000000000000000000000000000000000000000000000000000000000000001n;
+const bigInt = BigInt('100000000000000000000000000000000000000000000000000000000000000000000000000000000001');
+const n1 = 1n;
+const n53 = 9007199254740991n;
+const fiftyThree = BigInt('9007199254740991');
+const bigInt64Array = new BigInt64Array([n1, n53]);
+const bigUint64Array = new BigUint64Array([n1, n53]);
+const symbol = Symbol('');
+const object = {};
+const array = {};
+const string = '';
+const booleanTrue = true;
+const booleanFalse = true;
+const functionExprValue = function() {};
+const arrowFunctionValue = () => {};
+const classValue = class {};
+const map = new Map();
+const set = new Set();
+const weakMap = new WeakMap();
+const weakRef = new WeakRef({});
+const weakSet = new WeakSet();
+const nullValue = null;
+const undefinedValue = undefined;
+let unassigned;
+
+{
+  const s = new Set([negativeZero, negativeZero]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(negativeZero), true);
+  s.delete(negativeZero);
+  assert.sameValue(s.size, 0);
+  s.add(negativeZero);
+  assert.sameValue(s.has(negativeZero), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([positiveZero, positiveZero]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(positiveZero), true);
+  s.delete(positiveZero);
+  assert.sameValue(s.size, 0);
+  s.add(positiveZero);
+  assert.sameValue(s.has(positiveZero), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([zero, zero]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(zero), true);
+  s.delete(zero);
+  assert.sameValue(s.size, 0);
+  s.add(zero);
+  assert.sameValue(s.has(zero), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([one, one]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(one), true);
+  s.delete(one);
+  assert.sameValue(s.size, 0);
+  s.add(one);
+  assert.sameValue(s.has(one), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([twoRaisedToFiftyThreeMinusOne, twoRaisedToFiftyThreeMinusOne]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(twoRaisedToFiftyThreeMinusOne), true);
+  s.delete(twoRaisedToFiftyThreeMinusOne);
+  assert.sameValue(s.size, 0);
+  s.add(twoRaisedToFiftyThreeMinusOne);  assert.sameValue(s.has(twoRaisedToFiftyThreeMinusOne), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([int32Array, int32Array]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(int32Array), true);
+  s.delete(int32Array);
+  assert.sameValue(s.size, 0);
+  s.add(int32Array);
+  assert.sameValue(s.has(int32Array), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([uint32Array, uint32Array]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(uint32Array), true);
+  s.delete(uint32Array);
+  assert.sameValue(s.size, 0);
+  s.add(uint32Array);
+  assert.sameValue(s.has(uint32Array), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([n, n]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(n), true);
+  s.delete(n);
+  assert.sameValue(s.size, 0);
+  s.add(n);
+  assert.sameValue(s.has(n), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([bigInt, bigInt]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(bigInt), true);
+  s.delete(bigInt);
+  assert.sameValue(s.size, 0);
+  s.add(bigInt);
+  assert.sameValue(s.has(bigInt), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([n1, n1]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(n1), true);
+  s.delete(n1);
+  assert.sameValue(s.size, 0);
+  s.add(n1);
+  assert.sameValue(s.has(n1), true);
+}
+{  const s = new Set([n53, n53]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(n53), true);
+  s.delete(n53);
+  assert.sameValue(s.size, 0);
+  s.add(n53);
+  assert.sameValue(s.has(n53), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([fiftyThree, fiftyThree]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(fiftyThree), true);
+  s.delete(fiftyThree);
+  assert.sameValue(s.size, 0);
+  s.add(fiftyThree);
+  assert.sameValue(s.has(fiftyThree), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([bigInt64Array, bigInt64Array]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(bigInt64Array), true);
+  s.delete(bigInt64Array);
+  assert.sameValue(s.size, 0);
+  s.add(bigInt64Array);
+  assert.sameValue(s.has(bigInt64Array), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([bigUint64Array, bigUint64Array]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(bigUint64Array), true);
+  s.delete(bigUint64Array);
+  assert.sameValue(s.size, 0);
+  s.add(bigUint64Array);
+  assert.sameValue(s.has(bigUint64Array), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([symbol, symbol]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(symbol), true);
+  s.delete(symbol);
+  assert.sameValue(s.size, 0);
+  s.add(symbol);
+  assert.sameValue(s.has(symbol), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([object, object]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(object), true);
+  s.delete(object);
+  assert.sameValue(s.size, 0);
+  s.add(object);
+  assert.sameValue(s.has(object), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([array, array]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(array), true);
+  s.delete(array);
+  assert.sameValue(s.size, 0);
+  s.add(array);
+  assert.sameValue(s.has(array), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([string, string]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(string), true);
+  s.delete(string);
+  assert.sameValue(s.size, 0);
+  s.add(string);
+  assert.sameValue(s.has(string), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([booleanTrue, booleanTrue]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(booleanTrue), true);
+  s.delete(booleanTrue);
+  assert.sameValue(s.size, 0);
+  s.add(booleanTrue);
+  assert.sameValue(s.has(booleanTrue), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([booleanFalse, booleanFalse]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(booleanFalse), true);
+  s.delete(booleanFalse);
+  assert.sameValue(s.size, 0);
+  s.add(booleanFalse);
+  assert.sameValue(s.has(booleanFalse), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([functionExprValue, functionExprValue]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(functionExprValue), true);
+  s.delete(functionExprValue);
+  assert.sameValue(s.size, 0);
+  s.add(functionExprValue);  assert.sameValue(s.has(functionExprValue), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([arrowFunctionValue, arrowFunctionValue]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(arrowFunctionValue), true);
+  s.delete(arrowFunctionValue);
+  assert.sameValue(s.size, 0);
+  s.add(arrowFunctionValue);  assert.sameValue(s.has(arrowFunctionValue), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([classValue, classValue]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(classValue), true);
+  s.delete(classValue);
+  assert.sameValue(s.size, 0);
+  s.add(classValue);
+  assert.sameValue(s.has(classValue), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([map, map]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(map), true);
+  s.delete(map);
+  assert.sameValue(s.size, 0);
+  s.add(map);
+  assert.sameValue(s.has(map), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([set, set]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(set), true);
+  s.delete(set);
+  assert.sameValue(s.size, 0);
+  s.add(set);
+  assert.sameValue(s.has(set), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([weakMap, weakMap]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(weakMap), true);
+  s.delete(weakMap);
+  assert.sameValue(s.size, 0);
+  s.add(weakMap);
+  assert.sameValue(s.has(weakMap), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([weakRef, weakRef]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(weakRef), true);
+  s.delete(weakRef);
+  assert.sameValue(s.size, 0);
+  s.add(weakRef);
+  assert.sameValue(s.has(weakRef), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([weakSet, weakSet]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(weakSet), true);
+  s.delete(weakSet);
+  assert.sameValue(s.size, 0);
+  s.add(weakSet);
+  assert.sameValue(s.has(weakSet), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([nullValue, nullValue]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(nullValue), true);
+  s.delete(nullValue);
+  assert.sameValue(s.size, 0);
+  s.add(nullValue);
+  assert.sameValue(s.has(nullValue), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([undefinedValue, undefinedValue]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(undefinedValue), true);
+  s.delete(undefinedValue);
+  assert.sameValue(s.size, 0);
+  s.add(undefinedValue);
+  assert.sameValue(s.has(undefinedValue), true);
+  assert.sameValue(s.size, 1);
+};
+
+{
+  const s = new Set([unassigned, unassigned]);
+  assert.sameValue(s.size, 1);
+  assert.sameValue(s.has(unassigned), true);
+  s.delete(unassigned);
+  assert.sameValue(s.size, 0);
+  s.add(unassigned);
+  assert.sameValue(s.has(unassigned), true);
+  assert.sameValue(s.size, 1);
+};
+