TEST(CoreTest, InvalidHandle) {
MojoHandle h0, h1;
MojoHandleSignals sig;
- char buffer[10] = { 0 };
+ char buffer[10] = {0};
uint32_t buffer_size;
void* write_pointer;
const void* read_pointer;
MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE));
// Message pipe:
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- MojoWriteMessage(h0, buffer, 3, NULL, 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ MojoWriteMessage(h0, buffer, 3, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- MojoReadMessage(h0, buffer, &buffer_size, NULL, NULL,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ MojoReadMessage(
+ h0, buffer, &buffer_size, NULL, NULL, MOJO_READ_MESSAGE_FLAG_NONE));
// Data pipe:
buffer_size = static_cast<uint32_t>(sizeof(buffer));
MojoWriteData(h0, buffer, &buffer_size, MOJO_WRITE_DATA_FLAG_NONE));
write_pointer = NULL;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- MojoBeginWriteData(h0, &write_pointer, &buffer_size,
- MOJO_WRITE_DATA_FLAG_NONE));
+ MojoBeginWriteData(
+ h0, &write_pointer, &buffer_size, MOJO_WRITE_DATA_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoEndWriteData(h0, 1));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
MojoReadData(h0, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE));
read_pointer = NULL;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- MojoBeginReadData(h0, &read_pointer, &buffer_size,
- MOJO_READ_DATA_FLAG_NONE));
+ MojoBeginReadData(
+ h0, &read_pointer, &buffer_size, MOJO_READ_DATA_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoEndReadData(h0, 1));
// Shared buffer:
TEST(CoreTest, BasicMessagePipe) {
MojoHandle h0, h1;
MojoHandleSignals sig;
- char buffer[10] = { 0 };
+ char buffer[10] = {0};
uint32_t buffer_size;
h0 = MOJO_HANDLE_INVALID;
// Try to read.
buffer_size = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- MojoReadMessage(h0, buffer, &buffer_size, NULL, NULL,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_SHOULD_WAIT,
+ MojoReadMessage(
+ h0, buffer, &buffer_size, NULL, NULL, MOJO_READ_MESSAGE_FLAG_NONE));
// Write to |h1|.
static const char kHello[] = "hello";
buffer_size = static_cast<uint32_t>(sizeof(kHello));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(h1, kHello, buffer_size, NULL, 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ MojoWriteMessage(
+ h1, kHello, buffer_size, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// |h0| should be readable.
sig = MOJO_HANDLE_SIGNAL_READABLE;
// Read from |h0|.
buffer_size = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h0, buffer, &buffer_size, NULL, NULL,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ MojoReadMessage(
+ h0, buffer, &buffer_size, NULL, NULL, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0));
// |h1| should no longer be readable or writable.
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- MojoWait(h1,
- MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
- 1000));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ MojoWait(
+ h1, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 1000));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1));
}
TEST(CoreTest, BasicDataPipe) {
MojoHandle hp, hc;
MojoHandleSignals sig;
- char buffer[20] = { 0 };
+ char buffer[20] = {0};
uint32_t buffer_size;
void* write_pointer;
const void* read_pointer;
// Try to begin a two-phase read from |hc|.
read_pointer = NULL;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- MojoBeginReadData(hc, &read_pointer, &buffer_size,
- MOJO_READ_DATA_FLAG_NONE));
+ MojoBeginReadData(
+ hc, &read_pointer, &buffer_size, MOJO_READ_DATA_FLAG_NONE));
// Write to |hp|.
static const char kHello[] = "hello ";
// Don't include terminating null.
buffer_size = static_cast<uint32_t>(strlen(kHello));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteData(hp, kHello, &buffer_size,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ MojoWriteData(hp, kHello, &buffer_size, MOJO_WRITE_MESSAGE_FLAG_NONE));
// |hc| should be(come) readable.
sig = MOJO_HANDLE_SIGNAL_READABLE;
// Do a two-phase write to |hp|.
EXPECT_EQ(MOJO_RESULT_OK,
- MojoBeginWriteData(hp, &write_pointer, &buffer_size,
- MOJO_WRITE_DATA_FLAG_NONE));
+ MojoBeginWriteData(
+ hp, &write_pointer, &buffer_size, MOJO_WRITE_DATA_FLAG_NONE));
static const char kWorld[] = "world";
ASSERT_GE(buffer_size, sizeof(kWorld));
// Include the terminating null.
// Do a two-phase read from |hc|.
read_pointer = NULL;
EXPECT_EQ(MOJO_RESULT_OK,
- MojoBeginReadData(hc, &read_pointer, &buffer_size,
- MOJO_READ_DATA_FLAG_NONE));
+ MojoBeginReadData(
+ hc, &read_pointer, &buffer_size, MOJO_READ_DATA_FLAG_NONE));
ASSERT_LE(buffer_size, sizeof(buffer) - 1);
memcpy(&buffer[1], read_pointer, buffer_size);
EXPECT_EQ(MOJO_RESULT_OK, MojoEndReadData(hc, buffer_size));