1// Copyright 2016 The Chromium Authors. All rights reserved.
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_scheduler/sequence_sort_key.h"
6
7#include "base/task_scheduler/task_traits.h"
8#include "base/time/time.h"
9#include "testing/gtest/include/gtest/gtest.h"
10
11namespace base {
12namespace internal {
13
14TEST(TaskSchedulerSequenceSortKeyTest, OperatorLessThan) {
15  SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
16                        TimeTicks::FromInternalValue(1000));
17  SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
18                        TimeTicks::FromInternalValue(2000));
19  SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
20                        TimeTicks::FromInternalValue(1000));
21  SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
22                        TimeTicks::FromInternalValue(2000));
23  SequenceSortKey key_e(TaskPriority::BACKGROUND,
24                        TimeTicks::FromInternalValue(1000));
25  SequenceSortKey key_f(TaskPriority::BACKGROUND,
26                        TimeTicks::FromInternalValue(2000));
27
28  EXPECT_FALSE(key_a < key_a);
29  EXPECT_LT(key_b, key_a);
30  EXPECT_LT(key_c, key_a);
31  EXPECT_LT(key_d, key_a);
32  EXPECT_LT(key_e, key_a);
33  EXPECT_LT(key_f, key_a);
34
35  EXPECT_FALSE(key_a < key_b);
36  EXPECT_FALSE(key_b < key_b);
37  EXPECT_LT(key_c, key_b);
38  EXPECT_LT(key_d, key_b);
39  EXPECT_LT(key_e, key_b);
40  EXPECT_LT(key_f, key_b);
41
42  EXPECT_FALSE(key_a < key_c);
43  EXPECT_FALSE(key_b < key_c);
44  EXPECT_FALSE(key_c < key_c);
45  EXPECT_LT(key_d, key_c);
46  EXPECT_LT(key_e, key_c);
47  EXPECT_LT(key_f, key_c);
48
49  EXPECT_FALSE(key_a < key_d);
50  EXPECT_FALSE(key_b < key_d);
51  EXPECT_FALSE(key_c < key_d);
52  EXPECT_FALSE(key_d < key_d);
53  EXPECT_LT(key_e, key_d);
54  EXPECT_LT(key_f, key_d);
55
56  EXPECT_FALSE(key_a < key_e);
57  EXPECT_FALSE(key_b < key_e);
58  EXPECT_FALSE(key_c < key_e);
59  EXPECT_FALSE(key_d < key_e);
60  EXPECT_FALSE(key_e < key_e);
61  EXPECT_LT(key_f, key_e);
62
63  EXPECT_FALSE(key_a < key_f);
64  EXPECT_FALSE(key_b < key_f);
65  EXPECT_FALSE(key_c < key_f);
66  EXPECT_FALSE(key_d < key_f);
67  EXPECT_FALSE(key_e < key_f);
68  EXPECT_FALSE(key_f < key_f);
69}
70
71TEST(TaskSchedulerSequenceSortKeyTest, OperatorGreaterThan) {
72  SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
73                        TimeTicks::FromInternalValue(1000));
74  SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
75                        TimeTicks::FromInternalValue(2000));
76  SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
77                        TimeTicks::FromInternalValue(1000));
78  SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
79                        TimeTicks::FromInternalValue(2000));
80  SequenceSortKey key_e(TaskPriority::BACKGROUND,
81                        TimeTicks::FromInternalValue(1000));
82  SequenceSortKey key_f(TaskPriority::BACKGROUND,
83                        TimeTicks::FromInternalValue(2000));
84
85  EXPECT_FALSE(key_a > key_a);
86  EXPECT_FALSE(key_b > key_a);
87  EXPECT_FALSE(key_c > key_a);
88  EXPECT_FALSE(key_d > key_a);
89  EXPECT_FALSE(key_e > key_a);
90  EXPECT_FALSE(key_f > key_a);
91
92  EXPECT_GT(key_a, key_b);
93  EXPECT_FALSE(key_b > key_b);
94  EXPECT_FALSE(key_c > key_b);
95  EXPECT_FALSE(key_d > key_b);
96  EXPECT_FALSE(key_e > key_b);
97  EXPECT_FALSE(key_f > key_b);
98
99  EXPECT_GT(key_a, key_c);
100  EXPECT_GT(key_b, key_c);
101  EXPECT_FALSE(key_c > key_c);
102  EXPECT_FALSE(key_d > key_c);
103  EXPECT_FALSE(key_e > key_c);
104  EXPECT_FALSE(key_f > key_c);
105
106  EXPECT_GT(key_a, key_d);
107  EXPECT_GT(key_b, key_d);
108  EXPECT_GT(key_c, key_d);
109  EXPECT_FALSE(key_d > key_d);
110  EXPECT_FALSE(key_e > key_d);
111  EXPECT_FALSE(key_f > key_d);
112
113  EXPECT_GT(key_a, key_e);
114  EXPECT_GT(key_b, key_e);
115  EXPECT_GT(key_c, key_e);
116  EXPECT_GT(key_d, key_e);
117  EXPECT_FALSE(key_e > key_e);
118  EXPECT_FALSE(key_f > key_e);
119
120  EXPECT_GT(key_a, key_f);
121  EXPECT_GT(key_b, key_f);
122  EXPECT_GT(key_c, key_f);
123  EXPECT_GT(key_d, key_f);
124  EXPECT_GT(key_e, key_f);
125  EXPECT_FALSE(key_f > key_f);
126}
127
128TEST(TaskSchedulerSequenceSortKeyTest, OperatorEqual) {
129  SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
130                        TimeTicks::FromInternalValue(1000));
131  SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
132                        TimeTicks::FromInternalValue(2000));
133  SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
134                        TimeTicks::FromInternalValue(1000));
135  SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
136                        TimeTicks::FromInternalValue(2000));
137  SequenceSortKey key_e(TaskPriority::BACKGROUND,
138                        TimeTicks::FromInternalValue(1000));
139  SequenceSortKey key_f(TaskPriority::BACKGROUND,
140                        TimeTicks::FromInternalValue(2000));
141
142  EXPECT_EQ(key_a, key_a);
143  EXPECT_FALSE(key_b == key_a);
144  EXPECT_FALSE(key_c == key_a);
145  EXPECT_FALSE(key_d == key_a);
146  EXPECT_FALSE(key_e == key_a);
147  EXPECT_FALSE(key_f == key_a);
148
149  EXPECT_FALSE(key_a == key_b);
150  EXPECT_EQ(key_b, key_b);
151  EXPECT_FALSE(key_c == key_b);
152  EXPECT_FALSE(key_d == key_b);
153  EXPECT_FALSE(key_e == key_b);
154  EXPECT_FALSE(key_f == key_b);
155
156  EXPECT_FALSE(key_a == key_c);
157  EXPECT_FALSE(key_b == key_c);
158  EXPECT_EQ(key_c, key_c);
159  EXPECT_FALSE(key_d == key_c);
160  EXPECT_FALSE(key_e == key_c);
161  EXPECT_FALSE(key_f == key_c);
162
163  EXPECT_FALSE(key_a == key_d);
164  EXPECT_FALSE(key_b == key_d);
165  EXPECT_FALSE(key_c == key_d);
166  EXPECT_EQ(key_d, key_d);
167  EXPECT_FALSE(key_e == key_d);
168  EXPECT_FALSE(key_f == key_d);
169
170  EXPECT_FALSE(key_a == key_e);
171  EXPECT_FALSE(key_b == key_e);
172  EXPECT_FALSE(key_c == key_e);
173  EXPECT_FALSE(key_d == key_e);
174  EXPECT_EQ(key_e, key_e);
175  EXPECT_FALSE(key_f == key_e);
176
177  EXPECT_FALSE(key_a == key_f);
178  EXPECT_FALSE(key_b == key_f);
179  EXPECT_FALSE(key_c == key_f);
180  EXPECT_FALSE(key_d == key_f);
181  EXPECT_FALSE(key_e == key_f);
182  EXPECT_EQ(key_f, key_f);
183}
184
185TEST(TaskSchedulerSequenceSortKeyTest, OperatorNotEqual) {
186  SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
187                        TimeTicks::FromInternalValue(1000));
188  SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
189                        TimeTicks::FromInternalValue(2000));
190  SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
191                        TimeTicks::FromInternalValue(1000));
192  SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
193                        TimeTicks::FromInternalValue(2000));
194  SequenceSortKey key_e(TaskPriority::BACKGROUND,
195                        TimeTicks::FromInternalValue(1000));
196  SequenceSortKey key_f(TaskPriority::BACKGROUND,
197                        TimeTicks::FromInternalValue(2000));
198
199  EXPECT_FALSE(key_a != key_a);
200  EXPECT_NE(key_b, key_a);
201  EXPECT_NE(key_c, key_a);
202  EXPECT_NE(key_d, key_a);
203  EXPECT_NE(key_e, key_a);
204  EXPECT_NE(key_f, key_a);
205
206  EXPECT_NE(key_a, key_b);
207  EXPECT_FALSE(key_b != key_b);
208  EXPECT_NE(key_c, key_b);
209  EXPECT_NE(key_d, key_b);
210  EXPECT_NE(key_e, key_b);
211  EXPECT_NE(key_f, key_b);
212
213  EXPECT_NE(key_a, key_c);
214  EXPECT_NE(key_b, key_c);
215  EXPECT_FALSE(key_c != key_c);
216  EXPECT_NE(key_d, key_c);
217  EXPECT_NE(key_e, key_c);
218  EXPECT_NE(key_f, key_c);
219
220  EXPECT_NE(key_a, key_d);
221  EXPECT_NE(key_b, key_d);
222  EXPECT_NE(key_c, key_d);
223  EXPECT_FALSE(key_d != key_d);
224  EXPECT_NE(key_e, key_d);
225  EXPECT_NE(key_f, key_d);
226
227  EXPECT_NE(key_a, key_e);
228  EXPECT_NE(key_b, key_e);
229  EXPECT_NE(key_c, key_e);
230  EXPECT_NE(key_d, key_e);
231  EXPECT_FALSE(key_e != key_e);
232  EXPECT_NE(key_f, key_e);
233
234  EXPECT_NE(key_a, key_f);
235  EXPECT_NE(key_b, key_f);
236  EXPECT_NE(key_c, key_f);
237  EXPECT_NE(key_d, key_f);
238  EXPECT_NE(key_e, key_f);
239  EXPECT_FALSE(key_f != key_f);
240}
241
242}  // namespace internal
243}  // namespace base
244