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> |
(...skipping 23 matching lines...) Expand all Loading... |
34 MojoHandleSignals sig; | 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 // Wait: |
44 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 44 EXPECT_EQ( |
45 MojoWait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, 1000000, | 45 MOJO_RESULT_INVALID_ARGUMENT, |
46 nullptr)); | 46 MojoWait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, 0, nullptr)); |
47 | 47 |
48 h0 = MOJO_HANDLE_INVALID; | 48 h0 = MOJO_HANDLE_INVALID; |
49 sig = ~MOJO_HANDLE_SIGNAL_NONE; | 49 sig = ~MOJO_HANDLE_SIGNAL_NONE; |
50 EXPECT_EQ( | 50 EXPECT_EQ( |
51 MOJO_RESULT_INVALID_ARGUMENT, | 51 MOJO_RESULT_INVALID_ARGUMENT, |
52 MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE, nullptr, nullptr)); | 52 MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE, nullptr, nullptr)); |
53 | 53 |
54 // Message pipe: | 54 // Message pipe: |
55 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 55 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
56 MojoWriteMessage(h0, buffer, 3, nullptr, 0, | 56 MojoWriteMessage(h0, buffer, 3, nullptr, 0, |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
91 MojoHandleSignals sig; | 91 MojoHandleSignals sig; |
92 char buffer[10] = {0}; | 92 char buffer[10] = {0}; |
93 uint32_t buffer_size; | 93 uint32_t buffer_size; |
94 | 94 |
95 h0 = MOJO_HANDLE_INVALID; | 95 h0 = MOJO_HANDLE_INVALID; |
96 h1 = MOJO_HANDLE_INVALID; | 96 h1 = MOJO_HANDLE_INVALID; |
97 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1)); | 97 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1)); |
98 EXPECT_NE(h0, MOJO_HANDLE_INVALID); | 98 EXPECT_NE(h0, MOJO_HANDLE_INVALID); |
99 EXPECT_NE(h1, MOJO_HANDLE_INVALID); | 99 EXPECT_NE(h1, MOJO_HANDLE_INVALID); |
100 | 100 |
101 // Shouldn't be readable, we haven't written anything. | 101 // Shouldn't be readable, we haven't written anything. Should be writable. |
102 MojoHandleSignalsState state; | 102 MojoHandleSignalsState state; |
103 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | 103 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(h0, &state)); |
104 MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 0, &state)); | |
105 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | 104 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); |
106 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 105 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
107 | 106 |
108 // Should be writable. | |
109 EXPECT_EQ(MOJO_RESULT_OK, | |
110 MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &state)); | |
111 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | |
112 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | |
113 | |
114 // Last parameter is optional. | 107 // Last parameter is optional. |
115 EXPECT_EQ(MOJO_RESULT_OK, | 108 EXPECT_EQ(MOJO_RESULT_OK, |
116 MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, nullptr)); | 109 MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, nullptr)); |
117 | 110 |
118 // Try to read. | 111 // Try to read. |
119 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 112 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
120 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | 113 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, |
121 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | 114 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, |
122 MOJO_READ_MESSAGE_FLAG_NONE)); | 115 MOJO_READ_MESSAGE_FLAG_NONE)); |
123 | 116 |
(...skipping 16 matching lines...) Expand all Loading... |
140 | 133 |
141 // Read from |h0|. | 134 // Read from |h0|. |
142 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 135 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
143 EXPECT_EQ(MOJO_RESULT_OK, | 136 EXPECT_EQ(MOJO_RESULT_OK, |
144 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | 137 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, |
145 MOJO_READ_MESSAGE_FLAG_NONE)); | 138 MOJO_READ_MESSAGE_FLAG_NONE)); |
146 EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size); | 139 EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size); |
147 EXPECT_STREQ(kHello, buffer); | 140 EXPECT_STREQ(kHello, buffer); |
148 | 141 |
149 // |h0| should no longer be readable. | 142 // |h0| should no longer be readable. |
150 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | 143 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(h0, &state)); |
151 MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 10, &state)); | |
152 | |
153 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | 144 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); |
154 EXPECT_EQ(kSignalAll, state.satisfiable_signals); | 145 EXPECT_EQ(kSignalAll, state.satisfiable_signals); |
155 | 146 |
156 // Close |h0|. | 147 // Close |h0|. |
157 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0)); | 148 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0)); |
158 | 149 |
159 EXPECT_EQ(MOJO_RESULT_OK, | 150 EXPECT_EQ(MOJO_RESULT_OK, |
160 MojoWait(h1, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 151 MojoWait(h1, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
161 MOJO_DEADLINE_INDEFINITE, &state)); | 152 MOJO_DEADLINE_INDEFINITE, &state)); |
162 | 153 |
163 // |h1| should no longer be readable or writable. | 154 // |h1| should no longer be readable or writable. |
164 EXPECT_EQ( | 155 EXPECT_EQ( |
165 MOJO_RESULT_FAILED_PRECONDITION, | 156 MOJO_RESULT_FAILED_PRECONDITION, |
166 MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | 157 MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
167 1000, &state)); | 158 MOJO_DEADLINE_INDEFINITE, &state)); |
168 | 159 |
169 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); | 160 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
170 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); | 161 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
171 | 162 |
172 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1)); | 163 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1)); |
173 } | 164 } |
174 | 165 |
175 TEST(CoreTest, BasicDataPipe) { | 166 TEST(CoreTest, BasicDataPipe) { |
176 MojoHandle hp, hc; | 167 MojoHandle hp, hc; |
177 MojoHandleSignals sig; | 168 MojoHandleSignals sig; |
178 char buffer[20] = {0}; | 169 char buffer[20] = {0}; |
179 uint32_t buffer_size; | 170 uint32_t buffer_size; |
180 void* write_pointer; | 171 void* write_pointer; |
181 const void* read_pointer; | 172 const void* read_pointer; |
182 | 173 |
183 hp = MOJO_HANDLE_INVALID; | 174 hp = MOJO_HANDLE_INVALID; |
184 hc = MOJO_HANDLE_INVALID; | 175 hc = MOJO_HANDLE_INVALID; |
185 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &hp, &hc)); | 176 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &hp, &hc)); |
186 EXPECT_NE(hp, MOJO_HANDLE_INVALID); | 177 EXPECT_NE(hp, MOJO_HANDLE_INVALID); |
187 EXPECT_NE(hc, MOJO_HANDLE_INVALID); | 178 EXPECT_NE(hc, MOJO_HANDLE_INVALID); |
188 | 179 |
189 // The consumer |hc| shouldn't be readable. | 180 // The consumer |hc| shouldn't be readable. |
190 MojoHandleSignalsState state; | 181 MojoHandleSignalsState state; |
191 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | 182 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(hc, &state)); |
192 MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 0, &state)); | |
193 | |
194 EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals); | 183 EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals); |
195 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 184 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
196 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 185 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
197 state.satisfiable_signals); | 186 state.satisfiable_signals); |
198 | 187 |
199 // The producer |hp| should be writable. | 188 // The producer |hp| should be writable. |
200 EXPECT_EQ(MOJO_RESULT_OK, | 189 EXPECT_EQ(MOJO_RESULT_OK, MojoQueryHandleSignalsState(hp, &state)); |
201 MojoWait(hp, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &state)); | |
202 | |
203 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | 190 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); |
204 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 191 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
205 state.satisfiable_signals); | 192 state.satisfiable_signals); |
206 | 193 |
207 // Try to read from |hc|. | 194 // Try to read from |hc|. |
208 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 195 buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
209 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | 196 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, |
210 MojoReadData(hc, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE)); | 197 MojoReadData(hc, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE)); |
211 | 198 |
212 // Try to begin a two-phase read from |hc|. | 199 // Try to begin a two-phase read from |hc|. |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
269 read_pointer = nullptr; | 256 read_pointer = nullptr; |
270 EXPECT_EQ(MOJO_RESULT_OK, MojoBeginReadData(hc, &read_pointer, &buffer_size, | 257 EXPECT_EQ(MOJO_RESULT_OK, MojoBeginReadData(hc, &read_pointer, &buffer_size, |
271 MOJO_READ_DATA_FLAG_NONE)); | 258 MOJO_READ_DATA_FLAG_NONE)); |
272 ASSERT_LE(buffer_size, sizeof(buffer) - 1); | 259 ASSERT_LE(buffer_size, sizeof(buffer) - 1); |
273 memcpy(&buffer[1], read_pointer, buffer_size); | 260 memcpy(&buffer[1], read_pointer, buffer_size); |
274 EXPECT_EQ(MOJO_RESULT_OK, MojoEndReadData(hc, buffer_size)); | 261 EXPECT_EQ(MOJO_RESULT_OK, MojoEndReadData(hc, buffer_size)); |
275 EXPECT_STREQ("hello world", buffer); | 262 EXPECT_STREQ("hello world", buffer); |
276 | 263 |
277 // |hc| should no longer be readable. | 264 // |hc| should no longer be readable. |
278 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 265 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
279 MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 1000, &state)); | 266 MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, |
| 267 &state)); |
280 | 268 |
281 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); | 269 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
282 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); | 270 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
283 | 271 |
284 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc)); | 272 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc)); |
285 | 273 |
286 // TODO(vtl): Test the other way around -- closing the consumer should make | 274 // TODO(vtl): Test the other way around -- closing the consumer should make |
287 // the producer never-writable? | 275 // the producer never-writable? |
288 } | 276 } |
289 | 277 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
339 // This checks that things actually work in C (not C++). | 327 // This checks that things actually work in C (not C++). |
340 TEST(CoreTest, MinimalCTest) { | 328 TEST(CoreTest, MinimalCTest) { |
341 const char* failure = MinimalCTest(); | 329 const char* failure = MinimalCTest(); |
342 EXPECT_FALSE(failure) << failure; | 330 EXPECT_FALSE(failure) << failure; |
343 } | 331 } |
344 | 332 |
345 // TODO(vtl): Add multi-threaded tests. | 333 // TODO(vtl): Add multi-threaded tests. |
346 | 334 |
347 } // namespace | 335 } // namespace |
348 } // namespace mojo | 336 } // namespace mojo |
OLD | NEW |