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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: mojo/edk/embedder/embedder_unittest.cc

Issue 814543006: Move //mojo/{public, edk} underneath //third_party (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase Created 5 years, 11 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « mojo/edk/embedder/embedder_internal.h ('k') | mojo/edk/embedder/entrypoints.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/edk/embedder/embedder_unittest.cc
diff --git a/mojo/edk/embedder/embedder_unittest.cc b/mojo/edk/embedder/embedder_unittest.cc
deleted file mode 100644
index ed4ea2e2df361e749eebf1ce3736fa4f40c615ed..0000000000000000000000000000000000000000
--- a/mojo/edk/embedder/embedder_unittest.cc
+++ /dev/null
@@ -1,639 +0,0 @@
-// 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 <string.h>
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/test_io_thread.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/multiprocess_test_helper.h"
-#include "mojo/public/c/system/core.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace mojo {
-namespace embedder {
-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;
-
-class ScopedTestChannel {
- public:
- // Creates a channel that lives on a given I/O thread (determined by the given
- // |TaskRunner|) attached to the given |platform_handle|. After construction,
- // |bootstrap_message_pipe()| gives the Mojo handle for the bootstrap message
- // pipe on this channel; it is up to the caller to close this handle.
- // Note: The I/O thread must outlive this object (and its message loop must
- // continue pumping messages while this object is alive).
- ScopedTestChannel(scoped_refptr<base::TaskRunner> io_thread_task_runner,
- ScopedPlatformHandle platform_handle)
- : io_thread_task_runner_(io_thread_task_runner),
- bootstrap_message_pipe_(MOJO_HANDLE_INVALID),
- did_create_channel_event_(true, false),
- channel_info_(nullptr) {
- bootstrap_message_pipe_ =
- CreateChannel(platform_handle.Pass(), io_thread_task_runner_,
- base::Bind(&ScopedTestChannel::DidCreateChannel,
- base::Unretained(this)),
- nullptr)
- .release()
- .value();
- CHECK_NE(bootstrap_message_pipe_, MOJO_HANDLE_INVALID);
- }
-
- // Destructor: Shuts down the channel. (As noted above, for this to happen,
- // the I/O thread must be alive and pumping messages.)
- ~ScopedTestChannel() { DestroyChannel(channel_info_); }
-
- // Waits for channel creation to be completed.
- void WaitForChannelCreationCompletion() { did_create_channel_event_.Wait(); }
-
- MojoHandle bootstrap_message_pipe() const { return bootstrap_message_pipe_; }
-
- // Call only after |WaitForChannelCreationCompletion()|. Use only to check
- // that it's not null.
- const ChannelInfo* channel_info() const { return channel_info_; }
-
- private:
- void DidCreateChannel(ChannelInfo* channel_info) {
- CHECK(channel_info);
- CHECK(!channel_info_);
- channel_info_ = channel_info;
- did_create_channel_event_.Signal();
- }
-
- scoped_refptr<base::TaskRunner> io_thread_task_runner_;
-
- // Valid from creation until whenever it gets closed (by the "owner" of this
- // object).
- // Note: We don't want use the C++ wrappers here, since we want to test the
- // API at the lowest level.
- MojoHandle bootstrap_message_pipe_;
-
- // Set after channel creation has been completed (i.e., the callback to
- // |CreateChannel()| has been called).
- base::WaitableEvent did_create_channel_event_;
-
- // Valid after channel creation completion until destruction.
- ChannelInfo* channel_info_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedTestChannel);
-};
-
-class EmbedderTest : public testing::Test {
- public:
- EmbedderTest() : test_io_thread_(base::TestIOThread::kAutoStart) {}
- ~EmbedderTest() override {}
-
- protected:
- base::TestIOThread* test_io_thread() { return &test_io_thread_; }
-
- private:
- base::TestIOThread test_io_thread_;
-
- DISALLOW_COPY_AND_ASSIGN(EmbedderTest);
-};
-
-TEST_F(EmbedderTest, ChannelsBasic) {
- mojo::embedder::test::InitWithSimplePlatformSupport();
-
- {
- PlatformChannelPair channel_pair;
- ScopedTestChannel server_channel(test_io_thread()->task_runner(),
- channel_pair.PassServerHandle());
- MojoHandle server_mp = server_channel.bootstrap_message_pipe();
- EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
- ScopedTestChannel client_channel(test_io_thread()->task_runner(),
- channel_pair.PassClientHandle());
- MojoHandle client_mp = client_channel.bootstrap_message_pipe();
- EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
-
- // We can write to a message pipe handle immediately.
- const char kHello[] = "hello";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp, kHello,
- static_cast<uint32_t>(sizeof(kHello)), nullptr,
- 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // Now wait for the other side to become readable.
- MojoHandleSignalsState state;
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- char buffer[1000] = {};
- uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- EXPECT_EQ(sizeof(kHello), num_bytes);
- EXPECT_STREQ(kHello, buffer);
-
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
-
- // By this point, these waits should basically be no-ops (since we've waited
- // for the client message pipe to become readable, which implies that both
- // the server and client channels were completely created).
- server_channel.WaitForChannelCreationCompletion();
- client_channel.WaitForChannelCreationCompletion();
- EXPECT_TRUE(server_channel.channel_info());
- EXPECT_TRUE(client_channel.channel_info());
- }
-
- EXPECT_TRUE(test::Shutdown());
-}
-
-class TestAsyncWaiter {
- public:
- TestAsyncWaiter() : event_(true, false), wait_result_(MOJO_RESULT_UNKNOWN) {}
-
- void Awake(MojoResult result) {
- base::AutoLock l(wait_result_lock_);
- wait_result_ = result;
- event_.Signal();
- }
-
- bool TryWait() { return event_.TimedWait(TestTimeouts::action_timeout()); }
-
- MojoResult wait_result() const {
- base::AutoLock l(wait_result_lock_);
- return wait_result_;
- }
-
- private:
- base::WaitableEvent event_;
-
- mutable base::Lock wait_result_lock_;
- MojoResult wait_result_;
-
- DISALLOW_COPY_AND_ASSIGN(TestAsyncWaiter);
-};
-
-void WriteHello(MessagePipeHandle pipe) {
- static const char kHello[] = "hello";
- CHECK_EQ(MOJO_RESULT_OK,
- WriteMessageRaw(pipe, kHello, static_cast<uint32_t>(sizeof(kHello)),
- nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-}
-
-void CloseScopedHandle(ScopedMessagePipeHandle handle) {
- // Do nothing and the destructor will close it.
-}
-
-TEST_F(EmbedderTest, AsyncWait) {
- mojo::embedder::test::InitWithSimplePlatformSupport();
-
- {
- ScopedMessagePipeHandle client_mp;
- ScopedMessagePipeHandle server_mp;
- EXPECT_EQ(MOJO_RESULT_OK,
- mojo::CreateMessagePipe(nullptr, &client_mp, &server_mp));
-
- TestAsyncWaiter waiter;
- EXPECT_EQ(MOJO_RESULT_OK,
- AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
- base::Bind(&TestAsyncWaiter::Awake,
- base::Unretained(&waiter))));
-
- test_io_thread()->task_runner()->PostTask(
- FROM_HERE, base::Bind(&WriteHello, server_mp.get()));
- EXPECT_TRUE(waiter.TryWait());
- EXPECT_EQ(MOJO_RESULT_OK, waiter.wait_result());
-
- // If message is in the queue, it does't allow us to wait.
- TestAsyncWaiter waiter_that_doesnt_wait;
- EXPECT_EQ(
- MOJO_RESULT_ALREADY_EXISTS,
- AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
- base::Bind(&TestAsyncWaiter::Awake,
- base::Unretained(&waiter_that_doesnt_wait))));
-
- char buffer[1000];
- uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
- CHECK_EQ(MOJO_RESULT_OK,
- ReadMessageRaw(client_mp.get(), buffer, &num_bytes, nullptr,
- nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
-
- TestAsyncWaiter unsatisfiable_waiter;
- EXPECT_EQ(MOJO_RESULT_OK,
- AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
- base::Bind(&TestAsyncWaiter::Awake,
- base::Unretained(&unsatisfiable_waiter))));
-
- test_io_thread()->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&CloseScopedHandle, base::Passed(server_mp.Pass())));
-
- EXPECT_TRUE(unsatisfiable_waiter.TryWait());
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- unsatisfiable_waiter.wait_result());
- }
-
- EXPECT_TRUE(test::Shutdown());
-}
-
-TEST_F(EmbedderTest, ChannelsHandlePassing) {
- mojo::embedder::test::InitWithSimplePlatformSupport();
-
- {
- PlatformChannelPair channel_pair;
- ScopedTestChannel server_channel(test_io_thread()->task_runner(),
- channel_pair.PassServerHandle());
- MojoHandle server_mp = server_channel.bootstrap_message_pipe();
- EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
- ScopedTestChannel client_channel(test_io_thread()->task_runner(),
- channel_pair.PassClientHandle());
- MojoHandle client_mp = client_channel.bootstrap_message_pipe();
- EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
-
- MojoHandle h0, h1;
- EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1));
-
- // Write a message to |h0| (attaching nothing).
- const char kHello[] = "hello";
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWriteMessage(h0, kHello, static_cast<uint32_t>(sizeof(kHello)),
- nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // Write one message to |server_mp|, attaching |h1|.
- const char kWorld[] = "world!!!";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp, kWorld,
- static_cast<uint32_t>(sizeof(kWorld)), &h1, 1,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
- h1 = MOJO_HANDLE_INVALID;
-
- // Write another message to |h0|.
- const char kFoo[] = "foo";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(h0, kFoo, static_cast<uint32_t>(sizeof(kFoo)),
- nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // Wait for |client_mp| to become readable.
- MojoHandleSignalsState state;
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- // Read a message from |client_mp|.
- char buffer[1000] = {};
- uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
- MojoHandle handles[10] = {};
- uint32_t num_handles = arraysize(handles);
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp, buffer, &num_bytes, handles,
- &num_handles, MOJO_READ_MESSAGE_FLAG_NONE));
- EXPECT_EQ(sizeof(kWorld), num_bytes);
- EXPECT_STREQ(kWorld, buffer);
- EXPECT_EQ(1u, num_handles);
- EXPECT_NE(handles[0], MOJO_HANDLE_INVALID);
- h1 = handles[0];
-
- // Wait for |h1| to become readable.
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- // Read a message from |h1|.
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- memset(handles, 0, sizeof(handles));
- num_handles = arraysize(handles);
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h1, buffer, &num_bytes, handles, &num_handles,
- MOJO_READ_MESSAGE_FLAG_NONE));
- EXPECT_EQ(sizeof(kHello), num_bytes);
- EXPECT_STREQ(kHello, buffer);
- EXPECT_EQ(0u, num_handles);
-
- // Wait for |h1| to become readable (again).
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- // Read the second message from |h1|.
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h1, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- EXPECT_EQ(sizeof(kFoo), num_bytes);
- EXPECT_STREQ(kFoo, buffer);
-
- // Write a message to |h1|.
- const char kBarBaz[] = "barbaz";
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWriteMessage(h1, kBarBaz, static_cast<uint32_t>(sizeof(kBarBaz)),
- nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // Wait for |h0| to become readable.
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- // Read a message from |h0|.
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h0, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- EXPECT_EQ(sizeof(kBarBaz), num_bytes);
- EXPECT_STREQ(kBarBaz, buffer);
-
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0));
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1));
-
- server_channel.WaitForChannelCreationCompletion();
- client_channel.WaitForChannelCreationCompletion();
- EXPECT_TRUE(server_channel.channel_info());
- EXPECT_TRUE(client_channel.channel_info());
- }
-
- EXPECT_TRUE(test::Shutdown());
-}
-
-// 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_ANDROID)
-// Android multi-process tests are not executing the new process. This is flaky.
-#define MAYBE_MultiprocessChannels DISABLED_MultiprocessChannels
-#else
-#define MAYBE_MultiprocessChannels MultiprocessChannels
-#endif // defined(OS_ANDROID)
-TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
- mojo::embedder::test::InitWithSimplePlatformSupport();
- mojo::test::MultiprocessTestHelper multiprocess_test_helper;
- multiprocess_test_helper.StartChild("MultiprocessChannelsClient");
-
- {
- ScopedTestChannel server_channel(
- test_io_thread()->task_runner(),
- multiprocess_test_helper.server_platform_handle.Pass());
- MojoHandle server_mp = server_channel.bootstrap_message_pipe();
- EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
- server_channel.WaitForChannelCreationCompletion();
- EXPECT_TRUE(server_channel.channel_info());
-
- // 1. Write a message to |server_mp| (attaching nothing).
- const char kHello[] = "hello";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp, kHello,
- static_cast<uint32_t>(sizeof(kHello)), nullptr,
- 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // TODO(vtl): If the scope were ended immediately here (maybe after closing
- // |server_mp|), we die with a fatal error in |Channel::HandleLocalError()|.
-
- // 2. Read a message from |server_mp|.
- MojoHandleSignalsState state;
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- char buffer[1000] = {};
- uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(server_mp, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- const char kWorld[] = "world!";
- EXPECT_EQ(sizeof(kWorld), num_bytes);
- EXPECT_STREQ(kWorld, buffer);
-
- // Create a new message pipe (endpoints |mp0| and |mp1|).
- MojoHandle mp0, mp1;
- EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &mp0, &mp1));
-
- // 3. Write something to |mp0|.
- const char kFoo[] = "FOO";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(mp0, kFoo, static_cast<uint32_t>(sizeof(kFoo)),
- nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // 4. Write a message to |server_mp|, attaching |mp1|.
- const char kBar[] = "Bar";
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWriteMessage(server_mp, kBar, static_cast<uint32_t>(sizeof(kBar)),
- &mp1, 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
- mp1 = MOJO_HANDLE_INVALID;
-
- // 5. Close |server_mp|.
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
-
- // 9. Read a message from |mp0|, which should have |mp2| attached.
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- MojoHandle mp2 = MOJO_HANDLE_INVALID;
- uint32_t num_handles = 1;
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(mp0, buffer, &num_bytes, &mp2, &num_handles,
- MOJO_READ_MESSAGE_FLAG_NONE));
- const char kQuux[] = "quux";
- EXPECT_EQ(sizeof(kQuux), num_bytes);
- EXPECT_STREQ(kQuux, buffer);
- EXPECT_EQ(1u, num_handles);
- EXPECT_NE(mp2, MOJO_HANDLE_INVALID);
-
- // 7. Read a message from |mp2|.
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
- state.satisfied_signals);
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
- state.satisfiable_signals);
-
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(mp2, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- const char kBaz[] = "baz";
- EXPECT_EQ(sizeof(kBaz), num_bytes);
- EXPECT_STREQ(kBaz, buffer);
-
- // 10. Close |mp0|.
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp0));
-
-// 12. Wait on |mp2| (which should eventually fail) and then close it.
-// TODO(vtl): crbug.com/351768
-#if 0
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- &state));
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals);
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfiable_signals);
-#endif
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp2));
- }
-
- EXPECT_TRUE(multiprocess_test_helper.WaitForChildTestShutdown());
- EXPECT_TRUE(test::Shutdown());
-}
-
-MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) {
- ScopedPlatformHandle client_platform_handle =
- mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
- EXPECT_TRUE(client_platform_handle.is_valid());
-
- base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart);
- mojo::embedder::test::InitWithSimplePlatformSupport();
-
- {
- ScopedTestChannel client_channel(test_io_thread.task_runner(),
- client_platform_handle.Pass());
- MojoHandle client_mp = client_channel.bootstrap_message_pipe();
- EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
- client_channel.WaitForChannelCreationCompletion();
- CHECK(client_channel.channel_info() != nullptr);
-
- // 1. Read the first message from |client_mp|.
- MojoHandleSignalsState state;
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- char buffer[1000] = {};
- uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- const char kHello[] = "hello";
- EXPECT_EQ(sizeof(kHello), num_bytes);
- EXPECT_STREQ(kHello, buffer);
-
- // 2. Write a message to |client_mp| (attaching nothing).
- const char kWorld[] = "world!";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(client_mp, kWorld,
- static_cast<uint32_t>(sizeof(kWorld)), nullptr,
- 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // 4. Read a message from |client_mp|, which should have |mp1| attached.
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- // The other end of the handle may or may not be closed at this point, so we
- // can't test MOJO_HANDLE_SIGNAL_WRITABLE or MOJO_HANDLE_SIGNAL_PEER_CLOSED.
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE,
- state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE);
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE,
- state.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE);
- // TODO(vtl): If the scope were to end here (and |client_mp| closed), we'd
- // die (again due to |Channel::HandleLocalError()|).
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- MojoHandle mp1 = MOJO_HANDLE_INVALID;
- uint32_t num_handles = 1;
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp, buffer, &num_bytes, &mp1, &num_handles,
- MOJO_READ_MESSAGE_FLAG_NONE));
- const char kBar[] = "Bar";
- EXPECT_EQ(sizeof(kBar), num_bytes);
- EXPECT_STREQ(kBar, buffer);
- EXPECT_EQ(1u, num_handles);
- EXPECT_NE(mp1, MOJO_HANDLE_INVALID);
- // TODO(vtl): If the scope were to end here (and the two handles closed),
- // we'd die due to |Channel::RunRemoteMessagePipeEndpoint()| not handling
- // write errors (assuming the parent had closed the pipe).
-
- // 6. Close |client_mp|.
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
-
- // Create a new message pipe (endpoints |mp2| and |mp3|).
- MojoHandle mp2, mp3;
- EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &mp2, &mp3));
-
- // 7. Write a message to |mp3|.
- const char kBaz[] = "baz";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(mp3, kBaz, static_cast<uint32_t>(sizeof(kBaz)),
- nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // 8. Close |mp3|.
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp3));
-
- // 9. Write a message to |mp1|, attaching |mp2|.
- const char kQuux[] = "quux";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(mp1, kQuux, static_cast<uint32_t>(sizeof(kQuux)),
- &mp2, 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
- mp2 = MOJO_HANDLE_INVALID;
-
- // 3. Read a message from |mp1|.
- EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals);
- EXPECT_EQ(kSignalAll, state.satisfiable_signals);
-
- memset(buffer, 0, sizeof(buffer));
- num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(mp1, buffer, &num_bytes, nullptr, nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
- const char kFoo[] = "FOO";
- EXPECT_EQ(sizeof(kFoo), num_bytes);
- EXPECT_STREQ(kFoo, buffer);
-
- // 11. Wait on |mp1| (which should eventually fail) and then close it.
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE, &state));
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
- EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
- EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp1));
- }
-
- EXPECT_TRUE(test::Shutdown());
-}
-
-// TODO(vtl): Test immediate write & close.
-// TODO(vtl): Test broken-connection cases.
-
-} // namespace
-} // namespace embedder
-} // namespace mojo
« no previous file with comments | « mojo/edk/embedder/embedder_internal.h ('k') | mojo/edk/embedder/entrypoints.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698