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) { 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); 370 } 371 372 static void skpeverytechpro_blogspot_com100(skiatest::Reporter* reporter) { 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); 404 } 405 406 static void skpflite_com41(skiatest::Reporter* reporter) { 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); 427 } 428 429 static void skpilkoora_com37(skiatest::Reporter* reporter) { 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); 459 } 460 461 static void skpmm4everfriends_com43(skiatest::Reporter* reporter) { 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); 482 } 483 484 static void skpmtrk_uz27(skiatest::Reporter* reporter) { 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); 509 } 510 511 static void skpfrauen_magazin_com83(skiatest::Reporter* reporter) { 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); 533 } 534 535 #define TRY_BROKEN_TESTS 0 536 #if TRY_BROKEN_TESTS 537 static void skpi_gino_com16(skiatest::Reporter* reporter) { 538 SkPath path; 539 path.setFillType(SkPath::kEvenOdd_FillType); 540 path.moveTo(184, 734); 541 path.quadTo(133.051727f, 734, 97.0258636f, 770.025879f); 542 path.quadTo(61, 806.051758f, 61, 857); 543 path.quadTo(61, 895.835083f, 81.9317017f, 926); 544 path.lineTo(286.068298f, 926); 545 path.quadTo(307, 895.835083f, 307, 857); 546 path.quadTo(307, 806.051758f, 270.974121f, 770.025879f); 547 path.quadTo(234.948273f, 734, 184, 734); 548 path.close(); 549 SkPath pathB; 550 pathB.setFillType(SkPath::kWinding_FillType); 551 pathB.moveTo(185, 734); 552 pathB.cubicTo(252.93103f, 734, 308, 789.06897f, 308, 857); 553 pathB.cubicTo(308, 924.93103f, 252.93103f, 980, 185, 980); 554 pathB.lineTo(184, 980); 555 pathB.cubicTo(116.068977f, 980, 61, 924.93103f, 61, 857); 556 pathB.cubicTo(61, 789.06897f, 116.068977f, 734, 184, 734); 557 pathB.lineTo(185, 734); 558 pathB.close(); 559 testPathOp(reporter, path, pathB, kIntersect_PathOp); 560 } 561 562 static void skppchappy_com_au102(skiatest::Reporter* reporter) { 563 SkPath path; 564 path.setFillType(SkPath::kEvenOdd_FillType); 565 path.moveTo(363, 493); 566 path.cubicTo(360.790863f, 493, 359, 494.790863f, 359, 497); 567 path.lineTo(359, 656); 568 path.cubicTo(359, 658.209106f, 360.790863f, 660, 363, 660); 569 path.lineTo(623.001709f, 660); 570 path.cubicTo(624.657776f, 659.999023f, 626, 658.65625f, 626, 657); 571 path.lineTo(626, 496); 572 path.cubicTo(626, 494.343872f, 624.657959f, 493.00116f, 623.002075f, 493); 573 path.lineTo(363, 493); 574 path.close(); 575 SkPath pathB; 576 pathB.setFillType(SkPath::kInverseWinding_FillType); 577 pathB.moveTo(362, 494); 578 pathB.lineTo(623, 494); 579 pathB.cubicTo(624.65686f, 494, 626, 494.895416f, 626, 496); 580 pathB.lineTo(626, 657); 581 pathB.cubicTo(626, 658.65686f, 624.65686f, 660, 623, 660); 582 pathB.lineTo(362, 660); 583 pathB.cubicTo(360.34314f, 660, 359, 658.65686f, 359, 657); 584 pathB.lineTo(359, 496); 585 pathB.cubicTo(359, 494.895416f, 360.34314f, 494, 362, 494); 586 pathB.close(); 587 testPathOp(reporter, path, pathB, kIntersect_PathOp); 588 } 589 590 static void skpsciality_com161(skiatest::Reporter* reporter) { 591 SkPath path; 592 path.setFillType(SkPath::kEvenOdd_FillType); 593 path.moveTo(656, 728); 594 path.cubicTo(653.790833f, 728, 652, 729.790833f, 652, 732); 595 path.lineTo(652, 789); 596 path.cubicTo(652, 791.209106f, 653.790833f, 793, 656, 793); 597 path.lineTo(769.001282f, 793); 598 path.cubicTo(770.657532f, 792.999268f, 772, 791.656433f, 772, 790); 599 path.lineTo(772, 731); 600 path.cubicTo(772, 729.34314f, 770.65686f, 728, 769, 728); 601 path.lineTo(656, 728); 602 path.close(); 603 SkPath pathB; 604 pathB.setFillType(SkPath::kInverseWinding_FillType); 605 pathB.moveTo(655, 729); 606 pathB.lineTo(769, 729); 607 pathB.cubicTo(770.65686f, 729, 772, 729.895447f, 772, 731); 608 pathB.lineTo(772, 790); 609 pathB.cubicTo(772, 791.65686f, 770.65686f, 793, 769, 793); 610 pathB.lineTo(655, 793); 611 pathB.cubicTo(653.34314f, 793, 652, 791.65686f, 652, 790); 612 pathB.lineTo(652, 731); 613 pathB.cubicTo(652, 729.895447f, 653.34314f, 729, 655, 729); 614 pathB.close(); 615 testPathOp(reporter, path, pathB, kIntersect_PathOp); 616 } 617 #endif 618 619 static void skpsudoestenegocios_com186(skiatest::Reporter* reporter) { 620 SkPath path; 621 path.setFillType(SkPath::kEvenOdd_FillType); 622 path.moveTo(0, 495); 623 path.lineTo(1.23685242e-14f, 293); 624 path.lineTo(44, 293); 625 path.quadTo(45.6568527f, 293, 46.8288002f, 294.171204f); 626 path.quadTo(48, 295.34314f, 48, 297); 627 path.lineTo(48, 491); 628 path.quadTo(48, 492.65686f, 46.8288002f, 493.828796f); 629 path.quadTo(45.6568527f, 495, 44, 495); 630 path.lineTo(0, 495); 631 path.close(); 632 path.moveTo(1, 294); 633 path.lineTo(44, 294); 634 path.cubicTo(45.6568565f, 294, 47, 295.34314f, 47, 297); 635 path.lineTo(47, 491); 636 path.cubicTo(47, 492.65686f, 45.6568565f, 494, 44, 494); 637 path.lineTo(1, 494); 638 path.lineTo(1, 294); 639 path.close(); 640 SkPath pathB; 641 pathB.setFillType(SkPath::kWinding_FillType); 642 pathB.moveTo(48, 495); 643 pathB.lineTo(24, 471); 644 pathB.lineTo(24, 317); 645 pathB.lineTo(48, 293); 646 testPathOp(reporter, path, pathB, kIntersect_PathOp); 647 } 648 649 static void skpthesuburbanite_com213(skiatest::Reporter* reporter) { 650 SkPath path; 651 path.setFillType(SkPath::kEvenOdd_FillType); 652 path.moveTo(863.439026f, 692); 653 path.lineTo(863.283264f, 692); 654 path.lineTo(802, 708.420837f); 655 path.lineTo(802, 718.773621f); 656 path.lineTo(866, 701.624817f); 657 path.lineTo(866, 701.557922f); 658 path.lineTo(863.439026f, 692); 659 path.close(); 660 SkPath pathB; 661 pathB.setFillType(SkPath::kWinding_FillType); 662 pathB.moveTo(783.256775f, 713.443054f); 663 pathB.lineTo(863.428589f, 691.96106f); 664 pathB.lineTo(866.016724f, 701.620361f); 665 pathB.lineTo(785.84491f, 723.102356f); 666 pathB.close(); 667 testPathOp(reporter, path, pathB, kIntersect_PathOp); 668 } 669 670 static void skphostloco_com11(skiatest::Reporter* reporter) { 671 SkPath path; 672 path.setFillType(SkPath::kEvenOdd_FillType); 673 path.moveTo(6.66133815e-16f, 648); 674 path.lineTo(25.8522835f, 648); 675 path.quadTo(27.5087376f, 647.999634f, 28.6807098f, 646.82843f); 676 path.quadTo(29.8518829f, 645.656433f, 29.8522835f, 644); 677 path.lineTo(29.8522835f, 467); 678 path.quadTo(29.8518829f, 465.343536f, 28.6807098f, 464.17157f); 679 path.quadTo(27.5087376f, 463.000397f, 25.8522835f, 463); 680 path.lineTo(2.22044605e-16f, 463); 681 path.lineTo(6.66133815e-16f, 648); 682 path.close(); 683 SkPath pathB; 684 pathB.setFillType(SkPath::kWinding_FillType); 685 pathB.moveTo(0, 463); 686 pathB.lineTo(30, 463); 687 pathB.lineTo(30, 648); 688 pathB.lineTo(0, 648); 689 pathB.close(); 690 testPathOp(reporter, path, pathB, kIntersect_PathOp); 691 } 692 693 static void skpsergeychunkevich_com8(skiatest::Reporter* reporter) { 694 SkPath path; 695 path.setFillType(SkPath::kEvenOdd_FillType); 696 path.moveTo(0, 926); 697 path.lineTo(0, 0); 698 path.lineTo(1265, 0); 699 path.lineTo(1265, 926); 700 path.lineTo(0, 926); 701 path.close(); 702 SkPath pathB; 703 pathB.setFillType(SkPath::kInverseWinding_FillType); 704 pathB.moveTo(37, 374); 705 pathB.lineTo(37, 535); 706 pathB.cubicTo(37, 536.65686f, 35.6568565f, 538, 34, 538); 707 pathB.lineTo(1.02866934e-14f, 538); 708 pathB.lineTo(6.12303177e-17f, 371); 709 pathB.lineTo(34, 371); 710 pathB.cubicTo(35.6568565f, 371, 37, 372.34314f, 37, 374); 711 pathB.close(); 712 testPathOp(reporter, path, pathB, kIntersect_PathOp); 713 } 714 715 static void skptracksflow_com9(skiatest::Reporter* reporter) { 716 SkPath path; 717 path.setFillType(SkPath::kEvenOdd_FillType); 718 path.moveTo(16, 56); 719 path.lineTo(32, 56); 720 path.lineTo(32, 72); 721 path.lineTo(16, 72); 722 path.lineTo(16, 56); 723 path.close(); 724 SkPath pathB; 725 pathB.setFillType(SkPath::kEvenOdd_FillType); 726 pathB.moveTo(31.65625f, 70.0555649f); 727 pathB.lineTo(31.65625f, 70.0554962f); 728 pathB.lineTo(26.9727192f, 65.3615341f); 729 pathB.cubicTo(27.6210003f, 64.4029694f, 28.0048752f, 63.2470932f, 28.0048752f, 62.0027809f); 730 pathB.cubicTo(28.0048752f, 58.6875305f, 25.3199062f, 56, 22.0046558f, 56); 731 pathB.cubicTo(18.6894073f, 56, 16.0031872f, 58.6875305f, 16.0031872f, 62.0027809f); 732 pathB.cubicTo(16.0031872f, 65.3180008f, 18.6913433f, 68.0055618f, 22.0066261f, 68.0055618f); 733 pathB.cubicTo(23.2509995f, 68.0055618f, 24.4072189f, 67.6187515f, 25.3657818f, 66.9704056f); 734 pathB.lineTo(30.0599365f, 71.65625f); 735 pathB.lineTo(30.0600014f, 71.65625f); 736 pathB.cubicTo(30.2668133f, 71.875f, 30.5524693f, 71.9992828f, 30.868f, 71.9992828f); 737 pathB.cubicTo(31.4994049f, 71.9992828f, 32.0014687f, 71.4909363f, 32.0014687f, 70.8595276f); 738 pathB.cubicTo(32.0015335f, 70.5439072f, 31.875f, 70.2623444f, 31.65625f, 70.0555649f); 739 pathB.close(); 740 pathB.moveTo(18.0054054f, 62.0027809f); 741 pathB.cubicTo(18.0054054f, 59.7925949f, 19.7970943f, 58.0009079f, 22.0072823f, 58.0009079f); 742 pathB.cubicTo(24.2174377f, 58.0009079f, 26.0091248f, 59.7925949f, 26.0091248f, 62.0027809f); 743 pathB.cubicTo(26.0091248f, 64.2129364f, 24.2174377f, 66.0046234f, 22.0072803f, 66.0046234f); 744 pathB.cubicTo(19.7970943f, 66.0045929f, 18.0054054f, 64.2129059f, 18.0054054f, 62.0027809f); 745 pathB.close(); 746 testPathOp(reporter, path, pathB, kIntersect_PathOp); 747 } 748 749 static void skpautobutler_dk29(skiatest::Reporter* reporter) { 750 SkPath path; 751 path.setFillType(SkPath::kEvenOdd_FillType); 752 path.moveTo(0, 926); 753 path.lineTo(0, 0); 754 path.lineTo(1265, 0); 755 path.lineTo(1265, 926); 756 path.lineTo(0, 926); 757 path.close(); 758 SkPath pathB; 759 pathB.setFillType(SkPath::kWinding_FillType); 760 pathB.moveTo(21, 162); 761 pathB.lineTo(21, 301); 762 pathB.lineTo(8.57224448e-15f, 301); 763 pathB.lineTo(6.12303177e-17f, 162); 764 pathB.close(); 765 testPathOp(reporter, path, pathB, kIntersect_PathOp); 766 } 767 768 static void skponlinecollege_org144(skiatest::Reporter* reporter) { 769 SkPath path; 770 path.setFillType(SkPath::kEvenOdd_FillType); 771 path.moveTo(179, 407); 772 path.cubicTo(177.34314f, 407, 176, 408.34314f, 176, 410); 773 path.lineTo(176, 436); 774 path.cubicTo(176, 437.65686f, 177.34314f, 439, 179, 439); 775 path.lineTo(337.002289f, 439); 776 path.cubicTo(338.105835f, 438.998779f, 339, 438.103821f, 339, 437); 777 path.lineTo(339, 409); 778 path.cubicTo(339, 407.896362f, 338.10611f, 407.001526f, 337.002838f, 407); 779 path.lineTo(179, 407); 780 path.close(); 781 SkPath pathB; 782 pathB.setFillType(SkPath::kInverseWinding_FillType); 783 pathB.moveTo(179, 408); 784 pathB.lineTo(337, 408); 785 pathB.cubicTo(338.65686f, 408, 340, 408.895416f, 340, 410); 786 pathB.lineTo(340, 436); 787 pathB.cubicTo(340, 437.65686f, 338.65686f, 439, 337, 439); 788 pathB.lineTo(179, 439); 789 pathB.cubicTo(177.895432f, 439, 177, 437.65686f, 177, 436); 790 pathB.lineTo(177, 410); 791 pathB.cubicTo(177, 408.895416f, 177.895432f, 408, 179, 408); 792 pathB.close(); 793 testPathOp(reporter, path, pathB, kIntersect_PathOp); 794 } 795 796 static void skpnational_com_au81(skiatest::Reporter* reporter) { 797 SkPath path; 798 path.setFillType(SkPath::kEvenOdd_FillType); 799 path.moveTo(807, 817); 800 path.quadTo(806.585876f, 817.000122f, 806.292908f, 817.292908f); 801 path.quadTo(806.000122f, 817.585876f, 806, 818); 802 path.lineTo(806, 881); 803 path.lineTo(1111, 881); 804 path.lineTo(1111, 818); 805 path.quadTo(1110.99988f, 817.585876f, 1110.70715f, 817.292908f); 806 path.quadTo(1110.41406f, 817.000122f, 1110, 817); 807 path.lineTo(807, 817); 808 path.close(); 809 SkPath pathB; 810 pathB.setFillType(SkPath::kInverseWinding_FillType); 811 pathB.moveTo(807, 817); 812 pathB.lineTo(1110, 817); 813 pathB.cubicTo(1110.55225f, 817, 1111, 817.447693f, 1111, 818); 814 pathB.lineTo(1111, 880); 815 pathB.lineTo(806, 880); 816 pathB.lineTo(806, 818); 817 pathB.cubicTo(806, 817.447693f, 806.447693f, 817, 807, 817); 818 pathB.close(); 819 testPathOp(reporter, path, pathB, kIntersect_PathOp); 820 } 821 822 static void skprentacheat_com30(skiatest::Reporter* reporter) { 823 SkPath path; 824 path.setFillType(SkPath::kEvenOdd_FillType); 825 path.moveTo(967, 263); 826 path.quadTo(966.585876f, 263.000092f, 966.292908f, 263.292908f); 827 path.quadTo(966.000122f, 263.585876f, 966, 264); 828 path.lineTo(966, 301); 829 path.lineTo(1214, 301); 830 path.lineTo(1214, 264); 831 path.quadTo(1213.99988f, 263.585876f, 1213.70715f, 263.292908f); 832 path.quadTo(1213.41406f, 263.000092f, 1213, 263); 833 path.lineTo(967, 263); 834 path.close(); 835 SkPath pathB; 836 pathB.setFillType(SkPath::kInverseWinding_FillType); 837 pathB.moveTo(967, 263); 838 pathB.lineTo(1213, 263); 839 pathB.cubicTo(1213.55225f, 263, 1214, 263.447723f, 1214, 264); 840 pathB.lineTo(1214, 300); 841 pathB.lineTo(966, 300); 842 pathB.lineTo(966, 264); 843 pathB.cubicTo(966, 263.447723f, 966.447693f, 263, 967, 263); 844 pathB.close(); 845 testPathOp(reporter, path, pathB, kIntersect_PathOp); 846 } 847 848 static void skpbreakmystyle_com10(skiatest::Reporter* reporter) { 849 SkPath path; 850 path.setFillType(SkPath::kEvenOdd_FillType); 851 path.moveTo(271.032867f, -5.32907052e-15f); 852 path.lineTo(56.9671326f, -5.16253706e-15f); 853 path.quadTo(52.7835083f, 3.69968891f, 48.7416f, 7.74160004f); 854 path.quadTo(1, 55.4831848f, 1, 123); 855 path.quadTo(1, 190.516815f, 48.7416f, 238.258392f); 856 path.quadTo(96.4831848f, 286, 164, 286); 857 path.quadTo(231.516815f, 286, 279.258392f, 238.258392f); 858 path.quadTo(327, 190.516815f, 327, 123); 859 path.quadTo(327, 55.4831848f, 279.258392f, 7.74160004f); 860 path.quadTo(275.216431f, 3.69964004f, 271.032867f, -5.32907052e-15f); 861 path.close(); 862 SkPath pathB; 863 pathB.setFillType(SkPath::kWinding_FillType); 864 pathB.moveTo(327, 123); 865 pathB.quadTo(327, 190.516815f, 279.258392f, 238.258392f); 866 pathB.quadTo(231.516815f, 286, 164, 286); 867 pathB.quadTo(96.4831848f, 286, 48.7416f, 238.258392f); 868 pathB.quadTo(1, 190.516815f, 1, 123); 869 pathB.quadTo(1, 55.4831848f, 48.7416f, 7.74160004f); 870 pathB.quadTo(96.4831848f, -40, 164, -40); 871 pathB.quadTo(231.516815f, -40, 279.258392f, 7.74160004f); 872 pathB.quadTo(327, 55.4831848f, 327, 123); 873 pathB.close(); 874 testPathOp(reporter, path, pathB, kIntersect_PathOp); 875 } 876 877 static void skpsd_graphic_net104(skiatest::Reporter* reporter) { 878 SkPath path; 879 path.setFillType(SkPath::kEvenOdd_FillType); 880 path.moveTo(475.421448f, 836.985962f); 881 path.lineTo(461.280975f, 841.990662f); 882 path.cubicTo(466.80899f, 857.609802f, 458.62854f, 874.752991f, 443.009399f, 880.281006f); 883 path.cubicTo(435.199829f, 883.044983f, 427.009247f, 882.381897f, 420.080048f, 879.075378f); 884 path.lineTo(413.620056f, 892.613037f); 885 path.quadTo(430.419983f, 900.629761f, 447.96701f, 894.43811f); 886 path.quadTo(448.00708f, 894.42395f, 448.014038f, 894.421509f); 887 path.quadTo(448.043976f, 894.410889f, 448.061066f, 894.404846f); 888 path.quadTo(465.596313f, 888.179932f, 473.613037f, 871.379944f); 889 path.quadTo(477.351227f, 863.546143f, 478, 855.549866f); 890 path.lineTo(478, 848.804321f); 891 path.quadTo(477.528076f, 842.93811f, 475.421448f, 836.985962f); 892 path.close(); 893 SkPath pathB; 894 pathB.setFillType(SkPath::kWinding_FillType); 895 pathB.moveTo(405.592621f, 909.435547f); 896 pathB.lineTo(390.578583f, 867.014099f); 897 pathB.lineTo(433, 852.000061f); 898 pathB.lineTo(490.435486f, 879.40741f); 899 testPathOp(reporter, path, pathB, kIntersect_PathOp); 900 } 901 902 #if TRY_BROKEN_TESTS 903 /* this cubic/quad pair 904 c = 430,280 430,278.895416 473.876068,278 528,278 905 q = 430,280 430.009796,277.101196 458.703552,275.050262 906 only intersect at the shared point (430,280) 907 they sort backwards because the tangent from pt[0] to control pt[1] 908 c' = (0.00000000000000000, -1.1045837402343750) 909 q' = (0.0097961425781250000, -2.8988037109375000) 910 suggests that the quad is counterclockwise of the cubic, when the reverse is true 911 the angle code is fooled because the control pt[1] of both the quad and cubic 912 is far away from cubic cntl [2] and quad pt [2]. 913 Maybe in angle setup, this instability can be detected to suppress sorting on the initial tangent 914 Or the error term can be passed to NearRay that is magnified by the distance from the next ctrl? 915 */ 916 static void skpnaoxrane_ru23(skiatest::Reporter* reporter) { 917 SkPath path; 918 path.setFillType(SkPath::kEvenOdd_FillType); 919 path.moveTo(458.703552f, 275.050262f); 920 path.quadTo(487.41687f, 273.000702f, 528, 273); 921 path.lineTo(529, 273); 922 path.quadTo(530.242371f, 273.000305f, 531.121338f, 273.878693f); 923 path.quadTo(531.999695f, 274.75766f, 532, 276); 924 path.lineTo(532, 378); 925 path.quadTo(531.990173f, 380.898804f, 503.296448f, 382.949738f); 926 path.quadTo(474.58313f, 384.999298f, 434, 385); 927 path.lineTo(433, 385); 928 path.quadTo(431.75766f, 384.999695f, 430.878693f, 384.121307f); 929 path.quadTo(430.000305f, 383.24234f, 430, 382); 930 path.lineTo(430, 280); 931 path.quadTo(430.009796f, 277.101196f, 458.703552f, 275.050262f); 932 path.close(); 933 SkPath pathB; 934 pathB.setFillType(SkPath::kInverseWinding_FillType); 935 pathB.moveTo(528, 278); 936 pathB.lineTo(529, 278); 937 pathB.cubicTo(530.65686f, 278, 532, 278, 532, 278); 938 pathB.lineTo(532, 378); 939 pathB.cubicTo(532, 379.104584f, 488.123932f, 380, 434, 380); 940 pathB.lineTo(433, 380); 941 pathB.cubicTo(431.34314f, 380, 430, 380, 430, 380); 942 pathB.lineTo(430, 280); 943 pathB.cubicTo(430, 278.895416f, 473.876068f, 278, 528, 278); 944 pathB.close(); 945 testPathOp(reporter, path, pathB, kIntersect_PathOp); 946 } 947 948 /* didn't investigate thoroughly, but looks to be missorting quad and cubic 949 {{468.507751,560.724426}, {467.275146,552.856262}, {465.84668,547.288391}} 950 {{463.779907,542.671143}, {464.829529,542.672974}, {466.946289,550.755676}, {468.507751,560.724426}} 951 decision maker is case 14 leftLessThanRight 952 */ 953 static void skptcmevents_org23(skiatest::Reporter* reporter) { 954 SkPath path; 955 path.setFillType(SkPath::kEvenOdd_FillType); 956 path.moveTo(465.503998f, 546); 957 path.lineTo(347, 546); 958 path.lineTo(347, 632); 959 path.lineTo(469.104248f, 632); 960 path.quadTo(470.79007f, 627.638672f, 471.833496f, 621.036255f); 961 path.quadTo(474.902588f, 601.562866f, 470.591064f, 574.024353f); 962 path.lineTo(468.507751f, 560.724426f); 963 path.quadTo(467.275146f, 552.856262f, 465.84668f, 547.288391f); 964 path.quadTo(465.670349f, 546.601501f, 465.503998f, 546); 965 path.close(); 966 SkPath pathB; 967 pathB.setFillType(SkPath::kInverseWinding_FillType); 968 pathB.moveTo(363.052246f, 542.495361f); 969 pathB.lineTo(463.779907f, 542.671143f); 970 pathB.cubicTo(464.829529f, 542.672974f, 466.946289f, 550.755676f, 468.507751f, 560.724426f); 971 pathB.lineTo(470.591064f, 574.024353f); 972 pathB.cubicTo(476.26178f, 610.226624f, 471.498932f, 639.557922f, 459.953003f, 639.537781f); 973 pathB.lineTo(368.727936f, 639.378601f); 974 pathB.cubicTo(351.933868f, 639.349304f, 337.053741f, 631.244324f, 335.492249f, 621.275574f); 975 pathB.lineTo(325.968597f, 560.475708f); 976 pathB.cubicTo(324.407104f, 550.506958f, 341.01001f, 542.456909f, 363.052246f, 542.495361f); 977 pathB.close(); 978 testPathOp(reporter, path, pathB, kIntersect_PathOp); 979 } 980 981 static void skpredbullskatearcade_es16(skiatest::Reporter* reporter) { 982 SkPath path; 983 path.setFillType(SkPath::kEvenOdd_FillType); 984 path.moveTo(936.765625f, 458.965302f); 985 path.cubicTo(937.028442f, 453.863251f, 933.145813f, 449.864502f, 928.093445f, 450.033905f); 986 path.lineTo(661.882263f, 458.958862f); 987 path.lineTo(661.875366f, 458.959106f); 988 path.cubicTo(656.828369f, 459.13205f, 652.525085f, 463.399719f, 652.258545f, 468.496124f); 989 path.lineTo(652.258179f, 468.503662f); 990 path.lineTo(649.021729f, 531.322754f); 991 path.cubicTo(648.75885f, 536.424805f, 652.641479f, 540.423523f, 657.693848f, 540.25415f); 992 path.lineTo(923.905029f, 531.329163f); 993 path.cubicTo(928.955017f, 531.159851f, 933.262268f, 526.890442f, 933.528809f, 521.791565f); 994 path.lineTo(933.529175f, 521.784363f); 995 path.lineTo(936.765625f, 458.965302f); 996 path.close(); 997 SkPath pathB; 998 pathB.setFillType(SkPath::kInverseWinding_FillType); 999 pathB.moveTo(661.882263f, 458.958862f); 1000 pathB.lineTo(928.093445f, 450.033905f); 1001 pathB.cubicTo(929.103882f, 450, 929.709961f, 454.108612f, 929.447144f, 459.210663f); 1002 pathB.lineTo(926.210693f, 522.029724f); 1003 pathB.cubicTo(926.079224f, 524.58075f, 925.153442f, 526.676208f, 924.143066f, 526.710083f); 1004 pathB.lineTo(657.931885f, 535.635071f); 1005 pathB.cubicTo(652.879456f, 535.804443f, 648.890259f, 533.873779f, 649.021729f, 531.322754f); 1006 pathB.lineTo(652.258179f, 468.503662f); 1007 pathB.cubicTo(652.520996f, 463.401611f, 656.829834f, 459.128235f, 661.882263f, 458.958862f); 1008 pathB.close(); 1009 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1010 } 1011 1012 static void skpfinanzasdigital_com9(skiatest::Reporter* reporter) { 1013 SkPath path; 1014 path.setFillType(SkPath::kEvenOdd_FillType); 1015 path.moveTo(156, 126); 1016 path.quadTo(154.343552f, 126.000397f, 153.17157f, 127.17157f); 1017 path.quadTo(152.000397f, 128.343552f, 152, 130); 1018 path.lineTo(152, 174); 1019 path.lineTo(1114, 174); 1020 path.lineTo(1114, 130); 1021 path.quadTo(1113.99963f, 128.343552f, 1112.82837f, 127.17157f); 1022 path.quadTo(1111.65649f, 126.000397f, 1110, 126); 1023 path.lineTo(156, 126); 1024 path.close(); 1025 SkPath pathB; 1026 pathB.setFillType(SkPath::kInverseWinding_FillType); 1027 pathB.moveTo(156, 126); 1028 pathB.lineTo(1110, 126); 1029 pathB.cubicTo(1111.65686f, 126, 1113, 127.790863f, 1113, 130); 1030 pathB.lineTo(1113, 174); 1031 pathB.lineTo(153, 174); 1032 pathB.lineTo(153, 130); 1033 pathB.cubicTo(153, 127.790863f, 154.34314f, 126, 156, 126); 1034 pathB.close(); 1035 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1036 } 1037 #endif 1038 1039 static void skppartainasdemo250_org56(skiatest::Reporter* reporter) { 1040 SkPath path; 1041 path.setFillType(SkPath::kEvenOdd_FillType); 1042 path.moveTo(182.000015f, 645); 1043 path.lineTo(182, 640); 1044 path.cubicTo(174.322327f, 640, 166.644669f, 637.071045f, 160.786804f, 631.213196f); 1045 path.cubicTo(149.071075f, 619.497437f, 149.071075f, 600.502563f, 160.786804f, 588.786804f); 1046 path.lineTo(157.251266f, 585.251221f); 1047 path.quadTo(147, 595.502502f, 147.000015f, 610); 1048 path.quadTo(147, 624.482605f, 157.230255f, 634.727722f); 1049 path.quadTo(157.251251f, 634.748779f, 157.251282f, 634.748779f); 1050 path.quadTo(157.282852f, 634.780334f, 157.272263f, 634.769775f); 1051 path.quadTo(167.517334f, 645, 182.000015f, 645); 1052 path.close(); 1053 SkPath pathB; 1054 pathB.setFillType(SkPath::kWinding_FillType); 1055 pathB.moveTo(182, 659.497498f); 1056 pathB.lineTo(206.748749f, 634.748718f); 1057 pathB.lineTo(182.000015f, 610); 1058 pathB.lineTo(132.502533f, 610); 1059 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1060 } 1061 1062 static void skpmlk_com326(skiatest::Reporter* reporter) { 1063 SkPath path; 1064 path.setFillType(SkPath::kEvenOdd_FillType); 1065 path.moveTo(154, 670); 1066 path.cubicTo(151.238571f, 670, 149, 672.238586f, 149, 675); 1067 path.lineTo(149, 710.001465f); 1068 path.cubicTo(149.000809f, 712.209961f, 150.791367f, 714, 153, 714); 1069 path.lineTo(189, 714); 1070 path.cubicTo(191.209137f, 714, 193, 712.209167f, 193, 710); 1071 path.lineTo(193, 675); 1072 path.cubicTo(193, 672.238586f, 190.761429f, 670, 188, 670); 1073 path.lineTo(154, 670); 1074 path.close(); 1075 SkPath pathB; 1076 pathB.setFillType(SkPath::kInverseWinding_FillType); 1077 pathB.moveTo(154, 671); 1078 pathB.lineTo(188, 671); 1079 pathB.cubicTo(190.761429f, 671, 193, 672.790833f, 193, 675); 1080 pathB.lineTo(193, 710); 1081 pathB.cubicTo(193, 712.761414f, 190.761429f, 715, 188, 715); 1082 pathB.lineTo(154, 715); 1083 pathB.cubicTo(151.238571f, 715, 149, 712.761414f, 149, 710); 1084 pathB.lineTo(149, 675); 1085 pathB.cubicTo(149, 672.790833f, 151.238571f, 671, 154, 671); 1086 pathB.close(); 1087 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1088 } 1089 1090 static void skpcyclist_friends_gr52(skiatest::Reporter* reporter) { 1091 SkPath path; 1092 path.setFillType(SkPath::kEvenOdd_FillType); 1093 path.moveTo(50, 182); 1094 path.lineTo(1215, 182); 1095 path.lineTo(1215, 202); 1096 path.quadTo(1214.99951f, 204.070572f, 1213.53552f, 205.535538f); 1097 path.quadTo(1212.07056f, 206.999496f, 1210, 207); 1098 path.lineTo(55, 207); 1099 path.quadTo(52.9294319f, 206.999496f, 51.4644661f, 205.535538f); 1100 path.quadTo(50.0004997f, 204.070572f, 50, 202); 1101 path.lineTo(50, 182); 1102 path.close(); 1103 SkPath pathB; 1104 pathB.setFillType(SkPath::kInverseWinding_FillType); 1105 pathB.moveTo(50, 183); 1106 pathB.lineTo(1215, 183); 1107 pathB.lineTo(1215, 202); 1108 pathB.cubicTo(1215, 204.761429f, 1212.76147f, 207, 1210, 207); 1109 pathB.lineTo(55, 207); 1110 pathB.cubicTo(52.238575f, 207, 50, 204.761429f, 50, 202); 1111 pathB.lineTo(50, 183); 1112 pathB.close(); 1113 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1114 } 1115 1116 /* cubic ends just above opp line */ 1117 static void skpwww_fj_p_com_22(skiatest::Reporter* reporter) { 1118 SkPath path; 1119 path.setFillType(SkPath::kEvenOdd_FillType); 1120 path.moveTo(172, 201); 1121 path.lineTo(172, 202); 1122 path.lineTo(220, 202); 1123 path.cubicTo(221.65686f, 202, 223, 200.65686f, 223, 199); 1124 path.cubicTo(223, 200.104568f, 221.65686f, 201, 220, 201); 1125 path.lineTo(172, 201); 1126 path.close(); 1127 SkPath pathB; 1128 pathB.setFillType(SkPath::kWinding_FillType); 1129 pathB.moveTo(161, 202); 1130 pathB.lineTo(161, 199); 1131 pathB.lineTo(223, 199.000015f); 1132 pathB.lineTo(223, 202); 1133 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1134 } 1135 1136 #define TRY_SEPT_BROKEN_TESTS 0 1137 #if TRY_SEPT_BROKEN_TESTS 1138 // pair of lines are not quite coincident, so sorting line/cubic fails (i think) 1139 static void skpwww_lavoixdunord_fr_11(skiatest::Reporter* reporter) { 1140 SkPath path; 1141 path.setFillType(SkPath::kEvenOdd_FillType); 1142 path.moveTo(806, 57); 1143 path.cubicTo(806, 55.3431473f, 807.34314f, 54, 809, 54); 1144 path.lineTo(930, 54); 1145 path.cubicTo(931.65686f, 54, 933, 55.3431473f, 933, 57); 1146 path.lineTo(933, 91); 1147 path.cubicTo(933, 92.6568527f, 931.65686f, 94, 930, 94); 1148 path.lineTo(809, 94); 1149 path.cubicTo(807.34314f, 94, 806, 92.6568527f, 806, 91); 1150 path.lineTo(806, 57); 1151 path.close(); 1152 path.moveTo(808, 58); 1153 path.cubicTo(808, 56.8954315f, 808.895447f, 56, 810, 56); 1154 path.lineTo(929, 56); 1155 path.cubicTo(930.104553f, 56, 931, 56.8954315f, 931, 58); 1156 path.lineTo(931, 90); 1157 path.cubicTo(931, 91.1045685f, 930.104553f, 92, 929, 92); 1158 path.lineTo(810, 92); 1159 path.cubicTo(808.895447f, 92, 808, 91.1045685f, 808, 90); 1160 path.lineTo(808, 58); 1161 path.close(); 1162 SkPath pathB; 1163 pathB.setFillType(SkPath::kWinding_FillType); 1164 pathB.moveTo(806, 54); 1165 pathB.lineTo(808, 56); 1166 pathB.lineTo(935.02002f, 56.0200005f); 1167 pathB.lineTo(933, 54); 1168 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1169 } 1170 1171 // pair of curves have nearly the same initial tangent but are sorting by 1172 // that alone sorts them incorrectly. Need to detect that tangents are nearly 1173 // identical and not reliable by themselves 1174 static void skppptv_com_62(skiatest::Reporter* reporter) { 1175 SkPath path; 1176 path.setFillType(SkPath::kEvenOdd_FillType); 1177 path.moveTo(173, 5342); 1178 path.quadTo(171.343536f, 5342.00049f, 170.17157f, 5343.17139f); 1179 path.quadTo(169.000397f, 5344.34375f, 169, 5346); 1180 path.lineTo(169, 5372); 1181 path.lineTo(234, 5372); 1182 path.lineTo(234, 5346); 1183 path.quadTo(233.999603f, 5344.34375f, 232.82843f, 5343.17139f); 1184 path.quadTo(231.656464f, 5342.00049f, 230, 5342); 1185 path.lineTo(173, 5342); 1186 path.close(); 1187 SkPath pathB; 1188 pathB.setFillType(SkPath::kInverseWinding_FillType); 1189 pathB.moveTo(173, 5342); 1190 pathB.lineTo(230, 5342); 1191 pathB.cubicTo(231.65686f, 5342, 233, 5343.79102f, 233, 5346); 1192 pathB.lineTo(233, 5372); 1193 pathB.lineTo(169, 5372); 1194 pathB.lineTo(169, 5346); 1195 pathB.cubicTo(169, 5343.79102f, 170.790863f, 5342, 173, 5342); 1196 pathB.close(); 1197 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1198 } 1199 1200 // nearly identical to lavoixdunord -- to not-quite-coincident lines 1201 static void skpwww_booking_com_68(skiatest::Reporter* reporter) { 1202 SkPath path; 1203 path.setFillType(SkPath::kEvenOdd_FillType); 1204 path.moveTo(90, 187); 1205 path.cubicTo(90, 185.34314f, 91.3431473f, 184, 93, 184); 1206 path.lineTo(588, 184); 1207 path.cubicTo(589.65686f, 184, 591, 185.34314f, 591, 187); 1208 path.lineTo(591, 218); 1209 path.cubicTo(591, 219.65686f, 589.65686f, 221, 588, 221); 1210 path.lineTo(93, 221); 1211 path.cubicTo(91.3431473f, 221, 90, 219.65686f, 90, 218); 1212 path.lineTo(90, 187); 1213 path.close(); 1214 path.moveTo(92, 188); 1215 path.cubicTo(92, 186.895432f, 92.8954315f, 186, 94, 186); 1216 path.lineTo(587, 186); 1217 path.cubicTo(588.104553f, 186, 589, 186.895432f, 589, 188); 1218 path.lineTo(589, 217); 1219 path.cubicTo(589, 218.104568f, 588.104553f, 219, 587, 219); 1220 path.lineTo(94, 219); 1221 path.cubicTo(92.8954315f, 219, 92, 218.104568f, 92, 217); 1222 path.lineTo(92, 188); 1223 path.close(); 1224 SkPath pathB; 1225 pathB.setFillType(SkPath::kWinding_FillType); 1226 pathB.moveTo(90, 184); 1227 pathB.lineTo(92, 186); 1228 pathB.lineTo(593.02002f, 186.020004f); 1229 pathB.lineTo(591, 184); 1230 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1231 } 1232 1233 // visually looks like lavoixdunord and www_booking_com 1234 static void skpwww_despegar_com_mx_272(skiatest::Reporter* reporter) { 1235 SkPath path; 1236 path.setFillType(SkPath::kEvenOdd_FillType); 1237 path.moveTo(635, 1788); 1238 path.cubicTo(635, 1786.34314f, 636.34314f, 1785, 638, 1785); 1239 path.lineTo(832, 1785); 1240 path.cubicTo(833.65686f, 1785, 835, 1786.34314f, 835, 1788); 1241 path.lineTo(835, 1812); 1242 path.cubicTo(835, 1813.65686f, 833.65686f, 1815, 832, 1815); 1243 path.lineTo(638, 1815); 1244 path.cubicTo(636.34314f, 1815, 635, 1813.65686f, 635, 1812); 1245 path.lineTo(635, 1788); 1246 path.close(); 1247 path.moveTo(637, 1789); 1248 path.cubicTo(637, 1787.89539f, 637.895447f, 1787, 639, 1787); 1249 path.lineTo(831, 1787); 1250 path.cubicTo(832.104553f, 1787, 833, 1787.89539f, 833, 1789); 1251 path.lineTo(833, 1811); 1252 path.cubicTo(833, 1812.10461f, 832.104553f, 1813, 831, 1813); 1253 path.lineTo(639, 1813); 1254 path.cubicTo(637.895447f, 1813, 637, 1812.10461f, 637, 1811); 1255 path.lineTo(637, 1789); 1256 path.close(); 1257 SkPath pathB; 1258 pathB.setFillType(SkPath::kWinding_FillType); 1259 pathB.moveTo(835, 1785); 1260 pathB.lineTo(833, 1787); 1261 pathB.lineTo(832.97998f, 1817.02002f); 1262 pathB.lineTo(835, 1815); 1263 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1264 } 1265 #endif 1266 1267 static void skpwww_joomla_org_23(skiatest::Reporter* reporter) { 1268 SkPath path; 1269 path.setFillType(SkPath::kEvenOdd_FillType); 1270 path.moveTo(320, 347); 1271 path.cubicTo(320, 344.238586f, 322.238586f, 342, 325, 342); 1272 path.lineTo(416, 342); 1273 path.cubicTo(418.761414f, 342, 421, 344.238586f, 421, 347); 1274 path.cubicTo(421, 344.790863f, 418.761414f, 343, 416, 343); 1275 path.lineTo(325, 343); 1276 path.cubicTo(322.238586f, 343, 320, 344.790863f, 320, 347); 1277 path.close(); 1278 path.moveTo(320, 378); 1279 path.cubicTo(320, 380.761414f, 322.238586f, 383, 325, 383); 1280 path.lineTo(416, 383); 1281 path.cubicTo(418.761414f, 383, 421, 380.761414f, 421, 378); 1282 path.cubicTo(421, 380.209137f, 418.761414f, 382, 416, 382); 1283 path.lineTo(325, 382); 1284 path.cubicTo(322.238586f, 382, 320, 380.209137f, 320, 378); 1285 path.close(); 1286 SkPath pathB; 1287 pathB.setFillType(SkPath::kWinding_FillType); 1288 pathB.moveTo(320, 383); 1289 pathB.lineTo(320, 378); 1290 pathB.lineTo(421, 378.000031f); 1291 pathB.lineTo(421, 383); 1292 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1293 } 1294 1295 static void skpwww_macrumors_com_131(skiatest::Reporter* reporter) { 1296 SkPath path; 1297 path.setFillType(SkPath::kEvenOdd_FillType); 1298 path.moveTo(136, 14089); 1299 path.lineTo(136, 14056); 1300 path.lineTo(778, 14056); 1301 path.lineTo(778, 14089); 1302 path.quadTo(777.999573f, 14090.6562f, 776.82843f, 14091.8281f); 1303 path.quadTo(775.656433f, 14093, 774, 14093); 1304 path.lineTo(140, 14093); 1305 path.quadTo(138.343552f, 14093, 137.17157f, 14091.8281f); 1306 path.quadTo(136.000397f, 14090.6562f, 136, 14089); 1307 path.close(); 1308 SkPath pathB; 1309 pathB.setFillType(SkPath::kInverseWinding_FillType); 1310 pathB.moveTo(136, 14057); 1311 pathB.lineTo(778, 14057); 1312 pathB.lineTo(778, 14089); 1313 pathB.cubicTo(778, 14091.209f, 776.209167f, 14093, 774, 14093); 1314 pathB.lineTo(140, 14093); 1315 pathB.cubicTo(137.790863f, 14093, 136, 14091.209f, 136, 14089); 1316 pathB.lineTo(136, 14057); 1317 pathB.close(); 1318 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1319 } 1320 1321 static void skpwww_leadpages_net_84(skiatest::Reporter* reporter) { 1322 SkPath path; 1323 path.setFillType(SkPath::kEvenOdd_FillType); 1324 path.moveTo(377.1716f, 5910.17139f); 1325 path.cubicTo(376.447723f, 5910.89551f, 376, 5911.89551f, 376, 5913); 1326 path.lineTo(376, 5972); 1327 path.cubicTo(376, 5974.20898f, 377.790863f, 5976, 380, 5976); 1328 path.cubicTo(378.34314f, 5976, 377, 5974.20898f, 377, 5972); 1329 path.lineTo(377, 5913); 1330 path.cubicTo(377, 5912.17139f, 377.335785f, 5911.42188f, 377.878693f, 5910.87891f); 1331 path.lineTo(377.1716f, 5910.17139f); 1332 path.close(); 1333 SkPath pathB; 1334 pathB.setFillType(SkPath::kWinding_FillType); 1335 pathB.moveTo(376, 5909); 1336 pathB.lineTo(378.481873f, 5909); 1337 pathB.lineTo(379.999878f, 5976); 1338 pathB.lineTo(376, 5976); 1339 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1340 } 1341 1342 static void skpwww_briian_com_34(skiatest::Reporter* reporter) { 1343 SkPath path; 1344 path.setFillType(SkPath::kEvenOdd_FillType); 1345 path.moveTo(843, 216); 1346 path.cubicTo(843, 213.238571f, 845.238586f, 211, 848, 211); 1347 path.lineTo(1191, 211); 1348 path.cubicTo(1193.76147f, 211, 1196, 213.238571f, 1196, 216); 1349 path.lineTo(1196, 779); 1350 path.cubicTo(1196, 781.761414f, 1193.76147f, 784, 1191, 784); 1351 path.lineTo(848, 784); 1352 path.cubicTo(845.238586f, 784, 843, 781.761414f, 843, 779); 1353 path.lineTo(843, 216); 1354 path.close(); 1355 path.moveTo(844, 217); 1356 path.cubicTo(844, 214.238571f, 846.238586f, 212, 849, 212); 1357 path.lineTo(1190, 212); 1358 path.cubicTo(1192.76147f, 212, 1195, 214.238571f, 1195, 217); 1359 path.lineTo(1195, 778); 1360 path.cubicTo(1195, 779.65686f, 1192.76147f, 781, 1190, 781); 1361 path.lineTo(849, 781); 1362 path.cubicTo(846.238586f, 781, 844, 779.65686f, 844, 778); 1363 path.lineTo(844, 217); 1364 path.close(); 1365 SkPath pathB; 1366 pathB.setFillType(SkPath::kWinding_FillType); 1367 pathB.moveTo(843, 784); 1368 pathB.lineTo(843, 779); 1369 pathB.lineTo(1196, 779.000061f); 1370 pathB.lineTo(1196, 784); 1371 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1372 } 1373 1374 1375 static void skpwww_sciality_com_100(skiatest::Reporter* reporter) { 1376 SkPath path; 1377 path.setFillType(SkPath::kEvenOdd_FillType); 1378 path.moveTo(162, 468); 1379 path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472); 1380 path.lineTo(158, 528); 1381 path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532); 1382 path.lineTo(275, 532); 1383 path.cubicTo(277.209137f, 532, 279, 530.209106f, 279, 528); 1384 path.lineTo(279, 472); 1385 path.cubicTo(279, 469.790863f, 277.209137f, 468, 275, 468); 1386 path.lineTo(162, 468); 1387 path.close(); 1388 SkPath pathB; 1389 pathB.setFillType(SkPath::kWinding_FillType); 1390 pathB.moveTo(275, 468); 1391 pathB.cubicTo(276.65686f, 468, 278, 469.34314f, 278, 471); 1392 pathB.lineTo(278, 529); 1393 pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532); 1394 pathB.lineTo(161, 532); 1395 pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529); 1396 pathB.lineTo(158, 471); 1397 pathB.cubicTo(158, 469.34314f, 159.34314f, 468, 161, 468); 1398 pathB.lineTo(275, 468); 1399 pathB.close(); 1400 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1401 } 1402 1403 #if TRY_SEPT_BROKEN_TESTS 1404 static void skpwww_sciality_com_101(skiatest::Reporter* reporter) { 1405 SkPath path; 1406 path.setFillType(SkPath::kEvenOdd_FillType); 1407 path.moveTo(162, 468); 1408 path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472); 1409 path.lineTo(158, 528); 1410 path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532); 1411 path.lineTo(275.009186f, 532); 1412 path.cubicTo(276.661774f, 531.994995f, 278, 530.653748f, 278, 529); 1413 path.lineTo(278, 471); 1414 path.cubicTo(278, 469.346375f, 276.662079f, 468.005249f, 275.009705f, 468); 1415 path.lineTo(162, 468); 1416 path.close(); 1417 SkPath pathB; 1418 pathB.setFillType(SkPath::kInverseWinding_FillType); 1419 pathB.moveTo(161, 469); 1420 pathB.lineTo(275, 469); 1421 pathB.cubicTo(276.65686f, 469, 278, 469.895416f, 278, 471); 1422 pathB.lineTo(278, 529); 1423 pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532); 1424 pathB.lineTo(161, 532); 1425 pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529); 1426 pathB.lineTo(158, 471); 1427 pathB.cubicTo(158, 469.895416f, 159.34314f, 469, 161, 469); 1428 pathB.close(); 1429 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1430 } 1431 #endif 1432 1433 static void skpwww_meb_gov_tr_5(skiatest::Reporter* reporter) { 1434 SkPath path; 1435 path.setFillType(SkPath::kEvenOdd_FillType); 1436 path.moveTo(137.34314f, 145.34314f); 1437 path.quadTo(139.687088f, 143.000793f, 143, 143); 1438 path.lineTo(242, 143); 1439 path.quadTo(245.312912f, 143.000793f, 247.65686f, 145.34314f); 1440 path.quadTo(249.999207f, 147.687088f, 250, 151); 1441 path.lineTo(250, 177); 1442 path.lineTo(135, 177); 1443 path.lineTo(135, 151); 1444 path.quadTo(135.000793f, 147.687088f, 137.34314f, 145.34314f); 1445 path.close(); 1446 SkPath pathB; 1447 pathB.setFillType(SkPath::kWinding_FillType); 1448 pathB.moveTo(135, 143); 1449 pathB.lineTo(250, 143); 1450 pathB.lineTo(250, 177); 1451 pathB.lineTo(135, 177); 1452 pathB.close(); 1453 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1454 } 1455 1456 #if TRY_SEPT_BROKEN_TESTS 1457 static void skpwww_meb_gov_tr_6(skiatest::Reporter* reporter) { 1458 SkPath path; 1459 path.setFillType(SkPath::kEvenOdd_FillType); 1460 path.moveTo(143, 143); 1461 path.quadTo(139.687088f, 143.000793f, 137.34314f, 145.34314f); 1462 path.quadTo(135.000793f, 147.687088f, 135, 151); 1463 path.lineTo(135, 177); 1464 path.lineTo(250, 177); 1465 path.lineTo(250, 151); 1466 path.quadTo(249.999207f, 147.687088f, 247.65686f, 145.34314f); 1467 path.quadTo(245.312912f, 143.000793f, 242, 143); 1468 path.lineTo(143, 143); 1469 path.close(); 1470 SkPath pathB; 1471 pathB.setFillType(SkPath::kInverseWinding_FillType); 1472 pathB.moveTo(143, 143); 1473 pathB.lineTo(242, 143); 1474 pathB.cubicTo(245.865997f, 143, 249, 146.581726f, 249, 151); 1475 pathB.lineTo(249, 177); 1476 pathB.lineTo(135, 177); 1477 pathB.lineTo(135, 151); 1478 pathB.cubicTo(135, 146.581726f, 138.581726f, 143, 143, 143); 1479 pathB.close(); 1480 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1481 } 1482 #endif 1483 1484 static void skpgithub_io_25(skiatest::Reporter* reporter) { 1485 SkPath path; 1486 path.setFillType(SkPath::kEvenOdd_FillType); 1487 path.moveTo(1001.87866f, 14.8786793f); 1488 path.quadTo(1002.75745f, 14.0001001f, 1004, 14); 1489 path.lineTo(1105, 14); 1490 path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f); 1491 path.quadTo(1107.99988f, 15.7574596f, 1108, 17); 1492 path.lineTo(1108, 41); 1493 path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f); 1494 path.quadTo(1106.24255f, 43.9999008f, 1105, 44); 1495 path.lineTo(1004, 44); 1496 path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f); 1497 path.quadTo(1001.00012f, 42.2425423f, 1001, 41); 1498 path.lineTo(1001, 17); 1499 path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f); 1500 path.close(); 1501 SkPath pathB; 1502 pathB.setFillType(SkPath::kInverseWinding_FillType); 1503 pathB.moveTo(1005, 16); 1504 pathB.lineTo(1104, 16); 1505 pathB.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18); 1506 pathB.lineTo(1106, 40); 1507 pathB.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42); 1508 pathB.lineTo(1005, 42); 1509 pathB.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40); 1510 pathB.lineTo(1003, 18); 1511 pathB.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16); 1512 pathB.close(); 1513 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1514 } 1515 1516 static void skpgithub_io_26(skiatest::Reporter* reporter) { 1517 SkPath path; 1518 path.setFillType(SkPath::kEvenOdd_FillType); 1519 path.moveTo(1001.87866f, 14.8786793f); 1520 path.quadTo(1002.75745f, 14.0001001f, 1004, 14); 1521 path.lineTo(1105, 14); 1522 path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f); 1523 path.quadTo(1107.99988f, 15.7574596f, 1108, 17); 1524 path.lineTo(1108, 41); 1525 path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f); 1526 path.quadTo(1106.24255f, 43.9999008f, 1105, 44); 1527 path.lineTo(1004, 44); 1528 path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f); 1529 path.quadTo(1001.00012f, 42.2425423f, 1001, 41); 1530 path.lineTo(1001, 17); 1531 path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f); 1532 path.close(); 1533 path.moveTo(1003, 18); 1534 path.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16); 1535 path.lineTo(1104, 16); 1536 path.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18); 1537 path.lineTo(1106, 40); 1538 path.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42); 1539 path.lineTo(1005, 42); 1540 path.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40); 1541 path.lineTo(1003, 18); 1542 path.close(); 1543 SkPath pathB; 1544 pathB.setFillType(SkPath::kWinding_FillType); 1545 pathB.moveTo(1108, 14); 1546 pathB.lineTo(1106, 16); 1547 pathB.lineTo(1105.97998f, 46.0200005f); 1548 pathB.lineTo(1108, 44); 1549 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1550 } 1551 1552 static void skpskpicture14(skiatest::Reporter* reporter) { 1553 SkPath path; 1554 path.setFillType(SkPath::kEvenOdd_FillType); 1555 path.moveTo(0, 994); 1556 path.lineTo(0, 0); 1557 path.lineTo(512, 0); 1558 path.lineTo(512, 994); 1559 path.lineTo(0, 994); 1560 path.close(); 1561 SkPath pathB; 1562 pathB.setFillType(SkPath::kWinding_FillType); 1563 pathB.moveTo(-317, 168); 1564 pathB.quadTo(-317, 166.757385f, -316.121338f, 165.878662f); 1565 pathB.quadTo(-315.242645f, 165, -314, 165); 1566 pathB.lineTo(320, 165); 1567 pathB.quadTo(321.242615f, 165, 322.121338f, 165.878662f); 1568 pathB.quadTo(323, 166.757385f, 323, 168); 1569 pathB.lineTo(323, 193); 1570 pathB.lineTo(-317, 193); 1571 pathB.close(); 1572 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1573 } 1574 1575 #if TRY_SEPT_BROKEN_TESTS 1576 static void skpskpicture15(skiatest::Reporter* reporter) { 1577 SkPath path; 1578 path.setFillType(SkPath::kEvenOdd_FillType); 1579 path.moveTo(0, 193); 1580 path.lineTo(323, 193); 1581 path.lineTo(323, 168); 1582 path.quadTo(323, 166.757385f, 322.121338f, 165.878662f); 1583 path.quadTo(321.242615f, 165, 320, 165); 1584 path.lineTo(0, 165); 1585 path.lineTo(0, 193); 1586 path.close(); 1587 SkPath pathB; 1588 pathB.setFillType(SkPath::kInverseWinding_FillType); 1589 pathB.moveTo(-314, 165); 1590 pathB.lineTo(320, 165); 1591 pathB.cubicTo(321.65686f, 165, 323, 166.34314f, 323, 168); 1592 pathB.lineTo(323, 192); 1593 pathB.lineTo(-317, 192); 1594 pathB.lineTo(-317, 168); 1595 pathB.cubicTo(-317, 166.34314f, -315.65686f, 165, -314, 165); 1596 pathB.close(); 1597 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1598 } 1599 #endif 1600 1601 static void (*firstTest)(skiatest::Reporter* ) = 0; 1602 1603 static struct TestDesc tests[] = { 1604 TEST(skpskpicture14), 1605 #if TRY_SEPT_BROKEN_TESTS 1606 TEST(skpskpicture15), 1607 TEST(skpwww_meb_gov_tr_6), 1608 TEST(skpwww_sciality_com_101), 1609 TEST(skpwww_booking_com_68), // similar to lavoixdunord 1610 TEST(skpwww_despegar_com_mx_272), // similar to lavoixdunord 1611 TEST(skpwww_lavoixdunord_fr_11), // not quite coincident, sorting line/cubic fails 1612 TEST(skppptv_com_62), // cubic have nearly identical tangents, sort incorrectly 1613 #endif 1614 #if TRY_BROKEN_TESTS 1615 TEST(skppchappy_com_au102), 1616 TEST(skpsciality_com161), 1617 TEST(skpi_gino_com16), 1618 TEST(skpnaoxrane_ru23), // see test for failure evaluation 1619 TEST(skptcmevents_org23), // see test for (partial) failure evaluation 1620 TEST(skpredbullskatearcade_es16), // cubic have nearly identical tangents, sort incorrectly 1621 TEST(skpfinanzasdigital_com9), // cubic/quad tangents too close to sort 1622 #endif 1623 TEST(skpgithub_io_26), 1624 TEST(skpgithub_io_25), 1625 TEST(skpwww_meb_gov_tr_5), 1626 TEST(skpwww_sciality_com_100), 1627 TEST(skpwww_joomla_org_23), 1628 TEST(skpwww_macrumors_com_131), 1629 TEST(skpwww_briian_com_34), 1630 TEST(skpwww_leadpages_net_84), 1631 TEST(skpwww_fj_p_com_22), 1632 TEST(skppartainasdemo250_org56), 1633 TEST(skpsd_graphic_net104), 1634 TEST(skpbreakmystyle_com10), 1635 TEST(skpnational_com_au81), 1636 TEST(skprentacheat_com30), 1637 TEST(skptracksflow_com9), 1638 TEST(skpautobutler_dk29), 1639 TEST(skponlinecollege_org144), 1640 TEST(skphostloco_com11), 1641 TEST(skpsergeychunkevich_com8), 1642 TEST(skpmlk_com326), 1643 TEST(skpcyclist_friends_gr52), 1644 TEST(skpfrauen_magazin_com83), 1645 TEST(skpthesuburbanite_com213), 1646 TEST(skpsudoestenegocios_com186), 1647 TEST(skpmtrk_uz27), 1648 TEST(skpilkoora_com37), 1649 TEST(skpmm4everfriends_com43), 1650 TEST(skpflite_com41), 1651 TEST(skpcheeseandburger_com225), 1652 TEST(skpeverytechpro_blogspot_com100), 1653 }; 1654 1655 static const size_t testCount = SK_ARRAY_COUNT(tests); 1656 1657 static bool runReverse = false; 1658 static void (*stopTest)(skiatest::Reporter* ) = 0; 1659 1660 static void PathOpsSkpTest(skiatest::Reporter* reporter) { 1661 #if DEBUG_SHOW_TEST_NAME 1662 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 1663 #endif 1664 RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse); 1665 } 1666 1667 #include "TestClassDef.h" 1668 1669 DEFINE_TESTCLASS_SHORT(PathOpsSkpTest) 1670
