Provide gtest printers for ui/gfx geometry types

ui/gfx/geometry/rect_unittest.cc

 // Copyright (c) 2013 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 <limits>
 
 #include "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/test/gfx_util.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 namespace gfx {
 
 TEST(RectTest, Contains) {
   static const struct ContainsCase {
     int rect_x;
@@ skipping 200 matching lines @@
     EXPECT_EQ(r3.height(), u.height());
   }
 }
 
 TEST(RectTest, Subtract) {
   Rect result;
 
   // Matching
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(10, 10, 20, 20));
-  EXPECT_EQ(Rect(0, 0, 0, 0).ToString(), result.ToString());
+  EXPECT_EQ(Rect(0, 0, 0, 0), result);
 
   // Contains
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(5, 5, 30, 30));
-  EXPECT_EQ(Rect(0, 0, 0, 0).ToString(), result.ToString());
+  EXPECT_EQ(Rect(0, 0, 0, 0), result);
 
   // No intersection
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(30, 30, 30, 30));
-  EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 
   // Not a complete intersection in either direction
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(15, 15, 20, 20));
-  EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 
   // Complete intersection in the x-direction, top edge is fully covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(10, 15, 20, 20));
-  EXPECT_EQ(Rect(10, 10, 20, 5).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 20, 5), result);
 
   // Complete intersection in the x-direction, top edge is fully covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(5, 15, 30, 20));
-  EXPECT_EQ(Rect(10, 10, 20, 5).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 20, 5), result);
 
   // Complete intersection in the x-direction, bottom edge is fully covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(5, 5, 30, 20));
-  EXPECT_EQ(Rect(10, 25, 20, 5).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 25, 20, 5), result);
 
   // Complete intersection in the x-direction, none of the edges is fully
   // covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(5, 15, 30, 1));
-  EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 
   // Complete intersection in the y-direction, left edge is fully covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(10, 10, 10, 30));
-  EXPECT_EQ(Rect(20, 10, 10, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(20, 10, 10, 20), result);
 
   // Complete intersection in the y-direction, left edge is fully covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(5, 5, 20, 30));
-  EXPECT_EQ(Rect(25, 10, 5, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(25, 10, 5, 20), result);
 
   // Complete intersection in the y-direction, right edge is fully covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(20, 5, 20, 30));
-  EXPECT_EQ(Rect(10, 10, 10, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 10, 20), result);
 
   // Complete intersection in the y-direction, none of the edges is fully
   // covered.
   result = Rect(10, 10, 20, 20);
   result.Subtract(Rect(15, 5, 1, 30));
-  EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 }
 
 TEST(RectTest, IsEmpty) {
   EXPECT_TRUE(Rect(0, 0, 0, 0).IsEmpty());
   EXPECT_TRUE(Rect(0, 0, 0, 0).size().IsEmpty());
   EXPECT_TRUE(Rect(0, 0, 10, 0).IsEmpty());
   EXPECT_TRUE(Rect(0, 0, 10, 0).size().IsEmpty());
   EXPECT_TRUE(Rect(0, 0, 0, 10).IsEmpty());
   EXPECT_TRUE(Rect(0, 0, 0, 10).size().IsEmpty());
   EXPECT_FALSE(Rect(0, 0, 10, 10).IsEmpty());
@@ skipping 263 matching lines @@
     Rect enclosed = ToEnclosingRect(r1);
     EXPECT_FLOAT_AND_NAN_EQ(r2.x(), enclosed.x());
     EXPECT_FLOAT_AND_NAN_EQ(r2.y(), enclosed.y());
     EXPECT_FLOAT_AND_NAN_EQ(r2.width(), enclosed.width());
     EXPECT_FLOAT_AND_NAN_EQ(r2.height(), enclosed.height());
   }
 }
 
 TEST(RectTest, ToNearestRect) {
   Rect rect;
-  EXPECT_EQ(rect.ToString(), ToNearestRect(RectF(rect)).ToString());
+  EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
 
   rect = Rect(-1, -1, 3, 3);
-  EXPECT_EQ(rect.ToString(), ToNearestRect(RectF(rect)).ToString());
+  EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
 
   RectF rectf(-1.00001f, -0.999999f, 3.0000001f, 2.999999f);
-  EXPECT_EQ(rect.ToString(), ToNearestRect(rectf).ToString());
+  EXPECT_EQ(rect, ToNearestRect(rectf));
 }
 
 TEST(RectTest, ToFlooredRect) {
   static const struct Test {
     float x1; // source
     float y1;
     float w1;
     float h1;
     int x2; // target
     int y2;
@@ skipping 55 matching lines @@
     }, {
       Rect(-1, -2, 0, 0),
       1.5f,
       Rect(-1, -3, 0, 0),
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     Rect result = ScaleToEnclosedRect(tests[i].input_rect,
                                       tests[i].input_scale);
-    EXPECT_EQ(tests[i].expected_rect.ToString(), result.ToString());
+    EXPECT_EQ(tests[i].expected_rect, result);
   }
 }
 
 TEST(RectTest, ScaleToEnclosingRect) {
   static const struct Test {
     Rect input_rect;
     float input_scale;
     Rect expected_rect;
   } tests[] = {
     {
@@ skipping 23 matching lines @@
     }, {
       Rect(-1, -2, 0, 0),
       1.5f,
       Rect(-2, -3, 0, 0),
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     Rect result = ScaleToEnclosingRect(tests[i].input_rect,
                                        tests[i].input_scale);
-    EXPECT_EQ(tests[i].expected_rect.ToString(), result.ToString());
+    EXPECT_EQ(tests[i].expected_rect, result);
   }
 }
 
 #if defined(OS_WIN)
 TEST(RectTest, ConstructAndAssign) {
   const RECT rect_1 = { 0, 0, 10, 10 };
   const RECT rect_2 = { 0, 0, -10, -10 };
   Rect test1(rect_1);
   Rect test2(rect_2);
 }
 #endif
 
 TEST(RectTest, ToRectF) {
   // Check that implicit conversion from integer to float compiles.
   Rect a(10, 20, 30, 40);
   RectF b(10, 20, 30, 40);
 
   RectF intersect = IntersectRects(a, b);
-  EXPECT_EQ(b.ToString(), intersect.ToString());
+  EXPECT_EQ(b, intersect);
 
   EXPECT_EQ(a, b);
   EXPECT_EQ(b, a);
 }
 
 TEST(RectTest, BoundingRect) {
   struct {
     Point a;
     Point b;
     Rect expected;
   } int_tests[] = {
     // If point B dominates A, then A should be the origin.
     { Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0) },
     { Point(4, 6), Point(8, 6), Rect(4, 6, 4, 0) },
     { Point(4, 6), Point(4, 9), Rect(4, 6, 0, 3) },
     { Point(4, 6), Point(8, 9), Rect(4, 6, 4, 3) },
     // If point A dominates B, then B should be the origin.
     { Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0) },
     { Point(8, 6), Point(4, 6), Rect(4, 6, 4, 0) },
     { Point(4, 9), Point(4, 6), Rect(4, 6, 0, 3) },
     { Point(8, 9), Point(4, 6), Rect(4, 6, 4, 3) },
     // If neither point dominates, then the origin is a combination of the two.
     { Point(4, 6), Point(6, 4), Rect(4, 4, 2, 2) },
     { Point(-4, -6), Point(-6, -4), Rect(-6, -6, 2, 2) },
     { Point(-4, 6), Point(6, -4), Rect(-4, -4, 10, 10) },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(int_tests); ++i) {
     Rect actual = BoundingRect(int_tests[i].a, int_tests[i].b);
-    EXPECT_EQ(int_tests[i].expected.ToString(), actual.ToString());
+    EXPECT_EQ(int_tests[i].expected, actual);
   }
 
   struct {
     PointF a;
     PointF b;
     RectF expected;
   } float_tests[] = {
     // If point B dominates A, then A should be the origin.
     { PointF(4.2f, 6.8f), PointF(4.2f, 6.8f),
       RectF(4.2f, 6.8f, 0, 0) },
@@ skipping 16 matching lines @@
     { PointF(4.2f, 6.8f), PointF(6.8f, 4.2f),
       RectF(4.2f, 4.2f, 2.6f, 2.6f) },
     { PointF(-4.2f, -6.8f), PointF(-6.8f, -4.2f),
       RectF(-6.8f, -6.8f, 2.6f, 2.6f) },
     { PointF(-4.2f, 6.8f), PointF(6.8f, -4.2f),
       RectF(-4.2f, -4.2f, 11.0f, 11.0f) }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(float_tests); ++i) {
     RectF actual = BoundingRect(float_tests[i].a, float_tests[i].b);
-    EXPECT_EQ(float_tests[i].expected.ToString(), actual.ToString());
+    EXPECT_RECTF_EQ(float_tests[i].expected, actual);
   }
 }
 
 TEST(RectTest, IsExpressibleAsRect) {
   EXPECT_TRUE(RectF().IsExpressibleAsRect());
 
   float min = std::numeric_limits<int>::min();
   float max = std::numeric_limits<int>::max();
   float infinity = std::numeric_limits<float>::infinity();
 
@@ skipping 16 matching lines @@
 
   EXPECT_FALSE(RectF(infinity, 0, 1, 1).IsExpressibleAsRect());
   EXPECT_FALSE(RectF(0, infinity, 1, 1).IsExpressibleAsRect());
   EXPECT_FALSE(RectF(0, 0, infinity, 1).IsExpressibleAsRect());
   EXPECT_FALSE(RectF(0, 0, 1, infinity).IsExpressibleAsRect());
 }
 
 TEST(RectTest, Offset) {
   Rect i(1, 2, 3, 4);
 
-  EXPECT_EQ(Rect(2, 1, 3, 4).ToString(), (i + Vector2d(1, -1)).ToString());
-  EXPECT_EQ(Rect(2, 1, 3, 4).ToString(), (Vector2d(1, -1) + i).ToString());
+  EXPECT_EQ(Rect(2, 1, 3, 4), (i + Vector2d(1, -1)));
+  EXPECT_EQ(Rect(2, 1, 3, 4), (Vector2d(1, -1) + i));
   i += Vector2d(1, -1);
-  EXPECT_EQ(Rect(2, 1, 3, 4).ToString(), i.ToString());
-  EXPECT_EQ(Rect(1, 2, 3, 4).ToString(), (i - Vector2d(1, -1)).ToString());
+  EXPECT_EQ(Rect(2, 1, 3, 4), i);
+  EXPECT_EQ(Rect(1, 2, 3, 4), (i - Vector2d(1, -1)));
   i -= Vector2d(1, -1);
-  EXPECT_EQ(Rect(1, 2, 3, 4).ToString(), i.ToString());
+  EXPECT_EQ(Rect(1, 2, 3, 4), i);
 
   RectF f(1.1f, 2.2f, 3.3f, 4.4f);
-  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f).ToString(),
-            (f + Vector2dF(1.1f, -1.1f)).ToString());
-  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f).ToString(),
-            (Vector2dF(1.1f, -1.1f) + f).ToString());
+  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (f + Vector2dF(1.1f, -1.1f)));
+  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (Vector2dF(1.1f, -1.1f) + f));
   f += Vector2dF(1.1f, -1.1f);
-  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f).ToString(), f.ToString());
-  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f).ToString(),
-            (f - Vector2dF(1.1f, -1.1f)).ToString());
+  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), f);
+  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), (f - Vector2dF(1.1f, -1.1f)));
   f -= Vector2dF(1.1f, -1.1f);
-  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f).ToString(), f.ToString());
+  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), f);
 }
 
 TEST(RectTest, Corners) {
   Rect i(1, 2, 3, 4);
   RectF f(1.1f, 2.1f, 3.1f, 4.1f);
 
-  EXPECT_EQ(Point(1, 2).ToString(), i.origin().ToString());
-  EXPECT_EQ(Point(4, 2).ToString(), i.top_right().ToString());
-  EXPECT_EQ(Point(1, 6).ToString(), i.bottom_left().ToString());
-  EXPECT_EQ(Point(4, 6).ToString(), i.bottom_right().ToString());
+  EXPECT_EQ(Point(1, 2), i.origin());
+  EXPECT_EQ(Point(4, 2), i.top_right());
+  EXPECT_EQ(Point(1, 6), i.bottom_left());
+  EXPECT_EQ(Point(4, 6), i.bottom_right());
 
-  EXPECT_EQ(PointF(1.1f, 2.1f).ToString(), f.origin().ToString());
-  EXPECT_EQ(PointF(4.2f, 2.1f).ToString(), f.top_right().ToString());
-  EXPECT_EQ(PointF(1.1f, 6.2f).ToString(), f.bottom_left().ToString());
-  EXPECT_EQ(PointF(4.2f, 6.2f).ToString(), f.bottom_right().ToString());
+  EXPECT_EQ(PointF(1.1f, 2.1f), f.origin());
+  EXPECT_EQ(PointF(4.2f, 2.1f), f.top_right());
+  EXPECT_EQ(PointF(1.1f, 6.2f), f.bottom_left());
+  EXPECT_EQ(PointF(4.2f, 6.2f), f.bottom_right());
 }
 
 TEST(RectTest, ManhattanDistanceToPoint) {
   Rect i(1, 2, 3, 4);
   EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(1, 2)));
   EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(4, 6)));
   EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(2, 4)));
   EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(0, 0)));
   EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(2, 0)));
   EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 0)));
@@ skipping 51 matching lines @@
       0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 1.1f, 1.0f)));
   EXPECT_FLOAT_EQ(
       0.1f + kEpsilon,
       f.ManhattanInternalDistance(gfx::RectF(-1.5f, 0.0f, 1.4f, 1.0f)));
   EXPECT_FLOAT_EQ(
       kEpsilon,
       f.ManhattanInternalDistance(gfx::RectF(-1.5f, 0.0f, 1.5f, 1.0f)));
 }
 
 }  // namespace gfx