v8/test/inspector/debugger/get-possible-breakpoints-master-expected.txt

Checks Debugger.getPossibleBreakpoints
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

function testEval() {
  #eval('// comment only');
  #eval('// comment only\n');
#}

// function without return
function procedure() {
  var a = #1;
  var b = #2;
#}

function testProcedure() {
  #procedure();
#}

function returnTrue() {
  #return true;
#}

function testIf() {
  var a;
  #if (true) #a = true;
  #if (!a) {
    #a = true;
  } else {
    #a = false;
  }
  #if (#returnTrue()) {
    #a = false;
  } else {
    #a = true;
  }
#}

function emptyFunction() {#}

function testEmptyFunction() {
  #emptyFunction();
#}

function twoArguments(a1, a2) {
#}

function testCallArguments() {
  #twoArguments(#emptyFunction(), #emptyFunction());
#}

function testNested() {
  function nested1() {
    function nested2() {
      function nested3() {
      #}
      #nested3();
      #return;
    #}
    #return #nested2();
  #}
  #nested1();
#}

function return42() {
  #return 42;
#}

function returnCall() {
  #return #return42();
#}

function testCallAtReturn() {
  #return #returnCall();
#}

function returnObject() {
  #return ({ foo: () => #42# });
#}

function testWith() {
  #with (#returnObject()) {
    #foo();
  }
  #with({}) {
    #return;
  }
#}

function testForLoop() {
  for (var i = #0; i #< 1; ++#i) {}
  for (var i = #0; i #< 1; ++#i) #i;
  for (var i = #0; i #< 0; ++#i) {}
#}

function testForOfLoop() {
  for (var k #of []) {}
  for (var k #of #[1]) #k;
  var a = #[];
  for (var k #of #a) {}
#}

function testForInLoop() {
  var o = #{};
  for (var #k in #o) {}
  for (var #k in #o) #k;
  for (var #k in #{ a:1 }) {}
  for (var #k in #{ a:1 }) #k;
#}

function testSimpleExpressions() {
  #1 + 2 + 3;
  var a = #1;
  #++a;
  #a--;
#}

Object.defineProperty(this, 'getterFoo', {
  get: () => #return42#
});

function testGetter() {
  #getterFoo();
#}

var obj = {
  foo: () => (#{
    boo: () => #return42#
  })#
};

function testChainedCalls() {
  #obj.#foo().#boo()#();
#}

function testChainedWithNative() {
  #Array.#from([1]).#concat([2]).#map(v => v #* 2#);
#}

function testPromiseThen() {
  #return Promise.#resolve().#then(v => v #* 2#).#then(v => v #* 2#);
#}

function testSwitch() {
  for (var i = #0; i #< 3; ++#i) {
    #switch(i) {
      case 0: #continue;
      case 1: #return42(); #break;
      default: #return;
    }
  }
#}

function* idMaker() {
  #yield 1;
  #yield 2;
  #yield 3;
#}

function testGenerator() {
  var gen = #idMaker();
  #return42();
  #gen.#next().value;
  #debugger;
  #gen.#next().value;
  #return42();
  #gen.#next().value;
  #return42();
  #gen.#next().value;
#}

function throwException() {
  #throw #new Error();
#}

function testCaughtException() {
  try {
    #throwException()
  } catch (e) {
    #return;
  }
#}

function testClasses() {
  #class Cat {
    constructor(name) {
      #this.name = name;
    #}

    speak() {
    #}
  }
  #class Lion extends Cat {
    constructor(name) {
      #super(name);
    #}

    speak() {
      #super.#speak();
    #}
  }
  #new Lion().#speak();
#}

async function asyncFoo() {
  #await Promise.resolve().then(v => v #* 2#);
  #return42();
  #await #asyncBoo();
#}

async function asyncBoo() {
  #await Promise.resolve();
#}

async function testAsyncAwait() {
  #await asyncFoo();
  #await #awaitBoo();
#}

// TODO(kozyatinskiy): fix this.
async function testPromiseAsyncWithCode() {
  var nextTest;
  var testPromise = #new Promise(resolve => nextTest #= resolve#);
  async function main() {
    async function foo() {
      var resolveNested;
      var p = #new Promise(resolve => resolveNested #= resolve#);
      #setTimeout(resolveNested, 0);
      #await #p;
    #}
    #setTimeout(returnCall, 0);
    #await #foo();
    #await #foo();
    #nextTest();
  #}
  #main();
  #return testPromise;
#}

function returnFunction() {
  #return returnObject;
#}

async function testPromiseComplex() {
  var nextTest;
  var testPromise = #new Promise(resolve => nextTest #= resolve#);
  async function main() {
    async function foo() {
      #await Promise.resolve();
      #return 42;
    #}
    var x = #1;
    var y = #2;
    #returnFunction(#emptyFunction(), x++, --y, x => 2 #* x#, #returnCall())#().a = #await #foo((a => 2 #*a#)#(5));
    #nextTest();
  #}
  #main();
  #return testPromise;
#}

function twiceDefined() {
  return a + b;
}

function twiceDefined() {
  #return a + b;
#}