| // 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)); |
| } |