Add a mid-sized integration test for the Dart Embedding Api which

runtime/vm/port_test.cc

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/message_queue.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 
+// Intercept the create port callback and remember which port was created.
+static Dart_Port saved_create_port = 0;
+static void MyCreatePortCallback(Dart_Isolate dart_isolate,
+                                 Dart_Port port) {
+  saved_create_port = port;
+}
+
 // Intercept the post message callback and just store a copy of the message.
 static const int kMaxSavedMsg = 80;
 static char saved_msg[kMaxSavedMsg];
 static bool MyPostMessageCallback(Dart_Isolate dest_isolate,
                                   Dart_Port dest_port,
                                   Dart_Port reply_port,
                                   Dart_Message dart_message) {
   const char* msg = reinterpret_cast<char*>(dart_message);
   OS::SNPrint(saved_msg, kMaxSavedMsg, "%s", msg);
   bool result = (strcmp(msg, "fail") != 0);
   free(dart_message);
   return result;
 }
 
 
 // Intercept the close port callback and remember which port was closed.
-static Dart_Port saved_port = 0;
+static Dart_Port saved_close_port = 0;
 static void MyClosePortCallback(Dart_Isolate dart_isolate,
                                 Dart_Port port) {
-  saved_port = port;
+  saved_close_port = port;
 }
 
 
 static void InitPortMapTest() {
-  Dart_SetMessageCallbacks(&MyPostMessageCallback, &MyClosePortCallback);
-  saved_port = 0;
+  Dart_SetMessageCallbacks(
+      &MyCreatePortCallback, &MyPostMessageCallback, &MyClosePortCallback);
+  saved_create_port = 0;
+  saved_close_port = 0;
   saved_msg[0] = '\0';
 }
 
 
 TEST_CASE(PortMap_CreateAndCloseOnePort) {
   InitPortMapTest();
   intptr_t port = PortMap::CreatePort();
   EXPECT_NE(0, port);
   EXPECT(PortMap::IsActivePort(port));
 
+  // Embedder was notified of port creation.
+  EXPECT_EQ(port, saved_create_port);
+
   PortMap::ClosePort(port);
   EXPECT(!PortMap::IsActivePort(port));
 
   // Embedder was notified of port closure.
-  EXPECT_EQ(port, saved_port);
+  EXPECT_EQ(port, saved_close_port);
 }
 
 
 TEST_CASE(PortMap_CreateAndCloseTwoPorts) {
   InitPortMapTest();
   Dart_Port port1 = PortMap::CreatePort();
   Dart_Port port2 = PortMap::CreatePort();
   EXPECT(PortMap::IsActivePort(port1));
   EXPECT(PortMap::IsActivePort(port2));
 
   // Uniqueness.
   EXPECT_NE(port1, port2);
 
   PortMap::ClosePort(port1);
   EXPECT(!PortMap::IsActivePort(port1));
   EXPECT(PortMap::IsActivePort(port2));
-  EXPECT_EQ(port1, saved_port);
+  EXPECT_EQ(port1, saved_close_port);
 
   PortMap::ClosePort(port2);
   EXPECT(!PortMap::IsActivePort(port1));
   EXPECT(!PortMap::IsActivePort(port2));
-  EXPECT_EQ(port2, saved_port);
+  EXPECT_EQ(port2, saved_close_port);
 }
 
 
 TEST_CASE(PortMap_ClosePorts) {
   InitPortMapTest();
   Dart_Port port1 = PortMap::CreatePort();
   Dart_Port port2 = PortMap::CreatePort();
   EXPECT(PortMap::IsActivePort(port1));
   EXPECT(PortMap::IsActivePort(port2));
 
   // Close all ports at once.
   PortMap::ClosePorts();
   EXPECT(!PortMap::IsActivePort(port1));
   EXPECT(!PortMap::IsActivePort(port2));
 
   // Embedder is notified to close all ports as well.
-  EXPECT_EQ(kCloseAllPorts, saved_port);
+  EXPECT_EQ(kCloseAllPorts, saved_close_port);
 }
 
 
 TEST_CASE(PortMap_CreateManyPorts) {
   InitPortMapTest();
   for (int i = 0; i < 32; i++) {
     Dart_Port port = PortMap::CreatePort();
     EXPECT(PortMap::IsActivePort(port));
     PortMap::ClosePort(port);
     EXPECT(!PortMap::IsActivePort(port));
@@ skipping 121 matching lines @@
   // Give the spawned thread enough time to properly exit.
   Monitor* waiter = new Monitor();
   {
     MonitorLocker ml(waiter);
     ml.Wait(20);
   }
   delete waiter;
 }
 
 }  // namespace dart