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