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 static void seanbug(skiatest::Reporter* reporter, const char* filename) { 5430 SkPath path; 5431 path.setFillType(SkPath::kEvenOdd_FillType); 5432 path.moveTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000)); // 5804, 6036 5433 path.lineTo(SkBits2Float(0x45b55f0a), SkBits2Float(0x45bc9fc0)); // 5803.88f, 6035.97f 5434 path.lineTo(SkBits2Float(0x45b55e15), SkBits2Float(0x45bc9f7b)); // 5803.76f, 6035.94f 5435 path.lineTo(SkBits2Float(0x45b55d1f), SkBits2Float(0x45bc9f32)); // 5803.64f, 6035.9f 5436 path.lineTo(SkBits2Float(0x45b55c29), SkBits2Float(0x45bc9ee3)); // 5803.52f, 6035.86f 5437 path.lineTo(SkBits2Float(0x45b55b34), SkBits2Float(0x45bc9e90)); // 5803.4f, 6035.82f 5438 path.lineTo(SkBits2Float(0x45b55a3f), SkBits2Float(0x45bc9e38)); // 5803.28f, 6035.78f 5439 path.lineTo(SkBits2Float(0x45b5594a), SkBits2Float(0x45bc9ddc)); // 5803.16f, 6035.73f 5440 path.lineTo(SkBits2Float(0x45b55856), SkBits2Float(0x45bc9d7a)); // 5803.04f, 6035.68f 5441 path.lineTo(SkBits2Float(0x45b55762), SkBits2Float(0x45bc9d14)); // 5802.92f, 6035.63f 5442 path.lineTo(SkBits2Float(0x45b5566f), SkBits2Float(0x45bc9caa)); // 5802.8f, 6035.58f 5443 path.lineTo(SkBits2Float(0x45b5557c), SkBits2Float(0x45bc9c3b)); // 5802.69f, 6035.53f 5444 path.lineTo(SkBits2Float(0x45b55489), SkBits2Float(0x45bc9bc7)); // 5802.57f, 6035.47f 5445 path.lineTo(SkBits2Float(0x45b55397), SkBits2Float(0x45bc9b4f)); // 5802.45f, 6035.41f 5446 path.lineTo(SkBits2Float(0x45b552a6), SkBits2Float(0x45bc9ad3)); // 5802.33f, 6035.35f 5447 path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45bc9a52)); // 5802.21f, 6035.29f 5448 path.lineTo(SkBits2Float(0x45b550c5), SkBits2Float(0x45bc99cd)); // 5802.1f, 6035.23f 5449 path.lineTo(SkBits2Float(0x45b54fd6), SkBits2Float(0x45bc9943)); // 5801.98f, 6035.16f 5450 path.lineTo(SkBits2Float(0x45b54ee8), SkBits2Float(0x45bc98b6)); // 5801.86f, 6035.09f 5451 path.lineTo(SkBits2Float(0x45b54dfb), SkBits2Float(0x45bc9824)); // 5801.75f, 6035.02f 5452 path.lineTo(SkBits2Float(0x45b54d0e), SkBits2Float(0x45bc978d)); // 5801.63f, 6034.94f 5453 path.lineTo(SkBits2Float(0x45b54c23), SkBits2Float(0x45bc96f3)); // 5801.52f, 6034.87f 5454 path.lineTo(SkBits2Float(0x45b54b39), SkBits2Float(0x45bc9654)); // 5801.4f, 6034.79f 5455 path.lineTo(SkBits2Float(0x45b54a4f), SkBits2Float(0x45bc95b2)); // 5801.29f, 6034.71f 5456 path.lineTo(SkBits2Float(0x45b54967), SkBits2Float(0x45bc950b)); // 5801.18f, 6034.63f 5457 path.lineTo(SkBits2Float(0x45b54880), SkBits2Float(0x45bc9460)); // 5801.06f, 6034.55f 5458 path.lineTo(SkBits2Float(0x45b5479a), SkBits2Float(0x45bc93b1)); // 5800.95f, 6034.46f 5459 path.lineTo(SkBits2Float(0x45b546b6), SkBits2Float(0x45bc92fe)); // 5800.84f, 6034.37f 5460 path.lineTo(SkBits2Float(0x45b545d3), SkBits2Float(0x45bc9248)); // 5800.73f, 6034.29f 5461 path.lineTo(SkBits2Float(0x45b544f1), SkBits2Float(0x45bc918d)); // 5800.62f, 6034.19f 5462 path.lineTo(SkBits2Float(0x45b54410), SkBits2Float(0x45bc90cf)); // 5800.51f, 6034.1f 5463 path.lineTo(SkBits2Float(0x45b54331), SkBits2Float(0x45bc900d)); // 5800.4f, 6034.01f 5464 path.lineTo(SkBits2Float(0x45b54254), SkBits2Float(0x45bc8f47)); // 5800.29f, 6033.91f 5465 path.lineTo(SkBits2Float(0x45b54178), SkBits2Float(0x45bc8e7d)); // 5800.18f, 6033.81f 5466 path.lineTo(SkBits2Float(0x45b5409e), SkBits2Float(0x45bc8db0)); // 5800.08f, 6033.71f 5467 path.lineTo(SkBits2Float(0x45b53fc6), SkBits2Float(0x45bc8cde)); // 5799.97f, 6033.61f 5468 path.lineTo(SkBits2Float(0x45b53eef), SkBits2Float(0x45bc8c0a)); // 5799.87f, 6033.5f 5469 path.lineTo(SkBits2Float(0x45b53e1a), SkBits2Float(0x45bc8b31)); // 5799.76f, 6033.4f 5470 path.lineTo(SkBits2Float(0x45b53d47), SkBits2Float(0x45bc8a56)); // 5799.66f, 6033.29f 5471 path.lineTo(SkBits2Float(0x45b53c75), SkBits2Float(0x45bc8976)); // 5799.56f, 6033.18f 5472 path.lineTo(SkBits2Float(0x45b53ba6), SkBits2Float(0x45bc8893)); // 5799.46f, 6033.07f 5473 path.lineTo(SkBits2Float(0x45b53ad8), SkBits2Float(0x45bc87ad)); // 5799.36f, 6032.96f 5474 path.lineTo(SkBits2Float(0x45b53a0d), SkBits2Float(0x45bc86c4)); // 5799.26f, 6032.85f 5475 path.lineTo(SkBits2Float(0x45b53944), SkBits2Float(0x45bc85d6)); // 5799.16f, 6032.73f 5476 path.lineTo(SkBits2Float(0x45b5387c), SkBits2Float(0x45bc84e6)); // 5799.06f, 6032.61f 5477 path.lineTo(SkBits2Float(0x45b537b7), SkBits2Float(0x45bc83f2)); // 5798.96f, 6032.49f 5478 path.lineTo(SkBits2Float(0x45b536f4), SkBits2Float(0x45bc82fc)); // 5798.87f, 6032.37f 5479 path.lineTo(SkBits2Float(0x45b53634), SkBits2Float(0x45bc8201)); // 5798.78f, 6032.25f 5480 path.lineTo(SkBits2Float(0x45b53575), SkBits2Float(0x45bc8104)); // 5798.68f, 6032.13f 5481 path.lineTo(SkBits2Float(0x45b534ba), SkBits2Float(0x45bc8004)); // 5798.59f, 6032 5482 path.lineTo(SkBits2Float(0x45b53400), SkBits2Float(0x45bc7f00)); // 5798.5f, 6031.88f 5483 path.lineTo(SkBits2Float(0x45b53349), SkBits2Float(0x45bc7df9)); // 5798.41f, 6031.75f 5484 path.lineTo(SkBits2Float(0x45b53294), SkBits2Float(0x45bc7cf0)); // 5798.32f, 6031.62f 5485 path.lineTo(SkBits2Float(0x45b531e2), SkBits2Float(0x45bc7be3)); // 5798.24f, 6031.49f 5486 path.lineTo(SkBits2Float(0x45b53133), SkBits2Float(0x45bc7ad3)); // 5798.15f, 6031.35f 5487 path.lineTo(SkBits2Float(0x45b53086), SkBits2Float(0x45bc79c1)); // 5798.07f, 6031.22f 5488 path.lineTo(SkBits2Float(0x45b52fdc), SkBits2Float(0x45bc78ab)); // 5797.98f, 6031.08f 5489 path.lineTo(SkBits2Float(0x45b52f35), SkBits2Float(0x45bc7793)); // 5797.9f, 6030.95f 5490 path.lineTo(SkBits2Float(0x45b52e90), SkBits2Float(0x45bc7678)); // 5797.82f, 6030.81f 5491 path.lineTo(SkBits2Float(0x45b52def), SkBits2Float(0x45bc755a)); // 5797.74f, 6030.67f 5492 path.lineTo(SkBits2Float(0x45b52d50), SkBits2Float(0x45bc7439)); // 5797.66f, 6030.53f 5493 path.lineTo(SkBits2Float(0x45b52cb4), SkBits2Float(0x45bc7316)); // 5797.59f, 6030.39f 5494 path.lineTo(SkBits2Float(0x45b52c1b), SkBits2Float(0x45bc71f0)); // 5797.51f, 6030.24f 5495 path.lineTo(SkBits2Float(0x45b52b86), SkBits2Float(0x45bc70c7)); // 5797.44f, 6030.1f 5496 path.lineTo(SkBits2Float(0x45b52af3), SkBits2Float(0x45bc6f9c)); // 5797.37f, 6029.95f 5497 path.lineTo(SkBits2Float(0x45b52a63), SkBits2Float(0x45bc6e6e)); // 5797.3f, 6029.8f 5498 path.lineTo(SkBits2Float(0x45b529d7), SkBits2Float(0x45bc6d3e)); // 5797.23f, 6029.66f 5499 path.lineTo(SkBits2Float(0x45b5294e), SkBits2Float(0x45bc6c0b)); // 5797.16f, 6029.51f 5500 path.lineTo(SkBits2Float(0x45b528c8), SkBits2Float(0x45bc6ad6)); // 5797.1f, 6029.35f 5501 path.lineTo(SkBits2Float(0x45b52846), SkBits2Float(0x45bc699e)); // 5797.03f, 6029.2f 5502 path.lineTo(SkBits2Float(0x45b527c7), SkBits2Float(0x45bc6864)); // 5796.97f, 6029.05f 5503 path.lineTo(SkBits2Float(0x45b5274b), SkBits2Float(0x45bc6728)); // 5796.91f, 6028.89f 5504 path.lineTo(SkBits2Float(0x45b526d3), SkBits2Float(0x45bc65e9)); // 5796.85f, 6028.74f 5505 path.lineTo(SkBits2Float(0x45b5265e), SkBits2Float(0x45bc64a8)); // 5796.8f, 6028.58f 5506 path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bc639b)); // 5796.75f, 6028.45f 5507 path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bab032)); // 5796.75f, 5974.02f 5508 path.lineTo(SkBits2Float(0x45b52611), SkBits2Float(0x45baaffd)); // 5796.76f, 5974 5509 path.lineTo(SkBits2Float(0x45b52687), SkBits2Float(0x45baae9d)); // 5796.82f, 5973.83f 5510 path.lineTo(SkBits2Float(0x45b52700), SkBits2Float(0x45baad40)); // 5796.88f, 5973.66f 5511 path.lineTo(SkBits2Float(0x45b5277d), SkBits2Float(0x45baabe7)); // 5796.94f, 5973.49f 5512 path.lineTo(SkBits2Float(0x45b527fe), SkBits2Float(0x45baaa91)); // 5797, 5973.32f 5513 path.lineTo(SkBits2Float(0x45b52883), SkBits2Float(0x45baa93f)); // 5797.06f, 5973.16f 5514 path.lineTo(SkBits2Float(0x45b5290b), SkBits2Float(0x45baa7f1)); // 5797.13f, 5972.99f 5515 path.lineTo(SkBits2Float(0x45b52998), SkBits2Float(0x45baa6a6)); // 5797.2f, 5972.83f 5516 path.lineTo(SkBits2Float(0x45b52a28), SkBits2Float(0x45baa55f)); // 5797.27f, 5972.67f 5517 path.lineTo(SkBits2Float(0x45b52abb), SkBits2Float(0x45baa41c)); // 5797.34f, 5972.51f 5518 path.lineTo(SkBits2Float(0x45b52b52), SkBits2Float(0x45baa2dc)); // 5797.42f, 5972.36f 5519 path.lineTo(SkBits2Float(0x45b52bed), SkBits2Float(0x45baa1a0)); // 5797.49f, 5972.2f 5520 path.lineTo(SkBits2Float(0x45b52c8c), SkBits2Float(0x45baa068)); // 5797.57f, 5972.05f 5521 path.lineTo(SkBits2Float(0x45b52d2e), SkBits2Float(0x45ba9f34)); // 5797.65f, 5971.9f 5522 path.lineTo(SkBits2Float(0x45b52dd3), SkBits2Float(0x45ba9e04)); // 5797.73f, 5971.75f 5523 path.lineTo(SkBits2Float(0x45b52e7c), SkBits2Float(0x45ba9cd8)); // 5797.81f, 5971.61f 5524 path.lineTo(SkBits2Float(0x45b52f28), SkBits2Float(0x45ba9baf)); // 5797.89f, 5971.46f 5525 path.lineTo(SkBits2Float(0x45b52fd8), SkBits2Float(0x45ba9a8b)); // 5797.98f, 5971.32f 5526 path.lineTo(SkBits2Float(0x45b5308b), SkBits2Float(0x45ba996b)); // 5798.07f, 5971.18f 5527 path.lineTo(SkBits2Float(0x45b53141), SkBits2Float(0x45ba984f)); // 5798.16f, 5971.04f 5528 path.lineTo(SkBits2Float(0x45b531fa), SkBits2Float(0x45ba9736)); // 5798.25f, 5970.9f 5529 path.lineTo(SkBits2Float(0x45b532b7), SkBits2Float(0x45ba9623)); // 5798.34f, 5970.77f 5530 path.lineTo(SkBits2Float(0x45b53377), SkBits2Float(0x45ba9513)); // 5798.43f, 5970.63f 5531 path.lineTo(SkBits2Float(0x45b5343a), SkBits2Float(0x45ba9407)); // 5798.53f, 5970.5f 5532 path.lineTo(SkBits2Float(0x45b53500), SkBits2Float(0x45ba9300)); // 5798.63f, 5970.38f 5533 path.lineTo(SkBits2Float(0x45b535c9), SkBits2Float(0x45ba91fd)); // 5798.72f, 5970.25f 5534 path.lineTo(SkBits2Float(0x45b53695), SkBits2Float(0x45ba90fe)); // 5798.82f, 5970.12f 5535 path.lineTo(SkBits2Float(0x45b53765), SkBits2Float(0x45ba9004)); // 5798.92f, 5970 5536 path.lineTo(SkBits2Float(0x45b53837), SkBits2Float(0x45ba8f0e)); // 5799.03f, 5969.88f 5537 path.lineTo(SkBits2Float(0x45b5390c), SkBits2Float(0x45ba8e1d)); // 5799.13f, 5969.76f 5538 path.lineTo(SkBits2Float(0x45b539e4), SkBits2Float(0x45ba8d30)); // 5799.24f, 5969.65f 5539 path.lineTo(SkBits2Float(0x45b53abf), SkBits2Float(0x45ba8c48)); // 5799.34f, 5969.54f 5540 path.lineTo(SkBits2Float(0x45b53b9d), SkBits2Float(0x45ba8b64)); // 5799.45f, 5969.42f 5541 path.lineTo(SkBits2Float(0x45b53c7d), SkBits2Float(0x45ba8a85)); // 5799.56f, 5969.31f 5542 path.lineTo(SkBits2Float(0x45b53d60), SkBits2Float(0x45ba89aa)); // 5799.67f, 5969.21f 5543 path.lineTo(SkBits2Float(0x45b53e46), SkBits2Float(0x45ba88d4)); // 5799.78f, 5969.1f 5544 path.lineTo(SkBits2Float(0x45b53f2f), SkBits2Float(0x45ba8803)); // 5799.9f, 5969 5545 path.lineTo(SkBits2Float(0x45b5401a), SkBits2Float(0x45ba8736)); // 5800.01f, 5968.9f 5546 path.lineTo(SkBits2Float(0x45b54108), SkBits2Float(0x45ba866f)); // 5800.13f, 5968.8f 5547 path.lineTo(SkBits2Float(0x45b541f8), SkBits2Float(0x45ba85ac)); // 5800.25f, 5968.71f 5548 path.lineTo(SkBits2Float(0x45b542eb), SkBits2Float(0x45ba84ee)); // 5800.36f, 5968.62f 5549 path.lineTo(SkBits2Float(0x45b543e0), SkBits2Float(0x45ba8435)); // 5800.48f, 5968.53f 5550 path.lineTo(SkBits2Float(0x45b544d8), SkBits2Float(0x45ba8380)); // 5800.61f, 5968.44f 5551 path.lineTo(SkBits2Float(0x45b545d2), SkBits2Float(0x45ba82d1)); // 5800.73f, 5968.35f 5552 path.lineTo(SkBits2Float(0x45b546cf), SkBits2Float(0x45ba8227)); // 5800.85f, 5968.27f 5553 path.lineTo(SkBits2Float(0x45b547ce), SkBits2Float(0x45ba8182)); // 5800.98f, 5968.19f 5554 path.lineTo(SkBits2Float(0x45b548cf), SkBits2Float(0x45ba80e2)); // 5801.1f, 5968.11f 5555 path.lineTo(SkBits2Float(0x45b549d2), SkBits2Float(0x45ba8047)); // 5801.23f, 5968.03f 5556 path.lineTo(SkBits2Float(0x45b54ad8), SkBits2Float(0x45ba7fb1)); // 5801.36f, 5967.96f 5557 path.lineTo(SkBits2Float(0x45b54be0), SkBits2Float(0x45ba7f20)); // 5801.48f, 5967.89f 5558 path.lineTo(SkBits2Float(0x45b54cea), SkBits2Float(0x45ba7e95)); // 5801.61f, 5967.82f 5559 path.lineTo(SkBits2Float(0x45b54df6), SkBits2Float(0x45ba7e0e)); // 5801.75f, 5967.76f 5560 path.lineTo(SkBits2Float(0x45b54f04), SkBits2Float(0x45ba7d8d)); // 5801.88f, 5967.69f 5561 path.lineTo(SkBits2Float(0x45b55015), SkBits2Float(0x45ba7d12)); // 5802.01f, 5967.63f 5562 path.lineTo(SkBits2Float(0x45b55127), SkBits2Float(0x45ba7c9c)); // 5802.14f, 5967.58f 5563 path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45ba7c62)); // 5802.21f, 5967.55f 5564 path.lineTo(SkBits2Float(0x45c7b29a), SkBits2Float(0x45ba7c62)); // 6390.33f, 5967.55f 5565 path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45ba7c8b)); // 6390.37f, 5967.57f 5566 path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45ba7cff)); // 6390.48f, 5967.62f 5567 path.lineTo(SkBits2Float(0x45c7b4c7), SkBits2Float(0x45ba7d78)); // 6390.6f, 5967.68f 5568 path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45ba7df5)); // 6390.71f, 5967.74f 5569 path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45ba7e78)); // 6390.82f, 5967.81f 5570 path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45ba7f00)); // 6390.94f, 5967.88f 5571 path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45ba7f8d)); // 6391.05f, 5967.94f 5572 path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45ba801e)); // 6391.16f, 5968.01f 5573 path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45ba80b5)); // 6391.27f, 5968.09f 5574 path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45ba8150)); // 6391.38f, 5968.16f 5575 path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45ba81f0)); // 6391.49f, 5968.24f 5576 path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45ba8294)); // 6391.6f, 5968.32f 5577 path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45ba833d)); // 6391.71f, 5968.4f 5578 path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45ba83eb)); // 6391.82f, 5968.49f 5579 path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45ba849d)); // 6391.92f, 5968.58f 5580 path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45ba8554)); // 6392.03f, 5968.67f 5581 path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45ba860f)); // 6392.13f, 5968.76f 5582 path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45ba86cf)); // 6392.24f, 5968.85f 5583 path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45ba8792)); // 6392.34f, 5968.95f 5584 path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45ba885b)); // 6392.44f, 5969.04f 5585 path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45ba8927)); // 6392.54f, 5969.14f 5586 path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45ba89f7)); // 6392.64f, 5969.25f 5587 path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45ba8acc)); // 6392.74f, 5969.35f 5588 path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45ba8ba5)); // 6392.84f, 5969.46f 5589 path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45ba8c82)); // 6392.94f, 5969.56f 5590 path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45ba8d62)); // 6393.04f, 5969.67f 5591 path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45ba8e47)); // 6393.13f, 5969.78f 5592 path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45ba8f30)); // 6393.22f, 5969.9f 5593 path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45ba901c)); // 6393.32f, 5970.01f 5594 path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45ba910c)); // 6393.41f, 5970.13f 5595 path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45ba9200)); // 6393.5f, 5970.25f 5596 path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45ba92f8)); // 6393.59f, 5970.37f 5597 path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45ba93f3)); // 6393.68f, 5970.49f 5598 path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45ba94f2)); // 6393.76f, 5970.62f 5599 path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45ba95f4)); // 6393.85f, 5970.74f 5600 path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45ba96fa)); // 6393.93f, 5970.87f 5601 path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45ba9803)); // 6394.02f, 5971 5602 path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45ba9910)); // 6394.1f, 5971.13f 5603 path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45ba9a20)); // 6394.18f, 5971.27f 5604 path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45ba9b33)); // 6394.26f, 5971.4f 5605 path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45ba9c4a)); // 6394.34f, 5971.54f 5606 path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45ba9d63)); // 6394.41f, 5971.67f 5607 path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45ba9e80)); // 6394.49f, 5971.81f 5608 path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45ba9fa0)); // 6394.56f, 5971.95f 5609 path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45baa0c3)); // 6394.63f, 5972.1f 5610 path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45baa1e9)); // 6394.7f, 5972.24f 5611 path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45baa312)); // 6394.77f, 5972.38f 5612 path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45baa43e)); // 6394.84f, 5972.53f 5613 path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45baa56d)); // 6394.9f, 5972.68f 5614 path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45baa69f)); // 6394.97f, 5972.83f 5615 path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45baa7d3)); // 6395.03f, 5972.98f 5616 path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45baa90a)); // 6395.09f, 5973.13f 5617 path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45baaa44)); // 6395.15f, 5973.28f 5618 path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45baab80)); // 6395.2f, 5973.44f 5619 path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45baacbf)); // 6395.26f, 5973.59f 5620 path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45baae00)); // 6395.31f, 5973.75f 5621 path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45baaf44)); // 6395.36f, 5973.91f 5622 path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bab08a)); // 6395.41f, 5974.07f 5623 path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bab1d3)); // 6395.46f, 5974.23f 5624 path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bab31d)); // 6395.51f, 5974.39f 5625 path.lineTo(SkBits2Float(0x45c7dc6a), SkBits2Float(0x45bab46a)); // 6395.55f, 5974.55f 5626 path.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45bc5fbe)); // 6395.55f, 6027.97f 5627 path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bc60e7)); // 6395.51f, 6028.11f 5628 path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bc620f)); // 6395.46f, 6028.26f 5629 path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bc6336)); // 6395.41f, 6028.4f 5630 path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45bc645c)); // 6395.36f, 6028.54f 5631 path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45bc6580)); // 6395.31f, 6028.69f 5632 path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45bc66a3)); // 6395.26f, 6028.83f 5633 path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45bc67c5)); // 6395.2f, 6028.97f 5634 path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45bc68e6)); // 6395.15f, 6029.11f 5635 path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45bc6a05)); // 6395.09f, 6029.25f 5636 path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45bc6b23)); // 6395.03f, 6029.39f 5637 path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45bc6c3f)); // 6394.97f, 6029.53f 5638 path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45bc6d5a)); // 6394.9f, 6029.67f 5639 path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45bc6e73)); // 6394.84f, 6029.81f 5640 path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45bc6f8b)); // 6394.77f, 6029.94f 5641 path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45bc70a1)); // 6394.7f, 6030.08f 5642 path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45bc71b5)); // 6394.63f, 6030.21f 5643 path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45bc72c7)); // 6394.56f, 6030.35f 5644 path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45bc73d8)); // 6394.49f, 6030.48f 5645 path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45bc74e7)); // 6394.41f, 6030.61f 5646 path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45bc75f4)); // 6394.34f, 6030.74f 5647 path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45bc76ff)); // 6394.26f, 6030.87f 5648 path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45bc7807)); // 6394.18f, 6031 5649 path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45bc790e)); // 6394.1f, 6031.13f 5650 path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45bc7a13)); // 6394.02f, 6031.26f 5651 path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45bc7b16)); // 6393.93f, 6031.39f 5652 path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45bc7c16)); // 6393.85f, 6031.51f 5653 path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45bc7d14)); // 6393.76f, 6031.63f 5654 path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45bc7e10)); // 6393.68f, 6031.76f 5655 path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45bc7f09)); // 6393.59f, 6031.88f 5656 path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45bc8000)); // 6393.5f, 6032 5657 path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45bc80f5)); // 6393.41f, 6032.12f 5658 path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45bc81e7)); // 6393.32f, 6032.24f 5659 path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45bc82d6)); // 6393.22f, 6032.35f 5660 path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45bc83c3)); // 6393.13f, 6032.47f 5661 path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45bc84ad)); // 6393.04f, 6032.58f 5662 path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45bc8595)); // 6392.94f, 6032.7f 5663 path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45bc8679)); // 6392.84f, 6032.81f 5664 path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45bc875b)); // 6392.74f, 6032.92f 5665 path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45bc883a)); // 6392.64f, 6033.03f 5666 path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45bc8917)); // 6392.54f, 6033.14f 5667 path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45bc89f0)); // 6392.44f, 6033.24f 5668 path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45bc8ac6)); // 6392.34f, 6033.35f 5669 path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45bc8b99)); // 6392.24f, 6033.45f 5670 path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45bc8c69)); // 6392.13f, 6033.55f 5671 path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45bc8d36)); // 6392.03f, 6033.65f 5672 path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45bc8e00)); // 6391.92f, 6033.75f 5673 path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45bc8ec7)); // 6391.82f, 6033.85f 5674 path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45bc8f8a)); // 6391.71f, 6033.94f 5675 path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45bc904a)); // 6391.6f, 6034.04f 5676 path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45bc9106)); // 6391.49f, 6034.13f 5677 path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45bc91bf)); // 6391.38f, 6034.22f 5678 path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45bc9275)); // 6391.27f, 6034.31f 5679 path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45bc9327)); // 6391.16f, 6034.39f 5680 path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45bc93d5)); // 6391.05f, 6034.48f 5681 path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45bc9480)); // 6390.94f, 6034.56f 5682 path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45bc9527)); // 6390.82f, 6034.64f 5683 path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45bc95ca)); // 6390.71f, 6034.72f 5684 path.lineTo(SkBits2Float(0x45c7b4c8), SkBits2Float(0x45bc966a)); // 6390.6f, 6034.8f 5685 path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45bc9706)); // 6390.48f, 6034.88f 5686 path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45bc979e)); // 6390.37f, 6034.95f 5687 path.lineTo(SkBits2Float(0x45c7b205), SkBits2Float(0x45bc9832)); // 6390.25f, 6035.02f 5688 path.lineTo(SkBits2Float(0x45c7b118), SkBits2Float(0x45bc98c2)); // 6390.14f, 6035.09f 5689 path.lineTo(SkBits2Float(0x45c7b02a), SkBits2Float(0x45bc994e)); // 6390.02f, 6035.16f 5690 path.lineTo(SkBits2Float(0x45c7af3b), SkBits2Float(0x45bc99d5)); // 6389.9f, 6035.23f 5691 path.lineTo(SkBits2Float(0x45c7ae4b), SkBits2Float(0x45bc9a59)); // 6389.79f, 6035.29f 5692 path.lineTo(SkBits2Float(0x45c7ad5a), SkBits2Float(0x45bc9ad9)); // 6389.67f, 6035.36f 5693 path.lineTo(SkBits2Float(0x45c7ac69), SkBits2Float(0x45bc9b54)); // 6389.55f, 6035.42f 5694 path.lineTo(SkBits2Float(0x45c7ab77), SkBits2Float(0x45bc9bcb)); // 6389.43f, 6035.47f 5695 path.lineTo(SkBits2Float(0x45c7aa84), SkBits2Float(0x45bc9c3e)); // 6389.31f, 6035.53f 5696 path.lineTo(SkBits2Float(0x45c7a991), SkBits2Float(0x45bc9cac)); // 6389.2f, 6035.58f 5697 path.lineTo(SkBits2Float(0x45c7a89e), SkBits2Float(0x45bc9d16)); // 6389.08f, 6035.64f 5698 path.lineTo(SkBits2Float(0x45c7a7aa), SkBits2Float(0x45bc9d7b)); // 6388.96f, 6035.69f 5699 path.lineTo(SkBits2Float(0x45c7a6b6), SkBits2Float(0x45bc9ddc)); // 6388.84f, 6035.73f 5700 path.lineTo(SkBits2Float(0x45c7a5c1), SkBits2Float(0x45bc9e39)); // 6388.72f, 6035.78f 5701 path.lineTo(SkBits2Float(0x45c7a4cc), SkBits2Float(0x45bc9e90)); // 6388.6f, 6035.82f 5702 path.lineTo(SkBits2Float(0x45c7a3d7), SkBits2Float(0x45bc9ee3)); // 6388.48f, 6035.86f 5703 path.lineTo(SkBits2Float(0x45c7a2e1), SkBits2Float(0x45bc9f32)); // 6388.36f, 6035.9f 5704 path.lineTo(SkBits2Float(0x45c7a1eb), SkBits2Float(0x45bc9f7b)); // 6388.24f, 6035.94f 5705 path.lineTo(SkBits2Float(0x45c7a0f6), SkBits2Float(0x45bc9fc0)); // 6388.12f, 6035.97f 5706 path.lineTo(SkBits2Float(0x45c7a000), SkBits2Float(0x45bca000)); // 6388, 6036 5707 path.lineTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000)); // 5804, 6036 5708 path.close(); 5709 5710 SkPath path2; 5711 path2.setFillType(SkPath::kWinding_FillType); 5712 path2.moveTo(SkBits2Float(0x45b52600), SkBits2Float(0x45ba7c62)); // 5796.75f, 5967.55f 5713 path2.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45ba7c62)); // 6395.55f, 5967.55f 5714 path2.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45bca239)); // 6395.55f, 6036.28f 5715 path2.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bca239)); // 5796.75f, 6036.28f 5716 path2.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45ba7c62)); // 5796.75f, 5967.55f 5717 path2.close(); 5718 5719 SkPath result_path; 5720 testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename); 5721 } 5722 5723 static void (*skipTest)(skiatest::Reporter* , const char* filename) = 0; 5724 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0; 5725 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0; 5726 5727 #define TEST(name) { name, #name } 5728 5729 static struct TestDesc tests[] = { 5730 TEST(seanbug), 5731 TEST(android1), 5732 TEST(bug5240), 5733 TEST(circlesOp4), 5734 TEST(loop17), 5735 TEST(cubicOp158), 5736 TEST(loops_i1), 5737 TEST(loops_i2), 5738 TEST(loops_i3), 5739 TEST(loops_i4), 5740 TEST(loops_i5), 5741 TEST(loops_i6), 5742 TEST(cubics_d3), 5743 TEST(cubics_o), 5744 TEST(cubics_d2), 5745 TEST(cubics_d), 5746 TEST(dean2), 5747 TEST(fuzzX_392), 5748 TEST(crbug_526025), 5749 TEST(fuzz38), 5750 TEST(cubics44d), 5751 TEST(cubics45u), 5752 TEST(loops61i), 5753 TEST(loops62i), 5754 TEST(loops63i), 5755 TEST(loops58iAsQuads), 5756 TEST(cubics41d), 5757 TEST(loops59iasQuads), 5758 TEST(loops59i), 5759 TEST(loops44i), 5760 TEST(loops45i), 5761 TEST(loops46i), 5762 TEST(loops47i), 5763 TEST(loops48i), 5764 TEST(loops49i), 5765 TEST(loops50i), 5766 TEST(loops51i), 5767 TEST(loops52i), 5768 TEST(loops53i), 5769 TEST(loops54i), 5770 TEST(loops55i), 5771 TEST(loops56i), 5772 TEST(loops57i), 5773 TEST(loops58i), 5774 TEST(loops33iMod), 5775 TEST(loops33iAsQuads), 5776 TEST(loops33i), 5777 TEST(loops40i), 5778 TEST(loops40iAsQuads), 5779 TEST(loops39i), 5780 TEST(loops38i), 5781 TEST(loops37i), 5782 TEST(loops36i), 5783 TEST(loops35i), 5784 TEST(loops34i), 5785 TEST(loops32i), 5786 TEST(loops31i), 5787 TEST(loops30i), 5788 TEST(loops29i), 5789 TEST(loops28i), 5790 TEST(loops27i), 5791 TEST(loops26i), 5792 TEST(loops25i), 5793 TEST(loops24i), 5794 TEST(loops23i), 5795 TEST(loops22i), 5796 TEST(loops21i), 5797 TEST(loops20i), 5798 TEST(cubics20d), 5799 TEST(cubics6d), 5800 TEST(cubics7d), 5801 TEST(cubics8d), 5802 TEST(cubics9d), 5803 TEST(cubics10u), 5804 TEST(cubics11i), 5805 TEST(cubics12d), 5806 TEST(cubics13d), 5807 TEST(cubics14d), 5808 TEST(cubics15d), 5809 TEST(cubics16i), 5810 TEST(cubics17d), 5811 TEST(cubics18d), 5812 TEST(cubics19d), 5813 TEST(cubicOp157), 5814 TEST(cubicOp142), 5815 TEST(loops4i), 5816 TEST(quadRect1), 5817 TEST(quadRect2), 5818 TEST(quadRect3), 5819 TEST(quadRect4), 5820 TEST(quadRect5), 5821 TEST(quadRect6), 5822 TEST(cubicOp141), 5823 TEST(cubicOp58d), 5824 TEST(loops5i), 5825 TEST(cubicOp140), 5826 TEST(cubicOp139), 5827 TEST(cubics138), 5828 TEST(cubics137), 5829 TEST(cubicOp136a), 5830 TEST(cubicOp136), 5831 TEST(cubicOp135), 5832 TEST(cubicOp134), 5833 TEST(cubicOp133), 5834 TEST(loop12), 5835 TEST(cubicOp132), 5836 TEST(loop11), 5837 TEST(loop10), 5838 TEST(circlesOp3), 5839 TEST(loop9), 5840 TEST(loop8), 5841 TEST(rects5), 5842 TEST(loop7), 5843 TEST(cubicOp130a), 5844 TEST(rRect1x), 5845 TEST(circlesOp2), 5846 TEST(circlesOp1), 5847 TEST(cubicOp131), 5848 TEST(cubicOp130), 5849 TEST(cubicOp129), 5850 TEST(cubicOp128), 5851 TEST(cubicOp127), 5852 TEST(cubicOp126), 5853 TEST(cubicOp125), 5854 TEST(cubicOp124), 5855 TEST(loop6), 5856 TEST(loop5), 5857 TEST(cubicOp123), 5858 TEST(cubicOp122), 5859 TEST(cubicOp121), 5860 TEST(cubicOp120), 5861 TEST(cubicOp119), 5862 TEST(loop4), 5863 TEST(loop3), 5864 TEST(loop2), 5865 TEST(loop1asQuad), 5866 TEST(loop1), 5867 TEST(issue3517), 5868 TEST(cubicOp118), 5869 TEST(cubicOp117), 5870 TEST(cubicOp116), 5871 TEST(testRect2), 5872 TEST(testRect1), 5873 TEST(cubicOp115), 5874 TEST(issue2753), 5875 TEST(cubicOp114), 5876 TEST(issue2808), 5877 TEST(cubicOp114asQuad), 5878 TEST(rects4), 5879 TEST(rects3), 5880 TEST(rects2), 5881 TEST(rects1), 5882 TEST(issue2540), 5883 TEST(issue2504), 5884 TEST(kari1), 5885 TEST(quadOp10i), 5886 TEST(cubicOp113), 5887 TEST(skpcarrot_is24), 5888 TEST(issue1417), 5889 TEST(cubicOp112), 5890 TEST(skpadspert_net23), 5891 TEST(skpadspert_de11), 5892 TEST(findFirst1), 5893 TEST(xOp2i), 5894 TEST(xOp3i), 5895 TEST(xOp1u), 5896 TEST(xOp1i), 5897 TEST(cubicOp111), 5898 TEST(cubicOp110), 5899 TEST(cubicOp109), 5900 TEST(cubicOp108), 5901 TEST(cubicOp107), 5902 TEST(cubicOp106), 5903 TEST(cubicOp105), 5904 TEST(cubicOp104), 5905 TEST(cubicOp103), 5906 TEST(cubicOp102), 5907 TEST(cubicOp101), 5908 TEST(cubicOp100), 5909 TEST(cubicOp99), 5910 TEST(issue1435), 5911 TEST(cubicOp98x), 5912 TEST(cubicOp97x), 5913 TEST(skpcarpetplanet_ru22), 5914 TEST(cubicOp96d), 5915 TEST(cubicOp95u), 5916 TEST(skpadbox_lt15), 5917 TEST(skpagentxsites_com55), 5918 TEST(skpadventistmission_org572), 5919 TEST(skpadoption_org196), 5920 TEST(skpbambootheme_com12), 5921 TEST(skpbakosoft_com10), 5922 TEST(skpakmmos_ru100), 5923 TEST(skpbangalorenest_com4), 5924 TEST(skpbingoentertainment_net189), 5925 TEST(skpbestred_ru37), 5926 TEST(skpbenzoteh_ru152), 5927 TEST(skpcamcorder_kz21), 5928 TEST(skpcaffelavazzait_com_ua21), 5929 TEST(skpcarrefour_ro62), 5930 TEST(skpcavablar_net563), 5931 TEST(skpinsomnia_gr72), 5932 TEST(skpadbox_lt8), 5933 TEST(skpact_com43), 5934 TEST(skpacesoftech_com47), 5935 TEST(skpabcspark_ca103), 5936 TEST(cubicOp94u), 5937 TEST(cubicOp93d), 5938 TEST(cubicOp92i), 5939 TEST(skpadithya_putr4_blogspot_com551), 5940 TEST(skpadindex_de4), 5941 TEST(skpaiaigames_com870), 5942 TEST(skpaaalgarve_org53), 5943 TEST(skpkkiste_to716), 5944 TEST(cubicOp91u), 5945 TEST(cubicOp90u), 5946 TEST(cubicOp89u), 5947 TEST(cubicOp88u), 5948 TEST(cubicOp87u), 5949 TEST(cubicOp86i), 5950 TEST(loopEdge2), 5951 TEST(loopEdge1), 5952 TEST(rectOp3x), 5953 TEST(rectOp2i), 5954 TEST(rectOp1i), 5955 TEST(issue1418b), 5956 TEST(cubicOp85i), 5957 TEST(issue1418), 5958 TEST(skpkkiste_to98), 5959 TEST(skpahrefs_com29), 5960 TEST(cubicOp85d), 5961 TEST(skpahrefs_com88), 5962 TEST(skphealth_com76), 5963 TEST(skpancestry_com1), 5964 TEST(skpbyte_com1), 5965 TEST(skpeldorado_com_ua1), 5966 TEST(skp96prezzi1), 5967 TEST(skpClip2), 5968 TEST(skpClip1), 5969 TEST(cubicOp84d), 5970 TEST(cubicOp83i), 5971 TEST(cubicOp82i), 5972 TEST(cubicOp81d), 5973 TEST(cubicOp80i), 5974 TEST(cubicOp79u), 5975 TEST(cubicOp78u), 5976 TEST(cubicOp77i), 5977 TEST(cubicOp76u), 5978 TEST(cubicOp75d), 5979 TEST(cubicOp74d), 5980 TEST(cubicOp73d), 5981 TEST(cubicOp72i), 5982 TEST(cubicOp71d), 5983 TEST(skp5), 5984 TEST(skp4), 5985 TEST(skp3), 5986 TEST(skp2), 5987 TEST(skp1), 5988 TEST(rRect1), 5989 TEST(cubicOp70d), 5990 TEST(cubicOp69d), 5991 TEST(cubicOp68u), 5992 TEST(cubicOp67u), 5993 TEST(cubicOp66u), 5994 TEST(rectOp1d), 5995 TEST(cubicOp65d), 5996 TEST(cubicOp64d), 5997 TEST(cubicOp63d), 5998 TEST(cubicOp62d), 5999 TEST(cubicOp61d), 6000 TEST(cubicOp60d), 6001 TEST(cubicOp59d), 6002 TEST(cubicOp57d), 6003 TEST(cubicOp56d), 6004 TEST(cubicOp55d), 6005 TEST(cubicOp54d), 6006 TEST(cubicOp53d), 6007 TEST(cubicOp52d), 6008 TEST(cubicOp51d), 6009 TEST(cubicOp50d), 6010 TEST(cubicOp49d), 6011 TEST(cubicOp48d), 6012 TEST(cubicOp47d), 6013 TEST(cubicOp46d), 6014 TEST(cubicOp45d), 6015 TEST(cubicOp44d), 6016 TEST(cubicOp43d), 6017 TEST(cubicOp42d), 6018 TEST(cubicOp41i), 6019 TEST(cubicOp40d), 6020 TEST(cubicOp39d), 6021 TEST(cubicOp38d), 6022 TEST(cubicOp37d), 6023 TEST(cubicOp36u), 6024 TEST(cubicOp35d), 6025 TEST(cubicOp34d), 6026 TEST(cubicOp33i), 6027 TEST(cubicOp32d), 6028 TEST(cubicOp31d), 6029 TEST(cubicOp31x), 6030 TEST(cubicOp31u), 6031 TEST(cubicOp30d), 6032 TEST(cubicOp29d), 6033 TEST(cubicOp28u), 6034 TEST(cubicOp27d), 6035 TEST(cubicOp26d), 6036 TEST(cubicOp25i), 6037 TEST(testOp8d), 6038 TEST(testDiff1), 6039 TEST(testIntersect1), 6040 TEST(testUnion1), 6041 TEST(testXor1), 6042 TEST(testDiff2), 6043 TEST(testIntersect2), 6044 TEST(testUnion2), 6045 TEST(testXor2), 6046 TEST(testOp1d), 6047 TEST(testOp2d), 6048 TEST(testOp3d), 6049 TEST(testOp1u), 6050 TEST(testOp4d), 6051 TEST(testOp5d), 6052 TEST(testOp6d), 6053 TEST(testOp7d), 6054 TEST(testOp2u), 6055 6056 TEST(cubicOp24d), 6057 TEST(cubicOp23d), 6058 TEST(cubicOp22d), 6059 TEST(cubicOp21d), 6060 TEST(cubicOp20d), 6061 TEST(cubicOp19i), 6062 TEST(cubicOp18d), 6063 TEST(cubicOp17d), 6064 TEST(cubicOp16d), 6065 TEST(cubicOp15d), 6066 TEST(cubicOp14d), 6067 TEST(cubicOp13d), 6068 TEST(cubicOp12d), 6069 TEST(cubicOp11d), 6070 TEST(cubicOp10d), 6071 TEST(cubicOp1i), 6072 TEST(cubicOp9d), 6073 TEST(quadOp9d), 6074 TEST(lineOp9d), 6075 TEST(cubicOp8d), 6076 TEST(cubicOp7d), 6077 TEST(cubicOp6d), 6078 TEST(cubicOp5d), 6079 TEST(cubicOp3d), 6080 TEST(cubicOp2d), 6081 TEST(cubicOp1d), 6082 }; 6083 6084 static const size_t testCount = SK_ARRAY_COUNT(tests); 6085 6086 static struct TestDesc subTests[] = { 6087 TEST(loops47i), 6088 TEST(loops61i), 6089 TEST(loops62i), 6090 TEST(issue3517), 6091 }; 6092 6093 static const size_t subTestCount = SK_ARRAY_COUNT(subTests); 6094 6095 static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = nullptr; 6096 6097 static bool runSubTests = false; 6098 static bool runSubTestsFirst = true; 6099 static bool runReverse = false; 6100 6101 DEF_TEST(PathOpsOp, reporter) { 6102 #if DEBUG_SHOW_TEST_NAME 6103 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 6104 #endif 6105 if (runSubTests && runSubTestsFirst) { 6106 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse); 6107 } 6108 RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse); 6109 if (runSubTests && !runSubTestsFirst) { 6110 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse); 6111 } 6112 } 6113 6114 static void fuzz767834(skiatest::Reporter* reporter, const char* filename) { 6115 SkPath one; 6116 SkPath two; 6117 one.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6118 6119 one.conicTo(SkBits2Float(0x02807252), SkBits2Float(0xee23000a), SkBits2Float(0x00000000), SkBits2Float(0x0fe00008), SkBits2Float(0x52526831)); // 1.88735e-37f, -1.26115e+28f, 0, 2.20881e-29f, 2.25923e+11f 6120 6121 one.cubicTo(SkBits2Float(0x474d475a), SkBits2Float(0x72727252), SkBits2Float(0x72267272), SkBits2Float(0x535202ff), SkBits2Float(0x53535353), SkBits2Float(0x58943353)); // 52551.4f, 4.80215e+30f, 3.29682e+30f, 9.01993e+11f, 9.07636e+11f, 1.30359e+15f 6122 6123 one.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x52595252), SkBits2Float(0x8e460900), SkBits2Float(0x7272db72)); // 2.60326e+11f, 2.33347e+11f, -2.44097e-30f, 4.81028e+30f 6124 6125 one.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6126 6127 one.close(); 6128 6129 one.moveTo(SkBits2Float(0x72000400), SkBits2Float(0x72727272)); // 2.53561e+30f, 4.80216e+30f 6130 6131 one.quadTo(SkBits2Float(0x60727272), SkBits2Float(0x72727272), SkBits2Float(0x2a527272), SkBits2Float(0x72525252)); // 6.98806e+19f, 4.80216e+30f, 1.86915e-13f, 4.16585e+30f 6132 6133 one.cubicTo(SkBits2Float(0x72727251), SkBits2Float(0x52617272), SkBits2Float(0x46032352), SkBits2Float(0x7272728e), SkBits2Float(0x5c527272), SkBits2Float(0x72726552)); // 4.80215e+30f, 2.42072e+11f, 8392.83f, 4.80217e+30f, 2.36942e+17f, 4.80114e+30f 6134 6135 one.cubicTo(SkBits2Float(0x2b7280ff), SkBits2Float(0x7240ffff), SkBits2Float(0x72724960), SkBits2Float(0x52008072), SkBits2Float(0x72725230), SkBits2Float(0x5f727272)); // 8.61547e-13f, 3.82276e+30f, 4.79898e+30f, 1.37978e+11f, 4.79966e+30f, 1.74702e+19f 6136 6137 one.lineTo(SkBits2Float(0x72000400), SkBits2Float(0x72727272)); // 2.53561e+30f, 4.80216e+30f 6138 6139 one.close(); 6140 6141 one.moveTo(SkBits2Float(0x8e524603), SkBits2Float(0x72727272)); // -2.59182e-30f, 4.80216e+30f 6142 6143 one.close(); 6144 6145 one.moveTo(SkBits2Float(0x8e524603), SkBits2Float(0x72727272)); // -2.59182e-30f, 4.80216e+30f 6146 6147 one.quadTo(SkBits2Float(0x72725d72), SkBits2Float(0x52008072), SkBits2Float(0x00016552), SkBits2Float(0x72724000)); // 4.80053e+30f, 1.37978e+11f, 1.28182e-40f, 4.79826e+30f 6148 6149 one.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x392a5b25), SkBits2Float(0x72685768), SkBits2Float(0x000000ff)); // 1.1796e-38f, 0.000162464f, 4.602e+30f, 3.57331e-43f 6150 6151 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6152 6153 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xd2008072), SkBits2Float(0x8e460900), SkBits2Float(0x72727072)); // 4.80216e+30f, -1.37978e+11f, -2.44097e-30f, 4.802e+30f 6154 6155 one.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x58943303), SkBits2Float(0x72727272), SkBits2Float(0x59525252), SkBits2Float(0x00090052), SkBits2Float(0x72000000)); // -1.29345e+20f, 1.30357e+15f, 4.80216e+30f, 3.70002e+15f, 8.26634e-40f, 2.5353e+30f 6156 6157 one.quadTo(SkBits2Float(0x005252ec), SkBits2Float(0x72000400), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 7.56026e-39f, 2.53561e+30f, 4.80216e+30f, 4.80216e+30f 6158 6159 one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6160 6161 one.close(); 6162 6163 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6164 6165 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x522a5272), SkBits2Float(0x20725252), SkBits2Float(0x72727251)); // 4.80216e+30f, 1.82882e+11f, 2.05254e-19f, 4.80215e+30f 6166 6167 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x59525252), SkBits2Float(0x46090052), SkBits2Float(0x72db728e)); // 4.80216e+30f, 3.70002e+15f, 8768.08f, 8.69321e+30f 6168 6169 one.quadTo(SkBits2Float(0x005252ec), SkBits2Float(0x72000400), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 7.56026e-39f, 2.53561e+30f, 4.80216e+30f, 4.80216e+30f 6170 6171 one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6172 6173 one.close(); 6174 6175 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6176 6177 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x522a5272), SkBits2Float(0x20725252), SkBits2Float(0x72727251)); // 4.80216e+30f, 1.82882e+11f, 2.05254e-19f, 4.80215e+30f 6178 6179 one.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460323), SkBits2Float(0x72727272), SkBits2Float(0x525c5272)); // 2.25894e+11f, -2.44069e-30f, 4.80216e+30f, 2.36569e+11f 6180 6181 one.conicTo(SkBits2Float(0xff727272), SkBits2Float(0xff2b549b), SkBits2Float(0x607240ff), SkBits2Float(0x72727249), SkBits2Float(0x30520080)); // -3.22267e+38f, -2.27737e+38f, 6.98249e+19f, 4.80215e+30f, 7.63983e-10f 6182 6183 one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6184 6185 one.close(); 6186 6187 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6188 6189 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x0052525f), SkBits2Float(0x8e524603), SkBits2Float(0x72727272)); // 4.80216e+30f, 7.56006e-39f, -2.59182e-30f, 4.80216e+30f 6190 6191 one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6192 6193 one.close(); 6194 6195 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6196 6197 one.quadTo(SkBits2Float(0x72725d72), SkBits2Float(0x52008072), SkBits2Float(0x00016552), SkBits2Float(0x72724000)); // 4.80053e+30f, 1.37978e+11f, 1.28182e-40f, 4.79826e+30f 6198 6199 one.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x392a5b25), SkBits2Float(0x72685768), SkBits2Float(0x000000ff)); // 1.1796e-38f, 0.000162464f, 4.602e+30f, 3.57331e-43f 6200 6201 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6202 6203 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xd2008072), SkBits2Float(0x8e460900), SkBits2Float(0x72727072)); // 4.80216e+30f, -1.37978e+11f, -2.44097e-30f, 4.802e+30f 6204 6205 one.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x58943303), SkBits2Float(0x72727272), SkBits2Float(0x59525252), SkBits2Float(0x46090052), SkBits2Float(0x72db728e)); // -1.29345e+20f, 1.30357e+15f, 4.80216e+30f, 3.70002e+15f, 8768.08f, 8.69321e+30f 6206 6207 one.quadTo(SkBits2Float(0x005252ec), SkBits2Float(0x72000400), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 7.56026e-39f, 2.53561e+30f, 4.80216e+30f, 4.80216e+30f 6208 6209 one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6210 6211 one.close(); 6212 6213 one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f 6214 6215 one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x522a5272), SkBits2Float(0x20725252), SkBits2Float(0x72727251)); // 4.80216e+30f, 1.82882e+11f, 2.05254e-19f, 4.80215e+30f 6216 6217 testPathOpFuzz(reporter, two, one, kIntersect_SkPathOp, filename); 6218 } 6219 6220 static void fuzz535151(skiatest::Reporter* reporter, const char* filename) { 6221 SkPath one; 6222 one.setFillType(SkPath::kWinding_FillType); 6223 SkPath two; 6224 two.setFillType(SkPath::kWinding_FillType); 6225 two.moveTo(0, 0); 6226 two.lineTo(0, 50); 6227 two.lineTo(4.29497e+09f, 50); 6228 SkPath dummy; 6229 testPathOpFuzz(reporter, one, two, kIntersect_SkPathOp, filename); 6230 } 6231 6232 static void bufferOverflow(skiatest::Reporter* reporter, const char* filename) { 6233 SkPath path; 6234 path.addRect(0,0, 300,170141183460469231731687303715884105728.f); 6235 SkPath pathB; 6236 pathB.addRect(0,0, 300,16); 6237 testPathOpFuzz(reporter, path, pathB, kUnion_SkPathOp, filename); 6238 } 6239 6240 // m 100,0 60,170 -160,-110 200,0 -170,11000000000 z 6241 static void fuzz433(skiatest::Reporter* reporter, const char* filename) { 6242 SkPath path1, path2; 6243 path1.moveTo(100,0); 6244 path1.lineTo(60,170); 6245 path1.lineTo(-160,-110); 6246 path1.lineTo(200,0); 6247 path1.lineTo(-170,11000000000.0f); 6248 path1.close(); 6249 6250 path2.moveTo(100 + 20,0 + 20); 6251 path2.lineTo(60 + 20,170 + 20); 6252 path2.lineTo(-160 + 20,-110 + 20); 6253 path2.lineTo(200 + 20,0 + 20); 6254 path2.lineTo(-170 + 20,11000000000.0f + 20); 6255 path2.close(); 6256 6257 testPathOpFuzz(reporter, path1, path2, kIntersect_SkPathOp, filename); 6258 } 6259 6260 static void fuzz433b(skiatest::Reporter* reporter, const char* filename) { 6261 SkPath path1, path2; 6262 path1.setFillType(SkPath::kEvenOdd_FillType); 6263 path1.moveTo(140, 40); 6264 path1.lineTo(200, 210); 6265 path1.lineTo(40, 100); 6266 path1.lineTo(240, 100); 6267 path1.lineTo(70, 1.1e+10f); 6268 path1.lineTo(140, 40); 6269 path1.close(); 6270 6271 path1.setFillType(SkPath::kWinding_FillType); 6272 path2.moveTo(190, 60); 6273 path2.lineTo(250, 230); 6274 path2.lineTo(90, 120); 6275 path2.lineTo(290, 120); 6276 path2.lineTo(120, 1.1e+10f); 6277 path2.lineTo(190, 60); 6278 path2.close(); 6279 6280 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename); 6281 } 6282 6283 static void fuzz487a(skiatest::Reporter* reporter, const char* filename) { 6284 SkPath path; 6285 path.setFillType((SkPath::FillType) 0); 6286 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6287 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 6288 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333)); 6289 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc)); 6290 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff)); 6291 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 6292 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 6293 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000)); 6294 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000)); 6295 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000)); 6296 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 6297 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 6298 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000)); 6299 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6300 path.close(); 6301 6302 SkPath path1(path); 6303 path.reset(); 6304 path.setFillType((SkPath::FillType) 0); 6305 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6306 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 6307 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a)); 6308 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a)); 6309 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd)); 6310 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000)); 6311 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a)); 6312 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333)); 6313 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000)); 6314 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000)); 6315 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a)); 6316 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334)); 6317 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd)); 6318 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd)); 6319 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd)); 6320 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334)); 6321 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000)); 6322 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6323 path.close(); 6324 6325 SkPath path2(path); 6326 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6327 } 6328 6329 static void fuzz487b(skiatest::Reporter* reporter, const char* filename) { 6330 SkPath path; 6331 path.setFillType((SkPath::FillType) 0); 6332 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6333 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 6334 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333)); 6335 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc)); 6336 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff)); 6337 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 6338 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a)); 6339 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000)); 6340 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000)); 6341 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000)); 6342 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 6343 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000)); 6344 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000)); 6345 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6346 path.close(); 6347 6348 SkPath path1(path); 6349 path.reset(); 6350 path.setFillType((SkPath::FillType) 0); 6351 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6352 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000)); 6353 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a)); 6354 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a)); 6355 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd)); 6356 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000)); 6357 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a)); 6358 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333)); 6359 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000)); 6360 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000)); 6361 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a)); 6362 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334)); 6363 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd)); 6364 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd)); 6365 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd)); 6366 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334)); 6367 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000)); 6368 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000)); 6369 path.close(); 6370 6371 SkPath path2(path); 6372 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6373 } 6374 6375 static void fuzz714(skiatest::Reporter* reporter, const char* filename) { 6376 SkPath path; 6377 path.setFillType((SkPath::FillType) 1); 6378 path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000)); 6379 path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000)); 6380 path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000)); 6381 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000)); // 2.22222e+022f 6382 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000)); // 2.22222e+022f 6383 path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000)); 6384 path.close(); 6385 6386 SkPath path1(path); 6387 path.reset(); 6388 path.setFillType((SkPath::FillType) 0); 6389 path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000)); 6390 path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000)); 6391 path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000)); 6392 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000)); // 2.22222e+022f 6393 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000)); // 2.22222e+022f 6394 path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000)); 6395 path.close(); 6396 6397 SkPath path2(path); 6398 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6399 } 6400 6401 static void fuzz1(skiatest::Reporter* reporter, const char* filename) { 6402 SkPath path; 6403 path.setFillType((SkPath::FillType) 0); 6404 path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6405 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6406 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6407 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000)); 6408 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000)); 6409 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000)); 6410 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001)); 6411 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000)); 6412 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000)); 6413 path.close(); 6414 6415 SkPath path1(path); 6416 path.reset(); 6417 path.setFillType((SkPath::FillType) 0); 6418 6419 SkPath path2(path); 6420 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6421 } 6422 6423 6424 static void fuzz753_91(skiatest::Reporter* reporter, const char* filename) { 6425 SkPath path; 6426 path.setFillType((SkPath::FillType) 0); 6427 path.moveTo(SkBits2Float(0x42910000), SkBits2Float(0x00000000)); // 72.5f, 0 6428 path.lineTo(SkBits2Float(0x42166668), SkBits2Float(0x00000000)); // 37.6f, 0 6429 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 6430 path.lineTo(SkBits2Float(0x41840004), SkBits2Float(0xc291cccd)); // 16.5f, -72.9f 6431 path.lineTo(SkBits2Float(0x42fb6668), SkBits2Float(0x42c73334)); // 125.7f, 99.6f 6432 path.lineTo(SkBits2Float(0x43646668), SkBits2Float(0x43880ccd)); // 228.4f, 272.1f 6433 6434 SkPath path1(path); 6435 path.reset(); 6436 path.setFillType((SkPath::FillType) 0); 6437 path.moveTo(SkBits2Float(0x428bf702), SkBits2Float(0xcf223cbf)); // 69.9824f, -2.72189e+09f 6438 path.lineTo(SkBits2Float(0x42112d68), SkBits2Float(0xcf223cbf)); // 36.2943f, -2.72189e+09f 6439 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 6440 path.lineTo(SkBits2Float(0x424a99e0), SkBits2Float(0xcf223cc0)); // 50.6503f, -2.72189e+09f 6441 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 6442 path.lineTo(SkBits2Float(0x40f8fbe0), SkBits2Float(0xcf223cc0)); // 7.78075f, -2.72189e+09f 6443 6444 SkPath path2(path); 6445 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 6446 } 6447 6448 static void bug597926_0(skiatest::Reporter* reporter, const char* filename) { 6449 SkPath path; 6450 path.setFillType((SkPath::FillType) 0); 6451 path.moveTo(SkBits2Float(0x43b38000), SkBits2Float(0x433e0000)); // 359, 190 6452 path.lineTo(SkBits2Float(0x40c00000), SkBits2Float(0x449ce000)); // 6, 1255 6453 path.cubicTo(SkBits2Float(0x438c0000), SkBits2Float(0x4497a000), SkBits2Float(0x43e40000), SkBits2Float(0x44750000), SkBits2Float(0x41000000), SkBits2Float(0x44aa2000)); // 280, 1213, 456, 980, 8, 1361 6454 path.moveTo(SkBits2Float(0x43290000), SkBits2Float(0x4431c000)); // 169, 711 6455 path.lineTo(SkBits2Float(0xd987d6ba), SkBits2Float(0xd93d0ad4)); // -4.7794e+15f, -3.32567e+15f 6456 path.conicTo(SkBits2Float(0x43cc8000), SkBits2Float(0x445b8000), SkBits2Float(0xd888b096), SkBits2Float(0xd9a1ebfa), SkBits2Float(0x3ebcb199)); // 409, 878, -1.20234e+15f, -5.69712e+15f, 0.368542f 6457 path.cubicTo(SkBits2Float(0x43c00000), SkBits2Float(0x443a8000), SkBits2Float(0x42380000), SkBits2Float(0x4421c000), SkBits2Float(0x42500000), SkBits2Float(0x448ca000)); // 384, 746, 46, 647, 52, 1125 6458 path.quadTo(SkBits2Float(0x43948000), SkBits2Float(0x42ac0000), SkBits2Float(0x43880000), SkBits2Float(0x4487e000)); // 297, 86, 272, 1087 6459 SkPath path1(path); 6460 path.reset(); 6461 path.setFillType((SkPath::FillType) 0); 6462 path.moveTo(SkBits2Float(0xc51d735c), SkBits2Float(0xc49db029)); // -2519.21f, -1261.51f 6463 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 6464 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 6465 path.quadTo(SkBits2Float(0xc51bf7eb), SkBits2Float(0xc49cf010), SkBits2Float(0xc51ba866), SkBits2Float(0xc49cb9e6)); // -2495.49f, -1255.5f, -2490.52f, -1253.81f 6466 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 6467 SkPath path2(path); 6468 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6469 } 6470 6471 static void fuzz1450_0(skiatest::Reporter* reporter, const char* filename) { 6472 SkPath path; 6473 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f 6474 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 6475 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x43348000), SkBits2Float(0x43800001), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 180.5f, 256, 0.707107f 6476 SkPath path1(path); 6477 path.reset(); 6478 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 6479 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f 6480 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f 6481 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512 6482 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16 6483 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024 6484 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 6485 path.close(); 6486 SkPath path2(path); 6487 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename); 6488 } 6489 6490 static void fuzz1450_1(skiatest::Reporter* reporter, const char* filename) { 6491 SkPath path; 6492 path.setFillType(SkPath::kEvenOdd_FillType); 6493 path.moveTo(SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe)); // 1.07374e+09f, -1.07374e+09f 6494 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x43b40000), SkBits2Float(0xcf000000), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 360, -2.14748e+09f, 0.707107f 6495 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256 6496 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16 6497 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512 6498 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f 6499 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024 6500 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140 6501 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f 6502 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f 6503 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f 6504 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256 6505 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 1.07374e+09f, -1.07374e+09f, 0.707107f 6506 path.close(); 6507 SkPath path1(path); 6508 path.reset(); 6509 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321 6510 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270 6511 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08 6512 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64 6513 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321 6514 path.close(); 6515 SkPath path2(path); 6516 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename); 6517 } 6518 6519 static void fuzz763_9(skiatest::Reporter* reporter, const char* filename) { 6520 SkPath path; 6521 path.setFillType((SkPath::FillType) 1); 6522 6523 SkPath path1(path); 6524 path.reset(); 6525 path.setFillType((SkPath::FillType) 0); 6526 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6527 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 6528 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b)); // 1.99397e+36f, -4.84373e+27f 6529 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f 6530 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6531 path.close(); 6532 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6533 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6)); // -8.10388e-33f, 0.00148185f, 2.25206e-21f, 5.54035e+21f 6534 path.moveTo(SkBits2Float(0x29272a81), SkBits2Float(0x2ab03a55)); // 3.71183e-14f, 3.13044e-13f 6535 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x8a2f2121)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, -8.43217e-33f 6536 path.quadTo(SkBits2Float(0x373b3a27), SkBits2Float(0x201fc4c1), SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d)); // 1.11596e-05f, 1.35329e-19f, 2.98959e-15f, 2.8457e+15f 6537 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, 0.00105459f 6538 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 6539 path.quadTo(SkBits2Float(0xd912102a), SkBits2Float(0x284f9a28), SkBits2Float(0xb38a1f30), SkBits2Float(0x3a3ac23a)); // -2.56957e+15f, 1.15242e-14f, -6.4318e-08f, 0.000712428f 6540 path.lineTo(SkBits2Float(0xc809272a), SkBits2Float(0x29b02829)); // -140445, 7.82294e-14f 6541 6542 SkPath path2(path); 6543 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6544 } 6545 6546 6547 static void fuzz763_4(skiatest::Reporter* reporter, const char* filename) { 6548 SkPath path; 6549 path.setFillType((SkPath::FillType) 1); 6550 6551 SkPath path1(path); 6552 path.reset(); 6553 path.setFillType((SkPath::FillType) 0); 6554 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6555 path.lineTo(SkBits2Float(0x555b3a2d), SkBits2Float(0x2a212a8c)); // 1.50652e+13f, 1.43144e-13f 6556 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 6557 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac2b33a)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148544f 6558 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 6559 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6560 path.close(); 6561 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6562 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x2a21081f)); // 1.43144e-13f, 1.43025e-13f 6563 path.conicTo(SkBits2Float(0xde6a4b7b), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // -4.22068e+18f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589 6564 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6565 path.close(); 6566 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6567 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6568 path.lineTo(SkBits2Float(0x2928088c), SkBits2Float(0x2be61d2a)); // 3.73109e-14f, 1.63506e-12f 6569 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 6570 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 6571 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f 6572 path.close(); 6573 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6574 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 6575 6576 SkPath path2(path); 6577 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6578 } 6579 6580 static void fuzz763_3(skiatest::Reporter* reporter, const char* filename) { 6581 SkPath path; 6582 path.setFillType((SkPath::FillType) 1); 6583 6584 SkPath path1(path); 6585 path.reset(); 6586 path.setFillType((SkPath::FillType) 0); 6587 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6588 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f 6589 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 6590 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 6591 path.moveTo(SkBits2Float(0x25682929), SkBits2Float(0x212a8c5b)); // 2.01367e-16f, 5.7784e-19f 6592 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4a7bc0)); // 4.7323e-37f, 6.11969e+25f 6593 path.conicTo(SkBits2Float(0x032108ed), SkBits2Float(0x283a7bc0), SkBits2Float(0x47ed7a6a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21ff28)); // 4.73239e-37f, 1.03519e-14f, 121589, 9.4495e-15f, 0.000617968f 6594 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.00148185f, 1.50241e-13f, -1.38859e-25f 6595 path.lineTo(SkBits2Float(0x295b2d2a), SkBits2Float(0x2d296868)); // 4.86669e-14f, 9.62972e-12f 6596 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6597 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x898ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, -3.39271e-33f, 4.61198e-19f, 0.00096035f, 121589 6598 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6599 path.close(); 6600 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 6601 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0xb38a281a), SkBits2Float(0x29283ac2)); // -1.2117e+19f, 0.00105459f, -6.43342e-08f, 3.73545e-14f 6602 path.moveTo(SkBits2Float(0x962be61d), SkBits2Float(0x432a2927)); // -1.38859e-25f, 170.161f 6603 path.conicTo(SkBits2Float(0x3a2a552a), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42236)); // 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f 6604 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 6605 path.lineTo(SkBits2Float(0x272927b0), SkBits2Float(0x5b392929)); // 2.3475e-15f, 5.21181e+16f 6606 path.moveTo(SkBits2Float(0x3a1127b4), SkBits2Float(0x2921ee3b)); // 0.000553723f, 3.59558e-14f 6607 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 6608 path.moveTo(SkBits2Float(0x21081f3f), SkBits2Float(0x9fd4e62a)); // 4.61199e-19f, -9.01663e-20f 6609 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 6610 6611 SkPath path2(path); 6612 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6613 } 6614 6615 static void fuzz763_5(skiatest::Reporter* reporter, const char* filename) { 6616 SkPath path; 6617 path.setFillType((SkPath::FillType) 1); 6618 6619 SkPath path1(path); 6620 path.reset(); 6621 path.setFillType((SkPath::FillType) 0); 6622 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6623 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 6624 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6625 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 6626 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6627 path.close(); 6628 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6629 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589 6630 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6631 path.close(); 6632 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f 6633 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3b21), SkBits2Float(0x28ee4f9a), SkBits2Float(0x68293b78)); // -1.2117e+19f, 0.00105462f, 2.64578e-14f, 3.19671e+24f 6634 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d8c55)); // 4.87407e+16f, 4.88495e+16f 6635 6636 SkPath path2(path); 6637 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6638 } 6639 6640 static void fuzz763_2(skiatest::Reporter* reporter, const char* filename) { 6641 SkPath path; 6642 path.setFillType((SkPath::FillType) 1); 6643 6644 SkPath path1(path); 6645 path.reset(); 6646 path.setFillType((SkPath::FillType) 0); 6647 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6648 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f 6649 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 6650 path.lineTo(SkBits2Float(0x081f2ad7), SkBits2Float(0x7bc00321)); // 4.78977e-34f, 1.99397e+36f 6651 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6652 path.quadTo(SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28), SkBits2Float(0x29283ac2), SkBits2Float(0x962be62a)); // 2.58753e+09f, 0.00136978f, 3.73545e-14f, -1.38859e-25f 6653 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 6654 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 6655 path.lineTo(SkBits2Float(0x29292727), SkBits2Float(0x21475b3b)); // 3.75595e-14f, 6.75446e-19f 6656 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6657 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 6658 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 6659 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 6660 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f 6661 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 6662 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 6663 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 6664 path.quadTo(SkBits2Float(0x29210f21), SkBits2Float(0x282a085d), SkBits2Float(0xc2ab2127), SkBits2Float(0xa6800028)); // 3.57623e-14f, 9.43871e-15f, -85.5648f, -8.88183e-16f 6665 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6666 path.close(); 6667 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6668 path.quadTo(SkBits2Float(0x216a2770), SkBits2Float(0x2ab73b28), SkBits2Float(0x4b28f427), SkBits2Float(0x283b5b28)); // 7.93345e-19f, 3.25484e-13f, 1.10726e+07f, 1.04004e-14f 6669 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6670 path.close(); 6671 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f 6672 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 6673 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 6674 6675 SkPath path2(path); 6676 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6677 } 6678 6679 // crbug.com/626164 6680 static void fuzz763_1c(skiatest::Reporter* reporter, const char* filename) { 6681 SkPath path; 6682 path.setFillType((SkPath::FillType) 0); 6683 6684 SkPath path1(path); 6685 path.reset(); 6686 path.setFillType((SkPath::FillType) 0); 6687 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6688 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 6689 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f 6690 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 6691 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 6692 6693 SkPath path2(path); 6694 SkPath dummy; 6695 testPathOpFuzz(reporter, path1, path2, (SkPathOp)4, filename); 6696 } 6697 6698 // crbug.com/626186 6699 static void fuzz763_1b(skiatest::Reporter* reporter, const char* filename) { 6700 SkPath path; 6701 path.setFillType((SkPath::FillType) 0); 6702 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6703 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 6704 path.lineTo(SkBits2Float(0xda1905ed), SkBits2Float(0x3c05fbfb)); // -1.0768e+16f, 0.00817775f 6705 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 6706 6707 SkPath path1(path); 6708 path.reset(); 6709 path.setFillType((SkPath::FillType) 0); 6710 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6711 path.quadTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0xfa253c3c), SkBits2Float(0xfefa00d3), SkBits2Float(0x25fad9df)); // 0.011489f, -2.14488e+35f, -1.66156e+38f, 4.35157e-16f 6712 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6713 path.close(); 6714 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6715 path.lineTo(SkBits2Float(0x8dfefa00), SkBits2Float(0xf0f9fad9)); // -1.57141e-30f, -6.1892e+29f 6716 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 6717 6718 SkPath path2(path); 6719 testPathOpFuzz(reporter, path1, path2, (SkPathOp)2, filename); 6720 } 6721 6722 static void fuzz763_1a(skiatest::Reporter* reporter, const char* filename) { 6723 SkPath path; 6724 path.setFillType((SkPath::FillType) 0); 6725 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6726 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 6727 6728 SkPath path1(path); 6729 path.reset(); 6730 path.setFillType((SkPath::FillType) 0); 6731 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6732 path.quadTo(SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0xbd595959), SkBits2Float(0x3f3f3f09)); // 1.49562e+13f, 7.50652e+15f, -0.0530637f, 0.747056f 6733 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0x3f3f3f3f)); // 0.747059f, 0.747059f 6734 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6735 path.lineTo(SkBits2Float(0x09090909), SkBits2Float(0x3038d509)); // 1.6495e-33f, 6.72416e-10f 6736 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 6737 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6738 path.close(); 6739 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6740 path.lineTo(SkBits2Float(0x38d57f4b), SkBits2Float(0x59597f4b)); // 0.000101803f, 3.82625e+15f 6741 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f 6742 path.close(); 6743 path.moveTo(SkBits2Float(0x384700ff), SkBits2Float(0x0108804b)); // 4.74462e-05f, 2.50713e-38f 6744 6745 SkPath path2(path); 6746 testPathOpFuzz(reporter, path1, path2, (SkPathOp)0, filename); 6747 } 6748 6749 // crbug.com/627780 6750 static void fuzz763_3a(skiatest::Reporter* reporter, const char* filename) { 6751 SkPath path; 6752 path.setFillType((SkPath::FillType) 1); 6753 6754 SkPath path1(path); 6755 path.reset(); 6756 path.setFillType((SkPath::FillType) 0); 6757 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6758 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f 6759 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 6760 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6761 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 6762 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 6763 path.moveTo(SkBits2Float(0x8adf2028), SkBits2Float(0x3a219a3a)); // -2.14862e-32f, 0.000616464f 6764 path.quadTo(SkBits2Float(0x3ab38e28), SkBits2Float(0x29283ac2), SkBits2Float(0x2be61d2a), SkBits2Float(0x812a4396)); // 0.0013699f, 3.73545e-14f, 1.63506e-12f, -3.12726e-38f 6765 6766 SkPath path2(path); 6767 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 6768 } 6769 6770 // crbug.com/627689 6771 static void fuzz763_5a(skiatest::Reporter* reporter, const char* filename) { 6772 SkPath path; 6773 path.setFillType((SkPath::FillType) 1); 6774 path.moveTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0 6775 path.conicTo(SkBits2Float(0x4183d871), SkBits2Float(0x41fea321), SkBits2Float(0xb700ff00), SkBits2Float(0x4240b8b8), SkBits2Float(0x3b058283)); // 16.4807f, 31.8297f, -7.68877e-06f, 48.1804f, 0.0020372f 6776 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f 6777 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 6778 path.quadTo(SkBits2Float(0x3a51246a), SkBits2Float(0xb6da45a3), SkBits2Float(0x38bc5c3c), SkBits2Float(0x00000000)); // 0.000797814f, -6.50501e-06f, 8.98172e-05f, 0 6779 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f 6780 path.quadTo(SkBits2Float(0x39a32d2d), SkBits2Float(0x00000000), SkBits2Float(0xb8a13a00), SkBits2Float(0x00000000)); // 0.000311234f, 0, -7.68788e-05f, 0 6781 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f 6782 path.quadTo(SkBits2Float(0x39ba814c), SkBits2Float(0xb838fed2), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0.00035573f, -4.41063e-05f, 0, 0 6783 path.lineTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0 6784 path.close(); 6785 6786 SkPath path1(path); 6787 path.reset(); 6788 path.setFillType((SkPath::FillType) 0); 6789 6790 SkPath path2(path); 6791 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6792 } 6793 6794 // crbug.com/627401 6795 static void fuzz763_2a(skiatest::Reporter* reporter, const char* filename) { 6796 SkPath path; 6797 path.setFillType((SkPath::FillType) 1); 6798 6799 SkPath path1(path); 6800 path.reset(); 6801 path.setFillType((SkPath::FillType) 0); 6802 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6803 path.quadTo(SkBits2Float(0x3e484500), SkBits2Float(0x164f3a30), SkBits2Float(0x49484801), SkBits2Float(0x7d0100c8)); // 0.195576f, 1.67397e-25f, 820352, 1.07172e+37f 6804 path.conicTo(SkBits2Float(0xff7f36fd), SkBits2Float(0x3e647d01), SkBits2Float(0x0c00f430), SkBits2Float(0x486b6448), SkBits2Float(0x00484848)); // -3.39239e+38f, 0.223133f, 9.93424e-32f, 241041, 6.63809e-39f 6805 path.lineTo(SkBits2Float(0x4f4f557d), SkBits2Float(0x48480112)); // 3.47849e+09f, 204804 6806 path.lineTo(SkBits2Float(0xf40c01ff), SkBits2Float(0x45008000)); // -4.43702e+31f, 2056 6807 path.moveTo(SkBits2Float(0x4bfffa00), SkBits2Float(0x7d4ac859)); // 3.35514e+07f, 1.68465e+37f 6808 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 6809 6810 SkPath path2(path); 6811 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6812 } 6813 6814 // crbug.com/627761 6815 static void fuzz763_2b(skiatest::Reporter* reporter, const char* filename) { 6816 SkPath path; 6817 path.setFillType((SkPath::FillType) 1); 6818 6819 SkPath path1(path); 6820 path.reset(); 6821 path.setFillType((SkPath::FillType) 0); 6822 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f 6823 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6824 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f 6825 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 6826 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6827 path.close(); 6828 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6829 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 6830 path.lineTo(SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 4.78968e-34f, 1.99397e+36f 6831 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f 6832 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6833 path.close(); 6834 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f 6835 path.quadTo(SkBits2Float(0x8a4fc29a), SkBits2Float(0x3ab3283a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6)); // -1.00033e-32f, 0.00136686f, 2.25206e-21f, 300.343f 6836 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6837 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 6838 path.quadTo(SkBits2Float(0xc25d2757), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152), SkBits2Float(0x28d91210)); // -55.2884f, 0.000916855f, 1.2818e-13f, 2.40997e-14f 6839 path.quadTo(SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f 6840 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6841 path.close(); 6842 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6843 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 6844 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6845 path.close(); 6846 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f 6847 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x2d8a3a21), SkBits2Float(0x5b682b68), SkBits2Float(0x5b292d55)); // -1.2117e+19f, 1.57146e-11f, 6.53499e+16f, 4.76191e+16f 6848 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f)); // 1.43144e-13f, 4.7323e-37f 6849 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 6850 path.moveTo(SkBits2Float(0x21df2828), SkBits2Float(0x9a3a8a3a)); // 1.51217e-18f, -3.85756e-23f 6851 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x28273ac2), SkBits2Float(0xe61d2a29), SkBits2Float(0x2a63962b)); // 0.00136978f, 9.2831e-15f, -1.85547e+23f, 2.02138e-13f 6852 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 6853 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6854 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f 6855 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6856 path.close(); 6857 6858 SkPath path2(path); 6859 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 6860 } 6861 6862 static void fuzz763_2c(skiatest::Reporter* reporter, const char* filename) { 6863 SkPath path; 6864 path.setFillType((SkPath::FillType) 1); 6865 6866 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 0, 2.68653e-06f 6867 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x364a4a4a), SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0, 3.01436e-06f, 3.01436e-06f, 0, 0 6868 path.lineTo(SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000)); // 3.01436e-06f, 0 6869 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 6870 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 6871 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 6872 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 6873 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 6874 path.close(); 6875 SkPath path1(path); 6876 path.reset(); 6877 path.setFillType((SkPath::FillType) 0); 6878 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6879 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 6880 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f 6881 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 6882 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 6883 SkPath path2(path); 6884 testPathOpFuzz(reporter, path1, path2, kReverseDifference_SkPathOp, filename); 6885 } 6886 6887 static void fuzz763_6(skiatest::Reporter* reporter, const char* filename) { 6888 SkPath path; 6889 path.setFillType((SkPath::FillType) 1); 6890 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 6891 path.cubicTo(SkBits2Float(0x68295b2d), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 3.19905e+24f, 0, 0, 0, 0, 4.03114e+24f 6892 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 6893 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 6894 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 6895 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 6896 path.conicTo(SkBits2Float(0x68295b02), SkBits2Float(0x60f7f28b), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f), SkBits2Float(0x42784f5a)); // 3.19903e+24f, 1.42932e+20f, 0, 5.14279e+25f, 62.0775f 6897 path.close(); 6898 path.moveTo(SkBits2Float(0x654d6d10), SkBits2Float(0x00000000)); // 6.06311e+22f, 0 6899 path.lineTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000)); // 6.14991e+25f, 0 6900 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc0)); // 0, 6.14991e+25f 6901 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 6902 6903 SkPath path1(path); 6904 path.reset(); 6905 path.setFillType((SkPath::FillType) 0); 6906 path.moveTo(SkBits2Float(0x3ac23a55), SkBits2Float(0x2a292827)); // 0.00148184f, 1.50241e-13f 6907 path.lineTo(SkBits2Float(0x63962be6), SkBits2Float(0x272a812a)); // 5.54035e+21f, 2.36623e-15f 6908 6909 SkPath path2(path); 6910 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6911 } 6912 6913 static void fuzz763_7(skiatest::Reporter* reporter, const char* filename) { 6914 SkPath path; 6915 path.setFillType((SkPath::FillType) 0); 6916 6917 SkPath path1(path); 6918 path.reset(); 6919 path.setFillType((SkPath::FillType) 0); 6920 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 6921 path.moveTo(SkBits2Float(0x0f2a312a), SkBits2Float(0xc0032108)); // 8.39112e-30f, -2.04889f 6922 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 6923 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 6924 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f 6925 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 6926 path.lineTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f 6927 path.close(); 6928 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f 6929 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 6930 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6931 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f 6932 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f 6933 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f 6934 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 6935 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f 6936 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f 6937 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 6938 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 6939 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f 6940 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6941 path.close(); 6942 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6943 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 6944 path.moveTo(SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b)); // 9.16179e-12f, 1.5954e+13f 6945 path.moveTo(SkBits2Float(0x5529685b), SkBits2Float(0x11295b68)); // 1.16416e+13f, 1.33599e-28f 6946 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 6947 path.moveTo(SkBits2Float(0x555b8c55), SkBits2Float(0x21682929)); // 1.50872e+13f, 7.86591e-19f 6948 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6949 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 6950 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6951 path.close(); 6952 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6953 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 6954 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6955 path.close(); 6956 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6957 path.quadTo(SkBits2Float(0x2d28282a), SkBits2Float(0x5568295b), SkBits2Float(0x3a21df68), SkBits2Float(0x4f9a3a8a)); // 9.55861e-12f, 1.5954e+13f, 0.000617495f, 5.17506e+09f 6958 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6959 path.close(); 6960 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 6961 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 6962 6963 SkPath path2(path); 6964 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 6965 } 6966 6967 static void kfuzz2(skiatest::Reporter* reporter, const char* filename) { 6968 SkPath path1; 6969 SkPath path; 6970 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6971 path.close(); 6972 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6973 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 6974 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6975 path.close(); 6976 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6977 path.lineTo(SkBits2Float(0x60601a1d), SkBits2Float(0x60606060)); // 6.4593e+19f, 6.46721e+19f 6978 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f 6979 path.close(); 6980 path.moveTo(SkBits2Float(0xe5e2f300), SkBits2Float(0xee244a40)); // -1.33967e+23f, -1.27113e+28f 6981 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6982 path.close(); 6983 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6984 path.lineTo(SkBits2Float(0xfafafafa), SkBits2Float(0xe30000fa)); // -6.51582e+35f, -2.36125e+21f 6985 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 6986 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6987 path.close(); 6988 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6989 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 6990 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6991 path.close(); 6992 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6993 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 6994 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f 6995 path.close(); 6996 SkPath path2(path); 6997 testPathOpFuzz(reporter, path1, path2, kXOR_SkPathOp, filename); 6998 } 6999 7000 static void fuzz763_10(skiatest::Reporter* reporter, const char* filename) { 7001 SkPath path; 7002 path.setFillType((SkPath::FillType) 1); 7003 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f 7004 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7005 path.quadTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 6.14991e+25f, 0, 0, 6.14991e+25f 7006 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f 7007 path.close(); 7008 7009 SkPath path1(path); 7010 path.reset(); 7011 path.setFillType((SkPath::FillType) 0); 7012 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7013 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 4.87407e+16f, 2.49685e-13f 7014 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7015 path.close(); 7016 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7017 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 7018 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7019 path.close(); 7020 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7021 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a29)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121588 7022 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7023 path.close(); 7024 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7025 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 3.20001e+24f, 3.84878e-14f, 2.49282e-13f, 4.78969e-34f 7026 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 7027 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7028 path.close(); 7029 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7030 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a2129)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96181e-33f 7031 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f 7032 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f 7033 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7034 path.close(); 7035 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f 7036 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f 7037 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f 7038 7039 SkPath path2(path); 7040 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7041 } 7042 7043 static void fuzz763_11(skiatest::Reporter* reporter, const char* filename) { 7044 SkPath path; 7045 path.setFillType((SkPath::FillType) 0); 7046 7047 SkPath path1(path); 7048 path.reset(); 7049 path.setFillType((SkPath::FillType) 0); 7050 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7051 path.moveTo(SkBits2Float(0x2a0f312a), SkBits2Float(0xc0032108)); // 1.2718e-13f, -2.04889f 7052 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 7053 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 7054 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f 7055 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 7056 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f 7057 path.close(); 7058 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f 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.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f 7062 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x2a812a3b), SkBits2Float(0x2a552927)); // 2.25206e-21f, 300.343f, 2.29443e-13f, 1.89325e-13f 7063 path.quadTo(SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x203a3b27), SkBits2Float(0x22c5381f)); // 0.00241343f, 3.71093e-14f, 1.57744e-19f, 5.34564e-18f 7064 path.moveTo(SkBits2Float(0x5d27ec2a), SkBits2Float(0x705921c2)); // 7.56256e+17f, 2.68796e+29f 7065 path.quadTo(SkBits2Float(0x102a5152), SkBits2Float(0x5b2dd912), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 3.35892e-29f, 4.89338e+16f, 4.03114e+24f, 1.50617e+13f 7066 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032127)); // 3.60396e-20f, -2.0489f 7067 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 7068 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 7069 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 7070 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 7071 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 7072 path.close(); 7073 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 7074 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a21211f)); // 4.85282e+16f, 1.43112e-13f 7075 path.lineTo(SkBits2Float(0x03552a8c), SkBits2Float(0x6a4f7b28)); // 6.26439e-37f, 6.27073e+25f 7076 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 7077 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 7078 path.close(); 7079 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f 7080 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x262a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 5.91556e-16f, 0.000649768f 7081 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f 7082 path.conicTo(SkBits2Float(0x371f203a), SkBits2Float(0xc52a22c4), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x5210513a)); // 9.48464e-06f, -2722.17f, -55.289f, 0.000916855f, 1.5496e+11f 7083 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 7084 path.moveTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f 7085 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 7086 path.quadTo(SkBits2Float(0x2d685568), SkBits2Float(0x5568295b), SkBits2Float(0x2a552d29), SkBits2Float(0x295b2d27)); // 1.32066e-11f, 1.5954e+13f, 1.89339e-13f, 4.86669e-14f 7087 path.lineTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f 7088 path.close(); 7089 7090 SkPath path2(path); 7091 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7092 } 7093 7094 static void fuzz763_12(skiatest::Reporter* reporter, const char* filename) { 7095 SkPath path; 7096 path.setFillType((SkPath::FillType) 1); 7097 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7098 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a29082a)); // 0, 5.10868e+25f 7099 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 7100 path.conicTo(SkBits2Float(0x67aedf99), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f801112)); // 1.65163e+24f, 0, 0, 0, 1.00052f 7101 path.close(); 7102 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7103 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 6.14991e+25f, 0, 0, 4.03114e+24f, 1.50617e+13f 7104 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 7105 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 7106 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 7107 path.cubicTo(SkBits2Float(0x679158b0), SkBits2Float(0x00000000), SkBits2Float(0x67531e34), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.37276e+24f, 0, 9.96976e+23f, 0, 0, 0 7108 path.close(); 7109 7110 SkPath path1(path); 7111 path.reset(); 7112 path.setFillType((SkPath::FillType) 0); 7113 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7114 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 7115 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7116 path.close(); 7117 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7118 path.lineTo(SkBits2Float(0x3a6821df), SkBits2Float(0x2a8c3a8a)); // 0.000885514f, 2.49096e-13f 7119 path.moveTo(SkBits2Float(0x29272a1d), SkBits2Float(0xb03a2a55)); // 3.7118e-14f, -6.77266e-10f 7120 path.moveTo(SkBits2Float(0x20213b1e), SkBits2Float(0xc5272927)); // 1.36568e-19f, -2674.57f 7121 path.quadTo(SkBits2Float(0xc422373b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27), SkBits2Float(0x523a7059)); // -648.863f, -8.22676e+26f, 1.31706e-18f, 2.00187e+11f 7122 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 7123 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x555b2d29)); // 4.03113e+24f, 1.50617e+13f 7124 path.moveTo(SkBits2Float(0x1f2a212a), SkBits2Float(0x2d032108)); // 3.60263e-20f, 7.45382e-12f 7125 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // 4.03114e+24f, 1.89339e-13f 7126 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 7127 7128 SkPath path2(path); 7129 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7130 } 7131 7132 static void fuzz763_13(skiatest::Reporter* reporter, const char* filename) { 7133 SkPath path; 7134 path.setFillType((SkPath::FillType) 1); 7135 7136 SkPath path1(path); 7137 path.reset(); 7138 path.setFillType((SkPath::FillType) 0); 7139 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7140 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a)); // 6.14991e+25f, 75739, 9.4495e-15f, 0.00170234f, 2.58753e+09f 7141 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7142 path.close(); 7143 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7144 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 7145 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7146 path.close(); 7147 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7148 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 7149 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x68295b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.19905e+24f 7150 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f 7151 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 7152 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 7153 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 7154 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7155 path.close(); 7156 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7157 path.lineTo(SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 4.88097e+16f, 5.7784e-19f 7158 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 7159 path.lineTo(SkBits2Float(0x68295b68), SkBits2Float(0x2d296855)); // 3.19906e+24f, 9.6297e-12f 7160 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f 7161 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 7162 path.quadTo(SkBits2Float(0x6028282a), SkBits2Float(0x68292ddf), SkBits2Float(0x5b2d555b), SkBits2Float(0x68556829)); // 4.84679e+19f, 3.1957e+24f, 4.8789e+16f, 4.03114e+24f 7163 7164 SkPath path2(path); 7165 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7166 } 7167 7168 static void fuzz763_14(skiatest::Reporter* reporter, const char* filename) { 7169 SkPath path; 7170 path.setFillType((SkPath::FillType) 0); 7171 7172 SkPath path1(path); 7173 path.reset(); 7174 path.setFillType((SkPath::FillType) 0); 7175 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0xf45b2d29)); // 4.03114e+24f, -6.94598e+31f 7176 path.moveTo(SkBits2Float(0x1f2a302a), SkBits2Float(0xc8032108)); // 3.60387e-20f, -134276 7177 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 7178 7179 SkPath path2(path); 7180 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7181 } 7182 7183 static void fuzz763_15(skiatest::Reporter* reporter, const char* filename) { 7184 SkPath path; 7185 path.setFillType((SkPath::FillType) 1); 7186 7187 SkPath path1(path); 7188 path.reset(); 7189 path.setFillType((SkPath::FillType) 0); 7190 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f 7191 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 7192 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 7193 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 7194 path.close(); 7195 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 7196 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 7197 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x283ac221), SkBits2Float(0xe6432a29), SkBits2Float(0x2a96812b)); // 0.00136978f, 1.03672e-14f, -2.3041e+23f, 2.6735e-13f 7198 path.lineTo(SkBits2Float(0x5529272a), SkBits2Float(0x1eb03a2a)); // 1.16241e+13f, 1.86588e-20f 7199 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 7200 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f 7201 path.close(); 7202 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f 7203 path.close(); 7204 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f 7205 path.quadTo(SkBits2Float(0xc82763e7), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // -171408, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f 7206 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x8c555b2d)); // 4.03113e+24f, -1.64364e-31f 7207 path.moveTo(SkBits2Float(0x081f2a21), SkBits2Float(0x252d0321)); // 4.78968e-34f, 1.50064e-16f 7208 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2df068)); // 1.59583e+13f, 4.89595e+16f 7209 path.quadTo(SkBits2Float(0x2a1f2a8c), SkBits2Float(0x21482a21), SkBits2Float(0x4b7bc003), SkBits2Float(0x8ced3a6a)); // 1.41368e-13f, 6.78184e-19f, 1.64987e+07f, -3.65508e-31f 7210 path.moveTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f 7211 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 7212 path.lineTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f 7213 path.close(); 7214 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7215 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 7216 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7217 path.close(); 7218 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7219 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 7220 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x292a8c55), SkBits2Float(0x21081f2a)); // 3.20001e+24f, 3.84878e-14f, 3.78693e-14f, 4.61198e-19f 7221 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 7222 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7223 path.close(); 7224 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7225 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a21df)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96194e-33f 7226 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f 7227 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f 7228 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f 7229 path.close(); 7230 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f 7231 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f 7232 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f 7233 7234 SkPath path2(path); 7235 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7236 } 7237 7238 static void fuzz763_16(skiatest::Reporter* reporter, const char* filename) { 7239 SkPath path; 7240 path.setFillType((SkPath::FillType) 0); 7241 7242 SkPath path1(path); 7243 path.reset(); 7244 path.setFillType((SkPath::FillType) 0); 7245 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7246 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7247 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 7248 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 7249 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7250 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 7251 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7252 path.close(); 7253 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7254 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7255 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7256 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 7257 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 7258 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7259 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 7260 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7261 path.close(); 7262 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7263 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f 7264 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7265 path.close(); 7266 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7267 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7268 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7269 path.close(); 7270 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7271 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 7272 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 7273 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7274 path.close(); 7275 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7276 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7277 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f 7278 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 7279 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 7280 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7281 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 7282 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7283 path.close(); 7284 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7285 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f 7286 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 7287 path.lineTo(SkBits2Float(0x8c558c55), SkBits2Float(0x212a1f2a)); // -1.64512e-31f, 5.76395e-19f 7288 7289 SkPath path2(path); 7290 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7291 } 7292 7293 static void fuzz763_17(skiatest::Reporter* reporter, const char* filename) { 7294 SkPath path; 7295 path.setFillType((SkPath::FillType) 0); 7296 7297 SkPath path1(path); 7298 path.reset(); 7299 path.setFillType((SkPath::FillType) 0); 7300 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7301 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7302 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 7303 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 7304 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f 7305 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 7306 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7307 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7308 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 7309 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 7310 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7311 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 7312 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 7313 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7314 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7315 path.close(); 7316 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7317 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 7318 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 7319 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7320 path.close(); 7321 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7322 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7323 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7324 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 7325 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 7326 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7327 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f 7328 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7329 path.close(); 7330 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7331 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f 7332 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7333 path.close(); 7334 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f 7335 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 7336 path.lineTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f 7337 path.close(); 7338 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f 7339 path.lineTo(SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a)); // 1.16348e+26f, 0.000209024f 7340 7341 SkPath path2(path); 7342 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7343 } 7344 7345 static void fuzz763_18(skiatest::Reporter* reporter, const char* filename) { 7346 SkPath path; 7347 path.setFillType((SkPath::FillType) 0); 7348 7349 SkPath path1(path); 7350 path.reset(); 7351 path.setFillType((SkPath::FillType) 0); 7352 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7353 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7354 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 7355 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 7356 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f 7357 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 7358 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7359 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7360 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 7361 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 7362 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7363 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 7364 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 7365 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7366 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7367 path.close(); 7368 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7369 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 7370 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 7371 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7372 path.close(); 7373 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7374 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7375 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7376 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 7377 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 7378 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7379 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f 7380 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7381 path.close(); 7382 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7383 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f 7384 7385 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7386 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7387 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7388 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 7389 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 7390 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 7391 7392 SkPath path2(path); 7393 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7394 } 7395 7396 static void fuzz763_19(skiatest::Reporter* reporter, const char* filename) { 7397 SkPath path; 7398 path.setFillType((SkPath::FillType) 1); 7399 7400 SkPath path1(path); 7401 path.reset(); 7402 path.setFillType((SkPath::FillType) 0); 7403 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f 7404 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 9.43289e-15f, 1.61207e+25f 7405 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7406 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 7407 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7408 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7409 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 7410 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 7411 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7412 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 7413 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 7414 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7415 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7416 path.close(); 7417 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7418 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 7419 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 7420 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7421 path.close(); 7422 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7423 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7424 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7425 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 7426 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 7427 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7428 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 7429 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7430 path.close(); 7431 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7432 path.lineTo(SkBits2Float(0x555b2c29), SkBits2Float(0x6c212a8c)); // 1.50614e+13f, 7.79352e+26f 7433 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 7434 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 7435 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7436 path.close(); 7437 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7438 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f 7439 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7440 path.close(); 7441 7442 SkPath path2(path); 7443 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7444 } 7445 7446 static void fuzz763_20(skiatest::Reporter* reporter, const char* filename) { 7447 SkPath path; 7448 path.setFillType((SkPath::FillType) 0); 7449 7450 SkPath path1(path); 7451 path.reset(); 7452 path.setFillType((SkPath::FillType) 0); 7453 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7454 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7455 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 7456 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 7457 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7458 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 7459 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7460 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7461 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 7462 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 7463 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7464 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 7465 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7466 path.close(); 7467 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7468 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f 7469 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7470 path.close(); 7471 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7472 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7473 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7474 path.close(); 7475 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7476 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 7477 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 7478 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7479 path.close(); 7480 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7481 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x8c555b2d)); // 4.03114e+24f, -1.64364e-31f 7482 path.moveTo(SkBits2Float(0x081f2a31), SkBits2Float(0xc0032921)); // 4.78969e-34f, -2.04939f 7483 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 7484 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 7485 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7486 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 7487 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7488 path.close(); 7489 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7490 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f 7491 path.lineTo(SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830)); // 4.88298e+16f, -2.64185e+29f 7492 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7493 path.close(); 7494 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7495 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 7496 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x212128c0)); // -1.31678e-31f, 5.46029e-19f 7497 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f 7498 path.close(); 7499 7500 SkPath path2(path); 7501 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7502 } 7503 7504 static void fuzz763_21(skiatest::Reporter* reporter, const char* filename) { 7505 SkPath path; 7506 path.setFillType((SkPath::FillType) 1); 7507 path.moveTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f 7508 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 7509 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 7510 path.lineTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f 7511 path.close(); 7512 path.moveTo(SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 3.0681e+24f, 1.65068e+23f 7513 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 7514 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 7515 path.lineTo(SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.1893e+24f, 1.56583e+23f 7516 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 7517 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 7518 path.close(); 7519 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 7520 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 7521 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 7522 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 7523 path.close(); 7524 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 7525 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f 7526 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 7527 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 7528 path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x492bb324)); // 3.19904e+24f, 0, 0, 0, 703282 7529 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 7530 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68156829)); // 0, 2.82222e+24f 7531 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f 7532 path.lineTo(SkBits2Float(0x673918f3), SkBits2Float(0x681b0f5f)); // 8.74098e+23f, 2.929e+24f 7533 path.lineTo(SkBits2Float(0x67391759), SkBits2Float(0x681b0fae)); // 8.74068e+23f, 2.92902e+24f 7534 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 7535 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 7536 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f 7537 path.close(); 7538 7539 SkPath path1(path); 7540 path.reset(); 7541 path.setFillType((SkPath::FillType) 0); 7542 7543 SkPath path2(path); 7544 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 7545 } 7546 7547 static void fuzz763_22(skiatest::Reporter* reporter, const char* filename) { 7548 SkPath path; 7549 path.setFillType((SkPath::FillType) 1); 7550 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f 7551 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7552 path.lineTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x00000000)); // 5.63611e+25f, 0 7553 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a034b21)); // 0, 3.9681e+25f 7554 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f 7555 path.close(); 7556 path.moveTo(SkBits2Float(0x6617da56), SkBits2Float(0x00000000)); // 1.79276e+23f, 0 7557 path.conicTo(SkBits2Float(0x5e704d09), SkBits2Float(0x5e3a4dfd), SkBits2Float(0x00000000), SkBits2Float(0x65eb62ef), SkBits2Float(0x430fa5e6)); // 4.32888e+18f, 3.35617e+18f, 0, 1.38948e+23f, 143.648f 7558 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 7559 path.conicTo(SkBits2Float(0x62743d2d), SkBits2Float(0x5e49b862), SkBits2Float(0x6617da56), SkBits2Float(0x00000000), SkBits2Float(0x410ef54c)); // 1.12635e+21f, 3.63387e+18f, 1.79276e+23f, 0, 8.93489f 7560 path.close(); 7561 7562 SkPath path1(path); 7563 path.reset(); 7564 path.setFillType((SkPath::FillType) 0); 7565 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7566 path.quadTo(SkBits2Float(0x4f9a3a8a), SkBits2Float(0xc28a0d28), SkBits2Float(0x273a3ab3), SkBits2Float(0x8b2a2928)); // 5.17506e+09f, -69.0257f, 2.58445e-15f, -3.27718e-32f 7567 path.lineTo(SkBits2Float(0x63283ae6), SkBits2Float(0x27282a81)); // 3.1033e+21f, 2.33377e-15f 7568 7569 SkPath path2(path); 7570 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 7571 } 7572 7573 static void fuzz763_23(skiatest::Reporter* reporter, const char* filename) { 7574 SkPath path; 7575 path.setFillType((SkPath::FillType) 0); 7576 7577 SkPath path1(path); 7578 path.reset(); 7579 path.setFillType((SkPath::FillType) 0); 7580 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7581 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7582 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 7583 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 7584 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7585 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 7586 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f 7587 path.close(); 7588 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7589 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7590 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 7591 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 7592 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7593 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 7594 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f 7595 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f 7596 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7597 path.close(); 7598 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7599 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 7600 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 7601 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f 7602 path.close(); 7603 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7604 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7605 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7606 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 7607 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 7608 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 7609 7610 SkPath path2(path); 7611 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7612 } 7613 7614 static void fuzz763_24(skiatest::Reporter* reporter, const char* filename) { 7615 SkPath path; 7616 path.setFillType((SkPath::FillType) 1); 7617 7618 SkPath path1(path); 7619 path.reset(); 7620 path.setFillType((SkPath::FillType) 0); 7621 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f 7622 path.close(); 7623 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f 7624 path.quadTo(SkBits2Float(0x9fb9c16e), SkBits2Float(0x27737375), SkBits2Float(0xb7c5ff00), SkBits2Float(0x00ff9908)); // -7.86706e-20f, 3.37856e-15f, -2.3603e-05f, 2.34729e-38f 7625 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7626 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 7627 path.quadTo(SkBits2Float(0x04007f41), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec41ec)); // 1.51048e-36f, -2.2914e+27f, -2.2914e+27f, -2.28494e+27f 7628 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7629 path.close(); 7630 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7631 path.quadTo(SkBits2Float(0x000000ec), SkBits2Float(0xececcc00), SkBits2Float(0x48ececec), SkBits2Float(0x0278806e)); // 3.30706e-43f, -2.29016e+27f, 485223, 1.8257e-37f 7632 path.lineTo(SkBits2Float(0x72ececec), SkBits2Float(0xecec02ec)); // 9.38559e+30f, -2.28256e+27f 7633 path.quadTo(SkBits2Float(0xec04007f), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec0400)); // -6.38322e+26f, -2.2914e+27f, -2.2914e+27f, -2.2826e+27f 7634 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7635 path.close(); 7636 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7637 path.quadTo(SkBits2Float(0x000040ec), SkBits2Float(0x3a333300), SkBits2Float(0xecec3333), SkBits2Float(0xececdbec)); // 2.32896e-41f, 0.000683591f, -2.28439e+27f, -2.29076e+27f 7638 path.lineTo(SkBits2Float(0x3300007f), SkBits2Float(0x33d83333)); // 2.98028e-08f, 1.00676e-07f 7639 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7640 path.close(); 7641 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7642 path.quadTo(SkBits2Float(0x9e9ea900), SkBits2Float(0x33ececec), SkBits2Float(0xececec33), SkBits2Float(0xec336e6e)); // -1.67988e-20f, 1.10327e-07f, -2.29138e+27f, -8.67677e+26f 7643 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7644 path.close(); 7645 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7646 path.lineTo(SkBits2Float(0xedededed), SkBits2Float(0xedededed)); // -9.20445e+27f, -9.20445e+27f 7647 path.lineTo(SkBits2Float(0xecececec), SkBits2Float(0xecececec)); // -2.2914e+27f, -2.2914e+27f 7648 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7649 path.close(); 7650 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7651 path.lineTo(SkBits2Float(0x01003300), SkBits2Float(0x33d83333)); // 2.35465e-38f, 1.00676e-07f 7652 path.quadTo(SkBits2Float(0xecec3333), SkBits2Float(0x04eeedec), SkBits2Float(0xe0e0e0e0), SkBits2Float(0x9ee0e0e0)); // -2.28439e+27f, 5.6172e-36f, -1.29634e+20f, -2.38099e-20f 7653 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7654 path.close(); 7655 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f 7656 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 7657 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 7658 7659 SkPath path2(path); 7660 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7661 } 7662 7663 static void fuzz763_25(skiatest::Reporter* reporter, const char* filename) { 7664 SkPath path; 7665 path.setFillType((SkPath::FillType) 1); 7666 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f 7667 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 7668 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 7669 path.lineTo(SkBits2Float(0x68555b29), SkBits2Float(0x00000000)); // 4.03018e+24f, 0 7670 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x682d2927), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6829686f)); // 0, 3.27091e+24f, 0, 0, 3.20003e+24f 7671 path.lineTo(SkBits2Float(0xdf218a28), SkBits2Float(0x00000000)); // -1.16402e+19f, 0 7672 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f 7673 path.close(); 7674 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7675 path.conicTo(SkBits2Float(0x6642c40c), SkBits2Float(0x00000000), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3edcd74d)); // 2.29939e+23f, 0, 8.52382e+22f, 5.00576e+25f, 0.43133f 7676 path.conicTo(SkBits2Float(0x68295afa), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x4277a57b)); // 3.19903e+24f, 0, 0, 0, 61.9116f 7677 path.close(); 7678 7679 SkPath path1(path); 7680 path.reset(); 7681 path.setFillType((SkPath::FillType) 0); 7682 7683 SkPath path2(path); 7684 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7685 } 7686 7687 7688 static void fuzz763_26(skiatest::Reporter* reporter, const char* filename) { 7689 SkPath path; 7690 path.setFillType((SkPath::FillType) 0); 7691 7692 SkPath path1(path); 7693 path.reset(); 7694 path.setFillType((SkPath::FillType) 0); 7695 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7696 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc003210a)); // 3.60396e-20f, -2.04889f 7697 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 7698 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 7699 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7700 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 7701 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7702 path.close(); 7703 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f 7704 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7705 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7706 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 7707 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 7708 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7709 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 7710 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7711 path.close(); 7712 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7713 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f 7714 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7715 path.close(); 7716 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7717 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2127ed29)); // 2.25206e-21f, 300.343f, 0.000650423f, 5.68957e-19f 7718 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 7719 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 7720 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f 7721 path.close(); 7722 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f 7723 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x5b2d5529)); // 4.03114e+24f, 4.87888e+16f 7724 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f 7725 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 7726 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 7727 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7728 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 7729 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7730 path.close(); 7731 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7732 path.lineTo(SkBits2Float(0x555b1b29), SkBits2Float(0x6c212a8c)); // 1.50569e+13f, 7.79352e+26f 7733 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 7734 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 7735 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7736 path.close(); 7737 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7738 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f 7739 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f 7740 path.close(); 7741 7742 SkPath path2(path); 7743 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7744 } 7745 7746 static void fuzz763_28(skiatest::Reporter* reporter, const char* filename) { 7747 SkPath path; 7748 path.setFillType((SkPath::FillType) 0); 7749 7750 SkPath path1(path); 7751 path.reset(); 7752 path.setFillType((SkPath::FillType) 0); 7753 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7754 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7755 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 7756 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 7757 path.moveTo(SkBits2Float(0x6c395b2d), SkBits2Float(0xf0682955)); // 8.96327e+26f, -2.87402e+29f 7758 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 7759 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7760 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7761 path.lineTo(SkBits2Float(0x8a283a28), SkBits2Float(0x284f1a3a)); // -8.09984e-33f, 1.14965e-14f 7762 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f 7763 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f 7764 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 7765 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f 7766 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f 7767 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 7768 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 7769 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f 7770 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7771 path.close(); 7772 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7773 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 7774 path.lineTo(SkBits2Float(0x5b2d212d), SkBits2Float(0x2d556829)); // 4.87316e+16f, 1.21308e-11f 7775 path.moveTo(SkBits2Float(0x68552968), SkBits2Float(0x5568295b)); // 4.02651e+24f, 1.5954e+13f 7776 path.moveTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f 7777 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f 7778 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 7779 7780 SkPath path2(path); 7781 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7782 } 7783 7784 static void fuzz763_27(skiatest::Reporter* reporter, const char* filename) { 7785 SkPath path; 7786 path.setFillType((SkPath::FillType) 0); 7787 7788 SkPath path1(path); 7789 path.reset(); 7790 path.setFillType((SkPath::FillType) 0); 7791 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7792 path.quadTo(SkBits2Float(0x30309ab8), SkBits2Float(0x305b3030), SkBits2Float(0x00f53030), SkBits2Float(0x3a3a0000)); // 6.42483e-10f, 7.97402e-10f, 2.2517e-38f, 0.000709534f 7793 path.quadTo(SkBits2Float(0xb8b8d5b8), SkBits2Float(0x0b0b0b03), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a0b0b)); // -8.81361e-05f, 2.67787e-32f, 2.67787e-32f, 0.000709698f 7794 path.quadTo(SkBits2Float(0xb8b8b8b8), SkBits2Float(0x0b1203b8), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a2110)); // -8.80821e-05f, 2.81214e-32f, 2.67787e-32f, 0.000710026f 7795 7796 SkPath path2(path); 7797 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7798 } 7799 7800 static void fuzz763_29(skiatest::Reporter* reporter, const char* filename) { 7801 SkPath path; 7802 path.setFillType((SkPath::FillType) 1); 7803 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7804 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x743e0000)); // 0, 6.02134e+31f 7805 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 7806 path.quadTo(SkBits2Float(0x74360ca0), SkBits2Float(0x7401e10c), SkBits2Float(0x7436a382), SkBits2Float(0x7401cc18)); // 5.76937e+31f, 4.11603e+31f, 5.78805e+31f, 4.11344e+31f 7807 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 7808 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 7809 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 7810 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 7811 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 7812 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 7813 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 7814 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7815 path.close(); 7816 7817 SkPath path1(path); 7818 path.reset(); 7819 path.setFillType((SkPath::FillType) 0); 7820 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7821 path.lineTo(SkBits2Float(0xf0682955), SkBits2Float(0x211f5b2d)); // -2.87402e+29f, 5.3992e-19f 7822 path.moveTo(SkBits2Float(0x2d2aff2d), SkBits2Float(0x74747474)); // 9.72004e-12f, 7.74708e+31f 7823 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 7824 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 7825 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 7826 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 7827 7828 SkPath path2(path); 7829 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7830 } 7831 7832 static void fuzz763_30(skiatest::Reporter* reporter, const char* filename) { 7833 SkPath path; 7834 path.setFillType((SkPath::FillType) 1); 7835 7836 SkPath path1(path); 7837 path.reset(); 7838 path.setFillType((SkPath::FillType) 0); 7839 path.moveTo(SkBits2Float(0x1f2108c0), SkBits2Float(0x4b7b0321)); // 3.41003e-20f, 1.64503e+07f 7840 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 7841 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f 7842 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 7843 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f 7844 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x4b7b28c0)); // 4.7323e-37f, 1.646e+07f 7845 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x2d081f21)); // 2.50338e-13f, 7.73762e-12f 7846 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7847 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7848 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 7849 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 7850 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 7851 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 7852 path.lineTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7853 path.close(); 7854 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7855 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x3ac22c21), SkBits2Float(0x6c401057), SkBits2Float(0x6d6d6b64)); // 0.00136978f, 0.00148142f, 9.28764e+26f, 4.59236e+27f 7856 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 7857 7858 SkPath path2(path); 7859 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7860 } 7861 7862 static void fuzz763_31(skiatest::Reporter* reporter, const char* filename) { 7863 SkPath path; 7864 path.setFillType((SkPath::FillType) 1); 7865 7866 SkPath path1(path); 7867 path.reset(); 7868 path.setFillType((SkPath::FillType) 0); 7869 path.moveTo(SkBits2Float(0xd72a8c55), SkBits2Float(0x61081f2a)); // -1.8752e+14f, 1.56938e+20f 7870 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf3a2128), SkBits2Float(0x471ac575)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.3412e+19f, 39621.5f 7871 path.lineTo(SkBits2Float(0x28404040), SkBits2Float(0x552a298a)); // 1.06721e-14f, 1.16935e+13f 7872 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7873 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 7874 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7875 path.close(); 7876 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7877 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 7878 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7879 path.close(); 7880 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f 7881 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 7882 7883 SkPath path2(path); 7884 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7885 } 7886 7887 static void fuzz763_33(skiatest::Reporter* reporter, const char* filename) { 7888 SkPath path; 7889 path.setFillType((SkPath::FillType) 1); 7890 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f 7891 path.quadTo(SkBits2Float(0x724341bf), SkBits2Float(0x72433fc4), SkBits2Float(0x6d757575), SkBits2Float(0x6d6d6d6d)); // 3.86746e+30f, 3.86731e+30f, 4.74786e+27f, 4.59251e+27f 7892 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 7893 path.conicTo(SkBits2Float(0x6c6c8b72), SkBits2Float(0x00000000), SkBits2Float(0x6c6c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x400812df)); // 1.14386e+27f, 0, 1.14327e+27f, 0, 2.12615f 7894 path.quadTo(SkBits2Float(0x72432acb), SkBits2Float(0x72432295), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 3.86568e+30f, 3.86505e+30f, 7.66623e+30f, 7.66608e+30f 7895 path.close(); 7896 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f 7897 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 7898 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 7899 path.close(); 7900 path.moveTo(SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.14323e+27f, 3.11171e+27f 7901 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 7902 path.lineTo(SkBits2Float(0x6a674231), SkBits2Float(0x6c0c3394)); // 6.98936e+25f, 6.77973e+26f 7903 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 7904 path.close(); 7905 7906 SkPath path1(path); 7907 path.reset(); 7908 path.setFillType((SkPath::FillType) 0); 7909 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7910 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f 7911 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f 7912 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 7913 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x95066b78)); // 2.01583e+34f, -2.71459e-26f 7914 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f 7915 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f 7916 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 7917 path.lineTo(SkBits2Float(0x8787878f), SkBits2Float(0x87878787)); // -2.03922e-34f, -2.03922e-34f 7918 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7919 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7920 path.lineTo(SkBits2Float(0x6c105778), SkBits2Float(0x6d406b64)); // 6.97994e+26f, 3.72193e+27f 7921 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 7922 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 7923 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7924 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7925 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 7926 path.lineTo(SkBits2Float(0xb4bcacbc), SkBits2Float(0xbcadbcbc)); // -3.51434e-07f, -0.0212082f 7927 path.moveTo(SkBits2Float(0xa03aacbc), SkBits2Float(0x757575a0)); // -1.5812e-19f, 3.11157e+32f 7928 path.close(); 7929 7930 SkPath path2(path); 7931 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 7932 } 7933 7934 static void fuzz763_32(skiatest::Reporter* reporter, const char* filename) { 7935 SkPath path; 7936 path.setFillType((SkPath::FillType) 1); 7937 7938 SkPath path1(path); 7939 path.reset(); 7940 path.setFillType((SkPath::FillType) 0); 7941 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7942 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 7943 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 7944 path.moveTo(SkBits2Float(0xe0f2f210), SkBits2Float(0xc3f2eef2)); // -1.40049e+20f, -485.867f 7945 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 7946 path.moveTo(SkBits2Float(0x556c0010), SkBits2Float(0x002a8768)); // 1.62178e+13f, 3.90567e-39f 7947 path.quadTo(SkBits2Float(0xf2f22021), SkBits2Float(0xf2f2f56e), SkBits2Float(0xf2f2f2f2), SkBits2Float(0xf22040d9)); // -9.59158e+30f, -9.62459e+30f, -9.6242e+30f, -3.17414e+30f 7948 path.lineTo(SkBits2Float(0xc013f2f2), SkBits2Float(0x0000294d)); // -2.3117f, 1.48159e-41f 7949 7950 SkPath path2(path); 7951 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 7952 } 7953 7954 static void fuzz763_34(skiatest::Reporter* reporter, const char* filename) { 7955 SkPath path; 7956 path.setFillType((SkPath::FillType) 1); 7957 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7958 path.quadTo(SkBits2Float(0x63690f37), SkBits2Float(0x6d0a3d9b), SkBits2Float(0x00000000), SkBits2Float(0x6d3e3e3e)); // 4.29919e+21f, 2.67396e+27f, 0, 3.67984e+27f 7959 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 7960 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0 7961 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 7962 path.conicTo(SkBits2Float(0x6c8c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6cc8e82a), SkBits2Float(0x5b684b68)); // 1.35809e+27f, 0, 0, 1.94305e+27f, 6.53851e+16f 7963 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7964 path.close(); 7965 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7966 path.quadTo(SkBits2Float(0x641ae35f), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.14287e+22f, 0, 0, 0 7967 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0 7968 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 7969 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f 7970 path.close(); 7971 7972 SkPath path1(path); 7973 path.reset(); 7974 path.setFillType((SkPath::FillType) 0); 7975 path.moveTo(SkBits2Float(0x6c3e3e3e), SkBits2Float(0x586c79ff)); // 9.19959e+26f, 1.04003e+15f 7976 path.quadTo(SkBits2Float(0x6c6c4a6c), SkBits2Float(0x6c6c6c6c), SkBits2Float(0xc83e6c6c), SkBits2Float(0x3e313e3e)); // 1.14263e+27f, 1.14327e+27f, -194994, 0.173089f 7977 7978 SkPath path2(path); 7979 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 7980 } 7981 7982 static void fuzz763_36(skiatest::Reporter* reporter, const char* filename) { 7983 SkPath path; 7984 path.setFillType((SkPath::FillType) 0); 7985 7986 SkPath path1(path); 7987 path.reset(); 7988 path.setFillType((SkPath::FillType) 0); 7989 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f 7990 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f 7991 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 7992 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 7993 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7994 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 7995 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7996 path.close(); 7997 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 7998 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 7999 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 8000 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 8001 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 8002 path.close(); 8003 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f 8004 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 8005 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8006 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 8007 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8008 path.close(); 8009 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8010 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3adf21), SkBits2Float(0x284f1a3a), SkBits2Float(0x213ab38a)); // 9.4456e-15f, -8.99754e-33f, 1.14965e-14f, 6.32569e-19f 8011 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8012 path.close(); 8013 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8014 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a20002a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000610354f, 2.50336e-13f 8015 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8016 path.close(); 8017 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8018 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 8019 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4341f20), SkBits2Float(0xecc52a22)); // 2.22225e-15f, 0.000713932f, -720.486f, -1.90686e+27f 8020 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 8021 path.lineTo(SkBits2Float(0x1f2a2a8c), SkBits2Float(0x03210821)); // 3.60341e-20f, 4.7323e-37f 8022 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8023 path.close(); 8024 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8025 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 8026 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8027 path.close(); 8028 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8029 path.quadTo(SkBits2Float(0xe61d2a28), SkBits2Float(0x2a43962b), SkBits2Float(0x29272a81), SkBits2Float(0x2bb02a55)); // -1.85547e+23f, 1.73716e-13f, 3.71183e-14f, 1.25173e-12f 8030 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3ac52729), SkBits2Float(0xc4223b32), SkBits2Float(0x6c2a201f)); // 2.22225e-15f, 0.00150416f, -648.925f, 8.22676e+26f 8031 8032 SkPath path2(path); 8033 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8034 } 8035 8036 static void fuzz763_35(skiatest::Reporter* reporter, const char* filename) { 8037 SkPath path; 8038 path.setFillType((SkPath::FillType) 1); 8039 8040 SkPath path1(path); 8041 path.reset(); 8042 path.setFillType((SkPath::FillType) 0); 8043 path.moveTo(SkBits2Float(0x2aed2a8c), SkBits2Float(0x03210a1f)); // 4.21292e-13f, 4.73253e-37f 8044 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 8045 path.quadTo(SkBits2Float(0x74747474), SkBits2Float(0x74747474), SkBits2Float(0x20437474), SkBits2Float(0x43a52b02)); // 7.74708e+31f, 7.74708e+31f, 1.65557e-19f, 330.336f 8046 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f 8047 path.lineTo(SkBits2Float(0x4b7bd603), SkBits2Float(0x6cf33b6a)); // 1.65043e+07f, 2.3524e+27f 8048 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 8049 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 8050 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 8051 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 8052 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 8053 path.lineTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f 8054 path.close(); 8055 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f 8056 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 8057 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 8058 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x742974e8)); // 7.74706e+31f, 5.3703e+31f 8059 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 8060 path.moveTo(SkBits2Float(0x31292768), SkBits2Float(0x212d2aff)); // 2.46151e-09f, 5.86716e-19f 8061 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a), SkBits2Float(0x00002a49)); // 5.69738e-19f, 1.08774e-08f, 3.42981e+33f, 1.51691e-41f 8062 path.moveTo(SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 8063 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 8064 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 8065 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 8066 path.lineTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 8067 path.close(); 8068 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f 8069 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 8070 8071 SkPath path2(path); 8072 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8073 } 8074 8075 static void fuzz763_37(skiatest::Reporter* reporter, const char* filename) { 8076 SkPath path; 8077 path.setFillType((SkPath::FillType) 0); 8078 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2d3368)); // 1.59583e+13f, 4.87517e+16f 8079 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 8080 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 8081 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8082 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 8083 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 8084 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 8085 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 8086 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8087 path.close(); 8088 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8089 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 8090 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8091 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 8092 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8093 path.close(); 8094 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8095 path.quadTo(SkBits2Float(0x28282a2a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.33502e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f 8096 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 8097 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8098 path.close(); 8099 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8100 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 8101 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8102 path.close(); 8103 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8104 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 8105 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8106 path.close(); 8107 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8108 path.lineTo(SkBits2Float(0x8ced293a), SkBits2Float(0x5c5c5c5c)); // -3.65404e-31f, 2.48104e+17f 8109 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f 8110 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f 8111 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f 8112 path.lineTo(SkBits2Float(0x682d2952), SkBits2Float(0xee682103)); // 3.27093e+24f, -1.79601e+28f 8113 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a3b0355)); // 4.85282e+16f, 1.66101e-13f 8114 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f 8115 path.close(); 8116 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f 8117 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 8118 8119 SkPath path1(path); 8120 path.reset(); 8121 path.setFillType((SkPath::FillType) 0); 8122 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8123 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 8124 8125 SkPath path2(path); 8126 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8127 } 8128 8129 static void fuzz763_38(skiatest::Reporter* reporter, const char* filename) { 8130 SkPath path; 8131 path.setFillType((SkPath::FillType) 0); 8132 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8133 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 8134 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8135 path.close(); 8136 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8137 path.close(); 8138 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8139 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x2ac05252), SkBits2Float(0x727fb721)); // 4.80216e+30f, 2.25832e+11f, 3.41632e-13f, 5.06496e+30f 8140 path.lineTo(SkBits2Float(0x73727322), SkBits2Float(0x555b2d29)); // 1.92088e+31f, 1.50617e+13f 8141 path.lineTo(SkBits2Float(0xab2a212e), SkBits2Float(0x7a27872a)); // -6.04422e-13f, 2.17464e+35f 8142 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f 8143 path.quadTo(SkBits2Float(0x52524852), SkBits2Float(0x72525228), SkBits2Float(0x72727272), SkBits2Float(0x3a727272)); // 2.25789e+11f, 4.16584e+30f, 4.80216e+30f, 0.000924862f 8144 path.lineTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f 8145 path.close(); 8146 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f 8147 path.quadTo(SkBits2Float(0x2a292827), SkBits2Float(0x962b0080), SkBits2Float(0x5252752a), SkBits2Float(0x72725252)); // 1.50241e-13f, -1.38134e-25f, 2.25977e+11f, 4.79967e+30f 8148 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79967e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 8149 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda000072), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.00732e+15f, 2.25867e+11f, 2.25831e+11f 8150 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f 8151 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f 8152 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f 8153 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f 8154 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f 8155 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 8156 path.close(); 8157 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 8158 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x3a727272), SkBits2Float(0x28273ac2), SkBits2Float(0x00802a29)); // 4.80216e+30f, 0.000924862f, 9.2831e-15f, 1.17701e-38f 8159 path.lineTo(SkBits2Float(0x52752a96), SkBits2Float(0x72525252)); // 2.63245e+11f, 4.16585e+30f 8160 path.quadTo(SkBits2Float(0x72525272), SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272)); // 4.16586e+30f, 2.25966e+11f, 2.25831e+11f, 4.80216e+30f 8161 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f 8162 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 8163 path.close(); 8164 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 8165 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f 8166 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x72525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 4.16585e+30f 8167 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x72727252), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada)); // 4.80216e+30f, 4.80215e+30f, -9.04113e+15f, 2.25867e+11f 8168 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 8169 path.close(); 8170 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f 8171 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f 8172 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f 8173 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f 8174 path.moveTo(SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 2.34994e+11f, 2.25831e+11f 8175 path.close(); 8176 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8177 path.close(); 8178 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8179 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 8180 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f 8181 path.quadTo(SkBits2Float(0x52525272), SkBits2Float(0x3b3b0052), SkBits2Float(0x5b2d553a), SkBits2Float(0x68556829)); // 2.25832e+11f, 0.00285341f, 4.87889e+16f, 4.03114e+24f 8182 8183 SkPath path1(path); 8184 path.reset(); 8185 path.setFillType((SkPath::FillType) 0); 8186 path.moveTo(SkBits2Float(0x52528c55), SkBits2Float(0x29215252)); // 2.26074e+11f, 3.58206e-14f 8187 8188 SkPath path2(path); 8189 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8190 } 8191 8192 static void fuzz763_41(skiatest::Reporter* reporter, const char* filename) { 8193 SkPath path; 8194 path.setFillType((SkPath::FillType) 0); 8195 8196 SkPath path1(path); 8197 path.reset(); 8198 path.setFillType((SkPath::FillType) 0); 8199 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8200 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f 8201 path.quadTo(SkBits2Float(0x00057272), SkBits2Float(0x72ff0000), SkBits2Float(0xba405e72), SkBits2Float(0x031b0074)); // 5.00233e-40f, 1.01016e+31f, -0.000733829f, 4.55509e-37f 8202 path.lineTo(SkBits2Float(0x664af700), SkBits2Float(0x56397d39)); // 2.39619e+23f, 5.09869e+13f 8203 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300e4), SkBits2Float(0x257c0c9f), SkBits2Float(0x72400006)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 3.80295e+30f 8204 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x030000ff), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ec4000)); // -0.000836826f, 3.7617e-37f, 1.17894e+32f, -8.92527e+24f 8205 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f 8206 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x08727272), SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // -1.83687e-37f, 7.29588e-34f, 4.09355e-34f, 4.09355e-34f 8207 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f 8208 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f 8209 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 8210 path.quadTo(SkBits2Float(0x00800039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 1.1755e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f 8211 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f 8212 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f 8213 path.lineTo(SkBits2Float(0x666d0100), SkBits2Float(0x726efe62)); // 2.79805e+23f, 4.73376e+30f 8214 path.lineTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f 8215 path.close(); 8216 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f 8217 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 8218 path.quadTo(SkBits2Float(0x72057272), SkBits2Float(0x8c7a3472), SkBits2Float(0x72727272), SkBits2Float(0x00f6475e)); // 2.64319e+30f, -1.92751e-31f, 4.80216e+30f, 2.26171e-38f 8219 path.moveTo(SkBits2Float(0x6d106d43), SkBits2Float(0x6efe6266)); // 2.79362e+27f, 3.93641e+28f 8220 path.quadTo(SkBits2Float(0x72727a05), SkBits2Float(0xba5b7272), SkBits2Float(0x03000074), SkBits2Float(0x5aff00e8)); // 4.80274e+30f, -0.000837124f, 3.76163e-37f, 3.58886e+16f 8221 path.quadTo(SkBits2Float(0x00da0039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 2.00202e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f 8222 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f 8223 path.lineTo(SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // -4.56078e+36f, 50176.2f 8224 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62766d01)); // 1.03774e-38f, 1.13644e+21f 8225 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f 8226 8227 SkPath path2(path); 8228 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8229 } 8230 8231 static void fuzz763_40(skiatest::Reporter* reporter, const char* filename) { 8232 SkPath path; 8233 path.setFillType((SkPath::FillType) 1); 8234 8235 SkPath path1(path); 8236 path.reset(); 8237 path.setFillType((SkPath::FillType) 0); 8238 path.moveTo(SkBits2Float(0x10190004), SkBits2Float(0x7272727a)); // 3.01739e-29f, 4.80216e+30f 8239 path.quadTo(SkBits2Float(0xf3db5e64), SkBits2Float(0x5b97fc16), SkBits2Float(0x000039fc), SkBits2Float(0x01008000)); // -3.47604e+31f, 8.55598e+16f, 2.08009e-41f, 2.36017e-38f 8240 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x41720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 15.1251f 8241 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f 8242 path.lineTo(SkBits2Float(0x01000000), SkBits2Float(0x10010004)); // 2.35099e-38f, 2.54408e-29f 8243 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 8244 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f 8245 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f 8246 path.lineTo(SkBits2Float(0x72000000), SkBits2Float(0x5b5e72b4)); // 2.5353e+30f, 6.26136e+16f 8247 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 1.13998e-35f, 4.80216e+30f, 6.26133e+16f 8248 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 8249 path.moveTo(SkBits2Float(0x72008972), SkBits2Float(0x458fe705)); // 2.54594e+30f, 4604.88f 8250 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xe8727272), SkBits2Float(0xba5b5e03), SkBits2Float(0x03000074)); // 1.73224e+35f, -4.5797e+24f, -0.00083682f, 3.76163e-37f 8251 path.lineTo(SkBits2Float(0xf3dbff00), SkBits2Float(0x00397d16)); // -3.48598e+31f, 5.2795e-39f 8252 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 8253 8254 SkPath path2(path); 8255 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8256 } 8257 8258 static void fuzz763_39(skiatest::Reporter* reporter, const char* filename) { 8259 SkPath path; 8260 path.setFillType((SkPath::FillType) 0); 8261 8262 SkPath path1(path); 8263 path.reset(); 8264 path.setFillType((SkPath::FillType) 0); 8265 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8266 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f 8267 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f 8268 path.lineTo(SkBits2Float(0x664aff00), SkBits2Float(0x56397d39)); // 2.39655e+23f, 5.09869e+13f 8269 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300ff), SkBits2Float(0x257c0c9f), SkBits2Float(0x72787257)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 4.92099e+30f 8270 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ecff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.95346e+24f 8271 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f 8272 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x72727272), SkBits2Float(0x724adf00), SkBits2Float(0x00397d39)); // -1.83687e-37f, 4.80216e+30f, 4.01828e+30f, 5.27954e-39f 8273 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x16f3abab), SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // 1.73224e+35f, 3.93671e-25f, -4.56078e+36f, 50176.2f 8274 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62767201)); // 1.03774e-38f, 1.13653e+21f 8275 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f 8276 8277 SkPath path2(path); 8278 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8279 } 8280 8281 8282 static void fuzz763_42(skiatest::Reporter* reporter, const char* filename) { 8283 SkPath path; 8284 path.setFillType((SkPath::FillType) 0); 8285 8286 SkPath path1(path); 8287 path.reset(); 8288 path.setFillType((SkPath::FillType) 0); 8289 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8290 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x05720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 1.13789e-35f 8291 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f 8292 path.lineTo(SkBits2Float(0x724aff00), SkBits2Float(0x56397d39)); // 4.02075e+30f, 5.09869e+13f 8293 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xfa8d00ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a)); // 1.73224e+35f, -3.66067e+35f, 2.10289e-16f, 4.80216e+30f 8294 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8e0ff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.50011e+24f 8295 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 8296 path.quadTo(SkBits2Float(0x00397d39), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x385e7272)); // 5.27954e-39f, 1.13998e-35f, 4.80216e+30f, 5.30355e-05f 8297 path.quadTo(SkBits2Float(0x057200ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.1379e-35f, 2.10289e-16f, 4.80216e+30f, 6.26133e+16f 8298 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 8299 path.quadTo(SkBits2Float(0x2b2d16f3), SkBits2Float(0x0039fc4d), SkBits2Float(0x68800000), SkBits2Float(0x0100fafa)); // 6.14938e-13f, 5.32513e-39f, 4.8357e+24f, 2.369e-38f 8300 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f 8301 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f 8302 path.lineTo(SkBits2Float(0x72720000), SkBits2Float(0xff725b5e)); // 4.7933e+30f, -3.22148e+38f 8303 path.moveTo(SkBits2Float(0x72720572), SkBits2Float(0x5b5e2572)); // 4.79373e+30f, 6.25286e+16f 8304 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x25727272), SkBits2Float(0x72728c7a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 2.10289e-16f, 4.80417e+30f, 6.26133e+16f 8305 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 8306 path.quadTo(SkBits2Float(0x97fc16f3), SkBits2Float(0x0039fc5b), SkBits2Float(0x00f6472e), SkBits2Float(0x01008000)); // -1.62909e-24f, 5.32515e-39f, 2.26171e-38f, 2.36017e-38f 8307 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f 8308 8309 SkPath path2(path); 8310 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8311 } 8312 8313 static void fuzz763_43(skiatest::Reporter* reporter, const char* filename) { 8314 SkPath path; 8315 path.setFillType((SkPath::FillType) 1); 8316 8317 SkPath path1(path); 8318 path.reset(); 8319 path.setFillType((SkPath::FillType) 0); 8320 path.moveTo(SkBits2Float(0x5c386c3a), SkBits2Float(0x4e691a3e)); // 2.07642e+17f, 9.77703e+08f 8321 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 8322 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 8323 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 8324 path.close(); 8325 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 8326 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 8327 path.lineTo(SkBits2Float(0x438a0b9c), SkBits2Float(0x60a1d2c8)); // 276.091f, 9.32848e+19f 8328 path.quadTo(SkBits2Float(0xe13fb902), SkBits2Float(0x07ee536f), SkBits2Float(0x971d8ac1), SkBits2Float(0x2f9f174b)); // -2.21041e+20f, 3.58593e-34f, -5.09046e-25f, 2.89385e-10f 8329 path.lineTo(SkBits2Float(0x0f2cf5d8), SkBits2Float(0xe271654c)); // 8.5276e-30f, -1.11324e+21f 8330 path.lineTo(SkBits2Float(0xe6cf24d2), SkBits2Float(0xd9537742)); // -4.89105e+23f, -3.72015e+15f 8331 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 8332 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 8333 path.lineTo(SkBits2Float(0xda45ad4e), SkBits2Float(0xedce4a04)); // -1.39103e+16f, -7.98042e+27f 8334 path.lineTo(SkBits2Float(0xac0e45da), SkBits2Float(0x8f632841)); // -2.02182e-12f, -1.11997e-29f 8335 path.lineTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 8336 path.close(); 8337 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f 8338 path.quadTo(SkBits2Float(0xf35c4ad5), SkBits2Float(0x0692f251), SkBits2Float(0x69632126), SkBits2Float(0xb927af67)); // -1.74534e+31f, 5.52751e-35f, 1.71614e+25f, -0.000159917f 8339 path.moveTo(SkBits2Float(0x6534bff9), SkBits2Float(0x434a9986)); // 5.3348e+22f, 202.6f 8340 path.quadTo(SkBits2Float(0x37c603e5), SkBits2Float(0xa0683953), SkBits2Float(0x751915e4), SkBits2Float(0x831c911a)); // 2.36053e-05f, -1.96701e-19f, 1.94059e+32f, -4.60108e-37f 8341 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 8342 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 8343 8344 SkPath path2(path); 8345 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8346 } 8347 8348 static void fuzz763_44(skiatest::Reporter* reporter, const char* filename) { 8349 SkPath path; 8350 path.setFillType((SkPath::FillType) 1); 8351 path.moveTo(SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 3.36945e+36f, 1.01083e+37f 8352 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0x7ccaca6d), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 8.4236e+36f, 0, 0 8353 path.lineTo(SkBits2Float(0x7d7d7d7d), SkBits2Float(0x00000000)); // 2.10591e+37f, 0 8354 path.quadTo(SkBits2Float(0x7ccacab0), SkBits2Float(0x7d1817f4), SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 8.42364e+36f, 1.26354e+37f, 3.36945e+36f, 1.01083e+37f 8355 path.close(); 8356 8357 SkPath path1(path); 8358 path.reset(); 8359 path.setFillType((SkPath::FillType) 0); 8360 path.moveTo(SkBits2Float(0x109d0000), SkBits2Float(0xff7bc000)); // 6.19256e-29f, -3.34633e+38f 8361 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 8362 path.quadTo(SkBits2Float(0x72728302), SkBits2Float(0x8b727272), SkBits2Float(0x72727272), SkBits2Float(0xc00308f6)); // 4.80344e+30f, -4.66936e-32f, 4.80216e+30f, -2.04742f 8363 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 8364 8365 SkPath path2(path); 8366 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8367 } 8368 8369 static void fuzz763_45(skiatest::Reporter* reporter, const char* filename) { 8370 SkPath path; 8371 path.setFillType((SkPath::FillType) 0); 8372 8373 SkPath path1(path); 8374 path.reset(); 8375 path.setFillType((SkPath::FillType) 0); 8376 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8377 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 8378 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 8379 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 8380 path.moveTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8381 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f 8382 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 8383 path.lineTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f 8384 path.close(); 8385 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f 8386 path.lineTo(SkBits2Float(0x7f303030), SkBits2Float(0x7a303030)); // 2.34194e+38f, 2.28705e+35f 8387 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 8388 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 8389 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 8390 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f 8391 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 8392 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 8393 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 8394 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 8395 path.moveTo(SkBits2Float(0x77303030), SkBits2Float(0xff303030)); // 3.57352e+33f, -2.34194e+38f 8396 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 8397 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x77303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.57352e+33f, 6.40969e-10f 8398 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 8399 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a7a3030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 3.24763e+35f 8400 SkPath path2(path); 8401 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8402 } 8403 8404 static void fuzz763_46(skiatest::Reporter* reporter, const char* filename) { 8405 SkPath path; 8406 path.setFillType((SkPath::FillType) 0); 8407 8408 SkPath path1(path); 8409 path.reset(); 8410 path.setFillType((SkPath::FillType) 0); 8411 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8412 path.conicTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x44263030), SkBits2Float(0x44304430), SkBits2Float(0x4c444430)); // 785.067f, 785.067f, 664.753f, 705.065f, 5.145e+07f 8413 path.moveTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444)); // 785.067f, 785.067f 8414 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 8415 SkPath path2(path); 8416 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8417 } 8418 8419 static void fuzz763_47(skiatest::Reporter* reporter, const char* filename) { 8420 SkPath path; 8421 path.setFillType((SkPath::FillType) 1); 8422 8423 SkPath path1(path); 8424 path.reset(); 8425 path.setFillType((SkPath::FillType) 0); 8426 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8427 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 8428 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 8429 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8430 path.close(); 8431 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8432 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 1.43144e-13f, 4.79393e+30f 8433 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x5974fa80), SkBits2Float(0x00747474), SkBits2Float(0x59585264)); // 4.80216e+30f, 4.30971e+15f, 1.06947e-38f, 3.80557e+15f 8434 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 8435 path.quadTo(SkBits2Float(0x80807d80), SkBits2Float(0x80808080), SkBits2Float(0xff7f0000), SkBits2Float(0x80808080)); // -1.18e-38f, -1.1801e-38f, -3.38953e+38f, -1.1801e-38f 8436 path.quadTo(SkBits2Float(0x80808080), SkBits2Float(0x80808080), SkBits2Float(0xed842b00), SkBits2Float(0x7252ff6d)); // -1.1801e-38f, -1.1801e-38f, -5.113e+27f, 4.17924e+30f 8437 path.quadTo(SkBits2Float(0x72577200), SkBits2Float(0x55525352), SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 4.26733e+30f, 1.44535e+13f, 1.43144e-13f, 4.79393e+30f 8438 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x6f740080), SkBits2Float(0x8c556874), SkBits2Float(0x2982ffff)); // 4.80216e+30f, 7.55149e+28f, -1.64404e-31f, 5.81757e-14f 8439 8440 SkPath path2(path); 8441 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8442 } 8443 8444 static void fuzz763_48(skiatest::Reporter* reporter, const char* filename) { 8445 SkPath path; 8446 path.setFillType((SkPath::FillType) 1); 8447 8448 SkPath path1(path); 8449 path.reset(); 8450 path.setFillType((SkPath::FillType) 0); 8451 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8452 path.lineTo(SkBits2Float(0xed0081bc), SkBits2Float(0x1b2d8040)); // -2.48568e+27f, 1.43517e-22f 8453 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f 8454 path.close(); 8455 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f 8456 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 8457 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 8458 path.lineTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f 8459 path.close(); 8460 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8461 path.close(); 8462 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8463 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52524872), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.2579e+11f, 4.16585e+30f, 4.80216e+30f 8464 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x80406666), SkBits2Float(0x68291b2d), SkBits2Float(0x0315ff80)); // 4.80215e+30f, -5.91421e-39f, 3.19432e+24f, 4.40805e-37f 8465 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 8466 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8467 path.close(); 8468 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8469 path.quadTo(SkBits2Float(0x72727227), SkBits2Float(0x72727272), SkBits2Float(0x74727272), SkBits2Float(0x55747421)); // 4.80214e+30f, 4.80216e+30f, 7.68345e+31f, 1.67987e+13f 8470 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f 8471 path.close(); 8472 path.moveTo(SkBits2Float(0x724b0000), SkBits2Float(0x00725f72)); // 4.02083e+30f, 1.05035e-38f 8473 path.lineTo(SkBits2Float(0x52525252), SkBits2Float(0x72725252)); // 2.25831e+11f, 4.79967e+30f 8474 path.quadTo(SkBits2Float(0x26727272), SkBits2Float(0x0303a525), SkBits2Float(0x52005c03), SkBits2Float(0x72525252)); // 8.41157e-16f, 3.8687e-37f, 1.37825e+11f, 4.16585e+30f 8475 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x1ff07255), SkBits2Float(0x2a8c5572), SkBits2Float(0x21082a21)); // 4.80216e+30f, 1.01833e-19f, 2.49283e-13f, 4.61343e-19f 8476 path.lineTo(SkBits2Float(0x2a2a3a21), SkBits2Float(0x29212828)); // 1.51192e-13f, 3.5784e-14f 8477 8478 SkPath path2(path); 8479 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8480 } 8481 8482 static void fuzz763_49(skiatest::Reporter* reporter, const char* filename) { 8483 SkPath path; 8484 path.setFillType((SkPath::FillType) 0); 8485 8486 SkPath path1(path); 8487 path.reset(); 8488 path.setFillType((SkPath::FillType) 0); 8489 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8490 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 8491 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 8492 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 8493 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f 8494 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x78787878), SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 6.40969e-10f, 2.01583e+34f, 2.01583e+34f, 2.01583e+34f 8495 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8496 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8497 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8498 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8499 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8500 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8501 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8502 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8503 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8504 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8505 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8506 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8507 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f 8508 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x7878788d)); // 2.01583e+34f, 2.01584e+34f 8509 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 2.01583e+34f, 6.40969e-10f 8510 8511 SkPath path2(path); 8512 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8513 } 8514 8515 static void fuzz763_50(skiatest::Reporter* reporter, const char* filename) { 8516 SkPath path; 8517 path.setFillType((SkPath::FillType) 1); 8518 path.moveTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0 8519 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x74fc5b97), SkBits2Float(0x7d458fe4)); // 0, 0, 0, 1.59951e+32f, 1.64128e+37f 8520 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0 8521 path.lineTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0 8522 path.close(); 8523 path.moveTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0 8524 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8525 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0 8526 path.close(); 8527 8528 SkPath path1(path); 8529 path.reset(); 8530 path.setFillType((SkPath::FillType) 0); 8531 8532 SkPath path2(path); 8533 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8534 } 8535 8536 static void fuzz763_51(skiatest::Reporter* reporter, const char* filename) { 8537 SkPath path; 8538 path.setFillType((SkPath::FillType) 1); 8539 8540 SkPath path1(path); 8541 path.reset(); 8542 path.setFillType((SkPath::FillType) 0); 8543 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8544 path.quadTo(SkBits2Float(0x868b5aae), SkBits2Float(0x626c45ab), SkBits2Float(0xefea1ffe), SkBits2Float(0x0029fc76)); // -5.24192e-35f, 1.08961e+21f, -1.44916e+29f, 3.85582e-39f 8545 path.moveTo(SkBits2Float(0xfacbff01), SkBits2Float(0x56fc5b97)); // -5.29604e+35f, 1.38735e+14f 8546 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 8547 8548 SkPath path2(path); 8549 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8550 } 8551 8552 static void fuzz763_52(skiatest::Reporter* reporter, const char* filename) { 8553 SkPath path; 8554 path.setFillType((SkPath::FillType) 1); 8555 8556 SkPath path1(path); 8557 path.reset(); 8558 path.setFillType((SkPath::FillType) 0); 8559 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8560 path.quadTo(SkBits2Float(0x29ff4bae), SkBits2Float(0xa1d75590), SkBits2Float(0x9fd6f6c3), SkBits2Float(0x70621ede)); // 1.13374e-13f, -1.45916e-18f, -9.10408e-20f, 2.79924e+29f 8561 path.quadTo(SkBits2Float(0x57a839d3), SkBits2Float(0x1a80d34b), SkBits2Float(0x0147a31b), SkBits2Float(0xff7fffff)); // 3.69933e+14f, 5.32809e-23f, 3.66675e-38f, -3.40282e+38f 8562 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8563 path.close(); 8564 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8565 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 8566 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8567 path.close(); 8568 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8569 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 8570 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8571 path.close(); 8572 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8573 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 8574 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f 8575 path.close(); 8576 8577 SkPath path2(path); 8578 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8579 } 8580 8581 static void fuzz763_53(skiatest::Reporter* reporter, const char* filename) { 8582 SkPath path; 8583 path.setFillType((SkPath::FillType) 1); 8584 path.moveTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0 8585 path.lineTo(SkBits2Float(0x74fc5b97), SkBits2Float(0x77df944a)); // 1.59951e+32f, 9.06945e+33f 8586 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf8fbe3ff)); // 0, -4.08716e+34f 8587 path.lineTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0 8588 path.close(); 8589 8590 SkPath path1(path); 8591 path.reset(); 8592 path.setFillType((SkPath::FillType) 0); 8593 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8594 path.quadTo(SkBits2Float(0x45ab86ae), SkBits2Float(0xd6d6626c), SkBits2Float(0xd6d6d6d6), SkBits2Float(0x7644d6d6)); // 5488.83f, -1.17859e+14f, -1.18109e+14f, 9.98093e+32f 8595 path.moveTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f 8596 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 8597 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 8598 path.lineTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f 8599 path.close(); 8600 path.moveTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f 8601 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 8602 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 8603 path.lineTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f 8604 path.close(); 8605 8606 SkPath path2(path); 8607 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8608 } 8609 8610 // hangs 654939 8611 static void fuzz763_54(skiatest::Reporter* reporter, const char* filename) { 8612 SkPath path; 8613 path.setFillType((SkPath::FillType) 0); 8614 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8615 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 8616 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 8617 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8618 path.close(); 8619 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8620 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 8621 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5252525a), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // -4.79387e+14f, 2.25831e+11f, 4.16585e+30f, 4.80216e+30f 8622 path.quadTo(SkBits2Float(0x48525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 215369, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f 8623 path.quadTo(SkBits2Float(0xdada007b), SkBits2Float(0x5252525a), SkBits2Float(0x72675252), SkBits2Float(0x72727272)); // -3.0681e+16f, 2.25831e+11f, 4.5818e+30f, 4.80216e+30f 8624 path.quadTo(SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 2.25831e+11f, 3.36289e-15f, 4.80216e+30f, 4.80216e+30f 8625 path.quadTo(SkBits2Float(0x1c292172), SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa), SkBits2Float(0x8c556a4b)); // 5.59606e-22f, 1.99397e+36f, -7.05861e-23f, -1.64409e-31f 8626 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f 8627 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8628 path.close(); 8629 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8630 path.close(); 8631 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8632 path.quadTo(SkBits2Float(0x72725570), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79991e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 8633 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x555bb672), SkBits2Float(0x29686968), SkBits2Float(0x252a081f)); // 4.80215e+30f, 1.50985e+13f, 5.16058e-14f, 1.47479e-16f 8634 path.moveTo(SkBits2Float(0x5d68392a), SkBits2Float(0x01002780)); // 1.04584e+18f, 2.35382e-38f 8635 path.moveTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f 8636 path.quadTo(SkBits2Float(0x5adada00), SkBits2Float(0xa5252652), SkBits2Float(0x727272ad), SkBits2Float(0xda007b72)); // 3.08006e+16f, -1.43245e-16f, 4.80218e+30f, -9.04113e+15f 8637 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f 8638 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8639 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x74217472), SkBits2Float(0x005b5574), SkBits2Float(0x72680000)); // 4.80216e+30f, 5.11671e+31f, 8.38768e-39f, 4.59523e+30f 8640 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada)); // 4.80216e+30f, 2.25831e+11f, 1.13368e-38f, 2.34994e+11f 8641 path.lineTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f 8642 path.close(); 8643 8644 SkPath path1(path); 8645 path.reset(); 8646 path.setFillType((SkPath::FillType) 0); 8647 8648 SkPath path2(path); 8649 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename); 8650 } 8651 8652 8653 // afl crash 8654 static void fuzz763_55(skiatest::Reporter* reporter, const char* filename) { 8655 SkPath path; 8656 path.setFillType((SkPath::FillType) 0); 8657 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f 8658 path.lineTo(SkBits2Float(0x55555568), SkBits2Float(0x55555555)); // 1.46602e+13f, 1.46602e+13f 8659 path.lineTo(SkBits2Float(0x98989898), SkBits2Float(0x55989898)); // -3.94452e-24f, 2.09726e+13f 8660 path.lineTo(SkBits2Float(0xf6f65555), SkBits2Float(0x101006f6)); // -2.49812e+33f, 2.84044e-29f 8661 path.quadTo(SkBits2Float(0xdca33f10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf621f6f6), SkBits2Float(0xf70ff6f6)); // -3.67598e+17f, -2.50452e+33f, -8.21259e+32f, -2.91995e+33f 8662 path.lineTo(SkBits2Float(0x9400f6f6), SkBits2Float(0x10530000)); // -6.51105e-27f, 4.16124e-29f 8663 path.quadTo(SkBits2Float(0x0f101010), SkBits2Float(0x00101010), SkBits2Float(0xf610f720), SkBits2Float(0xf6f6f6f6)); // 7.10284e-30f, 1.47513e-39f, -7.35062e+32f, -2.50452e+33f 8664 path.lineTo(SkBits2Float(0x105352f6), SkBits2Float(0x1cf6ff10)); // 4.16763e-29f, 1.63448e-21f 8665 path.lineTo(SkBits2Float(0xf6f6220a), SkBits2Float(0x003700f6)); // -2.49608e+33f, 5.0513e-39f 8666 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 8667 path.quadTo(SkBits2Float(0x10101007), SkBits2Float(0x10f7fd10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf6f645e0)); // 2.84113e-29f, 9.78142e-29f, -2.50452e+33f, -2.4975e+33f 8668 path.lineTo(SkBits2Float(0xed9ef6f6), SkBits2Float(0x53535353)); // -6.14965e+27f, 9.07636e+11f 8669 path.lineTo(SkBits2Float(0x53006cf6), SkBits2Float(0x53295353)); // 5.51584e+11f, 7.27247e+11f 8670 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f 8671 path.close(); 8672 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f 8673 path.lineTo(SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5353d9f6)); // -2.50452e+33f, 9.09895e+11f 8674 8675 SkPath path1(path); 8676 path.reset(); 8677 path.setFillType((SkPath::FillType) 0); 8678 8679 SkPath path2(path); 8680 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8681 } 8682 8683 // 656149 8684 static void fuzz763_56(skiatest::Reporter* reporter, const char* filename) { 8685 SkPath path; 8686 path.setFillType((SkPath::FillType) 0); 8687 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8688 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 8689 path.quadTo(SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f 8690 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x00005252)); // -4.79387e+14f, 3.08006e+16f, 2.25831e+11f, 2.9531e-41f 8691 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 8692 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8693 path.close(); 8694 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8695 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255), SkBits2Float(0xda007b72)); // 4.79967e+30f, 4.80216e+30f, 4.80215e+30f, -9.04113e+15f 8696 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f 8697 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8698 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa)); // 1.99397e+36f, -7.05861e-23f 8699 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f 8700 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8701 path.close(); 8702 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8703 path.close(); 8704 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f 8705 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f 8706 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x26525ada), SkBits2Float(0x72ada525)); // 4.80215e+30f, -9.04113e+15f, 7.29815e-16f, 6.87879e+30f 8707 path.quadTo(SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x72727252)); // 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 4.80215e+30f 8708 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72722772), SkBits2Float(0x72727272)); // 2.25966e+11f, 2.25831e+11f, 4.79636e+30f, 4.80216e+30f 8709 path.quadTo(SkBits2Float(0x74727272), SkBits2Float(0x55747421), SkBits2Float(0x0000005b), SkBits2Float(0x72727268)); // 7.68345e+31f, 1.67987e+13f, 1.27518e-43f, 4.80216e+30f 8710 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x72557272)); // 2.25966e+11f, 2.25831e+11f, 4.80216e+30f, 4.22775e+30f 8711 path.quadTo(SkBits2Float(0x5adada72), SkBits2Float(0x52525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272)); // 3.08009e+16f, 2.25831e+11f, 4.79967e+30f, 4.80216e+30f 8712 8713 SkPath path1(path); 8714 path.reset(); 8715 path.setFillType((SkPath::FillType) 0); 8716 8717 SkPath path2(path); 8718 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8719 } 8720 8721 static void fuzz763_57(skiatest::Reporter* reporter, const char* filename) { 8722 SkPath path; 8723 path.setFillType((SkPath::FillType) 0); 8724 8725 SkPath path1(path); 8726 path.reset(); 8727 path.setFillType((SkPath::FillType) 0); 8728 path.moveTo(SkBits2Float(0x68546829), SkBits2Float(0x555b2d29)); // 4.01225e+24f, 1.50617e+13f 8729 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0x4b7b2108)); // 3.60404e-20f, 1.6458e+07f 8730 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f 8731 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f 8732 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 8733 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x3b2a8c55)); // 4.85282e+16f, 0.00260236f 8734 path.lineTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f 8735 path.close(); 8736 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f 8737 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 8738 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 8739 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 8740 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8741 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 8742 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f 8743 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 8744 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 8745 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8746 path.close(); 8747 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f 8748 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f 8749 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8750 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 8751 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8752 path.close(); 8753 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8754 path.quadTo(SkBits2Float(0x2828102a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.32938e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f 8755 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 8756 path.lineTo(SkBits2Float(0x3a803adf), SkBits2Float(0x8a294f1a)); // 0.000978317f, -8.15193e-33f 8757 path.quadTo(SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x093a2a81), SkBits2Float(0x5c5c8ced)); // 3.49912e-14f, 1.73993e-13f, 2.24089e-33f, 2.48318e+17f 8758 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8759 path.close(); 8760 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f 8761 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 8762 path.lineTo(SkBits2Float(0x1f212a8c), SkBits2Float(0xc0032108)); // 3.41283e-20f, -2.04889f 8763 path.lineTo(SkBits2Float(0xed847b4b), SkBits2Float(0x2d552829)); // -5.12513e+27f, 1.21166e-11f 8764 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 8765 8766 SkPath path2(path); 8767 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename); 8768 } 8769 8770 static void fuzzhang_1(skiatest::Reporter* reporter, const char* filename) { 8771 SkPath path; 8772 path.setFillType((SkPath::FillType) 1); 8773 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8774 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 8775 path.conicTo(SkBits2Float(0x66f837a9), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f823406)); // 5.86087e+23f, 0, 0, 0, 1.01721f 8776 path.close(); 8777 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8778 path.quadTo(SkBits2Float(0x675b1bfe), SkBits2Float(0x00000000), SkBits2Float(0x67d76c42), SkBits2Float(0x6292c469)); // 1.03471e+24f, 0, 2.03461e+24f, 1.35369e+21f 8779 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 8780 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 8781 path.quadTo(SkBits2Float(0x679e1b26), SkBits2Float(0x687703c4), SkBits2Float(0x00000000), SkBits2Float(0x687d2968)); // 1.49327e+24f, 4.66598e+24f, 0, 4.78209e+24f 8782 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8783 path.close(); 8784 8785 SkPath path1(path); 8786 path.reset(); 8787 path.setFillType((SkPath::FillType) 0); 8788 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8789 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 8790 path.quadTo(SkBits2Float(0xf8f8c0ed), SkBits2Float(0xf8f8f8f8), SkBits2Float(0x9f9f9f9f), SkBits2Float(0x3014149f)); // -4.03626e+34f, -4.03981e+34f, -6.76032e-20f, 5.38714e-10f 8791 8792 SkPath path2(path); 8793 testPathOp(reporter, path1, path2, (SkPathOp) 0, filename); 8794 } 8795 8796 static void release_13(skiatest::Reporter* reporter, const char* filename) { 8797 SkPath path; 8798 path.setFillType((SkPath::FillType) 1); 8799 path.setFillType(SkPath::kEvenOdd_FillType); 8800 path.moveTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f 8801 path.lineTo(SkBits2Float(0xd43a056e), SkBits2Float(0xd4851696)); // -3.19582e+12f, -4.57288e+12f 8802 path.quadTo(SkBits2Float(0xd3d48e79), SkBits2Float(0xd49fb136), SkBits2Float(0x00000000), SkBits2Float(0xd4d4d4d4)); // -1.82585e+12f, -5.48698e+12f, 0, -7.31283e+12f 8803 path.quadTo(SkBits2Float(0xd3d06670), SkBits2Float(0xd4a0bb38), SkBits2Float(0xd41d628f), SkBits2Float(0xd472c531)); // -1.79014e+12f, -5.52269e+12f, -2.70385e+12f, -4.17076e+12f 8804 path.lineTo(SkBits2Float(0xd43a0559), SkBits2Float(0xd485168e)); // -3.19581e+12f, -4.57287e+12f 8805 path.lineTo(SkBits2Float(0xd446958b), SkBits2Float(0xd4810278)); // -3.41165e+12f, -4.43274e+12f 8806 path.lineTo(SkBits2Float(0xd443884a), SkBits2Float(0xd488cf65)); // -3.35922e+12f, -4.70076e+12f 8807 path.quadTo(SkBits2Float(0xd47efa09), SkBits2Float(0xd49fd72a), SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -4.38047e+12f, -5.49208e+12f, -5.71218e+12f, -6.33007e+12f 8808 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f 8809 path.lineTo(SkBits2Float(0xd459d4d4), SkBits2Float(0xd4c4d4d4)); // -3.74231e+12f, -6.76307e+12f 8810 path.lineTo(SkBits2Float(0xd440daf9), SkBits2Float(0xd4c632d3)); // -3.31323e+12f, -6.81005e+12f 8811 path.lineTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f 8812 path.close(); 8813 path.moveTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f 8814 path.lineTo(SkBits2Float(0xd4422174), SkBits2Float(0xd4d02069)); // -3.33514e+12f, -7.15118e+12f 8815 path.lineTo(SkBits2Float(0xd440daa3), SkBits2Float(0xd4c632d9)); // -3.31321e+12f, -6.81005e+12f 8816 path.lineTo(SkBits2Float(0xd41017bc), SkBits2Float(0xd4cb99b6)); // -2.47549e+12f, -6.99566e+12f 8817 path.lineTo(SkBits2Float(0xd442213b), SkBits2Float(0xd4d02067)); // -3.33512e+12f, -7.15117e+12f 8818 path.lineTo(SkBits2Float(0xd442d4d4), SkBits2Float(0xd4d4d4d4)); // -3.34718e+12f, -7.31283e+12f 8819 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f 8820 path.close(); 8821 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8822 path.lineTo(SkBits2Float(0xd484e02c), SkBits2Float(0xd45fafcd)); // -4.56557e+12f, -3.84291e+12f 8823 path.lineTo(SkBits2Float(0xd462c867), SkBits2Float(0xd45655f7)); // -3.8961e+12f, -3.68226e+12f 8824 path.lineTo(SkBits2Float(0xd45ac463), SkBits2Float(0xd45ac505)); // -3.75839e+12f, -3.75843e+12f 8825 path.lineTo(SkBits2Float(0xd43d2fa9), SkBits2Float(0xd43d2fb5)); // -3.25019e+12f, -3.2502e+12f 8826 path.lineTo(SkBits2Float(0xd41d6287), SkBits2Float(0xd472c52a)); // -2.70385e+12f, -4.17076e+12f 8827 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xd3db1b95), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, -1.88212e+12f, 0, 0 8828 path.quadTo(SkBits2Float(0xd4b7efac), SkBits2Float(0x00000000), SkBits2Float(0xd4d0e88f), SkBits2Float(0xd40b8b46)); // -6.32e+12f, 0, -7.17804e+12f, -2.39735e+12f 8829 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, 0 8830 path.lineTo(SkBits2Float(0xdcdc154b), SkBits2Float(0x00000000)); // -4.95583e+17f, 0 8831 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4c4d477)); // -7.31283e+12f, -6.76303e+12f 8832 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d442)); // -7.31283e+12f, -7.31275e+12f 8833 path.lineTo(SkBits2Float(0xd4d4a691), SkBits2Float(0xd4d4d442)); // -7.30662e+12f, -7.31275e+12f 8834 path.lineTo(SkBits2Float(0xd454d4d4), SkBits2Float(0xd4d4aa30)); // -3.65641e+12f, -7.30711e+12f 8835 path.lineTo(SkBits2Float(0xd4bd9def), SkBits2Float(0xd4d43df0)); // -6.51519e+12f, -7.29258e+12f 8836 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f 8837 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f 8838 path.lineTo(SkBits2Float(0xd4bab953), SkBits2Float(0xd4c4d48e)); // -6.41579e+12f, -6.76304e+12f 8839 path.lineTo(SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -5.71218e+12f, -6.33007e+12f 8840 path.lineTo(SkBits2Float(0xd4ae61eb), SkBits2Float(0xd4ae61f4)); // -5.99174e+12f, -5.99174e+12f 8841 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8842 path.close(); 8843 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8844 path.lineTo(SkBits2Float(0xd446965c), SkBits2Float(0xd4810237)); // -3.4117e+12f, -4.4327e+12f 8845 path.lineTo(SkBits2Float(0xd45ac549), SkBits2Float(0xd45ac55f)); // -3.75845e+12f, -3.75846e+12f 8846 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f 8847 path.close(); 8848 path.moveTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f 8849 path.lineTo(SkBits2Float(0xd4cde20a), SkBits2Float(0xd434bb57)); // -7.07408e+12f, -3.10495e+12f 8850 path.lineTo(SkBits2Float(0xd4c75ffe), SkBits2Float(0xd46f215d)); // -6.85047e+12f, -4.10823e+12f 8851 path.lineTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f 8852 path.close(); 8853 8854 SkPath path1(path); 8855 path.reset(); 8856 path.setFillType((SkPath::FillType) 0); 8857 path.setFillType(SkPath::kWinding_FillType); 8858 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8859 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xa5a50000), SkBits2Float(0xd4d4a5a5), SkBits2Float(0xd4d4d4d4)); // 0, -2.86229e-16f, -7.3065e+12f, -7.31283e+12f 8860 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4), SkBits2Float(0xd4d41dd4)); // -7.31283e+12f, -7.31283e+12f, -7.14103e+12f, -7.28827e+12f 8861 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d432d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4a5a5d4)); // -7.31283e+12f, -7.29109e+12f, -7.31283e+12f, -5.69161e+12f 8862 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, 0 8863 path.moveTo(SkBits2Float(0xa5a5a500), SkBits2Float(0xd4d4d4a5)); // -2.87347e-16f, -7.31281e+12f 8864 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x2ad4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4)); // -7.31283e+12f, 3.78064e-13f, -7.31283e+12f, -7.14103e+12f 8865 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f 8866 path.quadTo(SkBits2Float(0xd4d40000), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.28426e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f 8867 8868 SkPath path2(path); 8869 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 8870 } 8871 8872 static void fuzzhang_2(skiatest::Reporter* reporter, const char* filename) { 8873 SkPath path; 8874 path.setFillType((SkPath::FillType) 0); 8875 path.setFillType(SkPath::kWinding_FillType); 8876 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8877 path.quadTo(SkBits2Float(0xe0e02972), SkBits2Float(0xe0e060e0), SkBits2Float(0x728e4603), SkBits2Float(0x72727272)); // -1.29221e+20f, -1.29345e+20f, 5.63603e+30f, 4.80216e+30f 8878 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8879 path.close(); 8880 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8881 path.quadTo(SkBits2Float(0x68720052), SkBits2Float(0x52527372), SkBits2Float(0x00527252), SkBits2Float(0x728e4601)); // 4.57127e+24f, 2.2597e+11f, 7.57152e-39f, 5.63603e+30f 8882 path.quadTo(SkBits2Float(0x52ec7272), SkBits2Float(0x6265527f), SkBits2Float(0x8e460152), SkBits2Float(0x72ff8072)); // 5.07766e+11f, 1.05756e+21f, -2.4406e-30f, 1.01215e+31f 8883 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8884 path.close(); 8885 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8886 path.lineTo(SkBits2Float(0x52626552), SkBits2Float(0x72727272)); // 2.43091e+11f, 4.80216e+30f 8887 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x62727272), SkBits2Float(0x39393939), SkBits2Float(0x728bc739)); // 4.80216e+30f, 1.11809e+21f, 0.000176643f, 5.53719e+30f 8888 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 8889 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x56727272), SkBits2Float(0x72720152), SkBits2Float(0x72727270)); // 4.80216e+30f, 6.66433e+13f, 4.79341e+30f, 4.80216e+30f 8890 path.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460300), SkBits2Float(0x72727272), SkBits2Float(0x52525272)); // 2.25894e+11f, -2.44068e-30f, 4.80216e+30f, 2.25832e+11f 8891 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 8892 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8893 path.close(); 8894 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8895 path.lineTo(SkBits2Float(0x72727272), SkBits2Float(0x52525f72)); // 4.80216e+30f, 2.25886e+11f 8896 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8897 path.close(); 8898 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f 8899 path.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x64655252), SkBits2Float(0x72c1c152), SkBits2Float(0x72727272)); // 2.60326e+11f, 1.69209e+22f, 7.67543e+30f, 4.80216e+30f 8900 8901 SkPath path1(path); 8902 path.reset(); 8903 path.setFillType((SkPath::FillType) 0); 8904 path.setFillType(SkPath::kWinding_FillType); 8905 8906 SkPath path2(path); 8907 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename); 8908 } 8909 8910 static void fuzzhang_3(skiatest::Reporter* reporter, const char* filename) { 8911 SkPath path; 8912 path.setFillType((SkPath::FillType) 0); 8913 path.setFillType(SkPath::kWinding_FillType); 8914 8915 SkPath path1(path); 8916 path.reset(); 8917 path.setFillType((SkPath::FillType) 0); 8918 path.setFillType(SkPath::kWinding_FillType); 8919 path.moveTo(SkBits2Float(0x46090052), SkBits2Float(0x7270726c)); // 8768.08f, 4.76254e+30f 8920 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8921 path.close(); 8922 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8923 path.lineTo(SkBits2Float(0x77727272), SkBits2Float(0x52520072)); // 4.91741e+33f, 2.25488e+11f 8924 path.lineTo(SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // 8768.08f, 4.80219e+30f 8925 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f 8926 path.lineTo(SkBits2Float(0x6c460900), SkBits2Float(0x72727072)); // 9.57639e+26f, 4.802e+30f 8927 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 8928 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f 8929 path.lineTo(SkBits2Float(0x0052ca00), SkBits2Float(0x728e4603)); // 7.60297e-39f, 5.63603e+30f 8930 path.quadTo(SkBits2Float(0xff727272), SkBits2Float(0x52527272), SkBits2Float(0x39392072), SkBits2Float(0xe0393939)); // -3.22267e+38f, 2.25966e+11f, 0.000176551f, -5.3387e+19f 8931 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8932 path.close(); 8933 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8934 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 8935 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 8936 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f 8937 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xca005252), SkBits2Float(0x46030052), SkBits2Float(0x7272728e)); // 4.80216e+30f, -2.10242e+06f, 8384.08f, 4.80217e+30f 8938 path.quadTo(SkBits2Float(0x7272ff72), SkBits2Float(0x20725252), SkBits2Float(0x39393939), SkBits2Float(0xd76ee039)); // 4.81307e+30f, 2.05254e-19f, 0.000176643f, -2.62647e+14f 8939 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 8940 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 8941 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f 8942 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8943 path.quadTo(SkBits2Float(0x72667254), SkBits2Float(0x00000040), SkBits2Float(0x00a70155), SkBits2Float(0x726800ff)); // 4.56447e+30f, 8.96831e-44f, 1.5337e-38f, 4.59531e+30f 8944 path.quadTo(SkBits2Float(0x7b727272), SkBits2Float(0xad000c52), SkBits2Float(0x1c10adad), SkBits2Float(0x72728d8a)); // 1.25886e+36f, -7.27869e-12f, 4.78701e-22f, 4.80425e+30f 8945 path.quadTo(SkBits2Float(0xff056546), SkBits2Float(0x727205ff), SkBits2Float(0x524b5aff), SkBits2Float(0x64005252)); // -1.77313e+38f, 4.79377e+30f, 2.18351e+11f, 9.46846e+21f 8946 path.quadTo(SkBits2Float(0x72524872), SkBits2Float(0xdada7272), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // 4.16508e+30f, -3.07437e+16f, 2.25831e+11f, 4.80215e+30f 8947 path.quadTo(SkBits2Float(0x72724172), SkBits2Float(0xdad10072), SkBits2Float(0x52524b5a), SkBits2Float(0x725b8000)); // 4.79837e+30f, -2.94144e+16f, 2.25802e+11f, 4.34765e+30f 8948 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f 8949 path.quadTo(SkBits2Float(0x72728372), SkBits2Float(0x00000040), SkBits2Float(0xf6a70147), SkBits2Float(0xc2c2c256)); // 4.80347e+30f, 8.96831e-44f, -1.69363e+33f, -97.3796f 8950 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f 8951 path.close(); 8952 path.moveTo(SkBits2Float(0x7a787a7a), SkBits2Float(0x7a3a7a7a)); // 3.22543e+35f, 2.42063e+35f 8953 path.lineTo(SkBits2Float(0x8f4603e0), SkBits2Float(0x72727272)); // -9.7629e-30f, 4.80216e+30f 8954 path.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x46090052), SkBits2Float(0x7270726c), SkBits2Float(0x60e04372)); // 1.1796e-38f, 8768.08f, 4.76254e+30f, 1.29279e+20f 8955 path.moveTo(SkBits2Float(0x943603e0), SkBits2Float(0x77727272)); // -9.18942e-27f, 4.91741e+33f 8956 path.quadTo(SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce), SkBits2Float(0x5252ec72)); // 2.368e+17f, 8768.08f, 4.80219e+30f, 2.26478e+11f 8957 8958 SkPath path2(path); 8959 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8960 } 8961 8962 static void fuzz754434_1(skiatest::Reporter* reporter, const char* filename) { 8963 SkPath path; 8964 path.setFillType((SkPath::FillType) 0); 8965 path.setFillType(SkPath::kWinding_FillType); 8966 8967 SkPath path1(path); 8968 path.reset(); 8969 path.setFillType((SkPath::FillType) 0); 8970 path.setFillType(SkPath::kWinding_FillType); 8971 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8972 path.cubicTo(SkBits2Float(0x535e5372), SkBits2Float(0x53536153), SkBits2Float(0x79530f53), SkBits2Float(0x101b6c88), SkBits2Float(0x5353735e), SkBits2Float(0x006df653)); // 9.54883e+11f, 9.07871e+11f, 6.84928e+34f, 3.0652e-29f, 9.08174e+11f, 1.00984e-38f 8973 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5656f666), SkBits2Float(0x5a565656), SkBits2Float(0x00000056), SkBits2Float(0xf66e5600)); // -4.71318e+30f, -2.50452e+33f, 5.90884e+13f, 1.50826e+16f, 1.20512e-43f, -1.20851e+33f 8974 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f 8975 path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f 8976 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf653f6f6), SkBits2Float(0x563ef666), SkBits2Float(0x56565656), SkBits2Float(0x65565656), SkBits2Float(0xf6765656)); // -4.71318e+30f, -1.07479e+33f, 5.24914e+13f, 5.89166e+13f, 6.32612e+22f, -1.24908e+33f 8977 8978 SkPath path2(path); 8979 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 8980 } 8981 8982 static void fuzz754434_2(skiatest::Reporter* reporter, const char* filename) { 8983 SkPath path; 8984 path.setFillType((SkPath::FillType) 1); 8985 path.setFillType(SkPath::kEvenOdd_FillType); 8986 path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0 8987 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f 8988 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f 8989 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8990 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0 8991 path.close(); 8992 8993 SkPath path1(path); 8994 path.reset(); 8995 path.setFillType((SkPath::FillType) 0); 8996 path.setFillType(SkPath::kWinding_FillType); 8997 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 8998 path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f 8999 path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f 9000 path.conicTo(SkBits2Float(0x6c8879ff), SkBits2Float(0x08761b1b), SkBits2Float(0x7066662d), SkBits2Float(0x70707070), SkBits2Float(0x70707070)); // 1.31992e+27f, 7.40598e-34f, 2.8522e+29f, 2.97649e+29f, 2.97649e+29f 9001 9002 SkPath path2(path); 9003 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 9004 } 9005 9006 static void fuzz754434_3(skiatest::Reporter* reporter, const char* filename) { 9007 SkPath path; 9008 path.setFillType((SkPath::FillType) 0); 9009 path.setFillType(SkPath::kWinding_FillType); 9010 9011 SkPath path1(path); 9012 path.reset(); 9013 path.setFillType((SkPath::FillType) 0); 9014 path.setFillType(SkPath::kWinding_FillType); 9015 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 9016 path.cubicTo(SkBits2Float(0x535e5372), SkBits2Float(0x53536153), SkBits2Float(0x79530f53), SkBits2Float(0x101b6c88), SkBits2Float(0x5353735e), SkBits2Float(0x006df653)); // 9.54883e+11f, 9.07871e+11f, 6.84928e+34f, 3.0652e-29f, 9.08174e+11f, 1.00984e-38f 9017 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5656f666), SkBits2Float(0x5a565656), SkBits2Float(0x00000056), SkBits2Float(0xf66e5600)); // -4.71318e+30f, -2.50452e+33f, 5.90884e+13f, 1.50826e+16f, 1.20512e-43f, -1.20851e+33f 9018 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f 9019 path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f 9020 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf653f6f6), SkBits2Float(0x563ef666), SkBits2Float(0x56565656), SkBits2Float(0x65565656), SkBits2Float(0xf6765656)); // -4.71318e+30f, -1.07479e+33f, 5.24914e+13f, 5.89166e+13f, 6.32612e+22f, -1.24908e+33f 9021 9022 SkPath path2(path); 9023 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename); 9024 } 9025 9026 static void fuzz754434_4(skiatest::Reporter* reporter, const char* filename) { 9027 SkPath path; 9028 path.setFillType((SkPath::FillType) 1); 9029 path.setFillType(SkPath::kEvenOdd_FillType); 9030 path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0 9031 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f 9032 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f 9033 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 9034 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0 9035 path.close(); 9036 9037 SkPath path1(path); 9038 path.reset(); 9039 path.setFillType((SkPath::FillType) 0); 9040 path.setFillType(SkPath::kWinding_FillType); 9041 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 9042 path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f 9043 path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f 9044 path.conicTo(SkBits2Float(0x6c8879ff), SkBits2Float(0x08761b1b), SkBits2Float(0x7066662d), SkBits2Float(0x70707070), SkBits2Float(0x70707070)); // 1.31992e+27f, 7.40598e-34f, 2.8522e+29f, 2.97649e+29f, 2.97649e+29f 9045 9046 SkPath path2(path); 9047 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename); 9048 } 9049 9050 static struct TestDesc failTests[] = { 9051 TEST(fuzz767834), 9052 TEST(fuzz754434_1), 9053 TEST(fuzz754434_2), 9054 TEST(fuzz754434_3), 9055 TEST(fuzz754434_4), 9056 TEST(fuzzhang_3), 9057 TEST(fuzzhang_2), 9058 TEST(release_13), 9059 TEST(fuzzhang_1), 9060 TEST(fuzz763_57), 9061 TEST(fuzz763_56), 9062 TEST(fuzz763_55), 9063 TEST(fuzz763_54), 9064 TEST(fuzz763_53), 9065 TEST(fuzz763_52), 9066 TEST(fuzz763_51), 9067 TEST(fuzz763_50), 9068 TEST(fuzz763_49), 9069 TEST(fuzz763_48), 9070 TEST(fuzz763_47), 9071 TEST(fuzz763_46), 9072 TEST(fuzz763_45), 9073 TEST(fuzz763_44), 9074 TEST(fuzz763_43), 9075 TEST(fuzz763_42), 9076 TEST(fuzz763_41), 9077 TEST(fuzz763_40), 9078 TEST(fuzz763_39), 9079 TEST(fuzz763_38), 9080 TEST(fuzz763_37), 9081 TEST(fuzz763_36), 9082 TEST(fuzz763_35), 9083 TEST(fuzz763_34), 9084 TEST(fuzz763_33), 9085 TEST(fuzz763_32), 9086 TEST(fuzz763_31), 9087 TEST(fuzz763_30), 9088 TEST(fuzz763_29), 9089 TEST(fuzz763_28), 9090 TEST(fuzz763_27), 9091 TEST(fuzz763_26), 9092 TEST(fuzz763_25), 9093 TEST(fuzz763_24), 9094 TEST(fuzz763_23), 9095 TEST(fuzz763_22), 9096 TEST(fuzz763_21), 9097 TEST(fuzz763_20), 9098 TEST(fuzz763_19), 9099 TEST(fuzz763_18), 9100 TEST(fuzz763_17), 9101 TEST(fuzz763_16), 9102 TEST(fuzz763_15), 9103 TEST(fuzz763_14), 9104 TEST(fuzz763_13), 9105 TEST(fuzz763_12), 9106 TEST(fuzz763_11), 9107 TEST(fuzz763_10), 9108 TEST(kfuzz2), 9109 TEST(fuzz763_7), 9110 TEST(fuzz763_6), 9111 TEST(fuzz763_2c), 9112 TEST(fuzz763_2b), 9113 TEST(fuzz763_2a), 9114 TEST(fuzz763_5a), 9115 TEST(fuzz763_3a), 9116 TEST(fuzz763_1a), 9117 TEST(fuzz763_1b), 9118 TEST(fuzz763_1c), 9119 TEST(fuzz763_2), 9120 TEST(fuzz763_5), 9121 TEST(fuzz763_3), 9122 TEST(fuzz763_4), 9123 TEST(fuzz763_9), 9124 TEST(fuzz1450_1), 9125 TEST(fuzz1450_0), 9126 TEST(bug597926_0), 9127 TEST(fuzz535151), 9128 TEST(fuzz753_91), 9129 TEST(fuzz714), 9130 TEST(fuzz487a), 9131 TEST(fuzz433), 9132 TEST(fuzz1), 9133 TEST(fuzz487b), 9134 TEST(fuzz433b), 9135 TEST(bufferOverflow), 9136 }; 9137 9138 static const size_t failTestCount = SK_ARRAY_COUNT(failTests); 9139 9140 DEF_TEST(PathOpsFailOp, reporter) { 9141 #if DEBUG_SHOW_TEST_NAME 9142 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 9143 #endif 9144 RunTestSet(reporter, failTests, failTestCount, nullptr, nullptr, nullptr, false); 9145 } 9146 9147 static struct TestDesc repTests[] = { 9148 TEST(fuzz763_5a), 9149 }; 9150 9151 DEF_TEST(PathOpsRepOp, reporter) { 9152 for (int index = 0; index < 1; ++index) 9153 RunTestSet(reporter, repTests, SK_ARRAY_COUNT(repTests), nullptr, nullptr, nullptr, false); 9154 } 9155
