OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/task_scheduler/sequence_sort_key.h" | 5 #include "base/task_scheduler/sequence_sort_key.h" |
6 | 6 |
7 #include "base/task_scheduler/task_traits.h" | 7 #include "base/task_scheduler/task_traits.h" |
8 #include "base/time/time.h" | 8 #include "base/time/time.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
10 | 10 |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
118 EXPECT_FALSE(key_f > key_e); | 118 EXPECT_FALSE(key_f > key_e); |
119 | 119 |
120 EXPECT_GT(key_a, key_f); | 120 EXPECT_GT(key_a, key_f); |
121 EXPECT_GT(key_b, key_f); | 121 EXPECT_GT(key_b, key_f); |
122 EXPECT_GT(key_c, key_f); | 122 EXPECT_GT(key_c, key_f); |
123 EXPECT_GT(key_d, key_f); | 123 EXPECT_GT(key_d, key_f); |
124 EXPECT_GT(key_e, key_f); | 124 EXPECT_GT(key_e, key_f); |
125 EXPECT_FALSE(key_f > key_f); | 125 EXPECT_FALSE(key_f > key_f); |
126 } | 126 } |
127 | 127 |
| 128 TEST(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 |
| 185 TEST(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 |
128 } // namespace internal | 242 } // namespace internal |
129 } // namespace base | 243 } // namespace base |
OLD | NEW |