| <!DOCTYPE html> |
| <html> |
| <head> |
| <script src="../../../http/tests/inspector/resources/inspector-test.js"></script> |
| <script src="../resources/log-pause-location.js"></script> |
| <script> |
| function add(a, b) { |
| return a + b; |
| } |
| |
| function a() { |
| return 1; |
| } |
| |
| function b() { |
| return 2; |
| } |
| |
| function entryMultipleStatementsOnOneLine() { |
| debugger; |
| a(); b(); |
| } |
| |
| function entryMultipleCallsInOneStatement() { |
| debugger; |
| add(a(), b()); |
| } |
| |
| function entryMultilineStatement() { |
| debugger; |
| add( |
| a() |
| , |
| b() |
| ); |
| } |
| |
| function entryComplexLine() { |
| var x; |
| debugger; |
| a(); x = 1; b(); |
| } |
| |
| function entryComplexStatement() { |
| var x; |
| debugger; |
| add(a(), x = 1, b()); |
| } |
| |
| function entryCommaExpression() { |
| debugger; |
| a(), b(), a(); |
| } |
| |
| function entryDotPropertyAccessCall() { |
| var o = {x:{x:{a}}}; |
| debugger; |
| o.x.x.a(); |
| } |
| |
| function entryBracketPropertyAccessCall() { |
| var o = {x:{x:{a}}}; |
| debugger; |
| o['x']['x']['a'](); |
| } |
| |
| function entryUseCall() { |
| debugger; |
| add.call(null, 1, 2); |
| } |
| |
| function entryUseApply() { |
| debugger; |
| a.apply(null, [1, 2]); |
| } |
| |
| function entryAnonymousFunctionInvocation() { |
| debugger; |
| (function() { |
| a(); |
| })(); |
| } |
| |
| function entryFunctionWithConditionalReturn() { |
| function testCondition(condition) { |
| if (condition) |
| return true; |
| return false; |
| } |
| debugger; |
| testCondition(true); |
| testCondition(false); |
| } |
| |
| function entryEmptyFunction() { |
| function emptyFunction() { } |
| debugger; |
| emptyFunction(); |
| } |
| |
| // --------- |
| |
| function test() |
| { |
| let suite = InspectorTest.createAsyncSuite("Debugger.stepping.functionCalls"); |
| |
| window.initializeSteppingTestSuite(suite); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleStatementsOnOneLine1", |
| description: "Should be able to step in and out through each statement.", |
| expression: "setTimeout(entryMultipleStatementsOnOneLine)", |
| // a(); b(); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "in", // into b |
| "out", // out of b |
| "resume", |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleStatementsOnOneLine2", |
| description: "Should be able to step over through each statement.", |
| expression: "setTimeout(entryMultipleStatementsOnOneLine)", |
| // a(); b(); |
| steps: [ |
| "over", |
| "over", // a(); |
| "over", // b(); |
| "resume", |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleCallsInOneStatement1", |
| description: "Should be able to step in and out of each function call in the single statement.", |
| expression: "setTimeout(entryMultipleCallsInOneStatement)", |
| // add(a(), b()) |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "in", // into b |
| "out", // out of b |
| "in", // into add |
| "out", // out of add |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleCallsInOneStatement2", |
| description: "When stepping over in the middle of a statement complete the statement.", |
| expression: "setTimeout(entryMultipleCallsInOneStatement)", |
| // add(a(), b()) |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "over", // complete: add(a(), b()) |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleCallsInOneStatement3", |
| description: "Should be able to step through each function call in a single statement with stepInto.", |
| expression: "setTimeout(entryMultipleCallsInOneStatement)", |
| // add(a(), b()) |
| steps: [ |
| "over", |
| "in", // into a - before return statement |
| "in", // leaving a |
| "in", // before b() |
| "in", // into b - before return statement |
| "in", // leaving b |
| "in", // before add() |
| "in", // into add - before return statement |
| "in", // leaving add |
| "in", // back at entryMultipleCallsInOneStatement |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleCallsInOneStatement4", |
| description: "Step out of .", |
| expression: "setTimeout(entryMultipleCallsInOneStatement)", |
| // add(a(), b()) |
| steps: [ |
| "over", |
| "in", // into a - before return statement |
| "over", // leaving a |
| "over", // before b() |
| "in", // into b - before return statement |
| "over", // leaving b |
| "over", // before add() |
| "in", // into add - before return statement |
| "over", // leaving add |
| "over", // back at entryMultipleCallsInOneStatement |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleCallsInOneStatement5", |
| description: "Should be able to step over a multi-line statement.", |
| expression: "setTimeout(entryMultilineStatement)", |
| // add( |
| // a() |
| // , |
| // b() |
| // ); |
| steps: [ |
| "over", |
| "over", // complete: add(a(), b()) |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.MultipleCallsInOneStatement6", |
| description: "When stepping over in the middle of a statement complete the statement even if multi-line.", |
| expression: "setTimeout(entryMultilineStatement)", |
| // add( |
| // a() |
| // , |
| // b() |
| // ); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "over", // complete: add(a(), b()) |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.ComplexLine1", |
| description: "Should be able to step in and out through each statement.", |
| expression: "setTimeout(entryComplexLine)", |
| // a(); x = 1; b(); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a - before x = 1 |
| "in", // x = 1 - before b() |
| "in", // into b |
| "out", // out of b |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.ComplexLine2", |
| description: "Should be able to step over through each statement.", |
| expression: "setTimeout(entryComplexLine)", |
| // a(); x = 1; b(); |
| steps: [ |
| "over", |
| "over", // a(); |
| "over", // x = 1 |
| "over", // b(); |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.ComplexStatement1", |
| description: "Should be able to step in and out through each statement.", |
| expression: "setTimeout(entryComplexStatement)", |
| // add(a(), x = 1, b()); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| // FIXME: Opportunity to pause at assignment expressions. |
| "in", // into b |
| "out", // out of b |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.ComplexStatement2", |
| description: "Should be able to step in and out through each statement.", |
| expression: "setTimeout(entryCommaExpression)", |
| // a(), b(), a(); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "in", // into b |
| "out", // out of b |
| "in", // into a |
| "out", // out of a |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.ComplexStatement3", |
| description: "Should be able to step in and out through each statement.", |
| expression: "setTimeout(entryCommaExpression)", |
| // a(), b(), a(); |
| steps: [ |
| "over", |
| "in", // into a - before return |
| "in", // leaving a |
| "in", // before b() |
| "in", // into b - before return |
| "over", // leaving b |
| "over", // before a() |
| "over", // complete: a() |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.ComplexStatement4", |
| description: "Should be able to step over the statement.", |
| expression: "setTimeout(entryCommaExpression)", |
| // a(), b(), a(); |
| steps: [ |
| "over", |
| "over", // a() |
| "over", // b() |
| "over", // a() |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.DotPropertyAccessCallStepIn", |
| description: "Should be able to step into the call.", |
| expression: "setTimeout(entryDotPropertyAccessCall)", |
| // o.x.x.a(); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.DotPropertyAccessCallStepOver", |
| description: "Should be able to step over the call.", |
| expression: "setTimeout(entryDotPropertyAccessCall)", |
| // o.x.x.a(); |
| steps: [ |
| "over", |
| "over", // complete: o.x.x.a() |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.BracketPropertyAccessCallStepIn", |
| description: "Should be able to step into the call.", |
| expression: "setTimeout(entryBracketPropertyAccessCall)", |
| // o['x']['x']['a'](); |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.FunctionPrototypeCallStepIn", |
| description: "Should be able to step into a call using Function.prototype.call.", |
| expression: "setTimeout(entryUseCall)", |
| // add.call(null, 1, 2) |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.FunctionPrototypeApplyStepIn", |
| description: "Should be able to step into a call using Function.prototype.apply.", |
| expression: "setTimeout(entryUseApply)", |
| // add.apply(null, [1, 2]) |
| steps: [ |
| "over", |
| "in", // into a |
| "out", // out of a |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.AnonymousFunctionInvocationStepOver", |
| description: "Should be able to step into a anonymous function invocation.", |
| expression: "setTimeout(entryAnonymousFunctionInvocation)", |
| // (function() { a() })(); |
| steps: [ |
| "over", |
| "over", // complete: (function() { a() })(); - leaving entry |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.AnonymousFunctionInvocationStepOver", |
| description: "Should be able to step into a anonymous function invocation.", |
| expression: "setTimeout(entryAnonymousFunctionInvocation)", |
| // (function() { a() })(); |
| steps: [ |
| "over", |
| "in", // into anonymous |
| "over", // complete: a() - leaving anonymous |
| "in", // leaving entry |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.FunctionWithConditionalReturn", |
| description: "Step through function with return in the middle of the function.", |
| expression: "setTimeout(entryFunctionWithConditionalReturn)", |
| // testCondition(condition) { if (condition) return true; return false; } |
| steps: [ |
| "over", |
| "in", // into testCondition(true) |
| "in", // if (condition) [true] |
| "in", // return true |
| "in", // leaving testCondition |
| "in", // into testCondition(false) |
| "in", // if (condition) [false] |
| "in", // return false |
| "in", // leaving testCondition |
| "resume" |
| ] |
| }); |
| |
| addSteppingTestCase({ |
| name: "Debugger.stepping.EmptyFunction", |
| description: "Step through an empty function should pause at least once.", |
| expression: "setTimeout(entryEmptyFunction)", |
| // emptyFunction() { } |
| steps: [ |
| "over", |
| "in", // into emptyFunction - before leaving emptyFunction |
| "in", // leaving emptyFunction |
| "resume" |
| ] |
| }); |
| |
| loadMainPageContent().then(() => { |
| suite.runTestCasesAndFinish(); |
| }); |
| } |
| </script> |
| </head> |
| <body onload="runTest()"> |
| <p>Checking pause locations when stepping in, out, and over statements with function calls.</p> |
| </body> |
| </html> |
