| OLD | NEW |
|---|
| (Empty) |
| 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. | |
| 4 | |
| 5 #include "mojo/public/system/core_cpp.h" | |
| 6 | |
| 7 #include <map> | |
| 8 | |
| 9 #include "mojo/public/system/macros.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 | |
| 12 namespace mojo { | |
| 13 namespace { | |
| 14 | |
| 15 TEST(CoreCppTest, GetTimeTicksNow) { | |
| 16 const MojoTimeTicks start = GetTimeTicksNow(); | |
| 17 EXPECT_NE(static_cast<MojoTimeTicks>(0), start) | |
| 18 << "GetTimeTicksNow should return nonzero value"; | |
| 19 } | |
| 20 | |
| 21 TEST(CoreCppTest, Basic) { | |
| 22 // Basic |Handle| implementation: | |
| 23 { | |
| 24 EXPECT_EQ(MOJO_HANDLE_INVALID, kInvalidHandleValue); | |
| 25 | |
| 26 Handle h_0; | |
| 27 EXPECT_EQ(kInvalidHandleValue, h_0.value()); | |
| 28 EXPECT_EQ(kInvalidHandleValue, *h_0.mutable_value()); | |
| 29 EXPECT_FALSE(h_0.is_valid()); | |
| 30 | |
| 31 Handle h_1(static_cast<MojoHandle>(123)); | |
| 32 EXPECT_EQ(static_cast<MojoHandle>(123), h_1.value()); | |
| 33 EXPECT_EQ(static_cast<MojoHandle>(123), *h_1.mutable_value()); | |
| 34 EXPECT_TRUE(h_1.is_valid()); | |
| 35 *h_1.mutable_value() = static_cast<MojoHandle>(456); | |
| 36 EXPECT_EQ(static_cast<MojoHandle>(456), h_1.value()); | |
| 37 EXPECT_TRUE(h_1.is_valid()); | |
| 38 | |
| 39 h_1.swap(h_0); | |
| 40 EXPECT_EQ(static_cast<MojoHandle>(456), h_0.value()); | |
| 41 EXPECT_TRUE(h_0.is_valid()); | |
| 42 EXPECT_FALSE(h_1.is_valid()); | |
| 43 | |
| 44 h_1.set_value(static_cast<MojoHandle>(789)); | |
| 45 h_0.swap(h_1); | |
| 46 EXPECT_EQ(static_cast<MojoHandle>(789), h_0.value()); | |
| 47 EXPECT_TRUE(h_0.is_valid()); | |
| 48 EXPECT_EQ(static_cast<MojoHandle>(456), h_1.value()); | |
| 49 EXPECT_TRUE(h_1.is_valid()); | |
| 50 | |
| 51 // Make sure copy constructor works. | |
| 52 Handle h_2(h_0); | |
| 53 EXPECT_EQ(static_cast<MojoHandle>(789), h_2.value()); | |
| 54 // And assignment. | |
| 55 h_2 = h_1; | |
| 56 EXPECT_EQ(static_cast<MojoHandle>(456), h_2.value()); | |
| 57 | |
| 58 // Make sure that we can put |Handle|s into |std::map|s. | |
| 59 h_0 = Handle(static_cast<MojoHandle>(987)); | |
| 60 h_1 = Handle(static_cast<MojoHandle>(654)); | |
| 61 h_2 = Handle(static_cast<MojoHandle>(321)); | |
| 62 Handle h_3; | |
| 63 std::map<Handle, int> handle_to_int; | |
| 64 handle_to_int[h_0] = 0; | |
| 65 handle_to_int[h_1] = 1; | |
| 66 handle_to_int[h_2] = 2; | |
| 67 handle_to_int[h_3] = 3; | |
| 68 | |
| 69 EXPECT_EQ(4u, handle_to_int.size()); | |
| 70 EXPECT_FALSE(handle_to_int.find(h_0) == handle_to_int.end()); | |
| 71 EXPECT_EQ(0, handle_to_int[h_0]); | |
| 72 EXPECT_FALSE(handle_to_int.find(h_1) == handle_to_int.end()); | |
| 73 EXPECT_EQ(1, handle_to_int[h_1]); | |
| 74 EXPECT_FALSE(handle_to_int.find(h_2) == handle_to_int.end()); | |
| 75 EXPECT_EQ(2, handle_to_int[h_2]); | |
| 76 EXPECT_FALSE(handle_to_int.find(h_3) == handle_to_int.end()); | |
| 77 EXPECT_EQ(3, handle_to_int[h_3]); | |
| 78 EXPECT_TRUE(handle_to_int.find(Handle(static_cast<MojoHandle>(13579))) == | |
| 79 handle_to_int.end()); | |
| 80 | |
| 81 // TODO(vtl): With C++11, support |std::unordered_map|s, etc. (Or figure out | |
| 82 // how to support the variations of |hash_map|.) | |
| 83 } | |
| 84 | |
| 85 // |Handle|/|ScopedHandle| functions: | |
| 86 { | |
| 87 ScopedHandle h; | |
| 88 | |
| 89 EXPECT_EQ(kInvalidHandleValue, h.get().value()); | |
| 90 | |
| 91 // This should be a no-op. | |
| 92 Close(h.Pass()); | |
| 93 | |
| 94 // It should still be invalid. | |
| 95 EXPECT_EQ(kInvalidHandleValue, h.get().value()); | |
| 96 | |
| 97 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 98 Wait(h.get(), MOJO_WAIT_FLAG_EVERYTHING, 1000000)); | |
| 99 | |
| 100 std::vector<Handle> wh; | |
| 101 wh.push_back(h.get()); | |
| 102 std::vector<MojoWaitFlags> wf; | |
| 103 wf.push_back(MOJO_WAIT_FLAG_EVERYTHING); | |
| 104 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 105 WaitMany(wh, wf, MOJO_DEADLINE_INDEFINITE)); | |
| 106 } | |
| 107 | |
| 108 // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions: | |
| 109 { | |
| 110 MessagePipeHandle h_invalid; | |
| 111 EXPECT_FALSE(h_invalid.is_valid()); | |
| 112 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 113 WriteMessageRaw(h_invalid, | |
| 114 NULL, 0, | |
| 115 NULL, 0, | |
| 116 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 117 char buffer[10] = { 0 }; | |
| 118 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 119 WriteMessageRaw(h_invalid, | |
| 120 buffer, sizeof(buffer), | |
| 121 NULL, 0, | |
| 122 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 123 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 124 ReadMessageRaw(h_invalid, | |
| 125 NULL, NULL, | |
| 126 NULL, NULL, | |
| 127 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 128 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
| 129 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 130 ReadMessageRaw(h_invalid, | |
| 131 buffer, &buffer_size, | |
| 132 NULL, NULL, | |
| 133 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 134 | |
| 135 // Basic tests of waiting and closing. | |
| 136 MojoHandle hv_0 = kInvalidHandleValue; | |
| 137 { | |
| 138 ScopedMessagePipeHandle h_0; | |
| 139 ScopedMessagePipeHandle h_1; | |
| 140 EXPECT_FALSE(h_0.get().is_valid()); | |
| 141 EXPECT_FALSE(h_1.get().is_valid()); | |
| 142 | |
| 143 CreateMessagePipe(&h_0, &h_1); | |
| 144 EXPECT_TRUE(h_0.get().is_valid()); | |
| 145 EXPECT_TRUE(h_1.get().is_valid()); | |
| 146 EXPECT_NE(h_0.get().value(), h_1.get().value()); | |
| 147 // Save the handle values, so we can check that things got closed | |
| 148 // correctly. | |
| 149 hv_0 = h_0.get().value(); | |
| 150 MojoHandle hv_1 = h_1.get().value(); | |
| 151 | |
| 152 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
| 153 Wait(h_0.get(), MOJO_WAIT_FLAG_READABLE, 0)); | |
| 154 std::vector<Handle> wh; | |
| 155 wh.push_back(h_0.get()); | |
| 156 wh.push_back(h_1.get()); | |
| 157 std::vector<MojoWaitFlags> wf; | |
| 158 wf.push_back(MOJO_WAIT_FLAG_READABLE); | |
| 159 wf.push_back(MOJO_WAIT_FLAG_WRITABLE); | |
| 160 EXPECT_EQ(1, WaitMany(wh, wf, 1000)); | |
| 161 | |
| 162 // Test closing |h_1| explicitly. | |
| 163 Close(h_1.Pass()); | |
| 164 EXPECT_FALSE(h_1.get().is_valid()); | |
| 165 | |
| 166 // Make sure |h_1| is closed. | |
| 167 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 168 MojoWait(hv_1, | |
| 169 MOJO_WAIT_FLAG_EVERYTHING, | |
| 170 MOJO_DEADLINE_INDEFINITE)); | |
| 171 | |
| 172 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 173 Wait(h_0.get(), MOJO_WAIT_FLAG_READABLE, | |
| 174 MOJO_DEADLINE_INDEFINITE)); | |
| 175 } | |
| 176 // |hv_0| should have been closed when |h_0| went out of scope, so this | |
| 177 // close should fail. | |
| 178 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv_0)); | |
| 179 | |
| 180 // Actually test writing/reading messages. | |
| 181 { | |
| 182 ScopedMessagePipeHandle h_0; | |
| 183 ScopedMessagePipeHandle h_1; | |
| 184 CreateMessagePipe(&h_0, &h_1); | |
| 185 | |
| 186 const char kHello[] = "hello"; | |
| 187 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | |
| 188 EXPECT_EQ(MOJO_RESULT_OK, | |
| 189 WriteMessageRaw(h_0.get(), | |
| 190 kHello, kHelloSize, | |
| 191 NULL, 0, | |
| 192 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 193 EXPECT_EQ(MOJO_RESULT_OK, | |
| 194 Wait(h_1.get(), MOJO_WAIT_FLAG_READABLE, | |
| 195 MOJO_DEADLINE_INDEFINITE)); | |
| 196 char buffer[10] = { 0 }; | |
| 197 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
| 198 EXPECT_EQ(MOJO_RESULT_OK, | |
| 199 ReadMessageRaw(h_1.get(), | |
| 200 buffer, &buffer_size, | |
| 201 NULL, NULL, | |
| 202 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 203 EXPECT_EQ(kHelloSize, buffer_size); | |
| 204 EXPECT_STREQ(kHello, buffer); | |
| 205 | |
| 206 // Send a handle over the previously-establish |MessagePipe|. | |
| 207 ScopedMessagePipeHandle h_2; | |
| 208 ScopedMessagePipeHandle h_3; | |
| 209 CreateMessagePipe(&h_2, &h_3); | |
| 210 | |
| 211 // Write a message to |h_2|, before we send |h_3|. | |
| 212 const char kWorld[] = "world!"; | |
| 213 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | |
| 214 EXPECT_EQ(MOJO_RESULT_OK, | |
| 215 WriteMessageRaw(h_2.get(), | |
| 216 kWorld, kWorldSize, | |
| 217 NULL, 0, | |
| 218 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 219 | |
| 220 // Send |h_3| over |h_1| to |h_0|. | |
| 221 MojoHandle handles[5]; | |
| 222 handles[0] = h_3.release().value(); | |
| 223 EXPECT_NE(kInvalidHandleValue, handles[0]); | |
| 224 EXPECT_FALSE(h_3.get().is_valid()); | |
| 225 uint32_t handles_count = 1; | |
| 226 EXPECT_EQ(MOJO_RESULT_OK, | |
| 227 WriteMessageRaw(h_1.get(), | |
| 228 kHello, kHelloSize, | |
| 229 handles, handles_count, | |
| 230 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 231 // |handles[0]| should actually be invalid now. | |
| 232 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handles[0])); | |
| 233 | |
| 234 // Read "hello" and the sent handle. | |
| 235 EXPECT_EQ(MOJO_RESULT_OK, | |
| 236 Wait(h_0.get(), MOJO_WAIT_FLAG_READABLE, | |
| 237 MOJO_DEADLINE_INDEFINITE)); | |
| 238 memset(buffer, 0, sizeof(buffer)); | |
| 239 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
| 240 for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++) | |
| 241 handles[i] = kInvalidHandleValue; | |
| 242 handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles)); | |
| 243 EXPECT_EQ(MOJO_RESULT_OK, | |
| 244 ReadMessageRaw(h_0.get(), | |
| 245 buffer, &buffer_size, | |
| 246 handles, &handles_count, | |
| 247 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 248 EXPECT_EQ(kHelloSize, buffer_size); | |
| 249 EXPECT_STREQ(kHello, buffer); | |
| 250 EXPECT_EQ(1u, handles_count); | |
| 251 EXPECT_NE(kInvalidHandleValue, handles[0]); | |
| 252 | |
| 253 // Read from the sent/received handle. | |
| 254 h_3.reset(MessagePipeHandle(handles[0])); | |
| 255 // Save |handles[0]| to check that it gets properly closed. | |
| 256 hv_0 = handles[0]; | |
| 257 EXPECT_EQ(MOJO_RESULT_OK, | |
| 258 Wait(h_3.get(), MOJO_WAIT_FLAG_READABLE, | |
| 259 MOJO_DEADLINE_INDEFINITE)); | |
| 260 memset(buffer, 0, sizeof(buffer)); | |
| 261 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
| 262 for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++) | |
| 263 handles[i] = kInvalidHandleValue; | |
| 264 handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles)); | |
| 265 EXPECT_EQ(MOJO_RESULT_OK, | |
| 266 ReadMessageRaw(h_3.get(), | |
| 267 buffer, &buffer_size, | |
| 268 handles, &handles_count, | |
| 269 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 270 EXPECT_EQ(kWorldSize, buffer_size); | |
| 271 EXPECT_STREQ(kWorld, buffer); | |
| 272 EXPECT_EQ(0u, handles_count); | |
| 273 } | |
| 274 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv_0)); | |
| 275 } | |
| 276 | |
| 277 // TODO(vtl): Test |CloseRaw()|. | |
| 278 // TODO(vtl): Test |reset()| more thoroughly? | |
| 279 } | |
| 280 | |
| 281 TEST(CoreCppTest, TearDownWithMessagesEnqueued) { | |
| 282 // Tear down a |MessagePipe| which still has a message enqueued, with the | |
| 283 // message also having a valid |MessagePipe| handle. | |
| 284 { | |
| 285 ScopedMessagePipeHandle h_0; | |
| 286 ScopedMessagePipeHandle h_1; | |
| 287 CreateMessagePipe(&h_0, &h_1); | |
| 288 | |
| 289 // Send a handle over the previously-establish |MessagePipe|. | |
| 290 ScopedMessagePipeHandle h_2; | |
| 291 ScopedMessagePipeHandle h_3; | |
| 292 CreateMessagePipe(&h_2, &h_3); | |
| 293 | |
| 294 // Write a message to |h_2|, before we send |h_3|. | |
| 295 const char kWorld[] = "world!"; | |
| 296 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | |
| 297 EXPECT_EQ(MOJO_RESULT_OK, | |
| 298 WriteMessageRaw(h_2.get(), | |
| 299 kWorld, kWorldSize, | |
| 300 NULL, 0, | |
| 301 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 302 // And also a message to |h_3|. | |
| 303 EXPECT_EQ(MOJO_RESULT_OK, | |
| 304 WriteMessageRaw(h_3.get(), | |
| 305 kWorld, kWorldSize, | |
| 306 NULL, 0, | |
| 307 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 308 | |
| 309 // Send |h_3| over |h_1| to |h_0|. | |
| 310 const char kHello[] = "hello"; | |
| 311 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | |
| 312 MojoHandle h_3_value; | |
| 313 h_3_value = h_3.release().value(); | |
| 314 EXPECT_NE(kInvalidHandleValue, h_3_value); | |
| 315 EXPECT_FALSE(h_3.get().is_valid()); | |
| 316 EXPECT_EQ(MOJO_RESULT_OK, | |
| 317 WriteMessageRaw(h_1.get(), | |
| 318 kHello, kHelloSize, | |
| 319 &h_3_value, 1, | |
| 320 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 321 // |h_3_value| should actually be invalid now. | |
| 322 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h_3_value)); | |
| 323 | |
| 324 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_0.release().value())); | |
| 325 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_1.release().value())); | |
| 326 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_2.release().value())); | |
| 327 } | |
| 328 | |
| 329 // Do this in a different order: make the enqueued |MessagePipe| handle only | |
| 330 // half-alive. | |
| 331 { | |
| 332 ScopedMessagePipeHandle h_0; | |
| 333 ScopedMessagePipeHandle h_1; | |
| 334 CreateMessagePipe(&h_0, &h_1); | |
| 335 | |
| 336 // Send a handle over the previously-establish |MessagePipe|. | |
| 337 ScopedMessagePipeHandle h_2; | |
| 338 ScopedMessagePipeHandle h_3; | |
| 339 CreateMessagePipe(&h_2, &h_3); | |
| 340 | |
| 341 // Write a message to |h_2|, before we send |h_3|. | |
| 342 const char kWorld[] = "world!"; | |
| 343 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | |
| 344 EXPECT_EQ(MOJO_RESULT_OK, | |
| 345 WriteMessageRaw(h_2.get(), | |
| 346 kWorld, kWorldSize, | |
| 347 NULL, 0, | |
| 348 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 349 // And also a message to |h_3|. | |
| 350 EXPECT_EQ(MOJO_RESULT_OK, | |
| 351 WriteMessageRaw(h_3.get(), | |
| 352 kWorld, kWorldSize, | |
| 353 NULL, 0, | |
| 354 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 355 | |
| 356 // Send |h_3| over |h_1| to |h_0|. | |
| 357 const char kHello[] = "hello"; | |
| 358 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | |
| 359 MojoHandle h_3_value; | |
| 360 h_3_value = h_3.release().value(); | |
| 361 EXPECT_NE(kInvalidHandleValue, h_3_value); | |
| 362 EXPECT_FALSE(h_3.get().is_valid()); | |
| 363 EXPECT_EQ(MOJO_RESULT_OK, | |
| 364 WriteMessageRaw(h_1.get(), | |
| 365 kHello, kHelloSize, | |
| 366 &h_3_value, 1, | |
| 367 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 368 // |h_3_value| should actually be invalid now. | |
| 369 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h_3_value)); | |
| 370 | |
| 371 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_2.release().value())); | |
| 372 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_0.release().value())); | |
| 373 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_1.release().value())); | |
| 374 } | |
| 375 } | |
| 376 | |
| 377 // TODO(vtl): Write data pipe tests. | |
| 378 | |
| 379 } // namespace | |
| 380 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 134823005:
Mojo: re-organize public tests (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src