summaryrefslogtreecommitdiffstats
path: root/gfx/rect_unittest.cc
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/rect_unittest.cc')
-rw-r--r--gfx/rect_unittest.cc314
1 files changed, 314 insertions, 0 deletions
diff --git a/gfx/rect_unittest.cc b/gfx/rect_unittest.cc
new file mode 100644
index 0000000..f5b4d9b
--- /dev/null
+++ b/gfx/rect_unittest.cc
@@ -0,0 +1,314 @@
+// 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));
+}
generated by cgit v1.1 at 2025-02-13 19:16:14 +0000