75 lines
2.8 KiB
C++
75 lines
2.8 KiB
C++
// Copyright 2015 The Chromium OS Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef LIBBRILLO_BRILLO_MESSAGE_LOOPS_MOCK_MESSAGE_LOOP_H_
|
|
#define LIBBRILLO_BRILLO_MESSAGE_LOOPS_MOCK_MESSAGE_LOOP_H_
|
|
|
|
#include <gmock/gmock.h>
|
|
|
|
#include <base/location.h>
|
|
#include <base/test/simple_test_clock.h>
|
|
#include <base/time/time.h>
|
|
|
|
#include <brillo/brillo_export.h>
|
|
#include <brillo/message_loops/fake_message_loop.h>
|
|
#include <brillo/message_loops/message_loop.h>
|
|
|
|
namespace brillo {
|
|
|
|
// The MockMessageLoop is a mockable MessageLoop that will by default act as a
|
|
// FakeMessageLoop. It is possible to set expectations with EXPECT_CALL without
|
|
// any action associated and they will call the same methods in the underlying
|
|
// FakeMessageLoop implementation.
|
|
// This message loop implementation is useful to check interaction with the
|
|
// message loop when running unittests.
|
|
class BRILLO_EXPORT MockMessageLoop : public MessageLoop {
|
|
public:
|
|
// Create a FakeMessageLoop optionally using a SimpleTestClock to update the
|
|
// time when Run() or RunOnce(true) are called and should block.
|
|
explicit MockMessageLoop(base::SimpleTestClock* clock)
|
|
: fake_loop_(clock) {
|
|
// Redirect all actions to calling the underlying FakeMessageLoop by
|
|
// default. For the overloaded methods, we need to disambiguate between the
|
|
// different options by specifying the type of the method pointer.
|
|
ON_CALL(*this, PostDelayedTask(::testing::_, ::testing::_, ::testing::_))
|
|
.WillByDefault(::testing::Invoke(
|
|
&fake_loop_,
|
|
static_cast<TaskId(FakeMessageLoop::*)(
|
|
const base::Location&,
|
|
base::OnceClosure,
|
|
base::TimeDelta)>(
|
|
&FakeMessageLoop::PostDelayedTask)));
|
|
ON_CALL(*this, CancelTask(::testing::_))
|
|
.WillByDefault(::testing::Invoke(&fake_loop_,
|
|
&FakeMessageLoop::CancelTask));
|
|
ON_CALL(*this, RunOnce(::testing::_))
|
|
.WillByDefault(::testing::Invoke(&fake_loop_,
|
|
&FakeMessageLoop::RunOnce));
|
|
}
|
|
~MockMessageLoop() override = default;
|
|
|
|
MOCK_METHOD(TaskId,
|
|
PostDelayedTask,
|
|
(const base::Location&, base::OnceClosure, base::TimeDelta),
|
|
(override));
|
|
using MessageLoop::PostDelayedTask;
|
|
MOCK_METHOD(bool, CancelTask, (TaskId), (override));
|
|
MOCK_METHOD(bool, RunOnce, (bool), (override));
|
|
|
|
// Returns the actual FakeMessageLoop instance so default actions can be
|
|
// override with other actions or call
|
|
FakeMessageLoop* fake_loop() {
|
|
return &fake_loop_;
|
|
}
|
|
|
|
private:
|
|
FakeMessageLoop fake_loop_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(MockMessageLoop);
|
|
};
|
|
|
|
} // namespace brillo
|
|
|
|
#endif // LIBBRILLO_BRILLO_MESSAGE_LOOPS_MOCK_MESSAGE_LOOP_H_
|