// Basic surface tests.

assertEq(typeof String.prototype.matchAll, "function");
assertEq(String.prototype.matchAll.name, "matchAll");
assertEq(String.prototype.matchAll.length, 1);

assertEq(typeof Symbol.matchAll, "symbol");

assertEq(typeof RegExp.prototype[Symbol.matchAll], "function");
assertEq(RegExp.prototype[Symbol.matchAll].name, "[Symbol.matchAll]");
assertEq(RegExp.prototype[Symbol.matchAll].length, 1);

const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
const RegExpStringIteratorPrototype = Object.getPrototypeOf("".matchAll(""));

assertEq(Object.getPrototypeOf(RegExpStringIteratorPrototype), IteratorPrototype);

assertEq(typeof RegExpStringIteratorPrototype.next, "function");
assertEq(RegExpStringIteratorPrototype.next.name, "next");
assertEq(RegExpStringIteratorPrototype.next.length, 0);

assertEq(RegExpStringIteratorPrototype[Symbol.toStringTag], "RegExp String Iterator");


// Basic functional tests.

const RegExp_prototype_exec = RegExp.prototype.exec;
const RegExp_prototype_match = RegExp.prototype[Symbol.match];

function assertEqIterMatchResult(actual, expected) {
    assertEq(actual.done, expected.done);
    if (actual.value === undefined || expected.value === undefined) {
        assertEq(actual.value, expected.value);
    } else {
        assertEqArray(actual.value, expected.value);
        assertEq(actual.value.input, expected.value.input);
        assertEq(actual.value.index, expected.value.index);
    }
}

function assertEqMatchResults(actual, expected) {
    var actualIter = actual[Symbol.iterator]();
    var expectedIter = expected[Symbol.iterator]();
    while (true) {
        var actualResult = actualIter.next();
        var expectedResult = expectedIter.next();
        assertEqIterMatchResult(actualResult, expectedResult);
        if (actualResult.done && expectedResult.done)
            return;
    }
}

function* matchResults(string, regexp, lastIndex = 0) {
    regexp.lastIndex = lastIndex;
    while (true) {
        var match = Reflect.apply(RegExp_prototype_exec, regexp, [string]);
        if (match === null)
            return;
        yield match;
        if (!regexp.global)
            return;
    }
}

assertEqMatchResults(/a/[Symbol.matchAll]("ababcca"), matchResults("ababcca", /a/));
assertEqMatchResults("ababcca".matchAll(/a/g), matchResults("ababcca", /a/g));
assertEqMatchResults("ababcca".matchAll("a"), matchResults("ababcca", /a/g));


// Cross-compartment tests.

{
    let otherGlobal = newGlobal();

    let iterator = otherGlobal.eval(`"ababcca".matchAll(/a/g)`);
    let expected = matchResults("ababcca", /a/g);

    assertEqIterMatchResult(RegExpStringIteratorPrototype.next.call(iterator),
                            expected.next());
}


// Optimization tests.
//
// The optimized path for MatchAllIterator reuses the input RegExp to avoid
// extra RegExp allocations. To make this optimization undetectable from
// user code, we need to ensure that:
// 1. Modifications to the input RegExp through RegExp.prototype.compile are
//    detected and properly handled (= ignored).
// 2. The RegExpStringIterator doesn't modify the input RegExp, for example
//    by updating the lastIndex property.
// 3. Guards against modifications of built-in RegExp.prototype are installed.

// Recompile RegExp (source) before first match.
{
    let regexp = /a+/g;
    let iterator = "aabb".matchAll(regexp);

    regexp.compile("b+", "g");
    assertEqMatchResults(iterator, matchResults("aabb", /a+/g));
}

// Recompile RegExp (flags) before first match.
{
    let regexp = /a+/gi;
    let iterator = "aAbb".matchAll(regexp);

    regexp.compile("a+", "");
    assertEqMatchResults(iterator, matchResults("aAbb", /a+/gi));
}

// Recompile RegExp (source) after first match.
{
    let regexp = /a+/g;
    let iterator = "aabbaa".matchAll(regexp);
    let expected = matchResults("aabbaa", /a+/g);

    assertEqIterMatchResult(iterator.next(), expected.next());
    regexp.compile("b+", "g");
    assertEqIterMatchResult(iterator.next(), expected.next());
}

// Recompile RegExp (flags) after first match.
{
    let regexp = /a+/g;
    let iterator = "aabbAA".matchAll(regexp);
    let expected = matchResults("aabbAA", /a+/g);

    assertEqIterMatchResult(iterator.next(), expected.next());
    regexp.compile("a+", "i");
    assertEqIterMatchResult(iterator.next(), expected.next());
}

// lastIndex property of input RegExp not modified when optimized path used.
{
    let regexp = /a+/g;
    regexp.lastIndex = 1;
    let iterator = "aabbaa".matchAll(regexp);
    let expected = matchResults("aabbaa", /a+/g, 1);

    assertEq(regexp.lastIndex, 1);
    assertEqIterMatchResult(iterator.next(), expected.next());
    assertEq(regexp.lastIndex, 1);
    assertEqIterMatchResult(iterator.next(), expected.next());
    assertEq(regexp.lastIndex, 1);
}

// Modifications to lastIndex property of input RegExp ignored when optimized path used.
{
    let regexp = /a+/g;
    let iterator = "aabbaa".matchAll(regexp);
    regexp.lastIndex = 1;
    let expected = matchResults("aabbaa", /a+/g);

    assertEq(regexp.lastIndex, 1);
    assertEqIterMatchResult(iterator.next(), expected.next());
    assertEq(regexp.lastIndex, 1);
    assertEqIterMatchResult(iterator.next(), expected.next());
    assertEq(regexp.lastIndex, 1);
}

// RegExp.prototype[Symbol.match] is modified to a getter, ensure this getter
// is called exactly twice.
try {
    let regexp = /a+/g;

    let callCount = 0;
    Object.defineProperty(RegExp.prototype, Symbol.match, {
        get() {
            assertEq(this, regexp);
            callCount++;
            return RegExp_prototype_match;
        }
    });
    let iterator = "aabbaa".matchAll(regexp);
    assertEq(callCount, 2);
} finally {
    // Restore optimizable RegExp.prototype shape.
    Object.defineProperty(RegExp.prototype, Symbol.match, {
        value: RegExp_prototype_match,
        writable: true, enumerable: false, configurable: true
    });
}

// RegExp.prototype.exec is changed to a getter.
try {
    let regexp = /a+/g;
    let iterator = "aabbaa".matchAll(regexp);
    let lastIndices = [0, 2, 6][Symbol.iterator]();

    let iteratorRegExp = null;
    let callCount = 0;
    Object.defineProperty(RegExp.prototype, "exec", {
        get() {
            callCount++;

            if (iteratorRegExp === null)
                iteratorRegExp = this;

            assertEq(this === regexp, false);
            assertEq(this, iteratorRegExp);
            assertEq(this.source, regexp.source);
            assertEq(this.flags, regexp.flags);
            assertEq(this.lastIndex, lastIndices.next().value);
            return RegExp_prototype_exec;
        }
    });

    assertEqMatchResults(iterator, matchResults("aabbaa", /a+/g));
    assertEq(callCount, 3);
} finally {
    // Restore optimizable RegExp.prototype shape.
    Object.defineProperty(RegExp.prototype, "exec", {
        value: RegExp_prototype_exec,
        writable: true, enumerable: false, configurable: true
    });
}

// RegExp.prototype.exec is changed to a value property.
try {
    let regexp = /a+/g;
    let iterator = "aabbaa".matchAll(regexp);
    let lastIndices = [0, 2, 6][Symbol.iterator]();

    let iteratorRegExp = null;
    let callCount = 0;
    RegExp.prototype.exec = function(...args) {
        callCount++;

        if (iteratorRegExp === null)
            iteratorRegExp = this;

        assertEq(this === regexp, false);
        assertEq(this, iteratorRegExp);
        assertEq(this.source, regexp.source);
        assertEq(this.flags, regexp.flags);
        assertEq(this.lastIndex, lastIndices.next().value);
        return Reflect.apply(RegExp_prototype_exec, this, args);
    };

    assertEqMatchResults(iterator, matchResults("aabbaa", /a+/g));
    assertEq(callCount, 3);
} finally {
    // Restore optimizable RegExp.prototype shape.
    Object.defineProperty(RegExp.prototype, "exec", {
        value: RegExp_prototype_exec,
        writable: true, enumerable: false, configurable: true
    });
}

// Initial 'lastIndex' is zero if the RegExp is neither global nor sticky (1).
{
    let regexp = /a+/;
    regexp.lastIndex = 2;

    let iterator = regexp[Symbol.matchAll]("aaaaa");
    assertEqMatchResults(iterator, matchResults("aaaaa", /a+/g, 0));
}

// Initial 'lastIndex' is zero if the RegExp is neither global nor sticky (2).
{
    let regexp = /a+/g;
    regexp.lastIndex = 2;

    let iterator = regexp[Symbol.matchAll]("aaaaa");
    assertEqMatchResults(iterator, matchResults("aaaaa", /a+/g, 2));
}

// Initial 'lastIndex' is zero if the RegExp is neither global nor sticky (3).
{
    let regexp = /a+/y;
    regexp.lastIndex = 2;

    let iterator = regexp[Symbol.matchAll]("aaaaa");
    assertEqMatchResults(iterator, matchResults("aaaaa", /a+/g, 2));
}

//Initial 'lastIndex' is zero if the RegExp is neither global nor sticky (4).
{
    let regexp = /a+/gy;
    regexp.lastIndex = 2;

    let iterator = regexp[Symbol.matchAll]("aaaaa");
    assertEqMatchResults(iterator, matchResults("aaaaa", /a+/g, 2));
}

if (typeof reportCompare === "function")
    reportCompare(true, true);