Move src/gfx/ to src/ui/gfx...

gfx/rect_unittest.cc

Index: gfx/rect_unittest.cc
===================================================================
--- gfx/rect_unittest.cc	(revision 73487)
+++ gfx/rect_unittest.cc	(working copy)
@@ -1,314 +0,0 @@
-// Copyright (c) 2006-2008 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 "base/basictypes.h"
-#include "gfx/rect.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-typedef testing::Test RectTest;
-
-TEST(RectTest, Contains) {
-  static const struct ContainsCase {
-    int rect_x;
-    int rect_y;
-    int rect_width;
-    int rect_height;
-    int point_x;
-    int point_y;
-    bool contained;
-  } contains_cases[] = {
-    {0, 0, 10, 10, 0, 0, true},
-    {0, 0, 10, 10, 5, 5, true},
-    {0, 0, 10, 10, 9, 9, true},
-    {0, 0, 10, 10, 5, 10, false},
-    {0, 0, 10, 10, 10, 5, false},
-    {0, 0, 10, 10, -1, -1, false},
-    {0, 0, 10, 10, 50, 50, false},
-  #ifdef NDEBUG
-    {0, 0, -10, -10, 0, 0, false},
-  #endif  // NDEBUG
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(contains_cases); ++i) {
-    const ContainsCase& value = contains_cases[i];
-    gfx::Rect rect(value.rect_x, value.rect_y,
-                   value.rect_width, value.rect_height);
-    EXPECT_EQ(value.contained, rect.Contains(value.point_x, value.point_y));
-  }
-}
-
-TEST(RectTest, Intersects) {
-  static const struct {
-    int x1;  // rect 1
-    int y1;
-    int w1;
-    int h1;
-    int x2;  // rect 2
-    int y2;
-    int w2;
-    int h2;
-    bool intersects;
-  } tests[] = {
-    { 0, 0, 0, 0, 0, 0, 0, 0, false },
-    { 0, 0, 10, 10, 0, 0, 10, 10, true },
-    { 0, 0, 10, 10, 10, 10, 10, 10, false },
-    { 10, 10, 10, 10, 0, 0, 10, 10, false },
-    { 10, 10, 10, 10, 5, 5, 10, 10, true },
-    { 10, 10, 10, 10, 15, 15, 10, 10, true },
-    { 10, 10, 10, 10, 20, 15, 10, 10, false },
-    { 10, 10, 10, 10, 21, 15, 10, 10, false }
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
-    gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
-    EXPECT_EQ(tests[i].intersects, r1.Intersects(r2));
-  }
-}
-
-TEST(RectTest, Intersect) {
-  static const struct {
-    int x1;  // rect 1
-    int y1;
-    int w1;
-    int h1;
-    int x2;  // rect 2
-    int y2;
-    int w2;
-    int h2;
-    int x3;  // rect 3: the union of rects 1 and 2
-    int y3;
-    int w3;
-    int h3;
-  } tests[] = {
-    { 0, 0, 0, 0,   // zeros
-      0, 0, 0, 0,
-      0, 0, 0, 0 },
-    { 0, 0, 4, 4,   // equal
-      0, 0, 4, 4,
-      0, 0, 4, 4 },
-    { 0, 0, 4, 4,   // neighboring
-      4, 4, 4, 4,
-      0, 0, 0, 0 },
-    { 0, 0, 4, 4,   // overlapping corners
-      2, 2, 4, 4,
-      2, 2, 2, 2 },
-    { 0, 0, 4, 4,   // T junction
-      3, 1, 4, 2,
-      3, 1, 1, 2 },
-    { 3, 0, 2, 2,   // gap
-      0, 0, 2, 2,
-      0, 0, 0, 0 }
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
-    gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
-    gfx::Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
-    gfx::Rect ir = r1.Intersect(r2);
-    EXPECT_EQ(r3.x(), ir.x());
-    EXPECT_EQ(r3.y(), ir.y());
-    EXPECT_EQ(r3.width(), ir.width());
-    EXPECT_EQ(r3.height(), ir.height());
-  }
-}
-
-TEST(RectTest, Union) {
-  static const struct Test {
-    int x1;  // rect 1
-    int y1;
-    int w1;
-    int h1;
-    int x2;  // rect 2
-    int y2;
-    int w2;
-    int h2;
-    int x3;  // rect 3: the union of rects 1 and 2
-    int y3;
-    int w3;
-    int h3;
-  } tests[] = {
-    { 0, 0, 0, 0,
-      0, 0, 0, 0,
-      0, 0, 0, 0 },
-    { 0, 0, 4, 4,
-      0, 0, 4, 4,
-      0, 0, 4, 4 },
-    { 0, 0, 4, 4,
-      4, 4, 4, 4,
-      0, 0, 8, 8 },
-    { 0, 0, 4, 4,
-      0, 5, 4, 4,
-      0, 0, 4, 9 },
-    { 0, 0, 2, 2,
-      3, 3, 2, 2,
-      0, 0, 5, 5 },
-    { 3, 3, 2, 2,   // reverse r1 and r2 from previous test
-      0, 0, 2, 2,
-      0, 0, 5, 5 },
-    { 0, 0, 0, 0,   // union with empty rect
-      2, 2, 2, 2,
-      2, 2, 2, 2 }
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
-    gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
-    gfx::Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
-    gfx::Rect u = r1.Union(r2);
-    EXPECT_EQ(r3.x(), u.x());
-    EXPECT_EQ(r3.y(), u.y());
-    EXPECT_EQ(r3.width(), u.width());
-    EXPECT_EQ(r3.height(), u.height());
-  }
-}
-
-TEST(RectTest, Equals) {
-  ASSERT_TRUE(gfx::Rect(0, 0, 0, 0).Equals(gfx::Rect(0, 0, 0, 0)));
-  ASSERT_TRUE(gfx::Rect(1, 2, 3, 4).Equals(gfx::Rect(1, 2, 3, 4)));
-  ASSERT_FALSE(gfx::Rect(0, 0, 0, 0).Equals(gfx::Rect(0, 0, 0, 1)));
-  ASSERT_FALSE(gfx::Rect(0, 0, 0, 0).Equals(gfx::Rect(0, 0, 1, 0)));
-  ASSERT_FALSE(gfx::Rect(0, 0, 0, 0).Equals(gfx::Rect(0, 1, 0, 0)));
-  ASSERT_FALSE(gfx::Rect(0, 0, 0, 0).Equals(gfx::Rect(1, 0, 0, 0)));
-}
-
-TEST(RectTest, AdjustToFit) {
-  static const struct Test {
-    int x1;  // source
-    int y1;
-    int w1;
-    int h1;
-    int x2;  // target
-    int y2;
-    int w2;
-    int h2;
-    int x3;  // rect 3: results of invoking AdjustToFit
-    int y3;
-    int w3;
-    int h3;
-  } tests[] = {
-    { 0, 0, 2, 2,
-      0, 0, 2, 2,
-      0, 0, 2, 2 },
-    { 2, 2, 3, 3,
-      0, 0, 4, 4,
-      1, 1, 3, 3 },
-    { -1, -1, 5, 5,
-      0, 0, 4, 4,
-      0, 0, 4, 4 },
-    { 2, 2, 4, 4,
-      0, 0, 3, 3,
-      0, 0, 3, 3 },
-    { 2, 2, 1, 1,
-      0, 0, 3, 3,
-      2, 2, 1, 1 }
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
-    gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
-    gfx::Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
-    gfx::Rect u(r1.AdjustToFit(r2));
-    EXPECT_EQ(r3.x(), u.x());
-    EXPECT_EQ(r3.y(), u.y());
-    EXPECT_EQ(r3.width(), u.width());
-    EXPECT_EQ(r3.height(), u.height());
-  }
-}
-
-TEST(RectTest, Subtract) {
-  // Matching
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(10, 10, 20, 20)).Equals(
-      gfx::Rect(0, 0, 0, 0)));
-
-  // Contains
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 5, 30, 30)).Equals(
-      gfx::Rect(0, 0, 0, 0)));
-
-  // No intersection
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(30, 30, 20, 20)).Equals(
-      gfx::Rect(10, 10, 20, 20)));
-
-  // Not a complete intersection in either direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(15, 15, 20, 20)).Equals(
-      gfx::Rect(10, 10, 20, 20)));
-
-  // Complete intersection in the x-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(10, 15, 20, 20)).Equals(
-      gfx::Rect(10, 10, 20, 5)));
-
-  // Complete intersection in the x-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 15, 30, 20)).Equals(
-      gfx::Rect(10, 10, 20, 5)));
-
-  // Complete intersection in the x-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 5, 30, 20)).Equals(
-      gfx::Rect(10, 25, 20, 5)));
-
-  // Complete intersection in the y-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(10, 10, 10, 30)).Equals(
-      gfx::Rect(20, 10, 10, 20)));
-
-  // Complete intersection in the y-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 5, 20, 30)).Equals(
-      gfx::Rect(25, 10, 5, 20)));
-}
-
-TEST(RectTest, IsEmpty) {
-  EXPECT_TRUE(gfx::Rect(0, 0, 0, 0).IsEmpty());
-  EXPECT_TRUE(gfx::Rect(0, 0, 0, 0).size().IsEmpty());
-  EXPECT_TRUE(gfx::Rect(0, 0, 10, 0).IsEmpty());
-  EXPECT_TRUE(gfx::Rect(0, 0, 10, 0).size().IsEmpty());
-  EXPECT_TRUE(gfx::Rect(0, 0, 0, 10).IsEmpty());
-  EXPECT_TRUE(gfx::Rect(0, 0, 0, 10).size().IsEmpty());
-  EXPECT_FALSE(gfx::Rect(0, 0, 10, 10).IsEmpty());
-  EXPECT_FALSE(gfx::Rect(0, 0, 10, 10).size().IsEmpty());
-}
-
-TEST(RectTest, SharesEdgeWith) {
-  gfx::Rect r(2, 3, 4, 5);
-
-  // Must be non-overlapping
-  EXPECT_FALSE(r.SharesEdgeWith(r));
-
-  gfx::Rect just_above(2, 1, 4, 2);
-  gfx::Rect just_below(2, 8, 4, 2);
-  gfx::Rect just_left(0, 3, 2, 5);
-  gfx::Rect just_right(6, 3, 2, 5);
-
-  EXPECT_TRUE(r.SharesEdgeWith(just_above));
-  EXPECT_TRUE(r.SharesEdgeWith(just_below));
-  EXPECT_TRUE(r.SharesEdgeWith(just_left));
-  EXPECT_TRUE(r.SharesEdgeWith(just_right));
-
-  // Wrong placement
-  gfx::Rect same_height_no_edge(0, 0, 1, 5);
-  gfx::Rect same_width_no_edge(0, 0, 4, 1);
-
-  EXPECT_FALSE(r.SharesEdgeWith(same_height_no_edge));
-  EXPECT_FALSE(r.SharesEdgeWith(same_width_no_edge));
-
-  gfx::Rect just_above_no_edge(2, 1, 5, 2);  // too wide
-  gfx::Rect just_below_no_edge(2, 8, 3, 2);  // too narrow
-  gfx::Rect just_left_no_edge(0, 3, 2, 6);   // too tall
-  gfx::Rect just_right_no_edge(6, 3, 2, 4);  // too short
-
-  EXPECT_FALSE(r.SharesEdgeWith(just_above_no_edge));
-  EXPECT_FALSE(r.SharesEdgeWith(just_below_no_edge));
-  EXPECT_FALSE(r.SharesEdgeWith(just_left_no_edge));
-  EXPECT_FALSE(r.SharesEdgeWith(just_right_no_edge));
-}