1 files changed, 150 insertions, 0 deletions
diff --git a/js/src/tests/test262/built-ins/String/prototype/matchAll/shell.js b/js/src/tests/test262/built-ins/String/prototype/matchAll/shell.js
new file mode 100644
index 0000000000..b2377bc5bc
--- /dev/null
+++ b/js/src/tests/test262/built-ins/String/prototype/matchAll/shell.js
@@ -0,0 +1,150 @@
+// GENERATED, DO NOT EDIT
+// file: compareIterator.js
+// Copyright (C) 2018 Peter Wong.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: Compare the values of an iterator with an array of expected values
+defines: [assert.compareIterator]
+---*/
+
+// Example:
+//
+//    function* numbers() {
+//      yield 1;
+//      yield 2;
+//      yield 3;
+//    }
+//
+//    assert.compareIterator(numbers(), [
+//      v => assert.sameValue(v, 1),
+//      v => assert.sameValue(v, 2),
+//      v => assert.sameValue(v, 3),
+//    ]);
+//
+assert.compareIterator = function(iter, validators, message) {
+  message = message || '';
+
+  var i, result;
+  for (i = 0; i < validators.length; i++) {
+    result = iter.next();
+    assert(!result.done, 'Expected ' + i + ' values(s). Instead iterator only produced ' + (i - 1) + ' value(s). ' + message);
+    validators[i](result.value);
+  }
+
+  result = iter.next();
+  assert(result.done, 'Expected only ' + i + ' values(s). Instead iterator produced more. ' + message);
+  assert.sameValue(result.value, undefined, 'Expected value of `undefined` when iterator completes. ' + message);
+}
+
+// file: regExpUtils.js
+// Copyright (C) 2017 Mathias Bynens.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    Collection of functions used to assert the correctness of RegExp objects.
+defines: [buildString, testPropertyEscapes, testPropertyOfStrings, testExtendedCharacterClass, matchValidator]
+---*/
+
+function buildString(args) {
+  // Use member expressions rather than destructuring `args` for improved
+  // compatibility with engines that only implement assignment patterns
+  // partially or not at all.
+  const loneCodePoints = args.loneCodePoints;
+  const ranges = args.ranges;
+  const CHUNK_SIZE = 10000;
+  let result = Reflect.apply(String.fromCodePoint, null, loneCodePoints);
+  for (let i = 0; i < ranges.length; i++) {
+    const range = ranges[i];
+    const start = range[0];
+    const end = range[1];
+    const codePoints = [];
+    for (let length = 0, codePoint = start; codePoint <= end; codePoint++) {
+      codePoints[length++] = codePoint;
+      if (length === CHUNK_SIZE) {
+        result += Reflect.apply(String.fromCodePoint, null, codePoints);
+        codePoints.length = length = 0;
+      }
+    }
+    result += Reflect.apply(String.fromCodePoint, null, codePoints);
+  }
+  return result;
+}
+
+function printCodePoint(codePoint) {
+  const hex = codePoint
+    .toString(16)
+    .toUpperCase()
+    .padStart(6, "0");
+  return `U+${hex}`;
+}
+
+function printStringCodePoints(string) {
+  const buf = [];
+  for (const symbol of string) {
+    const formatted = printCodePoint(symbol.codePointAt(0));
+    buf.push(formatted);
+  }
+  return buf.join(' ');
+}
+
+function testPropertyEscapes(regExp, string, expression) {
+  if (!regExp.test(string)) {
+    for (const symbol of string) {
+      const hex = printCodePoint(symbol.codePointAt(0));
+      assert(
+        regExp.test(symbol),
+        `\`${ expression }\` should match U+${ hex } (\`${ symbol }\`)`
+      );
+    }
+  }
+}
+
+function testPropertyOfStrings(args) {
+  // Use member expressions rather than destructuring `args` for improved
+  // compatibility with engines that only implement assignment patterns
+  // partially or not at all.
+  const regExp = args.regExp;
+  const expression = args.expression;
+  const matchStrings = args.matchStrings;
+  const nonMatchStrings = args.nonMatchStrings;
+  const allStrings = matchStrings.join('');
+  if (!regExp.test(allStrings)) {
+    for (const string of matchStrings) {
+      assert(
+        regExp.test(string),
+        `\`${ expression }\` should match ${ string } (U+${ printStringCodePoints(string) })`
+      );
+    }
+  }
+
+  const allNonMatchStrings = nonMatchStrings.join('');
+  if (regExp.test(allNonMatchStrings)) {
+    for (const string of nonMatchStrings) {
+      assert(
+        !regExp.test(string),
+        `\`${ expression }\` should not match ${ string } (U+${ printStringCodePoints(string) })`
+      );
+    }
+  }
+}
+
+// The exact same logic can be used to test extended character classes
+// as enabled through the RegExp `v` flag. This is useful to test not
+// just standalone properties of strings, but also string literals, and
+// set operations.
+const testExtendedCharacterClass = testPropertyOfStrings;
+
+// Returns a function that validates a RegExp match result.
+//
+// Example:
+//
+//    var validate = matchValidator(['b'], 1, 'abc');
+//    validate(/b/.exec('abc'));
+//
+function matchValidator(expectedEntries, expectedIndex, expectedInput) {
+  return function(match) {
+    assert.compareArray(match, expectedEntries, 'Match entries');
+    assert.sameValue(match.index, expectedIndex, 'Match index');
+    assert.sameValue(match.input, expectedInput, 'Match input');
+  }
+}