1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// Copyright (c) 2011 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 "chrome/browser/policy/logging_work_scheduler.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop.h"
#include "content/public/test/test_browser_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
using content::BrowserThread;
namespace policy {
class LoggingWorkSchedulerTest : public testing::Test {
public:
LoggingWorkSchedulerTest()
: ui_thread_(BrowserThread::UI, &loop_) {
}
virtual ~LoggingWorkSchedulerTest() {
}
virtual void TearDown() {
scheduler1_.reset();
scheduler2_.reset();
logger_.reset();
}
protected:
void Callback1() {
logger_->RegisterEvent();
if (count1_ > 0) {
count1_--;
scheduler1_->PostDelayedWork(
base::Bind(&LoggingWorkSchedulerTest::Callback1,
base::Unretained(this)), delay1_);
}
}
void Callback2() {
logger_->RegisterEvent();
if (count2_ > 0) {
count2_--;
scheduler2_->PostDelayedWork(
base::Bind(&LoggingWorkSchedulerTest::Callback2,
base::Unretained(this)), delay2_);
}
}
protected:
scoped_ptr<EventLogger> logger_;
// The first scheduler will fire |count1_| events with |delay1_| pauses
// between each.
scoped_ptr<LoggingWorkScheduler> scheduler1_;
int count1_;
int delay1_;
// The second scheduler will fire |count2_| events with |delay2_| pauses
// between each.
scoped_ptr<LoggingWorkScheduler> scheduler2_;
int count2_;
int delay2_;
MessageLoop loop_;
private:
content::TestBrowserThread ui_thread_;
DISALLOW_COPY_AND_ASSIGN(LoggingWorkSchedulerTest);
};
TEST_F(LoggingWorkSchedulerTest, LoggerTest) {
logger_.reset(new EventLogger);
scheduler1_.reset(new LoggingWorkScheduler(logger_.get()));
scheduler2_.reset(new LoggingWorkScheduler(logger_.get()));
// Configure the first scheduler to fire at 0, 30, 60, 90, 120.
count1_ = 4;
delay1_ = 30;
// Configure the first scheduler to fire at 0, 40, 80, 120.
count2_ = 3;
delay2_ = 40;
Callback1();
Callback2();
loop_.RunAllPending();
std::vector<int64> events;
logger_->Swap(&events);
EXPECT_EQ(9u, events.size());
EXPECT_EQ(0, events[0]);
EXPECT_EQ(0, events[1]);
EXPECT_EQ(30, events[2]);
EXPECT_EQ(40, events[3]);
EXPECT_EQ(60, events[4]);
EXPECT_EQ(80, events[5]);
EXPECT_EQ(90, events[6]);
EXPECT_EQ(120, events[7]);
EXPECT_EQ(120, events[8]);
EXPECT_EQ(0, EventLogger::CountEvents(events, 0, 0));
EXPECT_EQ(2, EventLogger::CountEvents(events, 0, 1));
EXPECT_EQ(4, EventLogger::CountEvents(events, 30, 51));
EXPECT_EQ(7, EventLogger::CountEvents(events, 0, 120));
EXPECT_EQ(7, EventLogger::CountEvents(events, 1, 120));
}
} // namespace policy
|
