cbc06bf9d9c5b35fa4c9903216c95267663face1
[WebKit-https.git] / LayoutTests / inspector / unit-tests / sync-test-suite.html
1 <!doctype html>
2 <html>
3 <head>
4 <script src="../../http/tests/inspector/resources/protocol-test.js"></script>
5 <script>
6 function test()
7 {
8     ProtocolTest.suppressStackTraces = true;
9
10     try {
11         let result = new SyncTestSuite(this);
12         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires name argument.");
13     } catch (e) {
14         ProtocolTest.log("PASS: instantiating SyncTestSuite requires name argument.");
15     }
16
17     try {
18         let result = new SyncTestSuite(this, {});
19         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires string name argument.");
20     } catch (e) {
21         ProtocolTest.log("PASS: instantiating SyncTestSuite requires string name argument.");
22     }
23
24     try {
25         let result = new SyncTestSuite(this, "      ");
26         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires non-whitespace name argument.");
27     } catch (e) {
28         ProtocolTest.log("PASS: instantiating SyncTestSuite requires non-whitespace name argument.");
29     }
30
31     try {
32         let result = new SyncTestSuite("something", {});
33         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires test harness argument.");
34     } catch (e) {
35         ProtocolTest.log("PASS: instantiating SyncTestSuite requires test harness argument.");
36     }
37
38     let badArgsSuite = ProtocolTest.createSyncSuite("dummy");
39     try {
40         badArgsSuite.addTestCase();
41         ProtocolTest.log("FAIL: should not be able to add empty test case.");
42     } catch (e) {
43         ProtocolTest.log("PASS: should not be able to add empty test case.");
44     }
45     try {
46         badArgsSuite.addTestCase("string");
47         ProtocolTest.log("FAIL: should not be able to add non-object test case.");
48     } catch (e) {
49         ProtocolTest.log("PASS: should not be able to add non-object test case.");
50     }
51     try {
52         badArgsSuite.addTestCase({
53             name: {},
54             test: () => true,
55         });
56         ProtocolTest.log("FAIL: test case should require string name.");
57     } catch (e) {
58         ProtocolTest.log("PASS: test case should require string name.");
59     }
60     try {
61         badArgsSuite.addTestCase({
62             name: "        ",
63             test() {},
64         });
65         ProtocolTest.log("FAIL: test case should require non-whitespace name.");
66     } catch (e) {
67         ProtocolTest.log("PASS: test case should require non-whitespace name.");
68     }
69     try {
70         badArgsSuite.addTestCase({
71             name: "foo",
72             test: null,
73         });
74         ProtocolTest.log("FAIL: test case should require test function.");
75     } catch (e) {
76         ProtocolTest.log("PASS: test case should require test function.");
77     }
78     try {
79         badArgsSuite.addTestCase({
80             name: "foo",
81             test() {},
82             setup: "astd"
83         });
84         ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter.");
85     } catch (e) {
86         ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter.");
87     }
88     try {
89         badArgsSuite.addTestCase({
90             name: "foo",
91             test() {},
92             setup: 123
93         });
94         ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter.");
95     } catch (e) {
96         ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter.");
97     }
98     try {
99         badArgsSuite.addTestCase({
100             name: "foo",
101             test() {},
102             setup: Promise.resolve()
103         });
104         ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter.");
105     } catch (e) {
106         ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter.");
107     }
108     try {
109         badArgsSuite.addTestCase({
110             name: "foo",
111             test() {},
112             teardown: "astd"
113         });
114         ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter.");
115     } catch (e) {
116         ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter.");
117     }
118     try {
119         badArgsSuite.addTestCase({
120             name: "foo",
121             test() {},
122             teardown: 123
123         });
124         ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter.");
125     } catch (e) {
126         ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter.");
127     }
128     try {
129         badArgsSuite.addTestCase({
130             name: "foo",
131             test() {},
132             teardown: Promise.resolve()
133         });
134         ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter.");
135     } catch (e) {
136         ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter.");
137     }
138     let runEmptySuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunEmptySuite");
139     try {
140         runEmptySuite.runTestCases();
141         ProtocolTest.log("FAIL: should not be able to run empty test suite.");
142     } catch (e) {
143         ProtocolTest.log("PASS: should not be able to run empty test suite.");
144     }
145
146     let runTwiceSuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunTwiceSuite");
147     runTwiceSuite.addTestCase({
148         name: "DummyTest0",
149         description: "Check that a suite can't run more than once.",
150         test: () => true,
151     });
152
153     try {
154         let result = runTwiceSuite.runTestCases();
155         ProtocolTest.expectThat(result === true, "Return value of runTwiceSuite.runTestCases() should be true when all tests pass.");
156
157         runTwiceSuite.runTestCases(); // Try to trigger an error.
158         ProtocolTest.log("FAIL: should not be able to run a test suite twice.");
159     } catch (e) {
160         ProtocolTest.log("PASS: should not be able to run a test suite twice.");
161     }
162
163     let thrownError = new Error({"token": 666});
164
165     let sequentialExecutionSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SequentialExecution");
166     sequentialExecutionSuite.addTestCase({
167         name: "DummyTest1",
168         description: "Check test case execution order.",
169         test: () => true
170     });
171     sequentialExecutionSuite.addTestCase({
172         name: "DummyTest2",
173         description: "Check test case execution order.",
174         test: () => true
175     });
176     sequentialExecutionSuite.addTestCase({
177         name: "DummyTest3",
178         description: "Check test case execution order.",
179         test: () => true
180     });
181     sequentialExecutionSuite.addTestCase({
182         name: "FailingTest4",
183         description: "Check that test fails by throwing an Error instance.",
184         test() { throw thrownError; }
185     });
186
187     let result = sequentialExecutionSuite.runTestCases();
188     ProtocolTest.expectThat(result === false, "Return value of sequentialExecutionSuite.runTestCases() should be false when a test case fails.");
189     ProtocolTest.expectThat(sequentialExecutionSuite.runCount === 4, "sequentialExecutionSuite should have executed four tests.");
190     ProtocolTest.expectThat(sequentialExecutionSuite.passCount === 3, "sequentialExecutionSuite should have passed three tests.");
191     ProtocolTest.expectThat(sequentialExecutionSuite.failCount === 1, "sequentialExecutionSuite should have failed 1 test.");
192     ProtocolTest.expectThat(sequentialExecutionSuite.skipCount === 0, "sequentialExecutionSuite should have skipped zero tests.");
193
194     let abortOnFailureSuite = ProtocolTest.createSyncSuite("SyncTestSuite.AbortOnFailure");
195     abortOnFailureSuite.addTestCase({
196         name: "PassingTest5",
197         description: "This test is a dummy.",
198         test: () => true
199     });
200     abortOnFailureSuite.addTestCase({
201         name: "FailingTest6",
202         description: "This test should fail by explicitly returning `false`.",
203         test: () => false
204     });
205     abortOnFailureSuite.addTestCase({
206         name: "PassingTest7",
207         description: "This test should not executed when the preceding test fails.",
208         test: () => true
209     });
210
211     abortOnFailureSuite.runTestCases();
212     ProtocolTest.expectThat(result === false, "Return value of abortOnFailureSuite.runTestCases() should be false when a test case fails.");
213     ProtocolTest.expectThat(abortOnFailureSuite.runCount === 2, "abortOnFailureSuite should have executed two tests.");
214     ProtocolTest.expectThat(abortOnFailureSuite.passCount === 1, "abortOnFailureSuite should have passed one test.");
215     ProtocolTest.expectThat(abortOnFailureSuite.failCount === 1, "abortOnFailureSuite should have failed one test.");
216     ProtocolTest.expectThat(abortOnFailureSuite.skipCount === 1, "abortOnFailureSuite should have skipped one test.");
217
218     let setupAndTeardownSymbol = Symbol("sync-suite-setup-and-teardown-token");
219     window[setupAndTeardownSymbol] = 0;
220
221     let setupAndTeardownTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupAndTeardown");
222     setupAndTeardownTestSuite.addTestCase({
223         name: "TestWithSetupAndTeardown",
224         description: "Check execution order for setup and teardown actions.",
225         setup: () => {
226             window[setupAndTeardownSymbol] = 1;
227             return true;
228         },
229         test() {
230             ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 1, "Test should see side effects of running setup() action.");
231             window[setupAndTeardownSymbol] = 2;
232             return true;
233         },
234         teardown: () => {
235             ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 2, "Teardown should see side effects of running setup() action.");
236             window[setupAndTeardownSymbol] = 3;
237             return true;
238         }
239     });
240     setupAndTeardownTestSuite.addTestCase({
241         name: "TestRunningAfterTeardown",
242         description: "Check execution order for test after a teardown action.",
243         test() {
244             ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 3, "Test should see side effects of previous test's teardown() action.");
245             return true;
246         },
247     });
248
249     setupAndTeardownTestSuite.runTestCases();
250
251     let setupExceptionTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupException");
252     setupExceptionTestSuite.addTestCase({
253         name: "TestWithExceptionDuringSetup",
254         description: "Check execution order for setup action that throws an exception.",
255         setup: () => { throw new Error() },
256         test() {
257             ProtocolTest.assert(false, "Test should not execute if its setup action threw an exception.");
258             return false;
259         },
260         teardown: () => {
261             ProtocolTest.assert(false, "Teardown action should not execute if its setup action threw an exception.");
262             return false;           
263         }
264     });
265     setupExceptionTestSuite.runTestCases();
266
267     let setupFailureTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupFailure");
268     setupFailureTestSuite.addTestCase({
269         name: "TestWithFailureDuringSetup",
270         description: "Check execution order for setup action that has failed.",
271         setup: () => false,
272         test() {
273             ProtocolTest.assert(false, "Test should not execute if its setup action returned false.")
274             return false;
275         },
276         teardown: () => {
277             ProtocolTest.assert(false, "Teardown action should not execute if its setup action returned false.")
278             return false;           
279         }
280     });
281     setupFailureTestSuite.runTestCases();
282
283     let teardownExceptionTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownException");
284     teardownExceptionTestSuite.addTestCase({
285         name: "TestWithExceptionDuringTeardown",
286         description: "Check execution order for teardown action that throws an exception.",
287         test: () => true,
288         teardown: () => { throw new Error() }
289     });
290     teardownExceptionTestSuite.addTestCase({
291         name: "TestAfterTeardownException",
292         descrption: "Check execution order for test after previous test's teardown throws an exception",
293         setup: () => {
294             ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action threw an exception.");
295             return false;
296         },
297         test() {
298             ProtocolTest.assert(false, "Test should not execute if previous test's teardown action threw an exception.");
299             return false;
300         }
301     });
302     teardownExceptionTestSuite.runTestCases();
303
304     let teardownFailureTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownFailure");
305     teardownFailureTestSuite.addTestCase({
306         name: "TestWithExceptionDuringTeardown",
307         description: "Check execution order for teardown action that has failed.",
308         test: () => true,
309         teardown: () => false,
310     });
311     teardownFailureTestSuite.addTestCase({
312         name: "TestAfterTeardownException",
313         descrption: "Check execution order for test after previous test's teardown throws an exception",
314         setup: () => {
315             ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action failed.");
316             return false;
317         },
318         test() {
319             ProtocolTest.assert(false, "Test should not execute if previous test's teardown action failed.");
320             return false;
321         }
322     });
323     teardownFailureTestSuite.runTestCases();
324
325     ProtocolTest.completeTest();
326 }
327 </script>
328 </head>
329 <body onLoad="runTest()">
330 </body>
331 </html>