<!doctype html>
<html>
<head>
<script src="../../http/tests/inspector/resources/protocol-test.js"></script>
<script>
function test()
{
    ProtocolTest.suppressStackTraces = true;

    try {
        let result = new AsyncTestSuite(this);
        ProtocolTest.fail("instantiating AsyncTestSuite requires name argument.");
    } catch (e) {
        ProtocolTest.pass("instantiating AsyncTestSuite requires name argument.");
    }

    try {
        let result = new AsyncTestSuite(this, {});
        ProtocolTest.fail("instantiating AsyncTestSuite requires string name argument.");
    } catch (e) {
        ProtocolTest.pass("instantiating AsyncTestSuite requires string name argument.");
    }

    try {
        let result = new AsyncTestSuite(this, "      ");
        ProtocolTest.fail("instantiating AsyncTestSuite requires non-whitespace name argument.");
    } catch (e) {
        ProtocolTest.pass("instantiating AsyncTestSuite requires non-whitespace name argument.");
    }

    try {
        let result = new AsyncTestSuite("something", {});
        ProtocolTest.fail("instantiating AsyncTestSuite requires test harness argument.");
    } catch (e) {
        ProtocolTest.pass("instantiating AsyncTestSuite requires test harness argument.");
    }

    let badArgsSuite = ProtocolTest.createAsyncSuite("dummy");
    try {
        badArgsSuite.addTestCase();
        ProtocolTest.fail("should not be able to add empty test case.");
    } catch (e) {
        ProtocolTest.pass("should not be able to add empty test case.");
    }
    try {
        badArgsSuite.addTestCase("string");
        ProtocolTest.fail("should not be able to add non-object test case.");
    } catch (e) {
        ProtocolTest.pass("should not be able to add non-object test case.");
    }
    try {
        badArgsSuite.addTestCase({
            name: {},
            test() {},
        });
        ProtocolTest.fail("test case should require string name.");
    } catch (e) {
        ProtocolTest.pass("test case should require string name.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "        ",
            test() {},
        });
        ProtocolTest.fail("test case should require non-whitespace name.");
    } catch (e) {
        ProtocolTest.pass("test case should require non-whitespace name.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test: null,
        });
        ProtocolTest.fail("test case should require test function.");
    } catch (e) {
        ProtocolTest.pass("test case should require test function.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {},
            setup: "astd"
        });
        ProtocolTest.fail("should not be able to specify non-Function `setup` parameter.");
    } catch (e) {
        ProtocolTest.pass("should not be able to specify non-Function `setup` parameter.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {},
            setup: 123
        });
        ProtocolTest.fail("should not be able to specify non-Function `setup` parameter.");
    } catch (e) {
        ProtocolTest.pass("should not be able to specify non-Function `setup` parameter.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {},
            setup: {}
        });
        ProtocolTest.fail("should not be able to specify non-Function `setup` parameter.");
    } catch (e) {
        ProtocolTest.pass("should not be able to specify non-Function `setup` parameter.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {},
            teardown: "astd"
        });
        ProtocolTest.fail("should not be able to specify non-Function `teardown` parameter.");
    } catch (e) {
        ProtocolTest.pass("should not be able to specify non-Function `teardown` parameter.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {},
            teardown: 123
        });
        ProtocolTest.fail("should not be able to specify non-Function `teardown` parameter.");
    } catch (e) {
        ProtocolTest.pass("should not be able to specify non-Function `teardown` parameter.");
    }
    try {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {},
            teardown: {}
        });
        ProtocolTest.fail("should not be able to specify non-Function `teardown` parameter.");
    } catch (e) {
        ProtocolTest.pass("should not be able to specify non-Function `teardown` parameter.");
    }

    let runEmptySuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.RunEmptySuite");
    try {
        runEmptySuite.runTestCases();
        ProtocolTest.fail("should not be able to run empty test suite.");
    } catch (e) {
        ProtocolTest.pass("should not be able to run empty test suite.");
    }

    let runTwiceSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.RunTwiceSuite");
    runTwiceSuite.addTestCase({
        name: "DummyTest0",
        description: "Check that a suite can't run more than once.",
        test(resolve, reject) { resolve(); }
    });

    let result = runTwiceSuite.runTestCases();
    try {
        // Test cases won't run in this event loop; this call should still throw.
        // Later tests are chained to this suite to avoid nondeterminism.
        runTwiceSuite.runTestCases();
        ProtocolTest.fail("should not be able to run a test suite twice.");
    } catch (e) {
        ProtocolTest.pass("should not be able to run a test suite twice.");
    }

    let rejectToken = {"token": 666};
    let thrownError = new Error(rejectToken);

    let sequentialExecutionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.SequentialExecution");
    sequentialExecutionSuite.addTestCase({
        name: "DummyTest1",
        description: "Check test case execution order.",
        test(resolve, reject) { resolve(); }
    });
    sequentialExecutionSuite.addTestCase({
        name: "DummyTest2",
        description: "Check test case execution order.",
        test(resolve, reject) { resolve(); }
    });
    sequentialExecutionSuite.addTestCase({
        name: "DummyTest3",
        description: "Check test case execution order.",
        test(resolve, reject) { resolve(); }
    });
    sequentialExecutionSuite.addTestCase({
        name: "FailingTest4",
        description: "Check that test fails by throwing an Error instance.",
        test(resolve, reject) { throw thrownError; }
    });

    let abortOnFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AbortOnFailure");
    abortOnFailureSuite.addTestCase({
        name: "PassingTest5",
        description: "This test is a dummy.",
        test(resolve, reject) { resolve(); }
    });
    abortOnFailureSuite.addTestCase({
        name: "FailingTest6",
        description: "This test should fail by explicitly calling the `reject` callback.",
        test(resolve, reject) { reject(rejectToken); }
    });
    abortOnFailureSuite.addTestCase({
        name: "PassingTest7",
        description: "This test should not executed when the preceding test fails.",
        test(resolve, reject) { resolve(); }
    });

    result = result.then(() => {
        let promise = sequentialExecutionSuite.runTestCases();
        ProtocolTest.expectThat(result instanceof Promise, "AsyncTestSuite.RunTestCases() should return a Promise.");
        return promise;
    });
    result = result.then(function resolved() {
        ProtocolTest.fail("Promise from sequentialExecutionSuite.runTestCases() should reject when a test case fails.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from sequentialExecutionSuite.runTestCases() should reject when a test case fails.");
        ProtocolTest.expectThat(e === thrownError, "Promise from sequentialExecutionSuite.runTestCases() should reject without altering its result value.");

        ProtocolTest.expectThat(sequentialExecutionSuite.runCount === 4, "sequentialExecutionSuite should have executed four tests.");
        ProtocolTest.expectThat(sequentialExecutionSuite.passCount === 3, "sequentialExecutionSuite should have passed three tests.");
        ProtocolTest.expectThat(sequentialExecutionSuite.failCount === 1, "sequentialExecutionSuite should have failed 1 test.");
        ProtocolTest.expectThat(sequentialExecutionSuite.skipCount === 0, "sequentialExecutionSuite should have skipped zero tests.");
        return Promise.resolve(); // Continue this test.
    });

    result = result.then(() => {
        return abortOnFailureSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.fail("Promise from abortOnFailureSuite.runTestCases() should reject when a test case fails.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from abortOnFailureSuite.runTestCases() should reject when a test case fails.");
        ProtocolTest.expectThat(e === rejectToken, "Promise from abortOnFailureSuite.runTestCases() should reject without altering its result value.");
        ProtocolTest.expectThat(abortOnFailureSuite.runCount === 2, "abortOnFailureSuite should have executed two tests.");
        ProtocolTest.expectThat(abortOnFailureSuite.passCount === 1, "abortOnFailureSuite should have passed one test.");
        ProtocolTest.expectThat(abortOnFailureSuite.failCount === 1, "abortOnFailureSuite should have failed one test.");
        ProtocolTest.expectThat(abortOnFailureSuite.skipCount === 1, "abortOnFailureSuite should have skipped one test.");

        return Promise.resolve(); // Continue this test.
    });

    var setupAndTeardownSymbol = Symbol("async-suite-setup-and-teardown-token");
    window[setupAndTeardownSymbol] = 0;

    let setupAndTeardownTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.SetupAndTeardown");
    setupAndTeardownTestSuite.addTestCase({
        name: "TestWithSetupAndTeardown",
        description: "Check execution order for setup and teardown actions.",
        setup: (resolve, reject) => {
            window[setupAndTeardownSymbol] = 1;
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 1, "Test should see side effects of running setup() action.");
            window[setupAndTeardownSymbol] = 2;
            resolve();
        },
        teardown: (resolve, reject) => {
            ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 2, "Teardown should see side effects of running setup() action.");
            window[setupAndTeardownSymbol] = 3;
            resolve();
        }
    });
    setupAndTeardownTestSuite.addTestCase({
        name: "TestRunningAfterTeardown",
        description: "Check execution order for test after a teardown action.",
        test(resolve, reject) {
            ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 3, "Test should see side effects of previous test's teardown() action.");
            resolve();
        },
    });

    result = result.then(() => {
        return setupAndTeardownTestSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.pass("Promise from setupAndTeardownTestSuite.runTestCases() should resolve.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.fail("Promise from setupAndTeardownTestSuite.runTestCases() should resolve.");
        return Promise.resolve(); // Continue this test.
    });

    let setupExceptionTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.SetupException");
    setupExceptionTestSuite.addTestCase({
        name: "TestWithExceptionDuringSetup",
        description: "Check execution order for setup action that throws an exception.",
        setup: (resolve, reject) => { throw new Error() },
        test(resolve, reject) {
            ProtocolTest.assert(false, "Test should not execute if its setup action threw an exception.");
            reject();
        },
        teardown: (resolve, reject) => {
            ProtocolTest.assert(false, "Teardown action should not execute if its setup action threw an exception.");
            reject();
        }
    });

    result = result.then(() => {
        return setupExceptionTestSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.fail("Promise from setupExceptionTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from setupExceptionTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    });

    let setupFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.SetupFailure");
    setupFailureTestSuite.addTestCase({
        name: "TestWithFailureDuringSetup",
        description: "Check execution order for setup action that has failed.",
        setup: (resolve, reject) => { reject(); },
        test(resolve, reject) {
            ProtocolTest.assert(false, "Test should not execute if its setup action failed.")
            reject();
        },
        teardown: (resolve, reject) => {
            ProtocolTest.assert(false, "Teardown action should not execute if its setup action failed.")
            reject();
        }
    });

    result = result.then(() => {
        return setupFailureTestSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.fail("Promise from setupFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from setupFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    });

    let teardownExceptionTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.TeardownException");
    teardownExceptionTestSuite.addTestCase({
        name: "TestWithExceptionDuringTeardown",
        description: "Check execution order for teardown action that throws an exception.",
        test(resolve, reject) { resolve(); },
        teardown: (resolve, reject) => { throw new Error() }
    });
    teardownExceptionTestSuite.addTestCase({
        name: "TestAfterTeardownException",
        descrption: "Check execution order for test after previous test's teardown throws an exception.",
        setup: (resolve, reject) => {
            ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action threw an exception.");
            reject();
        },
        test(resolve, reject) {
            ProtocolTest.assert(false, "Test should not execute if previous test's teardown action threw an exception.");
            reject();
        }
    });

    result = result.then(() => {
        return teardownExceptionTestSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.fail("Promise from teardownExceptionTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from teardownExceptionTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    });

    let teardownFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.TeardownFailure");
    teardownFailureTestSuite.addTestCase({
        name: "TestWithExceptionDuringTeardown",
        description: "Check execution order for teardown action that has failed.",
        test(resolve, reject) { resolve(); },
        teardown: (resolve, reject) => { reject(); },
    });
    teardownFailureTestSuite.addTestCase({
        name: "TestAfterTeardownException",
        description: "Check execution order for test after previous test's teardown throws an exception",
        setup: (resolve, reject) => {
            ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action failed.");
            reject();
        },
        test(resolve, reject) {
            ProtocolTest.assert(false, "Test should not execute if previous test's teardown action failed.");
            reject();
        }
    });

    result = result.then(() => {
        return teardownFailureTestSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.fail("Promise from teardownFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from teardownFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    });

    // Async test functions.
    let asyncFunctionSuccessTestSuiteDidEvaluate = false;
    let asyncFunctionSuccessTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionSuccess");
    asyncFunctionSuccessTestSuite.addTestCase({
        name: "AsyncFunctionSuccess",
        description: "Check that an async suite with async test functions can succeed",
        async test() {
            asyncFunctionSuccessTestSuiteDidEvaluate = true;
            return 42;
        }
    });

    result = result.then(() => {
        return asyncFunctionSuccessTestSuite.runTestCases();
    }).then(function resolve(x) {
        ProtocolTest.pass("Promise from asyncFunctionSuccessTestSuite.runTestCases() should succeed.");
        ProtocolTest.expectThat(asyncFunctionSuccessTestSuiteDidEvaluate, "Promise did evaluate the async test function.");
        ProtocolTest.expectEqual(x, 42, "Resolved value should be 42.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.fail("Promise from asyncFunctionSuccessTestSuite.runTestCases() should succeed.");
        return Promise.resolve(); // Continue this test.
    });

    let asyncFunctionExplicitFailureTestSuiteDidEvaluate = false;
    let asyncFunctionExplicitFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionExplicitFailure");
    asyncFunctionExplicitFailureTestSuite.addTestCase({
        name: "AsyncFunctionFailure",
        description: "Check that an async suite with async test functions that throws will reject",
        async test() {
            asyncFunctionExplicitFailureTestSuiteDidEvaluate = true;
            throw "AsyncFunctionFailure Exception Message";
        }
    });

    result = result.then(() => {
        return asyncFunctionExplicitFailureTestSuite.runTestCases();
    }).then(function resolve() {
        ProtocolTest.fail("Promise from asyncFunctionExplicitFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from asyncFunctionExplicitFailureTestSuite.runTestCases() should reject.");
        ProtocolTest.expectThat(asyncFunctionExplicitFailureTestSuiteDidEvaluate, "Promise did evaluate the async test function.");
        ProtocolTest.expectEqual(e, "AsyncFunctionFailure Exception Message", "Rejected value should be thrown exception.");
        return Promise.resolve(); // Continue this test.
    });

    let asyncFunctionRuntimeFailureTestSuiteDidEvaluate = false;
    let asyncFunctionRuntimeFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionRuntimeFailure");
    asyncFunctionRuntimeFailureTestSuite.addTestCase({
        name: "AsyncFunctionFailure",
        description: "Check that an async suite with async test functions that throws with a runtime error will reject",
        async test() {
            asyncFunctionRuntimeFailureTestSuiteDidEvaluate = true;
            ({}).x.x.x;
        }
    });

    result = result.then(() => {
        return asyncFunctionRuntimeFailureTestSuite.runTestCases();
    }).then(function resolve() {
        ProtocolTest.fail("Promise from asyncFunctionRuntimeFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from asyncFunctionRuntimeFailureTestSuite.runTestCases() should reject.");
        ProtocolTest.expectThat(asyncFunctionRuntimeFailureTestSuiteDidEvaluate, "Promise did evaluate the async test function.");
        ProtocolTest.expectThat(e instanceof TypeError, "Rejected value should be a runtime exception.");
        return Promise.resolve(); // Continue this test.
    });

    // Async setup() and teardown() success test cases.
    const asyncSetupAndTeardownSymbol = Symbol("async-suite-async-setup-and-teardown-token");
    window[asyncSetupAndTeardownSymbol] = 0;

    let asyncSetupAndAsyncTeardownTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupAndAsyncTeardown");
    asyncSetupAndAsyncTeardownTestSuite.addTestCase({
        name: "TestWithSetupAndTeardown",
        description: "Check execution order for setup and teardown actions.",
        async setup() {
            window[asyncSetupAndTeardownSymbol] = 1;
        },
        async test() {
            ProtocolTest.expectThat(window[asyncSetupAndTeardownSymbol] === 1, "Test should see side effects of running setup() action.");
            window[asyncSetupAndTeardownSymbol] = 2;
        },
        async teardown() {
            ProtocolTest.expectThat(window[asyncSetupAndTeardownSymbol] === 2, "Teardown should see side effects of running setup() action.");
            window[asyncSetupAndTeardownSymbol] = 3;
        }
    });
    asyncSetupAndAsyncTeardownTestSuite.addTestCase({
        name: "TestRunningAfterTeardown",
        description: "Check execution order for test after a teardown action.",
        test(resolve, reject) {
            ProtocolTest.expectThat(window[asyncSetupAndTeardownSymbol] === 3, "Test should see side effects of previous test's teardown() action.");
            resolve();
        },
    });

    result = result.then(() => {
        return asyncSetupAndAsyncTeardownTestSuite.runTestCases();
    }).then(function resolved() {
        ProtocolTest.pass("Promise from asyncSetupAndAsyncTeardownTestSuite.runTestCases() should resolve.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.fail("Promise from asyncSetupAndAsyncTeardownTestSuite.runTestCases() should resolve.");
        return Promise.resolve(); // Continue this test.
    });

    // Async setup() failure test cases.
    let asyncSetupExplicitFailureTestSuiteDidEvaluate = false;
    let asyncSetupExplicitFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupExplicitFailure");
    asyncSetupExplicitFailureTestSuite.addTestCase({
        name: "AsyncFunctionFailure",
        description: "Check that an async suite with async test functions that throws will reject",
        async test() {
            asyncSetupExplicitFailureTestSuiteDidEvaluate = true;
            throw "AsyncFunctionFailure Exception Message";
        }
    });

    result = result.then(() => {
        return asyncSetupExplicitFailureTestSuite.runTestCases();
    }).then(function resolve() {
        ProtocolTest.fail("Promise from asyncSetupExplicitFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from asyncSetupExplicitFailureTestSuite.runTestCases() should reject.");
        ProtocolTest.expectThat(asyncSetupExplicitFailureTestSuiteDidEvaluate, "Promise did evaluate the async setup function.");
        ProtocolTest.expectEqual(e, "AsyncFunctionFailure Exception Message", "Rejected value should be thrown exception.");
        return Promise.resolve(); // Continue this test.
    });

    let asyncSetupRuntimeFailureTestSuiteDidEvaluate = false;
    let asyncSetupRuntimeFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupRuntimeFailure");
    asyncSetupRuntimeFailureTestSuite.addTestCase({
        name: "AsyncFunctionFailure",
        description: "Check that an async suite with an async setup function that throws with a runtime error will reject",
        async setup() {
            asyncSetupRuntimeFailureTestSuiteDidEvaluate = true;
            ({}).x.x.x;
        },
        async test() { return true; },
    });

    result = result.then(() => {
        return asyncSetupRuntimeFailureTestSuite.runTestCases();
    }).then(function resolve() {
        ProtocolTest.fail("Promise from asyncSetupRuntimeFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from asyncSetupRuntimeFailureTestSuite.runTestCases() should reject.");
        ProtocolTest.expectThat(asyncSetupRuntimeFailureTestSuiteDidEvaluate, "Promise did evaluate the async setup function.");
        ProtocolTest.expectThat(e instanceof TypeError, "Rejected value should be a runtime exception.");
        return Promise.resolve(); // Continue this test.
    });

    // Async teardown() failure test cases.
    let asyncTeardownExplicitFailureTestSuiteDidEvaluate = false;
    let asyncTeardownExplicitFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncTeardownExplicitFailure");
    asyncTeardownExplicitFailureTestSuite.addTestCase({
        name: "AsyncFunctionFailure",
        description: "Check that an async suite with async test functions that throws will reject",
        async test() { return true; },
        async teardown() {
            asyncTeardownExplicitFailureTestSuiteDidEvaluate = true;
            throw "AsyncFunctionFailure Exception Message";
        },
    });

    result = result.then(() => {
        return asyncTeardownExplicitFailureTestSuite.runTestCases();
    }).then(function resolve() {
        ProtocolTest.fail("Promise from asyncTeardownExplicitFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from asyncTeardownExplicitFailureTestSuite.runTestCases() should reject.");
        ProtocolTest.expectThat(asyncTeardownExplicitFailureTestSuiteDidEvaluate, "Promise did evaluate the async teardown function.");
        ProtocolTest.expectEqual(e, "AsyncFunctionFailure Exception Message", "Rejected value should be thrown exception.");
        return Promise.resolve(); // Continue this test.
    });

    let asyncTeardownRuntimeFailureTestSuiteDidEvaluate = false;
    let asyncTeardownRuntimeFailureTestSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncTeardownRuntimeFailure");
    asyncTeardownRuntimeFailureTestSuite.addTestCase({
        name: "AsyncFunctionFailure",
        description: "Check that an async suite with an async teardown function that throws with a runtime error will reject",
        async test() { return true; },
        async teardown() {
            asyncTeardownRuntimeFailureTestSuiteDidEvaluate = true;
            ({}).x.x.x;
        },
    });

    result = result.then(() => {
        return asyncTeardownRuntimeFailureTestSuite.runTestCases();
    }).then(function resolve() {
        ProtocolTest.fail("Promise from asyncTeardownRuntimeFailureTestSuite.runTestCases() should reject.");
        return Promise.resolve(); // Continue this test.
    }, function rejected(e) {
        ProtocolTest.pass("Promise from asyncTeardownRuntimeFailureTestSuite.runTestCases() should reject.");
        ProtocolTest.expectThat(asyncTeardownRuntimeFailureTestSuiteDidEvaluate, "Promise did evaluate the async teardown function.");
        ProtocolTest.expectThat(e instanceof TypeError, "Rejected value should be a runtime exception.");
        return Promise.resolve(); // Continue this test.
    });

    // This will finish the test whether the chain was resolved or rejected.
    result = result.then(() => { ProtocolTest.completeTest(); });
}
</script>
</head>
<body onLoad="runTest()">
</body>
</html>