1 files changed, 478 insertions, 0 deletions
diff --git a/js/src/tests/non262/Set/intersection.js b/js/src/tests/non262/Set/intersection.js
new file mode 100644
index 0000000000..dd0411c5a4
--- /dev/null
+++ b/js/src/tests/non262/Set/intersection.js
@@ -0,0 +1,478 @@
+// |reftest| shell-option(--enable-new-set-methods) skip-if(!Set.prototype.intersection)
+
+assertEq(typeof Set.prototype.intersection, "function");
+assertDeepEq(Object.getOwnPropertyDescriptor(Set.prototype.intersection, "length"), {
+  value: 1, writable: false, enumerable: false, configurable: true,
+});
+assertDeepEq(Object.getOwnPropertyDescriptor(Set.prototype.intersection, "name"), {
+  value: "intersection", writable: false, enumerable: false, configurable: true,
+});
+
+const emptySet = new Set();
+const emptySetLike = new SetLike();
+const emptyMap = new Map();
+
+function asMap(values) {
+  return new Map(values.map(v => [v, v]));
+}
+
+// Intersection of two empty sets is an empty set.
+assertSetContainsExactOrderedItems(emptySet.intersection(emptySet), []);
+assertSetContainsExactOrderedItems(emptySet.intersection(emptySetLike), []);
+assertSetContainsExactOrderedItems(emptySet.intersection(emptyMap), []);
+
+// Test native Set, Set-like, and Map objects.
+for (let values of [
+  [], [1], [1, 2], [1, true, null, {}],
+]) {
+  // Intersection with an empty set.
+  assertSetContainsExactOrderedItems(new Set(values).intersection(emptySet), []);
+  assertSetContainsExactOrderedItems(new Set(values).intersection(emptySetLike), []);
+  assertSetContainsExactOrderedItems(new Set(values).intersection(emptyMap), []);
+  assertSetContainsExactOrderedItems(emptySet.intersection(new Set(values)), []);
+  assertSetContainsExactOrderedItems(emptySet.intersection(new SetLike(values)), []);
+  assertSetContainsExactOrderedItems(emptySet.intersection(asMap(values)), []);
+
+  // Two sets with the exact same values.
+  assertSetContainsExactOrderedItems(new Set(values).intersection(new Set(values)), values);
+  assertSetContainsExactOrderedItems(new Set(values).intersection(new SetLike(values)), values);
+  assertSetContainsExactOrderedItems(new Set(values).intersection(asMap(values)), values);
+
+  // Intersection of the same set object.
+  let set = new Set(values);
+  assertSetContainsExactOrderedItems(set.intersection(set), values);
+}
+
+// Check property accesses are in the correct order.
+{
+  let log = [];
+
+  let sizeValue = 0;
+
+  let {proxy: keysIter} = LoggingProxy({
+    next() {
+      log.push("next()");
+      return {done: true};
+    }
+  }, log);
+
+  let {proxy: setLike} = LoggingProxy({
+    size: {
+      valueOf() {
+        log.push("valueOf()");
+        return sizeValue;
+      }
+    },
+    has() {
+      throw new Error("Unexpected call to |has| method");
+    },
+    keys() {
+      log.push("keys()");
+      return keysIter;
+    },
+  }, log);
+
+  log.length = 0;
+  assertSetContainsExactOrderedItems(emptySet.intersection(setLike), []);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+  ]);
+
+  // Input has more elements than the this-value.
+  sizeValue = 1;
+
+  log.length = 0;
+  assertSetContainsExactOrderedItems(emptySet.intersection(setLike), []);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+  ]);
+
+  // Input has fewer elements than the this-value.
+  sizeValue = 0;
+
+  log.length = 0;
+  assertSetContainsExactOrderedItems(new Set([1]).intersection(setLike), []);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+    "keys()",
+    "[[get]]", "next",
+    "next()",
+  ]);
+}
+
+// Check input validation.
+{
+  let log = [];
+
+  const nonCallable = {};
+  let sizeValue = 0;
+
+  let {proxy: keysIter} = LoggingProxy({
+    next: nonCallable,
+  }, log);
+
+  let {proxy: setLike, obj: setLikeObj} = LoggingProxy({
+    size: {
+      valueOf() {
+        log.push("valueOf()");
+        return sizeValue;
+      }
+    },
+    has() {
+      throw new Error("Unexpected call to |has| method");
+    },
+    keys() {
+      log.push("keys()");
+      return keysIter;
+    },
+  }, log);
+
+  log.length = 0;
+  assertSetContainsExactOrderedItems(emptySet.intersection(setLike), []);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+  ]);
+
+  log.length = 0;
+  assertThrowsInstanceOf(() => new Set([1]).intersection(setLike), TypeError);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+    "keys()",
+    "[[get]]", "next",
+  ]);
+
+  // Change |keys| to return a non-object value.
+  setLikeObj.keys = () => 123;
+
+  log.length = 0;
+  assertSetContainsExactOrderedItems(emptySet.intersection(setLike), []);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+  ]);
+
+  log.length = 0;
+  assertThrowsInstanceOf(() => new Set([1]).intersection(setLike), TypeError);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+  ]);
+
+  // Change |keys| to a non-callable value.
+  setLikeObj.keys = nonCallable;
+
+  log.length = 0;
+  assertThrowsInstanceOf(() => emptySet.intersection(setLike), TypeError);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+    "[[get]]", "keys",
+  ]);
+
+  // Change |has| to a non-callable value.
+  setLikeObj.has = nonCallable;
+
+  log.length = 0;
+  assertThrowsInstanceOf(() => emptySet.intersection(setLike), TypeError);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+    "[[get]]", "has",
+  ]);
+
+  // Change |size| to NaN.
+  sizeValue = NaN;
+
+  log.length = 0;
+  assertThrowsInstanceOf(() => emptySet.intersection(setLike), TypeError);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+  ]);
+
+  // Change |size| to undefined.
+  sizeValue = undefined;
+
+  log.length = 0;
+  assertThrowsInstanceOf(() => emptySet.intersection(setLike), TypeError);
+
+  assertEqArray(log, [
+    "[[get]]", "size",
+    "valueOf()",
+  ]);
+}
+
+// Doesn't accept Array as an input.
+assertThrowsInstanceOf(() => emptySet.intersection([]), TypeError);
+
+// Works with Set subclasses.
+{
+  class MySet extends Set {}
+
+  let myEmptySet = new MySet;
+
+  assertSetContainsExactOrderedItems(emptySet.intersection(myEmptySet), []);
+  assertSetContainsExactOrderedItems(myEmptySet.intersection(myEmptySet), []);
+  assertSetContainsExactOrderedItems(myEmptySet.intersection(emptySet), []);
+}
+
+// Doesn't access any properties on the this-value.
+{
+  let log = [];
+
+  let {proxy: setProto} = LoggingProxy(Set.prototype, log);
+
+  let set = new Set([1, 2, 3]);
+  Object.setPrototypeOf(set, setProto);
+
+  assertSetContainsExactOrderedItems(Set.prototype.intersection.call(set, emptySet), []);
+
+  assertEqArray(log, []);
+}
+
+// Throws a TypeError when the this-value isn't a Set object.
+for (let thisValue of [
+  null, undefined, true, "", {}, new Map, new Proxy(new Set, {}),
+]) {
+  assertThrowsInstanceOf(() => Set.prototype.intersection.call(thisValue, emptySet), TypeError);
+}
+
+// Doesn't return the original Set object.
+{
+  let set = new Set([1]);
+  assertEq(set.intersection(emptySet) !== set, true);
+  assertEq(set.intersection(new Set([2])) !== set, true);
+}
+
+// Test insertion order
+{
+  let set = new Set([1, 2, 3]);
+
+  // Case 1: Input is empty.
+  assertSetContainsExactOrderedItems(set.intersection(new Set([])), []);
+
+  // Case 2: Input has fewer elements.
+  assertSetContainsExactOrderedItems(set.intersection(new Set([1, 2])), [1, 2]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([2, 1])), [2, 1]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([11, 2])), [2]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([2, 11])), [2]);
+
+  // Case 3: Input has same number of elements.
+  assertSetContainsExactOrderedItems(set.intersection(new Set([1, 2, 3])), [1, 2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([2, 3, 1])), [1, 2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([3, 2, 1])), [1, 2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([11, 2, 3])), [2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([2, 3, 11])), [2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([3, 2, 11])), [2, 3]);
+
+  // Case 4: Input has more elements.
+  assertSetContainsExactOrderedItems(set.intersection(new Set([2, 3, 4, 5])), [2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([4, 5, 2, 3])), [2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(new Set([5, 4, 3, 2])), [2, 3]);
+}
+
+// Calls |has| when the this-value has fewer or the same number of keys.
+{
+  const keys = [1, 2, 3];
+
+  for (let size of [keys.length, 100, Infinity]) {
+    let i = 0;
+
+    let setLike = {
+      size,
+      has(v) {
+        assertEq(this, setLike);
+        assertEq(arguments.length, 1);
+        assertEq(i < keys.length, true);
+        assertEq(v, keys[i++]);
+        return true;
+      },
+      keys() {
+        throw new Error("Unexpected call to |keys| method");
+      },
+    };
+
+    assertSetContainsExactOrderedItems(new Set(keys).intersection(setLike), keys);
+  }
+}
+
+// Calls |keys| when the this-value has more keys.
+{
+  const keys = [1, 2, 3];
+
+  for (let size of [0, 1, 2]) {
+    let i = 0;
+
+    let setLike = {
+      size,
+      has() {
+        throw new Error("Unexpected call to |keys| method");
+      },
+      keys() {
+        assertEq(this, setLike);
+        assertEq(arguments.length, 0);
+
+        let iterator = {
+          next() {
+            assertEq(this, iterator);
+            assertEq(arguments.length, 0);
+            if (i < keys.length) {
+              return {
+                done: false,
+                value: keys[i++],
+              };
+            }
+            return {
+              done: true,
+              get value() {
+                throw new Error("Unexpected call to |value| getter");
+              },
+            };
+          }
+        };
+
+        return iterator;
+      },
+    };
+
+    assertSetContainsExactOrderedItems(new Set(keys).intersection(setLike), keys);
+  }
+}
+
+// Test result set order when the this-value was modified.
+{
+  let setLike = {
+    size: 0,
+    has() {
+      throw new Error("Unexpected call to |has| method");
+    },
+    *keys() {
+      // Yield the same keys as in |set|.
+      yield* set.keys();
+
+      // Remove all existing items.
+      set.clear();
+
+      // Re-add keys 2 and 3, but in reversed order.
+      set.add(3);
+      set.add(2);
+
+      // Additionally add 99.
+      set.add(99);
+    },
+  };
+
+  let set = new Set([1, 2, 3, 4]);
+
+  assertSetContainsExactOrderedItems(set.intersection(setLike), [1, 2, 3, 4]);
+  assertSetContainsExactOrderedItems(set, [3, 2, 99]);
+}
+{
+  let setLike = {
+    size: 0,
+    has() {
+      throw new Error("Unexpected call to |has| method");
+    },
+    *keys() {
+      // Yield the same keys as in |set|.
+      yield* set.keys();
+
+      // Remove only keys 2 and 3.
+      set.delete(2);
+      set.delete(3);
+
+      // Re-add keys 2 and 3, but in reversed order.
+      set.add(3);
+      set.add(2);
+    },
+  };
+
+  let set = new Set([1, 2, 3, 4]);
+
+  assertSetContainsExactOrderedItems(set.intersection(setLike), [1, 2, 3, 4]);
+  assertSetContainsExactOrderedItems(set, [1, 4, 3, 2]);
+}
+
+// Test the same item can't be added multiple times.
+{
+  let seen = [];
+
+  let setLike = {
+    size: 100,
+    has(v) {
+      // Remove and then re-add 2.
+      if (v === 2 && !seen.includes(v)) {
+        set.delete(v);
+        set.add(v);
+      }
+
+      // Remember all visited keys.
+      seen.push(v);
+
+      return true;
+    },
+    keys() {
+      throw new Error("Unexpected call to |keys| method");
+    },
+  };
+
+  let set = new Set([1, 2, 3]);
+
+  assertSetContainsExactOrderedItems(set.intersection(setLike), [1, 2, 3]);
+  assertEqArray(seen, [1, 2, 3, 2]);
+}
+
+// Tests which modify any built-ins should appear last, because modifications may disable
+// optimised code paths.
+
+// Doesn't call the built-in |Set.prototype.{has, keys, size}| functions.
+const SetPrototypeHas = Object.getOwnPropertyDescriptor(Set.prototype, "has");
+const SetPrototypeKeys = Object.getOwnPropertyDescriptor(Set.prototype, "keys");
+const SetPrototypeSize = Object.getOwnPropertyDescriptor(Set.prototype, "size");
+
+delete Set.prototype.has;
+delete Set.prototype.keys;
+delete Set.prototype.size;
+
+try {
+  let set = new Set([1, 2, 3]);
+  let other = new SetLike([1, 2, 3]);
+  assertSetContainsExactOrderedItems(set.intersection(other), [1, 2, 3]);
+} finally {
+  Object.defineProperty(Set.prototype, "has", SetPrototypeHas);
+  Object.defineProperty(Set.prototype, "keys", SetPrototypeKeys);
+  Object.defineProperty(Set.prototype, "size", SetPrototypeSize);
+}
+
+if (typeof reportCompare === "function")
+  reportCompare(true, true);