875 lines
29 KiB
HTML
875 lines
29 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 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>
|