Initial in-process implementation of some Mojo primitives.

mojo/system/waiter_list_unittest.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// NOTE(vtl): These tests are inherently flaky (e.g., if run on a heavily-loaded
+// system). Sorry. |kEpsilonMicros| may be increased to increase tolerance and
+// reduce observed flakiness.
+
+#include "mojo/system/waiter_list.h"
+
+#include "base/threading/platform_thread.h"  // For |Sleep()|.
+#include "base/time/time.h"
+#include "mojo/system/waiter.h"
+#include "mojo/system/waiter_test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace mojo {
+namespace system {
+namespace {
+
+const int64_t kMicrosPerMs = 1000;
+const int64_t kEpsilonMicros = 15 * kMicrosPerMs;  // 15 ms.
+
+TEST(WaiterListTest, BasicCancel) {
+  MojoResult result;
+
+  // Cancel immediately after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_READABLE, 0);
+    thread.Start();
+    waiter_list.CancelAllWaiters();
+    waiter_list.RemoveWaiter(thread.waiter());  // Double-remove okay.
+  }  // Join |thread|.
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
+
+  // Cancel before after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_WRITABLE, 1);
+    waiter_list.CancelAllWaiters();
+    thread.Start();
+  }  // Join |thread|.
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
+
+  // Cancel some time after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_READABLE, 2);
+    thread.Start();
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(2 * kEpsilonMicros));
+    waiter_list.CancelAllWaiters();
+  }  // Join |thread|.
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
+}
+
+TEST(WaiterListTest, BasicAwakeSatisfied) {
+  MojoResult result;
+
+  // Awake immediately after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_READABLE, 0);
+    thread.Start();
+    waiter_list.AwakeWaitersForStateChange(MOJO_WAIT_FLAG_READABLE,
+                                           MOJO_WAIT_FLAG_READABLE |
+                                              MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread.waiter());
+  }  // Join |thread|.
+  EXPECT_EQ(0, result);
+
+  // Awake before after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_WRITABLE, 1);
+    waiter_list.AwakeWaitersForStateChange(MOJO_WAIT_FLAG_WRITABLE,
+                                           MOJO_WAIT_FLAG_READABLE |
+                                              MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread.waiter());
+    waiter_list.RemoveWaiter(thread.waiter());  // Double-remove okay.
+    thread.Start();
+  }  // Join |thread|.
+  EXPECT_EQ(1, result);
+
+  // Awake some time after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_READABLE, 2);
+    thread.Start();
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(2 * kEpsilonMicros));
+    waiter_list.AwakeWaitersForStateChange(MOJO_WAIT_FLAG_READABLE,
+                                           MOJO_WAIT_FLAG_READABLE |
+                                              MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread.waiter());
+  }  // Join |thread|.
+  EXPECT_EQ(2, result);
+}
+
+TEST(WaiterListTest, BasicAwakeUnsatisfiable) {
+  MojoResult result;
+
+  // Awake (for unsatisfiability) immediately after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_READABLE, 0);
+    thread.Start();
+    waiter_list.AwakeWaitersForStateChange(0, MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread.waiter());
+  }  // Join |thread|.
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
+
+  // Awake (for unsatisfiability) before after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_WRITABLE, 1);
+    waiter_list.AwakeWaitersForStateChange(MOJO_WAIT_FLAG_READABLE,
+                                           MOJO_WAIT_FLAG_READABLE);
+    waiter_list.RemoveWaiter(thread.waiter());
+    thread.Start();
+  }  // Join |thread|.
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
+
+  // Awake (for unsatisfiability) some time after thread start.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread(&result);
+    waiter_list.AddWaiter(thread.waiter(), MOJO_WAIT_FLAG_READABLE, 2);
+    thread.Start();
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(2 * kEpsilonMicros));
+    waiter_list.AwakeWaitersForStateChange(0, MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread.waiter());
+    waiter_list.RemoveWaiter(thread.waiter());  // Double-remove okay.
+  }  // Join |thread|.
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
+}
+
+TEST(WaiterListTest, MultipleWaiters) {
+  MojoResult result_1;
+  MojoResult result_2;
+  MojoResult result_3;
+  MojoResult result_4;
+
+  // Cancel two waiters.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread_1(&result_1);
+    waiter_list.AddWaiter(thread_1.waiter(), MOJO_WAIT_FLAG_READABLE, 0);
+    thread_1.Start();
+    test::SimpleWaiterThread thread_2(&result_2);
+    waiter_list.AddWaiter(thread_2.waiter(), MOJO_WAIT_FLAG_WRITABLE, 1);
+    thread_2.Start();
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(2 * kEpsilonMicros));
+    waiter_list.CancelAllWaiters();
+  }  // Join threads.
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result_1);
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result_2);
+
+  // Awake one waiter, cancel other.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread_1(&result_1);
+    waiter_list.AddWaiter(thread_1.waiter(), MOJO_WAIT_FLAG_READABLE, 2);
+    thread_1.Start();
+    test::SimpleWaiterThread thread_2(&result_2);
+    waiter_list.AddWaiter(thread_2.waiter(), MOJO_WAIT_FLAG_WRITABLE, 3);
+    thread_2.Start();
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(2 * kEpsilonMicros));
+    waiter_list.AwakeWaitersForStateChange(MOJO_WAIT_FLAG_READABLE,
+                                           MOJO_WAIT_FLAG_READABLE |
+                                              MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread_1.waiter());
+    waiter_list.CancelAllWaiters();
+  }  // Join threads.
+  EXPECT_EQ(2, result_1);
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result_2);
+
+  // Cancel one waiter, awake other for unsatisfiability.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread_1(&result_1);
+    waiter_list.AddWaiter(thread_1.waiter(), MOJO_WAIT_FLAG_READABLE, 4);
+    thread_1.Start();
+    test::SimpleWaiterThread thread_2(&result_2);
+    waiter_list.AddWaiter(thread_2.waiter(), MOJO_WAIT_FLAG_WRITABLE, 5);
+    thread_2.Start();
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(2 * kEpsilonMicros));
+    waiter_list.AwakeWaitersForStateChange(0, MOJO_WAIT_FLAG_READABLE);
+    waiter_list.RemoveWaiter(thread_2.waiter());
+    waiter_list.CancelAllWaiters();
+  }  // Join threads.
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result_1);
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result_2);
+
+  // Cancel one waiter, awake other for unsatisfiability.
+  {
+    WaiterList waiter_list;
+    test::SimpleWaiterThread thread_1(&result_1);
+    waiter_list.AddWaiter(thread_1.waiter(), MOJO_WAIT_FLAG_READABLE, 6);
+    thread_1.Start();
+
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(1 * kEpsilonMicros));
+
+    // Should do nothing.
+    waiter_list.AwakeWaitersForStateChange(0,
+                                           MOJO_WAIT_FLAG_READABLE |
+                                               MOJO_WAIT_FLAG_WRITABLE);
+
+    test::SimpleWaiterThread thread_2(&result_2);
+    waiter_list.AddWaiter(thread_2.waiter(), MOJO_WAIT_FLAG_WRITABLE, 7);
+    thread_2.Start();
+
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(1 * kEpsilonMicros));
+
+    // Awake #1.
+    waiter_list.AwakeWaitersForStateChange(MOJO_WAIT_FLAG_READABLE,
+                                           MOJO_WAIT_FLAG_READABLE |
+                                               MOJO_WAIT_FLAG_WRITABLE);
+    waiter_list.RemoveWaiter(thread_1.waiter());
+
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(1 * kEpsilonMicros));
+
+    test::SimpleWaiterThread thread_3(&result_3);
+    waiter_list.AddWaiter(thread_3.waiter(), MOJO_WAIT_FLAG_WRITABLE, 8);
+    thread_3.Start();
+
+    test::SimpleWaiterThread thread_4(&result_4);
+    waiter_list.AddWaiter(thread_4.waiter(), MOJO_WAIT_FLAG_READABLE, 9);
+    thread_4.Start();
+
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMicroseconds(1 * kEpsilonMicros));
+
+    // Awake #2 and #3 for unsatisfiability.
+    waiter_list.AwakeWaitersForStateChange(0, MOJO_WAIT_FLAG_READABLE);
+    waiter_list.RemoveWaiter(thread_2.waiter());
+    waiter_list.RemoveWaiter(thread_3.waiter());
+
+    // Cancel #4.
+    waiter_list.CancelAllWaiters();
+  }  // Join threads.
+  EXPECT_EQ(6, result_1);
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result_2);
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result_3);
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, result_4);
+}
+
+}  // namespace
+}  // namespace system
+}  // namespace mojo