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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: mojo/public/cpp/utility/tests/run_loop_unittest.cc

Issue 2250183003: Make the fuchsia mojo/public repo the source of truth. (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: Created 4 years, 4 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/public/cpp/utility/tests/BUILD.gn ('k') | mojo/public/dart/.analysis_options » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/public/cpp/utility/tests/run_loop_unittest.cc
diff --git a/mojo/public/cpp/utility/tests/run_loop_unittest.cc b/mojo/public/cpp/utility/tests/run_loop_unittest.cc
deleted file mode 100644
index 5e50a678b52b82a431f23bcfa3ea1c42555b9301..0000000000000000000000000000000000000000
--- a/mojo/public/cpp/utility/tests/run_loop_unittest.cc
+++ /dev/null
@@ -1,435 +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/public/cpp/utility/run_loop.h"
-
-#include <string>
-
-#include "gtest/gtest.h"
-#include "mojo/public/cpp/system/macros.h"
-#include "mojo/public/cpp/system/message_pipe.h"
-#include "mojo/public/cpp/test_support/test_utils.h"
-#include "mojo/public/cpp/utility/run_loop_handler.h"
-
-namespace mojo {
-namespace {
-
-class TestRunLoopHandler : public RunLoopHandler {
- public:
- TestRunLoopHandler() {}
- ~TestRunLoopHandler() override {}
-
- void clear_ready_count() { ready_count_ = 0; }
- int ready_count() const { return ready_count_; }
-
- void clear_error_count() { error_count_ = 0; }
- int error_count() const { return error_count_; }
-
- void clear_expected_handler_id() { have_expected_handler_id_ = false; }
- void set_expected_handler_id(Id id) {
- have_expected_handler_id_ = true;
- expected_handler_id_ = id;
- }
-
- MojoResult last_error_result() const { return last_error_result_; }
-
- // RunLoopHandler:
- void OnHandleReady(Id id) override {
- ready_count_++;
- if (have_expected_handler_id_) {
- EXPECT_EQ(expected_handler_id_, id);
- clear_expected_handler_id();
- }
- }
-
- void OnHandleError(Id id, MojoResult result) override {
- error_count_++;
- last_error_result_ = result;
- if (have_expected_handler_id_) {
- EXPECT_EQ(expected_handler_id_, id);
- clear_expected_handler_id();
- }
- }
-
- private:
- int ready_count_ = 0;
- int error_count_ = 0;
- bool have_expected_handler_id_ = false;
- Id expected_handler_id_ = 0u;
- MojoResult last_error_result_ = MOJO_RESULT_OK;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(TestRunLoopHandler);
-};
-
-// Trivial test to verify Run() with no added handles returns.
-TEST(RunLoopTest, ExitsWithNoHandles) {
- RunLoop run_loop;
- run_loop.Run();
-}
-
-class RemoveOnReadyRunLoopHandler : public TestRunLoopHandler {
- public:
- RemoveOnReadyRunLoopHandler() : run_loop_(nullptr) {}
- ~RemoveOnReadyRunLoopHandler() override {}
-
- void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
- // RunLoopHandler:
- void OnHandleReady(Id id) override {
- run_loop_->RemoveHandler(id);
- TestRunLoopHandler::OnHandleReady(id);
- }
-
- private:
- RunLoop* run_loop_;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveOnReadyRunLoopHandler);
-};
-
-// Verifies RunLoop quits when no more handles (handle is removed when ready).
-TEST(RunLoopTest, HandleReady) {
- RemoveOnReadyRunLoopHandler handler;
- MessagePipe test_pipe;
- EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
-
- RunLoop run_loop;
- handler.set_run_loop(&run_loop);
- auto id = run_loop.AddHandler(&handler, test_pipe.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- handler.set_expected_handler_id(id);
- run_loop.Run();
- EXPECT_EQ(1, handler.ready_count());
- EXPECT_EQ(0, handler.error_count());
- EXPECT_EQ(0u, run_loop.num_handlers());
-}
-
-class QuitOnReadyRunLoopHandler : public TestRunLoopHandler {
- public:
- QuitOnReadyRunLoopHandler() {}
- ~QuitOnReadyRunLoopHandler() override {}
-
- void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
- // RunLoopHandler:
- void OnHandleReady(Id id) override {
- run_loop_->Quit();
- TestRunLoopHandler::OnHandleReady(id);
- }
-
- private:
- RunLoop* run_loop_ = nullptr;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnReadyRunLoopHandler);
-};
-
-// Verifies Quit() from OnHandleReady() quits the loop.
-TEST(RunLoopTest, QuitFromReady) {
- QuitOnReadyRunLoopHandler handler;
- MessagePipe test_pipe;
- EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
-
- RunLoopHandler::Id id2;
- {
- RunLoop run_loop;
- handler.set_run_loop(&run_loop);
- auto id1 = run_loop.AddHandler(&handler, test_pipe.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- handler.set_expected_handler_id(id1);
- // Quitting should keep this handler.
- id2 = run_loop.AddHandler(&handler, test_pipe.handle1.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- EXPECT_NE(id2, id1);
- run_loop.Run();
- EXPECT_EQ(1, handler.ready_count());
- EXPECT_EQ(0, handler.error_count());
- EXPECT_EQ(1u, run_loop.num_handlers());
-
- // Destroying the RunLoop should call the second handler's OnHandleError().
- handler.set_expected_handler_id(id2);
- }
-}
-
-class QuitOnErrorRunLoopHandler : public TestRunLoopHandler {
- public:
- QuitOnErrorRunLoopHandler() {}
- ~QuitOnErrorRunLoopHandler() override {}
-
- void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
- // RunLoopHandler:
- void OnHandleError(Id id, MojoResult result) override {
- run_loop_->Quit();
- TestRunLoopHandler::OnHandleError(id, result);
- }
-
- private:
- RunLoop* run_loop_ = nullptr;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnErrorRunLoopHandler);
-};
-
-// Verifies Quit() when the deadline is reached works.
-TEST(RunLoopTest, QuitWhenDeadlineExpired) {
- QuitOnErrorRunLoopHandler handler;
- MessagePipe test_pipe;
- RunLoop run_loop;
- handler.set_run_loop(&run_loop);
- auto id = run_loop.AddHandler(&handler, test_pipe.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- static_cast<MojoDeadline>(10000));
- handler.set_expected_handler_id(id);
- run_loop.Run();
- EXPECT_EQ(0, handler.ready_count());
- EXPECT_EQ(1, handler.error_count());
- EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, handler.last_error_result());
- EXPECT_EQ(0u, run_loop.num_handlers());
-}
-
-// Test that handlers are notified of loop destruction.
-TEST(RunLoopTest, Destruction) {
- TestRunLoopHandler handler;
- MessagePipe test_pipe;
- {
- RunLoop run_loop;
- auto id = run_loop.AddHandler(&handler, test_pipe.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- handler.set_expected_handler_id(id);
- }
- EXPECT_EQ(1, handler.error_count());
- EXPECT_EQ(MOJO_RESULT_ABORTED, handler.last_error_result());
-}
-
-class RemoveManyRunLoopHandler : public TestRunLoopHandler {
- public:
- RemoveManyRunLoopHandler() {}
- ~RemoveManyRunLoopHandler() override {}
-
- void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
- void add_id(Id id) { ids_.push_back(id); }
-
- // RunLoopHandler:
- void OnHandleError(Id id, MojoResult result) override {
- for (size_t i = 0; i < ids_.size(); i++)
- run_loop_->RemoveHandler(ids_[i]);
- TestRunLoopHandler::OnHandleError(id, result);
- }
-
- private:
- std::vector<Id> ids_;
- RunLoop* run_loop_ = nullptr;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveManyRunLoopHandler);
-};
-
-// Test that handlers are notified of loop destruction.
-TEST(RunLoopTest, MultipleHandleDestruction) {
- RemoveManyRunLoopHandler odd_handler;
- TestRunLoopHandler even_handler;
- MessagePipe test_pipe1, test_pipe2, test_pipe3;
- {
- RunLoop run_loop;
- odd_handler.set_run_loop(&run_loop);
- odd_handler.add_id(run_loop.AddHandler(
- &odd_handler, test_pipe1.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE));
- auto even_id = run_loop.AddHandler(&even_handler, test_pipe2.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- even_handler.set_expected_handler_id(even_id);
- odd_handler.add_id(run_loop.AddHandler(
- &odd_handler, test_pipe3.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE));
- }
- EXPECT_EQ(1, odd_handler.error_count());
- EXPECT_EQ(1, even_handler.error_count());
- EXPECT_EQ(MOJO_RESULT_ABORTED, odd_handler.last_error_result());
- EXPECT_EQ(MOJO_RESULT_ABORTED, even_handler.last_error_result());
-}
-
-class AddHandlerOnErrorHandler : public TestRunLoopHandler {
- public:
- AddHandlerOnErrorHandler() {}
- ~AddHandlerOnErrorHandler() override {}
-
- void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
- void set_handle(Handle handle) { handle_ = handle; }
-
- // RunLoopHandler:
- void OnHandleError(Id id, MojoResult result) override {
- EXPECT_EQ(MOJO_RESULT_ABORTED, result);
-
- TestRunLoopHandler::OnHandleError(id, result);
-
- if (!on_handle_error_was_called_) {
- on_handle_error_was_called_ = true;
- auto id = run_loop_->AddHandler(
- this, handle_, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
- set_expected_handler_id(id);
- }
- }
-
- private:
- RunLoop* run_loop_ = nullptr;
- bool on_handle_error_was_called_ = false;
- Handle handle_;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(AddHandlerOnErrorHandler);
-};
-
-TEST(RunLoopTest, AddHandlerOnError) {
- AddHandlerOnErrorHandler handler;
- MessagePipe test_pipe;
- {
- RunLoop run_loop;
- handler.set_run_loop(&run_loop);
- handler.set_handle(test_pipe.handle0.get());
- auto id = run_loop.AddHandler(&handler, test_pipe.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- handler.set_expected_handler_id(id);
- }
- EXPECT_EQ(2, handler.error_count());
-}
-
-TEST(RunLoopTest, Current) {
- EXPECT_TRUE(RunLoop::current() == nullptr);
- {
- RunLoop run_loop;
- EXPECT_EQ(&run_loop, RunLoop::current());
- }
- EXPECT_TRUE(RunLoop::current() == nullptr);
-}
-
-class NestingRunLoopHandler : public TestRunLoopHandler {
- public:
- static constexpr size_t kDepthLimit = 10;
- static constexpr char kSignalMagic = 'X';
-
- NestingRunLoopHandler() {}
- ~NestingRunLoopHandler() override {}
-
- void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
- void set_pipe(MessagePipe* pipe) { pipe_ = pipe; }
- bool reached_depth_limit() const { return reached_depth_limit_; }
-
- // RunLoopHandler:
- void OnHandleReady(Id id) override {
- TestRunLoopHandler::OnHandleReady(id);
-
- ReadSignal();
- size_t current_depth = ++depth_;
- if (current_depth < kDepthLimit) {
- AddHandlerAndWriteSignal();
- run_loop_->Run();
- // The innermost loop stops running due to Quit() being called; the outer
- // loops stop running due to having no more handlers. No errors/timeouts
- // should ever occur.
- EXPECT_EQ(error_count(), 0);
- } else {
- EXPECT_EQ(current_depth, kDepthLimit);
- reached_depth_limit_ = true;
- run_loop_->Quit();
- }
- --depth_;
- }
-
- void AddHandlerAndWriteSignal() {
- run_loop_->AddHandler(this, pipe_->handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- static_cast<MojoDeadline>(10000));
- MojoResult write_result =
- WriteMessageRaw(pipe_->handle1.get(), &kSignalMagic, 1, nullptr, 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE);
- EXPECT_EQ(write_result, MOJO_RESULT_OK);
- }
-
- void ReadSignal() {
- char read_byte = 0;
- uint32_t bytes_read = 1;
- uint32_t handles_read = 0;
- MojoResult read_result =
- ReadMessageRaw(pipe_->handle0.get(), &read_byte, &bytes_read, nullptr,
- &handles_read, MOJO_READ_MESSAGE_FLAG_NONE);
- EXPECT_EQ(read_result, MOJO_RESULT_OK);
- EXPECT_EQ(read_byte, kSignalMagic);
- }
-
- private:
- RunLoop* run_loop_ = nullptr;
- MessagePipe* pipe_ = nullptr;
- size_t depth_ = 0u;
- bool reached_depth_limit_ = false;
-
- MOJO_DISALLOW_COPY_AND_ASSIGN(NestingRunLoopHandler);
-};
-
-// static
-const size_t NestingRunLoopHandler::kDepthLimit;
-
-// static
-const char NestingRunLoopHandler::kSignalMagic;
-
-TEST(RunLoopTest, NestedRun) {
- NestingRunLoopHandler handler;
- MessagePipe test_pipe;
- RunLoop run_loop;
- handler.set_run_loop(&run_loop);
- handler.set_pipe(&test_pipe);
- handler.AddHandlerAndWriteSignal();
- run_loop.Run();
-
- EXPECT_TRUE(handler.reached_depth_limit());
- // See the comment in NestingRunLoopHandler::OnHandleReady() above.
- EXPECT_EQ(handler.error_count(), 0);
-}
-
-struct Task {
- Task(int num, std::vector<int>* sequence) : num(num), sequence(sequence) {}
-
- void Run() const { sequence->push_back(num); }
-
- int num;
- std::vector<int>* sequence;
-};
-
-TEST(RunLoopTest, DelayedTaskOrder) {
- std::vector<int> sequence;
- RunLoop run_loop;
- run_loop.PostDelayedTask(Closure(Task(1, &sequence)), 0);
- run_loop.PostDelayedTask(Closure(Task(2, &sequence)), 0);
- run_loop.PostDelayedTask(Closure(Task(3, &sequence)), 0);
- run_loop.RunUntilIdle();
-
- ASSERT_EQ(3u, sequence.size());
- EXPECT_EQ(1, sequence[0]);
- EXPECT_EQ(2, sequence[1]);
- EXPECT_EQ(3, sequence[2]);
-}
-
-struct QuittingTask {
- explicit QuittingTask(RunLoop* run_loop) : run_loop(run_loop) {}
-
- void Run() const { run_loop->Quit(); }
-
- RunLoop* run_loop;
-};
-
-TEST(RunLoopTest, QuitFromDelayedTask) {
- TestRunLoopHandler handler;
- MessagePipe test_pipe;
- RunLoop run_loop;
- run_loop.AddHandler(&handler,
- test_pipe.handle0.get(),
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE);
- run_loop.PostDelayedTask(Closure(QuittingTask(&run_loop)), 0);
- run_loop.Run();
-}
-
-} // namespace
-} // namespace mojo
« no previous file with comments | « mojo/public/cpp/utility/tests/BUILD.gn ('k') | mojo/public/dart/.analysis_options » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698