Index: mojo/edk/system/core_unittest.cc |
diff --git a/third_party/mojo/src/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc |
similarity index 68% |
copy from third_party/mojo/src/mojo/edk/system/core_unittest.cc |
copy to mojo/edk/system/core_unittest.cc |
index 979cfbd15ffaacc9698223245a5b7764e9ef8be8..9daaaafcee910f9647a861cf53faa6655a74005b 100644 |
--- a/third_party/mojo/src/mojo/edk/system/core_unittest.cc |
+++ b/mojo/edk/system/core_unittest.cc |
@@ -2,20 +2,21 @@ |
// Use of this source code is governed by a BSD-style license that can be |
// found in the LICENSE file. |
-#include "third_party/mojo/src/mojo/edk/system/core.h" |
+#include "mojo/edk/system/core.h" |
#include <stdint.h> |
#include <limits> |
#include "base/bind.h" |
+#include "mojo/edk/embedder/embedder_internal.h" |
+#include "mojo/edk/system/awakable.h" |
+#include "mojo/edk/system/core_test_base.h" |
+#include "mojo/edk/system/test_utils.h" |
#include "mojo/public/cpp/system/macros.h" |
-#include "third_party/mojo/src/mojo/edk/system/awakable.h" |
-#include "third_party/mojo/src/mojo/edk/system/core_test_base.h" |
-#include "third_party/mojo/src/mojo/edk/system/test_utils.h" |
namespace mojo { |
-namespace system { |
+namespace edk { |
namespace { |
const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u}; |
@@ -47,7 +48,7 @@ TEST_F(CoreTest, Basic) { |
EXPECT_EQ(0u, info.GetWriteMessageCallCount()); |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0, |
+ core()->WriteMessage(h, nullptr, 0, nullptr, 0, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetWriteMessageCallCount()); |
@@ -55,25 +56,22 @@ TEST_F(CoreTest, Basic) { |
uint32_t num_bytes = 0; |
EXPECT_EQ( |
MOJO_RESULT_OK, |
- core()->ReadMessage(h, NullUserPointer(), MakeUserPointer(&num_bytes), |
- NullUserPointer(), NullUserPointer(), |
+ core()->ReadMessage(h, nullptr, &num_bytes, nullptr, nullptr, |
MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetReadMessageCallCount()); |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->ReadMessage(h, NullUserPointer(), NullUserPointer(), |
- NullUserPointer(), NullUserPointer(), |
+ core()->ReadMessage(h, nullptr, nullptr, nullptr, nullptr, |
MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(2u, info.GetReadMessageCallCount()); |
EXPECT_EQ(0u, info.GetWriteDataCallCount()); |
EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
- core()->WriteData(h, NullUserPointer(), NullUserPointer(), |
- MOJO_WRITE_DATA_FLAG_NONE)); |
+ core()->WriteData(h, nullptr, nullptr, MOJO_WRITE_DATA_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetWriteDataCallCount()); |
EXPECT_EQ(0u, info.GetBeginWriteDataCallCount()); |
EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
- core()->BeginWriteData(h, NullUserPointer(), NullUserPointer(), |
+ core()->BeginWriteData(h, nullptr, nullptr, |
MOJO_WRITE_DATA_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetBeginWriteDataCallCount()); |
@@ -83,13 +81,12 @@ TEST_F(CoreTest, Basic) { |
EXPECT_EQ(0u, info.GetReadDataCallCount()); |
EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
- core()->ReadData(h, NullUserPointer(), NullUserPointer(), |
- MOJO_READ_DATA_FLAG_NONE)); |
+ core()->ReadData(h, nullptr, nullptr, MOJO_READ_DATA_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetReadDataCallCount()); |
EXPECT_EQ(0u, info.GetBeginReadDataCallCount()); |
EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
- core()->BeginReadData(h, NullUserPointer(), NullUserPointer(), |
+ core()->BeginReadData(h, nullptr, nullptr, |
MOJO_READ_DATA_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetBeginReadDataCallCount()); |
@@ -100,26 +97,25 @@ TEST_F(CoreTest, Basic) { |
EXPECT_EQ(0u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, |
- NullUserPointer())); |
+ nullptr)); |
EXPECT_EQ(1u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
- core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer())); |
+ core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, nullptr)); |
EXPECT_EQ(2u, info.GetAddAwakableCallCount()); |
MojoHandleSignalsState hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(3u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(0u, hss.satisfiable_signals); |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, NullUserPointer())); |
+ core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, nullptr)); |
EXPECT_EQ(4u, info.GetAddAwakableCallCount()); |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
- core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, |
- MakeUserPointer(&hss))); |
+ core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, &hss)); |
EXPECT_EQ(5u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(0u, hss.satisfiable_signals); |
@@ -127,24 +123,21 @@ TEST_F(CoreTest, Basic) { |
MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE, |
+ nullptr, nullptr)); |
EXPECT_EQ(6u, info.GetAddAwakableCallCount()); |
uint32_t result_index = static_cast<uint32_t>(-1); |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- NullUserPointer())); |
+ core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE, |
+ &result_index, nullptr)); |
EXPECT_EQ(7u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(0u, result_index); |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- MakeUserPointer(&hss))); |
+ core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE, |
+ nullptr, &hss)); |
EXPECT_EQ(8u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(0u, hss.satisfiable_signals); |
@@ -152,9 +145,8 @@ TEST_F(CoreTest, Basic) { |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- MakeUserPointer(&hss))); |
+ core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE, |
+ &result_index, &hss)); |
EXPECT_EQ(9u, info.GetAddAwakableCallCount()); |
EXPECT_EQ(0u, result_index); |
EXPECT_EQ(0u, hss.satisfied_signals); |
@@ -192,15 +184,15 @@ TEST_F(CoreTest, InvalidArguments) { |
{ |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer())); |
+ MOJO_DEADLINE_INDEFINITE, nullptr)); |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer())); |
+ MOJO_DEADLINE_INDEFINITE, nullptr)); |
MojoHandleSignalsState hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss))); |
+ MOJO_DEADLINE_INDEFINITE, &hss)); |
// On invalid argument, it shouldn't modify the handle signals state. |
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, |
hss.satisfied_signals); |
@@ -209,7 +201,7 @@ TEST_F(CoreTest, InvalidArguments) { |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss))); |
+ MOJO_DEADLINE_INDEFINITE, &hss)); |
// On invalid argument, it shouldn't modify the handle signals state. |
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, |
hss.satisfied_signals); |
@@ -224,23 +216,19 @@ TEST_F(CoreTest, InvalidArguments) { |
~MOJO_HANDLE_SIGNAL_NONE}; |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 0, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(handles, signals, 0, MOJO_DEADLINE_INDEFINITE, |
+ nullptr, nullptr)); |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(nullptr, signals, 0, MOJO_DEADLINE_INDEFINITE, |
+ nullptr, nullptr)); |
// If |num_handles| is invalid, it should leave |result_index| and |
// |signals_states| alone. |
// (We use -1 internally; make sure that doesn't leak.) |
uint32_t result_index = 123; |
MojoHandleSignalsState hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0, |
- MOJO_DEADLINE_INDEFINITE, |
- MakeUserPointer(&result_index), |
- MakeUserPointer(&hss))); |
+ core()->WaitMany(nullptr, signals, 0, MOJO_DEADLINE_INDEFINITE, |
+ &result_index, &hss)); |
EXPECT_EQ(123u, result_index); |
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, |
hss.satisfied_signals); |
@@ -248,23 +236,20 @@ TEST_F(CoreTest, InvalidArguments) { |
hss.satisfiable_signals); |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 0, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(handles, nullptr, 0, MOJO_DEADLINE_INDEFINITE, |
+ nullptr, nullptr)); |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 1, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(handles, signals, 1, MOJO_DEADLINE_INDEFINITE, nullptr, |
+ nullptr)); |
// But if a handle is bad, then it should set |result_index| but still leave |
// |signals_states| alone. |
result_index = static_cast<uint32_t>(-1); |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
core()->WaitMany( |
- MakeUserPointer(handles), MakeUserPointer(signals), 1, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- MakeUserPointer(&hss))); |
+ handles, signals, 1, MOJO_DEADLINE_INDEFINITE, &result_index, |
+ &hss)); |
EXPECT_EQ(0u, result_index); |
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, |
hss.satisfied_signals); |
@@ -278,9 +263,8 @@ TEST_F(CoreTest, InvalidArguments) { |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
core()->WaitMany( |
- MakeUserPointer(handles), MakeUserPointer(signals), 1, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- MakeUserPointer(&hss))); |
+ handles, signals, 1, MOJO_DEADLINE_INDEFINITE, &result_index, |
+ &hss)); |
EXPECT_EQ(0u, result_index); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(0u, hss.satisfiable_signals); |
@@ -290,9 +274,8 @@ TEST_F(CoreTest, InvalidArguments) { |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
core()->WaitMany( |
- MakeUserPointer(handles), MakeUserPointer(signals), 2, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- MakeUserPointer(&hss))); |
+ handles, signals, 2, MOJO_DEADLINE_INDEFINITE, &result_index, |
+ &hss)); |
EXPECT_EQ(1u, result_index); |
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, |
hss.satisfied_signals); |
@@ -301,15 +284,13 @@ TEST_F(CoreTest, InvalidArguments) { |
handles[1] = handles[0] + 1; // Invalid handle. |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE, nullptr, |
+ nullptr)); |
handles[1] = CreateMockHandle(&info[1]); |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer())); |
+ core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE, nullptr, |
+ nullptr)); |
// TODO(vtl): Test one where we get "failed precondition" only for the |
// second handle (and the first one is valid to wait on). |
@@ -326,9 +307,8 @@ TEST_F(CoreTest, InvalidArguments) { |
// |num_handles|. |
{ |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WriteMessage(MOJO_HANDLE_INVALID, NullUserPointer(), 0, |
- NullUserPointer(), 0, |
- MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(MOJO_HANDLE_INVALID, nullptr, 0, |
+ nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
MockHandleInfo info; |
MojoHandle h = CreateMockHandle(&info); |
@@ -341,7 +321,7 @@ TEST_F(CoreTest, InvalidArguments) { |
// not. |
EXPECT_NE( |
MOJO_RESULT_OK, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
+ core()->WriteMessage(h, nullptr, 0, handles, |
std::numeric_limits<uint32_t>::max(), |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(0u, info.GetWriteMessageCallCount()); |
@@ -349,7 +329,7 @@ TEST_F(CoreTest, InvalidArguments) { |
// Huge handle count (plausibly big). |
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
core()->WriteMessage( |
- h, NullUserPointer(), 0, MakeUserPointer(handles), |
+ h, nullptr, 0, handles, |
std::numeric_limits<uint32_t>::max() / sizeof(handles[0]), |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(0u, info.GetWriteMessageCallCount()); |
@@ -357,23 +337,23 @@ TEST_F(CoreTest, InvalidArguments) { |
// Invalid handle in |handles|. |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 1, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(0u, info.GetWriteMessageCallCount()); |
// Two invalid handles in |handles|. |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 2, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(0u, info.GetWriteMessageCallCount()); |
// Can't send a handle over itself. |
handles[0] = h; |
EXPECT_EQ( |
MOJO_RESULT_BUSY, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 1, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(0u, info.GetWriteMessageCallCount()); |
MockHandleInfo info2; |
@@ -383,31 +363,31 @@ TEST_F(CoreTest, InvalidArguments) { |
handles[0] = h2; |
EXPECT_EQ( |
MOJO_RESULT_UNIMPLEMENTED, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 1, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetWriteMessageCallCount()); |
// One of the |handles| is still invalid. |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 2, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetWriteMessageCallCount()); |
// One of the |handles| is the same as |handle|. |
handles[1] = h; |
EXPECT_EQ( |
MOJO_RESULT_BUSY, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 2, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetWriteMessageCallCount()); |
// Can't send a handle twice in the same message. |
handles[1] = h2; |
EXPECT_EQ( |
MOJO_RESULT_BUSY, |
- core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), |
- 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h, nullptr, 0, handles, 2, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, info.GetWriteMessageCallCount()); |
// Note: Since we never successfully sent anything with it, |h2| should |
@@ -423,9 +403,8 @@ TEST_F(CoreTest, InvalidArguments) { |
{ |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->ReadMessage(MOJO_HANDLE_INVALID, NullUserPointer(), |
- NullUserPointer(), NullUserPointer(), |
- NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ core()->ReadMessage(MOJO_HANDLE_INVALID, nullptr, nullptr, nullptr, |
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); |
MockHandleInfo info; |
MojoHandle h = CreateMockHandle(&info); |
@@ -434,8 +413,8 @@ TEST_F(CoreTest, InvalidArguments) { |
uint32_t handle_count = 0; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h, NullUserPointer(), NullUserPointer(), NullUserPointer(), |
- MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h, nullptr, nullptr, nullptr, &handle_count, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
// Checked by |Core|, shouldn't go through to the dispatcher. |
EXPECT_EQ(1u, info.GetReadMessageCallCount()); |
@@ -457,14 +436,12 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { |
MojoHandle handle = MOJO_HANDLE_INVALID; |
MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE; |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer()), |
+ core()->WaitMany(nullptr, &signals, 1, MOJO_DEADLINE_INDEFINITE, |
+ nullptr, nullptr), |
kMemoryCheckFailedRegex); |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->WaitMany(MakeUserPointer(&handle), NullUserPointer(), 1, |
- MOJO_DEADLINE_INDEFINITE, NullUserPointer(), |
- NullUserPointer()), |
+ core()->WaitMany(&handle, nullptr, 1, MOJO_DEADLINE_INDEFINITE, nullptr, |
+ nullptr), |
kMemoryCheckFailedRegex); |
// TODO(vtl): |result_index| and |signals_states| are optional. Test them |
// with non-null invalid pointers? |
@@ -474,16 +451,13 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { |
{ |
MojoHandle h; |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(), |
- NullUserPointer()), |
+ core()->CreateMessagePipe(nullptr, nullptr, nullptr), |
kMemoryCheckFailedRegex); |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h), |
- NullUserPointer()), |
+ core()->CreateMessagePipe(nullptr, &h, nullptr), |
kMemoryCheckFailedRegex); |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(), |
- MakeUserPointer(&h)), |
+ core()->CreateMessagePipe(nullptr, nullptr, &h), |
kMemoryCheckFailedRegex); |
} |
@@ -496,7 +470,7 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { |
// Null |handles| with nonzero |num_handles|. |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 1, |
+ core()->WriteMessage(h, nullptr, 0, nullptr, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE), |
kMemoryCheckFailedRegex); |
@@ -512,8 +486,7 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { |
uint32_t handle_count = 1; |
EXPECT_DEATH_IF_SUPPORTED( |
- core()->ReadMessage(h, NullUserPointer(), NullUserPointer(), |
- NullUserPointer(), MakeUserPointer(&handle_count), |
+ core()->ReadMessage(h, nullptr, nullptr, nullptr, &handle_count, |
MOJO_READ_MESSAGE_FLAG_NONE), |
kMemoryCheckFailedRegex); |
@@ -530,9 +503,7 @@ TEST_F(CoreTest, MessagePipe) { |
MojoHandleSignalsState hss[2]; |
uint32_t result_index; |
- EXPECT_EQ(MOJO_RESULT_OK, |
- core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]), |
- MakeUserPointer(&h[1]))); |
+ EXPECT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(nullptr, &h[0], &h[1])); |
// Should get two distinct, valid handles. |
EXPECT_NE(h[0], MOJO_HANDLE_INVALID); |
EXPECT_NE(h[1], MOJO_HANDLE_INVALID); |
@@ -546,8 +517,7 @@ TEST_F(CoreTest, MessagePipe) { |
hss[1] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_DEADLINE_EXCEEDED, |
- core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0, |
- MakeUserPointer(&result_index), MakeUserPointer(hss))); |
+ core()->WaitMany(h, signals, 2, 0, &result_index, hss)); |
EXPECT_EQ(static_cast<uint32_t>(-1), result_index); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); |
EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals); |
@@ -559,9 +529,8 @@ TEST_F(CoreTest, MessagePipe) { |
uint32_t buffer_size = 1; |
EXPECT_EQ( |
MOJO_RESULT_SHOULD_WAIT, |
- core()->ReadMessage(h[0], UserPointer<void>(buffer), |
- MakeUserPointer(&buffer_size), NullUserPointer(), |
- NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ core()->ReadMessage(h[0], buffer, &buffer_size, nullptr, nullptr, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
// Check that it left its inputs alone. |
EXPECT_EQ('a', buffer[0]); |
EXPECT_EQ(1u, buffer_size); |
@@ -569,12 +538,12 @@ TEST_F(CoreTest, MessagePipe) { |
// Both should be writable. |
hss[0] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE, |
- 1000000000, MakeUserPointer(&hss[0]))); |
+ 1000000000, &hss[0])); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); |
EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals); |
hss[0] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, |
- 1000000000, MakeUserPointer(&hss[0]))); |
+ 1000000000, &hss[0])); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); |
EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals); |
@@ -586,9 +555,8 @@ TEST_F(CoreTest, MessagePipe) { |
hss[1] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_OK, |
- core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- MakeUserPointer(hss))); |
+ core()->WaitMany(h, signals, 2, MOJO_DEADLINE_INDEFINITE, &result_index, |
+ hss)); |
EXPECT_EQ(1u, result_index); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); |
EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals); |
@@ -599,8 +567,8 @@ TEST_F(CoreTest, MessagePipe) { |
buffer[0] = 'b'; |
EXPECT_EQ( |
MOJO_RESULT_OK, |
- core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1, |
- NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h[1], buffer, 1, nullptr, 0, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
// Check that |h[0]| is now readable. |
signals[0] = MOJO_HANDLE_SIGNAL_READABLE; |
@@ -610,9 +578,8 @@ TEST_F(CoreTest, MessagePipe) { |
hss[1] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_OK, |
- core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, |
- MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), |
- MakeUserPointer(hss))); |
+ core()->WaitMany(h, signals, 2, MOJO_DEADLINE_INDEFINITE, &result_index, |
+ hss)); |
EXPECT_EQ(0u, result_index); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss[0].satisfied_signals); |
@@ -625,26 +592,23 @@ TEST_F(CoreTest, MessagePipe) { |
buffer_size = 0; |
EXPECT_EQ( |
MOJO_RESULT_RESOURCE_EXHAUSTED, |
- core()->ReadMessage(h[0], NullUserPointer(), |
- MakeUserPointer(&buffer_size), NullUserPointer(), |
- NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ core()->ReadMessage(h[0], nullptr, &buffer_size, nullptr, nullptr, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(1u, buffer_size); |
// Then actually read it. |
buffer[0] = 'c'; |
buffer_size = 1; |
EXPECT_EQ( |
MOJO_RESULT_OK, |
- core()->ReadMessage(h[0], UserPointer<void>(buffer), |
- MakeUserPointer(&buffer_size), NullUserPointer(), |
- NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ core()->ReadMessage(h[0], buffer, &buffer_size, nullptr, nullptr, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ('b', buffer[0]); |
EXPECT_EQ(1u, buffer_size); |
// |h[0]| should no longer be readable. |
hss[0] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
- core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, |
- MakeUserPointer(&hss[0]))); |
+ core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, &hss[0])); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); |
EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals); |
@@ -652,17 +616,22 @@ TEST_F(CoreTest, MessagePipe) { |
buffer[0] = 'd'; |
EXPECT_EQ( |
MOJO_RESULT_OK, |
- core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1, |
- NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h[0], buffer, 1, nullptr, 0, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
// Close |h[0]|. |
EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0])); |
+ // Wait for |h[1]| to learn about the other end's closure. |
+ EXPECT_EQ(MOJO_RESULT_OK, |
+ core()->Wait(h[1], MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000, |
+ &hss[0])); |
+ |
// Check that |h[1]| is no longer writable (and will never be). |
hss[0] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000, |
- MakeUserPointer(&hss[0]))); |
+ &hss[0])); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss[0].satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
@@ -671,7 +640,7 @@ TEST_F(CoreTest, MessagePipe) { |
// Check that |h[1]| is still readable (for the moment). |
hss[0] = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, |
- 1000000000, MakeUserPointer(&hss[0]))); |
+ 1000000000, &hss[0])); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss[0].satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
@@ -679,15 +648,14 @@ TEST_F(CoreTest, MessagePipe) { |
// Discard a message from |h[1]|. |
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
- core()->ReadMessage(h[1], NullUserPointer(), NullUserPointer(), |
- NullUserPointer(), NullUserPointer(), |
+ core()->ReadMessage(h[1], nullptr, nullptr, nullptr, nullptr, |
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); |
// |h[1]| is no longer readable (and will never be). |
hss[0] = kFullMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss[0]))); |
+ &hss[0])); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[0].satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[0].satisfiable_signals); |
@@ -695,8 +663,8 @@ TEST_F(CoreTest, MessagePipe) { |
buffer[0] = 'e'; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1, |
- NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
+ core()->WriteMessage(h[1], buffer, 1, nullptr, 0, |
+ MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1])); |
} |
@@ -717,19 +685,16 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
MojoHandle h_passing[2]; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->CreateMessagePipe(NullUserPointer(), |
- MakeUserPointer(&h_passing[0]), |
- MakeUserPointer(&h_passing[1]))); |
+ core()->CreateMessagePipe(nullptr, &h_passing[0], &h_passing[1])); |
// Make sure that |h_passing[]| work properly. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, NullUserPointer(), 0, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, nullptr, 0, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -737,9 +702,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passing[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passing[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kHelloSize, num_bytes); |
EXPECT_STREQ(kHello, buffer); |
EXPECT_EQ(0u, num_handles); |
@@ -747,29 +711,26 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
// Make sure that you can't pass either of the message pipe's handles over |
// itself. |
EXPECT_EQ(MOJO_RESULT_BUSY, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, MakeUserPointer(&h_passing[0]), 1, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, |
+ &h_passing[0], 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, MakeUserPointer(&h_passing[1]), 1, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, |
+ &h_passing[1], 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
MojoHandle h_passed[2]; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->CreateMessagePipe(NullUserPointer(), |
- MakeUserPointer(&h_passed[0]), |
- MakeUserPointer(&h_passed[1]))); |
+ core()->CreateMessagePipe(nullptr, &h_passed[0], &h_passed[1])); |
// Make sure that |h_passed[]| work properly. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello), |
- kHelloSize, NullUserPointer(), 0, |
+ core()->WriteMessage(h_passed[0], kHello, kHelloSize, nullptr, 0, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -777,22 +738,21 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passed[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passed[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kHelloSize, num_bytes); |
EXPECT_STREQ(kHello, buffer); |
EXPECT_EQ(0u, num_handles); |
// Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld), |
- kWorldSize, MakeUserPointer(&h_passed[1]), 1, |
+ core()->WriteMessage(h_passing[0], kWorld, kWorldSize, |
+ &h_passed[1], 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -800,9 +760,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passing[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passing[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kWorldSize, num_bytes); |
EXPECT_STREQ(kWorld, buffer); |
EXPECT_EQ(1u, num_handles); |
@@ -821,13 +780,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
// Write to |h_passed[0]|. Should receive on |h_received|. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello), |
- kHelloSize, NullUserPointer(), 0, |
+ core()->WriteMessage(h_passed[0], kHello, kHelloSize, nullptr, 0, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -835,9 +793,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_received, UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_received, buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kHelloSize, num_bytes); |
EXPECT_STREQ(kHello, buffer); |
EXPECT_EQ(0u, num_handles); |
@@ -853,8 +810,7 @@ TEST_F(CoreTest, DataPipe) { |
MojoHandleSignalsState hss; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph), |
- MakeUserPointer(&ch))); |
+ core()->CreateDataPipe(nullptr, &ph, &ch)); |
// Should get two distinct, valid handles. |
EXPECT_NE(ph, MOJO_HANDLE_INVALID); |
EXPECT_NE(ch, MOJO_HANDLE_INVALID); |
@@ -864,13 +820,13 @@ TEST_F(CoreTest, DataPipe) { |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss))); |
+ core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
@@ -879,14 +835,14 @@ TEST_F(CoreTest, DataPipe) { |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss))); |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_DEADLINE_EXCEEDED, |
- core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss))); |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
@@ -895,15 +851,18 @@ TEST_F(CoreTest, DataPipe) { |
signed char elements[2] = {'A', 'B'}; |
uint32_t num_bytes = 2u; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteData(ph, UserPointer<const void>(elements), |
- MakeUserPointer(&num_bytes), |
+ core()->WriteData(ph, elements, &num_bytes, |
MOJO_WRITE_DATA_FLAG_NONE)); |
EXPECT_EQ(2u, num_bytes); |
+ |
+ // Wait for the data to arrive to the consumer. |
+ EXPECT_EQ(MOJO_RESULT_OK, |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss)); |
// Consumer should now be readable. |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
@@ -914,7 +873,7 @@ TEST_F(CoreTest, DataPipe) { |
num_bytes = 1u; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadData( |
- ch, UserPointer<void>(elements), MakeUserPointer(&num_bytes), |
+ ch, elements, &num_bytes, |
MOJO_READ_DATA_FLAG_NONE | MOJO_READ_DATA_FLAG_PEEK)); |
EXPECT_EQ('A', elements[0]); |
EXPECT_EQ(-1, elements[1]); |
@@ -923,8 +882,7 @@ TEST_F(CoreTest, DataPipe) { |
elements[0] = -1; |
elements[1] = -1; |
num_bytes = 1u; |
- EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData(ch, UserPointer<void>(elements), |
- MakeUserPointer(&num_bytes), |
+ EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData(ch, elements, &num_bytes, |
MOJO_READ_DATA_FLAG_NONE)); |
EXPECT_EQ('A', elements[0]); |
EXPECT_EQ(-1, elements[1]); |
@@ -933,8 +891,7 @@ TEST_F(CoreTest, DataPipe) { |
void* write_ptr = nullptr; |
num_bytes = 0u; |
ASSERT_EQ(MOJO_RESULT_OK, |
- core()->BeginWriteData(ph, MakeUserPointer(&write_ptr), |
- MakeUserPointer(&num_bytes), |
+ core()->BeginWriteData(ph, &write_ptr, &num_bytes, |
MOJO_WRITE_DATA_FLAG_NONE)); |
// We count on the default options providing a decent buffer size. |
ASSERT_GE(num_bytes, 3u); |
@@ -943,8 +900,7 @@ TEST_F(CoreTest, DataPipe) { |
elements[0] = 'X'; |
num_bytes = 1u; |
EXPECT_EQ(MOJO_RESULT_BUSY, |
- core()->WriteData(ph, UserPointer<const void>(elements), |
- MakeUserPointer(&num_bytes), |
+ core()->WriteData(ph, elements, &num_bytes, |
MOJO_WRITE_DATA_FLAG_NONE)); |
// Actually write the data, and complete it now. |
@@ -952,19 +908,23 @@ TEST_F(CoreTest, DataPipe) { |
static_cast<char*>(write_ptr)[1] = 'D'; |
static_cast<char*>(write_ptr)[2] = 'E'; |
EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u)); |
+ |
+ // Wait for the data to arrive to the consumer. |
+ EXPECT_EQ(MOJO_RESULT_OK, |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss)); |
// Query how much data we have. |
num_bytes = 0; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), |
+ core()->ReadData(ch, nullptr, &num_bytes, |
MOJO_READ_DATA_FLAG_QUERY)); |
- EXPECT_EQ(4u, num_bytes); |
+ EXPECT_GE(num_bytes, 1u); |
// Try to query with peek. Should fail. |
num_bytes = 0; |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), |
+ core()->ReadData(ch, nullptr, &num_bytes, |
MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK)); |
EXPECT_EQ(0u, num_bytes); |
@@ -972,56 +932,59 @@ TEST_F(CoreTest, DataPipe) { |
num_bytes = 10; |
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, |
core()->ReadData( |
- ch, NullUserPointer(), MakeUserPointer(&num_bytes), |
+ ch, nullptr, &num_bytes, |
MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); |
// Try to discard two characters, in peek mode. Should fail. |
num_bytes = 2; |
EXPECT_EQ( |
MOJO_RESULT_INVALID_ARGUMENT, |
- core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), |
+ core()->ReadData(ch, nullptr, &num_bytes, |
MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK)); |
- // Discard two characters. |
- num_bytes = 2; |
+ // Discard a character. |
+ num_bytes = 1; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadData( |
- ch, NullUserPointer(), MakeUserPointer(&num_bytes), |
+ ch, nullptr, &num_bytes, |
MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); |
- // Try a two-phase read of the remaining two bytes with peek. Should fail. |
+ // Ensure the 3 bytes were read. |
+ EXPECT_EQ(MOJO_RESULT_OK, |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss)); |
+ |
+ // Try a two-phase read of the remaining three bytes with peek. Should fail. |
const void* read_ptr = nullptr; |
- num_bytes = 2; |
+ num_bytes = 3; |
ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
- core()->BeginReadData(ch, MakeUserPointer(&read_ptr), |
- MakeUserPointer(&num_bytes), |
+ core()->BeginReadData(ch, &read_ptr, &num_bytes, |
MOJO_READ_DATA_FLAG_PEEK)); |
// Read the remaining two characters, in two-phase mode (all-or-none). |
- num_bytes = 2; |
+ num_bytes = 3; |
ASSERT_EQ(MOJO_RESULT_OK, |
- core()->BeginReadData(ch, MakeUserPointer(&read_ptr), |
- MakeUserPointer(&num_bytes), |
+ core()->BeginReadData(ch, &read_ptr, &num_bytes, |
MOJO_READ_DATA_FLAG_ALL_OR_NONE)); |
// Note: Count on still being able to do the contiguous read here. |
- ASSERT_EQ(2u, num_bytes); |
+ ASSERT_EQ(3u, num_bytes); |
// Discarding right now should fail. |
num_bytes = 1; |
EXPECT_EQ(MOJO_RESULT_BUSY, |
- core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), |
+ core()->ReadData(ch, nullptr, &num_bytes, |
MOJO_READ_DATA_FLAG_DISCARD)); |
// Actually check our data and end the two-phase read. |
- EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]); |
- EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]); |
- EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u)); |
+ EXPECT_EQ('C', static_cast<const char*>(read_ptr)[0]); |
+ EXPECT_EQ('D', static_cast<const char*>(read_ptr)[1]); |
+ EXPECT_EQ('E', static_cast<const char*>(read_ptr)[2]); |
+ EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 3u)); |
// Consumer should now be no longer readable. |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_DEADLINE_EXCEEDED, |
- core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss))); |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
EXPECT_EQ(0u, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
@@ -1031,11 +994,15 @@ TEST_F(CoreTest, DataPipe) { |
// Close the producer. |
EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph)); |
+ // Wait for this to get to the consumer. |
+ EXPECT_EQ(MOJO_RESULT_OK, |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000, &hss)); |
+ |
// The consumer should now be never-readable. |
hss = kFullMojoHandleSignalsState; |
EXPECT_EQ( |
MOJO_RESULT_FAILED_PRECONDITION, |
- core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss))); |
+ core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
@@ -1057,24 +1024,20 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
MojoHandle h_passing[2]; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->CreateMessagePipe(NullUserPointer(), |
- MakeUserPointer(&h_passing[0]), |
- MakeUserPointer(&h_passing[1]))); |
+ core()->CreateMessagePipe(nullptr, &h_passing[0], &h_passing[1])); |
MojoHandle ph, ch; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph), |
- MakeUserPointer(&ch))); |
+ core()->CreateDataPipe(nullptr, &ph, &ch)); |
// Send |ch| from |h_passing[0]| to |h_passing[1]|. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, MakeUserPointer(&ch), 1, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -1082,9 +1045,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passing[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passing[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kHelloSize, num_bytes); |
EXPECT_STREQ(kHello, buffer); |
EXPECT_EQ(1u, num_handles); |
@@ -1104,33 +1066,30 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
// Write to |ph|. Should receive on |ch_received|. |
num_bytes = kWorldSize; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteData(ph, UserPointer<const void>(kWorld), |
- MakeUserPointer(&num_bytes), |
+ core()->WriteData(ph, kWorld, &num_bytes, |
MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
num_bytes = kBufferSize; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->ReadData(ch_received, UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), |
+ core()->ReadData(ch_received, buffer, &num_bytes, |
MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kWorldSize, num_bytes); |
EXPECT_STREQ(kWorld, buffer); |
// Now pass |ph| in the same direction. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld), |
- kWorldSize, MakeUserPointer(&ph), 1, |
+ core()->WriteMessage(h_passing[0], kWorld, kWorldSize, &ph, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -1138,9 +1097,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passing[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passing[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kWorldSize, num_bytes); |
EXPECT_STREQ(kWorld, buffer); |
EXPECT_EQ(1u, num_handles); |
@@ -1160,20 +1118,18 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
// Write to |ph_received|. Should receive on |ch_received|. |
num_bytes = kHelloSize; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteData(ph_received, UserPointer<const void>(kHello), |
- MakeUserPointer(&num_bytes), |
+ core()->WriteData(ph_received, kHello, &num_bytes, |
MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
num_bytes = kBufferSize; |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->ReadData(ch_received, UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), |
+ core()->ReadData(ch_received, buffer, &num_bytes, |
MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kHelloSize, num_bytes); |
EXPECT_STREQ(kHello, buffer); |
@@ -1187,31 +1143,27 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
void* write_ptr = nullptr; |
num_bytes = 0; |
ASSERT_EQ(MOJO_RESULT_OK, |
- core()->BeginWriteData(ph, MakeUserPointer(&write_ptr), |
- MakeUserPointer(&num_bytes), |
+ core()->BeginWriteData(ph, &write_ptr, &num_bytes, |
MOJO_WRITE_DATA_FLAG_NONE)); |
ASSERT_GE(num_bytes, 1u); |
EXPECT_EQ(MOJO_RESULT_BUSY, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, MakeUserPointer(&ph), 1, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ph, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
// But |ch| can, even if |ph| is in a two-phase write. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, MakeUserPointer(&ch), 1, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
ch = MOJO_HANDLE_INVALID; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- NullUserPointer())); |
+ nullptr)); |
num_bytes = kBufferSize; |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passing[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passing[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kHelloSize, num_bytes); |
EXPECT_STREQ(kHello, buffer); |
EXPECT_EQ(1u, num_handles); |
@@ -1225,7 +1177,7 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
// Wait for |ch| to be readable. |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, |
- 1000000000, MakeUserPointer(&hss))); |
+ 1000000000, &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
hss.satisfiable_signals); |
@@ -1234,24 +1186,21 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
const void* read_ptr = nullptr; |
num_bytes = 1; |
ASSERT_EQ(MOJO_RESULT_OK, |
- core()->BeginReadData(ch, MakeUserPointer(&read_ptr), |
- MakeUserPointer(&num_bytes), |
+ core()->BeginReadData(ch, &read_ptr, &num_bytes, |
MOJO_READ_DATA_FLAG_ALL_OR_NONE)); |
EXPECT_EQ(MOJO_RESULT_BUSY, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), |
- kHelloSize, MakeUserPointer(&ch), 1, |
+ core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
// But |ph| can, even if |ch| is in a two-phase read. |
EXPECT_EQ(MOJO_RESULT_OK, |
- core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld), |
- kWorldSize, MakeUserPointer(&ph), 1, |
+ core()->WriteMessage(h_passing[0], kWorld, kWorldSize, &ph, 1, |
MOJO_WRITE_MESSAGE_FLAG_NONE)); |
ph = MOJO_HANDLE_INVALID; |
hss = kEmptyMojoHandleSignalsState; |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, |
- MakeUserPointer(&hss))); |
+ &hss)); |
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
hss.satisfied_signals); |
EXPECT_EQ(kAllSignals, hss.satisfiable_signals); |
@@ -1259,9 +1208,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { |
num_handles = MOJO_ARRAYSIZE(handles); |
EXPECT_EQ(MOJO_RESULT_OK, |
core()->ReadMessage( |
- h_passing[1], UserPointer<void>(buffer), |
- MakeUserPointer(&num_bytes), MakeUserPointer(handles), |
- MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); |
+ h_passing[1], buffer, &num_bytes, handles, &num_handles, |
+ MOJO_READ_MESSAGE_FLAG_NONE)); |
EXPECT_EQ(kWorldSize, num_bytes); |
EXPECT_STREQ(kWorld, buffer); |
EXPECT_EQ(1u, num_handles); |
@@ -1313,5 +1261,5 @@ TEST_F(CoreTest, AsyncWait) { |
// TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|. |
} // namespace |
-} // namespace system |
+} // namespace edk |
} // namespace mojo |