get-possible-breakpoints-master-expected.txt 4.87 KB
Newer Older
1 2 3 4 5 6
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() {
7 8 9
  |C|eval('// comment only');
  |C|eval('// comment only\n');
|R|}
10 11 12

// function without return
function procedure() {
13 14 15
  var a = |_|1;
  var b = |_|2;
|R|}
16 17

function testProcedure() {
18 19
  |C|procedure();
|R|}
20 21

function returnTrue() {
22 23
  |_|return true;|R|
}
24 25 26

function testIf() {
  var a;
27
  if (true) |_|a = true;
28 29
  |_|if (!a) {
    |_|a = true;
30
  } else {
31
    |_|a = false;
32
  }
33 34
  |_|if (|C|returnTrue()) {
    |_|a = false;
35
  } else {
36
    |_|a = true;
37
  }
38
|R|}
39

40
function emptyFunction() {|R|}
41 42

function testEmptyFunction() {
43 44
  |C|emptyFunction();
|R|}
45 46

function twoArguments(a1, a2) {
47
|R|}
48 49

function testCallArguments() {
50 51
  |C|twoArguments(|C|emptyFunction(), |C|emptyFunction());
|R|}
52 53 54 55 56

function testNested() {
  function nested1() {
    function nested2() {
      function nested3() {
57 58
      |R|}
      |C|nested3();
59 60
      |_|return;|R|
    }
61
    return |C|nested2();|R|
62
  }
63 64
  |C|nested1();
|R|}
65 66

function return42() {
67 68
  |_|return 42;|R|
}
69 70

function returnCall() {
71 72
  |_|return |C|return42();|R|
}
73 74

function testCallAtReturn() {
75 76
  |_|return |C|returnCall();|R|
}
77 78

function returnObject() {
79 80
  |_|return ({ foo: () => |_|42|R| });|R|
}
81 82

function testWith() {
83 84
  |_|with (|C|returnObject()) {
    |C|foo();
85
  }
86
  |_|with({}) {
87
    |_|return;|R|
88
  }
89
}
90 91

function testForLoop() {
92
  for (var i = |_|0; i |_|< 1; ++|_|i) {}
93
  for (var i = |_|0; i |_|< 1; ++|_|i) i;
94 95
  for (var i = |_|0; i |_|< 0; ++|_|i) {}
|R|}
96 97

function testForOfLoop() {
98 99
  for (var |C|k of |_|[]) {}
  for (var |C|k of |_|[1]) |_|k;
100
  var a = |_|[];
101
  for (var |C|k of |_|a) {}
102
|R|}
103 104

function testForInLoop() {
105 106 107 108 109 110
  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;
|R|}
111 112

function testSimpleExpressions() {
113
  1 + 2 + 3;
114 115 116 117
  var a = |_|1;
  |_|++a;
  |_|a--;
|R|}
118

119
|_|Object.|C|defineProperty(this, 'getterFoo', {
120
  get: () => |_|return42|R|
121 122 123
});

function testGetter() {
124 125
  |C|getterFoo();
|R|}
126

127
var obj = |_|{
128 129 130
  foo: () => (|_|{
    boo: () => |_|return42|R|
  })|R|
131 132 133
};

function testChainedCalls() {
134 135
  |_|obj.|C|foo().|C|boo()|C|();
|R|}
136 137

function testChainedWithNative() {
138 139
  |_|Array.|C|from([1]).|C|concat([2]).|C|map(v => v |_|* 2|R|);
|R|}
140 141

function testPromiseThen() {
142 143
  |_|return Promise.|C|resolve().|C|then(v => v |_|* 2|R|).|C|then(v => v |_|* 2|R|);|R|
}
144 145

function testSwitch() {
146 147 148 149
  for (var i = |_|0; i |_|< 3; ++|_|i) {
    |_|switch(i) {
      case 0: |_|continue;
      case 1: |C|return42(); |_|break;
150
      default: |_|return;|R|
151 152
    }
  }
153
|R|}
154

155
function* idMaker|_|() {
156 157 158 159
  |_|yield 1;
  |_|yield 2;
  |_|yield 3;
|R|}
160 161

function testGenerator() {
162 163
  var gen = |C|idMaker();
  |C|return42();
164
  gen.|C|next().value;
165
  |D|debugger;
166
  gen.|C|next().value;
167
  |C|return42();
168
  gen.|C|next().value;
169
  |C|return42();
170
  gen.|C|next().value;
171
|R|}
172 173

function throwException() {
174
  |_|throw |C|new Error();
175
}
176 177 178

function testCaughtException() {
  try {
179
    |C|throwException()
180
  } catch (e) {
181
    |_|return;|R|
182
  }
183
|R|}
184 185

function testClasses() {
186
  class Cat {
187
    constructor(name) {
188 189
      |_|this.name = name;
    |R|}
190 191

    speak() {
192
    |R|}
193
  }
194
  class Lion extends Cat {
195
    constructor(name) {
196 197
      |C|super(name);
    |R|}
198 199

    speak() {
200 201
      |_|super.|C|speak();
    |R|}
202
  }
203 204
  |C|new Lion().|C|speak();
|R|}
205 206

async function asyncFoo() {
207
  |_|await Promise.|C|resolve().|C|then(v => v |_|* 2|R|);
208 209 210
  |C|return42();
  |_|await |C|asyncBoo();
|R|}
211 212

async function asyncBoo() {
213
  |_|await Promise.|C|resolve();
214
|R|}
215 216

async function testAsyncAwait() {
217
  |_|await |C|asyncFoo();
218 219
  |_|await |C|awaitBoo();
|R|}
220 221 222 223

// TODO(kozyatinskiy): fix this.
async function testPromiseAsyncWithCode() {
  var nextTest;
224
  var testPromise = |C|new Promise(resolve => nextTest |_|= resolve|R|);
225 226 227
  async function main() {
    async function foo() {
      var resolveNested;
228 229
      var p = |C|new Promise(resolve => resolveNested |_|= resolve|R|);
      |C|setTimeout(resolveNested, 0);
230
      |_|await p;
231 232
    |R|}
    |C|setTimeout(returnCall, 0);
233 234
    |_|await |C|foo();
    |_|await |C|foo();
235 236 237
    |C|nextTest();
  |R|}
  |C|main();
238
  |_|return testPromise;|R|
239
|R|}
240 241

function returnFunction() {
242 243
  |_|return returnObject;|R|
}
244 245 246

async function testPromiseComplex() {
  var nextTest;
247
  var testPromise = |C|new Promise(resolve => nextTest |_|= resolve|R|);
248 249
  async function main() {
    async function foo() {
250
      |_|await Promise.|C|resolve();
251
      |_|return 42;|R|
252 253 254
    |R|}
    var x = |_|1;
    var y = |_|2;
255
    |C|returnFunction(|C|emptyFunction(), x++, --y, x => 2 |_|* x|R|, |C|returnCall())|C|().a = |_|await |C|foo((a => 2 |_|*a|R|)|C|(5));
256 257 258
    |C|nextTest();
  |R|}
  |C|main();
259
  |_|return testPromise;|R|
260
|R|}
261 262

function twiceDefined() {
263
  |_|return a + b;|R|
264 265 266
}

function twiceDefined() {
267 268
  |_|return a + b;|R|
}
269

270
|R|
271