| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "mojo/edk/embedder/embedder.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/command_line.h" |
| #include "base/files/file.h" |
| #include "base/logging.h" |
| #include "base/macros.h" |
| #include "base/memory/shared_memory.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/process/process_handle.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/test/test_timeouts.h" |
| #include "mojo/edk/embedder/platform_channel_pair.h" |
| #include "mojo/edk/embedder/test_embedder.h" |
| #include "mojo/edk/system/test_utils.h" |
| #include "mojo/edk/test/mojo_test_base.h" |
| #include "mojo/public/c/system/core.h" |
| #include "mojo/public/cpp/system/handle.h" |
| #include "mojo/public/cpp/system/message_pipe.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace mojo { |
| namespace edk { |
| namespace { |
| |
| const MojoHandleSignals kSignalReadadableWritable = |
| MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE; |
| |
| const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE | |
| MOJO_HANDLE_SIGNAL_WRITABLE | |
| MOJO_HANDLE_SIGNAL_PEER_CLOSED; |
| |
| // The multiprocess tests that use these don't compile on iOS. |
| #if !defined(OS_IOS) |
| const char kHelloWorld[] = "hello world"; |
| const char kByeWorld[] = "bye world"; |
| #endif |
| |
| using EmbedderTest = test::MojoTestBase; |
| |
| TEST_F(EmbedderTest, ChannelBasic) { |
| MojoHandle server_mp, client_mp; |
| CreateMessagePipe(&server_mp, &client_mp); |
| |
| const std::string kHello = "hello"; |
| |
| // We can write to a message pipe handle immediately. |
| WriteMessage(server_mp, kHello); |
| EXPECT_EQ(kHello, ReadMessage(client_mp)); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp)); |
| } |
| |
| // Test sending a MP which has read messages out of the OS pipe but which have |
| // not been consumed using MojoReadMessage yet. |
| TEST_F(EmbedderTest, SendReadableMessagePipe) { |
| MojoHandle server_mp, client_mp; |
| CreateMessagePipe(&server_mp, &client_mp); |
| |
| MojoHandle server_mp2, client_mp2; |
| CreateMessagePipe(&server_mp2, &client_mp2); |
| |
| // Write to server2 and wait for client2 to be readable before sending it. |
| // client2's MessagePipeDispatcher will have the message below in its |
| // message_queue_. For extra measures, also verify that this pending message |
| // can contain a message pipe. |
| MojoHandle server_mp3, client_mp3; |
| CreateMessagePipe(&server_mp3, &client_mp3); |
| |
| const std::string kHello = "hello"; |
| WriteMessageWithHandles(server_mp2, kHello, &client_mp3, 1); |
| |
| MojoHandleSignalsState state; |
| ASSERT_EQ(MOJO_RESULT_OK, MojoWait(client_mp2, MOJO_HANDLE_SIGNAL_READABLE, |
| MOJO_DEADLINE_INDEFINITE, &state)); |
| ASSERT_EQ(kSignalReadadableWritable, state.satisfied_signals); |
| ASSERT_EQ(kSignalAll, state.satisfiable_signals); |
| |
| // Now send client2 |
| WriteMessageWithHandles(server_mp, kHello, &client_mp2, 1); |
| |
| MojoHandle port; |
| std::string message = ReadMessageWithHandles(client_mp, &port, 1); |
| EXPECT_EQ(kHello, message); |
| |
| client_mp2 = port; |
| message = ReadMessageWithHandles(client_mp2, &client_mp3, 1); |
| EXPECT_EQ(kHello, message); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp3)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp3)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp2)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp2)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp)); |
| } |
| |
| // Verifies that a MP with pending messages to be written can be sent and the |
| // pending messages aren't dropped. |
| TEST_F(EmbedderTest, SendMessagePipeWithWriteQueue) { |
| MojoHandle server_mp, client_mp; |
| CreateMessagePipe(&server_mp, &client_mp); |
| |
| MojoHandle server_mp2, client_mp2; |
| CreateMessagePipe(&server_mp2, &client_mp2); |
| |
| static const size_t kNumMessages = 1001; |
| for (size_t i = 1; i <= kNumMessages; i++) |
| WriteMessage(client_mp2, std::string(i, 'A' + (i % 26))); |
| |
| // Now send client2. |
| WriteMessageWithHandles(server_mp, "hey", &client_mp2, 1); |
| client_mp2 = MOJO_HANDLE_INVALID; |
| |
| // Read client2 just so we can close it later. |
| EXPECT_EQ("hey", ReadMessageWithHandles(client_mp, &client_mp2, 1)); |
| EXPECT_NE(MOJO_HANDLE_INVALID, client_mp2); |
| |
| // Now verify that all the messages that were written were sent correctly. |
| for (size_t i = 1; i <= kNumMessages; i++) |
| ASSERT_EQ(std::string(i, 'A' + (i % 26)), ReadMessage(server_mp2)); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp2)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp2)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp)); |
| } |
| |
| TEST_F(EmbedderTest, ChannelsHandlePassing) { |
| MojoHandle server_mp, client_mp; |
| CreateMessagePipe(&server_mp, &client_mp); |
| EXPECT_NE(server_mp, MOJO_HANDLE_INVALID); |
| EXPECT_NE(client_mp, MOJO_HANDLE_INVALID); |
| |
| MojoHandle h0, h1; |
| CreateMessagePipe(&h0, &h1); |
| |
| // Write a message to |h0| (attaching nothing). |
| const std::string kHello = "hello"; |
| WriteMessage(h0, kHello); |
| |
| // Write one message to |server_mp|, attaching |h1|. |
| const std::string kWorld = "world!!!"; |
| WriteMessageWithHandles(server_mp, kWorld, &h1, 1); |
| h1 = MOJO_HANDLE_INVALID; |
| |
| // Write another message to |h0|. |
| const std::string kFoo = "foo"; |
| WriteMessage(h0, kFoo); |
| |
| // Wait for |client_mp| to become readable and read a message from it. |
| EXPECT_EQ(kWorld, ReadMessageWithHandles(client_mp, &h1, 1)); |
| EXPECT_NE(h1, MOJO_HANDLE_INVALID); |
| |
| // Wait for |h1| to become readable and read a message from it. |
| EXPECT_EQ(kHello, ReadMessage(h1)); |
| |
| // Wait for |h1| to become readable (again) and read its second message. |
| EXPECT_EQ(kFoo, ReadMessage(h1)); |
| |
| // Write a message to |h1|. |
| const std::string kBarBaz = "barbaz"; |
| WriteMessage(h1, kBarBaz); |
| |
| // Wait for |h0| to become readable and read a message from it. |
| EXPECT_EQ(kBarBaz, ReadMessage(h0)); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(server_mp)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(client_mp)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(h0)); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(h1)); |
| } |
| |
| TEST_F(EmbedderTest, PipeSetup) { |
| std::string child_token = GenerateRandomToken(); |
| std::string pipe_token = GenerateRandomToken(); |
| |
| ScopedMessagePipeHandle parent_mp = |
| CreateParentMessagePipe(pipe_token, child_token); |
| ScopedMessagePipeHandle child_mp = |
| CreateChildMessagePipe(pipe_token); |
| |
| const std::string kHello = "hello"; |
| WriteMessage(parent_mp.get().value(), kHello); |
| |
| EXPECT_EQ(kHello, ReadMessage(child_mp.get().value())); |
| } |
| |
| TEST_F(EmbedderTest, PipeSetup_LaunchDeath) { |
| PlatformChannelPair pair; |
| |
| std::string child_token = GenerateRandomToken(); |
| std::string pipe_token = GenerateRandomToken(); |
| |
| ScopedMessagePipeHandle parent_mp = |
| CreateParentMessagePipe(pipe_token, child_token); |
| ChildProcessLaunched(base::GetCurrentProcessHandle(), pair.PassServerHandle(), |
| child_token); |
| |
| // Close the remote end, simulating child death before the child connects to |
| // the reserved port. |
| ignore_result(pair.PassClientHandle()); |
| |
| EXPECT_EQ(MOJO_RESULT_OK, MojoWait(parent_mp.get().value(), |
| MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| MOJO_DEADLINE_INDEFINITE, |
| nullptr)); |
| } |
| |
| TEST_F(EmbedderTest, PipeSetup_LaunchFailure) { |
| PlatformChannelPair pair; |
| |
| std::string child_token = GenerateRandomToken(); |
| std::string pipe_token = GenerateRandomToken(); |
| |
| ScopedMessagePipeHandle parent_mp = |
| CreateParentMessagePipe(pipe_token, child_token); |
| |
| ChildProcessLaunchFailed(child_token); |
| EXPECT_EQ(MOJO_RESULT_OK, MojoWait(parent_mp.get().value(), |
| MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| MOJO_DEADLINE_INDEFINITE, |
| nullptr)); |
| } |
| |
| // The sequence of messages sent is: |
| // server_mp client_mp mp0 mp1 mp2 mp3 |
| // 1. "hello" |
| // 2. "world!" |
| // 3. "FOO" |
| // 4. "Bar"+mp1 |
| // 5. (close) |
| // 6. (close) |
| // 7. "baz" |
| // 8. (closed) |
| // 9. "quux"+mp2 |
| // 10. (close) |
| // 11. (wait/cl.) |
| // 12. (wait/cl.) |
| |
| #if !defined(OS_IOS) |
| |
| TEST_F(EmbedderTest, MultiprocessChannels) { |
| RUN_CHILD_ON_PIPE(MultiprocessChannelsClient, server_mp) |
| // 1. Write a message to |server_mp| (attaching nothing). |
| WriteMessage(server_mp, "hello"); |
| |
| // 2. Read a message from |server_mp|. |
| EXPECT_EQ("world!", ReadMessage(server_mp)); |
| |
| // 3. Create a new message pipe (endpoints |mp0| and |mp1|). |
| MojoHandle mp0, mp1; |
| CreateMessagePipe(&mp0, &mp1); |
| |
| // 4. Write something to |mp0|. |
| WriteMessage(mp0, "FOO"); |
| |
| // 5. Write a message to |server_mp|, attaching |mp1|. |
| WriteMessageWithHandles(server_mp, "Bar", &mp1, 1); |
| mp1 = MOJO_HANDLE_INVALID; |
| |
| // 6. Read a message from |mp0|, which should have |mp2| attached. |
| MojoHandle mp2 = MOJO_HANDLE_INVALID; |
| EXPECT_EQ("quux", ReadMessageWithHandles(mp0, &mp2, 1)); |
| |
| // 7. Read a message from |mp2|. |
| EXPECT_EQ("baz", ReadMessage(mp2)); |
| |
| // 8. Close |mp0|. |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp0)); |
| |
| // 9. Tell the client to quit. |
| WriteMessage(server_mp, "quit"); |
| |
| // 10. Wait on |mp2| (which should eventually fail) and then close it. |
| MojoHandleSignalsState state; |
| ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, |
| MOJO_DEADLINE_INDEFINITE, |
| &state)); |
| ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
| ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp2)); |
| END_CHILD() |
| } |
| |
| DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessChannelsClient, EmbedderTest, |
| client_mp) { |
| // 1. Read the first message from |client_mp|. |
| EXPECT_EQ("hello", ReadMessage(client_mp)); |
| |
| // 2. Write a message to |client_mp| (attaching nothing). |
| WriteMessage(client_mp, "world!"); |
| |
| // 4. Read a message from |client_mp|, which should have |mp1| attached. |
| MojoHandle mp1; |
| EXPECT_EQ("Bar", ReadMessageWithHandles(client_mp, &mp1, 1)); |
| |
| // 5. Create a new message pipe (endpoints |mp2| and |mp3|). |
| MojoHandle mp2, mp3; |
| CreateMessagePipe(&mp2, &mp3); |
| |
| // 6. Write a message to |mp3|. |
| WriteMessage(mp3, "baz"); |
| |
| // 7. Close |mp3|. |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp3)); |
| |
| // 8. Write a message to |mp1|, attaching |mp2|. |
| WriteMessageWithHandles(mp1, "quux", &mp2, 1); |
| mp2 = MOJO_HANDLE_INVALID; |
| |
| // 9. Read a message from |mp1|. |
| EXPECT_EQ("FOO", ReadMessage(mp1)); |
| |
| EXPECT_EQ("quit", ReadMessage(client_mp)); |
| |
| // 10. Wait on |mp1| (which should eventually fail) and then close it. |
| MojoHandleSignalsState state; |
| ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| MOJO_DEADLINE_INDEFINITE, &state)); |
| ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); |
| ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(mp1)); |
| } |
| |
| TEST_F(EmbedderTest, MultiprocessBaseSharedMemory) { |
| RUN_CHILD_ON_PIPE(MultiprocessSharedMemoryClient, server_mp) |
| // 1. Create a base::SharedMemory object and create a mojo shared buffer |
| // from it. |
| base::SharedMemoryCreateOptions options; |
| options.size = 123; |
| base::SharedMemory shared_memory; |
| ASSERT_TRUE(shared_memory.Create(options)); |
| base::SharedMemoryHandle shm_handle = base::SharedMemory::DuplicateHandle( |
| shared_memory.handle()); |
| MojoHandle sb1; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| CreateSharedBufferWrapper(shm_handle, 123, false, &sb1)); |
| |
| // 2. Map |sb1| and write something into it. |
| char* buffer = nullptr; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| MojoMapBuffer(sb1, 0, 123, reinterpret_cast<void**>(&buffer), 0)); |
| ASSERT_TRUE(buffer); |
| memcpy(buffer, kHelloWorld, sizeof(kHelloWorld)); |
| |
| // 3. Duplicate |sb1| into |sb2| and pass to |server_mp|. |
| MojoHandle sb2 = MOJO_HANDLE_INVALID; |
| EXPECT_EQ(MOJO_RESULT_OK, MojoDuplicateBufferHandle(sb1, 0, &sb2)); |
| EXPECT_NE(MOJO_HANDLE_INVALID, sb2); |
| WriteMessageWithHandles(server_mp, "hello", &sb2, 1); |
| |
| // 4. Read a message from |server_mp|. |
| EXPECT_EQ("bye", ReadMessage(server_mp)); |
| |
| // 5. Expect that the contents of the shared buffer have changed. |
| EXPECT_EQ(kByeWorld, std::string(buffer)); |
| |
| // 6. Map the original base::SharedMemory and expect it contains the |
| // expected value. |
| ASSERT_TRUE(shared_memory.Map(123)); |
| EXPECT_EQ(kByeWorld, |
| std::string(static_cast<char*>(shared_memory.memory()))); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(sb1)); |
| END_CHILD() |
| } |
| |
| DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessSharedMemoryClient, EmbedderTest, |
| client_mp) { |
| // 1. Read the first message from |client_mp|, which should have |sb1| which |
| // should be a shared buffer handle. |
| MojoHandle sb1; |
| EXPECT_EQ("hello", ReadMessageWithHandles(client_mp, &sb1, 1)); |
| |
| // 2. Map |sb1|. |
| char* buffer = nullptr; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| MojoMapBuffer(sb1, 0, 123, reinterpret_cast<void**>(&buffer), 0)); |
| ASSERT_TRUE(buffer); |
| |
| // 3. Ensure |buffer| contains the values we expect. |
| EXPECT_EQ(kHelloWorld, std::string(buffer)); |
| |
| // 4. Write into |buffer| and send a message back. |
| memcpy(buffer, kByeWorld, sizeof(kByeWorld)); |
| WriteMessage(client_mp, "bye"); |
| |
| // 5. Extract the shared memory handle and ensure we can map it and read the |
| // contents. |
| base::SharedMemoryHandle shm_handle; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| PassSharedMemoryHandle(sb1, &shm_handle, nullptr, nullptr)); |
| base::SharedMemory shared_memory(shm_handle, false); |
| ASSERT_TRUE(shared_memory.Map(123)); |
| EXPECT_NE(buffer, shared_memory.memory()); |
| EXPECT_EQ(kByeWorld, std::string(static_cast<char*>(shared_memory.memory()))); |
| |
| // 6. Close |sb1|. Should fail because |PassSharedMemoryHandle()| should have |
| // closed the handle. |
| EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(sb1)); |
| } |
| |
| #if defined(OS_MACOSX) && !defined(OS_IOS) |
| TEST_F(EmbedderTest, MultiprocessMachSharedMemory) { |
| RUN_CHILD_ON_PIPE(MultiprocessSharedMemoryClient, server_mp) |
| // 1. Create a Mach base::SharedMemory object and create a mojo shared |
| // buffer from it. |
| base::SharedMemoryCreateOptions options; |
| options.size = 123; |
| base::SharedMemory shared_memory; |
| ASSERT_TRUE(shared_memory.Create(options)); |
| base::SharedMemoryHandle shm_handle = base::SharedMemory::DuplicateHandle( |
| shared_memory.handle()); |
| MojoHandle sb1; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| CreateSharedBufferWrapper(shm_handle, 123, false, &sb1)); |
| |
| // 2. Map |sb1| and write something into it. |
| char* buffer = nullptr; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| MojoMapBuffer(sb1, 0, 123, reinterpret_cast<void**>(&buffer), 0)); |
| ASSERT_TRUE(buffer); |
| memcpy(buffer, kHelloWorld, sizeof(kHelloWorld)); |
| |
| // 3. Duplicate |sb1| into |sb2| and pass to |server_mp|. |
| MojoHandle sb2 = MOJO_HANDLE_INVALID; |
| EXPECT_EQ(MOJO_RESULT_OK, MojoDuplicateBufferHandle(sb1, 0, &sb2)); |
| EXPECT_NE(MOJO_HANDLE_INVALID, sb2); |
| WriteMessageWithHandles(server_mp, "hello", &sb2, 1); |
| |
| // 4. Read a message from |server_mp|. |
| EXPECT_EQ("bye", ReadMessage(server_mp)); |
| |
| // 5. Expect that the contents of the shared buffer have changed. |
| EXPECT_EQ(kByeWorld, std::string(buffer)); |
| |
| // 6. Map the original base::SharedMemory and expect it contains the |
| // expected value. |
| ASSERT_TRUE(shared_memory.Map(123)); |
| EXPECT_EQ(kByeWorld, |
| std::string(static_cast<char*>(shared_memory.memory()))); |
| |
| ASSERT_EQ(MOJO_RESULT_OK, MojoClose(sb1)); |
| END_CHILD() |
| } |
| |
| enum class HandleType { |
| POSIX, |
| MACH, |
| MACH_NULL, |
| }; |
| |
| const HandleType kTestHandleTypes[] = { |
| HandleType::MACH, |
| HandleType::MACH_NULL, |
| HandleType::POSIX, |
| HandleType::POSIX, |
| HandleType::MACH, |
| }; |
| |
| // Test that we can mix file descriptors and mach port handles. |
| TEST_F(EmbedderTest, MultiprocessMixMachAndFds) { |
| const size_t kShmSize = 1234; |
| RUN_CHILD_ON_PIPE(MultiprocessMixMachAndFdsClient, server_mp) |
| // 1. Create fds or Mach objects and mojo handles from them. |
| MojoHandle platform_handles[arraysize(kTestHandleTypes)]; |
| for (size_t i = 0; i < arraysize(kTestHandleTypes); i++) { |
| const auto type = kTestHandleTypes[i]; |
| ScopedPlatformHandle scoped_handle; |
| if (type == HandleType::POSIX) { |
| // The easiest source of fds is opening /dev/null. |
| base::File file(base::FilePath("/dev/null"), |
| base::File::FLAG_OPEN | base::File::FLAG_WRITE); |
| ASSERT_TRUE(file.IsValid()); |
| scoped_handle.reset(PlatformHandle(file.TakePlatformFile())); |
| EXPECT_EQ(PlatformHandle::Type::POSIX, scoped_handle.get().type); |
| } else if (type == HandleType::MACH_NULL) { |
| scoped_handle.reset(PlatformHandle( |
| static_cast<mach_port_t>(MACH_PORT_NULL))); |
| EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type); |
| } else { |
| base::SharedMemoryCreateOptions options; |
| options.size = kShmSize; |
| base::SharedMemory shared_memory; |
| ASSERT_TRUE(shared_memory.Create(options)); |
| base::SharedMemoryHandle shm_handle = |
| base::SharedMemory::DuplicateHandle(shared_memory.handle()); |
| scoped_handle.reset(PlatformHandle(shm_handle.GetMemoryObject())); |
| EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type); |
| } |
| ASSERT_EQ(MOJO_RESULT_OK, CreatePlatformHandleWrapper( |
| std::move(scoped_handle), platform_handles + i)); |
| } |
| |
| // 2. Send all the handles to the child. |
| WriteMessageWithHandles(server_mp, "hello", platform_handles, |
| arraysize(kTestHandleTypes)); |
| |
| // 3. Read a message from |server_mp|. |
| EXPECT_EQ("bye", ReadMessage(server_mp)); |
| END_CHILD() |
| } |
| |
| DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessMixMachAndFdsClient, EmbedderTest, |
| client_mp) { |
| const int kNumHandles = arraysize(kTestHandleTypes); |
| MojoHandle platform_handles[kNumHandles]; |
| |
| // 1. Read from |client_mp|, which should have a message containing |
| // |kNumHandles| handles. |
| EXPECT_EQ("hello", |
| ReadMessageWithHandles(client_mp, platform_handles, kNumHandles)); |
| |
| // 2. Extract each handle, and verify the type. |
| for (int i = 0; i < kNumHandles; i++) { |
| const auto type = kTestHandleTypes[i]; |
| ScopedPlatformHandle scoped_handle; |
| ASSERT_EQ(MOJO_RESULT_OK, |
| PassWrappedPlatformHandle(platform_handles[i], &scoped_handle)); |
| if (type == HandleType::POSIX) { |
| EXPECT_NE(0, scoped_handle.get().handle); |
| EXPECT_EQ(PlatformHandle::Type::POSIX, scoped_handle.get().type); |
| } else if (type == HandleType::MACH_NULL) { |
| EXPECT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL), |
| scoped_handle.get().port); |
| EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type); |
| } else { |
| EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL), |
| scoped_handle.get().port); |
| EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type); |
| } |
| } |
| |
| // 3. Say bye! |
| WriteMessage(client_mp, "bye"); |
| } |
| |
| #endif // defined(OS_MACOSX) && !defined(OS_IOS) |
| |
| // TODO(vtl): Test immediate write & close. |
| // TODO(vtl): Test broken-connection cases. |
| |
| #endif // !defined(OS_IOS) |
| |
| } // namespace |
| } // namespace edk |
| } // namespace mojo |