OLD | NEW |
| (Empty) |
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 | |
OLD | NEW |