Allow embedders to provide custom message delivery for an isolate.

runtime/vm/message_queue_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/port.h"
+#include "vm/message_queue.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
-TEST_CASE(Port) {
-  const char* msg_data = "Hallo Velo!";
-
-  intptr_t port1 = PortMap::CreatePort();
-  intptr_t port2 = PortMap::CreatePort();
-  EXPECT(port1 != port2);
-
-  PortMessage* msg1 = new PortMessage(port1, 0, strdup(msg_data));
-  EXPECT_EQ(true, PortMap::PostMessage(msg1));
-  PortMessage* msg = PortMap::ReceiveMessage(10);
-  EXPECT_EQ(port1, msg->dest_id());
-  EXPECT_EQ(msg1, msg);
+
+// Provide access to private members of MessageQueue for testing.
+class MessageQueueTestPeer {
+ public:
+  explicit MessageQueueTestPeer(MessageQueue* queue) : queue_(queue) {}
+
+  bool HasMessage() const { return queue_->head_ != NULL; }
+
+ private:
+  MessageQueue* queue_;
+};
+
+
+TEST_CASE(MessageQueue_BasicOperations) {
+  MessageQueue queue;
+  MessageQueueTestPeer queue_peer(&queue);
+  EXPECT(!queue_peer.HasMessage());
+
+  Dart_Port port = 1;
+
+  // Add two messages.
+  PortMessage* msg1 = new PortMessage(port, 0, strdup("msg1"));
+  queue.Enqueue(msg1);
+  EXPECT(queue_peer.HasMessage());
+
+  PortMessage* msg2 = new PortMessage(port, 0, strdup("msg2"));
+  queue.Enqueue(msg2);
+  EXPECT(queue_peer.HasMessage());
+
+  // Remove two messages.
+  PortMessage* msg = queue.Dequeue(0);
+  EXPECT(msg != NULL);
+  EXPECT_STREQ("msg1", reinterpret_cast<char*>(msg->data()));
+  EXPECT(queue_peer.HasMessage());
+
+  msg = queue.Dequeue(0);
+  EXPECT(msg != NULL);
+  EXPECT_STREQ("msg2", reinterpret_cast<char*>(msg->data()));
+  EXPECT(!queue_peer.HasMessage());
+
   delete msg1;
-
-  msg1 = new PortMessage(port2, 0, strdup(msg_data));
-  EXPECT_EQ(true, PortMap::PostMessage(msg1));
-  msg = PortMap::ReceiveMessage(10);
-  EXPECT_EQ(port2, msg->dest_id());
-  EXPECT_EQ(msg1, msg);
-  delete msg1;
-
-  PortMap::ClosePort(port1);
-  EXPECT_EQ(false, PortMap::IsActivePort(port1));
-  msg1 = new PortMessage(port1, 0, strdup(msg_data));
-  EXPECT_EQ(false, PortMap::PostMessage(msg1));
-  delete msg1;
-  EXPECT(PortMap::ReceiveMessage(10) == NULL);
-
-  EXPECT_EQ(true, PortMap::IsActivePort(port2));
-  msg1 = new PortMessage(port2, 0, strdup(msg_data));
-  EXPECT_EQ(true, PortMap::PostMessage(msg1));
-  PortMap::ClosePort(port2);
-  EXPECT(PortMap::ReceiveMessage(10) == NULL);
-
-  for (int i = 0; i < 32; i++) {
-    intptr_t port = PortMap::CreatePort();
-    PortMap::ClosePort(port);
-  }
-}
-
-
-// End-of-test marker.
-static const intptr_t kEOT = 0xFFFF;
-
-void* AllocIntData(intptr_t payload) {
-  intptr_t* result = reinterpret_cast<intptr_t*>(malloc(sizeof(payload)));
-  *result = payload;
-  return result;
-}
-
-
-intptr_t GetIntData(void* data) {
-  return *reinterpret_cast<intptr_t*>(data);
-}
-
-
-void ThreadedPort_start(uword parameter) {
+  delete msg2;
+}
+
+
+// A thread which receives an expected sequence of messages.
+static Monitor* sync = NULL;
+static MessageQueue* shared_queue = NULL;
+void MessageReceiver_start(uword unused) {
+  // We only need an isolate here because the MonitorLocker in the
+  // MessageQueue expects it.
   Dart::CreateIsolate(NULL, NULL);
 
-  intptr_t remote = parameter;
-  intptr_t local = PortMap::CreatePort();
-
-  PortMap::PostMessage(new PortMessage(remote, 0, AllocIntData(local)));
-
-  intptr_t count = 0;
-  while (true) {
-    PortMessage* msg = PortMap::ReceiveMessage(0);
-    EXPECT_EQ(local, msg->dest_id());
+  // Create a message queue and share it.
+  MessageQueue* queue = new MessageQueue();
+  shared_queue = queue;
+
+  // Tell the other thread to fill the queue a bit.
+  {
+    MonitorLocker ml(sync);
+    ml.Notify();
+  }
+
+  // Wait for the other thread to fill the queue a bit.
+  {
+    MonitorLocker ml(sync);
+    ml.Wait(0);
+  }
+
+  for (int i = 0; i < 3; i++) {
+    PortMessage* msg = queue->Dequeue(0);
     EXPECT(msg != NULL);
-    if (GetIntData(msg->data()) == kEOT) {
-      break;
-    }
-    EXPECT(GetIntData(msg->data()) == count);
+    EXPECT_EQ(i+10, msg->dest_port());
+    EXPECT_EQ(i+100, msg->reply_port());
+    EXPECT_EQ(i+1000, *(reinterpret_cast<int*>(msg->data())));
     delete msg;
-    PortMap::PostMessage(new PortMessage(remote, 0, AllocIntData(count * 2)));
-    count++;
-  }
-  PortMap::PostMessage(new PortMessage(remote, 0, AllocIntData(kEOT)));
-
+  }
+  for (int i = 0; i < 3; i++) {
+    PortMessage* msg = queue->Dequeue(0);
+    EXPECT(msg != NULL);
+    EXPECT_EQ(i+20, msg->dest_port());
+    EXPECT_EQ(i+200, msg->reply_port());
+    EXPECT_EQ(i+2000, *(reinterpret_cast<int*>(msg->data())));
+    delete msg;
+  }
+  shared_queue = NULL;
+  delete queue;
   Dart::ShutdownIsolate();
 }
 
 
-TEST_CASE(ThreadedPort) {
-  intptr_t local = PortMap::CreatePort();
-
-  Thread* thr = new Thread(ThreadedPort_start, local);
-  EXPECT(thr != NULL);
-
-  PortMessage* msg = PortMap::ReceiveMessage(0);
-  EXPECT_EQ(local, msg->dest_id());
+TEST_CASE(MessageQueue_WaitNotify) {
+  Thread* thread = new Thread(MessageReceiver_start, 0);
+  EXPECT(thread != NULL);
+
+  // Wait for the shared queue to be created.
+  sync = new Monitor();
+  {
+    MonitorLocker ml(sync);
+    ml.Wait(0);
+  }
+  ASSERT(shared_queue != NULL);
+
+  // Pile up three messages before the other thread runs.
+  for (int i = 0; i < 3; i++) {
+    int* data = reinterpret_cast<int*>(malloc(sizeof(*data)));
+    *data = i+1000;
+    PortMessage* msg = new PortMessage(i+10, i+100, data);
+    shared_queue->Enqueue(msg);
+  }
+
+  // Wake the other thread and have it start consuming messages.
+  {
+    MonitorLocker ml(sync);
+    ml.Notify();
+  }
+
+  // Add a few more messages after sleeping to allow the other thread
+  // to potentially exercise the blocking code path in Dequeue.
+  OS::Sleep(5);
+  for (int i = 0; i < 3; i++) {
+    int* data = reinterpret_cast<int*>(malloc(sizeof(*data)));
+    *data = i+2000;
+    PortMessage* msg = new PortMessage(i+20, i+200, data);
+    shared_queue->Enqueue(msg);
+  }
+
+  sync = NULL;
+  delete sync;
+}
+
+
+TEST_CASE(MessageQueue_FlushAll) {
+  MessageQueue queue;
+  MessageQueueTestPeer queue_peer(&queue);
+  Dart_Port port1 = 1;
+  Dart_Port port2 = 2;
+
+  // Add two messages.
+  PortMessage* msg1 = new PortMessage(port1, 0, strdup("msg1"));
+  queue.Enqueue(msg1);
+  PortMessage* msg2 = new PortMessage(port2, 0, strdup("msg2"));
+  queue.Enqueue(msg2);
+
+  EXPECT(queue_peer.HasMessage());
+  queue.FlushAll();
+  EXPECT(!queue_peer.HasMessage());
+
+  // msg1 and msg2 already delete by FlushAll.
+}
+
+
+TEST_CASE(MessageQueue_Flush) {
+  MessageQueue queue;
+  MessageQueueTestPeer queue_peer(&queue);
+  Dart_Port port1 = 1;
+  Dart_Port port2 = 2;
+
+  // Add two messages on different ports.
+  PortMessage* msg1 = new PortMessage(port1, 0, strdup("msg1"));
+  queue.Enqueue(msg1);
+  PortMessage* msg2 = new PortMessage(port2, 0, strdup("msg2"));
+  queue.Enqueue(msg2);
+  EXPECT(queue_peer.HasMessage());
+
+  queue.Flush(port1);
+
+  // One message is left in the queue.
+  EXPECT(queue_peer.HasMessage());
+  PortMessage* msg = queue.Dequeue(0);
   EXPECT(msg != NULL);
-  intptr_t remote = GetIntData(msg->data());  // Get the remote port.
-  delete msg;
-
-  for (intptr_t i = 0; i < 10; i++) {
-    PortMap::PostMessage(new PortMessage(remote, 0, AllocIntData(i)));
-    PortMessage* msg = PortMap::ReceiveMessage(0);
-    EXPECT_EQ(local, msg->dest_id());
-    EXPECT(msg != NULL);
-    EXPECT_EQ(i * 2, GetIntData(msg->data()));
-    delete msg;
-  }
-
-  PortMap::PostMessage(new PortMessage(remote, 0, AllocIntData(kEOT)));
-  msg = PortMap::ReceiveMessage(0);
-  EXPECT_EQ(local, msg->dest_id());
-  EXPECT(msg != NULL);
-  EXPECT_EQ(kEOT, GetIntData(msg->data()));
-  delete msg;
-
-  // Give the spawned thread enough time to properly exit.
-  Monitor* waiter = new Monitor();
-  {
-    MonitorLocker ml(waiter);
-    ml.Wait(20);
-  }
-  delete waiter;
-}
+  EXPECT_STREQ("msg2", reinterpret_cast<char*>(msg->data()));
+
+  EXPECT(!queue_peer.HasMessage());
+
+  // msg1 is already deleted by Flush.
+  delete msg2;
+}
+
+
+TEST_CASE(MessageQueue_Flush_MultipleMessages) {
+  MessageQueue queue;
+  MessageQueueTestPeer queue_peer(&queue);
+  Dart_Port port1 = 1;
+
+  PortMessage* msg1 = new PortMessage(port1, 0, strdup("msg1"));
+  queue.Enqueue(msg1);
+  PortMessage* msg2 = new PortMessage(port1, 0, strdup("msg2"));
+  queue.Enqueue(msg2);
+  EXPECT(queue_peer.HasMessage());
+
+  queue.Flush(port1);
+
+  // Queue is empty.
+  EXPECT(!queue_peer.HasMessage());
+  // msg1 and msg2 are already deleted by Flush.
+}
+
+
+TEST_CASE(MessageQueue_Flush_EmptyQueue) {
+  MessageQueue queue;
+  MessageQueueTestPeer queue_peer(&queue);
+  Dart_Port port1 = 1;
+
+  EXPECT(!queue_peer.HasMessage());
+  queue.Flush(port1);
+
+  // Queue is still empty.
+  EXPECT(!queue_peer.HasMessage());
+}

[siva, 2011/10/14 23:50:32]

I was thinking of having a port3 with 0 messages and
port4 with 2 messages and invoking queue.Flush(port3) and queue.Flush(port4) in
MessageQueue_Flush itself.

This is fine too having explicit tests for these cases.

[turnidge, 2011/10/17 18:38:48]

Ok.  I like to keep my unit tests as small as I can so I will leave this as is.

+
 
 }  // namespace dart