OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // This file tests the C++ Mojo system core wrappers. | 5 // This file tests the C++ Mojo system core wrappers. |
6 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets | 6 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets |
7 // compiled into a different binary from the C API tests. | 7 // compiled into a different binary from the C API tests. |
8 | 8 |
9 #include "mojo/public/cpp/system/core.h" | 9 #include "mojo/public/cpp/system/core.h" |
10 | 10 |
11 #include <stddef.h> | 11 #include <stddef.h> |
12 #include <stdint.h> | 12 #include <stdint.h> |
13 #include <map> | 13 #include <map> |
14 #include <utility> | 14 #include <utility> |
15 | 15 |
| 16 #include "mojo/public/cpp/system/wait.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
17 | 18 |
18 namespace mojo { | 19 namespace mojo { |
19 namespace { | 20 namespace { |
20 | 21 |
21 const MojoHandleSignals kSignalReadableWritable = | 22 const MojoHandleSignals kSignalReadableWritable = |
22 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE; | 23 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE; |
23 | 24 |
24 const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE | | 25 const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE | |
25 MOJO_HANDLE_SIGNAL_WRITABLE | | 26 MOJO_HANDLE_SIGNAL_WRITABLE | |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 | 102 |
102 EXPECT_EQ(kInvalidHandleValue, h.get().value()); | 103 EXPECT_EQ(kInvalidHandleValue, h.get().value()); |
103 | 104 |
104 // This should be a no-op. | 105 // This should be a no-op. |
105 Close(std::move(h)); | 106 Close(std::move(h)); |
106 | 107 |
107 // It should still be invalid. | 108 // It should still be invalid. |
108 EXPECT_EQ(kInvalidHandleValue, h.get().value()); | 109 EXPECT_EQ(kInvalidHandleValue, h.get().value()); |
109 | 110 |
110 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 111 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
111 Wait(h.get(), ~MOJO_HANDLE_SIGNAL_NONE, 1000000, nullptr)); | 112 Wait(h.get(), ~MOJO_HANDLE_SIGNAL_NONE)); |
112 | 113 |
113 std::vector<Handle> wh; | 114 std::vector<Handle> wh; |
114 wh.push_back(h.get()); | 115 wh.push_back(h.get()); |
115 std::vector<MojoHandleSignals> sigs; | 116 std::vector<MojoHandleSignals> sigs; |
116 sigs.push_back(~MOJO_HANDLE_SIGNAL_NONE); | 117 sigs.push_back(~MOJO_HANDLE_SIGNAL_NONE); |
117 WaitManyResult wait_many_result = | 118 size_t result_index; |
118 WaitMany(wh, sigs, MOJO_DEADLINE_INDEFINITE, nullptr); | 119 MojoResult rv = WaitMany(wh.data(), sigs.data(), wh.size(), &result_index); |
119 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, wait_many_result.result); | 120 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, rv); |
120 EXPECT_TRUE(wait_many_result.IsIndexValid()); | |
121 EXPECT_FALSE(wait_many_result.AreSignalsStatesValid()); | |
122 | |
123 // Make sure that our specialized template correctly handles |NULL| as well | |
124 // as |nullptr|. | |
125 wait_many_result = WaitMany(wh, sigs, MOJO_DEADLINE_INDEFINITE, NULL); | |
126 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, wait_many_result.result); | |
127 EXPECT_EQ(0u, wait_many_result.index); | |
128 EXPECT_TRUE(wait_many_result.IsIndexValid()); | |
129 EXPECT_FALSE(wait_many_result.AreSignalsStatesValid()); | |
130 } | 121 } |
131 | 122 |
132 // |MakeScopedHandle| (just compilation tests): | 123 // |MakeScopedHandle| (just compilation tests): |
133 { | 124 { |
134 EXPECT_FALSE(MakeScopedHandle(Handle()).is_valid()); | 125 EXPECT_FALSE(MakeScopedHandle(Handle()).is_valid()); |
135 EXPECT_FALSE(MakeScopedHandle(MessagePipeHandle()).is_valid()); | 126 EXPECT_FALSE(MakeScopedHandle(MessagePipeHandle()).is_valid()); |
136 EXPECT_FALSE(MakeScopedHandle(DataPipeProducerHandle()).is_valid()); | 127 EXPECT_FALSE(MakeScopedHandle(DataPipeProducerHandle()).is_valid()); |
137 EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid()); | 128 EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid()); |
138 EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid()); | 129 EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid()); |
139 } | 130 } |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
179 EXPECT_FALSE(h1.get().is_valid()); | 170 EXPECT_FALSE(h1.get().is_valid()); |
180 | 171 |
181 CreateMessagePipe(nullptr, &h0, &h1); | 172 CreateMessagePipe(nullptr, &h0, &h1); |
182 EXPECT_TRUE(h0.get().is_valid()); | 173 EXPECT_TRUE(h0.get().is_valid()); |
183 EXPECT_TRUE(h1.get().is_valid()); | 174 EXPECT_TRUE(h1.get().is_valid()); |
184 EXPECT_NE(h0.get().value(), h1.get().value()); | 175 EXPECT_NE(h0.get().value(), h1.get().value()); |
185 // Save the handle values, so we can check that things got closed | 176 // Save the handle values, so we can check that things got closed |
186 // correctly. | 177 // correctly. |
187 hv0 = h0.get().value(); | 178 hv0 = h0.get().value(); |
188 MojoHandle hv1 = h1.get().value(); | 179 MojoHandle hv1 = h1.get().value(); |
189 MojoHandleSignalsState state; | 180 MojoHandleSignalsState state = h0->QuerySignalsState(); |
190 | |
191 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
192 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, 0, &state)); | |
193 | 181 |
194 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | 182 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); |
195 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 183 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
196 | 184 |
197 std::vector<Handle> wh; | 185 std::vector<Handle> wh; |
198 wh.push_back(h0.get()); | 186 wh.push_back(h0.get()); |
199 wh.push_back(h1.get()); | 187 wh.push_back(h1.get()); |
200 std::vector<MojoHandleSignals> sigs; | 188 std::vector<MojoHandleSignals> sigs; |
201 sigs.push_back(MOJO_HANDLE_SIGNAL_READABLE); | 189 sigs.push_back(MOJO_HANDLE_SIGNAL_READABLE); |
202 sigs.push_back(MOJO_HANDLE_SIGNAL_WRITABLE); | 190 sigs.push_back(MOJO_HANDLE_SIGNAL_WRITABLE); |
203 std::vector<MojoHandleSignalsState> states(sigs.size()); | 191 std::vector<MojoHandleSignalsState> states(sigs.size()); |
204 WaitManyResult wait_many_result = WaitMany(wh, sigs, 1000, &states); | 192 |
205 EXPECT_EQ(MOJO_RESULT_OK, wait_many_result.result); | 193 size_t result_index; |
206 EXPECT_EQ(1u, wait_many_result.index); | 194 MojoResult rv = WaitMany(wh.data(), sigs.data(), wh.size(), &result_index, |
207 EXPECT_TRUE(wait_many_result.IsIndexValid()); | 195 states.data()); |
208 EXPECT_TRUE(wait_many_result.AreSignalsStatesValid()); | 196 EXPECT_EQ(MOJO_RESULT_OK, rv); |
| 197 EXPECT_EQ(1u, result_index); |
209 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, states[0].satisfied_signals); | 198 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, states[0].satisfied_signals); |
210 EXPECT_EQ(kSignalAll, states[0].satisfiable_signals); | 199 EXPECT_EQ(kSignalAll, states[0].satisfiable_signals); |
211 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, states[1].satisfied_signals); | 200 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, states[1].satisfied_signals); |
212 EXPECT_EQ(kSignalAll, states[1].satisfiable_signals); | 201 EXPECT_EQ(kSignalAll, states[1].satisfiable_signals); |
213 | 202 |
214 // Test closing |h1| explicitly. | 203 // Test closing |h1| explicitly. |
215 Close(std::move(h1)); | 204 Close(std::move(h1)); |
216 EXPECT_FALSE(h1.get().is_valid()); | 205 EXPECT_FALSE(h1.get().is_valid()); |
217 | 206 |
218 // Make sure |h1| is closed. | 207 // Make sure |h1| is closed. |
219 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 208 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
220 Wait(Handle(hv1), ~MOJO_HANDLE_SIGNAL_NONE, | 209 Wait(Handle(hv1), ~MOJO_HANDLE_SIGNAL_NONE)); |
221 MOJO_DEADLINE_INDEFINITE, nullptr)); | |
222 | 210 |
223 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 211 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
224 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, | 212 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, &state)); |
225 MOJO_DEADLINE_INDEFINITE, &state)); | |
226 | 213 |
227 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); | 214 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
228 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); | 215 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
229 } | 216 } |
230 // |hv0| should have been closed when |h0| went out of scope, so this close | 217 // |hv0| should have been closed when |h0| went out of scope, so this close |
231 // should fail. | 218 // should fail. |
232 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0)); | 219 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0)); |
233 | 220 |
234 // Actually test writing/reading messages. | 221 // Actually test writing/reading messages. |
235 { | 222 { |
236 ScopedMessagePipeHandle h0; | 223 ScopedMessagePipeHandle h0; |
237 ScopedMessagePipeHandle h1; | 224 ScopedMessagePipeHandle h1; |
238 CreateMessagePipe(nullptr, &h0, &h1); | 225 CreateMessagePipe(nullptr, &h0, &h1); |
239 | 226 |
240 const char kHello[] = "hello"; | 227 const char kHello[] = "hello"; |
241 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | 228 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); |
242 EXPECT_EQ(MOJO_RESULT_OK, | 229 EXPECT_EQ(MOJO_RESULT_OK, |
243 WriteMessageRaw(h0.get(), | 230 WriteMessageRaw(h0.get(), |
244 kHello, | 231 kHello, |
245 kHelloSize, | 232 kHelloSize, |
246 nullptr, | 233 nullptr, |
247 0, | 234 0, |
248 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 235 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
249 | 236 |
250 MojoHandleSignalsState state; | 237 MojoHandleSignalsState state; |
251 EXPECT_EQ(MOJO_RESULT_OK, Wait(h1.get(), MOJO_HANDLE_SIGNAL_READABLE, | 238 EXPECT_EQ(MOJO_RESULT_OK, |
252 MOJO_DEADLINE_INDEFINITE, &state)); | 239 Wait(h1.get(), MOJO_HANDLE_SIGNAL_READABLE, &state)); |
253 EXPECT_EQ(kSignalReadableWritable, state.satisfied_signals); | 240 EXPECT_EQ(kSignalReadableWritable, state.satisfied_signals); |
254 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 241 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
255 | 242 |
256 char buffer[10] = {0}; | 243 char buffer[10] = {0}; |
257 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 244 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
258 EXPECT_EQ(MOJO_RESULT_OK, | 245 EXPECT_EQ(MOJO_RESULT_OK, |
259 ReadMessageRaw(h1.get(), | 246 ReadMessageRaw(h1.get(), |
260 buffer, | 247 buffer, |
261 &buffer_size, | 248 &buffer_size, |
262 nullptr, | 249 nullptr, |
(...skipping 28 matching lines...) Expand all Loading... |
291 WriteMessageRaw(h1.get(), | 278 WriteMessageRaw(h1.get(), |
292 kHello, | 279 kHello, |
293 kHelloSize, | 280 kHelloSize, |
294 handles, | 281 handles, |
295 handles_count, | 282 handles_count, |
296 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 283 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
297 // |handles[0]| should actually be invalid now. | 284 // |handles[0]| should actually be invalid now. |
298 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handles[0])); | 285 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handles[0])); |
299 | 286 |
300 // Read "hello" and the sent handle. | 287 // Read "hello" and the sent handle. |
301 EXPECT_EQ(MOJO_RESULT_OK, Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, | 288 EXPECT_EQ(MOJO_RESULT_OK, |
302 MOJO_DEADLINE_INDEFINITE, &state)); | 289 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, &state)); |
303 EXPECT_EQ(kSignalReadableWritable, state.satisfied_signals); | 290 EXPECT_EQ(kSignalReadableWritable, state.satisfied_signals); |
304 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 291 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
305 | 292 |
306 memset(buffer, 0, sizeof(buffer)); | 293 memset(buffer, 0, sizeof(buffer)); |
307 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 294 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
308 for (size_t i = 0; i < arraysize(handles); i++) | 295 for (size_t i = 0; i < arraysize(handles); i++) |
309 handles[i] = kInvalidHandleValue; | 296 handles[i] = kInvalidHandleValue; |
310 handles_count = static_cast<uint32_t>(arraysize(handles)); | 297 handles_count = static_cast<uint32_t>(arraysize(handles)); |
311 EXPECT_EQ(MOJO_RESULT_OK, | 298 EXPECT_EQ(MOJO_RESULT_OK, |
312 ReadMessageRaw(h0.get(), | 299 ReadMessageRaw(h0.get(), |
313 buffer, | 300 buffer, |
314 &buffer_size, | 301 &buffer_size, |
315 handles, | 302 handles, |
316 &handles_count, | 303 &handles_count, |
317 MOJO_READ_MESSAGE_FLAG_NONE)); | 304 MOJO_READ_MESSAGE_FLAG_NONE)); |
318 EXPECT_EQ(kHelloSize, buffer_size); | 305 EXPECT_EQ(kHelloSize, buffer_size); |
319 EXPECT_STREQ(kHello, buffer); | 306 EXPECT_STREQ(kHello, buffer); |
320 EXPECT_EQ(1u, handles_count); | 307 EXPECT_EQ(1u, handles_count); |
321 EXPECT_NE(kInvalidHandleValue, handles[0]); | 308 EXPECT_NE(kInvalidHandleValue, handles[0]); |
322 | 309 |
323 // Read from the sent/received handle. | 310 // Read from the sent/received handle. |
324 mp.handle1.reset(MessagePipeHandle(handles[0])); | 311 mp.handle1.reset(MessagePipeHandle(handles[0])); |
325 // Save |handles[0]| to check that it gets properly closed. | 312 // Save |handles[0]| to check that it gets properly closed. |
326 hv0 = handles[0]; | 313 hv0 = handles[0]; |
327 | 314 |
328 EXPECT_EQ(MOJO_RESULT_OK, | 315 EXPECT_EQ(MOJO_RESULT_OK, |
329 Wait(mp.handle1.get(), MOJO_HANDLE_SIGNAL_READABLE, | 316 Wait(mp.handle1.get(), MOJO_HANDLE_SIGNAL_READABLE, &state)); |
330 MOJO_DEADLINE_INDEFINITE, &state)); | |
331 EXPECT_EQ(kSignalReadableWritable, state.satisfied_signals); | 317 EXPECT_EQ(kSignalReadableWritable, state.satisfied_signals); |
332 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 318 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
333 | 319 |
334 memset(buffer, 0, sizeof(buffer)); | 320 memset(buffer, 0, sizeof(buffer)); |
335 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 321 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
336 for (size_t i = 0; i < arraysize(handles); i++) | 322 for (size_t i = 0; i < arraysize(handles); i++) |
337 handles[i] = kInvalidHandleValue; | 323 handles[i] = kInvalidHandleValue; |
338 handles_count = static_cast<uint32_t>(arraysize(handles)); | 324 handles_count = static_cast<uint32_t>(arraysize(handles)); |
339 EXPECT_EQ(MOJO_RESULT_OK, | 325 EXPECT_EQ(MOJO_RESULT_OK, |
340 ReadMessageRaw(mp.handle1.get(), | 326 ReadMessageRaw(mp.handle1.get(), |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
515 h1.reset(); | 501 h1.reset(); |
516 | 502 |
517 // Creating a 1 EB shared buffer should fail without crashing. | 503 // Creating a 1 EB shared buffer should fail without crashing. |
518 EXPECT_FALSE(SharedBufferHandle::Create(1ULL << 60).is_valid()); | 504 EXPECT_FALSE(SharedBufferHandle::Create(1ULL << 60).is_valid()); |
519 } | 505 } |
520 | 506 |
521 // TODO(vtl): Write data pipe tests. | 507 // TODO(vtl): Write data pipe tests. |
522 | 508 |
523 } // namespace | 509 } // namespace |
524 } // namespace mojo | 510 } // namespace mojo |
OLD | NEW |