mojo/edk/test/multiprocess_test_helper_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/edk/test/multiprocess_test_helper.h"
   6
   7 #include "base/logging.h"
   8 #include "build/build_config.h"
   9 #include "mojo/edk/embedder/scoped_platform_handle.h"
  10 #include "mojo/edk/test/test_utils.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 #if defined(OS_POSIX)
  14 #include <fcntl.h>
  15 #endif
  16
  17 namespace mojo {
  18 namespace test {
  19 namespace {
  20
  21 bool IsNonBlocking(const embedder::PlatformHandle& handle) {
  22 #if defined(OS_WIN)
  23   // Haven't figured out a way to query whether a HANDLE was created with
  24   // FILE_FLAG_OVERLAPPED.
  25   return true;
  26 #else
  27   return fcntl(handle.fd, F_GETFL) & O_NONBLOCK;
  28 #endif
  29 }
  30
  31 bool WriteByte(const embedder::PlatformHandle& handle, char c) {
  32   size_t bytes_written = 0;
  33   BlockingWrite(handle, &c, 1, &bytes_written);
  34   return bytes_written == 1;
  35 }
  36
  37 bool ReadByte(const embedder::PlatformHandle& handle, char* c) {
  38   size_t bytes_read = 0;
  39   BlockingRead(handle, c, 1, &bytes_read);
  40   return bytes_read == 1;
  41 }
  42
  43 typedef testing::Test MultiprocessTestHelperTest;
  44
  45 #if defined(OS_ANDROID)
  46 // Android multi-process tests are not executing the new process. This is flaky.
  47 #define MAYBE_RunChild DISABLED_RunChild
  48 #else
  49 #define MAYBE_RunChild RunChild
  50 #endif  // defined(OS_ANDROID)
  51 TEST_F(MultiprocessTestHelperTest, MAYBE_RunChild) {
  52   MultiprocessTestHelper helper;
  53   EXPECT_TRUE(helper.server_platform_handle.is_valid());
  54
  55   helper.StartChild("RunChild");
  56   EXPECT_EQ(123, helper.WaitForChildShutdown());
  57 }
  58
  59 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(RunChild) {
  60   CHECK(MultiprocessTestHelper::client_platform_handle.is_valid());
  61   return 123;
  62 }
  63
  64 #if defined(OS_ANDROID)
  65 // Android multi-process tests are not executing the new process. This is flaky.
  66 #define MAYBE_TestChildMainNotFound DISABLED_TestChildMainNotFound
  67 #else
  68 #define MAYBE_TestChildMainNotFound TestChildMainNotFound
  69 #endif  // defined(OS_ANDROID)
  70 TEST_F(MultiprocessTestHelperTest, MAYBE_TestChildMainNotFound) {
  71   MultiprocessTestHelper helper;
  72   helper.StartChild("NoSuchTestChildMain");
  73   int result = helper.WaitForChildShutdown();
  74   EXPECT_FALSE(result >= 0 && result <= 127);
  75 }
  76
  77 #if defined(OS_ANDROID)
  78 // Android multi-process tests are not executing the new process. This is flaky.
  79 #define MAYBE_PassedChannel DISABLED_PassedChannel
  80 #else
  81 #define MAYBE_PassedChannel PassedChannel
  82 #endif  // defined(OS_ANDROID)
  83 TEST_F(MultiprocessTestHelperTest, MAYBE_PassedChannel) {
  84   MultiprocessTestHelper helper;
  85   EXPECT_TRUE(helper.server_platform_handle.is_valid());
  86   helper.StartChild("PassedChannel");
  87
  88   // Take ownership of the handle.
  89   embedder::ScopedPlatformHandle handle = helper.server_platform_handle.Pass();
  90
  91   // The handle should be non-blocking.
  92   EXPECT_TRUE(IsNonBlocking(handle.get()));
  93
  94   // Write a byte.
  95   const char c = 'X';
  96   EXPECT_TRUE(WriteByte(handle.get(), c));
  97
  98   // It'll echo it back to us, incremented.
  99   char d = 0;
 100   EXPECT_TRUE(ReadByte(handle.get(), &d));
 101   EXPECT_EQ(c + 1, d);
 102
 103   // And return it, incremented again.
 104   EXPECT_EQ(c + 2, helper.WaitForChildShutdown());
 105 }
 106
 107 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(PassedChannel) {
 108   CHECK(MultiprocessTestHelper::client_platform_handle.is_valid());
 109
 110   // Take ownership of the handle.
 111   embedder::ScopedPlatformHandle handle =
 112       MultiprocessTestHelper::client_platform_handle.Pass();
 113
 114   // The handle should be non-blocking.
 115   EXPECT_TRUE(IsNonBlocking(handle.get()));
 116
 117   // Read a byte.
 118   char c = 0;
 119   EXPECT_TRUE(ReadByte(handle.get(), &c));
 120
 121   // Write it back, incremented.
 122   c++;
 123   EXPECT_TRUE(WriteByte(handle.get(), c));
 124
 125   // And return it, incremented again.
 126   c++;
 127   return static_cast<int>(c);
 128 }
 129
 130 #if defined(OS_ANDROID)
 131 // Android multi-process tests are not executing the new process. This is flaky.
 132 #define MAYBE_ChildTestPasses DISABLED_ChildTestPasses
 133 #else
 134 #define MAYBE_ChildTestPasses ChildTestPasses
 135 #endif  // defined(OS_ANDROID)
 136 TEST_F(MultiprocessTestHelperTest, MAYBE_ChildTestPasses) {
 137   MultiprocessTestHelper helper;
 138   EXPECT_TRUE(helper.server_platform_handle.is_valid());
 139   helper.StartChild("ChildTestPasses");
 140   EXPECT_TRUE(helper.WaitForChildTestShutdown());
 141 }
 142
 143 MOJO_MULTIPROCESS_TEST_CHILD_TEST(ChildTestPasses) {
 144   ASSERT_TRUE(MultiprocessTestHelper::client_platform_handle.is_valid());
 145   EXPECT_TRUE(
 146       IsNonBlocking(MultiprocessTestHelper::client_platform_handle.get()));
 147 }
 148
 149 #if defined(OS_ANDROID)
 150 // Android multi-process tests are not executing the new process. This is flaky.
 151 #define MAYBE_ChildTestFailsAssert DISABLED_ChildTestFailsAssert
 152 #else
 153 #define MAYBE_ChildTestFailsAssert ChildTestFailsAssert
 154 #endif  // defined(OS_ANDROID)
 155 TEST_F(MultiprocessTestHelperTest, MAYBE_ChildTestFailsAssert) {
 156   MultiprocessTestHelper helper;
 157   EXPECT_TRUE(helper.server_platform_handle.is_valid());
 158   helper.StartChild("ChildTestFailsAssert");
 159   EXPECT_FALSE(helper.WaitForChildTestShutdown());
 160 }
 161
 162 MOJO_MULTIPROCESS_TEST_CHILD_TEST(ChildTestFailsAssert) {
 163   ASSERT_FALSE(MultiprocessTestHelper::client_platform_handle.is_valid())
 164       << "DISREGARD: Expected failure in child process";
 165   ASSERT_FALSE(
 166       IsNonBlocking(MultiprocessTestHelper::client_platform_handle.get()))
 167       << "Not reached";
 168   CHECK(false) << "Not reached";
 169 }
 170
 171 #if defined(OS_ANDROID)
 172 // Android multi-process tests are not executing the new process. This is flaky.
 173 #define MAYBE_ChildTestFailsExpect DISABLED_ChildTestFailsExpect
 174 #else
 175 #define MAYBE_ChildTestFailsExpect ChildTestFailsExpect
 176 #endif  // defined(OS_ANDROID)
 177 TEST_F(MultiprocessTestHelperTest, MAYBE_ChildTestFailsExpect) {
 178   MultiprocessTestHelper helper;
 179   EXPECT_TRUE(helper.server_platform_handle.is_valid());
 180   helper.StartChild("ChildTestFailsExpect");
 181   EXPECT_FALSE(helper.WaitForChildTestShutdown());
 182 }
 183
 184 MOJO_MULTIPROCESS_TEST_CHILD_TEST(ChildTestFailsExpect) {
 185   EXPECT_FALSE(MultiprocessTestHelper::client_platform_handle.is_valid())
 186       << "DISREGARD: Expected failure #1 in child process";
 187   EXPECT_FALSE(
 188       IsNonBlocking(MultiprocessTestHelper::client_platform_handle.get()))
 189       << "DISREGARD: Expected failure #2 in child process";
 190 }
 191
 192 }  // namespace
 193 }  // namespace test
 194 }  // namespace mojo