Checks possible break locations.

Running test: testEval
break at:
function testEval() {
  #eval('// comment only');
  eval('// comment only\n');

break at:
// comment onl#y

break at:
  eval('// comment only');
  #eval('// comment only\n');
}

break at:
// comment only#


break at:
  eval('// comment only\n');
#}


Running test: testProcedure
break at:
function testProcedure() {
  #procedure();
}

break at:
function procedure() {
  var a = #1;
  var b = 2;

break at:
  var a = 1;
  var b = #2;
}

break at:
  var b = 2;
#}


break at:
  procedure();
#}


Running test: testIf
break at:
  var a;
  if (true) #a = true;
  if (!a) {

break at:
  if (true) a = true;
  #if (!a) {
    a = true;

break at:
  } else {
    #a = false;
  }

break at:
  }
  #if (returnTrue()) {
    a = false;

break at:
function returnTrue() {
  #return true;
}

break at:
function returnTrue() {
  return true;#
}

break at:
  if (returnTrue()) {
    #a = false;
  } else {

break at:
  }
#}


Running test: testEmptyFunction
break at:
function testEmptyFunction() {
  #emptyFunction();
}

break at:

function emptyFunction() {#}


break at:
  emptyFunction();
#}


Running test: testCallArguments
break at:
function testCallArguments() {
  #twoArguments(emptyFunction(), emptyFunction());
}

break at:

function emptyFunction() {#}


break at:
function testCallArguments() {
  twoArguments(emptyFunction(), #emptyFunction());
}

break at:

function emptyFunction() {#}


break at:
function testCallArguments() {
  #twoArguments(emptyFunction(), emptyFunction());
}

break at:
function twoArguments(a1, a2) {
#}


break at:
  twoArguments(emptyFunction(), emptyFunction());
#}


Running test: testNested
break at:
  }
  #nested1();
}

break at:
    }
    return #nested2();
  }

break at:
      }
      #nested3();
      return;

break at:
      function nested3() {
      #}
      nested3();

break at:
      nested3();
      #return;
    }

break at:
      nested3();
      return;#
    }

break at:
    }
    return nested2();#
  }

break at:
  nested1();
#}


Running test: testCallAtReturn
break at:
function testCallAtReturn() {
  #return returnCall();
}

break at:
function returnCall() {
  #return return42();
}

break at:
function return42() {
  #return 42;
}

break at:
function return42() {
  return 42;#
}

break at:
function returnCall() {
  return return42();#
}

break at:
function testCallAtReturn() {
  return returnCall();#
}


Running test: testWith
break at:
function testWith() {
  #with (returnObject()) {
    foo();

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

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

break at:
  with (returnObject()) {
    #foo();
  }

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

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

break at:
  }
  #with({}) {
    return;

break at:
  with({}) {
    #return;
  }

break at:
  with({}) {
    return;#
  }


Running test: testForLoop
break at:
function testForLoop() {
  for (var i = #0; i < 1; ++i) {}
  for (var i = 0; i < 1; ++i) i;

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

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

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

break at:
  for (var i = 0; i < 1; ++i) {}
  for (var i = #0; i < 1; ++i) i;
  for (var i = 0; i < 0; ++i) {}

break at:
  for (var i = 0; i < 1; ++i) {}
  for (var i = 0; i #< 1; ++i) i;
  for (var i = 0; i < 0; ++i) {}

break at:
  for (var i = 0; i < 1; ++i) {}
  for (var i = 0; i < 1; ++#i) i;
  for (var i = 0; i < 0; ++i) {}

break at:
  for (var i = 0; i < 1; ++i) {}
  for (var i = 0; i #< 1; ++i) i;
  for (var i = 0; i < 0; ++i) {}

break at:
  for (var i = 0; i < 1; ++i) i;
  for (var i = #0; i < 0; ++i) {}
}

break at:
  for (var i = 0; i < 1; ++i) i;
  for (var i = 0; i #< 0; ++i) {}
}

break at:
  for (var i = 0; i < 0; ++i) {}
#}


Running test: testForOfLoop
break at:
function testForOfLoop() {
  for (var k of #[]) {}
  for (var k of [1]) k;

break at:
function testForOfLoop() {
  for (var #k of []) {}
  for (var k of [1]) k;

break at:
  for (var k of []) {}
  for (var k of #[1]) k;
  var a = [];

break at:
  for (var k of []) {}
  for (var #k of [1]) k;
  var a = [];

break at:
  for (var k of []) {}
  for (var k of [1]) #k;
  var a = [];

break at:
  for (var k of []) {}
  for (var #k of [1]) k;
  var a = [];

break at:
  for (var k of [1]) k;
  var a = #[];
  for (var k of a) {}

break at:
  var a = [];
  for (var k of #a) {}
}

break at:
  var a = [];
  for (var #k of a) {}
}

break at:
  for (var k of a) {}
#}


Running test: testForInLoop
break at:
function testForInLoop() {
  var o = #{};
  for (var k in o) {}

break at:
  var o = {};
  for (var k in #o) {}
  for (var k in o) k;

break at:
  var o = {};
  for (var #k in o) {}
  for (var k in o) k;

break at:
  for (var k in o) {}
  for (var k in #o) k;
  for (var k in { a:1 }) {}

break at:
  for (var k in o) {}
  for (var #k in o) k;
  for (var k in { a:1 }) {}

break at:
  for (var k in o) k;
  for (var k in #{ a:1 }) {}
  for (var k in { a:1 }) k;

break at:
  for (var k in o) k;
  for (var #k in { a:1 }) {}
  for (var k in { a:1 }) k;

break at:
  for (var k in { a:1 }) {}
  for (var k in #{ a:1 }) k;
}

break at:
  for (var k in { a:1 }) {}
  for (var #k in { a:1 }) k;
}

break at:
  for (var k in { a:1 }) {}
  for (var k in { a:1 }) #k;
}

break at:
  for (var k in { a:1 }) {}
  for (var #k in { a:1 }) k;
}

break at:
  for (var k in { a:1 }) k;
#}


Running test: testSimpleExpressions
break at:
  1 + 2 + 3;
  var a = #1;
  ++a;

break at:
  var a = 1;
  #++a;
  a--;

break at:
  ++a;
  #a--;
}

break at:
  a--;
#}


Running test: testGetter
break at:
function testGetter() {
  #getterFoo();
}

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

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

break at:
function testGetter() {
  #getterFoo();
}

break at:
function return42() {
  #return 42;
}

break at:
function return42() {
  return 42;#
}

break at:
  getterFoo();
#}


Running test: testChainedCalls
break at:
function testChainedCalls() {
  #obj.foo().boo()();
}

break at:
var obj = {
  foo: () => (#{
    boo: () => return42

break at:
    boo: () => return42
  })#
};

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

break at:
  foo: () => ({
    boo: () => #return42
  })

break at:
  foo: () => ({
    boo: () => return42#
  })

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

break at:
function return42() {
  #return 42;
}

break at:
function return42() {
  return 42;#
}

break at:
  obj.foo().boo()();
#}


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

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

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

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

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

break at:
  Array.from([1]).concat([2]).map(v => v * 2);
#}


Running test: testPromiseThen
break at:
function testPromiseThen() {
  #return Promise.resolve().then(v => v * 2).then(v => v * 2);
}

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


Running test: testSwitch
break at:
function testSwitch() {
  for (var i = #0; i < 3; ++i) {
    switch(i) {

break at:
function testSwitch() {
  for (var i = 0; i #< 3; ++i) {
    switch(i) {

break at:
  for (var i = 0; i < 3; ++i) {
    #switch(i) {
      case 0: continue;

break at:
    switch(i) {
      case 0: #continue;
      case 1: return42(); break;

break at:
function testSwitch() {
  for (var i = 0; i < 3; ++#i) {
    switch(i) {

break at:
function testSwitch() {
  for (var i = 0; i #< 3; ++i) {
    switch(i) {

break at:
  for (var i = 0; i < 3; ++i) {
    #switch(i) {
      case 0: continue;

break at:
      case 0: continue;
      case 1: #return42(); break;
      default: return;

break at:
function return42() {
  #return 42;
}

break at:
function return42() {
  return 42;#
}

break at:
      case 0: continue;
      case 1: return42(); #break;
      default: return;

break at:
function testSwitch() {
  for (var i = 0; i < 3; ++#i) {
    switch(i) {

break at:
function testSwitch() {
  for (var i = 0; i #< 3; ++i) {
    switch(i) {

break at:
  for (var i = 0; i < 3; ++i) {
    #switch(i) {
      case 0: continue;

break at:
      case 1: return42(); break;
      default: #return;
    }

break at:
      case 1: return42(); break;
      default: return;#
    }


Running test: testGenerator
break at:
function testGenerator() {
  var gen = #idMaker();
  return42();

break at:
function* idMaker() {
  #yield 1;
  yield 2;

break at:
  gen.next().value;
  #debugger;
  gen.next().value;

break at:
  debugger;
  gen.#next().value;
  return42();

break at:
  yield 1;
  #yield 2;
  yield 3;

break at:
  yield 2;
  #yield 3;
}

break at:
  yield 3;
#}


break at:
  gen.next().value;
#}


Running test: testCaughtException
break at:
  try {
    #throwException()
  } catch (e) {

break at:
function throwException() {
  #throw new Error();
}

break at:
  } catch (e) {
    #return;
  }

break at:
  } catch (e) {
    return;#
  }


Running test: testClasses
break at:
  }
  #new Lion().speak();
}

break at:
    constructor(name) {
      #super(name);
    }

break at:
    constructor(name) {
      #this.name = name;
    }

break at:
      this.name = name;
    #}


break at:
      super(name);
    #}


break at:
  }
  new Lion().#speak();
}

break at:
    speak() {
      #super.speak();
    }

break at:
    speak() {
    #}
  }

break at:
      super.speak();
    #}
  }

break at:
  new Lion().speak();
#}


Running test: testAsyncAwait
break at:
async function testAsyncAwait() {
  #await asyncFoo();
  await awaitBoo();

break at:
async function asyncFoo() {
  #await Promise.resolve().then(v => v * 2);
  return42();

break at:
function return42() {
  #return 42;
}

break at:
function return42() {
  return 42;#
}

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


Running test: testPromiseAsyncWithCode
break at:
  var nextTest;
  var testPromise = #new Promise(resolve => nextTest = resolve);
  async function main() {

break at:
  var nextTest;
  var testPromise = new Promise(resolve => nextTest #= resolve);
  async function main() {

break at:
  var nextTest;
  var testPromise = new Promise(resolve => nextTest = resolve#);
  async function main() {

break at:
  }
  #main();
  return testPromise;

break at:
    }
    #setTimeout(returnCall, 0);
    await foo();

break at:
    setTimeout(returnCall, 0);
    await #foo();
    await foo();

break at:
      var resolveNested;
      var p = #new Promise(resolve => resolveNested = resolve);
      setTimeout(resolveNested, 0);

break at:
      var resolveNested;
      var p = new Promise(resolve => resolveNested #= resolve);
      setTimeout(resolveNested, 0);

break at:
      var resolveNested;
      var p = new Promise(resolve => resolveNested = resolve#);
      setTimeout(resolveNested, 0);

break at:
      var p = new Promise(resolve => resolveNested = resolve);
      #setTimeout(resolveNested, 0);
      await p;

break at:
      setTimeout(resolveNested, 0);
      #await p;
    }

break at:
      var resolveNested;
      var p = #new Promise(resolve => resolveNested = resolve);
      setTimeout(resolveNested, 0);

break at:
      var resolveNested;
      var p = new Promise(resolve => resolveNested #= resolve);
      setTimeout(resolveNested, 0);

break at:
      var resolveNested;
      var p = new Promise(resolve => resolveNested = resolve#);
      setTimeout(resolveNested, 0);

break at:
      var p = new Promise(resolve => resolveNested = resolve);
      #setTimeout(resolveNested, 0);
      await p;

break at:
      setTimeout(resolveNested, 0);
      #await p;
    }


Running test: testPromiseComplex
break at:
  var nextTest;
  var testPromise = #new Promise(resolve => nextTest = resolve);
  async function main() {

break at:
  var nextTest;
  var testPromise = new Promise(resolve => nextTest #= resolve);
  async function main() {

break at:
  var nextTest;
  var testPromise = new Promise(resolve => nextTest = resolve#);
  async function main() {

break at:
  }
  #main();
  return testPromise;

break at:
    }
    var x = #1;
    var y = 2;

break at:
    var x = 1;
    var y = #2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));

break at:
    var y = 2;
    #returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
    nextTest();

break at:

function emptyFunction() {#}


break at:
    var y = 2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, #returnCall())().a = await foo((a => 2 *a)(5));
    nextTest();

break at:
function returnCall() {
  #return return42();
}

break at:
function return42() {
  #return 42;
}

break at:
function return42() {
  return 42;#
}

break at:
function returnCall() {
  return return42();#
}

break at:
    var y = 2;
    #returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
    nextTest();

break at:
function returnFunction() {
  #return returnObject;
}

break at:
function returnFunction() {
  return returnObject;#
}

break at:
    var y = 2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())#().a = await foo((a => 2 *a)(5));
    nextTest();

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

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

break at:
    var y = 2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)#(5));
    nextTest();

break at:
    var y = 2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 #*a)(5));
    nextTest();

break at:
    var y = 2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a#)(5));
    nextTest();

break at:
    var y = 2;
    returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await #foo((a => 2 *a)(5));
    nextTest();

break at:
    async function foo() {
      #await Promise.resolve();
      return 42;