[inspector] added step-into test to cover most stepInto cases

test/inspector/debugger/step-into-expected.txt

Index: test/inspector/debugger/step-into-expected.txt
diff --git a/test/inspector/debugger/step-into-expected.txt b/test/inspector/debugger/step-into-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3ef9faf08600edf2181fd96a02e3a197e53a78e1
--- /dev/null
+++ b/test/inspector/debugger/step-into-expected.txt
@@ -0,0 +1,855 @@
+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:
+  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:
+  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());

[dgozman, 2017/02/27 17:56:48]

Having this and line 141 is a bit confusing.

[kozy, 2017/02/27 18:35:08]

Yes, it should be before first 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:
+      return;
+    #}
+    return nested2();
+
+break at:
+    return nested2();
+  #}
+  nested1();
+
+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:
+  return 42;
+#}
+
+
+break at:
+  return return42();
+#}
+
+
+break at:
+  return returnCall();
+#}
+
+
+
+Running test: testWith
+break at:
+function testWith() {
+  #with (returnObject()) {
+    foo();
+
+break at:
+function returnObject() {
+  #return ({ foo: () => 42 });
+}
+
+break at:
+  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:
+  }
+#}
+
+
+
+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) {}
+  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:
+  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:
+function testSimpleExpressions() {
+  #1 + 2 + 3;
+  var a = 1;
+
+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:
+  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:
+  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:
+  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:
+  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:
+  }
+#}
+
+
+
+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:
+  }
+#}
+
+
+
+Running test: testClasses
+break at:
+function testClasses() {
+  #class Cat {
+    constructor(name) {
+
+break at:
+  }
+  #class Lion extends Cat {
+    constructor(name) {
+
+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:
+async function asyncFoo() {
+  await Promise.#resolve().then(v => v * 2);
+  return42();
+
+break at:
+async function asyncFoo() {
+  await Promise.resolve().#then(v => v * 2);
+  return42();
+
+break at:
+async function asyncFoo() {
+  #await Promise.resolve().then(v => v * 2);
+  return42();
+
+break at:
+function return42() {
+  #return 42;
+}
+
+break at:
+  return 42;
+#}
+
+
+break at:
+async function asyncBoo() {
+  await Promise.#resolve();
+
+
+break at:
+async function asyncBoo() {
+  #await Promise.resolve();
+
+