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