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.
5 // This file tests the C++ Mojo system core wrappers.
6 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets
7 // compiled into a different binary from the C API tests.
9 #include "mojo/public/cpp/system/core.h"
13 #include "mojo/public/cpp/system/macros.h"
14 #include "testing/gtest/include/gtest/gtest.h"
19 TEST(CoreCppTest, GetTimeTicksNow) {
20 const MojoTimeTicks start = GetTimeTicksNow();
21 EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
22 << "GetTimeTicksNow should return nonzero value";
25 TEST(CoreCppTest, Basic) {
26 // Basic |Handle| implementation:
28 EXPECT_EQ(MOJO_HANDLE_INVALID, kInvalidHandleValue);
31 EXPECT_EQ(kInvalidHandleValue, h0.value());
32 EXPECT_EQ(kInvalidHandleValue, *h0.mutable_value());
33 EXPECT_FALSE(h0.is_valid());
35 Handle h1(static_cast<MojoHandle>(123));
36 EXPECT_EQ(static_cast<MojoHandle>(123), h1.value());
37 EXPECT_EQ(static_cast<MojoHandle>(123), *h1.mutable_value());
38 EXPECT_TRUE(h1.is_valid());
39 *h1.mutable_value() = static_cast<MojoHandle>(456);
40 EXPECT_EQ(static_cast<MojoHandle>(456), h1.value());
41 EXPECT_TRUE(h1.is_valid());
44 EXPECT_EQ(static_cast<MojoHandle>(456), h0.value());
45 EXPECT_TRUE(h0.is_valid());
46 EXPECT_FALSE(h1.is_valid());
48 h1.set_value(static_cast<MojoHandle>(789));
50 EXPECT_EQ(static_cast<MojoHandle>(789), h0.value());
51 EXPECT_TRUE(h0.is_valid());
52 EXPECT_EQ(static_cast<MojoHandle>(456), h1.value());
53 EXPECT_TRUE(h1.is_valid());
55 // Make sure copy constructor works.
57 EXPECT_EQ(static_cast<MojoHandle>(789), h2.value());
60 EXPECT_EQ(static_cast<MojoHandle>(456), h2.value());
62 // Make sure that we can put |Handle|s into |std::map|s.
63 h0 = Handle(static_cast<MojoHandle>(987));
64 h1 = Handle(static_cast<MojoHandle>(654));
65 h2 = Handle(static_cast<MojoHandle>(321));
67 std::map<Handle, int> handle_to_int;
68 handle_to_int[h0] = 0;
69 handle_to_int[h1] = 1;
70 handle_to_int[h2] = 2;
71 handle_to_int[h3] = 3;
73 EXPECT_EQ(4u, handle_to_int.size());
74 EXPECT_FALSE(handle_to_int.find(h0) == handle_to_int.end());
75 EXPECT_EQ(0, handle_to_int[h0]);
76 EXPECT_FALSE(handle_to_int.find(h1) == handle_to_int.end());
77 EXPECT_EQ(1, handle_to_int[h1]);
78 EXPECT_FALSE(handle_to_int.find(h2) == handle_to_int.end());
79 EXPECT_EQ(2, handle_to_int[h2]);
80 EXPECT_FALSE(handle_to_int.find(h3) == handle_to_int.end());
81 EXPECT_EQ(3, handle_to_int[h3]);
82 EXPECT_TRUE(handle_to_int.find(Handle(static_cast<MojoHandle>(13579))) ==
85 // TODO(vtl): With C++11, support |std::unordered_map|s, etc. (Or figure out
86 // how to support the variations of |hash_map|.)
89 // |Handle|/|ScopedHandle| functions:
93 EXPECT_EQ(kInvalidHandleValue, h.get().value());
95 // This should be a no-op.
98 // It should still be invalid.
99 EXPECT_EQ(kInvalidHandleValue, h.get().value());
101 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
102 Wait(h.get(), MOJO_WAIT_FLAG_EVERYTHING, 1000000));
104 std::vector<Handle> wh;
105 wh.push_back(h.get());
106 std::vector<MojoWaitFlags> wf;
107 wf.push_back(MOJO_WAIT_FLAG_EVERYTHING);
108 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
109 WaitMany(wh, wf, MOJO_DEADLINE_INDEFINITE));
112 // |MakeScopedHandle| (just compilation tests):
114 EXPECT_FALSE(MakeScopedHandle(Handle()).is_valid());
115 EXPECT_FALSE(MakeScopedHandle(MessagePipeHandle()).is_valid());
116 EXPECT_FALSE(MakeScopedHandle(DataPipeProducerHandle()).is_valid());
117 EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid());
118 EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid());
121 // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions:
123 MessagePipeHandle h_invalid;
124 EXPECT_FALSE(h_invalid.is_valid());
125 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
126 WriteMessageRaw(h_invalid,
129 MOJO_WRITE_MESSAGE_FLAG_NONE));
130 char buffer[10] = { 0 };
131 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
132 WriteMessageRaw(h_invalid,
133 buffer, sizeof(buffer),
135 MOJO_WRITE_MESSAGE_FLAG_NONE));
136 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
137 ReadMessageRaw(h_invalid,
140 MOJO_READ_MESSAGE_FLAG_NONE));
141 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
142 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
143 ReadMessageRaw(h_invalid,
144 buffer, &buffer_size,
146 MOJO_READ_MESSAGE_FLAG_NONE));
148 // Basic tests of waiting and closing.
149 MojoHandle hv0 = kInvalidHandleValue;
151 ScopedMessagePipeHandle h0;
152 ScopedMessagePipeHandle h1;
153 EXPECT_FALSE(h0.get().is_valid());
154 EXPECT_FALSE(h1.get().is_valid());
156 CreateMessagePipe(&h0, &h1);
157 EXPECT_TRUE(h0.get().is_valid());
158 EXPECT_TRUE(h1.get().is_valid());
159 EXPECT_NE(h0.get().value(), h1.get().value());
160 // Save the handle values, so we can check that things got closed
162 hv0 = h0.get().value();
163 MojoHandle hv1 = h1.get().value();
165 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
166 Wait(h0.get(), MOJO_WAIT_FLAG_READABLE, 0));
167 std::vector<Handle> wh;
168 wh.push_back(h0.get());
169 wh.push_back(h1.get());
170 std::vector<MojoWaitFlags> wf;
171 wf.push_back(MOJO_WAIT_FLAG_READABLE);
172 wf.push_back(MOJO_WAIT_FLAG_WRITABLE);
173 EXPECT_EQ(1, WaitMany(wh, wf, 1000));
175 // Test closing |h1| explicitly.
177 EXPECT_FALSE(h1.get().is_valid());
179 // Make sure |h1| is closed.
180 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
181 MojoWait(hv1, MOJO_WAIT_FLAG_EVERYTHING,
182 MOJO_DEADLINE_INDEFINITE));
184 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
185 Wait(h0.get(), MOJO_WAIT_FLAG_READABLE,
186 MOJO_DEADLINE_INDEFINITE));
188 // |hv0| should have been closed when |h0| went out of scope, so this close
190 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0));
192 // Actually test writing/reading messages.
194 ScopedMessagePipeHandle h0;
195 ScopedMessagePipeHandle h1;
196 CreateMessagePipe(&h0, &h1);
198 const char kHello[] = "hello";
199 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
200 EXPECT_EQ(MOJO_RESULT_OK,
201 WriteMessageRaw(h0.get(),
204 MOJO_WRITE_MESSAGE_FLAG_NONE));
205 EXPECT_EQ(MOJO_RESULT_OK,
206 Wait(h1.get(), MOJO_WAIT_FLAG_READABLE,
207 MOJO_DEADLINE_INDEFINITE));
208 char buffer[10] = { 0 };
209 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
210 EXPECT_EQ(MOJO_RESULT_OK,
211 ReadMessageRaw(h1.get(),
212 buffer, &buffer_size,
214 MOJO_READ_MESSAGE_FLAG_NONE));
215 EXPECT_EQ(kHelloSize, buffer_size);
216 EXPECT_STREQ(kHello, buffer);
218 // Send a handle over the previously-establish message pipe. Use the
219 // |MessagePipe| wrapper (to test it), which automatically creates a
223 // Write a message to |mp.handle0|, before we send |mp.handle1|.
224 const char kWorld[] = "world!";
225 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
226 EXPECT_EQ(MOJO_RESULT_OK,
227 WriteMessageRaw(mp.handle0.get(),
230 MOJO_WRITE_MESSAGE_FLAG_NONE));
232 // Send |mp.handle1| over |h1| to |h0|.
233 MojoHandle handles[5];
234 handles[0] = mp.handle1.release().value();
235 EXPECT_NE(kInvalidHandleValue, handles[0]);
236 EXPECT_FALSE(mp.handle1.get().is_valid());
237 uint32_t handles_count = 1;
238 EXPECT_EQ(MOJO_RESULT_OK,
239 WriteMessageRaw(h1.get(),
241 handles, handles_count,
242 MOJO_WRITE_MESSAGE_FLAG_NONE));
243 // |handles[0]| should actually be invalid now.
244 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handles[0]));
246 // Read "hello" and the sent handle.
247 EXPECT_EQ(MOJO_RESULT_OK,
248 Wait(h0.get(), MOJO_WAIT_FLAG_READABLE,
249 MOJO_DEADLINE_INDEFINITE));
250 memset(buffer, 0, sizeof(buffer));
251 buffer_size = static_cast<uint32_t>(sizeof(buffer));
252 for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++)
253 handles[i] = kInvalidHandleValue;
254 handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles));
255 EXPECT_EQ(MOJO_RESULT_OK,
256 ReadMessageRaw(h0.get(),
257 buffer, &buffer_size,
258 handles, &handles_count,
259 MOJO_READ_MESSAGE_FLAG_NONE));
260 EXPECT_EQ(kHelloSize, buffer_size);
261 EXPECT_STREQ(kHello, buffer);
262 EXPECT_EQ(1u, handles_count);
263 EXPECT_NE(kInvalidHandleValue, handles[0]);
265 // Read from the sent/received handle.
266 mp.handle1.reset(MessagePipeHandle(handles[0]));
267 // Save |handles[0]| to check that it gets properly closed.
269 EXPECT_EQ(MOJO_RESULT_OK,
270 Wait(mp.handle1.get(), MOJO_WAIT_FLAG_READABLE,
271 MOJO_DEADLINE_INDEFINITE));
272 memset(buffer, 0, sizeof(buffer));
273 buffer_size = static_cast<uint32_t>(sizeof(buffer));
274 for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++)
275 handles[i] = kInvalidHandleValue;
276 handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles));
277 EXPECT_EQ(MOJO_RESULT_OK,
278 ReadMessageRaw(mp.handle1.get(),
279 buffer, &buffer_size,
280 handles, &handles_count,
281 MOJO_READ_MESSAGE_FLAG_NONE));
282 EXPECT_EQ(kWorldSize, buffer_size);
283 EXPECT_STREQ(kWorld, buffer);
284 EXPECT_EQ(0u, handles_count);
286 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0));
289 // TODO(vtl): Test |CloseRaw()|.
290 // TODO(vtl): Test |reset()| more thoroughly?
293 TEST(CoreCppTest, TearDownWithMessagesEnqueued) {
294 // Tear down a message pipe which still has a message enqueued, with the
295 // message also having a valid message pipe handle.
297 ScopedMessagePipeHandle h0;
298 ScopedMessagePipeHandle h1;
299 CreateMessagePipe(&h0, &h1);
301 // Send a handle over the previously-establish message pipe.
302 ScopedMessagePipeHandle h2;
303 ScopedMessagePipeHandle h3;
304 CreateMessagePipe(&h2, &h3);
306 // Write a message to |h2|, before we send |h3|.
307 const char kWorld[] = "world!";
308 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
309 EXPECT_EQ(MOJO_RESULT_OK,
310 WriteMessageRaw(h2.get(),
313 MOJO_WRITE_MESSAGE_FLAG_NONE));
314 // And also a message to |h3|.
315 EXPECT_EQ(MOJO_RESULT_OK,
316 WriteMessageRaw(h3.get(),
319 MOJO_WRITE_MESSAGE_FLAG_NONE));
321 // Send |h3| over |h1| to |h0|.
322 const char kHello[] = "hello";
323 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
325 h3_value = h3.release().value();
326 EXPECT_NE(kInvalidHandleValue, h3_value);
327 EXPECT_FALSE(h3.get().is_valid());
328 EXPECT_EQ(MOJO_RESULT_OK,
329 WriteMessageRaw(h1.get(),
332 MOJO_WRITE_MESSAGE_FLAG_NONE));
333 // |h3_value| should actually be invalid now.
334 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value));
336 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value()));
337 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value()));
338 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value()));
341 // Do this in a different order: make the enqueued message pipe handle only
344 ScopedMessagePipeHandle h0;
345 ScopedMessagePipeHandle h1;
346 CreateMessagePipe(&h0, &h1);
348 // Send a handle over the previously-establish message pipe.
349 ScopedMessagePipeHandle h2;
350 ScopedMessagePipeHandle h3;
351 CreateMessagePipe(&h2, &h3);
353 // Write a message to |h2|, before we send |h3|.
354 const char kWorld[] = "world!";
355 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
356 EXPECT_EQ(MOJO_RESULT_OK,
357 WriteMessageRaw(h2.get(),
360 MOJO_WRITE_MESSAGE_FLAG_NONE));
361 // And also a message to |h3|.
362 EXPECT_EQ(MOJO_RESULT_OK,
363 WriteMessageRaw(h3.get(),
366 MOJO_WRITE_MESSAGE_FLAG_NONE));
368 // Send |h3| over |h1| to |h0|.
369 const char kHello[] = "hello";
370 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
372 h3_value = h3.release().value();
373 EXPECT_NE(kInvalidHandleValue, h3_value);
374 EXPECT_FALSE(h3.get().is_valid());
375 EXPECT_EQ(MOJO_RESULT_OK,
376 WriteMessageRaw(h1.get(),
379 MOJO_WRITE_MESSAGE_FLAG_NONE));
380 // |h3_value| should actually be invalid now.
381 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value));
383 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value()));
384 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value()));
385 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value()));
389 // TODO(vtl): Write data pipe tests.