Hide Isolate pointer from embedder

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_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
@@ skipping 3656 matching lines @@
     EXPECT_EQ(1600, state->ZoneSizeInBytes());
     Dart_ExitScope();
   }
   EXPECT_EQ(0, state->ZoneSizeInBytes());
   EXPECT(scope == state->top_scope());
   Dart_ShutdownIsolate();
 }
 
 
 UNIT_TEST_CASE(Isolates) {
-  // This test currently assumes that the Dart_Isolate type is an opaque
-  // representation of Isolate*.
   Dart_Isolate iso_1 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_1, Api::CastIsolate(Isolate::Current()));
   Dart_Isolate isolate = Dart_CurrentIsolate();
   EXPECT_EQ(iso_1, isolate);
   Dart_ExitIsolate();
-  EXPECT(NULL == Dart_CurrentIsolate());
+  EXPECT(DART_ILLEGAL_ISOLATE == Dart_CurrentIsolate());
+  // Test that Dart_EnterIsolate returns an error when passed a bad isolate id.
+  EXPECT(!Dart_EnterIsolate(DART_ILLEGAL_ISOLATE));
   Dart_Isolate iso_2 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_2, Dart_CurrentIsolate());
   Dart_ExitIsolate();
-  EXPECT(NULL == Dart_CurrentIsolate());
+  EXPECT(DART_ILLEGAL_ISOLATE == Dart_CurrentIsolate());
   Dart_EnterIsolate(iso_2);
   EXPECT_EQ(iso_2, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
-  EXPECT(NULL == Dart_CurrentIsolate());
+  EXPECT(DART_ILLEGAL_ISOLATE == Dart_CurrentIsolate());
   Dart_EnterIsolate(iso_1);
   EXPECT_EQ(iso_1, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
-  EXPECT(NULL == Dart_CurrentIsolate());
+  EXPECT(DART_ILLEGAL_ISOLATE == Dart_CurrentIsolate());
 }
 
 
 UNIT_TEST_CASE(CurrentIsolateData) {
   intptr_t mydata = 12345;
   char* err;
+  // We expect that Dart_Port and Dart_Isolate are the same size.
+  EXPECT_EQ(sizeof(Dart_Port), sizeof(Dart_Isolate));
   Dart_Isolate isolate =
       Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer,
                          reinterpret_cast<void*>(mydata),
                          &err);
-  EXPECT(isolate != NULL);
+  EXPECT(isolate != DART_ILLEGAL_ISOLATE);
   EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateData()));
   EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_IsolateData(isolate)));
   Dart_ShutdownIsolate();
+  EXPECT(Dart_IsolateData(DART_ILLEGAL_ISOLATE) == NULL);
 }
 
 
 TEST_CASE(IsolateSetCheckedMode) {
   const char* kScriptChars =
       "int bad1() {\n"
       "  int foo = 'string';\n"
       "  return foo;\n"
       "}\n"
       "\n"
@@ skipping 28 matching lines @@
 }
 
 
 static void MyMessageNotifyCallback(Dart_Isolate dest_isolate) {
 }
 
 
 UNIT_TEST_CASE(SetMessageCallbacks) {
   Dart_Isolate dart_isolate = TestCase::CreateTestIsolate();
   Dart_SetMessageNotifyCallback(&MyMessageNotifyCallback);
-  Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
+  Isolate* isolate = Api::CastIsolate(dart_isolate);
   EXPECT_EQ(&MyMessageNotifyCallback, isolate->message_notify_callback());
   Dart_ShutdownIsolate();
 }
 
 
 TEST_CASE(TypeGetNonParamtericTypes) {
   const char* kScriptChars =
       "class MyClass0 {\n"
       "}\n"
       "\n"
@@ skipping 3447 matching lines @@
   Dart_CObject* response =
       reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(sizeof(Dart_CObject)));
   response->type = Dart_CObject_kInt32;
   response->value.as_int32 = 321;
   Dart_PostCObject(
       message->value.as_array.values[0]->value.as_send_port.id, response);
 }
 
 
 TEST_CASE(IllegalNewSendPort) {
-  Dart_Handle error = Dart_NewSendPort(ILLEGAL_PORT);
+  Dart_Handle error = Dart_NewSendPort(DART_ILLEGAL_PORT);
   EXPECT(Dart_IsError(error));
   EXPECT(Dart_IsApiError(error));
 }
 
 
 TEST_CASE(IllegalPost) {
   Dart_Handle message = Dart_True();
-  bool success = Dart_Post(ILLEGAL_PORT, message);
+  bool success = Dart_Post(DART_ILLEGAL_PORT, message);
   EXPECT(!success);
 }
 
 
 UNIT_TEST_CASE(NewNativePort) {
   // Create a port with a bogus handler.
   Dart_Port error_port = Dart_NewNativePort("Foo", NULL, true);
-  EXPECT_EQ(ILLEGAL_PORT, error_port);
+  EXPECT_EQ(DART_ILLEGAL_PORT, error_port);
 
   // Create the port w/o a current isolate, just to make sure that works.
   Dart_Port port_id1 =
       Dart_NewNativePort("Port123", NewNativePort_send123, true);
 
   TestIsolateScope __test_isolate__;
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       "void callPort(SendPort port) {\n"
       "  var receivePort = new RawReceivePort();\n"
@@ skipping 65 matching lines @@
       "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"
       "  };\n"
       "}\n";
 
-  if (Dart_CurrentIsolate() != NULL) {
+  if (Dart_CurrentIsolate() != DART_ILLEGAL_ISOLATE) {
     Dart_ExitIsolate();
   }
   Dart_Isolate isolate = TestCase::CreateTestIsolate(script_name);
-  ASSERT(isolate != NULL);
+  ASSERT(isolate != DART_ILLEGAL_ISOLATE);
   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);
@@ skipping 125 matching lines @@
       "}\n";
 
   // Tell the other thread that shared_isolate is created.
   Dart_Handle lib;
   {
     MonitorLocker ml(sync);
     char* error = NULL;
     shared_isolate = Dart_CreateIsolate(NULL, NULL,
                                         bin::isolate_snapshot_buffer,
                                         NULL, &error);
-    EXPECT(shared_isolate != NULL);
+    EXPECT(shared_isolate != DART_ILLEGAL_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);
     lib = Dart_LoadScript(url, source, 0, 0);
     EXPECT_VALID(lib);
     result = Dart_FinalizeLoading(false);
     EXPECT_VALID(result);
     result =
@@ skipping 58 matching lines @@
   EXPECT_EQ(0, result);
 
   {
     MonitorLocker ml(sync);
     // Wait for the other isolate to enter main.
     while (!main_entered) {
       ml.Wait();
     }
   }
 
+  // Test that Dart_InterruptIsolate returns false when passed an illegal
+  // isolate.
+  EXPECT(!Dart_InterruptIsolate(DART_ILLEGAL_ISOLATE));
+
   // 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) {
+    while (shared_isolate != DART_ILLEGAL_ISOLATE) {
       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;
 
   void* my_data = reinterpret_cast<void*>(12345);
 
   // Create an isolate.
   char* err;
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL,
                                             bin::isolate_snapshot_buffer,
                                             my_data, &err);
-  if (isolate == NULL) {
+  if (isolate == DART_ILLEGAL_ISOLATE) {
     OS::Print("Creation of isolate failed '%s'\n", err);
     free(err);
   }
-  EXPECT(isolate != NULL);
+  EXPECT(isolate != DART_ILLEGAL_ISOLATE);
 
   // The shutdown callback has not been called.
   EXPECT_EQ(0, reinterpret_cast<intptr_t>(saved_callback_data));
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // The shutdown callback has been called.
   EXPECT_EQ(12345, reinterpret_cast<intptr_t>(saved_callback_data));
 
@@ skipping 25 matching lines @@
       "\n"
       "void main() {\n"
       "  add(4, 5);\n"
       "}\n";
 
   // Create an isolate.
   char* err;
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL,
                                             bin::isolate_snapshot_buffer,
                                             NULL, &err);
-  if (isolate == NULL) {
+  if (isolate == DART_ILLEGAL_ISOLATE) {
     OS::Print("Creation of isolate failed '%s'\n", err);
     free(err);
   }
-  EXPECT(isolate != NULL);
+  EXPECT(isolate != DART_ILLEGAL_ISOLATE);
 
   Isolate::SetShutdownCallback(IsolateShutdownRunDartCodeTestCallback);
 
   {
     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);
     result = Dart_Invoke(lib, NewString("main"), 0, NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
 
 
   // The shutdown callback has not been called.
   EXPECT_EQ(0, add_result);
 
-  EXPECT(isolate != NULL);
+  EXPECT(isolate != DART_ILLEGAL_ISOLATE);
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // The shutdown callback has been called and ran Dart code.
   EXPECT_EQ(99, add_result);
 }
 
 static int64_t GetValue(Dart_Handle arg) {
   EXPECT_VALID(arg);
@@ skipping 1436 matching lines @@
     result = Dart_Invoke(lib,
                          NewString("testView16"),
                          1,
                          dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
   }
 }
 
 }  // namespace dart