1 // Copyright (c) 2011 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 <sstream>
6
7 #include "testing/gtest/include/gtest/gtest.h"
8 #include "ui/gfx/range/range.h"
9 #include "ui/gfx/range/range_f.h"
10
11 namespace {
12
13 template <typename T>
14 class RangeTest : public testing::Test {
15 };
16
17 typedef testing::Types<gfx::Range, gfx::RangeF> RangeTypes;
18 TYPED_TEST_SUITE(RangeTest, RangeTypes);
19
20 template <typename T>
TestContainsAndIntersects(const T & r1,const T & r2,const T & r3)21 void TestContainsAndIntersects(const T& r1,
22 const T& r2,
23 const T& r3) {
24 EXPECT_TRUE(r1.Intersects(r1));
25 EXPECT_TRUE(r1.Contains(r1));
26 EXPECT_EQ(T(10, 12), r1.Intersect(r1));
27
28 EXPECT_FALSE(r1.Intersects(r2));
29 EXPECT_FALSE(r1.Contains(r2));
30 EXPECT_TRUE(r1.Intersect(r2).is_empty());
31 EXPECT_FALSE(r2.Intersects(r1));
32 EXPECT_FALSE(r2.Contains(r1));
33 EXPECT_TRUE(r2.Intersect(r1).is_empty());
34
35 EXPECT_TRUE(r1.Intersects(r3));
36 EXPECT_TRUE(r3.Intersects(r1));
37 EXPECT_TRUE(r3.Contains(r1));
38 EXPECT_FALSE(r1.Contains(r3));
39 EXPECT_EQ(T(10, 12), r1.Intersect(r3));
40 EXPECT_EQ(T(10, 12), r3.Intersect(r1));
41
42 EXPECT_TRUE(r2.Intersects(r3));
43 EXPECT_TRUE(r3.Intersects(r2));
44 EXPECT_FALSE(r3.Contains(r2));
45 EXPECT_FALSE(r2.Contains(r3));
46 EXPECT_EQ(T(5, 8), r2.Intersect(r3));
47 EXPECT_EQ(T(5, 8), r3.Intersect(r2));
48 }
49
50 } // namespace
51
TYPED_TEST(RangeTest,EmptyInit)52 TYPED_TEST(RangeTest, EmptyInit) {
53 TypeParam r;
54 EXPECT_EQ(0U, r.start());
55 EXPECT_EQ(0U, r.end());
56 EXPECT_EQ(0U, r.length());
57 EXPECT_FALSE(r.is_reversed());
58 EXPECT_TRUE(r.is_empty());
59 EXPECT_TRUE(r.IsValid());
60 EXPECT_EQ(0U, r.GetMin());
61 EXPECT_EQ(0U, r.GetMax());
62 }
63
TYPED_TEST(RangeTest,StartEndInit)64 TYPED_TEST(RangeTest, StartEndInit) {
65 TypeParam r(10, 15);
66 EXPECT_EQ(10U, r.start());
67 EXPECT_EQ(15U, r.end());
68 EXPECT_EQ(5U, r.length());
69 EXPECT_FALSE(r.is_reversed());
70 EXPECT_FALSE(r.is_empty());
71 EXPECT_TRUE(r.IsValid());
72 EXPECT_EQ(10U, r.GetMin());
73 EXPECT_EQ(15U, r.GetMax());
74 }
75
TYPED_TEST(RangeTest,StartEndReversedInit)76 TYPED_TEST(RangeTest, StartEndReversedInit) {
77 TypeParam r(10, 5);
78 EXPECT_EQ(10U, r.start());
79 EXPECT_EQ(5U, r.end());
80 EXPECT_EQ(5U, r.length());
81 EXPECT_TRUE(r.is_reversed());
82 EXPECT_FALSE(r.is_empty());
83 EXPECT_TRUE(r.IsValid());
84 EXPECT_EQ(5U, r.GetMin());
85 EXPECT_EQ(10U, r.GetMax());
86 }
87
TYPED_TEST(RangeTest,PositionInit)88 TYPED_TEST(RangeTest, PositionInit) {
89 TypeParam r(12);
90 EXPECT_EQ(12U, r.start());
91 EXPECT_EQ(12U, r.end());
92 EXPECT_EQ(0U, r.length());
93 EXPECT_FALSE(r.is_reversed());
94 EXPECT_TRUE(r.is_empty());
95 EXPECT_TRUE(r.IsValid());
96 EXPECT_EQ(12U, r.GetMin());
97 EXPECT_EQ(12U, r.GetMax());
98 }
99
TYPED_TEST(RangeTest,InvalidRange)100 TYPED_TEST(RangeTest, InvalidRange) {
101 TypeParam r(TypeParam::InvalidRange());
102 EXPECT_EQ(0U, r.length());
103 EXPECT_EQ(r.start(), r.end());
104 EXPECT_EQ(r.GetMax(), r.GetMin());
105 EXPECT_FALSE(r.is_reversed());
106 EXPECT_TRUE(r.is_empty());
107 EXPECT_FALSE(r.IsValid());
108 EXPECT_EQ(r, TypeParam::InvalidRange());
109 EXPECT_TRUE(r.EqualsIgnoringDirection(TypeParam::InvalidRange()));
110 }
111
TYPED_TEST(RangeTest,Equality)112 TYPED_TEST(RangeTest, Equality) {
113 TypeParam r1(10, 4);
114 TypeParam r2(10, 4);
115 TypeParam r3(10, 2);
116 EXPECT_EQ(r1, r2);
117 EXPECT_NE(r1, r3);
118 EXPECT_NE(r2, r3);
119
120 TypeParam r4(11, 4);
121 EXPECT_NE(r1, r4);
122 EXPECT_NE(r2, r4);
123 EXPECT_NE(r3, r4);
124
125 TypeParam r5(12, 5);
126 EXPECT_NE(r1, r5);
127 EXPECT_NE(r2, r5);
128 EXPECT_NE(r3, r5);
129 }
130
TYPED_TEST(RangeTest,EqualsIgnoringDirection)131 TYPED_TEST(RangeTest, EqualsIgnoringDirection) {
132 TypeParam r1(10, 5);
133 TypeParam r2(5, 10);
134 EXPECT_TRUE(r1.EqualsIgnoringDirection(r2));
135 }
136
TYPED_TEST(RangeTest,SetStart)137 TYPED_TEST(RangeTest, SetStart) {
138 TypeParam r(10, 20);
139 EXPECT_EQ(10U, r.start());
140 EXPECT_EQ(10U, r.length());
141
142 r.set_start(42);
143 EXPECT_EQ(42U, r.start());
144 EXPECT_EQ(20U, r.end());
145 EXPECT_EQ(22U, r.length());
146 EXPECT_TRUE(r.is_reversed());
147 }
148
TYPED_TEST(RangeTest,SetEnd)149 TYPED_TEST(RangeTest, SetEnd) {
150 TypeParam r(10, 13);
151 EXPECT_EQ(10U, r.start());
152 EXPECT_EQ(3U, r.length());
153
154 r.set_end(20);
155 EXPECT_EQ(10U, r.start());
156 EXPECT_EQ(20U, r.end());
157 EXPECT_EQ(10U, r.length());
158 }
159
TYPED_TEST(RangeTest,SetStartAndEnd)160 TYPED_TEST(RangeTest, SetStartAndEnd) {
161 TypeParam r;
162 r.set_end(5);
163 r.set_start(1);
164 EXPECT_EQ(1U, r.start());
165 EXPECT_EQ(5U, r.end());
166 EXPECT_EQ(4U, r.length());
167 EXPECT_EQ(1U, r.GetMin());
168 EXPECT_EQ(5U, r.GetMax());
169 }
170
TYPED_TEST(RangeTest,ReversedRange)171 TYPED_TEST(RangeTest, ReversedRange) {
172 TypeParam r(10, 5);
173 EXPECT_EQ(10U, r.start());
174 EXPECT_EQ(5U, r.end());
175 EXPECT_EQ(5U, r.length());
176 EXPECT_TRUE(r.is_reversed());
177 EXPECT_TRUE(r.IsValid());
178 EXPECT_EQ(5U, r.GetMin());
179 EXPECT_EQ(10U, r.GetMax());
180 }
181
TYPED_TEST(RangeTest,SetReversedRange)182 TYPED_TEST(RangeTest, SetReversedRange) {
183 TypeParam r(10, 20);
184 r.set_start(25);
185 EXPECT_EQ(25U, r.start());
186 EXPECT_EQ(20U, r.end());
187 EXPECT_EQ(5U, r.length());
188 EXPECT_TRUE(r.is_reversed());
189 EXPECT_TRUE(r.IsValid());
190
191 r.set_end(21);
192 EXPECT_EQ(25U, r.start());
193 EXPECT_EQ(21U, r.end());
194 EXPECT_EQ(4U, r.length());
195 EXPECT_TRUE(r.IsValid());
196 EXPECT_EQ(21U, r.GetMin());
197 EXPECT_EQ(25U, r.GetMax());
198 }
199
TYPED_TEST(RangeTest,ContainAndIntersect)200 TYPED_TEST(RangeTest, ContainAndIntersect) {
201 {
202 SCOPED_TRACE("contain and intersect");
203 TypeParam r1(10, 12);
204 TypeParam r2(1, 8);
205 TypeParam r3(5, 12);
206 TestContainsAndIntersects(r1, r2, r3);
207 }
208 {
209 SCOPED_TRACE("contain and intersect: reversed");
210 TypeParam r1(12, 10);
211 TypeParam r2(8, 1);
212 TypeParam r3(12, 5);
213 TestContainsAndIntersects(r1, r2, r3);
214 }
215 // Invalid rect tests
216 TypeParam r1(10, 12);
217 TypeParam r2(8, 1);
218 TypeParam invalid = r1.Intersect(r2);
219 EXPECT_FALSE(invalid.IsValid());
220 EXPECT_FALSE(invalid.Contains(invalid));
221 EXPECT_FALSE(invalid.Contains(r1));
222 EXPECT_FALSE(invalid.Intersects(invalid));
223 EXPECT_FALSE(invalid.Intersects(r1));
224 EXPECT_FALSE(r1.Contains(invalid));
225 EXPECT_FALSE(r1.Intersects(invalid));
226 }
227
TEST(RangeTest,RangeOperations)228 TEST(RangeTest, RangeOperations) {
229 constexpr gfx::Range invalid_range = gfx::Range::InvalidRange();
230 constexpr gfx::Range ranges[] = {{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1},
231 {1, 2}, {2, 0}, {2, 1}, {2, 2}};
232
233 // Ensures valid behavior over same range.
234 for (const auto& range : ranges) {
235 SCOPED_TRACE(range.ToString());
236 // A range should contain itself.
237 EXPECT_TRUE(range.Contains(range));
238 // A ranges should intersect with itself.
239 EXPECT_TRUE(range.Intersects(range));
240 }
241
242 // Ensures valid behavior with an invalid range.
243 for (const auto& range : ranges) {
244 SCOPED_TRACE(range.ToString());
245 EXPECT_FALSE(invalid_range.Contains(range));
246 EXPECT_FALSE(invalid_range.Intersects(range));
247 EXPECT_FALSE(range.Contains(invalid_range));
248 EXPECT_FALSE(range.Intersects(invalid_range));
249 }
250 EXPECT_FALSE(invalid_range.Contains(invalid_range));
251 EXPECT_FALSE(invalid_range.Intersects(invalid_range));
252
253 // Ensures consistent operations between Contains(...) and Intersects(...).
254 for (const auto& range1 : ranges) {
255 for (const auto& range2 : ranges) {
256 SCOPED_TRACE(testing::Message()
257 << "range1=" << range1 << " range2=" << range2);
258 if (range1.Contains(range2)) {
259 EXPECT_TRUE(range1.Intersects(range2));
260 EXPECT_EQ(range2.Contains(range1),
261 range1.EqualsIgnoringDirection(range2));
262 }
263 EXPECT_EQ(range2.Intersects(range1), range1.Intersects(range2));
264
265 EXPECT_EQ(range1.Intersect(range2) != invalid_range,
266 range1.Intersects(range2));
267 }
268 }
269
270 // Ranges should behave the same way no matter the direction.
271 for (const auto& range1 : ranges) {
272 for (const auto& range2 : ranges) {
273 SCOPED_TRACE(testing::Message()
274 << "range1=" << range1 << " range2=" << range2);
275 EXPECT_EQ(range1.Contains(range2),
276 range1.Contains(gfx::Range(range2.GetMax(), range2.GetMin())));
277 EXPECT_EQ(
278 range1.Intersects(range2),
279 range1.Intersects(gfx::Range(range2.GetMax(), range2.GetMin())));
280 }
281 }
282 }
283
TEST(RangeTest,RangeFOperations)284 TEST(RangeTest, RangeFOperations) {
285 constexpr gfx::RangeF invalid_range = gfx::RangeF::InvalidRange();
286 constexpr gfx::RangeF ranges[] = {{0.f, 0.f}, {0.f, 1.f}, {0.f, 2.f},
287 {1.f, 0.f}, {1.f, 1.f}, {1.f, 2.f},
288 {2.f, 0.f}, {2.f, 1.f}, {2.f, 2.f}};
289
290 // Ensures valid behavior over same range.
291 for (const auto& range : ranges) {
292 SCOPED_TRACE(range.ToString());
293 // A range should contain itself.
294 EXPECT_TRUE(range.Contains(range));
295 // A ranges should intersect with itself.
296 EXPECT_TRUE(range.Intersects(range));
297 }
298
299 // Ensures valid behavior with an invalid range.
300 for (const auto& range : ranges) {
301 SCOPED_TRACE(range.ToString());
302 EXPECT_FALSE(invalid_range.Contains(range));
303 EXPECT_FALSE(invalid_range.Intersects(range));
304 EXPECT_FALSE(range.Contains(invalid_range));
305 EXPECT_FALSE(range.Intersects(invalid_range));
306 }
307 EXPECT_FALSE(invalid_range.Contains(invalid_range));
308 EXPECT_FALSE(invalid_range.Intersects(invalid_range));
309
310 // Ensures consistent operations between Contains(...) and Intersects(...).
311 for (const auto& range1 : ranges) {
312 for (const auto& range2 : ranges) {
313 SCOPED_TRACE(testing::Message()
314 << "range1=" << range1 << " range2=" << range2);
315 if (range1.Contains(range2)) {
316 EXPECT_TRUE(range1.Intersects(range2));
317 EXPECT_EQ(range2.Contains(range1),
318 range1.EqualsIgnoringDirection(range2));
319 }
320 EXPECT_EQ(range2.Intersects(range1), range1.Intersects(range2));
321
322 EXPECT_EQ(range1.Intersect(range2) != invalid_range,
323 range1.Intersects(range2));
324 }
325 }
326
327 // Ranges should behave the same way no matter the direction.
328 for (const auto& range1 : ranges) {
329 for (const auto& range2 : ranges) {
330 SCOPED_TRACE(testing::Message()
331 << "range1=" << range1 << " range2=" << range2);
332 EXPECT_EQ(range1.Contains(range2),
333 range1.Contains(gfx::RangeF(range2.GetMax(), range2.GetMin())));
334 EXPECT_EQ(
335 range1.Intersects(range2),
336 range1.Intersects(gfx::RangeF(range2.GetMax(), range2.GetMin())));
337 }
338 }
339 }
340
TEST(RangeTest,ContainsAndIntersects)341 TEST(RangeTest, ContainsAndIntersects) {
342 constexpr gfx::Range r1(0, 0);
343 constexpr gfx::Range r2(0, 1);
344 constexpr gfx::Range r3(1, 2);
345 constexpr gfx::Range r4(1, 0);
346 constexpr gfx::Range r5(2, 1);
347 constexpr gfx::Range r6(0, 2);
348 constexpr gfx::Range r7(2, 0);
349 constexpr gfx::Range r8(1, 1);
350
351 // Ensures Contains(...) handle the open range.
352 EXPECT_TRUE(r2.Contains(r1));
353 EXPECT_TRUE(r4.Contains(r1));
354 EXPECT_TRUE(r3.Contains(r5));
355 EXPECT_TRUE(r5.Contains(r3));
356
357 // Ensures larger ranges contains smaller ranges.
358 EXPECT_TRUE(r6.Contains(r1));
359 EXPECT_TRUE(r6.Contains(r2));
360 EXPECT_TRUE(r6.Contains(r3));
361 EXPECT_TRUE(r6.Contains(r4));
362 EXPECT_TRUE(r6.Contains(r5));
363
364 EXPECT_TRUE(r7.Contains(r1));
365 EXPECT_TRUE(r7.Contains(r2));
366 EXPECT_TRUE(r7.Contains(r3));
367 EXPECT_TRUE(r7.Contains(r4));
368 EXPECT_TRUE(r7.Contains(r5));
369
370 // Ensures Intersects(...) handle the open range.
371 EXPECT_TRUE(r2.Intersects(r1));
372 EXPECT_TRUE(r4.Intersects(r1));
373
374 // Ensures larger ranges intersects smaller ranges.
375 EXPECT_TRUE(r6.Intersects(r1));
376 EXPECT_TRUE(r6.Intersects(r2));
377 EXPECT_TRUE(r6.Intersects(r3));
378 EXPECT_TRUE(r6.Intersects(r4));
379 EXPECT_TRUE(r6.Intersects(r5));
380
381 EXPECT_TRUE(r7.Intersects(r1));
382 EXPECT_TRUE(r7.Intersects(r2));
383 EXPECT_TRUE(r7.Intersects(r3));
384 EXPECT_TRUE(r7.Intersects(r4));
385 EXPECT_TRUE(r7.Intersects(r5));
386
387 // Ensures adjacent ranges don't overlap.
388 EXPECT_FALSE(r2.Intersects(r3));
389 EXPECT_FALSE(r5.Intersects(r4));
390
391 // Ensures empty ranges are handled correctly.
392 EXPECT_FALSE(r1.Contains(r8));
393 EXPECT_FALSE(r2.Contains(r8));
394 EXPECT_TRUE(r3.Contains(r8));
395 EXPECT_TRUE(r8.Contains(r8));
396
397 EXPECT_FALSE(r1.Intersects(r8));
398 EXPECT_FALSE(r2.Intersects(r8));
399 EXPECT_TRUE(r3.Intersects(r8));
400 EXPECT_TRUE(r8.Intersects(r8));
401 }
402
TEST(RangeTest,ContainsAndIntersectsRangeF)403 TEST(RangeTest, ContainsAndIntersectsRangeF) {
404 constexpr gfx::RangeF r1(0.f, 0.f);
405 constexpr gfx::RangeF r2(0.f, 1.f);
406 constexpr gfx::RangeF r3(1.f, 2.f);
407 constexpr gfx::RangeF r4(1.f, 0.f);
408 constexpr gfx::RangeF r5(2.f, 1.f);
409 constexpr gfx::RangeF r6(0.f, 2.f);
410 constexpr gfx::RangeF r7(2.f, 0.f);
411 constexpr gfx::RangeF r8(1.f, 1.f);
412
413 // Ensures Contains(...) handle the open range.
414 EXPECT_TRUE(r2.Contains(r1));
415 EXPECT_TRUE(r4.Contains(r1));
416 EXPECT_TRUE(r3.Contains(r5));
417 EXPECT_TRUE(r5.Contains(r3));
418
419 // Ensures larger ranges contains smaller ranges.
420 EXPECT_TRUE(r6.Contains(r1));
421 EXPECT_TRUE(r6.Contains(r2));
422 EXPECT_TRUE(r6.Contains(r3));
423 EXPECT_TRUE(r6.Contains(r4));
424 EXPECT_TRUE(r6.Contains(r5));
425
426 EXPECT_TRUE(r7.Contains(r1));
427 EXPECT_TRUE(r7.Contains(r2));
428 EXPECT_TRUE(r7.Contains(r3));
429 EXPECT_TRUE(r7.Contains(r4));
430 EXPECT_TRUE(r7.Contains(r5));
431
432 // Ensures Intersects(...) handle the open range.
433 EXPECT_TRUE(r2.Intersects(r1));
434 EXPECT_TRUE(r4.Intersects(r1));
435
436 // Ensures larger ranges intersects smaller ranges.
437 EXPECT_TRUE(r6.Intersects(r1));
438 EXPECT_TRUE(r6.Intersects(r2));
439 EXPECT_TRUE(r6.Intersects(r3));
440 EXPECT_TRUE(r6.Intersects(r4));
441 EXPECT_TRUE(r6.Intersects(r5));
442
443 EXPECT_TRUE(r7.Intersects(r1));
444 EXPECT_TRUE(r7.Intersects(r2));
445 EXPECT_TRUE(r7.Intersects(r3));
446 EXPECT_TRUE(r7.Intersects(r4));
447 EXPECT_TRUE(r7.Intersects(r5));
448
449 // Ensures adjacent ranges don't overlap.
450 EXPECT_FALSE(r2.Intersects(r3));
451 EXPECT_FALSE(r5.Intersects(r4));
452
453 // Ensures empty ranges are handled correctly.
454 EXPECT_FALSE(r1.Contains(r8));
455 EXPECT_FALSE(r2.Contains(r8));
456 EXPECT_TRUE(r3.Contains(r8));
457 EXPECT_TRUE(r8.Contains(r8));
458
459 EXPECT_FALSE(r1.Intersects(r8));
460 EXPECT_FALSE(r2.Intersects(r8));
461 EXPECT_TRUE(r3.Intersects(r8));
462 EXPECT_TRUE(r8.Intersects(r8));
463 }
464
TEST(RangeTest,Intersect)465 TEST(RangeTest, Intersect) {
466 EXPECT_EQ(gfx::Range(0, 1).Intersect({0, 1}), gfx::Range(0, 1));
467 EXPECT_EQ(gfx::Range(0, 1).Intersect({0, 0}), gfx::Range(0, 0));
468 EXPECT_EQ(gfx::Range(0, 0).Intersect({1, 0}), gfx::Range(0, 0));
469 EXPECT_EQ(gfx::Range(0, 4).Intersect({2, 3}), gfx::Range(2, 3));
470 EXPECT_EQ(gfx::Range(0, 4).Intersect({2, 7}), gfx::Range(2, 4));
471 EXPECT_EQ(gfx::Range(0, 4).Intersect({3, 4}), gfx::Range(3, 4));
472
473 EXPECT_EQ(gfx::Range(0, 1).Intersect({1, 1}), gfx::Range::InvalidRange());
474 EXPECT_EQ(gfx::Range(1, 1).Intersect({1, 0}), gfx::Range::InvalidRange());
475 EXPECT_EQ(gfx::Range(0, 1).Intersect({1, 2}), gfx::Range::InvalidRange());
476 EXPECT_EQ(gfx::Range(0, 1).Intersect({2, 1}), gfx::Range::InvalidRange());
477 EXPECT_EQ(gfx::Range(2, 1).Intersect({1, 0}), gfx::Range::InvalidRange());
478 }
479
TEST(RangeTest,IntersectRangeF)480 TEST(RangeTest, IntersectRangeF) {
481 EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(0.f, 1.f)),
482 gfx::RangeF(0.f, 1.f));
483 EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(0.f, 0.f)),
484 gfx::RangeF(0.f, 0.f));
485 EXPECT_EQ(gfx::RangeF(0.f, 0.f).Intersect(gfx::RangeF(1.f, 0.f)),
486 gfx::RangeF(0.f, 0.f));
487 EXPECT_EQ(gfx::RangeF(0.f, 4.f).Intersect(gfx::RangeF(2.f, 3.f)),
488 gfx::RangeF(2.f, 3.f));
489 EXPECT_EQ(gfx::RangeF(0.f, 4.f).Intersect(gfx::RangeF(2.f, 7.f)),
490 gfx::RangeF(2.f, 4.f));
491 EXPECT_EQ(gfx::RangeF(0.f, 4.f).Intersect(gfx::RangeF(3.f, 4.f)),
492 gfx::RangeF(3.f, 4.f));
493
494 EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(1.f, 1.f)),
495 gfx::RangeF::InvalidRange());
496 EXPECT_EQ(gfx::RangeF(1.f, 1.f).Intersect(gfx::RangeF(1.f, 0.f)),
497 gfx::RangeF::InvalidRange());
498 EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(1.f, 2.f)),
499 gfx::RangeF::InvalidRange());
500 EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(2.f, 1.f)),
501 gfx::RangeF::InvalidRange());
502 EXPECT_EQ(gfx::RangeF(2.f, 1.f).Intersect(gfx::RangeF(1.f, 0.f)),
503 gfx::RangeF::InvalidRange());
504 }
505
TEST(RangeTest,IsBoundedBy)506 TEST(RangeTest, IsBoundedBy) {
507 constexpr gfx::Range r1(0, 0);
508 constexpr gfx::Range r2(0, 1);
509 EXPECT_TRUE(r1.IsBoundedBy(r1));
510 EXPECT_FALSE(r2.IsBoundedBy(r1));
511
512 constexpr gfx::Range r3(0, 2);
513 constexpr gfx::Range r4(2, 2);
514 EXPECT_TRUE(r4.IsBoundedBy(r3));
515 EXPECT_FALSE(r3.IsBoundedBy(r4));
516 }
517
TEST(RangeTest,ToString)518 TEST(RangeTest, ToString) {
519 gfx::Range range(4, 7);
520 EXPECT_EQ("{4,7}", range.ToString());
521
522 range = gfx::Range::InvalidRange();
523 std::ostringstream expected;
524 expected << "{" << range.start() << "," << range.end() << "}";
525 EXPECT_EQ(expected.str(), range.ToString());
526 }
527