| <!doctype html> |
| <html> |
| <head> |
| <script src="../../http/tests/inspector/resources/protocol-test.js"></script> |
| <script> |
| function test() |
| { |
| ProtocolTest.suppressStackTraces = true; |
| |
| try { |
| let result = new SyncTestSuite(this); |
| ProtocolTest.log("FAIL: instantiating SyncTestSuite requires name argument."); |
| } catch (e) { |
| ProtocolTest.log("PASS: instantiating SyncTestSuite requires name argument."); |
| } |
| |
| try { |
| let result = new SyncTestSuite(this, {}); |
| ProtocolTest.log("FAIL: instantiating SyncTestSuite requires string name argument."); |
| } catch (e) { |
| ProtocolTest.log("PASS: instantiating SyncTestSuite requires string name argument."); |
| } |
| |
| try { |
| let result = new SyncTestSuite(this, " "); |
| ProtocolTest.log("FAIL: instantiating SyncTestSuite requires non-whitespace name argument."); |
| } catch (e) { |
| ProtocolTest.log("PASS: instantiating SyncTestSuite requires non-whitespace name argument."); |
| } |
| |
| try { |
| let result = new SyncTestSuite("something", {}); |
| ProtocolTest.log("FAIL: instantiating SyncTestSuite requires test harness argument."); |
| } catch (e) { |
| ProtocolTest.log("PASS: instantiating SyncTestSuite requires test harness argument."); |
| } |
| |
| let badArgsSuite = ProtocolTest.createSyncSuite("dummy"); |
| try { |
| badArgsSuite.addTestCase(); |
| ProtocolTest.log("FAIL: should not be able to add empty test case."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to add empty test case."); |
| } |
| try { |
| badArgsSuite.addTestCase("string"); |
| ProtocolTest.log("FAIL: should not be able to add non-object test case."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to add non-object test case."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: {}, |
| test: () => true, |
| }); |
| ProtocolTest.log("FAIL: test case should require string name."); |
| } catch (e) { |
| ProtocolTest.log("PASS: test case should require string name."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: " ", |
| test() {}, |
| }); |
| ProtocolTest.log("FAIL: test case should require non-whitespace name."); |
| } catch (e) { |
| ProtocolTest.log("PASS: test case should require non-whitespace name."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test: null, |
| }); |
| ProtocolTest.log("FAIL: test case should require test function."); |
| } catch (e) { |
| ProtocolTest.log("PASS: test case should require test function."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| setup: "astd" |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| setup: 123 |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| setup: Promise.resolve() |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| teardown: "astd" |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| teardown: 123 |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| teardown: Promise.resolve() |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| async test() {}, |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify async `test` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify async `test` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| async setup() {}, |
| test() {}, |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify async `setup` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify async `setup` parameter."); |
| } |
| try { |
| badArgsSuite.addTestCase({ |
| name: "foo", |
| test() {}, |
| async teardown() {}, |
| }); |
| ProtocolTest.log("FAIL: should not be able to specify async `teardown` parameter."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to specify async `teardown` parameter."); |
| } |
| |
| let runEmptySuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunEmptySuite"); |
| try { |
| runEmptySuite.runTestCases(); |
| ProtocolTest.log("FAIL: should not be able to run empty test suite."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to run empty test suite."); |
| } |
| |
| let runTwiceSuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunTwiceSuite"); |
| runTwiceSuite.addTestCase({ |
| name: "DummyTest0", |
| description: "Check that a suite can't run more than once.", |
| test: () => true, |
| }); |
| |
| try { |
| let result = runTwiceSuite.runTestCases(); |
| ProtocolTest.expectThat(result === true, "Return value of runTwiceSuite.runTestCases() should be true when all tests pass."); |
| |
| runTwiceSuite.runTestCases(); // Try to trigger an error. |
| ProtocolTest.log("FAIL: should not be able to run a test suite twice."); |
| } catch (e) { |
| ProtocolTest.log("PASS: should not be able to run a test suite twice."); |
| } |
| |
| let thrownError = new Error({"token": 666}); |
| |
| let sequentialExecutionSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SequentialExecution"); |
| sequentialExecutionSuite.addTestCase({ |
| name: "DummyTest1", |
| description: "Check test case execution order.", |
| test: () => true |
| }); |
| sequentialExecutionSuite.addTestCase({ |
| name: "DummyTest2", |
| description: "Check test case execution order.", |
| test: () => true |
| }); |
| sequentialExecutionSuite.addTestCase({ |
| name: "DummyTest3", |
| description: "Check test case execution order.", |
| test: () => true |
| }); |
| sequentialExecutionSuite.addTestCase({ |
| name: "FailingTest4", |
| description: "Check that test fails by throwing an Error instance.", |
| test() { throw thrownError; } |
| }); |
| |
| let result = sequentialExecutionSuite.runTestCases(); |
| ProtocolTest.expectThat(result === false, "Return value of sequentialExecutionSuite.runTestCases() should be false when a test case fails."); |
| 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."); |
| |
| let abortOnFailureSuite = ProtocolTest.createSyncSuite("SyncTestSuite.AbortOnFailure"); |
| abortOnFailureSuite.addTestCase({ |
| name: "PassingTest5", |
| description: "This test is a dummy.", |
| test: () => true |
| }); |
| abortOnFailureSuite.addTestCase({ |
| name: "FailingTest6", |
| description: "This test should fail by explicitly returning `false`.", |
| test: () => false |
| }); |
| abortOnFailureSuite.addTestCase({ |
| name: "PassingTest7", |
| description: "This test should not executed when the preceding test fails.", |
| test: () => true |
| }); |
| |
| abortOnFailureSuite.runTestCases(); |
| ProtocolTest.expectThat(result === false, "Return value of abortOnFailureSuite.runTestCases() should be false when a test case fails."); |
| 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."); |
| |
| let setupAndTeardownSymbol = Symbol("sync-suite-setup-and-teardown-token"); |
| window[setupAndTeardownSymbol] = 0; |
| |
| let setupAndTeardownTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupAndTeardown"); |
| setupAndTeardownTestSuite.addTestCase({ |
| name: "TestWithSetupAndTeardown", |
| description: "Check execution order for setup and teardown actions.", |
| setup: () => { |
| window[setupAndTeardownSymbol] = 1; |
| return true; |
| }, |
| test() { |
| ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 1, "Test should see side effects of running setup() action."); |
| window[setupAndTeardownSymbol] = 2; |
| return true; |
| }, |
| teardown: () => { |
| ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 2, "Teardown should see side effects of running setup() action."); |
| window[setupAndTeardownSymbol] = 3; |
| return true; |
| } |
| }); |
| setupAndTeardownTestSuite.addTestCase({ |
| name: "TestRunningAfterTeardown", |
| description: "Check execution order for test after a teardown action.", |
| test() { |
| ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 3, "Test should see side effects of previous test's teardown() action."); |
| return true; |
| }, |
| }); |
| |
| setupAndTeardownTestSuite.runTestCases(); |
| |
| let setupExceptionTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupException"); |
| setupExceptionTestSuite.addTestCase({ |
| name: "TestWithExceptionDuringSetup", |
| description: "Check execution order for setup action that throws an exception.", |
| setup: () => { throw new Error() }, |
| test() { |
| ProtocolTest.assert(false, "Test should not execute if its setup action threw an exception."); |
| return false; |
| }, |
| teardown: () => { |
| ProtocolTest.assert(false, "Teardown action should not execute if its setup action threw an exception."); |
| return false; |
| } |
| }); |
| setupExceptionTestSuite.runTestCases(); |
| |
| let setupFailureTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupFailure"); |
| setupFailureTestSuite.addTestCase({ |
| name: "TestWithFailureDuringSetup", |
| description: "Check execution order for setup action that has failed.", |
| setup: () => false, |
| test() { |
| ProtocolTest.assert(false, "Test should not execute if its setup action returned false.") |
| return false; |
| }, |
| teardown: () => { |
| ProtocolTest.assert(false, "Teardown action should not execute if its setup action returned false.") |
| return false; |
| } |
| }); |
| setupFailureTestSuite.runTestCases(); |
| |
| let teardownExceptionTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownException"); |
| teardownExceptionTestSuite.addTestCase({ |
| name: "TestWithExceptionDuringTeardown", |
| description: "Check execution order for teardown action that throws an exception.", |
| test: () => true, |
| teardown: () => { throw new Error() } |
| }); |
| teardownExceptionTestSuite.addTestCase({ |
| name: "TestAfterTeardownException", |
| descrption: "Check execution order for test after previous test's teardown throws an exception", |
| setup: () => { |
| ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action threw an exception."); |
| return false; |
| }, |
| test() { |
| ProtocolTest.assert(false, "Test should not execute if previous test's teardown action threw an exception."); |
| return false; |
| } |
| }); |
| teardownExceptionTestSuite.runTestCases(); |
| |
| let teardownFailureTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownFailure"); |
| teardownFailureTestSuite.addTestCase({ |
| name: "TestWithExceptionDuringTeardown", |
| description: "Check execution order for teardown action that has failed.", |
| test: () => true, |
| teardown: () => false, |
| }); |
| teardownFailureTestSuite.addTestCase({ |
| name: "TestAfterTeardownException", |
| descrption: "Check execution order for test after previous test's teardown throws an exception", |
| setup: () => { |
| ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action failed."); |
| return false; |
| }, |
| test() { |
| ProtocolTest.assert(false, "Test should not execute if previous test's teardown action failed."); |
| return false; |
| } |
| }); |
| teardownFailureTestSuite.runTestCases(); |
| |
| ProtocolTest.completeTest(); |
| } |
| </script> |
| </head> |
| <body onLoad="runTest()"> |
| </body> |
| </html> |
