Use EXPECT_EQ when possible.

cc/base/tiling_data_unittest.cc

 // Copyright 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 "cc/base/tiling_data.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/test/geometry_test_utils.h"
@@ skipping 757 matching lines @@
   EXPECT_EQ(10, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(8, 5));
   EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
   EXPECT_EQ(3, data.num_tiles_x());
   EXPECT_EQ(10, data.num_tiles_y());
 }
 
 TEST(TilingDataTest, ExpandRectIgnoringBordersToTileBoundsEmpty) {
   TilingData empty_total_size(gfx::Size(0, 0), gfx::Size(8, 8), true);
-  EXPECT_RECT_EQ(
-      gfx::Rect(),
-      empty_total_size.ExpandRectIgnoringBordersToTileBounds(gfx::Rect()));
-  EXPECT_RECT_EQ(gfx::Rect(),
-                 empty_total_size.ExpandRectIgnoringBordersToTileBounds(
-                     gfx::Rect(100, 100, 100, 100)));
-  EXPECT_RECT_EQ(gfx::Rect(),
-                 empty_total_size.ExpandRectIgnoringBordersToTileBounds(
-                     gfx::Rect(100, 100)));
+  EXPECT_EQ(gfx::Rect(), empty_total_size.ExpandRectIgnoringBordersToTileBounds(
+                             gfx::Rect()));
+  EXPECT_EQ(gfx::Rect(), empty_total_size.ExpandRectIgnoringBordersToTileBounds(
+                             gfx::Rect(100, 100, 100, 100)));
+  EXPECT_EQ(gfx::Rect(), empty_total_size.ExpandRectIgnoringBordersToTileBounds(
+                             gfx::Rect(100, 100)));
 
   TilingData empty_max_texture_size(gfx::Size(8, 8), gfx::Size(0, 0), true);
-  EXPECT_RECT_EQ(gfx::Rect(),
-                 empty_max_texture_size.ExpandRectIgnoringBordersToTileBounds(
-                     gfx::Rect()));
-  EXPECT_RECT_EQ(gfx::Rect(),
-                 empty_max_texture_size.ExpandRectIgnoringBordersToTileBounds(
-                     gfx::Rect(100, 100, 100, 100)));
-  EXPECT_RECT_EQ(gfx::Rect(),
-                 empty_max_texture_size.ExpandRectIgnoringBordersToTileBounds(
-                     gfx::Rect(100, 100)));
+  EXPECT_EQ(gfx::Rect(),
+            empty_max_texture_size.ExpandRectIgnoringBordersToTileBounds(
+                gfx::Rect()));
+  EXPECT_EQ(gfx::Rect(),
+            empty_max_texture_size.ExpandRectIgnoringBordersToTileBounds(
+                gfx::Rect(100, 100, 100, 100)));
+  EXPECT_EQ(gfx::Rect(),
+            empty_max_texture_size.ExpandRectIgnoringBordersToTileBounds(
+                gfx::Rect(100, 100)));
 }
 
 TEST(TilingDataTest, ExpandRectIgnoringBordersToTileBounds) {
   TilingData data(gfx::Size(4, 4), gfx::Size(16, 32), true);
 
   // Small rect at origin rounds up to tile 0, 0.
   gfx::Rect at_origin_src(1, 1);
   gfx::Rect at_origin_result(data.TileBounds(0, 0));
   EXPECT_NE(at_origin_src, at_origin_result);
-  EXPECT_RECT_EQ(at_origin_result,
-                 data.ExpandRectIgnoringBordersToTileBounds(at_origin_src));
+  EXPECT_EQ(at_origin_result,
+            data.ExpandRectIgnoringBordersToTileBounds(at_origin_src));
 
   // Arbitrary internal rect.
   gfx::Rect rect_src(6, 6, 1, 3);
   // Tile 2, 2 => gfx::Rect(4, 4, 4, 4)
   // Tile 2, 3 => gfx::Rect(4, 6, 4, 4)
   gfx::Rect rect_result(
       gfx::UnionRects(data.TileBounds(2, 2), data.TileBounds(2, 3)));
   EXPECT_NE(rect_src, rect_result);
-  EXPECT_RECT_EQ(rect_result,
-                 data.ExpandRectIgnoringBordersToTileBounds(rect_src));
+  EXPECT_EQ(rect_result, data.ExpandRectIgnoringBordersToTileBounds(rect_src));
 
   // On tile bounds does not round up to next tile (ignores the border).
   gfx::Rect border_rect_src(
       gfx::UnionRects(data.TileBounds(1, 2), data.TileBounds(3, 4)));
   gfx::Rect border_rect_result(
       gfx::UnionRects(data.TileBounds(1, 2), data.TileBounds(3, 4)));
-  EXPECT_RECT_EQ(border_rect_result,
-                 data.ExpandRectIgnoringBordersToTileBounds(border_rect_src));
+  EXPECT_EQ(border_rect_result,
+            data.ExpandRectIgnoringBordersToTileBounds(border_rect_src));
 
   // Equal to tiling rect.
-  EXPECT_RECT_EQ(gfx::Rect(data.tiling_size()),
-                 data.ExpandRectIgnoringBordersToTileBounds(
-                     gfx::Rect(data.tiling_size())));
+  EXPECT_EQ(gfx::Rect(data.tiling_size()),
+            data.ExpandRectIgnoringBordersToTileBounds(
+                gfx::Rect(data.tiling_size())));
 
   // Containing, but larger than tiling rect.
-  EXPECT_RECT_EQ(
-      gfx::Rect(data.tiling_size()),
-      data.ExpandRectIgnoringBordersToTileBounds(gfx::Rect(100, 100)));
+  EXPECT_EQ(gfx::Rect(data.tiling_size()),
+            data.ExpandRectIgnoringBordersToTileBounds(gfx::Rect(100, 100)));
 
   // Non-intersecting with tiling rect.
   gfx::Rect non_intersect(200, 200, 100, 100);
   EXPECT_FALSE(non_intersect.Intersects(gfx::Rect(data.tiling_size())));
-  EXPECT_RECT_EQ(gfx::Rect(),
-                 data.ExpandRectIgnoringBordersToTileBounds(non_intersect));
+  EXPECT_EQ(gfx::Rect(),
+            data.ExpandRectIgnoringBordersToTileBounds(non_intersect));
 
   TilingData data2(gfx::Size(8, 8), gfx::Size(32, 64), true);
 
   // Inside other tile border texels doesn't include other tiles.
   gfx::Rect inner_rect_src(data2.TileBounds(1, 1));
   inner_rect_src.Inset(data2.border_texels(), data.border_texels());
   gfx::Rect inner_rect_result(data2.TileBounds(1, 1));
   gfx::Rect expanded =
       data2.ExpandRectIgnoringBordersToTileBounds(inner_rect_src);
   EXPECT_EQ(inner_rect_result.ToString(), expanded.ToString());
 }
 
 TEST(TilingDataTest, ExpandRectToTileBounds) {
   TilingData data(gfx::Size(4, 4), gfx::Size(16, 32), true);
 
   // Small rect at origin rounds up to tile 0, 0.
   gfx::Rect at_origin_src(1, 1);
   gfx::Rect at_origin_result(data.TileBounds(0, 0));
   EXPECT_NE(at_origin_src, at_origin_result);
-  EXPECT_RECT_EQ(at_origin_result, data.ExpandRectToTileBounds(at_origin_src));
+  EXPECT_EQ(at_origin_result, data.ExpandRectToTileBounds(at_origin_src));
 
   // Arbitrary internal rect.
   gfx::Rect rect_src(6, 6, 1, 3);
   // Tile 2, 2 => gfx::Rect(4, 4, 4, 4)
   // Tile 3, 4 => gfx::Rect(6, 8, 4, 4)
   gfx::Rect rect_result(
       gfx::UnionRects(data.TileBounds(2, 2), data.TileBounds(3, 4)));
   EXPECT_NE(rect_src, rect_result);
-  EXPECT_RECT_EQ(rect_result, data.ExpandRectToTileBounds(rect_src));
+  EXPECT_EQ(rect_result, data.ExpandRectToTileBounds(rect_src));
 
   // On tile bounds rounds up to next tile (since border overlaps).
   gfx::Rect border_rect_src(
       gfx::UnionRects(data.TileBounds(1, 2), data.TileBounds(3, 4)));
   gfx::Rect border_rect_result(
       gfx::UnionRects(data.TileBounds(0, 1), data.TileBounds(4, 5)));
-  EXPECT_RECT_EQ(border_rect_result,
-                 data.ExpandRectToTileBounds(border_rect_src));
+  EXPECT_EQ(border_rect_result, data.ExpandRectToTileBounds(border_rect_src));
 
   // Equal to tiling rect.
-  EXPECT_RECT_EQ(gfx::Rect(data.tiling_size()),
-                 data.ExpandRectToTileBounds(gfx::Rect(data.tiling_size())));
+  EXPECT_EQ(gfx::Rect(data.tiling_size()),
+            data.ExpandRectToTileBounds(gfx::Rect(data.tiling_size())));
 
   // Containing, but larger than tiling rect.
-  EXPECT_RECT_EQ(gfx::Rect(data.tiling_size()),
-                 data.ExpandRectToTileBounds(gfx::Rect(100, 100)));
+  EXPECT_EQ(gfx::Rect(data.tiling_size()),
+            data.ExpandRectToTileBounds(gfx::Rect(100, 100)));
 
   // Non-intersecting with tiling rect.
   gfx::Rect non_intersect(200, 200, 100, 100);
   EXPECT_FALSE(non_intersect.Intersects(gfx::Rect(data.tiling_size())));
-  EXPECT_RECT_EQ(gfx::Rect(), data.ExpandRectToTileBounds(non_intersect));
+  EXPECT_EQ(gfx::Rect(), data.ExpandRectToTileBounds(non_intersect));
 
   TilingData data2(gfx::Size(8, 8), gfx::Size(32, 64), true);
 
   // Inside other tile border texels doesn't include other tiles.
   gfx::Rect inner_rect_src(data2.TileBounds(1, 1));
   inner_rect_src.Inset(data2.border_texels(), data.border_texels());
   gfx::Rect inner_rect_result(data2.TileBounds(1, 1));
   gfx::Rect expanded = data2.ExpandRectToTileBounds(inner_rect_src);
   EXPECT_EQ(inner_rect_result.ToString(), expanded.ToString());
 }
@@ skipping 43 matching lines @@
   EXPECT_EQ(50, data.TileSizeX(3));
   EXPECT_EQ(4, data.num_tiles_x());
 
   EXPECT_EQ(50, data.TileSizeY(0));
   EXPECT_EQ(20, data.TileSizeY(1));
   EXPECT_EQ(20, data.TileSizeY(2));
   EXPECT_EQ(20, data.TileSizeY(3));
   EXPECT_EQ(35, data.TileSizeY(4));
   EXPECT_EQ(5, data.num_tiles_y());
 
-  EXPECT_RECT_EQ(gfx::Rect(70, 50), data.TileBounds(0, 0));
-  EXPECT_RECT_EQ(gfx::Rect(70, 50, 40, 20), data.TileBounds(1, 1));
-  EXPECT_RECT_EQ(gfx::Rect(110, 110, 40, 35), data.TileBounds(2, 4));
-  EXPECT_RECT_EQ(gfx::Rect(150, 70, 50, 20), data.TileBounds(3, 2));
-  EXPECT_RECT_EQ(gfx::Rect(150, 110, 50, 35), data.TileBounds(3, 4));
+  EXPECT_EQ(gfx::Rect(70, 50), data.TileBounds(0, 0));
+  EXPECT_EQ(gfx::Rect(70, 50, 40, 20), data.TileBounds(1, 1));
+  EXPECT_EQ(gfx::Rect(110, 110, 40, 35), data.TileBounds(2, 4));
+  EXPECT_EQ(gfx::Rect(150, 70, 50, 20), data.TileBounds(3, 2));
+  EXPECT_EQ(gfx::Rect(150, 110, 50, 35), data.TileBounds(3, 4));
 
-  EXPECT_RECT_EQ(gfx::Rect(100, 80), data.TileBoundsWithBorder(0, 0));
-  EXPECT_RECT_EQ(gfx::Rect(40, 20, 100, 80), data.TileBoundsWithBorder(1, 1));
-  EXPECT_RECT_EQ(gfx::Rect(80, 80, 100, 65), data.TileBoundsWithBorder(2, 4));
-  EXPECT_RECT_EQ(gfx::Rect(120, 40, 80, 80), data.TileBoundsWithBorder(3, 2));
-  EXPECT_RECT_EQ(gfx::Rect(120, 80, 80, 65), data.TileBoundsWithBorder(3, 4));
+  EXPECT_EQ(gfx::Rect(100, 80), data.TileBoundsWithBorder(0, 0));
+  EXPECT_EQ(gfx::Rect(40, 20, 100, 80), data.TileBoundsWithBorder(1, 1));
+  EXPECT_EQ(gfx::Rect(80, 80, 100, 65), data.TileBoundsWithBorder(2, 4));
+  EXPECT_EQ(gfx::Rect(120, 40, 80, 80), data.TileBoundsWithBorder(3, 2));
+  EXPECT_EQ(gfx::Rect(120, 80, 80, 65), data.TileBoundsWithBorder(3, 4));
 
   EXPECT_EQ(0, data.TileXIndexFromSrcCoord(0));
   EXPECT_EQ(0, data.TileXIndexFromSrcCoord(69));
   EXPECT_EQ(1, data.TileXIndexFromSrcCoord(70));
   EXPECT_EQ(1, data.TileXIndexFromSrcCoord(109));
   EXPECT_EQ(2, data.TileXIndexFromSrcCoord(110));
   EXPECT_EQ(2, data.TileXIndexFromSrcCoord(149));
   EXPECT_EQ(3, data.TileXIndexFromSrcCoord(150));
   EXPECT_EQ(3, data.TileXIndexFromSrcCoord(199));
 
@@ skipping 976 matching lines @@
   expected.push_back(std::make_pair(2, 2));
   expected.push_back(std::make_pair(2, 1));
   expected.push_back(std::make_pair(2, 0));
 
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
 }  // namespace
 
 }  // namespace cc