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