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