| <!doctype html> |
| <html> |
| <head> |
| <script src="../../http/tests/inspector/resources/inspector-test.js"></script> |
| <script> |
| let resultNumber = 100; |
| function asyncOperation() { |
| return new Promise((resolve, reject) => { |
| setTimeout(() => { |
| resolve(resultNumber++); |
| }, 50); |
| }); |
| } |
| |
| function rejectedEventually() { |
| return new Promise((resolve, reject) => { |
| setTimeout(() => { |
| reject("Rejection"); |
| }, 50); |
| }); |
| } |
| |
| function causeExceptionImmediately() { |
| throw "Thrown exception"; |
| } |
| |
| function test() |
| { |
| let suite = InspectorTest.createAsyncSuite("RuntimeManager"); |
| |
| suite.addTestCase({ |
| name: "RuntimeManager.prototype.evaluateInInspectedWindow.ObjectLiteralConvenience", |
| description: "Test evaluating an object literal string conveniently converts wraps it in parenthesis to avoid misinterpretation as a program with a block and labeled statement.", |
| test(resolve, reject) { |
| function testSource(expression, callback) { |
| WI.runtimeManager.evaluateInInspectedWindow(expression, {objectGroup: "test"}, (result, wasThrown) => { |
| InspectorTest.log("Source: " + expression); |
| callback(result, wasThrown); |
| }); |
| } |
| |
| function expectObject(result, wasThrown) { |
| InspectorTest.expectThat(result.type === "object", "Evaluation should produce an object."); |
| } |
| |
| function expectException(result, wasThrown) { |
| InspectorTest.expectThat(wasThrown, "Evaluation should produce an exception."); |
| } |
| |
| function expectValue(value) { |
| return function(result, wasThrown) { |
| InspectorTest.expectThat(result.value === value, "Evaluation should produce the labeled statement's value."); |
| } |
| } |
| |
| // The convenience will detect these and make them objects. |
| testSource("{a:1}", expectObject); |
| testSource("{a:1, b:2}", expectObject); |
| testSource(" {a:1, b:2} ", expectObject); |
| |
| // The convenience will incorrectly apply to these that would otherwise have been valid programs. |
| testSource("{ let a = 1; a += 1; a }", expectException); |
| |
| // Test we can run non-convenience cases by not starting / ending with characters other than curly braces. |
| testSource(";{a:1}", expectValue(1)); |
| testSource("{a:1};", expectValue(1)); |
| testSource(";{a:1, b:2}", expectException); |
| testSource(";{ let a = 1; a += 1; a }", expectValue(2)); |
| |
| InspectorBackend.runAfterPendingDispatches(resolve); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RuntimeManager.prototype.evaluateInInspectedWindow.AwaitConvenience", |
| description: "Test evaluating a simple await expression wraps it into an async function and eventually resolves the value.", |
| test(resolve, reject) { |
| function testSource(expression, callback) { |
| WI.runtimeManager.evaluateInInspectedWindow(expression, {objectGroup: "test"}, (result, wasThrown) => { |
| InspectorTest.log("Source: " + expression); |
| callback(result, wasThrown); |
| }); |
| } |
| |
| function expectUndefined(result, wasThrown) { |
| InspectorTest.expectThat(result.isUndefined(), "Transformed. Should log the value or an exception."); |
| } |
| |
| function expectException(result, wasThrown) { |
| InspectorTest.expectThat(wasThrown, "Exception. Should not get transformed and produce a SyntaxError."); |
| } |
| |
| // The convenience will detect these and make an async task. |
| const expected = 6; |
| testSource("await 1", expectUndefined); |
| testSource(" await 2 ", expectUndefined); |
| testSource("var x = await 3", expectUndefined); |
| testSource("await causeExceptionImmediately()", expectUndefined); |
| testSource("await Promise.resolve(4)", expectUndefined); |
| testSource("await Promise.reject('Promise.reject')", expectUndefined); |
| testSource("await rejectedEventually()", expectUndefined); |
| testSource("await asyncOperation()", expectUndefined); |
| testSource("x = await asyncOperation()", expectUndefined); |
| |
| InspectorTest.log(""); |
| |
| // The convenience will not apply to these expressions. |
| testSource("return 10", expectException); |
| testSource("await 10; 1", expectException); |
| testSource("1; await 10;", expectException); |
| testSource("x = y = await 10", expectException); |
| |
| // We can resolve after receiving the expected number of console.info messages. |
| let seen = 0; |
| let listener = WI.consoleManager.addEventListener(WI.ConsoleManager.Event.MessageAdded, (event) => { |
| let consoleMessage = event.data.message; |
| if (consoleMessage.level !== WI.ConsoleMessage.MessageLevel.Info) |
| return; |
| if (++seen !== expected) |
| return; |
| WI.consoleManager.removeEventListener(WI.ConsoleManager.Event.MessageAdded, listener); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.runTestCasesAndFinish(); |
| } |
| </script> |
| </head> |
| <body onload="runTest()"> |
| <p>Tests for RuntimeManager operations.</p> |
| </body> |
| </html> |
