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 #include "PathOpsExtendedTest.h" 8 #include "PathOpsTestCommon.h" 9 10 class PathTest_Private { 11 public: 12 PathTest_Private(SkPath* path) 13 : fPath(path) {} 14 15 void setPt(int index, SkScalar x, SkScalar y) { 16 fPath->setPt(index, x, y); 17 } 18 19 SkPath* fPath; 20 }; 21 22 static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) { 23 PathTest_Private testPath(path); 24 for (int index = 0; index < path->countPoints(); ++index) { 25 if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) { 26 testPath.setPt(index, to.fX, to.fY); 27 return; 28 } 29 } 30 } 31 32 static void cubicOp1d(skiatest::Reporter* reporter, const char* filename) { 33 SkPath path, pathB; 34 path.setFillType(SkPath::kWinding_FillType); 35 path.moveTo(0,1); 36 path.cubicTo(0,2, 1,0, 1,0); 37 path.close(); 38 pathB.setFillType(SkPath::kWinding_FillType); 39 pathB.moveTo(0,1); 40 pathB.cubicTo(0,1, 1,0, 2,0); 41 pathB.close(); 42 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 43 } 44 45 static void cubicOp2d(skiatest::Reporter* reporter, const char* filename) { 46 SkPath path, pathB; 47 path.setFillType(SkPath::kWinding_FillType); 48 path.moveTo(0,2); 49 path.cubicTo(0,1, 1,0, 1,0); 50 path.close(); 51 pathB.setFillType(SkPath::kWinding_FillType); 52 pathB.moveTo(0,1); 53 pathB.cubicTo(0,1, 2,0, 1,0); 54 pathB.close(); 55 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 56 } 57 58 static void cubicOp3d(skiatest::Reporter* reporter, const char* filename) { 59 SkPath path, pathB; 60 path.setFillType(SkPath::kWinding_FillType); 61 path.moveTo(0,1); 62 path.cubicTo(2,3, 1,0, 1,0); 63 path.close(); 64 pathB.setFillType(SkPath::kWinding_FillType); 65 pathB.moveTo(0,1); 66 pathB.cubicTo(0,1, 1,0, 3,2); 67 pathB.close(); 68 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 69 } 70 71 static void cubicOp5d(skiatest::Reporter* reporter, const char* filename) { 72 SkPath path, pathB; 73 path.setFillType(SkPath::kWinding_FillType); 74 path.moveTo(0,1); 75 path.cubicTo(0,2, 1,0, 2,0); 76 path.close(); 77 pathB.setFillType(SkPath::kWinding_FillType); 78 pathB.moveTo(0,1); 79 pathB.cubicTo(0,2, 1,0, 2,0); 80 pathB.close(); 81 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 82 } 83 84 static void cubicOp6d(skiatest::Reporter* reporter, const char* filename) { 85 SkPath path, pathB; 86 path.setFillType(SkPath::kWinding_FillType); 87 path.moveTo(0,1); 88 path.cubicTo(0,6, 1,0, 3,0); 89 path.close(); 90 pathB.setFillType(SkPath::kWinding_FillType); 91 pathB.moveTo(0,1); 92 pathB.cubicTo(0,3, 1,0, 6,0); 93 pathB.close(); 94 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 95 } 96 97 static void cubicOp7d(skiatest::Reporter* reporter, const char* filename) { 98 SkPath path, pathB; 99 path.setFillType(SkPath::kWinding_FillType); 100 path.moveTo(0,1); 101 path.cubicTo(3,4, 1,0, 3,0); 102 path.close(); 103 pathB.setFillType(SkPath::kWinding_FillType); 104 pathB.moveTo(0,1); 105 pathB.cubicTo(0,3, 1,0, 4,3); 106 pathB.close(); 107 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 108 } 109 110 static void cubicOp8d(skiatest::Reporter* reporter, const char* filename) { 111 SkPath path, pathB; 112 path.setFillType(SkPath::kWinding_FillType); 113 path.moveTo(0,1); 114 path.cubicTo(0,5, 1,0, 4,0); 115 path.close(); 116 pathB.setFillType(SkPath::kWinding_FillType); 117 pathB.moveTo(0,1); 118 pathB.cubicTo(0,4, 1,0, 5,0); 119 pathB.close(); 120 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 121 } 122 123 static void cubicOp9d(skiatest::Reporter* reporter, const char* filename) { 124 SkPath path, pathB; 125 path.setFillType(SkPath::kWinding_FillType); 126 path.moveTo(0,1); 127 path.cubicTo(1,6, 1,0, 2,1); 128 path.close(); 129 pathB.setFillType(SkPath::kWinding_FillType); 130 pathB.moveTo(0,1); 131 pathB.cubicTo(1,2, 1,0, 6,1); 132 pathB.close(); 133 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 134 } 135 136 static void quadOp9d(skiatest::Reporter* reporter, const char* filename) { 137 SkPath path, pathB; 138 path.setFillType(SkPath::kWinding_FillType); 139 path.moveTo(0,1); 140 path.quadTo(1,6, 1.5f,1); 141 path.quadTo(1.5f,0.5f, 2,1); 142 path.close(); 143 pathB.setFillType(SkPath::kWinding_FillType); 144 pathB.moveTo(0,1); 145 pathB.quadTo(1,2, 1.4f,1); 146 pathB.quadTo(3,0.4f, 6,1); 147 pathB.close(); 148 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 149 } 150 151 static void lineOp9d(skiatest::Reporter* reporter, const char* filename) { 152 SkPath path, pathB; 153 path.setFillType(SkPath::kWinding_FillType); 154 path.moveTo(0,1); 155 path.lineTo(1,6); 156 path.lineTo(1.5f,1); 157 path.lineTo(1.8f,0.8f); 158 path.lineTo(2,1); 159 path.close(); 160 pathB.setFillType(SkPath::kWinding_FillType); 161 pathB.moveTo(0,1); 162 pathB.lineTo(1,2); 163 pathB.lineTo(1.4f,1); 164 pathB.lineTo(3,0.4f); 165 pathB.lineTo(6,1); 166 pathB.close(); 167 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 168 } 169 170 static void cubicOp1i(skiatest::Reporter* reporter, const char* filename) { 171 SkPath path, pathB; 172 path.setFillType(SkPath::kWinding_FillType); 173 path.moveTo(0,1); 174 path.cubicTo(1,2, 1,0, 2,1); 175 path.close(); 176 pathB.setFillType(SkPath::kWinding_FillType); 177 pathB.moveTo(0,1); 178 pathB.cubicTo(1,2, 1,0, 2,1); 179 pathB.close(); 180 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 181 } 182 183 static void cubicOp10d(skiatest::Reporter* reporter, const char* filename) { 184 SkPath path, pathB; 185 path.setFillType(SkPath::kWinding_FillType); 186 path.moveTo(0,1); 187 path.cubicTo(1,3, 1,0, 4,1); 188 path.close(); 189 pathB.setFillType(SkPath::kWinding_FillType); 190 pathB.moveTo(0,1); 191 pathB.cubicTo(1,4, 1,0, 3,1); 192 pathB.close(); 193 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 194 } 195 196 static void cubicOp11d(skiatest::Reporter* reporter, const char* filename) { 197 SkPath path, pathB; 198 path.setFillType(SkPath::kWinding_FillType); 199 path.moveTo(0,1); 200 path.cubicTo(3,4, 1,0, 5,1); 201 path.close(); 202 pathB.setFillType(SkPath::kWinding_FillType); 203 pathB.moveTo(0,1); 204 pathB.cubicTo(1,5, 1,0, 4,3); 205 pathB.close(); 206 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 207 } 208 209 static void cubicOp12d(skiatest::Reporter* reporter, const char* filename) { 210 SkPath path, pathB; 211 path.setFillType(SkPath::kWinding_FillType); 212 path.moveTo(0,1); 213 path.cubicTo(1,6, 1,0, 1,0); 214 path.close(); 215 pathB.setFillType(SkPath::kWinding_FillType); 216 pathB.moveTo(0,1); 217 pathB.cubicTo(0,1, 1,0, 6,1); 218 pathB.close(); 219 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 220 } 221 222 static void cubicOp13d(skiatest::Reporter* reporter, const char* filename) { 223 SkPath path, pathB; 224 path.setFillType(SkPath::kWinding_FillType); 225 path.moveTo(0,1); 226 path.cubicTo(4,5, 1,0, 5,3); 227 path.close(); 228 pathB.setFillType(SkPath::kWinding_FillType); 229 pathB.moveTo(0,1); 230 pathB.cubicTo(3,5, 1,0, 5,4); 231 pathB.close(); 232 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 233 } 234 235 static void cubicOp14d(skiatest::Reporter* reporter, const char* filename) { 236 SkPath path, pathB; 237 path.setFillType(SkPath::kWinding_FillType); 238 path.moveTo(0,1); 239 path.cubicTo(0,2, 2,0, 2,1); 240 path.close(); 241 pathB.setFillType(SkPath::kWinding_FillType); 242 pathB.moveTo(0,2); 243 pathB.cubicTo(1,2, 1,0, 2,0); 244 pathB.close(); 245 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 246 } 247 248 static void cubicOp15d(skiatest::Reporter* reporter, const char* filename) { 249 SkPath path, pathB; 250 path.setFillType(SkPath::kWinding_FillType); 251 path.moveTo(0,1); 252 path.cubicTo(3,6, 2,0, 2,1); 253 path.close(); 254 pathB.setFillType(SkPath::kWinding_FillType); 255 pathB.moveTo(0,2); 256 pathB.cubicTo(1,2, 1,0, 6,3); 257 pathB.close(); 258 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 259 } 260 261 static void cubicOp16d(skiatest::Reporter* reporter, const char* filename) { 262 SkPath path, pathB; 263 path.setFillType(SkPath::kWinding_FillType); 264 path.moveTo(0,2); 265 path.cubicTo(0,1, 3,0, 1,0); 266 path.close(); 267 pathB.setFillType(SkPath::kWinding_FillType); 268 pathB.moveTo(0,3); 269 pathB.cubicTo(0,1, 2,0, 1,0); 270 pathB.close(); 271 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 272 } 273 274 static void cubicOp17d(skiatest::Reporter* reporter, const char* filename) { 275 SkPath path, pathB; 276 path.setFillType(SkPath::kWinding_FillType); 277 path.moveTo(0,2); 278 path.cubicTo(0,2, 4,0, 2,1); 279 path.close(); 280 pathB.setFillType(SkPath::kWinding_FillType); 281 pathB.moveTo(0,4); 282 pathB.cubicTo(1,2, 2,0, 2,0); 283 pathB.close(); 284 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 285 } 286 287 static void cubicOp18d(skiatest::Reporter* reporter, const char* filename) { 288 SkPath path, pathB; 289 path.setFillType(SkPath::kWinding_FillType); 290 path.moveTo(0,1); 291 path.cubicTo(3,5, 2,0, 2,1); 292 path.close(); 293 pathB.setFillType(SkPath::kWinding_FillType); 294 pathB.moveTo(0,2); 295 pathB.cubicTo(1,2, 1,0, 5,3); 296 pathB.close(); 297 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 298 } 299 300 static void cubicOp19i(skiatest::Reporter* reporter, const char* filename) { 301 SkPath path, pathB; 302 path.setFillType(SkPath::kWinding_FillType); 303 path.moveTo(0,2); 304 path.cubicTo(0,1, 2,1, 6,2); 305 path.close(); 306 pathB.setFillType(SkPath::kWinding_FillType); 307 pathB.moveTo(1,2); 308 pathB.cubicTo(2,6, 2,0, 1,0); 309 pathB.close(); 310 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 311 } 312 313 static void cubicOp20d(skiatest::Reporter* reporter, const char* filename) { 314 SkPath path, pathB; 315 path.setFillType(SkPath::kWinding_FillType); 316 path.moveTo(0,1); 317 path.cubicTo(0,1, 6,0, 2,1); 318 path.close(); 319 pathB.setFillType(SkPath::kWinding_FillType); 320 pathB.moveTo(0,6); 321 pathB.cubicTo(1,2, 1,0, 1,0); 322 pathB.close(); 323 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 324 } 325 326 static void cubicOp21d(skiatest::Reporter* reporter, const char* filename) { 327 SkPath path, pathB; 328 path.setFillType(SkPath::kWinding_FillType); 329 path.moveTo(0,1); 330 path.cubicTo(0,1, 2,1, 6,5); 331 path.close(); 332 pathB.setFillType(SkPath::kWinding_FillType); 333 pathB.moveTo(1,2); 334 pathB.cubicTo(5,6, 1,0, 1,0); 335 pathB.close(); 336 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 337 } 338 339 static void cubicOp22d(skiatest::Reporter* reporter, const char* filename) { 340 SkPath path, pathB; 341 path.setFillType(SkPath::kWinding_FillType); 342 path.moveTo(0,1); 343 path.cubicTo(2,3, 3,0, 2,1); 344 path.close(); 345 pathB.setFillType(SkPath::kWinding_FillType); 346 pathB.moveTo(0,3); 347 pathB.cubicTo(1,2, 1,0, 3,2); 348 pathB.close(); 349 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 350 } 351 352 static void cubicOp23d(skiatest::Reporter* reporter, const char* filename) { 353 SkPath path, pathB; 354 path.setFillType(SkPath::kWinding_FillType); 355 path.moveTo(0,1); 356 path.cubicTo(1,2, 4,0, 2,1); 357 path.close(); 358 pathB.setFillType(SkPath::kWinding_FillType); 359 pathB.moveTo(0,4); 360 pathB.cubicTo(1,2, 1,0, 2,1); 361 pathB.close(); 362 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 363 } 364 365 static void cubicOp24d(skiatest::Reporter* reporter, const char* filename) { 366 SkPath path, pathB; 367 path.setFillType(SkPath::kWinding_FillType); 368 path.moveTo(0,1); 369 path.cubicTo(1,2, 2,0, 3,2); 370 path.close(); 371 pathB.setFillType(SkPath::kWinding_FillType); 372 pathB.moveTo(0,2); 373 pathB.cubicTo(2,3, 1,0, 2,1); 374 pathB.close(); 375 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 376 } 377 378 static void testIntersect1(skiatest::Reporter* reporter, const char* filename) { 379 SkPath one, two; 380 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 381 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 382 testPathOp(reporter, one, two, kIntersect_SkPathOp, filename); 383 } 384 385 static void testUnion1(skiatest::Reporter* reporter, const char* filename) { 386 SkPath one, two; 387 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 388 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 389 testPathOp(reporter, one, two, kUnion_SkPathOp, filename); 390 } 391 392 static void testDiff1(skiatest::Reporter* reporter, const char* filename) { 393 SkPath one, two; 394 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 395 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 396 testPathOp(reporter, one, two, kDifference_SkPathOp, filename); 397 } 398 399 static void testXor1(skiatest::Reporter* reporter, const char* filename) { 400 SkPath one, two; 401 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 402 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 403 testPathOp(reporter, one, two, kXOR_SkPathOp, filename); 404 } 405 406 static void testIntersect2(skiatest::Reporter* reporter, const char* filename) { 407 SkPath one, two; 408 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 409 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 410 testPathOp(reporter, one, two, kIntersect_SkPathOp, filename); 411 } 412 413 static void testUnion2(skiatest::Reporter* reporter, const char* filename) { 414 SkPath one, two; 415 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 416 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 417 testPathOp(reporter, one, two, kUnion_SkPathOp, filename); 418 } 419 420 static void testDiff2(skiatest::Reporter* reporter, const char* filename) { 421 SkPath one, two; 422 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 423 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 424 testPathOp(reporter, one, two, kDifference_SkPathOp, filename); 425 } 426 427 static void testXor2(skiatest::Reporter* reporter, const char* filename) { 428 SkPath one, two; 429 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 430 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 431 testPathOp(reporter, one, two, kXOR_SkPathOp, filename); 432 } 433 434 static void testOp1d(skiatest::Reporter* reporter, const char* filename) { 435 SkPath path, pathB; 436 path.setFillType(SkPath::kWinding_FillType); 437 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 438 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 439 pathB.setFillType(SkPath::kWinding_FillType); 440 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 441 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 442 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 443 } 444 445 static void testOp2d(skiatest::Reporter* reporter, const char* filename) { 446 SkPath path, pathB; 447 path.setFillType(SkPath::kWinding_FillType); 448 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 449 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 450 pathB.setFillType(SkPath::kEvenOdd_FillType); 451 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 452 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 453 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 454 } 455 456 static void testOp3d(skiatest::Reporter* reporter, const char* filename) { 457 SkPath path, pathB; 458 path.setFillType(SkPath::kWinding_FillType); 459 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 460 path.addRect(1, 1, 2, 2, SkPath::kCW_Direction); 461 pathB.setFillType(SkPath::kWinding_FillType); 462 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 463 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 465 } 466 467 static void testOp1u(skiatest::Reporter* reporter, const char* filename) { 468 SkPath path, pathB; 469 path.setFillType(SkPath::kWinding_FillType); 470 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 471 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 472 pathB.setFillType(SkPath::kWinding_FillType); 473 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 474 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 475 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 476 } 477 478 static void testOp4d(skiatest::Reporter* reporter, const char* filename) { 479 SkPath path, pathB; 480 path.setFillType(SkPath::kWinding_FillType); 481 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 482 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction); 483 pathB.setFillType(SkPath::kWinding_FillType); 484 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 485 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 486 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 487 } 488 489 static void testOp5d(skiatest::Reporter* reporter, const char* filename) { 490 SkPath path, pathB; 491 path.setFillType(SkPath::kEvenOdd_FillType); 492 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 493 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 494 pathB.setFillType(SkPath::kEvenOdd_FillType); 495 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 496 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 497 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 498 } 499 500 static void testOp6d(skiatest::Reporter* reporter, const char* filename) { 501 SkPath path, pathB; 502 path.setFillType(SkPath::kEvenOdd_FillType); 503 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 504 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 505 pathB.setFillType(SkPath::kWinding_FillType); 506 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 507 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 508 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 509 } 510 511 static void testOp7d(skiatest::Reporter* reporter, const char* filename) { 512 SkPath path, pathB; 513 path.setFillType(SkPath::kEvenOdd_FillType); 514 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 515 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 516 pathB.setFillType(SkPath::kEvenOdd_FillType); 517 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 518 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 519 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 520 } 521 522 static void testOp2u(skiatest::Reporter* reporter, const char* filename) { 523 SkPath path, pathB; 524 path.setFillType(SkPath::kEvenOdd_FillType); 525 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 526 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 527 pathB.setFillType(SkPath::kWinding_FillType); 528 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 529 pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction); 530 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 531 } 532 533 static void testOp8d(skiatest::Reporter* reporter, const char* filename) { 534 SkPath path, pathB; 535 path.addRect(0, 0, 640, 480); 536 pathB.moveTo(577330, 1971.72f); 537 pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f); 538 pathB.close(); 539 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 540 } 541 static void cubicOp25i(skiatest::Reporter* reporter, const char* filename) { 542 SkPath path, pathB; 543 path.setFillType(SkPath::kWinding_FillType); 544 path.moveTo(0,1); 545 path.cubicTo(2,4, 5,0, 3,2); 546 path.close(); 547 pathB.setFillType(SkPath::kWinding_FillType); 548 pathB.moveTo(0,5); 549 pathB.cubicTo(2,3, 1,0, 4,2); 550 pathB.close(); 551 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 552 } 553 554 static void cubicOp26d(skiatest::Reporter* reporter, const char* filename) { 555 SkPath path, pathB; 556 path.setFillType(SkPath::kWinding_FillType); 557 path.moveTo(0,1); 558 path.cubicTo(3,4, 4,0, 3,2); 559 path.close(); 560 pathB.setFillType(SkPath::kWinding_FillType); 561 pathB.moveTo(0,4); 562 pathB.cubicTo(2,3, 1,0, 4,3); 563 pathB.close(); 564 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 565 } 566 567 static void cubicOp27d(skiatest::Reporter* reporter, const char* filename) { 568 SkPath path, pathB; 569 path.setFillType(SkPath::kWinding_FillType); 570 path.moveTo(0,1); 571 path.cubicTo(3,6, 1,0, 5,2); 572 path.close(); 573 pathB.setFillType(SkPath::kWinding_FillType); 574 pathB.moveTo(0,1); 575 pathB.cubicTo(2,5, 1,0, 6,3); 576 pathB.close(); 577 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 578 } 579 580 static void cubicOp28u(skiatest::Reporter* reporter, const char* filename) { 581 SkPath path, pathB; 582 path.setFillType(SkPath::kWinding_FillType); 583 path.moveTo(0,1); 584 path.cubicTo(1,4, 6,0, 3,2); 585 path.close(); 586 pathB.setFillType(SkPath::kWinding_FillType); 587 pathB.moveTo(0,6); 588 pathB.cubicTo(2,3, 1,0, 4,1); 589 pathB.close(); 590 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 591 } 592 593 static void cubicOp29d(skiatest::Reporter* reporter, const char* filename) { 594 SkPath path, pathB; 595 path.setFillType(SkPath::kWinding_FillType); 596 path.moveTo(0,1); 597 path.cubicTo(2,5, 6,0, 4,2); 598 path.close(); 599 pathB.setFillType(SkPath::kWinding_FillType); 600 pathB.moveTo(0,6); 601 pathB.cubicTo(2,4, 1,0, 5,2); 602 pathB.close(); 603 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 604 } 605 606 static void cubicOp30d(skiatest::Reporter* reporter, const char* filename) { 607 SkPath path, pathB; 608 path.setFillType(SkPath::kWinding_FillType); 609 path.moveTo(0,1); 610 path.cubicTo(2,5, 6,0, 5,3); 611 path.close(); 612 pathB.setFillType(SkPath::kWinding_FillType); 613 pathB.moveTo(0,6); 614 pathB.cubicTo(3,5, 1,0, 5,2); 615 pathB.close(); 616 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 617 } 618 619 static void cubicOp31d(skiatest::Reporter* reporter, const char* filename) { 620 SkPath path, pathB; 621 path.setFillType(SkPath::kWinding_FillType); 622 path.moveTo(0,2); 623 path.cubicTo(0,3, 2,1, 4,0); 624 path.close(); 625 pathB.setFillType(SkPath::kWinding_FillType); 626 pathB.moveTo(1,2); 627 pathB.cubicTo(0,4, 2,0, 3,0); 628 pathB.close(); 629 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 630 } 631 632 static void cubicOp31u(skiatest::Reporter* reporter, const char* filename) { 633 SkPath path, pathB; 634 path.setFillType(SkPath::kWinding_FillType); 635 path.moveTo(0,2); 636 path.cubicTo(0,3, 2,1, 4,0); 637 path.close(); 638 pathB.setFillType(SkPath::kWinding_FillType); 639 pathB.moveTo(1,2); 640 pathB.cubicTo(0,4, 2,0, 3,0); 641 pathB.close(); 642 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 643 } 644 645 static void cubicOp31x(skiatest::Reporter* reporter, const char* filename) { 646 SkPath path, pathB; 647 path.setFillType(SkPath::kWinding_FillType); 648 path.moveTo(0,2); 649 path.cubicTo(0,3, 2,1, 4,0); 650 path.close(); 651 pathB.setFillType(SkPath::kWinding_FillType); 652 pathB.moveTo(1,2); 653 pathB.cubicTo(0,4, 2,0, 3,0); 654 pathB.close(); 655 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename); 656 } 657 658 static void cubicOp32d(skiatest::Reporter* reporter, const char* filename) { 659 SkPath path, pathB; 660 path.setFillType(SkPath::kWinding_FillType); 661 path.moveTo(0,1); 662 path.cubicTo(1,2, 6,0, 3,1); 663 path.close(); 664 pathB.setFillType(SkPath::kWinding_FillType); 665 pathB.moveTo(0,6); 666 pathB.cubicTo(1,3, 1,0, 2,1); 667 pathB.close(); 668 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 669 } 670 671 static void cubicOp33i(skiatest::Reporter* reporter, const char* filename) { 672 SkPath path, pathB; 673 path.setFillType(SkPath::kWinding_FillType); 674 path.moveTo(0,1); 675 path.cubicTo(1,2, 6,0, 3,1); 676 path.close(); 677 pathB.setFillType(SkPath::kWinding_FillType); 678 pathB.moveTo(0,6); 679 pathB.cubicTo(1,3, 1,0, 2,1); 680 pathB.close(); 681 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 682 } 683 684 static void cubicOp34d(skiatest::Reporter* reporter, const char* filename) { 685 SkPath path, pathB; 686 path.setFillType(SkPath::kWinding_FillType); 687 path.moveTo(0,1); 688 path.cubicTo(3,5, 2,1, 3,1); 689 path.close(); 690 pathB.setFillType(SkPath::kWinding_FillType); 691 pathB.moveTo(1,2); 692 pathB.cubicTo(1,3, 1,0, 5,3); 693 pathB.close(); 694 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 695 } 696 697 static void cubicOp35d(skiatest::Reporter* reporter, const char* filename) { 698 SkPath path, pathB; 699 path.setFillType(SkPath::kWinding_FillType); 700 path.moveTo(0,1); 701 path.cubicTo(1,5, 2,1, 4,0); 702 path.close(); 703 pathB.setFillType(SkPath::kWinding_FillType); 704 pathB.moveTo(1,2); 705 pathB.cubicTo(0,4, 1,0, 5,1); 706 pathB.close(); 707 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 708 } 709 710 static void cubicOp36u(skiatest::Reporter* reporter, const char* filename) { 711 SkPath path, pathB; 712 path.setFillType(SkPath::kWinding_FillType); 713 path.moveTo(0,1); 714 path.cubicTo(1,6, 2,0, 5,1); 715 path.close(); 716 pathB.setFillType(SkPath::kWinding_FillType); 717 pathB.moveTo(0,2); 718 pathB.cubicTo(1,5, 1,0, 6,1); 719 pathB.close(); 720 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 721 } 722 723 static void cubicOp37d(skiatest::Reporter* reporter, const char* filename) { 724 SkPath path, pathB; 725 path.setFillType(SkPath::kWinding_FillType); 726 path.moveTo(0,1); 727 path.cubicTo(2,6, 6,1, 4,3); 728 path.close(); 729 pathB.setFillType(SkPath::kWinding_FillType); 730 pathB.moveTo(1,6); 731 pathB.cubicTo(3,4, 1,0, 6,2); 732 pathB.close(); 733 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 734 } 735 736 static void cubicOp38d(skiatest::Reporter* reporter, const char* filename) { 737 SkPath path, pathB; 738 path.setFillType(SkPath::kWinding_FillType); 739 path.moveTo(0,1); 740 path.cubicTo(0,6, 3,2, 4,1); 741 path.close(); 742 pathB.setFillType(SkPath::kWinding_FillType); 743 pathB.moveTo(2,3); 744 pathB.cubicTo(1,4, 1,0, 6,0); 745 pathB.close(); 746 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 747 } 748 749 static void cubicOp39d(skiatest::Reporter* reporter, const char* filename) { 750 SkPath path, pathB; 751 path.setFillType(SkPath::kWinding_FillType); 752 path.moveTo(0,1); 753 path.cubicTo(2,3, 5,1, 4,3); 754 path.close(); 755 pathB.setFillType(SkPath::kWinding_FillType); 756 pathB.moveTo(1,5); 757 pathB.cubicTo(3,4, 1,0, 3,2); 758 pathB.close(); 759 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 760 } 761 762 static void cubicOp40d(skiatest::Reporter* reporter, const char* filename) { 763 SkPath path, pathB; 764 path.setFillType(SkPath::kWinding_FillType); 765 path.moveTo(0,1); 766 path.cubicTo(1,5, 3,2, 4,2); 767 path.close(); 768 pathB.setFillType(SkPath::kWinding_FillType); 769 pathB.moveTo(2,3); 770 pathB.cubicTo(2,4, 1,0, 5,1); 771 pathB.close(); 772 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 773 } 774 775 static void cubicOp41i(skiatest::Reporter* reporter, const char* filename) { 776 SkPath path, pathB; 777 path.setFillType(SkPath::kWinding_FillType); 778 path.moveTo(0,1); 779 path.cubicTo(2,6, 4,3, 6,4); 780 path.close(); 781 pathB.setFillType(SkPath::kWinding_FillType); 782 pathB.moveTo(3,4); 783 pathB.cubicTo(4,6, 1,0, 6,2); 784 pathB.close(); 785 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 786 } 787 788 static void cubicOp42d(skiatest::Reporter* reporter, const char* filename) { 789 SkPath path, pathB; 790 path.setFillType(SkPath::kWinding_FillType); 791 path.moveTo(0,1); 792 path.cubicTo(1,2, 6,5, 5,4); 793 path.close(); 794 pathB.setFillType(SkPath::kWinding_FillType); 795 pathB.moveTo(5,6); 796 pathB.cubicTo(4,5, 1,0, 2,1); 797 pathB.close(); 798 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 799 } 800 801 static void cubicOp43d(skiatest::Reporter* reporter, const char* filename) { 802 SkPath path, pathB; 803 path.setFillType(SkPath::kWinding_FillType); 804 path.moveTo(0,2); 805 path.cubicTo(1,2, 4,0, 3,1); 806 path.close(); 807 pathB.setFillType(SkPath::kWinding_FillType); 808 pathB.moveTo(0,4); 809 pathB.cubicTo(1,3, 2,0, 2,1); 810 pathB.close(); 811 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 812 } 813 814 static void cubicOp44d(skiatest::Reporter* reporter, const char* filename) { 815 SkPath path, pathB; 816 path.setFillType(SkPath::kWinding_FillType); 817 path.moveTo(0,2); 818 path.cubicTo(3,6, 4,0, 3,2); 819 path.close(); 820 pathB.setFillType(SkPath::kWinding_FillType); 821 pathB.moveTo(0,4); 822 pathB.cubicTo(2,3, 2,0, 6,3); 823 pathB.close(); 824 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 825 } 826 827 static void cubicOp45d(skiatest::Reporter* reporter, const char* filename) { 828 SkPath path, pathB; 829 path.setFillType(SkPath::kWinding_FillType); 830 path.moveTo(0,2); 831 path.cubicTo(2,4, 4,0, 3,2); 832 path.close(); 833 pathB.setFillType(SkPath::kWinding_FillType); 834 pathB.moveTo(0,4); 835 pathB.cubicTo(2,3, 2,0, 4,2); 836 pathB.close(); 837 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 838 } 839 840 static void cubicOp46d(skiatest::Reporter* reporter, const char* filename) { 841 SkPath path, pathB; 842 path.setFillType(SkPath::kWinding_FillType); 843 path.moveTo(0,2); 844 path.cubicTo(3,5, 5,0, 4,2); 845 path.close(); 846 pathB.setFillType(SkPath::kWinding_FillType); 847 pathB.moveTo(0,5); 848 pathB.cubicTo(2,4, 2,0, 5,3); 849 pathB.close(); 850 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 851 } 852 853 static void cubicOp47d(skiatest::Reporter* reporter, const char* filename) { 854 SkPath path, pathB; 855 path.setFillType(SkPath::kWinding_FillType); 856 path.moveTo(0,1); 857 path.cubicTo(1,6, 6,2, 5,4); 858 path.close(); 859 pathB.setFillType(SkPath::kWinding_FillType); 860 pathB.moveTo(2,6); 861 pathB.cubicTo(4,5, 1,0, 6,1); 862 pathB.close(); 863 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 864 } 865 866 static void cubicOp48d(skiatest::Reporter* reporter, const char* filename) { 867 SkPath path, pathB; 868 path.setFillType(SkPath::kWinding_FillType); 869 path.moveTo(0,2); 870 path.cubicTo(2,3, 5,1, 3,2); 871 path.close(); 872 pathB.setFillType(SkPath::kWinding_FillType); 873 pathB.moveTo(1,5); 874 pathB.cubicTo(2,3, 2,0, 3,2); 875 pathB.close(); 876 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 877 } 878 879 static void cubicOp49d(skiatest::Reporter* reporter, const char* filename) { 880 SkPath path, pathB; 881 path.setFillType(SkPath::kWinding_FillType); 882 path.moveTo(0,2); 883 path.cubicTo(1,5, 3,2, 4,1); 884 path.close(); 885 pathB.setFillType(SkPath::kWinding_FillType); 886 pathB.moveTo(2,3); 887 pathB.cubicTo(1,4, 2,0, 5,1); 888 pathB.close(); 889 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 890 } 891 892 static void cubicOp50d(skiatest::Reporter* reporter, const char* filename) { 893 SkPath path, pathB; 894 path.setFillType(SkPath::kWinding_FillType); 895 path.moveTo(0,3); 896 path.cubicTo(1,6, 5,0, 5,1); 897 path.close(); 898 pathB.setFillType(SkPath::kWinding_FillType); 899 pathB.moveTo(0,5); 900 pathB.cubicTo(1,5, 3,0, 6,1); 901 pathB.close(); 902 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 903 } 904 905 static void cubicOp51d(skiatest::Reporter* reporter, const char* filename) { 906 SkPath path, pathB; 907 path.setFillType(SkPath::kWinding_FillType); 908 path.moveTo(0,3); 909 path.cubicTo(1,2, 4,1, 6,0); 910 path.close(); 911 pathB.setFillType(SkPath::kWinding_FillType); 912 pathB.moveTo(1,4); 913 pathB.cubicTo(0,6, 3,0, 2,1); 914 pathB.close(); 915 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 916 } 917 918 static void cubicOp52d(skiatest::Reporter* reporter, const char* filename) { 919 SkPath path, pathB; 920 path.setFillType(SkPath::kWinding_FillType); 921 path.moveTo(0,2); 922 path.cubicTo(1,2, 5,4, 4,3); 923 path.close(); 924 pathB.setFillType(SkPath::kWinding_FillType); 925 pathB.moveTo(4,5); 926 pathB.cubicTo(3,4, 2,0, 2,1); 927 pathB.close(); 928 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 929 } 930 931 static void cubicOp53d(skiatest::Reporter* reporter, const char* filename) { 932 SkPath path, pathB; 933 path.setFillType(SkPath::kWinding_FillType); 934 path.moveTo(0,3); 935 path.cubicTo(1,2, 5,3, 2,1); 936 path.close(); 937 pathB.setFillType(SkPath::kWinding_FillType); 938 pathB.moveTo(3,5); 939 pathB.cubicTo(1,2, 3,0, 2,1); 940 pathB.close(); 941 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 942 } 943 944 static void cubicOp54d(skiatest::Reporter* reporter, const char* filename) { 945 SkPath path, pathB; 946 path.setFillType(SkPath::kWinding_FillType); 947 path.moveTo(0,4); 948 path.cubicTo(1,3, 5,4, 4,2); 949 path.close(); 950 pathB.setFillType(SkPath::kWinding_FillType); 951 pathB.moveTo(4,5); 952 pathB.cubicTo(2,4, 4,0, 3,1); 953 pathB.close(); 954 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 955 } 956 957 static void cubicOp55d(skiatest::Reporter* reporter, const char* filename) { 958 SkPath path, pathB; 959 path.setFillType(SkPath::kWinding_FillType); 960 path.moveTo(0,5); 961 path.cubicTo(1,3, 3,2, 5,0); 962 path.close(); 963 pathB.setFillType(SkPath::kWinding_FillType); 964 pathB.moveTo(2,3); 965 pathB.cubicTo(0,5, 5,0, 3,1); 966 pathB.close(); 967 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 968 } 969 970 static void cubicOp56d(skiatest::Reporter* reporter, const char* filename) { 971 SkPath path, pathB; 972 path.setFillType(SkPath::kWinding_FillType); 973 path.moveTo(0,1); 974 path.cubicTo(2,6, 5,0, 2,1); 975 path.close(); 976 pathB.setFillType(SkPath::kWinding_FillType); 977 pathB.moveTo(0,5); 978 pathB.cubicTo(1,2, 1,0, 6,2); 979 pathB.close(); 980 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 981 } 982 983 static void cubicOp57d(skiatest::Reporter* reporter, const char* filename) { 984 SkPath path, pathB; 985 path.setFillType(SkPath::kWinding_FillType); 986 path.moveTo(0,5); 987 path.cubicTo(0,5, 5,4, 6,4); 988 path.close(); 989 pathB.setFillType(SkPath::kWinding_FillType); 990 pathB.moveTo(4,5); 991 pathB.cubicTo(4,6, 5,0, 5,0); 992 pathB.close(); 993 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 994 } 995 996 static void cubicOp58d(skiatest::Reporter* reporter, const char* filename) { 997 SkPath path, pathB; 998 path.setFillType(SkPath::kWinding_FillType); 999 path.moveTo(0,5); 1000 path.cubicTo(3,4, 6,5, 5,3); 1001 path.close(); 1002 pathB.setFillType(SkPath::kWinding_FillType); 1003 pathB.moveTo(5,6); 1004 pathB.cubicTo(3,5, 5,0, 4,3); 1005 pathB.close(); 1006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1007 } 1008 1009 static void cubicOp59d(skiatest::Reporter* reporter, const char* filename) { 1010 SkPath path, pathB; 1011 path.setFillType(SkPath::kWinding_FillType); 1012 path.moveTo(0,1); 1013 path.cubicTo(5,6, 4,0, 4,1); 1014 path.close(); 1015 pathB.setFillType(SkPath::kWinding_FillType); 1016 pathB.moveTo(0,4); 1017 pathB.cubicTo(1,4, 1,0, 6,5); 1018 pathB.close(); 1019 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1020 } 1021 1022 static void cubicOp60d(skiatest::Reporter* reporter, const char* filename) { 1023 SkPath path, pathB; 1024 path.setFillType(SkPath::kWinding_FillType); 1025 path.moveTo(0,2); 1026 path.cubicTo(4,6, 6,0, 5,2); 1027 path.close(); 1028 pathB.setFillType(SkPath::kWinding_FillType); 1029 pathB.moveTo(0,6); 1030 pathB.cubicTo(2,5, 2,0, 6,4); 1031 pathB.close(); 1032 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1033 } 1034 1035 static void cubicOp61d(skiatest::Reporter* reporter, const char* filename) { 1036 SkPath path, pathB; 1037 path.setFillType(SkPath::kWinding_FillType); 1038 path.moveTo(1,2); 1039 path.cubicTo(0,5, 3,2, 6,1); 1040 path.close(); 1041 pathB.setFillType(SkPath::kWinding_FillType); 1042 pathB.moveTo(2,3); 1043 pathB.cubicTo(1,6, 2,1, 5,0); 1044 pathB.close(); 1045 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1046 } 1047 1048 static void cubicOp62d(skiatest::Reporter* reporter, const char* filename) { 1049 SkPath path, pathB; 1050 path.setFillType(SkPath::kWinding_FillType); 1051 path.moveTo(1,3); 1052 path.cubicTo(5,6, 5,3, 5,4); 1053 path.close(); 1054 pathB.setFillType(SkPath::kWinding_FillType); 1055 pathB.moveTo(3,5); 1056 pathB.cubicTo(4,5, 3,1, 6,5); 1057 pathB.close(); 1058 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1059 } 1060 1061 static void cubicOp63d(skiatest::Reporter* reporter, const char* filename) { 1062 SkPath path, pathB; 1063 path.setFillType(SkPath::kWinding_FillType); 1064 path.moveTo(2,3); 1065 path.cubicTo(0,4, 3,2, 5,3); 1066 path.close(); 1067 pathB.setFillType(SkPath::kWinding_FillType); 1068 pathB.moveTo(2,3); 1069 pathB.cubicTo(3,5, 3,2, 4,0); 1070 pathB.close(); 1071 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1072 } 1073 1074 static void cubicOp64d(skiatest::Reporter* reporter, const char* filename) { 1075 SkPath path, pathB; 1076 path.moveTo(0,1); 1077 path.cubicTo(0,1, 1,0, 3,0); 1078 path.lineTo(0,1); 1079 path.close(); 1080 pathB.moveTo(0,1); 1081 pathB.cubicTo(0,3, 1,0, 1,0); 1082 pathB.lineTo(0,1); 1083 pathB.close(); 1084 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1085 } 1086 1087 static void cubicOp65d(skiatest::Reporter* reporter, const char* filename) { 1088 SkPath path, pathB; 1089 path.moveTo(0,1); 1090 path.cubicTo(1,5, 1,0, 1,0); 1091 path.lineTo(0,1); 1092 path.close(); 1093 pathB.moveTo(0,1); 1094 pathB.cubicTo(0,1, 1,0, 5,1); 1095 pathB.lineTo(0,1); 1096 pathB.close(); 1097 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1098 } 1099 1100 static void rectOp1d(skiatest::Reporter* reporter, const char* filename) { 1101 SkPath path, pathB; 1102 path.moveTo(0,1); 1103 path.cubicTo(0,1, 1,0, 3,0); 1104 path.lineTo(0,1); 1105 path.close(); 1106 pathB.moveTo(0,1); 1107 pathB.cubicTo(0,3, 1,0, 1,0); 1108 pathB.lineTo(0,1); 1109 pathB.close(); 1110 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1111 } 1112 1113 static void cubicOp66u(skiatest::Reporter* reporter, const char* filename) { 1114 SkPath path, pathB; 1115 path.setFillType(SkPath::kWinding_FillType); 1116 path.moveTo(0,1); 1117 path.cubicTo(2,6, 4,2, 5,3); 1118 path.close(); 1119 pathB.setFillType(SkPath::kWinding_FillType); 1120 pathB.moveTo(2,4); 1121 pathB.cubicTo(3,5, 1,0, 6,2); 1122 pathB.close(); 1123 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 1124 } 1125 1126 static void cubicOp67u(skiatest::Reporter* reporter, const char* filename) { 1127 SkPath path, pathB; 1128 path.moveTo(3,5); 1129 path.cubicTo(1,6, 5,0, 3,1); 1130 path.lineTo(3,5); 1131 path.close(); 1132 pathB.moveTo(0,5); 1133 pathB.cubicTo(1,3, 5,3, 6,1); 1134 pathB.lineTo(0,5); 1135 pathB.close(); 1136 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 1137 } 1138 1139 static void cubicOp68u(skiatest::Reporter* reporter, const char* filename) { 1140 SkPath path, pathB; 1141 path.moveTo(0,5); 1142 path.cubicTo(4,5, 4,1, 5,0); 1143 path.close(); 1144 pathB.moveTo(1,4); 1145 pathB.cubicTo(0,5, 5,0, 5,4); 1146 pathB.close(); 1147 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 1148 } 1149 1150 static void cubicOp69d(skiatest::Reporter* reporter, const char* filename) { 1151 SkPath path, pathB; 1152 path.moveTo(1,3); 1153 path.cubicTo(0,1, 3,1, 2,0); 1154 path.close(); 1155 pathB.moveTo(1,3); 1156 pathB.cubicTo(0,2, 3,1, 1,0); 1157 pathB.close(); 1158 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1159 } 1160 1161 SkPathOp ops[] = { 1162 kUnion_SkPathOp, 1163 kXOR_SkPathOp, 1164 kReverseDifference_SkPathOp, 1165 kXOR_SkPathOp, 1166 kReverseDifference_SkPathOp, 1167 }; 1168 1169 static void rRect1(skiatest::Reporter* reporter, const char* filename) { 1170 SkScalar xA = 0.65f; 1171 SkScalar xB = 10.65f; 1172 SkScalar xC = 20.65f; 1173 SkScalar xD = 30.65f; 1174 SkScalar xE = 40.65f; 1175 SkScalar xF = 50.65f; 1176 1177 SkScalar yA = 0.65f; 1178 SkScalar yB = 10.65f; 1179 SkScalar yC = 20.65f; 1180 SkScalar yD = 30.65f; 1181 SkScalar yE = 40.65f; 1182 SkScalar yF = 50.65f; 1183 SkPath paths[5]; 1184 SkRect rects[5]; 1185 rects[0].set(xB, yB, xE, yE); 1186 paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5)); // red 1187 rects[1].set(xA, yA, xD, yD); 1188 paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5)); // green 1189 rects[2].set(xC, yA, xF, yD); 1190 paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5)); // blue 1191 rects[3].set(xA, yC, xD, yF); 1192 paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5)); // yellow 1193 rects[4].set(xC, yC, xF, yF); 1194 paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5)); // cyan 1195 SkPath path; 1196 path.setFillType(SkPath::kInverseEvenOdd_FillType); 1197 for (int index = 0; index < 5; ++index) { 1198 testPathOp(reporter, path, paths[index], ops[index], filename); 1199 REPORTER_ASSERT(reporter, Op(path, paths[index], ops[index], &path)); 1200 } 1201 } 1202 1203 static void skp1(skiatest::Reporter* reporter, const char* filename) { 1204 SkPath path; 1205 path.setFillType(SkPath::kEvenOdd_FillType); 1206 path.moveTo(189,7); 1207 path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4); 1208 path.lineTo(243,4); 1209 path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7); 1210 path.lineTo(246,21); 1211 path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24); 1212 path.lineTo(192,24); 1213 path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21); 1214 path.lineTo(189,7); 1215 path.close(); 1216 path.moveTo(191,8); 1217 path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6); 1218 path.lineTo(242,6); 1219 path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8); 1220 path.lineTo(244,20); 1221 path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22); 1222 path.lineTo(193,22); 1223 path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20); 1224 path.lineTo(191,8); 1225 path.close(); 1226 SkPath pathB; 1227 pathB.setFillType(SkPath::kWinding_FillType); 1228 pathB.moveTo(189,4); 1229 pathB.lineTo(199,14); 1230 pathB.lineTo(236,14); 1231 pathB.lineTo(246,4); 1232 pathB.lineTo(189,4); 1233 pathB.close(); 1234 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1235 } 1236 1237 static void skp2(skiatest::Reporter* reporter, const char* filename) { 1238 SkPath path; 1239 path.setFillType(SkPath::kEvenOdd_FillType); 1240 path.moveTo(253.000000f, 11757.0000f); 1241 path.lineTo(253.000000f, 222.000000f); 1242 path.lineTo(823.000000f, 222.000000f); 1243 path.lineTo(823.000000f, 11757.0000f); 1244 path.lineTo(253.000000f, 11757.0000f); 1245 path.close(); 1246 SkPath pathB; 1247 pathB.setFillType(SkPath::kWinding_FillType); 1248 pathB.moveTo(258.000000f, 1028.00000f); 1249 pathB.lineTo(258.000000f, 1027.00000f); 1250 pathB.lineTo(823.000000f, 1027.00000f); 1251 pathB.lineTo(823.000000f, 1028.00000f); 1252 pathB.lineTo(258.000000f, 1028.00000f); 1253 pathB.close(); 1254 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1255 } 1256 1257 static void skp3(skiatest::Reporter* reporter, const char* filename) { 1258 SkPath path; 1259 path.setFillType(SkPath::kEvenOdd_FillType); 1260 path.moveTo(717.000000f, 507.000000f); 1261 path.lineTo(717.000000f, 425.000000f); 1262 path.lineTo(973.000000f, 425.000000f); 1263 path.lineTo(973.000000f, 507.000000f); 1264 path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f); 1265 path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f); 1266 path.lineTo(720.000000f, 510.000000f); 1267 path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f); 1268 path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f); 1269 path.close(); 1270 path.moveTo(719.000000f, 426.000000f); 1271 path.lineTo(971.000000f, 426.000000f); 1272 path.lineTo(971.000000f, 506.000000f); 1273 path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f); 1274 path.lineTo(721.000000f, 508.000000f); 1275 path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f); 1276 path.lineTo(719.000000f, 426.000000f); 1277 path.close(); 1278 SkPath pathB; 1279 pathB.setFillType(SkPath::kWinding_FillType); 1280 pathB.moveTo(717.000000f, 510.000000f); 1281 pathB.lineTo(760.000000f, 467.000000f); 1282 pathB.lineTo(930.000000f, 467.000000f); 1283 pathB.lineTo(973.000000f, 510.000000f); 1284 pathB.lineTo(717.000000f, 510.000000f); 1285 pathB.close(); 1286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1287 } 1288 1289 static void skp4(skiatest::Reporter* reporter, const char* filename) { 1290 SkPath path; 1291 path.setFillType(SkPath::kEvenOdd_FillType); 1292 path.moveTo(230.756805f, 591.756775f); 1293 path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f); 1294 path.lineTo(300.000000f, 590.000000f); 1295 path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f); 1296 path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f); 1297 path.lineTo(306.000000f, 617.000000f); 1298 path.lineTo(229.000000f, 617.000000f); 1299 path.lineTo(229.000000f, 596.000000f); 1300 path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f); 1301 path.close(); 1302 path.moveTo(231.000000f, 597.000000f); 1303 path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f); 1304 path.lineTo(299.000000f, 592.000000f); 1305 path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f); 1306 path.lineTo(304.000000f, 616.000000f); 1307 path.lineTo(231.000000f, 616.000000f); 1308 path.lineTo(231.000000f, 597.000000f); 1309 path.close(); 1310 SkPath pathB; 1311 pathB.setFillType(SkPath::kWinding_FillType); 1312 pathB.moveTo(306.000000f, 590.000000f); 1313 pathB.lineTo(292.000000f, 604.000000f); 1314 pathB.lineTo(305.000000f, 617.000000f); 1315 pathB.lineTo(306.000000f, 617.000000f); 1316 pathB.lineTo(306.000000f, 590.000000f); 1317 pathB.close(); 1318 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1319 } 1320 1321 static void skp5(skiatest::Reporter* reporter, const char* filename) { 1322 SkPath path; 1323 path.setFillType(SkPath::kEvenOdd_FillType); 1324 path.moveTo(18.0000000f, 226.000000f); 1325 path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f); 1326 path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f); 1327 path.lineTo(10.0000000f, 253.000000f); 1328 path.lineTo(1247.00000f, 253.000000f); 1329 path.lineTo(1247.00000f, 234.000000f); 1330 path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f); 1331 path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f); 1332 path.lineTo(18.0000000f, 226.000000f); 1333 path.close(); 1334 SkPath pathB; 1335 pathB.setFillType(SkPath::kInverseWinding_FillType); 1336 pathB.moveTo(18.0000000f, 226.000000f); 1337 pathB.lineTo(1239.00000f, 226.000000f); 1338 pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f); 1339 pathB.lineTo(1247.00000f, 252.000000f); 1340 pathB.lineTo(10.0000000f, 252.000000f); 1341 pathB.lineTo(10.0000000f, 234.000000f); 1342 pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f); 1343 pathB.close(); 1344 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1345 } 1346 1347 static void cubicOp70d(skiatest::Reporter* reporter, const char* filename) { 1348 SkPath path, pathB; 1349 path.setFillType(SkPath::kWinding_FillType); 1350 path.moveTo(0,1); 1351 path.cubicTo(0,5, 4,0, 5,0); 1352 path.close(); 1353 pathB.setFillType(SkPath::kWinding_FillType); 1354 pathB.moveTo(0,4); 1355 pathB.cubicTo(0,5, 1,0, 5,0); 1356 pathB.close(); 1357 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1358 } 1359 1360 static void cubicOp71d(skiatest::Reporter* reporter, const char* filename) { 1361 SkPath path, pathB; 1362 path.setFillType(SkPath::kWinding_FillType); 1363 path.moveTo(0,1); 1364 path.cubicTo(0,5, 4,1, 6,4); 1365 path.close(); 1366 pathB.setFillType(SkPath::kWinding_FillType); 1367 pathB.moveTo(1,4); 1368 pathB.cubicTo(4,6, 1,0, 5,0); 1369 pathB.close(); 1370 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1371 } 1372 1373 static void cubicOp72i(skiatest::Reporter* reporter, const char* filename) { 1374 SkPath path, pathB; 1375 path.setFillType(SkPath::kWinding_FillType); 1376 path.moveTo(0,1); 1377 path.cubicTo(0,5, 5,2, 5,4); 1378 path.close(); 1379 pathB.setFillType(SkPath::kWinding_FillType); 1380 pathB.moveTo(2,5); 1381 pathB.cubicTo(4,5, 1,0, 5,0); 1382 pathB.close(); 1383 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1384 } 1385 1386 static void cubicOp73d(skiatest::Reporter* reporter, const char* filename) { 1387 SkPath path, pathB; 1388 path.setFillType(SkPath::kWinding_FillType); 1389 path.moveTo(0,1); 1390 path.cubicTo(3,4, 4,0, 6,4); 1391 path.lineTo(0,1); 1392 path.close(); 1393 pathB.setFillType(SkPath::kWinding_FillType); 1394 pathB.moveTo(0,4); 1395 pathB.cubicTo(4,6, 1,0, 4,3); 1396 pathB.lineTo(0,4); 1397 pathB.close(); 1398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1399 } 1400 1401 static void cubicOp74d(skiatest::Reporter* reporter, const char* filename) { 1402 SkPath path, pathB; 1403 path.setFillType(SkPath::kWinding_FillType); 1404 path.moveTo(0,1); 1405 path.cubicTo(1,5, 5,1, 5,1); 1406 path.lineTo(0,1); 1407 path.close(); 1408 pathB.setFillType(SkPath::kWinding_FillType); 1409 pathB.moveTo(1,5); 1410 pathB.cubicTo(1,5, 1,0, 5,1); 1411 pathB.lineTo(1,5); 1412 pathB.close(); 1413 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1414 } 1415 1416 static void cubicOp75d(skiatest::Reporter* reporter, const char* filename) { 1417 SkPath path, pathB; 1418 path.setFillType(SkPath::kWinding_FillType); 1419 path.moveTo(0,1); 1420 path.cubicTo(0,4, 5,1, 6,4); 1421 path.lineTo(0,1); 1422 path.close(); 1423 pathB.setFillType(SkPath::kWinding_FillType); 1424 pathB.moveTo(1,5); 1425 pathB.cubicTo(4,6, 1,0, 4,0); 1426 pathB.lineTo(1,5); 1427 pathB.close(); 1428 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1429 } 1430 1431 static void cubicOp76u(skiatest::Reporter* reporter, const char* filename) { 1432 SkPath path, pathB; 1433 path.setFillType(SkPath::kWinding_FillType); 1434 path.moveTo(0,1); 1435 path.cubicTo(0,2, 2,0, 5,3); 1436 path.close(); 1437 pathB.setFillType(SkPath::kWinding_FillType); 1438 pathB.moveTo(0,2); 1439 pathB.cubicTo(3,5, 1,0, 2,0); 1440 pathB.close(); 1441 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 1442 } 1443 1444 static void cubicOp77i(skiatest::Reporter* reporter, const char* filename) { 1445 SkPath path, pathB; 1446 path.setFillType(SkPath::kEvenOdd_FillType); 1447 path.moveTo(0,1); 1448 path.cubicTo(1,3, 2,0, 3,2); 1449 path.lineTo(0,1); 1450 path.close(); 1451 pathB.setFillType(SkPath::kEvenOdd_FillType); 1452 pathB.moveTo(0,2); 1453 pathB.cubicTo(2,3, 1,0, 3,1); 1454 pathB.lineTo(0,2); 1455 pathB.close(); 1456 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1457 } 1458 1459 static void cubicOp78u(skiatest::Reporter* reporter, const char* filename) { 1460 SkPath path, pathB; 1461 path.setFillType(SkPath::kEvenOdd_FillType); 1462 path.moveTo(1,6); 1463 path.cubicTo(1,6, 5,0, 6,1); 1464 path.lineTo(1,6); 1465 path.close(); 1466 pathB.setFillType(SkPath::kEvenOdd_FillType); 1467 pathB.moveTo(0,5); 1468 pathB.cubicTo(1,6, 6,1, 6,1); 1469 pathB.lineTo(0,5); 1470 pathB.close(); 1471 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 1472 } 1473 1474 static void cubicOp79u(skiatest::Reporter* reporter, const char* filename) { 1475 SkPath path, pathB; 1476 path.setFillType(SkPath::kWinding_FillType); 1477 path.moveTo(0,1); 1478 path.cubicTo(1,3, 1,0, 6,4); 1479 path.close(); 1480 pathB.setFillType(SkPath::kWinding_FillType); 1481 pathB.moveTo(0,1); 1482 pathB.cubicTo(4,6, 1,0, 3,1); 1483 pathB.close(); 1484 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1485 } 1486 1487 static void cubicOp80i(skiatest::Reporter* reporter, const char* filename) { 1488 SkPath path, pathB; 1489 path.setFillType(SkPath::kWinding_FillType); 1490 path.moveTo(0,1); 1491 path.cubicTo(2,3, 2,1, 4,3); 1492 path.lineTo(0,1); 1493 path.close(); 1494 pathB.setFillType(SkPath::kWinding_FillType); 1495 pathB.moveTo(1,2); 1496 pathB.cubicTo(3,4, 1,0, 3,2); 1497 pathB.lineTo(1,2); 1498 pathB.close(); 1499 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1500 } 1501 1502 static void cubicOp81d(skiatest::Reporter* reporter, const char* filename) { 1503 SkPath path, pathB; 1504 path.setFillType(SkPath::kWinding_FillType); 1505 path.moveTo(0,1); 1506 path.cubicTo(4,6, 4,3, 5,4); 1507 path.close(); 1508 pathB.setFillType(SkPath::kWinding_FillType); 1509 pathB.moveTo(3,4); 1510 pathB.cubicTo(4,5, 1,0, 6,4); 1511 pathB.close(); 1512 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1513 } 1514 1515 static void cubicOp82i(skiatest::Reporter* reporter, const char* filename) { 1516 SkPath path, pathB; 1517 path.setFillType(SkPath::kEvenOdd_FillType); 1518 path.moveTo(0,1); 1519 path.cubicTo(2,3, 5,2, 3,0); 1520 path.lineTo(0,1); 1521 path.close(); 1522 pathB.setFillType(SkPath::kWinding_FillType); 1523 pathB.moveTo(2,5); 1524 pathB.cubicTo(0,3, 1,0, 3,2); 1525 pathB.lineTo(2,5); 1526 pathB.close(); 1527 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1528 } 1529 1530 static void cubicOp83i(skiatest::Reporter* reporter, const char* filename) { 1531 SkPath path, pathB; 1532 path.setFillType(SkPath::kWinding_FillType); 1533 path.moveTo(0,1); 1534 path.cubicTo(0,3, 2,1, 4,1); 1535 path.lineTo(0,1); 1536 path.close(); 1537 pathB.setFillType(SkPath::kWinding_FillType); 1538 pathB.moveTo(1,2); 1539 pathB.cubicTo(1,4, 1,0, 3,0); 1540 pathB.lineTo(1,2); 1541 pathB.close(); 1542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1543 } 1544 1545 static void cubicOp84d(skiatest::Reporter* reporter, const char* filename) { 1546 SkPath path, pathB; 1547 path.setFillType(SkPath::kWinding_FillType); 1548 path.moveTo(0,4); 1549 path.cubicTo(2,3, 6,3, 3,2); 1550 path.close(); 1551 pathB.setFillType(SkPath::kWinding_FillType); 1552 pathB.moveTo(3,6); 1553 pathB.cubicTo(2,3, 4,0, 3,2); 1554 pathB.close(); 1555 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1556 } 1557 1558 static void skpClip1(skiatest::Reporter* reporter, const char* filename) { 1559 SkPath path; 1560 path.setFillType(SkPath::kEvenOdd_FillType); 1561 path.moveTo(1126.17114f, 877.171204f); 1562 path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f); 1563 path.lineTo(1243.00000f, 876.000000f); 1564 path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f); 1565 path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f); 1566 path.lineTo(1247.00000f, 907.000000f); 1567 path.lineTo(1246.00000f, 907.000000f); 1568 path.lineTo(1246.00000f, 880.000000f); 1569 path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f); 1570 path.lineTo(1129.00000f, 877.000000f); 1571 path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f); 1572 path.lineTo(1126.00000f, 907.000000f); 1573 path.lineTo(1125.00000f, 907.000000f); 1574 path.lineTo(1125.00000f, 880.000000f); 1575 path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f); 1576 path.close(); 1577 SkPath pathB; 1578 pathB.setFillType(SkPath::kWinding_FillType); 1579 pathB.moveTo(1247.00000f, 876.000000f); 1580 pathB.lineTo(1231.00000f, 892.000000f); 1581 pathB.lineTo(1246.00000f, 907.000000f); 1582 pathB.lineTo(1247.00000f, 907.000000f); 1583 pathB.lineTo(1247.00000f, 876.000000f); 1584 pathB.close(); 1585 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1586 } 1587 1588 static void skpClip2(skiatest::Reporter* reporter, const char* filename) { 1589 SkPath path; 1590 path.setFillType(SkPath::kEvenOdd_FillType); 1591 path.moveTo(134.000000f, 11414.0000f); 1592 path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f); 1593 path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f); 1594 path.lineTo(806.000000f, 11419.0000f); 1595 path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f); 1596 path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f); 1597 path.lineTo(134.000000f, 11414.0000f); 1598 path.close(); 1599 SkPath pathB; 1600 pathB.setFillType(SkPath::kInverseWinding_FillType); 1601 pathB.moveTo(132.000000f, 11415.0000f); 1602 pathB.lineTo(806.000000f, 11415.0000f); 1603 pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f); 1604 pathB.lineTo(808.000000f, 11417.0000f); 1605 pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f); 1606 pathB.lineTo(132.000000f, 11419.0000f); 1607 pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f); 1608 pathB.lineTo(130.000000f, 11416.0000f); 1609 pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f); 1610 pathB.close(); 1611 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1612 } 1613 1614 static void skp96prezzi1(skiatest::Reporter* reporter, const char* filename) { 1615 SkPath path; 1616 path.setFillType(SkPath::kEvenOdd_FillType); 1617 path.moveTo(157.464005f, 670.463989f); 1618 path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f); 1619 path.lineTo(248.000000f, 669.000000f); 1620 path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f); 1621 path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f); 1622 path.lineTo(253.000000f, 706.000000f); 1623 path.lineTo(251.000000f, 706.000000f); 1624 path.lineTo(251.000000f, 675.000000f); 1625 path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f); 1626 path.lineTo(162.000000f, 671.000000f); 1627 path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f); 1628 path.lineTo(158.000000f, 706.000000f); 1629 path.lineTo(156.000000f, 706.000000f); 1630 path.lineTo(156.000000f, 674.000000f); 1631 path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f); 1632 path.close(); 1633 SkPath pathB; 1634 pathB.setFillType(SkPath::kWinding_FillType); 1635 pathB.moveTo(156.000000f, 669.000000f); 1636 pathB.lineTo(178.500000f, 691.500000f); 1637 pathB.lineTo(230.500000f, 691.500000f); 1638 pathB.lineTo(253.000000f, 669.000000f); 1639 pathB.lineTo(156.000000f, 669.000000f); 1640 pathB.close(); 1641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1642 } 1643 1644 static void skpancestry_com1(skiatest::Reporter* reporter, const char* filename) { 1645 SkPath path; 1646 path.setFillType(SkPath::kEvenOdd_FillType); 1647 path.moveTo(161.000000f, 925.000000f); 1648 path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f); 1649 path.lineTo(158.000000f, 926.000000f); 1650 path.lineTo(1108.00000f, 926.000000f); 1651 path.lineTo(1108.00000f, 925.999634f); 1652 path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f); 1653 path.lineTo(161.000000f, 925.000000f); 1654 path.close(); 1655 SkPath pathB; 1656 pathB.setFillType(SkPath::kEvenOdd_FillType); 1657 pathB.moveTo(161.000000f, 926.000000f); 1658 pathB.lineTo(1105.00000f, 926.000000f); 1659 pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f); 1660 pathB.lineTo(1109.00000f, 956.000000f); 1661 pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f); 1662 pathB.lineTo(161.000000f, 960.000000f); 1663 pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f); 1664 pathB.lineTo(157.000000f, 930.000000f); 1665 pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f); 1666 pathB.close(); 1667 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1668 } 1669 1670 static void skpeldorado_com_ua1(skiatest::Reporter* reporter, const char* filename) { 1671 SkPath path; 1672 path.setFillType(SkPath::kEvenOdd_FillType); 1673 path.moveTo(286.695129f, 291.000000f); 1674 path.lineTo(229.304855f, 561.000000f); 1675 path.lineTo(979.304871f, 561.000000f); 1676 path.lineTo(1036.69507f, 291.000000f); 1677 path.lineTo(286.695129f, 291.000000f); 1678 path.close(); 1679 SkPath pathB; 1680 pathB.setFillType(SkPath::kWinding_FillType); 1681 pathB.moveTo(1006.69513f, 291.000000f); 1682 pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f); 1683 pathB.lineTo(985.681519f, 531.000000f); 1684 pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f); 1685 pathB.lineTo(259.304871f, 561.000000f); 1686 pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f); 1687 pathB.lineTo(280.318420f, 321.000000f); 1688 pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f); 1689 pathB.lineTo(1006.69513f, 291.000000f); 1690 pathB.close(); 1691 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1692 } 1693 1694 static void skpbyte_com1(skiatest::Reporter* reporter, const char* filename) { 1695 SkPath path; 1696 path.setFillType(SkPath::kEvenOdd_FillType); 1697 path.moveTo(968.000000f, 14.0000000f); 1698 path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f); 1699 path.lineTo(963.000000f, 32.0000000f); 1700 path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f); 1701 path.lineTo(1034.00000f, 37.0000000f); 1702 path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f); 1703 path.lineTo(1039.00000f, 19.0000000f); 1704 path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f); 1705 path.lineTo(968.000000f, 14.0000000f); 1706 path.close(); 1707 SkPath pathB; 1708 pathB.setFillType(SkPath::kInverseWinding_FillType); 1709 pathB.moveTo(968.000000f, 14.0000000f); 1710 pathB.lineTo(1034.00000f, 14.0000000f); 1711 pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f); 1712 pathB.lineTo(1039.00000f, 32.0000000f); 1713 pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f); 1714 pathB.lineTo(968.000000f, 36.0000000f); 1715 pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f); 1716 pathB.lineTo(963.000000f, 19.0000000f); 1717 pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f); 1718 pathB.close(); 1719 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1720 } 1721 1722 static void skphealth_com76(skiatest::Reporter* reporter, const char* filename) { 1723 SkPath path; 1724 path.setFillType(SkPath::kEvenOdd_FillType); 1725 path.moveTo(708.099182f, 7.09919119f); 1726 path.lineTo(708.099182f, 7.09920025f); 1727 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f); 1728 path.lineTo(704.000000f, 33.0000000f); 1729 path.lineTo(705.000000f, 33.0000000f); 1730 path.lineTo(705.000000f, 17.0000000f); 1731 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f); 1732 path.lineTo(708.099182f, 7.09919119f); 1733 path.close(); 1734 SkPath pathB; 1735 pathB.setFillType(SkPath::kWinding_FillType); 1736 pathB.moveTo(704.000000f, 3.00000000f); 1737 pathB.lineTo(704.000000f, 33.0000000f); 1738 pathB.lineTo(705.000000f, 33.0000000f); 1739 pathB.lineTo(719.500000f, 3.00000000f); 1740 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1741 } 1742 1743 static void skpahrefs_com88(skiatest::Reporter* reporter, const char* filename) { 1744 SkPath path; 1745 path.setFillType(SkPath::kEvenOdd_FillType); 1746 path.moveTo(1099.82886f, 7.17117119f); 1747 path.lineTo(1099.12134f, 7.87867832f); 1748 path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f); 1749 path.lineTo(1100.00000f, 28.0000000f); 1750 path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f); 1751 path.lineTo(1088.00000f, 31.0000000f); 1752 path.lineTo(1088.00000f, 32.0000000f); 1753 path.lineTo(1097.00000f, 32.0000000f); 1754 path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f); 1755 path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f); 1756 path.lineTo(1101.00000f, 10.0000000f); 1757 path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f); 1758 path.lineTo(1099.82886f, 7.17117119f); 1759 path.close(); 1760 SkPath pathB; 1761 pathB.setFillType(SkPath::kWinding_FillType); 1762 pathB.moveTo(1101.00000f, 6.00000000f); 1763 pathB.lineTo(1088.00000f, 6.00000000f); 1764 pathB.lineTo(1088.00000f, 19.0000000f); 1765 pathB.lineTo(1101.00000f, 32.0000000f); 1766 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1767 } 1768 1769 static void skpahrefs_com29(skiatest::Reporter* reporter, const char* filename) { 1770 SkPath path; 1771 path.setFillType(SkPath::kEvenOdd_FillType); 1772 path.moveTo(1037.17114f, 7.17119980f); 1773 path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f); 1774 path.lineTo(1074.00000f, 6.00000000f); 1775 path.lineTo(1074.00000f, 32.0000000f); 1776 path.lineTo(1040.00000f, 32.0000000f); 1777 path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f); 1778 path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f); 1779 path.lineTo(1036.00000f, 10.0000000f); 1780 path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f); 1781 path.close(); 1782 path.moveTo(1037.00000f, 10.0000000f); 1783 path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f); 1784 path.lineTo(1073.00000f, 7.00000000f); 1785 path.lineTo(1073.00000f, 31.0000000f); 1786 path.lineTo(1040.00000f, 31.0000000f); 1787 path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f); 1788 path.lineTo(1037.00000f, 10.0000000f); 1789 path.close(); 1790 SkPath pathB; 1791 pathB.setFillType(SkPath::kWinding_FillType); 1792 pathB.moveTo(1036.00000f, 32.0000000f); 1793 pathB.lineTo(1049.00000f, 19.0000000f); 1794 pathB.lineTo(1073.00000f, 31.0000000f); 1795 pathB.lineTo(1074.00000f, 32.0000000f); 1796 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1797 } 1798 1799 static void cubicOp85d(skiatest::Reporter* reporter, const char* filename) { 1800 SkPath path; 1801 path.setFillType(SkPath::kWinding_FillType); 1802 path.moveTo(0,1); 1803 path.cubicTo(1,6, 1,0, 6,2); 1804 path.close(); 1805 SkPath pathB; 1806 pathB.setFillType(SkPath::kWinding_FillType); 1807 pathB.moveTo(0,1); 1808 pathB.cubicTo(2,6, 1,0, 6,1); 1809 pathB.close(); 1810 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 1811 } 1812 1813 static void skpkkiste_to98(skiatest::Reporter* reporter, const char* filename) { 1814 SkPath path; 1815 path.setFillType(SkPath::kEvenOdd_FillType); 1816 path.moveTo(96, 122); 1817 path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f); 1818 path.lineTo(94.1715698f, 125.17157f); 1819 path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124); 1820 path.lineTo(257, 124); 1821 path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f); 1822 path.lineTo(261.535522f, 123.46447f); 1823 path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122); 1824 path.lineTo(96, 122); 1825 path.close(); 1826 SkPath pathB; 1827 pathB.setFillType(SkPath::kWinding_FillType); 1828 pathB.moveTo(258, 122); 1829 pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127); 1830 pathB.lineTo(263, 284); 1831 pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289); 1832 pathB.lineTo(96, 289); 1833 pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284); 1834 pathB.lineTo(91, 127); 1835 pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122); 1836 pathB.lineTo(258, 122); 1837 pathB.close(); 1838 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1839 } 1840 1841 static void issue1417(skiatest::Reporter* reporter, const char* filename) { 1842 SkPath path1; 1843 path1.moveTo(122.58908843994140625f, 82.2836456298828125f); 1844 path1.quadTo(129.8215789794921875f, 80, 138, 80); 1845 path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f); 1846 path1.lineTo(161.1764678955078125f, 100); 1847 path1.lineTo(161.1764678955078125f, 100); 1848 path1.lineTo(115.29412078857421875f, 100); 1849 path1.lineTo(115.29412078857421875f, 100); 1850 path1.lineTo(122.58908843994140625f, 82.2836456298828125f); 1851 path1.lineTo(122.58908843994140625f, 82.2836456298828125f); 1852 path1.close(); 1853 path1.moveTo(98.68194580078125f, 140.343841552734375f); 1854 path1.lineTo(115.29412078857421875f, 100); 1855 path1.lineTo(115.29412078857421875f, 100); 1856 path1.lineTo(97.9337615966796875f, 100); 1857 path1.lineTo(97.9337615966796875f, 100); 1858 path1.quadTo(88, 112.94264984130859375f, 88, 130); 1859 path1.quadTo(88, 131.544830322265625f, 88.08148956298828125f, 133.0560302734375f); 1860 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1861 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1862 path1.close(); 1863 path1.moveTo(136.969696044921875f, 166.6666717529296875f); 1864 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1865 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1866 path1.lineTo(93.45894622802734375f, 153.02825927734375f); 1867 path1.lineTo(93.45894622802734375f, 153.02825927734375f); 1868 path1.quadTo(96.94116973876953125f, 159.65185546875f, 102.64466094970703125f, 165.3553466796875f); 1869 path1.quadTo(110.7924652099609375f, 173.503143310546875f, 120.8179779052734375f, 177.1177825927734375f); 1870 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1871 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1872 path1.close(); 1873 path1.moveTo(175.8309783935546875f, 141.5211334228515625f); 1874 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1875 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1876 path1.lineTo(153.15728759765625f, 177.7956390380859375f); 1877 path1.lineTo(153.15728759765625f, 177.7956390380859375f); 1878 path1.quadTo(164.392425537109375f, 174.318267822265625f, 173.3553466796875f, 165.3553466796875f); 1879 path1.quadTo(177.805816650390625f, 160.9048614501953125f, 180.90380859375f, 155.8941650390625f); 1880 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1881 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1882 path1.close(); 1883 path1.moveTo(175.8309783935546875f, 141.5211334228515625f); 1884 path1.lineTo(187.8782806396484375f, 133.7258148193359375f); 1885 path1.lineTo(187.8782806396484375f, 133.7258148193359375f); 1886 path1.quadTo(188, 131.8880615234375f, 188, 130); 1887 path1.quadTo(188, 112.942657470703125f, 178.0662384033203125f, 100); 1888 path1.lineTo(161.1764678955078125f, 100); 1889 path1.lineTo(161.1764678955078125f, 100); 1890 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1891 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1892 path1.close(); 1893 1894 SkPath path2; 1895 path2.moveTo(174.117645263671875f, 100); 1896 path2.lineTo(161.1764678955078125f, 100); 1897 path2.lineTo(161.1764678955078125f, 100); 1898 path2.lineTo(155.1280364990234375f, 82.86279296875f); 1899 path2.lineTo(155.1280364990234375f, 82.86279296875f); 1900 path2.quadTo(153.14971923828125f, 82.15229034423828125f, 151.098419189453125f, 81.618133544921875f); 1901 path2.lineTo(143.5294189453125f, 100); 1902 path2.lineTo(143.5294189453125f, 100); 1903 path2.lineTo(161.1764678955078125f, 100); 1904 path2.lineTo(161.1764678955078125f, 100); 1905 path2.lineTo(168.23529052734375f, 120); 1906 path2.lineTo(168.23529052734375f, 120); 1907 path2.lineTo(181.1764678955078125f, 120); 1908 path2.lineTo(181.1764678955078125f, 120); 1909 path2.lineTo(186.3661956787109375f, 134.7042236328125f); 1910 path2.lineTo(186.3661956787109375f, 134.7042236328125f); 1911 path2.lineTo(187.8782806396484375f, 133.7258148193359375f); 1912 path2.lineTo(187.8782806396484375f, 133.7258148193359375f); 1913 path2.quadTo(188, 131.8880615234375f, 188, 130); 1914 path2.quadTo(188, 124.80947113037109375f, 187.080169677734375f, 120); 1915 path2.lineTo(181.1764678955078125f, 120); 1916 path2.lineTo(181.1764678955078125f, 120); 1917 path2.lineTo(174.117645263671875f, 100); 1918 path2.lineTo(174.117645263671875f, 100); 1919 path2.close(); 1920 path2.moveTo(88.91983795166015625f, 120); 1921 path2.lineTo(107.0588226318359375f, 120); 1922 path2.lineTo(107.0588226318359375f, 120); 1923 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1924 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1925 path2.lineTo(88.08148956298828125f, 133.0560302734375f); 1926 path2.lineTo(88.08148956298828125f, 133.0560302734375f); 1927 path2.quadTo(88, 131.544830322265625f, 88, 130); 1928 path2.quadTo(88, 124.80951690673828125f, 88.91983795166015625f, 120); 1929 path2.close(); 1930 path2.moveTo(96.67621612548828125f, 145.21490478515625f); 1931 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1932 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1933 path2.lineTo(120.68767547607421875f, 155.4727783203125f); 1934 path2.lineTo(120.68767547607421875f, 155.4727783203125f); 1935 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1936 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1937 path2.lineTo(96.67621612548828125f, 145.21490478515625f); 1938 path2.lineTo(96.67621612548828125f, 145.21490478515625f); 1939 path2.close(); 1940 path2.moveTo(113.232177734375f, 173.5789947509765625f); 1941 path2.quadTo(116.8802642822265625f, 175.69805908203125f, 120.8179779052734375f, 177.1177825927734375f); 1942 path2.lineTo(132.2864990234375f, 169.6969757080078125f); 1943 path2.lineTo(132.2864990234375f, 169.6969757080078125f); 1944 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1945 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1946 path2.lineTo(113.232177734375f, 173.5789947509765625f); 1947 path2.lineTo(113.232177734375f, 173.5789947509765625f); 1948 path2.close(); 1949 // FIXME : difficult data, circle back later 1950 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename); 1951 } 1952 1953 static void issue1418(skiatest::Reporter* reporter, const char* filename) { 1954 SkPath path1; 1955 path1.moveTo(0, 0); 1956 path1.lineTo(1, 0); 1957 path1.lineTo(1, 0); 1958 path1.lineTo(1, 1); 1959 path1.lineTo(1, 1); 1960 path1.lineTo(0, 1); 1961 path1.lineTo(0, 1); 1962 path1.lineTo(0, 0); 1963 path1.lineTo(0, 0); 1964 path1.close(); 1965 1966 SkPath path2; 1967 path2.moveTo(0.64644664525985717773f, -0.35355341434478759766f); 1968 path2.quadTo(0.79289329051971435547f, -0.50000005960464477539f, 1.0000001192092895508f, -0.50000005960464477539f); 1969 path2.quadTo(1.2071068286895751953f, -0.50000005960464477539f, 1.3535535335540771484f, -0.35355341434478759766f); 1970 path2.quadTo(1.5000001192092895508f, -0.20710679888725280762f, 1.5000001192092895508f, 0); 1971 path2.quadTo(1.5000001192092895508f, 0.20710679888725280762f, 1.3535535335540771484f, 0.35355341434478759766f); 1972 path2.quadTo(1.2071068286895751953f, 0.50000005960464477539f, 1.0000001192092895508f, 0.50000005960464477539f); 1973 path2.quadTo(0.79289329051971435547f, 0.50000005960464477539f, 0.64644664525985717773f, 0.35355341434478759766f); 1974 path2.quadTo(0.50000005960464477539f, 0.20710679888725280762f, 0.50000005960464477539f, 0); 1975 path2.quadTo(0.50000005960464477539f, -0.20710679888725280762f, 0.64644664525985717773f, -0.35355341434478759766f); 1976 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename); 1977 } 1978 1979 static void cubicOp85i(skiatest::Reporter* reporter, const char* filename) { 1980 SkPath path, pathB; 1981 path.setFillType(SkPath::kWinding_FillType); 1982 path.moveTo(3, 4); 1983 path.cubicTo(1, 5, 4, 3, 6, 4); 1984 path.close(); 1985 pathB.setFillType(SkPath::kWinding_FillType); 1986 pathB.moveTo(3, 4); 1987 pathB.cubicTo(4, 6, 4, 3, 5, 1); 1988 pathB.close(); 1989 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 1990 } 1991 1992 static void issue1418b(skiatest::Reporter* reporter, const char* filename) { 1993 SkPath path1; 1994 path1.moveTo(0, 0); 1995 path1.lineTo(1, 0); 1996 path1.lineTo(1, 1); 1997 path1.lineTo(0, 1); 1998 path1.lineTo(0, 0); 1999 path1.close(); 2000 path1.setFillType(SkPath::kWinding_FillType); 2001 SkPath path2; 2002 path2.moveTo(0.646446645f, -0.353553414f); 2003 path2.quadTo(0.792893291f, -0.50000006f, 1.00000012f, -0.50000006f); 2004 path2.quadTo(1.20710683f, -0.50000006f, 1.35355353f, -0.353553414f); 2005 path2.quadTo(1.50000012f, -0.207106799f, 1.50000012f, 0); 2006 path2.quadTo(1.50000012f, 0.207106799f, 1.35355353f, 0.353553414f); 2007 path2.quadTo(1.20710683f, 0.50000006f, 1.00000012f, 0.50000006f); 2008 path2.quadTo(0.792893291f, 0.50000006f, 0.646446645f, 0.353553414f); 2009 path2.quadTo(0.50000006f, 0.207106799f, 0.50000006f, 0); 2010 path2.quadTo(0.50000006f, -0.207106799f, 0.646446645f, -0.353553414f); 2011 path2.close(); 2012 path2.moveTo(1.00000012f, 0.50000006f); 2013 path2.lineTo(1.00000012f, 1.00000012f); 2014 path2.lineTo(0.50000006f, 1.00000012f); 2015 path2.quadTo(0.50000006f, 0.792893291f, 0.646446645f, 0.646446645f); 2016 path2.quadTo(0.792893291f, 0.50000006f, 1.00000012f, 0.50000006f); 2017 path2.close(); 2018 path2.setFillType(SkPath::kEvenOdd_FillType); 2019 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename); 2020 } 2021 2022 static void rectOp1i(skiatest::Reporter* reporter, const char* filename) { 2023 SkPath path, pathB; 2024 path.setFillType(SkPath::kWinding_FillType); 2025 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 2026 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction); 2027 pathB.setFillType(SkPath::kWinding_FillType); 2028 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 2029 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 2030 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2031 } 2032 2033 static void rectOp2i(skiatest::Reporter* reporter, const char* filename) { 2034 SkPath path, pathB; 2035 path.setFillType(SkPath::kEvenOdd_FillType); 2036 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 2037 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 2038 pathB.setFillType(SkPath::kWinding_FillType); 2039 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 2040 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 2041 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2042 } 2043 2044 static void rectOp3x(skiatest::Reporter* reporter, const char* filename) { 2045 SkPath path, pathB; 2046 path.setFillType(SkPath::kEvenOdd_FillType); 2047 path.moveTo(0, 0); 2048 path.lineTo(3, 0); 2049 path.lineTo(3, 3); 2050 path.lineTo(0, 3); 2051 path.close(); 2052 path.moveTo(2, 2); 2053 path.lineTo(3, 2); 2054 path.lineTo(3, 3); 2055 path.lineTo(2, 3); 2056 path.close(); 2057 pathB.setFillType(SkPath::kWinding_FillType); 2058 pathB.moveTo(1, 1); 2059 pathB.lineTo(3, 1); 2060 pathB.lineTo(3, 3); 2061 pathB.lineTo(1, 3); 2062 pathB.close(); 2063 pathB.moveTo(2, 2); 2064 pathB.lineTo(3, 2); 2065 pathB.lineTo(3, 3); 2066 pathB.lineTo(2, 3); 2067 pathB.close(); 2068 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename); 2069 } 2070 2071 static void issue1435(skiatest::Reporter* reporter, const char* filename) { 2072 SkPath path1; 2073 path1.moveTo(160, 60); 2074 path1.lineTo(220, 230); 2075 path1.lineTo(60, 120); 2076 path1.lineTo(260, 120); 2077 path1.lineTo(90, 230); 2078 path1.lineTo(160, 60); 2079 path1.close(); 2080 path1.setFillType(SkPath::kEvenOdd_FillType); 2081 2082 SkPath path2; 2083 path2.moveTo(142.589081f, 102.283646f); 2084 path2.quadTo(149.821579f, 100, 158, 100); 2085 path2.quadTo(167.156921f, 100, 175.128036f, 102.862793f); 2086 path2.lineTo(181.176468f, 120); 2087 path2.lineTo(135.294128f, 120); 2088 path2.lineTo(142.589081f, 102.283646f); 2089 path2.close(); 2090 path2.moveTo(118.681946f, 160.343842f); 2091 path2.lineTo(135.294128f, 120); 2092 path2.lineTo(117.933762f, 120); 2093 path2.quadTo(108, 132.942657f, 108, 150); 2094 path2.quadTo(108, 151.54483f, 108.08149f, 153.05603f); 2095 path2.lineTo(118.681946f, 160.343842f); 2096 path2.close(); 2097 path2.moveTo(156.969696f, 186.666672f); 2098 path2.lineTo(118.681946f, 160.343842f); 2099 path2.lineTo(113.458946f, 173.028259f); 2100 path2.quadTo(116.94117f, 179.651855f, 122.644661f, 185.355347f); 2101 path2.quadTo(130.792465f, 193.503143f, 140.817978f, 197.117783f); 2102 path2.lineTo(156.969696f, 186.666672f); 2103 path2.close(); 2104 path2.moveTo(195.830978f, 161.521133f); 2105 path2.lineTo(156.969696f, 186.666672f); 2106 path2.lineTo(173.157288f, 197.795639f); 2107 path2.quadTo(184.392426f, 194.318268f, 193.355347f, 185.355347f); 2108 path2.quadTo(197.805817f, 180.904861f, 200.903809f, 175.894165f); 2109 path2.lineTo(195.830978f, 161.521133f); 2110 path2.close(); 2111 path2.moveTo(195.830978f, 161.521133f); 2112 path2.lineTo(207.878281f, 153.725815f); 2113 path2.quadTo(208, 151.888062f, 208, 150); 2114 path2.quadTo(208, 132.942657f, 198.066238f, 120); 2115 path2.lineTo(181.176468f, 120); 2116 path2.lineTo(195.830978f, 161.521133f); 2117 path2.close(); 2118 path2.setFillType(SkPath::kEvenOdd_FillType); 2119 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename); 2120 } 2121 2122 static void skpkkiste_to716(skiatest::Reporter* reporter, const char* filename) { 2123 SkPath path; 2124 path.setFillType(SkPath::kEvenOdd_FillType); 2125 path.moveTo(1173, 284); 2126 path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f); 2127 path.lineTo(1174, 123.999496f); 2128 path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127); 2129 path.lineTo(1173, 284); 2130 path.close(); 2131 SkPath pathB; 2132 pathB.setFillType(SkPath::kWinding_FillType); 2133 pathB.moveTo(1340, 122); 2134 pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127); 2135 pathB.lineTo(1345, 284); 2136 pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289); 2137 pathB.lineTo(1178, 289); 2138 pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284); 2139 pathB.lineTo(1173, 127); 2140 pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122); 2141 pathB.lineTo(1340, 122); 2142 pathB.close(); 2143 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2144 } 2145 2146 static void loopEdge1(skiatest::Reporter* reporter, const char* filename) { 2147 SkPath path; 2148 path.setFillType(SkPath::kEvenOdd_FillType); 2149 path.moveTo(0,0); 2150 path.lineTo(3,0); 2151 path.lineTo(3,2); 2152 path.lineTo(1,2); 2153 path.lineTo(1,1); 2154 path.lineTo(2,1); 2155 path.lineTo(2,3); 2156 path.lineTo(0,3); 2157 path.close(); 2158 SkPath pathB; 2159 pathB.setFillType(SkPath::kEvenOdd_FillType); 2160 pathB.moveTo(1,2); 2161 pathB.lineTo(2,2); 2162 pathB.lineTo(2,4); 2163 pathB.lineTo(1,4); 2164 pathB.close(); 2165 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2166 } 2167 2168 static void loopEdge2(skiatest::Reporter* reporter, const char* filename) { 2169 SkPath path; 2170 path.setFillType(SkPath::kEvenOdd_FillType); 2171 path.moveTo(0,0); 2172 path.lineTo(3,0); 2173 path.lineTo(3,2); 2174 path.lineTo(1,2); 2175 path.lineTo(1,1); 2176 path.lineTo(2,1); 2177 path.lineTo(2,3); 2178 path.lineTo(0,3); 2179 path.close(); 2180 SkPath pathB; 2181 pathB.setFillType(SkPath::kEvenOdd_FillType); 2182 pathB.moveTo(1 - 1e-6f,2); 2183 pathB.lineTo(2 - 1e-6f,2); 2184 pathB.lineTo(2 - 1e-6f,4); 2185 pathB.lineTo(1 - 1e-6f,4); 2186 pathB.close(); 2187 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2188 } 2189 2190 static void cubicOp86i(skiatest::Reporter* reporter, const char* filename) { 2191 SkPath path, pathB; 2192 path.setFillType(SkPath::kWinding_FillType); 2193 path.moveTo(0, 4); 2194 path.cubicTo(3, 4, 6, 2, 5, 2); 2195 path.close(); 2196 pathB.setFillType(SkPath::kEvenOdd_FillType); 2197 pathB.moveTo(2, 6); 2198 pathB.cubicTo(2, 5, 4, 0, 4, 3); 2199 pathB.close(); 2200 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2201 } 2202 2203 static void cubicOp87u(skiatest::Reporter* reporter, const char* filename) { 2204 SkPath path, pathB; 2205 path.setFillType(SkPath::kWinding_FillType); 2206 path.moveTo(0,1); 2207 path.cubicTo(0,2, 2,0, 6,4); 2208 path.close(); 2209 pathB.setFillType(SkPath::kWinding_FillType); 2210 pathB.moveTo(0,2); 2211 pathB.cubicTo(4,6, 1,0, 2,0); 2212 pathB.close(); 2213 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2214 } 2215 2216 static void cubicOp88u(skiatest::Reporter* reporter, const char* filename) { 2217 SkPath path, pathB; 2218 path.setFillType(SkPath::kWinding_FillType); 2219 path.moveTo(0,1); 2220 path.cubicTo(2,5, 5,0, 6,4); 2221 path.close(); 2222 pathB.setFillType(SkPath::kWinding_FillType); 2223 pathB.moveTo(0,5); 2224 pathB.cubicTo(4,6, 1,0, 5,2); 2225 pathB.close(); 2226 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2227 } 2228 2229 static void cubicOp89u(skiatest::Reporter* reporter, const char* filename) { 2230 SkPath path, pathB; 2231 path.setFillType(SkPath::kWinding_FillType); 2232 path.moveTo(0, 3); 2233 path.cubicTo(1, 6, 5, 0, 6, 3); 2234 path.close(); 2235 pathB.setFillType(SkPath::kWinding_FillType); 2236 pathB.moveTo(0, 5); 2237 pathB.cubicTo(3, 6, 3, 0, 6, 1); 2238 pathB.close(); 2239 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2240 } 2241 2242 static void cubicOp90u(skiatest::Reporter* reporter, const char* filename) { 2243 SkPath path, pathB; 2244 path.setFillType(SkPath::kEvenOdd_FillType); 2245 path.moveTo(0, 5); 2246 path.cubicTo(1, 2, 5, 2, 4, 1); 2247 path.close(); 2248 pathB.setFillType(SkPath::kEvenOdd_FillType); 2249 pathB.moveTo(2, 5); 2250 pathB.cubicTo(1, 4, 5, 0, 2, 1); 2251 pathB.close(); 2252 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2253 } 2254 2255 static void cubicOp91u(skiatest::Reporter* reporter, const char* filename) { 2256 SkPath path, pathB; 2257 path.setFillType(SkPath::kWinding_FillType); 2258 path.moveTo(1, 6); 2259 path.cubicTo(0, 3, 6, 3, 5, 0); 2260 path.close(); 2261 pathB.setFillType(SkPath::kWinding_FillType); 2262 pathB.moveTo(3, 6); 2263 pathB.cubicTo(0, 5, 6, 1, 3, 0); 2264 pathB.close(); 2265 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2266 } 2267 2268 static void skpaaalgarve_org53(skiatest::Reporter* reporter, const char* filename) { 2269 SkPath path; 2270 path.setFillType(SkPath::kEvenOdd_FillType); 2271 path.moveTo(-1.24344979e-014f, 348); 2272 path.lineTo(258, 348); 2273 path.lineTo(258, 322); 2274 path.quadTo(258, 317.857849f, 255.072006f, 314.928009f); 2275 path.quadTo(252.142136f, 312, 248, 312); 2276 path.lineTo(1.77635684e-015f, 312); 2277 path.lineTo(-1.24344979e-014f, 348); 2278 path.close(); 2279 SkPath pathB; 2280 pathB.setFillType(SkPath::kWinding_FillType); 2281 pathB.moveTo(0, 312); 2282 pathB.lineTo(258, 312); 2283 pathB.lineTo(258, 348); 2284 pathB.lineTo(0, 348); 2285 pathB.close(); 2286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2287 } 2288 2289 static void skpabcspark_ca103(skiatest::Reporter* reporter, const char* filename) { 2290 SkPath path; 2291 path.setFillType(SkPath::kEvenOdd_FillType); 2292 path.moveTo(1.99840144e-015f, 494); 2293 path.lineTo(97, 494); 2294 path.quadTo(100.313705f, 494, 102.6576f, 491.657593f); 2295 path.quadTo(105, 489.313721f, 105, 486); 2296 path.lineTo(105, 425); 2297 path.quadTo(105, 421.686279f, 102.6576f, 419.342407f); 2298 path.quadTo(100.313705f, 417, 97, 417); 2299 path.lineTo(2.22044605e-016f, 417); 2300 path.lineTo(1.99840144e-015f, 494); 2301 path.close(); 2302 SkPath pathB; 2303 pathB.setFillType(SkPath::kWinding_FillType); 2304 pathB.moveTo(0, 417); 2305 pathB.lineTo(105, 417); 2306 pathB.lineTo(105, 494); 2307 pathB.lineTo(0, 494); 2308 pathB.close(); 2309 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2310 } 2311 2312 static void skpacesoftech_com47(skiatest::Reporter* reporter, const char* filename) { 2313 SkPath path; 2314 path.setFillType(SkPath::kEvenOdd_FillType); 2315 path.moveTo(670.537415f, 285); 2316 path.lineTo(670.387451f, 285); 2317 path.lineTo(596.315186f, 314.850708f); 2318 path.lineTo(626.19696f, 389); 2319 path.lineTo(626.346863f, 389); 2320 path.lineTo(700.419189f, 359.149261f); 2321 path.lineTo(670.537415f, 285); 2322 path.close(); 2323 SkPath pathB; 2324 pathB.setFillType(SkPath::kWinding_FillType); 2325 pathB.moveTo(663.318542f, 374.100616f); 2326 pathB.quadTo(647.950989f, 380.293671f, 632.705322f, 373.806305f); 2327 pathB.quadTo(617.459595f, 367.318909f, 611.266541f, 351.951355f); 2328 pathB.quadTo(605.073486f, 336.58374f, 611.560913f, 321.338074f); 2329 pathB.quadTo(618.048279f, 306.092407f, 633.415833f, 299.899353f); 2330 pathB.quadTo(648.783447f, 293.706299f, 664.029114f, 300.193665f); 2331 pathB.quadTo(679.27478f, 306.68103f, 685.467834f, 322.048645f); 2332 pathB.quadTo(691.660889f, 337.416199f, 685.173523f, 352.661896f); 2333 pathB.quadTo(678.686157f, 367.907562f, 663.318542f, 374.100616f); 2334 pathB.close(); 2335 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2336 } 2337 2338 static void skpact_com43(skiatest::Reporter* reporter, const char* filename) { 2339 SkPath path; 2340 path.setFillType(SkPath::kEvenOdd_FillType); 2341 path.moveTo(1.45716772e-016f, 924.336121f); 2342 path.lineTo(-1.11022302e-016f, 920); 2343 path.lineTo(6, 920); 2344 path.lineTo(6, 926); 2345 path.lineTo(1.66389287f, 926); 2346 path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f); 2347 path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f); 2348 path.close(); 2349 path.moveTo(1, 921); 2350 path.lineTo(5, 921); 2351 path.lineTo(5, 925); 2352 path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921); 2353 path.close(); 2354 SkPath pathB; 2355 pathB.setFillType(SkPath::kWinding_FillType); 2356 pathB.moveTo(-1, 920); 2357 pathB.lineTo(0, 920); 2358 pathB.lineTo(3, 927); 2359 pathB.lineTo(-1, 927); 2360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2361 } 2362 2363 static void skpadbox_lt8(skiatest::Reporter* reporter, const char* filename) { 2364 SkPath path; 2365 path.setFillType(SkPath::kEvenOdd_FillType); 2366 path.moveTo(320.097229f, 628.573669f); 2367 path.lineTo(610.227173f, 85.7786865f); 2368 path.lineTo(946.652588f, 265.601807f); 2369 path.lineTo(656.522644f, 808.39679f); 2370 path.lineTo(320.097229f, 628.573669f); 2371 path.close(); 2372 SkPath pathB; 2373 pathB.setFillType(SkPath::kInverseWinding_FillType); 2374 pathB.moveTo(333.866608f, 623.496155f); 2375 pathB.lineTo(613.368042f, 100.585754f); 2376 pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f); 2377 pathB.lineTo(932.633057f, 269.854553f); 2378 pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f); 2379 pathB.lineTo(653.631897f, 794.414307f); 2380 pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f); 2381 pathB.lineTo(334.366943f, 625.145508f); 2382 pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f); 2383 pathB.close(); 2384 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2385 } 2386 2387 static void skpadindex_de4(skiatest::Reporter* reporter, const char* filename) { 2388 SkPath path; 2389 path.setFillType(SkPath::kEvenOdd_FillType); 2390 path.moveTo(0, 926); 2391 path.lineTo(0, 0); 2392 path.lineTo(1280, 0); 2393 path.lineTo(1280, 926); 2394 path.lineTo(0, 926); 2395 path.close(); 2396 SkPath pathB; 2397 pathB.setFillType(SkPath::kWinding_FillType); 2398 pathB.moveTo(0, 312); 2399 pathB.lineTo(8.20486257e-015f, 178); 2400 pathB.lineTo(49, 178); 2401 pathB.lineTo(49, 312); 2402 pathB.close(); 2403 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2404 } 2405 2406 static void skpadithya_putr4_blogspot_com551(skiatest::Reporter* reporter, const char* filename) { 2407 SkPath path; 2408 path.setFillType(SkPath::kEvenOdd_FillType); 2409 path.moveTo(205.605804f, 142.334625f); 2410 path.lineTo(254.665359f, 85.6058044f); 2411 path.lineTo(311.394196f, 134.665359f); 2412 path.lineTo(262.334625f, 191.39418f); 2413 path.lineTo(205.605804f, 142.334625f); 2414 path.close(); 2415 SkPath pathB; 2416 pathB.setFillType(SkPath::kWinding_FillType); 2417 pathB.moveTo(283.407959f, 110.462646f); 2418 pathB.cubicTo(298.864319f, 123.829437f, 300.558258f, 147.195221f, 287.191467f, 162.651581f); 2419 pathB.lineTo(286.537354f, 163.407959f); 2420 pathB.cubicTo(273.170563f, 178.864334f, 249.804779f, 180.558258f, 234.348419f, 167.191467f); 2421 pathB.lineTo(233.592026f, 166.537338f); 2422 pathB.cubicTo(218.135666f, 153.170547f, 216.441727f, 129.804779f, 229.808517f, 114.348412f); 2423 pathB.lineTo(230.462646f, 113.592026f); 2424 pathB.cubicTo(243.829437f, 98.1356659f, 267.195221f, 96.4417267f, 282.651581f, 109.808517f); 2425 pathB.lineTo(283.407959f, 110.462646f); 2426 pathB.close(); 2427 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2428 } 2429 2430 static void skpadspert_de11(skiatest::Reporter* reporter, const char* filename) { 2431 SkPath path; 2432 path.setFillType(SkPath::kEvenOdd_FillType); 2433 path.moveTo(-4.4408921e-016f, 682.5f); 2434 path.lineTo(30.5f, 682.5f); 2435 path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f); 2436 path.lineTo(34.5f, 486.5f); 2437 path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f); 2438 path.lineTo(0, 482.5f); 2439 path.lineTo(-4.4408921e-016f, 682.5f); 2440 path.close(); 2441 SkPath pathB; 2442 pathB.setFillType(SkPath::kWinding_FillType); 2443 pathB.moveTo(0, 482); 2444 pathB.lineTo(35, 482); 2445 pathB.lineTo(35, 683); 2446 pathB.lineTo(0, 683); 2447 pathB.close(); 2448 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2449 } 2450 2451 static void skpaiaigames_com870(skiatest::Reporter* reporter, const char* filename) { 2452 SkPath path; 2453 path.setFillType(SkPath::kEvenOdd_FillType); 2454 path.moveTo(324.071075f, 845.071045f); 2455 path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f); 2456 path.lineTo(325, 842.127197f); 2457 path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f); 2458 path.lineTo(324.071075f, 845.071045f); 2459 path.close(); 2460 path.moveTo(323.363953f, 714.636047f); 2461 path.lineTo(324.071075f, 713.928955f); 2462 path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f); 2463 path.lineTo(325, 716.872803f); 2464 path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f); 2465 path.close(); 2466 SkPath pathB; 2467 pathB.setFillType(SkPath::kWinding_FillType); 2468 pathB.moveTo(317, 711); 2469 pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721); 2470 pathB.lineTo(327, 838); 2471 pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848); 2472 pathB.lineTo(155, 848); 2473 pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838); 2474 pathB.lineTo(145, 721); 2475 pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711); 2476 pathB.lineTo(317, 711); 2477 pathB.close(); 2478 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2479 } 2480 2481 static void cubicOp92i(skiatest::Reporter* reporter, const char* filename) { 2482 SkPath path, pathB; 2483 path.setFillType(SkPath::kWinding_FillType); 2484 path.moveTo(0, 1); 2485 path.cubicTo(2, 6, 4, 1, 5, 4); 2486 path.close(); 2487 pathB.setFillType(SkPath::kWinding_FillType); 2488 pathB.moveTo(1, 4); 2489 pathB.cubicTo(4, 5, 1, 0, 6, 2); 2490 pathB.close(); 2491 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2492 } 2493 2494 static void cubicOp93d(skiatest::Reporter* reporter, const char* filename) { 2495 SkPath path, pathB; 2496 path.setFillType(SkPath::kWinding_FillType); 2497 path.moveTo(0, 1); 2498 path.cubicTo(1, 6, 4, 1, 4, 3); 2499 path.close(); 2500 pathB.setFillType(SkPath::kWinding_FillType); 2501 pathB.moveTo(1, 4); 2502 pathB.cubicTo(3, 4, 1, 0, 6, 1); 2503 pathB.close(); 2504 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 2505 } 2506 2507 static void cubicOp94u(skiatest::Reporter* reporter, const char* filename) { 2508 SkPath path, pathB; 2509 path.setFillType(SkPath::kEvenOdd_FillType); 2510 path.moveTo(0, 3); 2511 path.cubicTo(2, 3, 5, 0, 5, 3); 2512 path.close(); 2513 pathB.setFillType(SkPath::kEvenOdd_FillType); 2514 pathB.moveTo(0, 5); 2515 pathB.cubicTo(3, 5, 3, 0, 3, 2); 2516 pathB.close(); 2517 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2518 } 2519 2520 static void skpadbox_lt15(skiatest::Reporter* reporter, const char* filename) { 2521 SkPath path; 2522 path.setFillType(SkPath::kEvenOdd_FillType); 2523 path.moveTo(333.292084f, 624.570984f); 2524 path.lineTo(614.229797f, 98.9735107f); 2525 path.lineTo(933.457764f, 269.604431f); 2526 path.lineTo(652.52002f, 795.201904f); 2527 path.lineTo(333.292084f, 624.570984f); 2528 path.close(); 2529 SkPath pathB; 2530 pathB.setFillType(SkPath::kWinding_FillType); 2531 pathB.moveTo(613.368042f, 100.585754f); 2532 pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f); 2533 pathB.lineTo(932.633057f, 269.854553f); 2534 pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f); 2535 pathB.lineTo(653.631897f, 794.414307f); 2536 pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f); 2537 pathB.lineTo(334.366943f, 625.145508f); 2538 pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f); 2539 pathB.lineTo(613.368042f, 100.585754f); 2540 pathB.close(); 2541 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2542 } 2543 2544 static void skpadoption_org196(skiatest::Reporter* reporter, const char* filename) { 2545 SkPath path; 2546 path.setFillType(SkPath::kEvenOdd_FillType); 2547 path.moveTo(802, 367); 2548 path.lineTo(802, 324); 2549 path.lineTo(956, 324); 2550 path.lineTo(956, 371); 2551 path.quadTo(956, 373.071075f, 954.536011f, 374.536011f); 2552 path.quadTo(953.071045f, 376, 951, 376); 2553 path.lineTo(811, 376); 2554 path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367); 2555 path.close(); 2556 SkPath pathB; 2557 pathB.setFillType(SkPath::kInverseWinding_FillType); 2558 pathB.moveTo(803, 326); 2559 pathB.lineTo(955, 326); 2560 pathB.lineTo(955, 370); 2561 pathB.cubicTo(955, 372.761414f, 952.761414f, 375, 950, 375); 2562 pathB.lineTo(808, 375); 2563 pathB.cubicTo(805.238586f, 375, 803, 372.761414f, 803, 370); 2564 pathB.lineTo(803, 326); 2565 pathB.close(); 2566 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2567 } 2568 2569 static void skpadspert_net23(skiatest::Reporter* reporter, const char* filename) { 2570 SkPath path; 2571 path.setFillType(SkPath::kEvenOdd_FillType); 2572 path.moveTo(-2.220446e-018f, 483.5f); 2573 path.lineTo(0, 482.5f); 2574 path.lineTo(30.5f, 482.5f); 2575 path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f); 2576 path.lineTo(34.5f, 678.5f); 2577 path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f); 2578 path.lineTo(-4.4408921e-016f, 682.5f); 2579 path.lineTo(-4.41868766e-016f, 681.5f); 2580 path.lineTo(30.5f, 681.5f); 2581 path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f); 2582 path.lineTo(33.5f, 486.5f); 2583 path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f); 2584 path.lineTo(-2.220446e-018f, 483.5f); 2585 path.close(); 2586 SkPath pathB; 2587 pathB.setFillType(SkPath::kWinding_FillType); 2588 pathB.moveTo(0, 482); 2589 pathB.lineTo(35, 482); 2590 pathB.lineTo(35, 683); 2591 pathB.lineTo(0, 683); 2592 pathB.close(); 2593 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2594 } 2595 2596 static void skpadventistmission_org572(skiatest::Reporter* reporter, const char* filename) { 2597 SkPath path; 2598 path.setFillType(SkPath::kEvenOdd_FillType); 2599 path.moveTo(1182.00037f, 926); 2600 path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924); 2601 path.lineTo(938, 924); 2602 path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926); 2603 path.lineTo(1182.00037f, 926); 2604 path.close(); 2605 SkPath pathB; 2606 pathB.setFillType(SkPath::kWinding_FillType); 2607 pathB.moveTo(934, 924); 2608 pathB.lineTo(1182, 924); 2609 pathB.lineTo(1182, 926); 2610 pathB.lineTo(934, 926); 2611 pathB.close(); 2612 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2613 } 2614 2615 static void skpagentxsites_com55(skiatest::Reporter* reporter, const char* filename) { 2616 SkPath path; 2617 path.setFillType(SkPath::kEvenOdd_FillType); 2618 path.moveTo(925, 27); 2619 path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28); 2620 path.lineTo(924, 55); 2621 path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56); 2622 path.lineTo(1103, 56); 2623 path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55); 2624 path.lineTo(1104, 28); 2625 path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27); 2626 path.lineTo(925, 27); 2627 path.close(); 2628 SkPath pathB; 2629 pathB.setFillType(SkPath::kWinding_FillType); 2630 pathB.moveTo(1103, 27); 2631 pathB.cubicTo(1104.10461f, 27, 1105, 27.8954315f, 1105, 29); 2632 pathB.lineTo(1105, 54); 2633 pathB.cubicTo(1105, 55.1045685f, 1104.10461f, 56, 1103, 56); 2634 pathB.lineTo(926, 56); 2635 pathB.cubicTo(924.895447f, 56, 924, 55.1045685f, 924, 54); 2636 pathB.lineTo(924, 29); 2637 pathB.cubicTo(924, 27.8954315f, 924.895447f, 27, 926, 27); 2638 pathB.lineTo(1103, 27); 2639 pathB.close(); 2640 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2641 } 2642 2643 static void skpbakosoft_com10(skiatest::Reporter* reporter, const char* filename) { 2644 SkPath path; 2645 path.setFillType(SkPath::kEvenOdd_FillType); 2646 path.moveTo(190, 170); 2647 path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190); 2648 path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210); 2649 path.lineTo(370, 210); 2650 path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190); 2651 path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170); 2652 path.lineTo(190, 170); 2653 path.close(); 2654 SkPath pathB; 2655 pathB.setFillType(SkPath::kWinding_FillType); 2656 pathB.moveTo(210, 190); 2657 pathB.quadTo(210, 198.284271f, 204.142136f, 204.142136f); 2658 pathB.quadTo(198.284271f, 210, 190, 210); 2659 pathB.quadTo(181.715729f, 210, 175.857864f, 204.142136f); 2660 pathB.quadTo(170, 198.284271f, 170, 190); 2661 pathB.quadTo(170, 181.715729f, 175.857864f, 175.857864f); 2662 pathB.quadTo(181.715729f, 170, 190, 170); 2663 pathB.quadTo(198.284271f, 170, 204.142136f, 175.857864f); 2664 pathB.quadTo(210, 181.715729f, 210, 190); 2665 pathB.close(); 2666 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2667 } 2668 2669 static void skpbambootheme_com12(skiatest::Reporter* reporter, const char* filename) { 2670 SkPath path; 2671 path.setFillType(SkPath::kEvenOdd_FillType); 2672 path.moveTo(47.8780937f, 58); 2673 path.lineTo(0, 58); 2674 path.lineTo(-8.65973959e-015f, 96.9914017f); 2675 path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f); 2676 path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58); 2677 path.close(); 2678 SkPath pathB; 2679 pathB.setFillType(SkPath::kEvenOdd_FillType); 2680 pathB.moveTo(-1, -3); 2681 pathB.lineTo(-1, -3); 2682 pathB.cubicTo(26.6142502f, -3, 49, 19.3857498f, 49, 47); 2683 pathB.lineTo(49, 47); 2684 pathB.cubicTo(49, 74.6142502f, 26.6142502f, 97, -1, 97); 2685 pathB.lineTo(-1, 97); 2686 pathB.cubicTo(-28.6142502f, 97, -51, 74.6142502f, -51, 47); 2687 pathB.lineTo(-51, 47); 2688 pathB.cubicTo(-51, 19.3857498f, -28.6142502f, -3, -1, -3); 2689 pathB.close(); 2690 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2691 } 2692 2693 static void skpakmmos_ru100(skiatest::Reporter* reporter, const char* filename) { 2694 SkPath path; 2695 path.setFillType(SkPath::kEvenOdd_FillType); 2696 path.moveTo(693.000488f, 926); 2697 path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925); 2698 path.lineTo(578, 925); 2699 path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926); 2700 path.lineTo(693.000488f, 926); 2701 path.close(); 2702 SkPath pathB; 2703 pathB.setFillType(SkPath::kWinding_FillType); 2704 pathB.moveTo(575, 925); 2705 pathB.lineTo(693, 925); 2706 pathB.lineTo(693, 926); 2707 pathB.lineTo(575, 926); 2708 pathB.close(); 2709 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2710 } 2711 2712 static void skpcarpetplanet_ru22(skiatest::Reporter* reporter, const char* filename) { 2713 SkPath path; 2714 path.setFillType(SkPath::kEvenOdd_FillType); 2715 path.moveTo(195, 785); 2716 path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912); 2717 path.lineTo(67, 913); 2718 path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926); 2719 path.lineTo(322, 926); 2720 path.lineTo(322, 896.048035f); 2721 path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785); 2722 path.close(); 2723 SkPath pathB; 2724 pathB.setFillType(SkPath::kWinding_FillType); 2725 pathB.moveTo(195, 785); 2726 pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913); 2727 pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041); 2728 pathB.lineTo(194, 1041); 2729 pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913); 2730 pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785); 2731 pathB.lineTo(195, 785); 2732 pathB.close(); 2733 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2734 } 2735 2736 static void skpcarrot_is24(skiatest::Reporter* reporter, const char* filename) { 2737 SkPath path; 2738 path.setFillType(SkPath::kEvenOdd_FillType); 2739 path.moveTo(945, 597); 2740 path.quadTo(913.93396f, 597, 891.96698f, 618.96698f); 2741 path.quadTo(870, 640.93396f, 870, 672); 2742 path.quadTo(870, 703.06604f, 891.96698f, 725.03302f); 2743 path.quadTo(913.93396f, 747, 945, 747); 2744 path.quadTo(976.06604f, 747, 998.03302f, 725.03302f); 2745 path.quadTo(1020, 703.06604f, 1020, 672); 2746 path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f); 2747 path.quadTo(976.06604f, 597, 945, 597); 2748 path.close(); 2749 SkPath pathB; 2750 pathB.setFillType(SkPath::kWinding_FillType); 2751 pathB.moveTo(945.080994f, 597.161987f); 2752 pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f); 2753 pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f); 2754 pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f); 2755 pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f); 2756 pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f); 2757 pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f); 2758 pathB.close(); 2759 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2760 } 2761 2762 static void skpbangalorenest_com4(skiatest::Reporter* reporter, const char* filename) { 2763 SkPath path; 2764 path.setFillType(SkPath::kEvenOdd_FillType); 2765 path.moveTo(0, 926); 2766 path.lineTo(0, 0); 2767 path.lineTo(1265, 0); 2768 path.lineTo(1265, 926); 2769 path.lineTo(0, 926); 2770 path.close(); 2771 SkPath pathB; 2772 pathB.setFillType(SkPath::kWinding_FillType); 2773 pathB.moveTo(0, 290); 2774 pathB.lineTo(-2.64514972e-014f, 146); 2775 pathB.lineTo(30, 146); 2776 pathB.lineTo(30, 290); 2777 pathB.close(); 2778 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2779 } 2780 2781 static void skpbenzoteh_ru152(skiatest::Reporter* reporter, const char* filename) { 2782 SkPath path; 2783 path.setFillType(SkPath::kEvenOdd_FillType); 2784 path.moveTo(883, 23); 2785 path.lineTo(883, 0); 2786 path.lineTo(1122.5f, 0); 2787 path.lineTo(1122.5f, 25.2136822f); 2788 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f); 2789 path.quadTo(1120.07104f, 28, 1118, 28); 2790 path.lineTo(888, 28); 2791 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2792 path.quadTo(883, 25.0710678f, 883, 23); 2793 path.close(); 2794 SkPath pathB; 2795 pathB.setFillType(SkPath::kWinding_FillType); 2796 pathB.moveTo(883, 0); 2797 pathB.lineTo(1123, 0); 2798 pathB.lineTo(1123, 23); 2799 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f); 2800 pathB.quadTo(1120.07104f, 28, 1118, 28); 2801 pathB.lineTo(888, 28); 2802 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2803 pathB.quadTo(883, 25.0710678f, 883, 23); 2804 pathB.close(); 2805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2806 } 2807 2808 static void skpbestred_ru37(skiatest::Reporter* reporter, const char* filename) { 2809 SkPath path; 2810 path.setFillType(SkPath::kEvenOdd_FillType); 2811 path.moveTo(883, 23); 2812 path.lineTo(883, 0); 2813 path.lineTo(1122.5f, 0); 2814 path.lineTo(1122.5f, 25.2136822f); 2815 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f); 2816 path.quadTo(1120.07104f, 28, 1118, 28); 2817 path.lineTo(888, 28); 2818 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2819 path.quadTo(883, 25.0710678f, 883, 23); 2820 path.close(); 2821 SkPath pathB; 2822 pathB.setFillType(SkPath::kWinding_FillType); 2823 pathB.moveTo(883, 0); 2824 pathB.lineTo(1123, 0); 2825 pathB.lineTo(1123, 23); 2826 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f); 2827 pathB.quadTo(1120.07104f, 28, 1118, 28); 2828 pathB.lineTo(888, 28); 2829 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2830 pathB.quadTo(883, 25.0710678f, 883, 23); 2831 pathB.close(); 2832 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2833 } 2834 2835 static void skpbingoentertainment_net189(skiatest::Reporter* reporter, const char* filename) { 2836 SkPath path; 2837 path.setFillType(SkPath::kEvenOdd_FillType); 2838 path.moveTo(896, 745.38678f); 2839 path.lineTo(896, 873.38678f); 2840 path.lineTo(922.567993f, 876.683716f); 2841 path.lineTo(922.567993f, 748.683716f); 2842 path.lineTo(896, 745.38678f); 2843 path.close(); 2844 SkPath pathB; 2845 pathB.setFillType(SkPath::kWinding_FillType); 2846 pathB.moveTo(899.200928f, 745.783997f); 2847 pathB.cubicTo(897.119385f, 745.525696f, 895.432007f, 752.031982f, 895.432007f, 760.316284f); 2848 pathB.lineTo(895.432007f, 858.316284f); 2849 pathB.cubicTo(895.432007f, 866.600586f, 897.119385f, 873.525696f, 899.200928f, 873.783997f); 2850 pathB.lineTo(918.799133f, 876.216003f); 2851 pathB.cubicTo(920.880615f, 876.474304f, 922.567993f, 869.968018f, 922.567993f, 861.683716f); 2852 pathB.lineTo(922.567993f, 763.683716f); 2853 pathB.cubicTo(922.567993f, 755.399414f, 920.880615f, 748.474304f, 918.799133f, 748.216003f); 2854 pathB.lineTo(899.200928f, 745.783997f); 2855 pathB.close(); 2856 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2857 } 2858 2859 static void skpcarrefour_ro62(skiatest::Reporter* reporter, const char* filename) { 2860 SkPath path; 2861 path.setFillType(SkPath::kEvenOdd_FillType); 2862 path.moveTo(1104, 453); 2863 path.lineTo(399, 453); 2864 path.lineTo(399, 657); 2865 path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666); 2866 path.lineTo(1095, 666); 2867 path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657); 2868 path.lineTo(1104, 453); 2869 path.close(); 2870 SkPath pathB; 2871 pathB.setFillType(SkPath::kInverseWinding_FillType); 2872 pathB.moveTo(400, 453); 2873 pathB.lineTo(1103, 453); 2874 pathB.lineTo(1103, 666); 2875 pathB.lineTo(406, 666); 2876 pathB.cubicTo(402.686279f, 666, 400, 663.313721f, 400, 660); 2877 pathB.lineTo(400, 453); 2878 pathB.close(); 2879 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2880 } 2881 2882 static void skpcaffelavazzait_com_ua21(skiatest::Reporter* reporter, const char* filename) { 2883 SkPath path; 2884 path.setFillType(SkPath::kEvenOdd_FillType); 2885 path.moveTo(883, 23); 2886 path.lineTo(883, 0); 2887 path.lineTo(1122.5f, 0); 2888 path.lineTo(1122.5f, 25.2136822f); 2889 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f); 2890 path.quadTo(1120.07104f, 28, 1118, 28); 2891 path.lineTo(888, 28); 2892 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2893 path.quadTo(883, 25.0710678f, 883, 23); 2894 path.close(); 2895 SkPath pathB; 2896 pathB.setFillType(SkPath::kWinding_FillType); 2897 pathB.moveTo(883, 0); 2898 pathB.lineTo(1123, 0); 2899 pathB.lineTo(1123, 23); 2900 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f); 2901 pathB.quadTo(1120.07104f, 28, 1118, 28); 2902 pathB.lineTo(888, 28); 2903 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2904 pathB.quadTo(883, 25.0710678f, 883, 23); 2905 pathB.close(); 2906 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2907 } 2908 2909 static void skpcamcorder_kz21(skiatest::Reporter* reporter, const char* filename) { 2910 SkPath path; 2911 path.setFillType(SkPath::kEvenOdd_FillType); 2912 path.moveTo(883, 23); 2913 path.lineTo(883, 0); 2914 path.lineTo(1122.5f, 0); 2915 path.lineTo(1122.5f, 25.2136822f); 2916 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f); 2917 path.quadTo(1120.07104f, 28, 1118, 28); 2918 path.lineTo(888, 28); 2919 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2920 path.quadTo(883, 25.0710678f, 883, 23); 2921 path.close(); 2922 SkPath pathB; 2923 pathB.setFillType(SkPath::kWinding_FillType); 2924 pathB.moveTo(883, 0); 2925 pathB.lineTo(1123, 0); 2926 pathB.lineTo(1123, 23); 2927 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f); 2928 pathB.quadTo(1120.07104f, 28, 1118, 28); 2929 pathB.lineTo(888, 28); 2930 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f); 2931 pathB.quadTo(883, 25.0710678f, 883, 23); 2932 pathB.close(); 2933 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2934 } 2935 2936 static void skpcavablar_net563(skiatest::Reporter* reporter, const char* filename) { 2937 SkPath path; 2938 path.setFillType(SkPath::kEvenOdd_FillType); 2939 path.moveTo(160.000488f, 918); 2940 path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917); 2941 path.lineTo(94, 917); 2942 path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918); 2943 path.lineTo(160.000488f, 918); 2944 path.close(); 2945 SkPath pathB; 2946 pathB.setFillType(SkPath::kWinding_FillType); 2947 pathB.moveTo(91, 917); 2948 pathB.lineTo(160, 917); 2949 pathB.lineTo(160, 918); 2950 pathB.lineTo(91, 918); 2951 pathB.close(); 2952 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2953 } 2954 2955 static void skpinsomnia_gr72(skiatest::Reporter* reporter, const char* filename) { 2956 SkPath path; 2957 path.setFillType(SkPath::kEvenOdd_FillType); 2958 path.moveTo(1138, 231); 2959 path.lineTo(1137, 243.625748f); 2960 path.lineTo(1137, 926); 2961 path.lineTo(1139, 926); 2962 path.lineTo(1139, 231); 2963 path.lineTo(1138, 231); 2964 path.close(); 2965 SkPath pathB; 2966 pathB.setFillType(SkPath::kWinding_FillType); 2967 pathB.moveTo(1139, 231); 2968 pathB.lineTo(1138, 231); 2969 pathB.lineTo(633, 6101); 2970 pathB.lineTo(1139, 6607); 2971 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 2972 } 2973 2974 static void cubicOp95u(skiatest::Reporter* reporter, const char* filename) { 2975 SkPath path, pathB; 2976 path.setFillType(SkPath::kEvenOdd_FillType); 2977 path.moveTo(0, 2); 2978 path.cubicTo(2, 3, 5, 1, 3, 2); 2979 path.close(); 2980 pathB.setFillType(SkPath::kEvenOdd_FillType); 2981 pathB.moveTo(1, 5); 2982 pathB.cubicTo(2, 3, 2, 0, 3, 2); 2983 pathB.close(); 2984 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 2985 } 2986 2987 static void cubicOp96d(skiatest::Reporter* reporter, const char* filename) { 2988 SkPath path, pathB; 2989 path.setFillType(SkPath::kEvenOdd_FillType); 2990 path.moveTo(1, 6); 2991 path.cubicTo(0, 3, 6, 3, 5, 0); 2992 path.close(); 2993 pathB.setFillType(SkPath::kEvenOdd_FillType); 2994 pathB.moveTo(3, 6); 2995 pathB.cubicTo(0, 5, 6, 1, 3, 0); 2996 pathB.close(); 2997 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 2998 } 2999 3000 static void cubicOp97x(skiatest::Reporter* reporter, const char* filename) { 3001 SkPath path, pathB; 3002 path.setFillType(SkPath::kEvenOdd_FillType); 3003 path.moveTo(0, 2); 3004 path.cubicTo(0, 6, 2, 1, 2, 1); 3005 path.close(); 3006 pathB.setFillType(SkPath::kEvenOdd_FillType); 3007 pathB.moveTo(1, 2); 3008 pathB.cubicTo(1, 2, 2, 0, 6, 0); 3009 pathB.close(); 3010 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename); 3011 } 3012 3013 static void cubicOp98x(skiatest::Reporter* reporter, const char* filename) { 3014 SkPath path, pathB; 3015 path.setFillType(SkPath::kEvenOdd_FillType); 3016 path.moveTo(0, 3); 3017 path.cubicTo(3, 6, 4, 1, 6, 3); 3018 path.close(); 3019 pathB.setFillType(SkPath::kEvenOdd_FillType); 3020 pathB.moveTo(1, 4); 3021 pathB.cubicTo(3, 6, 3, 0, 6, 3); 3022 pathB.close(); 3023 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename); 3024 } 3025 3026 static void cubicOp99(skiatest::Reporter* reporter, const char* filename) { 3027 SkPath path, pathB; 3028 path.setFillType(SkPath::kWinding_FillType); 3029 path.moveTo(3,6); 3030 path.cubicTo(0,3, 6,5, 5,4); 3031 path.close(); 3032 pathB.setFillType(SkPath::kWinding_FillType); 3033 pathB.moveTo(5,6); 3034 pathB.cubicTo(4,5, 6,3, 3,0); 3035 pathB.close(); 3036 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3037 } 3038 3039 static void cubicOp100(skiatest::Reporter* reporter, const char* filename) { 3040 SkPath path, pathB; 3041 path.setFillType(SkPath::kWinding_FillType); 3042 path.moveTo(0,1); 3043 path.cubicTo(0,2, 2,1, 4,2); 3044 path.close(); 3045 pathB.setFillType(SkPath::kWinding_FillType); 3046 pathB.moveTo(1,2); 3047 pathB.cubicTo(2,4, 1,0, 2,0); 3048 pathB.close(); 3049 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3050 } 3051 3052 static void cubicOp101(skiatest::Reporter* reporter, const char* filename) { 3053 SkPath path, pathB; 3054 path.setFillType(SkPath::kWinding_FillType); 3055 path.moveTo(0, 1); 3056 path.cubicTo(2, 3, 2, 1, 5, 3); 3057 path.close(); 3058 pathB.setFillType(SkPath::kWinding_FillType); 3059 pathB.moveTo(1, 2); 3060 pathB.cubicTo(3, 5, 1, 0, 3, 2); 3061 pathB.close(); 3062 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3063 } 3064 3065 static void cubicOp102(skiatest::Reporter* reporter, const char* filename) { 3066 SkPath path, pathB; 3067 path.setFillType(SkPath::kWinding_FillType); 3068 path.moveTo(0,1); 3069 path.cubicTo(1,2, 1,0, 3,0); 3070 path.close(); 3071 pathB.setFillType(SkPath::kWinding_FillType); 3072 pathB.moveTo(0,1); 3073 pathB.cubicTo(0,3, 1,0, 2,1); 3074 pathB.close(); 3075 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3076 } 3077 3078 static void cubicOp103(skiatest::Reporter* reporter, const char* filename) { 3079 SkPath path, pathB; 3080 path.setFillType(SkPath::kWinding_FillType); 3081 path.moveTo(0,1); 3082 path.cubicTo(1,5, 2,0, 2,1); 3083 path.close(); 3084 pathB.setFillType(SkPath::kWinding_FillType); 3085 pathB.moveTo(0,2); 3086 pathB.cubicTo(1,2, 1,0, 5,1); 3087 pathB.close(); 3088 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3089 } 3090 3091 static void cubicOp104(skiatest::Reporter* reporter, const char* filename) { 3092 SkPath path, pathB; 3093 path.setFillType(SkPath::kWinding_FillType); 3094 path.moveTo(0,1); 3095 path.cubicTo(0,6, 4,0, 6,1); 3096 path.close(); 3097 pathB.setFillType(SkPath::kWinding_FillType); 3098 pathB.moveTo(0,4); 3099 pathB.cubicTo(1,6, 1,0, 6,0); 3100 pathB.close(); 3101 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3102 } 3103 3104 static void cubicOp105(skiatest::Reporter* reporter, const char* filename) { 3105 SkPath path, pathB; 3106 path.setFillType(SkPath::kWinding_FillType); 3107 path.moveTo(0,1); 3108 path.cubicTo(0,4, 6,5, 2,0); 3109 path.close(); 3110 pathB.setFillType(SkPath::kWinding_FillType); 3111 pathB.moveTo(5,6); 3112 pathB.cubicTo(0,2, 1,0, 4,0); 3113 pathB.close(); 3114 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3115 } 3116 3117 static void cubicOp106(skiatest::Reporter* reporter, const char* filename) { 3118 SkPath path, pathB; 3119 path.setFillType(SkPath::kWinding_FillType); 3120 path.moveTo(0, 1); 3121 path.cubicTo(4, 6, 2, 1, 2, 0); 3122 path.close(); 3123 pathB.setFillType(SkPath::kWinding_FillType); 3124 pathB.moveTo(1, 2); 3125 pathB.cubicTo(0, 2, 1, 0, 6, 4); 3126 pathB.close(); 3127 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3128 } 3129 3130 static void cubicOp107(skiatest::Reporter* reporter, const char* filename) { 3131 SkPath path, pathB; 3132 path.setFillType(SkPath::kWinding_FillType); 3133 path.moveTo(0, 1); 3134 path.cubicTo(4, 6, 2, 1, 2, 0); 3135 path.close(); 3136 pathB.setFillType(SkPath::kWinding_FillType); 3137 pathB.moveTo(1, 2); 3138 pathB.cubicTo(0, 2, 1, 0, 6, 4); 3139 pathB.close(); 3140 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3141 } 3142 3143 static void cubicOp108(skiatest::Reporter* reporter, const char* filename) { 3144 SkPath path, pathB; 3145 path.setFillType(SkPath::kWinding_FillType); 3146 path.moveTo(0, 1); 3147 path.cubicTo(4, 6, 2, 1, 2, 0); 3148 path.close(); 3149 pathB.setFillType(SkPath::kWinding_FillType); 3150 pathB.moveTo(1, 2); 3151 pathB.cubicTo(0, 2, 1, 0, 6, 4); 3152 pathB.close(); 3153 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 3154 } 3155 3156 static void cubicOp109(skiatest::Reporter* reporter, const char* filename) { 3157 SkPath path, pathB; 3158 path.setFillType(SkPath::kWinding_FillType); 3159 path.moveTo(0,1); 3160 path.cubicTo(4,5, 6,3, 5,4); 3161 path.close(); 3162 pathB.setFillType(SkPath::kWinding_FillType); 3163 pathB.moveTo(3,6); 3164 pathB.cubicTo(4,5, 1,0, 5,4); 3165 pathB.close(); 3166 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3167 } 3168 3169 static void cubicOp110(skiatest::Reporter* reporter, const char* filename) { 3170 SkPath path, pathB; 3171 path.setFillType(SkPath::kEvenOdd_FillType); 3172 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 3173 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction); 3174 pathB.setFillType(SkPath::kEvenOdd_FillType); 3175 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3176 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3177 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3178 } 3179 3180 static void cubicOp111(skiatest::Reporter* reporter, const char* filename) { 3181 SkPath path, pathB; 3182 path.setFillType(SkPath::kWinding_FillType); 3183 path.moveTo(1,4); 3184 path.cubicTo(0,5, 4,1, 3,1); 3185 path.close(); 3186 pathB.setFillType(SkPath::kWinding_FillType); 3187 pathB.moveTo(1,4); 3188 pathB.cubicTo(1,3, 4,1, 5,0); 3189 pathB.close(); 3190 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3191 } 3192 3193 static void xOp1u(skiatest::Reporter* reporter, const char* filename) { 3194 SkPath path, pathB; 3195 path.setFillType(SkPath::kEvenOdd_FillType); 3196 path.moveTo(1, 4); 3197 path.cubicTo(4, 5, 3, 2, 6, 3); 3198 path.close(); 3199 pathB.setFillType(SkPath::kEvenOdd_FillType); 3200 pathB.moveTo(2, 3); 3201 pathB.cubicTo(3, 6, 4, 1, 5, 4); 3202 pathB.close(); 3203 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 3204 } 3205 3206 static void xOp1i(skiatest::Reporter* reporter, const char* filename) { 3207 SkPath path, pathB; 3208 path.setFillType(SkPath::kEvenOdd_FillType); 3209 path.moveTo(1, 4); 3210 path.cubicTo(1, 5, 6, 0, 5, 1); 3211 path.close(); 3212 pathB.setFillType(SkPath::kEvenOdd_FillType); 3213 pathB.moveTo(0, 6); 3214 pathB.cubicTo(1, 5, 4, 1, 5, 1); 3215 pathB.close(); 3216 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3217 } 3218 3219 static void xOp2i(skiatest::Reporter* reporter, const char* filename) { 3220 SkPath path, pathB; 3221 path.setFillType(SkPath::kEvenOdd_FillType); 3222 path.moveTo(1, 5); 3223 path.cubicTo(0, 4, 3, 2, 6, 1); 3224 path.close(); 3225 pathB.setFillType(SkPath::kEvenOdd_FillType); 3226 pathB.moveTo(2, 3); 3227 pathB.cubicTo(1, 6, 5, 1, 4, 0); 3228 pathB.close(); 3229 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3230 } 3231 3232 static void xOp3i(skiatest::Reporter* reporter, const char* filename) { 3233 SkPath path, pathB; 3234 path.setFillType(SkPath::kWinding_FillType); 3235 path.moveTo(1,4); 3236 path.cubicTo(0,5, 4,1, 3,1); 3237 path.close(); 3238 pathB.setFillType(SkPath::kWinding_FillType); 3239 pathB.moveTo(1,4); 3240 pathB.cubicTo(1,3, 4,1, 5,0); 3241 pathB.close(); 3242 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3243 } 3244 3245 static void findFirst1(skiatest::Reporter* reporter, const char* filename) { 3246 SkPath path, pathB; 3247 path.setFillType(SkPath::kWinding_FillType); 3248 path.moveTo(0,1); 3249 path.cubicTo(1,6, 5,0, 2,1); 3250 path.close(); 3251 pathB.setFillType(SkPath::kWinding_FillType); 3252 pathB.moveTo(0,5); 3253 pathB.cubicTo(1,2, 1,0, 6,1); 3254 pathB.close(); 3255 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3256 } 3257 3258 static void cubicOp112(skiatest::Reporter* reporter, const char* filename) { 3259 SkPath path, pathB; 3260 path.setFillType(SkPath::kWinding_FillType); 3261 path.moveTo(2,4); 3262 path.cubicTo(2,3, 6,4, 1,0); 3263 path.close(); 3264 pathB.setFillType(SkPath::kWinding_FillType); 3265 pathB.moveTo(4,6); 3266 pathB.cubicTo(0,1, 4,2, 3,2); 3267 pathB.close(); 3268 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3269 } 3270 3271 static void cubicOp113(skiatest::Reporter* reporter, const char* filename) { 3272 SkPath path, pathB; 3273 path.moveTo(2,4); 3274 path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f); 3275 path.close(); 3276 pathB.moveTo(3,5); 3277 pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4); 3278 pathB.close(); 3279 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3280 } 3281 3282 static void cubicOp114(skiatest::Reporter* reporter, const char* filename) { 3283 SkPath path, pathB; 3284 path.setFillType(SkPath::kWinding_FillType); 3285 path.moveTo(0, 1); 3286 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f); 3287 path.close(); 3288 pathB.setFillType(SkPath::kWinding_FillType); 3289 pathB.moveTo(1, 3); 3290 pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1); 3291 pathB.close(); 3292 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3293 } 3294 3295 static void cubicOp114asQuad(skiatest::Reporter* reporter, const char* filename) { 3296 SkPath path, pathB; 3297 path.setFillType(SkPath::kWinding_FillType); 3298 path.moveTo(0, 1); 3299 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f); 3300 path.close(); 3301 pathB.setFillType(SkPath::kWinding_FillType); 3302 pathB.moveTo(1, 3); 3303 pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1); 3304 pathB.close(); 3305 SkPath qPath, qPathB; 3306 CubicPathToQuads(path, &qPath); 3307 CubicPathToQuads(pathB, &qPathB); 3308 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename); 3309 } 3310 3311 static void quadOp10i(skiatest::Reporter* reporter, const char* filename) { 3312 SkPath path, pathB; 3313 path.moveTo(0, 0); 3314 path.quadTo(1, 8, 3, 5); 3315 path.lineTo(8, 1); 3316 path.close(); 3317 pathB.moveTo(0, 0); 3318 pathB.quadTo(8, 1, 4, 8); 3319 pathB.close(); 3320 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3321 } 3322 3323 static void kari1(skiatest::Reporter* reporter, const char* filename) { 3324 SkPath path1; 3325 path1.moveTo(39.9375, -5.8359375); 3326 path1.lineTo(40.625, -5.7890625); 3327 path1.lineTo(37.7109375, 1.3515625); 3328 path1.lineTo(37.203125, 0.9609375); 3329 path1.close(); 3330 3331 SkPath path2; 3332 path2.moveTo(37.52734375f, -1.44140625f); 3333 path2.cubicTo(37.8736991882324f, -1.69921875f, 38.1640625f, -2.140625f, 38.3984375f, -2.765625f); 3334 path2.lineTo(38.640625f, -2.609375f); 3335 path2.cubicTo(38.53125f, -1.89583337306976f, 38.0664443969727f, -0.154893040657043f, 38.0664443969727f, -0.154893040657043f); 3336 path2.cubicTo(38.0664443969727f, -0.154893040657043f, 37.1809883117676f, -1.18359375f, 37.52734375, -1.44140625f); 3337 path2.close(); 3338 3339 testPathOp(reporter, path1, path2, kDifference_SkPathOp, filename); 3340 } 3341 3342 static void issue2504(skiatest::Reporter* reporter, const char* filename) { 3343 SkPath path1; 3344 path1.moveTo(34.2421875, -5.976562976837158203125); 3345 path1.lineTo(35.453121185302734375, 0); 3346 path1.lineTo(31.9375, 0); 3347 path1.close(); 3348 3349 SkPath path2; 3350 path2.moveTo(36.71843719482421875, 0.8886508941650390625); 3351 path2.cubicTo(36.71843719482421875, 0.8886508941650390625, 3352 35.123386383056640625, 0.554015457630157470703125, 3353 34.511409759521484375, -0.1152553558349609375); 3354 path2.cubicTo(33.899425506591796875, -0.7845261096954345703125, 3355 34.53484344482421875, -5.6777553558349609375, 3356 34.53484344482421875, -5.6777553558349609375); 3357 path2.close(); 3358 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename); 3359 } 3360 3361 static void issue2540(skiatest::Reporter* reporter, const char* filename) { 3362 SkPath path1; 3363 path1.moveTo(26.5054988861083984375, 85.73960113525390625); 3364 path1.cubicTo(84.19739532470703125, 17.77140045166015625, 16.93920135498046875, 101.86199951171875, 12.631000518798828125, 105.24700164794921875); 3365 path1.cubicTo(11.0819997787475585937500000, 106.46399688720703125, 11.5260000228881835937500000, 104.464996337890625, 11.5260000228881835937500000, 104.464996337890625); 3366 path1.lineTo(23.1654987335205078125, 89.72879791259765625); 3367 path1.cubicTo(23.1654987335205078125, 89.72879791259765625, -10.1713008880615234375, 119.9160003662109375, -17.1620006561279296875, 120.8249969482421875); 3368 path1.cubicTo(-19.1149997711181640625, 121.07900238037109375, -18.0380001068115234375, 119.79299163818359375, -18.0380001068115234375, 119.79299163818359375); 3369 path1.cubicTo(-18.0380001068115234375, 119.79299163818359375, 14.22100067138671875, 90.60700225830078125, 26.5054988861083984375, 85.73960113525390625); 3370 path1.close(); 3371 3372 SkPath path2; 3373 path2.moveTo(-25.077999114990234375, 124.9120025634765625); 3374 path2.cubicTo(-25.077999114990234375, 124.9120025634765625, -25.9509983062744140625, 125.95400238037109375, -24.368999481201171875, 125.7480010986328125); 3375 path2.cubicTo(-16.06999969482421875, 124.66899871826171875, 1.2680000066757202148437500, 91.23999786376953125, 37.264003753662109375, 95.35400390625); 3376 path2.cubicTo(37.264003753662109375, 95.35400390625, 11.3710002899169921875, 83.7339935302734375, -25.077999114990234375, 124.9120025634765625); 3377 path2.close(); 3378 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename); 3379 } 3380 3381 static void rects1(skiatest::Reporter* reporter, const char* filename) { 3382 SkPath path, pathB; 3383 path.setFillType(SkPath::kEvenOdd_FillType); 3384 path.moveTo(0, 0); 3385 path.lineTo(1, 0); 3386 path.lineTo(1, 1); 3387 path.lineTo(0, 1); 3388 path.close(); 3389 path.moveTo(0, 0); 3390 path.lineTo(6, 0); 3391 path.lineTo(6, 6); 3392 path.lineTo(0, 6); 3393 path.close(); 3394 pathB.setFillType(SkPath::kEvenOdd_FillType); 3395 pathB.moveTo(0, 0); 3396 pathB.lineTo(1, 0); 3397 pathB.lineTo(1, 1); 3398 pathB.lineTo(0, 1); 3399 pathB.close(); 3400 pathB.moveTo(0, 0); 3401 pathB.lineTo(2, 0); 3402 pathB.lineTo(2, 2); 3403 pathB.lineTo(0, 2); 3404 pathB.close(); 3405 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 3406 } 3407 3408 static void rects2(skiatest::Reporter* reporter, const char* filename) { 3409 SkPath path, pathB; 3410 path.setFillType(SkPath::kEvenOdd_FillType); 3411 path.moveTo(0, 0); 3412 path.lineTo(4, 0); 3413 path.lineTo(4, 4); 3414 path.lineTo(0, 4); 3415 path.close(); 3416 path.moveTo(3, 3); 3417 path.lineTo(4, 3); 3418 path.lineTo(4, 4); 3419 path.lineTo(3, 4); 3420 path.close(); 3421 pathB.setFillType(SkPath::kWinding_FillType); 3422 pathB.moveTo(3, 3); 3423 pathB.lineTo(6, 3); 3424 pathB.lineTo(6, 6); 3425 pathB.lineTo(3, 6); 3426 pathB.close(); 3427 pathB.moveTo(3, 3); 3428 pathB.lineTo(4, 3); 3429 pathB.lineTo(4, 4); 3430 pathB.lineTo(3, 4); 3431 pathB.close(); 3432 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3433 } 3434 3435 static void rects3(skiatest::Reporter* reporter, const char* filename) { 3436 SkPath path, pathB; 3437 path.setFillType(SkPath::kEvenOdd_FillType); 3438 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 3439 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction); 3440 pathB.setFillType(SkPath::kWinding_FillType); 3441 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3442 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3443 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3444 } 3445 3446 static void rects4(skiatest::Reporter* reporter, const char* filename) { 3447 SkPath path, pathB; 3448 path.setFillType(SkPath::kEvenOdd_FillType); 3449 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 3450 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3451 pathB.setFillType(SkPath::kWinding_FillType); 3452 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3453 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 3454 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3455 } 3456 3457 static void issue2753(skiatest::Reporter* reporter, const char* filename) { 3458 SkPath path1; 3459 path1.moveTo(142.701f, 110.568f); 3460 path1.lineTo(142.957f, 100); 3461 path1.lineTo(153.835f, 100); 3462 path1.lineTo(154.592f, 108.188f); 3463 path1.cubicTo(154.592f, 108.188f, 153.173f, 108.483f, 152.83f, 109.412f); 3464 path1.cubicTo(152.83f, 109.412f, 142.701f, 110.568f, 142.701f, 110.568f); 3465 path1.close(); 3466 3467 SkPath path2; 3468 path2.moveTo(39, 124.001f); 3469 path2.cubicTo(39, 124.001f, 50.6f, 117.001f, 50.6f, 117.001f); 3470 path2.cubicTo(50.6f, 117.001f, 164.601f, 85.2f, 188.201f, 117.601f); 3471 path2.cubicTo(188.201f, 117.601f, 174.801f, 93, 39, 124.001f); 3472 path2.close(); 3473 3474 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename); 3475 } 3476 3477 static void issue2808(skiatest::Reporter* reporter, const char* filename) { 3478 SkPath path1, path2; 3479 3480 path1.moveTo(509.20300293f, 385.601989746f); 3481 path1.quadTo(509.20300293f, 415.68838501f, 487.928710938f, 436.96270752f); 3482 path1.quadTo(466.654388428f, 458.236999512f, 436.567993164f, 458.236999512f); 3483 path1.quadTo(406.4815979f, 458.236999512f, 385.207275391f, 436.96270752f); 3484 path1.quadTo(363.932983398f, 415.68838501f, 363.932983398f, 385.601989746f); 3485 path1.quadTo(363.932983398f, 355.515594482f, 385.207275391f, 334.241271973f); 3486 path1.quadTo(406.4815979f, 312.96697998f, 436.567993164f, 312.96697998f); 3487 path1.quadTo(466.654388428f, 312.96697998f, 487.928710938f, 334.241271973f); 3488 path1.quadTo(509.20300293f, 355.515594482f, 509.20300293f, 385.601989746f); 3489 path1.close(); 3490 3491 path2.moveTo(449.033996582f, 290.87298584f); 3492 path2.quadTo(449.033996582f, 301.028259277f, 441.853149414f, 308.209106445f); 3493 path2.quadTo(434.672271729f, 315.389984131f, 424.516998291f, 315.389984131f); 3494 path2.quadTo(414.361724854f, 315.389984131f, 407.180847168f, 308.209106445f); 3495 path2.quadTo(400, 301.028259277f, 400, 290.87298584f); 3496 path2.quadTo(400, 280.717712402f, 407.180847168f, 273.536865234f); 3497 path2.quadTo(414.361724854f, 266.355987549f, 424.516998291f, 266.355987549f); 3498 path2.quadTo(434.672271729f, 266.355987549f, 441.853149414f, 273.536865234f); 3499 path2.quadTo(449.033996582f, 280.717712402f, 449.033996582f, 290.87298584f); 3500 path2.close(); 3501 3502 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename); 3503 } 3504 3505 static void cubicOp115(skiatest::Reporter* reporter, const char* filename) { 3506 SkPath path, pathB; 3507 path.setFillType(SkPath::kWinding_FillType); 3508 path.moveTo(0,1); 3509 path.cubicTo(3,4, 2,1, 5,3); 3510 path.close(); 3511 pathB.setFillType(SkPath::kWinding_FillType); 3512 pathB.moveTo(1,2); 3513 pathB.cubicTo(3,5, 1,0, 4,3); 3514 pathB.close(); 3515 SkPath path2(path); 3516 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3517 } 3518 3519 static void testRect1(skiatest::Reporter* reporter, const char* filename) { 3520 SkPath path, path2; 3521 path.addRect(0, 0, 60, 60, SkPath::kCCW_Direction); 3522 path.addRect(30, 20, 50, 50, SkPath::kCCW_Direction); 3523 path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction); 3524 // path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction); 3525 testPathOp(reporter, path, path2, kUnion_SkPathOp, filename); 3526 } 3527 3528 static void testRect2(skiatest::Reporter* reporter, const char* filename) { 3529 SkPath path, pathB; 3530 path.setFillType(SkPath::kWinding_FillType); 3531 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 3532 path.addRect(4, 4, 5, 5, SkPath::kCW_Direction); 3533 pathB.setFillType(SkPath::kEvenOdd_FillType); 3534 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 3535 pathB.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 3536 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3537 } 3538 3539 static void cubicOp116(skiatest::Reporter* reporter, const char* filename) { 3540 SkPath path, pathB; 3541 path.setFillType(SkPath::kWinding_FillType); 3542 path.moveTo(0,1); 3543 path.cubicTo(4,6, 2,0, 2,0); 3544 path.close(); 3545 pathB.setFillType(SkPath::kWinding_FillType); 3546 pathB.moveTo(0,2); 3547 pathB.cubicTo(0,2, 1,0, 6,4); 3548 pathB.close(); 3549 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3550 } 3551 3552 static void cubicOp117(skiatest::Reporter* reporter, const char* filename) { 3553 SkPath path, pathB; 3554 path.setFillType(SkPath::kWinding_FillType); 3555 path.moveTo(0,1); 3556 path.cubicTo(4,5, 6,0, 1,0); 3557 path.close(); 3558 pathB.setFillType(SkPath::kWinding_FillType); 3559 pathB.moveTo(0,6); 3560 pathB.cubicTo(0,1, 1,0, 5,4); 3561 pathB.close(); 3562 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3563 } 3564 3565 static void cubicOp118(skiatest::Reporter* reporter, const char* filename) { 3566 SkPath path, pathB; 3567 path.setFillType(SkPath::kWinding_FillType); 3568 path.moveTo(0,1); 3569 path.cubicTo(4,6, 5,1, 6,2); 3570 path.close(); 3571 pathB.setFillType(SkPath::kWinding_FillType); 3572 pathB.moveTo(1,5); 3573 pathB.cubicTo(2,6, 1,0, 6,4); 3574 pathB.close(); 3575 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3576 } 3577 3578 static void loop1(skiatest::Reporter* reporter, const char* filename) { 3579 SkPath path, pathB; 3580 path.moveTo(0,1); 3581 path.cubicTo(1,5, -5.66666651f,3.33333349f, 8.83333302f,2.33333349f); 3582 path.close(); 3583 pathB.moveTo(1,5); 3584 pathB.cubicTo(-5.66666651f,3.33333349f, 8.83333302f,2.33333349f, 0,1); 3585 pathB.close(); 3586 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3587 } 3588 3589 #include "SkPathOpsCubic.h" 3590 3591 static void loop1asQuad(skiatest::Reporter* reporter, const char* filename) { 3592 CubicPts cubic1 = {{{0,1}, {1,5}, {-5.66666651f,3.33333349f}, {8.83333302f,2.33333349f}}}; 3593 CubicPts cubic2 = {{{1,5}, {-5.66666651f,3.33333349f}, {8.83333302f,2.33333349f}, {0,1}}}; 3594 SkDCubic c1, c2; 3595 c1.debugSet(cubic1.fPts); 3596 c2.debugSet(cubic2.fPts); 3597 double c1InflectionTs[2], c2InflectionTs[2]; 3598 SkDEBUGCODE(int c1InfTCount =) c1.findInflections(c1InflectionTs); 3599 SkASSERT(c1InfTCount == 2); 3600 SkDEBUGCODE(int c2InfTCount =) c2.findInflections(c2InflectionTs); 3601 SkASSERT(c2InfTCount == 1); 3602 SkASSERT(c1InflectionTs[0] > c1InflectionTs[1]); 3603 SkDCubicPair c1pair = c1.chopAt(c1InflectionTs[0]); 3604 SkDCubicPair c1apair = c1pair.first().chopAt(c1InflectionTs[1]); 3605 SkDCubicPair c2pair = c2.chopAt(c2InflectionTs[0]); 3606 SkDQuad q1[2] = { c1pair.first().toQuad(), c1pair.second().toQuad() }; 3607 SkDQuad q1a[2] = { c1apair.first().toQuad(), c1apair.second().toQuad() }; 3608 SkDQuad q2[2] = { c2pair.first().toQuad(), c2pair.second().toQuad() }; 3609 SkPath path, pathB; 3610 path.moveTo(q1a[0].fPts[0].asSkPoint()); 3611 path.quadTo(q1a[0].fPts[1].asSkPoint(), q1a[0].fPts[2].asSkPoint()); 3612 path.quadTo(q1a[1].fPts[1].asSkPoint(), q1a[1].fPts[2].asSkPoint()); 3613 path.quadTo(q1[1].fPts[1].asSkPoint(), q1[1].fPts[2].asSkPoint()); 3614 path.close(); 3615 pathB.moveTo(q2[0].fPts[0].asSkPoint()); 3616 pathB.quadTo(q2[0].fPts[1].asSkPoint(), q2[0].fPts[2].asSkPoint()); 3617 pathB.quadTo(q2[1].fPts[1].asSkPoint(), q2[1].fPts[2].asSkPoint()); 3618 pathB.close(); 3619 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3620 } 3621 3622 static void loop2(skiatest::Reporter* reporter, const char* filename) { 3623 SkPath path, pathB; 3624 path.moveTo(0,1); 3625 path.cubicTo(3,4, 3.f,4.f, 4.5f,1.5f); 3626 path.close(); 3627 pathB.moveTo(3,4); 3628 pathB.cubicTo(3.f,4.f, 4.5f,1.5f, 0,1); 3629 pathB.close(); 3630 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3631 } 3632 3633 static void loop3(skiatest::Reporter* reporter, const char* filename) { 3634 SkPath path, pathB; 3635 path.moveTo(0,1); 3636 path.cubicTo(3,5, -3.66666651f,0, 10.5f,-1.66666651f); 3637 path.close(); 3638 pathB.moveTo(3,5); 3639 pathB.cubicTo(-3.66666651f,0, 10.5f,-1.66666651f, 0,1); 3640 pathB.close(); 3641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3642 } 3643 3644 static void loop4(skiatest::Reporter* reporter, const char* filename) { 3645 SkPath path, pathB; 3646 path.moveTo(0,5); 3647 path.cubicTo(1,5, 1,4, 0.833333313f,3); 3648 path.close(); 3649 pathB.moveTo(1,5); 3650 pathB.cubicTo(1,4, 0.833333313f,3, 0,5); 3651 pathB.close(); 3652 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3653 } 3654 3655 #include "SkParsePath.h" 3656 3657 static void issue3517(skiatest::Reporter* reporter, const char* filename) { 3658 SkPath path, pathB; 3659 3660 const char str[] = "M31.35 57.75L31.35 57.75C31.9 57.7486 32.45 57.7948 33 57.7413C33.55 57.6878 34.1 57.5014 34.65 57.4291C35.2 57.3569 35.75 57.3223 36.3 57.3079C36.85 57.2935 37.4 57.3143 37.95 57.3428C38.5 57.3712 39.05 57.4112 39.6 57.4786C40.15 57.546 40.7 57.7029 41.25 57.7472C41.8 57.7916 42.35 57.7962 42.9 57.7445C43.45 57.6928 44 57.5345 44.55 57.4373C45.1 57.34 45.65 57.2115 46.2 57.1611C46.75 57.1107 47.3 57.1371 47.85 57.1349C48.4 57.1327 48.95 57.144 49.5 57.1478C50.05 57.1516 50.6 57.1553 51.15 57.1579C51.7 57.1605 52.25 57.1601 52.8 57.1634C53.35 57.1667 53.9 57.1731 54.45 57.1776C55 57.182 55.55 57.1916 56.1 57.19C56.65 57.1884 57.2 57.178 57.75 57.168C58.3 57.158 58.85 57.1355 59.4 57.1299C59.95 57.1243 60.5 57.1338 61.05 57.1345C61.6 57.1352 62.15 57.124 62.7 57.134C63.25 57.1441 63.8 57.1731 64.35 57.195C64.9 57.2169 65.45 57.2532 66 57.2655C66.55 57.2778 67.1 57.2647 67.65 57.2687C68.2 57.2728 68.75 57.267 69.3 57.2896C69.85 57.3122 70.4 57.371 70.95 57.4044C71.5 57.4377 72.05 57.4668 72.6 57.4896C73.15 57.5123 73.7 57.545 74.25 57.5408C74.8 57.5365 75.35 57.5068 75.9 57.4641C76.45 57.4213 77 57.3244 77.55 57.2842C78.1 57.244 78.65 57.2163 79.2 57.2228C79.75 57.2293 80.3 57.29 80.85 57.3232C81.4 57.3563 81.95 57.396 82.5 57.4219C83.05 57.4478 83.6 57.4637 84.15 57.4787C84.7 57.4937 85.25 57.5011 85.8 57.5121C86.35 57.523 86.9 57.5411 87.45 57.5444C88 57.5477 88.55 57.5663 89.1 57.5318C89.65 57.4972 90.2 57.3126 90.75 57.337C91.3 57.3613 91.85 57.6088 92.4 57.6776C92.95 57.7465 93.5 57.7379 94.05 57.75C94.6 57.7621 95.15 57.75 95.7 57.75L95.7 57.75L31.35 57.75Z"; 3661 SkParsePath::FromSVGString(str, &path); 3662 3663 const char strB[] = "M31.35 57.75L31.35 57.75C31.9 57.7514 32.45 57.7052 33 57.7587C33.55 57.8122 34.1 57.9986 34.65 58.0709C35.2 58.1431 35.75 58.1777 36.3 58.1921C36.85 58.2065 37.4 58.1857 37.95 58.1572C38.5 58.1288 39.05 58.0888 39.6 58.0214C40.15 57.954 40.7 57.7971 41.25 57.7528C41.8 57.7084 42.35 57.7038 42.9 57.7555C43.45 57.8072 44 57.9655 44.55 58.0627C45.1 58.16 45.65 58.2885 46.2 58.3389C46.75 58.3893 47.3 58.3629 47.85 58.3651C48.4 58.3673 48.95 58.356 49.5 58.3522C50.05 58.3484 50.6 58.3447 51.15 58.3421C51.7 58.3395 52.25 58.3399 52.8 58.3366C53.35 58.3333 53.9 58.3269 54.45 58.3224C55 58.318 55.55 58.3084 56.1 58.31C56.65 58.3116 57.2 58.322 57.75 58.332C58.3 58.342 58.85 58.3645 59.4 58.3701C59.95 58.3757 60.5 58.3662 61.05 58.3655C61.6 58.3648 62.15 58.376 62.7 58.366C63.25 58.3559 63.8 58.3269 64.35 58.305C64.9 58.2831 65.45 58.2468 66 58.2345C66.55 58.2222 67.1 58.2353 67.65 58.2313C68.2 58.2272 68.75 58.233 69.3 58.2104C69.85 58.1878 70.4 58.129 70.95 58.0956C71.5 58.0623 72.05 58.0332 72.6 58.0104C73.15 57.9877 73.7 57.955 74.25 57.9592C74.8 57.9635 75.35 57.9932 75.9 58.0359C76.45 58.0787 77 58.1756 77.55 58.2158C78.1 58.256 78.65 58.2837 79.2 58.2772C79.75 58.2707 80.3 58.21 80.85 58.1768C81.4 58.1437 81.95 58.104 82.5 58.0781C83.05 58.0522 83.6 58.0363 84.15 58.0213C84.7 58.0063 85.25 57.9989 85.8 57.9879C86.35 57.977 86.9 57.9589 87.45 57.9556C88 57.9523 88.55 57.9337 89.1 57.9682C89.65 58.0028 90.2 58.1874 90.75 58.163C91.3 58.1387 91.85 57.8912 92.4 57.8224C92.95 57.7535 93.5 57.7621 94.05 57.75C94.6 57.7379 95.15 57.75 95.7 57.75L95.7 57.75L31.35 57.75Z"; 3664 SkParsePath::FromSVGString(strB, &pathB); 3665 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 3666 } 3667 3668 static void cubicOp119(skiatest::Reporter* reporter, const char* filename) { 3669 SkPath path, pathB; 3670 path.setFillType(SkPath::kWinding_FillType); 3671 path.moveTo(0,1); 3672 path.cubicTo(3,5, 2,1, 3,1); 3673 path.close(); 3674 pathB.setFillType(SkPath::kWinding_FillType); 3675 pathB.moveTo(1,2); 3676 pathB.cubicTo(1,3, 1,0, 5,3); 3677 pathB.close(); 3678 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3679 } 3680 3681 static void cubicOp120(skiatest::Reporter* reporter, const char* filename) { 3682 SkPath path, pathB; 3683 path.setFillType(SkPath::kWinding_FillType); 3684 path.moveTo(0,1); 3685 path.cubicTo(2,4, 2,1, 4,0); 3686 path.close(); 3687 pathB.setFillType(SkPath::kWinding_FillType); 3688 pathB.moveTo(1,2); 3689 pathB.cubicTo(0,4, 1,0, 4,2); 3690 pathB.close(); 3691 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3692 } 3693 3694 static void cubicOp121(skiatest::Reporter* reporter, const char* filename) { 3695 SkPath path, pathB; 3696 path.setFillType(SkPath::kWinding_FillType); 3697 path.moveTo(0,1); 3698 path.cubicTo(3,4, 3,2, 4,3); 3699 path.close(); 3700 pathB.setFillType(SkPath::kWinding_FillType); 3701 pathB.moveTo(2,3); 3702 pathB.cubicTo(3,4, 1,0, 4,3); 3703 pathB.close(); 3704 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3705 } 3706 3707 // FIXME : haven't debugged this failure yet 3708 static void cubicOp122(skiatest::Reporter* reporter, const char* filename) { 3709 SkPath path, pathB; 3710 path.setFillType(SkPath::kWinding_FillType); 3711 path.moveTo(0,1); 3712 path.cubicTo(3,5, 4,1, 4,0); 3713 path.close(); 3714 pathB.setFillType(SkPath::kWinding_FillType); 3715 pathB.moveTo(1,4); 3716 pathB.cubicTo(0,4, 1,0, 5,3); 3717 pathB.close(); 3718 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3719 } 3720 3721 static void cubicOp123(skiatest::Reporter* reporter, const char* filename) { 3722 SkPath path, pathB; 3723 path.setFillType(SkPath::kWinding_FillType); 3724 path.moveTo(0,1); 3725 path.cubicTo(1,5, 2,0, 6,0); 3726 path.close(); 3727 pathB.setFillType(SkPath::kWinding_FillType); 3728 pathB.moveTo(0,2); 3729 pathB.cubicTo(0,6, 1,0, 5,1); 3730 pathB.close(); 3731 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3732 } 3733 3734 static void loop5(skiatest::Reporter* reporter, const char* filename) { 3735 SkPath path, pathB; 3736 path.moveTo(0,2); 3737 path.cubicTo(1,2, 1,1.66666663f, 0.833333313f,1.33333325f); 3738 path.close(); 3739 pathB.moveTo(1,2); 3740 pathB.cubicTo(1,1.66666663f, 0.833333313f,1.33333325f, 0,2); 3741 pathB.close(); 3742 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3743 } 3744 3745 static void loop6(skiatest::Reporter* reporter, const char* filename) { 3746 SkPath path, pathB; 3747 path.moveTo(0,1); 3748 path.cubicTo(1,3, -1.66666675f,1.66666663f, 4.16666651f,1.00000012f); 3749 path.close(); 3750 pathB.moveTo(1,3); 3751 pathB.cubicTo(-1.66666675f,1.66666663f, 4.16666651f,1.00000012f, 0,1); 3752 pathB.close(); 3753 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3754 } 3755 3756 static void cubicOp124(skiatest::Reporter* reporter, const char* filename) { 3757 SkPath path, pathB; 3758 path.setFillType(SkPath::kWinding_FillType); 3759 path.moveTo(0,1); 3760 path.cubicTo(1,5, 6,0, 3,0); 3761 path.close(); 3762 pathB.setFillType(SkPath::kWinding_FillType); 3763 pathB.moveTo(0,6); 3764 pathB.cubicTo(0,3, 1,0, 5,1); 3765 pathB.close(); 3766 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3767 } 3768 3769 static void cubicOp125(skiatest::Reporter* reporter, const char* filename) { 3770 SkPath path, pathB; 3771 path.setFillType(SkPath::kWinding_FillType); 3772 path.moveTo(0,1); 3773 path.cubicTo(3,6, 3,1, 6,2); 3774 path.close(); 3775 pathB.setFillType(SkPath::kWinding_FillType); 3776 pathB.moveTo(1,3); 3777 pathB.cubicTo(2,6, 1,0, 6,3); 3778 pathB.close(); 3779 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3780 } 3781 3782 static void cubicOp126(skiatest::Reporter* reporter, const char* filename) { 3783 SkPath path, pathB; 3784 path.setFillType(SkPath::kWinding_FillType); 3785 path.moveTo(0,1); 3786 path.cubicTo(0,3, 6,0, 2,1); 3787 path.close(); 3788 pathB.setFillType(SkPath::kWinding_FillType); 3789 pathB.moveTo(0,6); 3790 pathB.cubicTo(1,2, 1,0, 3,0); 3791 pathB.close(); 3792 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3793 } 3794 3795 static void cubicOp127(skiatest::Reporter* reporter, const char* filename) { 3796 SkPath path, pathB; 3797 path.setFillType(SkPath::kWinding_FillType); 3798 path.moveTo(0,1); 3799 path.cubicTo(1,5, 6,0, 3,0); 3800 path.close(); 3801 pathB.setFillType(SkPath::kWinding_FillType); 3802 pathB.moveTo(0,6); 3803 pathB.cubicTo(0,3, 1,0, 5,1); 3804 pathB.close(); 3805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3806 } 3807 3808 static void cubicOp128(skiatest::Reporter* reporter, const char* filename) { 3809 SkPath path, pathB; 3810 path.setFillType(SkPath::kWinding_FillType); 3811 path.moveTo(0,1); 3812 path.cubicTo(0,3, 3,2, 5,2); 3813 path.close(); 3814 pathB.setFillType(SkPath::kWinding_FillType); 3815 pathB.moveTo(2,3); 3816 pathB.cubicTo(2,5, 1,0, 3,0); 3817 pathB.close(); 3818 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3819 } 3820 3821 static void cubicOp129(skiatest::Reporter* reporter, const char* filename) { 3822 SkPath path, pathB; 3823 path.setFillType(SkPath::kWinding_FillType); 3824 path.moveTo(5,6); 3825 path.cubicTo(3,4, 2,0, 2,1); 3826 path.close(); 3827 pathB.setFillType(SkPath::kWinding_FillType); 3828 pathB.moveTo(0,2); 3829 pathB.cubicTo(1,2, 6,5, 4,3); 3830 pathB.close(); 3831 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3832 } 3833 3834 static void cubicOp130(skiatest::Reporter* reporter, const char* filename) { 3835 SkPath path, pathB; 3836 path.setFillType(SkPath::kWinding_FillType); 3837 path.moveTo(5,6); 3838 path.cubicTo(4,6, 3,0, 2,1); 3839 path.close(); 3840 pathB.setFillType(SkPath::kWinding_FillType); 3841 pathB.moveTo(0,3); 3842 pathB.cubicTo(1,2, 6,5, 6,4); 3843 pathB.close(); 3844 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3845 } 3846 3847 #include "SkGeometry.h" 3848 3849 static void complex_to_quads(const SkPoint pts[], SkPath* path) { 3850 SkScalar loopT[3]; 3851 if (SkDCubic::ComplexBreak(pts, loopT)) { 3852 SkPoint cubicPair[7]; 3853 SkChopCubicAt(pts, cubicPair, loopT[0]); 3854 SkDCubic c1, c2; 3855 c1.set(cubicPair); 3856 c2.set(&cubicPair[3]); 3857 SkDQuad q1 = c1.toQuad(); 3858 SkDQuad q2 = c2.toQuad(); 3859 path->quadTo(q1[1].asSkPoint(), q1[2].asSkPoint()); 3860 path->quadTo(q2[1].asSkPoint(), q2[2].asSkPoint()); 3861 } else { 3862 path->cubicTo(pts[1], pts[2], pts[3]); 3863 } 3864 } 3865 3866 static void cubicOp130a(skiatest::Reporter* reporter, const char* filename) { 3867 SkPath path, pathB; 3868 path.setFillType(SkPath::kWinding_FillType); 3869 path.moveTo(5,6); 3870 SkPoint pts[] = { {5,6}, {4,6}, {3,0}, {2,1} }; 3871 complex_to_quads(pts, &path); 3872 path.close(); 3873 pathB.setFillType(SkPath::kWinding_FillType); 3874 pathB.moveTo(0,3); 3875 SkPoint pts2[] = { {0,3}, {1,2}, {6,5}, {6,4} }; 3876 complex_to_quads(pts2, &path); 3877 pathB.close(); 3878 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3879 } 3880 3881 static void cubicOp131(skiatest::Reporter* reporter, const char* filename) { 3882 SkPath path, pathB; 3883 path.setFillType(SkPath::kWinding_FillType); 3884 path.moveTo(0,1); 3885 path.cubicTo(3,4, 3,0, 6,2); 3886 path.close(); 3887 pathB.setFillType(SkPath::kWinding_FillType); 3888 pathB.moveTo(0,3); 3889 pathB.cubicTo(2,6, 1,0, 4,3); 3890 pathB.close(); 3891 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3892 } 3893 3894 static void circlesOp1(skiatest::Reporter* reporter, const char* filename) { 3895 SkPath path, pathB; 3896 path.setFillType(SkPath::kWinding_FillType); 3897 path.addCircle(0, 1, 2, SkPath::kCCW_Direction); 3898 pathB.setFillType(SkPath::kWinding_FillType); 3899 pathB.addCircle(0, 1, 1, SkPath::kCW_Direction); 3900 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3901 } 3902 3903 static void circlesOp2(skiatest::Reporter* reporter, const char* filename) { 3904 SkPath path, pathB; 3905 path.setFillType(SkPath::kWinding_FillType); 3906 path.addCircle(0, 1, 4, SkPath::kCCW_Direction); 3907 pathB.setFillType(SkPath::kWinding_FillType); 3908 pathB.addCircle(0, 4, 3, SkPath::kCW_Direction); 3909 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3910 } 3911 3912 static void rRect1x(skiatest::Reporter* reporter, const char* filename) { 3913 SkPath path, pathB; 3914 path.setFillType(SkPath::kEvenOdd_FillType); 3915 path.moveTo(20.65f, 5.65f); 3916 path.conicTo(20.65f, 1.13612f, 25.1404f, 0.65f, 0.888488f); 3917 path.lineTo(25.65f, 0.65f); 3918 path.lineTo(26.1596f, 0.67604f); 3919 path.conicTo(30.65f, 1.13612f, 30.65f, 5.65f, 0.888488f); 3920 path.lineTo(30.65f, 25.65f); 3921 path.conicTo(30.65f, 20.65f, 25.65f, 20.65f, 0.707107f); 3922 path.lineTo(20.65f, 20.65f); 3923 path.lineTo(20.65f, 5.65f); 3924 path.close(); 3925 path.moveTo(20.65f, 20.65f); 3926 path.lineTo(5.65f, 20.65f); 3927 path.conicTo(0.65f, 20.65f, 0.65f, 25.65f, 0.707107f); 3928 path.lineTo(0.65f, 45.65f); 3929 path.conicTo(0.65f, 50.65f, 5.65f, 50.65f, 0.707107f); 3930 path.lineTo(25.65f, 50.65f); 3931 path.conicTo(30.65f, 50.65f, 30.65f, 45.65f, 0.707107f); 3932 path.lineTo(30.65f, 25.65f); 3933 path.conicTo(30.65f, 30.65f, 25.65f, 30.65f, 0.707107f); 3934 path.conicTo(20.65f, 30.65f, 20.65f, 25.65f, 0.707107f); 3935 path.lineTo(20.65f, 20.65f); 3936 path.close(); 3937 SkPath path1(path); 3938 3939 path.reset(); 3940 path.setFillType(SkPath::kWinding_FillType); 3941 path.moveTo(20.65f, 45.65f); 3942 path.lineTo(20.65f, 25.65f); 3943 path.conicTo(20.65f, 20.65f, 25.65f, 20.65f, 0.707107f); 3944 path.lineTo(45.65f, 20.65f); 3945 path.conicTo(50.65f, 20.65f, 50.65f, 25.65f, 0.707107f); 3946 path.lineTo(50.65f, 45.65f); 3947 path.conicTo(50.65f, 50.65f, 45.65f, 50.65f, 0.707107f); 3948 path.lineTo(25.65f, 50.65f); 3949 path.conicTo(20.65f, 50.65f, 20.65f, 45.65f, 0.707107f); 3950 path.close(); 3951 SkPath path2(path); 3952 3953 testPathOp(reporter, path1, path2, kDifference_SkPathOp, filename); 3954 } 3955 3956 static void loop7(skiatest::Reporter* reporter, const char* filename) { 3957 SkPath path, pathB; 3958 path.moveTo(0,1); 3959 path.cubicTo(3,4, -1,0, 8.5f,-2.5f); 3960 path.close(); 3961 pathB.moveTo(3,4); 3962 pathB.cubicTo(-1,0, 8.5f,-2.5f, 0,1); 3963 pathB.close(); 3964 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3965 } 3966 3967 static void rects5(skiatest::Reporter* reporter, const char* filename) { 3968 SkPath path, pathB; 3969 path.setFillType(SkPath::kWinding_FillType); 3970 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction); 3971 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction); 3972 pathB.setFillType(SkPath::kEvenOdd_FillType); 3973 pathB.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 3974 pathB.addRect(5, 5, 6, 6, SkPath::kCW_Direction); 3975 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 3976 } 3977 3978 static void loop8(skiatest::Reporter* reporter, const char* filename) { 3979 SkPath path, pathB; 3980 path.moveTo(0,1); 3981 path.cubicTo(1,4, -3.83333325f,0.166666627f, 6,-1); 3982 path.close(); 3983 pathB.moveTo(1,4); 3984 pathB.cubicTo(-3.83333325f,0.166666627f, 6,-1, 0,1); 3985 pathB.close(); 3986 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3987 } 3988 3989 static void loop9(skiatest::Reporter* reporter, const char* filename) { 3990 SkPath path, pathB; 3991 path.moveTo(0,1); 3992 path.cubicTo(1,3, -2.5f,0, 3.33333325f,-0.666666627f); 3993 path.close(); 3994 pathB.moveTo(1,3); 3995 pathB.cubicTo(-2.5f,0, 3.33333325f,-0.666666627f, 0,1); 3996 pathB.close(); 3997 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 3998 } 3999 4000 static void circlesOp3(skiatest::Reporter* reporter, const char* filename) { 4001 SkPath path, pathB; 4002 path.setFillType(SkPath::kWinding_FillType); 4003 path.addCircle(0, 1, 2, SkPath::kCCW_Direction); 4004 pathB.setFillType(SkPath::kWinding_FillType); 4005 pathB.addCircle(3, 5, 3, SkPath::kCW_Direction); 4006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4007 } 4008 4009 static void loop10(skiatest::Reporter* reporter, const char* filename) { 4010 SkPath path, pathB; 4011 path.moveTo(5,6); 4012 path.cubicTo(1,2, 1,2, -3.66666651f,13.333334f); 4013 path.close(); 4014 pathB.moveTo(1,2); 4015 pathB.cubicTo(1,2, -3.66666651f,13.333334f, 5,6); 4016 pathB.close(); 4017 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4018 } 4019 4020 static void loop11(skiatest::Reporter* reporter, const char* filename) { 4021 SkPath path, pathB; 4022 path.moveTo(0,1); 4023 path.cubicTo(1,3, -1.83333349f,1.33333337f, 4,-1); 4024 path.close(); 4025 pathB.moveTo(1,3); 4026 pathB.cubicTo(-1.83333349f,1.33333337f, 4,-1, 0,1); 4027 pathB.close(); 4028 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4029 } 4030 4031 static void cubicOp132(skiatest::Reporter* reporter, const char* filename) { 4032 SkPath path, pathB; 4033 path.setFillType(SkPath::kWinding_FillType); 4034 path.moveTo(5,6); 4035 path.cubicTo(3,4, 3,0, 3,2); 4036 path.close(); 4037 pathB.setFillType(SkPath::kWinding_FillType); 4038 pathB.moveTo(0,3); 4039 pathB.cubicTo(2,3, 6,5, 4,3); 4040 pathB.close(); 4041 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4042 } 4043 4044 static void loop12(skiatest::Reporter* reporter, const char* filename) { 4045 SkPath path, pathB; 4046 path.moveTo(1,2); 4047 path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f); 4048 path.close(); 4049 pathB.moveTo(0,6); 4050 pathB.cubicTo(-3.16666675f,3.66666675f, 6.33333349f,3.33333349f, 1,2); 4051 pathB.close(); 4052 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4053 } 4054 4055 static void cubicOp133(skiatest::Reporter* reporter, const char* filename) { 4056 SkPath path, pathB; 4057 path.setFillType(SkPath::kWinding_FillType); 4058 path.moveTo(5,6); 4059 path.cubicTo(5,6, 5,0, 4,1); 4060 path.close(); 4061 pathB.setFillType(SkPath::kWinding_FillType); 4062 pathB.moveTo(0,5); 4063 pathB.cubicTo(1,4, 6,5, 6,5); 4064 pathB.close(); 4065 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4066 } 4067 4068 static void cubicOp134(skiatest::Reporter* reporter, const char* filename) { 4069 SkPath path, pathB; 4070 path.setFillType(SkPath::kWinding_FillType); 4071 path.moveTo(5,6); 4072 path.cubicTo(5,6, 6,0, 3,1); 4073 path.close(); 4074 pathB.setFillType(SkPath::kWinding_FillType); 4075 pathB.moveTo(0,6); 4076 pathB.cubicTo(1,3, 6,5, 6,5); 4077 pathB.close(); 4078 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4079 } 4080 4081 static void cubicOp135(skiatest::Reporter* reporter, const char* filename) { 4082 SkPath path, pathB; 4083 path.setFillType(SkPath::kWinding_FillType); 4084 path.moveTo(5,6); 4085 path.cubicTo(5,6, 6,0, 4,1); 4086 path.close(); 4087 pathB.setFillType(SkPath::kWinding_FillType); 4088 pathB.moveTo(0,6); 4089 pathB.cubicTo(1,4, 6,5, 6,5); 4090 pathB.close(); 4091 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4092 } 4093 4094 static void cubicOp136(skiatest::Reporter* reporter, const char* filename) { 4095 SkPath path, pathB; 4096 path.setFillType(SkPath::kWinding_FillType); 4097 path.moveTo(5,6); 4098 path.cubicTo(5,6, 5,0, 3,1); 4099 path.close(); 4100 pathB.setFillType(SkPath::kWinding_FillType); 4101 pathB.moveTo(0,5); 4102 pathB.cubicTo(1,3, 6,5, 6,5); 4103 pathB.close(); 4104 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4105 } 4106 4107 static void cubicOp136a(skiatest::Reporter* reporter, const char* filename) { 4108 SkPath path, pathB; 4109 path.setFillType(SkPath::kWinding_FillType); 4110 path.moveTo(5,6); 4111 path.quadTo(5,0, 3,1); 4112 path.close(); 4113 pathB.setFillType(SkPath::kWinding_FillType); 4114 pathB.moveTo(0,5); 4115 pathB.cubicTo(1,3, 6,5, 6,5); 4116 pathB.close(); 4117 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4118 } 4119 4120 static void cubics137(skiatest::Reporter* reporter, const char* filename) { 4121 SkPath path, pathB; 4122 path.setFillType(SkPath::kWinding_FillType); 4123 path.moveTo(0, 5); 4124 path.cubicTo(3, 6, 1, 0, 3, 2); 4125 path.close(); 4126 pathB.setFillType(SkPath::kWinding_FillType); 4127 pathB.moveTo(0, 1); 4128 pathB.cubicTo(2, 3, 5, 0, 6, 3); 4129 pathB.close(); 4130 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4131 } 4132 4133 static void cubics138(skiatest::Reporter* reporter, const char* filename) { 4134 SkPath path, pathB; 4135 path.setFillType(SkPath::kWinding_FillType); 4136 path.moveTo(0, 5); 4137 path.cubicTo(3, 6, 1, 0, 4, 2); 4138 path.close(); 4139 pathB.setFillType(SkPath::kWinding_FillType); 4140 pathB.moveTo(0, 1); 4141 pathB.cubicTo(2, 4, 5, 0, 6, 3); 4142 pathB.close(); 4143 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4144 } 4145 4146 // three curves intersect successfully nearby -- the angle only gets 2 of the 3 pts 4147 static void cubicOp139(skiatest::Reporter* reporter, const char* filename) { 4148 SkPath path, pathB; 4149 path.setFillType(SkPath::kWinding_FillType); 4150 path.moveTo(0,2); 4151 path.cubicTo(0,4, 3,1, 5,1); 4152 path.close(); 4153 pathB.setFillType(SkPath::kWinding_FillType); 4154 pathB.moveTo(1,3); 4155 pathB.cubicTo(1,5, 2,0, 4,0); 4156 pathB.close(); 4157 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4158 } 4159 4160 static void cubicOp140(skiatest::Reporter* reporter, const char* filename) { 4161 SkPath path, pathB; 4162 path.setFillType(SkPath::kWinding_FillType); 4163 path.moveTo(0,2); 4164 path.cubicTo(1,2, 5,4, 3,2); 4165 path.close(); 4166 pathB.setFillType(SkPath::kWinding_FillType); 4167 pathB.moveTo(4,5); 4168 pathB.cubicTo(2,3, 2,0, 2,1); 4169 pathB.close(); 4170 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4171 } 4172 4173 static void cubicOp141(skiatest::Reporter* reporter, const char* filename) { 4174 SkPath path, pathB; 4175 path.setFillType(SkPath::kWinding_FillType); 4176 path.moveTo(0,2); 4177 path.cubicTo(1,2, 6,4, 3,2); 4178 path.close(); 4179 pathB.setFillType(SkPath::kWinding_FillType); 4180 pathB.moveTo(4,6); 4181 pathB.cubicTo(2,3, 2,0, 2,1); 4182 pathB.close(); 4183 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4184 } 4185 4186 static void quadRect1(skiatest::Reporter* reporter, const char* filename) { 4187 SkPath path, pathB; 4188 path.moveTo(6,15); 4189 path.quadTo(16,0, 8,4); 4190 path.quadTo(2,7, 12,12); 4191 path.close(); 4192 pathB.addRect(4,11, 13,16); 4193 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4194 } 4195 4196 static void quadRect2(skiatest::Reporter* reporter, const char* filename) { 4197 SkPath path, pathB; 4198 path.moveTo(5,12); 4199 path.quadTo(15,7, 9,4); 4200 path.quadTo(1,0, 11,15); 4201 path.close(); 4202 pathB.addRect(4,11, 13,16); 4203 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4204 } 4205 4206 static void quadRect3(skiatest::Reporter* reporter, const char* filename) { 4207 SkPath path, pathB; 4208 path.moveTo(12,12); 4209 path.quadTo(2,7, 8,4); 4210 path.quadTo(16,0, 6,15); 4211 path.close(); 4212 pathB.addRect(4,11, 13,16); 4213 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4214 } 4215 4216 static void quadRect4(skiatest::Reporter* reporter, const char* filename) { 4217 SkPath path, pathB; 4218 path.moveTo(11,15); 4219 path.quadTo(1,0, 9,4); 4220 path.quadTo(15,7, 5,12); 4221 path.close(); 4222 pathB.addRect(4,11, 13,16); 4223 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4224 } 4225 4226 static void quadRect5(skiatest::Reporter* reporter, const char* filename) { 4227 SkPath path, pathB; 4228 path.moveTo(11,13); 4229 path.quadTo(4,4, 8,4); 4230 path.quadTo(12,4, 5,13); 4231 path.close(); 4232 pathB.addRect(4,11, 13,16); 4233 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4234 } 4235 4236 static void quadRect6(skiatest::Reporter* reporter, const char* filename) { 4237 SkPath path, pathB; 4238 path.moveTo(5,13); 4239 path.quadTo(12,4, 8,4); 4240 path.quadTo(4,4, 11,13); 4241 path.close(); 4242 pathB.addRect(4,11, 13,16); 4243 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4244 } 4245 4246 static void loops4i(skiatest::Reporter* reporter, const char* filename) { 4247 SkPath path, pathB; 4248 path.setFillType(SkPath::kWinding_FillType); 4249 path.moveTo(0, 3); 4250 path.cubicTo(0, 2, 0, 2, -1.66666663f, 2.16666675f); 4251 path.close(); 4252 pathB.setFillType(SkPath::kWinding_FillType); 4253 pathB.moveTo(0, 2); 4254 pathB.cubicTo(0, 2, -1.66666663f, 2.16666675f, 0, 3); 4255 pathB.close(); 4256 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4257 } 4258 4259 static void loops5i(skiatest::Reporter* reporter, const char* filename) { 4260 SkPath path, pathB; 4261 path.setFillType(SkPath::kWinding_FillType); 4262 path.moveTo(1, 2); 4263 path.cubicTo(0, 2, 0, 2, 0.166666672f, 2.66666675f); 4264 path.close(); 4265 pathB.setFillType(SkPath::kWinding_FillType); 4266 pathB.moveTo(0, 2); 4267 pathB.cubicTo(0, 2, 0.166666672f, 2.66666675f, 1, 2); 4268 pathB.close(); 4269 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4270 } 4271 4272 static void cubicOp142(skiatest::Reporter* reporter, const char* filename) { 4273 SkPath path, pathB; 4274 path.setFillType(SkPath::kWinding_FillType); 4275 path.moveTo(5,6); 4276 path.cubicTo(2,5, 2,1, 1,0); 4277 path.close(); 4278 pathB.setFillType(SkPath::kWinding_FillType); 4279 pathB.moveTo(1,2); 4280 pathB.cubicTo(0,1, 6,5, 5,2); 4281 pathB.close(); 4282 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4283 } 4284 4285 static void cubics6d(skiatest::Reporter* reporter, const char* filename) { 4286 SkPath path, pathB; 4287 path.setFillType(SkPath::kWinding_FillType); 4288 path.moveTo(3, 5); 4289 path.cubicTo(1, 5, 4, 2, 4, 0); 4290 path.close(); 4291 pathB.setFillType(SkPath::kWinding_FillType); 4292 pathB.moveTo(2, 4); 4293 pathB.cubicTo(0, 4, 5, 3, 5, 1); 4294 pathB.close(); 4295 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4296 } 4297 4298 static void cubics7d(skiatest::Reporter* reporter, const char* filename) { 4299 SkPath path, pathB; 4300 path.setFillType(SkPath::kWinding_FillType); 4301 path.moveTo(2, 6); 4302 path.cubicTo(2, 4, 5, 1, 3, 1); 4303 path.close(); 4304 pathB.setFillType(SkPath::kWinding_FillType); 4305 pathB.moveTo(1, 5); 4306 pathB.cubicTo(1, 3, 6, 2, 4, 2); 4307 pathB.close(); 4308 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4309 } 4310 4311 static void cubics8d(skiatest::Reporter* reporter, const char* filename) { 4312 SkPath path, pathB; 4313 path.setFillType(SkPath::kWinding_FillType); 4314 path.moveTo(2, 5); 4315 path.cubicTo(2, 4, 5, 1, 3, 2); 4316 path.close(); 4317 pathB.setFillType(SkPath::kWinding_FillType); 4318 pathB.moveTo(1, 5); 4319 pathB.cubicTo(2, 3, 5, 2, 4, 2); 4320 pathB.close(); 4321 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4322 } 4323 4324 static void cubics9d(skiatest::Reporter* reporter, const char* filename) { 4325 SkPath path, pathB; 4326 path.setFillType(SkPath::kWinding_FillType); 4327 path.moveTo(2, 4); 4328 path.cubicTo(2, 6, 3, 1, 5, 1); 4329 path.close(); 4330 pathB.setFillType(SkPath::kWinding_FillType); 4331 pathB.moveTo(1, 3); 4332 pathB.cubicTo(1, 5, 4, 2, 6, 2); 4333 pathB.close(); 4334 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4335 } 4336 4337 static void cubics10u(skiatest::Reporter* reporter, const char* filename) { 4338 SkPath path, pathB; 4339 path.setFillType(SkPath::kWinding_FillType); 4340 path.moveTo(2, 4); 4341 path.cubicTo(1, 6, 4, 1, 5, 1); 4342 path.close(); 4343 pathB.setFillType(SkPath::kWinding_FillType); 4344 pathB.moveTo(1, 4); 4345 pathB.cubicTo(1, 5, 4, 2, 6, 1); 4346 pathB.close(); 4347 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 4348 } 4349 4350 static void cubics11i(skiatest::Reporter* reporter, const char* filename) { 4351 SkPath path, pathB; 4352 path.setFillType(SkPath::kWinding_FillType); 4353 path.moveTo(2, 4); 4354 path.cubicTo(2, 5, 3, 2, 5, 1); 4355 path.close(); 4356 pathB.setFillType(SkPath::kWinding_FillType); 4357 pathB.moveTo(2, 3); 4358 pathB.cubicTo(1, 5, 4, 2, 5, 2); 4359 pathB.close(); 4360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4361 } 4362 4363 static void cubics12d(skiatest::Reporter* reporter, const char* filename) { 4364 SkPath path, pathB; 4365 path.setFillType(SkPath::kWinding_FillType); 4366 path.moveTo(2, 4); 4367 path.cubicTo(0, 4, 5, 3, 5, 1); 4368 path.close(); 4369 pathB.setFillType(SkPath::kWinding_FillType); 4370 pathB.moveTo(3, 5); 4371 pathB.cubicTo(1, 5, 4, 2, 4, 0); 4372 pathB.close(); 4373 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4374 } 4375 4376 static void cubics13d(skiatest::Reporter* reporter, const char* filename) { 4377 SkPath path, pathB; 4378 path.setFillType(SkPath::kWinding_FillType); 4379 path.moveTo(2, 3); 4380 path.cubicTo(1, 5, 4, 2, 5, 2); 4381 path.close(); 4382 pathB.setFillType(SkPath::kWinding_FillType); 4383 pathB.moveTo(2, 4); 4384 pathB.cubicTo(2, 5, 3, 2, 5, 1); 4385 pathB.close(); 4386 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4387 } 4388 4389 static void cubics14d(skiatest::Reporter* reporter, const char* filename) { 4390 SkPath path, pathB; 4391 path.setFillType(SkPath::kWinding_FillType); 4392 path.moveTo(2, 3); 4393 path.cubicTo(0, 4, 3, 1, 3, 0); 4394 path.close(); 4395 pathB.setFillType(SkPath::kWinding_FillType); 4396 pathB.moveTo(1, 3); 4397 pathB.cubicTo(0, 3, 3, 2, 4, 0); 4398 pathB.close(); 4399 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4400 } 4401 4402 static void cubics15d(skiatest::Reporter* reporter, const char* filename) { 4403 SkPath path, pathB; 4404 path.setFillType(SkPath::kWinding_FillType); 4405 path.moveTo(1, 5); 4406 path.cubicTo(3, 5, 4, 0, 4, 2); 4407 path.close(); 4408 pathB.setFillType(SkPath::kWinding_FillType); 4409 pathB.moveTo(0, 4); 4410 pathB.cubicTo(2, 4, 5, 1, 5, 3); 4411 pathB.close(); 4412 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4413 } 4414 4415 static void cubics16i(skiatest::Reporter* reporter, const char* filename) { 4416 SkPath path, pathB; 4417 path.setFillType(SkPath::kWinding_FillType); 4418 path.moveTo(1, 5); 4419 path.cubicTo(2, 5, 5, 0, 4, 2); 4420 path.close(); 4421 pathB.setFillType(SkPath::kWinding_FillType); 4422 pathB.moveTo(0, 5); 4423 pathB.cubicTo(2, 4, 5, 1, 5, 2); 4424 pathB.close(); 4425 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4426 } 4427 4428 static void cubics17d(skiatest::Reporter* reporter, const char* filename) { 4429 SkPath path, pathB; 4430 path.setFillType(SkPath::kWinding_FillType); 4431 path.moveTo(1, 5); 4432 path.cubicTo(3, 4, 4, 1, 4, 2); 4433 path.close(); 4434 pathB.setFillType(SkPath::kWinding_FillType); 4435 pathB.moveTo(1, 4); 4436 pathB.cubicTo(2, 4, 5, 1, 4, 3); 4437 pathB.close(); 4438 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4439 } 4440 4441 static void cubics18d(skiatest::Reporter* reporter, const char* filename) { 4442 SkPath path, pathB; 4443 path.setFillType(SkPath::kWinding_FillType); 4444 path.moveTo(1, 5); 4445 path.cubicTo(1, 3, 4, 0, 2, 0); 4446 path.close(); 4447 pathB.setFillType(SkPath::kWinding_FillType); 4448 pathB.moveTo(0, 4); 4449 pathB.cubicTo(0, 2, 5, 1, 3, 1); 4450 pathB.close(); 4451 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4452 } 4453 4454 static void cubics19d(skiatest::Reporter* reporter, const char* filename) { 4455 SkPath path, pathB; 4456 path.setFillType(SkPath::kWinding_FillType); 4457 path.moveTo(1, 5); 4458 path.cubicTo(2, 3, 5, 2, 4, 2); 4459 path.close(); 4460 pathB.setFillType(SkPath::kWinding_FillType); 4461 pathB.moveTo(2, 5); 4462 pathB.cubicTo(2, 4, 5, 1, 3, 2); 4463 pathB.close(); 4464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4465 } 4466 4467 static void cubicOp157(skiatest::Reporter* reporter, const char* filename) { 4468 SkPath path, pathB; 4469 path.setFillType(SkPath::kWinding_FillType); 4470 path.moveTo(1,5); 4471 path.cubicTo(1,3, 6,2, 4,2); 4472 path.close(); 4473 pathB.setFillType(SkPath::kWinding_FillType); 4474 pathB.moveTo(2,6); 4475 pathB.cubicTo(2,4, 5,1, 3,1); 4476 pathB.close(); 4477 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4478 } 4479 4480 static void cubics20d(skiatest::Reporter* reporter, const char* filename) { 4481 SkPath path, pathB; 4482 path.setFillType(SkPath::kWinding_FillType); 4483 path.moveTo(1, 2); 4484 path.cubicTo(0, 3, 6, 0, 3, 2); 4485 path.close(); 4486 pathB.setFillType(SkPath::kWinding_FillType); 4487 pathB.moveTo(0, 6); 4488 pathB.cubicTo(2, 3, 2, 1, 3, 0); 4489 pathB.close(); 4490 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 4491 } 4492 4493 static void loops20i(skiatest::Reporter* reporter, const char* filename) { 4494 SkPath path, pathB; 4495 path.setFillType(SkPath::kWinding_FillType); 4496 path.moveTo(1, 2); 4497 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3.66666651f); 4498 path.close(); 4499 pathB.setFillType(SkPath::kWinding_FillType); 4500 pathB.moveTo(0, 2); 4501 pathB.cubicTo(0.833333313f, 2, 1, 3.66666651f, 1, 2); 4502 pathB.close(); 4503 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4504 } 4505 4506 static void loops21i(skiatest::Reporter* reporter, const char* filename) { 4507 SkPath path, pathB; 4508 path.setFillType(SkPath::kWinding_FillType); 4509 path.moveTo(1, 2); 4510 path.cubicTo(0, 2, 0.833333313f, 2, 1, 4); 4511 path.close(); 4512 pathB.setFillType(SkPath::kWinding_FillType); 4513 pathB.moveTo(0, 2); 4514 pathB.cubicTo(0.833333313f, 2, 1, 4, 1, 2); 4515 pathB.close(); 4516 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4517 } 4518 4519 static void loops22i(skiatest::Reporter* reporter, const char* filename) { 4520 SkPath path, pathB; 4521 path.setFillType(SkPath::kWinding_FillType); 4522 path.moveTo(1, 3); 4523 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.66666651f); 4524 path.close(); 4525 pathB.setFillType(SkPath::kWinding_FillType); 4526 pathB.moveTo(0, 3); 4527 pathB.cubicTo(0.833333313f, 3, 1, 4.66666651f, 1, 3); 4528 pathB.close(); 4529 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4530 } 4531 4532 static void loops23i(skiatest::Reporter* reporter, const char* filename) { 4533 SkPath path, pathB; 4534 path.setFillType(SkPath::kWinding_FillType); 4535 path.moveTo(1, 5); 4536 path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f); 4537 path.close(); 4538 pathB.setFillType(SkPath::kWinding_FillType); 4539 pathB.moveTo(0, 1); 4540 pathB.cubicTo(6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f, 1, 5); 4541 pathB.close(); 4542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4543 } 4544 4545 static void loops24i(skiatest::Reporter* reporter, const char* filename) { 4546 SkPath path, pathB; 4547 path.setFillType(SkPath::kWinding_FillType); 4548 path.moveTo(1, 2); 4549 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3); 4550 path.close(); 4551 pathB.setFillType(SkPath::kWinding_FillType); 4552 pathB.moveTo(0, 2); 4553 pathB.cubicTo(0.833333313f, 2, 1, 3, 1, 2); 4554 pathB.close(); 4555 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4556 } 4557 4558 static void loops25i(skiatest::Reporter* reporter, const char* filename) { 4559 SkPath path, pathB; 4560 path.setFillType(SkPath::kWinding_FillType); 4561 path.moveTo(1, 5); 4562 path.cubicTo(0, 5, 0.833333313f, 5, 1, 7); 4563 path.close(); 4564 pathB.setFillType(SkPath::kWinding_FillType); 4565 pathB.moveTo(0, 5); 4566 pathB.cubicTo(0.833333313f, 5, 1, 7, 1, 5); 4567 pathB.close(); 4568 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4569 } 4570 4571 static void loops26i(skiatest::Reporter* reporter, const char* filename) { 4572 SkPath path, pathB; 4573 path.setFillType(SkPath::kWinding_FillType); 4574 path.moveTo(1, 6); 4575 path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f); 4576 path.close(); 4577 pathB.setFillType(SkPath::kWinding_FillType); 4578 pathB.moveTo(0, 2); 4579 pathB.cubicTo(6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f, 1, 6); 4580 pathB.close(); 4581 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4582 } 4583 4584 static void loops27i(skiatest::Reporter* reporter, const char* filename) { 4585 SkPath path, pathB; 4586 path.setFillType(SkPath::kWinding_FillType); 4587 path.moveTo(1, 3); 4588 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f); 4589 path.close(); 4590 pathB.setFillType(SkPath::kWinding_FillType); 4591 pathB.moveTo(0, 3); 4592 pathB.cubicTo(0.833333313f, 3, 1, 4.33333349f, 1, 3); 4593 pathB.close(); 4594 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4595 } 4596 4597 static void loops28i(skiatest::Reporter* reporter, const char* filename) { 4598 SkPath path, pathB; 4599 path.setFillType(SkPath::kWinding_FillType); 4600 path.moveTo(2, 3); 4601 path.cubicTo(1, 3, 1.83333337f, 3, 2, 4.66666651f); 4602 path.close(); 4603 pathB.setFillType(SkPath::kWinding_FillType); 4604 pathB.moveTo(1, 3); 4605 pathB.cubicTo(1.83333337f, 3, 2, 4.66666651f, 2, 3); 4606 pathB.close(); 4607 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4608 } 4609 4610 static void loops29i(skiatest::Reporter* reporter, const char* filename) { 4611 SkPath path, pathB; 4612 path.setFillType(SkPath::kWinding_FillType); 4613 path.moveTo(2, 4); 4614 path.cubicTo(0, 4, 1.66666663f, 4, 2, 7.33333302f); 4615 path.close(); 4616 pathB.setFillType(SkPath::kWinding_FillType); 4617 pathB.moveTo(0, 4); 4618 pathB.cubicTo(1.66666663f, 4, 2, 7.33333302f, 2, 4); 4619 pathB.close(); 4620 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4621 } 4622 4623 static void loops30i(skiatest::Reporter* reporter, const char* filename) { 4624 SkPath path, pathB; 4625 path.setFillType(SkPath::kWinding_FillType); 4626 path.moveTo(2, 4); 4627 path.cubicTo(0, 4, 1.66666663f, 4, 2, 8); 4628 path.close(); 4629 pathB.setFillType(SkPath::kWinding_FillType); 4630 pathB.moveTo(0, 4); 4631 pathB.cubicTo(1.66666663f, 4, 2, 8, 2, 4); 4632 pathB.close(); 4633 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4634 } 4635 4636 static void loops31i(skiatest::Reporter* reporter, const char* filename) { 4637 SkPath path, pathB; 4638 path.setFillType(SkPath::kWinding_FillType); 4639 path.moveTo(2, 5); 4640 path.cubicTo(1, 5, 1.83333337f, 5, 2, 6.66666651f); 4641 path.close(); 4642 pathB.setFillType(SkPath::kWinding_FillType); 4643 pathB.moveTo(1, 5); 4644 pathB.cubicTo(1.83333337f, 5, 2, 6.66666651f, 2, 5); 4645 pathB.close(); 4646 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4647 } 4648 4649 static void loops32i(skiatest::Reporter* reporter, const char* filename) { 4650 SkPath path, pathB; 4651 path.setFillType(SkPath::kWinding_FillType); 4652 path.moveTo(2, 6); 4653 path.cubicTo(1, 6, 1.83333337f, 6, 2, 8); 4654 path.close(); 4655 pathB.setFillType(SkPath::kWinding_FillType); 4656 pathB.moveTo(1, 6); 4657 pathB.cubicTo(1.83333337f, 6, 2, 8, 2, 6); 4658 pathB.close(); 4659 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4660 } 4661 4662 static void loops33i(skiatest::Reporter* reporter, const char* filename) { 4663 SkPath path, pathB; 4664 path.setFillType(SkPath::kWinding_FillType); 4665 path.moveTo(2, 6); 4666 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f); 4667 path.close(); 4668 pathB.setFillType(SkPath::kWinding_FillType); 4669 pathB.moveTo(1, 2); 4670 pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6); 4671 pathB.close(); 4672 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4673 } 4674 4675 static void loops33iMod(skiatest::Reporter* reporter, const char* filename) { 4676 SkPoint pts[] = {{2, 6}, {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f}, 4677 {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f}, {2, 6}}; 4678 bool up = false; 4679 float offset = 0.0380172729f; 4680 float step = 7.62939453e-006f; 4681 bool lastResult = true; 4682 // for (int i = 0; i < 30; ++i) { 4683 SkString name(filename); 4684 // name.appendS32(i); 4685 // if (i > 0) { 4686 // SkDebugf("\n\n<div id=\"%s\">\n", name.c_str()); 4687 // } 4688 pts[5].fY = 6.66666698f + offset; 4689 SkPath path, pathB; 4690 path.setFillType(SkPath::kWinding_FillType); 4691 path.moveTo(pts[0]); 4692 path.cubicTo(pts[1], pts[2], pts[3]); 4693 path.close(); 4694 pathB.setFillType(SkPath::kWinding_FillType); 4695 pathB.moveTo(pts[4]); 4696 pathB.cubicTo(pts[5], pts[6], pts[7]); 4697 pathB.close(); 4698 bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str()); 4699 if (lastResult != result) { 4700 up = !up; 4701 } 4702 step /= 2; 4703 offset += up ? step : -step; 4704 lastResult = result; 4705 // } 4706 } 4707 4708 4709 static void loops33iAsQuads(skiatest::Reporter* reporter, const char* filename) { 4710 SkPath path, pathB; 4711 path.setFillType(SkPath::kWinding_FillType); 4712 path.moveTo(2, 6); 4713 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f); 4714 path.close(); 4715 pathB.setFillType(SkPath::kWinding_FillType); 4716 pathB.moveTo(1, 2); 4717 pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6); 4718 pathB.close(); 4719 SkPath qPath, qPathB; 4720 CubicPathToQuads(path, &qPath); 4721 CubicPathToQuads(pathB, &qPathB); 4722 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename); 4723 } 4724 4725 static void loops34i(skiatest::Reporter* reporter, const char* filename) { 4726 SkPath path, pathB; 4727 path.setFillType(SkPath::kWinding_FillType); 4728 path.moveTo(3, 4); 4729 path.cubicTo(0, 4, 2.5f, 4, 3, 9); 4730 path.close(); 4731 pathB.setFillType(SkPath::kWinding_FillType); 4732 pathB.moveTo(0, 4); 4733 pathB.cubicTo(2.5f, 4, 3, 9, 3, 4); 4734 pathB.close(); 4735 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4736 } 4737 4738 static void loops35i(skiatest::Reporter* reporter, const char* filename) { 4739 SkPath path, pathB; 4740 path.setFillType(SkPath::kWinding_FillType); 4741 path.moveTo(3, 4); 4742 path.cubicTo(0, 4, 2.5f, 4, 3, 10); 4743 path.close(); 4744 pathB.setFillType(SkPath::kWinding_FillType); 4745 pathB.moveTo(0, 4); 4746 pathB.cubicTo(2.5f, 4, 3, 10, 3, 4); 4747 pathB.close(); 4748 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4749 } 4750 4751 static void loops36i(skiatest::Reporter* reporter, const char* filename) { 4752 SkPath path, pathB; 4753 path.setFillType(SkPath::kWinding_FillType); 4754 path.moveTo(3, 4); 4755 path.cubicTo(1, 4, 2.66666675f, 4, 3, 8); 4756 path.close(); 4757 pathB.setFillType(SkPath::kWinding_FillType); 4758 pathB.moveTo(1, 4); 4759 pathB.cubicTo(2.66666675f, 4, 3, 8, 3, 4); 4760 pathB.close(); 4761 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4762 } 4763 4764 static void loops37i(skiatest::Reporter* reporter, const char* filename) { 4765 SkPath path, pathB; 4766 path.setFillType(SkPath::kWinding_FillType); 4767 path.moveTo(2, 4); 4768 path.cubicTo(1, 4, 1.83333337f, 4, 2, 5.33333349f); 4769 path.close(); 4770 pathB.setFillType(SkPath::kWinding_FillType); 4771 pathB.moveTo(1, 4); 4772 pathB.cubicTo(1.83333337f, 4, 2, 5.33333349f, 2, 4); 4773 pathB.close(); 4774 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4775 } 4776 4777 static void loops38i(skiatest::Reporter* reporter, const char* filename) { 4778 SkPath path, pathB; 4779 path.setFillType(SkPath::kWinding_FillType); 4780 path.moveTo(3, 4); 4781 path.cubicTo(2, 4, 2.83333325f, 4, 3, 6); 4782 path.close(); 4783 pathB.setFillType(SkPath::kWinding_FillType); 4784 pathB.moveTo(2, 4); 4785 pathB.cubicTo(2.83333325f, 4, 3, 6, 3, 4); 4786 pathB.close(); 4787 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4788 } 4789 4790 static void loops39i(skiatest::Reporter* reporter, const char* filename) { 4791 SkPath path, pathB; 4792 path.setFillType(SkPath::kWinding_FillType); 4793 path.moveTo(3, 5); 4794 path.cubicTo(0, 5, 2.5f, 5, 3, 10); 4795 path.close(); 4796 pathB.setFillType(SkPath::kWinding_FillType); 4797 pathB.moveTo(0, 5); 4798 pathB.cubicTo(2.5f, 5, 3, 10, 3, 5); 4799 pathB.close(); 4800 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4801 } 4802 4803 static void loops40i(skiatest::Reporter* reporter, const char* filename) { 4804 SkPath path, pathB; 4805 path.setFillType(SkPath::kWinding_FillType); 4806 path.moveTo(3, 5); 4807 path.cubicTo(0, 5, 2.5f, 5, 3, 11); 4808 path.close(); 4809 pathB.setFillType(SkPath::kWinding_FillType); 4810 pathB.moveTo(0, 5); 4811 pathB.cubicTo(2.5f, 5, 3, 11, 3, 5); 4812 pathB.close(); 4813 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4814 } 4815 4816 static void loops40iAsQuads(skiatest::Reporter* reporter, const char* filename) { 4817 SkPath path, pathB; 4818 path.setFillType(SkPath::kWinding_FillType); 4819 path.moveTo(3, 5); 4820 path.cubicTo(0, 5, 2.5f, 5, 3, 11); 4821 path.close(); 4822 pathB.setFillType(SkPath::kWinding_FillType); 4823 pathB.moveTo(0, 5); 4824 pathB.cubicTo(2.5f, 5, 3, 11, 3, 5); 4825 pathB.close(); 4826 SkPath qPath, qPathB; 4827 CubicPathToQuads(path, &qPath); 4828 CubicPathToQuads(pathB, &qPathB); 4829 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename); 4830 } 4831 4832 static void loops44i(skiatest::Reporter* reporter, const char* filename) { 4833 SkPath path, pathB; 4834 path.setFillType(SkPath::kWinding_FillType); 4835 path.moveTo(1, 5); 4836 path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7); 4837 path.close(); 4838 pathB.setFillType(SkPath::kWinding_FillType); 4839 pathB.moveTo(0, 1); 4840 pathB.cubicTo(7.33333302f, 5.33333349f, -7, 7, 1, 5); 4841 pathB.close(); 4842 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4843 } 4844 4845 static void loops45i(skiatest::Reporter* reporter, const char* filename) { 4846 SkPath path, pathB; 4847 path.setFillType(SkPath::kWinding_FillType); 4848 path.moveTo(1, 6); 4849 path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8); 4850 path.close(); 4851 pathB.setFillType(SkPath::kWinding_FillType); 4852 pathB.moveTo(0, 2); 4853 pathB.cubicTo(7.33333302f, 6.33333302f, -7, 8, 1, 6); 4854 pathB.close(); 4855 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4856 } 4857 4858 static void loops46i(skiatest::Reporter* reporter, const char* filename) { 4859 SkPath path, pathB; 4860 path.setFillType(SkPath::kWinding_FillType); 4861 path.moveTo(2, 6); 4862 path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8); 4863 path.close(); 4864 pathB.setFillType(SkPath::kWinding_FillType); 4865 pathB.moveTo(1, 2); 4866 pathB.cubicTo(8.33333302f, 6.33333302f, -6, 8, 2, 6); 4867 pathB.close(); 4868 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4869 } 4870 4871 /* 4872 FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346 0 */ 4873 static void loops47i(skiatest::Reporter* reporter, const char* filename) { 4874 SkPath path, pathB; 4875 path.setFillType(SkPath::kWinding_FillType); 4876 path.moveTo(2, 4); 4877 path.cubicTo(0, 1, 6, 5.83333302f, -4, 8); 4878 path.close(); 4879 pathB.setFillType(SkPath::kWinding_FillType); 4880 pathB.moveTo(0, 1); 4881 pathB.cubicTo(6, 5.83333302f, -4, 8, 2, 4); 4882 pathB.close(); 4883 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4884 } 4885 4886 static void loops48i(skiatest::Reporter* reporter, const char* filename) { 4887 SkPath path, pathB; 4888 path.setFillType(SkPath::kWinding_FillType); 4889 path.moveTo(2, 6); 4890 path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f); 4891 path.close(); 4892 pathB.setFillType(SkPath::kWinding_FillType); 4893 pathB.moveTo(0, 1); 4894 pathB.cubicTo(9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f, 2, 6); 4895 pathB.close(); 4896 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4897 } 4898 4899 static void loops49i(skiatest::Reporter* reporter, const char* filename) { 4900 SkPath path, pathB; 4901 path.setFillType(SkPath::kWinding_FillType); 4902 path.moveTo(0, 2); 4903 path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2); 4904 path.close(); 4905 pathB.setFillType(SkPath::kWinding_FillType); 4906 pathB.moveTo(1, 4); 4907 pathB.cubicTo(-0.166666687f, 2.66666675f, 1.66666675f, 2, 0, 2); 4908 pathB.close(); 4909 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4910 } 4911 4912 static void loops50i(skiatest::Reporter* reporter, const char* filename) { 4913 SkPath path, pathB; 4914 path.setFillType(SkPath::kWinding_FillType); 4915 path.moveTo(0, 3); 4916 path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3); 4917 path.close(); 4918 pathB.setFillType(SkPath::kWinding_FillType); 4919 pathB.moveTo(1, 5); 4920 pathB.cubicTo(-0.166666687f, 3.66666675f, 1.66666675f, 3, 0, 3); 4921 pathB.close(); 4922 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4923 } 4924 4925 static void loops51i(skiatest::Reporter* reporter, const char* filename) { 4926 SkPath path, pathB; 4927 path.setFillType(SkPath::kWinding_FillType); 4928 path.moveTo(1, 2); 4929 path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2); 4930 path.close(); 4931 pathB.setFillType(SkPath::kWinding_FillType); 4932 pathB.moveTo(2, 4); 4933 pathB.cubicTo(0.833333313f, 2.66666675f, 2.66666675f, 2, 1, 2); 4934 pathB.close(); 4935 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4936 } 4937 4938 static void loops52i(skiatest::Reporter* reporter, const char* filename) { 4939 SkPath path, pathB; 4940 path.setFillType(SkPath::kWinding_FillType); 4941 path.moveTo(1, 3); 4942 path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3); 4943 path.close(); 4944 pathB.setFillType(SkPath::kWinding_FillType); 4945 pathB.moveTo(2, 5); 4946 pathB.cubicTo(0.833333313f, 3.66666675f, 2.66666675f, 3, 1, 3); 4947 pathB.close(); 4948 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4949 } 4950 4951 static void loops53i(skiatest::Reporter* reporter, const char* filename) { 4952 SkPath path, pathB; 4953 path.setFillType(SkPath::kWinding_FillType); 4954 path.moveTo(2, 3); 4955 path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3); 4956 path.close(); 4957 pathB.setFillType(SkPath::kWinding_FillType); 4958 pathB.moveTo(3, 5); 4959 pathB.cubicTo(1.83333325f, 3.66666675f, 3.66666651f, 3, 2, 3); 4960 pathB.close(); 4961 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4962 } 4963 4964 static void loops54i(skiatest::Reporter* reporter, const char* filename) { 4965 SkPath path, pathB; 4966 path.setFillType(SkPath::kWinding_FillType); 4967 path.moveTo(0, 2); 4968 path.cubicTo(1, 4, 0, 3, 1.66666675f, 2); 4969 path.close(); 4970 pathB.setFillType(SkPath::kWinding_FillType); 4971 pathB.moveTo(1, 4); 4972 pathB.cubicTo(0, 3, 1.66666675f, 2, 0, 2); 4973 pathB.close(); 4974 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4975 } 4976 4977 static void loops55i(skiatest::Reporter* reporter, const char* filename) { 4978 SkPath path, pathB; 4979 path.setFillType(SkPath::kWinding_FillType); 4980 path.moveTo(0, 3); 4981 path.cubicTo(1, 5, 0, 4, 1.66666675f, 3); 4982 path.close(); 4983 pathB.setFillType(SkPath::kWinding_FillType); 4984 pathB.moveTo(1, 5); 4985 pathB.cubicTo(0, 4, 1.66666675f, 3, 0, 3); 4986 pathB.close(); 4987 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 4988 } 4989 4990 static void loops56i(skiatest::Reporter* reporter, const char* filename) { 4991 SkPath path, pathB; 4992 path.setFillType(SkPath::kWinding_FillType); 4993 path.moveTo(1, 2); 4994 path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2); 4995 path.close(); 4996 pathB.setFillType(SkPath::kWinding_FillType); 4997 pathB.moveTo(2, 4); 4998 pathB.cubicTo(0.99999994f, 3, 2.66666675f, 2, 1, 2); 4999 pathB.close(); 5000 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5001 } 5002 5003 static void loops57i(skiatest::Reporter* reporter, const char* filename) { 5004 SkPath path, pathB; 5005 path.setFillType(SkPath::kWinding_FillType); 5006 path.moveTo(1, 3); 5007 path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3); 5008 path.close(); 5009 pathB.setFillType(SkPath::kWinding_FillType); 5010 pathB.moveTo(2, 5); 5011 pathB.cubicTo(0.99999994f, 4, 2.66666675f, 3, 1, 3); 5012 pathB.close(); 5013 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5014 } 5015 5016 static void loops58i(skiatest::Reporter* reporter, const char* filename) { 5017 SkPath path, pathB; 5018 path.setFillType(SkPath::kWinding_FillType); 5019 path.moveTo(2, 3); 5020 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3); 5021 path.close(); 5022 pathB.setFillType(SkPath::kWinding_FillType); 5023 pathB.moveTo(3, 5); 5024 pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3); 5025 pathB.close(); 5026 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5027 } 5028 5029 static void loops58iAsQuads(skiatest::Reporter* reporter, const char* filename) { 5030 SkPath path, pathB; 5031 path.setFillType(SkPath::kWinding_FillType); 5032 path.moveTo(2, 3); 5033 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3); 5034 path.close(); 5035 pathB.setFillType(SkPath::kWinding_FillType); 5036 pathB.moveTo(3, 5); 5037 pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3); 5038 pathB.close(); 5039 SkPath qPath, qPathB; 5040 CubicPathToQuads(path, &qPath); 5041 CubicPathToQuads(pathB, &qPathB); 5042 // SkPoint from = {2.61714339f,1.90228665f}; 5043 // SkPoint to = {2.617045833359139f,1.9013528935803314f}; 5044 // path_edit(from, to, &qPathB); 5045 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename); 5046 } 5047 5048 static void loops59i(skiatest::Reporter* reporter, const char* filename) { 5049 SkPath path, pathB; 5050 path.setFillType(SkPath::kWinding_FillType); 5051 path.moveTo(0, 6); 5052 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2); 5053 path.close(); 5054 pathB.setFillType(SkPath::kWinding_FillType); 5055 pathB.moveTo(1, 2); 5056 pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6); 5057 pathB.close(); 5058 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5059 } 5060 5061 static void loops59iasQuads(skiatest::Reporter* reporter, const char* filename) { 5062 SkPath path, pathB; 5063 path.setFillType(SkPath::kWinding_FillType); 5064 path.moveTo(0, 6); 5065 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2); 5066 path.close(); 5067 pathB.setFillType(SkPath::kWinding_FillType); 5068 pathB.moveTo(1, 2); 5069 pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6); 5070 pathB.close(); 5071 SkPath qPath, qPathB; 5072 CubicPathToQuads(path, &qPath); 5073 CubicPathToQuads(pathB, &qPathB); 5074 SkPoint from = {2.61714339f,1.90228665f}; 5075 SkPoint to = {2.617045833359139f,1.9013528935803314f}; 5076 path_edit(from, to, &qPathB); 5077 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename); 5078 } 5079 5080 static void cubics41d(skiatest::Reporter* reporter, const char* filename) { 5081 SkPath path, pathB; 5082 path.setFillType(SkPath::kWinding_FillType); 5083 path.moveTo(0, 1); 5084 path.cubicTo(1, 4, 3, 0, 3, 1); 5085 path.close(); 5086 pathB.setFillType(SkPath::kWinding_FillType); 5087 pathB.moveTo(0, 3); 5088 pathB.cubicTo(1, 3, 1, 0, 4, 1); 5089 pathB.close(); 5090 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5091 } 5092 5093 void loops61i(skiatest::Reporter* reporter, const char* filename) { 5094 SkPath path, pathB; 5095 path.setFillType(SkPath::kWinding_FillType); 5096 path.moveTo(0, 1); 5097 path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1); 5098 path.close(); 5099 pathB.setFillType(SkPath::kWinding_FillType); 5100 pathB.moveTo(1, 5); 5101 pathB.cubicTo(-6.33333302f, 0.666666627f, 8, -1, 0, 1); 5102 pathB.close(); 5103 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5104 } 5105 5106 static void loops62i(skiatest::Reporter* reporter, const char* filename) { 5107 SkPath path, pathB; 5108 path.setFillType(SkPath::kWinding_FillType); 5109 path.moveTo(0, 2); 5110 path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0); 5111 path.close(); 5112 pathB.setFillType(SkPath::kWinding_FillType); 5113 pathB.moveTo(1, 6); 5114 pathB.cubicTo(-6.33333302f, 1.66666663f, 8, 0, 0, 2); 5115 pathB.close(); 5116 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5117 } 5118 5119 static void loops63i(skiatest::Reporter* reporter, const char* filename) { 5120 SkPath path, pathB; 5121 path.setFillType(SkPath::kWinding_FillType); 5122 path.moveTo(0, 1); 5123 path.cubicTo(2, 4, -4, -0.833333254f, 6, -3); 5124 path.close(); 5125 pathB.setFillType(SkPath::kWinding_FillType); 5126 pathB.moveTo(2, 4); 5127 pathB.cubicTo(-4, -0.833333254f, 6, -3, 0, 1); 5128 pathB.close(); 5129 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5130 } 5131 5132 static void cubics44d(skiatest::Reporter* reporter, const char* filename) { 5133 SkPath path, pathB; 5134 path.setFillType(SkPath::kWinding_FillType); 5135 path.moveTo(3, 4); 5136 path.cubicTo(2, 5, 3, 1, 6, 2); 5137 path.close(); 5138 pathB.setFillType(SkPath::kWinding_FillType); 5139 pathB.moveTo(1, 3); 5140 pathB.cubicTo(2, 6, 4, 3, 5, 2); 5141 pathB.close(); 5142 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5143 } 5144 5145 static void cubics45u(skiatest::Reporter* reporter, const char* filename) { 5146 SkPath path, pathB; 5147 path.setFillType(SkPath::kWinding_FillType); 5148 path.moveTo(1, 3); 5149 path.cubicTo(2, 6, 4, 3, 5, 2); 5150 path.close(); 5151 pathB.setFillType(SkPath::kWinding_FillType); 5152 pathB.moveTo(3, 4); 5153 pathB.cubicTo(2, 5, 3, 1, 6, 2); 5154 pathB.close(); 5155 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename); 5156 } 5157 5158 static void fuzz38(skiatest::Reporter* reporter, const char* filename) { 5159 SkPath path, pathB; 5160 path.moveTo(100.34f, 303.312f); 5161 path.lineTo(-1e+08, 303.312f); 5162 path.lineTo(102, 310.156f); 5163 path.lineTo(100.34f, 310.156f); 5164 path.lineTo(100.34f, 303.312f); 5165 path.close(); 5166 testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, true); 5167 } 5168 5169 static void crbug_526025(skiatest::Reporter* reporter, const char* filename) { 5170 SkPath path; 5171 path.setFillType((SkPath::FillType) 1); 5172 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f 5173 path.cubicTo(SkBits2Float(0x4e0d628f), SkBits2Float(0xceffffff), SkBits2Float(0x4e800003), SkBits2Float(0xcec6b143), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffc)); // 5.93012e+08f, -2.14748e+09f, 1.07374e+09f, -1.66675e+09f, 1.07374e+09f, -1.07374e+09f 5174 path.cubicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcde53aee), SkBits2Float(0x4e0d6292), SkBits2Float(0xc307820e), SkBits2Float(0x44627d00), SkBits2Float(0x437ffff2)); // 1.07374e+09f, -4.80731e+08f, 5.93012e+08f, -135.508f, 905.953f, 256 5175 path.lineTo(SkBits2Float(0x444bf3bc), SkBits2Float(0x4460537e)); // 815.808f, 897.305f 5176 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f 5177 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16 5178 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512 5179 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f 5180 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024 5181 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 5182 5183 SkPath path1(path); 5184 path.reset(); 5185 path.setFillType((SkPath::FillType) 0); 5186 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321 5187 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270 5188 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08 5189 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64 5190 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321 5191 path.close(); 5192 5193 SkPath path2(path); 5194 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename); 5195 } 5196 5197 static void fuzzX_392(skiatest::Reporter* reporter, const char* filename) { 5198 SkPath path; 5199 path.setFillType(SkPath::kEvenOdd_FillType); 5200 path.moveTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bde212)); // 29, 379.766f 5201 path.lineTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bdc7ef)); // 29, 379.562f 5202 path.conicTo(SkBits2Float(0x42a5861e), SkBits2Float(0x43c61f86), SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86), SkBits2Float(0x3f7d23f3)); // 82.7619f, 396.246f, 139.024f, 396.246f, 0.98883f 5203 path.conicTo(SkBits2Float(0x42a58e20), SkBits2Float(0x43c61f86), SkBits2Float(0x41e80000), SkBits2Float(0x43bde212), SkBits2Float(0x3f7d2cf5)); // 82.7776f, 396.246f, 29, 379.766f, 0.988967f 5204 path.close(); 5205 5206 SkPath path1(path); 5207 path.setFillType(SkPath::kWinding_FillType); 5208 path.moveTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0xc3a31d72)); // -236.484f, -326.23f 5209 path.lineTo(SkBits2Float(0xc367a4ae), SkBits2Float(0xc3a31d72)); // -231.643f, -326.23f 5210 path.lineTo(SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86)); // 139.024f, 396.246f 5211 path.lineTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0x43c61f86)); // -236.484f, 396.246f 5212 5213 SkPath path2(path); 5214 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename); 5215 } 5216 5217 static void dean2(skiatest::Reporter* reporter, const char* filename) { 5218 SkPath path; 5219 path.setFillType((SkPath::FillType) 0); 5220 path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f 5221 path.cubicTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b), SkBits2Float(0x41531912), SkBits2Float(0x3f130322), SkBits2Float(0x4154a02b), SkBits2Float(0x3f2b74b3)); // 0.669749f, 13.2891f, 13.1936f, 0.574267f, 13.2891f, 0.669749f 5222 path.cubicTo(SkBits2Float(0x414a835a), SkBits2Float(0x3ec07ba6), SkBits2Float(0x413fcc0d), SkBits2Float(0x3e193319), SkBits2Float(0x4134a02b), SkBits2Float(0x00000000)); // 12.6571f, 0.375943f, 11.9873f, 0.149609f, 11.2891f, 0 5223 path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f 5224 path.close(); 5225 SkPath path1(path); 5226 5227 path.reset(); 5228 path.setFillType((SkPath::FillType) 0); 5229 path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f 5230 path.cubicTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b), SkBits2Float(0x41531912), SkBits2Float(0x3f130322), SkBits2Float(0x4154a02b), SkBits2Float(0x3f2b74b3)); // 0.669749f, 13.2891f, 13.1936f, 0.574267f, 13.2891f, 0.669749f 5231 path.lineTo(SkBits2Float(0x417ab74b), SkBits2Float(0x4154a02b)); // 15.6697f, 13.2891f 5232 path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f 5233 path.close(); 5234 SkPath path2(path); 5235 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename); 5236 } 5237 5238 static void cubics_d(skiatest::Reporter* reporter, const char* filename) { 5239 SkPath path, pathB; 5240 path.setFillType(SkPath::kWinding_FillType); 5241 path.moveTo(0, 1); 5242 path.cubicTo(3, 5, 1, 0, 3, 0); 5243 path.close(); 5244 pathB.setFillType(SkPath::kWinding_FillType); 5245 pathB.moveTo(0, 1); 5246 pathB.cubicTo(0, 3, 1, 0, 5, 3); 5247 pathB.close(); 5248 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5249 } 5250 5251 static void cubics_d2(skiatest::Reporter* reporter, const char* filename) { 5252 SkPath path, pathB; 5253 path.setFillType(SkPath::kWinding_FillType); 5254 path.moveTo(0, 1); 5255 path.cubicTo(2, 5, 2, 0, 2, 1); 5256 path.close(); 5257 pathB.setFillType(SkPath::kWinding_FillType); 5258 pathB.moveTo(0, 2); 5259 pathB.cubicTo(1, 2, 1, 0, 5, 2); 5260 pathB.close(); 5261 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5262 } 5263 5264 static void loops_i1(skiatest::Reporter* reporter, const char* filename) { 5265 SkPath path, pathB; 5266 path.setFillType(SkPath::kWinding_FillType); 5267 path.moveTo(2, 3); 5268 path.cubicTo(0, 4, -0.333333343f, 4.66666651f, 3, 5.83333349f); 5269 path.close(); 5270 pathB.setFillType(SkPath::kWinding_FillType); 5271 pathB.moveTo(0, 4); 5272 pathB.cubicTo(-0.333333343f, 4.66666651f, 3, 5.83333349f, 2, 3); 5273 pathB.close(); 5274 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5275 } 5276 5277 static void loops_i2(skiatest::Reporter* reporter, const char* filename) { 5278 SkPath path, pathB; 5279 path.setFillType(SkPath::kWinding_FillType); 5280 path.moveTo(2, 4); 5281 path.cubicTo(0, 5, -0.333333343f, 5.66666651f, 3, 6.83333302f); 5282 path.close(); 5283 pathB.setFillType(SkPath::kWinding_FillType); 5284 pathB.moveTo(0, 5); 5285 pathB.cubicTo(-0.333333343f, 5.66666651f, 3, 6.83333302f, 2, 4); 5286 pathB.close(); 5287 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5288 } 5289 5290 static void loops_i3(skiatest::Reporter* reporter, const char* filename) { 5291 SkPath path, pathB; 5292 path.setFillType(SkPath::kWinding_FillType); 5293 path.moveTo(2, 5); 5294 path.cubicTo(0, 6, -0.333333343f, 6.66666651f, 3, 7.83333302f); 5295 path.close(); 5296 pathB.setFillType(SkPath::kWinding_FillType); 5297 pathB.moveTo(0, 6); 5298 pathB.cubicTo(-0.333333343f, 6.66666651f, 3, 7.83333302f, 2, 5); 5299 pathB.close(); 5300 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5301 } 5302 5303 static void loops_i4(skiatest::Reporter* reporter, const char* filename) { 5304 SkPath path, pathB; 5305 path.setFillType(SkPath::kWinding_FillType); 5306 path.moveTo(3, 4); 5307 path.cubicTo(1, 5, 0.666666627f, 5.66666651f, 4, 6.83333302f); 5308 path.close(); 5309 pathB.setFillType(SkPath::kWinding_FillType); 5310 pathB.moveTo(1, 5); 5311 pathB.cubicTo(0.666666627f, 5.66666651f, 4, 6.83333302f, 3, 4); 5312 pathB.close(); 5313 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5314 } 5315 5316 static void loops_i5(skiatest::Reporter* reporter, const char* filename) { 5317 SkPath path, pathB; 5318 path.setFillType(SkPath::kWinding_FillType); 5319 path.moveTo(3, 5); 5320 path.cubicTo(1, 6, 0.666666627f, 6.66666651f, 4, 7.83333302f); 5321 path.close(); 5322 pathB.setFillType(SkPath::kWinding_FillType); 5323 pathB.moveTo(1, 6); 5324 pathB.cubicTo(0.666666627f, 6.66666651f, 4, 7.83333302f, 3, 5); 5325 pathB.close(); 5326 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5327 } 5328 5329 static void loops_i6(skiatest::Reporter* reporter, const char* filename) { 5330 SkPath path, pathB; 5331 path.setFillType(SkPath::kWinding_FillType); 5332 path.moveTo(4, 5); 5333 path.cubicTo(2, 6, 1.66666663f, 6.66666651f, 5, 7.83333302f); 5334 path.close(); 5335 pathB.setFillType(SkPath::kWinding_FillType); 5336 pathB.moveTo(2, 6); 5337 pathB.cubicTo(1.66666663f, 6.66666651f, 5, 7.83333302f, 4, 5); 5338 pathB.close(); 5339 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5340 } 5341 5342 static void cubics_d3(skiatest::Reporter* reporter, const char* filename) { 5343 SkPath path, pathB; 5344 path.setFillType(SkPath::kWinding_FillType); 5345 path.moveTo(3, 4); 5346 path.cubicTo(0, 6, 6, 1, 4, 2); 5347 path.close(); 5348 pathB.setFillType(SkPath::kWinding_FillType); 5349 pathB.moveTo(1, 6); 5350 pathB.cubicTo(2, 4, 4, 3, 6, 0); 5351 pathB.close(); 5352 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5353 } 5354 5355 static void cubics_o(skiatest::Reporter* reporter, const char* filename) { 5356 SkPath path, pathB; 5357 path.setFillType(SkPath::kWinding_FillType); 5358 path.moveTo(1, 4); 5359 path.cubicTo(2, 6, 5, 0, 5, 3); 5360 path.close(); 5361 pathB.setFillType(SkPath::kWinding_FillType); 5362 pathB.moveTo(0, 5); 5363 pathB.cubicTo(3, 5, 4, 1, 6, 2); 5364 pathB.close(); 5365 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename); 5366 } 5367 5368 static void cubicOp158(skiatest::Reporter* reporter, const char* filename) { 5369 SkPath path, pathB; 5370 path.setFillType(SkPath::kWinding_FillType); 5371 path.moveTo(0,1); 5372 path.cubicTo(2,4, 2,0, 2,0); 5373 path.close(); 5374 pathB.setFillType(SkPath::kWinding_FillType); 5375 pathB.moveTo(0,2); 5376 pathB.cubicTo(0,2, 1,0, 4,2); 5377 pathB.close(); 5378 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5379 } 5380 5381 static void loop17(skiatest::Reporter* reporter, const char* filename) { 5382 SkPath path, pathB; 5383 path.moveTo(1, 2); 5384 path.cubicTo(0, 3, -0.333333343f, 3.33333325f, 0.833333373f, 3.5f); 5385 path.close(); 5386 pathB.moveTo(0, 3); 5387 pathB.cubicTo(-0.333333343f, 3.33333325f, 0.833333373f, 3.5f, 1, 2); 5388 pathB.close(); 5389 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5390 } 5391 5392 static void circlesOp4(skiatest::Reporter* reporter, const char* filename) { 5393 SkPath path, pathB; 5394 path.setFillType(SkPath::kWinding_FillType); 5395 path.addCircle(0, 1, 5, SkPath::kCW_Direction); 5396 pathB.setFillType(SkPath::kWinding_FillType); 5397 pathB.addCircle(0, 1, 0, SkPath::kCW_Direction); 5398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename); 5399 } 5400 5401 static void bug5240(skiatest::Reporter* reporter, const char* filename) { 5402 SkPath path; 5403 path.moveTo(815, 82); 5404 path.cubicTo(814.4794311523438f, 82.7868881225586f, 814.5330810546875f, 5405 82.6266555786133f, 814.5291137695312f, 82.6252212524414f); 5406 path.cubicTo(814.5229492187500f, 82.6230010986328f, 814.3790283203125f, 5407 83.0008087158203f, 813.8533935546875f, 82.7072601318359f); 5408 path.close(); 5409 testPathOp(reporter, path, path, kUnion_SkPathOp, filename); 5410 } 5411 5412 static void android1(skiatest::Reporter* reporter, const char* filename) { 5413 SkPath path, pathB; 5414 path.moveTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0 5415 path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x00000000)); // 1075, 0 5416 path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x43720000)); // 1075, 242 5417 path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x43720000)); // -5, 242 5418 path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0 5419 path.close(); 5420 pathB.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 5421 pathB.lineTo(SkBits2Float(0x44870000), SkBits2Float(0x00000000)); // 1080, 0 5422 pathB.lineTo(SkBits2Float(0x44870000), SkBits2Float(0x43720000)); // 1080, 242 5423 pathB.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x43720000)); // 0, 242 5424 pathB.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 5425 pathB.close(); 5426 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename); 5427 } 5428 5429 5430 static void (*skipTest)(skiatest::Reporter* , const char* filename) = 0; 5431 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0; 5432 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0; 5433 5434 #define TEST(name) { name, #name } 5435 5436 static struct TestDesc tests[] = { 5437 TEST(android1), 5438 TEST(bug5240), 5439 TEST(circlesOp4), 5440 TEST(loop17), 5441 TEST(cubicOp158), 5442 TEST(loops_i1), 5443 TEST(loops_i2), 5444 TEST(loops_i3), 5445 TEST(loops_i4), 5446 TEST(loops_i5), 5447 TEST(loops_i6), 5448 TEST(cubics_d3), 5449 TEST(cubics_o), 5450 TEST(cubics_d2), 5451 TEST(cubics_d), 5452 TEST(dean2), 5453 TEST(fuzzX_392), 5454 TEST(crbug_526025), 5455 TEST(fuzz38), 5456 TEST(cubics44d), 5457 TEST(cubics45u), 5458 TEST(loops61i), 5459 TEST(loops62i), 5460 TEST(loops63i), 5461 TEST(loops58iAsQuads), 5462 TEST(cubics41d), 5463 TEST(loops59iasQuads), 5464 TEST(loops59i), 5465 TEST(loops44i), 5466 TEST(loops45i), 5467 TEST(loops46i), 5468 TEST(loops47i), 5469 TEST(loops48i), 5470 TEST(loops49i), 5471 TEST(loops50i), 5472 TEST(loops51i), 5473 TEST(loops52i), 5474 TEST(loops53i), 5475 TEST(loops54i), 5476 TEST(loops55i), 5477 TEST(loops56i), 5478 TEST(loops57i), 5479 TEST(loops58i), 5480 TEST(loops33iMod), 5481 TEST(loops33iAsQuads), 5482 TEST(loops33i), 5483 TEST(loops40i), 5484 TEST(loops40iAsQuads), 5485 TEST(loops39i), 5486 TEST(loops38i), 5487 TEST(loops37i), 5488 TEST(loops36i), 5489 TEST(loops35i), 5490 TEST(loops34i), 5491 TEST(loops32i), 5492 TEST(loops31i), 5493 TEST(loops30i), 5494 TEST(loops29i), 5495 TEST(loops28i), 5496 TEST(loops27i), 5497 TEST(loops26i), 5498 TEST(loops25i), 5499 TEST(loops24i), 5500 TEST(loops23i), 5501 TEST(loops22i), 5502 TEST(loops21i), 5503 TEST(loops20i), 5504 TEST(cubics20d), 5505 TEST(cubics6d), 5506 TEST(cubics7d), 5507 TEST(cubics8d), 5508 TEST(cubics9d), 5509 TEST(cubics10u), 5510 TEST(cubics11i), 5511 TEST(cubics12d), 5512 TEST(cubics13d), 5513 TEST(cubics14d), 5514 TEST(cubics15d), 5515 TEST(cubics16i), 5516 TEST(cubics17d), 5517 TEST(cubics18d), 5518 TEST(cubics19d), 5519 TEST(cubicOp157), 5520 TEST(cubicOp142), 5521 TEST(loops4i), 5522 TEST(quadRect1), 5523 TEST(quadRect2), 5524 TEST(quadRect3), 5525 TEST(quadRect4), 5526 TEST(quadRect5), 5527 TEST(quadRect6), 5528 TEST(cubicOp141), 5529 TEST(cubicOp58d), 5530 TEST(loops5i), 5531 TEST(cubicOp140), 5532 TEST(cubicOp139), 5533 TEST(cubics138), 5534 TEST(cubics137), 5535 TEST(cubicOp136a), 5536 TEST(cubicOp136), 5537 TEST(cubicOp135), 5538 TEST(cubicOp134), 5539 TEST(cubicOp133), 5540 TEST(loop12), 5541 TEST(cubicOp132), 5542 TEST(loop11), 5543 TEST(loop10), 5544 TEST(circlesOp3), 5545 TEST(loop9), 5546 TEST(loop8), 5547 TEST(rects5), 5548 TEST(loop7), 5549 TEST(cubicOp130a), 5550 TEST(rRect1x), 5551 TEST(circlesOp2), 5552 TEST(circlesOp1), 5553 TEST(cubicOp131), 5554 TEST(cubicOp130), 5555 TEST(cubicOp129), 5556 TEST(cubicOp128), 5557 TEST(cubicOp127), 5558 TEST(cubicOp126), 5559 TEST(cubicOp125), 5560 TEST(cubicOp124), 5561 TEST(loop6), 5562 TEST(loop5), 5563 TEST(cubicOp123), 5564 TEST(cubicOp122), 5565 TEST(cubicOp121), 5566 TEST(cubicOp120), 5567 TEST(cubicOp119), 5568 TEST(loop4), 5569 TEST(loop3), 5570 TEST(loop2), 5571 TEST(loop1asQuad), 5572 TEST(loop1), 5573 TEST(issue3517), 5574 TEST(cubicOp118), 5575 TEST(cubicOp117), 5576 TEST(cubicOp116), 5577 TEST(testRect2), 5578 TEST(testRect1), 5579 TEST(cubicOp115), 5580 TEST(issue2753), 5581 TEST(cubicOp114), 5582 TEST(issue2808), 5583 TEST(cubicOp114asQuad), 5584 TEST(rects4), 5585 TEST(rects3), 5586 TEST(rects2), 5587 TEST(rects1), 5588 TEST(issue2540), 5589 TEST(issue2504), 5590 TEST(kari1), 5591 TEST(quadOp10i), 5592 TEST(cubicOp113), 5593 TEST(skpcarrot_is24), 5594 TEST(issue1417), 5595 TEST(cubicOp112), 5596 TEST(skpadspert_net23), 5597 TEST(skpadspert_de11), 5598 TEST(findFirst1), 5599 TEST(xOp2i), 5600 TEST(xOp3i), 5601 TEST(xOp1u), 5602 TEST(xOp1i), 5603 TEST(cubicOp111), 5604 TEST(cubicOp110), 5605 TEST(cubicOp109), 5606 TEST(cubicOp108), 5607 TEST(cubicOp107), 5608 TEST(cubicOp106), 5609 TEST(cubicOp105), 5610 TEST(cubicOp104), 5611 TEST(cubicOp103), 5612 TEST(cubicOp102), 5613 TEST(cubicOp101), 5614 TEST(cubicOp100), 5615 TEST(cubicOp99), 5616 TEST(issue1435), 5617 TEST(cubicOp98x), 5618 TEST(cubicOp97x), 5619 TEST(skpcarpetplanet_ru22), 5620 TEST(cubicOp96d), 5621 TEST(cubicOp95u), 5622 TEST(skpadbox_lt15), 5623 TEST(skpagentxsites_com55), 5624 TEST(skpadventistmission_org572), 5625 TEST(skpadoption_org196), 5626 TEST(skpbambootheme_com12), 5627 TEST(skpbakosoft_com10), 5628 TEST(skpakmmos_ru100), 5629 TEST(skpbangalorenest_com4), 5630 TEST(skpbingoentertainment_net189), 5631 TEST(skpbestred_ru37), 5632 TEST(skpbenzoteh_ru152), 5633 TEST(skpcamcorder_kz21), 5634 TEST(skpcaffelavazzait_com_ua21), 5635 TEST(skpcarrefour_ro62), 5636 TEST(skpcavablar_net563), 5637 TEST(skpinsomnia_gr72), 5638 TEST(skpadbox_lt8), 5639 TEST(skpact_com43), 5640 TEST(skpacesoftech_com47), 5641 TEST(skpabcspark_ca103), 5642 TEST(cubicOp94u), 5643 TEST(cubicOp93d), 5644 TEST(cubicOp92i), 5645 TEST(skpadithya_putr4_blogspot_com551), 5646 TEST(skpadindex_de4), 5647 TEST(skpaiaigames_com870), 5648 TEST(skpaaalgarve_org53), 5649 TEST(skpkkiste_to716), 5650 TEST(cubicOp91u), 5651 TEST(cubicOp90u), 5652 TEST(cubicOp89u), 5653 TEST(cubicOp88u), 5654 TEST(cubicOp87u), 5655 TEST(cubicOp86i), 5656 TEST(loopEdge2), 5657 TEST(loopEdge1), 5658 TEST(rectOp3x), 5659 TEST(rectOp2i), 5660 TEST(rectOp1i), 5661 TEST(issue1418b), 5662 TEST(cubicOp85i), 5663 TEST(issue1418), 5664 TEST(skpkkiste_to98), 5665 TEST(skpahrefs_com29), 5666 TEST(cubicOp85d), 5667 TEST(skpahrefs_com88), 5668 TEST(skphealth_com76), 5669 TEST(skpancestry_com1), 5670 TEST(skpbyte_com1), 5671 TEST(skpeldorado_com_ua1), 5672 TEST(skp96prezzi1), 5673 TEST(skpClip2), 5674 TEST(skpClip1), 5675 TEST(cubicOp84d), 5676 TEST(cubicOp83i), 5677 TEST(cubicOp82i), 5678 TEST(cubicOp81d), 5679 TEST(cubicOp80i), 5680 TEST(cubicOp79u), 5681 TEST(cubicOp78u), 5682 TEST(cubicOp77i), 5683 TEST(cubicOp76u), 5684 TEST(cubicOp75d), 5685 TEST(cubicOp74d), 5686 TEST(cubicOp73d), 5687 TEST(cubicOp72i), 5688 TEST(cubicOp71d), 5689 TEST(skp5), 5690 TEST(skp4), 5691 TEST(skp3), 5692 TEST(skp2), 5693 TEST(skp1), 5694 TEST(rRect1), 5695 TEST(cubicOp70d), 5696 TEST(cubicOp69d), 5697 TEST(cubicOp68u), 5698 TEST(cubicOp67u), 5699 TEST(cubicOp66u), 5700 TEST(rectOp1d), 5701 TEST(cubicOp65d), 5702 TEST(cubicOp64d), 5703 TEST(cubicOp63d), 5704 TEST(cubicOp62d), 5705 TEST(cubicOp61d), 5706 TEST(cubicOp60d), 5707 TEST(cubicOp59d), 5708 TEST(cubicOp57d), 5709 TEST(cubicOp56d), 5710 TEST(cubicOp55d), 5711 TEST(cubicOp54d), 5712 TEST(cubicOp53d), 5713 TEST(cubicOp52d), 5714 TEST(cubicOp51d), 5715 TEST(cubicOp50d), 5716 TEST(cubicOp49d), 5717 TEST(cubicOp48d), 5718 TEST(cubicOp47d), 5719 TEST(cubicOp46d), 5720 TEST(cubicOp45d), 5721 TEST(cubicOp44d), 5722 TEST(cubicOp43d), 5723 TEST(cubicOp42d), 5724 TEST(cubicOp41i), 5725 TEST(cubicOp40d), 5726 TEST(cubicOp39d), 5727 TEST(cubicOp38d), 5728 TEST(cubicOp37d), 5729 TEST(cubicOp36u), 5730 TEST(cubicOp35d), 5731 TEST(cubicOp34d), 5732 TEST(cubicOp33i), 5733 TEST(cubicOp32d), 5734 TEST(cubicOp31d), 5735 TEST(cubicOp31x), 5736 TEST(cubicOp31u), 5737 TEST(cubicOp30d), 5738 TEST(cubicOp29d), 5739 TEST(cubicOp28u), 5740 TEST(cubicOp27d), 5741 TEST(cubicOp26d), 5742 TEST(cubicOp25i), 5743 TEST(testOp8d), 5744 TEST(testDiff1), 5745 TEST(testIntersect1), 5746 TEST(testUnion1), 5747 TEST(testXor1), 5748 TEST(testDiff2), 5749 TEST(testIntersect2), 5750 TEST(testUnion2), 5751 TEST(testXor2), 5752 TEST(testOp1d), 5753 TEST(testOp2d), 5754 TEST(testOp3d), 5755 TEST(testOp1u), 5756 TEST(testOp4d), 5757 TEST(testOp5d), 5758 TEST(testOp6d), 5759 TEST(testOp7d), 5760 TEST(testOp2u), 5761 5762 TEST(cubicOp24d), 5763 TEST(cubicOp23d), 5764 TEST(cubicOp22d), 5765 TEST(cubicOp21d), 5766 TEST(cubicOp20d), 5767 TEST(cubicOp19i), 5768 TEST(cubicOp18d), 5769 TEST(cubicOp17d), 5770 TEST(cubicOp16d), 5771 TEST(cubicOp15d), 5772 TEST(cubicOp14d), 5773 TEST(cubicOp13d), 5774 TEST(cubicOp12d), 5775 TEST(cubicOp11d), 5776 TEST(cubicOp10d), 5777 TEST(cubicOp1i), 5778 TEST(cubicOp9d), 5779 TEST(quadOp9d), 5780 TEST(lineOp9d), 5781 TEST(cubicOp8d), 5782 TEST(cubicOp7d), 5783 TEST(cubicOp6d), 5784 TEST(cubicOp5d), 5785 TEST(cubicOp3d), 5786 TEST(cubicOp2d), 5787 TEST(cubicOp1d), 5788 }; 5789 5790 static const size_t testCount = SK_ARRAY_COUNT(tests); 5791 5792 static struct TestDesc subTests[] = { 5793 TEST(loops47i), 5794 TEST(loops61i), 5795 TEST(loops62i), 5796 TEST(issue3517), 5797 }; 5798 5799 static const size_t subTestCount = SK_ARRAY_COUNT(subTests); 5800 5801 static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = 0; 5802 5803 static bool runSubTests = false; 5804 static bool runSubTestsFirst = true; 5805 static bool runReverse = false; 5806 5807 DEF_TEST(PathOpsOp, reporter) { 5808 #if DEBUG_SHOW_TEST_NAME 5809 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 5810 #endif 5811 if (runSubTests && runSubTestsFirst) { 5812 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse); 5813 } 5814 RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse); 5815 if (runSubTests && !runSubTestsFirst) { 5816 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse); 5817 } 5818 } 5819 5820 static void fuzz535151(skiatest::Reporter* reporter, const char* filename) { 5821 SkPath one; 5822 one.setFillType(SkPath::kWinding_FillType); 5823 SkPath two; 5824 two.setFillType(SkPath::kWinding_FillType); 5825 two.moveTo(0, 0); 5826 two.lineTo(0, 50); 5827 two.lineTo(4.29497e+09f, 50); 5828 SkPath dummy; 5829 testPathOpFuzz(reporter, one, two, kIntersect_SkPathOp, filename); 5830 } 5831 5832 static void bufferOverflow(skiatest::Reporter* reporter, const char* filename) { 5833 SkPath path; 5834 path.addRect(0,0, 300,170141183460469231731687303715884105728.f); 5835 SkPath pathB; 5836 pathB.addRect(0,0, 300,16); 5837 testPathOpFuzz(reporter, path, pathB, kUnion_SkPathOp, filename); 5838 } 5839 5840 // m 100,0 60,170 -160,-110 200,0 -170,11000000000 z 5841 static void fuzz433(skiatest::Reporter* reporter, const char* filename) { 5842 SkPath path1, path2; 5843 path1.moveTo(100,0); 5844 path1.lineTo(60,170); 5845 path1.lineTo(-160,-110); 5846 path1.lineTo(200,0); 5847 path1.lineTo(-170,11000000000.0f); 5848 path1.close(); 5849 5850 path2.moveTo(100 + 20,0 + 20); 5851 path2.lineTo(60 + 20,170 + 20); 5852 path2.lineTo(-160 + 20,-110 + 20); 5853 path2.lineTo(200 + 20,0 + 20); 5854 path2.lineTo(-170 + 20,11000000000.0f + 20); 5855 path2.close(); 5856 5857 testPathOpFuzz(reporter, path1, path2, kIntersect_SkPathOp, filename); 5858 } 5859 5860 static void fuzz433b(skiatest::Reporter* reporter, const char* filename) { 5861 SkPath path1, path2; 5862 path1.setFillType(SkPath::kEvenOdd_FillType); 5863 path1.moveTo(140, 40); 5864 path1.lineTo(200, 210); 5865 path1.lineTo(40, 100); 5866 path1.lineTo(240, 100); 5867 path1.lineTo(70, 1.1e+10f); 5868 path1.lineTo(140, 40); 5869 path1.close(); 5870 5871 path1.setFillType(SkPath::kWinding_FillType); 5872 path2.moveTo(190, 60); 5873 path2.lineTo(250, 230); 5874 path2.lineTo(90, 120); 5875 path2.lineTo(290, 120); 5876 path2.lineTo(120, 1.1e+10f); 5877 path2.lineTo(190, 60); 5878 path2.close(); 5879 5880 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename); 5881 } 5882 5883 static void fuzz487a(skiatest::Reporter* reporter, const char* filename) { 5884 SkPath path; 5885 path.setFillType((SkPath::FillType) 0); 5886 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5887 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 5888 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333)); 5889 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc)); 5890 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff)); 5891 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 5892 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 5893 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000)); 5894 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000)); 5895 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000)); 5896 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 5897 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 5898 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000)); 5899 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5900 path.close(); 5901 5902 SkPath path1(path); 5903 path.reset(); 5904 path.setFillType((SkPath::FillType) 0); 5905 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5906 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 5907 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a)); 5908 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a)); 5909 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd)); 5910 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000)); 5911 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a)); 5912 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333)); 5913 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000)); 5914 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000)); 5915 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a)); 5916 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334)); 5917 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd)); 5918 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd)); 5919 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd)); 5920 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334)); 5921 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000)); 5922 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5923 path.close(); 5924 5925 SkPath path2(path); 5926 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 5927 } 5928 5929 static void fuzz487b(skiatest::Reporter* reporter, const char* filename) { 5930 SkPath path; 5931 path.setFillType((SkPath::FillType) 0); 5932 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5933 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 5934 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333)); 5935 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc)); 5936 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff)); 5937 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 5938 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 5939 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000)); 5940 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000)); 5941 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000)); 5942 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 5943 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 5944 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000)); 5945 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5946 path.close(); 5947 5948 SkPath path1(path); 5949 path.reset(); 5950 path.setFillType((SkPath::FillType) 0); 5951 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5952 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 5953 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a)); 5954 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a)); 5955 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd)); 5956 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000)); 5957 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a)); 5958 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333)); 5959 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000)); 5960 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000)); 5961 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a)); 5962 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334)); 5963 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd)); 5964 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd)); 5965 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd)); 5966 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334)); 5967 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000)); 5968 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 5969 path.close(); 5970 5971 SkPath path2(path); 5972 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 5973 } 5974 5975 static void fuzz714(skiatest::Reporter* reporter, const char* filename) { 5976 SkPath path; 5977 path.setFillType((SkPath::FillType) 1); 5978 path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000)); 5979 path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000)); 5980 path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000)); 5981 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000)); // 2.22222e+022f 5982 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000)); // 2.22222e+022f 5983 path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000)); 5984 path.close(); 5985 5986 SkPath path1(path); 5987 path.reset(); 5988 path.setFillType((SkPath::FillType) 0); 5989 path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000)); 5990 path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000)); 5991 path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000)); 5992 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000)); // 2.22222e+022f 5993 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000)); // 2.22222e+022f 5994 path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000)); 5995 path.close(); 5996 5997 SkPath path2(path); 5998 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 5999 } 6000 6001 static void fuzz1(skiatest::Reporter* reporter, const char* filename) { 6002 SkPath path; 6003 path.setFillType((SkPath::FillType) 0); 6004 path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6005 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6006 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6007 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000)); 6008 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000)); 6009 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000)); 6010 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001)); 6011 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000)); 6012 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6013 path.close(); 6014 6015 SkPath path1(path); 6016 path.reset(); 6017 path.setFillType((SkPath::FillType) 0); 6018 6019 SkPath path2(path); 6020 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6021 } 6022 6023 6024 static void fuzz753_91(skiatest::Reporter* reporter, const char* filename) { 6025 SkPath path; 6026 path.setFillType((SkPath::FillType) 0); 6027 path.moveTo(SkBits2Float(0x42910000), SkBits2Float(0x00000000)); // 72.5f, 0 6028 path.lineTo(SkBits2Float(0x42166668), SkBits2Float(0x00000000)); // 37.6f, 0 6029 path.cubicTo(SkBits2Float(0x42166668), SkBits2Float(0xc1966668), SkBits2Float(0x41c66668), SkBits2Float(0xc20a6666), SkBits2Float(0x40f00010), SkBits2Float(0xc21ccccd)); // 37.6f, -18.8f, 24.8f, -34.6f, 7.50001f, -39.2f 6030 path.lineTo(SkBits2Float(0x41840004), SkBits2Float(0xc291cccd)); // 16.5f, -72.9f 6031 path.lineTo(SkBits2Float(0x42fb6668), SkBits2Float(0x42c73334)); // 125.7f, 99.6f 6032 path.lineTo(SkBits2Float(0x43646668), SkBits2Float(0x43880ccd)); // 228.4f, 272.1f 6033 6034 SkPath path1(path); 6035 path.reset(); 6036 path.setFillType((SkPath::FillType) 0); 6037 path.moveTo(SkBits2Float(0x428bf702), SkBits2Float(0xcf223cbf)); // 69.9824f, -2.72189e+09f 6038 path.lineTo(SkBits2Float(0x42112d68), SkBits2Float(0xcf223cbf)); // 36.2943f, -2.72189e+09f 6039 path.cubicTo(SkBits2Float(0x4220d9fc), SkBits2Float(0xcf223cc0), SkBits2Float(0x420ee118), SkBits2Float(0xcf223cc0), SkBits2Float(0x41cef2f8), SkBits2Float(0xcf223cc0)); // 40.2129f, -2.72189e+09f, 35.7198f, -2.72189e+09f, 25.8686f, -2.72189e+09f 6040 path.lineTo(SkBits2Float(0x424a99e0), SkBits2Float(0xcf223cc0)); // 50.6503f, -2.72189e+09f 6041 path.cubicTo(SkBits2Float(0x42266e32), SkBits2Float(0xcf223cc0), SkBits2Float(0x41f0fa20), SkBits2Float(0xcf223cc0), SkBits2Float(0x41872ed4), SkBits2Float(0xcf223cc0)); // 41.6076f, -2.72189e+09f, 30.1221f, -2.72189e+09f, 16.8979f, -2.72189e+09f 6042 path.lineTo(SkBits2Float(0x40f8fbe0), SkBits2Float(0xcf223cc0)); // 7.78075f, -2.72189e+09f 6043 6044 SkPath path2(path); 6045 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6046 } 6047 6048 static void bug597926_0(skiatest::Reporter* reporter, const char* filename) { 6049 SkPath path; 6050 path.setFillType((SkPath::FillType) 0); 6051 path.moveTo(SkBits2Float(0x43b38000), SkBits2Float(0x433e0000)); // 359, 190 6052 path.lineTo(SkBits2Float(0x40c00000), SkBits2Float(0x449ce000)); // 6, 1255 6053 path.cubicTo(SkBits2Float(0x438c0000), SkBits2Float(0x4497a000), SkBits2Float(0x43e40000), SkBits2Float(0x44750000), SkBits2Float(0x41000000), SkBits2Float(0x44aa2000)); // 280, 1213, 456, 980, 8, 1361 6054 path.moveTo(SkBits2Float(0x43290000), SkBits2Float(0x4431c000)); // 169, 711 6055 path.lineTo(SkBits2Float(0xd987d6ba), SkBits2Float(0xd93d0ad4)); // -4.7794e+15f, -3.32567e+15f 6056 path.conicTo(SkBits2Float(0x43cc8000), SkBits2Float(0x445b8000), SkBits2Float(0xd888b096), SkBits2Float(0xd9a1ebfa), SkBits2Float(0x3ebcb199)); // 409, 878, -1.20234e+15f, -5.69712e+15f, 0.368542f 6057 path.cubicTo(SkBits2Float(0x43c00000), SkBits2Float(0x443a8000), SkBits2Float(0x42380000), SkBits2Float(0x4421c000), SkBits2Float(0x42500000), SkBits2Float(0x448ca000)); // 384, 746, 46, 647, 52, 1125 6058 path.quadTo(SkBits2Float(0x43948000), SkBits2Float(0x42ac0000), SkBits2Float(0x43880000), SkBits2Float(0x4487e000)); // 297, 86, 272, 1087 6059 SkPath path1(path); 6060 path.reset(); 6061 path.setFillType((SkPath::FillType) 0); 6062 path.moveTo(SkBits2Float(0xc51d735c), SkBits2Float(0xc49db029)); // -2519.21f, -1261.51f 6063 path.cubicTo(SkBits2Float(0xc51d1dbd), SkBits2Float(0xc49d7a3f), SkBits2Float(0xc51c524a), SkBits2Float(0xc49d1610), SkBits2Float(0xc51d1a96), SkBits2Float(0xc49d86a6)); // -2513.86f, -1259.82f, -2501.14f, -1256.69f, -2513.66f, -1260.21f 6064 path.cubicTo(SkBits2Float(0xc51cd471), SkBits2Float(0xc49d54d0), SkBits2Float(0xc51c2e51), SkBits2Float(0xc49d0081), SkBits2Float(0xc51d197b), SkBits2Float(0xc49d7927)); // -2509.28f, -1258.65f, -2498.89f, -1256.02f, -2513.59f, -1259.79f 6065 path.quadTo(SkBits2Float(0xc51bf7eb), SkBits2Float(0xc49cf010), SkBits2Float(0xc51ba866), SkBits2Float(0xc49cb9e6)); // -2495.49f, -1255.5f, -2490.52f, -1253.81f 6066 path.cubicTo(SkBits2Float(0xc51bac0d), SkBits2Float(0xc49cc50e), SkBits2Float(0xc51c29eb), SkBits2Float(0xc49cfb01), SkBits2Float(0xc51c5bca), SkBits2Float(0xc49d1fa6)); // -2490.75f, -1254.16f, -2498.62f, -1255.84f, -2501.74f, -1256.99f 6067 SkPath path2(path); 6068 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6069 } 6070 6071 static void fuzz1450_0(skiatest::Reporter* reporter, const char* filename) { 6072 SkPath path; 6073 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f 6074 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 1.07374e+09f, -1.07374e+09f, 0.707107f 6075 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x43348000), SkBits2Float(0x43800001), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 180.5f, 256, 0.707107f 6076 SkPath path1(path); 6077 path.reset(); 6078 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 6079 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f 6080 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f 6081 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512 6082 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16 6083 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024 6084 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 6085 path.close(); 6086 SkPath path2(path); 6087 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename); 6088 } 6089 6090 static void fuzz1450_1(skiatest::Reporter* reporter, const char* filename) { 6091 SkPath path; 6092 path.setFillType(SkPath::kEvenOdd_FillType); 6093 path.moveTo(SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe)); // 1.07374e+09f, -1.07374e+09f 6094 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x43b40000), SkBits2Float(0xcf000000), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 360, -2.14748e+09f, 0.707107f 6095 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256 6096 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16 6097 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512 6098 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f 6099 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024 6100 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 6101 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f 6102 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f 6103 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f 6104 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256 6105 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 1.07374e+09f, -1.07374e+09f, 0.707107f 6106 path.close(); 6107 SkPath path1(path); 6108 path.reset(); 6109 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321 6110 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270 6111 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08 6112 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64 6113 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321 6114 path.close(); 6115 SkPath path2(path); 6116 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename); 6117 } 6118 6119 static void fuzz763_9(skiatest::Reporter* reporter, const char* filename) { 6120 SkPath path; 6121 path.setFillType((SkPath::FillType) 1); 6122 6123 SkPath path1(path); 6124 path.reset(); 6125 path.setFillType((SkPath::FillType) 0); 6126 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6127 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b), SkBits2Float(0x1f212a8c)); // 2.49282e-13f, 4.78968e-34f, 1.99397e+36f, -4.84373e+27f, 3.41283e-20f 6128 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b)); // 1.99397e+36f, -4.84373e+27f 6129 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f 6130 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6131 path.close(); 6132 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6133 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6)); // -8.10388e-33f, 0.00148185f, 2.25206e-21f, 5.54035e+21f 6134 path.moveTo(SkBits2Float(0x29272a81), SkBits2Float(0x2ab03a55)); // 3.71183e-14f, 3.13044e-13f 6135 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x8a2f2121)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, -8.43217e-33f 6136 path.quadTo(SkBits2Float(0x373b3a27), SkBits2Float(0x201fc4c1), SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d)); // 1.11596e-05f, 1.35329e-19f, 2.98959e-15f, 2.8457e+15f 6137 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, 0.00105459f 6138 path.cubicTo(SkBits2Float(0x373b3ac5), SkBits2Float(0x201fc422), SkBits2Float(0x523a702a), SkBits2Float(0x27576c51), SkBits2Float(0x5921c25d), SkBits2Float(0x51523a70)); // 1.11598e-05f, 1.35327e-19f, 2.00186e+11f, 2.9896e-15f, 2.8457e+15f, 5.64327e+10f 6139 path.quadTo(SkBits2Float(0xd912102a), SkBits2Float(0x284f9a28), SkBits2Float(0xb38a1f30), SkBits2Float(0x3a3ac23a)); // -2.56957e+15f, 1.15242e-14f, -6.4318e-08f, 0.000712428f 6140 path.lineTo(SkBits2Float(0xc809272a), SkBits2Float(0x29b02829)); // -140445, 7.82294e-14f 6141 6142 SkPath path2(path); 6143 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6144 } 6145 6146 6147 static void fuzz763_4(skiatest::Reporter* reporter, const char* filename) { 6148 SkPath path; 6149 path.setFillType((SkPath::FillType) 1); 6150 6151 SkPath path1(path); 6152 path.reset(); 6153 path.setFillType((SkPath::FillType) 0); 6154 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6155 path.lineTo(SkBits2Float(0x555b3a2d), SkBits2Float(0x2a212a8c)); // 1.50652e+13f, 1.43144e-13f 6156 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f 6157 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac2b33a)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148544f 6158 path.cubicTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x295b2d2a), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c275b)); // 2.25206e-21f, 5.54035e+21f, 4.86669e-14f, 3.19905e+24f, 9.6297e-12f, 2.48963e-13f 6159 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6160 path.close(); 6161 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6162 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x2a21081f)); // 1.43144e-13f, 1.43025e-13f 6163 path.conicTo(SkBits2Float(0xde6a4b7b), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // -4.22068e+18f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589 6164 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6165 path.close(); 6166 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6167 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6168 path.lineTo(SkBits2Float(0x2928088c), SkBits2Float(0x2be61d2a)); // 3.73109e-14f, 1.63506e-12f 6169 path.conicTo(SkBits2Float(0x2a812a63), SkBits2Float(0x2d292a27), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x552d6829)); // 2.29444e-13f, 9.6159e-12f, 1.5954e+13f, 4.87407e+16f, 1.19164e+13f 6170 path.conicTo(SkBits2Float(0x395b2d5b), SkBits2Float(0x68552768), SkBits2Float(0x555b2df0), SkBits2Float(0x1f722a8c), SkBits2Float(0x082a212a)); // 0.000209024f, 4.02636e+24f, 1.50619e+13f, 5.12807e-20f, 5.11965e-34f 6171 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6172 path.close(); 6173 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6174 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a), SkBits2Float(0x21df212a), SkBits2Float(0x033a8a3a)); // 6.14991e+25f, 6.77381e-19f, 9.33503e-15f, 1.51198e-18f, 5.48192e-37f 6175 6176 SkPath path2(path); 6177 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6178 } 6179 6180 static void fuzz763_3(skiatest::Reporter* reporter, const char* filename) { 6181 SkPath path; 6182 path.setFillType((SkPath::FillType) 1); 6183 6184 SkPath path1(path); 6185 path.reset(); 6186 path.setFillType((SkPath::FillType) 0); 6187 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6188 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f 6189 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x295b2d1f), SkBits2Float(0x29685568)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.86669e-14f, 5.15884e-14f 6190 path.conicTo(SkBits2Float(0x8c28295b), SkBits2Float(0x1f21212a), SkBits2Float(0xc0032a08), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced)); // -1.29547e-31f, 3.41205e-20f, -2.04944f, 3.04132e+35f, 5.77848e-19f 6191 path.moveTo(SkBits2Float(0x25682929), SkBits2Float(0x212a8c5b)); // 2.01367e-16f, 5.7784e-19f 6192 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4a7bc0)); // 4.7323e-37f, 6.11969e+25f 6193 path.conicTo(SkBits2Float(0x032108ed), SkBits2Float(0x283a7bc0), SkBits2Float(0x47ed7a6a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21ff28)); // 4.73239e-37f, 1.03519e-14f, 121589, 9.4495e-15f, 0.000617968f 6194 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.00148185f, 1.50241e-13f, -1.38859e-25f 6195 path.lineTo(SkBits2Float(0x295b2d2a), SkBits2Float(0x2d296868)); // 4.86669e-14f, 9.62972e-12f 6196 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6197 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x898ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, -3.39271e-33f, 4.61198e-19f, 0.00096035f, 121589 6198 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6199 path.close(); 6200 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6201 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0xb38a281a), SkBits2Float(0x29283ac2)); // -1.2117e+19f, 0.00105459f, -6.43342e-08f, 3.73545e-14f 6202 path.moveTo(SkBits2Float(0x962be61d), SkBits2Float(0x432a2927)); // -1.38859e-25f, 170.161f 6203 path.conicTo(SkBits2Float(0x3a2a552a), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42236)); // 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f 6204 path.cubicTo(SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d), SkBits2Float(0x51503a70), SkBits2Float(0x12102a10), SkBits2Float(0x633a28d9), SkBits2Float(0x29c80927)); // 2.98959e-15f, 2.8457e+15f, 5.58959e+10f, 4.54902e-28f, 3.43404e+21f, 8.88337e-14f 6205 path.lineTo(SkBits2Float(0x272927b0), SkBits2Float(0x5b392929)); // 2.3475e-15f, 5.21181e+16f 6206 path.moveTo(SkBits2Float(0x3a1127b4), SkBits2Float(0x2921ee3b)); // 0.000553723f, 3.59558e-14f 6207 path.cubicTo(SkBits2Float(0x5e215d3b), SkBits2Float(0x7828ee3a), SkBits2Float(0x8e28b03b), SkBits2Float(0x50783be8), SkBits2Float(0x9e0b8a3a), SkBits2Float(0x555b2d68)); // 2.90688e+18f, 1.37053e+34f, -2.07925e-30f, 1.66587e+10f, -7.38718e-21f, 1.50618e+13f 6208 path.moveTo(SkBits2Float(0x21081f3f), SkBits2Float(0x9fd4e62a)); // 4.61199e-19f, -9.01663e-20f 6209 path.cubicTo(SkBits2Float(0x3a293a2a), SkBits2Float(0x0e3bf0c5), SkBits2Float(0x3b29d42a), SkBits2Float(0x0f217265), SkBits2Float(0x2d5d2921), SkBits2Float(0x5568295b)); // 0.000645551f, 2.31655e-30f, 0.00259138f, 7.95994e-30f, 1.25715e-11f, 1.5954e+13f 6210 6211 SkPath path2(path); 6212 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6213 } 6214 6215 static void fuzz763_5(skiatest::Reporter* reporter, const char* filename) { 6216 SkPath path; 6217 path.setFillType((SkPath::FillType) 1); 6218 6219 SkPath path1(path); 6220 path.reset(); 6221 path.setFillType((SkPath::FillType) 0); 6222 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6223 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b79), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f 6224 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6225 path.cubicTo(SkBits2Float(0xe62a2928), SkBits2Float(0x2a63962b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x001f2a21)); // -2.0089e+23f, 2.02138e-13f, 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 2.86201e-39f 6226 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6227 path.close(); 6228 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6229 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589 6230 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6231 path.close(); 6232 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6233 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3b21), SkBits2Float(0x28ee4f9a), SkBits2Float(0x68293b78)); // -1.2117e+19f, 0.00105462f, 2.64578e-14f, 3.19671e+24f 6234 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d8c55)); // 4.87407e+16f, 4.88495e+16f 6235 6236 SkPath path2(path); 6237 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6238 } 6239 6240 static void fuzz763_2(skiatest::Reporter* reporter, const char* filename) { 6241 SkPath path; 6242 path.setFillType((SkPath::FillType) 1); 6243 6244 SkPath path1(path); 6245 path.reset(); 6246 path.setFillType((SkPath::FillType) 0); 6247 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6248 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f 6249 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f 6250 path.lineTo(SkBits2Float(0x081f2ad7), SkBits2Float(0x7bc00321)); // 4.78977e-34f, 1.99397e+36f 6251 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6252 path.quadTo(SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28), SkBits2Float(0x29283ac2), SkBits2Float(0x962be62a)); // 2.58753e+09f, 0.00136978f, 3.73545e-14f, -1.38859e-25f 6253 path.cubicTo(SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42237)); // 2.36623e-15f, 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f 6254 path.cubicTo(SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d), SkBits2Float(0x51523a70), SkBits2Float(0x12102a10), SkBits2Float(0x633a28d9), SkBits2Float(0x29c80927)); // 2.98959e-15f, 2.8457e+15f, 5.64327e+10f, 4.54902e-28f, 3.43404e+21f, 8.88337e-14f 6255 path.lineTo(SkBits2Float(0x29292727), SkBits2Float(0x21475b3b)); // 3.75595e-14f, 6.75446e-19f 6256 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6257 path.cubicTo(SkBits2Float(0x682d2928), SkBits2Float(0x555b6829), SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 3.27091e+24f, 1.50775e+13f, 1.50606e+13f, 1.43144e-13f, 4.7323e-37f, 6.14991e+25f 6258 path.conicTo(SkBits2Float(0x295b2ded), SkBits2Float(0x29685568), SkBits2Float(0x8c555b2d), SkBits2Float(0xe61d2a2a), SkBits2Float(0x2a63962b)); // 4.86676e-14f, 5.15884e-14f, -1.64364e-31f, -1.85547e+23f, 2.02138e-13f 6259 path.conicTo(SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a), SkBits2Float(0x4b7bc003)); // 1.5954e+13f, 4.87407e+16f, 5.7784e-19f, 4.61198e-19f, 1.64987e+07f 6260 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f 6261 path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a), SkBits2Float(0x8a3a21df), SkBits2Float(0x27b42a3a)); // 5.63611e+25f, 6.77381e-19f, 9.33503e-15f, -8.96194e-33f, 5.00058e-15f 6262 path.conicTo(SkBits2Float(0x2921217d), SkBits2Float(0x5e3a3b35), SkBits2Float(0x7828ee3a), SkBits2Float(0x8e28b03b), SkBits2Float(0x783be82a)); // 3.57782e-14f, 3.35484e+18f, 1.37053e+34f, -2.07925e-30f, 1.52448e+34f 6263 path.conicTo(SkBits2Float(0x8e0b8a3a), SkBits2Float(0x279fd4e6), SkBits2Float(0x7a293a2a), SkBits2Float(0x2a0ef0c5), SkBits2Float(0x653b29d4)); // -1.71996e-30f, 4.43622e-15f, 2.19669e+35f, 1.26957e-13f, 5.52409e+22f 6264 path.quadTo(SkBits2Float(0x29210f21), SkBits2Float(0x282a085d), SkBits2Float(0xc2ab2127), SkBits2Float(0xa6800028)); // 3.57623e-14f, 9.43871e-15f, -85.5648f, -8.88183e-16f 6265 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6266 path.close(); 6267 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6268 path.quadTo(SkBits2Float(0x216a2770), SkBits2Float(0x2ab73b28), SkBits2Float(0x4b28f427), SkBits2Float(0x283b5b28)); // 7.93345e-19f, 3.25484e-13f, 1.10726e+07f, 1.04004e-14f 6269 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6270 path.close(); 6271 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6272 path.conicTo(SkBits2Float(0xf86d273b), SkBits2Float(0x27e523e3), SkBits2Float(0x2927e0f5), SkBits2Float(0x2ac0e729), SkBits2Float(0x6b492128)); // -1.92402e+34f, 6.35992e-15f, 3.72766e-14f, 3.42665e-13f, 2.43151e+26f 6273 path.cubicTo(SkBits2Float(0x2f273927), SkBits2Float(0xa83a2c21), SkBits2Float(0xd7122121), SkBits2Float(0x21212921), SkBits2Float(0x3be3db3a), SkBits2Float(0xa9deb63b)); // 1.52089e-10f, -1.03346e-14f, -1.60671e+14f, 5.46034e-19f, 0.00695362f, -9.89039e-14f 6274 6275 SkPath path2(path); 6276 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6277 } 6278 6279 // crbug.com/626164 6280 static void fuzz763_1c(skiatest::Reporter* reporter, const char* filename) { 6281 SkPath path; 6282 path.setFillType((SkPath::FillType) 0); 6283 6284 SkPath path1(path); 6285 path.reset(); 6286 path.setFillType((SkPath::FillType) 0); 6287 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6288 path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f 6289 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f 6290 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.31432e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f 6291 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.31432e+06f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f 6292 6293 SkPath path2(path); 6294 SkPath dummy; 6295 testPathOpFuzz(reporter, path1, path2, (SkPathOp)4, filename); 6296 } 6297 6298 // crbug.com/626186 6299 static void fuzz763_1b(skiatest::Reporter* reporter, const char* filename) { 6300 SkPath path; 6301 path.setFillType((SkPath::FillType) 0); 6302 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6303 path.cubicTo(SkBits2Float(0x0000ff07), SkBits2Float(0xf9f9ff00), SkBits2Float(0xfe0ef9f4), SkBits2Float(0xd9b105fb), SkBits2Float(0x000000f9), SkBits2Float(0xfe11f901)); // 9.14866e-41f, -1.62257e+35f, -4.75121e+37f, -6.22846e+15f, 3.48923e-43f, -4.85077e+37f 6304 path.lineTo(SkBits2Float(0xda1905ed), SkBits2Float(0x3c05fbfb)); // -1.0768e+16f, 0.00817775f 6305 path.cubicTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0x3c3c3c3c), SkBits2Float(0x253c7f00), SkBits2Float(0xfa00d3fa), SkBits2Float(0x250025fe), SkBits2Float(0x00000006)); // 0.011489f, 0.011489f, 1.63494e-16f, -1.67228e+35f, 1.11151e-16f, 8.40779e-45f 6306 6307 SkPath path1(path); 6308 path.reset(); 6309 path.setFillType((SkPath::FillType) 0); 6310 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6311 path.quadTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0xfa253c3c), SkBits2Float(0xfefa00d3), SkBits2Float(0x25fad9df)); // 0.011489f, -2.14488e+35f, -1.66156e+38f, 4.35157e-16f 6312 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6313 path.close(); 6314 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6315 path.lineTo(SkBits2Float(0x8dfefa00), SkBits2Float(0xf0f9fad9)); // -1.57141e-30f, -6.1892e+29f 6316 path.cubicTo(SkBits2Float(0x20fe58f9), SkBits2Float(0x0525fbed), SkBits2Float(0x1905ffff), SkBits2Float(0x01f9f9f9), SkBits2Float(0xfbfe0ef9), SkBits2Float(0xfb212fff)); // 4.30882e-19f, 7.80453e-36f, 6.92764e-24f, 9.18268e-38f, -2.63829e+36f, -8.36933e+35f 6317 6318 SkPath path2(path); 6319 testPathOpFuzz(reporter, path1, path2, (SkPathOp)2, filename); 6320 } 6321 6322 static void fuzz763_1a(skiatest::Reporter* reporter, const char* filename) { 6323 SkPath path; 6324 path.setFillType((SkPath::FillType) 0); 6325 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6326 path.cubicTo(SkBits2Float(0x154be880), SkBits2Float(0x80000640), SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0x80045959), SkBits2Float(0x40154be8)); // 4.11789e-26f, -2.24208e-42f, 1.49562e+13f, 7.50652e+15f, -3.99394e-40f, 2.33276f 6327 6328 SkPath path1(path); 6329 path.reset(); 6330 path.setFillType((SkPath::FillType) 0); 6331 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6332 path.quadTo(SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0xbd595959), SkBits2Float(0x3f3f3f09)); // 1.49562e+13f, 7.50652e+15f, -0.0530637f, 0.747056f 6333 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0x3f3f3f3f)); // 0.747059f, 0.747059f 6334 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6335 path.lineTo(SkBits2Float(0x09090909), SkBits2Float(0x3038d509)); // 1.6495e-33f, 6.72416e-10f 6336 path.conicTo(SkBits2Float(0x5947ffff), SkBits2Float(0x40e88004), SkBits2Float(0x00002059), SkBits2Float(0x28555900), SkBits2Float(0x5959d559)); // 3.51844e+15f, 7.26563f, 1.16042e-41f, 1.18432e-14f, 3.83217e+15f 6337 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6338 path.close(); 6339 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6340 path.lineTo(SkBits2Float(0x38d57f4b), SkBits2Float(0x59597f4b)); // 0.000101803f, 3.82625e+15f 6341 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6342 path.close(); 6343 path.moveTo(SkBits2Float(0x384700ff), SkBits2Float(0x0108804b)); // 4.74462e-05f, 2.50713e-38f 6344 6345 SkPath path2(path); 6346 testPathOpFuzz(reporter, path1, path2, (SkPathOp)0, filename); 6347 } 6348 6349 // crbug.com/627780 6350 static void fuzz763_3a(skiatest::Reporter* reporter, const char* filename) { 6351 SkPath path; 6352 path.setFillType((SkPath::FillType) 1); 6353 6354 SkPath path1(path); 6355 path.reset(); 6356 path.setFillType((SkPath::FillType) 0); 6357 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6358 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f 6359 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f 6360 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6361 path.cubicTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x272a812a), SkBits2Float(0x295b2d29), SkBits2Float(0x2a685568), SkBits2Float(0x68295b2d)); // 2.25206e-21f, 5.54035e+21f, 2.36623e-15f, 4.86669e-14f, 2.06354e-13f, 3.19905e+24f 6362 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321), SkBits2Float(0x7a6a4b77), SkBits2Float(0x3a214726)); // 2.49282e-13f, 4.78968e-34f, 1.99397e+36f, 3.04132e+35f, 0.000615226f 6363 path.moveTo(SkBits2Float(0x8adf2028), SkBits2Float(0x3a219a3a)); // -2.14862e-32f, 0.000616464f 6364 path.quadTo(SkBits2Float(0x3ab38e28), SkBits2Float(0x29283ac2), SkBits2Float(0x2be61d2a), SkBits2Float(0x812a4396)); // 0.0013699f, 3.73545e-14f, 1.63506e-12f, -3.12726e-38f 6365 6366 SkPath path2(path); 6367 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6368 } 6369 6370 // crbug.com/627689 6371 static void fuzz763_5a(skiatest::Reporter* reporter, const char* filename) { 6372 SkPath path; 6373 path.setFillType((SkPath::FillType) 1); 6374 path.moveTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0 6375 path.conicTo(SkBits2Float(0x4183d871), SkBits2Float(0x41fea321), SkBits2Float(0xb700ff00), SkBits2Float(0x4240b8b8), SkBits2Float(0x3b058283)); // 16.4807f, 31.8297f, -7.68877e-06f, 48.1804f, 0.0020372f 6376 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f 6377 path.conicTo(SkBits2Float(0x3a455ec8), SkBits2Float(0xb8b8b8b3), SkBits2Float(0x38b2418d), SkBits2Float(0xb730d014), SkBits2Float(0x3f7ffff3)); // 0.000752908f, -8.80821e-05f, 8.49991e-05f, -1.05389e-05f, 0.999999f 6378 path.quadTo(SkBits2Float(0x3a51246a), SkBits2Float(0xb6da45a3), SkBits2Float(0x38bc5c3c), SkBits2Float(0x00000000)); // 0.000797814f, -6.50501e-06f, 8.98172e-05f, 0 6379 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f 6380 path.quadTo(SkBits2Float(0x39a32d2d), SkBits2Float(0x00000000), SkBits2Float(0xb8a13a00), SkBits2Float(0x00000000)); // 0.000311234f, 0, -7.68788e-05f, 0 6381 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f 6382 path.quadTo(SkBits2Float(0x39ba814c), SkBits2Float(0xb838fed2), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0.00035573f, -4.41063e-05f, 0, 0 6383 path.lineTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0 6384 path.close(); 6385 6386 SkPath path1(path); 6387 path.reset(); 6388 path.setFillType((SkPath::FillType) 0); 6389 6390 SkPath path2(path); 6391 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6392 } 6393 6394 // crbug.com/627401 6395 static void fuzz763_2a(skiatest::Reporter* reporter, const char* filename) { 6396 SkPath path; 6397 path.setFillType((SkPath::FillType) 1); 6398 6399 SkPath path1(path); 6400 path.reset(); 6401 path.setFillType((SkPath::FillType) 0); 6402 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6403 path.quadTo(SkBits2Float(0x3e484500), SkBits2Float(0x164f3a30), SkBits2Float(0x49484801), SkBits2Float(0x7d0100c8)); // 0.195576f, 1.67397e-25f, 820352, 1.07172e+37f 6404 path.conicTo(SkBits2Float(0xff7f36fd), SkBits2Float(0x3e647d01), SkBits2Float(0x0c00f430), SkBits2Float(0x486b6448), SkBits2Float(0x00484848)); // -3.39239e+38f, 0.223133f, 9.93424e-32f, 241041, 6.63809e-39f 6405 path.lineTo(SkBits2Float(0x4f4f557d), SkBits2Float(0x48480112)); // 3.47849e+09f, 204804 6406 path.lineTo(SkBits2Float(0xf40c01ff), SkBits2Float(0x45008000)); // -4.43702e+31f, 2056 6407 path.moveTo(SkBits2Float(0x4bfffa00), SkBits2Float(0x7d4ac859)); // 3.35514e+07f, 1.68465e+37f 6408 path.conicTo(SkBits2Float(0x7d014f3e), SkBits2Float(0x00f4ff01), SkBits2Float(0x6b64480c), SkBits2Float(0x48484848), SkBits2Float(0x557d0100)); // 1.07426e+37f, 2.24993e-38f, 2.75975e+26f, 205089, 1.73863e+13f 6409 6410 SkPath path2(path); 6411 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6412 } 6413 6414 // crbug.com/627761 6415 static void fuzz763_2b(skiatest::Reporter* reporter, const char* filename) { 6416 SkPath path; 6417 path.setFillType((SkPath::FillType) 1); 6418 6419 SkPath path1(path); 6420 path.reset(); 6421 path.setFillType((SkPath::FillType) 0); 6422 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f 6423 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6424 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f 6425 path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x4721ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f9a3a8a)); // 5.63611e+25f, 41453.5f, 9.4495e-15f, 0.000617492f, 5.17506e+09f 6426 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6427 path.close(); 6428 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6429 path.cubicTo(SkBits2Float(0x273ac23a), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x272a812a), SkBits2Float(0x295b2d29), SkBits2Float(0x29685568)); // 2.5918e-15f, 2.25206e-21f, 5.54035e+21f, 2.36623e-15f, 4.86669e-14f, 5.15884e-14f 6430 path.lineTo(SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 4.78968e-34f, 1.99397e+36f 6431 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f 6432 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6433 path.close(); 6434 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6435 path.quadTo(SkBits2Float(0x8a4fc29a), SkBits2Float(0x3ab3283a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6)); // -1.00033e-32f, 0.00136686f, 2.25206e-21f, 300.343f 6436 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6437 path.conicTo(SkBits2Float(0x1e2ab03a), SkBits2Float(0x2920213b), SkBits2Float(0x3b3ac527), SkBits2Float(0xc422333b), SkBits2Float(0x6c2a9f1f)); // 9.03617e-21f, 3.5556e-14f, 0.00284989f, -648.8f, 8.25075e+26f 6438 path.quadTo(SkBits2Float(0xc25d2757), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152), SkBits2Float(0x28d91210)); // -55.2884f, 0.000916855f, 1.2818e-13f, 2.40997e-14f 6439 path.quadTo(SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f 6440 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6441 path.close(); 6442 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6443 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0xcb7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, -1.64987e+07f, 121589 6444 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6445 path.close(); 6446 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6447 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x2d8a3a21), SkBits2Float(0x5b682b68), SkBits2Float(0x5b292d55)); // -1.2117e+19f, 1.57146e-11f, 6.53499e+16f, 4.76191e+16f 6448 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f)); // 1.43144e-13f, 4.7323e-37f 6449 path.conicTo(SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x3a21477a)); // 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f, 0.000615231f 6450 path.moveTo(SkBits2Float(0x21df2828), SkBits2Float(0x9a3a8a3a)); // 1.51217e-18f, -3.85756e-23f 6451 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x28273ac2), SkBits2Float(0xe61d2a29), SkBits2Float(0x2a63962b)); // 0.00136978f, 9.2831e-15f, -1.85547e+23f, 2.02138e-13f 6452 path.conicTo(SkBits2Float(0x2d29272a), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 9.61523e-12f, 1.5954e+13f, 4.87407e+16f, 4.88097e+16f, 5.7784e-19f 6453 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6454 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6455 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6456 path.close(); 6457 6458 SkPath path2(path); 6459 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6460 } 6461 6462 static void fuzz763_2c(skiatest::Reporter* reporter, const char* filename) { 6463 SkPath path; 6464 path.setFillType((SkPath::FillType) 1); 6465 6466 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 0, 2.68653e-06f 6467 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x364a4a4a), SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0, 3.01436e-06f, 3.01436e-06f, 0, 0 6468 path.lineTo(SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000)); // 3.01436e-06f, 0 6469 path.cubicTo(SkBits2Float(0x364a30f0), SkBits2Float(0x344ac7fb), SkBits2Float(0x3656d432), SkBits2Float(0x34cabb48), SkBits2Float(0x367031a9), SkBits2Float(0x351802f1)); // 3.01288e-06f, 1.88855e-07f, 3.2012e-06f, 3.77617e-07f, 3.57917e-06f, 5.66287e-07f 6470 path.cubicTo(SkBits2Float(0x36a7b150), SkBits2Float(0x35ab09db), SkBits2Float(0x371874ed), SkBits2Float(0x3604f2c7), SkBits2Float(0x3784e0c7), SkBits2Float(0x36344a51)); // 4.99763e-06f, 1.27434e-06f, 9.08713e-06f, 1.98108e-06f, 1.58403e-05f, 2.68653e-06f 6471 path.cubicTo(SkBits2Float(0x3743dc9a), SkBits2Float(0x36344a4f), SkBits2Float(0x36fbef33), SkBits2Float(0x36344a4e), SkBits2Float(0x36604a35), SkBits2Float(0x36344a4c)); // 1.16743e-05f, 2.68653e-06f, 7.50823e-06f, 2.68653e-06f, 3.34218e-06f, 2.68653e-06f 6472 path.cubicTo(SkBits2Float(0x36531715), SkBits2Float(0x36344a4c), SkBits2Float(0x3645e3f5), SkBits2Float(0x36344a4b), SkBits2Float(0x3638b0d4), SkBits2Float(0x36344a4b)); // 3.14549e-06f, 2.68653e-06f, 2.9488e-06f, 2.68653e-06f, 2.75211e-06f, 2.68653e-06f 6473 path.cubicTo(SkBits2Float(0x35f64120), SkBits2Float(0x36344a4b), SkBits2Float(0x35764124), SkBits2Float(0x36344a4a), SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 1.83474e-06f, 2.68653e-06f, 9.17369e-07f, 2.68653e-06f, 0, 2.68653e-06f 6474 path.close(); 6475 SkPath path1(path); 6476 path.reset(); 6477 path.setFillType((SkPath::FillType) 0); 6478 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6479 path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f 6480 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f 6481 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.31432e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f 6482 path.cubicTo(SkBits2Float(0x544a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.47532e+12f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f 6483 SkPath path2(path); 6484 testPathOpFuzz(reporter, path1, path2, kReverseDifference_SkPathOp, filename); 6485 } 6486 6487 static void fuzz763_6(skiatest::Reporter* reporter, const char* filename) { 6488 SkPath path; 6489 path.setFillType((SkPath::FillType) 1); 6490 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 6491 path.cubicTo(SkBits2Float(0x68295b2d), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 3.19905e+24f, 0, 0, 0, 0, 4.03114e+24f 6492 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 6493 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x67d55b2a), SkBits2Float(0x67296a4b), SkBits2Float(0x67555b2a), SkBits2Float(0x677e1f70), SkBits2Float(0x66d55b2a)); // 0, 2.01509e+24f, 8.00041e+23f, 1.00755e+24f, 1.20006e+24f, 5.03773e+23f 6494 path.cubicTo(SkBits2Float(0x678f0684), SkBits2Float(0x6684f008), SkBits2Float(0x6798f8ea), SkBits2Float(0x6625a942), SkBits2Float(0x67961914), SkBits2Float(0x65ce709a)); // 1.35084e+24f, 3.1389e+23f, 1.44478e+24f, 1.95578e+23f, 1.41764e+24f, 1.21861e+23f 6495 path.cubicTo(SkBits2Float(0x679174f7), SkBits2Float(0x63199132), SkBits2Float(0x6756c79f), SkBits2Float(0x606478de), SkBits2Float(0x65682bcf), SkBits2Float(0x00000000)); // 1.3738e+24f, 2.83281e+21f, 1.01427e+24f, 6.58526e+19f, 6.85248e+22f, 0 6496 path.conicTo(SkBits2Float(0x68295b02), SkBits2Float(0x60f7f28b), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f), SkBits2Float(0x42784f5a)); // 3.19903e+24f, 1.42932e+20f, 0, 5.14279e+25f, 62.0775f 6497 path.close(); 6498 path.moveTo(SkBits2Float(0x654d6d10), SkBits2Float(0x00000000)); // 6.06311e+22f, 0 6499 path.lineTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000)); // 6.14991e+25f, 0 6500 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc0)); // 0, 6.14991e+25f 6501 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6502 6503 SkPath path1(path); 6504 path.reset(); 6505 path.setFillType((SkPath::FillType) 0); 6506 path.moveTo(SkBits2Float(0x3ac23a55), SkBits2Float(0x2a292827)); // 0.00148184f, 1.50241e-13f 6507 path.lineTo(SkBits2Float(0x63962be6), SkBits2Float(0x272a812a)); // 5.54035e+21f, 2.36623e-15f 6508 6509 SkPath path2(path); 6510 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6511 } 6512 6513 static void fuzz763_7(skiatest::Reporter* reporter, const char* filename) { 6514 SkPath path; 6515 path.setFillType((SkPath::FillType) 0); 6516 6517 SkPath path1(path); 6518 path.reset(); 6519 path.setFillType((SkPath::FillType) 0); 6520 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6521 path.moveTo(SkBits2Float(0x0f2a312a), SkBits2Float(0xc0032108)); // 8.39112e-30f, -2.04889f 6522 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f 6523 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 6524 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f 6525 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x08685568), SkBits2Float(0x7bc00321)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 6.99154e-34f, 1.99397e+36f 6526 path.lineTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f 6527 path.close(); 6528 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f 6529 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 6530 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6531 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f 6532 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f 6533 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f 6534 path.conicTo(SkBits2Float(0xba1f203a), SkBits2Float(0xc422c538), SkBits2Float(0x215d5927), SkBits2Float(0x70ec2ac2), SkBits2Float(0x2a51523a)); // -0.000607017f, -651.082f, 7.49957e-19f, 5.84721e+29f, 1.85915e-13f 6535 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f 6536 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f 6537 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f 6538 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a29ca)); // 5.73801e-19f, 2.06544e-13f, 3.19905e+24f, 9.6297e-12f, -1.05027e-31f, 1.51135e-13f 6539 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f 6540 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6541 path.close(); 6542 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6543 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55), SkBits2Float(0xed7aba1f), SkBits2Float(0x2a212a8c)); // 6.14991e+25f, 4.88097e+16f, 5.7784e-19f, -4.84977e+27f, 1.43144e-13f 6544 path.moveTo(SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b)); // 9.16179e-12f, 1.5954e+13f 6545 path.moveTo(SkBits2Float(0x5529685b), SkBits2Float(0x11295b68)); // 1.16416e+13f, 1.33599e-28f 6546 path.conicTo(SkBits2Float(0x5b782968), SkBits2Float(0x3a292d55), SkBits2Float(0x2a8c555b), SkBits2Float(0x68295a2d), SkBits2Float(0x2d296855)); // 6.98513e+16f, 0.000645359f, 2.49282e-13f, 3.19897e+24f, 9.6297e-12f 6547 path.moveTo(SkBits2Float(0x555b8c55), SkBits2Float(0x21682929)); // 1.50872e+13f, 7.86591e-19f 6548 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6549 path.conicTo(SkBits2Float(0xac2d8ced), SkBits2Float(0x5b682968), SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55), SkBits2Float(0x081f282a)); // -2.4663e-12f, 6.53477e+16f, 4.76191e+16f, 5.7784e-19f, 4.78945e-34f 6550 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6551 path.close(); 6552 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6553 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x03081f21), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 2.50338e-13f, 4.00025e-37f, 5.63611e+25f, 6.77381e-19f 6554 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6555 path.close(); 6556 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6557 path.quadTo(SkBits2Float(0x2d28282a), SkBits2Float(0x5568295b), SkBits2Float(0x3a21df68), SkBits2Float(0x4f9a3a8a)); // 9.55861e-12f, 1.5954e+13f, 0.000617495f, 5.17506e+09f 6558 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6559 path.close(); 6560 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6561 path.cubicTo(SkBits2Float(0x5568c23a), SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a), SkBits2Float(0x3a7bc003), SkBits2Float(0x294b2827)); // 1.59951e+13f, 4.87407e+16f, 5.7784e-19f, 4.61198e-19f, 0.00096035f, 4.51099e-14f 6562 6563 SkPath path2(path); 6564 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6565 } 6566 6567 static void kfuzz2(skiatest::Reporter* reporter, const char* filename) { 6568 SkPath path1; 6569 SkPath path; 6570 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6571 path.close(); 6572 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6573 path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xf19e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0x60600100), SkBits2Float(0x0100ff60)); // -2.36118e+21f, -1.57043e+30f, -1.26726e+30f, -3.40177e+38f, 6.45647e+19f, 2.36931e-38f 6574 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6575 path.close(); 6576 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6577 path.lineTo(SkBits2Float(0x60601a1d), SkBits2Float(0x60606060)); // 6.4593e+19f, 6.46721e+19f 6578 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6579 path.close(); 6580 path.moveTo(SkBits2Float(0xe5e2f300), SkBits2Float(0xee244a40)); // -1.33967e+23f, -1.27113e+28f 6581 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6582 path.close(); 6583 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6584 path.lineTo(SkBits2Float(0xfafafafa), SkBits2Float(0xe30000fa)); // -6.51582e+35f, -2.36125e+21f 6585 path.conicTo(SkBits2Float(0x92e592e5), SkBits2Float(0xfafafafb), SkBits2Float(0xc4fa0000), SkBits2Float(0x6060fafa), SkBits2Float(0x60606060)); // -1.44881e-27f, -6.51582e+35f, -2000, 6.48462e+19f, 6.46721e+19f 6586 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6587 path.close(); 6588 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6589 path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xf19e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0xfafafa00), SkBits2Float(0xfafafafa)); // -2.36118e+21f, -1.57043e+30f, -1.26726e+30f, -3.40177e+38f, -6.51572e+35f, -6.51582e+35f 6590 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6591 path.close(); 6592 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6593 path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xe39e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0xeed0ee9a), SkBits2Float(0x9a98ffca)); // -2.36118e+21f, -5.85032e+21f, -1.26726e+30f, -3.40177e+38f, -3.23307e+28f, -6.3279e-23f 6594 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6595 path.close(); 6596 SkPath path2(path); 6597 testPathOpFuzz(reporter, path1, path2, kXOR_SkPathOp, filename); 6598 } 6599 6600 static void fuzz763_10(skiatest::Reporter* reporter, const char* filename) { 6601 SkPath path; 6602 path.setFillType((SkPath::FillType) 1); 6603 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f 6604 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6605 path.quadTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 6.14991e+25f, 0, 0, 6.14991e+25f 6606 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f 6607 path.close(); 6608 6609 SkPath path1(path); 6610 path.reset(); 6611 path.setFillType((SkPath::FillType) 0); 6612 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6613 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 4.87407e+16f, 2.49685e-13f 6614 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6615 path.close(); 6616 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6617 path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f 6618 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6619 path.close(); 6620 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6621 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a29)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121588 6622 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6623 path.close(); 6624 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6625 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 3.20001e+24f, 3.84878e-14f, 2.49282e-13f, 4.78969e-34f 6626 path.conicTo(SkBits2Float(0x6a497b19), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.08939e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461 6627 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6628 path.close(); 6629 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6630 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a2129)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96181e-33f 6631 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f 6632 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f 6633 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6634 path.close(); 6635 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f 6636 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f 6637 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f 6638 6639 SkPath path2(path); 6640 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6641 } 6642 6643 static void fuzz763_11(skiatest::Reporter* reporter, const char* filename) { 6644 SkPath path; 6645 path.setFillType((SkPath::FillType) 0); 6646 6647 SkPath path1(path); 6648 path.reset(); 6649 path.setFillType((SkPath::FillType) 0); 6650 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6651 path.moveTo(SkBits2Float(0x2a0f312a), SkBits2Float(0xc0032108)); // 1.2718e-13f, -2.04889f 6652 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f 6653 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7b21), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14984e+25f, 9.43289e-15f, 1.21279e-11f 6654 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f 6655 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x08685568), SkBits2Float(0x7bc00321)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 6.99154e-34f, 1.99397e+36f 6656 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f 6657 path.close(); 6658 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f 6659 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 6660 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6661 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f 6662 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x2a812a3b), SkBits2Float(0x2a552927)); // 2.25206e-21f, 300.343f, 2.29443e-13f, 1.89325e-13f 6663 path.quadTo(SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x203a3b27), SkBits2Float(0x22c5381f)); // 0.00241343f, 3.71093e-14f, 1.57744e-19f, 5.34564e-18f 6664 path.moveTo(SkBits2Float(0x5d27ec2a), SkBits2Float(0x705921c2)); // 7.56256e+17f, 2.68796e+29f 6665 path.quadTo(SkBits2Float(0x102a5152), SkBits2Float(0x5b2dd912), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 3.35892e-29f, 4.89338e+16f, 4.03114e+24f, 1.50617e+13f 6666 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032127)); // 3.60396e-20f, -2.0489f 6667 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0x2a8c684b), SkBits2Float(0xf05b272d), SkBits2Float(0x2a1f1555), SkBits2Float(0x21082a21), SkBits2Float(0x6a4b7b03)); // 3.4979e+24f, 2.49414e-13f, -2.71298e+29f, 1.41294e-13f, 4.61343e-19f, 6.14982e+25f 6668 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 6669 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 6670 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 6671 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 6672 path.close(); 6673 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 6674 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a21211f)); // 4.85282e+16f, 1.43112e-13f 6675 path.lineTo(SkBits2Float(0x03552a8c), SkBits2Float(0x6a4f7b28)); // 6.26439e-37f, 6.27073e+25f 6676 path.conicTo(SkBits2Float(0x2347ed93), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.08381e-17f, 9.4495e-15f, 0.00170234f, 2.58753e+09f, 0.00136978f 6677 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 6678 path.close(); 6679 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 6680 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x262a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 5.91556e-16f, 0.000649768f 6681 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f 6682 path.conicTo(SkBits2Float(0x371f203a), SkBits2Float(0xc52a22c4), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x5210513a)); // 9.48464e-06f, -2722.17f, -55.289f, 0.000916855f, 1.5496e+11f 6683 path.cubicTo(SkBits2Float(0x63102ad9), SkBits2Float(0x29c80927), SkBits2Float(0x633a27b0), SkBits2Float(0x2909c827), SkBits2Float(0x272927b1), SkBits2Float(0x3a685b2d)); // 2.65942e+21f, 8.88337e-14f, 3.43395e+21f, 3.05937e-14f, 2.3475e-15f, 0.000886368f 6684 path.moveTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f 6685 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x5b2d2729)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 4.87382e+16f 6686 path.quadTo(SkBits2Float(0x2d685568), SkBits2Float(0x5568295b), SkBits2Float(0x2a552d29), SkBits2Float(0x295b2d27)); // 1.32066e-11f, 1.5954e+13f, 1.89339e-13f, 4.86669e-14f 6687 path.lineTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f 6688 path.close(); 6689 6690 SkPath path2(path); 6691 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6692 } 6693 6694 static void fuzz763_12(skiatest::Reporter* reporter, const char* filename) { 6695 SkPath path; 6696 path.setFillType((SkPath::FillType) 1); 6697 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6698 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a29082a)); // 0, 5.10868e+25f 6699 path.conicTo(SkBits2Float(0x6a295ac3), SkBits2Float(0x61bb988e), SkBits2Float(0x6829682d), SkBits2Float(0x5f3ba76a), SkBits2Float(0x42730a87)); // 5.11843e+25f, 4.32567e+20f, 3.20001e+24f, 1.35219e+19f, 60.7603f 6700 path.conicTo(SkBits2Float(0x67aedf99), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f801112)); // 1.65163e+24f, 0, 0, 0, 1.00052f 6701 path.close(); 6702 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6703 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 6.14991e+25f, 0, 0, 4.03114e+24f, 1.50617e+13f 6704 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 6705 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x67d55b2a), SkBits2Float(0x67296a4b), SkBits2Float(0x67555b2a), SkBits2Float(0x677e1f70), SkBits2Float(0x66d55b2a)); // 0, 2.01509e+24f, 8.00041e+23f, 1.00755e+24f, 1.20006e+24f, 5.03773e+23f 6706 path.cubicTo(SkBits2Float(0x678f0684), SkBits2Float(0x6684f008), SkBits2Float(0x6798f8ea), SkBits2Float(0x6625a942), SkBits2Float(0x67961914), SkBits2Float(0x65ce709a)); // 1.35084e+24f, 3.1389e+23f, 1.44478e+24f, 1.95578e+23f, 1.41764e+24f, 1.21861e+23f 6707 path.cubicTo(SkBits2Float(0x679158b0), SkBits2Float(0x00000000), SkBits2Float(0x67531e34), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.37276e+24f, 0, 9.96976e+23f, 0, 0, 0 6708 path.close(); 6709 6710 SkPath path1(path); 6711 path.reset(); 6712 path.setFillType((SkPath::FillType) 0); 6713 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6714 path.conicTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0xed237a6a), SkBits2Float(0x2d682967), SkBits2Float(0x2a8c555b)); // 4.61198e-19f, 1.64987e+07f, -3.16213e+27f, 1.31969e-11f, 2.49282e-13f 6715 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6716 path.close(); 6717 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6718 path.lineTo(SkBits2Float(0x3a6821df), SkBits2Float(0x2a8c3a8a)); // 0.000885514f, 2.49096e-13f 6719 path.moveTo(SkBits2Float(0x29272a1d), SkBits2Float(0xb03a2a55)); // 3.7118e-14f, -6.77266e-10f 6720 path.moveTo(SkBits2Float(0x20213b1e), SkBits2Float(0xc5272927)); // 1.36568e-19f, -2674.57f 6721 path.quadTo(SkBits2Float(0xc422373b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27), SkBits2Float(0x523a7059)); // -648.863f, -8.22676e+26f, 1.31706e-18f, 2.00187e+11f 6722 path.cubicTo(SkBits2Float(0x12102a10), SkBits2Float(0xe73a28d9), SkBits2Float(0xc8092763), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // 4.54902e-28f, -8.79114e+23f, -140446, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f 6723 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x555b2d29)); // 4.03113e+24f, 1.50617e+13f 6724 path.moveTo(SkBits2Float(0x1f2a212a), SkBits2Float(0x2d032108)); // 3.60263e-20f, 7.45382e-12f 6725 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // 4.03114e+24f, 1.89339e-13f 6726 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a528c5b), SkBits2Float(0x284f5b2d), SkBits2Float(0x218aa621), SkBits2Float(0x3f2d2db3), SkBits2Float(0x68293a2a)); // 5.73801e-19f, 1.87004e-13f, 1.15106e-14f, 9.39522e-19f, 0.676479f, 3.19661e+24f 6727 6728 SkPath path2(path); 6729 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6730 } 6731 6732 static void fuzz763_13(skiatest::Reporter* reporter, const char* filename) { 6733 SkPath path; 6734 path.setFillType((SkPath::FillType) 1); 6735 6736 SkPath path1(path); 6737 path.reset(); 6738 path.setFillType((SkPath::FillType) 0); 6739 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6740 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a)); // 6.14991e+25f, 75739, 9.4495e-15f, 0.00170234f, 2.58753e+09f 6741 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6742 path.close(); 6743 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6744 path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a8128), SkBits2Float(0x3a2a5529), SkBits2Float(0x3b1e2ab0)); // 0.00148109f, 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f, 0.00241343f 6745 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6746 path.close(); 6747 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6748 path.cubicTo(SkBits2Float(0x3b272927), SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 0.00255067f, 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f 6749 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x68295b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.19905e+24f 6750 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f 6751 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f 6752 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x6829292d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a291f)); // 5.73801e-19f, 2.06544e-13f, 3.19536e+24f, 9.6297e-12f, -1.05027e-31f, 1.51133e-13f 6753 path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f, 1.99397e+36f 6754 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6755 path.close(); 6756 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6757 path.lineTo(SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 4.88097e+16f, 5.7784e-19f 6758 path.conicTo(SkBits2Float(0x8ced7aba), SkBits2Float(0x3f2a212a), SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b), SkBits2Float(0x29685b2d)); // -3.65895e-31f, 0.664569f, 9.16179e-12f, 1.5954e+13f, 5.15934e-14f 6759 path.lineTo(SkBits2Float(0x68295b68), SkBits2Float(0x2d296855)); // 3.19906e+24f, 9.6297e-12f 6760 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6761 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x6aba7b03), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 1.12721e+26f, 6.77381e-19f 6762 path.quadTo(SkBits2Float(0x6028282a), SkBits2Float(0x68292ddf), SkBits2Float(0x5b2d555b), SkBits2Float(0x68556829)); // 4.84679e+19f, 3.1957e+24f, 4.8789e+16f, 4.03114e+24f 6763 6764 SkPath path2(path); 6765 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6766 } 6767 6768 static void fuzz763_14(skiatest::Reporter* reporter, const char* filename) { 6769 SkPath path; 6770 path.setFillType((SkPath::FillType) 0); 6771 6772 SkPath path1(path); 6773 path.reset(); 6774 path.setFillType((SkPath::FillType) 0); 6775 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0xf45b2d29)); // 4.03114e+24f, -6.94598e+31f 6776 path.moveTo(SkBits2Float(0x1f2a302a), SkBits2Float(0xc8032108)); // 3.60387e-20f, -134276 6777 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf0db684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x302a5b25), SkBits2Float(0xf0685568)); // 3.4979e+24f, -5.43226e+29f, -1.64207e-31f, 5.76527e-19f, 6.19752e-10f, -2.87615e+29f 6778 6779 SkPath path2(path); 6780 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6781 } 6782 6783 static void fuzz763_15(skiatest::Reporter* reporter, const char* filename) { 6784 SkPath path; 6785 path.setFillType((SkPath::FillType) 1); 6786 6787 SkPath path1(path); 6788 path.reset(); 6789 path.setFillType((SkPath::FillType) 0); 6790 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f 6791 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 6792 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x2c6829c0), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 5.77848e-19f, 4.7323e-37f, 3.29924e-12f, 2.49282e-13f, 4.78969e-34f 6793 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 6794 path.close(); 6795 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 6796 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf218a28), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.16402e+19f, 2.58751e+09f 6797 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x283ac221), SkBits2Float(0xe6432a29), SkBits2Float(0x2a96812b)); // 0.00136978f, 1.03672e-14f, -2.3041e+23f, 2.6735e-13f 6798 path.lineTo(SkBits2Float(0x5529272a), SkBits2Float(0x1eb03a2a)); // 1.16241e+13f, 1.86588e-20f 6799 path.conicTo(SkBits2Float(0x2a272021), SkBits2Float(0x3ac52729), SkBits2Float(0xc422313b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27)); // 1.48437e-13f, 0.00150416f, -648.769f, -8.22676e+26f, 1.31706e-18f 6800 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 6801 path.close(); 6802 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f 6803 path.close(); 6804 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f 6805 path.quadTo(SkBits2Float(0xc82763e7), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // -171408, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f 6806 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x8c555b2d)); // 4.03113e+24f, -1.64364e-31f 6807 path.moveTo(SkBits2Float(0x081f2a21), SkBits2Float(0x252d0321)); // 4.78968e-34f, 1.50064e-16f 6808 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2df068)); // 1.59583e+13f, 4.89595e+16f 6809 path.quadTo(SkBits2Float(0x2a1f2a8c), SkBits2Float(0x21482a21), SkBits2Float(0x4b7bc003), SkBits2Float(0x8ced3a6a)); // 1.41368e-13f, 6.78184e-19f, 1.64987e+07f, -3.65508e-31f 6810 path.moveTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f 6811 path.conicTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d155b2d), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 3.20982e+24f, 8.48991e-12f, 1.5954e+13f, 4.87407e+16f, 2.49685e-13f 6812 path.lineTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f 6813 path.close(); 6814 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6815 path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f 6816 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6817 path.close(); 6818 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6819 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x212aed7a), SkBits2Float(0x0321081f), SkBits2Float(0x293a7bc0), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 5.79125e-19f, 4.7323e-37f, 4.14076e-14f, 6.77381e-19f 6820 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x292a8c55), SkBits2Float(0x21081f2a)); // 3.20001e+24f, 3.84878e-14f, 3.78693e-14f, 4.61198e-19f 6821 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.14991e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461 6822 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6823 path.close(); 6824 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6825 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a21df)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96194e-33f 6826 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f 6827 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f 6828 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 6829 path.close(); 6830 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f 6831 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f 6832 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f 6833 6834 SkPath path2(path); 6835 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6836 } 6837 6838 static void fuzz763_16(skiatest::Reporter* reporter, const char* filename) { 6839 SkPath path; 6840 path.setFillType((SkPath::FillType) 0); 6841 6842 SkPath path1(path); 6843 path.reset(); 6844 path.setFillType((SkPath::FillType) 0); 6845 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6846 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 6847 path.cubicTo(SkBits2Float(0x68372d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c552775), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.46012e+24f, -2.71613e+29f, -1.64208e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 6848 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f 6849 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 6850 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 6851 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 6852 path.close(); 6853 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 6854 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 6855 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6856 path.conicTo(SkBits2Float(0x68385b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.48239e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f 6857 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 6858 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6859 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739 6860 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6861 path.close(); 6862 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6863 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f 6864 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6865 path.close(); 6866 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6867 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 6868 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6869 path.close(); 6870 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6871 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x681aed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 2.92648e+24f, 1.46617e+13f, 9.01175e-21f 6872 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f 6873 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 6874 path.close(); 6875 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 6876 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6877 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f 6878 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f 6879 path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x0329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77841e-19f, 4.9674e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 6880 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 6881 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 6882 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 6883 path.close(); 6884 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 6885 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f 6886 path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x5bf05568), SkBits2Float(0x212a3a8c)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, 1.35296e+17f, 5.76757e-19f 6887 path.lineTo(SkBits2Float(0x8c558c55), SkBits2Float(0x212a1f2a)); // -1.64512e-31f, 5.76395e-19f 6888 6889 SkPath path2(path); 6890 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6891 } 6892 6893 static void fuzz763_17(skiatest::Reporter* reporter, const char* filename) { 6894 SkPath path; 6895 path.setFillType((SkPath::FillType) 0); 6896 6897 SkPath path1(path); 6898 path.reset(); 6899 path.setFillType((SkPath::FillType) 0); 6900 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6901 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 6902 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 6903 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f 6904 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f 6905 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f 6906 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 6907 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6908 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f 6909 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 6910 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6911 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x254793ed)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73106e-16f 6912 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 6913 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 6914 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6915 path.close(); 6916 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6917 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f 6918 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f 6919 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6920 path.close(); 6921 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 6922 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6923 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 6924 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 6925 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 6926 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6927 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f 6928 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6929 path.close(); 6930 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6931 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f 6932 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6933 path.close(); 6934 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f 6935 path.conicTo(SkBits2Float(0x55086821), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2c6829), SkBits2Float(0x21218c55), SkBits2Float(0x2a6c1f03)); // 9.3738e+12f, 6.14991e+25f, 4.85282e+16f, 5.47346e-19f, 2.09718e-13f 6936 path.lineTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f 6937 path.close(); 6938 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f 6939 path.lineTo(SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a)); // 1.16348e+26f, 0.000209024f 6940 6941 SkPath path2(path); 6942 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6943 } 6944 6945 static void fuzz763_18(skiatest::Reporter* reporter, const char* filename) { 6946 SkPath path; 6947 path.setFillType((SkPath::FillType) 0); 6948 6949 SkPath path1(path); 6950 path.reset(); 6951 path.setFillType((SkPath::FillType) 0); 6952 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6953 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 6954 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 6955 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f 6956 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f 6957 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f 6958 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 6959 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6960 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f 6961 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 6962 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6963 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x254793ed)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73106e-16f 6964 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 6965 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 6966 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6967 path.close(); 6968 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6969 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f 6970 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f 6971 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 6972 path.close(); 6973 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 6974 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6975 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 6976 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 6977 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 6978 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6979 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f 6980 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6981 path.close(); 6982 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 6983 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f 6984 6985 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 6986 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6987 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 6988 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 6989 path.conicTo(SkBits2Float(0x2a8c54ed), SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0x29ed846a), SkBits2Float(0x555b2d28)); // 2.49279e-13f, 4.61198e-19f, 1.64987e+07f, 1.05479e-13f, 1.50617e+13f 6990 path.conicTo(SkBits2Float(0x68392d5b), SkBits2Float(0xf0682955), SkBits2Float(0x2a1f5b2d), SkBits2Float(0xef552a21), SkBits2Float(0x5b2d2a8c)); // 3.4979e+24f, -2.87402e+29f, 1.41537e-13f, -6.59712e+28f, 4.8742e+16f 6991 6992 SkPath path2(path); 6993 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6994 } 6995 6996 static void fuzz763_19(skiatest::Reporter* reporter, const char* filename) { 6997 SkPath path; 6998 path.setFillType((SkPath::FillType) 1); 6999 7000 SkPath path1(path); 7001 path.reset(); 7002 path.setFillType((SkPath::FillType) 0); 7003 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f 7004 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 9.43289e-15f, 1.61207e+25f 7005 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7006 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f 7007 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7008 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7009 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x8c5bf055), SkBits2Float(0x2a1f2a55), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, -1.69435e-31f, 1.41367e-13f, 4.7362e-37f, 1.43189e+16f 7010 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 7011 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7012 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2547937a)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73105e-16f 7013 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 7014 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7015 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7016 path.close(); 7017 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7018 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f 7019 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f 7020 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7021 path.close(); 7022 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7023 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7024 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7025 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 7026 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 7027 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7028 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 7029 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7030 path.close(); 7031 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7032 path.lineTo(SkBits2Float(0x555b2c29), SkBits2Float(0x6c212a8c)); // 1.50614e+13f, 7.79352e+26f 7033 path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0xf05b5568), SkBits2Float(0x212a3a8c)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, -2.71522e+29f, 5.76757e-19f 7034 path.conicTo(SkBits2Float(0x290321d9), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x2abe2a1f), SkBits2Float(0x7bc00321)); // 2.91172e-14f, 1.50618e+13f, 2.49284e-13f, 3.378e-13f, 1.99397e+36f 7035 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7036 path.close(); 7037 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7038 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f 7039 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7040 path.close(); 7041 7042 SkPath path2(path); 7043 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7044 } 7045 7046 static void fuzz763_20(skiatest::Reporter* reporter, const char* filename) { 7047 SkPath path; 7048 path.setFillType((SkPath::FillType) 0); 7049 7050 SkPath path1(path); 7051 path.reset(); 7052 path.setFillType((SkPath::FillType) 0); 7053 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7054 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7055 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 7056 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f 7057 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7058 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8c552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.49281e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f 7059 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7060 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7061 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f 7062 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 7063 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7064 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321182a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.73414e-37f, 6.14991e+25f, 75739 7065 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7066 path.close(); 7067 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7068 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f 7069 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7070 path.close(); 7071 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7072 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7073 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7074 path.close(); 7075 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7076 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f 7077 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x51282727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 4.51382e+10f 7078 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7079 path.close(); 7080 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7081 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x8c555b2d)); // 4.03114e+24f, -1.64364e-31f 7082 path.moveTo(SkBits2Float(0x081f2a31), SkBits2Float(0xc0032921)); // 4.78969e-34f, -2.04939f 7083 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f 7084 path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x4329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77841e-19f, 169.032f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f 7085 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7086 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x3a210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 0.000614217f, 1.99729e+36f 7087 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7088 path.close(); 7089 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7090 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f 7091 path.lineTo(SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830)); // 4.88298e+16f, -2.64185e+29f 7092 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7093 path.close(); 7094 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7095 path.conicTo(SkBits2Float(0x0321d90a), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x212a2a1f), SkBits2Float(0x4b7bc003)); // 4.75628e-37f, 1.50618e+13f, 2.49284e-13f, 5.7654e-19f, 1.64987e+07f 7096 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x212128c0)); // -1.31678e-31f, 5.46029e-19f 7097 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7098 path.close(); 7099 7100 SkPath path2(path); 7101 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7102 } 7103 7104 static void fuzz763_21(skiatest::Reporter* reporter, const char* filename) { 7105 SkPath path; 7106 path.setFillType((SkPath::FillType) 1); 7107 path.moveTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f 7108 path.cubicTo(SkBits2Float(0x68303469), SkBits2Float(0x661f92fc), SkBits2Float(0x6837d3c3), SkBits2Float(0x662b0eb2), SkBits2Float(0x683fa268), SkBits2Float(0x663759e1)); // 3.32841e+24f, 1.88392e+23f, 3.4724e+24f, 2.01949e+23f, 3.61987e+24f, 2.16463e+23f 7109 path.cubicTo(SkBits2Float(0x68c4391f), SkBits2Float(0x672c5c9f), SkBits2Float(0x688b20ab), SkBits2Float(0x6804b825), SkBits2Float(0x681ddb5e), SkBits2Float(0x6838dc00)); // 7.4131e+24f, 8.13956e+23f, 5.25609e+24f, 2.507e+24f, 2.98183e+24f, 3.49189e+24f 7110 path.lineTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f 7111 path.close(); 7112 path.moveTo(SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 3.0681e+24f, 1.65068e+23f 7113 path.cubicTo(SkBits2Float(0x6823b0e1), SkBits2Float(0x660d990f), SkBits2Float(0x6824f6d5), SkBits2Float(0x660f668c), SkBits2Float(0x68263e4e), SkBits2Float(0x66113632)); // 3.09203e+24f, 1.67169e+23f, 3.11609e+24f, 1.69298e+23f, 3.14025e+24f, 1.71436e+23f 7114 path.cubicTo(SkBits2Float(0x682715e4), SkBits2Float(0x6612676d), SkBits2Float(0x6827ee22), SkBits2Float(0x66139997), SkBits2Float(0x6828c709), SkBits2Float(0x6614cba5)); // 3.15616e+24f, 1.72843e+23f, 3.17211e+24f, 1.74255e+23f, 3.18812e+24f, 1.75667e+23f 7115 path.lineTo(SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.1893e+24f, 1.56583e+23f 7116 path.cubicTo(SkBits2Float(0x68270421), SkBits2Float(0x6601102c), SkBits2Float(0x68252b97), SkBits2Float(0x65fb1edd), SkBits2Float(0x68234ce5), SkBits2Float(0x65f4367f)); // 3.15485e+24f, 1.52371e+23f, 3.11998e+24f, 1.48235e+23f, 3.08466e+24f, 1.44158e+23f 7117 path.conicTo(SkBits2Float(0x6822e012), SkBits2Float(0x6602acc5), SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e), SkBits2Float(0x3f7ffa04)); // 3.07663e+24f, 1.54274e+23f, 3.0681e+24f, 1.65068e+23f, 0.999909f 7118 path.close(); 7119 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 7120 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 7121 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x68617414), SkBits2Float(0x66af1c42), SkBits2Float(0x68624f96), SkBits2Float(0x6757755b), SkBits2Float(0x685b93f2)); // 0, 4.25869e+24f, 4.13468e+23f, 4.27489e+24f, 1.01747e+24f, 4.14771e+24f 7122 path.cubicTo(SkBits2Float(0x67a63a84), SkBits2Float(0x68fe1c37), SkBits2Float(0x67c05eed), SkBits2Float(0x69930962), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 1.56998e+24f, 9.60001e+24f, 1.81689e+24f, 2.22196e+25f, 0, 5.14279e+25f 7123 path.close(); 7124 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 7125 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f 7126 path.cubicTo(SkBits2Float(0x6a2c8798), SkBits2Float(0x68f7a144), SkBits2Float(0x6951f5ea), SkBits2Float(0x6796ad55), SkBits2Float(0x683fa268), SkBits2Float(0x663759e1)); // 5.21439e+25f, 9.35519e+24f, 1.58642e+25f, 1.4231e+24f, 3.61987e+24f, 2.16463e+23f 7127 path.cubicTo(SkBits2Float(0x683871e3), SkBits2Float(0x66253b4f), SkBits2Float(0x6830da01), SkBits2Float(0x66144d3e), SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.48407e+24f, 1.95071e+23f, 3.34063e+24f, 1.75084e+23f, 3.1893e+24f, 1.56583e+23f 7128 path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x492bb324)); // 3.19904e+24f, 0, 0, 0, 703282 7129 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x677b84f0), SkBits2Float(0x00000000), SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 0, 0, 1.18777e+24f, 0, 3.0681e+24f, 1.65068e+23f 7130 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68156829)); // 0, 2.82222e+24f 7131 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 7132 path.lineTo(SkBits2Float(0x673918f3), SkBits2Float(0x681b0f5f)); // 8.74098e+23f, 2.929e+24f 7133 path.lineTo(SkBits2Float(0x67391759), SkBits2Float(0x681b0fae)); // 8.74068e+23f, 2.92902e+24f 7134 path.cubicTo(SkBits2Float(0x674384e7), SkBits2Float(0x682e2068), SkBits2Float(0x674db698), SkBits2Float(0x6843893b), SkBits2Float(0x6757755b), SkBits2Float(0x685b93f2)); // 9.23313e+23f, 3.28916e+24f, 9.71453e+23f, 3.69357e+24f, 1.01747e+24f, 4.14771e+24f 7135 path.cubicTo(SkBits2Float(0x67a63484), SkBits2Float(0x68556bdd), SkBits2Float(0x67f18c5f), SkBits2Float(0x6848eb25), SkBits2Float(0x681ddb5e), SkBits2Float(0x6838dc00)); // 1.56976e+24f, 4.03142e+24f, 2.28136e+24f, 3.79524e+24f, 2.98183e+24f, 3.49189e+24f 7136 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 7137 path.close(); 7138 7139 SkPath path1(path); 7140 path.reset(); 7141 path.setFillType((SkPath::FillType) 0); 7142 7143 SkPath path2(path); 7144 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 7145 } 7146 7147 static void fuzz763_22(skiatest::Reporter* reporter, const char* filename) { 7148 SkPath path; 7149 path.setFillType((SkPath::FillType) 1); 7150 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f 7151 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7152 path.lineTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x00000000)); // 5.63611e+25f, 0 7153 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a034b21)); // 0, 3.9681e+25f 7154 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f 7155 path.close(); 7156 path.moveTo(SkBits2Float(0x6617da56), SkBits2Float(0x00000000)); // 1.79276e+23f, 0 7157 path.conicTo(SkBits2Float(0x5e704d09), SkBits2Float(0x5e3a4dfd), SkBits2Float(0x00000000), SkBits2Float(0x65eb62ef), SkBits2Float(0x430fa5e6)); // 4.32888e+18f, 3.35617e+18f, 0, 1.38948e+23f, 143.648f 7158 path.conicTo(SkBits2Float(0x5e798b32), SkBits2Float(0x627a95c0), SkBits2Float(0x61f5014c), SkBits2Float(0x61fba0fd), SkBits2Float(0x40f8a1a1)); // 4.49538e+18f, 1.15562e+21f, 5.64943e+20f, 5.80217e+20f, 7.76973f 7159 path.conicTo(SkBits2Float(0x62743d2d), SkBits2Float(0x5e49b862), SkBits2Float(0x6617da56), SkBits2Float(0x00000000), SkBits2Float(0x410ef54c)); // 1.12635e+21f, 3.63387e+18f, 1.79276e+23f, 0, 8.93489f 7160 path.close(); 7161 7162 SkPath path1(path); 7163 path.reset(); 7164 path.setFillType((SkPath::FillType) 0); 7165 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7166 path.quadTo(SkBits2Float(0x4f9a3a8a), SkBits2Float(0xc28a0d28), SkBits2Float(0x273a3ab3), SkBits2Float(0x8b2a2928)); // 5.17506e+09f, -69.0257f, 2.58445e-15f, -3.27718e-32f 7167 path.lineTo(SkBits2Float(0x63283ae6), SkBits2Float(0x27282a81)); // 3.1033e+21f, 2.33377e-15f 7168 7169 SkPath path2(path); 7170 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 7171 } 7172 7173 static void fuzz763_23(skiatest::Reporter* reporter, const char* filename) { 7174 SkPath path; 7175 path.setFillType((SkPath::FillType) 0); 7176 7177 SkPath path1(path); 7178 path.reset(); 7179 path.setFillType((SkPath::FillType) 0); 7180 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7181 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7182 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x03210c2a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.73276e-37f, 6.14991e+25f 7183 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f 7184 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7185 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x29295b2d), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, 4.2514e-13f, 3.76046e-14f, 3.04146e+24f, 1.99729e+36f 7186 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7187 path.close(); 7188 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7189 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7190 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x8c5bf055), SkBits2Float(0x2a1f2a55), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, -1.69435e-31f, 1.41367e-13f, 4.7362e-37f, 1.43189e+16f 7191 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 7192 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7193 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x08211f72), SkBits2Float(0x032a2a21), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2547937a)); // 2.49282e-13f, 4.84861e-34f, 5.00069e-37f, 6.14991e+25f, 1.73105e-16f 7194 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 7195 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7196 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7197 path.close(); 7198 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7199 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f 7200 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f 7201 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7202 path.close(); 7203 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7204 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7205 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7206 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 7207 path.conicTo(SkBits2Float(0x2a8c54ed), SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0x29ed846a), SkBits2Float(0x555b2d28)); // 2.49279e-13f, 4.61198e-19f, 1.64987e+07f, 1.05479e-13f, 1.50617e+13f 7208 path.conicTo(SkBits2Float(0x68392d5b), SkBits2Float(0xf0682955), SkBits2Float(0x2a1f5b2d), SkBits2Float(0xef552a21), SkBits2Float(0x5b2d2a8c)); // 3.4979e+24f, -2.87402e+29f, 1.41537e-13f, -6.59712e+28f, 4.8742e+16f 7209 7210 SkPath path2(path); 7211 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7212 } 7213 7214 static void fuzz763_24(skiatest::Reporter* reporter, const char* filename) { 7215 SkPath path; 7216 path.setFillType((SkPath::FillType) 1); 7217 7218 SkPath path1(path); 7219 path.reset(); 7220 path.setFillType((SkPath::FillType) 0); 7221 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f 7222 path.close(); 7223 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f 7224 path.quadTo(SkBits2Float(0x9fb9c16e), SkBits2Float(0x27737375), SkBits2Float(0xb7c5ff00), SkBits2Float(0x00ff9908)); // -7.86706e-20f, 3.37856e-15f, -2.3603e-05f, 2.34729e-38f 7225 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7226 path.cubicTo(SkBits2Float(0x1616ecec), SkBits2Float(0x2c321616), SkBits2Float(0x3516c616), SkBits2Float(0x6e161616), SkBits2Float(0x4c416033), SkBits2Float(0xf6000000)); // 1.21917e-25f, 2.53076e-12f, 5.61676e-07f, 1.16124e+28f, 5.06923e+07f, -6.49037e+32f 7227 path.quadTo(SkBits2Float(0x04007f41), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec41ec)); // 1.51048e-36f, -2.2914e+27f, -2.2914e+27f, -2.28494e+27f 7228 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7229 path.close(); 7230 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7231 path.quadTo(SkBits2Float(0x000000ec), SkBits2Float(0xececcc00), SkBits2Float(0x48ececec), SkBits2Float(0x0278806e)); // 3.30706e-43f, -2.29016e+27f, 485223, 1.8257e-37f 7232 path.lineTo(SkBits2Float(0x72ececec), SkBits2Float(0xecec02ec)); // 9.38559e+30f, -2.28256e+27f 7233 path.quadTo(SkBits2Float(0xec04007f), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec0400)); // -6.38322e+26f, -2.2914e+27f, -2.2914e+27f, -2.2826e+27f 7234 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7235 path.close(); 7236 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7237 path.quadTo(SkBits2Float(0x000040ec), SkBits2Float(0x3a333300), SkBits2Float(0xecec3333), SkBits2Float(0xececdbec)); // 2.32896e-41f, 0.000683591f, -2.28439e+27f, -2.29076e+27f 7238 path.lineTo(SkBits2Float(0x3300007f), SkBits2Float(0x33d83333)); // 2.98028e-08f, 1.00676e-07f 7239 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7240 path.close(); 7241 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7242 path.quadTo(SkBits2Float(0x9e9ea900), SkBits2Float(0x33ececec), SkBits2Float(0xececec33), SkBits2Float(0xec336e6e)); // -1.67988e-20f, 1.10327e-07f, -2.29138e+27f, -8.67677e+26f 7243 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7244 path.close(); 7245 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7246 path.lineTo(SkBits2Float(0xedededed), SkBits2Float(0xedededed)); // -9.20445e+27f, -9.20445e+27f 7247 path.lineTo(SkBits2Float(0xecececec), SkBits2Float(0xecececec)); // -2.2914e+27f, -2.2914e+27f 7248 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7249 path.close(); 7250 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7251 path.lineTo(SkBits2Float(0x01003300), SkBits2Float(0x33d83333)); // 2.35465e-38f, 1.00676e-07f 7252 path.quadTo(SkBits2Float(0xecec3333), SkBits2Float(0x04eeedec), SkBits2Float(0xe0e0e0e0), SkBits2Float(0x9ee0e0e0)); // -2.28439e+27f, 5.6172e-36f, -1.29634e+20f, -2.38099e-20f 7253 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7254 path.close(); 7255 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7256 path.cubicTo(SkBits2Float(0x299e9e9e), SkBits2Float(0xecececec), SkBits2Float(0xececb6ec), SkBits2Float(0xf0ececec), SkBits2Float(0x0000ecec), SkBits2Float(0x9ebe6e6e)); // 7.04413e-14f, -2.2914e+27f, -2.28936e+27f, -5.86599e+29f, 8.49916e-41f, -2.01627e-20f 7257 path.cubicTo(SkBits2Float(0x9e9e9e9e), SkBits2Float(0xe8009e9e), SkBits2Float(0x9e9e9e9e), SkBits2Float(0xecec9e9e), SkBits2Float(0xec3333ec), SkBits2Float(0xececf0ec)); // -1.67945e-20f, -2.42956e+24f, -1.67945e-20f, -2.28844e+27f, -8.66572e+26f, -2.29155e+27f 7258 7259 SkPath path2(path); 7260 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7261 } 7262 7263 static void fuzz763_25(skiatest::Reporter* reporter, const char* filename) { 7264 SkPath path; 7265 path.setFillType((SkPath::FillType) 1); 7266 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f 7267 path.conicTo(SkBits2Float(0x653140d9), SkBits2Float(0x6a4b4f74), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3f6728a2)); // 5.23159e+22f, 6.14468e+25f, 8.52382e+22f, 5.00576e+25f, 0.902964f 7268 path.cubicTo(SkBits2Float(0x68295bc5), SkBits2Float(0x00000000), SkBits2Float(0x682958ff), SkBits2Float(0x00000000), SkBits2Float(0x68286829), SkBits2Float(0x00000000)); // 3.19909e+24f, 0, 3.19889e+24f, 0, 3.18112e+24f, 0 7269 path.lineTo(SkBits2Float(0x68555b29), SkBits2Float(0x00000000)); // 4.03018e+24f, 0 7270 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x682d2927), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6829686f)); // 0, 3.27091e+24f, 0, 0, 3.20003e+24f 7271 path.lineTo(SkBits2Float(0xdf218a28), SkBits2Float(0x00000000)); // -1.16402e+19f, 0 7272 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f 7273 path.close(); 7274 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7275 path.conicTo(SkBits2Float(0x6642c40c), SkBits2Float(0x00000000), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3edcd74d)); // 2.29939e+23f, 0, 8.52382e+22f, 5.00576e+25f, 0.43133f 7276 path.conicTo(SkBits2Float(0x68295afa), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x4277a57b)); // 3.19903e+24f, 0, 0, 0, 61.9116f 7277 path.close(); 7278 7279 SkPath path1(path); 7280 path.reset(); 7281 path.setFillType((SkPath::FillType) 0); 7282 7283 SkPath path2(path); 7284 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7285 } 7286 7287 7288 static void fuzz763_26(skiatest::Reporter* reporter, const char* filename) { 7289 SkPath path; 7290 path.setFillType((SkPath::FillType) 0); 7291 7292 SkPath path1(path); 7293 path.reset(); 7294 path.setFillType((SkPath::FillType) 0); 7295 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7296 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc003210a)); // 3.60396e-20f, -2.04889f 7297 path.cubicTo(SkBits2Float(0x68372d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.46012e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 7298 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f 7299 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7300 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 7301 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7302 path.close(); 7303 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7304 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7305 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7306 path.conicTo(SkBits2Float(0x68385b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212121), SkBits2Float(0x5a4b7bc0)); // 3.48239e+24f, 1.51141e+13f, 1.41368e-13f, 4.73517e-37f, 1.43189e+16f 7307 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f 7308 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7309 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739 7310 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7311 path.close(); 7312 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7313 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f 7314 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7315 path.close(); 7316 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7317 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2127ed29)); // 2.25206e-21f, 300.343f, 0.000650423f, 5.68957e-19f 7318 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f 7319 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f 7320 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7321 path.close(); 7322 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7323 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x5b2d5529)); // 4.03114e+24f, 4.87888e+16f 7324 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f 7325 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f 7326 path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x0329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77841e-19f, 4.9674e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 7327 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7328 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 7329 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7330 path.close(); 7331 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7332 path.lineTo(SkBits2Float(0x555b1b29), SkBits2Float(0x6c212a8c)); // 1.50569e+13f, 7.79352e+26f 7333 path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x8c5bf055), SkBits2Float(0x1f212a3a)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, -1.69435e-31f, 3.4128e-20f 7334 path.conicTo(SkBits2Float(0x290321d9), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x2a212a1f), SkBits2Float(0x7bc00321)); // 2.91172e-14f, 1.50618e+13f, 2.49284e-13f, 1.43143e-13f, 1.99397e+36f 7335 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7336 path.close(); 7337 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7338 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f 7339 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7340 path.close(); 7341 7342 SkPath path2(path); 7343 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7344 } 7345 7346 static void fuzz763_28(skiatest::Reporter* reporter, const char* filename) { 7347 SkPath path; 7348 path.setFillType((SkPath::FillType) 0); 7349 7350 SkPath path1(path); 7351 path.reset(); 7352 path.setFillType((SkPath::FillType) 0); 7353 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7354 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7355 path.cubicTo(SkBits2Float(0x68302d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6aa37bc0)); // 3.32789e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 9.88197e+25f 7356 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2d28ed84), SkBits2Float(0x5b2d2955)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.60243e-12f, 4.87406e+16f 7357 path.moveTo(SkBits2Float(0x6c395b2d), SkBits2Float(0xf0682955)); // 8.96327e+26f, -2.87402e+29f 7358 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef8c55), SkBits2Float(0x68295b2d), SkBits2Float(0x21086855), SkBits2Float(0x4b7bc003)); // 5.76397e-19f, 4.25523e-13f, 3.19905e+24f, 4.62167e-19f, 1.64987e+07f 7359 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7360 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7361 path.lineTo(SkBits2Float(0x8a283a28), SkBits2Float(0x284f1a3a)); // -8.09984e-33f, 1.14965e-14f 7362 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f 7363 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f 7364 path.conicTo(SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f 7365 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f 7366 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f 7367 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f 7368 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a29ca)); // 5.73801e-19f, 2.06544e-13f, 3.19905e+24f, 9.6297e-12f, -1.05027e-31f, 1.51135e-13f 7369 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f 7370 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7371 path.close(); 7372 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7373 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2d6829), SkBits2Float(0x1f212a55), SkBits2Float(0x8ced7aba), SkBits2Float(0x3f2a212a)); // 6.14991e+25f, 4.88097e+16f, 3.41281e-20f, -3.65895e-31f, 0.664569f 7374 path.lineTo(SkBits2Float(0x5b2d212d), SkBits2Float(0x2d556829)); // 4.87316e+16f, 1.21308e-11f 7375 path.moveTo(SkBits2Float(0x68552968), SkBits2Float(0x5568295b)); // 4.02651e+24f, 1.5954e+13f 7376 path.moveTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f 7377 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7378 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a)); // 5.77848e-19f, 4.7323e-37f, 5.63611e+25f, 6.77381e-19f, 9.33503e-15f 7379 7380 SkPath path2(path); 7381 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7382 } 7383 7384 static void fuzz763_27(skiatest::Reporter* reporter, const char* filename) { 7385 SkPath path; 7386 path.setFillType((SkPath::FillType) 0); 7387 7388 SkPath path1(path); 7389 path.reset(); 7390 path.setFillType((SkPath::FillType) 0); 7391 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7392 path.quadTo(SkBits2Float(0x30309ab8), SkBits2Float(0x305b3030), SkBits2Float(0x00f53030), SkBits2Float(0x3a3a0000)); // 6.42483e-10f, 7.97402e-10f, 2.2517e-38f, 0.000709534f 7393 path.quadTo(SkBits2Float(0xb8b8d5b8), SkBits2Float(0x0b0b0b03), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a0b0b)); // -8.81361e-05f, 2.67787e-32f, 2.67787e-32f, 0.000709698f 7394 path.quadTo(SkBits2Float(0xb8b8b8b8), SkBits2Float(0x0b1203b8), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a2110)); // -8.80821e-05f, 2.81214e-32f, 2.67787e-32f, 0.000710026f 7395 7396 SkPath path2(path); 7397 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7398 } 7399 7400 static void fuzz763_29(skiatest::Reporter* reporter, const char* filename) { 7401 SkPath path; 7402 path.setFillType((SkPath::FillType) 1); 7403 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7404 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x743e0000)); // 0, 6.02134e+31f 7405 path.cubicTo(SkBits2Float(0x74083cf1), SkBits2Float(0x74536e73), SkBits2Float(0x742ac4e4), SkBits2Float(0x7415f5be), SkBits2Float(0x7433ee3c), SkBits2Float(0x7405a69a)); // 4.31756e+31f, 6.70053e+31f, 5.41189e+31f, 4.75242e+31f, 5.70223e+31f, 4.23556e+31f 7406 path.quadTo(SkBits2Float(0x74360ca0), SkBits2Float(0x7401e10c), SkBits2Float(0x7436a382), SkBits2Float(0x7401cc18)); // 5.76937e+31f, 4.11603e+31f, 5.78805e+31f, 4.11344e+31f 7407 path.cubicTo(SkBits2Float(0x74374a91), SkBits2Float(0x7401ef19), SkBits2Float(0x74375c84), SkBits2Float(0x7404d9b9), SkBits2Float(0x7437868f), SkBits2Float(0x740bae8a)); // 5.80873e+31f, 4.11777e+31f, 5.81095e+31f, 4.2102e+31f, 5.81616e+31f, 4.42669e+31f 7408 path.cubicTo(SkBits2Float(0x7437d6c1), SkBits2Float(0x7418b629), SkBits2Float(0x74387e9b), SkBits2Float(0x7433fbc5), SkBits2Float(0x743e2ff7), SkBits2Float(0x74655fa2)); // 5.82609e+31f, 4.83962e+31f, 5.84687e+31f, 5.7039e+31f, 6.02728e+31f, 7.26914e+31f 7409 path.cubicTo(SkBits2Float(0x741ada75), SkBits2Float(0x74745717), SkBits2Float(0x73c106b4), SkBits2Float(0x74744e64), SkBits2Float(0x00000000), SkBits2Float(0x74744006)); // 4.9075e+31f, 7.74345e+31f, 3.05862e+31f, 7.74237e+31f, 0, 7.74059e+31f 7410 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x74746c7c), SkBits2Float(0x74244dce), SkBits2Float(0x7474733e), SkBits2Float(0x74400000), SkBits2Float(0x74747445)); // 0, 7.7461e+31f, 5.207e+31f, 7.74693e+31f, 6.08472e+31f, 7.74706e+31f 7411 path.cubicTo(SkBits2Float(0x743f5854), SkBits2Float(0x746f3659), SkBits2Float(0x743ebe05), SkBits2Float(0x746a3017), SkBits2Float(0x743e2ff7), SkBits2Float(0x74655fa2)); // 6.06397e+31f, 7.58094e+31f, 6.04486e+31f, 7.42171e+31f, 6.02728e+31f, 7.26914e+31f 7412 path.cubicTo(SkBits2Float(0x7447a582), SkBits2Float(0x74615dee), SkBits2Float(0x744f74f6), SkBits2Float(0x745c4903), SkBits2Float(0x7455e7e6), SkBits2Float(0x7455d751)); // 6.32705e+31f, 7.14216e+31f, 6.57457e+31f, 6.98112e+31f, 6.77895e+31f, 6.77689e+31f 7413 path.cubicTo(SkBits2Float(0x74747474), SkBits2Float(0x743750a4), SkBits2Float(0x74747474), SkBits2Float(0x73f46f0d), SkBits2Float(0x74747474), SkBits2Float(0x00000000)); // 7.74708e+31f, 5.80948e+31f, 7.74708e+31f, 3.87321e+31f, 7.74708e+31f, 0 7414 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7415 path.close(); 7416 7417 SkPath path1(path); 7418 path.reset(); 7419 path.setFillType((SkPath::FillType) 0); 7420 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7421 path.lineTo(SkBits2Float(0xf0682955), SkBits2Float(0x211f5b2d)); // -2.87402e+29f, 5.3992e-19f 7422 path.moveTo(SkBits2Float(0x2d2aff2d), SkBits2Float(0x74747474)); // 9.72004e-12f, 7.74708e+31f 7423 path.cubicTo(SkBits2Float(0x7474748e), SkBits2Float(0x74747490), SkBits2Float(0x8c722174), SkBits2Float(0x181f0080), SkBits2Float(0x74c0e520), SkBits2Float(0x747d7463)); // 7.7471e+31f, 7.7471e+31f, -1.86531e-31f, 2.05505e-24f, 1.22262e+32f, 8.0323e+31f 7424 path.cubicTo(SkBits2Float(0x7b005e4b), SkBits2Float(0xdf3a6a3a), SkBits2Float(0x2a3a2848), SkBits2Float(0x2d2d7821), SkBits2Float(0x8c55212d), SkBits2Float(0x2d2d2d24)); // 6.66526e+35f, -1.34326e+19f, 1.65341e-13f, 9.86059e-12f, -1.64189e-31f, 9.84393e-12f 7425 path.conicTo(SkBits2Float(0xde28804c), SkBits2Float(0x28e03721), SkBits2Float(0x3329df28), SkBits2Float(0x2d291515), SkBits2Float(0x0568295b)); // -3.03545e+18f, 2.48929e-14f, 3.95513e-08f, 9.61122e-12f, 1.09162e-35f 7426 path.conicTo(SkBits2Float(0x556a2d21), SkBits2Float(0x21088c2a), SkBits2Float(0x3a333303), SkBits2Float(0x5b293a8a), SkBits2Float(0x6855683b)); // 1.60925e+13f, 4.62641e-19f, 0.000683591f, 4.76336e+16f, 4.03115e+24f 7427 7428 SkPath path2(path); 7429 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7430 } 7431 7432 static void fuzz763_30(skiatest::Reporter* reporter, const char* filename) { 7433 SkPath path; 7434 path.setFillType((SkPath::FillType) 1); 7435 7436 SkPath path1(path); 7437 path.reset(); 7438 path.setFillType((SkPath::FillType) 0); 7439 path.moveTo(SkBits2Float(0x1f2108c0), SkBits2Float(0x4b7b0321)); // 3.41003e-20f, 1.64503e+07f 7440 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 7441 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7442 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x2a4b7bc0), SkBits2Float(0x68295b2d)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 1.8073e-13f, 3.19905e+24f 7443 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f 7444 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x4b7b28c0)); // 4.7323e-37f, 1.646e+07f 7445 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x2d081f21)); // 2.50338e-13f, 7.73762e-12f 7446 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7447 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7448 path.cubicTo(SkBits2Float(0x69392d55), SkBits2Float(0x2d5b684b), SkBits2Float(0x8c5527f0), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 1.39916e+25f, 1.24719e-11f, -1.64209e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f 7449 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0xed7a6a1f), SkBits2Float(0x3a214793), SkBits2Float(0x3328282a), SkBits2Float(0x3a8a3adf)); // 5.77848e-19f, -4.84372e+27f, 0.000615233f, 3.91521e-08f, 0.00105461f 7450 path.conicTo(SkBits2Float(0x4be80304), SkBits2Float(0xdcdcdc15), SkBits2Float(0xdcdcdcdc), SkBits2Float(0x71dcdcdc), SkBits2Float(0x6c107164)); // 3.04102e+07f, -4.97332e+17f, -4.97339e+17f, 2.18732e+30f, 6.98483e+26f 7451 path.conicTo(SkBits2Float(0x6c0f1d6c), SkBits2Float(0x8e406c6e), SkBits2Float(0x6c6c0200), SkBits2Float(0x6c6ce46c), SkBits2Float(0x6c6c6c6c)); // 6.92061e+26f, -2.3718e-30f, 1.14126e+27f, 1.14554e+27f, 1.14327e+27f 7452 path.lineTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7453 path.close(); 7454 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7455 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x3ac22c21), SkBits2Float(0x6c401057), SkBits2Float(0x6d6d6b64)); // 0.00136978f, 0.00148142f, 9.28764e+26f, 4.59236e+27f 7456 path.cubicTo(SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x286d6d6d), SkBits2Float(0x081d2a29), SkBits2Float(0x6d690321), SkBits2Float(0x6b6b026d)); // 4.59251e+27f, 4.59251e+27f, 1.31799e-14f, 4.7295e-34f, 4.50711e+27f, 2.84109e+26f 7457 7458 SkPath path2(path); 7459 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7460 } 7461 7462 static void fuzz763_31(skiatest::Reporter* reporter, const char* filename) { 7463 SkPath path; 7464 path.setFillType((SkPath::FillType) 1); 7465 7466 SkPath path1(path); 7467 path.reset(); 7468 path.setFillType((SkPath::FillType) 0); 7469 path.moveTo(SkBits2Float(0xd72a8c55), SkBits2Float(0x61081f2a)); // -1.8752e+14f, 1.56938e+20f 7470 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf3a2128), SkBits2Float(0x471ac575)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.3412e+19f, 39621.5f 7471 path.lineTo(SkBits2Float(0x28404040), SkBits2Float(0x552a298a)); // 1.06721e-14f, 1.16935e+13f 7472 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7473 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x80ed7a3a), SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, -2.18089e-38f, 1.65317e-13f, -1.16126e+19f, 2.58751e+09f 7474 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7475 path.close(); 7476 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7477 path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x432a2928), SkBits2Float(0x96812be6), SkBits2Float(0x272a1d2a), SkBits2Float(0x3a2a3529), SkBits2Float(0x3b1e2ab0)); // 0.00148109f, 170.161f, -2.08688e-25f, 2.3608e-15f, 0.000649291f, 0.00241343f 7478 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7479 path.close(); 7480 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7481 path.cubicTo(SkBits2Float(0xc5272927), SkBits2Float(0x22383b39), SkBits2Float(0x1051523a), SkBits2Float(0x2927b029), SkBits2Float(0x685b2d27), SkBits2Float(0x5b2d6855)); // -2674.57f, 2.4968e-18f, 4.12813e-29f, 3.72342e-14f, 4.14012e+24f, 4.88099e+16f 7482 7483 SkPath path2(path); 7484 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7485 } 7486 7487 static void fuzz763_33(skiatest::Reporter* reporter, const char* filename) { 7488 SkPath path; 7489 path.setFillType((SkPath::FillType) 1); 7490 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f 7491 path.quadTo(SkBits2Float(0x724341bf), SkBits2Float(0x72433fc4), SkBits2Float(0x6d757575), SkBits2Float(0x6d6d6d6d)); // 3.86746e+30f, 3.86731e+30f, 4.74786e+27f, 4.59251e+27f 7492 path.cubicTo(SkBits2Float(0x6d18b5e5), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6cbe03bd), SkBits2Float(0x6d4b455b), SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 2.95385e+27f, 4.59251e+27f, 1.83771e+27f, 3.93183e+27f, 1.14323e+27f, 3.11171e+27f 7493 path.conicTo(SkBits2Float(0x6c6c8b72), SkBits2Float(0x00000000), SkBits2Float(0x6c6c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x400812df)); // 1.14386e+27f, 0, 1.14327e+27f, 0, 2.12615f 7494 path.quadTo(SkBits2Float(0x72432acb), SkBits2Float(0x72432295), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 3.86568e+30f, 3.86505e+30f, 7.66623e+30f, 7.66608e+30f 7495 path.close(); 7496 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f 7497 path.cubicTo(SkBits2Float(0x74f97d76), SkBits2Float(0x74f97d90), SkBits2Float(0x75381628), SkBits2Float(0x7538182c), SkBits2Float(0x7538153b), SkBits2Float(0x75381835)); // 1.58133e+32f, 1.58133e+32f, 2.33357e+32f, 2.33367e+32f, 2.33353e+32f, 2.33368e+32f 7498 path.cubicTo(SkBits2Float(0x7538144e), SkBits2Float(0x7538183f), SkBits2Float(0x74f9760f), SkBits2Float(0x74f97ddd), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 2.33348e+32f, 2.33368e+32f, 1.58115e+32f, 1.58134e+32f, 7.66623e+30f, 7.66608e+30f 7499 path.close(); 7500 path.moveTo(SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.14323e+27f, 3.11171e+27f 7501 path.conicTo(SkBits2Float(0x6c6c55ae), SkBits2Float(0x6d80b520), SkBits2Float(0x6c6c1071), SkBits2Float(0x6e0f1d6c), SkBits2Float(0x3f96e656)); // 1.14284e+27f, 4.97913e+27f, 1.14154e+27f, 1.1073e+28f, 1.1789f 7502 path.lineTo(SkBits2Float(0x6a674231), SkBits2Float(0x6c0c3394)); // 6.98936e+25f, 6.77973e+26f 7503 path.cubicTo(SkBits2Float(0x6b12c63f), SkBits2Float(0x6c881439), SkBits2Float(0x6bba4ae5), SkBits2Float(0x6ced1e23), SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.77439e+26f, 1.31608e+27f, 4.50428e+26f, 2.29326e+27f, 1.14323e+27f, 3.11171e+27f 7504 path.close(); 7505 7506 SkPath path1(path); 7507 path.reset(); 7508 path.setFillType((SkPath::FillType) 0); 7509 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7510 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f 7511 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f 7512 path.conicTo(SkBits2Float(0x3e3e3e3e), SkBits2Float(0xafbcad20), SkBits2Float(0x78787878), SkBits2Float(0x78787829), SkBits2Float(0x78787878)); // 0.185784f, -3.432e-10f, 2.01583e+34f, 2.01582e+34f, 2.01583e+34f 7513 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x95066b78)); // 2.01583e+34f, -2.71459e-26f 7514 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f 7515 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f 7516 path.conicTo(SkBits2Float(0x3e3e3e3e), SkBits2Float(0xafbcad20), SkBits2Float(0x78787878), SkBits2Float(0x78787829), SkBits2Float(0x78787878)); // 0.185784f, -3.432e-10f, 2.01583e+34f, 2.01582e+34f, 2.01583e+34f 7517 path.lineTo(SkBits2Float(0x8787878f), SkBits2Float(0x87878787)); // -2.03922e-34f, -2.03922e-34f 7518 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7519 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7520 path.lineTo(SkBits2Float(0x6c105778), SkBits2Float(0x6d406b64)); // 6.97994e+26f, 3.72193e+27f 7521 path.cubicTo(SkBits2Float(0x7575756d), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x6d6d7575), SkBits2Float(0x6d6d6d6d)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 4.59312e+27f, 4.59251e+27f 7522 path.cubicTo(SkBits2Float(0x6d696d6d), SkBits2Float(0x026d6d6d), SkBits2Float(0x80bc6b6b), SkBits2Float(0xaebcdfd0), SkBits2Float(0x7878bcac), SkBits2Float(0x78787878)); // 4.51514e+27f, 1.74434e-37f, -1.73036e-38f, -8.58901e-11f, 2.01799e+34f, 2.01583e+34f 7523 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7524 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7525 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7526 path.lineTo(SkBits2Float(0xb4bcacbc), SkBits2Float(0xbcadbcbc)); // -3.51434e-07f, -0.0212082f 7527 path.moveTo(SkBits2Float(0xa03aacbc), SkBits2Float(0x757575a0)); // -1.5812e-19f, 3.11157e+32f 7528 path.close(); 7529 7530 SkPath path2(path); 7531 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7532 } 7533 7534 static void fuzz763_32(skiatest::Reporter* reporter, const char* filename) { 7535 SkPath path; 7536 path.setFillType((SkPath::FillType) 1); 7537 7538 SkPath path1(path); 7539 path.reset(); 7540 path.setFillType((SkPath::FillType) 0); 7541 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7542 path.cubicTo(SkBits2Float(0xdedcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0x55dcdcdc), SkBits2Float(0x29407d7f)); // -7.95742e+18f, -4.97339e+17f, -4.97339e+17f, -4.97339e+17f, 3.03551e+13f, 4.27414e-14f 7543 path.cubicTo(SkBits2Float(0x7b93ed4b), SkBits2Float(0x29521472), SkBits2Float(0xdfc83c28), SkBits2Float(0x1a3a834e), SkBits2Float(0x6855e84f), SkBits2Float(0xf2f22a80)); // 1.53616e+36f, 4.66471e-14f, -2.88569e+19f, 3.857e-23f, 4.0406e+24f, -9.59318e+30f 7544 path.moveTo(SkBits2Float(0xe0f2f210), SkBits2Float(0xc3f2eef2)); // -1.40049e+20f, -485.867f 7545 path.cubicTo(SkBits2Float(0x108ced7a), SkBits2Float(0x7bc00308), SkBits2Float(0x287a6a3a), SkBits2Float(0x242847ed), SkBits2Float(0x2bcb302a), SkBits2Float(0xf21003e8)); // 5.55862e-29f, 1.99396e+36f, 1.39008e-14f, 3.64901e-17f, 1.44374e-12f, -2.85252e+30f 7546 path.moveTo(SkBits2Float(0x556c0010), SkBits2Float(0x002a8768)); // 1.62178e+13f, 3.90567e-39f 7547 path.quadTo(SkBits2Float(0xf2f22021), SkBits2Float(0xf2f2f56e), SkBits2Float(0xf2f2f2f2), SkBits2Float(0xf22040d9)); // -9.59158e+30f, -9.62459e+30f, -9.6242e+30f, -3.17414e+30f 7548 path.lineTo(SkBits2Float(0xc013f2f2), SkBits2Float(0x0000294d)); // -2.3117f, 1.48159e-41f 7549 7550 SkPath path2(path); 7551 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7552 } 7553 7554 static void fuzz763_34(skiatest::Reporter* reporter, const char* filename) { 7555 SkPath path; 7556 path.setFillType((SkPath::FillType) 1); 7557 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7558 path.quadTo(SkBits2Float(0x63690f37), SkBits2Float(0x6d0a3d9b), SkBits2Float(0x00000000), SkBits2Float(0x6d3e3e3e)); // 4.29919e+21f, 2.67396e+27f, 0, 3.67984e+27f 7559 path.conicTo(SkBits2Float(0x6b9253fc), SkBits2Float(0x6c956a8b), SkBits2Float(0x6c6ac798), SkBits2Float(0x692a5d27), SkBits2Float(0x3e56eb72)); // 3.538e+26f, 1.44506e+27f, 1.13532e+27f, 1.28723e+25f, 0.209883f 7560 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0 7561 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7562 path.conicTo(SkBits2Float(0x6c8c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6cc8e82a), SkBits2Float(0x5b684b68)); // 1.35809e+27f, 0, 0, 1.94305e+27f, 6.53851e+16f 7563 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7564 path.close(); 7565 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7566 path.quadTo(SkBits2Float(0x641ae35f), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.14287e+22f, 0, 0, 0 7567 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0 7568 path.conicTo(SkBits2Float(0x6c6ba1fc), SkBits2Float(0x688c9eb1), SkBits2Float(0x6c6ac798), SkBits2Float(0x692a5d27), SkBits2Float(0x3f7fec32)); // 1.13945e+27f, 5.31247e+24f, 1.13532e+27f, 1.28723e+25f, 0.999698f 7569 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7570 path.close(); 7571 7572 SkPath path1(path); 7573 path.reset(); 7574 path.setFillType((SkPath::FillType) 0); 7575 path.moveTo(SkBits2Float(0x6c3e3e3e), SkBits2Float(0x586c79ff)); // 9.19959e+26f, 1.04003e+15f 7576 path.quadTo(SkBits2Float(0x6c6c4a6c), SkBits2Float(0x6c6c6c6c), SkBits2Float(0xc83e6c6c), SkBits2Float(0x3e313e3e)); // 1.14263e+27f, 1.14327e+27f, -194994, 0.173089f 7577 7578 SkPath path2(path); 7579 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7580 } 7581 7582 static void fuzz763_36(skiatest::Reporter* reporter, const char* filename) { 7583 SkPath path; 7584 path.setFillType((SkPath::FillType) 0); 7585 7586 SkPath path1(path); 7587 path.reset(); 7588 path.setFillType((SkPath::FillType) 0); 7589 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7590 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7591 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f 7592 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f 7593 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7594 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f 7595 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7596 path.close(); 7597 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7598 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7599 path.conicTo(SkBits2Float(0x212a081f), SkBits2Float(0x4b7bc003), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556839), SkBits2Float(0x2a8c555b)); // 5.7609e-19f, 1.64987e+07f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f 7600 path.conicTo(SkBits2Float(0xf42a212a), SkBits2Float(0x4b7bc003), SkBits2Float(0x2aed7a39), SkBits2Float(0x2108c08c), SkBits2Float(0x7b03211f)); // -5.39162e+31f, 1.64987e+07f, 4.21845e-13f, 4.63334e-19f, 6.80863e+35f 7601 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7602 path.close(); 7603 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7604 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 7605 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7606 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x03210807), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 5.76399e-19f, 4.73229e-37f, 6.14984e+25f, 75739 7607 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7608 path.close(); 7609 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7610 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3adf21), SkBits2Float(0x284f1a3a), SkBits2Float(0x213ab38a)); // 9.4456e-15f, -8.99754e-33f, 1.14965e-14f, 6.32569e-19f 7611 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7612 path.close(); 7613 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7614 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a20002a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000610354f, 2.50336e-13f 7615 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7616 path.close(); 7617 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7618 path.conicTo(SkBits2Float(0xed210830), SkBits2Float(0xc04b6a03), SkBits2Float(0x68297b27), SkBits2Float(0x55555b2d), SkBits2Float(0x2ab03a2a)); // -3.11481e+27f, -3.17835f, 3.20141e+24f, 1.46617e+13f, 3.13042e-13f 7619 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4341f20), SkBits2Float(0xecc52a22)); // 2.22225e-15f, 0.000713932f, -720.486f, -1.90686e+27f 7620 path.cubicTo(SkBits2Float(0x5921c25d), SkBits2Float(0x29523a70), SkBits2Float(0x555b2d68), SkBits2Float(0x1f212a8c), SkBits2Float(0x0321d90a), SkBits2Float(0x5b2d6829)); // 2.8457e+15f, 4.66801e-14f, 1.50618e+13f, 3.41283e-20f, 4.75628e-37f, 4.88097e+16f 7621 path.lineTo(SkBits2Float(0x1f2a2a8c), SkBits2Float(0x03210821)); // 3.60341e-20f, 4.7323e-37f 7622 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7623 path.close(); 7624 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7625 path.conicTo(SkBits2Float(0x2eed6a7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.07964e-10f, 9.4495e-15f, 0.000617492f, 2.58753e+09f, 0.00136978f 7626 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7627 path.close(); 7628 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7629 path.quadTo(SkBits2Float(0xe61d2a28), SkBits2Float(0x2a43962b), SkBits2Float(0x29272a81), SkBits2Float(0x2bb02a55)); // -1.85547e+23f, 1.73716e-13f, 3.71183e-14f, 1.25173e-12f 7630 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3ac52729), SkBits2Float(0xc4223b32), SkBits2Float(0x6c2a201f)); // 2.22225e-15f, 0.00150416f, -648.925f, 8.22676e+26f 7631 7632 SkPath path2(path); 7633 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7634 } 7635 7636 static void fuzz763_35(skiatest::Reporter* reporter, const char* filename) { 7637 SkPath path; 7638 path.setFillType((SkPath::FillType) 1); 7639 7640 SkPath path1(path); 7641 path.reset(); 7642 path.setFillType((SkPath::FillType) 0); 7643 path.moveTo(SkBits2Float(0x2aed2a8c), SkBits2Float(0x03210a1f)); // 4.21292e-13f, 4.73253e-37f 7644 path.conicTo(SkBits2Float(0x0000007b), SkBits2Float(0x7474747f), SkBits2Float(0x74747474), SkBits2Float(0x747474c4), SkBits2Float(0x74747474)); // 1.7236e-43f, 7.74709e+31f, 7.74708e+31f, 7.74712e+31f, 7.74708e+31f 7645 path.quadTo(SkBits2Float(0x74747474), SkBits2Float(0x74747474), SkBits2Float(0x20437474), SkBits2Float(0x43a52b02)); // 7.74708e+31f, 7.74708e+31f, 1.65557e-19f, 330.336f 7646 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f 7647 path.lineTo(SkBits2Float(0x4b7bd603), SkBits2Float(0x6cf33b6a)); // 1.65043e+07f, 2.3524e+27f 7648 path.conicTo(SkBits2Float(0x35778caa), SkBits2Float(0x0000002a), SkBits2Float(0x74742164), SkBits2Float(0x2a3a7474), SkBits2Float(0x4cc22157)); // 9.22194e-07f, 5.88545e-44f, 7.7368e+31f, 1.65605e-13f, 1.0178e+08f 7649 path.cubicTo(SkBits2Float(0x21479321), SkBits2Float(0x23434cc2), SkBits2Float(0x3a214793), SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a)); // 6.76185e-19f, 1.05872e-17f, 0.000615233f, 5.69738e-19f, 1.08774e-08f, 3.42981e+33f 7650 path.conicTo(SkBits2Float(0x0000002a), SkBits2Float(0x7474743e), SkBits2Float(0x74747474), SkBits2Float(0x74746474), SkBits2Float(0x74747474)); // 5.88545e-44f, 7.74706e+31f, 7.74708e+31f, 7.7451e+31f, 7.74708e+31f 7651 path.cubicTo(SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35), SkBits2Float(0x74744000), SkBits2Float(0x2974e874)); // 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f, 7.74059e+31f, 5.43805e-14f 7652 path.cubicTo(SkBits2Float(0x74647474), SkBits2Float(0x74747474), SkBits2Float(0x12ec7474), SkBits2Float(0x4cc22147), SkBits2Float(0x47932343), SkBits2Float(0x282a3a21)); // 7.24002e+31f, 7.74708e+31f, 1.49224e-27f, 1.0178e+08f, 75334.5f, 9.4495e-15f 7653 path.lineTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f 7654 path.close(); 7655 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f 7656 path.conicTo(SkBits2Float(0x3a323adf), SkBits2Float(0x4977291a), SkBits2Float(0x0000002a), SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 0.000679893f, 1.01237e+06f, 5.88545e-44f, 7.74706e+31f, 7.74708e+31f 7657 path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35)); // 7.74708e+31f, 7.74708e+31f, 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f 7658 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x742974e8)); // 7.74706e+31f, 5.3703e+31f 7659 path.cubicTo(SkBits2Float(0x74746474), SkBits2Float(0x74747474), SkBits2Float(0xd912ec74), SkBits2Float(0x553a3728), SkBits2Float(0x29202a8c), SkBits2Float(0x5555201b)); // 7.7451e+31f, 7.74708e+31f, -2.58471e+15f, 1.27966e+13f, 3.5564e-14f, 1.46459e+13f 7660 path.moveTo(SkBits2Float(0x31292768), SkBits2Float(0x212d2aff)); // 2.46151e-09f, 5.86716e-19f 7661 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a), SkBits2Float(0x00002a49)); // 5.69738e-19f, 1.08774e-08f, 3.42981e+33f, 1.51691e-41f 7662 path.moveTo(SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 7663 path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35)); // 7.74708e+31f, 7.74708e+31f, 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f 7664 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 7665 path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x43747474), SkBits2Float(0xa52b0220), SkBits2Float(0x47812a43), SkBits2Float(0x282a3a21)); // 7.74708e+31f, 7.74708e+31f, 244.455f, -1.48326e-16f, 66132.5f, 9.4495e-15f 7666 path.lineTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 7667 path.close(); 7668 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 7669 path.conicTo(SkBits2Float(0x3a323adf), SkBits2Float(0x19433b1a), SkBits2Float(0x5921e7fc), SkBits2Float(0x1f2a212a), SkBits2Float(0x35032108)); // 0.000679893f, 1.00932e-23f, 2.84828e+15f, 3.60263e-20f, 4.88494e-07f 7670 7671 SkPath path2(path); 7672 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7673 } 7674 7675 static void fuzz763_37(skiatest::Reporter* reporter, const char* filename) { 7676 SkPath path; 7677 path.setFillType((SkPath::FillType) 0); 7678 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2d3368)); // 1.59583e+13f, 4.87517e+16f 7679 path.conicTo(SkBits2Float(0x5b2d555b), SkBits2Float(0x68275b2d), SkBits2Float(0x21685527), SkBits2Float(0x0321082a), SkBits2Float(0x6ab485c0)); // 4.8789e+16f, 3.16127e+24f, 7.87174e-19f, 4.7323e-37f, 1.09119e+26f 7680 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f 7681 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 7682 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xee682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.50349e-13f, 3.27093e+24f, -1.79601e+28f, 1.64988e+07f 7683 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7684 path.conicTo(SkBits2Float(0x4b03213b), SkBits2Float(0xc07b2a08), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830), SkBits2Float(0x2a8c555b)); // 8.59372e+06f, -3.92444f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f 7685 path.conicTo(SkBits2Float(0x0321212a), SkBits2Float(0x4b7bd2c0), SkBits2Float(0xed7ac039), SkBits2Float(0x2f218c08), SkBits2Float(0x1f037b2a)); // 4.73517e-37f, 1.65035e+07f, -4.85023e+27f, 1.46926e-10f, 2.78422e-20f 7686 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 7687 path.close(); 7688 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 7689 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 7690 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7691 path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 75739 7692 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7693 path.close(); 7694 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7695 path.quadTo(SkBits2Float(0x28282a2a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.33502e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f 7696 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x081f2a21)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 4.78968e-34f 7697 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7698 path.close(); 7699 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7700 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0xdf93ed7a), SkBits2Float(0x1a3a803a), SkBits2Float(0xb38a294f), SkBits2Float(0x3ac2213a)); // 6.14991e+25f, -2.13186e+19f, 3.85675e-23f, -6.43364e-08f, 0.00148109f 7701 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7702 path.close(); 7703 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7704 path.conicTo(SkBits2Float(0xe62b291d), SkBits2Float(0x2a812a43), SkBits2Float(0x8ced093a), SkBits2Float(0xb38a5c5c), SkBits2Float(0x3ac2213a)); // -2.02071e+23f, 2.29443e-13f, -3.65212e-31f, -6.44293e-08f, 0.00148109f 7705 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7706 path.close(); 7707 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 7708 path.lineTo(SkBits2Float(0x8ced293a), SkBits2Float(0x5c5c5c5c)); // -3.65404e-31f, 2.48104e+17f 7709 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f 7710 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f 7711 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f 7712 path.lineTo(SkBits2Float(0x682d2952), SkBits2Float(0xee682103)); // 3.27093e+24f, -1.79601e+28f 7713 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a3b0355)); // 4.85282e+16f, 1.66101e-13f 7714 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f 7715 path.close(); 7716 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f 7717 path.conicTo(SkBits2Float(0x084b218c), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x5bf05568), SkBits2Float(0x1f2a8c55)); // 6.11275e-34f, 1.16348e+26f, 0.000209024f, 1.35296e+17f, 3.6115e-20f 7718 7719 SkPath path1(path); 7720 path.reset(); 7721 path.setFillType((SkPath::FillType) 0); 7722 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7723 path.cubicTo(SkBits2Float(0xbcb4bcac), SkBits2Float(0x000029ff), SkBits2Float(0x010000bc), SkBits2Float(0x00bcbc00), SkBits2Float(0xbebcbcbc), SkBits2Float(0xb6aebcae)); // -0.0220626f, 1.50654e-41f, 2.35104e-38f, 1.73325e-38f, -0.368627f, -5.20757e-06f 7724 7725 SkPath path2(path); 7726 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7727 } 7728 7729 static void fuzz763_38(skiatest::Reporter* reporter, const char* filename) { 7730 SkPath path; 7731 path.setFillType((SkPath::FillType) 0); 7732 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7733 path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0x5b292d11), SkBits2Float(0x212a8c55), SkBits2Float(0x555b2d2d), SkBits2Float(0x52525268)); // 6.53477e+16f, 4.76188e+16f, 5.7784e-19f, 1.50617e+13f, 2.25831e+11f 7734 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7735 path.close(); 7736 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 7737 path.close(); 7738 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 7739 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x2ac05252), SkBits2Float(0x727fb721)); // 4.80216e+30f, 2.25832e+11f, 3.41632e-13f, 5.06496e+30f 7740 path.lineTo(SkBits2Float(0x73727322), SkBits2Float(0x555b2d29)); // 1.92088e+31f, 1.50617e+13f 7741 path.lineTo(SkBits2Float(0xab2a212e), SkBits2Float(0x7a27872a)); // -6.04422e-13f, 2.17464e+35f 7742 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f 7743 path.quadTo(SkBits2Float(0x52524852), SkBits2Float(0x72525228), SkBits2Float(0x72727272), SkBits2Float(0x3a727272)); // 2.25789e+11f, 4.16584e+30f, 4.80216e+30f, 0.000924862f 7744 path.lineTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f 7745 path.close(); 7746 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f 7747 path.quadTo(SkBits2Float(0x2a292827), SkBits2Float(0x962b0080), SkBits2Float(0x5252752a), SkBits2Float(0x72725252)); // 1.50241e-13f, -1.38134e-25f, 2.25977e+11f, 4.79967e+30f 7748 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79967e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 7749 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda000072), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.00732e+15f, 2.25867e+11f, 2.25831e+11f 7750 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f 7751 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f 7752 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f 7753 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f 7754 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f 7755 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 7756 path.close(); 7757 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 7758 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x3a727272), SkBits2Float(0x28273ac2), SkBits2Float(0x00802a29)); // 4.80216e+30f, 0.000924862f, 9.2831e-15f, 1.17701e-38f 7759 path.lineTo(SkBits2Float(0x52752a96), SkBits2Float(0x72525252)); // 2.63245e+11f, 4.16585e+30f 7760 path.quadTo(SkBits2Float(0x72525272), SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272)); // 4.16586e+30f, 2.25966e+11f, 2.25831e+11f, 4.80216e+30f 7761 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f 7762 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 7763 path.close(); 7764 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 7765 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f 7766 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x72525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 4.16585e+30f 7767 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x72727252), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada)); // 4.80216e+30f, 4.80215e+30f, -9.04113e+15f, 2.25867e+11f 7768 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 7769 path.close(); 7770 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 7771 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f 7772 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f 7773 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f 7774 path.moveTo(SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 2.34994e+11f, 2.25831e+11f 7775 path.close(); 7776 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 7777 path.close(); 7778 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 7779 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 7780 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f 7781 path.quadTo(SkBits2Float(0x52525272), SkBits2Float(0x3b3b0052), SkBits2Float(0x5b2d553a), SkBits2Float(0x68556829)); // 2.25832e+11f, 0.00285341f, 4.87889e+16f, 4.03114e+24f 7782 7783 SkPath path1(path); 7784 path.reset(); 7785 path.setFillType((SkPath::FillType) 0); 7786 path.moveTo(SkBits2Float(0x52528c55), SkBits2Float(0x29215252)); // 2.26074e+11f, 3.58206e-14f 7787 7788 SkPath path2(path); 7789 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7790 } 7791 7792 static void fuzz763_41(skiatest::Reporter* reporter, const char* filename) { 7793 SkPath path; 7794 path.setFillType((SkPath::FillType) 0); 7795 7796 SkPath path1(path); 7797 path.reset(); 7798 path.setFillType((SkPath::FillType) 0); 7799 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7800 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f 7801 path.quadTo(SkBits2Float(0x00057272), SkBits2Float(0x72ff0000), SkBits2Float(0xba405e72), SkBits2Float(0x031b0074)); // 5.00233e-40f, 1.01016e+31f, -0.000733829f, 4.55509e-37f 7802 path.lineTo(SkBits2Float(0x664af700), SkBits2Float(0x56397d39)); // 2.39619e+23f, 5.09869e+13f 7803 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300e4), SkBits2Float(0x257c0c9f), SkBits2Float(0x72400006)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 3.80295e+30f 7804 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x030000ff), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ec4000)); // -0.000836826f, 3.7617e-37f, 1.17894e+32f, -8.92527e+24f 7805 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f 7806 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x08727272), SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // -1.83687e-37f, 7.29588e-34f, 4.09355e-34f, 4.09355e-34f 7807 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f 7808 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f 7809 path.conicTo(SkBits2Float(0x72728c08), SkBits2Float(0x5b5e7272), SkBits2Float(0x000074ba), SkBits2Float(0x03f8e300), SkBits2Float(0x5aff00e8)); // 4.80414e+30f, 6.26133e+16f, 4.18736e-41f, 1.46282e-36f, 3.58886e+16f 7810 path.quadTo(SkBits2Float(0x00800039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 1.1755e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f 7811 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f 7812 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f 7813 path.lineTo(SkBits2Float(0x666d0100), SkBits2Float(0x726efe62)); // 2.79805e+23f, 4.73376e+30f 7814 path.lineTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f 7815 path.close(); 7816 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f 7817 path.conicTo(SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x475afc16), SkBits2Float(0x170100ad), SkBits2Float(0x01008000)); // 4.80216e+30f, -3.47604e+31f, 56060.1f, 4.1683e-25f, 2.36017e-38f 7818 path.quadTo(SkBits2Float(0x72057272), SkBits2Float(0x8c7a3472), SkBits2Float(0x72727272), SkBits2Float(0x00f6475e)); // 2.64319e+30f, -1.92751e-31f, 4.80216e+30f, 2.26171e-38f 7819 path.moveTo(SkBits2Float(0x6d106d43), SkBits2Float(0x6efe6266)); // 2.79362e+27f, 3.93641e+28f 7820 path.quadTo(SkBits2Float(0x72727a05), SkBits2Float(0xba5b7272), SkBits2Float(0x03000074), SkBits2Float(0x5aff00e8)); // 4.80274e+30f, -0.000837124f, 3.76163e-37f, 3.58886e+16f 7821 path.quadTo(SkBits2Float(0x00da0039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 2.00202e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f 7822 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f 7823 path.lineTo(SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // -4.56078e+36f, 50176.2f 7824 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62766d01)); // 1.03774e-38f, 1.13644e+21f 7825 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f 7826 7827 SkPath path2(path); 7828 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7829 } 7830 7831 static void fuzz763_40(skiatest::Reporter* reporter, const char* filename) { 7832 SkPath path; 7833 path.setFillType((SkPath::FillType) 1); 7834 7835 SkPath path1(path); 7836 path.reset(); 7837 path.setFillType((SkPath::FillType) 0); 7838 path.moveTo(SkBits2Float(0x10190004), SkBits2Float(0x7272727a)); // 3.01739e-29f, 4.80216e+30f 7839 path.quadTo(SkBits2Float(0xf3db5e64), SkBits2Float(0x5b97fc16), SkBits2Float(0x000039fc), SkBits2Float(0x01008000)); // -3.47604e+31f, 8.55598e+16f, 2.08009e-41f, 2.36017e-38f 7840 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x41720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 15.1251f 7841 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f 7842 path.lineTo(SkBits2Float(0x01000000), SkBits2Float(0x10010004)); // 2.35099e-38f, 2.54408e-29f 7843 path.conicTo(SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16), SkBits2Float(0x0000d07d), SkBits2Float(0x01008000)); // 4.80216e+30f, -3.47604e+31f, 3.58785e+06f, 7.47915e-41f, 2.36017e-38f 7844 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f 7845 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f 7846 path.lineTo(SkBits2Float(0x72000000), SkBits2Float(0x5b5e72b4)); // 2.5353e+30f, 6.26136e+16f 7847 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 1.13998e-35f, 4.80216e+30f, 6.26133e+16f 7848 path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01727200), SkBits2Float(0x72727a00), SkBits2Float(0x5e8d7272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 4.45302e-38f, 4.80274e+30f, 5.09617e+18f 7849 path.moveTo(SkBits2Float(0x72008972), SkBits2Float(0x458fe705)); // 2.54594e+30f, 4604.88f 7850 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xe8727272), SkBits2Float(0xba5b5e03), SkBits2Float(0x03000074)); // 1.73224e+35f, -4.5797e+24f, -0.00083682f, 3.76163e-37f 7851 path.lineTo(SkBits2Float(0xf3dbff00), SkBits2Float(0x00397d16)); // -3.48598e+31f, 5.2795e-39f 7852 path.cubicTo(SkBits2Float(0x7a101900), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x0197fc16), SkBits2Float(0x200c2010), SkBits2Float(0x20203620)); // 1.87049e+35f, 4.80216e+30f, -3.47604e+31f, 5.58304e-38f, 1.18691e-19f, 1.35704e-19f 7853 7854 SkPath path2(path); 7855 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7856 } 7857 7858 static void fuzz763_39(skiatest::Reporter* reporter, const char* filename) { 7859 SkPath path; 7860 path.setFillType((SkPath::FillType) 0); 7861 7862 SkPath path1(path); 7863 path.reset(); 7864 path.setFillType((SkPath::FillType) 0); 7865 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7866 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f 7867 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f 7868 path.lineTo(SkBits2Float(0x664aff00), SkBits2Float(0x56397d39)); // 2.39655e+23f, 5.09869e+13f 7869 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300ff), SkBits2Float(0x257c0c9f), SkBits2Float(0x72787257)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 4.92099e+30f 7870 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ecff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.95346e+24f 7871 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f 7872 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x72727272), SkBits2Float(0x724adf00), SkBits2Float(0x00397d39)); // -1.83687e-37f, 4.80216e+30f, 4.01828e+30f, 5.27954e-39f 7873 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x16f3abab), SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // 1.73224e+35f, 3.93671e-25f, -4.56078e+36f, 50176.2f 7874 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62767201)); // 1.03774e-38f, 1.13653e+21f 7875 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f 7876 7877 SkPath path2(path); 7878 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7879 } 7880 7881 7882 static void fuzz763_42(skiatest::Reporter* reporter, const char* filename) { 7883 SkPath path; 7884 path.setFillType((SkPath::FillType) 0); 7885 7886 SkPath path1(path); 7887 path.reset(); 7888 path.setFillType((SkPath::FillType) 0); 7889 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7890 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x05720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 1.13789e-35f 7891 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f 7892 path.lineTo(SkBits2Float(0x724aff00), SkBits2Float(0x56397d39)); // 4.02075e+30f, 5.09869e+13f 7893 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xfa8d00ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a)); // 1.73224e+35f, -3.66067e+35f, 2.10289e-16f, 4.80216e+30f 7894 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8e0ff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.50011e+24f 7895 path.conicTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d), SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x4aff0072)); // 0.000231069f, 2.53975e+30f, 1.73224e+35f, 4.80216e+30f, 8.3559e+06f 7896 path.quadTo(SkBits2Float(0x00397d39), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x385e7272)); // 5.27954e-39f, 1.13998e-35f, 4.80216e+30f, 5.30355e-05f 7897 path.quadTo(SkBits2Float(0x057200ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.1379e-35f, 2.10289e-16f, 4.80216e+30f, 6.26133e+16f 7898 path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01000400), SkBits2Float(0x72727a10), SkBits2Float(0x5e647272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 2.35128e-38f, 4.80275e+30f, 4.11534e+18f 7899 path.quadTo(SkBits2Float(0x2b2d16f3), SkBits2Float(0x0039fc4d), SkBits2Float(0x68800000), SkBits2Float(0x0100fafa)); // 6.14938e-13f, 5.32513e-39f, 4.8357e+24f, 2.369e-38f 7900 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f 7901 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f 7902 path.lineTo(SkBits2Float(0x72720000), SkBits2Float(0xff725b5e)); // 4.7933e+30f, -3.22148e+38f 7903 path.moveTo(SkBits2Float(0x72720572), SkBits2Float(0x5b5e2572)); // 4.79373e+30f, 6.25286e+16f 7904 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x25727272), SkBits2Float(0x72728c7a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 2.10289e-16f, 4.80417e+30f, 6.26133e+16f 7905 path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01000400), SkBits2Float(0x72727a10), SkBits2Float(0x5e827272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 2.35128e-38f, 4.80275e+30f, 4.69985e+18f 7906 path.quadTo(SkBits2Float(0x97fc16f3), SkBits2Float(0x0039fc5b), SkBits2Float(0x00f6472e), SkBits2Float(0x01008000)); // -1.62909e-24f, 5.32515e-39f, 2.26171e-38f, 2.36017e-38f 7907 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f 7908 7909 SkPath path2(path); 7910 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7911 } 7912 7913 static void fuzz763_43(skiatest::Reporter* reporter, const char* filename) { 7914 SkPath path; 7915 path.setFillType((SkPath::FillType) 1); 7916 7917 SkPath path1(path); 7918 path.reset(); 7919 path.setFillType((SkPath::FillType) 0); 7920 path.moveTo(SkBits2Float(0x5c386c3a), SkBits2Float(0x4e691a3e)); // 2.07642e+17f, 9.77703e+08f 7921 path.cubicTo(SkBits2Float(0x6f69f9f5), SkBits2Float(0x18ff8791), SkBits2Float(0x2492263c), SkBits2Float(0xbc6fdb48), SkBits2Float(0xc2f82107), SkBits2Float(0x729a18e1)); // 7.24122e+28f, 6.60528e-24f, 6.33822e-17f, -0.0146397f, -124.065f, 6.10442e+30f 7922 path.cubicTo(SkBits2Float(0x07d729d1), SkBits2Float(0xdea6db48), SkBits2Float(0xcd1dfb88), SkBits2Float(0x90826769), SkBits2Float(0x1c20e5a4), SkBits2Float(0xa4c3ba9b)); // 3.23742e-34f, -6.01164e+18f, -1.65657e+08f, -5.14353e-29f, 5.32364e-22f, -8.48839e-17f 7923 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 7924 path.close(); 7925 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 7926 path.cubicTo(SkBits2Float(0xdeea1d6e), SkBits2Float(0xc7774804), SkBits2Float(0x27cf0dcf), SkBits2Float(0x6ae8b99f), SkBits2Float(0x24ac3260), SkBits2Float(0x062fa93c)); // -8.43488e+18f, -63304, 5.7469e-15f, 1.40674e+26f, 7.46784e-17f, 3.30382e-35f 7927 path.lineTo(SkBits2Float(0x438a0b9c), SkBits2Float(0x60a1d2c8)); // 276.091f, 9.32848e+19f 7928 path.quadTo(SkBits2Float(0xe13fb902), SkBits2Float(0x07ee536f), SkBits2Float(0x971d8ac1), SkBits2Float(0x2f9f174b)); // -2.21041e+20f, 3.58593e-34f, -5.09046e-25f, 2.89385e-10f 7929 path.lineTo(SkBits2Float(0x0f2cf5d8), SkBits2Float(0xe271654c)); // 8.5276e-30f, -1.11324e+21f 7930 path.lineTo(SkBits2Float(0xe6cf24d2), SkBits2Float(0xd9537742)); // -4.89105e+23f, -3.72015e+15f 7931 path.cubicTo(SkBits2Float(0x1aaaee04), SkBits2Float(0x9e3b804c), SkBits2Float(0x84cba87d), SkBits2Float(0x4e0e8ccc), SkBits2Float(0x2aec611a), SkBits2Float(0x7ae4b639)); // 7.06949e-23f, -9.92623e-21f, -4.78798e-36f, 5.97898e+08f, 4.19894e-13f, 5.9377e+35f 7932 path.conicTo(SkBits2Float(0x73357921), SkBits2Float(0x6f163021), SkBits2Float(0x70ea542c), SkBits2Float(0xe008f404), SkBits2Float(0x1f6c5e52)); // 1.43778e+31f, 4.64809e+28f, 5.8017e+29f, -3.94741e+19f, 5.0053e-20f 7933 path.lineTo(SkBits2Float(0xda45ad4e), SkBits2Float(0xedce4a04)); // -1.39103e+16f, -7.98042e+27f 7934 path.lineTo(SkBits2Float(0xac0e45da), SkBits2Float(0x8f632841)); // -2.02182e-12f, -1.11997e-29f 7935 path.lineTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 7936 path.close(); 7937 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 7938 path.quadTo(SkBits2Float(0xf35c4ad5), SkBits2Float(0x0692f251), SkBits2Float(0x69632126), SkBits2Float(0xb927af67)); // -1.74534e+31f, 5.52751e-35f, 1.71614e+25f, -0.000159917f 7939 path.moveTo(SkBits2Float(0x6534bff9), SkBits2Float(0x434a9986)); // 5.3348e+22f, 202.6f 7940 path.quadTo(SkBits2Float(0x37c603e5), SkBits2Float(0xa0683953), SkBits2Float(0x751915e4), SkBits2Float(0x831c911a)); // 2.36053e-05f, -1.96701e-19f, 1.94059e+32f, -4.60108e-37f 7941 path.cubicTo(SkBits2Float(0xba4f10f1), SkBits2Float(0x5a7571df), SkBits2Float(0x4ec67459), SkBits2Float(0x33c58827), SkBits2Float(0x10b78ccb), SkBits2Float(0xedbd2748)); // -0.000789895f, 1.72716e+16f, 1.66476e+09f, 9.19829e-08f, 7.23977e-29f, -7.31752e+27f 7942 path.cubicTo(SkBits2Float(0x6d06f06a), SkBits2Float(0xe30465cf), SkBits2Float(0xc5458fe7), SkBits2Float(0xca488dc4), SkBits2Float(0x38f9021c), SkBits2Float(0x3e8d58db)); // 2.6101e+27f, -2.44231e+21f, -3160.99f, -3.28587e+06f, 0.000118736f, 0.276069f 7943 7944 SkPath path2(path); 7945 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7946 } 7947 7948 static void fuzz763_44(skiatest::Reporter* reporter, const char* filename) { 7949 SkPath path; 7950 path.setFillType((SkPath::FillType) 1); 7951 path.moveTo(SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 3.36945e+36f, 1.01083e+37f 7952 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0x7ccaca6d), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 8.4236e+36f, 0, 0 7953 path.lineTo(SkBits2Float(0x7d7d7d7d), SkBits2Float(0x00000000)); // 2.10591e+37f, 0 7954 path.quadTo(SkBits2Float(0x7ccacab0), SkBits2Float(0x7d1817f4), SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 8.42364e+36f, 1.26354e+37f, 3.36945e+36f, 1.01083e+37f 7955 path.close(); 7956 7957 SkPath path1(path); 7958 path.reset(); 7959 path.setFillType((SkPath::FillType) 0); 7960 path.moveTo(SkBits2Float(0x109d0000), SkBits2Float(0xff7bc000)); // 6.19256e-29f, -3.34633e+38f 7961 path.conicTo(SkBits2Float(0x979797ed), SkBits2Float(0x3a214797), SkBits2Float(0x28aa217a), SkBits2Float(0x01007272), SkBits2Float(0x00000072)); // -9.7965e-25f, 0.000615233f, 1.88883e-14f, 2.3592e-38f, 1.59748e-43f 7962 path.quadTo(SkBits2Float(0x72728302), SkBits2Float(0x8b727272), SkBits2Float(0x72727272), SkBits2Float(0xc00308f6)); // 4.80344e+30f, -4.66936e-32f, 4.80216e+30f, -2.04742f 7963 path.conicTo(SkBits2Float(0x7f52753a), SkBits2Float(0x8072ffff), SkBits2Float(0x67af2103), SkBits2Float(0x7d2a6847), SkBits2Float(0x7d7d7d7d)); // 2.79747e+38f, -1.05611e-38f, 1.65405e+24f, 1.41569e+37f, 2.10591e+37f 7964 7965 SkPath path2(path); 7966 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 7967 } 7968 7969 static void fuzz763_45(skiatest::Reporter* reporter, const char* filename) { 7970 SkPath path; 7971 path.setFillType((SkPath::FillType) 0); 7972 7973 SkPath path1(path); 7974 path.reset(); 7975 path.setFillType((SkPath::FillType) 0); 7976 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7977 path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 2.28705e+35f, 6.40969e-10f 7978 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x74303030), SkBits2Float(0x74303030), SkBits2Float(0x30303030), SkBits2Float(0x74303030)); // 6.40969e-10f, 5.58363e+31f, 5.58363e+31f, 6.40969e-10f, 5.58363e+31f 7979 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 7980 path.moveTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 7981 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f 7982 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a743030), SkBits2Float(0x74303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.16974e+35f, 5.58363e+31f, 6.40969e-10f 7983 path.lineTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f 7984 path.close(); 7985 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f 7986 path.lineTo(SkBits2Float(0x7f303030), SkBits2Float(0x7a303030)); // 2.34194e+38f, 2.28705e+35f 7987 path.conicTo(SkBits2Float(0x77303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0xf9303030), SkBits2Float(0x7a303030)); // 3.57352e+33f, 6.40969e-10f, 6.40969e-10f, -5.71764e+34f, 2.28705e+35f 7988 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 7989 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 7990 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 7991 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 7992 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 6.40969e-10f 7993 path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 6.40969e-10f 7994 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 7995 path.moveTo(SkBits2Float(0x77303030), SkBits2Float(0xff303030)); // 3.57352e+33f, -2.34194e+38f 7996 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7f773030), SkBits2Float(0x7a7a3030), SkBits2Float(0x7a303030)); // 6.40969e-10f, 6.40969e-10f, 3.2857e+38f, 3.24763e+35f, 2.28705e+35f 7997 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x77303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.57352e+33f, 6.40969e-10f 7998 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7b303030), SkBits2Float(0x73303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 9.14822e+35f, 1.39591e+31f, 6.40969e-10f 7999 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a7a3030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 3.24763e+35f 8000 SkPath path2(path); 8001 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8002 } 8003 8004 static void fuzz763_46(skiatest::Reporter* reporter, const char* filename) { 8005 SkPath path; 8006 path.setFillType((SkPath::FillType) 0); 8007 8008 SkPath path1(path); 8009 path.reset(); 8010 path.setFillType((SkPath::FillType) 0); 8011 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8012 path.conicTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x44263030), SkBits2Float(0x44304430), SkBits2Float(0x4c444430)); // 785.067f, 785.067f, 664.753f, 705.065f, 5.145e+07f 8013 path.moveTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444)); // 785.067f, 785.067f 8014 path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x44444444), SkBits2Float(0x30303030), SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x4444444c)); // 6.40969e-10f, 785.067f, 6.40969e-10f, 785.067f, 785.067f, 785.067f 8015 SkPath path2(path); 8016 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8017 } 8018 8019 static void fuzz763_47(skiatest::Reporter* reporter, const char* filename) { 8020 SkPath path; 8021 path.setFillType((SkPath::FillType) 1); 8022 8023 SkPath path1(path); 8024 path.reset(); 8025 path.setFillType((SkPath::FillType) 0); 8026 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8027 path.cubicTo(SkBits2Float(0x7272728e), SkBits2Float(0x52527272), SkBits2Float(0x2d555252), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29), SkBits2Float(0x2a212a8c)); // 4.80217e+30f, 2.25966e+11f, 1.21259e-11f, 4.03114e+24f, 1.50617e+13f, 1.43144e-13f 8028 path.conicTo(SkBits2Float(0x00296808), SkBits2Float(0x00000002), SkBits2Float(0x52525252), SkBits2Float(0x72007272), SkBits2Float(0x52527272)); // 3.80257e-39f, 2.8026e-45f, 2.25831e+11f, 2.54416e+30f, 2.25966e+11f 8029 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8030 path.close(); 8031 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8032 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 1.43144e-13f, 4.79393e+30f 8033 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x5974fa80), SkBits2Float(0x00747474), SkBits2Float(0x59585264)); // 4.80216e+30f, 4.30971e+15f, 1.06947e-38f, 3.80557e+15f 8034 path.cubicTo(SkBits2Float(0x64007474), SkBits2Float(0x088c5852), SkBits2Float(0x80808021), SkBits2Float(0x8c808080), SkBits2Float(0x80802108), SkBits2Float(0x80808080)); // 9.4783e+21f, 8.44671e-34f, -1.18009e-38f, -1.97989e-31f, -1.17668e-38f, -1.1801e-38f 8035 path.quadTo(SkBits2Float(0x80807d80), SkBits2Float(0x80808080), SkBits2Float(0xff7f0000), SkBits2Float(0x80808080)); // -1.18e-38f, -1.1801e-38f, -3.38953e+38f, -1.1801e-38f 8036 path.quadTo(SkBits2Float(0x80808080), SkBits2Float(0x80808080), SkBits2Float(0xed842b00), SkBits2Float(0x7252ff6d)); // -1.1801e-38f, -1.1801e-38f, -5.113e+27f, 4.17924e+30f 8037 path.quadTo(SkBits2Float(0x72577200), SkBits2Float(0x55525352), SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 4.26733e+30f, 1.44535e+13f, 1.43144e-13f, 4.79393e+30f 8038 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x6f740080), SkBits2Float(0x8c556874), SkBits2Float(0x2982ffff)); // 4.80216e+30f, 7.55149e+28f, -1.64404e-31f, 5.81757e-14f 8039 8040 SkPath path2(path); 8041 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8042 } 8043 8044 static void fuzz763_48(skiatest::Reporter* reporter, const char* filename) { 8045 SkPath path; 8046 path.setFillType((SkPath::FillType) 1); 8047 8048 SkPath path1(path); 8049 path.reset(); 8050 path.setFillType((SkPath::FillType) 0); 8051 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8052 path.lineTo(SkBits2Float(0xed0081bc), SkBits2Float(0x1b2d8040)); // -2.48568e+27f, 1.43517e-22f 8053 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f 8054 path.close(); 8055 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f 8056 path.conicTo(SkBits2Float(0x662d5576), SkBits2Float(0x2d804066), SkBits2Float(0x8068291b), SkBits2Float(0x740315ff), SkBits2Float(0x74747474)); // 2.04636e+23f, 1.45805e-11f, -9.56564e-39f, 4.15428e+31f, 7.74708e+31f 8057 path.cubicTo(SkBits2Float(0x762d0529), SkBits2Float(0x72525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x52727252)); // 8.77316e+32f, 4.16585e+30f, 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 2.60325e+11f 8058 path.lineTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f 8059 path.close(); 8060 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8061 path.close(); 8062 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8063 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52524872), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.2579e+11f, 4.16585e+30f, 4.80216e+30f 8064 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x80406666), SkBits2Float(0x68291b2d), SkBits2Float(0x0315ff80)); // 4.80215e+30f, -5.91421e-39f, 3.19432e+24f, 4.40805e-37f 8065 path.cubicTo(SkBits2Float(0x74747474), SkBits2Float(0x7b722974), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x72720052), SkBits2Float(0x72727272)); // 7.74708e+31f, 1.25738e+36f, 3.08006e+16f, 2.25831e+11f, 4.79333e+30f, 4.80216e+30f 8066 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8067 path.close(); 8068 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8069 path.quadTo(SkBits2Float(0x72727227), SkBits2Float(0x72727272), SkBits2Float(0x74727272), SkBits2Float(0x55747421)); // 4.80214e+30f, 4.80216e+30f, 7.68345e+31f, 1.67987e+13f 8070 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8071 path.close(); 8072 path.moveTo(SkBits2Float(0x724b0000), SkBits2Float(0x00725f72)); // 4.02083e+30f, 1.05035e-38f 8073 path.lineTo(SkBits2Float(0x52525252), SkBits2Float(0x72725252)); // 2.25831e+11f, 4.79967e+30f 8074 path.quadTo(SkBits2Float(0x26727272), SkBits2Float(0x0303a525), SkBits2Float(0x52005c03), SkBits2Float(0x72525252)); // 8.41157e-16f, 3.8687e-37f, 1.37825e+11f, 4.16585e+30f 8075 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x1ff07255), SkBits2Float(0x2a8c5572), SkBits2Float(0x21082a21)); // 4.80216e+30f, 1.01833e-19f, 2.49283e-13f, 4.61343e-19f 8076 path.lineTo(SkBits2Float(0x2a2a3a21), SkBits2Float(0x29212828)); // 1.51192e-13f, 3.5784e-14f 8077 8078 SkPath path2(path); 8079 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8080 } 8081 8082 static void fuzz763_49(skiatest::Reporter* reporter, const char* filename) { 8083 SkPath path; 8084 path.setFillType((SkPath::FillType) 0); 8085 8086 SkPath path1(path); 8087 path.reset(); 8088 path.setFillType((SkPath::FillType) 0); 8089 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8090 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x78303030), SkBits2Float(0x78787881), SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 6.40969e-10f, 1.42941e+34f, 2.01583e+34f, 2.01583e+34f, 6.40969e-10f 8091 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 8092 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 8093 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 8094 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x78787878), SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 6.40969e-10f, 2.01583e+34f, 2.01583e+34f, 2.01583e+34f 8095 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8096 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8097 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8098 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8099 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8100 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8101 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8102 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8103 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8104 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8105 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8106 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8107 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8108 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x7878788d)); // 2.01583e+34f, 2.01584e+34f 8109 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 2.01583e+34f, 6.40969e-10f 8110 8111 SkPath path2(path); 8112 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8113 } 8114 8115 static void fuzz763_50(skiatest::Reporter* reporter, const char* filename) { 8116 SkPath path; 8117 path.setFillType((SkPath::FillType) 1); 8118 path.moveTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0 8119 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x74fc5b97), SkBits2Float(0x7d458fe4)); // 0, 0, 0, 1.59951e+32f, 1.64128e+37f 8120 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0 8121 path.lineTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0 8122 path.close(); 8123 path.moveTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0 8124 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8125 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0 8126 path.close(); 8127 8128 SkPath path1(path); 8129 path.reset(); 8130 path.setFillType((SkPath::FillType) 0); 8131 8132 SkPath path2(path); 8133 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8134 } 8135 8136 static void fuzz763_51(skiatest::Reporter* reporter, const char* filename) { 8137 SkPath path; 8138 path.setFillType((SkPath::FillType) 1); 8139 8140 SkPath path1(path); 8141 path.reset(); 8142 path.setFillType((SkPath::FillType) 0); 8143 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8144 path.quadTo(SkBits2Float(0x868b5aae), SkBits2Float(0x626c45ab), SkBits2Float(0xefea1ffe), SkBits2Float(0x0029fc76)); // -5.24192e-35f, 1.08961e+21f, -1.44916e+29f, 3.85582e-39f 8145 path.moveTo(SkBits2Float(0xfacbff01), SkBits2Float(0x56fc5b97)); // -5.29604e+35f, 1.38735e+14f 8146 path.cubicTo(SkBits2Float(0x7d4559c9), SkBits2Float(0xad801c39), SkBits2Float(0xfbe2091a), SkBits2Float(0x7268e394), SkBits2Float(0x7c800079), SkBits2Float(0xa1d75590)); // 1.63953e+37f, -1.45644e-11f, -2.34729e+36f, 4.61284e+30f, 5.31699e+36f, -1.45916e-18f 8147 8148 SkPath path2(path); 8149 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8150 } 8151 8152 static void fuzz763_52(skiatest::Reporter* reporter, const char* filename) { 8153 SkPath path; 8154 path.setFillType((SkPath::FillType) 1); 8155 8156 SkPath path1(path); 8157 path.reset(); 8158 path.setFillType((SkPath::FillType) 0); 8159 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8160 path.quadTo(SkBits2Float(0x29ff4bae), SkBits2Float(0xa1d75590), SkBits2Float(0x9fd6f6c3), SkBits2Float(0x70621ede)); // 1.13374e-13f, -1.45916e-18f, -9.10408e-20f, 2.79924e+29f 8161 path.quadTo(SkBits2Float(0x57a839d3), SkBits2Float(0x1a80d34b), SkBits2Float(0x0147a31b), SkBits2Float(0xff7fffff)); // 3.69933e+14f, 5.32809e-23f, 3.66675e-38f, -3.40282e+38f 8162 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8163 path.close(); 8164 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8165 path.conicTo(SkBits2Float(0x75757568), SkBits2Float(0x7575755e), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75756575)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11077e+32f 8166 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8167 path.close(); 8168 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8169 path.conicTo(SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75917575), SkBits2Float(0x75757575)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.68782e+32f, 3.11156e+32f 8170 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8171 path.close(); 8172 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8173 path.conicTo(SkBits2Float(0x75757575), SkBits2Float(0x7575758f), SkBits2Float(0x7f757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575)); // 3.11156e+32f, 3.11157e+32f, 3.26271e+38f, 3.11156e+32f, 3.11156e+32f 8174 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8175 path.close(); 8176 8177 SkPath path2(path); 8178 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8179 } 8180 8181 static void fuzz763_53(skiatest::Reporter* reporter, const char* filename) { 8182 SkPath path; 8183 path.setFillType((SkPath::FillType) 1); 8184 path.moveTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0 8185 path.lineTo(SkBits2Float(0x74fc5b97), SkBits2Float(0x77df944a)); // 1.59951e+32f, 9.06945e+33f 8186 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf8fbe3ff)); // 0, -4.08716e+34f 8187 path.lineTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0 8188 path.close(); 8189 8190 SkPath path1(path); 8191 path.reset(); 8192 path.setFillType((SkPath::FillType) 0); 8193 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8194 path.quadTo(SkBits2Float(0x45ab86ae), SkBits2Float(0xd6d6626c), SkBits2Float(0xd6d6d6d6), SkBits2Float(0x7644d6d6)); // 5488.83f, -1.17859e+14f, -1.18109e+14f, 9.98093e+32f 8195 path.moveTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f 8196 path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x64fed6d6), SkBits2Float(0x7644ef40), SkBits2Float(0x290877fc), SkBits2Float(0x447644b8), SkBits2Float(0x80fafc76)); // -1.18109e+14f, 3.76076e+22f, 9.98577e+32f, 3.03021e-14f, 985.074f, -2.30494e-38f 8197 path.conicTo(SkBits2Float(0x87808080), SkBits2Float(0x764400ae), SkBits2Float(0x764400fc), SkBits2Float(0x450080fc), SkBits2Float(0x3636366c)); // -1.93348e-34f, 9.93852e+32f, 9.93858e+32f, 2056.06f, 2.71518e-06f 8198 path.lineTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f 8199 path.close(); 8200 path.moveTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f 8201 path.conicTo(SkBits2Float(0x7644626c), SkBits2Float(0x088912fc), SkBits2Float(0xae8744ef), SkBits2Float(0x76571f5a), SkBits2Float(0x45ab86fc)); // 9.95788e+32f, 8.24985e-34f, -6.15133e-11f, 1.0908e+33f, 5488.87f 8202 path.conicTo(SkBits2Float(0x4064fe62), SkBits2Float(0x290877ef), SkBits2Float(0x780080b8), SkBits2Float(0x553c7644), SkBits2Float(0x644eae87)); // 3.57803f, 3.03021e-14f, 1.04254e+34f, 1.2951e+13f, 1.52504e+22f 8203 path.lineTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f 8204 path.close(); 8205 8206 SkPath path2(path); 8207 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8208 } 8209 8210 // hangs 654939 8211 static void fuzz763_54(skiatest::Reporter* reporter, const char* filename) { 8212 SkPath path; 8213 path.setFillType((SkPath::FillType) 0); 8214 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8215 path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0xb3b32d11), SkBits2Float(0xb3b3b3b3), SkBits2Float(0x5b29b3b3), SkBits2Float(0x212a8c55)); // 6.53477e+16f, -8.34353e-08f, -8.36802e-08f, 4.77669e+16f, 5.7784e-19f 8216 path.conicTo(SkBits2Float(0x68555b2d), SkBits2Float(0x28296869), SkBits2Float(0x5b252a08), SkBits2Float(0x5d68392a), SkBits2Float(0x29282780)); // 4.03018e+24f, 9.40402e-15f, 4.64896e+16f, 1.04584e+18f, 3.73378e-14f 8217 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8218 path.close(); 8219 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8220 path.cubicTo(SkBits2Float(0x52727272), SkBits2Float(0x72727252), SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.60326e+11f, 4.80215e+30f, 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f 8221 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5252525a), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // -4.79387e+14f, 2.25831e+11f, 4.16585e+30f, 4.80216e+30f 8222 path.quadTo(SkBits2Float(0x48525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 215369, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f 8223 path.quadTo(SkBits2Float(0xdada007b), SkBits2Float(0x5252525a), SkBits2Float(0x72675252), SkBits2Float(0x72727272)); // -3.0681e+16f, 2.25831e+11f, 4.5818e+30f, 4.80216e+30f 8224 path.quadTo(SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 2.25831e+11f, 3.36289e-15f, 4.80216e+30f, 4.80216e+30f 8225 path.quadTo(SkBits2Float(0x1c292172), SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa), SkBits2Float(0x8c556a4b)); // 5.59606e-22f, 1.99397e+36f, -7.05861e-23f, -1.64409e-31f 8226 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f 8227 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8228 path.close(); 8229 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8230 path.close(); 8231 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8232 path.quadTo(SkBits2Float(0x72725570), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79991e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 8233 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x555bb672), SkBits2Float(0x29686968), SkBits2Float(0x252a081f)); // 4.80215e+30f, 1.50985e+13f, 5.16058e-14f, 1.47479e-16f 8234 path.moveTo(SkBits2Float(0x5d68392a), SkBits2Float(0x01002780)); // 1.04584e+18f, 2.35382e-38f 8235 path.moveTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f 8236 path.quadTo(SkBits2Float(0x5adada00), SkBits2Float(0xa5252652), SkBits2Float(0x727272ad), SkBits2Float(0xda007b72)); // 3.08006e+16f, -1.43245e-16f, 4.80218e+30f, -9.04113e+15f 8237 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f 8238 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8239 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x74217472), SkBits2Float(0x005b5574), SkBits2Float(0x72680000)); // 4.80216e+30f, 5.11671e+31f, 8.38768e-39f, 4.59523e+30f 8240 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada)); // 4.80216e+30f, 2.25831e+11f, 1.13368e-38f, 2.34994e+11f 8241 path.lineTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f 8242 path.close(); 8243 8244 SkPath path1(path); 8245 path.reset(); 8246 path.setFillType((SkPath::FillType) 0); 8247 8248 SkPath path2(path); 8249 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8250 } 8251 8252 8253 // afl crash 8254 static void fuzz763_55(skiatest::Reporter* reporter, const char* filename) { 8255 SkPath path; 8256 path.setFillType((SkPath::FillType) 0); 8257 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f 8258 path.lineTo(SkBits2Float(0x55555568), SkBits2Float(0x55555555)); // 1.46602e+13f, 1.46602e+13f 8259 path.lineTo(SkBits2Float(0x98989898), SkBits2Float(0x55989898)); // -3.94452e-24f, 2.09726e+13f 8260 path.lineTo(SkBits2Float(0xf6f65555), SkBits2Float(0x101006f6)); // -2.49812e+33f, 2.84044e-29f 8261 path.quadTo(SkBits2Float(0xdca33f10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf621f6f6), SkBits2Float(0xf70ff6f6)); // -3.67598e+17f, -2.50452e+33f, -8.21259e+32f, -2.91995e+33f 8262 path.lineTo(SkBits2Float(0x9400f6f6), SkBits2Float(0x10530000)); // -6.51105e-27f, 4.16124e-29f 8263 path.quadTo(SkBits2Float(0x0f101010), SkBits2Float(0x00101010), SkBits2Float(0xf610f720), SkBits2Float(0xf6f6f6f6)); // 7.10284e-30f, 1.47513e-39f, -7.35062e+32f, -2.50452e+33f 8264 path.lineTo(SkBits2Float(0x105352f6), SkBits2Float(0x1cf6ff10)); // 4.16763e-29f, 1.63448e-21f 8265 path.lineTo(SkBits2Float(0xf6f6220a), SkBits2Float(0x003700f6)); // -2.49608e+33f, 5.0513e-39f 8266 path.cubicTo(SkBits2Float(0x0000001e), SkBits2Float(0x00fff4f6), SkBits2Float(0xff101064), SkBits2Float(0xf6b6ac7f), SkBits2Float(0xf6f629f6), SkBits2Float(0x10f6f6f6)); // 4.2039e-44f, 2.35059e-38f, -1.91494e+38f, -1.85253e+33f, -2.4964e+33f, 9.74104e-29f 8267 path.quadTo(SkBits2Float(0x10101007), SkBits2Float(0x10f7fd10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf6f645e0)); // 2.84113e-29f, 9.78142e-29f, -2.50452e+33f, -2.4975e+33f 8268 path.lineTo(SkBits2Float(0xed9ef6f6), SkBits2Float(0x53535353)); // -6.14965e+27f, 9.07636e+11f 8269 path.lineTo(SkBits2Float(0x53006cf6), SkBits2Float(0x53295353)); // 5.51584e+11f, 7.27247e+11f 8270 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f 8271 path.close(); 8272 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f 8273 path.lineTo(SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5353d9f6)); // -2.50452e+33f, 9.09895e+11f 8274 8275 SkPath path1(path); 8276 path.reset(); 8277 path.setFillType((SkPath::FillType) 0); 8278 8279 SkPath path2(path); 8280 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8281 } 8282 8283 // 656149 8284 static void fuzz763_56(skiatest::Reporter* reporter, const char* filename) { 8285 SkPath path; 8286 path.setFillType((SkPath::FillType) 0); 8287 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8288 path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0xb3b32d11), SkBits2Float(0xb3b3b3b3), SkBits2Float(0x5b29b3b3), SkBits2Float(0x72725255)); // 6.53477e+16f, -8.34353e-08f, -8.36802e-08f, 4.77669e+16f, 4.79967e+30f 8289 path.quadTo(SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f 8290 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x00005252)); // -4.79387e+14f, 3.08006e+16f, 2.25831e+11f, 2.9531e-41f 8291 path.conicTo(SkBits2Float(0xadada525), SkBits2Float(0x52525ab4), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x52527272)); // -1.97412e-11f, 2.25866e+11f, 2.25831e+11f, 4.80216e+30f, 2.25966e+11f 8292 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8293 path.close(); 8294 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8295 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255), SkBits2Float(0xda007b72)); // 4.79967e+30f, 4.80216e+30f, 4.80215e+30f, -9.04113e+15f 8296 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f 8297 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8298 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa)); // 1.99397e+36f, -7.05861e-23f 8299 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f 8300 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8301 path.close(); 8302 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8303 path.close(); 8304 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8305 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 8306 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x26525ada), SkBits2Float(0x72ada525)); // 4.80215e+30f, -9.04113e+15f, 7.29815e-16f, 6.87879e+30f 8307 path.quadTo(SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x72727252)); // 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 4.80215e+30f 8308 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72722772), SkBits2Float(0x72727272)); // 2.25966e+11f, 2.25831e+11f, 4.79636e+30f, 4.80216e+30f 8309 path.quadTo(SkBits2Float(0x74727272), SkBits2Float(0x55747421), SkBits2Float(0x0000005b), SkBits2Float(0x72727268)); // 7.68345e+31f, 1.67987e+13f, 1.27518e-43f, 4.80216e+30f 8310 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x72557272)); // 2.25966e+11f, 2.25831e+11f, 4.80216e+30f, 4.22775e+30f 8311 path.quadTo(SkBits2Float(0x5adada72), SkBits2Float(0x52525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272)); // 3.08009e+16f, 2.25831e+11f, 4.79967e+30f, 4.80216e+30f 8312 8313 SkPath path1(path); 8314 path.reset(); 8315 path.setFillType((SkPath::FillType) 0); 8316 8317 SkPath path2(path); 8318 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8319 } 8320 8321 static void fuzz763_57(skiatest::Reporter* reporter, const char* filename) { 8322 SkPath path; 8323 path.setFillType((SkPath::FillType) 0); 8324 8325 SkPath path1(path); 8326 path.reset(); 8327 path.setFillType((SkPath::FillType) 0); 8328 path.moveTo(SkBits2Float(0x68546829), SkBits2Float(0x555b2d29)); // 4.01225e+24f, 1.50617e+13f 8329 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0x4b7b2108)); // 3.60404e-20f, 1.6458e+07f 8330 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f 8331 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f 8332 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xce682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.50349e-13f, 3.27093e+24f, -9.73619e+08f, 1.64988e+07f 8333 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x3b2a8c55)); // 4.85282e+16f, 0.00260236f 8334 path.lineTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f 8335 path.close(); 8336 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f 8337 path.conicTo(SkBits2Float(0xd2c00321), SkBits2Float(0xc0394b7b), SkBits2Float(0x8c08ed7a), SkBits2Float(0x211f2f2a), SkBits2Float(0x704b7b03)); // -4.12343e+11f, -2.89523f, -1.05485e-31f, 5.39337e-19f, 2.51897e+29f 8338 path.cubicTo(SkBits2Float(0x2d6829ed), SkBits2Float(0x5b2d555b), SkBits2Float(0x68275b2d), SkBits2Float(0x21685527), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 1.3197e-11f, 4.8789e+16f, 3.16127e+24f, 7.87174e-19f, 4.7323e-37f, 6.14991e+25f 8339 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f 8340 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8341 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x228cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xee682103), SkBits2Float(0x287bc055)); // 5.76397e-19f, 3.82003e-18f, 3.27093e+24f, -1.79601e+28f, 1.3975e-14f 8342 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 8343 path.conicTo(SkBits2Float(0x4b03213b), SkBits2Float(0xc07b2a08), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830), SkBits2Float(0x2a8c555b)); // 8.59372e+06f, -3.92444f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f 8344 path.conicTo(SkBits2Float(0x0321212a), SkBits2Float(0x4b7bd2c0), SkBits2Float(0xed7ac039), SkBits2Float(0x2f2a8c08), SkBits2Float(0x7b03211f)); // 4.73517e-37f, 1.65035e+07f, -4.85023e+27f, 1.55112e-10f, 6.80863e+35f 8345 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8346 path.close(); 8347 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8348 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 8349 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8350 path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4797ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 77787 8351 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8352 path.close(); 8353 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8354 path.quadTo(SkBits2Float(0x2828102a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.32938e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f 8355 path.cubicTo(SkBits2Float(0x683f2d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x211f2a21)); // 3.61123e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 5.39271e-19f 8356 path.lineTo(SkBits2Float(0x3a803adf), SkBits2Float(0x8a294f1a)); // 0.000978317f, -8.15193e-33f 8357 path.quadTo(SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x093a2a81), SkBits2Float(0x5c5c8ced)); // 3.49912e-14f, 1.73993e-13f, 2.24089e-33f, 2.48318e+17f 8358 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8359 path.close(); 8360 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8361 path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x293a2a81), SkBits2Float(0x5c5c8ced), SkBits2Float(0x5c5c6e5c)); // 0.00148109f, 3.49912e-14f, 1.73993e-13f, 4.13372e-14f, 2.48318e+17f, 2.48183e+17f 8362 path.lineTo(SkBits2Float(0x1f212a8c), SkBits2Float(0xc0032108)); // 3.41283e-20f, -2.04889f 8363 path.lineTo(SkBits2Float(0xed847b4b), SkBits2Float(0x2d552829)); // -5.12513e+27f, 1.21166e-11f 8364 path.conicTo(SkBits2Float(0x552d5b5b), SkBits2Float(0x3b5a6839), SkBits2Float(0x5b2df068), SkBits2Float(0x2a212a1f), SkBits2Float(0x532a8cef)); // 1.1913e+13f, 0.00333263f, 4.89595e+16f, 1.43143e-13f, 7.32509e+11f 8365 8366 SkPath path2(path); 8367 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8368 } 8369 8370 static void fuzzhang_1(skiatest::Reporter* reporter, const char* filename) { 8371 SkPath path; 8372 path.setFillType((SkPath::FillType) 1); 8373 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8374 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x668ece09), SkBits2Float(0x00000000), SkBits2Float(0x6751c81a), SkBits2Float(0x61c4b0fb)); // 0, 0, 3.37188e+23f, 0, 9.90666e+23f, 4.53539e+20f 8375 path.conicTo(SkBits2Float(0x66f837a9), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f823406)); // 5.86087e+23f, 0, 0, 0, 1.01721f 8376 path.close(); 8377 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8378 path.quadTo(SkBits2Float(0x675b1bfe), SkBits2Float(0x00000000), SkBits2Float(0x67d76c42), SkBits2Float(0x6292c469)); // 1.03471e+24f, 0, 2.03461e+24f, 1.35369e+21f 8379 path.cubicTo(SkBits2Float(0x6a16df68), SkBits2Float(0x651a2f15), SkBits2Float(0x6c1e7f31), SkBits2Float(0x67a1f9b4), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 4.55985e+25f, 4.55071e+22f, 7.66444e+26f, 1.52981e+24f, 0, 5.14279e+25f 8380 path.conicTo(SkBits2Float(0x680dcb75), SkBits2Float(0x68dd898d), SkBits2Float(0x681a434a), SkBits2Float(0x6871046b), SkBits2Float(0x3fea0440)); // 2.67843e+24f, 8.36944e+24f, 2.91394e+24f, 4.55269e+24f, 1.82825f 8381 path.quadTo(SkBits2Float(0x679e1b26), SkBits2Float(0x687703c4), SkBits2Float(0x00000000), SkBits2Float(0x687d2968)); // 1.49327e+24f, 4.66598e+24f, 0, 4.78209e+24f 8382 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8383 path.close(); 8384 8385 SkPath path1(path); 8386 path.reset(); 8387 path.setFillType((SkPath::FillType) 0); 8388 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8389 path.cubicTo(SkBits2Float(0x535353ec), SkBits2Float(0x98989898), SkBits2Float(0x98989898), SkBits2Float(0xf207f36e), SkBits2Float(0xf3f2f2f2), SkBits2Float(0xed3a9781)); // 9.07646e+11f, -3.94452e-24f, -3.94452e-24f, -2.69278e+30f, -3.84968e+31f, -3.60921e+27f 8390 path.quadTo(SkBits2Float(0xf8f8c0ed), SkBits2Float(0xf8f8f8f8), SkBits2Float(0x9f9f9f9f), SkBits2Float(0x3014149f)); // -4.03626e+34f, -4.03981e+34f, -6.76032e-20f, 5.38714e-10f 8391 8392 SkPath path2(path); 8393 testPathOp(reporter, path1, path2, (SkPathOp) 0, filename); 8394 } 8395 8396 static void release_13(skiatest::Reporter* reporter, const char* filename) { 8397 SkPath path; 8398 path.setFillType((SkPath::FillType) 1); 8399 path.setFillType(SkPath::kEvenOdd_FillType); 8400 path.moveTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f 8401 path.lineTo(SkBits2Float(0xd43a056e), SkBits2Float(0xd4851696)); // -3.19582e+12f, -4.57288e+12f 8402 path.quadTo(SkBits2Float(0xd3d48e79), SkBits2Float(0xd49fb136), SkBits2Float(0x00000000), SkBits2Float(0xd4d4d4d4)); // -1.82585e+12f, -5.48698e+12f, 0, -7.31283e+12f 8403 path.quadTo(SkBits2Float(0xd3d06670), SkBits2Float(0xd4a0bb38), SkBits2Float(0xd41d628f), SkBits2Float(0xd472c531)); // -1.79014e+12f, -5.52269e+12f, -2.70385e+12f, -4.17076e+12f 8404 path.lineTo(SkBits2Float(0xd43a0559), SkBits2Float(0xd485168e)); // -3.19581e+12f, -4.57287e+12f 8405 path.lineTo(SkBits2Float(0xd446958b), SkBits2Float(0xd4810278)); // -3.41165e+12f, -4.43274e+12f 8406 path.lineTo(SkBits2Float(0xd443884a), SkBits2Float(0xd488cf65)); // -3.35922e+12f, -4.70076e+12f 8407 path.quadTo(SkBits2Float(0xd47efa09), SkBits2Float(0xd49fd72a), SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -4.38047e+12f, -5.49208e+12f, -5.71218e+12f, -6.33007e+12f 8408 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f 8409 path.lineTo(SkBits2Float(0xd459d4d4), SkBits2Float(0xd4c4d4d4)); // -3.74231e+12f, -6.76307e+12f 8410 path.lineTo(SkBits2Float(0xd440daf9), SkBits2Float(0xd4c632d3)); // -3.31323e+12f, -6.81005e+12f 8411 path.lineTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f 8412 path.close(); 8413 path.moveTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f 8414 path.lineTo(SkBits2Float(0xd4422174), SkBits2Float(0xd4d02069)); // -3.33514e+12f, -7.15118e+12f 8415 path.lineTo(SkBits2Float(0xd440daa3), SkBits2Float(0xd4c632d9)); // -3.31321e+12f, -6.81005e+12f 8416 path.lineTo(SkBits2Float(0xd41017bc), SkBits2Float(0xd4cb99b6)); // -2.47549e+12f, -6.99566e+12f 8417 path.lineTo(SkBits2Float(0xd442213b), SkBits2Float(0xd4d02067)); // -3.33512e+12f, -7.15117e+12f 8418 path.lineTo(SkBits2Float(0xd442d4d4), SkBits2Float(0xd4d4d4d4)); // -3.34718e+12f, -7.31283e+12f 8419 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f 8420 path.close(); 8421 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8422 path.lineTo(SkBits2Float(0xd484e02c), SkBits2Float(0xd45fafcd)); // -4.56557e+12f, -3.84291e+12f 8423 path.lineTo(SkBits2Float(0xd462c867), SkBits2Float(0xd45655f7)); // -3.8961e+12f, -3.68226e+12f 8424 path.lineTo(SkBits2Float(0xd45ac463), SkBits2Float(0xd45ac505)); // -3.75839e+12f, -3.75843e+12f 8425 path.lineTo(SkBits2Float(0xd43d2fa9), SkBits2Float(0xd43d2fb5)); // -3.25019e+12f, -3.2502e+12f 8426 path.lineTo(SkBits2Float(0xd41d6287), SkBits2Float(0xd472c52a)); // -2.70385e+12f, -4.17076e+12f 8427 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xd3db1b95), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, -1.88212e+12f, 0, 0 8428 path.quadTo(SkBits2Float(0xd4b7efac), SkBits2Float(0x00000000), SkBits2Float(0xd4d0e88f), SkBits2Float(0xd40b8b46)); // -6.32e+12f, 0, -7.17804e+12f, -2.39735e+12f 8429 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, 0 8430 path.lineTo(SkBits2Float(0xdcdc154b), SkBits2Float(0x00000000)); // -4.95583e+17f, 0 8431 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4c4d477)); // -7.31283e+12f, -6.76303e+12f 8432 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d442)); // -7.31283e+12f, -7.31275e+12f 8433 path.lineTo(SkBits2Float(0xd4d4a691), SkBits2Float(0xd4d4d442)); // -7.30662e+12f, -7.31275e+12f 8434 path.lineTo(SkBits2Float(0xd454d4d4), SkBits2Float(0xd4d4aa30)); // -3.65641e+12f, -7.30711e+12f 8435 path.lineTo(SkBits2Float(0xd4bd9def), SkBits2Float(0xd4d43df0)); // -6.51519e+12f, -7.29258e+12f 8436 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f 8437 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f 8438 path.lineTo(SkBits2Float(0xd4bab953), SkBits2Float(0xd4c4d48e)); // -6.41579e+12f, -6.76304e+12f 8439 path.lineTo(SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -5.71218e+12f, -6.33007e+12f 8440 path.lineTo(SkBits2Float(0xd4ae61eb), SkBits2Float(0xd4ae61f4)); // -5.99174e+12f, -5.99174e+12f 8441 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8442 path.close(); 8443 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8444 path.lineTo(SkBits2Float(0xd446965c), SkBits2Float(0xd4810237)); // -3.4117e+12f, -4.4327e+12f 8445 path.lineTo(SkBits2Float(0xd45ac549), SkBits2Float(0xd45ac55f)); // -3.75845e+12f, -3.75846e+12f 8446 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8447 path.close(); 8448 path.moveTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f 8449 path.lineTo(SkBits2Float(0xd4cde20a), SkBits2Float(0xd434bb57)); // -7.07408e+12f, -3.10495e+12f 8450 path.lineTo(SkBits2Float(0xd4c75ffe), SkBits2Float(0xd46f215d)); // -6.85047e+12f, -4.10823e+12f 8451 path.lineTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f 8452 path.close(); 8453 8454 SkPath path1(path); 8455 path.reset(); 8456 path.setFillType((SkPath::FillType) 0); 8457 path.setFillType(SkPath::kWinding_FillType); 8458 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8459 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xa5a50000), SkBits2Float(0xd4d4a5a5), SkBits2Float(0xd4d4d4d4)); // 0, -2.86229e-16f, -7.3065e+12f, -7.31283e+12f 8460 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4), SkBits2Float(0xd4d41dd4)); // -7.31283e+12f, -7.31283e+12f, -7.14103e+12f, -7.28827e+12f 8461 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d432d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4a5a5d4)); // -7.31283e+12f, -7.29109e+12f, -7.31283e+12f, -5.69161e+12f 8462 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, 0 8463 path.moveTo(SkBits2Float(0xa5a5a500), SkBits2Float(0xd4d4d4a5)); // -2.87347e-16f, -7.31281e+12f 8464 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x2ad4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4)); // -7.31283e+12f, 3.78064e-13f, -7.31283e+12f, -7.14103e+12f 8465 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f 8466 path.quadTo(SkBits2Float(0xd4d40000), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.28426e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f 8467 8468 SkPath path2(path); 8469 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8470 } 8471 8472 static void fuzzhang_2(skiatest::Reporter* reporter, const char* filename) { 8473 SkPath path; 8474 path.setFillType((SkPath::FillType) 0); 8475 path.setFillType(SkPath::kWinding_FillType); 8476 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8477 path.quadTo(SkBits2Float(0xe0e02972), SkBits2Float(0xe0e060e0), SkBits2Float(0x728e4603), SkBits2Float(0x72727272)); // -1.29221e+20f, -1.29345e+20f, 5.63603e+30f, 4.80216e+30f 8478 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8479 path.close(); 8480 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8481 path.quadTo(SkBits2Float(0x68720052), SkBits2Float(0x52527372), SkBits2Float(0x00527252), SkBits2Float(0x728e4601)); // 4.57127e+24f, 2.2597e+11f, 7.57152e-39f, 5.63603e+30f 8482 path.quadTo(SkBits2Float(0x52ec7272), SkBits2Float(0x6265527f), SkBits2Float(0x8e460152), SkBits2Float(0x72ff8072)); // 5.07766e+11f, 1.05756e+21f, -2.4406e-30f, 1.01215e+31f 8483 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8484 path.close(); 8485 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8486 path.lineTo(SkBits2Float(0x52626552), SkBits2Float(0x72727272)); // 2.43091e+11f, 4.80216e+30f 8487 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x62727272), SkBits2Float(0x39393939), SkBits2Float(0x728bc739)); // 4.80216e+30f, 1.11809e+21f, 0.000176643f, 5.53719e+30f 8488 path.cubicTo(SkBits2Float(0x72728092), SkBits2Float(0x72727260), SkBits2Float(0x4d727272), SkBits2Float(0x5252522a), SkBits2Float(0x72735252), SkBits2Float(0x72707272)); // 4.80325e+30f, 4.80215e+30f, 2.54224e+08f, 2.2583e+11f, 4.81948e+30f, 4.76254e+30f 8489 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x56727272), SkBits2Float(0x72720152), SkBits2Float(0x72727270)); // 4.80216e+30f, 6.66433e+13f, 4.79341e+30f, 4.80216e+30f 8490 path.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460300), SkBits2Float(0x72727272), SkBits2Float(0x52525272)); // 2.25894e+11f, -2.44068e-30f, 4.80216e+30f, 2.25832e+11f 8491 path.conicTo(SkBits2Float(0xb5727272), SkBits2Float(0x7f2b727f), SkBits2Float(0x607272ff), SkBits2Float(0x72727276), SkBits2Float(0x2a527272)); // -9.03186e-07f, 2.27892e+38f, 6.98812e+19f, 4.80216e+30f, 1.86915e-13f 8492 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8493 path.close(); 8494 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8495 path.lineTo(SkBits2Float(0x72727272), SkBits2Float(0x52525f72)); // 4.80216e+30f, 2.25886e+11f 8496 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8497 path.close(); 8498 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8499 path.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x64655252), SkBits2Float(0x72c1c152), SkBits2Float(0x72727272)); // 2.60326e+11f, 1.69209e+22f, 7.67543e+30f, 4.80216e+30f 8500 8501 SkPath path1(path); 8502 path.reset(); 8503 path.setFillType((SkPath::FillType) 0); 8504 path.setFillType(SkPath::kWinding_FillType); 8505 8506 SkPath path2(path); 8507 testPathOpFail(reporter, path1, path2, (SkPathOp) 1, filename); 8508 } 8509 8510 static void fuzzhang_3(skiatest::Reporter* reporter, const char* filename) { 8511 SkPath path; 8512 path.setFillType((SkPath::FillType) 0); 8513 path.setFillType(SkPath::kWinding_FillType); 8514 8515 SkPath path1(path); 8516 path.reset(); 8517 path.setFillType((SkPath::FillType) 0); 8518 path.setFillType(SkPath::kWinding_FillType); 8519 path.moveTo(SkBits2Float(0x46090052), SkBits2Float(0x7270726c)); // 8768.08f, 4.76254e+30f 8520 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8521 path.close(); 8522 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8523 path.lineTo(SkBits2Float(0x77727272), SkBits2Float(0x52520072)); // 4.91741e+33f, 2.25488e+11f 8524 path.lineTo(SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // 8768.08f, 4.80219e+30f 8525 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f 8526 path.lineTo(SkBits2Float(0x6c460900), SkBits2Float(0x72727072)); // 9.57639e+26f, 4.802e+30f 8527 path.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x72943603), SkBits2Float(0x72777272), SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // -1.29345e+20f, 5.87124e+30f, 4.90119e+30f, 2.368e+17f, 8768.08f, 4.80219e+30f 8528 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f 8529 path.lineTo(SkBits2Float(0x0052ca00), SkBits2Float(0x728e4603)); // 7.60297e-39f, 5.63603e+30f 8530 path.quadTo(SkBits2Float(0xff727272), SkBits2Float(0x52527272), SkBits2Float(0x39392072), SkBits2Float(0xe0393939)); // -3.22267e+38f, 2.25966e+11f, 0.000176551f, -5.3387e+19f 8531 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8532 path.close(); 8533 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8534 path.cubicTo(SkBits2Float(0xdada7272), SkBits2Float(0x2dff7272), SkBits2Float(0x767272f0), SkBits2Float(0x72727272), SkBits2Float(0x21727f72), SkBits2Float(0x0b210929)); // -3.07437e+16f, 2.9041e-11f, 1.22936e+33f, 4.80216e+30f, 8.21615e-19f, 3.10144e-32f 8535 path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x72a5d6d6), SkBits2Float(0x72553872), SkBits2Float(0xdada7072), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // -1.18109e+14f, 6.56957e+30f, 4.22327e+30f, -3.07426e+16f, 2.25831e+11f, 4.80215e+30f 8536 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f 8537 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xca005252), SkBits2Float(0x46030052), SkBits2Float(0x7272728e)); // 4.80216e+30f, -2.10242e+06f, 8384.08f, 4.80217e+30f 8538 path.quadTo(SkBits2Float(0x7272ff72), SkBits2Float(0x20725252), SkBits2Float(0x39393939), SkBits2Float(0xd76ee039)); // 4.81307e+30f, 2.05254e-19f, 0.000176643f, -2.62647e+14f 8539 path.cubicTo(SkBits2Float(0xdada7272), SkBits2Float(0x2dff7272), SkBits2Float(0x767272f0), SkBits2Float(0x72727272), SkBits2Float(0x21727f72), SkBits2Float(0x0b210929)); // -3.07437e+16f, 2.9041e-11f, 1.22936e+33f, 4.80216e+30f, 8.21615e-19f, 3.10144e-32f 8540 path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x72a5d6d6), SkBits2Float(0x72553872), SkBits2Float(0xdada7072), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // -1.18109e+14f, 6.56957e+30f, 4.22327e+30f, -3.07426e+16f, 2.25831e+11f, 4.80215e+30f 8541 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f 8542 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8543 path.quadTo(SkBits2Float(0x72667254), SkBits2Float(0x00000040), SkBits2Float(0x00a70155), SkBits2Float(0x726800ff)); // 4.56447e+30f, 8.96831e-44f, 1.5337e-38f, 4.59531e+30f 8544 path.quadTo(SkBits2Float(0x7b727272), SkBits2Float(0xad000c52), SkBits2Float(0x1c10adad), SkBits2Float(0x72728d8a)); // 1.25886e+36f, -7.27869e-12f, 4.78701e-22f, 4.80425e+30f 8545 path.quadTo(SkBits2Float(0xff056546), SkBits2Float(0x727205ff), SkBits2Float(0x524b5aff), SkBits2Float(0x64005252)); // -1.77313e+38f, 4.79377e+30f, 2.18351e+11f, 9.46846e+21f 8546 path.quadTo(SkBits2Float(0x72524872), SkBits2Float(0xdada7272), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // 4.16508e+30f, -3.07437e+16f, 2.25831e+11f, 4.80215e+30f 8547 path.quadTo(SkBits2Float(0x72724172), SkBits2Float(0xdad10072), SkBits2Float(0x52524b5a), SkBits2Float(0x725b8000)); // 4.79837e+30f, -2.94144e+16f, 2.25802e+11f, 4.34765e+30f 8548 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8549 path.quadTo(SkBits2Float(0x72728372), SkBits2Float(0x00000040), SkBits2Float(0xf6a70147), SkBits2Float(0xc2c2c256)); // 4.80347e+30f, 8.96831e-44f, -1.69363e+33f, -97.3796f 8550 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8551 path.close(); 8552 path.moveTo(SkBits2Float(0x7a787a7a), SkBits2Float(0x7a3a7a7a)); // 3.22543e+35f, 2.42063e+35f 8553 path.lineTo(SkBits2Float(0x8f4603e0), SkBits2Float(0x72727272)); // -9.7629e-30f, 4.80216e+30f 8554 path.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x46090052), SkBits2Float(0x7270726c), SkBits2Float(0x60e04372)); // 1.1796e-38f, 8768.08f, 4.76254e+30f, 1.29279e+20f 8555 path.moveTo(SkBits2Float(0x943603e0), SkBits2Float(0x77727272)); // -9.18942e-27f, 4.91741e+33f 8556 path.quadTo(SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce), SkBits2Float(0x5252ec72)); // 2.368e+17f, 8768.08f, 4.80219e+30f, 2.26478e+11f 8557 8558 SkPath path2(path); 8559 testPathOpFail(reporter, path1, path2, (SkPathOp) 3, filename); 8560 } 8561 8562 8563 static struct TestDesc failTests[] = { 8564 TEST(fuzzhang_3), 8565 TEST(fuzzhang_2), 8566 TEST(release_13), 8567 TEST(fuzzhang_1), 8568 TEST(fuzz763_57), 8569 TEST(fuzz763_56), 8570 TEST(fuzz763_55), 8571 TEST(fuzz763_54), 8572 TEST(fuzz763_53), 8573 TEST(fuzz763_52), 8574 TEST(fuzz763_51), 8575 TEST(fuzz763_50), 8576 TEST(fuzz763_49), 8577 TEST(fuzz763_48), 8578 TEST(fuzz763_47), 8579 TEST(fuzz763_46), 8580 TEST(fuzz763_45), 8581 TEST(fuzz763_44), 8582 TEST(fuzz763_43), 8583 TEST(fuzz763_42), 8584 TEST(fuzz763_41), 8585 TEST(fuzz763_40), 8586 TEST(fuzz763_39), 8587 TEST(fuzz763_38), 8588 TEST(fuzz763_37), 8589 TEST(fuzz763_36), 8590 TEST(fuzz763_35), 8591 TEST(fuzz763_34), 8592 TEST(fuzz763_33), 8593 TEST(fuzz763_32), 8594 TEST(fuzz763_31), 8595 TEST(fuzz763_30), 8596 TEST(fuzz763_29), 8597 TEST(fuzz763_28), 8598 TEST(fuzz763_27), 8599 TEST(fuzz763_26), 8600 TEST(fuzz763_25), 8601 TEST(fuzz763_24), 8602 TEST(fuzz763_23), 8603 TEST(fuzz763_22), 8604 TEST(fuzz763_21), 8605 TEST(fuzz763_20), 8606 TEST(fuzz763_19), 8607 TEST(fuzz763_18), 8608 TEST(fuzz763_17), 8609 TEST(fuzz763_16), 8610 TEST(fuzz763_15), 8611 TEST(fuzz763_14), 8612 TEST(fuzz763_13), 8613 TEST(fuzz763_12), 8614 TEST(fuzz763_11), 8615 TEST(fuzz763_10), 8616 TEST(kfuzz2), 8617 TEST(fuzz763_7), 8618 TEST(fuzz763_6), 8619 TEST(fuzz763_2c), 8620 TEST(fuzz763_2b), 8621 TEST(fuzz763_2a), 8622 TEST(fuzz763_5a), 8623 TEST(fuzz763_3a), 8624 TEST(fuzz763_1a), 8625 TEST(fuzz763_1b), 8626 TEST(fuzz763_1c), 8627 TEST(fuzz763_2), 8628 TEST(fuzz763_5), 8629 TEST(fuzz763_3), 8630 TEST(fuzz763_4), 8631 TEST(fuzz763_9), 8632 TEST(fuzz1450_1), 8633 TEST(fuzz1450_0), 8634 TEST(bug597926_0), 8635 TEST(fuzz535151), 8636 TEST(fuzz753_91), 8637 TEST(fuzz714), 8638 TEST(fuzz487a), 8639 TEST(fuzz433), 8640 TEST(fuzz1), 8641 TEST(fuzz487b), 8642 TEST(fuzz433b), 8643 TEST(bufferOverflow), 8644 }; 8645 8646 static const size_t failTestCount = SK_ARRAY_COUNT(failTests); 8647 8648 DEF_TEST(PathOpsFailOp, reporter) { 8649 #if DEBUG_SHOW_TEST_NAME 8650 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 8651 #endif 8652 RunTestSet(reporter, failTests, failTestCount, nullptr, nullptr, nullptr, false); 8653 } 8654 8655 static struct TestDesc repTests[] = { 8656 TEST(fuzz763_5a), 8657 }; 8658 8659 DEF_TEST(PathOpsRepOp, reporter) { 8660 for (int index = 0; index < 1; ++index) 8661 RunTestSet(reporter, repTests, SK_ARRAY_COUNT(repTests), nullptr, nullptr, nullptr, false); 8662 } 8663
