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

    ProtocolTest.expectException(() => {
        new AsyncTestSuite(this);
    });

    ProtocolTest.expectException(() => {
        new AsyncTestSuite(this, {});
    });

    ProtocolTest.expectException(() => {
        new AsyncTestSuite(this, "      ");
    });

    ProtocolTest.expectException(() => {
        new AsyncTestSuite("something", {});
    });

    let badArgsSuite = ProtocolTest.createAsyncSuite("dummy");
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase();
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase("string");
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: {},
            test() {
            },
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "        ",
            test() {
            },
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test: null,
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            setup: "astd",
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            setup: 123,
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            setup: {},
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            teardown: "astd",
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            teardown: 123,
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            teardown: {},
        });
    });

    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 runTwiceSuiteRunCount = 0;
    let runTwiceSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.RunTwiceSuite");
    runTwiceSuite.addTestCase({
        name: "DummyTest0",
        test(resolve, reject) {
            ProtocolTest.expectEqual(++runTwiceSuiteRunCount, 1, "DummyTest0 should only run once.");
            resolve();
        },
    });

    let result = runTwiceSuite.runTestCases();
    ProtocolTest.expectException(() => {
        // 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();
    });

    function checkResult(suite, expectedCounts) {
        result = result.then(() => suite.runTestCases());

        let message = `Promise from ${suite.name}.runTestCases() should resolve even if a test case fails.`;

        result = result.then(function resolved() {
            ProtocolTest.log("");
            ProtocolTest.pass(message);

            ProtocolTest.expectEqual(expectedCounts.runCount, suite.runCount, `${suite.name} should have executed ${expectedCounts.runCount} tests.`);
            ProtocolTest.expectEqual(expectedCounts.passCount, suite.passCount, `${suite.name} should have passed ${expectedCounts.passCount} tests.`);
            ProtocolTest.expectEqual(expectedCounts.failCount, suite.failCount, `${suite.name} should have failed ${expectedCounts.failCount} tests.`);
            ProtocolTest.expectEqual(expectedCounts.skipCount, suite.skipCount, `${suite.name} should have skipped ${expectedCounts.skipCount} tests.`);
        }, function rejected(e) {
            ProtocolTest.log("");
            ProtocolTest.fail(message);

            ProtocolTest.log(e.message);
        });
    }

    // Promise test functions.

    let promiseFunctionSuccessSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseFunctionSuccess");
    promiseFunctionSuccessSuite.addTestCase({
        name: "PromiseFunctionSuccess",
        test(resolve, reject) {
            resolve();
        },
    });
    checkResult(promiseFunctionSuccessSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 0,
        skipCount: 0,
    });

    let promiseFunctionExceptionSuite = ProtocolTest.createAsyncSuite("PromiseTestSuite.PromiseFunctionException");
    promiseFunctionExceptionSuite.addTestCase({
        name: "PromiseFunctionException",
        test(resolve, reject) {
            ProtocolTest.log("Throwing...");
            throw "PromiseFunctionException throw";
        },
    });
    checkResult(promiseFunctionExceptionSuite, {
        runCount: 1,
        passCount: 0,
        failCount: 1,
        skipCount: 0,
    });

    let promiseFunctionFailureSuite = ProtocolTest.createAsyncSuite("PromiseTestSuite.PromiseFunctionFailure");
    promiseFunctionFailureSuite.addTestCase({
        name: "PromiseFunctionFailure",
        test(resolve, reject) {
            ProtocolTest.log("Rejecting...");
            reject("PromiseFunctionFailure reject");
        },
    });
    checkResult(promiseFunctionFailureSuite, {
        runCount: 1,
        passCount: 0,
        failCount: 1,
        skipCount: 0,
    });

    let promiseSequentialExecutionPhase = 0;
    let promiseSequentialExecutionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseSequentialExecution");
    promiseSequentialExecutionSuite.addTestCase({
        name: "1 (Pass)",
        test(resolve, reject) {
            ProtocolTest.assert(promiseSequentialExecutionPhase === 0);
            promiseSequentialExecutionPhase = 1;
            resolve();
        },
    });
    promiseSequentialExecutionSuite.addTestCase({
        name: "2 (Pass)",
        test(resolve, reject) {
            ProtocolTest.assert(promiseSequentialExecutionPhase === 1);
            promiseSequentialExecutionPhase = 2;
            resolve();
        },
    });
    promiseSequentialExecutionSuite.addTestCase({
        name: "3 (Pass)",
        test(resolve, reject) {
            ProtocolTest.assert(promiseSequentialExecutionPhase === 2);
            promiseSequentialExecutionPhase = 3;
            resolve();
        },
    });
    promiseSequentialExecutionSuite.addTestCase({
        name: "4 (Pass)",
        test(resolve, reject) {
            ProtocolTest.assert(promiseSequentialExecutionPhase === 3);
            promiseSequentialExecutionPhase = 4;
            resolve();
        },
    });
    checkResult(promiseSequentialExecutionSuite, {
        runCount: 4,
        passCount: 4,
        failCount: 0,
        skipCount: 0,
    });
    result = result.then(() => {
        ProtocolTest.assert(promiseSequentialExecutionPhase === 4);
    });

    let promiseContinueOnFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseContinueOnFailure");
    promiseContinueOnFailureSuite.addTestCase({
        name: "1 (Pass)",
        test(resolve, reject) {
            resolve();
        },
    });
    promiseContinueOnFailureSuite.addTestCase({
        name: "2 (Fail)",
        test(resolve, reject) {
            ProtocolTest.log("Throwing...");
            throw {x: "PromiseContinueOnFailure throw"};
        },
    });
    promiseContinueOnFailureSuite.addTestCase({
        name: "3 (Pass)",
        test(resolve, reject) {
            resolve();
        },
    });
    promiseContinueOnFailureSuite.addTestCase({
        name: "4 (Fail)",
        test(resolve, reject) {
            ProtocolTest.log("Rejecting...");
            reject({x: "PromiseContinueOnFailure reject"});
        },
    });
    checkResult(promiseContinueOnFailureSuite, {
        runCount: 4,
        passCount: 2,
        failCount: 2,
        skipCount: 0,
    });

    let promiseSetupAndTeardownPhase = 0;
    let promiseSetupAndTeardownSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseSetupAndTeardown");
    promiseSetupAndTeardownSuite.addTestCase({
        name: "TestWithSetupAndTeardown",
        setup(resolve, reject) {
            ProtocolTest.assert(promiseSetupAndTeardownPhase === 0);
            promiseSetupAndTeardownPhase = 1;
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.assert(promiseSetupAndTeardownPhase === 1);
            promiseSetupAndTeardownPhase = 2;
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.assert(promiseSetupAndTeardownPhase === 2);
            promiseSetupAndTeardownPhase = 3;
            resolve();
        },
    });
    promiseSetupAndTeardownSuite.addTestCase({
        name: "TestRunningAfterTeardown",
        test(resolve, reject) {
            ProtocolTest.assert(promiseSetupAndTeardownPhase === 3);
            resolve();
        },
    });
    checkResult(promiseSetupAndTeardownSuite, {
        runCount: 2,
        passCount: 2,
        failCount: 0,
        skipCount: 0,
    });

    let promiseSetupExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseSetupException");
    promiseSetupExceptionSuite.addTestCase({
        name: "TestWithExceptionDuringSetup",
        setup(resolve, reject) {
            ProtocolTest.log("Throwing...");
            throw "PromiseSetupException throw";
        },
        test(resolve, reject) {
            ProtocolTest.fail("Test should not execute if its setup action threw an exception.");
            reject();
        },
        teardown(resolve, reject) {
            ProtocolTest.fail("Teardown action should not execute if its setup action threw an exception.");
            reject();
        },
    });
    promiseSetupExceptionSuite.addTestCase({
        name: "TestAfterSetupException",
        setup(resolve, reject) {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action threw an exception.");
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.pass("Test should still execute if previous test's setup action threw an exception.");
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.pass("Teardown action should still execute if previous test's setup action threw an exception.");
            resolve();
        },
    });
    checkResult(promiseSetupExceptionSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let promiseSetupFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseSetupFailure");
    promiseSetupFailureSuite.addTestCase({
        name: "TestWithFailureDuringSetup",
        setup(resolve, reject) {
            ProtocolTest.log("Rejecting...");
            reject("PromiseSetupFailure reject");
        },
        test(resolve, reject) {
            ProtocolTest.fail("Test should not execute if its setup action failed.");
            reject();
        },
        teardown(resolve, reject) {
            ProtocolTest.fail("Teardown action should not execute if its setup action failed.");
            reject();
        },
    });
    promiseSetupFailureSuite.addTestCase({
        name: "TestAfterSetupException",
        setup(resolve, reject) {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action failed.");
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.pass("Test should still execute if previous test's setup action failed.");
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.pass("Teardown action should still execute if previous test's setup action failed.");
            resolve();
        },
    });
    checkResult(promiseSetupFailureSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let promiseTeardownExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseTeardownException");
    promiseTeardownExceptionSuite.addTestCase({
        name: "TestWithExceptionDuringTeardown",
        test(resolve, reject) {
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.log("Throwing...");
            throw "PromiseTeardownException throw";
        },
    });
    promiseTeardownExceptionSuite.addTestCase({
        name: "TestAfterTeardownException",
        setup(resolve, reject) {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action threw an exception.");
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.pass("Test should still execute if previous test's teardown action threw an exception.");
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action threw an exception.");
            resolve();
        },
    });
    checkResult(promiseTeardownExceptionSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    let promiseTeardownFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseTeardownFailure");
    promiseTeardownFailureSuite.addTestCase({
        name: "TestWithExceptionDuringTeardown",
        test(resolve, reject) {
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.log("Rejecting...");
            reject("PromiseTeardownFailure reject");
        },
    });
    promiseTeardownFailureSuite.addTestCase({
        name: "TestAfterTeardownException",
        setup(resolve, reject) {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action failed.");
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.pass("Test should still execute if previous test's teardown action failed.");
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action failed.");
            resolve();
        },
    });
    checkResult(promiseTeardownFailureSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    let promiseTimeoutSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.PromiseTimeout");
    promiseTimeoutSuite.addTestCase({
        name: "PromiseTestWithTimeout",
        test(resolve, reject) {
            ProtocolTest.log("Timeout...");
            setTimeout(() => {
                resolve();
            }, 50);
        },
        timeout: 5,
    });
    promiseTimeoutSuite.addTestCase({
        name: "PromiseTestAfterTimeout",
        setup(resolve, reject) {
            ProtocolTest.pass("Setup action should still execute if previous test timed out.");
            resolve();
        },
        test(resolve, reject) {
            ProtocolTest.pass("Test should still execute if previous test timed out.");
            resolve();
        },
        teardown(resolve, reject) {
            ProtocolTest.pass("Teardown action should still execute if previous test timed out.");
            resolve();
        },
    });
    checkResult(promiseTimeoutSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    // Async test functions.

    let asyncFunctionSuccessSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionSuccess");
    asyncFunctionSuccessSuite.addTestCase({
        name: "AsyncFunctionSuccess",
        async test() {
        },
    });
    checkResult(asyncFunctionSuccessSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 0,
        skipCount: 0,
    });

    let asyncFunctionExplicitExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionExplicitException");
    asyncFunctionExplicitExceptionSuite.addTestCase({
        name: "AsyncFunctionExplicitException",
        async test() {
            ProtocolTest.log("Throwing...");
            throw "AsyncFunctionExplicitException throw";
        },
    });
    checkResult(asyncFunctionExplicitExceptionSuite, {
        runCount: 1,
        passCount: 0,
        failCount: 1,
        skipCount: 0,
    });

    let asyncFunctionRuntimeExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionRuntimeException");
    asyncFunctionRuntimeExceptionSuite.addTestCase({
        name: "AsyncFunctionRuntimeException",
        async test() {
            ProtocolTest.log("Throwing...");
            ({}).x.x.x;
        },
    });
    checkResult(asyncFunctionRuntimeExceptionSuite, {
        runCount: 1,
        passCount: 0,
        failCount: 1,
        skipCount: 0,
    });

    let asyncFunctionFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncFunctionFailure");
    asyncFunctionFailureSuite.addTestCase({
        name: "AsyncFunctionException",
        async test() {
            ProtocolTest.log("Rejecting...");
            return Promise.reject("AsyncFunctionFailure reject");
        },
    });
    checkResult(asyncFunctionFailureSuite, {
        runCount: 1,
        passCount: 0,
        failCount: 1,
        skipCount: 0,
    });

    let asyncSequentialExecutionPhase = 0;
    let asyncSequentialExecutionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSequentialExecution");
    asyncSequentialExecutionSuite.addTestCase({
        name: "1 (Pass)",
        async test() {
            ProtocolTest.assert(asyncSequentialExecutionPhase === 0);
            asyncSequentialExecutionPhase = 1;
        },
    });
    asyncSequentialExecutionSuite.addTestCase({
        name: "2 (Pass)",
        async test() {
            ProtocolTest.assert(asyncSequentialExecutionPhase === 1);
            asyncSequentialExecutionPhase = 2;
        },
    });
    asyncSequentialExecutionSuite.addTestCase({
        name: "3 (Pass)",
        async test() {
            ProtocolTest.assert(asyncSequentialExecutionPhase === 2);
            asyncSequentialExecutionPhase = 3;
        },
    });
    asyncSequentialExecutionSuite.addTestCase({
        name: "4 (Pass)",
        async test() {
            ProtocolTest.assert(asyncSequentialExecutionPhase === 3);
            asyncSequentialExecutionPhase = 4;
        },
    });
    checkResult(asyncSequentialExecutionSuite, {
        runCount: 4,
        passCount: 4,
        failCount: 0,
        skipCount: 0,
    });
    result = result.then(() => {
        ProtocolTest.assert(asyncSequentialExecutionPhase === 4);
    });

    let asyncContinueOnFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncContinueOnFailure");
    asyncContinueOnFailureSuite.addTestCase({
        name: "1 (Pass)",
        async test() {
        },
    });
    asyncContinueOnFailureSuite.addTestCase({
        name: "2 (Fail)",
        async test() {
            ProtocolTest.log("Throwing...");
            throw {x: "AsyncContinueOnFailure throw"};
        },
    });
    asyncContinueOnFailureSuite.addTestCase({
        name: "3 (Pass)",
        async test() {
        },
    });
    asyncContinueOnFailureSuite.addTestCase({
        name: "4 (Fail)",
        async test() {
            ProtocolTest.log("Throwing...");
            ({}).x.x.x;
        },
    });
    asyncContinueOnFailureSuite.addTestCase({
        name: "5 (Pass)",
        async test() {
        },
    });
    asyncContinueOnFailureSuite.addTestCase({
        name: "6 (Fail)",
        async test() {
            ProtocolTest.log("Rejecting...");
            return Promise.reject("AsyncContinueOnFailure reject");
        },
    });
    checkResult(asyncContinueOnFailureSuite, {
        runCount: 6,
        passCount: 3,
        failCount: 3,
        skipCount: 0,
    });

    let asyncSetupAndTeardownPhase = 0;
    let asyncSetupAndTeardownSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupAndTeardown");
    asyncSetupAndTeardownSuite.addTestCase({
        name: "AsyncTestWithSetupAndTeardown",
        async setup() {
            ProtocolTest.assert(asyncSetupAndTeardownPhase === 0);
            asyncSetupAndTeardownPhase = 1;
        },
        async test() {
            ProtocolTest.assert(asyncSetupAndTeardownPhase === 1);
            asyncSetupAndTeardownPhase = 2;
        },
        async teardown() {
            ProtocolTest.assert(asyncSetupAndTeardownPhase === 2);
            asyncSetupAndTeardownPhase = 3;
        },
    });
    asyncSetupAndTeardownSuite.addTestCase({
        name: "AsyncTestRunningAfterTeardown",
        async test() {
            ProtocolTest.assert(asyncSetupAndTeardownPhase === 3);
        },
    });
    checkResult(asyncSetupAndTeardownSuite, {
        runCount: 2,
        passCount: 2,
        failCount: 0,
        skipCount: 0,
    });

    let asyncSetupExplicitExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupExplicitException");
    asyncSetupExplicitExceptionSuite.addTestCase({
        name: "AsyncTestWithExplicitExceptionDuringSetup",
        async setup() {
            ProtocolTest.log("Throwing...");
            throw "AsyncSetupExplicitException throw";
        },
        async test() {
            ProtocolTest.fail("Test should not execute if its setup action threw an exception.");
        },
        async teardown() {
            ProtocolTest.fail("Teardown action should not execute if its setup action threw an exception.");
        },
    });
    asyncSetupExplicitExceptionSuite.addTestCase({
        name: "AsyncTestAfterSetupExplicitException",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action threw an exception.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test's setup action threw an exception.");
        },
        async teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's setup action threw an exception.");
        },
    });
    checkResult(asyncSetupExplicitExceptionSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let asyncSetupRuntimeExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupRuntimeException");
    asyncSetupRuntimeExceptionSuite.addTestCase({
        name: "AsyncTestWithRuntimeExceptionDuringSetup",
        async setup() {
            ProtocolTest.log("Throwing...");
            ({}).x.x.x;
        },
        async test() {
            ProtocolTest.fail("Test should not execute if its setup action threw an exception.");
        },
        async teardown() {
            ProtocolTest.fail("Teardown action should not execute if its setup action threw an exception.");
        },
    });
    asyncSetupRuntimeExceptionSuite.addTestCase({
        name: "AsyncTestAfterSetupRuntimeException",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action threw an exception.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test's setup action threw an exception.");
        },
        async teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's setup action threw an exception.");
        },
    });
    checkResult(asyncSetupRuntimeExceptionSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let asyncSetupFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncSetupFailure");
    asyncSetupFailureSuite.addTestCase({
        name: "AsyncTestWithFailureDuringSetup",
        async setup() {
            ProtocolTest.log("Rejecting...");
            return Promise.reject("AsyncSetupFailure reject");
        },
        async test() {
        },
    });
    asyncSetupFailureSuite.addTestCase({
        name: "AsyncTestAfterSetupFailure",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action failed.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test's setup action failed.");
        },
        async teardown() {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action failed.");
        },
    });
    checkResult(asyncSetupFailureSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let asyncTeardownExplicitExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncTeardownExplicitException");
    asyncTeardownExplicitExceptionSuite.addTestCase({
        name: "AsyncTestWithExplicitExceptionDuringTeardown",
        async test() {
        },
        async teardown() {
            ProtocolTest.log("Throwing...");
            throw "AsyncTeardownExplicitException throw";
        },
    });
    asyncTeardownExplicitExceptionSuite.addTestCase({
        name: "AsyncTestAfterTeardownExplicitException",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action threw an exception.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test's teardown action threw an exception.");
        },
        async teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action threw an exception.");
        },
    });
    checkResult(asyncTeardownExplicitExceptionSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    let asyncTeardownRuntimeExceptionSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncTeardownRuntimeException");
    asyncTeardownRuntimeExceptionSuite.addTestCase({
        name: "AsyncTestWithRuntimeExceptionDuringTeardown",
        async test() {
        },
        async teardown() {
            ProtocolTest.log("Throwing...");
            ({}).x.x.x;
        },
    });
    asyncTeardownRuntimeExceptionSuite.addTestCase({
        name: "AsyncTestAfterTeardownRuntimeException",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action threw an exception.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test's teardown action threw an exception.");
        },
        async teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action threw an exception.");
        },
    });
    checkResult(asyncTeardownRuntimeExceptionSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    let asyncTeardownFailureSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncTeardownFailure");
    asyncTeardownFailureSuite.addTestCase({
        name: "AsyncTestWithFailureDuringTeardown",
        async test() {
        },
        async teardown() {
            ProtocolTest.log("Rejecting...");
            return Promise.reject("AsyncTeardownFailure reject");
        },
    });
    asyncTeardownFailureSuite.addTestCase({
        name: "AsyncTestAfterTeardownFailure",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action failed.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test's teardown action failed.");
        },
        async teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action failed.");
        },
    });
    checkResult(asyncTeardownFailureSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    let asyncTimeoutSuite = ProtocolTest.createAsyncSuite("AsyncTestSuite.AsyncTimeout");
    asyncTimeoutSuite.addTestCase({
        name: "AsyncTestWithTimeout",
        async test() {
            ProtocolTest.log("Timeout...");
            await Promise.delay(50);
        },
        timeout: 5,
    });
    asyncTimeoutSuite.addTestCase({
        name: "AsyncTestAfterTimeout",
        async setup() {
            ProtocolTest.pass("Setup action should still execute if previous test timed out.");
        },
        async test() {
            ProtocolTest.pass("Test should still execute if previous test timed out.");
        },
        async teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test timed out.");
        },
    });
    checkResult(asyncTimeoutSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

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