test_nesting-04.js

Enable keyboard shortcuts

/* Any copyright is dedicated to the Public Domain.

   http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

/**

 * Verify that we never pause while being already paused.

 * i.e. we don't support more than one nested event loops.

*/

add_task(

  threadFrontTest(async ({ commands, threadFront, debuggee }) => {

    await threadFront.setBreakpoint({ sourceUrl: "nesting-04.js", line: 2 });

    const packet = await executeOnNextTickAndWaitForPause(

      () => evalCode(debuggee),

      threadFront

);

    Assert.equal(packet.frame.where.line, 5);

    Assert.equal(packet.why.type, "debuggerStatement");

    info("Test calling interrupt");

    const onPaused = waitForPause(threadFront);

    await threadFront.interrupt();

    // interrupt() doesn't return anything, but bailout while emitting a paused packet

    // But we don't pause again, the reason prove it so

    const paused = await onPaused;

    equal(paused.why.type, "alreadyPaused");

    info("Test by evaluating code via the console");

    const { result } = await commands.scriptCommand.execute(

      "debugger; functionWithDebuggerStatement()",

        frameActor: packet.frame.actorID,

);

    // The fact that it returned immediately means that we did not pause

    equal(result, 42);

    info("Test by calling code from chrome context");

    // This should be equivalent to any actor somehow triggering some page's JS

    const rv = debuggee.functionWithDebuggerStatement();

    // The fact that it returned immediately means that we did not pause

    equal(rv, 42);

    info("Test by stepping over a function that breaks");

    // This will only step over the debugger; statement we just break on

    const step1 = await stepOver(threadFront);

    equal(step1.why.type, "resumeLimit");

    equal(step1.frame.where.line, 6);

    // stepOver will actually resume and re-pause on the breakpoint

    const step2 = await stepOver(threadFront);

    equal(step2.why.type, "breakpoint");

    equal(step2.frame.where.line, 2);

    // Sanity check to ensure that the functionWithDebuggerStatement really pauses

    info("Resume and pause on the breakpoint");

    const pausedPacket = await resumeAndWaitForPause(threadFront);

    Assert.equal(pausedPacket.frame.where.line, 2);

    // The breakpoint takes over the debugger statement

    Assert.equal(pausedPacket.why.type, "breakpoint");

    await threadFront.resume();

})

);

function evalCode(debuggee) {

  /* eslint-disable */

  Cu.evalInSandbox(

    `function functionWithDebuggerStatement() {

      debugger;

      return 42;

    debugger;

    functionWithDebuggerStatement();

    var a = 1;

    functionWithDebuggerStatement();`,

    debuggee,

    "1.8",

    "nesting-04.js",

);

  /* eslint-enable */