Revision: 21092
Author: [email protected]
Date: Wed Apr 30 14:17:40 2014 UTC
Log: Trigger exception debug event for promises at the throw site.
[email protected]
Review URL: https://codereview.chromium.org/260723002
http://code.google.com/p/v8/source/detail?r=21092
Added:
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-late.js
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-throw-in-constructor.js
Modified:
/branches/bleeding_edge/include/v8-debug.h
/branches/bleeding_edge/src/debug-debugger.js
/branches/bleeding_edge/src/debug.cc
/branches/bleeding_edge/src/debug.h
/branches/bleeding_edge/src/isolate.cc
/branches/bleeding_edge/src/mirror-debugger.js
/branches/bleeding_edge/src/promise.js
/branches/bleeding_edge/src/runtime.cc
/branches/bleeding_edge/src/runtime.h
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-all.js
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-uncaught.js
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-throw-in-reject.js
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-uncaught-all.js
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-uncaught-uncaught.js
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-undefined-reject.js
=======================================
--- /dev/null
+++ /branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-late.js
Wed Apr 30 14:17:40 2014 UTC
@@ -0,0 +1,38 @@
+// 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: --harmony-promises --expose-debug-as debug
+
+// 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) {
+ // 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);
=======================================
--- /dev/null
+++
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-throw-in-constructor.js
Wed Apr 30 14:17:40 2014 UTC
@@ -0,0 +1,46 @@
+// 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: --harmony-promises --expose-debug-as debug
+
+// Test debug events when we only listen to uncaught exceptions and
+// an exception is thrown in the 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 {
+ // Ignore exceptions during startup in stress runs.
+ if (step >= 1) return;
+ 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) {
+ // 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);
+ exception = e;
+ }
+}
+
+Debug.setBreakOnUncaughtException();
+Debug.setListener(listener);
+
+var p = new Promise(function(resolve, reject) {
+ throw new Error("uncaught"); // event
+});
+
+assertEquals(1, step);
+assertNull(exception);
=======================================
--- /branches/bleeding_edge/include/v8-debug.h Tue Apr 29 14:03:06 2014 UTC
+++ /branches/bleeding_edge/include/v8-debug.h Wed Apr 30 14:17:40 2014 UTC
@@ -20,8 +20,7 @@
BeforeCompile = 4,
AfterCompile = 5,
ScriptCollected = 6,
- PendingExceptionInPromise = 7,
- BreakForCommand = 8
+ BreakForCommand = 7
};
=======================================
--- /branches/bleeding_edge/src/debug-debugger.js Tue Apr 29 06:42:26 2014
UTC
+++ /branches/bleeding_edge/src/debug-debugger.js Wed Apr 30 14:17:40 2014
UTC
@@ -19,8 +19,7 @@
NewFunction: 3,
BeforeCompile: 4,
AfterCompile: 5,
- ScriptCollected: 6,
- PendingExceptionInPromise: 7 };
+ ScriptCollected: 6 };
// Types of exceptions that can be broken upon.
Debug.ExceptionBreak = { Caught : 0,
=======================================
--- /branches/bleeding_edge/src/debug.cc Tue Apr 29 14:03:06 2014 UTC
+++ /branches/bleeding_edge/src/debug.cc Wed Apr 30 14:17:40 2014 UTC
@@ -37,6 +37,7 @@
disable_break_(false),
break_on_exception_(false),
break_on_uncaught_exception_(false),
+ current_promise_catch_handler_(NULL),
debug_break_return_(NULL),
debug_break_slot_(NULL),
isolate_(isolate) {
@@ -1315,6 +1316,53 @@
return break_on_exception_;
}
}
+
+
+void Debug::PromiseHandlePrologue(Handle<JSFunction> promise_getter) {
+ ASSERT(current_promise_getter_.is_null());
+ current_promise_getter_ = Handle<JSFunction>::cast(
+ isolate_->global_handles()->Create(*promise_getter));
+ current_promise_catch_handler_ =
+
StackHandler::FromAddress(Isolate::handler(isolate_->thread_local_top()));
+}
+
+
+void Debug::PromiseHandleEpilogue() {
+ current_promise_catch_handler_ = NULL;
+ Handle<Object> promise_getter;
+ if (!current_promise_getter_.ToHandle(&promise_getter)) return;
+ isolate_->global_handles()->Destroy(promise_getter.location());
+ current_promise_getter_ = MaybeHandle<JSFunction>();
+}
+
+
+Handle<Object> Debug::GetPromiseForUncaughtException() {
+ Handle<JSFunction> promise_getter;
+ Handle<Object> undefined = isolate_->factory()->undefined_value();
+ if (current_promise_getter_.ToHandle(&promise_getter)) {
+ // Find the top-most try-catch handler.
+ StackHandler* handler = StackHandler::FromAddress(
+ Isolate::handler(isolate_->thread_local_top()));
+ while (handler != NULL && !handler->is_catch()) {
+ handler = handler->next();
+ }
+#ifdef DEBUG
+ // Make sure that our promise catch handler is in the list of handlers,
+ // even if it's not the top-most try-catch handler.
+ StackHandler* temp = handler;
+ while (temp != current_promise_catch_handler_ && !temp->is_catch()) {
+ temp = temp->next();
+ CHECK(temp != NULL);
+ }
+#endif // DEBUG
+
+ if (handler == current_promise_catch_handler_) {
+ return Execution::Call(
+ isolate_, promise_getter, undefined, 0, NULL).ToHandleChecked();
+ }
+ }
+ return undefined;
+}
void Debug::PrepareStep(StepAction step_action,
@@ -2640,9 +2688,7 @@
}
-void Debugger::OnException(Handle<Object> exception,
- bool uncaught,
- Handle<Object> promise) {
+void Debugger::OnException(Handle<Object> exception, bool uncaught) {
HandleScope scope(isolate_);
Debug* debug = isolate_->debug();
@@ -2650,6 +2696,9 @@
if (debug->InDebugger()) return;
if (!Debugger::EventActive(v8::Exception)) return;
+ Handle<Object> promise = debug->GetPromiseForUncaughtException();
+ uncaught |= !promise->IsUndefined();
+
// Bail out if exception breaks are not active
if (uncaught) {
// Uncaught exceptions are reported by either flags.
@@ -2667,10 +2716,6 @@
// Clear all current stepping setup.
debug->ClearStepping();
- // Determine event;
- DebugEvent event = promise->IsUndefined()
- ? v8::Exception : v8::PendingExceptionInPromise;
-
// Create the event data object.
Handle<Object> event_data;
// Bail out and don't call debugger if exception.
@@ -2680,7 +2725,7 @@
}
// Process debug event.
- ProcessDebugEvent(event, Handle<JSObject>::cast(event_data), false);
+ ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data),
false);
// Return to continue execution from where the exception was thrown.
}
@@ -3162,7 +3207,8 @@
void Debugger::ListenersChanged() {
- if (IsDebuggerActive()) {
+ bool active = IsDebuggerActive();
+ if (active) {
// Disable the compilation cache when the debugger is active.
isolate_->compilation_cache()->Disable();
debugger_unload_pending_ = false;
=======================================
--- /branches/bleeding_edge/src/debug.h Tue Apr 29 06:42:26 2014 UTC
+++ /branches/bleeding_edge/src/debug.h Wed Apr 30 14:17:40 2014 UTC
@@ -235,6 +235,12 @@
void FloodHandlerWithOneShot();
void ChangeBreakOnException(ExceptionBreakType type, bool enable);
bool IsBreakOnException(ExceptionBreakType type);
+
+ void PromiseHandlePrologue(Handle<JSFunction> promise_getter);
+ void PromiseHandleEpilogue();
+ // Returns a promise if it does not have a reject handler.
+ Handle<Object> GetPromiseForUncaughtException();
+
void PrepareStep(StepAction step_action,
int step_count,
StackFrame::Id frame_id);
@@ -541,6 +547,13 @@
bool break_on_exception_;
bool break_on_uncaught_exception_;
+ // When a promise is being resolved, we may want to trigger a debug
event for
+ // the case we catch a throw. For this purpose we remember the try-catch
+ // handler address that would catch the exception. We also hold onto a
+ // closure that returns a promise if the exception is considered
uncaught.
+ StackHandler* current_promise_catch_handler_;
+ MaybeHandle<JSFunction> current_promise_getter_;
+
// Per-thread data.
class ThreadLocal {
public:
@@ -777,9 +790,7 @@
MUST_USE_RESULT MaybeHandle<Object> MakeScriptCollectedEvent(int id);
void OnDebugBreak(Handle<Object> break_points_hit, bool auto_continue);
- void OnException(Handle<Object> exception,
- bool uncaught,
- Handle<Object> promise = Handle<Object>::null());
+ void OnException(Handle<Object> exception, bool uncaught);
void OnBeforeCompile(Handle<Script> script);
enum AfterCompileFlags {
=======================================
--- /branches/bleeding_edge/src/isolate.cc Wed Apr 30 09:50:58 2014 UTC
+++ /branches/bleeding_edge/src/isolate.cc Wed Apr 30 14:17:40 2014 UTC
@@ -1031,8 +1031,7 @@
// Notify debugger of exception.
if (catchable_by_javascript) {
- debugger_->OnException(
- exception_handle, report_exception, factory()->undefined_value());
+ debugger_->OnException(exception_handle, report_exception);
}
// Generate the message if required.
=======================================
--- /branches/bleeding_edge/src/mirror-debugger.js Tue Apr 29 06:42:26 2014
UTC
+++ /branches/bleeding_edge/src/mirror-debugger.js Wed Apr 30 14:17:40 2014
UTC
@@ -1186,7 +1186,7 @@
PromiseMirror.prototype.status = function() {
- var status = %GetPromiseStatus(this.value_);
+ var status = builtins.GetPromiseStatus(this.value_);
if (status == 0) return "pending";
if (status == 1) return "resolved";
return "rejected";
@@ -1194,7 +1194,7 @@
PromiseMirror.prototype.promiseValue = function() {
- return %GetPromiseValue(this.value_);
+ return builtins.GetPromiseValue(this.value_);
};
=======================================
--- /branches/bleeding_edge/src/promise.js Tue Apr 29 06:42:26 2014 UTC
+++ /branches/bleeding_edge/src/promise.js Wed Apr 30 14:17:40 2014 UTC
@@ -35,10 +35,13 @@
throw MakeTypeError('resolver_not_a_function', [resolver]);
var promise = PromiseInit(this);
try {
+ %DebugPromiseHandlePrologue(function() { return promise });
resolver(function(x) { PromiseResolve(promise, x) },
function(r) { PromiseReject(promise, r) });
} catch (e) {
PromiseReject(promise, e);
+ } finally {
+ %DebugPromiseHandleEpilogue();
}
}
@@ -161,6 +164,11 @@
function PromiseHandle(value, handler, deferred) {
try {
+ %DebugPromiseHandlePrologue(
+ function() {
+ var queue = GET_PRIVATE(deferred.promise, promiseOnReject);
+ return (queue && queue.length == 0) ? deferred.promise :
UNDEFINED;
+ });
var result = handler(value);
if (result === deferred.promise)
throw MakeTypeError('promise_cyclic', [result]);
@@ -169,21 +177,13 @@
else
deferred.resolve(result);
} catch (exception) {
- var uncaught = false;
- var reject_queue = GET_PRIVATE(deferred.promise, promiseOnReject);
- if (reject_queue && reject_queue.length == 0) {
- // The deferred promise may get a reject handler attached later.
- // For now, we consider the exception to be (for the moment)
uncaught.
- uncaught = true;
- }
try {
+ %DebugPromiseHandleEpilogue(); // Match the previous prologue.
+ %DebugPromiseHandlePrologue(function() { return deferred.promise });
deferred.reject(exception);
- } catch (e) {
- // The reject handler can only throw for a custom deferred promise.
- // We consider the original exception to be uncaught.
- uncaught = true;
- }
- if (uncaught) %DebugPendingExceptionInPromise(exception,
deferred.promise);
+ } catch (e) { }
+ } finally {
+ %DebugPromiseHandleEpilogue();
}
}
@@ -320,14 +320,6 @@
function GetPromiseStatus(promise) {
return GET_PRIVATE(promise, promiseStatus);
}
-
-function GetPromiseOnResolve(promise) {
- return GET_PRIVATE(promise, promiseOnResolve);
-}
-
-function GetPromiseOnReject(promise) {
- return GET_PRIVATE(promise, promiseOnReject);
-}
function GetPromiseValue(promise) {
return GET_PRIVATE(promise, promiseValue);
=======================================
--- /branches/bleeding_edge/src/runtime.cc Wed Apr 30 13:19:19 2014 UTC
+++ /branches/bleeding_edge/src/runtime.cc Wed Apr 30 14:17:40 2014 UTC
@@ -5657,13 +5657,22 @@
}
-// Notify the debugger if an expcetion in a promise is not caught (yet).
-RUNTIME_FUNCTION(Runtime_DebugPendingExceptionInPromise) {
- ASSERT(args.length() == 2);
+// The argument is a closure that is kept until the epilogue is called.
+// On exception, the closure is called, which returns the promise if the
+// exception is considered uncaught, or undefined otherwise.
+RUNTIME_FUNCTION(Runtime_DebugPromiseHandlePrologue) {
+ ASSERT(args.length() == 1);
HandleScope scope(isolate);
- CONVERT_ARG_HANDLE_CHECKED(Object, exception, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 1);
- isolate->debugger()->OnException(exception, true, promise);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, promise_getter, 0);
+ isolate->debug()->PromiseHandlePrologue(promise_getter);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugPromiseHandleEpilogue) {
+ ASSERT(args.length() == 0);
+ SealHandleScope shs(isolate);
+ isolate->debug()->PromiseHandleEpilogue();
return isolate->heap()->undefined_value();
}
=======================================
--- /branches/bleeding_edge/src/runtime.h Wed Apr 30 13:19:19 2014 UTC
+++ /branches/bleeding_edge/src/runtime.h Wed Apr 30 14:17:40 2014 UTC
@@ -75,7 +75,8 @@
F(SetInlineBuiltinFlag, 1, 1) \
F(StoreArrayLiteralElement, 5, 1) \
F(DebugPrepareStepInIfStepping, 1, 1) \
- F(DebugPendingExceptionInPromise, 2, 1) \
+ F(DebugPromiseHandlePrologue, 1, 1) \
+ F(DebugPromiseHandleEpilogue, 0, 1) \
F(FlattenString, 1, 1) \
F(LoadMutableDouble, 2, 1) \
F(TryMigrateInstance, 1, 1) \
=======================================
--- /branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-all.js
Fri Apr 25 07:03:05 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-all.js
Wed Apr 30 14:17:40 2014 UTC
@@ -6,8 +6,7 @@
// Test debug events when we listen to all exceptions and
// there is a catch handler for the exception thrown in a Promise.
-// Expectation:
-// - only the normal Exception debug event is triggered.
+// We expect a normal Exception debug event to be triggered.
Debug = debug.Debug;
@@ -35,10 +34,10 @@
// Ignore exceptions during startup in stress runs.
if (step >= 1) return;
assertEquals(["resolve", "end main", "throw"], log);
- assertTrue(event != Debug.DebugEvent.PendingExceptionInPromise);
if (event == Debug.DebugEvent.Exception) {
assertEquals("caught", event_data.exception().message);
assertEquals(undefined, event_data.promise());
+ assertFalse(event_data.uncaught());
step++;
}
} catch (e) {
=======================================
---
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-uncaught.js
Fri Apr 25 07:03:05 2014 UTC
+++
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-caught-uncaught.js
Wed Apr 30 14:17:40 2014 UTC
@@ -6,8 +6,7 @@
// Test debug events when we only listen to uncaught exceptions and
// there is a catch handler for the exception thrown in a Promise.
-// Expectation:
-// - no debug event is triggered.
+// We expect no debug event to be triggered.
Debug = debug.Debug;
@@ -28,7 +27,6 @@
function listener(event, exec_state, event_data, data) {
try {
assertTrue(event != Debug.DebugEvent.Exception);
- assertTrue(event != Debug.DebugEvent.PendingExceptionInPromise);
} catch (e) {
// Signal a failure with exit code 1. This is necessary since the
// debugger swallows exceptions and we expect the chained function
=======================================
---
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-throw-in-reject.js
Fri Apr 25 07:03:05 2014 UTC
+++
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-throw-in-reject.js
Wed Apr 30 14:17:40 2014 UTC
@@ -6,7 +6,7 @@
// 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 a PendingExceptionInPromise event to be triggered.
+// handler. We expect an Exception debug event with a promise to be
triggered.
Debug = debug.Debug;
@@ -21,7 +21,7 @@
function MyPromise(resolver) {
var reject = function() {
log.push("throw reject");
- throw new Error("reject");
+ throw new Error("reject"); // event
};
var resolve = function() { };
log.push("construct");
@@ -39,12 +39,12 @@
function listener(event, exec_state, event_data, data) {
try {
- if (event == Debug.DebugEvent.PendingExceptionInPromise) {
+ if (event == Debug.DebugEvent.Exception) {
assertEquals(["resolve", "construct", "end main",
"throw caught", "throw reject"], log);
- assertEquals("caught", event_data.exception().message);
- } else if (event == Debug.DebugEvent.Exception) {
- assertUnreachable();
+ assertEquals("reject", event_data.exception().message);
+ assertEquals(q, event_data.promise());
+ assertTrue(exec_state.frame(0).sourceLineText().indexOf('// event')
0);
}
} catch (e) {
// Signal a failure with exit code 1. This is necessary since the
=======================================
--- /branches/bleeding_edge/test/mjsunit/es6/debug-promises-uncaught-all.js
Fri Apr 25 07:03:05 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/es6/debug-promises-uncaught-all.js
Wed Apr 30 14:17:40 2014 UTC
@@ -6,10 +6,7 @@
// Test debug events when we listen to all exceptions and
// there is a catch handler for the exception thrown in a Promise.
-// Expectation:
-// - the normal Exception debug event is triggered.
-// - the PendingExceptionInPromise debug event is triggered afterwards,
-// with the same exception object.
+// We expect an Exception debug event with a promise to be triggered.
Debug = debug.Debug;
@@ -25,28 +22,24 @@
var q = p.chain(
function() {
log.push("throw");
- throw new Error("uncaught");
+ throw new Error("uncaught"); // event
});
function listener(event, exec_state, event_data, data) {
try {
// Ignore exceptions during startup in stress runs.
- if (step > 1) return;
+ if (step >= 1) return;
assertEquals(["resolve", "end main", "throw"], log);
if (event == Debug.DebugEvent.Exception) {
assertEquals(0, step);
- exception = event_data.exception();
- assertEquals(undefined, event_data.promise());
- } else if (event == Debug.DebugEvent.PendingExceptionInPromise) {
- assertEquals(1, step);
- assertEquals(exception, event_data.exception());
- assertEquals("uncaught", exception.message);
+ assertEquals("uncaught", event_data.exception().message);
assertTrue(event_data.promise() instanceof Promise);
+ assertEquals(q, event_data.promise());
assertTrue(event_data.uncaught());
- } else {
- return;
+ // Assert that the debug event is triggered at the throw site.
+ assertTrue(exec_state.frame(0).sourceLineText().indexOf("// event")
0);
+ step++;
}
- step++;
} catch (e) {
// Signal a failure with exit code 1. This is necessary since the
// debugger swallows exceptions and we expect the chained function
=======================================
---
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-uncaught-uncaught.js
Fri Apr 25 07:03:05 2014 UTC
+++
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-uncaught-uncaught.js
Wed Apr 30 14:17:40 2014 UTC
@@ -6,8 +6,7 @@
// Test debug events when we only listen to uncaught exceptions and
// there is a catch handler for the exception thrown in a Promise.
-// Expectation:
-// - only the PendingExceptionInPromise debug event is triggered.
+// We expect an Exception debug event with a promise to be triggered.
Debug = debug.Debug;
@@ -22,7 +21,7 @@
var q = p.chain(
function() {
log.push("throw");
- throw new Error("uncaught");
+ throw new Error("uncaught"); // event
});
function listener(event, exec_state, event_data, data) {
@@ -31,12 +30,13 @@
if (step >= 1) return;
assertEquals(["resolve", "end main", "throw"], log);
if (event == Debug.DebugEvent.Exception) {
- assertUnreachable();
- } else if (event == Debug.DebugEvent.PendingExceptionInPromise) {
assertEquals(0, step);
assertEquals("uncaught", event_data.exception().message);
assertTrue(event_data.promise() instanceof Promise);
+ assertEquals(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);
step++;
}
} catch (e) {
=======================================
---
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-undefined-reject.js
Fri Apr 25 07:03:05 2014 UTC
+++
/branches/bleeding_edge/test/mjsunit/es6/debug-promises-undefined-reject.js
Wed Apr 30 14:17:40 2014 UTC
@@ -6,7 +6,7 @@
// 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 a PendingExceptionInPromise event to be triggered.
+// We expect an Exception event with a promise to be triggered.
Debug = debug.Debug;
@@ -31,16 +31,16 @@
var q = p.chain(
function() {
log.push("throw caught");
- throw new Error("caught");
+ throw new Error("caught"); // event
});
function listener(event, exec_state, event_data, data) {
try {
- if (event == Debug.DebugEvent.PendingExceptionInPromise) {
+ if (event == Debug.DebugEvent.Exception) {
assertEquals(["resolve", "construct", "end main", "throw caught"],
log);
- assertEquals("caught", event_data.exception().message);
- } else if (event == Debug.DebugEvent.Exception) {
- assertUnreachable();
+ assertEquals("undefined is not a function",
+ event_data.exception().message);
+ assertEquals(q, event_data.promise());
}
} catch (e) {
// Signal a failure with exit code 1. This is necessary since the
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
