[mojo-edk] Bring most tests back up on 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 754 matching lines @@
                              h) {
   for (;;) {
     std::string message = ReadMessage(h);
     if (message == "exit")
       break;
     WriteMessage(h, message);
   }
   return 0;
 }
 
-TEST_F(MultiprocessMessagePipeTest, MultiprocessChannelPipe) {
+#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) {
   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;
 }
 
-TEST_F(MultiprocessMessagePipeTest, PassMessagePipeCrossProcess) {
+#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) {
   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;
 }
 
-TEST_F(MultiprocessMessagePipeTest, PassMoarMessagePipesCrossProcess) {
+#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) {
   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);
 }
 
-TEST_F(MultiprocessMessagePipeTest, ChannelPipesWithMultipleChildren) {
+#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) {
   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));
 }
 
-TEST_F(MultiprocessMessagePipeTest, PingPongPipe) {
+#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) {
   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;
 }
 
-TEST_F(MultiprocessMessagePipeTest, ChildToChildPipes) {
+#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) {
   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()
 }
 
-TEST_F(MultiprocessMessagePipeTest, MoreChildToChildPipes) {
+#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) {
   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));
 }
 
-TEST_F(MultiprocessMessagePipeTest, SendPipeThenClosePeer) {
+#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) {
   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 30 matching lines @@
 
   // Wait for the service client to signal closure.
   EXPECT_EQ(MOJO_RESULT_OK, MojoWait(service_client,
                                      MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                                      MOJO_DEADLINE_INDEFINITE, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(service_client));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(application_client));
 }
 
-TEST_F(MultiprocessMessagePipeTest, SendPipeWithClosedPeerBetweenChildren) {
+#if defined(OS_ANDROID)
+// Android multi-process tests are not executing the new process. This is flaky.
+#define MAYBE_SendPipeWithClosedPeerBetweenChildren \
+    DISABLED_SendPipeWithClosedPeerBetweenChildren
+#else
+#define MAYBE_SendPipeWithClosedPeerBetweenChildren \
+    SendPipeWithClosedPeerBetweenChildren
+#endif
+TEST_F(MultiprocessMessagePipeTest,
+       MAYBE_SendPipeWithClosedPeerBetweenChildren) {
   RUN_CHILD_ON_PIPE(SendOtherChildPipeWithClosedPeer, kid_a)
     RUN_CHILD_ON_PIPE(ReceivePipeWithClosedPeerFromOtherChild, kid_b)
       // Receive an "application request" from the first child and forward it
       // to the second child.
       MojoHandle application_request;
       EXPECT_EQ("c2a plz",
                 ReadMessageWithHandles(kid_a, &application_request, 1));
 
       WriteMessageWithHandles(kid_b, "c2a", &application_request, 1);
     END_CHILD()
 
     WriteMessage(kid_a, "quit");
   END_CHILD()
 }
 
-TEST_F(MultiprocessMessagePipeTest, SendClosePeerSend) {
+
+#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) {
   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));
 }
 
-TEST_F(MultiprocessMessagePipeTest, WriteCloseSendPeer) {
+#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) {
   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");
 }
 
-TEST_F(MultiprocessMessagePipeTest, BootstrapMessagePipeAsync) {
+#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) {
   // 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