1 files changed, 99 insertions, 64 deletions
diff --git a/mojo/system/simple_dispatcher_unittest.cc b/mojo/system/simple_dispatcher_unittest.cc
index 26fc277..3b292ddd 100644
--- a/mojo/system/simple_dispatcher_unittest.cc
+++ b/mojo/system/simple_dispatcher_unittest.cc
@@ -92,6 +92,7 @@ TEST(SimpleDispatcherTest, Basic) {
 
   scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
   Waiter w;
+  uint32_t context = 0;
 
   // Try adding a readable waiter when already readable.
   w.Init();
@@ -106,8 +107,9 @@ TEST(SimpleDispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 1));
   d->SetSatisfiedFlags(MOJO_WAIT_FLAG_WRITABLE);
   stopwatch.Start();
-  EXPECT_EQ(1, w.Wait(MOJO_DEADLINE_INDEFINITE));
+  EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(1u, context);
   d->RemoveWaiter(&w);
 
   // Wait for zero time for writable when already writable.
@@ -116,8 +118,9 @@ TEST(SimpleDispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 2));
   d->SetSatisfiedFlags(MOJO_WAIT_FLAG_WRITABLE);
   stopwatch.Start();
-  EXPECT_EQ(2, w.Wait(0));
+  EXPECT_EQ(MOJO_RESULT_OK, w.Wait(0, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(2u, context);
   d->RemoveWaiter(&w);
 
   // Wait for non-zero, finite time for writable when already writable.
@@ -126,8 +129,10 @@ TEST(SimpleDispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 3));
   d->SetSatisfiedFlags(MOJO_WAIT_FLAG_WRITABLE);
   stopwatch.Start();
-  EXPECT_EQ(3, w.Wait(2 * test::EpsilonTimeout().InMicroseconds()));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(3u, context);
   d->RemoveWaiter(&w);
 
   // Wait for zero time for writable when not writable (will time out).
@@ -135,7 +140,7 @@ TEST(SimpleDispatcherTest, Basic) {
   d->SetSatisfiedFlags(MOJO_WAIT_FLAG_READABLE);
   EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 4));
   stopwatch.Start();
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0));
+  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, NULL));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   d->RemoveWaiter(&w);
 
@@ -143,10 +148,10 @@ TEST(SimpleDispatcherTest, Basic) {
   // out).
   w.Init();
   d->SetSatisfiedFlags(MOJO_WAIT_FLAG_READABLE);
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 4));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 5));
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            w.Wait(2 * test::EpsilonTimeout().InMicroseconds()));
+            w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), NULL));
   base::TimeDelta elapsed = stopwatch.Elapsed();
   EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout());
   EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
@@ -160,45 +165,50 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) {
 
   scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
   Waiter w;
+  uint32_t context = 0;
 
   // Try adding a writable waiter when it can never be writable.
   w.Init();
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE);
   d->SetSatisfiedFlags(0);
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 5));
+            d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 1));
   // Shouldn't need to remove the waiter (it was not added).
 
   // Wait (forever) for writable and then it becomes never writable.
   w.Init();
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE);
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 6));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 2));
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE);
   stopwatch.Start();
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, w.Wait(MOJO_DEADLINE_INDEFINITE));
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+            w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(2u, context);
   d->RemoveWaiter(&w);
 
   // Wait for zero time for writable and then it becomes never writable.
   w.Init();
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE);
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 6));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 3));
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE);
   stopwatch.Start();
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, w.Wait(0));
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, w.Wait(0, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(3u, context);
   d->RemoveWaiter(&w);
 
   // Wait for non-zero, finite time for writable and then it becomes never
   // writable.
   w.Init();
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE);
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 7));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 4));
   d->SetSatisfiableFlags(MOJO_WAIT_FLAG_READABLE);
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            w.Wait(2 * test::EpsilonTimeout().InMicroseconds()));
+            w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(4u, context);
   d->RemoveWaiter(&w);
 
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
@@ -209,45 +219,49 @@ TEST(SimpleDispatcherTest, BasicClosed) {
 
   scoped_refptr<MockSimpleDispatcher> d;
   Waiter w;
+  uint32_t context = 0;
 
   // Try adding a writable waiter when the dispatcher has been closed.
   d = new MockSimpleDispatcher();
   w.Init();
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 8));
+            d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 1));
   // Shouldn't need to remove the waiter (it was not added).
 
   // Wait (forever) for writable and then the dispatcher is closed.
   d = new MockSimpleDispatcher();
   w.Init();
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 9));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 2));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
-  EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(MOJO_DEADLINE_INDEFINITE));
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(2u, context);
   // Don't need to remove waiters from closed dispatchers.
 
   // Wait for zero time for writable and then the dispatcher is closed.
   d = new MockSimpleDispatcher();
   w.Init();
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 10));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 3));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
-  EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(0));
+  EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(0, &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(3u, context);
   // Don't need to remove waiters from closed dispatchers.
 
   // Wait for non-zero, finite time for writable and then the dispatcher is
   // closed.
   d = new MockSimpleDispatcher();
   w.Init();
-  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 11));
+  EXPECT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_WAIT_FLAG_WRITABLE, 4));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED,
-            w.Wait(2 * test::EpsilonTimeout().InMicroseconds()));
+            w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
+  EXPECT_EQ(4u, context);
   // Don't need to remove waiters from closed dispatchers.
 }
 
@@ -255,6 +269,7 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
   test::Stopwatch stopwatch;
   bool did_wait;
   MojoResult result;
+  uint32_t context;
 
   // Wait for readable (already readable).
   {
@@ -264,8 +279,8 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
       test::WaiterThread thread(d,
                                 MOJO_WAIT_FLAG_READABLE,
                                 MOJO_DEADLINE_INDEFINITE,
-                                0,
-                                &did_wait, &result);
+                                1,
+                                &did_wait, &result, &context);
       stopwatch.Start();
       thread.Start();
     }  // Joins the thread.
@@ -282,8 +297,8 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
     test::WaiterThread thread(d,
                               MOJO_WAIT_FLAG_READABLE,
                               MOJO_DEADLINE_INDEFINITE,
-                              1,
-                              &did_wait, &result);
+                              2,
+                              &did_wait, &result, &context);
     stopwatch.Start();
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -294,7 +309,8 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
   EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout());
   EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
   EXPECT_TRUE(did_wait);
-  EXPECT_EQ(1, result);
+  EXPECT_EQ(MOJO_RESULT_OK, result);
+  EXPECT_EQ(2u, context);
 
   // Wait for readable and becomes never-readable after some time.
   {
@@ -302,8 +318,8 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
     test::WaiterThread thread(d,
                               MOJO_WAIT_FLAG_READABLE,
                               MOJO_DEADLINE_INDEFINITE,
-                              2,
-                              &did_wait, &result);
+                              3,
+                              &did_wait, &result, &context);
     stopwatch.Start();
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -315,6 +331,7 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
   EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
+  EXPECT_EQ(3u, context);
 
   // Wait for readable and dispatcher gets closed.
   {
@@ -322,8 +339,8 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
     test::WaiterThread thread(d,
                               MOJO_WAIT_FLAG_READABLE,
                               MOJO_DEADLINE_INDEFINITE,
-                              3,
-                              &did_wait, &result);
+                              4,
+                              &did_wait, &result, &context);
     stopwatch.Start();
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -334,6 +351,7 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
   EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
+  EXPECT_EQ(4u, context);
 
   // Wait for readable and times out.
   {
@@ -342,8 +360,8 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
       test::WaiterThread thread(d,
                                 MOJO_WAIT_FLAG_READABLE,
                                 2 * test::EpsilonTimeout().InMicroseconds(),
-                                4,
-                                &did_wait, &result);
+                                5,
+                                &did_wait, &result, &context);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -361,30 +379,34 @@ TEST(SimpleDispatcherTest, BasicThreaded) {
 }
 
 TEST(SimpleDispatcherTest, MultipleWaiters) {
-  static const size_t kNumWaiters = 20;
+  static const uint32_t kNumWaiters = 20;
 
   bool did_wait[kNumWaiters];
   MojoResult result[kNumWaiters];
+  uint32_t context[kNumWaiters];
 
   // All wait for readable and becomes readable after some time.
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
-    for (size_t i = 0; i < kNumWaiters; i++) {
+    for (uint32_t i = 0; i < kNumWaiters; i++) {
       threads.push_back(new test::WaiterThread(d,
                                                MOJO_WAIT_FLAG_READABLE,
                                                MOJO_DEADLINE_INDEFINITE,
-                                               static_cast<MojoResult>(i),
-                                               &did_wait[i], &result[i]));
+                                               i,
+                                               &did_wait[i],
+                                               &result[i],
+                                               &context[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
     d->SetSatisfiedFlags(MOJO_WAIT_FLAG_READABLE);
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }  // Joins the threads.
-  for (size_t i = 0; i < kNumWaiters; i++) {
+  for (uint32_t i = 0; i < kNumWaiters; i++) {
     EXPECT_TRUE(did_wait[i]);
-    EXPECT_EQ(static_cast<MojoResult>(i), result[i]);
+    EXPECT_EQ(MOJO_RESULT_OK, result[i]);
+    EXPECT_EQ(i, context[i]);
   }
 
   // Some wait for readable, some for writable, and becomes readable after some
@@ -392,20 +414,24 @@ TEST(SimpleDispatcherTest, MultipleWaiters) {
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
-    for (size_t i = 0; i < kNumWaiters / 2; i++) {
+    for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
       threads.push_back(new test::WaiterThread(d,
                                                MOJO_WAIT_FLAG_READABLE,
                                                MOJO_DEADLINE_INDEFINITE,
-                                               static_cast<MojoResult>(i),
-                                               &did_wait[i], &result[i]));
+                                               i,
+                                               &did_wait[i],
+                                               &result[i],
+                                               &context[i]));
       threads.back()->Start();
     }
-    for (size_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
+    for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
       threads.push_back(new test::WaiterThread(d,
                                                MOJO_WAIT_FLAG_WRITABLE,
                                                MOJO_DEADLINE_INDEFINITE,
-                                               static_cast<MojoResult>(i),
-                                               &did_wait[i], &result[i]));
+                                               i,
+                                               &did_wait[i],
+                                               &result[i],
+                                               &context[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -413,13 +439,15 @@ TEST(SimpleDispatcherTest, MultipleWaiters) {
     // This will wake up the ones waiting to write.
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }  // Joins the threads.
-  for (size_t i = 0; i < kNumWaiters / 2; i++) {
+  for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
     EXPECT_TRUE(did_wait[i]);
-    EXPECT_EQ(static_cast<MojoResult>(i), result[i]);
+    EXPECT_EQ(MOJO_RESULT_OK, result[i]);
+    EXPECT_EQ(i, context[i]);
   }
-  for (size_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
+  for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
     EXPECT_TRUE(did_wait[i]);
     EXPECT_EQ(MOJO_RESULT_CANCELLED, result[i]);
+    EXPECT_EQ(i, context[i]);
   }
 
   // Some wait for readable, some for writable, and becomes readable and
@@ -427,20 +455,24 @@ TEST(SimpleDispatcherTest, MultipleWaiters) {
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
-    for (size_t i = 0; i < kNumWaiters / 2; i++) {
+    for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
       threads.push_back(new test::WaiterThread(d,
                                                MOJO_WAIT_FLAG_READABLE,
                                                MOJO_DEADLINE_INDEFINITE,
-                                               static_cast<MojoResult>(i),
-                                               &did_wait[i], &result[i]));
+                                               i,
+                                               &did_wait[i],
+                                               &result[i],
+                                               &context[i]));
       threads.back()->Start();
     }
-    for (size_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
+    for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
       threads.push_back(new test::WaiterThread(d,
                                                MOJO_WAIT_FLAG_WRITABLE,
                                                MOJO_DEADLINE_INDEFINITE,
-                                               static_cast<MojoResult>(i),
-                                               &did_wait[i], &result[i]));
+                                               i,
+                                               &did_wait[i],
+                                               &result[i],
+                                               &context[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -449,13 +481,15 @@ TEST(SimpleDispatcherTest, MultipleWaiters) {
     d->SetSatisfiedFlags(MOJO_WAIT_FLAG_READABLE);
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }  // Joins the threads.
-  for (size_t i = 0; i < kNumWaiters / 2; i++) {
+  for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
     EXPECT_TRUE(did_wait[i]);
-    EXPECT_EQ(static_cast<MojoResult>(i), result[i]);
+    EXPECT_EQ(MOJO_RESULT_OK, result[i]);
+    EXPECT_EQ(i, context[i]);
   }
-  for (size_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
+  for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
     EXPECT_TRUE(did_wait[i]);
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result[i]);
+    EXPECT_EQ(i, context[i]);
   }
 
   // Some wait for readable, some for writable, and becomes readable after some
@@ -463,22 +497,22 @@ TEST(SimpleDispatcherTest, MultipleWaiters) {
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
-    for (size_t i = 0; i < kNumWaiters / 2; i++) {
+    for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
       threads.push_back(
           new test::WaiterThread(d,
                                  MOJO_WAIT_FLAG_READABLE,
                                  3 * test::EpsilonTimeout().InMicroseconds(),
-                                 static_cast<MojoResult>(i),
-                                 &did_wait[i], &result[i]));
+                                 i,
+                                 &did_wait[i], &result[i], &context[i]));
       threads.back()->Start();
     }
-    for (size_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
+    for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
       threads.push_back(
           new test::WaiterThread(d,
                                  MOJO_WAIT_FLAG_WRITABLE,
                                  1 * test::EpsilonTimeout().InMicroseconds(),
-                                 static_cast<MojoResult>(i),
-                                 &did_wait[i], &result[i]));
+                                 i,
+                                 &did_wait[i], &result[i], &context[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -486,11 +520,12 @@ TEST(SimpleDispatcherTest, MultipleWaiters) {
     // All those waiting for writable should have timed out.
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }  // Joins the threads.
-  for (size_t i = 0; i < kNumWaiters / 2; i++) {
+  for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
     EXPECT_TRUE(did_wait[i]);
-    EXPECT_EQ(static_cast<MojoResult>(i), result[i]);
+    EXPECT_EQ(MOJO_RESULT_OK, result[i]);
+    EXPECT_EQ(i, context[i]);
   }
-  for (size_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
+  for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
     EXPECT_TRUE(did_wait[i]);
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, result[i]);
   }