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

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

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

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

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

    let badArgsSuite = ProtocolTest.createSyncSuite("dummy");
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase();
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase("string");
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: {},
            test() {
                return true;
            },
        });
    });
    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: Promise.resolve()
        });
    });
    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: Promise.resolve()
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            async test() {
            },
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            async setup() {
            },
            test() {
            },
        });
    });
    ProtocolTest.expectException(() => {
        badArgsSuite.addTestCase({
            name: "foo",
            test() {
            },
            async teardown() {
            },
        });
    });

    ProtocolTest.expectException(() => {
        let runEmptySuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunEmptySuite");
        runEmptySuite.runTestCases();
    });

    let runTwiceSuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunTwiceSuite");
    runTwiceSuite.addTestCase({
        name: "DummyTest0",
        test() {
            return true;
        },
    });

    ProtocolTest.expectThat(runTwiceSuite.runTestCases() === true, "Return value of runTwiceSuite.runTestCases() should be true when all tests pass.");

    ProtocolTest.expectException(() => {
        runTwiceSuite.runTestCases();
    });

    function checkResult(suite, expectedCounts) {
        ProtocolTest.expectThat(suite.runTestCases(), `Return value of ${suite.name}.runTestCases() should be true even if a test case fails.`);
        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.`);
    }

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

    let sequentialExecutionPhase = 0;
    let sequentialExecutionSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SequentialExecution");
    sequentialExecutionSuite.addTestCase({
        name: "1 (Pass)",
        test() {
            ProtocolTest.assert(sequentialExecutionPhase === 0);
            sequentialExecutionPhase = 1;
            return true;
        },
    });
    sequentialExecutionSuite.addTestCase({
        name: "2 (Pass)",
        test() {
            ProtocolTest.assert(sequentialExecutionPhase === 1);
            sequentialExecutionPhase = 2;
            return true;
        },
    });
    sequentialExecutionSuite.addTestCase({
        name: "3 (Pass)",
        test() {
            ProtocolTest.assert(sequentialExecutionPhase === 2);
            sequentialExecutionPhase = 3;
            return true;
        },
    });
    sequentialExecutionSuite.addTestCase({
        name: "4 (Pass)",
        test() {
            ProtocolTest.assert(sequentialExecutionPhase === 3);
            sequentialExecutionPhase = 4;
            return true;
        },
    });
    checkResult(sequentialExecutionSuite, {
        runCount: 4,
        passCount: 4,
        failCount: 0,
        skipCount: 0,
    });

    let continueOnFailureSuite = ProtocolTest.createSyncSuite("SyncTestSuite.ContinueOnFailure");
    continueOnFailureSuite.addTestCase({
        name: "1 (Pass)",
        test() {
            return true;
        },
    });
    continueOnFailureSuite.addTestCase({
        name: "2 (Fail)",
        test() {
            ProtocolTest.log("Throwing...");
            throw {x: "ContinueOnFailure throw"};
        },
    });
    continueOnFailureSuite.addTestCase({
        name: "3 (Pass)",
        test() {
            return true;
        },
    });
    continueOnFailureSuite.addTestCase({
        name: "4 (Fail)",
        test() {
            ProtocolTest.log("Failing...");
            return false;
        },
    });
    checkResult(continueOnFailureSuite, {
        runCount: 4,
        passCount: 2,
        failCount: 2,
        skipCount: 0,
    });

    let setupAndTeardownPhase = 0;
    let setupAndTeardownSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupAndTeardown");
    setupAndTeardownSuite.addTestCase({
        name: "TestWithSetupAndTeardown",
        setup() {
            ProtocolTest.assert(setupAndTeardownPhase === 0);
            setupAndTeardownPhase = 1;
            return true;
        },
        test() {
            ProtocolTest.assert(setupAndTeardownPhase === 1);
            setupAndTeardownPhase = 2;
            return true;
        },
        teardown() {
            ProtocolTest.assert(setupAndTeardownPhase === 2);
            setupAndTeardownPhase = 3;
            return true;
        },
    });
    setupAndTeardownSuite.addTestCase({
        name: "TestRunningAfterTeardown",
        test() {
            ProtocolTest.assert(setupAndTeardownPhase === 3);
            return true;
        },
    });
    checkResult(setupAndTeardownSuite, {
        runCount: 2,
        passCount: 2,
        failCount: 0,
        skipCount: 0,
    });

    
    let setupExceptionSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupException");
    setupExceptionSuite.addTestCase({
        name: "TestWithExceptionDuringSetup",
        setup() {
            ProtocolTest.log("Throwing...");
            throw "SetupException throw";
        },
        test() {
            ProtocolTest.fail("Test should not execute if its setup action threw an exception.");
            return false;
        },
        teardown() {
            ProtocolTest.fail("Teardown action should not execute if its setup action threw an exception.");
            return false;
        },
    });
    setupExceptionSuite.addTestCase({
        name: "TestAfterSetupException",
        setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action threw an exception.");
            return true;
        },
        test() {
            ProtocolTest.pass("Test should still execute if previous test's setup action threw an exception.");
            return true;
        },
        teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's setup action threw an exception.");
            return true;
        },
    });
    checkResult(setupExceptionSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let setupFailureSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupFailure");
    setupFailureSuite.addTestCase({
        name: "TestWithFailureDuringSetup",
        setup() {
            ProtocolTest.log("Failing...");
            return false;
        },
        test() {
            ProtocolTest.fail("Test should not execute if its setup action failed.");
            return false;
        },
        teardown() {
            ProtocolTest.fail("Teardown action should not execute if its setup action failed.");
            return false;
        },
    });
    setupFailureSuite.addTestCase({
        name: "TestAfterSetupException",
        setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's setup action failed.");
            return true;
        },
        test() {
            ProtocolTest.pass("Test should still execute if previous test's setup action failed.");
            return true;
        },
        teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's setup action failed.");
            return true;
        },
    });
    checkResult(setupFailureSuite, {
        runCount: 1,
        passCount: 1,
        failCount: 1,
        skipCount: 1,
    });

    let teardownExceptionSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownException");
    teardownExceptionSuite.addTestCase({
        name: "TestWithExceptionDuringTeardown",
        test() {
            return true;
        },
        teardown() {
            ProtocolTest.log("Throwing...");
            throw "TeardownException throw";
        },
    });
    teardownExceptionSuite.addTestCase({
        name: "TestAfterTeardownException",
        setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action threw an exception.");
            return true;
        },
        test() {
            ProtocolTest.pass("Test should still execute if previous test's teardown action threw an exception.");
            return true;
        },
        teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action threw an exception.");
            return true;
        },
    });
    checkResult(teardownExceptionSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    let teardownFailureSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownFailure");
    teardownFailureSuite.addTestCase({
        name: "TestWithExceptionDuringTeardown",
        test() {
            return true;
        },
        teardown() {
            ProtocolTest.log("Failing...");
            return false;
        },
    });
    teardownFailureSuite.addTestCase({
        name: "TestAfterTeardownException",
        setup() {
            ProtocolTest.pass("Setup action should still execute if previous test's teardown action failed.");
            return true;
        },
        test() {
            ProtocolTest.pass("Test should still execute if previous test's teardown action failed.");
            return true;
        },
        teardown() {
            ProtocolTest.pass("Teardown action should still execute if previous test's teardown action failed.");
            return true;
        },
    });
    checkResult(teardownFailureSuite, {
        runCount: 2,
        passCount: 1,
        failCount: 1,
        skipCount: 0,
    });

    ProtocolTest.completeTest();
}
</script>
</head>
<body onLoad="runTest()">
</body>
</html>