Implement a new child test helper for Android.

mojo/edk/system/multiprocess_message_pipe_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.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
@@ skipping 97 matching lines @@
     std::string write_buffer = read_buffer + read_buffer;
     CHECK_EQ(MojoWriteMessage(h, write_buffer.data(),
                               static_cast<uint32_t>(write_buffer.size()),
                               nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   return rv;
 }
 
-// Sends "hello" to child, and expects "hellohello" back.
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_Basic DISABLED_Basic
-#else
-#define MAYBE_Basic Basic
-#endif  // defined(OS_ANDROID)
-TEST_F(MultiprocessMessagePipeTest, MAYBE_Basic) {
+TEST_F(MultiprocessMessagePipeTest, Basic) {
   RUN_CHILD_ON_PIPE(EchoEcho, h)
     std::string hello("hello");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, hello.data(),
                                static_cast<uint32_t>(hello.size()), nullptr, 0u,
                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     HandleSignalsState hss;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 15 matching lines @@
     ASSERT_EQ(hello + hello, read_buffer);
 
     std::string quitquitquit("quitquitquit");
     CHECK_EQ(MojoWriteMessage(h, quitquitquit.data(),
                               static_cast<uint32_t>(quitquitquit.size()),
                               nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   END_CHILD_AND_EXPECT_EXIT_CODE(1 % 100);
 }
 
-// Sends a bunch of messages to the child. Expects them "repeated" back. Waits
-// for the child to close its end before quitting.
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_QueueMessages DISABLED_QueueMessages
-#else
-#define MAYBE_QueueMessages QueueMessages
-#endif  // defined(OS_ANDROID)
-TEST_F(MultiprocessMessagePipeTest, MAYBE_QueueMessages) {
+TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
   static const size_t kNumMessages = 1001;
   RUN_CHILD_ON_PIPE(EchoEcho, h)
     for (size_t i = 0; i < kNumMessages; i++) {
       std::string write_buffer(i, 'A' + (i % 26));
       ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, write_buffer.data(),
                                static_cast<uint32_t>(write_buffer.size()),
                                nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE));
     }
 
@@ skipping 105 matching lines @@
 
   // It should have written something to the shared buffer.
   static const char kWorld[] = "world!!!";
   CHECK_EQ(memcmp(buffer, kWorld, sizeof(kWorld)), 0);
 
   // And we're done.
 
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing
-#else
-#define MAYBE_SharedBufferPassing SharedBufferPassing
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
+TEST_F(MultiprocessMessagePipeTest, SharedBufferPassing) {
   RUN_CHILD_ON_PIPE(CheckSharedBuffer, h)
     // Make a shared buffer.
     MojoCreateSharedBufferOptions options;
     options.struct_size = sizeof(options);
     options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
     MojoHandle shared_buffer;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoCreateSharedBuffer(&options, 100, &shared_buffer));
 
@@ skipping 210 matching lines @@
   // Now write some data into the message pipe.
   std::string write_buffer = "world";
   CHECK_EQ(MojoWriteMessage(handles[0], write_buffer.data(),
                             static_cast<uint32_t>(write_buffer.size()), nullptr,
                             0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   MojoClose(handles[0]);
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_MessagePipePassing DISABLED_MessagePipePassing
-#else
-#define MAYBE_MessagePipePassing MessagePipePassing
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_MessagePipePassing) {
+TEST_F(MultiprocessMessagePipeTest, MessagePipePassing) {
   RUN_CHILD_ON_PIPE(CheckMessagePipe, h)
     MojoCreateSharedBufferOptions options;
     options.struct_size = sizeof(options);
     options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
     MojoHandle mp1, mp2;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoCreateMessagePipe(nullptr, &mp1, &mp2));
 
     // Write a string into one end of the new message pipe and send the other
@@ skipping 21 matching lines @@
                              &read_buffer_size, nullptr,
                              0, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     CHECK_EQ(read_buffer, std::string("world"));
 
     MojoClose(mp1);
   END_CHILD()
 }
 
-// Like above test, but verifies passing the other MP handle works as well.
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_MessagePipeTwoPassing DISABLED_MessagePipeTwoPassing
-#else
-#define MAYBE_MessagePipeTwoPassing MessagePipeTwoPassing
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_MessagePipeTwoPassing) {
+TEST_F(MultiprocessMessagePipeTest, MessagePipeTwoPassing) {
   RUN_CHILD_ON_PIPE(CheckMessagePipe, h)
     MojoHandle mp1, mp2;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoCreateMessagePipe(nullptr, &mp2, &mp1));
 
     // Write a string into one end of the new message pipe and send the other
     // end.
     const std::string hello("hello");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(mp1, &hello[0],
@@ skipping 67 matching lines @@
   // Now write some data into the message pipe.
   std::string write_buffer = "world";
   CHECK_EQ(MojoWriteMessage(handles[0], write_buffer.data(),
                             static_cast<uint32_t>(write_buffer.size()),
                             nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
             MOJO_RESULT_OK);
   MojoClose(handles[0]);
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_DataPipeConsumer DISABLED_DataPipeConsumer
-#else
-#define MAYBE_DataPipeConsumer DataPipeConsumer
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_DataPipeConsumer) {
+TEST_F(MultiprocessMessagePipeTest, DataPipeConsumer) {
   RUN_CHILD_ON_PIPE(DataPipeConsumer, h)
     MojoCreateSharedBufferOptions options;
     options.struct_size = sizeof(options);
     options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE;
 
     MojoHandle mp1, mp2;
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoCreateMessagePipe(nullptr, &mp2, &mp1));
 
     // Write a string into one end of the new message pipe and send the other
@@ skipping 73 matching lines @@
                              h) {
   for (;;) {
     std::string message = ReadMessage(h);
     if (message == "exit")
       break;
     WriteMessage(h, message);
   }
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_MultiprocessChannelPipe DISABLED_MultiprocessChannelPipe
-#else
-#define MAYBE_MultiprocessChannelPipe MultiprocessChannelPipe
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_MultiprocessChannelPipe) {
+TEST_F(MultiprocessMessagePipeTest, MultiprocessChannelPipe) {
   RUN_CHILD_ON_PIPE(ChannelEchoClient, h)
     VerifyEcho(h, "in an interstellar burst");
     VerifyEcho(h, "i am back to save the universe");
     VerifyEcho(h, std::string(10 * 1024 * 1024, 'o'));
 
     WriteMessage(h, "exit");
   END_CHILD()
 }
 
 // Receives a pipe handle from the primordial channel and echos on it until
 // "exit". Used to test simple pipe transfer across processes via channels.
 DEFINE_TEST_CLIENT_WITH_PIPE(EchoServiceClient, MultiprocessMessagePipeTest,
                              h) {
   MojoHandle p;
   ReadMessageWithHandles(h, &p, 1);
   for (;;) {
     std::string message = ReadMessage(p);
     if (message == "exit")
       break;
     WriteMessage(p, message);
   }
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_PassMessagePipeCrossProcess DISABLED_PassMessagePipeCrossProcess
-#else
-#define MAYBE_PassMessagePipeCrossProcess PassMessagePipeCrossProcess
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_PassMessagePipeCrossProcess) {
+TEST_F(MultiprocessMessagePipeTest, PassMessagePipeCrossProcess) {
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
   RUN_CHILD_ON_PIPE(EchoServiceClient, h)
 
     // Pass one end of the pipe to the other process.
     WriteMessageWithHandles(h, "here take this", &p1, 1);
 
     VerifyEcho(p0, "and you may ask yourself");
     VerifyEcho(p0, "where does that highway go?");
     VerifyEcho(p0, std::string(20 * 1024 * 1024, 'i'));
@@ skipping 36 matching lines @@
       WriteMessage(handles[index], ReadMessage(handles[index]));
     }
   }
 
   for (size_t i = 1; i < handles.size(); ++i)
     CloseHandle(handles[i]);
 
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_PassMoarMessagePipesCrossProcess \
-    DISABLED_PassMoarMessagePipesCrossProcess
-#else
-#define MAYBE_PassMoarMessagePipesCrossProcess PassMoarMessagePipesCrossProcess
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_PassMoarMessagePipesCrossProcess) {
+TEST_F(MultiprocessMessagePipeTest, PassMoarMessagePipesCrossProcess) {
   MojoHandle echo_factory_proxy, echo_factory_request;
   CreateMessagePipe(&echo_factory_proxy, &echo_factory_request);
 
   MojoHandle echo_proxy_a, echo_request_a;
   CreateMessagePipe(&echo_proxy_a, &echo_request_a);
 
   MojoHandle echo_proxy_b, echo_request_b;
   CreateMessagePipe(&echo_proxy_b, &echo_request_b);
 
   MojoHandle echo_proxy_c, echo_request_c;
@@ skipping 24 matching lines @@
 
     WriteMessage(h, "exit");
   END_CHILD()
 
   CloseHandle(echo_factory_proxy);
   CloseHandle(echo_proxy_a);
   CloseHandle(echo_proxy_b);
   CloseHandle(echo_proxy_c);
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_ChannelPipesWithMultipleChildren \
-    DISABLED_ChannelPipesWithMultipleChildren
-#else
-#define MAYBE_ChannelPipesWithMultipleChildren ChannelPipesWithMultipleChildren
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_ChannelPipesWithMultipleChildren) {
+TEST_F(MultiprocessMessagePipeTest, ChannelPipesWithMultipleChildren) {
   RUN_CHILD_ON_PIPE(ChannelEchoClient, a)
     RUN_CHILD_ON_PIPE(ChannelEchoClient, b)
       VerifyEcho(a, "hello child 0");
       VerifyEcho(b, "hello child 1");
 
       WriteMessage(a, "exit");
       WriteMessage(b, "exit");
     END_CHILD()
   END_CHILD()
 }
 
 // Reads and turns a pipe handle some number of times to create lots of
 // transient proxies.
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(PingPongPipeClient,
                                   MultiprocessMessagePipeTest, h) {
   const size_t kNumBounces = 50;
   MojoHandle p0, p1;
   ReadMessageWithHandles(h, &p0, 1);
   ReadMessageWithHandles(h, &p1, 1);
   for (size_t i = 0; i < kNumBounces; ++i) {
     WriteMessageWithHandles(h, "", &p1, 1);
     ReadMessageWithHandles(h, &p1, 1);
   }
   WriteMessageWithHandles(h, "", &p0, 1);
   WriteMessage(p1, "bye");
   MojoClose(p1);
   EXPECT_EQ("quit", ReadMessage(h));
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_PingPongPipe DISABLED_PingPongPipe
-#else
-#define MAYBE_PingPongPipe PingPongPipe
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_PingPongPipe) {
+TEST_F(MultiprocessMessagePipeTest, PingPongPipe) {
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
 
   RUN_CHILD_ON_PIPE(PingPongPipeClient, h)
     const size_t kNumBounces = 50;
     WriteMessageWithHandles(h, "", &p0, 1);
     WriteMessageWithHandles(h, "", &p1, 1);
     for (size_t i = 0; i < kNumBounces; ++i) {
       ReadMessageWithHandles(h, &p1, 1);
       WriteMessageWithHandles(h, "", &p1, 1);
@@ skipping 78 matching lines @@
       break;
     }
   }
 
   for (auto& pipe: named_pipes)
     CloseHandle(pipe.second);
 
   return 0;
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_ChildToChildPipes DISABLED_ChildToChildPipes
-#else
-#define MAYBE_ChildToChildPipes ChildToChildPipes
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_ChildToChildPipes) {
+TEST_F(MultiprocessMessagePipeTest, ChildToChildPipes) {
   RUN_CHILD_ON_PIPE(CommandDrivenClient, h0)
     RUN_CHILD_ON_PIPE(CommandDrivenClient, h1)
       CommandDrivenClientController a(h0);
       CommandDrivenClientController b(h1);
 
       // Create a pipe and pass each end to a different client.
       MojoHandle p0, p1;
       CreateMessagePipe(&p0, &p1);
       a.SendHandle("x", p0);
       b.SendHandle("y", p1);
 
       // Make sure they can talk.
       a.Send("say:x:hello sir");
       b.Send("hear:y:hello sir");
 
       b.Send("say:y:i love multiprocess pipes!");
       a.Send("hear:x:i love multiprocess pipes!");
 
       a.Exit();
       b.Exit();
     END_CHILD()
   END_CHILD()
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_MoreChildToChildPipes DISABLED_MoreChildToChildPipes
-#else
-#define MAYBE_MoreChildToChildPipes MoreChildToChildPipes
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_MoreChildToChildPipes) {
+TEST_F(MultiprocessMessagePipeTest, MoreChildToChildPipes) {
   RUN_CHILD_ON_PIPE(CommandDrivenClient, h0)
     RUN_CHILD_ON_PIPE(CommandDrivenClient, h1)
       RUN_CHILD_ON_PIPE(CommandDrivenClient, h2)
         RUN_CHILD_ON_PIPE(CommandDrivenClient, h3)
           CommandDrivenClientController a(h0), b(h1), c(h2), d(h3);
 
           // Connect a to b and c to d
 
           MojoHandle p0, p1;
 
@@ skipping 65 matching lines @@
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReceivePipeWithClosedPeer,
                                   MultiprocessMessagePipeTest, h) {
   MojoHandle p;
   EXPECT_EQ("foo", ReadMessageWithHandles(h, &p, 1));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                                      MOJO_DEADLINE_INDEFINITE, nullptr));
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_SendPipeThenClosePeer DISABLED_SendPipeThenClosePeer
-#else
-#define MAYBE_SendPipeThenClosePeer SendPipeThenClosePeer
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_SendPipeThenClosePeer) {
+TEST_F(MultiprocessMessagePipeTest, SendPipeThenClosePeer) {
   RUN_CHILD_ON_PIPE(ReceivePipeWithClosedPeer, h)
     MojoHandle a, b;
     CreateMessagePipe(&a, &b);
 
     // Send |a| and immediately close |b|. The child should observe closure.
     WriteMessageWithHandles(h, "foo", &a, 1);
     MojoClose(b);
   END_CHILD()
 }
 
@@ skipping 56 matching lines @@
                 ReadMessageWithHandles(kid_a, &application_request, 1));
 
       WriteMessageWithHandles(kid_b, "c2a", &application_request, 1);
     END_CHILD()
 
     WriteMessage(kid_a, "quit");
   END_CHILD()
 }
 
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_SendClosePeerSend DISABLED_SendClosePeerSend
-#else
-#define MAYBE_SendClosePeerSend SendClosePeerSend
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_SendClosePeerSend) {
+TEST_F(MultiprocessMessagePipeTest, SendClosePeerSend) {
   MojoHandle a, b;
   CreateMessagePipe(&a, &b);
 
   MojoHandle c, d;
   CreateMessagePipe(&c, &d);
 
   // Send |a| over |c|, immediately close |b|, then send |a| back over |d|.
   WriteMessageWithHandles(c, "foo", &a, 1);
   EXPECT_EQ("foo", ReadMessageWithHandles(d, &a, 1));
   WriteMessageWithHandles(d, "bar", &a, 1);
@@ skipping 22 matching lines @@
   // the parent, just for some extra proxying goodness.
   WriteMessageWithHandles(c, "foo", &pipe[1], 1);
   EXPECT_EQ("foo", ReadMessageWithHandles(d, &pipe[1], 1));
 
   // And finally pass it back to the parent.
   WriteMessageWithHandles(h, "bar", &pipe[1], 1);
 
   EXPECT_EQ("quit", ReadMessage(h));
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_WriteCloseSendPeer DISABLED_WriteCloseSendPeer
-#else
-#define MAYBE_WriteCloseSendPeer WriteCloseSendPeer
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_WriteCloseSendPeer) {
+TEST_F(MultiprocessMessagePipeTest, WriteCloseSendPeer) {
   MojoHandle pipe[2];
   CreateMessagePipe(&pipe[0], &pipe[1]);
 
   RUN_CHILD_ON_PIPE(WriteCloseSendPeerClient, h)
     // Pass the pipe to the child.
     WriteMessageWithHandles(h, "foo", pipe, 2);
 
     // Read back an endpoint which should have messages on it.
     MojoHandle p;
     EXPECT_EQ("bar", ReadMessageWithHandles(h, &p, 1));
@@ skipping 19 matching lines @@
             edk::PassWrappedPlatformHandle(channel_handle, &channel));
   ASSERT_TRUE(channel.is_valid());
 
   // Create a new pipe using our end of the channel.
   ScopedMessagePipeHandle pipe = edk::CreateMessagePipe(std::move(channel));
 
   // Ensure that we can read and write on the new pipe.
   VerifyEcho(pipe.get().value(), "goodbye");
 }
 
-#if defined(OS_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_BootstrapMessagePipeAsync DISABLED_BootstrapMessagePipeAsync
-#else
-#define MAYBE_BootstrapMessagePipeAsync BootstrapMessagePipeAsync
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_BootstrapMessagePipeAsync) {
+TEST_F(MultiprocessMessagePipeTest, BootstrapMessagePipeAsync) {
   // Tests that new cross-process message pipes can be created synchronously
   // using asynchronous negotiation over an arbitrary platform channel.
   RUN_CHILD_ON_PIPE(BootstrapMessagePipeAsyncClient, child)
     // Pass one end of a platform channel to the child.
     PlatformChannelPair platform_channel;
     MojoHandle client_channel_handle;
     EXPECT_EQ(MOJO_RESULT_OK,
               CreatePlatformHandleWrapper(platform_channel.PassClientHandle(),
                                           &client_channel_handle));
     WriteMessageWithHandles(child, "hi", &client_channel_handle, 1);
 
     // Create a new pipe using our end of the channel.
     ScopedMessagePipeHandle pipe =
         edk::CreateMessagePipe(platform_channel.PassServerHandle());
 
     // Ensure that we can read and write on the new pipe.
     VerifyEcho(pipe.get().value(), "goodbye");
   END_CHILD()
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo