- Remove the legacy debug protocol.

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
-#include "platform/json.h"
+#include "platform/text_buffer.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/lockers.h"
 #include "vm/unit_test.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
@@ skipping 7048 matching lines @@
 static Dart_Isolate RunLoopTestCallback(const char* script_name,
                                         const char* main,
                                         const char* package_root,
                                         const char** package_map,
                                         Dart_IsolateFlags* flags,
                                         void* data,
                                         char** error) {
   const char* kScriptChars =
       "import 'builtin';\n"
       "import 'dart:isolate';\n"
-      "void entry(message) {\n"
-      "  var data = message[0];\n"
-      "  var replyTo = message[1];\n"
-      "  if (data) {\n"
-      "    throw new Exception('MakeChildExit');\n"
-      "  } else {\n"
-      "    replyTo.send('hello');\n"
-      "  }\n"
-      "}\n"
-      "\n"
-      "void main(exc_child, exc_parent) {\n"
-      "  var receivePort = new RawReceivePort();\n"
-      "  Isolate.spawn(entry, [exc_child, receivePort.sendPort]);\n"
-      "  receivePort.handler = (message) {\n"
-      "    receivePort.close();\n"
-      "    if (message != 'hello') throw new Exception('ShouldNotHappen');\n"
-      "    if (exc_parent) throw new Exception('MakeParentExit');\n"
+      "void main(exception) {\n"

[rmacnak, 2015/12/04 00:41:24]

bool throwException

[Ivan Posva, 2015/12/04 01:44:57]

Done.

+      "  var rp = new RawReceivePort();\n"
+      "  rp.handler = (msg) {\n"
+      "    rp.close();\n"
+      "    if (exception) {\n"
+      "      throw new Exception('ExceptionFromTimer');\n"
+      "    }\n"
       "  };\n"
+      "  rp.sendPort.send(1);\n"
       "}\n";
 
   if (Dart_CurrentIsolate() != NULL) {
     Dart_ExitIsolate();
   }
   Dart_Isolate isolate = TestCase::CreateTestIsolate(script_name);
   ASSERT(isolate != NULL);
   if (Dart_IsServiceIsolate(isolate)) {
     return isolate;
   }
   Dart_EnterScope();
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   Dart_Handle result = Dart_SetLibraryTagHandler(TestCase::library_handler);
   EXPECT_VALID(result);
   Dart_Handle lib = Dart_LoadScript(url, source, 0, 0);
   EXPECT_VALID(lib);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   EXPECT(retval);
   return isolate;
 }
 
 
-// The error string from the last unhandled exception. This value is only
-// valid until the next Dart_ExitScope().
-static char* last_exception = NULL;
-
-
-static void RunLoopUnhandledExceptionCallback(Dart_Handle exception) {
-  Dart_Handle error_string = Dart_ToString(exception);
-  EXPECT_VALID(error_string);
-  const char* error_text;
-  Dart_Handle result = Dart_StringToCString(error_string, &error_text);
-  // Duplicate the string since error text is freed when callback is finished.
-  last_exception = strdup(error_text);
-  EXPECT_VALID(result);
-}
-
-
 // Common code for RunLoop_Success/RunLoop_Failure.
-static void RunLoopTest(bool throw_exception_child,
-                        bool throw_exception_parent) {
+static void RunLoopTest(bool throw_exception) {
   Dart_IsolateCreateCallback saved = Isolate::CreateCallback();
   Isolate::SetCreateCallback(RunLoopTestCallback);
-  Isolate::SetUnhandledExceptionCallback(RunLoopUnhandledExceptionCallback);
   Dart_Isolate isolate = RunLoopTestCallback(
       NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 
   Dart_EnterIsolate(isolate);
   Dart_EnterScope();
   Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
   EXPECT_VALID(lib);
 
   Dart_Handle result;
-  Dart_Handle args[2];
-  args[0] = (throw_exception_child ? Dart_True() : Dart_False());
-  args[1] = (throw_exception_parent ? Dart_True() : Dart_False());
-  result = Dart_Invoke(lib, NewString("main"), 2, args);
+  Dart_Handle args[1];
+  args[0] = (throw_exception ? Dart_True() : Dart_False());
+  result = Dart_Invoke(lib, NewString("main"), 1, args);
   EXPECT_VALID(result);
-  if (throw_exception_child) {
-    // TODO(tball): fix race-condition
-    // EXPECT_NOTNULL(last_exception);
-    // EXPECT_STREQ("UnhandledException", last_exception);
+  result = Dart_RunLoop();
+  if (throw_exception) {
+    EXPECT_ERROR(result, "Exception: ExceptionFromTimer");
   } else {
-    result = Dart_RunLoop();
-    if (throw_exception_parent) {
-      EXPECT_ERROR(result, "Exception: MakeParentExit");
-      EXPECT_NOTNULL(last_exception);
-      EXPECT_STREQ("UnhandledException", last_exception);
-    } else {
-      EXPECT_VALID(result);
-      EXPECT(last_exception == NULL);
-    }
-  }
-  if (last_exception != NULL) {
-    free(last_exception);
-    last_exception = NULL;
+    EXPECT_VALID(result);
   }
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   Isolate::SetCreateCallback(saved);
 }
 
 
 UNIT_TEST_CASE(RunLoop_Success) {
-  RunLoopTest(false, false);
+  RunLoopTest(false);
 }
 
 
-// This test exits the vm.  Listed as FAIL in vm.status.
-UNIT_TEST_CASE(RunLoop_ExceptionChild) {
-  RunLoopTest(true, false);
+UNIT_TEST_CASE(RunLoop_Exception) {
+  RunLoopTest(true);
 }
 
 
-UNIT_TEST_CASE(RunLoop_ExceptionParent) {
-  RunLoopTest(false, true);
-}
-
-
 // Utility functions and variables for test case IsolateInterrupt starts here.
 static Monitor* sync = NULL;
 static Dart_Isolate shared_isolate = NULL;
 static bool main_entered = false;
 
 
 void MarkMainEntered(Dart_NativeArguments args) {
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
   // Indicate that main has been entered.
   {
@@ skipping 63 matching lines @@
 
   // Tell the other thread that we are done.
   {
     MonitorLocker ml(sync);
     shared_isolate = NULL;
     ml.Notify();
   }
 }
 
 
-// This callback handles isolate interrupts for the IsolateInterrupt
-// test.  It ignores the first two interrupts and throws an exception
-// on the third interrupt.
-const int kInterruptCount = 10;
-static int interrupt_count = 0;
-static bool IsolateInterruptTestCallback() {
-  OS::Print(" ========== Interrupt callback called #%d\n", interrupt_count + 1);
-  {
-    MonitorLocker ml(sync);
-    interrupt_count++;
-    ml.Notify();
-  }
-  if (interrupt_count == kInterruptCount) {
-    Dart_EnterScope();
-    Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
-    EXPECT_VALID(lib);
-    Dart_Handle exc = NewString("foo");
-    EXPECT_VALID(exc);
-    Dart_Handle result = Dart_ThrowException(exc);
-    EXPECT_VALID(result);
-    UNREACHABLE();  // Dart_ThrowException only returns if it gets an error.
-    return false;
-  }
-  ASSERT(interrupt_count < kInterruptCount);
-  return true;
-}
-
-
-TEST_CASE(IsolateInterrupt) {
-  Dart_IsolateInterruptCallback saved = Isolate::InterruptCallback();
-  Isolate::SetInterruptCallback(IsolateInterruptTestCallback);
-
-  sync = new Monitor();
-  int result = OSThread::Start("IsolateInterrupt", BusyLoop_start, 0);
-  EXPECT_EQ(0, result);
-
-  {
-    MonitorLocker ml(sync);
-    // Wait for the other isolate to enter main.
-    while (!main_entered) {
-      ml.Wait();
-    }
-  }
-
-  // Send a number of interrupts to the other isolate. All but the
-  // last allow execution to continue. The last causes an exception in
-  // the isolate.
-  for (int i = 0; i < kInterruptCount; i++) {
-    // Space out the interrupts a bit.
-    OS::Sleep(i + 1);
-    Dart_InterruptIsolate(shared_isolate);
-    {
-      MonitorLocker ml(sync);
-      // Wait for interrupt_count to be increased.
-      while (interrupt_count == i) {
-        ml.Wait();
-      }
-      OS::Print(" ========== Interrupt processed #%d\n", interrupt_count);
-    }
-  }
-
-  {
-    MonitorLocker ml(sync);
-    // Wait for our isolate to finish.
-    while (shared_isolate != NULL) {
-      ml.Wait();
-    }
-  }
-
-  // We should have received the expected number of interrupts.
-  EXPECT_EQ(kInterruptCount, interrupt_count);
-
-  Isolate::SetInterruptCallback(saved);
-}
-
 static void* saved_callback_data;
 static void IsolateShutdownTestCallback(void* callback_data) {
   saved_callback_data = callback_data;
 }
 
 UNIT_TEST_CASE(IsolateShutdown) {
   Dart_IsolateShutdownCallback saved = Isolate::ShutdownCallback();
   Isolate::SetShutdownCallback(IsolateShutdownTestCallback);
 
   saved_callback_data = NULL;
@@ skipping 2121 matching lines @@
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Heartbeat test for new events.
   EXPECT_SUBSTRING("\"name\":\"TestVMDuration2\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_bar\"", buffer);
 }
 
 }  // namespace dart