blob: d5993b6fca4cd14ab08d80fc215f8544ca6b2b50 [file] [log] [blame]
// 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 "base/trace_event/memory_dump_scheduler.h"
#include <memory>
#include "base/bind.h"
#include "base/single_thread_task_runner.h"
#include "base/synchronization/waitable_event.h"
#include "base/threading/thread.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::testing::AtMost;
using ::testing::Invoke;
using ::testing::_;
namespace base {
namespace trace_event {
namespace {
// Wrapper to use gmock on a callback.
struct CallbackWrapper {
MOCK_METHOD1(OnTick, void(MemoryDumpLevelOfDetail));
};
} // namespace
class MemoryDumpSchedulerTest : public testing::Test {
public:
MemoryDumpSchedulerTest()
: testing::Test(),
evt_(WaitableEvent::ResetPolicy::MANUAL,
WaitableEvent::InitialState::NOT_SIGNALED),
bg_thread_("MemoryDumpSchedulerTest Thread") {
bg_thread_.Start();
}
protected:
MemoryDumpScheduler scheduler_;
WaitableEvent evt_;
CallbackWrapper on_tick_;
Thread bg_thread_;
};
TEST_F(MemoryDumpSchedulerTest, SingleTrigger) {
const uint32_t kPeriodMs = 1;
const auto kLevelOfDetail = MemoryDumpLevelOfDetail::DETAILED;
const uint32_t kTicks = 5;
MemoryDumpScheduler::Config config;
config.triggers.push_back({kLevelOfDetail, kPeriodMs});
config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
testing::InSequence sequence;
EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
EXPECT_CALL(on_tick_, OnTick(_))
.WillRepeatedly(Invoke(
[this, kLevelOfDetail](MemoryDumpLevelOfDetail level_of_detail) {
EXPECT_EQ(kLevelOfDetail, level_of_detail);
this->evt_.Signal();
}));
// Check that Stop() before Start() doesn't cause any error.
scheduler_.Stop();
const TimeTicks tstart = TimeTicks::Now();
scheduler_.Start(config, bg_thread_.task_runner());
evt_.Wait();
const double time_ms = (TimeTicks::Now() - tstart).InMillisecondsF();
// It takes N-1 ms to perform N ticks of 1ms each.
EXPECT_GE(time_ms, kPeriodMs * (kTicks - 1));
// Check that stopping twice doesn't cause any problems.
scheduler_.Stop();
scheduler_.Stop();
}
TEST_F(MemoryDumpSchedulerTest, MultipleTriggers) {
const uint32_t kPeriodLightMs = 3;
const uint32_t kPeriodDetailedMs = 9;
MemoryDumpScheduler::Config config;
const MemoryDumpLevelOfDetail kLight = MemoryDumpLevelOfDetail::LIGHT;
const MemoryDumpLevelOfDetail kDetailed = MemoryDumpLevelOfDetail::DETAILED;
config.triggers.push_back({kLight, kPeriodLightMs});
config.triggers.push_back({kDetailed, kPeriodDetailedMs});
config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
TimeTicks t1, t2, t3;
testing::InSequence sequence;
EXPECT_CALL(on_tick_, OnTick(kDetailed))
.WillOnce(
Invoke([&t1](MemoryDumpLevelOfDetail) { t1 = TimeTicks::Now(); }));
EXPECT_CALL(on_tick_, OnTick(kLight)).Times(1);
EXPECT_CALL(on_tick_, OnTick(kLight)).Times(1);
EXPECT_CALL(on_tick_, OnTick(kDetailed))
.WillOnce(
Invoke([&t2](MemoryDumpLevelOfDetail) { t2 = TimeTicks::Now(); }));
EXPECT_CALL(on_tick_, OnTick(kLight))
.WillOnce(
Invoke([&t3](MemoryDumpLevelOfDetail) { t3 = TimeTicks::Now(); }));
// Rationale for WillRepeatedly and not just WillOnce: Extra ticks might
// happen if the Stop() takes time. Not an interesting case, but we need to
// avoid gmock to shout in that case.
EXPECT_CALL(on_tick_, OnTick(_))
.WillRepeatedly(
Invoke([this](MemoryDumpLevelOfDetail) { this->evt_.Signal(); }));
scheduler_.Start(config, bg_thread_.task_runner());
evt_.Wait();
scheduler_.Stop();
EXPECT_GE((t2 - t1).InMillisecondsF(), kPeriodDetailedMs);
EXPECT_GE((t3 - t2).InMillisecondsF(), kPeriodLightMs);
}
TEST_F(MemoryDumpSchedulerTest, StartStopQuickly) {
const uint32_t kPeriodMs = 3;
const uint32_t kQuickIterations = 5;
const uint32_t kDetailedTicks = 10;
MemoryDumpScheduler::Config light_config;
light_config.triggers.push_back({MemoryDumpLevelOfDetail::LIGHT, kPeriodMs});
light_config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
MemoryDumpScheduler::Config detailed_config;
detailed_config.triggers.push_back(
{MemoryDumpLevelOfDetail::DETAILED, kPeriodMs});
detailed_config.callback =
Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
testing::InSequence sequence;
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::LIGHT))
.Times(AtMost(kQuickIterations));
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::DETAILED))
.Times(kDetailedTicks - 1);
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::DETAILED))
.WillRepeatedly(
Invoke([this](MemoryDumpLevelOfDetail) { this->evt_.Signal(); }));
const TimeTicks tstart = TimeTicks::Now();
for (unsigned int i = 0; i < kQuickIterations; i++) {
scheduler_.Start(light_config, bg_thread_.task_runner());
scheduler_.Stop();
}
scheduler_.Start(detailed_config, bg_thread_.task_runner());
evt_.Wait();
const double time_ms = (TimeTicks::Now() - tstart).InMillisecondsF();
scheduler_.Stop();
// It takes N-1 ms to perform N ticks of 1ms each.
EXPECT_GE(time_ms, kPeriodMs * (kDetailedTicks - 1));
}
TEST_F(MemoryDumpSchedulerTest, StopAndStartOnAnotherThread) {
const uint32_t kPeriodMs = 1;
const uint32_t kTicks = 3;
MemoryDumpScheduler::Config config;
config.triggers.push_back({MemoryDumpLevelOfDetail::DETAILED, kPeriodMs});
config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
scoped_refptr<TaskRunner> expected_task_runner = bg_thread_.task_runner();
testing::InSequence sequence;
EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
EXPECT_CALL(on_tick_, OnTick(_))
.WillRepeatedly(
Invoke([this, expected_task_runner](MemoryDumpLevelOfDetail) {
EXPECT_TRUE(expected_task_runner->RunsTasksInCurrentSequence());
this->evt_.Signal();
}));
scheduler_.Start(config, bg_thread_.task_runner());
evt_.Wait();
scheduler_.Stop();
bg_thread_.Stop();
Thread bg_thread_2("MemoryDumpSchedulerTest Thread 2");
bg_thread_2.Start();
evt_.Reset();
expected_task_runner = bg_thread_2.task_runner();
EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
EXPECT_CALL(on_tick_, OnTick(_))
.WillRepeatedly(
Invoke([this, expected_task_runner](MemoryDumpLevelOfDetail) {
EXPECT_TRUE(expected_task_runner->RunsTasksInCurrentSequence());
this->evt_.Signal();
}));
scheduler_.Start(config, bg_thread_2.task_runner());
evt_.Wait();
scheduler_.Stop();
}
} // namespace trace_event
} // namespace base