1 /* 2 * Copyright 2012 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "SkMatrix.h" 9 #include "SkRRect.h" 10 #include "Test.h" 11 12 static void test_tricky_radii(skiatest::Reporter* reporter) { 13 { 14 // crbug.com/458522 15 SkRRect rr; 16 const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; 17 const SkScalar rad = 12814; 18 const SkVector vec[] = { { rad, rad }, { 0, rad }, { rad, rad }, { 0, rad } }; 19 rr.setRectRadii(bounds, vec); 20 } 21 22 { 23 // crbug.com//463920 24 SkRect r = SkRect::MakeLTRB(0, 0, 1009, 33554432.0); 25 SkVector radii[4] = { 26 { 13.0f, 8.0f }, { 170.0f, 2.0 }, { 256.0f, 33554432.0 }, { 110.0f, 5.0f } 27 }; 28 SkRRect rr; 29 rr.setRectRadii(r, radii); 30 31 REPORTER_ASSERT(reporter, (double) rr.radii(SkRRect::kUpperRight_Corner).fY + 32 (double) rr.radii(SkRRect::kLowerRight_Corner).fY <= 33 rr.height()); 34 } 35 } 36 37 static void test_empty_crbug_458524(skiatest::Reporter* reporter) { 38 SkRRect rr; 39 const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; 40 const SkScalar rad = 40; 41 rr.setRectXY(bounds, rad, rad); 42 43 SkRRect other; 44 SkMatrix matrix; 45 matrix.setScale(0, 1); 46 rr.transform(matrix, &other); 47 REPORTER_ASSERT(reporter, SkRRect::kEmpty_Type == other.getType()); 48 } 49 50 // Test that all the SkRRect entry points correctly handle un-sorted and 51 // zero-sized input rects 52 static void test_empty(skiatest::Reporter* reporter) { 53 static const SkRect oooRects[] = { // out of order 54 { 100, 0, 0, 100 }, // ooo horizontal 55 { 0, 100, 100, 0 }, // ooo vertical 56 { 100, 100, 0, 0 }, // ooo both 57 }; 58 59 static const SkRect emptyRects[] = { 60 { 100, 100, 100, 200 }, // empty horizontal 61 { 100, 100, 200, 100 }, // empty vertical 62 { 100, 100, 100, 100 }, // empty both 63 { 0, 0, 0, 0 } // setEmpty-empty 64 }; 65 66 static const SkVector radii[4] = { { 0, 1 }, { 2, 3 }, { 4, 5 }, { 6, 7 } }; 67 68 SkRRect r; 69 70 for (size_t i = 0; i < SK_ARRAY_COUNT(oooRects); ++i) { 71 r.setRect(oooRects[i]); 72 REPORTER_ASSERT(reporter, !r.isEmpty()); 73 74 r.setOval(oooRects[i]); 75 REPORTER_ASSERT(reporter, !r.isEmpty()); 76 77 r.setRectXY(oooRects[i], 1, 2); 78 REPORTER_ASSERT(reporter, !r.isEmpty()); 79 80 r.setNinePatch(oooRects[i], 0, 1, 2, 3); 81 REPORTER_ASSERT(reporter, !r.isEmpty()); 82 83 r.setRectRadii(oooRects[i], radii); 84 REPORTER_ASSERT(reporter, !r.isEmpty()); 85 } 86 87 for (size_t i = 0; i < SK_ARRAY_COUNT(emptyRects); ++i) { 88 r.setRect(emptyRects[i]); 89 REPORTER_ASSERT(reporter, r.isEmpty()); 90 91 r.setOval(emptyRects[i]); 92 REPORTER_ASSERT(reporter, r.isEmpty()); 93 94 r.setRectXY(emptyRects[i], 1, 2); 95 REPORTER_ASSERT(reporter, r.isEmpty()); 96 97 r.setNinePatch(emptyRects[i], 0, 1, 2, 3); 98 REPORTER_ASSERT(reporter, r.isEmpty()); 99 100 r.setRectRadii(emptyRects[i], radii); 101 REPORTER_ASSERT(reporter, r.isEmpty()); 102 } 103 } 104 105 static const SkScalar kWidth = 100.0f; 106 static const SkScalar kHeight = 100.0f; 107 108 static void test_inset(skiatest::Reporter* reporter) { 109 SkRRect rr, rr2; 110 SkRect r = { 0, 0, 100, 100 }; 111 112 rr.setRect(r); 113 rr.inset(-20, -20, &rr2); 114 REPORTER_ASSERT(reporter, rr2.isRect()); 115 116 rr.inset(20, 20, &rr2); 117 REPORTER_ASSERT(reporter, rr2.isRect()); 118 119 rr.inset(r.width()/2, r.height()/2, &rr2); 120 REPORTER_ASSERT(reporter, rr2.isEmpty()); 121 122 rr.setRectXY(r, 20, 20); 123 rr.inset(19, 19, &rr2); 124 REPORTER_ASSERT(reporter, rr2.isSimple()); 125 rr.inset(20, 20, &rr2); 126 REPORTER_ASSERT(reporter, rr2.isRect()); 127 } 128 129 130 static void test_9patch_rrect(skiatest::Reporter* reporter, 131 const SkRect& rect, 132 SkScalar l, SkScalar t, SkScalar r, SkScalar b, 133 bool checkRadii) { 134 SkRRect rr; 135 rr.setNinePatch(rect, l, t, r, b); 136 137 REPORTER_ASSERT(reporter, SkRRect::kNinePatch_Type == rr.type()); 138 REPORTER_ASSERT(reporter, rr.rect() == rect); 139 140 if (checkRadii) { 141 // This test doesn't hold if the radii will be rescaled by SkRRect 142 SkRect ninePatchRadii = { l, t, r, b }; 143 SkPoint rquad[4]; 144 ninePatchRadii.toQuad(rquad); 145 for (int i = 0; i < 4; ++i) { 146 REPORTER_ASSERT(reporter, rquad[i] == rr.radii((SkRRect::Corner) i)); 147 } 148 } 149 SkRRect rr2; // construct the same RR using the most general set function 150 SkVector radii[4] = { { l, t }, { r, t }, { r, b }, { l, b } }; 151 rr2.setRectRadii(rect, radii); 152 REPORTER_ASSERT(reporter, rr2 == rr && rr2.getType() == rr.getType()); 153 } 154 155 // Test out the basic API entry points 156 static void test_round_rect_basic(skiatest::Reporter* reporter) { 157 // Test out initialization methods 158 SkPoint zeroPt = { 0, 0 }; 159 SkRRect empty; 160 161 empty.setEmpty(); 162 163 REPORTER_ASSERT(reporter, SkRRect::kEmpty_Type == empty.type()); 164 REPORTER_ASSERT(reporter, empty.rect().isEmpty()); 165 166 for (int i = 0; i < 4; ++i) { 167 REPORTER_ASSERT(reporter, zeroPt == empty.radii((SkRRect::Corner) i)); 168 } 169 170 //---- 171 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); 172 173 SkRRect rr1; 174 rr1.setRect(rect); 175 176 REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr1.type()); 177 REPORTER_ASSERT(reporter, rr1.rect() == rect); 178 179 for (int i = 0; i < 4; ++i) { 180 REPORTER_ASSERT(reporter, zeroPt == rr1.radii((SkRRect::Corner) i)); 181 } 182 SkRRect rr1_2; // construct the same RR using the most general set function 183 SkVector rr1_2_radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; 184 rr1_2.setRectRadii(rect, rr1_2_radii); 185 REPORTER_ASSERT(reporter, rr1_2 == rr1 && rr1_2.getType() == rr1.getType()); 186 SkRRect rr1_3; // construct the same RR using the nine patch set function 187 rr1_3.setNinePatch(rect, 0, 0, 0, 0); 188 REPORTER_ASSERT(reporter, rr1_3 == rr1 && rr1_3.getType() == rr1.getType()); 189 190 //---- 191 SkPoint halfPoint = { SkScalarHalf(kWidth), SkScalarHalf(kHeight) }; 192 SkRRect rr2; 193 rr2.setOval(rect); 194 195 REPORTER_ASSERT(reporter, SkRRect::kOval_Type == rr2.type()); 196 REPORTER_ASSERT(reporter, rr2.rect() == rect); 197 198 for (int i = 0; i < 4; ++i) { 199 REPORTER_ASSERT(reporter, 200 rr2.radii((SkRRect::Corner) i).equalsWithinTolerance(halfPoint)); 201 } 202 SkRRect rr2_2; // construct the same RR using the most general set function 203 SkVector rr2_2_radii[4] = { { halfPoint.fX, halfPoint.fY }, { halfPoint.fX, halfPoint.fY }, 204 { halfPoint.fX, halfPoint.fY }, { halfPoint.fX, halfPoint.fY } }; 205 rr2_2.setRectRadii(rect, rr2_2_radii); 206 REPORTER_ASSERT(reporter, rr2_2 == rr2 && rr2_2.getType() == rr2.getType()); 207 SkRRect rr2_3; // construct the same RR using the nine patch set function 208 rr2_3.setNinePatch(rect, halfPoint.fX, halfPoint.fY, halfPoint.fX, halfPoint.fY); 209 REPORTER_ASSERT(reporter, rr2_3 == rr2 && rr2_3.getType() == rr2.getType()); 210 211 //---- 212 SkPoint p = { 5, 5 }; 213 SkRRect rr3; 214 rr3.setRectXY(rect, p.fX, p.fY); 215 216 REPORTER_ASSERT(reporter, SkRRect::kSimple_Type == rr3.type()); 217 REPORTER_ASSERT(reporter, rr3.rect() == rect); 218 219 for (int i = 0; i < 4; ++i) { 220 REPORTER_ASSERT(reporter, p == rr3.radii((SkRRect::Corner) i)); 221 } 222 SkRRect rr3_2; // construct the same RR using the most general set function 223 SkVector rr3_2_radii[4] = { { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 } }; 224 rr3_2.setRectRadii(rect, rr3_2_radii); 225 REPORTER_ASSERT(reporter, rr3_2 == rr3 && rr3_2.getType() == rr3.getType()); 226 SkRRect rr3_3; // construct the same RR using the nine patch set function 227 rr3_3.setNinePatch(rect, 5, 5, 5, 5); 228 REPORTER_ASSERT(reporter, rr3_3 == rr3 && rr3_3.getType() == rr3.getType()); 229 230 //---- 231 test_9patch_rrect(reporter, rect, 10, 9, 8, 7, true); 232 233 { 234 // Test out the rrect from skia:3466 235 SkRect rect2 = SkRect::MakeLTRB(0.358211994f, 0.755430222f, 0.872866154f, 0.806214333f); 236 237 test_9patch_rrect(reporter, 238 rect2, 239 0.926942348f, 0.642850280f, 0.529063463f, 0.587844372f, 240 false); 241 } 242 243 //---- 244 SkPoint radii2[4] = { { 0, 0 }, { 0, 0 }, { 50, 50 }, { 20, 50 } }; 245 246 SkRRect rr5; 247 rr5.setRectRadii(rect, radii2); 248 249 REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr5.type()); 250 REPORTER_ASSERT(reporter, rr5.rect() == rect); 251 252 for (int i = 0; i < 4; ++i) { 253 REPORTER_ASSERT(reporter, radii2[i] == rr5.radii((SkRRect::Corner) i)); 254 } 255 256 // Test out == & != 257 REPORTER_ASSERT(reporter, empty != rr3); 258 REPORTER_ASSERT(reporter, rr3 != rr5); 259 } 260 261 // Test out the cases when the RR degenerates to a rect 262 static void test_round_rect_rects(skiatest::Reporter* reporter) { 263 SkRect r; 264 265 //---- 266 SkRRect empty; 267 268 empty.setEmpty(); 269 270 REPORTER_ASSERT(reporter, SkRRect::kEmpty_Type == empty.type()); 271 r = empty.rect(); 272 REPORTER_ASSERT(reporter, 0 == r.fLeft && 0 == r.fTop && 0 == r.fRight && 0 == r.fBottom); 273 274 //---- 275 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); 276 SkRRect rr1; 277 rr1.setRectXY(rect, 0, 0); 278 279 REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr1.type()); 280 r = rr1.rect(); 281 REPORTER_ASSERT(reporter, rect == r); 282 283 //---- 284 SkPoint radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; 285 286 SkRRect rr2; 287 rr2.setRectRadii(rect, radii); 288 289 REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr2.type()); 290 r = rr2.rect(); 291 REPORTER_ASSERT(reporter, rect == r); 292 293 //---- 294 SkPoint radii2[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; 295 296 SkRRect rr3; 297 rr3.setRectRadii(rect, radii2); 298 REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr3.type()); 299 } 300 301 // Test out the cases when the RR degenerates to an oval 302 static void test_round_rect_ovals(skiatest::Reporter* reporter) { 303 //---- 304 SkRect oval; 305 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); 306 SkRRect rr1; 307 rr1.setRectXY(rect, SkScalarHalf(kWidth), SkScalarHalf(kHeight)); 308 309 REPORTER_ASSERT(reporter, SkRRect::kOval_Type == rr1.type()); 310 oval = rr1.rect(); 311 REPORTER_ASSERT(reporter, oval == rect); 312 } 313 314 // Test out the non-degenerate RR cases 315 static void test_round_rect_general(skiatest::Reporter* reporter) { 316 //---- 317 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); 318 SkRRect rr1; 319 rr1.setRectXY(rect, 20, 20); 320 321 REPORTER_ASSERT(reporter, SkRRect::kSimple_Type == rr1.type()); 322 323 //---- 324 SkPoint radii[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; 325 326 SkRRect rr2; 327 rr2.setRectRadii(rect, radii); 328 329 REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr2.type()); 330 } 331 332 // Test out questionable-parameter handling 333 static void test_round_rect_iffy_parameters(skiatest::Reporter* reporter) { 334 335 // When the radii exceed the base rect they are proportionally scaled down 336 // to fit 337 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); 338 SkPoint radii[4] = { { 50, 100 }, { 100, 50 }, { 50, 100 }, { 100, 50 } }; 339 340 SkRRect rr1; 341 rr1.setRectRadii(rect, radii); 342 343 REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr1.type()); 344 345 const SkPoint& p = rr1.radii(SkRRect::kUpperLeft_Corner); 346 347 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(p.fX, 33.33333f)); 348 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(p.fY, 66.66666f)); 349 350 // Negative radii should be capped at zero 351 SkRRect rr2; 352 rr2.setRectXY(rect, -10, -20); 353 354 REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr2.type()); 355 356 const SkPoint& p2 = rr2.radii(SkRRect::kUpperLeft_Corner); 357 358 REPORTER_ASSERT(reporter, 0.0f == p2.fX); 359 REPORTER_ASSERT(reporter, 0.0f == p2.fY); 360 } 361 362 // Move a small box from the start position by (stepX, stepY) 'numSteps' times 363 // testing for containment in 'rr' at each step. 364 static void test_direction(skiatest::Reporter* reporter, const SkRRect &rr, 365 SkScalar initX, int stepX, SkScalar initY, int stepY, 366 int numSteps, const bool* contains) { 367 SkScalar x = initX, y = initY; 368 for (int i = 0; i < numSteps; ++i) { 369 SkRect test = SkRect::MakeXYWH(x, y, 370 stepX ? SkIntToScalar(stepX) : SK_Scalar1, 371 stepY ? SkIntToScalar(stepY) : SK_Scalar1); 372 test.sort(); 373 374 REPORTER_ASSERT(reporter, contains[i] == rr.contains(test)); 375 376 x += stepX; 377 y += stepY; 378 } 379 } 380 381 // Exercise the RR's contains rect method 382 static void test_round_rect_contains_rect(skiatest::Reporter* reporter) { 383 384 static const int kNumRRects = 4; 385 static const SkVector gRadii[kNumRRects][4] = { 386 { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }, // rect 387 { { 20, 20 }, { 20, 20 }, { 20, 20 }, { 20, 20 } }, // circle 388 { { 10, 10 }, { 10, 10 }, { 10, 10 }, { 10, 10 } }, // simple 389 { { 0, 0 }, { 20, 20 }, { 10, 10 }, { 30, 30 } } // complex 390 }; 391 392 SkRRect rrects[kNumRRects]; 393 for (int i = 0; i < kNumRRects; ++i) { 394 rrects[i].setRectRadii(SkRect::MakeWH(40, 40), gRadii[i]); 395 } 396 397 // First test easy outs - boxes that are obviously out on 398 // each corner and edge 399 static const SkRect easyOuts[] = { 400 { -5, -5, 5, 5 }, // NW 401 { 15, -5, 20, 5 }, // N 402 { 35, -5, 45, 5 }, // NE 403 { 35, 15, 45, 20 }, // E 404 { 35, 45, 35, 45 }, // SE 405 { 15, 35, 20, 45 }, // S 406 { -5, 35, 5, 45 }, // SW 407 { -5, 15, 5, 20 } // W 408 }; 409 410 for (int i = 0; i < kNumRRects; ++i) { 411 for (size_t j = 0; j < SK_ARRAY_COUNT(easyOuts); ++j) { 412 REPORTER_ASSERT(reporter, !rrects[i].contains(easyOuts[j])); 413 } 414 } 415 416 // Now test non-trivial containment. For each compass 417 // point walk a 1x1 rect in from the edge of the bounding 418 // rect 419 static const int kNumSteps = 15; 420 bool answers[kNumRRects][8][kNumSteps] = { 421 // all the test rects are inside the degenerate rrect 422 { 423 // rect 424 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 425 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 426 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 427 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 428 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 429 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 430 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 431 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 432 }, 433 // for the circle we expect 6 blocks to be out on the 434 // corners (then the rest in) and only the first block 435 // out on the vertical and horizontal axes (then 436 // the rest in) 437 { 438 // circle 439 { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 440 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 441 { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 442 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 443 { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 444 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 445 { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 446 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 447 }, 448 // for the simple round rect we expect 3 out on 449 // the corners (then the rest in) and no blocks out 450 // on the vertical and horizontal axes 451 { 452 // simple RR 453 { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 454 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 455 { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 456 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 457 { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 458 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 459 { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 460 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 461 }, 462 // for the complex case the answer is different for each direction 463 { 464 // complex RR 465 // all in for NW (rect) corner (same as rect case) 466 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 467 // only first block out for N (same as circle case) 468 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 469 // first 6 blocks out for NE (same as circle case) 470 { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 471 // only first block out for E (same as circle case) 472 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 473 // first 3 blocks out for SE (same as simple case) 474 { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 475 // first two blocks out for S 476 { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 477 // first 9 blocks out for SW 478 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 }, 479 // first two blocks out for W (same as S) 480 { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 481 } 482 }; 483 484 for (int i = 0; i < kNumRRects; ++i) { 485 test_direction(reporter, rrects[i], 0, 1, 0, 1, kNumSteps, answers[i][0]); // NW 486 test_direction(reporter, rrects[i], 19.5f, 0, 0, 1, kNumSteps, answers[i][1]); // N 487 test_direction(reporter, rrects[i], 40, -1, 0, 1, kNumSteps, answers[i][2]); // NE 488 test_direction(reporter, rrects[i], 40, -1, 19.5f, 0, kNumSteps, answers[i][3]); // E 489 test_direction(reporter, rrects[i], 40, -1, 40, -1, kNumSteps, answers[i][4]); // SE 490 test_direction(reporter, rrects[i], 19.5f, 0, 40, -1, kNumSteps, answers[i][5]); // S 491 test_direction(reporter, rrects[i], 0, 1, 40, -1, kNumSteps, answers[i][6]); // SW 492 test_direction(reporter, rrects[i], 0, 1, 19.5f, 0, kNumSteps, answers[i][7]); // W 493 } 494 } 495 496 // Called for a matrix that should cause SkRRect::transform to fail. 497 static void assert_transform_failure(skiatest::Reporter* reporter, const SkRRect& orig, 498 const SkMatrix& matrix) { 499 // The test depends on the fact that the original is not empty. 500 SkASSERT(!orig.isEmpty()); 501 SkRRect dst; 502 dst.setEmpty(); 503 504 const SkRRect copyOfDst = dst; 505 const SkRRect copyOfOrig = orig; 506 bool success = orig.transform(matrix, &dst); 507 // This transform should fail. 508 REPORTER_ASSERT(reporter, !success); 509 // Since the transform failed, dst should be unchanged. 510 REPORTER_ASSERT(reporter, copyOfDst == dst); 511 // original should not be modified. 512 REPORTER_ASSERT(reporter, copyOfOrig == orig); 513 REPORTER_ASSERT(reporter, orig != dst); 514 } 515 516 #define GET_RADII \ 517 const SkVector& origUL = orig.radii(SkRRect::kUpperLeft_Corner); \ 518 const SkVector& origUR = orig.radii(SkRRect::kUpperRight_Corner); \ 519 const SkVector& origLR = orig.radii(SkRRect::kLowerRight_Corner); \ 520 const SkVector& origLL = orig.radii(SkRRect::kLowerLeft_Corner); \ 521 const SkVector& dstUL = dst.radii(SkRRect::kUpperLeft_Corner); \ 522 const SkVector& dstUR = dst.radii(SkRRect::kUpperRight_Corner); \ 523 const SkVector& dstLR = dst.radii(SkRRect::kLowerRight_Corner); \ 524 const SkVector& dstLL = dst.radii(SkRRect::kLowerLeft_Corner) 525 526 // Called to test various transforms on a single SkRRect. 527 static void test_transform_helper(skiatest::Reporter* reporter, const SkRRect& orig) { 528 SkRRect dst; 529 dst.setEmpty(); 530 531 // The identity matrix will duplicate the rrect. 532 bool success = orig.transform(SkMatrix::I(), &dst); 533 REPORTER_ASSERT(reporter, success); 534 REPORTER_ASSERT(reporter, orig == dst); 535 536 // Skew and Perspective make transform fail. 537 SkMatrix matrix; 538 matrix.reset(); 539 matrix.setSkewX(SkIntToScalar(2)); 540 assert_transform_failure(reporter, orig, matrix); 541 542 matrix.reset(); 543 matrix.setSkewY(SkIntToScalar(3)); 544 assert_transform_failure(reporter, orig, matrix); 545 546 matrix.reset(); 547 matrix.setPerspX(4); 548 assert_transform_failure(reporter, orig, matrix); 549 550 matrix.reset(); 551 matrix.setPerspY(5); 552 assert_transform_failure(reporter, orig, matrix); 553 554 // Rotation fails. 555 matrix.reset(); 556 matrix.setRotate(SkIntToScalar(90)); 557 assert_transform_failure(reporter, orig, matrix); 558 matrix.setRotate(SkIntToScalar(37)); 559 assert_transform_failure(reporter, orig, matrix); 560 561 // Translate will keep the rect moved, but otherwise the same. 562 matrix.reset(); 563 SkScalar translateX = SkIntToScalar(32); 564 SkScalar translateY = SkIntToScalar(15); 565 matrix.setTranslateX(translateX); 566 matrix.setTranslateY(translateY); 567 dst.setEmpty(); 568 success = orig.transform(matrix, &dst); 569 REPORTER_ASSERT(reporter, success); 570 for (int i = 0; i < 4; ++i) { 571 REPORTER_ASSERT(reporter, 572 orig.radii((SkRRect::Corner) i) == dst.radii((SkRRect::Corner) i)); 573 } 574 REPORTER_ASSERT(reporter, orig.rect().width() == dst.rect().width()); 575 REPORTER_ASSERT(reporter, orig.rect().height() == dst.rect().height()); 576 REPORTER_ASSERT(reporter, dst.rect().left() == orig.rect().left() + translateX); 577 REPORTER_ASSERT(reporter, dst.rect().top() == orig.rect().top() + translateY); 578 579 // Keeping the translation, but adding skew will make transform fail. 580 matrix.setSkewY(SkIntToScalar(7)); 581 assert_transform_failure(reporter, orig, matrix); 582 583 // Scaling in -x will flip the round rect horizontally. 584 matrix.reset(); 585 matrix.setScaleX(SkIntToScalar(-1)); 586 dst.setEmpty(); 587 success = orig.transform(matrix, &dst); 588 REPORTER_ASSERT(reporter, success); 589 { 590 GET_RADII; 591 // Radii have swapped in x. 592 REPORTER_ASSERT(reporter, origUL == dstUR); 593 REPORTER_ASSERT(reporter, origUR == dstUL); 594 REPORTER_ASSERT(reporter, origLR == dstLL); 595 REPORTER_ASSERT(reporter, origLL == dstLR); 596 } 597 // Width and height remain the same. 598 REPORTER_ASSERT(reporter, orig.rect().width() == dst.rect().width()); 599 REPORTER_ASSERT(reporter, orig.rect().height() == dst.rect().height()); 600 // Right and left have swapped (sort of) 601 REPORTER_ASSERT(reporter, orig.rect().right() == -dst.rect().left()); 602 // Top has stayed the same. 603 REPORTER_ASSERT(reporter, orig.rect().top() == dst.rect().top()); 604 605 // Keeping the scale, but adding a persp will make transform fail. 606 matrix.setPerspX(7); 607 assert_transform_failure(reporter, orig, matrix); 608 609 // Scaling in -y will flip the round rect vertically. 610 matrix.reset(); 611 matrix.setScaleY(SkIntToScalar(-1)); 612 dst.setEmpty(); 613 success = orig.transform(matrix, &dst); 614 REPORTER_ASSERT(reporter, success); 615 { 616 GET_RADII; 617 // Radii have swapped in y. 618 REPORTER_ASSERT(reporter, origUL == dstLL); 619 REPORTER_ASSERT(reporter, origUR == dstLR); 620 REPORTER_ASSERT(reporter, origLR == dstUR); 621 REPORTER_ASSERT(reporter, origLL == dstUL); 622 } 623 // Width and height remain the same. 624 REPORTER_ASSERT(reporter, orig.rect().width() == dst.rect().width()); 625 REPORTER_ASSERT(reporter, orig.rect().height() == dst.rect().height()); 626 // Top and bottom have swapped (sort of) 627 REPORTER_ASSERT(reporter, orig.rect().top() == -dst.rect().bottom()); 628 // Left has stayed the same. 629 REPORTER_ASSERT(reporter, orig.rect().left() == dst.rect().left()); 630 631 // Scaling in -x and -y will swap in both directions. 632 matrix.reset(); 633 matrix.setScaleY(SkIntToScalar(-1)); 634 matrix.setScaleX(SkIntToScalar(-1)); 635 dst.setEmpty(); 636 success = orig.transform(matrix, &dst); 637 REPORTER_ASSERT(reporter, success); 638 { 639 GET_RADII; 640 REPORTER_ASSERT(reporter, origUL == dstLR); 641 REPORTER_ASSERT(reporter, origUR == dstLL); 642 REPORTER_ASSERT(reporter, origLR == dstUL); 643 REPORTER_ASSERT(reporter, origLL == dstUR); 644 } 645 // Width and height remain the same. 646 REPORTER_ASSERT(reporter, orig.rect().width() == dst.rect().width()); 647 REPORTER_ASSERT(reporter, orig.rect().height() == dst.rect().height()); 648 REPORTER_ASSERT(reporter, orig.rect().top() == -dst.rect().bottom()); 649 REPORTER_ASSERT(reporter, orig.rect().right() == -dst.rect().left()); 650 651 // Scale in both directions. 652 SkScalar xScale = SkIntToScalar(3); 653 SkScalar yScale = 3.2f; 654 matrix.reset(); 655 matrix.setScaleX(xScale); 656 matrix.setScaleY(yScale); 657 dst.setEmpty(); 658 success = orig.transform(matrix, &dst); 659 REPORTER_ASSERT(reporter, success); 660 // Radii are scaled. 661 for (int i = 0; i < 4; ++i) { 662 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.radii((SkRRect::Corner) i).fX, 663 orig.radii((SkRRect::Corner) i).fX * xScale)); 664 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.radii((SkRRect::Corner) i).fY, 665 orig.radii((SkRRect::Corner) i).fY * yScale)); 666 } 667 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().width(), 668 orig.rect().width() * xScale)); 669 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().height(), 670 orig.rect().height() * yScale)); 671 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().left(), 672 orig.rect().left() * xScale)); 673 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().top(), 674 orig.rect().top() * yScale)); 675 } 676 677 static void test_round_rect_transform(skiatest::Reporter* reporter) { 678 SkRRect rrect; 679 { 680 SkRect r = { 0, 0, kWidth, kHeight }; 681 rrect.setRectXY(r, SkIntToScalar(4), SkIntToScalar(7)); 682 test_transform_helper(reporter, rrect); 683 } 684 { 685 SkRect r = { SkIntToScalar(5), SkIntToScalar(15), 686 SkIntToScalar(27), SkIntToScalar(34) }; 687 SkVector radii[4] = { { 0, SkIntToScalar(1) }, 688 { SkIntToScalar(2), SkIntToScalar(3) }, 689 { SkIntToScalar(4), SkIntToScalar(5) }, 690 { SkIntToScalar(6), SkIntToScalar(7) } }; 691 rrect.setRectRadii(r, radii); 692 test_transform_helper(reporter, rrect); 693 } 694 } 695 696 // Test out the case where an oval already off in space is translated/scaled 697 // further off into space - yielding numerical issues when the rect & radii 698 // are transformed separatly 699 // BUG=skia:2696 700 static void test_issue_2696(skiatest::Reporter* reporter) { 701 SkRRect rrect; 702 SkRect r = { 28443.8594f, 53.1428604f, 28446.7148f, 56.0000038f }; 703 rrect.setOval(r); 704 705 SkMatrix xform; 706 xform.setAll(2.44f, 0.0f, 485411.7f, 707 0.0f, 2.44f, -438.7f, 708 0.0f, 0.0f, 1.0f); 709 SkRRect dst; 710 711 bool success = rrect.transform(xform, &dst); 712 REPORTER_ASSERT(reporter, success); 713 714 SkScalar halfWidth = SkScalarHalf(dst.width()); 715 SkScalar halfHeight = SkScalarHalf(dst.height()); 716 717 for (int i = 0; i < 4; ++i) { 718 REPORTER_ASSERT(reporter, 719 SkScalarNearlyEqual(dst.radii((SkRRect::Corner)i).fX, halfWidth)); 720 REPORTER_ASSERT(reporter, 721 SkScalarNearlyEqual(dst.radii((SkRRect::Corner)i).fY, halfHeight)); 722 } 723 } 724 725 DEF_TEST(RoundRect, reporter) { 726 test_round_rect_basic(reporter); 727 test_round_rect_rects(reporter); 728 test_round_rect_ovals(reporter); 729 test_round_rect_general(reporter); 730 test_round_rect_iffy_parameters(reporter); 731 test_inset(reporter); 732 test_round_rect_contains_rect(reporter); 733 test_round_rect_transform(reporter); 734 test_issue_2696(reporter); 735 test_tricky_radii(reporter); 736 test_empty_crbug_458524(reporter); 737 test_empty(reporter); 738 } 739
