Split mojo/public/cpp/system/tests/core_unittest.cc, part 1.

mojo/public/cpp/system/tests/core_unittest.cc

 // Copyright 2014 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.
 
 // This file tests the C++ Mojo system core wrappers.
 // TODO(vtl): Split this test into more reasonable units/files.
 
 #include <stddef.h>
 
 #include <map>
+#include <vector>
 
 #include "mojo/public/cpp/system/buffer.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/public/cpp/system/handle.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/cpp/system/time.h"
 #include "mojo/public/cpp/system/wait.h"
 #include "mojo/public/cpp/system/wait_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
-TEST(CoreTest, GetTimeTicksNow) {
-  const MojoTimeTicks start = GetTimeTicksNow();
-  EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
-      << "GetTimeTicksNow should return nonzero value";
-}
-
 TEST(CoreTest, Basic) {
-  // Basic |Handle| implementation:
-  {
-    EXPECT_EQ(MOJO_HANDLE_INVALID, kInvalidHandleValue);
-
-    Handle h0;
-    EXPECT_EQ(kInvalidHandleValue, h0.value());
-    EXPECT_EQ(kInvalidHandleValue, *h0.mutable_value());
-    EXPECT_FALSE(h0.is_valid());
-
-    Handle h1(static_cast<MojoHandle>(123));
-    EXPECT_EQ(static_cast<MojoHandle>(123), h1.value());
-    EXPECT_EQ(static_cast<MojoHandle>(123), *h1.mutable_value());
-    EXPECT_TRUE(h1.is_valid());
-    *h1.mutable_value() = static_cast<MojoHandle>(456);
-    EXPECT_EQ(static_cast<MojoHandle>(456), h1.value());
-    EXPECT_TRUE(h1.is_valid());
-
-    h1.swap(h0);
-    EXPECT_EQ(static_cast<MojoHandle>(456), h0.value());
-    EXPECT_TRUE(h0.is_valid());
-    EXPECT_FALSE(h1.is_valid());
-
-    h1.set_value(static_cast<MojoHandle>(789));
-    h0.swap(h1);
-    EXPECT_EQ(static_cast<MojoHandle>(789), h0.value());
-    EXPECT_TRUE(h0.is_valid());
-    EXPECT_EQ(static_cast<MojoHandle>(456), h1.value());
-    EXPECT_TRUE(h1.is_valid());
-
-    // Make sure copy constructor works.
-    Handle h2(h0);
-    EXPECT_EQ(static_cast<MojoHandle>(789), h2.value());
-    // And assignment.
-    h2 = h1;
-    EXPECT_EQ(static_cast<MojoHandle>(456), h2.value());
-
-    // Make sure that we can put |Handle|s into |std::map|s.
-    h0 = Handle(static_cast<MojoHandle>(987));
-    h1 = Handle(static_cast<MojoHandle>(654));
-    h2 = Handle(static_cast<MojoHandle>(321));
-    Handle h3;
-    std::map<Handle, int> handle_to_int;
-    handle_to_int[h0] = 0;
-    handle_to_int[h1] = 1;
-    handle_to_int[h2] = 2;
-    handle_to_int[h3] = 3;
-
-    EXPECT_EQ(4u, handle_to_int.size());
-    EXPECT_FALSE(handle_to_int.find(h0) == handle_to_int.end());
-    EXPECT_EQ(0, handle_to_int[h0]);
-    EXPECT_FALSE(handle_to_int.find(h1) == handle_to_int.end());
-    EXPECT_EQ(1, handle_to_int[h1]);
-    EXPECT_FALSE(handle_to_int.find(h2) == handle_to_int.end());
-    EXPECT_EQ(2, handle_to_int[h2]);
-    EXPECT_FALSE(handle_to_int.find(h3) == handle_to_int.end());
-    EXPECT_EQ(3, handle_to_int[h3]);
-    EXPECT_TRUE(handle_to_int.find(Handle(static_cast<MojoHandle>(13579))) ==
-                handle_to_int.end());
-
-    // TODO(vtl): With C++11, support |std::unordered_map|s, etc. (Or figure out
-    // how to support the variations of |hash_map|.)
-  }
-
-  // |Handle|/|ScopedHandle| functions:
+  // |Wait|/|WaitMany|:
   {
     ScopedHandle h;
 
-    EXPECT_EQ(kInvalidHandleValue, h.get().value());
-
-    // This should be a no-op.
-    Close(h.Pass());
-
-    // It should still be invalid.
-    EXPECT_EQ(kInvalidHandleValue, h.get().value());
-
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               Wait(h.get(), ~MOJO_HANDLE_SIGNAL_NONE, 1000000, nullptr));
 
     std::vector<Handle> wh;
     wh.push_back(h.get());
     std::vector<MojoHandleSignals> sigs;
     sigs.push_back(~MOJO_HANDLE_SIGNAL_NONE);
     WaitManyResult wait_many_result =
         WaitMany(wh, sigs, MOJO_DEADLINE_INDEFINITE, nullptr);
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, wait_many_result.result);
     EXPECT_TRUE(wait_many_result.IsIndexValid());
     EXPECT_FALSE(wait_many_result.AreSignalsStatesValid());
 
     // Make sure that our specialized template correctly handles |NULL| as well
     // as |nullptr|.
     wait_many_result = WaitMany(wh, sigs, MOJO_DEADLINE_INDEFINITE, NULL);
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, wait_many_result.result);
     EXPECT_EQ(0u, wait_many_result.index);
     EXPECT_TRUE(wait_many_result.IsIndexValid());
     EXPECT_FALSE(wait_many_result.AreSignalsStatesValid());
   }
 
   // |MakeScopedHandle| (just compilation tests):
   {
-    EXPECT_FALSE(MakeScopedHandle(Handle()).is_valid());
     EXPECT_FALSE(MakeScopedHandle(MessagePipeHandle()).is_valid());
-    EXPECT_FALSE(MakeScopedHandle(DataPipeProducerHandle()).is_valid());
-    EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid());
     EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid());
   }
 
   // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions:
   {
     MessagePipeHandle h_invalid;
     EXPECT_FALSE(h_invalid.is_valid());
     EXPECT_EQ(
         MOJO_RESULT_INVALID_ARGUMENT,
         WriteMessageRaw(
@@ skipping 320 matching lines @@
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // |h3_value| should actually be invalid now.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value));
 
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value()));
   }
 }
 
-TEST(CoreTest, ScopedHandleMoveCtor) {
-  ScopedSharedBufferHandle buffer1;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1));
-  EXPECT_TRUE(buffer1.is_valid());
-
-  ScopedSharedBufferHandle buffer2;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer2));
-  EXPECT_TRUE(buffer2.is_valid());
-
-  // If this fails to close buffer1, ScopedHandleBase::CloseIfNecessary() will
-  // assert.
-  buffer1 = buffer2.Pass();
-
-  EXPECT_TRUE(buffer1.is_valid());
-  EXPECT_FALSE(buffer2.is_valid());
-}
-
-TEST(CoreTest, ScopedHandleMoveCtorSelf) {
-  ScopedSharedBufferHandle buffer1;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1));
-  EXPECT_TRUE(buffer1.is_valid());
-
-  buffer1 = buffer1.Pass();
-
-  EXPECT_TRUE(buffer1.is_valid());
-}
-
 TEST(CoreTest, WaitManyResult) {
   {
     WaitManyResult wmr(MOJO_RESULT_OK);
     EXPECT_FALSE(wmr.IsIndexValid());
     EXPECT_TRUE(wmr.AreSignalsStatesValid());
     EXPECT_EQ(MOJO_RESULT_OK, wmr.result);
   }
 
   {
     WaitManyResult wmr(MOJO_RESULT_FAILED_PRECONDITION);
@@ skipping 24 matching lines @@
 
   {
     WaitManyResult wmr(MOJO_RESULT_FAILED_PRECONDITION, 5u);
     EXPECT_TRUE(wmr.IsIndexValid());
     EXPECT_TRUE(wmr.AreSignalsStatesValid());
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, wmr.result);
     EXPECT_EQ(5u, wmr.index);
   }
 }
 
-TEST(CoreTest, DataPipe) {
-  ScopedDataPipeProducerHandle ph;
-  ScopedDataPipeConsumerHandle ch;
-
-  ASSERT_EQ(MOJO_RESULT_OK, CreateDataPipe(nullptr, &ph, &ch));
-  ASSERT_TRUE(ph.get().is_valid());
-  ASSERT_TRUE(ch.get().is_valid());
-
-  uint32_t read_threshold = 123u;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            GetDataPipeConsumerOptions(ch.get(), &read_threshold));
-  EXPECT_EQ(0u, read_threshold);
-
-  EXPECT_EQ(MOJO_RESULT_OK, SetDataPipeConsumerOptions(ch.get(), 2u));
-
-  EXPECT_EQ(MOJO_RESULT_OK,
-            GetDataPipeConsumerOptions(ch.get(), &read_threshold));
-  EXPECT_EQ(2u, read_threshold);
-
-  // Write a byte.
-  static const char kA = 'A';
-  uint32_t num_bytes = 1u;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            WriteDataRaw(ph.get(), &kA, &num_bytes, MOJO_WRITE_DATA_FLAG_NONE));
-
-  // Waiting for "read threshold" should fail. (Wait a nonzero amount, in case
-  // there's some latency.)
-  MojoHandleSignalsState state;
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            Wait(ch.get(), MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 1000, &state));
-  // ... but it should be readable.
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, state.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
-                MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
-            state.satisfiable_signals);
-
-  // Do a two-phase write of another byte.
-  void* write_buffer = nullptr;
-  num_bytes = 0u;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            BeginWriteDataRaw(ph.get(), &write_buffer, &num_bytes,
-                              MOJO_WRITE_DATA_FLAG_NONE));
-  ASSERT_TRUE(write_buffer);
-  ASSERT_GT(num_bytes, 0u);
-  static_cast<char*>(write_buffer)[0] = 'B';
-  EXPECT_EQ(MOJO_RESULT_OK, EndWriteDataRaw(ph.get(), 1u));
-
-  // Now waiting for "read threshold" should succeed. (Wait a nonzero amount, in
-  // case there's some latency.)
-  state = MojoHandleSignalsState();
-  EXPECT_EQ(MOJO_RESULT_OK,
-            Wait(ch.get(), MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 1000, &state));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
-            state.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
-                MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
-            state.satisfiable_signals);
-
-  // Read a byte.
-  char read_byte = 'x';
-  num_bytes = 1u;
-  EXPECT_EQ(MOJO_RESULT_OK, ReadDataRaw(ch.get(), &read_byte, &num_bytes,
-                                        MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ(1u, num_bytes);
-  EXPECT_EQ('A', read_byte);
-
-  // Waiting for "read threshold" should now fail.
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            Wait(ch.get(), MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
-
-  // Reset the read threshold/options.
-  EXPECT_EQ(MOJO_RESULT_OK, SetDataPipeConsumerOptionsToDefault(ch.get()));
-
-  // Waiting for "read threshold" should now succeed.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            Wait(ch.get(), MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 0, nullptr));
-
-  // Do a two-phase read.
-  const void* read_buffer = nullptr;
-  num_bytes = 0u;
-  ASSERT_EQ(MOJO_RESULT_OK, BeginReadDataRaw(ch.get(), &read_buffer, &num_bytes,
-                                             MOJO_READ_DATA_FLAG_NONE));
-  ASSERT_TRUE(read_buffer);
-  ASSERT_EQ(1u, num_bytes);
-  EXPECT_EQ('B', static_cast<const char*>(read_buffer)[0]);
-  EXPECT_EQ(MOJO_RESULT_OK, EndReadDataRaw(ch.get(), 1u));
-
-  // Waiting for "read" should now fail (time out).
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            Wait(ch.get(), MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 1000, nullptr));
-
-  // Close the producer.
-  ph.reset();
-
-  // Waiting for "read" should now fail.
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            Wait(ch.get(), MOJO_HANDLE_SIGNAL_READ_THRESHOLD, 1000, nullptr));
-}
-
 }  // namespace
 }  // namespace mojo