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