Add float version of gfx::Range

ui/gfx/range/range_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/range/range.h"
+#include "ui/gfx/range/range_f.h"
 
-TEST(RangeTest, EmptyInit) {
-  gfx::Range r;
+namespace {
+
+template <typename T>
+class RangeTest : public testing::Test {
+};
+
+typedef testing::Types<gfx::Range, gfx::RangeF> RangeTypes;
+TYPED_TEST_CASE(RangeTest, RangeTypes);
+
+template <typename T>
+void TestContainsAndIntersects(const T& r1,
+                               const T& r2,
+                               const T& r3) {
+  EXPECT_TRUE(r1.Intersects(r1));
+  EXPECT_TRUE(r1.Contains(r1));
+  EXPECT_EQ(T(10, 12), r1.Intersect(r1));
+
+  EXPECT_FALSE(r1.Intersects(r2));
+  EXPECT_FALSE(r1.Contains(r2));
+  EXPECT_TRUE(r1.Intersect(r2).is_empty());
+  EXPECT_FALSE(r2.Intersects(r1));
+  EXPECT_FALSE(r2.Contains(r1));
+  EXPECT_TRUE(r2.Intersect(r1).is_empty());
+
+  EXPECT_TRUE(r1.Intersects(r3));
+  EXPECT_TRUE(r3.Intersects(r1));
+  EXPECT_TRUE(r3.Contains(r1));
+  EXPECT_FALSE(r1.Contains(r3));
+  EXPECT_EQ(T(10, 12), r1.Intersect(r3));
+  EXPECT_EQ(T(10, 12), r3.Intersect(r1));
+
+  EXPECT_TRUE(r2.Intersects(r3));
+  EXPECT_TRUE(r3.Intersects(r2));
+  EXPECT_FALSE(r3.Contains(r2));
+  EXPECT_FALSE(r2.Contains(r3));
+  EXPECT_EQ(T(5, 8), r2.Intersect(r3));
+  EXPECT_EQ(T(5, 8), r3.Intersect(r2));
+}
+
+}  // namespace
+
+TYPED_TEST(RangeTest, EmptyInit) {
+  TypeParam r;
   EXPECT_EQ(0U, r.start());
   EXPECT_EQ(0U, r.end());
   EXPECT_EQ(0U, r.length());
   EXPECT_FALSE(r.is_reversed());
   EXPECT_TRUE(r.is_empty());
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(0U, r.GetMin());
   EXPECT_EQ(0U, r.GetMax());
 }
 
-TEST(RangeTest, StartEndInit) {
-  gfx::Range r(10, 15);
+TYPED_TEST(RangeTest, StartEndInit) {
+  TypeParam r(10, 15);
   EXPECT_EQ(10U, r.start());
   EXPECT_EQ(15U, r.end());
   EXPECT_EQ(5U, r.length());
   EXPECT_FALSE(r.is_reversed());
   EXPECT_FALSE(r.is_empty());
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(10U, r.GetMin());
   EXPECT_EQ(15U, r.GetMax());
 }
 
-TEST(RangeTest, StartEndReversedInit) {
-  gfx::Range r(10, 5);
+TYPED_TEST(RangeTest, StartEndReversedInit) {
+  TypeParam r(10, 5);
   EXPECT_EQ(10U, r.start());
   EXPECT_EQ(5U, r.end());
   EXPECT_EQ(5U, r.length());
   EXPECT_TRUE(r.is_reversed());
   EXPECT_FALSE(r.is_empty());
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(5U, r.GetMin());
   EXPECT_EQ(10U, r.GetMax());
 }
 
-TEST(RangeTest, PositionInit) {
-  gfx::Range r(12);
+TYPED_TEST(RangeTest, PositionInit) {
+  TypeParam r(12);
   EXPECT_EQ(12U, r.start());
   EXPECT_EQ(12U, r.end());
   EXPECT_EQ(0U, r.length());
   EXPECT_FALSE(r.is_reversed());
   EXPECT_TRUE(r.is_empty());
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(12U, r.GetMin());
   EXPECT_EQ(12U, r.GetMax());
 }
 
-TEST(RangeTest, InvalidRange) {
-  gfx::Range r(gfx::Range::InvalidRange());
-  EXPECT_EQ(0U, r.length());

[msw, 2015/02/12 21:01:04]

nit: please retain the length==0, start==end, reversed==false checks. The
semantics of an invalid RangeF should match those of an invalid Range.

[ckocagil, 2015/02/13 18:47:47]

start==end isn't possible since NaN isn't equal to NaN. Others done.

[msw, 2015/02/13 19:29:31]

Does this mean you can't test against an invalid range?
  gfx::RangeF my_range = gfx::RangeF::InvalidRange();
  if (my_range != gfx::RangeF::InvalidRange())
    printf("I assume |my_range| is valid, but it's not!!!");
I think that's a common check that this class should support.
Modify operator==() and add test cases here for == and !=.

What other semantic differences are caused by using NaN?
(please check&test Max(), Min(), and EqualsIgnoringDirection())
Did you consider using std::numeric_limits<float>::max() to parallel Range's
std::numeric_limits<size_t>::max())?

[ckocagil, 2015/02/13 20:05:50]

Good call. Done.

- Restored "start==end" case
- Added GetMax(), GetMin(), operator==, EqualsIgnoringDirection() cases.
- IsValid() uses "*this != InvalidRange()"
- Removed IsValid() special cases due to NaN's incomparability.
- Updated comments

-  EXPECT_EQ(r.start(), r.end());
-  EXPECT_FALSE(r.is_reversed());
+TYPED_TEST(RangeTest, InvalidRange) {
+  TypeParam r(TypeParam::InvalidRange());
   EXPECT_TRUE(r.is_empty());
   EXPECT_FALSE(r.IsValid());
 }
 
-TEST(RangeTest, Equality) {
-  gfx::Range r1(10, 4);
-  gfx::Range r2(10, 4);
-  gfx::Range r3(10, 2);
+TYPED_TEST(RangeTest, Equality) {
+  TypeParam r1(10, 4);
+  TypeParam r2(10, 4);
+  TypeParam r3(10, 2);
   EXPECT_EQ(r1, r2);
   EXPECT_NE(r1, r3);
   EXPECT_NE(r2, r3);
 
-  gfx::Range r4(11, 4);
+  TypeParam r4(11, 4);
   EXPECT_NE(r1, r4);
   EXPECT_NE(r2, r4);
   EXPECT_NE(r3, r4);
 
-  gfx::Range r5(12, 5);
+  TypeParam r5(12, 5);
   EXPECT_NE(r1, r5);
   EXPECT_NE(r2, r5);
   EXPECT_NE(r3, r5);
 }
 
-TEST(RangeTest, EqualsIgnoringDirection) {
-  gfx::Range r1(10, 5);
-  gfx::Range r2(5, 10);
+TYPED_TEST(RangeTest, EqualsIgnoringDirection) {
+  TypeParam r1(10, 5);
+  TypeParam r2(5, 10);
   EXPECT_TRUE(r1.EqualsIgnoringDirection(r2));
 }
 
-TEST(RangeTest, SetStart) {
-  gfx::Range r(10, 20);
+TYPED_TEST(RangeTest, SetStart) {
+  TypeParam r(10, 20);
   EXPECT_EQ(10U, r.start());
   EXPECT_EQ(10U, r.length());
 
   r.set_start(42);
   EXPECT_EQ(42U, r.start());
   EXPECT_EQ(20U, r.end());
   EXPECT_EQ(22U, r.length());
   EXPECT_TRUE(r.is_reversed());
 }
 
-TEST(RangeTest, SetEnd) {
-  gfx::Range r(10, 13);
+TYPED_TEST(RangeTest, SetEnd) {
+  TypeParam r(10, 13);
   EXPECT_EQ(10U, r.start());
   EXPECT_EQ(3U, r.length());
 
   r.set_end(20);
   EXPECT_EQ(10U, r.start());
   EXPECT_EQ(20U, r.end());
   EXPECT_EQ(10U, r.length());
 }
 
-TEST(RangeTest, SetStartAndEnd) {
-  gfx::Range r;
+TYPED_TEST(RangeTest, SetStartAndEnd) {
+  TypeParam r;
   r.set_end(5);
   r.set_start(1);
   EXPECT_EQ(1U, r.start());
   EXPECT_EQ(5U, r.end());
   EXPECT_EQ(4U, r.length());
   EXPECT_EQ(1U, r.GetMin());
   EXPECT_EQ(5U, r.GetMax());
 }
 
-TEST(RangeTest, ReversedRange) {
-  gfx::Range r(10, 5);
+TYPED_TEST(RangeTest, ReversedRange) {
+  TypeParam r(10, 5);
   EXPECT_EQ(10U, r.start());
   EXPECT_EQ(5U, r.end());
   EXPECT_EQ(5U, r.length());
   EXPECT_TRUE(r.is_reversed());
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(5U, r.GetMin());
   EXPECT_EQ(10U, r.GetMax());
 }
 
-TEST(RangeTest, SetReversedRange) {
-  gfx::Range r(10, 20);
+TYPED_TEST(RangeTest, SetReversedRange) {
+  TypeParam r(10, 20);
   r.set_start(25);
   EXPECT_EQ(25U, r.start());
   EXPECT_EQ(20U, r.end());
   EXPECT_EQ(5U, r.length());
   EXPECT_TRUE(r.is_reversed());
   EXPECT_TRUE(r.IsValid());
 
   r.set_end(21);
   EXPECT_EQ(25U, r.start());
   EXPECT_EQ(21U, r.end());
   EXPECT_EQ(4U, r.length());
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(21U, r.GetMin());
   EXPECT_EQ(25U, r.GetMax());
 }
 
-void TestContainsAndIntersects(const gfx::Range& r1,
-                               const gfx::Range& r2,
-                               const gfx::Range& r3) {
-  EXPECT_TRUE(r1.Intersects(r1));
-  EXPECT_TRUE(r1.Contains(r1));
-  EXPECT_EQ(gfx::Range(10, 12), r1.Intersect(r1));
-
-  EXPECT_FALSE(r1.Intersects(r2));
-  EXPECT_FALSE(r1.Contains(r2));
-  EXPECT_TRUE(r1.Intersect(r2).is_empty());
-  EXPECT_FALSE(r2.Intersects(r1));
-  EXPECT_FALSE(r2.Contains(r1));
-  EXPECT_TRUE(r2.Intersect(r1).is_empty());
-
-  EXPECT_TRUE(r1.Intersects(r3));
-  EXPECT_TRUE(r3.Intersects(r1));
-  EXPECT_TRUE(r3.Contains(r1));
-  EXPECT_FALSE(r1.Contains(r3));
-  EXPECT_EQ(gfx::Range(10, 12), r1.Intersect(r3));
-  EXPECT_EQ(gfx::Range(10, 12), r3.Intersect(r1));
-
-  EXPECT_TRUE(r2.Intersects(r3));
-  EXPECT_TRUE(r3.Intersects(r2));
-  EXPECT_FALSE(r3.Contains(r2));
-  EXPECT_FALSE(r2.Contains(r3));
-  EXPECT_EQ(gfx::Range(5, 8), r2.Intersect(r3));
-  EXPECT_EQ(gfx::Range(5, 8), r3.Intersect(r2));
-}
-
-TEST(RangeTest, ContainAndIntersect) {
+TYPED_TEST(RangeTest, ContainAndIntersect) {
   {
     SCOPED_TRACE("contain and intersect");
-    gfx::Range r1(10, 12);
-    gfx::Range r2(1, 8);
-    gfx::Range r3(5, 12);
+    TypeParam r1(10, 12);
+    TypeParam r2(1, 8);
+    TypeParam r3(5, 12);
     TestContainsAndIntersects(r1, r2, r3);
   }
   {
     SCOPED_TRACE("contain and intersect: reversed");
-    gfx::Range r1(12, 10);
-    gfx::Range r2(8, 1);
-    gfx::Range r3(12, 5);
+    TypeParam r1(12, 10);
+    TypeParam r2(8, 1);
+    TypeParam r3(12, 5);
     TestContainsAndIntersects(r1, r2, r3);
   }
   // Invalid rect tests
-  gfx::Range r1(10, 12);
-  gfx::Range r2(8, 1);
-  gfx::Range invalid = r1.Intersect(r2);
+  TypeParam r1(10, 12);
+  TypeParam r2(8, 1);
+  TypeParam invalid = r1.Intersect(r2);
   EXPECT_FALSE(invalid.IsValid());
   EXPECT_FALSE(invalid.Contains(invalid));
   EXPECT_FALSE(invalid.Contains(r1));
   EXPECT_FALSE(invalid.Intersects(invalid));
   EXPECT_FALSE(invalid.Intersects(r1));
   EXPECT_FALSE(r1.Contains(invalid));
   EXPECT_FALSE(r1.Intersects(invalid));
 }