Rationalize mojo_public_*tests targets.

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): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets
-// compiled into a different binary from the C API tests.
+// TODO(vtl): Split this test into more reasonable units/files.
 
 #include <stddef.h>
 
 #include <map>
 
 #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(CoreCppTest, GetTimeTicksNow) {
+TEST(CoreTest, GetTimeTicksNow) {
   const MojoTimeTicks start = GetTimeTicksNow();
   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
       << "GetTimeTicksNow should return nonzero value";
 }
 
-TEST(CoreCppTest, Basic) {
+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));
@@ skipping 315 matching lines @@
       EXPECT_STREQ(kWorld, buffer);
       EXPECT_EQ(0u, handles_count);
     }
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0));
   }
 
   // TODO(vtl): Test |CloseRaw()|.
   // TODO(vtl): Test |reset()| more thoroughly?
 }
 
-TEST(CoreCppTest, TearDownWithMessagesEnqueued) {
+TEST(CoreTest, TearDownWithMessagesEnqueued) {
   // Tear down a message pipe which still has a message enqueued, with the
   // message also having a valid message pipe handle.
   {
     ScopedMessagePipeHandle h0;
     ScopedMessagePipeHandle h1;
     ASSERT_EQ(MOJO_RESULT_OK, CreateMessagePipe(nullptr, &h0, &h1));
 
     // Send a handle over the previously-establish message pipe.
     ScopedMessagePipeHandle h2;
     ScopedMessagePipeHandle h3;
@@ skipping 87 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(CoreCppTest, ScopedHandleMoveCtor) {
+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(CoreCppTest, ScopedHandleMoveCtorSelf) {
+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(CoreCppTest, WaitManyResult) {
+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);
     EXPECT_FALSE(wmr.IsIndexValid());
@@ skipping 23 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(CoreCppTest, DataPipe) {
+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));
@@ skipping 80 matching lines @@
   // 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