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 9 #define TEST(name) { name, #name } 10 11 #define TEST_NEW_FAILURES 0 12 13 static void skpcheeseandburger_com225(skiatest::Reporter* reporter, const char* filename) { 14 SkPath path; 15 path.setFillType(SkPath::kEvenOdd_FillType); 16 path.moveTo(555, 468); 17 path.lineTo(555, 362); 18 path.lineTo(872, 362); 19 path.lineTo(872, 468); 20 path.lineTo(555, 468); 21 path.close(); 22 SkPath pathB; 23 pathB.setFillType(SkPath::kWinding_FillType); 24 pathB.moveTo(859.11792f, 397.320343f); 25 pathB.cubicTo(855.523071f, 399.691284f, 853.721191f, 402.40863f, 853.721191f, 405.552216f); 26 pathB.cubicTo(853.721191f, 407.911163f, 854.727478f, 410.115387f, 857.043518f, 412.252716f); 27 pathB.cubicTo(859.920532f, 414.916138f, 862.704773f, 417.086426f, 864.679382f, 418.852386f); 28 pathB.cubicTo(866.382446f, 420.371765f, 867.19104f, 422.108795f, 867.19104f, 423.506378f); 29 pathB.cubicTo(867.19104f, 424.551605f, 866.741821f, 425.539886f, 865.935242f, 426.281616f); 30 pathB.cubicTo(865.250366f, 426.910553f, 864.662415f, 427.339813f, 864.139282f, 427.4646f); 31 pathB.cubicTo(863.536377f, 427.605347f, 862.259521f, 426.491272f, 860.366821f, 424.208191f); 32 pathB.cubicTo(858.345276f, 421.770355f, 857.317017f, 419.733856f, 857.317017f, 417.98587f); 33 pathB.cubicTo(857.317017f, 417.198212f, 857.942993f, 415.930389f, 857.942993f, 415.930389f); 34 pathB.cubicTo(857.942993f, 415.930389f, 852.106018f, 421.296173f, 852.279663f, 422.549042f); 35 pathB.cubicTo(852.462402f, 423.890747f, 853.669312f, 425.703613f, 855.876465f, 428.252258f); 36 pathB.cubicTo(858.038818f, 430.754944f, 859.4953f, 431.840088f, 860.190125f, 431.594513f); 37 pathB.cubicTo(862.571045f, 430.754944f, 865.48999f, 429.237549f, 868.44397f, 427.018372f); 38 pathB.cubicTo(870.505371f, 425.470032f, 871.582581f, 423.534332f, 871.582581f, 421.001678f); 39 pathB.cubicTo(871.582581f, 417.945923f, 870.056213f, 415.171692f, 867.015381f, 412.640045f); 40 pathB.cubicTo(863.683105f, 409.872803f, 861.445923f, 408.027954f, 860.551514f, 407.140503f); 41 pathB.cubicTo(858.660767f, 405.264709f, 857.765259f, 403.50174f, 857.765259f, 402.187988f); 42 pathB.cubicTo(857.765259f, 401.141785f, 858.339355f, 400.394073f, 859.476318f, 399.925873f); 43 pathB.cubicTo(860.004395f, 399.704254f, 861.270264f, 400.515869f, 863.156006f, 402.36969f); 44 pathB.cubicTo(865.094727f, 404.28241f, 866.203796f, 405.565186f, 866.383484f, 406.130219f); 45 pathB.cubicTo(868.250244f, 404.305359f, 869.179688f, 403.397919f, 871.046509f, 401.58902f); 46 pathB.cubicTo(868.26825f, 399.296967f, 864.431824f, 394.705841f, 863.156006f, 394.600037f); 47 pathB.cubicTo(863.145996f, 394.600037f, 863.136108f, 394.59903f, 863.126099f, 394.59903f); 48 pathB.cubicTo(862.352417f, 394.598022f, 859.909607f, 396.79425f, 859.11792f, 397.320343f); 49 pathB.moveTo(832.164246f, 394.307526f); 50 pathB.cubicTo(832.451721f, 394.425323f, 832.598511f, 394.486206f, 832.886963f, 394.605011f); 51 pathB.cubicTo(834.078979f, 395.474518f, 834.674927f, 395.90979f, 835.867859f, 396.781281f); 52 pathB.cubicTo(836.502808f, 397.325348f, 836.863159f, 398.000183f, 836.863159f, 398.964539f); 53 pathB.lineTo(836.863159f, 419.740845f); 54 pathB.cubicTo(836.863159f, 420.876923f, 836.319092f, 422.17868f, 835.055298f, 423.617188f); 55 pathB.cubicTo(836.39502f, 424.512665f, 837.063843f, 424.961884f, 838.39856f, 425.864349f); 56 pathB.cubicTo(839.477661f, 426.578125f, 841.37439f, 427.27594f, 842.275879f, 427.443634f); 57 pathB.cubicTo(842.999634f, 427.574402f, 843.82019f, 427.513519f, 844.354309f, 427.216034f); 58 pathB.cubicTo(846.956787f, 425.765503f, 848.689819f, 423.588257f, 848.58606f, 423.483429f); 59 pathB.cubicTo(848.58606f, 423.483429f, 846.877991f, 423.327698f, 845.971558f, 422.807587f); 60 pathB.cubicTo(845.253784f, 422.284485f, 844.892395f, 422.022949f, 844.171631f, 421.502838f); 61 pathB.cubicTo(843.361023f, 420.915833f, 842.907837f, 420.308899f, 842.907837f, 419.350525f); 62 pathB.lineTo(842.907837f, 399.445709f); 63 pathB.cubicTo(842.907837f, 398.053101f, 843.272217f, 397.417175f, 843.812256f, 397.518005f); 64 pathB.cubicTo(844.170654f, 397.583893f, 844.711731f, 398.122986f, 845.432495f, 398.782837f); 65 pathB.cubicTo(846.116333f, 399.402771f, 846.459717f, 399.709259f, 847.14856f, 400.3302f); 66 pathB.cubicTo(844.986206f, 402.099152f, 843.988892f, 403.926025f, 843.988892f, 405.932556f); 67 pathB.cubicTo(843.988892f, 410.209229f, 848.272583f, 410.951935f, 849.576355f, 408.394348f); 68 pathB.cubicTo(849.871826f, 407.816345f, 850.421875f, 406.214081f, 850.387939f, 406.196106f); 69 pathB.cubicTo(850.387939f, 406.196106f, 849.305786f, 406.771118f, 848.495239f, 406.615387f); 70 pathB.cubicTo(846.96582f, 406.316895f, 846.153198f, 405.46637f, 846.153198f, 403.89505f); 71 pathB.cubicTo(846.153198f, 401.796661f, 848.50116f, 399.09729f, 852.279663f, 396.270142f); 72 pathB.cubicTo(851.014893f, 395.315796f, 847.723511f, 391.546265f, 846.875f, 391.546265f); 73 pathB.cubicTo(846.330933f, 391.546265f, 843.988892f, 394.403351f, 843.273193f, 394.972382f); 74 pathB.cubicTo(840.889282f, 392.886963f, 839.700317f, 391.850739f, 837.312378f, 389.786285f); 75 pathB.cubicTo(835.257935f, 391.589203f, 834.225708f, 392.491638f, 832.164246f, 394.307526f); 76 pathB.moveTo(818.860107f, 392.707275f); 77 pathB.cubicTo(819.857361f, 393.382111f, 822.302124f, 395.764038f, 824.387573f, 397.051819f); 78 pathB.cubicTo(822.57666f, 398.249756f, 820.582092f, 399.687286f, 818.860107f, 400.827332f); 79 pathB.lineTo(818.860107f, 392.707275f); 80 pathB.close(); 81 pathB.moveTo(810.69812f, 391.096039f); 82 pathB.cubicTo(810.69812f, 391.096039f, 812.786499f, 394.093903f, 812.786499f, 394.965393f); 83 pathB.lineTo(812.786499f, 415.743713f); 84 pathB.cubicTo(812.786499f, 417.753265f, 811.881042f, 418.497986f, 810.974609f, 419.769806f); 85 pathB.cubicTo(813.948486f, 421.160431f, 815.437988f, 421.864197f, 818.404846f, 423.283783f); 86 pathB.cubicTo(819.948181f, 423.95462f, 822.417969f, 424.592529f, 823.937317f, 423.782928f); 87 pathB.cubicTo(827.905518f, 421.663544f, 831.53125f, 417.600525f, 832.255005f, 415.191681f); 88 pathB.cubicTo(833.882263f, 409.877808f, 823.095825f, 411.495026f, 823.119751f, 411.518982f); 89 pathB.cubicTo(823.119751f, 411.518982f, 832.000488f, 411.874359f, 830.537964f, 416.29776f); 90 pathB.cubicTo(829.888123f, 418.253418f, 827.278564f, 420.292908f, 825.385864f, 419.55719f); 91 pathB.cubicTo(821.14209f, 417.915985f, 818.861023f, 417.414856f, 818.861023f, 414.970032f); 92 pathB.lineTo(818.861023f, 403.096436f); 93 pathB.cubicTo(822.126404f, 399.132233f, 831.289673f, 395.897797f, 831.356567f, 395.657227f); 94 pathB.cubicTo(831.356567f, 395.657227f, 823.022888f, 387.594055f, 821.763062f, 387.476257f); 95 pathB.cubicTo(821.755066f, 387.47525f, 821.746094f, 387.47525f, 821.737061f, 387.47525f); 96 pathB.cubicTo(820.793701f, 387.47525f, 810.72406f, 390.967255f, 810.69812f, 391.096039f); 97 pathB.moveTo(624.254211f, 390.498077f); 98 pathB.cubicTo(625.252502f, 390.893402f, 627.708252f, 392.592468f, 629.796692f, 393.307251f); 99 pathB.cubicTo(627.978821f, 395.006317f, 625.980225f, 397.000916f, 624.254211f, 398.618134f); 100 pathB.lineTo(624.254211f, 390.498077f); 101 pathB.close(); 102 pathB.moveTo(627.160217f, 384.460449f); 103 pathB.cubicTo(626.286743f, 384.51535f, 616.076233f, 390.993225f, 616.086243f, 391.141968f); 104 pathB.cubicTo(616.086243f, 391.141968f, 618.173645f, 393.561798f, 618.173645f, 394.437317f); 105 pathB.lineTo(618.173645f, 415.216614f); 106 pathB.cubicTo(618.173645f, 417.222168f, 617.265198f, 418.219482f, 616.355774f, 419.742859f); 107 pathB.cubicTo(619.331665f, 420.307892f, 620.824097f, 420.599396f, 623.802979f, 421.198364f); 108 pathB.cubicTo(625.346313f, 421.437958f, 627.818115f, 421.39801f, 629.342468f, 420.166138f); 109 pathB.cubicTo(633.340576f, 416.939667f, 636.982361f, 411.871368f, 637.714111f, 409.263855f); 110 pathB.cubicTo(639.348267f, 403.500732f, 628.508911f, 408.111816f, 628.52887f, 408.126801f); 111 pathB.cubicTo(628.52887f, 408.126801f, 637.468506f, 405.998444f, 635.985046f, 410.844147f); 112 pathB.cubicTo(635.332153f, 412.984467f, 632.705688f, 415.748718f, 630.801941f, 415.541077f); 113 pathB.cubicTo(626.537292f, 415.072876f, 624.257202f, 415.202667f, 624.257202f, 412.755859f); 114 pathB.cubicTo(624.257202f, 408.007019f, 624.255188f, 405.636078f, 624.255188f, 400.884247f); 115 pathB.cubicTo(627.525574f, 396.016602f, 636.801636f, 390.283447f, 636.801636f, 389.97995f); 116 pathB.cubicTo(636.801636f, 389.97995f, 628.360168f, 384.458435f, 627.18219f, 384.458435f); 117 pathB.cubicTo(627.174194f, 384.460449f, 627.167236f, 384.460449f, 627.160217f, 384.460449f); 118 pathB.moveTo(796.530396f, 416.438538f); 119 pathB.cubicTo(795.892517f, 416.365662f, 794.527832f, 415.589996f, 792.348572f, 414.036652f); 120 pathB.lineTo(792.348572f, 391.425476f); 121 pathB.cubicTo(792.348572f, 390.465118f, 792.530273f, 390.047852f, 792.89563f, 390.088776f); 122 pathB.cubicTo(793.075317f, 390.109741f, 793.3479f, 390.317383f, 793.804077f, 390.629852f); 123 pathB.cubicTo(795.113831f, 391.585205f, 795.768738f, 392.059387f, 797.077515f, 393.018738f); 124 pathB.cubicTo(797.983948f, 393.648651f, 798.348267f, 394.219666f, 798.348267f, 394.742767f); 125 pathB.lineTo(798.348267f, 413.253998f); 126 pathB.cubicTo(798.348267f, 415.391327f, 797.783264f, 416.451508f, 796.728088f, 416.451508f); 127 pathB.cubicTo(796.664185f, 416.4505f, 796.598267f, 416.446533f, 796.530396f, 416.438538f); 128 pathB.moveTo(795.165771f, 383.714722f); 129 pathB.cubicTo(794.022705f, 383.851471f, 783.959961f, 388.652252f, 783.880127f, 388.873871f); 130 pathB.cubicTo(783.880127f, 388.873871f, 785.054077f, 389.871155f, 785.522339f, 390.606873f); 131 pathB.cubicTo(786.000488f, 391.361603f, 786.246094f, 391.9935f, 786.246094f, 392.427765f); 132 pathB.lineTo(786.246094f, 411.987183f); 133 pathB.cubicTo(786.246094f, 413.733185f, 784.160645f, 416.428558f, 784.246521f, 416.759979f); 134 pathB.cubicTo(784.258484f, 416.79892f, 785.432495f, 417.14032f, 785.793823f, 417.350952f); 135 pathB.cubicTo(786.739258f, 417.937958f, 787.213379f, 418.228455f, 788.161804f, 418.821442f); 136 pathB.cubicTo(789.342773f, 419.554199f, 790.619568f, 419.956482f, 791.892395f, 420.098236f); 137 pathB.cubicTo(794.533813f, 420.390747f, 796.717102f, 419.337555f, 798.349304f, 416.999573f); 138 pathB.lineTo(798.349304f, 425.212463f); 139 pathB.cubicTo(797.94696f, 425.47702f, 797.750305f, 425.609772f, 797.356018f, 425.874329f); 140 pathB.cubicTo(795.259583f, 423.619202f, 792.806824f, 422.286499f, 789.985657f, 421.984009f); 141 pathB.cubicTo(785.157959f, 421.463898f, 780.409119f, 428.344086f, 780.423096f, 428.346069f); 142 pathB.cubicTo(780.423096f, 428.346069f, 783.340088f, 424.960907f, 785.889709f, 425.218445f); 143 pathB.cubicTo(789.25592f, 425.565857f, 793.166199f, 430.745972f, 793.805115f, 430.790894f); 144 pathB.cubicTo(793.940857f, 430.798889f, 795.918457f, 429.091797f, 798.454102f, 427.383728f); 145 pathB.cubicTo(801.049683f, 425.635742f, 804.230225f, 423.886749f, 806.619141f, 423.980591f); 146 pathB.cubicTo(805.621826f, 423.586243f, 805.048828f, 423.074127f, 804.804199f, 422.609924f); 147 pathB.cubicTo(804.616577f, 422.25354f, 804.616577f, 421.539764f, 804.616577f, 420.31488f); 148 pathB.cubicTo(804.623535f, 411.732605f, 804.623535f, 403.147339f, 804.623535f, 394.562073f); 149 pathB.cubicTo(804.623535f, 392.464691f, 805.970215f, 391.000183f, 805.984192f, 390.896362f); 150 pathB.cubicTo(805.984192f, 390.896362f, 796.785034f, 383.7117f, 795.219666f, 383.7117f); 151 pathB.cubicTo(795.19873f, 383.712708f, 795.181763f, 383.712708f, 795.165771f, 383.714722f); 152 pathB.moveTo(648.092285f, 387.883545f); 153 pathB.cubicTo(649.095581f, 388.312805f, 651.55835f, 390.099762f, 653.655701f, 390.884399f); 154 pathB.cubicTo(651.831848f, 392.522583f, 649.82428f, 394.447296f, 648.092285f, 396.003601f); 155 pathB.lineTo(648.092285f, 387.883545f); 156 pathB.close(); 157 pathB.moveTo(651.009277f, 381.943756f); 158 pathB.cubicTo(650.147766f, 381.983704f, 639.893372f, 388.105164f, 639.899353f, 388.254913f); 159 pathB.cubicTo(639.899353f, 388.254913f, 641.987793f, 390.744659f, 641.987793f, 391.617157f); 160 pathB.lineTo(641.987793f, 412.399475f); 161 pathB.cubicTo(641.987793f, 414.409027f, 641.082336f, 415.369354f, 640.169861f, 416.864807f); 162 pathB.cubicTo(643.155762f, 417.53064f, 644.650208f, 417.87207f, 647.638062f, 418.573853f); 163 pathB.cubicTo(649.188416f, 418.865356f, 651.666138f, 418.908295f, 653.19751f, 417.725311f); 164 pathB.cubicTo(657.204651f, 414.633636f, 660.859375f, 409.690125f, 661.590088f, 407.106567f); 165 pathB.cubicTo(663.231262f, 401.397339f, 652.356934f, 405.644073f, 652.375916f, 405.663025f); 166 pathB.cubicTo(652.375916f, 405.663025f, 661.338562f, 403.835175f, 659.857056f, 408.632935f); 167 pathB.cubicTo(659.199219f, 410.748291f, 656.568726f, 413.424713f, 654.656982f, 413.151184f); 168 pathB.cubicTo(650.381348f, 412.536224f, 648.092285f, 412.591125f, 648.092285f, 410.146332f); 169 pathB.lineTo(648.092285f, 398.270721f); 170 pathB.cubicTo(651.374634f, 393.5159f, 660.66571f, 388.09021f, 660.674683f, 387.791718f); 171 pathB.cubicTo(660.674683f, 387.791718f, 652.188232f, 381.941772f, 651.022278f, 381.942749f); 172 pathB.cubicTo(651.01825f, 381.942749f, 651.013245f, 381.942749f, 651.009277f, 381.943756f); 173 pathB.moveTo(761.636353f, 385.965851f); 174 pathB.cubicTo(761.927856f, 386.056702f, 762.071594f, 386.098633f, 762.363098f, 386.189453f); 175 pathB.cubicTo(763.570007f, 386.938171f, 764.175964f, 387.311554f, 765.376892f, 388.066254f); 176 pathB.cubicTo(766.019775f, 388.546417f, 766.384155f, 389.184326f, 766.384155f, 390.147675f); 177 pathB.lineTo(766.384155f, 410.924011f); 178 pathB.cubicTo(766.384155f, 412.057037f, 765.836121f, 413.410736f, 764.559326f, 414.979034f); 179 pathB.cubicTo(765.911987f, 415.738739f, 766.579834f, 416.12207f, 767.934509f, 416.887756f); 180 pathB.cubicTo(769.029602f, 417.495728f, 770.944336f, 418.000854f, 771.85675f, 418.075714f); 181 pathB.cubicTo(772.58551f, 418.134613f, 773.413086f, 417.987854f, 773.950195f, 417.638458f); 182 pathB.cubicTo(776.583618f, 415.917419f, 778.332642f, 413.564453f, 778.237793f, 413.473633f); 183 pathB.cubicTo(778.237793f, 413.473633f, 776.507812f, 413.497559f, 775.596313f, 413.066315f); 184 pathB.cubicTo(774.866577f, 412.61908f, 774.497253f, 412.39447f, 773.771484f, 411.951233f); 185 pathB.cubicTo(772.947876f, 411.444092f, 772.493652f, 410.877075f, 772.493652f, 409.919708f); 186 pathB.lineTo(772.493652f, 390.013885f); 187 pathB.cubicTo(772.493652f, 388.618286f, 772.860046f, 387.949432f, 773.407104f, 387.995361f); 188 pathB.cubicTo(773.771484f, 388.026306f, 774.318542f, 388.509491f, 775.049316f, 389.09848f); 189 pathB.cubicTo(775.742065f, 389.646515f, 776.088501f, 389.923065f, 776.77533f, 390.470123f); 190 pathB.cubicTo(774.590088f, 392.45871f, 773.589783f, 394.385376f, 773.589783f, 396.395935f); 191 pathB.cubicTo(773.589783f, 400.673584f, 777.907349f, 401.008026f, 779.237122f, 398.292694f); 192 pathB.cubicTo(779.539551f, 397.684723f, 780.089661f, 396.027557f, 780.058716f, 396.01358f); 193 pathB.cubicTo(780.058716f, 396.01358f, 778.970581f, 396.694427f, 778.149963f, 396.618561f); 194 pathB.cubicTo(776.598633f, 396.4758f, 775.775024f, 395.709106f, 775.775024f, 394.13681f); 195 pathB.cubicTo(775.775024f, 392.042419f, 778.149963f, 389.103455f, 781.973389f, 385.892975f); 196 pathB.cubicTo(780.697571f, 385.06839f, 777.326416f, 381.676208f, 776.506775f, 381.719147f); 197 pathB.cubicTo(775.908813f, 381.747101f, 773.588806f, 384.868744f, 772.860046f, 385.506622f); 198 pathB.cubicTo(770.451172f, 383.664795f, 769.248291f, 382.749359f, 766.843384f, 380.929504f); 199 pathB.cubicTo(764.758972f, 382.934052f, 763.716736f, 383.940338f, 761.636353f, 385.965851f); 200 pathB.moveTo(672.996521f, 379.821411f); 201 pathB.cubicTo(672.123047f, 379.891266f, 669.7052f, 382.898132f, 668.887573f, 383.64682f); 202 pathB.cubicTo(665.239868f, 386.999084f, 663.41095f, 390.213562f, 663.41095f, 393.356171f); 203 pathB.cubicTo(663.41095f, 395.715118f, 664.439209f, 397.642792f, 666.785156f, 399.150208f); 204 pathB.cubicTo(669.702148f, 401.02002f, 672.547302f, 402.439575f, 674.545837f, 403.655487f); 205 pathB.cubicTo(676.261902f, 404.697693f, 677.105469f, 406.231049f, 677.105469f, 407.625671f); 206 pathB.cubicTo(677.105469f, 408.671875f, 676.651245f, 409.777954f, 675.825684f, 410.7453f); 207 pathB.cubicTo(675.12384f, 411.569885f, 674.538879f, 412.145905f, 673.997803f, 412.417419f); 208 pathB.cubicTo(673.38385f, 412.724915f, 672.080078f, 411.958221f, 670.166382f, 410.198242f); 209 pathB.cubicTo(668.113892f, 408.319458f, 667.062683f, 406.55249f, 667.062683f, 404.808502f); 210 pathB.cubicTo(667.062683f, 404.020844f, 667.701599f, 402.580322f, 667.701599f, 402.580322f); 211 pathB.cubicTo(667.701599f, 402.580322f, 661.773804f, 409.542358f, 661.951477f, 410.7453f); 212 pathB.cubicTo(662.13916f, 412.037079f, 663.368042f, 413.524536f, 665.60321f, 415.469208f); 213 pathB.cubicTo(667.791443f, 417.368927f, 669.261963f, 418.074738f, 669.983704f, 417.630493f); 214 pathB.cubicTo(672.412537f, 416.138062f, 675.369446f, 413.822021f, 678.385254f, 410.790222f); 215 pathB.cubicTo(680.485657f, 408.677856f, 681.587769f, 406.446686f, 681.587769f, 403.917023f); 216 pathB.cubicTo(681.587769f, 400.859283f, 680.007446f, 398.490356f, 676.923767f, 396.806244f); 217 pathB.cubicTo(673.540588f, 394.957428f, 671.257507f, 393.71756f, 670.351074f, 393.075653f); 218 pathB.cubicTo(668.434326f, 391.71698f, 667.518921f, 390.193604f, 667.518921f, 388.88385f); 219 pathB.cubicTo(667.518921f, 387.837646f, 668.101929f, 386.934204f, 669.25592f, 386.156525f); 220 pathB.cubicTo(669.796997f, 385.788147f, 671.085815f, 386.257355f, 672.997498f, 387.592072f); 221 pathB.cubicTo(674.966125f, 388.968689f, 676.104187f, 389.951019f, 676.284851f, 390.465118f); 222 pathB.cubicTo(678.186584f, 388.130127f, 679.136963f, 386.966125f, 681.035706f, 384.646118f); 223 pathB.cubicTo(678.244507f, 383.133728f, 674.247375f, 379.819397f, 673.044434f, 379.819397f); 224 pathB.cubicTo(673.027466f, 379.819397f, 673.011475f, 379.820404f, 672.996521f, 379.821411f); 225 pathB.moveTo(732.95459f, 384.60318f); 226 pathB.cubicTo(733.246094f, 384.680054f, 733.391846f, 384.720001f, 733.689331f, 384.794861f); 227 pathB.cubicTo(735.072937f, 385.500641f, 735.769714f, 385.856049f, 737.162354f, 386.563812f); 228 pathB.cubicTo(737.891113f, 386.938171f, 738.164612f, 387.642975f, 738.164612f, 388.6073f); 229 pathB.lineTo(738.164612f, 408.510132f); 230 pathB.cubicTo(738.164612f, 410.257141f, 737.709412f, 411.893341f, 736.064209f, 413.416718f); 231 pathB.cubicTo(737.635498f, 414.235321f, 738.419189f, 414.651611f, 739.991455f, 415.475189f); 232 pathB.cubicTo(740.997742f, 416.034241f, 742.186707f, 416.344696f, 743.098145f, 416.379639f); 233 pathB.cubicTo(743.830872f, 416.410583f, 744.476807f, 416.175964f, 745.019836f, 415.851532f); 234 pathB.cubicTo(746.476318f, 414.977051f, 748.58075f, 413.571442f, 749.225647f, 413.079285f); 235 pathB.cubicTo(751.012573f, 414.253296f, 751.907043f, 414.845276f, 753.69696f, 416.028229f); 236 pathB.cubicTo(754.703247f, 416.610229f, 755.706543f, 416.84082f, 756.528076f, 416.892761f); 237 pathB.cubicTo(757.259827f, 416.93866f, 757.996582f, 416.807892f, 758.537659f, 416.494446f); 238 pathB.cubicTo(760.814758f, 415.174713f, 762.185425f, 413.509552f, 762.552734f, 412.830719f); 239 pathB.cubicTo(761.637329f, 412.681976f, 759.633789f, 411.58786f, 759.263428f, 411.387207f); 240 pathB.cubicTo(758.607544f, 410.994873f, 758.279114f, 410.803223f, 757.621216f, 410.413879f); 241 pathB.cubicTo(756.983276f, 410.020538f, 756.616943f, 409.301788f, 756.616943f, 408.343445f); 242 pathB.lineTo(756.616943f, 388.351746f); 243 pathB.cubicTo(756.616943f, 387.387421f, 757.164978f, 386.548859f, 758.627502f, 385.067383f); 244 pathB.cubicTo(755.523804f, 383.05484f, 753.97052f, 382.057556f, 750.862854f, 380.078949f); 245 pathB.cubicTo(749.001038f, 382.112457f, 748.069641f, 383.130707f, 746.207825f, 385.174194f); 246 pathB.cubicTo(746.501343f, 385.292999f, 746.647095f, 385.353912f, 746.939575f, 385.472687f); 247 pathB.cubicTo(747.996765f, 386.183472f, 748.525879f, 386.538879f, 749.587036f, 387.257629f); 248 pathB.cubicTo(750.224915f, 387.724823f, 750.498474f, 388.351746f, 750.498474f, 389.223267f); 249 pathB.lineTo(750.498474f, 407.822327f); 250 pathB.cubicTo(750.498474f, 408.694824f, 750.339722f, 409.955658f, 749.951416f, 410.847137f); 251 pathB.cubicTo(749.550049f, 411.761566f, 749.039978f, 411.585876f, 748.487915f, 411.560913f); 252 pathB.cubicTo(747.393799f, 411.503998f, 746.385498f, 410.53067f, 745.473083f, 410.022552f); 253 pathB.cubicTo(744.760254f, 409.627228f, 744.380981f, 409.013275f, 744.380981f, 407.965088f); 254 pathB.lineTo(744.380981f, 386.840363f); 255 pathB.cubicTo(744.380981f, 385.791138f, 744.833191f, 384.763916f, 745.657776f, 383.839508f); 256 pathB.cubicTo(742.656921f, 382.101501f, 741.161499f, 381.234985f, 738.162659f, 379.525909f); 257 pathB.cubicTo(736.083191f, 381.548431f, 735.039978f, 382.562683f, 732.95459f, 384.60318f); 258 pathB.moveTo(692.546936f, 385.171204f); 259 pathB.cubicTo(693.552246f, 385.667358f, 696.018005f, 387.607025f, 698.122375f, 388.521454f); 260 pathB.cubicTo(696.293518f, 390.043854f, 694.281982f, 391.844757f, 692.546936f, 393.294281f); 261 pathB.lineTo(692.546936f, 385.171204f); 262 pathB.close(); 263 pathB.moveTo(695.4729f, 379.417084f); 264 pathB.cubicTo(694.635376f, 379.426086f, 684.32605f, 384.880707f, 684.322083f, 385.025452f); 265 pathB.cubicTo(684.322083f, 385.025452f, 686.422485f, 387.645966f, 686.422485f, 388.521454f); 266 pathB.lineTo(686.422485f, 409.300781f); 267 pathB.cubicTo(686.422485f, 411.312347f, 685.51001f, 412.21579f, 684.595581f, 413.65033f); 268 pathB.cubicTo(687.592468f, 414.504852f, 689.089905f, 414.945099f, 692.088745f, 415.833557f); 269 pathB.cubicTo(693.645081f, 416.221893f, 696.128784f, 416.420563f, 697.667114f, 415.334412f); 270 pathB.cubicTo(701.67926f, 412.494293f, 705.344971f, 407.783386f, 706.077698f, 405.240753f); 271 pathB.cubicTo(707.721924f, 399.638367f, 696.822632f, 403.198273f, 696.845581f, 403.216248f); 272 pathB.cubicTo(696.845581f, 403.216248f, 705.825134f, 401.960388f, 704.337708f, 406.658325f); 273 pathB.cubicTo(703.683838f, 408.733765f, 701.044373f, 411.241455f, 699.129639f, 410.847137f); 274 pathB.cubicTo(694.843018f, 409.968628f, 692.545959f, 409.876801f, 692.545959f, 407.432983f); 275 pathB.lineTo(692.545959f, 395.563354f); 276 pathB.cubicTo(695.838318f, 391.012177f, 705.134338f, 386.160522f, 705.162292f, 385.873993f); 277 pathB.cubicTo(705.162292f, 385.873993f, 696.635925f, 379.416107f, 695.473938f, 379.417084f); 278 pathB.cubicTo(695.474915f, 379.417084f, 695.473938f, 379.417084f, 695.4729f, 379.417084f); 279 pathB.moveTo(570.463562f, 420.81601f); 280 pathB.lineTo(570.463562f, 402.922729f); 281 pathB.cubicTo(571.039551f, 402.800934f, 571.327087f, 402.743042f, 571.901123f, 402.625244f); 282 pathB.lineTo(571.901123f, 423.142029f); 283 pathB.cubicTo(570.911804f, 422.823578f, 570.463562f, 422.123779f, 570.463562f, 420.81601f); 284 pathB.moveTo(570.463562f, 384.062134f); 285 pathB.cubicTo(571.039551f, 384.149963f, 571.327087f, 384.198883f, 571.901123f, 384.290741f); 286 pathB.lineTo(571.901123f, 401.580048f); 287 pathB.cubicTo(571.327087f, 401.695862f, 571.039551f, 401.756744f, 570.463562f, 401.874542f); 288 pathB.lineTo(570.463562f, 384.062134f); 289 pathB.close(); 290 pathB.moveTo(573.880676f, 376.556f); 291 pathB.cubicTo(572.483093f, 376.996246f, 561.476013f, 385.624451f, 561.482971f, 385.70929f); 292 pathB.cubicTo(561.482971f, 385.70929f, 563.637268f, 388.554413f, 563.637268f, 389.688446f); 293 pathB.lineTo(563.637268f, 398.423462f); 294 pathB.cubicTo(556.411682f, 399.838043f, 555.429382f, 404.307373f, 555.418396f, 405.679993f); 295 pathB.lineTo(555.418396f, 405.724915f); 296 pathB.cubicTo(555.42041f, 405.94455f, 555.448364f, 406.073334f, 555.477295f, 406.083313f); 297 pathB.cubicTo(555.477295f, 406.083313f, 558.070862f, 404.250458f, 563.637268f, 403.222229f); 298 pathB.lineTo(563.637268f, 404.797516f); 299 pathB.cubicTo(556.993713f, 406.233063f, 555.191772f, 412.494293f, 555.569153f, 412.614105f); 300 pathB.cubicTo(555.569153f, 412.614105f, 561.572815f, 410.21521f, 563.637268f, 409.598267f); 301 pathB.lineTo(563.637268f, 424.00354f); 302 pathB.cubicTo(563.637268f, 426.357483f, 563.36676f, 427.901855f, 562.291565f, 429.70874f); 303 pathB.cubicTo(565.448181f, 430.067139f, 567.028442f, 430.256805f, 570.192017f, 430.653137f); 304 pathB.cubicTo(571.99292f, 430.893707f, 574.782166f, 430.669098f, 576.403381f, 429.136719f); 305 pathB.cubicTo(580.960571f, 424.828125f, 586.135681f, 419.346527f, 586.135681f, 416.115082f); 306 pathB.lineTo(586.135681f, 406.511566f); 307 pathB.cubicTo(586.135681f, 405.377533f, 586.047791f, 404.608856f, 586.678711f, 403.271149f); 308 pathB.cubicTo(584.151062f, 404.98819f, 582.888245f, 405.851715f, 580.362549f, 407.587738f); 309 pathB.cubicTo(579.281433f, 408.320465f, 579.192566f, 409.2948f, 579.192566f, 410.955933f); 310 pathB.lineTo(579.192566f, 421.869202f); 311 pathB.cubicTo(579.192566f, 423.180969f, 577.746033f, 423.273804f, 577.392639f, 423.266815f); 312 pathB.cubicTo(575.636658f, 423.228882f, 574.153259f, 423.295776f, 573.071106f, 423.077148f); 313 pathB.lineTo(573.071106f, 384.663086f); 314 pathB.cubicTo(575.230408f, 385.379852f, 576.309509f, 385.742249f, 578.473816f, 386.473999f); 315 pathB.cubicTo(579.373291f, 386.996094f, 579.553955f, 387.490234f, 579.553955f, 388.013336f); 316 pathB.cubicTo(581.861023f, 384.848785f, 583.015991f, 383.267487f, 585.325073f, 380.114899f); 317 pathB.cubicTo(581.680298f, 379.229431f, 575.865295f, 376.520081f, 574.157227f, 376.521057f); 318 pathB.cubicTo(574.047424f, 376.522064f, 573.955566f, 376.533051f, 573.880676f, 376.556f); 319 pathB.moveTo(593.447083f, 375.096527f); 320 pathB.cubicTo(592.363953f, 375.804291f, 591.821899f, 376.772644f, 591.821899f, 377.908691f); 321 pathB.lineTo(591.821899f, 419.46933f); 322 pathB.cubicTo(591.821899f, 420.517517f, 591.187012f, 422.018951f, 589.921143f, 423.991577f); 323 pathB.cubicTo(591.2948f, 424.412842f, 591.982605f, 424.622467f, 593.354248f, 425.050751f); 324 pathB.cubicTo(594.53125f, 425.462036f, 595.525513f, 425.555878f, 596.427979f, 425.404144f); 325 pathB.cubicTo(597.150757f, 425.279358f, 597.785645f, 424.914978f, 598.326721f, 424.475739f); 326 pathB.cubicTo(600.935242f, 422.385315f, 602.846985f, 419.809753f, 602.759094f, 419.749847f); 327 pathB.cubicTo(602.759094f, 419.749847f, 601.582153f, 419.935516f, 600.59082f, 419.831696f); 328 pathB.cubicTo(600.0448f, 419.74585f, 599.774231f, 419.700928f, 599.233154f, 419.615082f); 329 pathB.cubicTo(598.416565f, 419.484314f, 597.965332f, 418.860382f, 597.965332f, 417.988861f); 330 pathB.lineTo(597.965332f, 396.857147f); 331 pathB.cubicTo(597.965332f, 395.376678f, 598.326721f, 394.617004f, 598.867798f, 394.528137f); 332 pathB.cubicTo(599.232178f, 394.466248f, 599.773254f, 394.731812f, 600.59082f, 395.124115f); 333 pathB.cubicTo(601.601074f, 395.589325f, 602.111206f, 395.819946f, 603.123474f, 396.288116f); 334 pathB.cubicTo(603.93811f, 396.686432f, 603.93512f, 397.38324f, 603.93512f, 398.169891f); 335 pathB.cubicTo(603.93512f, 405.971497f, 603.93512f, 413.768127f, 603.93811f, 421.569702f); 336 pathB.cubicTo(603.93811f, 425.325256f, 601.109924f, 430.634155f, 601.133911f, 430.656128f); 337 pathB.cubicTo(601.133911f, 430.656128f, 605.184937f, 427.222015f, 607.017822f, 424.414825f); 338 pathB.cubicTo(609.118164f, 421.201355f, 610.280212f, 417.987854f, 610.280212f, 415.109802f); 339 pathB.lineTo(610.280212f, 394.593048f); 340 pathB.cubicTo(610.280212f, 393.890228f, 610.823242f, 393.112579f, 611.728699f, 392.020447f); 341 pathB.cubicTo(608.827698f, 390.960266f, 604.000977f, 387.703857f, 602.759094f, 387.967407f); 342 pathB.cubicTo(602.120239f, 388.104187f, 599.957947f, 391.29071f, 597.965332f, 393.27829f); 343 pathB.lineTo(597.965332f, 374.422668f); 344 pathB.cubicTo(597.965332f, 373.461334f, 598.326721f, 372.440063f, 598.867798f, 371.567566f); 345 pathB.cubicTo(596.701538f, 372.96817f, 595.616394f, 373.677948f, 593.447083f, 375.096527f); 346 pathB.moveTo(718.054138f, 409.318756f); 347 pathB.cubicTo(717.461182f, 408.789673f, 716.867188f, 408.178711f, 716.867188f, 407.218353f); 348 pathB.lineTo(716.867188f, 387.053986f); 349 pathB.cubicTo(716.867188f, 385.305969f, 717.323425f, 385.566528f, 718.328674f, 386.013763f); 350 pathB.cubicTo(719.645386f, 386.859314f, 720.307251f, 387.284576f, 721.622009f, 388.135132f); 351 pathB.cubicTo(722.266907f, 388.4935f, 722.903809f, 388.934753f, 722.903809f, 389.721405f); 352 pathB.lineTo(722.903809f, 407.794373f); 353 pathB.cubicTo(722.903809f, 408.66687f, 722.746094f, 410.490753f, 722.259888f, 410.758301f); 354 pathB.cubicTo(722.125122f, 410.83017f, 721.950439f, 410.862122f, 721.746826f, 410.862122f); 355 pathB.cubicTo(720.655701f, 410.864105f, 718.747925f, 409.936707f, 718.054138f, 409.318756f); 356 pathB.moveTo(711.928711f, 364.782227f); 357 pathB.cubicTo(711.195923f, 365.134613f, 710.648865f, 365.834412f, 710.648865f, 366.794769f); 358 pathB.lineTo(710.648865f, 407.392059f); 359 pathB.cubicTo(710.648865f, 409.397614f, 708.519531f, 411.37323f, 708.547485f, 411.684692f); 360 pathB.cubicTo(708.550476f, 411.745605f, 711.838867f, 413.067322f, 713.849365f, 414.368073f); 361 pathB.cubicTo(717.766663f, 416.906738f, 720.162537f, 415.845551f, 722.354797f, 414.073608f); 362 pathB.cubicTo(724.059875f, 412.69397f, 726.55957f, 410.981903f, 730.675537f, 410.124359f); 363 pathB.cubicTo(729.75708f, 409.143066f, 729.213013f, 407.993042f, 729.213013f, 406.683289f); 364 pathB.cubicTo(729.213013f, 399.630402f, 729.209045f, 396.103455f, 729.209045f, 389.047546f); 365 pathB.cubicTo(729.209045f, 387.648956f, 730.577698f, 385.292023f, 730.583679f, 385.149261f); 366 pathB.cubicTo(730.583679f, 385.149261f, 720.888306f, 378.762207f, 719.609497f, 378.947906f); 367 pathB.cubicTo(719.275085f, 378.996826f, 717.872498f, 381.118164f, 716.868225f, 381.896851f); 368 pathB.lineTo(716.868225f, 365.046783f); 369 pathB.cubicTo(716.868225f, 363.740021f, 716.960083f, 363.043213f, 717.597961f, 362); 370 pathB.cubicTo(715.331848f, 363.104095f, 714.19873f, 363.657166f, 711.928711f, 364.782227f); 371 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 372 } 373 374 static void skpeverytechpro_blogspot_com100(skiatest::Reporter* reporter, const char* filename) { 375 SkPath path; 376 path.setFillType(SkPath::kEvenOdd_FillType); 377 path.moveTo(1074.29285f, 627.292786f); 378 path.quadTo(1074.58582f, 627, 1075, 627); 379 path.lineTo(1117, 627); 380 path.quadTo(1124.04163f, 627, 1129.02246f, 631.9776f); 381 path.quadTo(1134, 636.958374f, 1134, 644); 382 path.lineTo(1134, 645); 383 path.quadTo(1134, 652.041626f, 1129.02246f, 657.0224f); 384 path.quadTo(1124.04163f, 662, 1117, 662); 385 path.lineTo(1075, 662); 386 path.quadTo(1074.58582f, 662, 1074.29285f, 661.707214f); 387 path.quadTo(1074, 661.414185f, 1074, 661); 388 path.lineTo(1074, 628); 389 path.quadTo(1074, 627.585815f, 1074.29285f, 627.292786f); 390 path.close(); 391 path.moveTo(1076, 629); 392 path.lineTo(1117, 629); 393 path.cubicTo(1125.2843f, 629, 1132, 635.715698f, 1132, 644); 394 path.lineTo(1132, 645); 395 path.cubicTo(1132, 653.284302f, 1125.2843f, 660, 1117, 660); 396 path.lineTo(1076, 660); 397 path.lineTo(1076, 629); 398 path.close(); 399 SkPath pathB; 400 pathB.setFillType(SkPath::kWinding_FillType); 401 pathB.moveTo(1074, 627); 402 pathB.lineTo(1075, 628); 403 pathB.lineTo(1116.5f, 644.5f); 404 pathB.lineTo(1134, 627); 405 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 406 } 407 408 static void skpflite_com41(skiatest::Reporter* reporter, const char* filename) { 409 SkPath path; 410 path.setFillType(SkPath::kEvenOdd_FillType); 411 path.moveTo(301.464081f, 424); 412 path.lineTo(296, 433.46405f); 413 path.lineTo(296, 433.810822f); 414 path.lineTo(303.25589f, 438); 415 path.lineTo(304.729736f, 438); 416 path.lineTo(311, 427.139557f); 417 path.lineTo(311, 426.305237f); 418 path.lineTo(307.007202f, 424); 419 path.lineTo(301.464081f, 424); 420 path.close(); 421 SkPath pathB; 422 pathB.setFillType(SkPath::kWinding_FillType); 423 pathB.moveTo(302.849854f, 421.599762f); 424 pathB.lineTo(311.510101f, 426.599762f); 425 pathB.lineTo(304.510101f, 438.724121f); 426 pathB.lineTo(295.849854f, 433.724121f); 427 pathB.close(); 428 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 429 } 430 431 static void skpilkoora_com37(skiatest::Reporter* reporter, const char* filename) { 432 SkPath path; 433 path.setFillType(SkPath::kEvenOdd_FillType); 434 path.moveTo(818, 157); 435 path.cubicTo(818, 148.715729f, 824.715698f, 142, 833, 142); 436 path.lineTo(909, 142); 437 path.lineTo(909, 143); 438 path.lineTo(833, 143); 439 path.cubicTo(825.268005f, 143, 819, 149.268005f, 819, 157); 440 path.lineTo(819, 926); 441 path.lineTo(818, 926); 442 path.lineTo(818, 157); 443 path.close(); 444 path.moveTo(1184, 926); 445 path.lineTo(1185, 926); 446 path.lineTo(1185, 157); 447 path.cubicTo(1185, 148.715729f, 1178.2843f, 142, 1170, 142); 448 path.lineTo(1093, 142); 449 path.lineTo(1093, 143); 450 path.lineTo(1170, 143); 451 path.cubicTo(1177.73193f, 143, 1184, 149.268005f, 1184, 157); 452 path.lineTo(1184, 926); 453 path.close(); 454 SkPath pathB; 455 pathB.setFillType(SkPath::kWinding_FillType); 456 pathB.moveTo(1185, 142); 457 pathB.lineTo(1001.5f, 325.5f); 458 pathB.lineTo(1001.5f, 782.5f); 459 pathB.lineTo(1185, 966); 460 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 461 } 462 463 static void skpmm4everfriends_com43(skiatest::Reporter* reporter, const char* filename) { 464 SkPath path; 465 path.setFillType(SkPath::kEvenOdd_FillType); 466 path.moveTo(540.74231f, 215.922546f); 467 path.cubicTo(540.893127f, 215.391159f, 541.443909f, 215.090134f, 541.972473f, 215.250168f); 468 path.lineTo(581.213318f, 227.131104f); 469 path.cubicTo(581.741882f, 227.291153f, 582.048157f, 227.851654f, 581.897339f, 228.383041f); 470 path.lineTo(576.708923f, 246.663925f); 471 path.cubicTo(576.558167f, 247.195297f, 576.007324f, 247.496338f, 575.47876f, 247.336288f); 472 path.lineTo(536.237915f, 235.455353f); 473 path.cubicTo(535.709351f, 235.295319f, 535.403137f, 234.734802f, 535.553894f, 234.20343f); 474 path.lineTo(540.74231f, 215.922546f); 475 path.close(); 476 SkPath pathB; 477 pathB.setFillType(SkPath::kWinding_FillType); 478 pathB.moveTo(541.015381f, 214.960388f); 479 pathB.lineTo(582.17041f, 227.420883f); 480 pathB.lineTo(576.435852f, 247.626068f); 481 pathB.lineTo(535.280823f, 235.165573f); 482 pathB.close(); 483 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 484 } 485 486 static void skpmtrk_uz27(skiatest::Reporter* reporter, const char* filename) { 487 SkPath path; 488 path.setFillType(SkPath::kEvenOdd_FillType); 489 path.moveTo(33, 787); 490 path.lineTo(33, 412); 491 path.lineTo(1233, 412); 492 path.lineTo(1233, 787); 493 path.quadTo(1233, 793.213196f, 1228.60803f, 797.607971f); 494 path.quadTo(1224.21326f, 802, 1218, 802); 495 path.lineTo(48, 802); 496 path.quadTo(41.7867966f, 802, 37.3919983f, 797.607971f); 497 path.quadTo(33, 793.213196f, 33, 787); 498 path.close(); 499 SkPath pathB; 500 pathB.setFillType(SkPath::kWinding_FillType); 501 pathB.moveTo(33, 412); 502 pathB.lineTo(1233, 412); 503 pathB.lineTo(1233, 787); 504 pathB.quadTo(1233, 793.213196f, 1228.60791f, 797.608032f); 505 pathB.quadTo(1224.21313f, 802, 1218, 802); 506 pathB.lineTo(48, 802); 507 pathB.quadTo(41.7867432f, 802, 37.3919678f, 797.608032f); 508 pathB.quadTo(33, 793.213196f, 33, 787); 509 pathB.close(); 510 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 511 } 512 513 static void skpfrauen_magazin_com83(skiatest::Reporter* reporter, const char* filename) { 514 SkPath path; 515 path.setFillType(SkPath::kEvenOdd_FillType); 516 path.moveTo(808, 886); 517 path.cubicTo(805.581055f, 886, 803.563293f, 887.717773f, 803.100037f, 890); 518 path.lineTo(1122.90002f, 890); 519 path.cubicTo(1122.43677f, 887.717773f, 1120.41895f, 886, 1118, 886); 520 path.lineTo(808, 886); 521 path.close(); 522 SkPath pathB; 523 pathB.setFillType(SkPath::kInverseWinding_FillType); 524 pathB.moveTo(808, 886); 525 pathB.lineTo(1118, 886); 526 pathB.cubicTo(1120.76147f, 886, 1123, 888.238586f, 1123, 891); 527 pathB.lineTo(1123, 1521); 528 pathB.cubicTo(1123, 1523.20911f, 1120.76147f, 1525, 1118, 1525); 529 pathB.lineTo(808, 1525); 530 pathB.cubicTo(805.238586f, 1525, 803, 1523.20911f, 803, 1521); 531 pathB.lineTo(803, 891); 532 pathB.cubicTo(803, 888.238586f, 805.238586f, 886, 808, 886); 533 pathB.close(); 534 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 535 } 536 537 static void skpi_gino_com16(skiatest::Reporter* reporter, const char* filename) { 538 SkPath path; 539 path.setFillType(SkPath::kEvenOdd_FillType); 540 path.moveTo(184, 734); 541 path.quadTo(133.051727f, 734, 97.0258636f, 770.025879f); 542 path.quadTo(61, 806.051758f, 61, 857); 543 path.quadTo(61, 895.835083f, 81.9317017f, 926); 544 path.lineTo(286.068298f, 926); 545 path.quadTo(307, 895.835083f, 307, 857); 546 path.quadTo(307, 806.051758f, 270.974121f, 770.025879f); 547 path.quadTo(234.948273f, 734, 184, 734); 548 path.close(); 549 SkPath pathB; 550 pathB.setFillType(SkPath::kWinding_FillType); 551 pathB.moveTo(185, 734); 552 pathB.cubicTo(252.93103f, 734, 308, 789.06897f, 308, 857); 553 pathB.cubicTo(308, 924.93103f, 252.93103f, 980, 185, 980); 554 pathB.lineTo(184, 980); 555 pathB.cubicTo(116.068977f, 980, 61, 924.93103f, 61, 857); 556 pathB.cubicTo(61, 789.06897f, 116.068977f, 734, 184, 734); 557 pathB.lineTo(185, 734); 558 pathB.close(); 559 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 560 } 561 562 static void skppchappy_com_au102(skiatest::Reporter* reporter, const char* filename) { 563 SkPath path; 564 path.setFillType(SkPath::kEvenOdd_FillType); 565 path.moveTo(363, 493); 566 path.cubicTo(360.790863f, 493, 359, 494.790863f, 359, 497); 567 path.lineTo(359, 656); 568 path.cubicTo(359, 658.209106f, 360.790863f, 660, 363, 660); 569 path.lineTo(623.001709f, 660); 570 path.cubicTo(624.657776f, 659.999023f, 626, 658.65625f, 626, 657); 571 path.lineTo(626, 496); 572 path.cubicTo(626, 494.343872f, 624.657959f, 493.00116f, 623.002075f, 493); 573 path.lineTo(363, 493); 574 path.close(); 575 SkPath pathB; 576 pathB.setFillType(SkPath::kInverseWinding_FillType); 577 pathB.moveTo(362, 494); 578 pathB.lineTo(623, 494); 579 pathB.cubicTo(624.65686f, 494, 626, 494.895416f, 626, 496); 580 pathB.lineTo(626, 657); 581 pathB.cubicTo(626, 658.65686f, 624.65686f, 660, 623, 660); 582 pathB.lineTo(362, 660); 583 pathB.cubicTo(360.34314f, 660, 359, 658.65686f, 359, 657); 584 pathB.lineTo(359, 496); 585 pathB.cubicTo(359, 494.895416f, 360.34314f, 494, 362, 494); 586 pathB.close(); 587 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 588 } 589 590 static void skpsciality_com161(skiatest::Reporter* reporter, const char* filename) { 591 SkPath path; 592 path.setFillType(SkPath::kEvenOdd_FillType); 593 path.moveTo(656, 728); 594 path.cubicTo(653.790833f, 728, 652, 729.790833f, 652, 732); 595 path.lineTo(652, 789); 596 path.cubicTo(652, 791.209106f, 653.790833f, 793, 656, 793); 597 path.lineTo(769.001282f, 793); 598 path.cubicTo(770.657532f, 792.999268f, 772, 791.656433f, 772, 790); 599 path.lineTo(772, 731); 600 path.cubicTo(772, 729.34314f, 770.65686f, 728, 769, 728); 601 path.lineTo(656, 728); 602 path.close(); 603 SkPath pathB; 604 pathB.setFillType(SkPath::kInverseWinding_FillType); 605 pathB.moveTo(655, 729); 606 pathB.lineTo(769, 729); 607 pathB.cubicTo(770.65686f, 729, 772, 729.895447f, 772, 731); 608 pathB.lineTo(772, 790); 609 pathB.cubicTo(772, 791.65686f, 770.65686f, 793, 769, 793); 610 pathB.lineTo(655, 793); 611 pathB.cubicTo(653.34314f, 793, 652, 791.65686f, 652, 790); 612 pathB.lineTo(652, 731); 613 pathB.cubicTo(652, 729.895447f, 653.34314f, 729, 655, 729); 614 pathB.close(); 615 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 616 } 617 618 static void skpsudoestenegocios_com186(skiatest::Reporter* reporter, const char* filename) { 619 SkPath path; 620 path.setFillType(SkPath::kEvenOdd_FillType); 621 path.moveTo(0, 495); 622 path.lineTo(1.23685242e-14f, 293); 623 path.lineTo(44, 293); 624 path.quadTo(45.6568527f, 293, 46.8288002f, 294.171204f); 625 path.quadTo(48, 295.34314f, 48, 297); 626 path.lineTo(48, 491); 627 path.quadTo(48, 492.65686f, 46.8288002f, 493.828796f); 628 path.quadTo(45.6568527f, 495, 44, 495); 629 path.lineTo(0, 495); 630 path.close(); 631 path.moveTo(1, 294); 632 path.lineTo(44, 294); 633 path.cubicTo(45.6568565f, 294, 47, 295.34314f, 47, 297); 634 path.lineTo(47, 491); 635 path.cubicTo(47, 492.65686f, 45.6568565f, 494, 44, 494); 636 path.lineTo(1, 494); 637 path.lineTo(1, 294); 638 path.close(); 639 SkPath pathB; 640 pathB.setFillType(SkPath::kWinding_FillType); 641 pathB.moveTo(48, 495); 642 pathB.lineTo(24, 471); 643 pathB.lineTo(24, 317); 644 pathB.lineTo(48, 293); 645 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 646 } 647 648 static void skpthesuburbanite_com213(skiatest::Reporter* reporter, const char* filename) { 649 SkPath path; 650 path.setFillType(SkPath::kEvenOdd_FillType); 651 path.moveTo(863.439026f, 692); 652 path.lineTo(863.283264f, 692); 653 path.lineTo(802, 708.420837f); 654 path.lineTo(802, 718.773621f); 655 path.lineTo(866, 701.624817f); 656 path.lineTo(866, 701.557922f); 657 path.lineTo(863.439026f, 692); 658 path.close(); 659 SkPath pathB; 660 pathB.setFillType(SkPath::kWinding_FillType); 661 pathB.moveTo(783.256775f, 713.443054f); 662 pathB.lineTo(863.428589f, 691.96106f); 663 pathB.lineTo(866.016724f, 701.620361f); 664 pathB.lineTo(785.84491f, 723.102356f); 665 pathB.close(); 666 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 667 } 668 669 static void skphostloco_com11(skiatest::Reporter* reporter, const char* filename) { 670 SkPath path; 671 path.setFillType(SkPath::kEvenOdd_FillType); 672 path.moveTo(6.66133815e-16f, 648); 673 path.lineTo(25.8522835f, 648); 674 path.quadTo(27.5087376f, 647.999634f, 28.6807098f, 646.82843f); 675 path.quadTo(29.8518829f, 645.656433f, 29.8522835f, 644); 676 path.lineTo(29.8522835f, 467); 677 path.quadTo(29.8518829f, 465.343536f, 28.6807098f, 464.17157f); 678 path.quadTo(27.5087376f, 463.000397f, 25.8522835f, 463); 679 path.lineTo(2.22044605e-16f, 463); 680 path.lineTo(6.66133815e-16f, 648); 681 path.close(); 682 SkPath pathB; 683 pathB.setFillType(SkPath::kWinding_FillType); 684 pathB.moveTo(0, 463); 685 pathB.lineTo(30, 463); 686 pathB.lineTo(30, 648); 687 pathB.lineTo(0, 648); 688 pathB.close(); 689 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 690 } 691 692 static void skpsergeychunkevich_com8(skiatest::Reporter* reporter, const char* filename) { 693 SkPath path; 694 path.setFillType(SkPath::kEvenOdd_FillType); 695 path.moveTo(0, 926); 696 path.lineTo(0, 0); 697 path.lineTo(1265, 0); 698 path.lineTo(1265, 926); 699 path.lineTo(0, 926); 700 path.close(); 701 SkPath pathB; 702 pathB.setFillType(SkPath::kInverseWinding_FillType); 703 pathB.moveTo(37, 374); 704 pathB.lineTo(37, 535); 705 pathB.cubicTo(37, 536.65686f, 35.6568565f, 538, 34, 538); 706 pathB.lineTo(1.02866934e-14f, 538); 707 pathB.lineTo(6.12303177e-17f, 371); 708 pathB.lineTo(34, 371); 709 pathB.cubicTo(35.6568565f, 371, 37, 372.34314f, 37, 374); 710 pathB.close(); 711 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 712 } 713 714 static void skptracksflow_com9(skiatest::Reporter* reporter, const char* filename) { 715 SkPath path; 716 path.setFillType(SkPath::kEvenOdd_FillType); 717 path.moveTo(16, 56); 718 path.lineTo(32, 56); 719 path.lineTo(32, 72); 720 path.lineTo(16, 72); 721 path.lineTo(16, 56); 722 path.close(); 723 SkPath pathB; 724 pathB.setFillType(SkPath::kEvenOdd_FillType); 725 pathB.moveTo(31.65625f, 70.0555649f); 726 pathB.lineTo(31.65625f, 70.0554962f); 727 pathB.lineTo(26.9727192f, 65.3615341f); 728 pathB.cubicTo(27.6210003f, 64.4029694f, 28.0048752f, 63.2470932f, 28.0048752f, 62.0027809f); 729 pathB.cubicTo(28.0048752f, 58.6875305f, 25.3199062f, 56, 22.0046558f, 56); 730 pathB.cubicTo(18.6894073f, 56, 16.0031872f, 58.6875305f, 16.0031872f, 62.0027809f); 731 pathB.cubicTo(16.0031872f, 65.3180008f, 18.6913433f, 68.0055618f, 22.0066261f, 68.0055618f); 732 pathB.cubicTo(23.2509995f, 68.0055618f, 24.4072189f, 67.6187515f, 25.3657818f, 66.9704056f); 733 pathB.lineTo(30.0599365f, 71.65625f); 734 pathB.lineTo(30.0600014f, 71.65625f); 735 pathB.cubicTo(30.2668133f, 71.875f, 30.5524693f, 71.9992828f, 30.868f, 71.9992828f); 736 pathB.cubicTo(31.4994049f, 71.9992828f, 32.0014687f, 71.4909363f, 32.0014687f, 70.8595276f); 737 pathB.cubicTo(32.0015335f, 70.5439072f, 31.875f, 70.2623444f, 31.65625f, 70.0555649f); 738 pathB.close(); 739 pathB.moveTo(18.0054054f, 62.0027809f); 740 pathB.cubicTo(18.0054054f, 59.7925949f, 19.7970943f, 58.0009079f, 22.0072823f, 58.0009079f); 741 pathB.cubicTo(24.2174377f, 58.0009079f, 26.0091248f, 59.7925949f, 26.0091248f, 62.0027809f); 742 pathB.cubicTo(26.0091248f, 64.2129364f, 24.2174377f, 66.0046234f, 22.0072803f, 66.0046234f); 743 pathB.cubicTo(19.7970943f, 66.0045929f, 18.0054054f, 64.2129059f, 18.0054054f, 62.0027809f); 744 pathB.close(); 745 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 746 } 747 748 static void skpautobutler_dk29(skiatest::Reporter* reporter, const char* filename) { 749 SkPath path; 750 path.setFillType(SkPath::kEvenOdd_FillType); 751 path.moveTo(0, 926); 752 path.lineTo(0, 0); 753 path.lineTo(1265, 0); 754 path.lineTo(1265, 926); 755 path.lineTo(0, 926); 756 path.close(); 757 SkPath pathB; 758 pathB.setFillType(SkPath::kWinding_FillType); 759 pathB.moveTo(21, 162); 760 pathB.lineTo(21, 301); 761 pathB.lineTo(8.57224448e-15f, 301); 762 pathB.lineTo(6.12303177e-17f, 162); 763 pathB.close(); 764 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 765 } 766 767 static void skponlinecollege_org144(skiatest::Reporter* reporter, const char* filename) { 768 SkPath path; 769 path.setFillType(SkPath::kEvenOdd_FillType); 770 path.moveTo(179, 407); 771 path.cubicTo(177.34314f, 407, 176, 408.34314f, 176, 410); 772 path.lineTo(176, 436); 773 path.cubicTo(176, 437.65686f, 177.34314f, 439, 179, 439); 774 path.lineTo(337.002289f, 439); 775 path.cubicTo(338.105835f, 438.998779f, 339, 438.103821f, 339, 437); 776 path.lineTo(339, 409); 777 path.cubicTo(339, 407.896362f, 338.10611f, 407.001526f, 337.002838f, 407); 778 path.lineTo(179, 407); 779 path.close(); 780 SkPath pathB; 781 pathB.setFillType(SkPath::kInverseWinding_FillType); 782 pathB.moveTo(179, 408); 783 pathB.lineTo(337, 408); 784 pathB.cubicTo(338.65686f, 408, 340, 408.895416f, 340, 410); 785 pathB.lineTo(340, 436); 786 pathB.cubicTo(340, 437.65686f, 338.65686f, 439, 337, 439); 787 pathB.lineTo(179, 439); 788 pathB.cubicTo(177.895432f, 439, 177, 437.65686f, 177, 436); 789 pathB.lineTo(177, 410); 790 pathB.cubicTo(177, 408.895416f, 177.895432f, 408, 179, 408); 791 pathB.close(); 792 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 793 } 794 795 static void skpnational_com_au81(skiatest::Reporter* reporter, const char* filename) { 796 SkPath path; 797 path.setFillType(SkPath::kEvenOdd_FillType); 798 path.moveTo(807, 817); 799 path.quadTo(806.585876f, 817.000122f, 806.292908f, 817.292908f); 800 path.quadTo(806.000122f, 817.585876f, 806, 818); 801 path.lineTo(806, 881); 802 path.lineTo(1111, 881); 803 path.lineTo(1111, 818); 804 path.quadTo(1110.99988f, 817.585876f, 1110.70715f, 817.292908f); 805 path.quadTo(1110.41406f, 817.000122f, 1110, 817); 806 path.lineTo(807, 817); 807 path.close(); 808 SkPath pathB; 809 pathB.setFillType(SkPath::kInverseWinding_FillType); 810 pathB.moveTo(807, 817); 811 pathB.lineTo(1110, 817); 812 pathB.cubicTo(1110.55225f, 817, 1111, 817.447693f, 1111, 818); 813 pathB.lineTo(1111, 880); 814 pathB.lineTo(806, 880); 815 pathB.lineTo(806, 818); 816 pathB.cubicTo(806, 817.447693f, 806.447693f, 817, 807, 817); 817 pathB.close(); 818 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 819 } 820 821 static void skprentacheat_com30(skiatest::Reporter* reporter, const char* filename) { 822 SkPath path; 823 path.setFillType(SkPath::kEvenOdd_FillType); 824 path.moveTo(967, 263); 825 path.quadTo(966.585876f, 263.000092f, 966.292908f, 263.292908f); 826 path.quadTo(966.000122f, 263.585876f, 966, 264); 827 path.lineTo(966, 301); 828 path.lineTo(1214, 301); 829 path.lineTo(1214, 264); 830 path.quadTo(1213.99988f, 263.585876f, 1213.70715f, 263.292908f); 831 path.quadTo(1213.41406f, 263.000092f, 1213, 263); 832 path.lineTo(967, 263); 833 path.close(); 834 SkPath pathB; 835 pathB.setFillType(SkPath::kInverseWinding_FillType); 836 pathB.moveTo(967, 263); 837 pathB.lineTo(1213, 263); 838 pathB.cubicTo(1213.55225f, 263, 1214, 263.447723f, 1214, 264); 839 pathB.lineTo(1214, 300); 840 pathB.lineTo(966, 300); 841 pathB.lineTo(966, 264); 842 pathB.cubicTo(966, 263.447723f, 966.447693f, 263, 967, 263); 843 pathB.close(); 844 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 845 } 846 847 static void skpbreakmystyle_com10(skiatest::Reporter* reporter, const char* filename) { 848 SkPath path; 849 path.setFillType(SkPath::kEvenOdd_FillType); 850 path.moveTo(271.032867f, -5.32907052e-15f); 851 path.lineTo(56.9671326f, -5.16253706e-15f); 852 path.quadTo(52.7835083f, 3.69968891f, 48.7416f, 7.74160004f); 853 path.quadTo(1, 55.4831848f, 1, 123); 854 path.quadTo(1, 190.516815f, 48.7416f, 238.258392f); 855 path.quadTo(96.4831848f, 286, 164, 286); 856 path.quadTo(231.516815f, 286, 279.258392f, 238.258392f); 857 path.quadTo(327, 190.516815f, 327, 123); 858 path.quadTo(327, 55.4831848f, 279.258392f, 7.74160004f); 859 path.quadTo(275.216431f, 3.69964004f, 271.032867f, -5.32907052e-15f); 860 path.close(); 861 SkPath pathB; 862 pathB.setFillType(SkPath::kWinding_FillType); 863 pathB.moveTo(327, 123); 864 pathB.quadTo(327, 190.516815f, 279.258392f, 238.258392f); 865 pathB.quadTo(231.516815f, 286, 164, 286); 866 pathB.quadTo(96.4831848f, 286, 48.7416f, 238.258392f); 867 pathB.quadTo(1, 190.516815f, 1, 123); 868 pathB.quadTo(1, 55.4831848f, 48.7416f, 7.74160004f); 869 pathB.quadTo(96.4831848f, -40, 164, -40); 870 pathB.quadTo(231.516815f, -40, 279.258392f, 7.74160004f); 871 pathB.quadTo(327, 55.4831848f, 327, 123); 872 pathB.close(); 873 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 874 } 875 876 static void skpsd_graphic_net104(skiatest::Reporter* reporter, const char* filename) { 877 SkPath path; 878 path.setFillType(SkPath::kEvenOdd_FillType); 879 path.moveTo(475.421448f, 836.985962f); 880 path.lineTo(461.280975f, 841.990662f); 881 path.cubicTo(466.80899f, 857.609802f, 458.62854f, 874.752991f, 443.009399f, 880.281006f); 882 path.cubicTo(435.199829f, 883.044983f, 427.009247f, 882.381897f, 420.080048f, 879.075378f); 883 path.lineTo(413.620056f, 892.613037f); 884 path.quadTo(430.419983f, 900.629761f, 447.96701f, 894.43811f); 885 path.quadTo(448.00708f, 894.42395f, 448.014038f, 894.421509f); 886 path.quadTo(448.043976f, 894.410889f, 448.061066f, 894.404846f); 887 path.quadTo(465.596313f, 888.179932f, 473.613037f, 871.379944f); 888 path.quadTo(477.351227f, 863.546143f, 478, 855.549866f); 889 path.lineTo(478, 848.804321f); 890 path.quadTo(477.528076f, 842.93811f, 475.421448f, 836.985962f); 891 path.close(); 892 SkPath pathB; 893 pathB.setFillType(SkPath::kWinding_FillType); 894 pathB.moveTo(405.592621f, 909.435547f); 895 pathB.lineTo(390.578583f, 867.014099f); 896 pathB.lineTo(433, 852.000061f); 897 pathB.lineTo(490.435486f, 879.40741f); 898 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 899 } 900 901 /* this cubic/quad pair 902 c = 430,280 430,278.895416 473.876068,278 528,278 903 q = 430,280 430.009796,277.101196 458.703552,275.050262 904 only intersect at the shared point (430,280) 905 they sort backwards because the tangent from pt[0] to control pt[1] 906 c' = (0.00000000000000000, -1.1045837402343750) 907 q' = (0.0097961425781250000, -2.8988037109375000) 908 suggests that the quad is counterclockwise of the cubic, when the reverse is true 909 the angle code is fooled because the control pt[1] of both the quad and cubic 910 is far away from cubic cntl [2] and quad pt [2]. 911 Maybe in angle setup, this instability can be detected to suppress sorting on the initial tangent 912 Or the error term can be passed to NearRay that is magnified by the distance from the next ctrl? 913 */ 914 static void skpnaoxrane_ru23(skiatest::Reporter* reporter, const char* filename) { 915 SkPath path; 916 path.setFillType(SkPath::kEvenOdd_FillType); 917 path.moveTo(458.703552f, 275.050262f); 918 path.quadTo(487.41687f, 273.000702f, 528, 273); 919 path.lineTo(529, 273); 920 path.quadTo(530.242371f, 273.000305f, 531.121338f, 273.878693f); 921 path.quadTo(531.999695f, 274.75766f, 532, 276); 922 path.lineTo(532, 378); 923 path.quadTo(531.990173f, 380.898804f, 503.296448f, 382.949738f); 924 path.quadTo(474.58313f, 384.999298f, 434, 385); 925 path.lineTo(433, 385); 926 path.quadTo(431.75766f, 384.999695f, 430.878693f, 384.121307f); 927 path.quadTo(430.000305f, 383.24234f, 430, 382); 928 path.lineTo(430, 280); 929 path.quadTo(430.009796f, 277.101196f, 458.703552f, 275.050262f); 930 path.close(); 931 SkPath pathB; 932 pathB.setFillType(SkPath::kInverseWinding_FillType); 933 pathB.moveTo(528, 278); 934 pathB.lineTo(529, 278); 935 pathB.cubicTo(530.65686f, 278, 532, 278, 532, 278); 936 pathB.lineTo(532, 378); 937 pathB.cubicTo(532, 379.104584f, 488.123932f, 380, 434, 380); 938 pathB.lineTo(433, 380); 939 pathB.cubicTo(431.34314f, 380, 430, 380, 430, 380); 940 pathB.lineTo(430, 280); 941 pathB.cubicTo(430, 278.895416f, 473.876068f, 278, 528, 278); 942 pathB.close(); 943 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 944 } 945 946 /* didn't investigate thoroughly, but looks to be missorting quad and cubic 947 {{468.507751,560.724426}, {467.275146,552.856262}, {465.84668,547.288391}} 948 {{463.779907,542.671143}, {464.829529,542.672974}, {466.946289,550.755676}, {468.507751,560.724426}} 949 decision maker is case 14 leftLessThanRight 950 */ 951 static void skptcmevents_org23(skiatest::Reporter* reporter, const char* filename) { 952 SkPath path; 953 path.setFillType(SkPath::kEvenOdd_FillType); 954 path.moveTo(465.503998f, 546); 955 path.lineTo(347, 546); 956 path.lineTo(347, 632); 957 path.lineTo(469.104248f, 632); 958 path.quadTo(470.79007f, 627.638672f, 471.833496f, 621.036255f); 959 path.quadTo(474.902588f, 601.562866f, 470.591064f, 574.024353f); 960 path.lineTo(468.507751f, 560.724426f); 961 path.quadTo(467.275146f, 552.856262f, 465.84668f, 547.288391f); 962 path.quadTo(465.670349f, 546.601501f, 465.503998f, 546); 963 path.close(); 964 SkPath pathB; 965 pathB.setFillType(SkPath::kInverseWinding_FillType); 966 pathB.moveTo(363.052246f, 542.495361f); 967 pathB.lineTo(463.779907f, 542.671143f); 968 pathB.cubicTo(464.829529f, 542.672974f, 466.946289f, 550.755676f, 468.507751f, 560.724426f); 969 pathB.lineTo(470.591064f, 574.024353f); 970 pathB.cubicTo(476.26178f, 610.226624f, 471.498932f, 639.557922f, 459.953003f, 639.537781f); 971 pathB.lineTo(368.727936f, 639.378601f); 972 pathB.cubicTo(351.933868f, 639.349304f, 337.053741f, 631.244324f, 335.492249f, 621.275574f); 973 pathB.lineTo(325.968597f, 560.475708f); 974 pathB.cubicTo(324.407104f, 550.506958f, 341.01001f, 542.456909f, 363.052246f, 542.495361f); 975 pathB.close(); 976 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 977 } 978 979 static void skpredbullskatearcade_es16(skiatest::Reporter* reporter, const char* filename) { 980 SkPath path; 981 path.setFillType(SkPath::kEvenOdd_FillType); 982 path.moveTo(936.765625f, 458.965302f); 983 path.cubicTo(937.028442f, 453.863251f, 933.145813f, 449.864502f, 928.093445f, 450.033905f); 984 path.lineTo(661.882263f, 458.958862f); 985 path.lineTo(661.875366f, 458.959106f); 986 path.cubicTo(656.828369f, 459.13205f, 652.525085f, 463.399719f, 652.258545f, 468.496124f); 987 path.lineTo(652.258179f, 468.503662f); 988 path.lineTo(649.021729f, 531.322754f); 989 path.cubicTo(648.75885f, 536.424805f, 652.641479f, 540.423523f, 657.693848f, 540.25415f); 990 path.lineTo(923.905029f, 531.329163f); 991 path.cubicTo(928.955017f, 531.159851f, 933.262268f, 526.890442f, 933.528809f, 521.791565f); 992 path.lineTo(933.529175f, 521.784363f); 993 path.lineTo(936.765625f, 458.965302f); 994 path.close(); 995 SkPath pathB; 996 pathB.setFillType(SkPath::kInverseWinding_FillType); 997 pathB.moveTo(661.882263f, 458.958862f); 998 pathB.lineTo(928.093445f, 450.033905f); 999 pathB.cubicTo(929.103882f, 450, 929.709961f, 454.108612f, 929.447144f, 459.210663f); 1000 pathB.lineTo(926.210693f, 522.029724f); 1001 pathB.cubicTo(926.079224f, 524.58075f, 925.153442f, 526.676208f, 924.143066f, 526.710083f); 1002 pathB.lineTo(657.931885f, 535.635071f); 1003 pathB.cubicTo(652.879456f, 535.804443f, 648.890259f, 533.873779f, 649.021729f, 531.322754f); 1004 pathB.lineTo(652.258179f, 468.503662f); 1005 pathB.cubicTo(652.520996f, 463.401611f, 656.829834f, 459.128235f, 661.882263f, 458.958862f); 1006 pathB.close(); 1007 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1008 } 1009 1010 static void skpfinanzasdigital_com9(skiatest::Reporter* reporter, const char* filename) { 1011 SkPath path; 1012 path.setFillType(SkPath::kEvenOdd_FillType); 1013 path.moveTo(156, 126); 1014 path.quadTo(154.343552f, 126.000397f, 153.17157f, 127.17157f); 1015 path.quadTo(152.000397f, 128.343552f, 152, 130); 1016 path.lineTo(152, 174); 1017 path.lineTo(1114, 174); 1018 path.lineTo(1114, 130); 1019 path.quadTo(1113.99963f, 128.343552f, 1112.82837f, 127.17157f); 1020 path.quadTo(1111.65649f, 126.000397f, 1110, 126); 1021 path.lineTo(156, 126); 1022 path.close(); 1023 SkPath pathB; 1024 pathB.setFillType(SkPath::kInverseWinding_FillType); 1025 pathB.moveTo(156, 126); 1026 pathB.lineTo(1110, 126); 1027 pathB.cubicTo(1111.65686f, 126, 1113, 127.790863f, 1113, 130); 1028 pathB.lineTo(1113, 174); 1029 pathB.lineTo(153, 174); 1030 pathB.lineTo(153, 130); 1031 pathB.cubicTo(153, 127.790863f, 154.34314f, 126, 156, 126); 1032 pathB.close(); 1033 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1034 } 1035 1036 static void skppartainasdemo250_org56(skiatest::Reporter* reporter, const char* filename) { 1037 SkPath path; 1038 path.setFillType(SkPath::kEvenOdd_FillType); 1039 path.moveTo(182.000015f, 645); 1040 path.lineTo(182, 640); 1041 path.cubicTo(174.322327f, 640, 166.644669f, 637.071045f, 160.786804f, 631.213196f); 1042 path.cubicTo(149.071075f, 619.497437f, 149.071075f, 600.502563f, 160.786804f, 588.786804f); 1043 path.lineTo(157.251266f, 585.251221f); 1044 path.quadTo(147, 595.502502f, 147.000015f, 610); 1045 path.quadTo(147, 624.482605f, 157.230255f, 634.727722f); 1046 path.quadTo(157.251251f, 634.748779f, 157.251282f, 634.748779f); 1047 path.quadTo(157.282852f, 634.780334f, 157.272263f, 634.769775f); 1048 path.quadTo(167.517334f, 645, 182.000015f, 645); 1049 path.close(); 1050 SkPath pathB; 1051 pathB.setFillType(SkPath::kWinding_FillType); 1052 pathB.moveTo(182, 659.497498f); 1053 pathB.lineTo(206.748749f, 634.748718f); 1054 pathB.lineTo(182.000015f, 610); 1055 pathB.lineTo(132.502533f, 610); 1056 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1057 } 1058 1059 static void skpmlk_com326(skiatest::Reporter* reporter, const char* filename) { 1060 SkPath path; 1061 path.setFillType(SkPath::kEvenOdd_FillType); 1062 path.moveTo(154, 670); 1063 path.cubicTo(151.238571f, 670, 149, 672.238586f, 149, 675); 1064 path.lineTo(149, 710.001465f); 1065 path.cubicTo(149.000809f, 712.209961f, 150.791367f, 714, 153, 714); 1066 path.lineTo(189, 714); 1067 path.cubicTo(191.209137f, 714, 193, 712.209167f, 193, 710); 1068 path.lineTo(193, 675); 1069 path.cubicTo(193, 672.238586f, 190.761429f, 670, 188, 670); 1070 path.lineTo(154, 670); 1071 path.close(); 1072 SkPath pathB; 1073 pathB.setFillType(SkPath::kInverseWinding_FillType); 1074 pathB.moveTo(154, 671); 1075 pathB.lineTo(188, 671); 1076 pathB.cubicTo(190.761429f, 671, 193, 672.790833f, 193, 675); 1077 pathB.lineTo(193, 710); 1078 pathB.cubicTo(193, 712.761414f, 190.761429f, 715, 188, 715); 1079 pathB.lineTo(154, 715); 1080 pathB.cubicTo(151.238571f, 715, 149, 712.761414f, 149, 710); 1081 pathB.lineTo(149, 675); 1082 pathB.cubicTo(149, 672.790833f, 151.238571f, 671, 154, 671); 1083 pathB.close(); 1084 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1085 } 1086 1087 static void skpcyclist_friends_gr52(skiatest::Reporter* reporter, const char* filename) { 1088 SkPath path; 1089 path.setFillType(SkPath::kEvenOdd_FillType); 1090 path.moveTo(50, 182); 1091 path.lineTo(1215, 182); 1092 path.lineTo(1215, 202); 1093 path.quadTo(1214.99951f, 204.070572f, 1213.53552f, 205.535538f); 1094 path.quadTo(1212.07056f, 206.999496f, 1210, 207); 1095 path.lineTo(55, 207); 1096 path.quadTo(52.9294319f, 206.999496f, 51.4644661f, 205.535538f); 1097 path.quadTo(50.0004997f, 204.070572f, 50, 202); 1098 path.lineTo(50, 182); 1099 path.close(); 1100 SkPath pathB; 1101 pathB.setFillType(SkPath::kInverseWinding_FillType); 1102 pathB.moveTo(50, 183); 1103 pathB.lineTo(1215, 183); 1104 pathB.lineTo(1215, 202); 1105 pathB.cubicTo(1215, 204.761429f, 1212.76147f, 207, 1210, 207); 1106 pathB.lineTo(55, 207); 1107 pathB.cubicTo(52.238575f, 207, 50, 204.761429f, 50, 202); 1108 pathB.lineTo(50, 183); 1109 pathB.close(); 1110 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1111 } 1112 1113 /* cubic ends just above opp line */ 1114 static void skpwww_fj_p_com_22(skiatest::Reporter* reporter, const char* filename) { 1115 SkPath path; 1116 path.setFillType(SkPath::kEvenOdd_FillType); 1117 path.moveTo(172, 201); 1118 path.lineTo(172, 202); 1119 path.lineTo(220, 202); 1120 path.cubicTo(221.65686f, 202, 223, 200.65686f, 223, 199); 1121 path.cubicTo(223, 200.104568f, 221.65686f, 201, 220, 201); 1122 path.lineTo(172, 201); 1123 path.close(); 1124 SkPath pathB; 1125 pathB.setFillType(SkPath::kWinding_FillType); 1126 pathB.moveTo(161, 202); 1127 pathB.lineTo(161, 199); 1128 pathB.lineTo(223, 199.000015f); 1129 pathB.lineTo(223, 202); 1130 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1131 } 1132 1133 // pair of lines are not quite coincident, so sorting line/cubic fails (i think) 1134 static void skpwww_lavoixdunord_fr_11(skiatest::Reporter* reporter, const char* filename) { 1135 SkPath path; 1136 path.setFillType(SkPath::kEvenOdd_FillType); 1137 path.moveTo(806, 57); 1138 path.cubicTo(806, 55.3431473f, 807.34314f, 54, 809, 54); 1139 path.lineTo(930, 54); 1140 path.cubicTo(931.65686f, 54, 933, 55.3431473f, 933, 57); 1141 path.lineTo(933, 91); 1142 path.cubicTo(933, 92.6568527f, 931.65686f, 94, 930, 94); 1143 path.lineTo(809, 94); 1144 path.cubicTo(807.34314f, 94, 806, 92.6568527f, 806, 91); 1145 path.lineTo(806, 57); 1146 path.close(); 1147 path.moveTo(808, 58); 1148 path.cubicTo(808, 56.8954315f, 808.895447f, 56, 810, 56); 1149 path.lineTo(929, 56); 1150 path.cubicTo(930.104553f, 56, 931, 56.8954315f, 931, 58); 1151 path.lineTo(931, 90); 1152 path.cubicTo(931, 91.1045685f, 930.104553f, 92, 929, 92); 1153 path.lineTo(810, 92); 1154 path.cubicTo(808.895447f, 92, 808, 91.1045685f, 808, 90); 1155 path.lineTo(808, 58); 1156 path.close(); 1157 SkPath pathB; 1158 pathB.setFillType(SkPath::kWinding_FillType); 1159 pathB.moveTo(806, 54); 1160 pathB.lineTo(808, 56); 1161 pathB.lineTo(935.02002f, 56.0200005f); 1162 pathB.lineTo(933, 54); 1163 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1164 } 1165 1166 // pair of curves have nearly the same initial tangent but are sorting by 1167 // that alone sorts them incorrectly. Need to detect that tangents are nearly 1168 // identical and not reliable by themselves 1169 static void skppptv_com_62(skiatest::Reporter* reporter, const char* filename) { 1170 SkPath path; 1171 path.setFillType(SkPath::kEvenOdd_FillType); 1172 path.moveTo(173, 5342); 1173 path.quadTo(171.343536f, 5342.00049f, 170.17157f, 5343.17139f); 1174 path.quadTo(169.000397f, 5344.34375f, 169, 5346); 1175 path.lineTo(169, 5372); 1176 path.lineTo(234, 5372); 1177 path.lineTo(234, 5346); 1178 path.quadTo(233.999603f, 5344.34375f, 232.82843f, 5343.17139f); 1179 path.quadTo(231.656464f, 5342.00049f, 230, 5342); 1180 path.lineTo(173, 5342); 1181 path.close(); 1182 SkPath pathB; 1183 pathB.setFillType(SkPath::kInverseWinding_FillType); 1184 pathB.moveTo(173, 5342); 1185 pathB.lineTo(230, 5342); 1186 pathB.cubicTo(231.65686f, 5342, 233, 5343.79102f, 233, 5346); 1187 pathB.lineTo(233, 5372); 1188 pathB.lineTo(169, 5372); 1189 pathB.lineTo(169, 5346); 1190 pathB.cubicTo(169, 5343.79102f, 170.790863f, 5342, 173, 5342); 1191 pathB.close(); 1192 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1193 } 1194 1195 // nearly identical to lavoixdunord -- to not-quite-coincident lines 1196 static void skpwww_booking_com_68(skiatest::Reporter* reporter, const char* filename) { 1197 SkPath path; 1198 path.setFillType(SkPath::kEvenOdd_FillType); 1199 path.moveTo(90, 187); 1200 path.cubicTo(90, 185.34314f, 91.3431473f, 184, 93, 184); 1201 path.lineTo(588, 184); 1202 path.cubicTo(589.65686f, 184, 591, 185.34314f, 591, 187); 1203 path.lineTo(591, 218); 1204 path.cubicTo(591, 219.65686f, 589.65686f, 221, 588, 221); 1205 path.lineTo(93, 221); 1206 path.cubicTo(91.3431473f, 221, 90, 219.65686f, 90, 218); 1207 path.lineTo(90, 187); 1208 path.close(); 1209 path.moveTo(92, 188); 1210 path.cubicTo(92, 186.895432f, 92.8954315f, 186, 94, 186); 1211 path.lineTo(587, 186); 1212 path.cubicTo(588.104553f, 186, 589, 186.895432f, 589, 188); 1213 path.lineTo(589, 217); 1214 path.cubicTo(589, 218.104568f, 588.104553f, 219, 587, 219); 1215 path.lineTo(94, 219); 1216 path.cubicTo(92.8954315f, 219, 92, 218.104568f, 92, 217); 1217 path.lineTo(92, 188); 1218 path.close(); 1219 SkPath pathB; 1220 pathB.setFillType(SkPath::kWinding_FillType); 1221 pathB.moveTo(90, 184); 1222 pathB.lineTo(92, 186); 1223 pathB.lineTo(593.02002f, 186.020004f); 1224 pathB.lineTo(591, 184); 1225 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1226 } 1227 1228 // visually looks like lavoixdunord and www_booking_com 1229 static void skpwww_despegar_com_mx_272(skiatest::Reporter* reporter, const char* filename) { 1230 SkPath path; 1231 path.setFillType(SkPath::kEvenOdd_FillType); 1232 path.moveTo(635, 1788); 1233 path.cubicTo(635, 1786.34314f, 636.34314f, 1785, 638, 1785); 1234 path.lineTo(832, 1785); 1235 path.cubicTo(833.65686f, 1785, 835, 1786.34314f, 835, 1788); 1236 path.lineTo(835, 1812); 1237 path.cubicTo(835, 1813.65686f, 833.65686f, 1815, 832, 1815); 1238 path.lineTo(638, 1815); 1239 path.cubicTo(636.34314f, 1815, 635, 1813.65686f, 635, 1812); 1240 path.lineTo(635, 1788); 1241 path.close(); 1242 path.moveTo(637, 1789); 1243 path.cubicTo(637, 1787.89539f, 637.895447f, 1787, 639, 1787); 1244 path.lineTo(831, 1787); 1245 path.cubicTo(832.104553f, 1787, 833, 1787.89539f, 833, 1789); 1246 path.lineTo(833, 1811); 1247 path.cubicTo(833, 1812.10461f, 832.104553f, 1813, 831, 1813); 1248 path.lineTo(639, 1813); 1249 path.cubicTo(637.895447f, 1813, 637, 1812.10461f, 637, 1811); 1250 path.lineTo(637, 1789); 1251 path.close(); 1252 SkPath pathB; 1253 pathB.setFillType(SkPath::kWinding_FillType); 1254 pathB.moveTo(835, 1785); 1255 pathB.lineTo(833, 1787); 1256 pathB.lineTo(832.97998f, 1817.02002f); 1257 pathB.lineTo(835, 1815); 1258 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1259 } 1260 1261 static void skpwww_joomla_org_23(skiatest::Reporter* reporter, const char* filename) { 1262 SkPath path; 1263 path.setFillType(SkPath::kEvenOdd_FillType); 1264 path.moveTo(320, 347); 1265 path.cubicTo(320, 344.238586f, 322.238586f, 342, 325, 342); 1266 path.lineTo(416, 342); 1267 path.cubicTo(418.761414f, 342, 421, 344.238586f, 421, 347); 1268 path.cubicTo(421, 344.790863f, 418.761414f, 343, 416, 343); 1269 path.lineTo(325, 343); 1270 path.cubicTo(322.238586f, 343, 320, 344.790863f, 320, 347); 1271 path.close(); 1272 path.moveTo(320, 378); 1273 path.cubicTo(320, 380.761414f, 322.238586f, 383, 325, 383); 1274 path.lineTo(416, 383); 1275 path.cubicTo(418.761414f, 383, 421, 380.761414f, 421, 378); 1276 path.cubicTo(421, 380.209137f, 418.761414f, 382, 416, 382); 1277 path.lineTo(325, 382); 1278 path.cubicTo(322.238586f, 382, 320, 380.209137f, 320, 378); 1279 path.close(); 1280 SkPath pathB; 1281 pathB.setFillType(SkPath::kWinding_FillType); 1282 pathB.moveTo(320, 383); 1283 pathB.lineTo(320, 378); 1284 pathB.lineTo(421, 378.000031f); 1285 pathB.lineTo(421, 383); 1286 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1287 } 1288 1289 static void skpwww_macrumors_com_131(skiatest::Reporter* reporter, const char* filename) { 1290 SkPath path; 1291 path.setFillType(SkPath::kEvenOdd_FillType); 1292 path.moveTo(136, 14089); 1293 path.lineTo(136, 14056); 1294 path.lineTo(778, 14056); 1295 path.lineTo(778, 14089); 1296 path.quadTo(777.999573f, 14090.6562f, 776.82843f, 14091.8281f); 1297 path.quadTo(775.656433f, 14093, 774, 14093); 1298 path.lineTo(140, 14093); 1299 path.quadTo(138.343552f, 14093, 137.17157f, 14091.8281f); 1300 path.quadTo(136.000397f, 14090.6562f, 136, 14089); 1301 path.close(); 1302 SkPath pathB; 1303 pathB.setFillType(SkPath::kInverseWinding_FillType); 1304 pathB.moveTo(136, 14057); 1305 pathB.lineTo(778, 14057); 1306 pathB.lineTo(778, 14089); 1307 pathB.cubicTo(778, 14091.209f, 776.209167f, 14093, 774, 14093); 1308 pathB.lineTo(140, 14093); 1309 pathB.cubicTo(137.790863f, 14093, 136, 14091.209f, 136, 14089); 1310 pathB.lineTo(136, 14057); 1311 pathB.close(); 1312 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1313 } 1314 1315 static void skpwww_leadpages_net_84(skiatest::Reporter* reporter, const char* filename) { 1316 SkPath path; 1317 path.setFillType(SkPath::kEvenOdd_FillType); 1318 path.moveTo(377.1716f, 5910.17139f); 1319 path.cubicTo(376.447723f, 5910.89551f, 376, 5911.89551f, 376, 5913); 1320 path.lineTo(376, 5972); 1321 path.cubicTo(376, 5974.20898f, 377.790863f, 5976, 380, 5976); 1322 path.cubicTo(378.34314f, 5976, 377, 5974.20898f, 377, 5972); 1323 path.lineTo(377, 5913); 1324 path.cubicTo(377, 5912.17139f, 377.335785f, 5911.42188f, 377.878693f, 5910.87891f); 1325 path.lineTo(377.1716f, 5910.17139f); 1326 path.close(); 1327 SkPath pathB; 1328 pathB.setFillType(SkPath::kWinding_FillType); 1329 pathB.moveTo(376, 5909); 1330 pathB.lineTo(378.481873f, 5909); 1331 pathB.lineTo(379.999878f, 5976); 1332 pathB.lineTo(376, 5976); 1333 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1334 } 1335 1336 static void skpwww_briian_com_34(skiatest::Reporter* reporter, const char* filename) { 1337 SkPath path; 1338 path.setFillType(SkPath::kEvenOdd_FillType); 1339 path.moveTo(843, 216); 1340 path.cubicTo(843, 213.238571f, 845.238586f, 211, 848, 211); 1341 path.lineTo(1191, 211); 1342 path.cubicTo(1193.76147f, 211, 1196, 213.238571f, 1196, 216); 1343 path.lineTo(1196, 779); 1344 path.cubicTo(1196, 781.761414f, 1193.76147f, 784, 1191, 784); 1345 path.lineTo(848, 784); 1346 path.cubicTo(845.238586f, 784, 843, 781.761414f, 843, 779); 1347 path.lineTo(843, 216); 1348 path.close(); 1349 path.moveTo(844, 217); 1350 path.cubicTo(844, 214.238571f, 846.238586f, 212, 849, 212); 1351 path.lineTo(1190, 212); 1352 path.cubicTo(1192.76147f, 212, 1195, 214.238571f, 1195, 217); 1353 path.lineTo(1195, 778); 1354 path.cubicTo(1195, 779.65686f, 1192.76147f, 781, 1190, 781); 1355 path.lineTo(849, 781); 1356 path.cubicTo(846.238586f, 781, 844, 779.65686f, 844, 778); 1357 path.lineTo(844, 217); 1358 path.close(); 1359 SkPath pathB; 1360 pathB.setFillType(SkPath::kWinding_FillType); 1361 pathB.moveTo(843, 784); 1362 pathB.lineTo(843, 779); 1363 pathB.lineTo(1196, 779.000061f); 1364 pathB.lineTo(1196, 784); 1365 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1366 } 1367 1368 static void skpwww_sciality_com_100(skiatest::Reporter* reporter, const char* filename) { 1369 SkPath path; 1370 path.setFillType(SkPath::kEvenOdd_FillType); 1371 path.moveTo(162, 468); 1372 path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472); 1373 path.lineTo(158, 528); 1374 path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532); 1375 path.lineTo(275, 532); 1376 path.cubicTo(277.209137f, 532, 279, 530.209106f, 279, 528); 1377 path.lineTo(279, 472); 1378 path.cubicTo(279, 469.790863f, 277.209137f, 468, 275, 468); 1379 path.lineTo(162, 468); 1380 path.close(); 1381 SkPath pathB; 1382 pathB.setFillType(SkPath::kWinding_FillType); 1383 pathB.moveTo(275, 468); 1384 pathB.cubicTo(276.65686f, 468, 278, 469.34314f, 278, 471); 1385 pathB.lineTo(278, 529); 1386 pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532); 1387 pathB.lineTo(161, 532); 1388 pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529); 1389 pathB.lineTo(158, 471); 1390 pathB.cubicTo(158, 469.34314f, 159.34314f, 468, 161, 468); 1391 pathB.lineTo(275, 468); 1392 pathB.close(); 1393 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1394 } 1395 1396 static void skpwww_sciality_com_101(skiatest::Reporter* reporter, const char* filename) { 1397 SkPath path; 1398 path.setFillType(SkPath::kEvenOdd_FillType); 1399 path.moveTo(162, 468); 1400 path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472); 1401 path.lineTo(158, 528); 1402 path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532); 1403 path.lineTo(275.009186f, 532); 1404 path.cubicTo(276.661774f, 531.994995f, 278, 530.653748f, 278, 529); 1405 path.lineTo(278, 471); 1406 path.cubicTo(278, 469.346375f, 276.662079f, 468.005249f, 275.009705f, 468); 1407 path.lineTo(162, 468); 1408 path.close(); 1409 SkPath pathB; 1410 pathB.setFillType(SkPath::kInverseWinding_FillType); 1411 pathB.moveTo(161, 469); 1412 pathB.lineTo(275, 469); 1413 pathB.cubicTo(276.65686f, 469, 278, 469.895416f, 278, 471); 1414 pathB.lineTo(278, 529); 1415 pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532); 1416 pathB.lineTo(161, 532); 1417 pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529); 1418 pathB.lineTo(158, 471); 1419 pathB.cubicTo(158, 469.895416f, 159.34314f, 469, 161, 469); 1420 pathB.close(); 1421 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1422 } 1423 1424 static void skpwww_meb_gov_tr_5(skiatest::Reporter* reporter, const char* filename) { 1425 SkPath path; 1426 path.setFillType(SkPath::kEvenOdd_FillType); 1427 path.moveTo(137.34314f, 145.34314f); 1428 path.quadTo(139.687088f, 143.000793f, 143, 143); 1429 path.lineTo(242, 143); 1430 path.quadTo(245.312912f, 143.000793f, 247.65686f, 145.34314f); 1431 path.quadTo(249.999207f, 147.687088f, 250, 151); 1432 path.lineTo(250, 177); 1433 path.lineTo(135, 177); 1434 path.lineTo(135, 151); 1435 path.quadTo(135.000793f, 147.687088f, 137.34314f, 145.34314f); 1436 path.close(); 1437 SkPath pathB; 1438 pathB.setFillType(SkPath::kWinding_FillType); 1439 pathB.moveTo(135, 143); 1440 pathB.lineTo(250, 143); 1441 pathB.lineTo(250, 177); 1442 pathB.lineTo(135, 177); 1443 pathB.close(); 1444 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1445 } 1446 1447 static void skpwww_meb_gov_tr_6(skiatest::Reporter* reporter, const char* filename) { 1448 SkPath path; 1449 path.setFillType(SkPath::kEvenOdd_FillType); 1450 path.moveTo(143, 143); 1451 path.quadTo(139.687088f, 143.000793f, 137.34314f, 145.34314f); 1452 path.quadTo(135.000793f, 147.687088f, 135, 151); 1453 path.lineTo(135, 177); 1454 path.lineTo(250, 177); 1455 path.lineTo(250, 151); 1456 path.quadTo(249.999207f, 147.687088f, 247.65686f, 145.34314f); 1457 path.quadTo(245.312912f, 143.000793f, 242, 143); 1458 path.lineTo(143, 143); 1459 path.close(); 1460 SkPath pathB; 1461 pathB.setFillType(SkPath::kInverseWinding_FillType); 1462 pathB.moveTo(143, 143); 1463 pathB.lineTo(242, 143); 1464 pathB.cubicTo(245.865997f, 143, 249, 146.581726f, 249, 151); 1465 pathB.lineTo(249, 177); 1466 pathB.lineTo(135, 177); 1467 pathB.lineTo(135, 151); 1468 pathB.cubicTo(135, 146.581726f, 138.581726f, 143, 143, 143); 1469 pathB.close(); 1470 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1471 } 1472 1473 static void skpgithub_io_25(skiatest::Reporter* reporter, const char* filename) { 1474 SkPath path; 1475 path.setFillType(SkPath::kEvenOdd_FillType); 1476 path.moveTo(1001.87866f, 14.8786793f); 1477 path.quadTo(1002.75745f, 14.0001001f, 1004, 14); 1478 path.lineTo(1105, 14); 1479 path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f); 1480 path.quadTo(1107.99988f, 15.7574596f, 1108, 17); 1481 path.lineTo(1108, 41); 1482 path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f); 1483 path.quadTo(1106.24255f, 43.9999008f, 1105, 44); 1484 path.lineTo(1004, 44); 1485 path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f); 1486 path.quadTo(1001.00012f, 42.2425423f, 1001, 41); 1487 path.lineTo(1001, 17); 1488 path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f); 1489 path.close(); 1490 SkPath pathB; 1491 pathB.setFillType(SkPath::kInverseWinding_FillType); 1492 pathB.moveTo(1005, 16); 1493 pathB.lineTo(1104, 16); 1494 pathB.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18); 1495 pathB.lineTo(1106, 40); 1496 pathB.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42); 1497 pathB.lineTo(1005, 42); 1498 pathB.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40); 1499 pathB.lineTo(1003, 18); 1500 pathB.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16); 1501 pathB.close(); 1502 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1503 } 1504 1505 static void skpgithub_io_26(skiatest::Reporter* reporter, const char* filename) { 1506 SkPath path; 1507 path.setFillType(SkPath::kEvenOdd_FillType); 1508 path.moveTo(1001.87866f, 14.8786793f); 1509 path.quadTo(1002.75745f, 14.0001001f, 1004, 14); 1510 path.lineTo(1105, 14); 1511 path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f); 1512 path.quadTo(1107.99988f, 15.7574596f, 1108, 17); 1513 path.lineTo(1108, 41); 1514 path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f); 1515 path.quadTo(1106.24255f, 43.9999008f, 1105, 44); 1516 path.lineTo(1004, 44); 1517 path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f); 1518 path.quadTo(1001.00012f, 42.2425423f, 1001, 41); 1519 path.lineTo(1001, 17); 1520 path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f); 1521 path.close(); 1522 path.moveTo(1003, 18); 1523 path.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16); 1524 path.lineTo(1104, 16); 1525 path.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18); 1526 path.lineTo(1106, 40); 1527 path.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42); 1528 path.lineTo(1005, 42); 1529 path.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40); 1530 path.lineTo(1003, 18); 1531 path.close(); 1532 SkPath pathB; 1533 pathB.setFillType(SkPath::kWinding_FillType); 1534 pathB.moveTo(1108, 14); 1535 pathB.lineTo(1106, 16); 1536 pathB.lineTo(1105.97998f, 46.0200005f); 1537 pathB.lineTo(1108, 44); 1538 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1539 } 1540 1541 static void skpskpicture14(skiatest::Reporter* reporter, const char* filename) { 1542 SkPath path; 1543 path.setFillType(SkPath::kEvenOdd_FillType); 1544 path.moveTo(0, 994); 1545 path.lineTo(0, 0); 1546 path.lineTo(512, 0); 1547 path.lineTo(512, 994); 1548 path.lineTo(0, 994); 1549 path.close(); 1550 SkPath pathB; 1551 pathB.setFillType(SkPath::kWinding_FillType); 1552 pathB.moveTo(-317, 168); 1553 pathB.quadTo(-317, 166.757385f, -316.121338f, 165.878662f); 1554 pathB.quadTo(-315.242645f, 165, -314, 165); 1555 pathB.lineTo(320, 165); 1556 pathB.quadTo(321.242615f, 165, 322.121338f, 165.878662f); 1557 pathB.quadTo(323, 166.757385f, 323, 168); 1558 pathB.lineTo(323, 193); 1559 pathB.lineTo(-317, 193); 1560 pathB.close(); 1561 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1562 } 1563 1564 static void skpskpicture15(skiatest::Reporter* reporter, const char* filename) { 1565 SkPath path; 1566 path.setFillType(SkPath::kEvenOdd_FillType); 1567 path.moveTo(0, 193); 1568 path.lineTo(323, 193); 1569 path.lineTo(323, 168); 1570 path.quadTo(323, 166.757385f, 322.121338f, 165.878662f); 1571 path.quadTo(321.242615f, 165, 320, 165); 1572 path.lineTo(0, 165); 1573 path.lineTo(0, 193); 1574 path.close(); 1575 SkPath pathB; 1576 pathB.setFillType(SkPath::kInverseWinding_FillType); 1577 pathB.moveTo(-314, 165); 1578 pathB.lineTo(320, 165); 1579 pathB.cubicTo(321.65686f, 165, 323, 166.34314f, 323, 168); 1580 pathB.lineTo(323, 192); 1581 pathB.lineTo(-317, 192); 1582 pathB.lineTo(-317, 168); 1583 pathB.cubicTo(-317, 166.34314f, -315.65686f, 165, -314, 165); 1584 pathB.close(); 1585 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1586 } 1587 1588 /* Three edges are partially coincident. Only one of the three knows about the other two. 1589 Subsequently, when the angle loop is created, it misses one of the edges. 1590 After coincident edges are processed, probably need a check-and-correct that makes sure the 1591 coincidences are all self-consistent. 1592 */ 1593 static void skpelpais_com_18(skiatest::Reporter* reporter, const char* filename) { 1594 SkPath path; 1595 path.setFillType(SkPath::kEvenOdd_FillType); 1596 path.moveTo(183, 8507); 1597 path.lineTo(552, 8506.99023f); 1598 path.lineTo(552, 8508); 1599 path.lineTo(183, 8508); 1600 path.lineTo(183, 8507); 1601 path.close(); 1602 SkPath pathB; 1603 pathB.setFillType(SkPath::kWinding_FillType); 1604 pathB.moveTo(183, 8508); 1605 pathB.lineTo(183, 8506.99023f); 1606 pathB.lineTo(552, 8507); 1607 pathB.lineTo(552, 8508); 1608 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1609 } 1610 1611 /* this generates a pair of lines that are essentially coincident; but the next line at a right 1612 angle is not treated as if it intersects at the same point. 1613 There are several of options: 1614 move the intersection of the right angle line to the coincident point (should 'near' do this? 1615 construct another coincident pair from the right angle line to the coincident point 1616 treat the intersection as simple and not coincident 1617 */ 1618 static void skpnamecheap_com_405(skiatest::Reporter* reporter, const char* filename) { 1619 SkPath path; 1620 path.setFillType(SkPath::kEvenOdd_FillType); 1621 path.moveTo(140, 1000); 1622 path.lineTo(140, 842); 1623 path.lineTo(141, 842); 1624 path.lineTo(141.14502f, 1000); 1625 path.lineTo(140, 1000); 1626 path.close(); 1627 SkPath pathB; 1628 pathB.setFillType(SkPath::kWinding_FillType); 1629 pathB.moveTo(140, 842); 1630 pathB.lineTo(141.008835f, 837.9646f); 1631 pathB.lineTo(141.235291f, 1109.05884f); 1632 pathB.lineTo(140, 1114); 1633 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1634 } 1635 1636 // fails on angle insert -- haven't investigated yet 1637 static void skpwww_alrakoba_net_62(skiatest::Reporter* reporter, const char* filename) { 1638 SkPath path; 1639 path.setFillType(SkPath::kEvenOdd_FillType); 1640 path.moveTo(134.34314f, 9802.34277f); 1641 path.quadTo(132, 9804.68652f, 132, 9808); 1642 path.lineTo(132, 9822); 1643 path.quadTo(132, 9825.31348f, 134.34314f, 9827.65723f); 1644 path.quadTo(136.686295f, 9830, 140, 9830); 1645 path.lineTo(140.028473f, 9830); 1646 path.lineTo(139.877213f, 9828.90723f); 1647 path.quadTo(137.692032f, 9828.5332f, 136.050247f, 9826.65723f); 1648 path.quadTo(134, 9824.31348f, 134, 9821); 1649 path.lineTo(134, 9809); 1650 path.quadTo(134, 9806.10059f, 136.050247f, 9804.0498f); 1651 path.lineTo(134.34314f, 9802.34277f); 1652 path.close(); 1653 SkPath pathB; 1654 pathB.setFillType(SkPath::kWinding_FillType); 1655 pathB.moveTo(132, 9800); 1656 pathB.lineTo(135.962357f, 9800); 1657 pathB.lineTo(140, 9830); 1658 pathB.lineTo(132, 9830); 1659 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1660 } 1661 1662 /* asserts in alignSpanState looks like a coincident related bug */ 1663 static void skpwww_cityads_ru_249(skiatest::Reporter* reporter, const char* filename) { 1664 SkPath path; 1665 path.setFillType(SkPath::kEvenOdd_FillType); 1666 path.moveTo(817.464478f, 11.4644661f); 1667 path.quadTo(818.928955f, 10, 821, 10); 1668 path.lineTo(998, 10); 1669 path.quadTo(999.082947f, 10, 1000, 10.4003992f); 1670 path.lineTo(1000, 13.3527431f); 1671 path.quadTo(999.917603f, 13.2607508f, 999.82843f, 13.1715727f); 1672 path.quadTo(998.65686f, 12, 997, 12); 1673 path.lineTo(822, 12); 1674 path.quadTo(820.34314f, 12, 819.17157f, 13.1715727f); 1675 path.quadTo(818, 14.3431454f, 818, 16); 1676 path.lineTo(818, 28); 1677 path.quadTo(818, 29.6568546f, 819.17157f, 30.8284264f); 1678 path.quadTo(820.34314f, 32, 822, 32); 1679 path.lineTo(997, 32); 1680 path.quadTo(998.65686f, 32, 999.82843f, 30.8284264f); 1681 path.quadTo(999.917603f, 30.7392426f, 1000, 30.6472569f); 1682 path.lineTo(1000, 33.5996017f); 1683 path.quadTo(999.082947f, 34, 998, 34); 1684 path.lineTo(821, 34); 1685 path.quadTo(818.928955f, 34, 817.464478f, 32.5355339f); 1686 path.quadTo(816, 31.0710678f, 816, 29); 1687 path.lineTo(816, 15); 1688 path.quadTo(816, 12.9289322f, 817.464478f, 11.4644661f); 1689 path.close(); 1690 SkPath pathB; 1691 pathB.setFillType(SkPath::kWinding_FillType); 1692 pathB.moveTo(1003, 10); 1693 pathB.lineTo(1000, 13); 1694 pathB.lineTo(999.969971f, 37.0299988f); 1695 pathB.lineTo(1003, 34); 1696 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1697 } 1698 1699 // fails on angle insert 1700 static void skpwww_dealnews_com_315(skiatest::Reporter* reporter, const char* filename) { 1701 SkPath path; 1702 path.setFillType(SkPath::kEvenOdd_FillType); 1703 path.moveTo(966.464478f, 4261.46436f); 1704 path.quadTo(965, 4262.92871f, 965, 4265); 1705 path.lineTo(965, 4276); 1706 path.quadTo(965, 4278.07129f, 966.464478f, 4279.53564f); 1707 path.quadTo(967.928955f, 4281, 970, 4281); 1708 path.lineTo(970.020325f, 4281); 1709 path.lineTo(969.887512f, 4279.81641f); 1710 path.quadTo(968.928284f, 4279.48145f, 968.17157f, 4278.53564f); 1711 path.quadTo(967, 4277.07129f, 967, 4275); 1712 path.lineTo(967, 4266); 1713 path.quadTo(967, 4264.44287f, 968.035217f, 4263.31396f); 1714 path.lineTo(968, 4263); 1715 path.lineTo(966.464478f, 4261.46436f); 1716 path.close(); 1717 SkPath pathB; 1718 pathB.setFillType(SkPath::kWinding_FillType); 1719 pathB.moveTo(965, 4260); 1720 pathB.lineTo(967.716675f, 4260); 1721 pathB.lineTo(970, 4281); 1722 pathB.lineTo(965, 4281); 1723 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1724 } 1725 1726 // fails in intersections insert 1727 static void skpwww_inmotionhosting_com_9(skiatest::Reporter* reporter, const char* filename) { 1728 SkPath path; 1729 path.setFillType(SkPath::kEvenOdd_FillType); 1730 path.moveTo(991.633911f, 1839); 1731 path.lineTo(964.265015f, 1839); 1732 path.lineTo(963.734985f, 1893.73242f); 1733 path.lineTo(991.3703f, 1894); 1734 path.lineTo(1018.23492f, 1894); 1735 path.lineTo(1018.76501f, 1839.2627f); 1736 path.lineTo(991.638184f, 1839); 1737 path.lineTo(991.633911f, 1839); 1738 path.close(); 1739 SkPath pathB; 1740 pathB.setFillType(SkPath::kWinding_FillType); 1741 pathB.moveTo(964.267578f, 1838.73499f); 1742 pathB.lineTo(1019.26501f, 1839.26758f); 1743 pathB.lineTo(1018.73242f, 1894.26501f); 1744 pathB.lineTo(963.734985f, 1893.73242f); 1745 pathB.close(); 1746 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1747 } 1748 1749 static void skpwww_alucinados_net_101(skiatest::Reporter* reporter, const char* filename) { 1750 SkPath path; 1751 path.setFillType(SkPath::kEvenOdd_FillType); 1752 path.moveTo(1129.53552f, 1164.46448f); 1753 path.lineTo(1128, 1166); 1754 path.lineTo(1128.12231f, 1166.49548f); 1755 path.quadTo(1129, 1167.56592f, 1129, 1169); 1756 path.lineTo(1129, 1170.05054f); 1757 path.lineTo(1130.34509f, 1175.49878f); 1758 path.quadTo(1131, 1174.38513f, 1131, 1173); 1759 path.lineTo(1131, 1168); 1760 path.quadTo(1131, 1165.92896f, 1129.53552f, 1164.46448f); 1761 path.close(); 1762 SkPath pathB; 1763 pathB.setFillType(SkPath::kWinding_FillType); 1764 pathB.moveTo(1131, 1163); 1765 pathB.lineTo(-43515.8555f, -177415.594f); 1766 pathB.lineTo(1129.76465f, 1173.05884f); 1767 pathB.lineTo(1131, 1178); 1768 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1769 } 1770 1771 // /SkOpContour.cpp:278: failed assertion "!approximately_negative(oEndT - oStartT) 1772 static void skpwww_hairjobsearch_com_31(skiatest::Reporter* reporter, const char* filename) { 1773 SkPath path; 1774 path.setFillType(SkPath::kEvenOdd_FillType); 1775 path.moveTo(143.292892f, 0.707106769f); 1776 path.quadTo(143, 0.414213538f, 143, 0); 1777 path.lineTo(1123, 0); 1778 path.quadTo(1123, 0.414213538f, 1122.70715f, 0.707106769f); 1779 path.quadTo(1122.41418f, 1, 1122, 1); 1780 path.lineTo(144, 1); 1781 path.quadTo(143.585785f, 1, 143.292892f, 0.707106769f); 1782 path.close(); 1783 SkPath pathB; 1784 pathB.setFillType(SkPath::kWinding_FillType); 1785 pathB.moveTo(143, 1); 1786 pathB.lineTo(144, 0); 1787 pathB.lineTo(1122, 0); 1788 pathB.lineTo(1123, 1); 1789 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1790 } 1791 1792 // SkOpSegment::checkSmallCoincidence; line 1958 SkASSERT(span.fWindValue); 1793 static void skpwww_heartiste_wordpress_com_86(skiatest::Reporter* reporter, const char* filename) { 1794 SkPath path; 1795 path.setFillType(SkPath::kEvenOdd_FillType); 1796 path.moveTo(741, 9432); 1797 path.lineTo(761, 9431.99023f); 1798 path.lineTo(761, 9433); 1799 path.lineTo(741, 9433); 1800 path.lineTo(741, 9432); 1801 path.close(); 1802 SkPath pathB; 1803 pathB.setFillType(SkPath::kWinding_FillType); 1804 pathB.moveTo(741, 9433); 1805 pathB.lineTo(741, 9431.99023f); 1806 pathB.lineTo(761, 9432); 1807 pathB.lineTo(761, 9433); 1808 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1809 } 1810 1811 static void skpwww_argus_presse_fr_41(skiatest::Reporter* reporter, const char* filename) { 1812 SkPath path; 1813 path.setFillType(SkPath::kEvenOdd_FillType); 1814 path.moveTo(1000, 343); 1815 path.lineTo(165, 343); 1816 path.lineTo(165, 364.869873f); 1817 path.lineTo(1000, 364.869873f); 1818 path.lineTo(1000, 343); 1819 path.close(); 1820 SkPath pathB; 1821 pathB.setFillType(SkPath::kWinding_FillType); 1822 pathB.moveTo(165, 343.000031f); 1823 pathB.lineTo(1000, 343.000031f); 1824 pathB.lineTo(1000, 364.869904f); 1825 pathB.lineTo(165, 364.869904f); 1826 pathB.close(); 1827 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1828 } 1829 1830 // SkOpSegment::checkSmallCoincidence; line 1958 SkASSERT(span.fWindValue); 1831 static void skpwww_320kbps_net_2231(skiatest::Reporter* reporter, const char* filename) { 1832 SkPath path; 1833 path.setFillType(SkPath::kEvenOdd_FillType); 1834 path.moveTo(838, 9125); 1835 path.lineTo(862, 9124.99023f); 1836 path.lineTo(862, 9126); 1837 path.lineTo(838, 9126); 1838 path.lineTo(838, 9125); 1839 path.close(); 1840 SkPath pathB; 1841 pathB.setFillType(SkPath::kWinding_FillType); 1842 pathB.moveTo(838, 9126); 1843 pathB.lineTo(838, 9124.99023f); 1844 pathB.lineTo(862, 9125); 1845 pathB.lineTo(862, 9126); 1846 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1847 } 1848 1849 // debugValidateLoop loop sum fails 1850 static void skpwww_exystence_net_61(skiatest::Reporter* reporter, const char* filename) { 1851 SkPath path; 1852 path.setFillType(SkPath::kEvenOdd_FillType); 1853 path.moveTo(143, 9075); 1854 path.lineTo(316, 9075); 1855 path.lineTo(316, 9073.99023f); 1856 path.lineTo(143, 9074); 1857 path.lineTo(143, 9075); 1858 path.close(); 1859 SkPath pathB; 1860 pathB.setFillType(SkPath::kWinding_FillType); 1861 pathB.moveTo(143, 9075); 1862 pathB.lineTo(143, 9073.99023f); 1863 pathB.lineTo(316, 9074); 1864 pathB.lineTo(316, 9075); 1865 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1866 } 1867 1868 // debugValidateLoop loop sum fails 1869 static void skpwww_trashness_com_36(skiatest::Reporter* reporter, const char* filename) { 1870 SkPath path; 1871 path.setFillType(SkPath::kEvenOdd_FillType); 1872 path.moveTo(541.5f, 4835.99512f); 1873 path.lineTo(91.5f, 4836); 1874 path.lineTo(91.5f, 4836.5f); 1875 path.lineTo(541.5f, 4836.5f); 1876 path.lineTo(541.5f, 4835.99512f); 1877 path.close(); 1878 SkPath pathB; 1879 pathB.setFillType(SkPath::kWinding_FillType); 1880 pathB.moveTo(91.5f, 4836.5f); 1881 pathB.lineTo(91.5f, 4835.99512f); 1882 pathB.lineTo(541.5f, 4836); 1883 pathB.lineTo(541.5f, 4836.5f); 1884 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1885 } 1886 1887 // SkIntersections::lineVertical fUsed >= fMax 1888 static void skpwww_getgold_jp_731(skiatest::Reporter* reporter, const char* filename) { 1889 SkPath path; 1890 path.setFillType(SkPath::kEvenOdd_FillType); 1891 path.moveTo(284.878693f, 10134.8789f); 1892 path.quadTo(284, 10135.7578f, 284, 10137); 1893 path.lineTo(284, 10216); 1894 path.quadTo(284, 10217.2422f, 284.878693f, 10218.1211f); 1895 path.quadTo(285.125122f, 10218.3672f, 285.40213f, 10218.5459f); 1896 path.lineTo(286, 10138); 1897 path.lineTo(286, 10136); 1898 path.lineTo(284.878693f, 10134.8789f); 1899 path.close(); 1900 SkPath pathB; 1901 pathB.setFillType(SkPath::kWinding_FillType); 1902 pathB.moveTo(284, 10134); 1903 pathB.lineTo(286.05957f, 10129.8809f); 1904 pathB.lineTo(285.399994f, 10216.2002f); 1905 pathB.lineTo(284, 10219); 1906 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1907 } 1908 1909 // SkOpContour::calcPartialCoincidentWinding SkASSERT(!approximately_negative(endT - startT)); 1910 static void skpwww_maturesupertube_com_21(skiatest::Reporter* reporter, const char* filename) { 1911 SkPath path; 1912 path.setFillType(SkPath::kEvenOdd_FillType); 1913 path.moveTo(3.17157292f, 11831.1719f); 1914 path.quadTo(4.34314585f, 11830, 6, 11830); 1915 path.lineTo(1259, 11830); 1916 path.quadTo(1260.65686f, 11830, 1261.82837f, 11831.1719f); 1917 path.quadTo(1263, 11832.3428f, 1263, 11834); 1918 path.lineTo(1263, 11848); 1919 path.quadTo(1263, 11849.6572f, 1261.82837f, 11850.8281f); 1920 path.quadTo(1260.65686f, 11852, 1259, 11852); 1921 path.lineTo(6, 11852); 1922 path.quadTo(4.34314585f, 11852, 3.17157292f, 11850.8281f); 1923 path.quadTo(2, 11849.6572f, 2, 11848); 1924 path.lineTo(2, 11834); 1925 path.quadTo(2, 11832.3428f, 3.17157292f, 11831.1719f); 1926 path.close(); 1927 path.moveTo(3.87867975f, 11831.8789f); 1928 path.quadTo(4.7573595f, 11831, 6, 11831); 1929 path.lineTo(1259, 11831); 1930 path.quadTo(1260.24268f, 11831, 1261.12134f, 11831.8789f); 1931 path.quadTo(1262, 11832.7578f, 1262, 11834); 1932 path.lineTo(1262, 11848); 1933 path.quadTo(1262, 11849.2422f, 1261.12134f, 11850.1211f); 1934 path.quadTo(1260.24268f, 11851, 1259, 11851); 1935 path.lineTo(6, 11851); 1936 path.quadTo(4.7573595f, 11851, 3.87867975f, 11850.1211f); 1937 path.quadTo(3, 11849.2422f, 3, 11848); 1938 path.lineTo(3, 11834); 1939 path.quadTo(3, 11832.7578f, 3.87867975f, 11831.8789f); 1940 path.close(); 1941 SkPath pathB; 1942 pathB.setFillType(SkPath::kWinding_FillType); 1943 pathB.moveTo(2, 11830); 1944 pathB.lineTo(4.5f, 11832.5f); 1945 pathB.lineTo(1260.5f, 11832.5f); 1946 pathB.lineTo(1263, 11830); 1947 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1948 } 1949 1950 // can't find winding of remaining vertical edges 1951 static void skpwww_hubbyscook_com_22(skiatest::Reporter* reporter, const char* filename) { 1952 SkPath path; 1953 path.setFillType(SkPath::kEvenOdd_FillType); 1954 path.moveTo(1000, 902.329346f); 1955 path.quadTo(998, 905.250427f, 998, 909); 1956 path.lineTo(998, 910); 1957 path.quadTo(998, 913.749573f, 1000, 916.670654f); 1958 path.lineTo(1000, 902.329346f); 1959 path.close(); 1960 SkPath pathB; 1961 pathB.setFillType(SkPath::kWinding_FillType); 1962 pathB.moveTo(998, 910); 1963 pathB.lineTo(998, 909); 1964 pathB.quadTo(998, 904.029419f, 1001.51471f, 900.514709f); 1965 pathB.quadTo(1005.02942f, 897, 1010, 897); 1966 pathB.lineTo(1011, 897); 1967 pathB.quadTo(1015.14215f, 897, 1018.07104f, 900.514709f); 1968 pathB.quadTo(1021, 904.029419f, 1021, 909); 1969 pathB.lineTo(1021, 910); 1970 pathB.quadTo(1021, 914.142151f, 1018.07104f, 917.071045f); 1971 pathB.quadTo(1015.14215f, 920, 1011, 920); 1972 pathB.lineTo(1010, 920); 1973 pathB.quadTo(1005.02942f, 920, 1001.51471f, 917.071045f); 1974 pathB.quadTo(998, 914.142151f, 998, 910); 1975 pathB.close(); 1976 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 1977 } 1978 1979 static void skpwww_gruposejaumdivulgador_com_br_4(skiatest::Reporter* reporter, const char* filename) { 1980 SkPath path; 1981 path.setFillType(SkPath::kEvenOdd_FillType); 1982 path.moveTo(610.5f, 5.78626502e-14f); 1983 path.lineTo(1083.5f, -6.12303177e-17f); 1984 path.lineTo(1083.5f, 469); 1985 path.lineTo(610.5f, 469); 1986 path.lineTo(610.5f, 5.78626502e-14f); 1987 path.close(); 1988 SkPath pathB; 1989 pathB.setFillType(SkPath::kWinding_FillType); 1990 pathB.moveTo(611, 0); 1991 pathB.lineTo(1084, 0); 1992 pathB.lineTo(1084, 469); 1993 pathB.lineTo(611, 469); 1994 pathB.close(); 1995 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 1996 } 1997 1998 // asserts in bridgeOp simple->isClosed() 1999 static void skpwww_phototransferapp_com_24(skiatest::Reporter* reporter, const char* filename) { 2000 SkPath path; 2001 path.setFillType(SkPath::kEvenOdd_FillType); 2002 path.moveTo(85.6091843f, 5.92893219f); 2003 path.quadTo(89.6041641f, 3, 93.7462997f, 3); 2004 path.lineTo(1212.74634f, 3); 2005 path.quadTo(1216.88843f, 3, 1218.75134f, 5.92893219f); 2006 path.quadTo(1220.61414f, 8.85775471f, 1219.10669f, 12.9996767f); 2007 path.quadTo(1220.46338f, 9.27196693f, 1218.4939f, 6.63603878f); 2008 path.quadTo(1216.52441f, 4, 1212.38232f, 4); 2009 path.lineTo(93.3823318f, 4); 2010 path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f); 2011 path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13); 2012 path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f); 2013 path.close(); 2014 SkPath pathB; 2015 pathB.setFillType(SkPath::kWinding_FillType); 2016 pathB.moveTo(83.7462997f, 3); 2017 pathB.lineTo(1222.74634f, 3); 2018 pathB.lineTo(1219.10657f, 13); 2019 pathB.lineTo(80.1065979f, 13); 2020 pathB.close(); 2021 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2022 } 2023 2024 static void skpwww_phototransferapp_com_24x(skiatest::Reporter* reporter, const char* filename) { 2025 SkPath path; 2026 path.setFillType(SkPath::kEvenOdd_FillType); 2027 path.moveTo(85.6091843f, 5.92893219f); 2028 path.quadTo(89.6041641f, 3, 93.7462997f, 3); 2029 path.lineTo(112.74634f, 3); 2030 path.quadTo(116.88843f, 3, 118.75134f, 5.92893219f); 2031 path.quadTo(120.61414f, 8.85775471f, 119.10669f, 12.9996767f); 2032 path.quadTo(120.46338f, 9.27196693f, 118.4939f, 6.63603878f); 2033 path.quadTo(116.52441f, 4, 112.38232f, 4); 2034 path.lineTo(93.3823318f, 4); 2035 path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f); 2036 path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13); 2037 path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f); 2038 path.close(); 2039 SkPath pathB; 2040 pathB.setFillType(SkPath::kWinding_FillType); 2041 pathB.moveTo(83.7462997f, 3); 2042 pathB.lineTo(122.74634f, 3); 2043 pathB.lineTo(119.10657f, 13); 2044 pathB.lineTo(80.1065979f, 13); 2045 pathB.close(); 2046 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2047 } 2048 2049 static void skpwww_helha_be_109(skiatest::Reporter* reporter, const char* filename) { 2050 SkPath path; 2051 path.setFillType(SkPath::kEvenOdd_FillType); 2052 path.moveTo(117.686981f, 3339.08423f); 2053 path.lineTo(109.533035f, 3350.72925f); 2054 path.quadTo(107.120552f, 3354.17456f, 103.879379f, 3354.41821f); 2055 path.quadTo(100.638504f, 3354.66187f, 98.4674301f, 3351.56177f); 2056 path.quadTo(100.87973f, 3355.00635f, 104.291222f, 3355.00635f); 2057 path.quadTo(107.70298f, 3355.00635f, 110.115463f, 3351.56104f); 2058 path.lineTo(118, 3340.30078f); 2059 path.lineTo(118, 3339.53125f); 2060 path.lineTo(117.686981f, 3339.08423f); 2061 path.close(); 2062 SkPath pathB; 2063 pathB.setFillType(SkPath::kWinding_FillType); 2064 pathB.moveTo(118.269409f, 3339.91602f); 2065 pathB.lineTo(117.686981f, 3339.08423f); 2066 pathB.lineTo(98.4669647f, 3351.56104f); 2067 pathB.lineTo(104.291214f, 3359.87891f); 2068 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2069 } 2070 2071 static void skpwww_cooksnaps_com_32(skiatest::Reporter* reporter, const char* filename) { 2072 SkPath path; 2073 path.setFillType(SkPath::kEvenOdd_FillType); 2074 path.moveTo(509.34021f, 176); 2075 path.lineTo(505, 176); 2076 path.quadTo(500.964233f, 176, 497.299988f, 176.896912f); 2077 path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f); 2078 path.lineTo(489.316986f, 180.4702f); 2079 path.quadTo(485.175385f, 182.861359f, 482.115265f, 186.082397f); 2080 path.quadTo(479.69455f, 188.700821f, 477.995941f, 191.618286f); 2081 path.quadTo(476.316772f, 194.550476f, 475.258759f, 197.959335f); 2082 path.quadTo(474, 202.218979f, 474, 207); 2083 path.lineTo(474, 208); 2084 path.quadTo(474, 212.03569f, 474.896851f, 215.699799f); 2085 path.quadTo(475.950256f, 219.315002f, 477.962708f, 222.803986f); 2086 path.lineTo(477.970215f, 222.816986f); 2087 path.lineTo(478.470215f, 223.683014f); 2088 path.quadTo(478.474915f, 223.691162f, 478.479645f, 223.69931f); 2089 path.quadTo(480.867981f, 227.831055f, 484.082947f, 230.885254f); 2090 path.quadTo(486.701447f, 233.305939f, 489.61908f, 235.004517f); 2091 path.quadTo(492.550232f, 236.682983f, 495.957611f, 237.740738f); 2092 path.quadTo(500.217987f, 239, 505, 239); 2093 path.lineTo(509.482178f, 239); 2094 path.quadTo(515.299133f, 238.212051f, 520.801941f, 235.038513f); 2095 path.quadTo(520.809509f, 235.034164f, 520.817017f, 235.0298f); 2096 path.lineTo(521.683044f, 234.5298f); 2097 path.quadTo(521.692078f, 234.524582f, 521.701111f, 234.519348f); 2098 path.quadTo(532.80603f, 228.09938f, 536.126709f, 215.70639f); 2099 path.quadTo(539.450134f, 203.303314f, 533.029785f, 192.183014f); 2100 path.lineTo(532.529785f, 191.316986f); 2101 path.quadTo(526.109497f, 180.196686f, 513.706421f, 176.873276f); 2102 path.quadTo(511.503082f, 176.282898f, 509.34021f, 176); 2103 path.close(); 2104 SkPath pathB; 2105 pathB.setFillType(SkPath::kWinding_FillType); 2106 pathB.moveTo(478.470215f, 223.683014f); 2107 pathB.lineTo(477.970215f, 222.816986f); 2108 pathB.quadTo(471.549896f, 211.696686f, 474.873322f, 199.293594f); 2109 pathB.quadTo(478.196686f, 186.890503f, 489.316986f, 180.4702f); 2110 pathB.lineTo(490.183014f, 179.9702f); 2111 pathB.quadTo(501.303345f, 173.549896f, 513.706421f, 176.873276f); 2112 pathB.quadTo(526.109497f, 180.196686f, 532.529785f, 191.316986f); 2113 pathB.lineTo(533.029785f, 192.183014f); 2114 pathB.quadTo(539.450134f, 203.303314f, 536.126709f, 215.70639f); 2115 pathB.quadTo(532.803345f, 228.109497f, 521.683044f, 234.5298f); 2116 pathB.lineTo(520.817017f, 235.0298f); 2117 pathB.quadTo(509.696686f, 241.450104f, 497.29361f, 238.126709f); 2118 pathB.quadTo(484.890533f, 234.803314f, 478.470215f, 223.683014f); 2119 pathB.close(); 2120 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2121 } 2122 2123 static void skpwww_cooksnaps_com_32a(skiatest::Reporter* reporter, const char* filename) { 2124 SkPath path; 2125 path.setFillType(SkPath::kEvenOdd_FillType); 2126 path.moveTo(497.299988f, 176.896912f); 2127 path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f); 2128 path.lineTo(489.316986f, 180.4702f); 2129 path.quadTo(485.175385f, 182.861359f, 482.115265f, 186.082397f); 2130 SkPath pathB; 2131 pathB.setFillType(SkPath::kWinding_FillType); 2132 pathB.moveTo(474.873322f, 199.293594f); 2133 pathB.quadTo(478.196686f, 186.890503f, 489.316986f, 180.4702f); 2134 pathB.lineTo(490.183014f, 179.9702f); 2135 pathB.quadTo(501.303345f, 173.549896f, 513.706421f, 176.873276f); 2136 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2137 } 2138 2139 // !simple->isClosed() 2140 static void skpwww_contextualnewsfeeds_com_346(skiatest::Reporter* reporter, const char* filename) { 2141 SkPath path; 2142 path.setFillType(SkPath::kEvenOdd_FillType); 2143 path.moveTo(460.257355f, 1202.27808f); 2144 path.lineTo(460.257355f, 1204.27808f); 2145 path.quadTo(461.081207f, 1204.27808f, 461.665161f, 1203.69873f); 2146 path.lineTo(461.67157f, 1203.69238f); 2147 path.lineTo(466.621307f, 1198.74268f); 2148 path.quadTo(466.623993f, 1198.73999f, 466.626648f, 1198.7373f); 2149 path.quadTo(466.914185f, 1198.44604f, 466.914185f, 1198.03552f); 2150 path.quadTo(466.914215f, 1197.62122f, 466.621307f, 1197.32837f); 2151 path.lineTo(465.914215f, 1196.62122f); 2152 path.lineTo(460.257355f, 1202.27808f); 2153 path.close(); 2154 SkPath pathB; 2155 pathB.setFillType(SkPath::kWinding_FillType); 2156 pathB.moveTo(460.257355f, 1205.10657f); 2157 pathB.lineTo(458.828979f, 1203.67822f); 2158 pathB.lineTo(465.914215f, 1196.62122f); 2159 pathB.lineTo(467.32843f, 1198.03552f); 2160 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2161 } 2162 2163 // line quad intersection SkIntersections::assert 2164 static void skpwww_pindosiya_com_99(skiatest::Reporter* reporter, const char* filename) { 2165 SkPath path; 2166 path.setFillType(SkPath::kEvenOdd_FillType); 2167 path.moveTo(899.17157f, 548.17157f); 2168 path.quadTo(898, 549.34314f, 898, 551); 2169 path.lineTo(898, 556); 2170 path.lineTo(899.027283f, 556); 2171 path.lineTo(900.02356f, 551.602844f); 2172 path.quadTo(900.06073f, 551.297058f, 900.156555f, 551.015747f); 2173 path.lineTo(900.5f, 549.5f); 2174 path.lineTo(899.17157f, 548.17157f); 2175 path.close(); 2176 SkPath pathB; 2177 pathB.setFillType(SkPath::kWinding_FillType); 2178 pathB.moveTo(898, 547); 2179 pathB.lineTo(901.086914f, 547); 2180 pathB.lineTo(899, 556); 2181 pathB.lineTo(898, 556); 2182 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2183 } 2184 2185 // SkOpAngle::setSector SkASSERT(fSectorStart >= 0); 2186 static void skpwww_karnivool_com_au_11(skiatest::Reporter* reporter, const char* filename) { 2187 SkPath path; 2188 path.setFillType(SkPath::kEvenOdd_FillType); 2189 path.moveTo(0, 1431); 2190 path.lineTo(0, 775); 2191 path.lineTo(1265, 775); 2192 path.lineTo(1265, 1431); 2193 path.lineTo(0, 1431); 2194 path.close(); 2195 SkPath pathB; 2196 pathB.setFillType(SkPath::kWinding_FillType); 2197 pathB.moveTo(32.3243904f, 851); 2198 pathB.lineTo(459.324402f, 851); 2199 pathB.lineTo(427, 1081); 2200 pathB.lineTo(-3.81469727e-06f, 1081); 2201 pathB.close(); 2202 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2203 } 2204 2205 static void skpwww_tunero_de_24(skiatest::Reporter* reporter, const char* filename) { 2206 SkPath path; 2207 path.setFillType(SkPath::kEvenOdd_FillType); 2208 path.moveTo(1020.79303f, 2252); 2209 path.quadTo(1018.72198f, 2252, 1016.86798f, 2253.46436f); 2210 path.quadTo(1015.02032f, 2254.92383f, 1014.4668f, 2256.98584f); 2211 path.lineTo(1014.46301f, 2257); 2212 path.lineTo(1011.53705f, 2268); 2213 path.quadTo(1010.98615f, 2270.07104f, 1012.06104f, 2271.53564f); 2214 path.quadTo(1013.13599f, 2273, 1015.20703f, 2273); 2215 path.lineTo(1083.20703f, 2273); 2216 path.quadTo(1085.27808f, 2273, 1087.13208f, 2271.53564f); 2217 path.quadTo(1088.97144f, 2270.08252f, 1089.52832f, 2268.03271f); 2218 path.lineTo(1089.53711f, 2268); 2219 path.lineTo(1092.46301f, 2257); 2220 path.lineTo(1092.4679f, 2256.98145f); 2221 path.quadTo(1093.00916f, 2254.92236f, 1091.93909f, 2253.46436f); 2222 path.quadTo(1090.86414f, 2252, 1088.79297f, 2252); 2223 path.lineTo(1020.79303f, 2252); 2224 path.close(); 2225 SkPath pathB; 2226 pathB.setFillType(SkPath::kWinding_FillType); 2227 pathB.moveTo(1011.53705f, 2268); 2228 pathB.lineTo(1014.46301f, 2257); 2229 pathB.quadTo(1015.01392f, 2254.92896f, 1016.86798f, 2253.46436f); 2230 pathB.quadTo(1018.72198f, 2252, 1020.79303f, 2252); 2231 pathB.lineTo(1088.79297f, 2252); 2232 pathB.quadTo(1090.86414f, 2252, 1091.93909f, 2253.46436f); 2233 pathB.quadTo(1093.01392f, 2254.92896f, 1092.46301f, 2257); 2234 pathB.lineTo(1089.53711f, 2268); 2235 pathB.quadTo(1088.98608f, 2270.07104f, 1087.13208f, 2271.53564f); 2236 pathB.quadTo(1085.27808f, 2273, 1083.20703f, 2273); 2237 pathB.lineTo(1015.20703f, 2273); 2238 pathB.quadTo(1013.13599f, 2273, 1012.06104f, 2271.53564f); 2239 pathB.quadTo(1010.98615f, 2270.07104f, 1011.53705f, 2268); 2240 pathB.close(); 2241 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2242 } 2243 2244 static void skpwww_docgelo_com_66(skiatest::Reporter* reporter, const char* filename) { 2245 SkPath path; 2246 path.setFillType(SkPath::kEvenOdd_FillType); 2247 path.moveTo(22.5f, 24174.5f); 2248 path.lineTo(185.5f, 24174.498f); 2249 path.lineTo(185.5f, 24174.75f); 2250 path.lineTo(22.5f, 24174.75f); 2251 path.lineTo(22.5f, 24174.5f); 2252 path.close(); 2253 SkPath pathB; 2254 pathB.setFillType(SkPath::kWinding_FillType); 2255 pathB.moveTo(22.5f, 24174.75f); 2256 pathB.lineTo(22.5f, 24174.498f); 2257 pathB.lineTo(185.5f, 24174.5f); 2258 pathB.lineTo(185.5f, 24174.75f); 2259 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2260 } 2261 2262 static void skpwww_kpopexplorer_net_22(skiatest::Reporter* reporter, const char* filename) { 2263 SkPath path; 2264 path.setFillType(SkPath::kEvenOdd_FillType); 2265 path.moveTo(1000, 866.329346f); 2266 path.quadTo(998, 869.250427f, 998, 873); 2267 path.lineTo(998, 874); 2268 path.quadTo(998, 877.749573f, 1000, 880.670654f); 2269 path.lineTo(1000, 866.329346f); 2270 path.close(); 2271 SkPath pathB; 2272 pathB.setFillType(SkPath::kWinding_FillType); 2273 pathB.moveTo(998, 874); 2274 pathB.lineTo(998, 873); 2275 pathB.quadTo(998, 868.029419f, 1001.51471f, 864.514709f); 2276 pathB.quadTo(1005.02942f, 861, 1010, 861); 2277 pathB.lineTo(1011, 861); 2278 pathB.quadTo(1015.14215f, 861, 1018.07104f, 864.514709f); 2279 pathB.quadTo(1021, 868.029419f, 1021, 873); 2280 pathB.lineTo(1021, 874); 2281 pathB.quadTo(1021, 878.142151f, 1018.07104f, 881.071045f); 2282 pathB.quadTo(1015.14215f, 884, 1011, 884); 2283 pathB.lineTo(1010, 884); 2284 pathB.quadTo(1005.02942f, 884, 1001.51471f, 881.071045f); 2285 pathB.quadTo(998, 878.142151f, 998, 874); 2286 pathB.close(); 2287 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2288 } 2289 2290 static void skpwww_artblart_com_8(skiatest::Reporter* reporter, const char* filename) { 2291 SkPath path; 2292 path.setFillType(SkPath::kEvenOdd_FillType); 2293 path.moveTo(22.5f, 24527.25f); 2294 path.lineTo(45, 24527.248f); 2295 path.lineTo(45, 24527.5f); 2296 path.lineTo(22.5f, 24527.5f); 2297 path.lineTo(22.5f, 24527.25f); 2298 path.close(); 2299 SkPath pathB; 2300 pathB.setFillType(SkPath::kWinding_FillType); 2301 pathB.moveTo(22.5f, 24527.5f); 2302 pathB.lineTo(22.5f, 24527.248f); 2303 pathB.lineTo(45, 24527.25f); 2304 pathB.lineTo(45, 24527.5f); 2305 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2306 } 2307 2308 // joinCoincidence / findT / assert 2309 static void skpwww_jessicaslens_wordpress_com_222(skiatest::Reporter* reporter, const char* filename) { 2310 SkPath path; 2311 path.setFillType(SkPath::kEvenOdd_FillType); 2312 path.moveTo(1000, 844.329346f); 2313 path.quadTo(998, 847.250427f, 998, 851); 2314 path.lineTo(998, 852); 2315 path.quadTo(998, 855.749573f, 1000, 858.670654f); 2316 path.lineTo(1000, 844.329346f); 2317 path.close(); 2318 SkPath pathB; 2319 pathB.setFillType(SkPath::kWinding_FillType); 2320 pathB.moveTo(998, 852); 2321 pathB.lineTo(998, 851); 2322 pathB.quadTo(998, 846.029419f, 1001.51471f, 842.514709f); 2323 pathB.quadTo(1005.02942f, 839, 1010, 839); 2324 pathB.lineTo(1011, 839); 2325 pathB.quadTo(1015.14215f, 839, 1018.07104f, 842.514709f); 2326 pathB.quadTo(1021, 846.029419f, 1021, 851); 2327 pathB.lineTo(1021, 852); 2328 pathB.quadTo(1021, 856.142151f, 1018.07104f, 859.071045f); 2329 pathB.quadTo(1015.14215f, 862, 1011, 862); 2330 pathB.lineTo(1010, 862); 2331 pathB.quadTo(1005.02942f, 862, 1001.51471f, 859.071045f); 2332 pathB.quadTo(998, 856.142151f, 998, 852); 2333 pathB.close(); 2334 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2335 } 2336 2337 // joinCoincidence / findT / assert 2338 static void skpwww_simplysaru_com_40(skiatest::Reporter* reporter, const char* filename) { 2339 SkPath path; 2340 path.setFillType(SkPath::kEvenOdd_FillType); 2341 path.moveTo(1000, 866.329346f); 2342 path.quadTo(998, 869.250427f, 998, 873); 2343 path.lineTo(998, 874); 2344 path.quadTo(998, 877.749573f, 1000, 880.670654f); 2345 path.lineTo(1000, 866.329346f); 2346 path.close(); 2347 SkPath pathB; 2348 pathB.setFillType(SkPath::kWinding_FillType); 2349 pathB.moveTo(998, 874); 2350 pathB.lineTo(998, 873); 2351 pathB.quadTo(998, 868.029419f, 1001.51471f, 864.514709f); 2352 pathB.quadTo(1005.02942f, 861, 1010, 861); 2353 pathB.lineTo(1011, 861); 2354 pathB.quadTo(1015.14215f, 861, 1018.07104f, 864.514709f); 2355 pathB.quadTo(1021, 868.029419f, 1021, 873); 2356 pathB.lineTo(1021, 874); 2357 pathB.quadTo(1021, 878.142151f, 1018.07104f, 881.071045f); 2358 pathB.quadTo(1015.14215f, 884, 1011, 884); 2359 pathB.lineTo(1010, 884); 2360 pathB.quadTo(1005.02942f, 884, 1001.51471f, 881.071045f); 2361 pathB.quadTo(998, 878.142151f, 998, 874); 2362 pathB.close(); 2363 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2364 } 2365 2366 // cubic-cubic intersection reduce checkLinear assert 2367 static void skpwww_partsdata_de_53(skiatest::Reporter* reporter, const char* filename) { 2368 SkPath path; 2369 path.setFillType(SkPath::kEvenOdd_FillType); 2370 path.moveTo(407, 119); 2371 path.lineTo(407, 28); 2372 path.lineTo(647, 28); 2373 path.lineTo(647, 119); 2374 path.lineTo(407, 119); 2375 path.close(); 2376 SkPath pathB; 2377 pathB.setFillType(SkPath::kWinding_FillType); 2378 pathB.moveTo(471.228394f, 64.443222f); 2379 pathB.cubicTo(471.193878f, 60.953373f, 470.234985f, 52.4797592f, 462.201569f, 46.6231461f); 2380 pathB.cubicTo(454.168152f, 40.7665405f, 446.592804f, 41.993145f, 443.033936f, 42.8568878f); 2381 pathB.cubicTo(439.475098f, 43.7206268f, 436.978638f, 45.4052658f, 436.304871f, 45.7851906f); 2382 pathB.cubicTo(435.631104f, 46.1651154f, 435.156006f, 45.8026352f, 434.957306f, 45.6384506f); 2383 pathB.cubicTo(434.758636f, 45.4742737f, 431.460999f, 42.0105858f, 430.916901f, 41.4664841f); 2384 pathB.cubicTo(430.372803f, 40.9223785f, 429.731628f, 41.3303604f, 429.375214f, 41.6996689f); 2385 pathB.cubicTo(429.375214f, 41.6996689f, 420.610016f, 50.5190887f, 419.918793f, 51.1754227f); 2386 pathB.cubicTo(419.22757f, 51.8321419f, 419.331482f, 52.2465706f, 419.884308f, 52.8339005f); 2387 pathB.cubicTo(420.437134f, 53.4212303f, 425.170624f, 58.0167313f, 425.619568f, 58.4660416f); 2388 pathB.cubicTo(426.068512f, 58.9153557f, 426.137878f, 59.2952805f, 426.137878f, 59.8136024f); 2389 pathB.cubicTo(426.137878f, 60.3319244f, 426.103394f, 103.141357f, 426.103394f, 103.970215f); 2390 pathB.cubicTo(426.103394f, 104.799835f, 426.310791f, 105.525177f, 427.17453f, 105.525177f); 2391 pathB.cubicTo(428.038269f, 105.525177f, 440.131409f, 105.491432f, 440.85675f, 105.491432f); 2392 pathB.cubicTo(441.582489f, 105.491432f, 441.996918f, 104.903343f, 441.996918f, 104.17762f); 2393 pathB.cubicTo(441.996918f, 103.452271f, 441.996918f, 89.5622559f, 441.996918f, 87.8002701f); 2394 pathB.cubicTo(441.996918f, 86.0382843f, 442.342712f, 86.2453079f, 442.826141f, 86.3491974f); 2395 pathB.cubicTo(443.309601f, 86.4530945f, 445.832184f, 87.040802f, 448.700195f, 87.040802f); 2396 pathB.cubicTo(466.87442f, 86.6949997f, 471.815338f, 69.4876556f, 471.228394f, 64.443222f); 2397 pathB.close(); 2398 pathB.moveTo(448.873108f, 72.4595642f); 2399 pathB.cubicTo(444.636658f, 72.4595642f, 441.202545f, 69.0254517f, 441.202545f, 64.7890244f); 2400 pathB.cubicTo(441.202545f, 60.5525932f, 444.636658f, 57.1184845f, 448.873108f, 57.1184845f); 2401 pathB.cubicTo(453.109528f, 57.1184845f, 456.54364f, 60.552597f, 456.54364f, 64.7890244f); 2402 pathB.cubicTo(456.54364f, 69.0254517f, 453.109528f, 72.4595642f, 448.873108f, 72.4595642f); 2403 pathB.close(); 2404 pathB.moveTo(520.242859f, 82.5275803f); 2405 pathB.cubicTo(519.733276f, 81.6547394f, 494.845154f, 41.3379478f, 494.263123f, 40.3923073f); 2406 pathB.cubicTo(493.681122f, 39.4462852f, 493.244324f, 39.5918846f, 492.807495f, 40.3195038f); 2407 pathB.cubicTo(492.515167f, 40.8071136f, 467.238037f, 81.6790085f, 466.528625f, 82.8373566f); 2408 pathB.cubicTo(465.819183f, 83.9945831f, 466.497528f, 84.2975311f, 466.904358f, 84.5792542f); 2409 pathB.cubicTo(466.904358f, 84.5792542f, 477.399689f, 91.2036743f, 478.235748f, 91.6981049f); 2410 pathB.cubicTo(479.071838f, 92.1929092f, 479.396393f, 91.9028473f, 479.669403f, 91.5104141f); 2411 pathB.cubicTo(479.942383f, 91.1175995f, 484.106384f, 84.1549606f, 484.481781f, 83.5570221f); 2412 pathB.cubicTo(484.857147f, 82.9602051f, 485.198792f, 82.8741379f, 485.966583f, 82.8741379f); 2413 pathB.cubicTo(486.734406f, 82.8741379f, 499.635925f, 82.8062668f, 500.830322f, 82.8062668f); 2414 pathB.cubicTo(502.024658f, 82.8062668f, 502.229797f, 83.4038391f, 502.400452f, 83.6427078f); 2415 pathB.cubicTo(502.571045f, 83.8815842f, 506.615631f, 90.7414703f, 506.990997f, 91.2870865f); 2416 pathB.cubicTo(507.651123f, 92.2475128f, 508.017395f, 92.1333847f, 508.672241f, 91.6962051f); 2417 pathB.cubicTo(509.327423f, 91.2597809f, 519.442444f, 85.0744324f, 520.243286f, 84.4920349f); 2418 pathB.cubicTo(521.042908f, 83.9100189f, 520.751709f, 83.4004211f, 520.242859f, 82.5275803f); 2419 pathB.close(); 2420 pathB.moveTo(493.720551f, 72.4811783f); 2421 pathB.cubicTo(491.265442f, 72.4811783f, 489.275574f, 70.4905548f, 489.275574f, 68.0362091f); 2422 pathB.cubicTo(489.275574f, 65.5811005f, 491.265808f, 63.5912399f, 493.720551f, 63.5912399f); 2423 pathB.cubicTo(496.175262f, 63.5912399f, 498.165527f, 65.5814819f, 498.165527f, 68.0362091f); 2424 pathB.cubicTo(498.165894f, 70.4905548f, 496.175659f, 72.4811783f, 493.720551f, 72.4811783f); 2425 pathB.close(); 2426 pathB.moveTo(526.561707f, 42.132679f); 2427 pathB.cubicTo(526.876404f, 41.786499f, 527.537292f, 41.1881752f, 528.512878f, 42.1956215f); 2428 pathB.cubicTo(529.488892f, 43.2030678f, 531.691833f, 45.2486725f, 531.881042f, 45.4693451f); 2429 pathB.cubicTo(532.07019f, 45.6896439f, 532.762939f, 46.2875862f, 533.517883f, 45.7525826f); 2430 pathB.cubicTo(534.272827f, 45.2172012f, 539.497681f, 41.9753265f, 545.384277f, 42.132679f); 2431 pathB.cubicTo(546.203247f, 42.2270889f, 546.580566f, 42.5421791f, 546.612f, 43.8324814f); 2432 pathB.cubicTo(546.643494f, 45.1227837f, 546.674561f, 55.1957283f, 546.612f, 56.2657356f); 2433 pathB.cubicTo(546.549072f, 57.3361206f, 546.549072f, 57.7452469f, 544.975525f, 57.8396568f); 2434 pathB.cubicTo(543.401978f, 57.9340706f, 538.742798f, 59.5709305f, 538.774658f, 64.6070251f); 2435 pathB.cubicTo(538.806458f, 69.6431122f, 538.806091f, 86.2631226f, 538.806091f, 86.9554901f); 2436 pathB.cubicTo(538.806091f, 87.6478424f, 538.585815f, 88.4349976f, 537.484314f, 88.4349976f); 2437 pathB.cubicTo(536.382446f, 88.4349976f, 524.79895f, 88.4031372f, 524.04364f, 88.4031372f); 2438 pathB.cubicTo(523.287964f, 88.4031372f, 522.910706f, 88.3402023f, 522.910706f, 86.8606949f); 2439 pathB.cubicTo(522.910706f, 85.3823242f, 522.910706f, 60.6094704f, 522.910706f, 60.0740852f); 2440 pathB.cubicTo(522.910706f, 59.5387039f, 522.81665f, 58.9092865f, 522.470093f, 58.6260452f); 2441 pathB.cubicTo(522.123901f, 58.3428116f, 517.465088f, 53.621048f, 517.181885f, 53.3378105f); 2442 pathB.cubicTo(516.898621f, 53.0545731f, 516.300659f, 52.330368f, 517.213318f, 51.5121231f); 2443 pathB.cubicTo(518.125977f, 50.6942635f, 526.561707f, 42.132679f, 526.561707f, 42.132679f); 2444 pathB.close(); 2445 pathB.moveTo(550.169006f, 43.7373123f); 2446 pathB.cubicTo(550.169006f, 42.6358337f, 550.767334f, 42.2263336f, 551.49115f, 42.2263336f); 2447 pathB.cubicTo(552.214966f, 42.2263336f, 552.781433f, 42.2263336f, 552.938843f, 42.2263336f); 2448 pathB.cubicTo(553.096191f, 42.2263336f, 553.725586f, 41.8801537f, 553.662598f, 41.124855f); 2449 pathB.cubicTo(553.600098f, 40.369175f, 553.662598f, 31.4614124f, 553.662598f, 30.8005257f); 2450 pathB.cubicTo(553.662598f, 30.1396389f, 553.75708f, 29.1951332f, 555.110657f, 29.1951332f); 2451 pathB.cubicTo(556.463928f, 29.1951332f, 566.536865f, 29.1951332f, 567.859009f, 29.1951332f); 2452 pathB.cubicTo(569.180786f, 29.1951332f, 569.463623f, 30.1711082f, 569.463623f, 30.7690544f); 2453 pathB.cubicTo(569.463623f, 31.3670006f, 569.463623f, 40.2122002f, 569.463623f, 41.0619125f); 2454 pathB.cubicTo(569.463623f, 41.9116249f, 569.746887f, 42.3207474f, 570.659912f, 42.3207474f); 2455 pathB.cubicTo(571.572571f, 42.3207474f, 575.507568f, 42.2263336f, 576.199951f, 42.2263336f); 2456 pathB.cubicTo(576.892273f, 42.2263336f, 577.742004f, 42.5725098f, 577.742004f, 43.8631973f); 2457 pathB.cubicTo(577.742004f, 45.1538811f, 577.742004f, 55.8877106f, 577.742004f, 56.5800705f); 2458 pathB.cubicTo(577.742004f, 57.2724266f, 577.616455f, 58.0595779f, 576.45166f, 58.0595779f); 2459 pathB.cubicTo(575.286865f, 58.0595779f, 570.943115f, 58.0595779f, 570.471069f, 58.0595779f); 2460 pathB.cubicTo(569.999023f, 58.0595779f, 569.479919f, 57.8389015f, 569.479919f, 59.0510979f); 2461 pathB.cubicTo(569.479919f, 60.2629128f, 569.479919f, 66.2124176f, 569.479919f, 67.1880188f); 2462 pathB.cubicTo(569.479919f, 68.1636047f, 570.628418f, 73.6406708f, 575.917053f, 73.6406708f); 2463 pathB.cubicTo(577.018921f, 73.6406708f, 577.742737f, 73.9242859f, 577.742737f, 75.4348907f); 2464 pathB.cubicTo(577.742737f, 76.945488f, 577.742737f, 87.0813751f, 577.742737f, 87.8366699f); 2465 pathB.cubicTo(577.742737f, 88.5915909f, 577.648315f, 89.4416809f, 576.295044f, 89.4416809f); 2466 pathB.cubicTo(574.028809f, 89.6312714f, 553.978088f, 88.0254974f, 553.631897f, 65.928421f); 2467 pathB.cubicTo(553.631897f, 65.928421f, 553.631897f, 59.6964378f, 553.631897f, 58.972229f); 2468 pathB.cubicTo(553.631897f, 58.2484055f, 553.034363f, 58.0436554f, 552.703735f, 58.0436554f); 2469 pathB.cubicTo(552.372681f, 58.0436554f, 551.522949f, 58.0436554f, 551.208252f, 58.0436554f); 2470 pathB.cubicTo(550.893921f, 58.0436554f, 550.170105f, 58.0906677f, 550.170105f, 56.6115417f); 2471 pathB.cubicTo(550.170105f, 55.1324081f, 550.169006f, 43.7373123f, 550.169006f, 43.7373123f); 2472 pathB.close(); 2473 pathB.moveTo(611.203857f, 39.5509338f); 2474 pathB.cubicTo(612.084961f, 39.5509338f, 612.620422f, 40.0544662f, 612.620422f, 40.8097687f); 2475 pathB.cubicTo(612.620422f, 41.5650673f, 612.620422f, 53.1486092f, 612.620422f, 53.6839905f); 2476 pathB.cubicTo(612.620422f, 54.2193718f, 612.651489f, 55.2264404f, 611.612976f, 55.2264404f); 2477 pathB.cubicTo(610.574463f, 55.2264404f, 604.404663f, 55.9817429f, 604.404663f, 61.899395f); 2478 pathB.cubicTo(604.404663f, 65.4878235f, 604.373169f, 66.6211548f, 604.373169f, 67.5338135f); 2479 pathB.cubicTo(604.373169f, 68.0684357f, 604.414124f, 74.3353043f, 599.934631f, 80.4702148f); 2480 pathB.cubicTo(596.765564f, 84.8109131f, 590.664368f, 89.3942871f, 582.150208f, 89.630127f); 2481 pathB.cubicTo(580.028015f, 89.630127f, 580.230469f, 88.5286484f, 580.230469f, 88.1820908f); 2482 pathB.cubicTo(580.230469f, 87.5845184f, 580.198975f, 75.8436279f, 580.198975f, 75.2142105f); 2483 pathB.cubicTo(580.198975f, 74.5844116f, 580.608154f, 73.8605804f, 581.58374f, 73.8605804f); 2484 pathB.cubicTo(583.40979f, 73.8605804f, 588.603271f, 72.7905731f, 588.603271f, 66.9043884f); 2485 pathB.cubicTo(588.603271f, 61.3958588f, 588.603271f, 61.8679237f, 588.603271f, 61.0496788f); 2486 pathB.cubicTo(588.603271f, 60.2314377f, 588.666565f, 54.3137856f, 593.230591f, 48.3961296f); 2487 pathB.cubicTo(597.794617f, 42.4784775f, 604.814087f, 39.5509338f, 611.203857f, 39.5509338f); 2488 pathB.close(); 2489 pathB.moveTo(635.22937f, 81.9311447f); 2490 pathB.cubicTo(635.057617f, 81.6475296f, 634.869141f, 81.3851471f, 634.664429f, 81.1439972f); 2491 pathB.lineTo(635.039001f, 81.0385895f); 2492 pathB.cubicTo(635.447754f, 80.9233246f, 635.729858f, 80.5509796f, 635.729858f, 80.1263123f); 2493 pathB.lineTo(635.729858f, 78.6149597f); 2494 pathB.cubicTo(635.729858f, 78.3309631f, 635.602417f, 78.0617523f, 635.382935f, 77.8816452f); 2495 pathB.cubicTo(635.162598f, 77.7015381f, 634.873291f, 77.6295013f, 634.595764f, 77.6852341f); 2496 pathB.cubicTo(633.906799f, 77.8232498f, 633.194397f, 77.9017334f, 632.478149f, 77.9191818f); 2497 pathB.cubicTo(631.714844f, 77.9373779f, 630.851501f, 77.9464874f, 629.911133f, 77.9464874f); 2498 pathB.lineTo(615.131226f, 77.9464874f); 2499 pathB.cubicTo(614.607605f, 77.9464874f, 614.18335f, 78.3707733f, 614.18335f, 78.8944016f); 2500 pathB.lineTo(614.18335f, 81.1337585f); 2501 pathB.cubicTo(614.18335f, 81.6573868f, 614.607605f, 82.0816803f, 615.131226f, 82.0816803f); 2502 pathB.lineTo(619.693787f, 82.0816803f); 2503 pathB.cubicTo(619.680908f, 82.1423492f, 619.669128f, 82.2026367f, 619.657776f, 82.2629166f); 2504 pathB.cubicTo(619.571289f, 82.728157f, 619.529602f, 83.3200302f, 619.529602f, 84.0730591f); 2505 pathB.cubicTo(619.529602f, 86.3196259f, 620.260254f, 88.1236954f, 621.701477f, 89.4348602f); 2506 pathB.cubicTo(623.116516f, 90.7225037f, 625.163269f, 91.3754272f, 627.784058f, 91.3754272f); 2507 pathB.cubicTo(630.525024f, 91.3754272f, 632.517944f, 90.8669662f, 633.876099f, 89.8208466f); 2508 pathB.cubicTo(635.291565f, 88.7314987f, 636.009705f, 87.0798492f, 636.009705f, 84.9129181f); 2509 pathB.cubicTo(636.010071f, 83.7905807f, 635.747314f, 82.7873077f, 635.22937f, 81.9311447f); 2510 pathB.close(); 2511 pathB.moveTo(631.880554f, 85.7326736f); 2512 pathB.cubicTo(631.690552f, 86.0545807f, 631.436157f, 86.307869f, 631.102844f, 86.5076904f); 2513 pathB.cubicTo(630.736206f, 86.7279816f, 630.277039f, 86.8906479f, 629.737854f, 86.9903717f); 2514 pathB.cubicTo(629.146362f, 87.1003265f, 628.488892f, 87.1564484f, 627.783997f, 87.1564484f); 2515 pathB.cubicTo(626.159668f, 87.1564484f, 624.996399f, 86.8656235f, 624.327881f, 86.293457f); 2516 pathB.cubicTo(623.693604f, 85.7489777f, 623.385315f, 84.995575f, 623.385315f, 83.9896393f); 2517 pathB.cubicTo(623.385315f, 83.3655396f, 623.431519f, 82.8718567f, 623.522583f, 82.5215149f); 2518 pathB.cubicTo(623.563477f, 82.3645325f, 623.616943f, 82.2189331f, 623.684448f, 82.0824356f); 2519 pathB.lineTo(630.008179f, 82.0824356f); 2520 pathB.cubicTo(630.758911f, 82.247757f, 631.311401f, 82.5256805f, 631.650757f, 82.9101562f); 2521 pathB.cubicTo(631.990112f, 83.2942505f, 632.154663f, 83.8303986f, 632.154663f, 84.549675f); 2522 pathB.cubicTo(632.154663f, 85.02742f, 632.062927f, 85.4251709f, 631.880554f, 85.7326736f); 2523 pathB.close(); 2524 pathB.moveTo(635.667664f, 69.5979919f); 2525 pathB.cubicTo(635.518311f, 69.0645142f, 635.325684f, 68.5818329f, 635.093994f, 68.1620941f); 2526 pathB.cubicTo(634.940796f, 67.8856812f, 634.770569f, 67.6316376f, 634.586304f, 67.4026184f); 2527 pathB.lineTo(635.054565f, 67.2619476f); 2528 pathB.cubicTo(635.455322f, 67.1417542f, 635.729858f, 66.7724457f, 635.729858f, 66.3538437f); 2529 pathB.lineTo(635.729858f, 64.7021942f); 2530 pathB.cubicTo(635.729858f, 64.4045486f, 635.590332f, 64.1243439f, 635.3526f, 63.9449997f); 2531 pathB.cubicTo(635.115234f, 63.7660294f, 634.807373f, 63.7087784f, 634.521057f, 63.7906761f); 2532 pathB.cubicTo(634.059998f, 63.9226265f, 633.544678f, 64.0155258f, 632.988831f, 64.0659485f); 2533 pathB.cubicTo(631.578735f, 64.1941071f, 629.921387f, 64.1565704f, 628.141968f, 64.0632935f); 2534 pathB.cubicTo(627.067383f, 64.0068054f, 625.948853f, 63.9779854f, 624.81665f, 63.9779854f); 2535 pathB.cubicTo(624.253601f, 63.9779854f, 623.681396f, 64.0359955f, 623.116089f, 64.1512604f); 2536 pathB.cubicTo(622.479126f, 64.2809448f, 621.888367f, 64.5437012f, 621.35907f, 64.9315872f); 2537 pathB.cubicTo(620.807007f, 65.3365402f, 620.360352f, 65.9159088f, 620.031189f, 66.6548996f); 2538 pathB.cubicTo(619.712708f, 67.3722839f, 619.557983f, 68.2625656f, 619.557983f, 69.3769379f); 2539 pathB.cubicTo(619.557983f, 70.4655304f, 619.669128f, 71.5268097f, 619.887878f, 72.5323639f); 2540 pathB.cubicTo(620.11499f, 73.573555f, 620.473694f, 74.5040283f, 620.954468f, 75.2983856f); 2541 pathB.cubicTo(621.196411f, 75.6976471f, 621.693481f, 75.861824f, 622.124939f, 75.6847534f); 2542 pathB.lineTo(623.832336f, 74.9851913f); 2543 pathB.cubicTo(624.086365f, 74.8809204f, 624.282776f, 74.6716156f, 624.370728f, 74.4111328f); 2544 pathB.cubicTo(624.45874f, 74.15065f, 624.429138f, 73.8651276f, 624.290405f, 73.6281509f); 2545 pathB.cubicTo(624.166382f, 73.416954f, 624.051147f, 73.1644287f, 623.947205f, 72.875885f); 2546 pathB.cubicTo(623.836853f, 72.5702744f, 623.741333f, 72.2407837f, 623.663574f, 71.8968811f); 2547 pathB.cubicTo(623.584717f, 71.549942f, 623.522217f, 71.2018585f, 623.477417f, 70.8621292f); 2548 pathB.cubicTo(623.434937f, 70.5409775f, 623.41333f, 70.2391663f, 623.41333f, 69.9646454f); 2549 pathB.cubicTo(623.41333f, 68.8229752f, 623.672729f, 68.4748993f, 623.75116f, 68.3960266f); 2550 pathB.cubicTo(623.853577f, 68.2940369f, 624.20166f, 68.0574341f, 625.236755f, 68.0574341f); 2551 pathB.cubicTo(625.39679f, 68.0574341f, 625.566284f, 68.0616074f, 625.744446f, 68.0695648f); 2552 pathB.lineTo(625.744446f, 68.7331085f); 2553 pathB.cubicTo(625.744446f, 69.8065338f, 625.819153f, 70.8048782f, 625.967041f, 71.70047f); 2554 pathB.cubicTo(626.12323f, 72.6483841f, 626.392456f, 73.4825516f, 626.767456f, 74.1794586f); 2555 pathB.cubicTo(627.173523f, 74.9328613f, 627.730957f, 75.5292969f, 628.424438f, 75.9528198f); 2556 pathB.cubicTo(629.123596f, 76.3790054f, 629.981628f, 76.5951309f, 630.975464f, 76.5951309f); 2557 pathB.cubicTo(631.722046f, 76.5951309f, 632.406799f, 76.4597626f, 633.009644f, 76.1924591f); 2558 pathB.cubicTo(633.611816f, 75.9262848f, 634.136536f, 75.5543213f, 634.567688f, 75.0875626f); 2559 pathB.cubicTo(634.998779f, 74.6223297f, 635.333191f, 74.0672302f, 635.561096f, 73.4370575f); 2560 pathB.cubicTo(635.78479f, 72.8212891f, 635.898193f, 72.1520538f, 635.898193f, 71.4479446f); 2561 pathB.cubicTo(635.898193f, 70.7688599f, 635.820496f, 70.1462708f, 635.667664f, 69.5979919f); 2562 pathB.close(); 2563 pathB.moveTo(631.656494f, 71.9905396f); 2564 pathB.cubicTo(631.416077f, 72.2574692f, 631.13739f, 72.3765259f, 630.751404f, 72.3765259f); 2565 pathB.cubicTo(630.390015f, 72.3765259f, 630.239502f, 72.2536774f, 630.190247f, 72.2127228f); 2566 pathB.cubicTo(630.002197f, 72.0587845f, 629.853149f, 71.8483429f, 629.735596f, 71.5704193f); 2567 pathB.cubicTo(629.594177f, 71.2348557f, 629.494507f, 70.8310394f, 629.439453f, 70.3714905f); 2568 pathB.cubicTo(629.379211f, 69.8607559f, 629.348511f, 69.3284073f, 629.348511f, 68.7892303f); 2569 pathB.cubicTo(629.348511f, 68.5765228f, 629.351929f, 68.3603973f, 629.357971f, 68.1416168f); 2570 pathB.lineTo(630.581177f, 68.1416168f); 2571 pathB.cubicTo(630.702515f, 68.2026672f, 630.831787f, 68.2841797f, 630.967163f, 68.3857956f); 2572 pathB.cubicTo(631.149902f, 68.523056f, 631.322815f, 68.703537f, 631.480225f, 68.922699f); 2573 pathB.cubicTo(631.639038f, 69.1437531f, 631.77478f, 69.4186478f, 631.884399f, 69.7390442f); 2574 pathB.cubicTo(631.989807f, 70.0488281f, 632.04364f, 70.4169922f, 632.04364f, 70.8329391f); 2575 pathB.cubicTo(632.042847f, 71.3228302f, 631.916565f, 71.7012329f, 631.656494f, 71.9905396f); 2576 pathB.close(); 2577 pathB.moveTo(622.689575f, 63.4953079f); 2578 pathB.lineTo(620.72998f, 63.4953079f); 2579 pathB.cubicTo(620.206421f, 63.4953079f, 619.782104f, 63.0710182f, 619.782104f, 62.54739f); 2580 pathB.lineTo(619.782104f, 61.3116837f); 2581 pathB.lineTo(617.958679f, 61.3116837f); 2582 pathB.cubicTo(617.536255f, 61.3116837f, 617.164307f, 61.0318604f, 617.047913f, 60.6257744f); 2583 pathB.lineTo(616.404114f, 58.3864136f); 2584 pathB.cubicTo(616.321411f, 58.1001472f, 616.378662f, 57.7922592f, 616.557678f, 57.5541458f); 2585 pathB.cubicTo(616.737061f, 57.3164062f, 617.017212f, 57.1764946f, 617.31488f, 57.1764946f); 2586 pathB.lineTo(619.782104f, 57.1764946f); 2587 pathB.lineTo(619.782104f, 54.3171997f); 2588 pathB.cubicTo(619.782104f, 53.7935715f, 620.206421f, 53.3692818f, 620.730042f, 53.3692818f); 2589 pathB.lineTo(622.689575f, 53.3692818f); 2590 pathB.cubicTo(623.213196f, 53.3692818f, 623.637512f, 53.7935715f, 623.637512f, 54.3171997f); 2591 pathB.lineTo(623.637512f, 57.1764946f); 2592 pathB.lineTo(630.443176f, 57.1764946f); 2593 pathB.cubicTo(631.548828f, 57.1764946f, 631.921936f, 57.0028381f, 632.009888f, 56.9493713f); 2594 pathB.cubicTo(632.057617f, 56.9205589f, 632.154724f, 56.8621674f, 632.154724f, 56.5288773f); 2595 pathB.cubicTo(632.154724f, 56.139473f, 632.116821f, 55.8179398f, 632.04248f, 55.5737572f); 2596 pathB.cubicTo(631.949219f, 55.268528f, 631.822205f, 54.9193192f, 631.665588f, 54.5363579f); 2597 pathB.cubicTo(631.563599f, 54.288002f, 631.572327f, 54.0085602f, 631.688354f, 53.7670288f); 2598 pathB.cubicTo(631.804749f, 53.5251198f, 632.017456f, 53.3438797f, 632.274536f, 53.2680435f); 2599 pathB.lineTo(633.9823f, 52.7641296f); 2600 pathB.cubicTo(634.430115f, 52.6325607f, 634.90332f, 52.8437576f, 635.105042f, 53.2623596f); 2601 pathB.cubicTo(635.375f, 53.8235245f, 635.59491f, 54.4404297f, 635.758301f, 55.0956268f); 2602 pathB.cubicTo(635.925537f, 55.7656174f, 636.010498f, 56.4928589f, 636.010498f, 57.2565002f); 2603 pathB.cubicTo(636.010498f, 58.7109833f, 635.553589f, 59.7790947f, 634.653076f, 60.4316406f); 2604 pathB.cubicTo(633.835938f, 61.0235176f, 632.596069f, 61.311306f, 630.863647f, 61.311306f); 2605 pathB.lineTo(623.637878f, 61.311306f); 2606 pathB.lineTo(623.637878f, 62.5470123f); 2607 pathB.cubicTo(623.637451f, 63.071022f, 623.213196f, 63.4953079f, 622.689575f, 63.4953079f); 2608 pathB.close(); 2609 pathB.moveTo(635.667664f, 46.2246475f); 2610 pathB.cubicTo(635.518311f, 45.6911545f, 635.325684f, 45.2084808f, 635.093994f, 44.7887421f); 2611 pathB.cubicTo(634.940796f, 44.5123291f, 634.770569f, 44.2582855f, 634.586304f, 44.029274f); 2612 pathB.lineTo(635.054565f, 43.8886032f); 2613 pathB.cubicTo(635.455322f, 43.7684059f, 635.729858f, 43.3990974f, 635.729858f, 42.9804955f); 2614 pathB.lineTo(635.729858f, 41.328846f); 2615 pathB.cubicTo(635.729858f, 41.0312004f, 635.590332f, 40.7509995f, 635.3526f, 40.5716515f); 2616 pathB.cubicTo(635.115234f, 40.3926849f, 634.807373f, 40.3354301f, 634.521057f, 40.4173279f); 2617 pathB.cubicTo(634.059998f, 40.5492783f, 633.544678f, 40.6421738f, 632.988831f, 40.6926041f); 2618 pathB.cubicTo(631.578735f, 40.8207626f, 629.921387f, 40.7836075f, 628.141968f, 40.689949f); 2619 pathB.cubicTo(627.067383f, 40.6334534f, 625.948853f, 40.6046371f, 624.81665f, 40.6046371f); 2620 pathB.cubicTo(624.253601f, 40.6046371f, 623.681396f, 40.6626511f, 623.116089f, 40.777916f); 2621 pathB.cubicTo(622.479126f, 40.9075928f, 621.888367f, 41.1703568f, 621.35907f, 41.5582428f); 2622 pathB.cubicTo(620.807007f, 41.963192f, 620.360352f, 42.5425606f, 620.031189f, 43.2815552f); 2623 pathB.cubicTo(619.712708f, 43.9989395f, 619.557983f, 44.8892212f, 619.557983f, 46.0035934f); 2624 pathB.cubicTo(619.557983f, 47.0921783f, 619.669128f, 48.1534653f, 619.887878f, 49.1590195f); 2625 pathB.cubicTo(620.11499f, 50.2002106f, 620.473694f, 51.1306839f, 620.954468f, 51.9250374f); 2626 pathB.cubicTo(621.196411f, 52.3243027f, 621.693481f, 52.4880981f, 622.124939f, 52.311409f); 2627 pathB.lineTo(623.832336f, 51.6118431f); 2628 pathB.cubicTo(624.086365f, 51.5075722f, 624.282776f, 51.2982712f, 624.370728f, 51.0377846f); 2629 pathB.cubicTo(624.45874f, 50.777298f, 624.429138f, 50.4917831f, 624.290405f, 50.2548065f); 2630 pathB.cubicTo(624.166382f, 50.0436096f, 624.051147f, 49.7910843f, 623.947205f, 49.5025406f); 2631 pathB.cubicTo(623.836853f, 49.1969299f, 623.741333f, 48.8674355f, 623.663574f, 48.5235291f); 2632 pathB.cubicTo(623.584717f, 48.1765938f, 623.522217f, 47.8285179f, 623.477417f, 47.4887848f); 2633 pathB.cubicTo(623.434937f, 47.1676331f, 623.41333f, 46.8658142f, 623.41333f, 46.5912971f); 2634 pathB.cubicTo(623.41333f, 45.4496269f, 623.672729f, 45.1015511f, 623.75116f, 45.0226822f); 2635 pathB.cubicTo(623.853577f, 44.9206886f, 624.20166f, 44.6840897f, 625.236755f, 44.6840897f); 2636 pathB.cubicTo(625.39679f, 44.6840897f, 625.566284f, 44.6882591f, 625.744446f, 44.6962204f); 2637 pathB.lineTo(625.744446f, 45.3597641f); 2638 pathB.cubicTo(625.744446f, 46.4331856f, 625.819153f, 47.43153f, 625.967041f, 48.3271217f); 2639 pathB.cubicTo(626.12323f, 49.2750397f, 626.392456f, 50.1092072f, 626.767456f, 50.8061142f); 2640 pathB.cubicTo(627.173523f, 51.5595169f, 627.730957f, 52.1559486f, 628.424438f, 52.5794754f); 2641 pathB.cubicTo(629.123596f, 53.005661f, 629.981628f, 53.2217865f, 630.975464f, 53.2217865f); 2642 pathB.cubicTo(631.722046f, 53.2217865f, 632.406799f, 53.086422f, 633.009644f, 52.8191147f); 2643 pathB.cubicTo(633.611816f, 52.5529366f, 634.136536f, 52.1809769f, 634.567688f, 51.7142181f); 2644 pathB.cubicTo(634.998779f, 51.2489815f, 635.333191f, 50.693882f, 635.561096f, 50.0637054f); 2645 pathB.cubicTo(635.78479f, 49.4479408f, 635.898193f, 48.7787094f, 635.898193f, 48.0746002f); 2646 pathB.cubicTo(635.898193f, 47.3958893f, 635.820496f, 46.7733002f, 635.667664f, 46.2246475f); 2647 pathB.close(); 2648 pathB.moveTo(631.656494f, 48.6171875f); 2649 pathB.cubicTo(631.416077f, 48.8841209f, 631.13739f, 49.0031815f, 630.751404f, 49.0031815f); 2650 pathB.cubicTo(630.390015f, 49.0031815f, 630.239502f, 48.8803291f, 630.190247f, 48.8393784f); 2651 pathB.cubicTo(630.002197f, 48.6854401f, 629.853149f, 48.4749985f, 629.735596f, 48.1970711f); 2652 pathB.cubicTo(629.594177f, 47.8615112f, 629.494507f, 47.457695f, 629.439453f, 46.9981461f); 2653 pathB.cubicTo(629.379211f, 46.4874115f, 629.348511f, 45.9550591f, 629.348511f, 45.4158859f); 2654 pathB.cubicTo(629.348511f, 45.2031708f, 629.351929f, 44.9870453f, 629.357971f, 44.7682648f); 2655 pathB.lineTo(630.581177f, 44.7682648f); 2656 pathB.cubicTo(630.702515f, 44.8293152f, 630.831787f, 44.9108353f, 630.967163f, 45.0124512f); 2657 pathB.cubicTo(631.149902f, 45.1497116f, 631.322815f, 45.3301926f, 631.480225f, 45.5493507f); 2658 pathB.cubicTo(631.639038f, 45.7704048f, 631.77478f, 46.0453033f, 631.884399f, 46.3656998f); 2659 pathB.cubicTo(631.989807f, 46.6754761f, 632.04364f, 47.0436478f, 632.04364f, 47.4595947f); 2660 pathB.cubicTo(632.042847f, 47.949852f, 631.916565f, 48.3282623f, 631.656494f, 48.6171875f); 2661 pathB.close(); 2662 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2663 } 2664 2665 // SkOpAngle::setSector SkASSERT(fSectorStart >= 0); 2666 static void skpwww_seopack_blogspot_com_2153(skiatest::Reporter* reporter, const char* filename) { 2667 SkPath path; 2668 path.setFillType(SkPath::kEvenOdd_FillType); 2669 path.moveTo(999.892212f, 246); 2670 path.lineTo(927.340759f, 245.505722f); 2671 path.quadTo(928.068054f, 246, 929, 246); 2672 path.lineTo(999.892212f, 246); 2673 path.close(); 2674 path.moveTo(927.340759f, 245.505722f); 2675 path.lineTo(926.5f, 245.5f); 2676 path.lineTo(925.17157f, 246.82843f); 2677 path.quadTo(926.34314f, 248, 928, 248); 2678 path.lineTo(1000, 248); 2679 path.lineTo(1000, 246); 2680 SkPath pathB; 2681 pathB.setFillType(SkPath::kWinding_FillType); 2682 pathB.moveTo(924, 248); 2683 pathB.lineTo(924, 245.472672f); 2684 pathB.lineTo(1143, 247); 2685 pathB.lineTo(1143, 248); 2686 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2687 } 2688 2689 // joinCoincidence / findT / assert 2690 static void skpwww_lokado_de_173(skiatest::Reporter* reporter, const char* filename) { 2691 SkPath path; 2692 path.setFillType(SkPath::kEvenOdd_FillType); 2693 path.moveTo(1000, 896.991394f); 2694 path.quadTo(999.789917f, 896.718872f, 999.535522f, 896.464478f); 2695 path.quadTo(998.071045f, 895, 996, 895); 2696 path.lineTo(956, 895); 2697 path.quadTo(951.857849f, 895, 948.928955f, 897.928955f); 2698 path.quadTo(946, 900.857849f, 946, 905); 2699 path.lineTo(946, 906); 2700 path.quadTo(946, 910.142151f, 948.928955f, 913.071045f); 2701 path.quadTo(951.857849f, 916, 956, 916); 2702 path.lineTo(996, 916); 2703 path.quadTo(998.071045f, 916, 999.535522f, 914.535522f); 2704 path.quadTo(999.789917f, 914.281128f, 1000, 914.008606f); 2705 path.lineTo(1000, 896.991394f); 2706 path.close(); 2707 SkPath pathB; 2708 pathB.setFillType(SkPath::kWinding_FillType); 2709 pathB.moveTo(946, 906); 2710 pathB.lineTo(946, 905); 2711 pathB.quadTo(946, 901.272095f, 948.928955f, 898.636047f); 2712 pathB.quadTo(951.857849f, 896, 956, 896); 2713 pathB.lineTo(996, 896); 2714 pathB.quadTo(998.071045f, 896, 999.535522f, 897.17157f); 2715 pathB.quadTo(1001, 898.34314f, 1001, 900); 2716 pathB.lineTo(1001, 911); 2717 pathB.quadTo(1001, 913.071045f, 999.535522f, 914.535522f); 2718 pathB.quadTo(998.071045f, 916, 996, 916); 2719 pathB.lineTo(956, 916); 2720 pathB.quadTo(951.857849f, 916, 948.928955f, 913.071045f); 2721 pathB.quadTo(946, 910.142151f, 946, 906); 2722 pathB.close(); 2723 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2724 } 2725 2726 // !simple->isClosed() 2727 static void skpwww_wartepop_blogspot_com_br_6(skiatest::Reporter* reporter, const char* filename) { 2728 SkPath path; 2729 path.setFillType(SkPath::kEvenOdd_FillType); 2730 path.moveTo(90.9763107f, 153.309662f); 2731 path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f); 2732 path.lineTo(124.666664f, 152.333344f); 2733 path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f); 2734 path.quadTo(128, 154.285965f, 128, 155.666672f); 2735 path.lineTo(128, 163.666672f); 2736 path.lineTo(90, 163.666672f); 2737 path.lineTo(90, 155.666672f); 2738 path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f); 2739 path.close(); 2740 SkPath pathB; 2741 pathB.setFillType(SkPath::kWinding_FillType); 2742 pathB.moveTo(90, 163.666672f); 2743 pathB.lineTo(90, 155.666672f); 2744 pathB.quadTo(90, 154.285965f, 90.9763107f, 153.309662f); 2745 pathB.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f); 2746 pathB.lineTo(124.666672f, 152.333344f); 2747 pathB.quadTo(125.909309f, 152.333344f, 126.787994f, 153.309662f); 2748 pathB.quadTo(127.666672f, 154.285965f, 127.666672f, 155.666672f); 2749 pathB.lineTo(127.666672f, 163.666672f); 2750 pathB.lineTo(127.666672f, 163.666672f); 2751 pathB.lineTo(127.666672f, 163.666672f); 2752 pathB.lineTo(90, 163.666672f); 2753 pathB.lineTo(90, 163.666672f); 2754 pathB.lineTo(90, 163.666672f); 2755 pathB.close(); 2756 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2757 } 2758 2759 static void skpwww_wartepop_blogspot_com_br_6a(skiatest::Reporter* reporter, const char* filename) { 2760 SkPath path; 2761 path.setFillType(SkPath::kEvenOdd_FillType); 2762 path.moveTo(90.9763107f, 153.309662f); 2763 path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f); 2764 path.lineTo(124.666672f, 152.333344f); 2765 path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f); 2766 path.quadTo(128, 154.285965f, 128, 155.666672f); 2767 path.lineTo(128, 163.666672f); 2768 path.lineTo(90, 163.666672f); 2769 path.lineTo(90, 155.666672f); 2770 path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f); 2771 path.close(); 2772 SkPath pathB; 2773 pathB.setFillType(SkPath::kWinding_FillType); 2774 pathB.moveTo(90, 163.666672f); 2775 pathB.lineTo(90, 155.666672f); 2776 pathB.quadTo(90, 154.285965f, 90.9763107f, 153.309662f); 2777 pathB.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f); 2778 pathB.lineTo(124.666672f, 152.333344f); 2779 pathB.quadTo(125.909309f, 152.333344f, 126.787994f, 153.309662f); 2780 pathB.quadTo(127.666672f, 154.285965f, 127.666672f, 155.666672f); 2781 pathB.lineTo(127.666672f, 163.666672f); 2782 pathB.lineTo(127.666672f, 163.666672f); 2783 pathB.lineTo(127.666672f, 163.666672f); 2784 pathB.lineTo(90, 163.666672f); 2785 pathB.lineTo(90, 163.666672f); 2786 pathB.lineTo(90, 163.666672f); 2787 pathB.close(); 2788 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2789 } 2790 2791 // !simple->isClosed() 2792 static void skpwww_odia_com_br_26(skiatest::Reporter* reporter, const char* filename) { 2793 SkPath path; 2794 path.setFillType(SkPath::kEvenOdd_FillType); 2795 path.moveTo(360.740479f, 741.040771f); 2796 path.quadTo(360.378967f, 741, 360, 741); 2797 path.quadTo(359.159821f, 741, 358.403076f, 741.200745f); 2798 path.quadTo(357.649658f, 741.415833f, 356.92746f, 741.846436f); 2799 path.quadTo(356.600769f, 742.041199f, 356.310211f, 742.262268f); 2800 path.quadTo(356.025513f, 742.489197f, 355.757355f, 742.757385f); 2801 path.quadTo(355.16394f, 743.350769f, 354.770874f, 744.027283f); 2802 path.quadTo(354.389618f, 744.71283f, 354.183258f, 745.528564f); 2803 path.quadTo(354.090027f, 745.897095f, 354.040833f, 746.259277f); 2804 path.quadTo(354, 746.621216f, 354, 747); 2805 path.quadTo(354, 747.839844f, 354.200653f, 748.596497f); 2806 path.quadTo(354.415771f, 749.35022f, 354.846466f, 750.072632f); 2807 path.quadTo(355.040741f, 750.398438f, 355.261444f, 750.688721f); 2808 path.quadTo(355.488861f, 750.974121f, 355.757355f, 751.242615f); 2809 path.quadTo(356.352142f, 751.837402f, 357.030304f, 752.230896f); 2810 path.quadTo(357.714539f, 752.610901f, 358.528564f, 752.816833f); 2811 path.quadTo(358.895294f, 752.909607f, 359.25528f, 752.95874f); 2812 path.quadTo(359.618896f, 753, 360, 753); 2813 path.quadTo(360.842285f, 753, 361.600952f, 752.798157f); 2814 path.quadTo(362.352386f, 752.583008f, 363.072601f, 752.153625f); 2815 path.quadTo(363.397339f, 751.960022f, 363.686829f, 751.740051f); 2816 path.quadTo(363.973297f, 751.511963f, 364.242645f, 751.242615f); 2817 path.quadTo(364.837799f, 750.647461f, 365.231354f, 749.968933f); 2818 path.quadTo(365.610992f, 749.285034f, 365.816803f, 748.471497f); 2819 path.quadTo(365.909668f, 748.104431f, 365.958832f, 747.743713f); 2820 path.quadTo(366, 747.380371f, 366, 747); 2821 path.quadTo(366, 746.158997f, 365.798767f, 745.401367f); 2822 path.quadTo(365.583618f, 744.648682f, 365.153595f, 743.927429f); 2823 path.quadTo(364.959442f, 743.601807f, 364.738678f, 743.311462f); 2824 path.quadTo(364.511108f, 743.025818f, 364.242645f, 742.757385f); 2825 path.quadTo(363.649017f, 742.163757f, 362.972168f, 741.770569f); 2826 path.quadTo(362.286835f, 741.389526f, 361.471497f, 741.183289f); 2827 path.quadTo(361.102509f, 741.089966f, 360.740479f, 741.040771f); 2828 path.close(); 2829 SkPath pathB; 2830 pathB.setFillType(SkPath::kWinding_FillType); 2831 pathB.moveTo(355.654724f, 739.711792f); 2832 pathB.lineTo(367.288269f, 742.654724f); 2833 pathB.lineTo(364.345337f, 754.288269f); 2834 pathB.lineTo(352.711792f, 751.345337f); 2835 pathB.close(); 2836 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2837 } 2838 2839 static void skpwww_evolvehq_com_210(skiatest::Reporter* reporter, const char* filename) { 2840 SkPath path; 2841 path.setFillType(SkPath::kEvenOdd_FillType); 2842 path.moveTo(172, 972); 2843 path.quadTo(170.757355f, 972, 169.878677f, 972.878662f); 2844 path.quadTo(169, 973.757385f, 169, 975); 2845 path.lineTo(169, 1171); 2846 path.quadTo(169, 1172.24268f, 169.878677f, 1173.12134f); 2847 path.quadTo(170.757355f, 1174, 172, 1174); 2848 path.lineTo(308, 1174); 2849 path.quadTo(309.242645f, 1174, 310.121307f, 1173.12134f); 2850 path.quadTo(310.337311f, 1172.9054f, 310.5f, 1172.66772f); 2851 path.lineTo(310.5f, 973.332336f); 2852 path.quadTo(310.337219f, 973.094604f, 310.121307f, 972.878662f); 2853 path.quadTo(309.242645f, 972, 308, 972); 2854 path.lineTo(172, 972); 2855 path.close(); 2856 SkPath pathB; 2857 pathB.setFillType(SkPath::kWinding_FillType); 2858 pathB.moveTo(170, 1171); 2859 pathB.lineTo(170, 975); 2860 pathB.quadTo(170, 974.17157f, 170.585785f, 973.585815f); 2861 pathB.quadTo(171.17157f, 973, 172, 973); 2862 pathB.lineTo(308, 973); 2863 pathB.quadTo(309.242645f, 973, 310.121307f, 973.585815f); 2864 pathB.quadTo(311, 974.17157f, 311, 975); 2865 pathB.lineTo(311, 1171); 2866 pathB.quadTo(311, 1172.24268f, 310.121307f, 1173.12134f); 2867 pathB.quadTo(309.242645f, 1174, 308, 1174); 2868 pathB.lineTo(172, 1174); 2869 pathB.quadTo(171.17157f, 1174, 170.585785f, 1173.12134f); 2870 pathB.quadTo(170, 1172.24268f, 170, 1171); 2871 pathB.close(); 2872 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2873 } 2874 2875 // hangs 2876 static void skpwww_catingueiraonline_com_352(skiatest::Reporter* reporter, const char* filename) { 2877 SkPath path; 2878 path.setFillType(SkPath::kEvenOdd_FillType); 2879 path.moveTo(443, 8292); 2880 path.lineTo(443, 8140); 2881 path.lineTo(444, 8140); 2882 path.lineTo(444.01001f, 8292); 2883 path.lineTo(443, 8292); 2884 path.close(); 2885 SkPath pathB; 2886 pathB.setFillType(SkPath::kWinding_FillType); 2887 pathB.moveTo(443, 8140); 2888 pathB.lineTo(444.01001f, 8140); 2889 pathB.lineTo(444, 8292); 2890 pathB.lineTo(443, 8292); 2891 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2892 } 2893 2894 // hangs 2895 static void skpwww_galaxystwo_com_4(skiatest::Reporter* reporter, const char* filename) { 2896 SkPath path; 2897 path.setFillType(SkPath::kEvenOdd_FillType); 2898 path.moveTo(10105, 2510); 2899 path.lineTo(10123, 2509.98999f); 2900 path.lineTo(10123, 2511); 2901 path.lineTo(10105, 2511); 2902 path.lineTo(10105, 2510); 2903 path.close(); 2904 SkPath pathB; 2905 pathB.setFillType(SkPath::kWinding_FillType); 2906 pathB.moveTo(10105, 2511); 2907 pathB.lineTo(10105, 2509.98999f); 2908 pathB.lineTo(10123, 2510); 2909 pathB.lineTo(10123, 2511); 2910 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2911 } 2912 2913 static void skpwww_thaienews_blogspot_com_36(skiatest::Reporter* reporter, const char* filename) { 2914 SkPath path; 2915 path.setFillType(SkPath::kEvenOdd_FillType); 2916 path.moveTo(429.994995f, 6268); 2917 path.lineTo(430, 2187); 2918 path.lineTo(430.5f, 2187); 2919 path.lineTo(430.5f, 6268); 2920 path.lineTo(429.994995f, 6268); 2921 path.close(); 2922 SkPath pathB; 2923 pathB.setFillType(SkPath::kWinding_FillType); 2924 pathB.moveTo(430.5f, 2187); 2925 pathB.lineTo(429.994995f, 2187); 2926 pathB.lineTo(430, 6268); 2927 pathB.lineTo(430.5f, 6268); 2928 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2929 } 2930 2931 static void skpwww_fashionscandal_com_94(skiatest::Reporter* reporter, const char* filename) { 2932 SkPath path; 2933 path.setFillType(SkPath::kEvenOdd_FillType); 2934 path.moveTo(25.9107456f, 272.577423f); 2935 path.quadTo(26.1548233f, 272.333344f, 26.5000019f, 272.333344f); 2936 path.lineTo(131.166672f, 272.333344f); 2937 path.quadTo(131.511841f, 272.333344f, 131.75592f, 272.577423f); 2938 path.quadTo(132, 272.821503f, 132, 273.166687f); 2939 path.lineTo(132, 417.166656f); 2940 path.quadTo(132, 417.511841f, 131.75592f, 417.75592f); 2941 path.quadTo(131.511841f, 418, 131.166672f, 418); 2942 path.lineTo(26.5000019f, 418); 2943 path.quadTo(26.1548233f, 418, 25.9107456f, 417.75592f); 2944 path.quadTo(25.6666679f, 417.511841f, 25.6666679f, 417.166656f); 2945 path.lineTo(25.6666679f, 273.166687f); 2946 path.quadTo(25.6666679f, 272.821503f, 25.9107456f, 272.577423f); 2947 path.close(); 2948 SkPath pathB; 2949 pathB.setFillType(SkPath::kWinding_FillType); 2950 pathB.moveTo(25.833334f, 417.166656f); 2951 pathB.lineTo(25.833334f, 273.166656f); 2952 pathB.quadTo(25.833334f, 272.890533f, 26.0285969f, 272.695251f); 2953 pathB.quadTo(26.2238579f, 272.5f, 26.5f, 272.5f); 2954 pathB.lineTo(131.166672f, 272.5f); 2955 pathB.quadTo(131.442825f, 272.5f, 131.638077f, 272.695251f); 2956 pathB.quadTo(131.833344f, 272.890533f, 131.833344f, 273.166656f); 2957 pathB.lineTo(131.833344f, 417.166656f); 2958 pathB.quadTo(131.833344f, 417.511841f, 131.638077f, 417.75592f); 2959 pathB.quadTo(131.442825f, 418, 131.166672f, 418); 2960 pathB.lineTo(26.5f, 418); 2961 pathB.quadTo(26.2238579f, 418, 26.0285969f, 417.75592f); 2962 pathB.quadTo(25.833334f, 417.511841f, 25.833334f, 417.166656f); 2963 pathB.close(); 2964 testPathOp(reporter, path, pathB, kDifference_PathOp, filename); 2965 } 2966 2967 static void skpwww_kenlevine_blogspot_com_28(skiatest::Reporter* reporter, const char* filename) { 2968 SkPath path; 2969 path.setFillType(SkPath::kEvenOdd_FillType); 2970 path.moveTo(276, 9506); 2971 path.lineTo(276, 7531); 2972 path.lineTo(277, 7531); 2973 path.lineTo(277.01001f, 9506); 2974 path.lineTo(276, 9506); 2975 path.close(); 2976 SkPath pathB; 2977 pathB.setFillType(SkPath::kWinding_FillType); 2978 pathB.moveTo(276, 7531); 2979 pathB.lineTo(277.01001f, 7531); 2980 pathB.lineTo(277, 9506); 2981 pathB.lineTo(276, 9506); 2982 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 2983 } 2984 2985 static void skpwww_defense_studies_blogspot_com_64(skiatest::Reporter* reporter, const char* filename) { 2986 SkPath path; 2987 path.setFillType(SkPath::kEvenOdd_FillType); 2988 path.moveTo(276, 9600); 2989 path.lineTo(276, 7703); 2990 path.lineTo(277, 7703); 2991 path.lineTo(277.01001f, 9600); 2992 path.lineTo(276, 9600); 2993 path.close(); 2994 SkPath pathB; 2995 pathB.setFillType(SkPath::kWinding_FillType); 2996 pathB.moveTo(276, 7703); 2997 pathB.lineTo(277.01001f, 7703); 2998 pathB.lineTo(277, 9600); 2999 pathB.lineTo(276, 9600); 3000 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3001 } 3002 3003 static void skpwww_uniquefx_net_442(skiatest::Reporter* reporter, const char* filename) { 3004 SkPath path; 3005 path.setFillType(SkPath::kEvenOdd_FillType); 3006 path.moveTo(960, 306); 3007 path.lineTo(960, 305); 3008 path.lineTo(1000, 305); 3009 path.lineTo(1000, 306.708527f); 3010 path.lineTo(960, 306); 3011 path.close(); 3012 SkPath pathB; 3013 pathB.setFillType(SkPath::kWinding_FillType); 3014 pathB.moveTo(960, 305); 3015 pathB.lineTo(958.997253f, 306.002747f); 3016 pathB.lineTo(1017, 307); 3017 pathB.lineTo(1019, 305); 3018 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3019 } 3020 3021 static void skpwww_kitcheninspirations_wordpress_com_32(skiatest::Reporter* reporter, const char* filename) { 3022 SkPath path; 3023 path.setFillType(SkPath::kEvenOdd_FillType); 3024 path.moveTo(47.1666679f, 19651.334f); 3025 path.lineTo(65.8333359f, 19651.332f); 3026 path.lineTo(65.8333359f, 19651.5f); 3027 path.lineTo(47.1666679f, 19651.5f); 3028 path.lineTo(47.1666679f, 19651.334f); 3029 path.close(); 3030 SkPath pathB; 3031 pathB.setFillType(SkPath::kWinding_FillType); 3032 pathB.moveTo(47.1666679f, 19651.5f); 3033 pathB.lineTo(47.1666679f, 19651.332f); 3034 pathB.lineTo(65.8333359f, 19651.334f); 3035 pathB.lineTo(65.8333359f, 19651.5f); 3036 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3037 } 3038 3039 static void skpwww_educationalcraft_com_4(skiatest::Reporter* reporter, const char* filename) { 3040 SkPath path; 3041 path.setFillType(SkPath::kEvenOdd_FillType); 3042 path.moveTo(941, 1494); 3043 path.lineTo(941, 1464); 3044 path.lineTo(985, 1464); 3045 path.lineTo(985, 1494); 3046 path.lineTo(941, 1494); 3047 path.close(); 3048 SkPath pathB; 3049 pathB.setFillType(SkPath::kWinding_FillType); 3050 pathB.moveTo(979.211975f, 1480.45496f); 3051 pathB.cubicTo(979.211975f, 1480.45496f, 976.348999f, 1479.68506f, 977.495972f, 1475.59497f); 3052 pathB.cubicTo(977.497009f, 1475.59497f, 981.072021f, 1477.88501f, 979.211975f, 1480.45496f); 3053 pathB.close(); 3054 pathB.moveTo(977.854004f, 1484.453f); 3055 pathB.cubicTo(977.854004f, 1484.453f, 975.265991f, 1483.26099f, 976.713989f, 1479.35205f); 3056 pathB.cubicTo(976.713989f, 1479.35303f, 979.84198f, 1482.23499f, 977.854004f, 1484.453f); 3057 pathB.close(); 3058 pathB.moveTo(980.226013f, 1476.229f); 3059 pathB.cubicTo(980.226013f, 1476.229f, 977.078003f, 1476.349f, 977.234985f, 1471.97095f); 3060 pathB.cubicTo(977.234985f, 1471.97095f, 980.666992f, 1473.12903f, 980.226013f, 1476.229f); 3061 pathB.close(); 3062 pathB.moveTo(984.546021f, 1478.31494f); 3063 pathB.cubicTo(984.546021f, 1478.31494f, 983.187988f, 1481.93396f, 980.026001f, 1481.276f); 3064 pathB.cubicTo(980.026978f, 1481.276f, 979.554993f, 1478.38904f, 984.546021f, 1478.31494f); 3065 pathB.close(); 3066 pathB.moveTo(978.989014f, 1484.198f); 3067 pathB.cubicTo(978.989014f, 1484.198f, 979.094971f, 1481.33496f, 983.786011f, 1481.823f); 3068 pathB.cubicTo(983.786011f, 1481.823f, 982.070007f, 1485.49805f, 978.989014f, 1484.198f); 3069 pathB.close(); 3070 pathB.moveTo(976.393005f, 1486.86804f); 3071 pathB.cubicTo(976.393005f, 1486.86804f, 976.719971f, 1484.06494f, 981.679016f, 1485.37f); 3072 pathB.cubicTo(981.679016f, 1485.37f, 979.169983f, 1488.40796f, 976.393005f, 1486.86804f); 3073 pathB.close(); 3074 pathB.moveTo(969.156982f, 1490.40002f); 3075 pathB.cubicTo(969.156982f, 1490.40002f, 971.478027f, 1488.23596f, 974.869995f, 1491.21399f); 3076 pathB.cubicTo(974.869995f, 1491.21497f, 970.828003f, 1493.026f, 969.156982f, 1490.40002f); 3077 pathB.close(); 3078 pathB.moveTo(972.825012f, 1483.93701f); 3079 pathB.cubicTo(972.825012f, 1483.93701f, 973.971985f, 1487.98401f, 971.161987f, 1488.94604f); 3080 pathB.cubicTo(971.161987f, 1488.94495f, 969.278015f, 1486.37097f, 972.825012f, 1483.93701f); 3081 pathB.close(); 3082 pathB.moveTo(965.60199f, 1489.98499f); 3083 pathB.cubicTo(965.60199f, 1489.98499f, 964.879028f, 1487.19202f, 969.864014f, 1486.75f); 3084 pathB.cubicTo(969.864014f, 1486.75f, 968.749023f, 1490.672f, 965.60199f, 1489.98499f); 3085 pathB.close(); 3086 pathB.moveTo(970.666992f, 1492.81604f); 3087 pathB.cubicTo(970.666992f, 1492.81604f, 967.327026f, 1494.49695f, 964.999023f, 1491.56299f); 3088 pathB.cubicTo(964.999023f, 1491.56299f, 967.304016f, 1489.43896f, 970.666992f, 1492.81604f); 3089 pathB.close(); 3090 pathB.moveTo(968.343994f, 1481.53796f); 3091 pathB.cubicTo(971.573975f, 1479.94995f, 971.687988f, 1476.78601f, 971.687988f, 1476.78601f); 3092 pathB.lineTo(971.393982f, 1466.83398f); 3093 pathB.lineTo(954.960999f, 1466.83398f); 3094 pathB.lineTo(954.666016f, 1476.78601f); 3095 pathB.cubicTo(954.666016f, 1476.78601f, 954.780029f, 1479.94995f, 958.008972f, 1481.53796f); 3096 pathB.cubicTo(960.781006f, 1482.90295f, 962.166992f, 1484.77698f, 962.166992f, 1484.77698f); 3097 pathB.cubicTo(962.166992f, 1484.77698f, 962.747986f, 1485.70105f, 963.177979f, 1485.70105f); 3098 pathB.cubicTo(963.606995f, 1485.70105f, 964.185974f, 1484.77698f, 964.185974f, 1484.77698f); 3099 pathB.cubicTo(964.185974f, 1484.77698f, 965.573975f, 1482.90295f, 968.343994f, 1481.53796f); 3100 pathB.close(); 3101 pathB.moveTo(963.215027f, 1486.67004f); 3102 pathB.cubicTo(962.744995f, 1486.67004f, 962.106995f, 1485.65405f, 962.106995f, 1485.65405f); 3103 pathB.cubicTo(962.106995f, 1485.65405f, 960.585022f, 1483.59595f, 957.539001f, 1482.09705f); 3104 pathB.cubicTo(953.991028f, 1480.35205f, 953.867004f, 1476.87598f, 953.867004f, 1476.87598f); 3105 pathB.lineTo(954.190002f, 1465.94397f); 3106 pathB.lineTo(972.23999f, 1465.94397f); 3107 pathB.lineTo(972.565002f, 1476.87695f); 3108 pathB.cubicTo(972.565002f, 1476.87695f, 972.440979f, 1480.35303f, 968.891968f, 1482.09802f); 3109 pathB.cubicTo(965.846008f, 1483.59705f, 964.325012f, 1485.65503f, 964.325012f, 1485.65503f); 3110 pathB.cubicTo(964.325012f, 1485.65503f, 963.687012f, 1486.67004f, 963.215027f, 1486.67004f); 3111 pathB.close(); 3112 pathB.moveTo(960.68103f, 1489.98499f); 3113 pathB.cubicTo(957.533997f, 1490.672f, 956.417969f, 1486.75f, 956.417969f, 1486.75f); 3114 pathB.cubicTo(961.403015f, 1487.19202f, 960.68103f, 1489.98499f, 960.68103f, 1489.98499f); 3115 pathB.close(); 3116 pathB.moveTo(963.143005f, 1489.59802f); 3117 pathB.cubicTo(963.763f, 1489.59802f, 964.265015f, 1490.09998f, 964.265015f, 1490.72095f); 3118 pathB.cubicTo(964.265015f, 1491.34204f, 963.763f, 1491.84399f, 963.143005f, 1491.84399f); 3119 pathB.cubicTo(962.521973f, 1491.84399f, 962.02002f, 1491.34204f, 962.02002f, 1490.72095f); 3120 pathB.cubicTo(962.02002f, 1490.09998f, 962.521973f, 1489.59802f, 963.143005f, 1489.59802f); 3121 pathB.close(); 3122 pathB.moveTo(961.283997f, 1491.56299f); 3123 pathB.cubicTo(958.953979f, 1494.49695f, 955.61499f, 1492.81604f, 955.61499f, 1492.81604f); 3124 pathB.cubicTo(958.97699f, 1489.43896f, 961.283997f, 1491.56299f, 961.283997f, 1491.56299f); 3125 pathB.close(); 3126 pathB.moveTo(957.127014f, 1490.40002f); 3127 pathB.cubicTo(955.455017f, 1493.026f, 951.414001f, 1491.21399f, 951.414001f, 1491.21399f); 3128 pathB.cubicTo(954.802979f, 1488.23596f, 957.127014f, 1490.40002f, 957.127014f, 1490.40002f); 3129 pathB.close(); 3130 pathB.moveTo(949.890991f, 1486.86804f); 3131 pathB.cubicTo(947.112976f, 1488.40796f, 944.604004f, 1485.37f, 944.604004f, 1485.37f); 3132 pathB.cubicTo(949.562012f, 1484.06494f, 949.890991f, 1486.86804f, 949.890991f, 1486.86804f); 3133 pathB.close(); 3134 pathB.moveTo(947.070984f, 1480.45496f); 3135 pathB.cubicTo(945.211975f, 1477.88501f, 948.786011f, 1475.59497f, 948.786011f, 1475.59497f); 3136 pathB.cubicTo(949.934021f, 1479.68506f, 947.070984f, 1480.45496f, 947.070984f, 1480.45496f); 3137 pathB.close(); 3138 pathB.moveTo(946.054016f, 1476.229f); 3139 pathB.cubicTo(945.61499f, 1473.12903f, 949.046997f, 1471.97095f, 949.046997f, 1471.97095f); 3140 pathB.cubicTo(949.205994f, 1476.349f, 946.054016f, 1476.229f, 946.054016f, 1476.229f); 3141 pathB.close(); 3142 pathB.moveTo(948.427002f, 1484.453f); 3143 pathB.cubicTo(946.440002f, 1482.23499f, 949.567993f, 1479.35205f, 949.567993f, 1479.35205f); 3144 pathB.cubicTo(951.015991f, 1483.26099f, 948.427002f, 1484.453f, 948.427002f, 1484.453f); 3145 pathB.close(); 3146 pathB.moveTo(947.294006f, 1484.198f); 3147 pathB.cubicTo(944.210999f, 1485.49805f, 942.495972f, 1481.823f, 942.495972f, 1481.823f); 3148 pathB.cubicTo(947.187988f, 1481.33496f, 947.294006f, 1484.198f, 947.294006f, 1484.198f); 3149 pathB.close(); 3150 pathB.moveTo(946.255005f, 1481.276f); 3151 pathB.cubicTo(943.094971f, 1481.93396f, 941.736023f, 1478.31494f, 941.736023f, 1478.31494f); 3152 pathB.cubicTo(946.728027f, 1478.38904f, 946.255005f, 1481.276f, 946.255005f, 1481.276f); 3153 pathB.close(); 3154 pathB.moveTo(945.312988f, 1478.18005f); 3155 pathB.cubicTo(942.052979f, 1477.80103f, 942.651001f, 1473.87805f, 942.651001f, 1473.87805f); 3156 pathB.cubicTo(946.562988f, 1475.66199f, 945.312988f, 1478.18005f, 945.312988f, 1478.18005f); 3157 pathB.close(); 3158 pathB.moveTo(945.382019f, 1474.328f); 3159 pathB.cubicTo(942.924011f, 1472.729f, 944.492004f, 1469.48706f, 944.492004f, 1469.48706f); 3160 pathB.cubicTo(947.388977f, 1471.95703f, 945.382019f, 1474.328f, 945.382019f, 1474.328f); 3161 pathB.close(); 3162 pathB.moveTo(946.797974f, 1470.27405f); 3163 pathB.cubicTo(944.664978f, 1467.90198f, 947.083984f, 1465.50598f, 947.083984f, 1465.50598f); 3164 pathB.cubicTo(949.145996f, 1468.82605f, 946.797974f, 1470.27405f, 946.797974f, 1470.27405f); 3165 pathB.close(); 3166 pathB.moveTo(947.392029f, 1471.64197f); 3167 pathB.cubicTo(947.624023f, 1468.56299f, 951.361023f, 1468.29199f, 951.361023f, 1468.29199f); 3168 pathB.cubicTo(950.554016f, 1471.98499f, 947.392029f, 1471.64197f, 947.392029f, 1471.64197f); 3169 pathB.close(); 3170 pathB.moveTo(948.64801f, 1468.15002f); 3171 pathB.cubicTo(948.638977f, 1465.22095f, 952.265991f, 1464.46399f, 952.265991f, 1464.46399f); 3172 pathB.cubicTo(951.672974f, 1468.53101f, 948.64801f, 1468.15002f, 948.64801f, 1468.15002f); 3173 pathB.close(); 3174 pathB.moveTo(951.176025f, 1486.97803f); 3175 pathB.cubicTo(948.963013f, 1484.62f, 951.361023f, 1481.77698f, 951.361023f, 1481.77698f); 3176 pathB.cubicTo(953.734985f, 1485.48596f, 951.176025f, 1486.97803f, 951.176025f, 1486.97803f); 3177 pathB.close(); 3178 pathB.moveTo(947.51001f, 1488.53101f); 3179 pathB.cubicTo(947.51001f, 1488.53101f, 951.596985f, 1486.32202f, 953.234009f, 1489.08997f); 3180 pathB.cubicTo(953.234009f, 1489.08997f, 951.158997f, 1491.03601f, 947.51001f, 1488.53101f); 3181 pathB.close(); 3182 pathB.moveTo(955.120972f, 1488.94495f); 3183 pathB.cubicTo(952.309021f, 1487.98303f, 953.458984f, 1483.93604f, 953.458984f, 1483.93604f); 3184 pathB.cubicTo(957.004028f, 1486.37097f, 955.120972f, 1488.94495f, 955.120972f, 1488.94495f); 3185 pathB.close(); 3186 pathB.moveTo(978.770996f, 1488.53101f); 3187 pathB.cubicTo(975.122986f, 1491.03601f, 973.047974f, 1489.08997f, 973.047974f, 1489.08997f); 3188 pathB.cubicTo(974.684998f, 1486.32202f, 978.770996f, 1488.53101f, 978.770996f, 1488.53101f); 3189 pathB.close(); 3190 pathB.moveTo(975.106995f, 1486.97803f); 3191 pathB.cubicTo(975.106995f, 1486.97803f, 972.546997f, 1485.48706f, 974.919983f, 1481.77698f); 3192 pathB.cubicTo(974.919983f, 1481.776f, 977.31897f, 1484.61902f, 975.106995f, 1486.97803f); 3193 pathB.close(); 3194 pathB.moveTo(974.016968f, 1464.46399f); 3195 pathB.cubicTo(974.016968f, 1464.46399f, 977.643982f, 1465.22095f, 977.633972f, 1468.15002f); 3196 pathB.cubicTo(977.633972f, 1468.15002f, 974.611023f, 1468.53101f, 974.016968f, 1464.46399f); 3197 pathB.close(); 3198 pathB.moveTo(974.919983f, 1468.29199f); 3199 pathB.cubicTo(974.919983f, 1468.29199f, 978.658997f, 1468.56299f, 978.890015f, 1471.64197f); 3200 pathB.cubicTo(978.890015f, 1471.64197f, 975.72699f, 1471.98499f, 974.919983f, 1468.29199f); 3201 pathB.close(); 3202 pathB.moveTo(979.197998f, 1465.50598f); 3203 pathB.cubicTo(979.197998f, 1465.50598f, 981.619019f, 1467.90198f, 979.481995f, 1470.27405f); 3204 pathB.cubicTo(979.481995f, 1470.27405f, 977.138f, 1468.82605f, 979.197998f, 1465.50598f); 3205 pathB.close(); 3206 pathB.moveTo(980.900024f, 1474.328f); 3207 pathB.cubicTo(980.900024f, 1474.328f, 978.893005f, 1471.95703f, 981.791016f, 1469.48706f); 3208 pathB.cubicTo(981.791016f, 1469.48596f, 983.358032f, 1472.729f, 980.900024f, 1474.328f); 3209 pathB.close(); 3210 pathB.moveTo(980.968994f, 1478.18005f); 3211 pathB.cubicTo(980.968994f, 1478.18005f, 979.718018f, 1475.66199f, 983.632019f, 1473.87805f); 3212 pathB.cubicTo(983.632019f, 1473.87805f, 984.229004f, 1477.80103f, 980.968994f, 1478.18005f); 3213 pathB.close(); 3214 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3215 } 3216 3217 static void skpwww_narayana_publishers_com_194(skiatest::Reporter* reporter, const char* filename) { 3218 SkPath path; 3219 path.setFillType(SkPath::kEvenOdd_FillType); 3220 path.moveTo(1083.34314f, 445.65686f); 3221 path.quadTo(1081, 443.313721f, 1081, 440); 3222 path.lineTo(1257, 440); 3223 path.quadTo(1257, 443.313721f, 1254.65686f, 445.65686f); 3224 path.quadTo(1252.31372f, 448, 1249, 448); 3225 path.lineTo(1089, 448); 3226 path.quadTo(1085.68628f, 448, 1083.34314f, 445.65686f); 3227 path.close(); 3228 path.moveTo(1083, 441); 3229 path.lineTo(1255, 441); 3230 path.quadTo(1255, 443.071075f, 1253.53552f, 444.535522f); 3231 path.quadTo(1252.07104f, 446, 1250, 446); 3232 path.lineTo(1088, 446); 3233 path.quadTo(1085.92896f, 446, 1084.46448f, 444.535522f); 3234 path.quadTo(1083, 443.071075f, 1083, 441); 3235 path.close(); 3236 SkPath pathB; 3237 pathB.setFillType(SkPath::kWinding_FillType); 3238 pathB.moveTo(1081, 440); 3239 pathB.lineTo(1082, 440); 3240 pathB.lineTo(1090.01001f, 448); 3241 pathB.lineTo(1081, 448); 3242 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3243 } 3244 3245 static void skpwww_cooksnaps_com_17(skiatest::Reporter* reporter, const char* filename) { 3246 SkPath path; 3247 path.setFillType(SkPath::kEvenOdd_FillType); 3248 path.moveTo(170.340179f, 176); 3249 path.lineTo(166, 176); 3250 path.quadTo(161.964188f, 176, 158.299957f, 176.896912f); 3251 path.quadTo(154.678162f, 177.952271f, 151.183014f, 179.9702f); 3252 path.lineTo(150.316986f, 180.4702f); 3253 path.quadTo(146.175812f, 182.861099f, 143.115921f, 186.081696f); 3254 path.quadTo(140.693939f, 188.70134f, 138.99472f, 191.620407f); 3255 path.quadTo(137.316833f, 194.550888f, 136.259338f, 197.957367f); 3256 path.quadTo(135, 202.217865f, 135, 207); 3257 path.lineTo(135, 208); 3258 path.quadTo(135, 212.035751f, 135.896912f, 215.699997f); 3259 path.quadTo(136.952286f, 219.321869f, 138.9702f, 222.816986f); 3260 path.lineTo(139.4702f, 223.683014f); 3261 path.quadTo(141.861099f, 227.824188f, 145.081696f, 230.884079f); 3262 path.quadTo(147.70134f, 233.306061f, 150.620407f, 235.00528f); 3263 path.quadTo(153.550888f, 236.683167f, 156.957367f, 237.740662f); 3264 path.quadTo(161.217865f, 239, 166, 239); 3265 path.lineTo(170.482162f, 239); 3266 path.quadTo(176.307037f, 238.210968f, 181.816986f, 235.0298f); 3267 path.lineTo(182.683014f, 234.5298f); 3268 path.quadTo(182.686462f, 234.527817f, 182.689896f, 234.525818f); 3269 path.quadTo(193.804352f, 228.105652f, 197.126709f, 215.70639f); 3270 path.quadTo(200.450104f, 203.303314f, 194.0298f, 192.183014f); 3271 path.lineTo(193.5298f, 191.316986f); 3272 path.quadTo(187.109497f, 180.196686f, 174.706406f, 176.873276f); 3273 path.quadTo(172.503067f, 176.282898f, 170.340179f, 176); 3274 path.close(); 3275 SkPath pathB; 3276 pathB.setFillType(SkPath::kWinding_FillType); 3277 pathB.moveTo(139.4702f, 223.683014f); 3278 pathB.lineTo(138.9702f, 222.816986f); 3279 pathB.quadTo(132.549896f, 211.696686f, 135.873291f, 199.293594f); 3280 pathB.quadTo(139.196686f, 186.890503f, 150.316986f, 180.4702f); 3281 pathB.lineTo(151.183014f, 179.9702f); 3282 pathB.quadTo(162.303314f, 173.549896f, 174.706406f, 176.873276f); 3283 pathB.quadTo(187.109497f, 180.196686f, 193.5298f, 191.316986f); 3284 pathB.lineTo(194.0298f, 192.183014f); 3285 pathB.quadTo(200.450104f, 203.303314f, 197.126709f, 215.70639f); 3286 pathB.quadTo(193.803314f, 228.109497f, 182.683014f, 234.5298f); 3287 pathB.lineTo(181.816986f, 235.0298f); 3288 pathB.quadTo(170.696686f, 241.450104f, 158.293594f, 238.126709f); 3289 pathB.quadTo(145.890503f, 234.803314f, 139.4702f, 223.683014f); 3290 pathB.close(); 3291 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3292 } 3293 3294 static void skpwww_swapspacesystems_com_5(skiatest::Reporter* reporter, const char* filename) { 3295 SkPath path; 3296 path.setFillType(SkPath::kEvenOdd_FillType); 3297 path.moveTo(819.050781f, 5539.72412f); 3298 path.quadTo(819.651672f, 5539.1543f, 820.479858f, 5539.17578f); 3299 path.lineTo(1191.35278f, 5548.8877f); 3300 path.quadTo(1192.18091f, 5548.90918f, 1192.7511f, 5549.50977f); 3301 path.quadTo(1193.32141f, 5550.11133f, 1193.29968f, 5550.93945f); 3302 path.lineTo(1186.57214f, 5807.85107f); 3303 path.quadTo(1186.55054f, 5808.6792f, 1185.94958f, 5809.24951f); 3304 path.quadTo(1185.34863f, 5809.81982f, 1184.52051f, 5809.79834f); 3305 path.lineTo(813.647705f, 5800.08643f); 3306 path.quadTo(812.819519f, 5800.06494f, 812.249268f, 5799.46387f); 3307 path.quadTo(811.679016f, 5798.86279f, 811.700684f, 5798.03467f); 3308 path.lineTo(818.428162f, 5541.12305f); 3309 path.quadTo(818.44989f, 5540.29492f, 819.050781f, 5539.72412f); 3310 path.close(); 3311 SkPath pathB; 3312 pathB.setFillType(SkPath::kWinding_FillType); 3313 pathB.moveTo(818.48053f, 5539.12354f); 3314 pathB.lineTo(1193.35205f, 5548.93994f); 3315 pathB.lineTo(1186.5199f, 5809.85059f); 3316 pathB.lineTo(811.648376f, 5800.03418f); 3317 pathB.close(); 3318 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3319 } 3320 3321 static void skpwww_kitcheninspirations_wordpress_com_66(skiatest::Reporter* reporter, const char* filename) { 3322 SkPath path; 3323 path.setFillType(SkPath::kEvenOdd_FillType); 3324 path.moveTo(47.1666679f, 27820.668f); 3325 path.lineTo(60.8333359f, 27820.668f); 3326 path.lineTo(60.8333359f, 27820.498f); 3327 path.lineTo(47.1666679f, 27820.5f); 3328 path.lineTo(47.1666679f, 27820.668f); 3329 path.close(); 3330 SkPath pathB; 3331 pathB.setFillType(SkPath::kWinding_FillType); 3332 pathB.moveTo(47.1666679f, 27820.668f); 3333 pathB.lineTo(47.1666679f, 27820.498f); 3334 pathB.lineTo(60.8333359f, 27820.5f); 3335 pathB.lineTo(60.8333359f, 27820.668f); 3336 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3337 } 3338 3339 static void skpwww_etiqadd_com_2464(skiatest::Reporter* reporter, const char* filename) { 3340 SkPath path; 3341 path.setFillType(SkPath::kEvenOdd_FillType); 3342 path.moveTo(630.378662f, 1293.42896f); 3343 path.quadTo(631.257385f, 1292.55029f, 632.5f, 1292.55029f); 3344 path.quadTo(633.742615f, 1292.55029f, 634.621338f, 1293.42896f); 3345 path.lineTo(639.571045f, 1298.37866f); 3346 path.quadTo(640.449768f, 1299.25732f, 640.449707f, 1300.5f); 3347 path.quadTo(640.449768f, 1301.74268f, 639.571045f, 1302.62134f); 3348 path.lineTo(634.621338f, 1307.57104f); 3349 path.quadTo(633.742615f, 1308.44971f, 632.5f, 1308.44971f); 3350 path.quadTo(631.257385f, 1308.44971f, 630.378662f, 1307.57104f); 3351 path.lineTo(625.428955f, 1302.62134f); 3352 path.quadTo(624.550232f, 1301.74268f, 624.550293f, 1300.5f); 3353 path.quadTo(624.550232f, 1299.25732f, 625.428955f, 1298.37866f); 3354 path.lineTo(630.378662f, 1293.42896f); 3355 path.close(); 3356 SkPath pathB; 3357 pathB.setFillType(SkPath::kWinding_FillType); 3358 pathB.moveTo(632.5f, 1291.30762f); 3359 pathB.lineTo(641.692383f, 1300.5f); 3360 pathB.lineTo(632.5f, 1309.69238f); 3361 pathB.lineTo(623.307617f, 1300.5f); 3362 pathB.close(); 3363 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3364 } 3365 3366 static void skpwww_narayana_verlag_de_194(skiatest::Reporter* reporter, const char* filename) { 3367 SkPath path; 3368 path.setFillType(SkPath::kEvenOdd_FillType); 3369 path.moveTo(1083.34314f, 513.65686f); 3370 path.quadTo(1081, 511.313721f, 1081, 508); 3371 path.lineTo(1257, 508); 3372 path.quadTo(1257, 511.313721f, 1254.65686f, 513.65686f); 3373 path.quadTo(1252.31372f, 516, 1249, 516); 3374 path.lineTo(1089, 516); 3375 path.quadTo(1085.68628f, 516, 1083.34314f, 513.65686f); 3376 path.close(); 3377 path.moveTo(1083, 509); 3378 path.lineTo(1255, 509); 3379 path.quadTo(1255, 511.071075f, 1253.53552f, 512.535522f); 3380 path.quadTo(1252.07104f, 514, 1250, 514); 3381 path.lineTo(1088, 514); 3382 path.quadTo(1085.92896f, 514, 1084.46448f, 512.535522f); 3383 path.quadTo(1083, 511.071075f, 1083, 509); 3384 path.close(); 3385 SkPath pathB; 3386 pathB.setFillType(SkPath::kWinding_FillType); 3387 pathB.moveTo(1081, 508); 3388 pathB.lineTo(1082, 508); 3389 pathB.lineTo(1090.01001f, 516); 3390 pathB.lineTo(1081, 516); 3391 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3392 } 3393 3394 static void skpwww_americascup_com_108(skiatest::Reporter* reporter, const char* filename) { 3395 SkPath path; 3396 path.setFillType(SkPath::kEvenOdd_FillType); 3397 path.moveTo(999.454102f, 689.17157f); 3398 path.quadTo(1001.172f, 688, 1002.82886f, 688); 3399 path.lineTo(1013.82886f, 688); 3400 path.lineTo(1002.17114f, 713); 3401 path.lineTo(991.171143f, 713); 3402 path.quadTo(989.514282f, 713, 988.889038f, 711.82843f); 3403 path.quadTo(988.263794f, 710.65686f, 989.036377f, 709); 3404 path.lineTo(996.963623f, 692); 3405 path.quadTo(997.736206f, 690.34314f, 999.454102f, 689.17157f); 3406 path.close(); 3407 SkPath pathB; 3408 pathB.setFillType(SkPath::kWinding_FillType); 3409 pathB.moveTo(998.828857f, 688); 3410 pathB.lineTo(1013.82886f, 688); 3411 pathB.lineTo(1002.17114f, 713); 3412 pathB.lineTo(987.171143f, 713); 3413 pathB.close(); 3414 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3415 } 3416 3417 static void skpwww_vantageproduction_com_109(skiatest::Reporter* reporter, const char* filename) { 3418 SkPath path; 3419 path.setFillType(SkPath::kEvenOdd_FillType); 3420 path.moveTo(794.514709f, 759.485291f); 3421 path.quadTo(791, 755.970581f, 791, 751); 3422 path.lineTo(1133, 751); 3423 path.quadTo(1133, 755.970581f, 1129.48523f, 759.485291f); 3424 path.quadTo(1125.97058f, 763, 1121, 763); 3425 path.lineTo(803, 763); 3426 path.quadTo(798.029419f, 763, 794.514709f, 759.485291f); 3427 path.close(); 3428 path.moveTo(793, 752); 3429 path.lineTo(1131, 752); 3430 path.quadTo(1131, 755.727905f, 1128.36401f, 758.363953f); 3431 path.quadTo(1125.72791f, 761, 1122, 761); 3432 path.lineTo(802, 761); 3433 path.quadTo(798.272095f, 761, 795.636047f, 758.363953f); 3434 path.quadTo(793, 755.727905f, 793, 752); 3435 path.close(); 3436 SkPath pathB; 3437 pathB.setFillType(SkPath::kWinding_FillType); 3438 pathB.moveTo(791, 751); 3439 pathB.lineTo(792, 751); 3440 pathB.lineTo(804.01001f, 763); 3441 pathB.lineTo(791, 763); 3442 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3443 } 3444 3445 static void skpwww_aceinfographics_com_106(skiatest::Reporter* reporter, const char* filename) { 3446 SkPath path; 3447 path.setFillType(SkPath::kEvenOdd_FillType); 3448 path.moveTo(166.878677f, 7638.87891f); 3449 path.quadTo(166, 7639.75732f, 166, 7641); 3450 path.lineTo(166, 11577); 3451 path.quadTo(166, 11578.2422f, 166.878677f, 11579.1211f); 3452 path.quadTo(167.388f, 11579.6309f, 168.019989f, 11579.8447f); 3453 path.lineTo(168.019974f, 11576.2979f); 3454 path.quadTo(168, 11576.1533f, 168, 11576); 3455 path.lineTo(168, 7642); 3456 path.lineTo(168.000015f, 7641.99316f); 3457 path.lineTo(168, 7640); 3458 path.lineTo(166.878677f, 7638.87891f); 3459 path.close(); 3460 SkPath pathB; 3461 pathB.setFillType(SkPath::kWinding_FillType); 3462 pathB.moveTo(166, 7638); 3463 pathB.lineTo(168.020004f, 7635.97998f); 3464 pathB.lineTo(168, 11578); 3465 pathB.lineTo(166, 11580); 3466 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3467 } 3468 3469 static void skpwww_tcmevents_org_13(skiatest::Reporter* reporter, const char* filename) { 3470 SkPath path; 3471 path.setFillType(SkPath::kEvenOdd_FillType); 3472 path.moveTo(465.951904f, 547.960144f); 3473 path.quadTo(465.66571f, 546.867371f, 465.404938f, 546); 3474 path.lineTo(465.504089f, 546); 3475 path.quadTo(465.670349f, 546.601257f, 465.84668f, 547.288391f); 3476 path.quadTo(467.274506f, 552.852356f, 468.506836f, 560.718567f); 3477 path.quadTo(467.336121f, 553.24585f, 465.951904f, 547.960144f); 3478 path.close(); 3479 path.moveTo(470.591064f, 574.024353f); 3480 path.quadTo(474.844055f, 601.176025f, 471.728271f, 620.364502f); 3481 path.quadTo(470.567017f, 627.515991f, 468.635742f, 632); 3482 path.lineTo(469.106812f, 632); 3483 path.quadTo(470.791504f, 627.638672f, 471.833496f, 621.036255f); 3484 path.quadTo(474.905701f, 601.569519f, 470.591064f, 574.024353f); 3485 path.close(); 3486 SkPath pathB; 3487 pathB.setFillType(SkPath::kWinding_FillType); 3488 pathB.moveTo(322.992462f, 541.475708f); 3489 pathB.lineTo(465.531616f, 541.724426f); 3490 pathB.lineTo(468.507751f, 560.724426f); 3491 pathB.lineTo(325.968597f, 560.475708f); 3492 pathB.close(); 3493 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3494 } 3495 3496 static void skpwww_paseoitaigara_com_br_56(skiatest::Reporter* reporter, const char* filename) { 3497 SkPath path; 3498 path.setFillType(SkPath::kEvenOdd_FillType); 3499 path.moveTo(633.147217f, 1247); 3500 path.lineTo(718, 1162.14722f); 3501 path.lineTo(802.852783f, 1247); 3502 path.lineTo(718, 1331.85278f); 3503 path.lineTo(633.147217f, 1247); 3504 path.close(); 3505 SkPath pathB; 3506 pathB.setFillType(SkPath::kWinding_FillType); 3507 pathB.moveTo(635.268494f, 1244.87866f); 3508 pathB.lineTo(715.878662f, 1164.26855f); 3509 pathB.quadTo(716.757385f, 1163.38989f, 718, 1163.38989f); 3510 pathB.quadTo(719.242615f, 1163.38989f, 720.121338f, 1164.26855f); 3511 pathB.lineTo(800.731506f, 1244.87866f); 3512 pathB.quadTo(801.610168f, 1245.75732f, 801.610168f, 1247); 3513 pathB.quadTo(801.610229f, 1248.24268f, 800.731445f, 1249.12134f); 3514 pathB.lineTo(720.121338f, 1329.73145f); 3515 pathB.quadTo(719.242676f, 1330.61011f, 718, 1330.61011f); 3516 pathB.quadTo(716.757385f, 1330.61011f, 715.878723f, 1329.73145f); 3517 pathB.lineTo(635.268555f, 1249.12134f); 3518 pathB.quadTo(634.389832f, 1248.24268f, 634.389832f, 1247); 3519 pathB.quadTo(634.389832f, 1245.75732f, 635.268494f, 1244.87866f); 3520 pathB.close(); 3521 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3522 } 3523 3524 static void skpwww_mortgagemarketguide_com_109(skiatest::Reporter* reporter, const char* filename) { 3525 SkPath path; 3526 path.setFillType(SkPath::kEvenOdd_FillType); 3527 path.moveTo(816.514709f, 781.485291f); 3528 path.quadTo(813, 777.970581f, 813, 773); 3529 path.lineTo(1133, 773); 3530 path.quadTo(1133, 777.970581f, 1129.48523f, 781.485291f); 3531 path.quadTo(1125.97058f, 785, 1121, 785); 3532 path.lineTo(825, 785); 3533 path.quadTo(820.029419f, 785, 816.514709f, 781.485291f); 3534 path.close(); 3535 path.moveTo(815, 774); 3536 path.lineTo(1131, 774); 3537 path.quadTo(1131, 777.727905f, 1128.36401f, 780.363953f); 3538 path.quadTo(1125.72791f, 783, 1122, 783); 3539 path.lineTo(824, 783); 3540 path.quadTo(820.272095f, 783, 817.636047f, 780.363953f); 3541 path.quadTo(815, 777.727905f, 815, 774); 3542 path.close(); 3543 SkPath pathB; 3544 pathB.setFillType(SkPath::kWinding_FillType); 3545 pathB.moveTo(813, 773); 3546 pathB.lineTo(814, 773); 3547 pathB.lineTo(826.01001f, 785); 3548 pathB.lineTo(813, 785); 3549 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3550 } 3551 3552 static void skpwww_9to5mac_com_64(skiatest::Reporter* reporter, const char* filename) { 3553 SkPath path; 3554 path.setFillType(SkPath::kEvenOdd_FillType); 3555 path.moveTo(365, 5101); 3556 path.lineTo(365, 5082); 3557 path.lineTo(366, 5083); 3558 path.lineTo(367, 5092.96631f); 3559 path.lineTo(367, 5100); 3560 path.quadTo(367, 5101.50537f, 367.967712f, 5102.61084f); 3561 path.lineTo(368.278717f, 5105.71045f); 3562 path.quadTo(367.277618f, 5105.34863f, 366.464478f, 5104.53564f); 3563 path.quadTo(365, 5103.07129f, 365, 5101); 3564 path.close(); 3565 SkPath pathB; 3566 pathB.setFillType(SkPath::kWinding_FillType); 3567 pathB.moveTo(365, 5082); 3568 pathB.lineTo(365.848175f, 5081.15186f); 3569 pathB.lineTo(368, 5103); 3570 pathB.lineTo(365, 5106); 3571 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3572 } 3573 3574 static void skpwww_googleventures_com_32(skiatest::Reporter* reporter, const char* filename) { 3575 SkPath path; 3576 path.setFillType(SkPath::kEvenOdd_FillType); 3577 path.moveTo(725.911682f, 898.767456f); 3578 path.lineTo(741.232544f, 885.911682f); 3579 path.lineTo(754.088318f, 901.232544f); 3580 path.lineTo(738.767456f, 914.088318f); 3581 path.lineTo(725.911682f, 898.767456f); 3582 path.close(); 3583 SkPath pathB; 3584 pathB.setFillType(SkPath::kWinding_FillType); 3585 pathB.moveTo(728.37677f, 870.59082f); 3586 pathB.lineTo(754.088257f, 901.232605f); 3587 pathB.lineTo(738.767395f, 914.088379f); 3588 pathB.lineTo(713.055908f, 883.446594f); 3589 pathB.close(); 3590 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3591 } 3592 3593 #if TEST_NEW_FAILURES 3594 static void skpwww_devbridge_com_22(skiatest::Reporter* reporter, const char* filename) { 3595 SkPath path; 3596 path.setFillType(SkPath::kEvenOdd_FillType); 3597 path.moveTo(4915, 1523); 3598 path.quadTo(4887.24756f, 1523, 4867.62402f, 1542.6239f); 3599 path.quadTo(4848, 1562.24768f, 4848, 1590); 3600 path.quadTo(4848, 1617.75232f, 4867.62402f, 1637.3761f); 3601 path.quadTo(4887.24756f, 1657, 4915, 1657); 3602 path.quadTo(4942.75244f, 1657, 4962.37598f, 1637.3761f); 3603 path.quadTo(4982, 1617.75232f, 4982, 1590); 3604 path.quadTo(4982, 1562.24768f, 4962.37598f, 1542.6239f); 3605 path.quadTo(4942.75244f, 1523, 4915, 1523); 3606 path.close(); 3607 SkPath pathB; 3608 pathB.setFillType(SkPath::kWinding_FillType); 3609 pathB.moveTo(4981.99902f, 1590); 3610 pathB.quadTo(4981.99902f, 1617.75232f, 4962.375f, 1637.3761f); 3611 pathB.quadTo(4942.75146f, 1657, 4914.99902f, 1657); 3612 pathB.quadTo(4887.24658f, 1657, 4867.62305f, 1637.3761f); 3613 pathB.quadTo(4847.99902f, 1617.75232f, 4847.99902f, 1590); 3614 pathB.quadTo(4847.99902f, 1562.24768f, 4867.62305f, 1542.6239f); 3615 pathB.quadTo(4887.24658f, 1523, 4914.99902f, 1523); 3616 pathB.quadTo(4942.75146f, 1523, 4962.375f, 1542.6239f); 3617 pathB.quadTo(4981.99902f, 1562.24768f, 4981.99902f, 1590); 3618 pathB.close(); 3619 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3620 } 3621 3622 // cubic/quad intersection 3623 static void skpwww_alamdi_com_3(skiatest::Reporter* reporter, const char* filename) { 3624 SkPath path; 3625 path.setFillType(SkPath::kEvenOdd_FillType); 3626 path.moveTo(10210.8789f, 5315.87891f); 3627 path.quadTo(10211.7578f, 5315, 10213, 5315); 3628 path.lineTo(10230, 5315); 3629 path.quadTo(10231.2422f, 5315, 10232.1211f, 5315.87891f); 3630 path.quadTo(10233, 5316.75732f, 10233, 5318); 3631 path.lineTo(10233, 5338); 3632 path.quadTo(10233, 5339.24268f, 10232.1211f, 5340.12109f); 3633 path.quadTo(10231.2422f, 5341, 10230, 5341); 3634 path.lineTo(10213, 5341); 3635 path.quadTo(10211.7578f, 5341, 10210.8789f, 5340.12109f); 3636 path.quadTo(10210, 5339.24268f, 10210, 5338); 3637 path.lineTo(10210, 5318); 3638 path.quadTo(10210, 5316.75732f, 10210.8789f, 5315.87891f); 3639 path.close(); 3640 SkPath pathB; 3641 pathB.setFillType(SkPath::kEvenOdd_FillType); 3642 pathB.moveTo(10213, 5315); 3643 pathB.lineTo(10230, 5315); 3644 pathB.cubicTo(10231.6572f, 5315, 10233, 5316.34326f, 10233, 5318); 3645 pathB.lineTo(10233, 5338); 3646 pathB.cubicTo(10233, 5339.10449f, 10231.6572f, 5340, 10230, 5340); 3647 pathB.lineTo(10213, 5340); 3648 pathB.cubicTo(10211.3428f, 5340, 10210, 5339.10449f, 10210, 5338); 3649 pathB.lineTo(10210, 5318); 3650 pathB.cubicTo(10210, 5316.34326f, 10211.3428f, 5315, 10213, 5315); 3651 pathB.close(); 3652 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3653 } 3654 3655 // bumpSpan failed assertion "span->fOppValue >= 0" 3656 static void skpwww_familysurvivalprotocol_wordpress_com_61(skiatest::Reporter* reporter, const char* filename) { 3657 SkPath path; 3658 path.setFillType(SkPath::kEvenOdd_FillType); 3659 path.moveTo(143, 14557); 3660 path.lineTo(165, 14557); 3661 path.lineTo(165, 14555.9902f); 3662 path.lineTo(143, 14556); 3663 path.lineTo(143, 14557); 3664 path.close(); 3665 SkPath pathB; 3666 pathB.setFillType(SkPath::kWinding_FillType); 3667 pathB.moveTo(143, 14557); 3668 pathB.lineTo(143, 14555.9902f); 3669 pathB.lineTo(165, 14556); 3670 pathB.lineTo(165, 14557); 3671 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3672 } 3673 #endif 3674 3675 static void skpwww_firstunitedbank_com_19(skiatest::Reporter* reporter, const char* filename) { 3676 SkPath path; 3677 path.setFillType(SkPath::kEvenOdd_FillType); 3678 path.moveTo(808.585815f, 11673.5859f); 3679 path.quadTo(809.17157f, 11673, 810, 11673); 3680 path.lineTo(1032, 11673); 3681 path.quadTo(1038.21326f, 11673, 1042.60657f, 11677.3936f); 3682 path.quadTo(1047, 11681.7871f, 1047, 11688); 3683 path.quadTo(1047, 11682.2012f, 1042.60657f, 11678.1006f); 3684 path.quadTo(1038.21326f, 11674, 1032, 11674); 3685 path.lineTo(810, 11674); 3686 path.quadTo(809.585815f, 11674, 809.292908f, 11674.293f); 3687 path.quadTo(809, 11674.5859f, 809, 11675); 3688 path.lineTo(809, 11701); 3689 path.quadTo(809, 11701.4141f, 809.292908f, 11701.707f); 3690 path.quadTo(809.585815f, 11702, 810, 11702); 3691 path.lineTo(1032, 11702); 3692 path.quadTo(1038.21326f, 11702, 1042.60657f, 11697.8994f); 3693 path.quadTo(1047, 11693.7988f, 1047, 11688); 3694 path.quadTo(1047, 11694.2129f, 1042.60657f, 11698.6064f); 3695 path.quadTo(1038.21326f, 11703, 1032, 11703); 3696 path.lineTo(810, 11703); 3697 path.quadTo(809.17157f, 11703, 808.585815f, 11702.4141f); 3698 path.quadTo(808, 11701.8281f, 808, 11701); 3699 path.lineTo(808, 11675); 3700 path.quadTo(808, 11674.1719f, 808.585815f, 11673.5859f); 3701 path.close(); 3702 SkPath pathB; 3703 pathB.setFillType(SkPath::kWinding_FillType); 3704 pathB.moveTo(808, 11703); 3705 pathB.lineTo(809.5f, 11701.5f); 3706 pathB.lineTo(1062.91907f, 11687.0811f); 3707 pathB.lineTo(1047, 11703); 3708 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3709 } 3710 3711 // addSimpleAngle: failed assertion "index == count() - 2" 3712 static void skpwww_shinydemos_com_5(skiatest::Reporter* reporter, const char* filename) { 3713 SkPath path; 3714 path.setFillType(SkPath::kEvenOdd_FillType); 3715 path.moveTo(205.884888f, 648.203857f); 3716 path.lineTo(771.570374f, 82.5183716f); 3717 path.lineTo(1110.98169f, 421.929626f); 3718 path.lineTo(545.296143f, 987.615112f); 3719 path.lineTo(205.884888f, 648.203857f); 3720 path.close(); 3721 SkPath pathB; 3722 pathB.setFillType(SkPath::kWinding_FillType); 3723 pathB.moveTo(771.570374f, 82.5183716f); 3724 pathB.lineTo(1110.98169f, 421.929626f); 3725 pathB.lineTo(545.296204f, 987.615051f); 3726 pathB.lineTo(205.884949f, 648.203796f); 3727 pathB.close(); 3728 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3729 } 3730 3731 // addTCoincident oPeek = &other->fTs[++oPeekIndex]; 3732 static void skpwww_lptemp_com_3(skiatest::Reporter* reporter, const char* filename) { 3733 SkPath path; 3734 path.setFillType(SkPath::kEvenOdd_FillType); 3735 path.moveTo(78.6429825f, 1394.30969f); 3736 path.quadTo(79.6192932f, 1393.33337f, 81.0000076f, 1393.33337f); 3737 path.lineTo(341, 1393.33337f); 3738 path.quadTo(342.380707f, 1393.33337f, 343.357025f, 1394.30969f); 3739 path.quadTo(344.333344f, 1395.28601f, 344.333344f, 1396.66675f); 3740 path.lineTo(344.333344f, 1465.66663f); 3741 path.quadTo(344.333344f, 1467.04736f, 343.357025f, 1468.02368f); 3742 path.quadTo(342.380707f, 1469, 341, 1469); 3743 path.lineTo(81.0000076f, 1469); 3744 path.quadTo(79.6192932f, 1469, 78.6429825f, 1468.02368f); 3745 path.quadTo(77.6666718f, 1467.04736f, 77.6666718f, 1465.66663f); 3746 path.lineTo(77.6666718f, 1396.66675f); 3747 path.quadTo(77.6666718f, 1395.28601f, 78.6429825f, 1394.30969f); 3748 path.close(); 3749 SkPath pathB; 3750 pathB.setFillType(SkPath::kEvenOdd_FillType); 3751 pathB.moveTo(81, 1393.33337f); 3752 pathB.lineTo(341, 1393.33337f); 3753 pathB.cubicTo(342.840942f, 1393.33337f, 344.333344f, 1394.82568f, 344.333344f, 1396.66675f); 3754 pathB.lineTo(344.333344f, 1465.66675f); 3755 pathB.cubicTo(344.333344f, 1467.32361f, 342.840942f, 1468.66675f, 341, 1468.66675f); 3756 pathB.lineTo(81, 1468.66675f); 3757 pathB.cubicTo(79.15905f, 1468.66675f, 77.6666718f, 1467.32361f, 77.6666718f, 1465.66675f); 3758 pathB.lineTo(77.6666718f, 1396.66675f); 3759 pathB.cubicTo(77.6666718f, 1394.82568f, 79.15905f, 1393.33337f, 81, 1393.33337f); 3760 pathB.close(); 3761 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3762 } 3763 3764 #if TEST_NEW_FAILURES 3765 // SkOpSegment.cpp:3915: failed assertion "otherEnd >= 0" 3766 static void skpwww_shinydemos_com_15(skiatest::Reporter* reporter, const char* filename) { 3767 SkPath path; 3768 path.setFillType(SkPath::kEvenOdd_FillType); 3769 path.moveTo(1000, 310.947968f); 3770 path.lineTo(771.570374f, 82.5183716f); 3771 path.lineTo(205.884888f, 648.203857f); 3772 path.lineTo(448.68103f, 891); 3773 path.lineTo(641.911255f, 891); 3774 path.lineTo(1000, 532.911316f); 3775 path.lineTo(1000, 310.947968f); 3776 path.close(); 3777 SkPath pathB; 3778 pathB.setFillType(SkPath::kWinding_FillType); 3779 pathB.moveTo(771.570374f, 82.5183716f); 3780 pathB.lineTo(1110.98169f, 421.929626f); 3781 pathB.lineTo(545.296204f, 987.615051f); 3782 pathB.lineTo(205.884949f, 648.203796f); 3783 pathB.close(); 3784 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3785 } 3786 3787 // SkOpSegment.cpp:4398: failed assertion "!span->fDone" 3788 static void skpwww_lptemp_com_5(skiatest::Reporter* reporter, const char* filename) { 3789 SkPath path; 3790 path.setFillType(SkPath::kEvenOdd_FillType); 3791 path.moveTo(78.6429825f, 3150.97632f); 3792 path.quadTo(79.6192932f, 3150, 81.0000076f, 3150); 3793 path.lineTo(341, 3150); 3794 path.quadTo(342.380707f, 3150, 343.357025f, 3150.97632f); 3795 path.quadTo(344.333344f, 3151.95264f, 344.333344f, 3153.33325f); 3796 path.lineTo(344.333344f, 5205.3335f); 3797 path.quadTo(344.333344f, 5206.71436f, 343.357025f, 5207.69092f); 3798 path.quadTo(342.380707f, 5208.66699f, 341, 5208.66699f); 3799 path.lineTo(81.0000076f, 5208.66699f); 3800 path.quadTo(79.6192932f, 5208.66699f, 78.6429825f, 5207.69092f); 3801 path.quadTo(77.6666718f, 5206.71436f, 77.6666718f, 5205.3335f); 3802 path.lineTo(77.6666718f, 3153.33325f); 3803 path.quadTo(77.6666718f, 3151.95264f, 78.6429825f, 3150.97632f); 3804 path.close(); 3805 SkPath pathB; 3806 pathB.setFillType(SkPath::kEvenOdd_FillType); 3807 pathB.moveTo(81, 3150); 3808 pathB.lineTo(341, 3150); 3809 pathB.cubicTo(342.840942f, 3150, 344.333344f, 3151.49268f, 344.333344f, 3153.3335f); 3810 pathB.lineTo(344.333344f, 5205.3335f); 3811 pathB.cubicTo(344.333344f, 5206.99023f, 342.840942f, 5208.3335f, 341, 5208.3335f); 3812 pathB.lineTo(81, 5208.3335f); 3813 pathB.cubicTo(79.15905f, 5208.3335f, 77.6666718f, 5206.99023f, 77.6666718f, 5205.3335f); 3814 pathB.lineTo(77.6666718f, 3153.3335f); 3815 pathB.cubicTo(77.6666718f, 3151.49268f, 79.15905f, 3150, 81, 3150); 3816 pathB.close(); 3817 testPathOp(reporter, path, pathB, kIntersect_PathOp, filename); 3818 } 3819 #endif 3820 3821 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0; 3822 3823 static struct TestDesc tests[] = { 3824 TEST(skpwww_lptemp_com_3), 3825 TEST(skpwww_shinydemos_com_5), 3826 #if TEST_NEW_FAILURES 3827 TEST(skpwww_lptemp_com_5), 3828 TEST(skpwww_shinydemos_com_15), 3829 TEST(skpwww_familysurvivalprotocol_wordpress_com_61), 3830 TEST(skpwww_alamdi_com_3), 3831 TEST(skpwww_devbridge_com_22), 3832 #endif 3833 TEST(skpwww_firstunitedbank_com_19), 3834 TEST(skpwww_googleventures_com_32), 3835 TEST(skpwww_9to5mac_com_64), 3836 TEST(skpwww_wartepop_blogspot_com_br_6), 3837 TEST(skpwww_wartepop_blogspot_com_br_6a), 3838 TEST(skpwww_cooksnaps_com_32a), 3839 TEST(skpwww_argus_presse_fr_41), 3840 TEST(skpwww_cooksnaps_com_17), 3841 TEST(skpwww_cooksnaps_com_32), 3842 TEST(skpwww_kitcheninspirations_wordpress_com_66), 3843 TEST(skpwww_tcmevents_org_13), 3844 TEST(skpwww_narayana_publishers_com_194), 3845 TEST(skpwww_swapspacesystems_com_5), 3846 TEST(skpwww_vantageproduction_com_109), 3847 TEST(skpwww_americascup_com_108), 3848 TEST(skpwww_narayana_verlag_de_194), 3849 TEST(skpwww_etiqadd_com_2464), 3850 TEST(skpwww_paseoitaigara_com_br_56), 3851 TEST(skpwww_mortgagemarketguide_com_109), 3852 TEST(skpwww_aceinfographics_com_106), 3853 TEST(skpwww_educationalcraft_com_4), 3854 TEST(skpwww_kitcheninspirations_wordpress_com_32), 3855 TEST(skpwww_artblart_com_8), 3856 TEST(skpwww_docgelo_com_66), 3857 TEST(skpwww_uniquefx_net_442), 3858 TEST(skpwww_defense_studies_blogspot_com_64), 3859 TEST(skpwww_kenlevine_blogspot_com_28), 3860 TEST(skpwww_fashionscandal_com_94), 3861 TEST(skpwww_thaienews_blogspot_com_36), 3862 TEST(skpwww_galaxystwo_com_4), 3863 TEST(skpwww_catingueiraonline_com_352), 3864 TEST(skpwww_evolvehq_com_210), 3865 TEST(skpwww_odia_com_br_26), 3866 TEST(skpwww_lokado_de_173), 3867 TEST(skpwww_seopack_blogspot_com_2153), 3868 TEST(skpwww_partsdata_de_53), 3869 TEST(skpwww_simplysaru_com_40), 3870 TEST(skpwww_jessicaslens_wordpress_com_222), 3871 TEST(skpwww_kpopexplorer_net_22), 3872 TEST(skpwww_tunero_de_24), 3873 TEST(skpwww_karnivool_com_au_11), 3874 TEST(skpwww_pindosiya_com_99), 3875 TEST(skpwww_contextualnewsfeeds_com_346), 3876 TEST(skpwww_helha_be_109), 3877 TEST(skpwww_phototransferapp_com_24), 3878 TEST(skpwww_phototransferapp_com_24x), 3879 TEST(skpwww_gruposejaumdivulgador_com_br_4), 3880 TEST(skpwww_hubbyscook_com_22), 3881 TEST(skpwww_maturesupertube_com_21), 3882 TEST(skpwww_getgold_jp_731), 3883 TEST(skpwww_trashness_com_36), 3884 TEST(skpwww_exystence_net_61), 3885 TEST(skpwww_320kbps_net_2231), 3886 TEST(skpwww_heartiste_wordpress_com_86), 3887 TEST(skpwww_hairjobsearch_com_31), 3888 TEST(skpwww_alucinados_net_101), 3889 TEST(skpnamecheap_com_405), 3890 TEST(skpelpais_com_18), 3891 TEST(skpwww_cityads_ru_249), 3892 TEST(skpwww_alrakoba_net_62), 3893 TEST(skpwww_dealnews_com_315), 3894 TEST(skpwww_inmotionhosting_com_9), 3895 TEST(skpskpicture14), 3896 TEST(skpskpicture15), 3897 TEST(skpwww_meb_gov_tr_6), 3898 TEST(skpwww_sciality_com_101), 3899 TEST(skpwww_booking_com_68), 3900 TEST(skpwww_despegar_com_mx_272), 3901 TEST(skpwww_lavoixdunord_fr_11), 3902 TEST(skppptv_com_62), 3903 TEST(skppchappy_com_au102), 3904 TEST(skpsciality_com161), 3905 TEST(skpi_gino_com16), 3906 TEST(skpnaoxrane_ru23), 3907 TEST(skptcmevents_org23), 3908 TEST(skpredbullskatearcade_es16), 3909 TEST(skpfinanzasdigital_com9), 3910 TEST(skpgithub_io_26), 3911 TEST(skpgithub_io_25), 3912 TEST(skpwww_meb_gov_tr_5), 3913 TEST(skpwww_sciality_com_100), 3914 TEST(skpwww_joomla_org_23), 3915 TEST(skpwww_macrumors_com_131), 3916 TEST(skpwww_briian_com_34), 3917 TEST(skpwww_leadpages_net_84), 3918 TEST(skpwww_fj_p_com_22), 3919 TEST(skppartainasdemo250_org56), 3920 TEST(skpsd_graphic_net104), 3921 TEST(skpbreakmystyle_com10), 3922 TEST(skpnational_com_au81), 3923 TEST(skprentacheat_com30), 3924 TEST(skptracksflow_com9), 3925 TEST(skpautobutler_dk29), 3926 TEST(skponlinecollege_org144), 3927 TEST(skphostloco_com11), 3928 TEST(skpsergeychunkevich_com8), 3929 TEST(skpmlk_com326), 3930 TEST(skpcyclist_friends_gr52), 3931 TEST(skpfrauen_magazin_com83), 3932 TEST(skpthesuburbanite_com213), 3933 TEST(skpsudoestenegocios_com186), 3934 TEST(skpmtrk_uz27), 3935 TEST(skpilkoora_com37), 3936 TEST(skpmm4everfriends_com43), 3937 TEST(skpflite_com41), 3938 TEST(skpcheeseandburger_com225), 3939 TEST(skpeverytechpro_blogspot_com100), 3940 }; 3941 3942 static const size_t testCount = SK_ARRAY_COUNT(tests); 3943 3944 static bool runReverse = false; 3945 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0; 3946 3947 DEF_TEST(PathOpsSkp, reporter) { 3948 #if DEBUG_SHOW_TEST_NAME 3949 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 3950 #endif 3951 RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse); 3952 } 3953
