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