416 lines
12 KiB
HTML
416 lines
12 KiB
HTML
<!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>
|