diff options
Diffstat (limited to 'deps/v8/test/inspector/regress/regress-crbug-1270780.js')
-rw-r--r-- | deps/v8/test/inspector/regress/regress-crbug-1270780.js | 107 |
1 files changed, 107 insertions, 0 deletions
diff --git a/deps/v8/test/inspector/regress/regress-crbug-1270780.js b/deps/v8/test/inspector/regress/regress-crbug-1270780.js new file mode 100644 index 0000000000..0be18f4230 --- /dev/null +++ b/deps/v8/test/inspector/regress/regress-crbug-1270780.js @@ -0,0 +1,107 @@ +// Copyright 2022 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. + +let {session, contextGroup, Protocol} = InspectorTest.start('Regression test for crbug.com/1270780.'); + +contextGroup.addScript(` +function* gen() { + yield 1; + throw new Error(); +} + +function callGen() { + try { + for (const x of gen()) {} + } catch {} +} + +const throwNextIter = () => ({ + values: [1, 2], + next() { + // Throw an exception once 'values' is empty. + if (this.values.length === 0) { + throw new Error(); + } + return {value: this.values.shift(), done: false}; + }, + [Symbol.iterator]() { return this; } +}); + +const throwReturnIter = () => ({ + values: [1, 2], + next() { + if (this.values.length === 0) { return {done: true}}; + return {value: this.values.shift(), done: false}; + }, + return() { + throw new Error(); + }, + [Symbol.iterator]() { return this; } +}); + +function iterateIterator(iter) { + try { + for (const x of iter) {} + } catch {} +} + +function breakingLoopBody(iter) { + try { + for (const x of iter) { + break; // Triger '.return'. + } + } catch {} +} + +function throwingLoopBody(iter) { + try { + for (const x of iter) { + throw new Error(); + } + } catch {} +}`); + +async function runTest(expression, expectedNumberOfPauses = 1) { + await Promise.all([ + Protocol.Debugger.enable(), + Protocol.Debugger.setPauseOnExceptions({state: 'uncaught'}), + ]); + + // Don't pause. + await Protocol.Runtime.evaluate({ expression, replMode: true }); + InspectorTest.log('Not pausing for uncaught exception: SUCCESS'); + + // Run the same expression but with 'caught' and expect a pause. + await Protocol.Debugger.setPauseOnExceptions({ state: 'caught' }); + const evalPromise = Protocol.Runtime.evaluate({ expression, replMode: true }); + + for (let x = 1; x <= expectedNumberOfPauses; ++x) { + await Protocol.Debugger.oncePaused(); + InspectorTest.log(`Pause no. ${x} for caught exception: SUCCESS`); + await Protocol.Debugger.resume(); + } + + await Promise.all([ + Protocol.Debugger.disable(), + evalPromise, + ]); +} + +InspectorTest.runAsyncTestSuite([ + async function testThrowingGenerator() { + await runTest('callGen()'); + }, + async function testThrowingNext() { + await runTest('iterateIterator(throwNextIter())'); + }, + async function testThrowingReturn() { + await runTest('breakingLoopBody(throwReturnIter())'); + }, + async function testThrowingLoopBody() { + await runTest('throwingLoopBody([1, 2])'); + }, + async function testThrowingLoopBodyAndThrowingReturn() { + await runTest('throwingLoopBody(throwReturnIter())', 2); + }, +]); |