diff options
Diffstat (limited to 'deps/v8/test/mjsunit/es6/debug-promises')
24 files changed, 1460 insertions, 0 deletions
diff --git a/deps/v8/test/mjsunit/es6/debug-promises/async-task-event.js b/deps/v8/test/mjsunit/es6/debug-promises/async-task-event.js new file mode 100644 index 000000000..88030a2e7 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/async-task-event.js @@ -0,0 +1,61 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug + +Debug = debug.Debug; + +var base_id = -1; +var exception = null; +var expected = [ + "enqueue #1", + "willHandle #1", + "then #1", + "enqueue #2", + "didHandle #1", + "willHandle #2", + "then #2", + "enqueue #3", + "didHandle #2", + "willHandle #3", + "didHandle #3" +]; + +function assertLog(msg) { + print(msg); + assertTrue(expected.length > 0); + assertEquals(expected.shift(), msg); + if (!expected.length) { + Debug.setListener(null); + } +} + +function listener(event, exec_state, event_data, data) { + if (event != Debug.DebugEvent.AsyncTaskEvent) return; + try { + if (base_id < 0) + base_id = event_data.id(); + var id = event_data.id() - base_id + 1; + assertEquals("Promise.resolve", event_data.name()); + assertLog(event_data.type() + " #" + id); + } catch (e) { + print(e + e.stack) + exception = e; + } +} + +Debug.setListener(listener); + +var resolver; +var p = new Promise(function(resolve, reject) { + resolver = resolve; +}); +p.then(function() { + assertLog("then #1"); +}).then(function() { + assertLog("then #2"); +}); +resolver(); + +assertNull(exception); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/events.js b/deps/v8/test/mjsunit/es6/debug-promises/events.js new file mode 100644 index 000000000..a9f94543f --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/events.js @@ -0,0 +1,124 @@ +// Copyright 2014 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. + +// Flags: --allow-natives-syntax --expose-debug-as debug + +Debug = debug.Debug; + +var eventsExpected = 16; +var exception = null; +var result = []; + +function updatePromise(promise, parentPromise, status, value) { + var i; + for (i = 0; i < result.length; ++i) { + if (result[i].promise === promise) { + result[i].parentPromise = parentPromise || result[i].parentPromise; + result[i].status = status || result[i].status; + result[i].value = value || result[i].value; + break; + } + } + assertTrue(i < result.length); +} + +function listener(event, exec_state, event_data, data) { + if (event != Debug.DebugEvent.PromiseEvent) return; + try { + eventsExpected--; + assertTrue(event_data.promise().isPromise()); + if (event_data.status() === 0) { + // New promise. + assertEquals("pending", event_data.promise().status()); + result.push({ promise: event_data.promise().value(), status: 0 }); + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } else if (event_data.status() !== undefined) { + // Resolve/reject promise. + updatePromise(event_data.promise().value(), + undefined, + event_data.status(), + event_data.value().value()); + } else { + // Chain promises. + assertTrue(event_data.parentPromise().isPromise()); + updatePromise(event_data.promise().value(), + event_data.parentPromise().value()); + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } + } catch (e) { + print(e + e.stack) + exception = e; + } +} + +Debug.setListener(listener); + +function resolver(resolve, reject) { resolve(); } + +var p1 = new Promise(resolver); // event +var p2 = p1.then().then(); // event +var p3 = new Promise(function(resolve, reject) { // event + reject("rejected"); +}); +var p4 = p3.then(); // event +var p5 = p1.then(); // event + +function assertAsync(b, s) { + if (b) { + print(s, "succeeded"); + } else { + %AbortJS(s + " FAILED!"); + } +} + +function testDone(iteration) { + function checkResult() { + if (eventsExpected === 0) { + assertAsync(result.length === 6, "result.length"); + + assertAsync(result[0].promise === p1, "result[0].promise"); + assertAsync(result[0].parentPromise === undefined, + "result[0].parentPromise"); + assertAsync(result[0].status === 1, "result[0].status"); + assertAsync(result[0].value === undefined, "result[0].value"); + + assertAsync(result[1].parentPromise === p1, + "result[1].parentPromise"); + assertAsync(result[1].status === 1, "result[1].status"); + + assertAsync(result[2].promise === p2, "result[2].promise"); + + assertAsync(result[3].promise === p3, "result[3].promise"); + assertAsync(result[3].parentPromise === undefined, + "result[3].parentPromise"); + assertAsync(result[3].status === -1, "result[3].status"); + assertAsync(result[3].value === "rejected", "result[3].value"); + + assertAsync(result[4].promise === p4, "result[4].promise"); + assertAsync(result[4].parentPromise === p3, + "result[4].parentPromise"); + assertAsync(result[4].status === -1, "result[4].status"); + assertAsync(result[4].value === "rejected", "result[4].value"); + + assertAsync(result[5].promise === p5, "result[5].promise"); + assertAsync(result[5].parentPromise === p1, + "result[5].parentPromise"); + assertAsync(result[5].status === 1, "result[5].status"); + + assertAsync(exception === null, "exception === null"); + Debug.setListener(null); + } else if (iteration > 10) { + %AbortJS("Not all events were received!"); + } else { + testDone(iteration + 1); + } + } + + var iteration = iteration || 0; + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reentry.js b/deps/v8/test/mjsunit/es6/debug-promises/reentry.js new file mode 100644 index 000000000..fbe54242d --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reentry.js @@ -0,0 +1,17 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug + +// Test reentry of special try catch for Promises. + +Debug = debug.Debug; + +Debug.setBreakOnUncaughtException(); +Debug.setListener(function(event, exec_state, event_data, data) { }); + +var p = new Promise(function(resolve, reject) { resolve(); }); +var q = p.chain(function() { + new Promise(function(resolve, reject) { resolve(); }); +}); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-after-resolve.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-after-resolve.js new file mode 100644 index 000000000..a0036cfd0 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-after-resolve.js @@ -0,0 +1,37 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we listen to uncaught exceptions and +// the Promise is rejected in a chained closure after it has been resolved. +// We expect no Exception debug event to be triggered. + +Debug = debug.Debug; + +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(reject); +}); + +var q = p.chain( + function(value) { + assertEquals(["resolve", "end main"], log); + value(new Error("reject")); + }); + +function listener(event, exec_state, event_data, data) { + try { + assertTrue(event != Debug.DebugEvent.Exception); + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnException(); +Debug.setListener(listener); + +log.push("end main"); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-all.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-all.js new file mode 100644 index 000000000..0fca57730 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-all.js @@ -0,0 +1,72 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we listen to all exceptions and +// there is a catch handler for the to-be-rejected Promise. +// We expect a normal Exception debug event to be triggered. + +Debug = debug.Debug; + +var log = []; +var expected_events = 1; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +var q = p.chain( + function(value) { + log.push("reject"); + return Promise.reject(new Error("reject")); + }); + +q.catch( + function(e) { + assertEquals("reject", e.message); + }); + + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("reject", event_data.exception().message); + assertSame(q, event_data.promise()); + assertFalse(event_data.uncaught()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "end main", "reject"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-late.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-late.js new file mode 100644 index 000000000..2ff13d560 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-late.js @@ -0,0 +1,34 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions, the Promise +// is rejected, and a catch handler is installed right before the rejection. +// We expect no debug event to be triggered. + +Debug = debug.Debug; + +var p = new Promise(function(resolve, reject) { + resolve(); +}); + +var q = p.chain( + function() { + q.catch(function(e) { + assertEquals("caught", e.message); + }); + return Promise.reject(Error("caught")); + }); + +function listener(event, exec_state, event_data, data) { + try { + assertTrue(event != Debug.DebugEvent.Exception); + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-uncaught.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-uncaught.js new file mode 100644 index 000000000..d3fd9f3ae --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-caught-uncaught.js @@ -0,0 +1,36 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions and +// there is a catch handler for the to-be-rejected Promise. +// We expect no debug event to be triggered. + +Debug = debug.Debug; + +var p = new Promise(function(resolve, reject) { + resolve(); +}); + +var q = p.chain( + function() { + return Promise.reject(Error("caught reject")); + }); + +q.catch( + function(e) { + assertEquals("caught reject", e.message); + }); + +function listener(event, exec_state, event_data, data) { + try { + assertTrue(event != Debug.DebugEvent.Exception); + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-in-constructor.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-in-constructor.js new file mode 100644 index 000000000..a05b3ac5d --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-in-constructor.js @@ -0,0 +1,39 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug + +// Test debug events when we only listen to uncaught exceptions and +// the Promise is rejected in the Promise constructor. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var steps = 0; +var exception = null; + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + steps++; + assertEquals("uncaught", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } + } catch (e) { + exception = e; + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +var p = new Promise(function(resolve, reject) { + reject(new Error("uncaught")); // event +}); + +assertEquals(1, steps); +assertNull(exception); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-all.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-all.js new file mode 100644 index 000000000..beaf1878f --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-all.js @@ -0,0 +1,69 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we listen to all exceptions and +// there is a catch handler for the to-be-rejected Promise. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +var q = p.chain( + function() { + log.push("reject"); + return Promise.reject(new Error("uncaught reject")); + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("uncaught reject", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertSame(q, event_data.promise()); + assertTrue(event_data.uncaught()); + // All of the frames on the stack are from native Javascript. + assertEquals(0, exec_state.frameCount()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "end main", "reject"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-late.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-late.js new file mode 100644 index 000000000..4a883da13 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-late.js @@ -0,0 +1,76 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions and +// there is a catch handler for the to-be-rejected Promise. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var reject_closure; + +var p = new Promise(function(resolve, reject) { + log.push("postpone p"); + reject_closure = reject; +}); + +var q = new Promise(function(resolve, reject) { + log.push("resolve q"); + resolve(); +}); + +q.then(function() { + log.push("reject p"); + reject_closure(new Error("uncaught reject p")); // event +}) + + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("uncaught reject p", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertSame(p, event_data.promise()); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["postpone p", "resolve q", "end main", "reject p"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-uncaught.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-uncaught.js new file mode 100644 index 000000000..86e2a815e --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-uncaught-uncaught.js @@ -0,0 +1,69 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions and +// there is no catch handler for the to-be-rejected Promise. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +var q = p.chain( + function() { + log.push("reject"); + return Promise.reject(Error("uncaught reject")); // event + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("uncaught reject", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertSame(q, event_data.promise()); + assertTrue(event_data.uncaught()); + // All of the frames on the stack are from native Javascript. + assertEquals(0, exec_state.frameCount()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "end main", "reject"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-with-invalid-reject.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-with-invalid-reject.js new file mode 100644 index 000000000..fc6233da8 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-with-invalid-reject.js @@ -0,0 +1,77 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when a Promise is rejected, which is caught by a custom +// promise, which has a number for reject closure. We expect an Exception debug +// events trying to call the invalid reject closure. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +function MyPromise(resolver) { + var reject = 1; + var resolve = function() { }; + log.push("construct"); + resolver(resolve, reject); +}; + +MyPromise.prototype = new Promise(function() {}); +p.constructor = MyPromise; + +var q = p.chain( + function() { + log.push("reject caught"); + return Promise.reject(new Error("caught")); + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("number is not a function", event_data.exception().message); + // All of the frames on the stack are from native Javascript. + assertEquals(0, exec_state.frameCount()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "construct", "end main", "reject caught"], + log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); + +log.push("end main"); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-with-throw-in-reject.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-with-throw-in-reject.js new file mode 100644 index 000000000..15e464ec6 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-with-throw-in-reject.js @@ -0,0 +1,87 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when a Promise is rejected, which is caught by a +// custom promise, which throws a new exception in its reject handler. +// We expect two Exception debug events: +// 1) when promise q is rejected. +// 2) when the custom reject closure in MyPromise throws an exception. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +function MyPromise(resolver) { + var reject = function() { + log.push("throw in reject"); + throw new Error("reject"); // event + }; + var resolve = function() { }; + log.push("construct"); + resolver(resolve, reject); +}; + +MyPromise.prototype = new Promise(function() {}); +p.constructor = MyPromise; + +var q = p.chain( + function() { + log.push("reject caught"); + return Promise.reject(new Error("caught")); + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("reject", event_data.exception().message); + // Assert that the debug event is triggered at the throw site. + assertTrue( + exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } + } catch (e) { + // Signal a failure with exit code 1. This is necessary since the + // debugger swallows exceptions and we expect the chained function + // and this listener to be executed after the main script is finished. + print("Unexpected exception: " + e + "\n" + e.stack); + quit(1); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "construct", "end main", + "reject caught", "throw in reject"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/reject-with-undefined-reject.js b/deps/v8/test/mjsunit/es6/debug-promises/reject-with-undefined-reject.js new file mode 100644 index 000000000..d11c01ff7 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/reject-with-undefined-reject.js @@ -0,0 +1,77 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when a Promise is rejected, which is caught by a custom +// promise, which has undefined for reject closure. We expect an Exception +// debug even calling the (undefined) custom rejected closure. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +function MyPromise(resolver) { + var reject = undefined; + var resolve = function() { }; + log.push("construct"); + resolver(resolve, reject); +}; + +MyPromise.prototype = new Promise(function() {}); +p.constructor = MyPromise; + +var q = p.chain( + function() { + log.push("reject caught"); + return Promise.reject(new Error("caught")); + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("caught", event_data.exception().message); + // All of the frames on the stack are from native Javascript. + assertEquals(0, exec_state.frameCount()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "construct", "end main", "reject caught"], + log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); + +log.push("end main"); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-all.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-all.js new file mode 100644 index 000000000..2fbf05141 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-all.js @@ -0,0 +1,71 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we listen to all exceptions and +// there is a catch handler for the exception thrown in a Promise. +// We expect a normal Exception debug event to be triggered. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +var q = p.chain( + function() { + log.push("throw"); + throw new Error("caught"); + }); + +q.catch( + function(e) { + assertEquals("caught", e.message); + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("caught", event_data.exception().message); + assertSame(q, event_data.promise()); + assertFalse(event_data.uncaught()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "end main", "throw"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-late.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-late.js new file mode 100644 index 000000000..ac79aba76 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-late.js @@ -0,0 +1,34 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions, the Promise +// throws, and a catch handler is installed right before throwing. +// We expect no debug event to be triggered. + +Debug = debug.Debug; + +var p = new Promise(function(resolve, reject) { + resolve(); +}); + +var q = p.chain( + function() { + q.catch(function(e) { + assertEquals("caught", e.message); + }); + throw new Error("caught"); + }); + +function listener(event, exec_state, event_data, data) { + try { + assertTrue(event != Debug.DebugEvent.Exception); + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-uncaught.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-uncaught.js new file mode 100644 index 000000000..0ad9ce48a --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-caught-uncaught.js @@ -0,0 +1,36 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions and +// there is a catch handler for the exception thrown in a Promise. +// We expect no debug event to be triggered. + +Debug = debug.Debug; + +var p = new Promise(function(resolve, reject) { + resolve(); +}); + +var q = p.chain( + function() { + throw new Error("caught throw"); + }); + +q.catch( + function(e) { + assertEquals("caught throw", e.message); + }); + +function listener(event, exec_state, event_data, data) { + try { + assertTrue(event != Debug.DebugEvent.Exception); + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-in-constructor.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-in-constructor.js new file mode 100644 index 000000000..fd6b4dd34 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-in-constructor.js @@ -0,0 +1,40 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug + +// Test debug events when we only listen to uncaught exceptions and +// an exception is thrown in the Promise constructor. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var step = 0; +var exception = null; + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + assertEquals(0, step); + assertEquals("uncaught", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + step++; + } + } catch (e) { + exception = e; + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +var p = new Promise(function(resolve, reject) { + throw new Error("uncaught"); // event +}); + +assertEquals(1, step); +assertNull(exception); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-uncaught-all.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-uncaught-all.js new file mode 100644 index 000000000..72f800bf5 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-uncaught-all.js @@ -0,0 +1,70 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we listen to all exceptions and +// there is no catch handler for the exception thrown in a Promise. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +var q = p.chain( + function() { + log.push("throw"); + throw new Error("uncaught"); // event + }); + +function listener(event, exec_state, event_data, data) { + try { + // Ignore exceptions during startup in stress runs. + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("uncaught", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertSame(q, event_data.promise()); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "end main", "throw"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Rerun testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-uncaught-uncaught.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-uncaught-uncaught.js new file mode 100644 index 000000000..69aa8ebbd --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-uncaught-uncaught.js @@ -0,0 +1,70 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when we only listen to uncaught exceptions and +// there is a catch handler for the exception thrown in a Promise. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var expected_events = 1; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +var q = p.chain( + function() { + log.push("throw"); + throw new Error("uncaught"); // event + }); + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.AsyncTaskEvent) return; + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + assertEquals("uncaught", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertSame(q, event_data.promise()); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "end main", "throw"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-with-throw-in-reject.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-with-throw-in-reject.js new file mode 100644 index 000000000..1ea1c7f9f --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-with-throw-in-reject.js @@ -0,0 +1,90 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when an exception is thrown inside a Promise, which is +// caught by a custom promise, which throws a new exception in its reject +// handler. We expect two Exception debug events: +// 1) when the exception is thrown in the promise q. +// 2) when the custom reject closure in MyPromise throws an exception. + +Debug = debug.Debug; + +var expected_events = 2; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +function MyPromise(resolver) { + var reject = function() { + log.push("throw in reject"); + throw new Error("reject"); // event + }; + var resolve = function() { }; + log.push("construct"); + resolver(resolve, reject); +}; + +MyPromise.prototype = new Promise(function() {}); +p.constructor = MyPromise; + +var q = p.chain( + function() { + log.push("throw caught"); + throw new Error("caught"); // event + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + if (expected_events == 1) { + assertEquals(["resolve", "construct", "end main", + "throw caught"], log); + assertEquals("caught", event_data.exception().message); + } else if (expected_events == 0) { + assertEquals("reject", event_data.exception().message); + } else { + assertUnreachable(); + } + assertSame(q, event_data.promise()); + assertTrue(exec_state.frame(0).sourceLineText().indexOf('// event') > 0); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "construct", "end main", + "throw caught", "throw in reject"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/throw-with-undefined-reject.js b/deps/v8/test/mjsunit/es6/debug-promises/throw-with-undefined-reject.js new file mode 100644 index 000000000..94dcdffa2 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/throw-with-undefined-reject.js @@ -0,0 +1,88 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug --allow-natives-syntax + +// Test debug events when an exception is thrown inside a Promise, which is +// caught by a custom promise, which has no reject handler. +// We expect two Exception debug events: +// 1) when the exception is thrown in the promise q. +// 2) when calling the undefined custom reject closure in MyPromise throws. + +Debug = debug.Debug; + +var expected_events = 2; +var log = []; + +var p = new Promise(function(resolve, reject) { + log.push("resolve"); + resolve(); +}); + +function MyPromise(resolver) { + var reject = undefined; + var resolve = function() { }; + log.push("construct"); + resolver(resolve, reject); +}; + +MyPromise.prototype = new Promise(function() {}); +p.constructor = MyPromise; + +var q = p.chain( + function() { + log.push("throw caught"); + throw new Error("caught"); // event + }); + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + expected_events--; + assertTrue(expected_events >= 0); + if (expected_events == 1) { + assertTrue( + exec_state.frame(0).sourceLineText().indexOf('// event') > 0); + assertEquals("caught", event_data.exception().message); + } else if (expected_events == 0) { + // All of the frames on the stack are from native Javascript. + assertEquals(0, exec_state.frameCount()); + assertEquals("undefined is not a function", + event_data.exception().message); + } else { + assertUnreachable(); + } + assertSame(q, event_data.promise()); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +log.push("end main"); + +function testDone(iteration) { + function checkResult() { + try { + assertTrue(iteration < 10); + if (expected_events === 0) { + assertEquals(["resolve", "construct", "end main", "throw caught"], log); + } else { + testDone(iteration + 1); + } + } catch (e) { + %AbortJS(e + "\n" + e.stack); + } + } + + // Run testDone through the Object.observe processing loop. + var dummy = {}; + Object.observe(dummy, checkResult); + dummy.dummy = dummy; +} + +testDone(0); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/try-reject-in-constructor.js b/deps/v8/test/mjsunit/es6/debug-promises/try-reject-in-constructor.js new file mode 100644 index 000000000..00981a67d --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/try-reject-in-constructor.js @@ -0,0 +1,42 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug + +// Test debug events when we only listen to uncaught exceptions and +// the Promise is rejected within a try-catch in the Promise constructor. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var step = 0; +var exception = null; + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + assertEquals(0, step); + assertEquals("uncaught", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + step++; + } + } catch (e) { + exception = e; + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +var p = new Promise(function(resolve, reject) { + try { // This try-catch must not prevent this uncaught reject event. + reject(new Error("uncaught")); // event + } catch (e) { } +}); + +assertEquals(1, step); +assertNull(exception); diff --git a/deps/v8/test/mjsunit/es6/debug-promises/try-throw-reject-in-constructor.js b/deps/v8/test/mjsunit/es6/debug-promises/try-throw-reject-in-constructor.js new file mode 100644 index 000000000..feff81da9 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/debug-promises/try-throw-reject-in-constructor.js @@ -0,0 +1,44 @@ +// Copyright 2014 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. + +// Flags: --expose-debug-as debug + +// Test debug events when we only listen to uncaught exceptions and +// an exception is thrown in the Promise constructor, but caught in an +// inner try-catch. The Promise is rejected afterwards. +// We expect an Exception debug event with a promise to be triggered. + +Debug = debug.Debug; + +var step = 0; +var exception = null; + +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Exception) { + assertEquals(0, step); + assertEquals("uncaught", event_data.exception().message); + assertTrue(event_data.promise() instanceof Promise); + assertTrue(event_data.uncaught()); + // Assert that the debug event is triggered at the throw site. + assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event") > 0); + step++; + } + } catch (e) { + exception = e; + } +} + +Debug.setBreakOnUncaughtException(); +Debug.setListener(listener); + +var p = new Promise(function(resolve, reject) { + try { // This try-catch must not prevent this uncaught reject event. + throw new Error("caught"); + } catch (e) { } + reject(new Error("uncaught")); // event +}); + +assertEquals(1, step); +assertNull(exception); |