// Copyright 2017 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 <stdint.h>
#include <map>
#include <memory>
#include <set>
#include "base/bind.h"
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/rand_util.h"
#include "base/synchronization/waitable_event.h"
#include "base/test/bind_test_util.h"
#include "base/threading/platform_thread.h"
#include "base/threading/simple_thread.h"
#include "base/time/time.h"
#include "mojo/core/test/mojo_test_base.h"
#include "mojo/public/c/system/data_pipe.h"
#include "mojo/public/c/system/trap.h"
#include "mojo/public/c/system/types.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace mojo {
namespace core {
namespace {
using TrapTest = test::MojoTestBase;
class TriggerHelper {
public:
using ContextCallback = base::RepeatingCallback<void(const MojoTrapEvent&)>;
TriggerHelper() {}
~TriggerHelper() {}
MojoResult CreateTrap(MojoHandle* handle) {
return MojoCreateTrap(&Notify, nullptr, handle);
}
template <typename Handler>
uintptr_t CreateContext(Handler handler) {
return CreateContextWithCancel(handler, [] {});
}
template <typename Handler, typename CancelHandler>
uintptr_t CreateContextWithCancel(Handler handler,
CancelHandler cancel_handler) {
auto* context =
new NotificationContext(base::BindLambdaForTesting(handler));
context->SetCancelCallback(
base::BindOnce(base::BindLambdaForTesting([cancel_handler, context] {
cancel_handler();
delete context;
})));
return reinterpret_cast<uintptr_t>(context);
}
private:
class NotificationContext {
public:
explicit NotificationContext(const ContextCallback& callback)
: callback_(callback) {}
~NotificationContext() {}
void SetCancelCallback(base::OnceClosure cancel_callback) {
cancel_callback_ = std::move(cancel_callback);
}
void Notify(const MojoTrapEvent& event) {
if (event.result == MOJO_RESULT_CANCELLED && cancel_callback_)
std::move(cancel_callback_).Run();
else
callback_.Run(event);
}
private:
const ContextCallback callback_;
base::OnceClosure cancel_callback_;
DISALLOW_COPY_AND_ASSIGN(NotificationContext);
};
static void Notify(const MojoTrapEvent* event) {
reinterpret_cast<NotificationContext*>(event->trigger_context)
->Notify(*event);
}
DISALLOW_COPY_AND_ASSIGN(TriggerHelper);
};
class ThreadedRunner : public base::SimpleThread {
public:
explicit ThreadedRunner(base::OnceClosure callback)
: SimpleThread("ThreadedRunner"), callback_(std::move(callback)) {}
~ThreadedRunner() override {}
void Run() override { std::move(callback_).Run(); }
private:
base::OnceClosure callback_;
DISALLOW_COPY_AND_ASSIGN(ThreadedRunner);
};
void ExpectNoNotification(const MojoTrapEvent* event) {
NOTREACHED();
}
void ExpectOnlyCancel(const MojoTrapEvent* event) {
EXPECT_EQ(event->result, MOJO_RESULT_CANCELLED);
}
TEST_F(TrapTest, InvalidArguments) {
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
MojoCreateTrap(&ExpectNoNotification, nullptr, nullptr));
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectNoNotification, nullptr, &t));
// Try to add triggers for handles which don't raise trappable signals.
EXPECT_EQ(
MOJO_RESULT_INVALID_ARGUMENT,
MojoAddTrigger(t, t, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, 0, nullptr));
MojoHandle buffer_handle = CreateBuffer(42);
EXPECT_EQ(
MOJO_RESULT_INVALID_ARGUMENT,
MojoAddTrigger(t, buffer_handle, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, 0, nullptr));
// Try to remove a trigger on a non-trap handle.
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
MojoRemoveTrigger(buffer_handle, 0, nullptr));
// Try to arm an invalid or non-trap handle.
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
MojoArmTrap(MOJO_HANDLE_INVALID, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
MojoArmTrap(buffer_handle, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(buffer_handle));
// Try to arm with a non-null count but a null output buffer.
uint32_t num_blocking_events = 1;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
MojoArmTrap(t, nullptr, &num_blocking_events, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, TrapMessagePipeReadable) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
int num_expected_notifications = 1;
const uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_GT(num_expected_notifications, 0);
num_expected_notifications -= 1;
EXPECT_EQ(MOJO_RESULT_OK, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
const char kMessage1[] = "hey hey hey hey";
const char kMessage2[] = "i said hey";
const char kMessage3[] = "what's goin' on?";
// Writing to |b| multiple times should notify exactly once.
WriteMessage(b, kMessage1);
WriteMessage(b, kMessage2);
wait.Wait();
// This also shouldn't fire a notification; the trap is still disarmed.
WriteMessage(b, kMessage3);
// Arming should fail with relevant information.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(readable_a_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
// Flush the three messages from above.
EXPECT_EQ(kMessage1, ReadMessage(a));
EXPECT_EQ(kMessage2, ReadMessage(a));
EXPECT_EQ(kMessage3, ReadMessage(a));
// Now we can rearm the trap.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
}
TEST_F(TrapTest, CloseWatchedMessagePipeHandle) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t readable_a_context = helper.CreateContextWithCancel(
[](const MojoTrapEvent&) {}, [&] { wait.Signal(); });
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
// Test that closing a watched handle fires an appropriate notification, even
// when the trap is unarmed.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, CloseWatchedMessagePipeHandlePeer) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
// Test that closing a watched handle's peer with an armed trap fires an
// appropriate notification.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
wait.Wait();
// And now arming should fail with correct information about |a|'s state.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(readable_a_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_PEER_CLOSED);
EXPECT_FALSE(blocking_events[0].signals_state.satisfiable_signals &
MOJO_HANDLE_SIGNAL_READABLE);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
}
TEST_F(TrapTest, TrapDataPipeConsumerReadable) {
constexpr size_t kTestPipeCapacity = 64;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
int num_expected_notifications = 1;
const uintptr_t readable_consumer_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_GT(num_expected_notifications, 0);
num_expected_notifications -= 1;
EXPECT_EQ(MOJO_RESULT_OK, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, consumer, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_consumer_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
const char kMessage1[] = "hey hey hey hey";
const char kMessage2[] = "i said hey";
const char kMessage3[] = "what's goin' on?";
// Writing to |producer| multiple times should notify exactly once.
WriteData(producer, kMessage1);
WriteData(producer, kMessage2);
wait.Wait();
// This also shouldn't fire a notification; the trap is still disarmed.
WriteData(producer, kMessage3);
// Arming should fail with relevant information.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(readable_consumer_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
// Flush the three messages from above.
EXPECT_EQ(kMessage1, ReadData(consumer, sizeof(kMessage1) - 1));
EXPECT_EQ(kMessage2, ReadData(consumer, sizeof(kMessage2) - 1));
EXPECT_EQ(kMessage3, ReadData(consumer, sizeof(kMessage3) - 1));
// Now we can rearm the trap.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
}
TEST_F(TrapTest, TrapDataPipeConsumerNewDataReadable) {
constexpr size_t kTestPipeCapacity = 64;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
int num_new_data_notifications = 0;
const uintptr_t new_data_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
num_new_data_notifications += 1;
EXPECT_EQ(MOJO_RESULT_OK, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, consumer, MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
new_data_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
const char kMessage1[] = "hey hey hey hey";
const char kMessage2[] = "i said hey";
const char kMessage3[] = "what's goin' on?";
// Writing to |producer| multiple times should notify exactly once.
WriteData(producer, kMessage1);
WriteData(producer, kMessage2);
wait.Wait();
// This also shouldn't fire a notification; the trap is still disarmed.
WriteData(producer, kMessage3);
// Arming should fail with relevant information.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(new_data_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
// Attempt to read more data than is available. Should fail but clear the
// NEW_DATA_READABLE signal.
char large_buffer[512];
uint32_t large_read_size = 512;
MojoReadDataOptions options;
options.struct_size = sizeof(options);
options.flags = MOJO_READ_DATA_FLAG_ALL_OR_NONE;
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
MojoReadData(consumer, &options, large_buffer, &large_read_size));
// Attempt to arm again. Should succeed.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Write more data. Should notify.
wait.Reset();
WriteData(producer, kMessage1);
wait.Wait();
// Reading some data should clear NEW_DATA_READABLE again so we can rearm.
EXPECT_EQ(kMessage1, ReadData(consumer, sizeof(kMessage1) - 1));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(2, num_new_data_notifications);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
}
TEST_F(TrapTest, TrapDataPipeProducerWritable) {
constexpr size_t kTestPipeCapacity = 8;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
// Half the capacity of the data pipe.
const char kTestData[] = "aaaa";
static_assert((sizeof(kTestData) - 1) * 2 == kTestPipeCapacity,
"Invalid test data for this test.");
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
int num_expected_notifications = 1;
const uintptr_t writable_producer_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_GT(num_expected_notifications, 0);
num_expected_notifications -= 1;
EXPECT_EQ(MOJO_RESULT_OK, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, producer, MOJO_HANDLE_SIGNAL_WRITABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
writable_producer_context, nullptr));
// The producer is already writable, so arming should fail with relevant
// information.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(writable_producer_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
// Write some data, but don't fill the pipe yet. Arming should fail again.
WriteData(producer, kTestData);
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(writable_producer_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
// Write more data, filling the pipe to capacity. Arming should succeed now.
WriteData(producer, kTestData);
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Now read from the pipe, making the producer writable again. Should notify.
EXPECT_EQ(kTestData, ReadData(consumer, sizeof(kTestData) - 1));
wait.Wait();
// Arming should fail again.
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(writable_producer_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
// Fill the pipe once more and arm the trap. Should succeed.
WriteData(producer, kTestData);
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
};
TEST_F(TrapTest, CloseWatchedDataPipeConsumerHandle) {
constexpr size_t kTestPipeCapacity = 8;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t readable_consumer_context = helper.CreateContextWithCancel(
[](const MojoTrapEvent&) {}, [&] { wait.Signal(); });
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, consumer, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_consumer_context, nullptr));
// Closing the consumer should fire a cancellation notification.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, CloseWatchedDataPipeConsumerHandlePeer) {
constexpr size_t kTestPipeCapacity = 8;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t readable_consumer_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, consumer, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_consumer_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Closing the producer should fire a notification for an unsatisfiable
// condition.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
wait.Wait();
// Now attempt to rearm and expect appropriate error feedback.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(readable_consumer_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, blocking_events[0].result);
EXPECT_FALSE(blocking_events[0].signals_state.satisfiable_signals &
MOJO_HANDLE_SIGNAL_READABLE);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
}
TEST_F(TrapTest, CloseWatchedDataPipeProducerHandle) {
constexpr size_t kTestPipeCapacity = 8;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t writable_producer_context = helper.CreateContextWithCancel(
[](const MojoTrapEvent&) {}, [&] { wait.Signal(); });
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, producer, MOJO_HANDLE_SIGNAL_WRITABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
writable_producer_context, nullptr));
// Closing the consumer should fire a cancellation notification.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, CloseWatchedDataPipeProducerHandlePeer) {
constexpr size_t kTestPipeCapacity = 8;
MojoHandle producer, consumer;
CreateDataPipe(&producer, &consumer, kTestPipeCapacity);
const char kTestMessageFullCapacity[] = "xxxxxxxx";
static_assert(sizeof(kTestMessageFullCapacity) - 1 == kTestPipeCapacity,
"Invalid test message size for this test.");
// Make the pipe unwritable initially.
WriteData(producer, kTestMessageFullCapacity);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t writable_producer_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, producer, MOJO_HANDLE_SIGNAL_WRITABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
writable_producer_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Closing the consumer should fire a notification for an unsatisfiable
// condition, as the full data pipe can never be read from again and is
// therefore permanently full and unwritable.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer));
wait.Wait();
// Now attempt to rearm and expect appropriate error feedback.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(writable_producer_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, blocking_events[0].result);
EXPECT_FALSE(blocking_events[0].signals_state.satisfiable_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
}
TEST_F(TrapTest, ArmWithNoTriggers) {
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectNoNotification, nullptr, &t));
EXPECT_EQ(MOJO_RESULT_NOT_FOUND, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, DuplicateTriggerContext) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectOnlyCancel, nullptr, &t));
EXPECT_EQ(
MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, 0, nullptr));
EXPECT_EQ(
MOJO_RESULT_ALREADY_EXISTS,
MojoAddTrigger(t, b, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, 0, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
}
TEST_F(TrapTest, RemoveUnknownTrigger) {
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectNoNotification, nullptr, &t));
EXPECT_EQ(MOJO_RESULT_NOT_FOUND, MojoRemoveTrigger(t, 1234, nullptr));
}
TEST_F(TrapTest, ArmWithTriggerConditionAlreadySatisfied) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectOnlyCancel, nullptr, &t));
EXPECT_EQ(
MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_WRITABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, 0, nullptr));
// |a| is always writable, so we can never arm this trap.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(0u, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
}
TEST_F(TrapTest, ArmWithTriggerConditionAlreadyUnsatisfiable) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectOnlyCancel, nullptr, &t));
EXPECT_EQ(
MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, 0, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
// |b| is closed and never wrote any messages, so |a| won't be readable again.
// MojoArmTrap() should fail, incidcating as much.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = kMaxBlockingEvents;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(0u, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_PEER_CLOSED);
EXPECT_FALSE(blocking_events[0].signals_state.satisfiable_signals &
MOJO_HANDLE_SIGNAL_READABLE);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
}
TEST_F(TrapTest, MultipleTriggers) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
base::WaitableEvent a_wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
base::WaitableEvent b_wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
int num_a_notifications = 0;
int num_b_notifications = 0;
uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
num_a_notifications += 1;
EXPECT_EQ(MOJO_RESULT_OK, event.result);
a_wait.Signal();
});
uintptr_t readable_b_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
num_b_notifications += 1;
EXPECT_EQ(MOJO_RESULT_OK, event.result);
b_wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
// Add two independent triggers to trap |a| or |b| readability.
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, b, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_b_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
const char kMessage1[] = "things are happening";
const char kMessage2[] = "ok. ok. ok. ok.";
const char kMessage3[] = "plz wake up";
// Writing to |b| should signal |a|'s watch.
WriteMessage(b, kMessage1);
a_wait.Wait();
a_wait.Reset();
// Subsequent messages on |b| should not trigger another notification.
WriteMessage(b, kMessage2);
WriteMessage(b, kMessage3);
// Messages on |a| also shouldn't trigger |b|'s notification, since the
// trap should be disarmed by now.
WriteMessage(a, kMessage1);
WriteMessage(a, kMessage2);
WriteMessage(a, kMessage3);
// Arming should fail. Since we only ask for at most one context's information
// that's all we should get back. Which one we get is unspecified.
constexpr size_t kMaxBlockingEvents = 3;
uint32_t num_blocking_events = 1;
MojoTrapEvent blocking_events[kMaxBlockingEvents] = {
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])},
{sizeof(blocking_events[0])}};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_TRUE(blocking_events[0].trigger_context == readable_a_context ||
blocking_events[0].trigger_context == readable_b_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
// Now try arming again, verifying that both contexts are returned.
num_blocking_events = kMaxBlockingEvents;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(2u, num_blocking_events);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[1].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
EXPECT_TRUE(blocking_events[1].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
EXPECT_TRUE((blocking_events[0].trigger_context == readable_a_context &&
blocking_events[1].trigger_context == readable_b_context) ||
(blocking_events[0].trigger_context == readable_b_context &&
blocking_events[1].trigger_context == readable_a_context));
// Flush out the test messages so we should be able to successfully rearm.
EXPECT_EQ(kMessage1, ReadMessage(a));
EXPECT_EQ(kMessage2, ReadMessage(a));
EXPECT_EQ(kMessage3, ReadMessage(a));
EXPECT_EQ(kMessage1, ReadMessage(b));
EXPECT_EQ(kMessage2, ReadMessage(b));
EXPECT_EQ(kMessage3, ReadMessage(b));
// Add a trigger whose condition is always satisfied so we can't arm. Arming
// should fail with only this new watch's information.
uintptr_t writable_c_context =
helper.CreateContext([](const MojoTrapEvent&) { NOTREACHED(); });
MojoHandle c, d;
CreateMessagePipe(&c, &d);
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, c, MOJO_HANDLE_SIGNAL_WRITABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
writable_c_context, nullptr));
num_blocking_events = kMaxBlockingEvents;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_events[0]));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(writable_c_context, blocking_events[0].trigger_context);
EXPECT_EQ(MOJO_RESULT_OK, blocking_events[0].result);
EXPECT_TRUE(blocking_events[0].signals_state.satisfied_signals &
MOJO_HANDLE_SIGNAL_WRITABLE);
// Remove the new trigger and arming should succeed once again.
EXPECT_EQ(MOJO_RESULT_OK, MojoRemoveTrigger(t, writable_c_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(c));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
}
TEST_F(TrapTest, ActivateOtherTriggerFromEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA[] = "hello a";
static const char kTestMessageToB[] = "hello b";
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ("hello a", ReadMessage(a));
// Re-arm the trap and signal |b|.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(a, kTestMessageToB);
});
uintptr_t readable_b_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToB, ReadMessage(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
wait.Signal();
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, b, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_b_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Send a message to |a|. The relevant trigger should be notified and the
// event handler should send a message to |b|, in turn notifying the other
// trigger. The second event handler will signal |wait|.
WriteMessage(b, kTestMessageToA);
wait.Wait();
}
TEST_F(TrapTest, ActivateSameTriggerFromEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA[] = "hello a";
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
int expected_notifications = 10;
uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ("hello a", ReadMessage(a));
EXPECT_GT(expected_notifications, 0);
expected_notifications -= 1;
if (expected_notifications == 0) {
wait.Signal();
return;
} else {
// Re-arm the trap and signal |a| again.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(b, kTestMessageToA);
}
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Send a message to |a|. When the trigger above is activated, the event
// handler will rearm the trap and send another message to |a|. This will
// happen until |expected_notifications| reaches 0.
WriteMessage(b, kTestMessageToA);
wait.Wait();
}
TEST_F(TrapTest, ImplicitRemoveOtherTriggerWithinEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle c, d;
CreateMessagePipe(&c, &d);
static const char kTestMessageToA[] = "hi a";
static const char kTestMessageToC[] = "hi c";
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
uintptr_t readable_a_context = helper.CreateContextWithCancel(
[](const MojoTrapEvent&) { NOTREACHED(); }, [&] { wait.Signal(); });
uintptr_t readable_c_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToC, ReadMessage(c));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Must result in exactly ONE notification from the above trigger, for
// CANCELLED only. Because we cannot dispatch notifications until the
// stack unwinds, and because we must never dispatch non-cancellation
// notifications for a handle once it's been closed, we must be certain
// that cancellation due to closure preemptively invalidates any
// pending non-cancellation notifications queued on the current
// RequestContext, such as the one resulting from the WriteMessage here.
WriteMessage(b, kTestMessageToA);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
// Rearming should be fine since |a|'s trigger should already be
// implicitly removed (even though the notification will not have
// been invoked yet.)
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Nothing interesting should happen as a result of this.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, c, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_c_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(d, kTestMessageToC);
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(c));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
}
TEST_F(TrapTest, ExplicitRemoveOtherTriggerWithinEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle c, d;
CreateMessagePipe(&c, &d);
static const char kTestMessageToA[] = "hi a";
static const char kTestMessageToC[] = "hi c";
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
uintptr_t readable_a_context =
helper.CreateContext([](const MojoTrapEvent&) { NOTREACHED(); });
uintptr_t readable_c_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToC, ReadMessage(c));
// Now rearm the trap.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Should result in no notifications from the above trigger, because the
// trigger will have been removed by the time the event handler can
// execute.
WriteMessage(b, kTestMessageToA);
WriteMessage(b, kTestMessageToA);
EXPECT_EQ(MOJO_RESULT_OK,
MojoRemoveTrigger(t, readable_a_context, nullptr));
// Rearming should be fine now.
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// Nothing interesting should happen as a result of these.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
wait.Signal();
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, c, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_c_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(d, kTestMessageToC);
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(c));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
}
TEST_F(TrapTest, NestedCancellation) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle c, d;
CreateMessagePipe(&c, &d);
static const char kTestMessageToA[] = "hey a";
static const char kTestMessageToC[] = "hey c";
static const char kTestMessageToD[] = "hey d";
// This is a tricky test. It establishes a trigger on |b| using one trap and
// triggers on |c| and |d| using another trap.
//
// A message is written to |d| to activate |c|'s trigger, and the resuling
// event handler invocation does the folllowing:
// 1. Writes to |a| to eventually activate |b|'s trigger.
// 2. Rearms |c|'s trap.
// 3. Writes to |d| to eventually activate |c|'s trigger again.
//
// Meanwhile, |b|'s event handler removes |c|'s trigger altogether before
// writing to |c| to activate |d|'s trigger.
//
// The net result should be that |c|'s trigger only gets activated once (from
// the first write to |d| above) and everyone else gets notified as expected.
MojoHandle b_trap;
MojoHandle cd_trap;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&b_trap));
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&cd_trap));
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
uintptr_t readable_d_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToD, ReadMessage(d));
wait.Signal();
});
int num_expected_c_notifications = 1;
uintptr_t readable_c_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_GT(num_expected_c_notifications--, 0);
// Trigger an eventual |readable_b_context| notification.
WriteMessage(a, kTestMessageToA);
EXPECT_EQ(kTestMessageToC, ReadMessage(c));
EXPECT_EQ(MOJO_RESULT_OK,
MojoArmTrap(cd_trap, nullptr, nullptr, nullptr));
// Trigger another eventual |readable_c_context| notification.
WriteMessage(d, kTestMessageToC);
});
uintptr_t readable_b_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK,
MojoRemoveTrigger(cd_trap, readable_c_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoArmTrap(cd_trap, nullptr, nullptr, nullptr));
WriteMessage(c, kTestMessageToD);
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(b_trap, b, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_b_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(cd_trap, c, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_c_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(cd_trap, d, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_d_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(b_trap, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(cd_trap, nullptr, nullptr, nullptr));
WriteMessage(d, kTestMessageToC);
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(cd_trap));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b_trap));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(c));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
}
TEST_F(TrapTest, RemoveSelfWithinEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA[] = "hey a";
MojoHandle t;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
static uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
// There should be no problem removing this trigger from its own
// notification invocation.
EXPECT_EQ(MOJO_RESULT_OK,
MojoRemoveTrigger(t, readable_a_context, nullptr));
EXPECT_EQ(kTestMessageToA, ReadMessage(a));
// Arming should fail because there are no longer any registered
// triggers on the trap.
EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
MojoArmTrap(t, nullptr, nullptr, nullptr));
// And closing |a| should be fine (and should not invoke this
// notification with MOJO_RESULT_CANCELLED) for the same reason.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
wait.Signal();
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(b, kTestMessageToA);
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, CloseTrapWithinEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA1[] = "hey a";
static const char kTestMessageToA2[] = "hey a again";
MojoHandle t;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToA1, ReadMessage(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// There should be no problem closing this trap from its own
// notification callback.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
// And these should not trigger more notifications, because |t| has been
// closed already.
WriteMessage(b, kTestMessageToA2);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
wait.Signal();
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(b, kTestMessageToA1);
wait.Wait();
}
TEST_F(TrapTest, CloseTrapAfterImplicitTriggerRemoval) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA[] = "hey a";
MojoHandle t;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToA, ReadMessage(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// This will cue up a notification for |MOJO_RESULT_CANCELLED|...
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
// ...but it should never fire because we close the trap here.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
wait.Signal();
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(b, kTestMessageToA);
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
}
TEST_F(TrapTest, OtherThreadRemovesTriggerDuringEventHandler) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA[] = "hey a";
MojoHandle t;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
base::WaitableEvent wait_for_notification(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
base::WaitableEvent wait_for_cancellation(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
static bool callback_done = false;
uintptr_t readable_a_context = helper.CreateContextWithCancel(
[&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToA, ReadMessage(a));
wait_for_notification.Signal();
// Give the other thread sufficient time to race with the completion
// of this callback. There should be no race, since the cancellation
// notification must be mutually exclusive to this notification.
base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
callback_done = true;
},
[&] {
EXPECT_TRUE(callback_done);
wait_for_cancellation.Signal();
});
ThreadedRunner runner(base::BindOnce(base::BindLambdaForTesting([&] {
wait_for_notification.Wait();
// Cancel the watch while the notification is still running.
EXPECT_EQ(MOJO_RESULT_OK,
MojoRemoveTrigger(t, readable_a_context, nullptr));
wait_for_cancellation.Wait();
EXPECT_TRUE(callback_done);
})));
runner.Start();
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
WriteMessage(b, kTestMessageToA);
runner.Join();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, TriggersRemoveEachOtherWithinEventHandlers) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
static const char kTestMessageToA[] = "hey a";
static const char kTestMessageToB[] = "hey b";
base::WaitableEvent wait_for_a_to_notify(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
base::WaitableEvent wait_for_b_to_notify(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
base::WaitableEvent wait_for_a_to_cancel(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
base::WaitableEvent wait_for_b_to_cancel(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
MojoHandle a_trap;
MojoHandle b_trap;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&a_trap));
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&b_trap));
// We set up two traps, one triggered on |a| readability and one triggered on
// |b| readability. Each removes the other's trigger from within its own event
// handler. This should be safe, i.e., it should not deadlock in spite of the
// fact that we also guarantee mutually exclusive event handler invocation
// (including cancellations) on any given trap.
bool a_cancelled = false;
bool b_cancelled = false;
static uintptr_t readable_b_context;
uintptr_t readable_a_context = helper.CreateContextWithCancel(
[&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToA, ReadMessage(a));
wait_for_a_to_notify.Signal();
wait_for_b_to_notify.Wait();
EXPECT_EQ(MOJO_RESULT_OK,
MojoRemoveTrigger(b_trap, readable_b_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b_trap));
},
[&] {
a_cancelled = true;
wait_for_a_to_cancel.Signal();
wait_for_b_to_cancel.Wait();
});
readable_b_context = helper.CreateContextWithCancel(
[&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
EXPECT_EQ(kTestMessageToB, ReadMessage(b));
wait_for_b_to_notify.Signal();
wait_for_a_to_notify.Wait();
EXPECT_EQ(MOJO_RESULT_OK,
MojoRemoveTrigger(a_trap, readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a_trap));
},
[&] {
b_cancelled = true;
wait_for_b_to_cancel.Signal();
wait_for_a_to_cancel.Wait();
});
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(a_trap, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(a_trap, nullptr, nullptr, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(b_trap, b, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_b_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(b_trap, nullptr, nullptr, nullptr));
ThreadedRunner runner(base::BindOnce(
[](MojoHandle b) { WriteMessage(b, kTestMessageToA); }, b));
runner.Start();
WriteMessage(a, kTestMessageToB);
wait_for_a_to_cancel.Wait();
wait_for_b_to_cancel.Wait();
runner.Join();
EXPECT_TRUE(a_cancelled);
EXPECT_TRUE(b_cancelled);
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
}
TEST_F(TrapTest, AlwaysCancel) {
// Basic sanity check to ensure that all possible ways to remove a trigger
// result in a final MOJO_RESULT_CANCELLED notification.
MojoHandle a, b;
CreateMessagePipe(&a, &b);
MojoHandle t;
TriggerHelper helper;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
auto ignore_event = [](const MojoTrapEvent&) {};
auto signal_wait = [&] { wait.Signal(); };
// Cancel via |MojoRemoveTrigger()|.
uintptr_t context = helper.CreateContextWithCancel(ignore_event, signal_wait);
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, context,
nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoRemoveTrigger(t, context, nullptr));
wait.Wait();
wait.Reset();
// Cancel by closing the trigger's watched handle.
context = helper.CreateContextWithCancel(ignore_event, signal_wait);
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, context,
nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
wait.Wait();
wait.Reset();
// Cancel by closing the trap handle.
context = helper.CreateContextWithCancel(ignore_event, signal_wait);
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, b, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, context,
nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
}
TEST_F(TrapTest, ArmFailureCirculation) {
// Sanity check to ensure that all ready trigger events will eventually be
// returned over a finite number of calls to MojoArmTrap().
constexpr size_t kNumTestPipes = 100;
constexpr size_t kNumTestHandles = kNumTestPipes * 2;
MojoHandle handles[kNumTestHandles];
// Create a bunch of pipes and make sure they're all readable.
for (size_t i = 0; i < kNumTestPipes; ++i) {
CreateMessagePipe(&handles[i], &handles[i + kNumTestPipes]);
WriteMessage(handles[i], "hey");
WriteMessage(handles[i + kNumTestPipes], "hay");
WaitForSignals(handles[i], MOJO_HANDLE_SIGNAL_READABLE);
WaitForSignals(handles[i + kNumTestPipes], MOJO_HANDLE_SIGNAL_READABLE);
}
// Create a trap and watch all of them for readability.
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, MojoCreateTrap(&ExpectOnlyCancel, nullptr, &t));
for (size_t i = 0; i < kNumTestHandles; ++i) {
EXPECT_EQ(
MOJO_RESULT_OK,
MojoAddTrigger(t, handles[i], MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED, i, nullptr));
}
// Keep trying to arm |t| until every trigger gets an entry in
// |ready_contexts|. If MojoArmTrap() is well-behaved, this should terminate
// eventually.
std::set<uintptr_t> ready_contexts;
while (ready_contexts.size() < kNumTestHandles) {
uint32_t num_blocking_events = 1;
MojoTrapEvent blocking_event = {sizeof(blocking_event)};
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
MojoArmTrap(t, nullptr, &num_blocking_events, &blocking_event));
EXPECT_EQ(1u, num_blocking_events);
EXPECT_EQ(MOJO_RESULT_OK, blocking_event.result);
ready_contexts.insert(blocking_event.trigger_context);
}
for (size_t i = 0; i < kNumTestHandles; ++i)
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(handles[i]));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
}
TEST_F(TrapTest, TriggerOnUnsatisfiedSignals) {
MojoHandle a, b;
CreateMessagePipe(&a, &b);
base::WaitableEvent wait(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
TriggerHelper helper;
const uintptr_t readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
wait.Signal();
});
MojoHandle t;
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
const char kMessage[] = "this is not a message";
WriteMessage(b, kMessage);
wait.Wait();
// Now we know |a| is readable. Remove the trigger and add a new one to watch
// for a not-readable state.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
const uintptr_t not_readable_a_context =
helper.CreateContext([&](const MojoTrapEvent& event) {
EXPECT_EQ(MOJO_RESULT_OK, event.result);
wait.Signal();
});
EXPECT_EQ(MOJO_RESULT_OK, helper.CreateTrap(&t));
EXPECT_EQ(MOJO_RESULT_OK,
MojoAddTrigger(t, a, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_UNSATISFIED,
not_readable_a_context, nullptr));
EXPECT_EQ(MOJO_RESULT_OK, MojoArmTrap(t, nullptr, nullptr, nullptr));
// This should not block, because the event should be signaled by
// |not_readable_a_context| when we read the only available message off of
// |a|.
wait.Reset();
EXPECT_EQ(kMessage, ReadMessage(a));
wait.Wait();
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(t));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
}
base::Closure g_do_random_thing_callback;
void ReadAllMessages(const MojoTrapEvent* event) {
if (event->result == MOJO_RESULT_OK) {
MojoHandle handle = static_cast<MojoHandle>(event->trigger_context);
MojoMessageHandle message;
while (MojoReadMessage(handle, nullptr, &message) == MOJO_RESULT_OK)
MojoDestroyMessage(message);
}
constexpr size_t kNumRandomThingsToDoOnNotify = 5;
for (size_t i = 0; i < kNumRandomThingsToDoOnNotify; ++i)
g_do_random_thing_callback.Run();
}
MojoHandle RandomHandle(MojoHandle* handles, size_t size) {
return handles[base::RandInt(0, static_cast<int>(size) - 1)];
}
void DoRandomThing(MojoHandle* traps,
size_t num_traps,
MojoHandle* watched_handles,
size_t num_watched_handles) {
switch (base::RandInt(0, 10)) {
case 0:
MojoClose(RandomHandle(traps, num_traps));
break;
case 1:
MojoClose(RandomHandle(watched_handles, num_watched_handles));
break;
case 2:
case 3:
case 4: {
MojoMessageHandle message;
ASSERT_EQ(MOJO_RESULT_OK, MojoCreateMessage(nullptr, &message));
ASSERT_EQ(MOJO_RESULT_OK,
MojoSetMessageContext(message, 1, nullptr, nullptr, nullptr));
MojoWriteMessage(RandomHandle(watched_handles, num_watched_handles),
message, nullptr);
break;
}
case 5:
case 6: {
MojoHandle t = RandomHandle(traps, num_traps);
MojoHandle h = RandomHandle(watched_handles, num_watched_handles);
MojoAddTrigger(t, h, MOJO_HANDLE_SIGNAL_READABLE,
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
static_cast<uintptr_t>(h), nullptr);
break;
}
case 7:
case 8: {
uint32_t num_blocking_events = 1;
MojoTrapEvent blocking_event = {sizeof(blocking_event)};
if (MojoArmTrap(RandomHandle(traps, num_traps), nullptr,
&num_blocking_events,
&blocking_event) == MOJO_RESULT_FAILED_PRECONDITION &&
blocking_event.result == MOJO_RESULT_OK) {
ReadAllMessages(&blocking_event);
}
break;
}
case 9:
case 10: {
MojoHandle t = RandomHandle(traps, num_traps);
MojoHandle h = RandomHandle(watched_handles, num_watched_handles);
MojoRemoveTrigger(t, static_cast<uintptr_t>(h), nullptr);
break;
}
default:
NOTREACHED();
break;
}
}
TEST_F(TrapTest, ConcurrencyStressTest) {
// Regression test for https://crbug.com/740044. Exercises racy usage of the
// trap API to weed out potential crashes.
constexpr size_t kNumTraps = 50;
constexpr size_t kNumWatchedHandles = 50;
static_assert(kNumWatchedHandles % 2 == 0, "Invalid number of test handles.");
constexpr size_t kNumThreads = 10;
static constexpr size_t kNumOperationsPerThread = 400;
MojoHandle traps[kNumTraps];
MojoHandle watched_handles[kNumWatchedHandles];
g_do_random_thing_callback = base::BindRepeating(
&DoRandomThing, traps, kNumTraps, watched_handles, kNumWatchedHandles);
for (size_t i = 0; i < kNumTraps; ++i)
MojoCreateTrap(&ReadAllMessages, nullptr, &traps[i]);
for (size_t i = 0; i < kNumWatchedHandles; i += 2)
CreateMessagePipe(&watched_handles[i], &watched_handles[i + 1]);
std::unique_ptr<ThreadedRunner> threads[kNumThreads];
for (size_t i = 0; i < kNumThreads; ++i) {
threads[i] = std::make_unique<ThreadedRunner>(base::BindOnce([] {
for (size_t i = 0; i < kNumOperationsPerThread; ++i)
g_do_random_thing_callback.Run();
}));
threads[i]->Start();
}
for (size_t i = 0; i < kNumThreads; ++i)
threads[i]->Join();
for (size_t i = 0; i < kNumTraps; ++i)
MojoClose(traps[i]);
for (size_t i = 0; i < kNumWatchedHandles; ++i)
MojoClose(watched_handles[i]);
}
} // namespace
} // namespace core
} // namespace mojo