OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 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 API. | 5 // This file tests the C API. |
6 | 6 |
7 #include "mojo/public/c/system/core.h" | 7 #include "mojo/public/c/system/core.h" |
8 | 8 |
9 #include <stdint.h> | 9 #include <stdint.h> |
10 #include <string.h> | 10 #include <string.h> |
11 | 11 |
| 12 #include "mojo/public/cpp/system/wait.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
13 | 14 |
14 namespace mojo { | 15 namespace mojo { |
15 namespace { | 16 namespace { |
16 | 17 |
17 const MojoHandleSignals kSignalReadadableWritable = | 18 const MojoHandleSignals kSignalReadadableWritable = |
18 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE; | 19 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE; |
19 | 20 |
20 const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE | | 21 const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE | |
21 MOJO_HANDLE_SIGNAL_WRITABLE | | 22 MOJO_HANDLE_SIGNAL_WRITABLE | |
22 MOJO_HANDLE_SIGNAL_PEER_CLOSED; | 23 MOJO_HANDLE_SIGNAL_PEER_CLOSED; |
23 | 24 |
24 TEST(CoreTest, GetTimeTicksNow) { | 25 TEST(CoreTest, GetTimeTicksNow) { |
25 const MojoTimeTicks start = MojoGetTimeTicksNow(); | 26 const MojoTimeTicks start = MojoGetTimeTicksNow(); |
26 EXPECT_NE(static_cast<MojoTimeTicks>(0), start) | 27 EXPECT_NE(static_cast<MojoTimeTicks>(0), start) |
27 << "MojoGetTimeTicksNow should return nonzero value"; | 28 << "MojoGetTimeTicksNow should return nonzero value"; |
28 } | 29 } |
29 | 30 |
30 // The only handle that's guaranteed to be invalid is |MOJO_HANDLE_INVALID|. | 31 // The only handle that's guaranteed to be invalid is |MOJO_HANDLE_INVALID|. |
31 // Tests that everything that takes a handle properly recognizes it. | 32 // Tests that everything that takes a handle properly recognizes it. |
32 TEST(CoreTest, InvalidHandle) { | 33 TEST(CoreTest, InvalidHandle) { |
33 MojoHandle h0, h1; | 34 MojoHandle h0, h1; |
34 MojoHandleSignals sig; | |
35 char buffer[10] = {0}; | 35 char buffer[10] = {0}; |
36 uint32_t buffer_size; | 36 uint32_t buffer_size; |
37 void* write_pointer; | 37 void* write_pointer; |
38 const void* read_pointer; | 38 const void* read_pointer; |
39 | 39 |
40 // Close: | 40 // Close: |
41 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(MOJO_HANDLE_INVALID)); | 41 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(MOJO_HANDLE_INVALID)); |
42 | 42 |
43 // Wait: | 43 // Message pipe: |
44 EXPECT_EQ( | |
45 MOJO_RESULT_INVALID_ARGUMENT, | |
46 MojoWait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, 0, nullptr)); | |
47 | |
48 h0 = MOJO_HANDLE_INVALID; | 44 h0 = MOJO_HANDLE_INVALID; |
49 sig = ~MOJO_HANDLE_SIGNAL_NONE; | |
50 EXPECT_EQ( | |
51 MOJO_RESULT_INVALID_ARGUMENT, | |
52 MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE, nullptr, nullptr)); | |
53 | |
54 // Message pipe: | |
55 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 45 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
56 MojoWriteMessage(h0, buffer, 3, nullptr, 0, | 46 MojoWriteMessage(h0, buffer, 3, nullptr, 0, |
57 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 47 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
58 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 48 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
59 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 49 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
60 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | 50 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, |
61 MOJO_READ_MESSAGE_FLAG_NONE)); | 51 MOJO_READ_MESSAGE_FLAG_NONE)); |
62 | 52 |
63 // Data pipe: | 53 // Data pipe: |
64 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 54 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
97 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1)); | 87 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1)); |
98 EXPECT_NE(h0, MOJO_HANDLE_INVALID); | 88 EXPECT_NE(h0, MOJO_HANDLE_INVALID); |
99 EXPECT_NE(h1, MOJO_HANDLE_INVALID); | 89 EXPECT_NE(h1, MOJO_HANDLE_INVALID); |
100 | 90 |
101 // Shouldn't be readable, we haven't written anything. Should be writable. | 91 // Shouldn't be readable, we haven't written anything. Should be writable. |
102 MojoHandleSignalsState state; | 92 MojoHandleSignalsState state; |
103 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(h0, &state)); | 93 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(h0, &state)); |
104 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | 94 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); |
105 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 95 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
106 | 96 |
107 // Last parameter is optional. | |
108 EXPECT_EQ(MOJO_RESULT_OK, | |
109 MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, nullptr)); | |
110 | |
111 // Try to read. | 97 // Try to read. |
112 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 98 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
113 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | 99 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, |
114 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | 100 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, |
115 MOJO_READ_MESSAGE_FLAG_NONE)); | 101 MOJO_READ_MESSAGE_FLAG_NONE)); |
116 | 102 |
117 // Write to |h1|. | 103 // Write to |h1|. |
118 static const char kHello[] = "hello"; | 104 static const char kHello[] = "hello"; |
119 buffer_size = static_cast<uint32_t>(sizeof(kHello)); | 105 buffer_size = static_cast<uint32_t>(sizeof(kHello)); |
120 EXPECT_EQ(MOJO_RESULT_OK, MojoWriteMessage(h1, kHello, buffer_size, nullptr, | 106 EXPECT_EQ(MOJO_RESULT_OK, MojoWriteMessage(h1, kHello, buffer_size, nullptr, |
121 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 107 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
122 | 108 |
123 // |h0| should be readable. | 109 // |h0| should be readable. |
124 uint32_t result_index = 1; | 110 size_t result_index = 1; |
125 MojoHandleSignalsState states[1]; | 111 MojoHandleSignalsState states[1]; |
126 sig = MOJO_HANDLE_SIGNAL_READABLE; | 112 sig = MOJO_HANDLE_SIGNAL_READABLE; |
127 EXPECT_EQ(MOJO_RESULT_OK, MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE, | 113 Handle handle0(h0); |
128 &result_index, states)); | 114 EXPECT_EQ(MOJO_RESULT_OK, |
| 115 mojo::WaitMany(&handle0, &sig, 1, &result_index, states)); |
129 | 116 |
130 EXPECT_EQ(0u, result_index); | 117 EXPECT_EQ(0u, result_index); |
131 EXPECT_EQ(kSignalReadadableWritable, states[0].satisfied_signals); | 118 EXPECT_EQ(kSignalReadadableWritable, states[0].satisfied_signals); |
132 EXPECT_EQ(kSignalAll, states[0].satisfiable_signals); | 119 EXPECT_EQ(kSignalAll, states[0].satisfiable_signals); |
133 | 120 |
134 // Read from |h0|. | 121 // Read from |h0|. |
135 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 122 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
136 EXPECT_EQ(MOJO_RESULT_OK, | 123 EXPECT_EQ(MOJO_RESULT_OK, |
137 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | 124 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, |
138 MOJO_READ_MESSAGE_FLAG_NONE)); | 125 MOJO_READ_MESSAGE_FLAG_NONE)); |
139 EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size); | 126 EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size); |
140 EXPECT_STREQ(kHello, buffer); | 127 EXPECT_STREQ(kHello, buffer); |
141 | 128 |
142 // |h0| should no longer be readable. | 129 // |h0| should no longer be readable. |
143 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(h0, &state)); | 130 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(h0, &state)); |
144 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | 131 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); |
145 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 132 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
146 | 133 |
147 // Close |h0|. | 134 // Close |h0|. |
148 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0)); | 135 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0)); |
149 | 136 |
150 EXPECT_EQ(MOJO_RESULT_OK, | 137 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h1), |
151 MojoWait(h1, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 138 MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state)); |
152 MOJO_DEADLINE_INDEFINITE, &state)); | |
153 | 139 |
154 // |h1| should no longer be readable or writable. | 140 // |h1| should no longer be readable or writable. |
155 EXPECT_EQ( | 141 EXPECT_EQ( |
156 MOJO_RESULT_FAILED_PRECONDITION, | 142 MOJO_RESULT_FAILED_PRECONDITION, |
157 MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | 143 mojo::Wait(mojo::Handle(h1), |
158 MOJO_DEADLINE_INDEFINITE, &state)); | 144 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
| 145 &state)); |
159 | 146 |
160 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); | 147 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
161 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); | 148 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
162 | 149 |
163 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1)); | 150 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1)); |
164 } | 151 } |
165 | 152 |
166 TEST(CoreTest, BasicDataPipe) { | 153 TEST(CoreTest, BasicDataPipe) { |
167 MojoHandle hp, hc; | 154 MojoHandle hp, hc; |
168 MojoHandleSignals sig; | 155 MojoHandleSignals sig; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
203 MOJO_READ_DATA_FLAG_NONE)); | 190 MOJO_READ_DATA_FLAG_NONE)); |
204 | 191 |
205 // Write to |hp|. | 192 // Write to |hp|. |
206 static const char kHello[] = "hello "; | 193 static const char kHello[] = "hello "; |
207 // Don't include terminating null. | 194 // Don't include terminating null. |
208 buffer_size = static_cast<uint32_t>(strlen(kHello)); | 195 buffer_size = static_cast<uint32_t>(strlen(kHello)); |
209 EXPECT_EQ(MOJO_RESULT_OK, MojoWriteData(hp, kHello, &buffer_size, | 196 EXPECT_EQ(MOJO_RESULT_OK, MojoWriteData(hp, kHello, &buffer_size, |
210 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 197 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
211 | 198 |
212 // |hc| should be(come) readable. | 199 // |hc| should be(come) readable. |
213 uint32_t result_index = 1; | 200 size_t result_index = 1; |
214 MojoHandleSignalsState states[1]; | 201 MojoHandleSignalsState states[1]; |
215 sig = MOJO_HANDLE_SIGNAL_READABLE; | 202 sig = MOJO_HANDLE_SIGNAL_READABLE; |
216 EXPECT_EQ(MOJO_RESULT_OK, MojoWaitMany(&hc, &sig, 1, MOJO_DEADLINE_INDEFINITE, | 203 Handle consumer_handle(hc); |
217 &result_index, states)); | 204 EXPECT_EQ(MOJO_RESULT_OK, |
| 205 mojo::WaitMany(&consumer_handle, &sig, 1, &result_index, states)); |
218 | 206 |
219 EXPECT_EQ(0u, result_index); | 207 EXPECT_EQ(0u, result_index); |
220 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 208 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
221 states[0].satisfied_signals); | 209 states[0].satisfied_signals); |
222 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 210 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
223 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 211 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
224 states[0].satisfiable_signals); | 212 states[0].satisfiable_signals); |
225 | 213 |
226 // Do a two-phase write to |hp|. | 214 // Do a two-phase write to |hp|. |
227 EXPECT_EQ(MOJO_RESULT_OK, MojoBeginWriteData(hp, &write_pointer, &buffer_size, | 215 EXPECT_EQ(MOJO_RESULT_OK, MojoBeginWriteData(hp, &write_pointer, &buffer_size, |
228 MOJO_WRITE_DATA_FLAG_NONE)); | 216 MOJO_WRITE_DATA_FLAG_NONE)); |
229 static const char kWorld[] = "world"; | 217 static const char kWorld[] = "world"; |
230 ASSERT_GE(buffer_size, sizeof(kWorld)); | 218 ASSERT_GE(buffer_size, sizeof(kWorld)); |
231 // Include the terminating null. | 219 // Include the terminating null. |
232 memcpy(write_pointer, kWorld, sizeof(kWorld)); | 220 memcpy(write_pointer, kWorld, sizeof(kWorld)); |
233 EXPECT_EQ(MOJO_RESULT_OK, | 221 EXPECT_EQ(MOJO_RESULT_OK, |
234 MojoEndWriteData(hp, static_cast<uint32_t>(sizeof(kWorld)))); | 222 MojoEndWriteData(hp, static_cast<uint32_t>(sizeof(kWorld)))); |
235 | 223 |
236 // Read one character from |hc|. | 224 // Read one character from |hc|. |
237 memset(buffer, 0, sizeof(buffer)); | 225 memset(buffer, 0, sizeof(buffer)); |
238 buffer_size = 1; | 226 buffer_size = 1; |
239 EXPECT_EQ(MOJO_RESULT_OK, | 227 EXPECT_EQ(MOJO_RESULT_OK, |
240 MojoReadData(hc, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE)); | 228 MojoReadData(hc, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE)); |
241 | 229 |
242 // Close |hp|. | 230 // Close |hp|. |
243 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hp)); | 231 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hp)); |
244 | 232 |
245 // |hc| should still be readable. | 233 // |hc| should still be readable. |
246 EXPECT_EQ(MOJO_RESULT_OK, | 234 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(hc), |
247 MojoWait(hc, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 235 MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state)); |
248 MOJO_DEADLINE_INDEFINITE, &state)); | |
249 | 236 |
250 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 237 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
251 state.satisfied_signals); | 238 state.satisfied_signals); |
252 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 239 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
253 state.satisfiable_signals); | 240 state.satisfiable_signals); |
254 | 241 |
255 // Do a two-phase read from |hc|. | 242 // Do a two-phase read from |hc|. |
256 read_pointer = nullptr; | 243 read_pointer = nullptr; |
257 EXPECT_EQ(MOJO_RESULT_OK, MojoBeginReadData(hc, &read_pointer, &buffer_size, | 244 EXPECT_EQ(MOJO_RESULT_OK, MojoBeginReadData(hc, &read_pointer, &buffer_size, |
258 MOJO_READ_DATA_FLAG_NONE)); | 245 MOJO_READ_DATA_FLAG_NONE)); |
259 ASSERT_LE(buffer_size, sizeof(buffer) - 1); | 246 ASSERT_LE(buffer_size, sizeof(buffer) - 1); |
260 memcpy(&buffer[1], read_pointer, buffer_size); | 247 memcpy(&buffer[1], read_pointer, buffer_size); |
261 EXPECT_EQ(MOJO_RESULT_OK, MojoEndReadData(hc, buffer_size)); | 248 EXPECT_EQ(MOJO_RESULT_OK, MojoEndReadData(hc, buffer_size)); |
262 EXPECT_STREQ("hello world", buffer); | 249 EXPECT_STREQ("hello world", buffer); |
263 | 250 |
264 // |hc| should no longer be readable. | 251 // |hc| should no longer be readable. |
265 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 252 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
266 MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, | 253 mojo::Wait(mojo::Handle(hc), MOJO_HANDLE_SIGNAL_READABLE, &state)); |
267 &state)); | |
268 | 254 |
269 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); | 255 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
270 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); | 256 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
271 | 257 |
272 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc)); | 258 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc)); |
273 | 259 |
274 // TODO(vtl): Test the other way around -- closing the consumer should make | 260 // TODO(vtl): Test the other way around -- closing the consumer should make |
275 // the producer never-writable? | 261 // the producer never-writable? |
276 } | 262 } |
277 | 263 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 // This checks that things actually work in C (not C++). | 313 // This checks that things actually work in C (not C++). |
328 TEST(CoreTest, MinimalCTest) { | 314 TEST(CoreTest, MinimalCTest) { |
329 const char* failure = MinimalCTest(); | 315 const char* failure = MinimalCTest(); |
330 EXPECT_FALSE(failure) << failure; | 316 EXPECT_FALSE(failure) << failure; |
331 } | 317 } |
332 | 318 |
333 // TODO(vtl): Add multi-threaded tests. | 319 // TODO(vtl): Add multi-threaded tests. |
334 | 320 |
335 } // namespace | 321 } // namespace |
336 } // namespace mojo | 322 } // namespace mojo |
OLD | NEW |