Skip to content

Commit 0347f00

Browse files
backesCommit Bot
backes
authored and
Commit Bot
committed
Refactor platform tests to avoid deprecated API
The old tasks API is deprecated and we want to remove it in 8.0. Thus, this CL refactors the platform tests to use the new TaskRunner-based API, and removes redundant tests. R=ahaas@chromium.org Bug: v8:9810 Change-Id: Ie53c90184639e77b3247228059fd88290b233e0c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1868619 Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Clemens Backes <clemensb@chromium.org> Cr-Commit-Position: refs/heads/master@{#64412}
1 parent a893810 commit 0347f00

1 file changed

Lines changed: 77 additions & 137 deletions

File tree

‎test/unittests/libplatform/default-platform-unittest.cc‎

Lines changed: 77 additions & 137 deletions
Original file line numberDiff line numberDiff line change
@@ -45,196 +45,136 @@ class DefaultPlatformWithMockTime : public DefaultPlatform {
4545

4646
double DefaultPlatformWithMockTime::mock_time_ = 0.0;
4747

48-
} // namespace
48+
template <typename Platform>
49+
class PlatformTest : public ::testing::Test {
50+
public:
51+
PlatformTest() : task_runner_(platform_.GetForegroundTaskRunner(isolate())) {}
4952

53+
Isolate* isolate() { return reinterpret_cast<Isolate*>(dummy_); }
5054

51-
TEST(DefaultPlatformTest, PumpMessageLoop) {
52-
InSequence s;
55+
Platform* platform() { return &platform_; }
56+
57+
// These methods take ownership of the task. Tests might still reference them,
58+
// if the tasks are expected to still exist.
59+
void CallOnForegroundThread(Task* task) {
60+
task_runner_->PostTask(std::unique_ptr<Task>(task));
61+
}
62+
void CallDelayedOnForegroundThread(Task* task, double delay_in_seconds) {
63+
task_runner_->PostDelayedTask(std::unique_ptr<Task>(task),
64+
delay_in_seconds);
65+
}
66+
void CallIdleOnForegroundThread(IdleTask* task) {
67+
task_runner_->PostIdleTask(std::unique_ptr<IdleTask>(task));
68+
}
5369

54-
int dummy;
55-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
70+
bool PumpMessageLoop() { return platform_.PumpMessageLoop(isolate()); }
5671

57-
DefaultPlatform platform;
58-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
72+
private:
73+
Platform platform_;
74+
InSequence in_sequence_;
75+
std::shared_ptr<TaskRunner> task_runner_;
76+
77+
int dummy_;
78+
};
79+
80+
class DefaultPlatformTest : public PlatformTest<DefaultPlatform> {};
81+
class DefaultPlatformTestWithMockTime
82+
: public PlatformTest<DefaultPlatformWithMockTime> {};
83+
84+
} // namespace
85+
86+
TEST_F(DefaultPlatformTest, PumpMessageLoop) {
87+
EXPECT_FALSE(platform()->PumpMessageLoop(isolate()));
5988

6089
StrictMock<MockTask>* task = new StrictMock<MockTask>;
61-
platform.CallOnForegroundThread(isolate, task);
90+
CallOnForegroundThread(task);
6291
EXPECT_CALL(*task, Run());
6392
EXPECT_CALL(*task, Die());
64-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
65-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
93+
EXPECT_TRUE(PumpMessageLoop());
94+
EXPECT_FALSE(PumpMessageLoop());
6695
}
6796

68-
TEST(DefaultPlatformTest, PumpMessageLoopWithTaskRunner) {
69-
InSequence s;
70-
71-
int dummy;
72-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
73-
74-
DefaultPlatform platform;
97+
TEST_F(DefaultPlatformTest, PumpMessageLoopWithTaskRunner) {
7598
std::shared_ptr<TaskRunner> taskrunner =
76-
platform.GetForegroundTaskRunner(isolate);
77-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
99+
platform()->GetForegroundTaskRunner(isolate());
100+
EXPECT_FALSE(PumpMessageLoop());
78101

79102
StrictMock<MockTask>* task = new StrictMock<MockTask>;
80103
taskrunner->PostTask(std::unique_ptr<Task>(task));
81104
EXPECT_CALL(*task, Run());
82105
EXPECT_CALL(*task, Die());
83-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
84-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
85-
}
86-
87-
TEST(DefaultPlatformTest, PumpMessageLoopDelayed) {
88-
InSequence s;
89-
90-
int dummy;
91-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
92-
93-
DefaultPlatformWithMockTime platform;
94-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
95-
96-
StrictMock<MockTask>* task1 = new StrictMock<MockTask>;
97-
StrictMock<MockTask>* task2 = new StrictMock<MockTask>;
98-
platform.CallDelayedOnForegroundThread(isolate, task2, 100);
99-
platform.CallDelayedOnForegroundThread(isolate, task1, 10);
100-
101-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
102-
103-
platform.IncreaseTime(11);
104-
EXPECT_CALL(*task1, Run());
105-
EXPECT_CALL(*task1, Die());
106-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
107-
108-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
109-
110-
platform.IncreaseTime(90);
111-
EXPECT_CALL(*task2, Run());
112-
EXPECT_CALL(*task2, Die());
113-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
106+
EXPECT_TRUE(PumpMessageLoop());
107+
EXPECT_FALSE(PumpMessageLoop());
114108
}
115109

116-
TEST(DefaultPlatformTest, PumpMessageLoopDelayedWithTaskRunner) {
117-
InSequence s;
118-
119-
int dummy;
120-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
121-
122-
DefaultPlatformWithMockTime platform;
123-
std::shared_ptr<TaskRunner> taskrunner =
124-
platform.GetForegroundTaskRunner(isolate);
125-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
110+
TEST_F(DefaultPlatformTestWithMockTime, PumpMessageLoopDelayed) {
111+
EXPECT_FALSE(PumpMessageLoop());
126112

127113
StrictMock<MockTask>* task1 = new StrictMock<MockTask>;
128114
StrictMock<MockTask>* task2 = new StrictMock<MockTask>;
129-
taskrunner->PostDelayedTask(std::unique_ptr<Task>(task2), 100);
130-
taskrunner->PostDelayedTask(std::unique_ptr<Task>(task1), 10);
115+
CallDelayedOnForegroundThread(task2, 100);
116+
CallDelayedOnForegroundThread(task1, 10);
131117

132-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
118+
EXPECT_FALSE(PumpMessageLoop());
133119

134-
platform.IncreaseTime(11);
120+
platform()->IncreaseTime(11);
135121
EXPECT_CALL(*task1, Run());
136122
EXPECT_CALL(*task1, Die());
137-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
123+
EXPECT_TRUE(PumpMessageLoop());
138124

139-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
125+
EXPECT_FALSE(PumpMessageLoop());
140126

141-
platform.IncreaseTime(90);
127+
platform()->IncreaseTime(90);
142128
EXPECT_CALL(*task2, Run());
143129
EXPECT_CALL(*task2, Die());
144-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
130+
EXPECT_TRUE(PumpMessageLoop());
145131
}
146132

147-
TEST(DefaultPlatformTest, PumpMessageLoopNoStarvation) {
148-
InSequence s;
149-
150-
int dummy;
151-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
152-
153-
DefaultPlatformWithMockTime platform;
154-
EXPECT_FALSE(platform.PumpMessageLoop(isolate));
133+
TEST_F(DefaultPlatformTestWithMockTime, PumpMessageLoopNoStarvation) {
134+
EXPECT_FALSE(PumpMessageLoop());
155135

156136
StrictMock<MockTask>* task1 = new StrictMock<MockTask>;
157137
StrictMock<MockTask>* task2 = new StrictMock<MockTask>;
158138
StrictMock<MockTask>* task3 = new StrictMock<MockTask>;
159-
platform.CallOnForegroundThread(isolate, task1);
160-
platform.CallDelayedOnForegroundThread(isolate, task2, 10);
161-
platform.IncreaseTime(11);
139+
CallOnForegroundThread(task1);
140+
CallDelayedOnForegroundThread(task2, 10);
141+
platform()->IncreaseTime(11);
162142

163143
EXPECT_CALL(*task1, Run());
164144
EXPECT_CALL(*task1, Die());
165-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
145+
EXPECT_TRUE(PumpMessageLoop());
166146

167-
platform.CallOnForegroundThread(isolate, task3);
147+
CallOnForegroundThread(task3);
168148

169149
EXPECT_CALL(*task2, Run());
170150
EXPECT_CALL(*task2, Die());
171-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
151+
EXPECT_TRUE(PumpMessageLoop());
172152
EXPECT_CALL(*task3, Run());
173153
EXPECT_CALL(*task3, Die());
174-
EXPECT_TRUE(platform.PumpMessageLoop(isolate));
154+
EXPECT_TRUE(PumpMessageLoop());
175155
}
176156

177-
178-
TEST(DefaultPlatformTest, PendingDelayedTasksAreDestroyedOnShutdown) {
179-
InSequence s;
180-
181-
int dummy;
182-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
183-
184-
{
185-
DefaultPlatformWithMockTime platform;
186-
StrictMock<MockTask>* task = new StrictMock<MockTask>;
187-
platform.CallDelayedOnForegroundThread(isolate, task, 10);
188-
EXPECT_CALL(*task, Die());
189-
}
157+
TEST_F(DefaultPlatformTestWithMockTime,
158+
PendingDelayedTasksAreDestroyedOnShutdown) {
159+
StrictMock<MockTask>* task = new StrictMock<MockTask>;
160+
CallDelayedOnForegroundThread(task, 10);
161+
EXPECT_CALL(*task, Die());
190162
}
191163

192-
TEST(DefaultPlatformTest, RunIdleTasks) {
193-
InSequence s;
194-
195-
int dummy;
196-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
197-
198-
DefaultPlatformWithMockTime platform;
199-
164+
TEST_F(DefaultPlatformTestWithMockTime, RunIdleTasks) {
200165
StrictMock<MockIdleTask>* task = new StrictMock<MockIdleTask>;
201-
platform.CallIdleOnForegroundThread(isolate, task);
166+
CallIdleOnForegroundThread(task);
202167
EXPECT_CALL(*task, Run(42.0 + 23.0));
203168
EXPECT_CALL(*task, Die());
204-
platform.IncreaseTime(23.0);
205-
platform.RunIdleTasks(isolate, 42.0);
169+
platform()->IncreaseTime(23.0);
170+
platform()->RunIdleTasks(isolate(), 42.0);
206171
}
207172

208-
TEST(DefaultPlatformTest, RunIdleTasksWithTaskRunner) {
209-
InSequence s;
210-
211-
int dummy;
212-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
213-
214-
DefaultPlatformWithMockTime platform;
215-
std::shared_ptr<TaskRunner> taskrunner =
216-
platform.GetForegroundTaskRunner(isolate);
217-
173+
TEST_F(DefaultPlatformTestWithMockTime,
174+
PendingIdleTasksAreDestroyedOnShutdown) {
218175
StrictMock<MockIdleTask>* task = new StrictMock<MockIdleTask>;
219-
taskrunner->PostIdleTask(std::unique_ptr<IdleTask>(task));
220-
EXPECT_CALL(*task, Run(42.0 + 23.0));
176+
CallIdleOnForegroundThread(task);
221177
EXPECT_CALL(*task, Die());
222-
platform.IncreaseTime(23.0);
223-
platform.RunIdleTasks(isolate, 42.0);
224-
}
225-
226-
TEST(DefaultPlatformTest, PendingIdleTasksAreDestroyedOnShutdown) {
227-
InSequence s;
228-
229-
int dummy;
230-
Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
231-
232-
{
233-
DefaultPlatformWithMockTime platform;
234-
StrictMock<MockIdleTask>* task = new StrictMock<MockIdleTask>;
235-
platform.CallIdleOnForegroundThread(isolate, task);
236-
EXPECT_CALL(*task, Die());
237-
}
238178
}
239179

240180
namespace {
@@ -259,7 +199,7 @@ class TestBackgroundTask : public Task {
259199

260200
} // namespace
261201

262-
TEST(DefaultPlatformTest, RunBackgroundTask) {
202+
TEST(CustomDefaultPlatformTest, RunBackgroundTask) {
263203
DefaultPlatform platform;
264204
platform.SetThreadPoolSize(1);
265205

@@ -273,7 +213,7 @@ TEST(DefaultPlatformTest, RunBackgroundTask) {
273213
EXPECT_TRUE(task_executed);
274214
}
275215

276-
TEST(DefaultPlatformTest, PostForegroundTaskAfterPlatformTermination) {
216+
TEST(CustomDefaultPlatformTest, PostForegroundTaskAfterPlatformTermination) {
277217
std::shared_ptr<TaskRunner> foreground_taskrunner;
278218
{
279219
DefaultPlatformWithMockTime platform;

0 commit comments

Comments
 (0)