ui/gfx/geometry/rect_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <limits>
   6
   7 #include "base/basictypes.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "ui/gfx/geometry/rect.h"
  10 #include "ui/gfx/geometry/rect_conversions.h"
  11
  12 #if defined(OS_WIN)
  13 #include <windows.h>
  14 #endif
  15
  16 namespace gfx {
  17
  18 TEST(RectTest, Contains) {
  19   static const struct ContainsCase {
  20     int rect_x;
  21     int rect_y;
  22     int rect_width;
  23     int rect_height;
  24     int point_x;
  25     int point_y;
  26     bool contained;
  27   } contains_cases[] = {
  28     {0, 0, 10, 10, 0, 0, true},
  29     {0, 0, 10, 10, 5, 5, true},
  30     {0, 0, 10, 10, 9, 9, true},
  31     {0, 0, 10, 10, 5, 10, false},
  32     {0, 0, 10, 10, 10, 5, false},
  33     {0, 0, 10, 10, -1, -1, false},
  34     {0, 0, 10, 10, 50, 50, false},
  35   #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
  36     {0, 0, -10, -10, 0, 0, false},
  37   #endif
  38   };
  39   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(contains_cases); ++i) {
  40     const ContainsCase& value = contains_cases[i];
  41     Rect rect(value.rect_x, value.rect_y, value.rect_width, value.rect_height);
  42     EXPECT_EQ(value.contained, rect.Contains(value.point_x, value.point_y));
  43   }
  44 }
  45
  46 TEST(RectTest, Intersects) {
  47   static const struct {
  48     int x1;  // rect 1
  49     int y1;
  50     int w1;
  51     int h1;
  52     int x2;  // rect 2
  53     int y2;
  54     int w2;
  55     int h2;
  56     bool intersects;
  57   } tests[] = {
  58     { 0, 0, 0, 0, 0, 0, 0, 0, false },
  59     { 0, 0, 0, 0, -10, -10, 20, 20, false },
  60     { -10, 0, 0, 20, 0, -10, 20, 0, false },
  61     { 0, 0, 10, 10, 0, 0, 10, 10, true },
  62     { 0, 0, 10, 10, 10, 10, 10, 10, false },
  63     { 10, 10, 10, 10, 0, 0, 10, 10, false },
  64     { 10, 10, 10, 10, 5, 5, 10, 10, true },
  65     { 10, 10, 10, 10, 15, 15, 10, 10, true },
  66     { 10, 10, 10, 10, 20, 15, 10, 10, false },
  67     { 10, 10, 10, 10, 21, 15, 10, 10, false }
  68   };
  69   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
  70     Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
  71     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
  72     EXPECT_EQ(tests[i].intersects, r1.Intersects(r2));
  73     EXPECT_EQ(tests[i].intersects, r2.Intersects(r1));
  74   }
  75 }
  76
  77 TEST(RectTest, Intersect) {
  78   static const struct {
  79     int x1;  // rect 1
  80     int y1;
  81     int w1;
  82     int h1;
  83     int x2;  // rect 2
  84     int y2;
  85     int w2;
  86     int h2;
  87     int x3;  // rect 3: the union of rects 1 and 2
  88     int y3;
  89     int w3;
  90     int h3;
  91   } tests[] = {
  92     { 0, 0, 0, 0,   // zeros
  93       0, 0, 0, 0,
  94       0, 0, 0, 0 },
  95     { 0, 0, 4, 4,   // equal
  96       0, 0, 4, 4,
  97       0, 0, 4, 4 },
  98     { 0, 0, 4, 4,   // neighboring
  99       4, 4, 4, 4,
 100       0, 0, 0, 0 },
 101     { 0, 0, 4, 4,   // overlapping corners
 102       2, 2, 4, 4,
 103       2, 2, 2, 2 },
 104     { 0, 0, 4, 4,   // T junction
 105       3, 1, 4, 2,
 106       3, 1, 1, 2 },
 107     { 3, 0, 2, 2,   // gap
 108       0, 0, 2, 2,
 109       0, 0, 0, 0 }
 110   };
 111   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 112     Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 113     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 114     Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
 115     Rect ir = IntersectRects(r1, r2);
 116     EXPECT_EQ(r3.x(), ir.x());
 117     EXPECT_EQ(r3.y(), ir.y());
 118     EXPECT_EQ(r3.width(), ir.width());
 119     EXPECT_EQ(r3.height(), ir.height());
 120   }
 121 }
 122
 123 TEST(RectTest, Union) {
 124   static const struct Test {
 125     int x1;  // rect 1
 126     int y1;
 127     int w1;
 128     int h1;
 129     int x2;  // rect 2
 130     int y2;
 131     int w2;
 132     int h2;
 133     int x3;  // rect 3: the union of rects 1 and 2
 134     int y3;
 135     int w3;
 136     int h3;
 137   } tests[] = {
 138     { 0, 0, 0, 0,
 139       0, 0, 0, 0,
 140       0, 0, 0, 0 },
 141     { 0, 0, 4, 4,
 142       0, 0, 4, 4,
 143       0, 0, 4, 4 },
 144     { 0, 0, 4, 4,
 145       4, 4, 4, 4,
 146       0, 0, 8, 8 },
 147     { 0, 0, 4, 4,
 148       0, 5, 4, 4,
 149       0, 0, 4, 9 },
 150     { 0, 0, 2, 2,
 151       3, 3, 2, 2,
 152       0, 0, 5, 5 },
 153     { 3, 3, 2, 2,   // reverse r1 and r2 from previous test
 154       0, 0, 2, 2,
 155       0, 0, 5, 5 },
 156     { 0, 0, 0, 0,   // union with empty rect
 157       2, 2, 2, 2,
 158       2, 2, 2, 2 }
 159   };
 160   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 161     Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 162     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 163     Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
 164     Rect u = UnionRects(r1, r2);
 165     EXPECT_EQ(r3.x(), u.x());
 166     EXPECT_EQ(r3.y(), u.y());
 167     EXPECT_EQ(r3.width(), u.width());
 168     EXPECT_EQ(r3.height(), u.height());
 169   }
 170 }
 171
 172 TEST(RectTest, Equals) {
 173   ASSERT_TRUE(Rect(0, 0, 0, 0) == Rect(0, 0, 0, 0));
 174   ASSERT_TRUE(Rect(1, 2, 3, 4) == Rect(1, 2, 3, 4));
 175   ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 0, 0, 1));
 176   ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 0, 1, 0));
 177   ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 1, 0, 0));
 178   ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(1, 0, 0, 0));
 179 }
 180
 181 TEST(RectTest, AdjustToFit) {
 182   static const struct Test {
 183     int x1;  // source
 184     int y1;
 185     int w1;
 186     int h1;
 187     int x2;  // target
 188     int y2;
 189     int w2;
 190     int h2;
 191     int x3;  // rect 3: results of invoking AdjustToFit
 192     int y3;
 193     int w3;
 194     int h3;
 195   } tests[] = {
 196     { 0, 0, 2, 2,
 197       0, 0, 2, 2,
 198       0, 0, 2, 2 },
 199     { 2, 2, 3, 3,
 200       0, 0, 4, 4,
 201       1, 1, 3, 3 },
 202     { -1, -1, 5, 5,
 203       0, 0, 4, 4,
 204       0, 0, 4, 4 },
 205     { 2, 2, 4, 4,
 206       0, 0, 3, 3,
 207       0, 0, 3, 3 },
 208     { 2, 2, 1, 1,
 209       0, 0, 3, 3,
 210       2, 2, 1, 1 }
 211   };
 212   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 213     Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 214     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 215     Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
 216     Rect u = r1;
 217     u.AdjustToFit(r2);
 218     EXPECT_EQ(r3.x(), u.x());
 219     EXPECT_EQ(r3.y(), u.y());
 220     EXPECT_EQ(r3.width(), u.width());
 221     EXPECT_EQ(r3.height(), u.height());
 222   }
 223 }
 224
 225 TEST(RectTest, Subtract) {
 226   Rect result;
 227
 228   // Matching
 229   result = Rect(10, 10, 20, 20);
 230   result.Subtract(Rect(10, 10, 20, 20));
 231   EXPECT_EQ(Rect(0, 0, 0, 0).ToString(), result.ToString());
 232
 233   // Contains
 234   result = Rect(10, 10, 20, 20);
 235   result.Subtract(Rect(5, 5, 30, 30));
 236   EXPECT_EQ(Rect(0, 0, 0, 0).ToString(), result.ToString());
 237
 238   // No intersection
 239   result = Rect(10, 10, 20, 20);
 240   result.Subtract(Rect(30, 30, 30, 30));
 241   EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
 242
 243   // Not a complete intersection in either direction
 244   result = Rect(10, 10, 20, 20);
 245   result.Subtract(Rect(15, 15, 20, 20));
 246   EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
 247
 248   // Complete intersection in the x-direction, top edge is fully covered.
 249   result = Rect(10, 10, 20, 20);
 250   result.Subtract(Rect(10, 15, 20, 20));
 251   EXPECT_EQ(Rect(10, 10, 20, 5).ToString(), result.ToString());
 252
 253   // Complete intersection in the x-direction, top edge is fully covered.
 254   result = Rect(10, 10, 20, 20);
 255   result.Subtract(Rect(5, 15, 30, 20));
 256   EXPECT_EQ(Rect(10, 10, 20, 5).ToString(), result.ToString());
 257
 258   // Complete intersection in the x-direction, bottom edge is fully covered.
 259   result = Rect(10, 10, 20, 20);
 260   result.Subtract(Rect(5, 5, 30, 20));
 261   EXPECT_EQ(Rect(10, 25, 20, 5).ToString(), result.ToString());
 262
 263   // Complete intersection in the x-direction, none of the edges is fully
 264   // covered.
 265   result = Rect(10, 10, 20, 20);
 266   result.Subtract(Rect(5, 15, 30, 1));
 267   EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
 268
 269   // Complete intersection in the y-direction, left edge is fully covered.
 270   result = Rect(10, 10, 20, 20);
 271   result.Subtract(Rect(10, 10, 10, 30));
 272   EXPECT_EQ(Rect(20, 10, 10, 20).ToString(), result.ToString());
 273
 274   // Complete intersection in the y-direction, left edge is fully covered.
 275   result = Rect(10, 10, 20, 20);
 276   result.Subtract(Rect(5, 5, 20, 30));
 277   EXPECT_EQ(Rect(25, 10, 5, 20).ToString(), result.ToString());
 278
 279   // Complete intersection in the y-direction, right edge is fully covered.
 280   result = Rect(10, 10, 20, 20);
 281   result.Subtract(Rect(20, 5, 20, 30));
 282   EXPECT_EQ(Rect(10, 10, 10, 20).ToString(), result.ToString());
 283
 284   // Complete intersection in the y-direction, none of the edges is fully
 285   // covered.
 286   result = Rect(10, 10, 20, 20);
 287   result.Subtract(Rect(15, 5, 1, 30));
 288   EXPECT_EQ(Rect(10, 10, 20, 20).ToString(), result.ToString());
 289 }
 290
 291 TEST(RectTest, IsEmpty) {
 292   EXPECT_TRUE(Rect(0, 0, 0, 0).IsEmpty());
 293   EXPECT_TRUE(Rect(0, 0, 0, 0).size().IsEmpty());
 294   EXPECT_TRUE(Rect(0, 0, 10, 0).IsEmpty());
 295   EXPECT_TRUE(Rect(0, 0, 10, 0).size().IsEmpty());
 296   EXPECT_TRUE(Rect(0, 0, 0, 10).IsEmpty());
 297   EXPECT_TRUE(Rect(0, 0, 0, 10).size().IsEmpty());
 298   EXPECT_FALSE(Rect(0, 0, 10, 10).IsEmpty());
 299   EXPECT_FALSE(Rect(0, 0, 10, 10).size().IsEmpty());
 300 }
 301
 302 TEST(RectTest, SplitVertically) {
 303   Rect left_half, right_half;
 304
 305   // Splitting when origin is (0, 0).
 306   Rect(0, 0, 20, 20).SplitVertically(&left_half, &right_half);
 307   EXPECT_TRUE(left_half == Rect(0, 0, 10, 20));
 308   EXPECT_TRUE(right_half == Rect(10, 0, 10, 20));
 309
 310   // Splitting when origin is arbitrary.
 311   Rect(10, 10, 20, 10).SplitVertically(&left_half, &right_half);
 312   EXPECT_TRUE(left_half == Rect(10, 10, 10, 10));
 313   EXPECT_TRUE(right_half == Rect(20, 10, 10, 10));
 314
 315   // Splitting a rectangle of zero width.
 316   Rect(10, 10, 0, 10).SplitVertically(&left_half, &right_half);
 317   EXPECT_TRUE(left_half == Rect(10, 10, 0, 10));
 318   EXPECT_TRUE(right_half == Rect(10, 10, 0, 10));
 319
 320   // Splitting a rectangle of odd width.
 321   Rect(10, 10, 5, 10).SplitVertically(&left_half, &right_half);
 322   EXPECT_TRUE(left_half == Rect(10, 10, 2, 10));
 323   EXPECT_TRUE(right_half == Rect(12, 10, 3, 10));
 324 }
 325
 326 TEST(RectTest, CenterPoint) {
 327   Point center;
 328
 329   // When origin is (0, 0).
 330   center = Rect(0, 0, 20, 20).CenterPoint();
 331   EXPECT_TRUE(center == Point(10, 10));
 332
 333   // When origin is even.
 334   center = Rect(10, 10, 20, 20).CenterPoint();
 335   EXPECT_TRUE(center == Point(20, 20));
 336
 337   // When origin is odd.
 338   center = Rect(11, 11, 20, 20).CenterPoint();
 339   EXPECT_TRUE(center == Point(21, 21));
 340
 341   // When 0 width or height.
 342   center = Rect(10, 10, 0, 20).CenterPoint();
 343   EXPECT_TRUE(center == Point(10, 20));
 344   center = Rect(10, 10, 20, 0).CenterPoint();
 345   EXPECT_TRUE(center == Point(20, 10));
 346
 347   // When an odd size.
 348   center = Rect(10, 10, 21, 21).CenterPoint();
 349   EXPECT_TRUE(center == Point(20, 20));
 350
 351   // When an odd size and position.
 352   center = Rect(11, 11, 21, 21).CenterPoint();
 353   EXPECT_TRUE(center == Point(21, 21));
 354 }
 355
 356 TEST(RectTest, CenterPointF) {
 357   PointF center;
 358
 359   // When origin is (0, 0).
 360   center = RectF(0, 0, 20, 20).CenterPoint();
 361   EXPECT_TRUE(center == PointF(10, 10));
 362
 363   // When origin is even.
 364   center = RectF(10, 10, 20, 20).CenterPoint();
 365   EXPECT_TRUE(center == PointF(20, 20));
 366
 367   // When origin is odd.
 368   center = RectF(11, 11, 20, 20).CenterPoint();
 369   EXPECT_TRUE(center == PointF(21, 21));
 370
 371   // When 0 width or height.
 372   center = RectF(10, 10, 0, 20).CenterPoint();
 373   EXPECT_TRUE(center == PointF(10, 20));
 374   center = RectF(10, 10, 20, 0).CenterPoint();
 375   EXPECT_TRUE(center == PointF(20, 10));
 376
 377   // When an odd size.
 378   center = RectF(10, 10, 21, 21).CenterPoint();
 379   EXPECT_TRUE(center == PointF(20.5f, 20.5f));
 380
 381   // When an odd size and position.
 382   center = RectF(11, 11, 21, 21).CenterPoint();
 383   EXPECT_TRUE(center == PointF(21.5f, 21.5f));
 384 }
 385
 386 TEST(RectTest, SharesEdgeWith) {
 387   Rect r(2, 3, 4, 5);
 388
 389   // Must be non-overlapping
 390   EXPECT_FALSE(r.SharesEdgeWith(r));
 391
 392   Rect just_above(2, 1, 4, 2);
 393   Rect just_below(2, 8, 4, 2);
 394   Rect just_left(0, 3, 2, 5);
 395   Rect just_right(6, 3, 2, 5);
 396
 397   EXPECT_TRUE(r.SharesEdgeWith(just_above));
 398   EXPECT_TRUE(r.SharesEdgeWith(just_below));
 399   EXPECT_TRUE(r.SharesEdgeWith(just_left));
 400   EXPECT_TRUE(r.SharesEdgeWith(just_right));
 401
 402   // Wrong placement
 403   Rect same_height_no_edge(0, 0, 1, 5);
 404   Rect same_width_no_edge(0, 0, 4, 1);
 405
 406   EXPECT_FALSE(r.SharesEdgeWith(same_height_no_edge));
 407   EXPECT_FALSE(r.SharesEdgeWith(same_width_no_edge));
 408
 409   Rect just_above_no_edge(2, 1, 5, 2);  // too wide
 410   Rect just_below_no_edge(2, 8, 3, 2);  // too narrow
 411   Rect just_left_no_edge(0, 3, 2, 6);   // too tall
 412   Rect just_right_no_edge(6, 3, 2, 4);  // too short
 413
 414   EXPECT_FALSE(r.SharesEdgeWith(just_above_no_edge));
 415   EXPECT_FALSE(r.SharesEdgeWith(just_below_no_edge));
 416   EXPECT_FALSE(r.SharesEdgeWith(just_left_no_edge));
 417   EXPECT_FALSE(r.SharesEdgeWith(just_right_no_edge));
 418 }
 419
 420 // Similar to EXPECT_FLOAT_EQ, but lets NaN equal NaN
 421 #define EXPECT_FLOAT_AND_NAN_EQ(a, b) \
 422   { if (a == a || b == b) { EXPECT_FLOAT_EQ(a, b); } }
 423
 424 TEST(RectTest, ScaleRect) {
 425   static const struct Test {
 426     int x1;  // source
 427     int y1;
 428     int w1;
 429     int h1;
 430     float scale;
 431     float x2;  // target
 432     float y2;
 433     float w2;
 434     float h2;
 435   } tests[] = {
 436     { 3, 3, 3, 3,
 437       1.5f,
 438       4.5f, 4.5f, 4.5f, 4.5f },
 439     { 3, 3, 3, 3,
 440       0.0f,
 441       0.0f, 0.0f, 0.0f, 0.0f },
 442     { 3, 3, 3, 3,
 443       std::numeric_limits<float>::quiet_NaN(),
 444       std::numeric_limits<float>::quiet_NaN(),
 445       std::numeric_limits<float>::quiet_NaN(),
 446       std::numeric_limits<float>::quiet_NaN(),
 447       std::numeric_limits<float>::quiet_NaN() },
 448     { 3, 3, 3, 3,
 449       std::numeric_limits<float>::max(),
 450       std::numeric_limits<float>::max(),
 451       std::numeric_limits<float>::max(),
 452       std::numeric_limits<float>::max(),
 453       std::numeric_limits<float>::max() }
 454   };
 455
 456   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 457     Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 458     RectF r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 459
 460     RectF scaled = ScaleRect(r1, tests[i].scale);
 461     EXPECT_FLOAT_AND_NAN_EQ(r2.x(), scaled.x());
 462     EXPECT_FLOAT_AND_NAN_EQ(r2.y(), scaled.y());
 463     EXPECT_FLOAT_AND_NAN_EQ(r2.width(), scaled.width());
 464     EXPECT_FLOAT_AND_NAN_EQ(r2.height(), scaled.height());
 465   }
 466 }
 467
 468 TEST(RectTest, ToEnclosedRect) {
 469   static const struct Test {
 470     float x1; // source
 471     float y1;
 472     float w1;
 473     float h1;
 474     int x2; // target
 475     int y2;
 476     int w2;
 477     int h2;
 478   } tests [] = {
 479     { 0.0f, 0.0f, 0.0f, 0.0f,
 480       0, 0, 0, 0 },
 481     { -1.5f, -1.5f, 3.0f, 3.0f,
 482       -1, -1, 2, 2 },
 483     { -1.5f, -1.5f, 3.5f, 3.5f,
 484       -1, -1, 3, 3 },
 485     { std::numeric_limits<float>::max(),
 486       std::numeric_limits<float>::max(),
 487       2.0f, 2.0f,
 488       std::numeric_limits<int>::max(),
 489       std::numeric_limits<int>::max(),
 490       0, 0 },
 491     { 0.0f, 0.0f,
 492       std::numeric_limits<float>::max(),
 493       std::numeric_limits<float>::max(),
 494       0, 0,
 495       std::numeric_limits<int>::max(),
 496       std::numeric_limits<int>::max() },
 497     { 20000.5f, 20000.5f, 0.5f, 0.5f,
 498       20001, 20001, 0, 0 },
 499     { std::numeric_limits<float>::quiet_NaN(),
 500       std::numeric_limits<float>::quiet_NaN(),
 501       std::numeric_limits<float>::quiet_NaN(),
 502       std::numeric_limits<float>::quiet_NaN(),
 503       0, 0, 0, 0 }
 504   };
 505
 506   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 507     RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 508     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 509
 510     Rect enclosed = ToEnclosedRect(r1);
 511     EXPECT_FLOAT_AND_NAN_EQ(r2.x(), enclosed.x());
 512     EXPECT_FLOAT_AND_NAN_EQ(r2.y(), enclosed.y());
 513     EXPECT_FLOAT_AND_NAN_EQ(r2.width(), enclosed.width());
 514     EXPECT_FLOAT_AND_NAN_EQ(r2.height(), enclosed.height());
 515   }
 516 }
 517
 518 TEST(RectTest, ToEnclosingRect) {
 519   static const struct Test {
 520     float x1; // source
 521     float y1;
 522     float w1;
 523     float h1;
 524     int x2; // target
 525     int y2;
 526     int w2;
 527     int h2;
 528   } tests [] = {
 529     { 0.0f, 0.0f, 0.0f, 0.0f,
 530       0, 0, 0, 0 },
 531     { 5.5f, 5.5f, 0.0f, 0.0f,
 532       5, 5, 0, 0 },
 533     { -1.5f, -1.5f, 3.0f, 3.0f,
 534       -2, -2, 4, 4 },
 535     { -1.5f, -1.5f, 3.5f, 3.5f,
 536       -2, -2, 4, 4 },
 537     { std::numeric_limits<float>::max(),
 538       std::numeric_limits<float>::max(),
 539       2.0f, 2.0f,
 540       std::numeric_limits<int>::max(),
 541       std::numeric_limits<int>::max(),
 542       0, 0 },
 543     { 0.0f, 0.0f,
 544       std::numeric_limits<float>::max(),
 545       std::numeric_limits<float>::max(),
 546       0, 0,
 547       std::numeric_limits<int>::max(),
 548       std::numeric_limits<int>::max() },
 549     { 20000.5f, 20000.5f, 0.5f, 0.5f,
 550       20000, 20000, 1, 1 },
 551     { std::numeric_limits<float>::quiet_NaN(),
 552       std::numeric_limits<float>::quiet_NaN(),
 553       std::numeric_limits<float>::quiet_NaN(),
 554       std::numeric_limits<float>::quiet_NaN(),
 555       0, 0, 0, 0 }
 556   };
 557
 558   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 559     RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 560     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 561
 562     Rect enclosed = ToEnclosingRect(r1);
 563     EXPECT_FLOAT_AND_NAN_EQ(r2.x(), enclosed.x());
 564     EXPECT_FLOAT_AND_NAN_EQ(r2.y(), enclosed.y());
 565     EXPECT_FLOAT_AND_NAN_EQ(r2.width(), enclosed.width());
 566     EXPECT_FLOAT_AND_NAN_EQ(r2.height(), enclosed.height());
 567   }
 568 }
 569
 570 TEST(RectTest, ToNearestRect) {
 571   Rect rect;
 572   EXPECT_EQ(rect.ToString(), ToNearestRect(RectF(rect)).ToString());
 573
 574   rect = Rect(-1, -1, 3, 3);
 575   EXPECT_EQ(rect.ToString(), ToNearestRect(RectF(rect)).ToString());
 576
 577   RectF rectf(-1.00001f, -0.999999f, 3.0000001f, 2.999999f);
 578   EXPECT_EQ(rect.ToString(), ToNearestRect(rectf).ToString());
 579 }
 580
 581 TEST(RectTest, ToFlooredRect) {
 582   static const struct Test {
 583     float x1; // source
 584     float y1;
 585     float w1;
 586     float h1;
 587     int x2; // target
 588     int y2;
 589     int w2;
 590     int h2;
 591   } tests [] = {
 592     { 0.0f, 0.0f, 0.0f, 0.0f,
 593       0, 0, 0, 0 },
 594     { -1.5f, -1.5f, 3.0f, 3.0f,
 595       -2, -2, 3, 3 },
 596     { -1.5f, -1.5f, 3.5f, 3.5f,
 597       -2, -2, 3, 3 },
 598     { 20000.5f, 20000.5f, 0.5f, 0.5f,
 599       20000, 20000, 0, 0 },
 600   };
 601
 602   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 603     RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
 604     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 605
 606     Rect floored = ToFlooredRectDeprecated(r1);
 607     EXPECT_FLOAT_EQ(r2.x(), floored.x());
 608     EXPECT_FLOAT_EQ(r2.y(), floored.y());
 609     EXPECT_FLOAT_EQ(r2.width(), floored.width());
 610     EXPECT_FLOAT_EQ(r2.height(), floored.height());
 611   }
 612 }
 613
 614 TEST(RectTest, ScaleToEnclosedRect) {
 615   static const struct Test {
 616     Rect input_rect;
 617     float input_scale;
 618     Rect expected_rect;
 619   } tests[] = {
 620     {
 621       Rect(),
 622       5.f,
 623       Rect(),
 624     }, {
 625       Rect(1, 1, 1, 1),
 626       5.f,
 627       Rect(5, 5, 5, 5),
 628     }, {
 629       Rect(-1, -1, 0, 0),
 630       5.f,
 631       Rect(-5, -5, 0, 0),
 632     }, {
 633       Rect(1, -1, 0, 1),
 634       5.f,
 635       Rect(5, -5, 0, 5),
 636     }, {
 637       Rect(-1, 1, 1, 0),
 638       5.f,
 639       Rect(-5, 5, 5, 0),
 640     }, {
 641       Rect(1, 2, 3, 4),
 642       1.5f,
 643       Rect(2, 3, 4, 6),
 644     }, {
 645       Rect(-1, -2, 0, 0),
 646       1.5f,
 647       Rect(-1, -3, 0, 0),
 648     }
 649   };
 650
 651   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 652     Rect result = ScaleToEnclosedRect(tests[i].input_rect,
 653                                       tests[i].input_scale);
 654     EXPECT_EQ(tests[i].expected_rect.ToString(), result.ToString());
 655   }
 656 }
 657
 658 TEST(RectTest, ScaleToEnclosingRect) {
 659   static const struct Test {
 660     Rect input_rect;
 661     float input_scale;
 662     Rect expected_rect;
 663   } tests[] = {
 664     {
 665       Rect(),
 666       5.f,
 667       Rect(),
 668     }, {
 669       Rect(1, 1, 1, 1),
 670       5.f,
 671       Rect(5, 5, 5, 5),
 672     }, {
 673       Rect(-1, -1, 0, 0),
 674       5.f,
 675       Rect(-5, -5, 0, 0),
 676     }, {
 677       Rect(1, -1, 0, 1),
 678       5.f,
 679       Rect(5, -5, 0, 5),
 680     }, {
 681       Rect(-1, 1, 1, 0),
 682       5.f,
 683       Rect(-5, 5, 5, 0),
 684     }, {
 685       Rect(1, 2, 3, 4),
 686       1.5f,
 687       Rect(1, 3, 5, 6),
 688     }, {
 689       Rect(-1, -2, 0, 0),
 690       1.5f,
 691       Rect(-2, -3, 0, 0),
 692     }
 693   };
 694
 695   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 696     Rect result = ScaleToEnclosingRect(tests[i].input_rect,
 697                                        tests[i].input_scale);
 698     EXPECT_EQ(tests[i].expected_rect.ToString(), result.ToString());
 699   }
 700 }
 701
 702 #if defined(OS_WIN)
 703 TEST(RectTest, ConstructAndAssign) {
 704   const RECT rect_1 = { 0, 0, 10, 10 };
 705   const RECT rect_2 = { 0, 0, -10, -10 };
 706   Rect test1(rect_1);
 707   Rect test2(rect_2);
 708 }
 709 #endif
 710
 711 TEST(RectTest, ToRectF) {
 712   // Check that implicit conversion from integer to float compiles.
 713   Rect a(10, 20, 30, 40);
 714   RectF b(10, 20, 30, 40);
 715
 716   RectF intersect = IntersectRects(a, b);
 717   EXPECT_EQ(b.ToString(), intersect.ToString());
 718
 719   EXPECT_EQ(a, b);
 720   EXPECT_EQ(b, a);
 721 }
 722
 723 TEST(RectTest, BoundingRect) {
 724   struct {
 725     Point a;
 726     Point b;
 727     Rect expected;
 728   } int_tests[] = {
 729     // If point B dominates A, then A should be the origin.
 730     { Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0) },
 731     { Point(4, 6), Point(8, 6), Rect(4, 6, 4, 0) },
 732     { Point(4, 6), Point(4, 9), Rect(4, 6, 0, 3) },
 733     { Point(4, 6), Point(8, 9), Rect(4, 6, 4, 3) },
 734     // If point A dominates B, then B should be the origin.
 735     { Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0) },
 736     { Point(8, 6), Point(4, 6), Rect(4, 6, 4, 0) },
 737     { Point(4, 9), Point(4, 6), Rect(4, 6, 0, 3) },
 738     { Point(8, 9), Point(4, 6), Rect(4, 6, 4, 3) },
 739     // If neither point dominates, then the origin is a combination of the two.
 740     { Point(4, 6), Point(6, 4), Rect(4, 4, 2, 2) },
 741     { Point(-4, -6), Point(-6, -4), Rect(-6, -6, 2, 2) },
 742     { Point(-4, 6), Point(6, -4), Rect(-4, -4, 10, 10) },
 743   };
 744
 745   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(int_tests); ++i) {
 746     Rect actual = BoundingRect(int_tests[i].a, int_tests[i].b);
 747     EXPECT_EQ(int_tests[i].expected.ToString(), actual.ToString());
 748   }
 749
 750   struct {
 751     PointF a;
 752     PointF b;
 753     RectF expected;
 754   } float_tests[] = {
 755     // If point B dominates A, then A should be the origin.
 756     { PointF(4.2f, 6.8f), PointF(4.2f, 6.8f),
 757       RectF(4.2f, 6.8f, 0, 0) },
 758     { PointF(4.2f, 6.8f), PointF(8.5f, 6.8f),
 759       RectF(4.2f, 6.8f, 4.3f, 0) },
 760     { PointF(4.2f, 6.8f), PointF(4.2f, 9.3f),
 761       RectF(4.2f, 6.8f, 0, 2.5f) },
 762     { PointF(4.2f, 6.8f), PointF(8.5f, 9.3f),
 763       RectF(4.2f, 6.8f, 4.3f, 2.5f) },
 764     // If point A dominates B, then B should be the origin.
 765     { PointF(4.2f, 6.8f), PointF(4.2f, 6.8f),
 766       RectF(4.2f, 6.8f, 0, 0) },
 767     { PointF(8.5f, 6.8f), PointF(4.2f, 6.8f),
 768       RectF(4.2f, 6.8f, 4.3f, 0) },
 769     { PointF(4.2f, 9.3f), PointF(4.2f, 6.8f),
 770       RectF(4.2f, 6.8f, 0, 2.5f) },
 771     { PointF(8.5f, 9.3f), PointF(4.2f, 6.8f),
 772       RectF(4.2f, 6.8f, 4.3f, 2.5f) },
 773     // If neither point dominates, then the origin is a combination of the two.
 774     { PointF(4.2f, 6.8f), PointF(6.8f, 4.2f),
 775       RectF(4.2f, 4.2f, 2.6f, 2.6f) },
 776     { PointF(-4.2f, -6.8f), PointF(-6.8f, -4.2f),
 777       RectF(-6.8f, -6.8f, 2.6f, 2.6f) },
 778     { PointF(-4.2f, 6.8f), PointF(6.8f, -4.2f),
 779       RectF(-4.2f, -4.2f, 11.0f, 11.0f) }
 780   };
 781
 782   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(float_tests); ++i) {
 783     RectF actual = BoundingRect(float_tests[i].a, float_tests[i].b);
 784     EXPECT_EQ(float_tests[i].expected.ToString(), actual.ToString());
 785   }
 786 }
 787
 788 TEST(RectTest, IsExpressibleAsRect) {
 789   EXPECT_TRUE(RectF().IsExpressibleAsRect());
 790
 791   float min = std::numeric_limits<int>::min();
 792   float max = std::numeric_limits<int>::max();
 793   float infinity = std::numeric_limits<float>::infinity();
 794
 795   EXPECT_TRUE(RectF(
 796       min + 200, min + 200, max - 200, max - 200).IsExpressibleAsRect());
 797   EXPECT_FALSE(RectF(
 798       min - 200, min + 200, max + 200, max + 200).IsExpressibleAsRect());
 799   EXPECT_FALSE(RectF(
 800       min + 200 , min - 200, max + 200, max + 200).IsExpressibleAsRect());
 801   EXPECT_FALSE(RectF(
 802       min + 200, min + 200, max + 200, max - 200).IsExpressibleAsRect());
 803   EXPECT_FALSE(RectF(
 804       min + 200, min + 200, max - 200, max + 200).IsExpressibleAsRect());
 805
 806   EXPECT_TRUE(RectF(0, 0, max - 200, max - 200).IsExpressibleAsRect());
 807   EXPECT_FALSE(RectF(200, 0, max + 200, max - 200).IsExpressibleAsRect());
 808   EXPECT_FALSE(RectF(0, 200, max - 200, max + 200).IsExpressibleAsRect());
 809   EXPECT_FALSE(RectF(0, 0, max + 200, max - 200).IsExpressibleAsRect());
 810   EXPECT_FALSE(RectF(0, 0, max - 200, max + 200).IsExpressibleAsRect());
 811
 812   EXPECT_FALSE(RectF(infinity, 0, 1, 1).IsExpressibleAsRect());
 813   EXPECT_FALSE(RectF(0, infinity, 1, 1).IsExpressibleAsRect());
 814   EXPECT_FALSE(RectF(0, 0, infinity, 1).IsExpressibleAsRect());
 815   EXPECT_FALSE(RectF(0, 0, 1, infinity).IsExpressibleAsRect());
 816 }
 817
 818 TEST(RectTest, Offset) {
 819   Rect i(1, 2, 3, 4);
 820
 821   EXPECT_EQ(Rect(2, 1, 3, 4).ToString(), (i + Vector2d(1, -1)).ToString());
 822   EXPECT_EQ(Rect(2, 1, 3, 4).ToString(), (Vector2d(1, -1) + i).ToString());
 823   i += Vector2d(1, -1);
 824   EXPECT_EQ(Rect(2, 1, 3, 4).ToString(), i.ToString());
 825   EXPECT_EQ(Rect(1, 2, 3, 4).ToString(), (i - Vector2d(1, -1)).ToString());
 826   i -= Vector2d(1, -1);
 827   EXPECT_EQ(Rect(1, 2, 3, 4).ToString(), i.ToString());
 828
 829   RectF f(1.1f, 2.2f, 3.3f, 4.4f);
 830   EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f).ToString(),
 831             (f + Vector2dF(1.1f, -1.1f)).ToString());
 832   EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f).ToString(),
 833             (Vector2dF(1.1f, -1.1f) + f).ToString());
 834   f += Vector2dF(1.1f, -1.1f);
 835   EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f).ToString(), f.ToString());
 836   EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f).ToString(),
 837             (f - Vector2dF(1.1f, -1.1f)).ToString());
 838   f -= Vector2dF(1.1f, -1.1f);
 839   EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f).ToString(), f.ToString());
 840 }
 841
 842 TEST(RectTest, Corners) {
 843   Rect i(1, 2, 3, 4);
 844   RectF f(1.1f, 2.1f, 3.1f, 4.1f);
 845
 846   EXPECT_EQ(Point(1, 2).ToString(), i.origin().ToString());
 847   EXPECT_EQ(Point(4, 2).ToString(), i.top_right().ToString());
 848   EXPECT_EQ(Point(1, 6).ToString(), i.bottom_left().ToString());
 849   EXPECT_EQ(Point(4, 6).ToString(), i.bottom_right().ToString());
 850
 851   EXPECT_EQ(PointF(1.1f, 2.1f).ToString(), f.origin().ToString());
 852   EXPECT_EQ(PointF(4.2f, 2.1f).ToString(), f.top_right().ToString());
 853   EXPECT_EQ(PointF(1.1f, 6.2f).ToString(), f.bottom_left().ToString());
 854   EXPECT_EQ(PointF(4.2f, 6.2f).ToString(), f.bottom_right().ToString());
 855 }
 856
 857 TEST(RectTest, ManhattanDistanceToPoint) {
 858   Rect i(1, 2, 3, 4);
 859   EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(1, 2)));
 860   EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(4, 6)));
 861   EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(2, 4)));
 862   EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(0, 0)));
 863   EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(2, 0)));
 864   EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 0)));
 865   EXPECT_EQ(1, i.ManhattanDistanceToPoint(Point(5, 4)));
 866   EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 8)));
 867   EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(3, 8)));
 868   EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(0, 7)));
 869   EXPECT_EQ(1, i.ManhattanDistanceToPoint(Point(0, 3)));
 870
 871   RectF f(1.1f, 2.1f, 3.1f, 4.1f);
 872   EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(1.1f, 2.1f)));
 873   EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(4.2f, 6.f)));
 874   EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(2.f, 4.f)));
 875   EXPECT_FLOAT_EQ(3.2f, f.ManhattanDistanceToPoint(PointF(0.f, 0.f)));
 876   EXPECT_FLOAT_EQ(2.1f, f.ManhattanDistanceToPoint(PointF(2.f, 0.f)));
 877   EXPECT_FLOAT_EQ(2.9f, f.ManhattanDistanceToPoint(PointF(5.f, 0.f)));
 878   EXPECT_FLOAT_EQ(.8f, f.ManhattanDistanceToPoint(PointF(5.f, 4.f)));
 879   EXPECT_FLOAT_EQ(2.6f, f.ManhattanDistanceToPoint(PointF(5.f, 8.f)));
 880   EXPECT_FLOAT_EQ(1.8f, f.ManhattanDistanceToPoint(PointF(3.f, 8.f)));
 881   EXPECT_FLOAT_EQ(1.9f, f.ManhattanDistanceToPoint(PointF(0.f, 7.f)));
 882   EXPECT_FLOAT_EQ(1.1f, f.ManhattanDistanceToPoint(PointF(0.f, 3.f)));
 883 }
 884
 885 TEST(RectTest, ManhattanInternalDistance) {
 886   Rect i(0, 0, 400, 400);
 887   EXPECT_EQ(0, i.ManhattanInternalDistance(gfx::Rect(-1, 0, 2, 1)));
 888   EXPECT_EQ(1, i.ManhattanInternalDistance(gfx::Rect(400, 0, 1, 400)));
 889   EXPECT_EQ(2, i.ManhattanInternalDistance(gfx::Rect(-100, -100, 100, 100)));
 890   EXPECT_EQ(2, i.ManhattanInternalDistance(gfx::Rect(-101, 100, 100, 100)));
 891   EXPECT_EQ(4, i.ManhattanInternalDistance(gfx::Rect(-101, -101, 100, 100)));
 892   EXPECT_EQ(435, i.ManhattanInternalDistance(gfx::Rect(630, 603, 100, 100)));
 893
 894   RectF f(0.0f, 0.0f, 400.0f, 400.0f);
 895   static const float kEpsilon = std::numeric_limits<float>::epsilon();
 896
 897   EXPECT_FLOAT_EQ(
 898       0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 2.0f, 1.0f)));
 899   EXPECT_FLOAT_EQ(
 900       kEpsilon,
 901       f.ManhattanInternalDistance(gfx::RectF(400.0f, 0.0f, 1.0f, 400.0f)));
 902   EXPECT_FLOAT_EQ(2.0f * kEpsilon,
 903                   f.ManhattanInternalDistance(
 904                       gfx::RectF(-100.0f, -100.0f, 100.0f, 100.0f)));
 905   EXPECT_FLOAT_EQ(
 906       1.0f + kEpsilon,
 907       f.ManhattanInternalDistance(gfx::RectF(-101.0f, 100.0f, 100.0f, 100.0f)));
 908   EXPECT_FLOAT_EQ(2.0f + 2.0f * kEpsilon,
 909                   f.ManhattanInternalDistance(
 910                       gfx::RectF(-101.0f, -101.0f, 100.0f, 100.0f)));
 911   EXPECT_FLOAT_EQ(
 912       433.0f + 2.0f * kEpsilon,
 913       f.ManhattanInternalDistance(gfx::RectF(630.0f, 603.0f, 100.0f, 100.0f)));
 914
 915   EXPECT_FLOAT_EQ(
 916       0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 1.1f, 1.0f)));
 917   EXPECT_FLOAT_EQ(
 918       0.1f + kEpsilon,
 919       f.ManhattanInternalDistance(gfx::RectF(-1.5f, 0.0f, 1.4f, 1.0f)));
 920   EXPECT_FLOAT_EQ(
 921       kEpsilon,
 922       f.ManhattanInternalDistance(gfx::RectF(-1.5f, 0.0f, 1.5f, 1.0f)));
 923 }
 924
 925 }  // namespace gfx