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