1 // Copyright 2021 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/task/sequence_manager/task_order.h"
6
7 #include "base/task/sequence_manager/enqueue_order.h"
8 #include "base/time/time.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10 #include "third_party/abseil-cpp/absl/types/optional.h"
11
12 namespace base {
13 namespace sequence_manager {
14
15 class TaskOrderTest : public testing::Test {
16 protected:
MakeImmediateTaskOrder(int enqueue_order)17 static TaskOrder MakeImmediateTaskOrder(int enqueue_order) {
18 return MakeTaskOrder(enqueue_order, TimeTicks(), enqueue_order);
19 }
20
MakeDelayedTaskOrder(int enqueue_order,TimeTicks delayed_run_time,int sequence_num)21 static TaskOrder MakeDelayedTaskOrder(int enqueue_order,
22 TimeTicks delayed_run_time,
23 int sequence_num) {
24 return MakeTaskOrder(enqueue_order, delayed_run_time, sequence_num);
25 }
26
ExpectLessThan(TaskOrder & order1,TaskOrder & order2)27 void ExpectLessThan(TaskOrder& order1, TaskOrder& order2) {
28 EXPECT_TRUE(order1 < order2);
29 EXPECT_TRUE(order1 <= order2);
30 EXPECT_FALSE(order1 == order2);
31 EXPECT_TRUE(order1 != order2);
32 EXPECT_FALSE(order1 >= order2);
33 EXPECT_FALSE(order1 > order2);
34
35 EXPECT_FALSE(order2 < order1);
36 EXPECT_FALSE(order2 <= order1);
37 EXPECT_FALSE(order2 == order1);
38 EXPECT_TRUE(order1 != order2);
39 EXPECT_TRUE(order2 >= order1);
40 EXPECT_TRUE(order2 > order1);
41 }
42
ExpectEqual(TaskOrder & order1,TaskOrder & order2)43 void ExpectEqual(TaskOrder& order1, TaskOrder& order2) {
44 EXPECT_FALSE(order1 < order2);
45 EXPECT_TRUE(order1 <= order2);
46 EXPECT_TRUE(order1 == order2);
47 EXPECT_FALSE(order1 != order2);
48 EXPECT_TRUE(order1 >= order2);
49 EXPECT_FALSE(order1 > order2);
50
51 EXPECT_FALSE(order2 < order1);
52 EXPECT_TRUE(order2 <= order1);
53 EXPECT_TRUE(order2 == order1);
54 EXPECT_FALSE(order1 != order2);
55 EXPECT_TRUE(order2 >= order1);
56 EXPECT_FALSE(order2 > order1);
57 }
58
59 private:
MakeTaskOrder(int enqueue_order,TimeTicks delayed_run_time,int sequence_num)60 static TaskOrder MakeTaskOrder(int enqueue_order,
61 TimeTicks delayed_run_time,
62 int sequence_num) {
63 return TaskOrder::CreateForTesting(
64 EnqueueOrder::FromIntForTesting(enqueue_order), delayed_run_time,
65 sequence_num);
66 }
67 };
68
TEST_F(TaskOrderTest,ImmediateTasksNotEqual)69 TEST_F(TaskOrderTest, ImmediateTasksNotEqual) {
70 TaskOrder order1 = MakeImmediateTaskOrder(/*enqueue_order=*/10);
71 TaskOrder order2 = MakeImmediateTaskOrder(/*enqueue_order=*/11);
72
73 ExpectLessThan(order1, order2);
74 }
75
TEST_F(TaskOrderTest,ImmediateTasksEqual)76 TEST_F(TaskOrderTest, ImmediateTasksEqual) {
77 TaskOrder order1 = MakeImmediateTaskOrder(/*enqueue_order=*/10);
78 TaskOrder order2 = MakeImmediateTaskOrder(/*enqueue_order=*/10);
79
80 ExpectEqual(order1, order2);
81 }
82
TEST_F(TaskOrderTest,DelayedTasksOrderedByEnqueueNumberFirst)83 TEST_F(TaskOrderTest, DelayedTasksOrderedByEnqueueNumberFirst) {
84 // Enqueued earlier but has and a later delayed run time and posting order.
85 TaskOrder order1 = MakeDelayedTaskOrder(
86 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(2),
87 /*sequence_num=*/2);
88 TaskOrder order2 = MakeDelayedTaskOrder(
89 /*enqueue_order=*/11, /*delayed_run_time=*/TimeTicks() + Seconds(1),
90 /*sequence_num=*/1);
91
92 ExpectLessThan(order1, order2);
93 }
94
TEST_F(TaskOrderTest,DelayedTasksSameEnqueueOrder)95 TEST_F(TaskOrderTest, DelayedTasksSameEnqueueOrder) {
96 TaskOrder order1 = MakeDelayedTaskOrder(
97 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(1),
98 /*sequence_num=*/2);
99 TaskOrder order2 = MakeDelayedTaskOrder(
100 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(2),
101 /*sequence_num=*/1);
102
103 ExpectLessThan(order1, order2);
104 }
105
TEST_F(TaskOrderTest,DelayedTasksSameEnqueueOrderAndRunTime)106 TEST_F(TaskOrderTest, DelayedTasksSameEnqueueOrderAndRunTime) {
107 TaskOrder order1 = MakeDelayedTaskOrder(
108 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(1),
109 /*sequence_num=*/1);
110 TaskOrder order2 = MakeDelayedTaskOrder(
111 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(1),
112 /*sequence_num=*/2);
113
114 ExpectLessThan(order1, order2);
115 }
116
TEST_F(TaskOrderTest,DelayedTasksEqual)117 TEST_F(TaskOrderTest, DelayedTasksEqual) {
118 TaskOrder order1 = MakeDelayedTaskOrder(
119 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(1),
120 /*sequence_num=*/1);
121 TaskOrder order2 = MakeDelayedTaskOrder(
122 /*enqueue_order=*/10, /*delayed_run_time=*/TimeTicks() + Seconds(1),
123 /*sequence_num=*/1);
124
125 ExpectEqual(order1, order2);
126 }
127
128 } // namespace sequence_manager
129 } // namespace base
130