Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(9)

Side by Side Diff: mojo/public/c/system/tests/core_unittest.cc

Issue 2750273002: Revert of Mojo EDK: Introduce MojoQueryHandleSignalsState API (Closed)
Patch Set: Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « mojo/public/c/system/functions.h ('k') | mojo/public/c/system/tests/core_unittest_pure_c.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « mojo/public/c/system/functions.h ('k') | mojo/public/c/system/tests/core_unittest_pure_c.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698