Flutter Engine
The Flutter Engine
Macros | Functions | Variables
PathOpsBattles.cpp File Reference
#include "include/core/SkPath.h"
#include "include/pathops/SkPathOps.h"
#include "src/base/SkFloatBits.h"
#include "tests/PathOpsExtendedTest.h"
#include "tests/Test.h"
#include <cstddef>
#include <iterator>

Go to the source code of this file.

Macros

#define TEST(name)   { name, #name }
 

Functions

static void issue414409 (skiatest::Reporter *reporter, const char *filename)
 
static void issue414409b (skiatest::Reporter *reporter, const char *filename)
 
static void issue414409c (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp2 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp3 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp5 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp6 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp7 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp8 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp9 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp10 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp11 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp12 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp13 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp14 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp15 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp16 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp17 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp18 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp19 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp20 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp21 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp22 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp23 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp24 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp25 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp26 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp27 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp28 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp29 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp30 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp31 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp32 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp33 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp34 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp35 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp36 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp37 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp38 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp39 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp40 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp41 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp42 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp43 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp44 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp45 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp46 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp47 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp48 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp49 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp50 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp51 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp52 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp53 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp54 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp55 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp56 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp57 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp58 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp59 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp60 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp61 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp62 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp63 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp64 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp65 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp66 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp67 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp68 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp69 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp70 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp71 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp72 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp73 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp74 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp75 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp76 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp77 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp78 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp79 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp80 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp81 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp82 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp83 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp84 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp85 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp86 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp87 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp88 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp89 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp90 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp91 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp92 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp93 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp94 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp95 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp96 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp97 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp98 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp99 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp100 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp101 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp102 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp103 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp104 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp105 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp106 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp107 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp108 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp109 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp110 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp111 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp112 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp113 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp114 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp115 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp116 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp117 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp118 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp119 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp120 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp121 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp122 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp123 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp124 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp125 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp126 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp127 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp128 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp129 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp130 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp131 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp132 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp133 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp134 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp135 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp136 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp137 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp138 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp139 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp140 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp141 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp142 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp143 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp144 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp145 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp146 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp147 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp148 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp149 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp150 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp151 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp152 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp153 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp154 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp155 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp156 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp157 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp158 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp159 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp160 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp161 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp162 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp163 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp164 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp165 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp166 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp167 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp168 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp169 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp170 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp171 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp172 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp173 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp174 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp175 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp176 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp177 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp178 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp179 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp180 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp181 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp182 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp183 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp184 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp185 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp186 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp187 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp188 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp189 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp190 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp191 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp192 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp193 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp194 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp195 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp196 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp197 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp198 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp199 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp200 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp201 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp202 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp203 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp204 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp205 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp206 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp207 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp208 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp209 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp210 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp211 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp212 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp213 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp214 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp215 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp216 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp217 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp218 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp219 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp220 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp221 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp222 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp223 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp224 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp225 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp226 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp227 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp228 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp229 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp230 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp231 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp232 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp233 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp234 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp235 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp236 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp237 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp238 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp239 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp240 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp241 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp242 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp243 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp244 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp245 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp246 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp247 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp248 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp249 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp250 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp251 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp252 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp253 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp254 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp255 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp256 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp257 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp258 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp259 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp260 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp261 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp262 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp263 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp264 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp265 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp266 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp267 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp268 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp269 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp270 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp271 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp272 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp273 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp274 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp275 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp276 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp277 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp278 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp279 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp280 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp281 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp282 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp283 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp284 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp285 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp286 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp287 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp288 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp289 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp290 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp291 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp292 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp293 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp294 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp295 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp296 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp297 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp298 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp299 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp300 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp301 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp302 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp303 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp304 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp305 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp306 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp307 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp308 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp309 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp310 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp311 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp312 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp313 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp314 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp315 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp316 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp317 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp318 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp319 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp320 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp321 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp322 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp323 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp324 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp325 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp326 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp327 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp328 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp329 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp330 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp331 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp332 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp333 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp334 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp335 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp336 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp337 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp338 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp339 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp340 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp341 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp342 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp343 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp344 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp345 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp346 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp347 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp348 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp349 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp350 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp351 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp352 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1390 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1391 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1392 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1393 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1394 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1395 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp1396 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp2193 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp2194 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp3368 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp3369 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp3370 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp3371 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp3372 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4290 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4291 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4292 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4293 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4294 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4295 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp4296 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp5193 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp5194 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp402 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp6000 (skiatest::Reporter *reporter, const char *filename)
 
static void battleOp6001 (skiatest::Reporter *reporter, const char *filename)
 
 DEF_TEST (PathOpsBattle, reporter)
 

Variables

static void(* firstTest )(skiatest::Reporter *, const char *filename) = battleOp183
 
static void(* stopTest )(skiatest::Reporter *, const char *filename) = nullptr
 
static struct TestDesc tests []
 
static const size_t testCount = std::size(tests)
 
static bool runReverse = false
 

Macro Definition Documentation

◆ TEST

#define TEST (   name)    { name, #name }

Definition at line 18 of file PathOpsBattles.cpp.

Function Documentation

◆ battleOp1()

static void battleOp1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 99 of file PathOpsBattles.cpp.

99 {
100 SkPath path;
101 path.setFillType((SkPathFillType) 0);
102path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
103path.cubicTo(SkBits2Float(0x3ea4d9f5), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f24d9a9), SkBits2Float(0xc2a5ff0a), SkBits2Float(0x3f774519), SkBits2Float(0xc2a5fd1f));
104path.lineTo(SkBits2Float(0x3f32bfc3), SkBits2Float(0xc26ffbd7));
105path.cubicTo(SkBits2Float(0x3eee5669), SkBits2Float(0xc26ffe9e), SkBits2Float(0x3e6e56cc), SkBits2Float(0xc2700000), SkBits2Float(0x357ffb40), SkBits2Float(0xc2700000));
106path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
107path.close();
108
109 SkPath path1(path);
110 path.reset();
111 path.setFillType((SkPathFillType) 0);
112path.moveTo(SkBits2Float(0x3f774503), SkBits2Float(0xc2a5fd1f));
113path.cubicTo(SkBits2Float(0x3f7f82ff), SkBits2Float(0xc2a5fcee), SkBits2Float(0x3f83e06d), SkBits2Float(0xc2a5fcbb), SkBits2Float(0x3f87ff59), SkBits2Float(0xc2a5fc85));
114path.lineTo(SkBits2Float(0x3f449f80), SkBits2Float(0xc26ffaf7));
115path.cubicTo(SkBits2Float(0x3f3eaa52), SkBits2Float(0xc26ffb47), SkBits2Float(0x3f38b4f5), SkBits2Float(0xc26ffb92), SkBits2Float(0x3f32bf98), SkBits2Float(0xc26ffbd9));
116path.lineTo(SkBits2Float(0x3f774503), SkBits2Float(0xc2a5fd1f));
117path.close();
118
119 SkPath path2(path);
120 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
121}
reporter
reporter
Definition: FontMgrTest.cpp:39
testPathOp
bool testPathOp(skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp shapeOp, const char *testName)
Definition: PathOpsExtendedTest.cpp:618
path1
static SkPath path1()
Definition: PathOpsIssue3651.cpp:19
path2
static SkPath path2()
Definition: PathOpsIssue3651.cpp:198
SkBits2Float
static float SkBits2Float(uint32_t bits)
Definition: SkFloatBits.h:48
SkPathOp
SkPathOp
Definition: SkPathOps.h:22
SkPathFillType
SkPathFillType
Definition: SkPathTypes.h:11
SkPath
Definition: SkPath.h:59
flutter::path
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
Definition: switches.h:57

◆ battleOp10()

static void battleOp10 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 331 of file PathOpsBattles.cpp.

331 {
332 SkPath path;
333 path.setFillType((SkPathFillType) 0);
334path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
335path.cubicTo(SkBits2Float(0x3ddcd524), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e5cd462), SkBits2Float(0xc2a5ffe3), SkBits2Float(0x3ea59eff), SkBits2Float(0xc2a5ffac));
336path.lineTo(SkBits2Float(0x3e6f74a3), SkBits2Float(0xc26fff89));
337path.cubicTo(SkBits2Float(0x3e1fa33e), SkBits2Float(0xc26fffd9), SkBits2Float(0x3d9fa303), SkBits2Float(0xc2700000), SkBits2Float(0xb580e440), SkBits2Float(0xc2700000));
338path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
339path.close();
340
341 SkPath path1(path);
342 path.reset();
343 path.setFillType((SkPathFillType) 0);
344path.moveTo(SkBits2Float(0x3ea59f9c), SkBits2Float(0xc2a5ffad));
345path.cubicTo(SkBits2Float(0x3eab24c0), SkBits2Float(0xc2a5ffa7), SkBits2Float(0x3eb0aa54), SkBits2Float(0xc2a5ffa1), SkBits2Float(0x3eb62fe9), SkBits2Float(0xc2a5ff9b));
346path.lineTo(SkBits2Float(0x3e83b355), SkBits2Float(0xc26fff6f));
347path.cubicTo(SkBits2Float(0x3e7f6bdb), SkBits2Float(0xc26fff79), SkBits2Float(0x3e777021), SkBits2Float(0xc26fff81), SkBits2Float(0x3e6f7465), SkBits2Float(0xc26fff8a));
348path.lineTo(SkBits2Float(0x3ea59f9c), SkBits2Float(0xc2a5ffad));
349path.close();
350
351 SkPath path2(path);
352 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
353}

◆ battleOp100()

static void battleOp100 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2697 of file PathOpsBattles.cpp.

2697 {
2698 SkPath path;
2699 path.setFillType((SkPathFillType) 0);
2700path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2701path.cubicTo(SkBits2Float(0x403cde0b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40bcccc9), SkBits2Float(0xc2a5af6a), SkBits2Float(0x410d5936), SkBits2Float(0xc2a50e98));
2702path.lineTo(SkBits2Float(0x40cc5bf6), SkBits2Float(0xc26ea2fc));
2703path.cubicTo(SkBits2Float(0x40887b5e), SkBits2Float(0xc26f8b7f), SkBits2Float(0x400887d8), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2704path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2705path.close();
2706
2707 SkPath path1(path);
2708 path.reset();
2709 path.setFillType((SkPathFillType) 0);
2710path.moveTo(SkBits2Float(0x410d5935), SkBits2Float(0xc2a50e99));
2711path.cubicTo(SkBits2Float(0x41120ace), SkBits2Float(0xc2a4fe85), SkBits2Float(0x4116bbb5), SkBits2Float(0xc2a4eda4), SkBits2Float(0x411b6bdd), SkBits2Float(0xc2a4dbf6));
2712path.lineTo(SkBits2Float(0x40e0b4a3), SkBits2Float(0xc26e59c7));
2713path.cubicTo(SkBits2Float(0x40d9ed7a), SkBits2Float(0xc26e7357), SkBits2Float(0x40d32536), SkBits2Float(0xc26e8bbe), SkBits2Float(0x40cc5bf1), SkBits2Float(0xc26ea2fc));
2714path.lineTo(SkBits2Float(0x410d5935), SkBits2Float(0xc2a50e99));
2715path.close();
2716
2717 SkPath path2(path);
2718 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2719}

◆ battleOp101()

static void battleOp101 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2722 of file PathOpsBattles.cpp.

2722 {
2723 SkPath path;
2724 path.setFillType((SkPathFillType) 0);
2725path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2726path.cubicTo(SkBits2Float(0x406db78d), SkBits2Float(0xc2a60000), SkBits2Float(0x40ed953d), SkBits2Float(0xc2a58058), SkBits2Float(0x4131afb7), SkBits2Float(0xc2a481e4));
2727path.lineTo(SkBits2Float(0x410072b2), SkBits2Float(0xc26dd78e));
2728path.cubicTo(SkBits2Float(0x40abbf2e), SkBits2Float(0xc26f4770), SkBits2Float(0x402bd807), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2729path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2730path.close();
2731
2732 SkPath path1(path);
2733 path.reset();
2734 path.setFillType((SkPathFillType) 0);
2735path.moveTo(SkBits2Float(0x4131afba), SkBits2Float(0xc2a481e4));
2736path.cubicTo(SkBits2Float(0x413792dd), SkBits2Float(0xc2a46874), SkBits2Float(0x413d74a2), SkBits2Float(0xc2a44dc1), SkBits2Float(0x414354e9), SkBits2Float(0xc2a431ca));
2737path.lineTo(SkBits2Float(0x410d3424), SkBits2Float(0xc26d63c0));
2738path.cubicTo(SkBits2Float(0x4108f4b6), SkBits2Float(0xc26d8c2e), SkBits2Float(0x4104b435), SkBits2Float(0xc26db2c8), SkBits2Float(0x410072b4), SkBits2Float(0xc26dd78e));
2739path.lineTo(SkBits2Float(0x4131afba), SkBits2Float(0xc2a481e4));
2740path.close();
2741
2742 SkPath path2(path);
2743 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2744}

◆ battleOp102()

static void battleOp102 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2747 of file PathOpsBattles.cpp.

2747 {
2748 SkPath path;
2749 path.setFillType((SkPathFillType) 1);
2750path.moveTo(SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2751path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2752path.cubicTo(SkBits2Float(0x406db78d), SkBits2Float(0xc2a60000), SkBits2Float(0x40ed953d), SkBits2Float(0xc2a58058), SkBits2Float(0x4131afba), SkBits2Float(0xc2a481e4));
2753path.cubicTo(SkBits2Float(0x413792dd), SkBits2Float(0xc2a46874), SkBits2Float(0x413d74a2), SkBits2Float(0xc2a44dc1), SkBits2Float(0x414354e9), SkBits2Float(0xc2a431ca));
2754path.lineTo(SkBits2Float(0x410d3424), SkBits2Float(0xc26d63c0));
2755path.cubicTo(SkBits2Float(0x4108f4b6), SkBits2Float(0xc26d8c2e), SkBits2Float(0x4104b435), SkBits2Float(0xc26db2c8), SkBits2Float(0x410072b2), SkBits2Float(0xc26dd78e));
2756path.cubicTo(SkBits2Float(0x40abbf2e), SkBits2Float(0xc26f4770), SkBits2Float(0x402bd807), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2757path.close();
2758
2759 SkPath path1(path);
2760 path.reset();
2761 path.setFillType((SkPathFillType) 0);
2762path.moveTo(SkBits2Float(0x414354ed), SkBits2Float(0xc2a431cb));
2763path.cubicTo(SkBits2Float(0x419152e5), SkBits2Float(0xc2a26c3a), SkBits2Float(0x41c0119b), SkBits2Float(0xc29f5c06), SkBits2Float(0x41ed1335), SkBits2Float(0xc29b0f0a));
2764path.lineTo(SkBits2Float(0x41ab612b), SkBits2Float(0xc2602e6b));
2765path.cubicTo(SkBits2Float(0x418ad84d), SkBits2Float(0xc2666635), SkBits2Float(0x41521b54), SkBits2Float(0xc26ad3fe), SkBits2Float(0x410d3426), SkBits2Float(0xc26d63c0));
2766path.lineTo(SkBits2Float(0x414354ed), SkBits2Float(0xc2a431cb));
2767path.close();
2768
2769 SkPath path2(path);
2770 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2771}

◆ battleOp103()

static void battleOp103 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2774 of file PathOpsBattles.cpp.

2774 { //crash
2775 SkPath path;
2776 path.setFillType((SkPathFillType) 0);
2777path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2778path.cubicTo(SkBits2Float(0x408e2d73), SkBits2Float(0xc2a5ffff), SkBits2Float(0x410e100a), SkBits2Float(0xc2a54957), SkBits2Float(0x41543cd2), SkBits2Float(0xc2a3ddc8));
2779path.lineTo(SkBits2Float(0x41196cba), SkBits2Float(0xc26cea49));
2780path.cubicTo(SkBits2Float(0x40cd643f), SkBits2Float(0xc26ef7e9), SkBits2Float(0x404d8eb8), SkBits2Float(0xc26fffff), SkBits2Float(0xb5ac02ba), SkBits2Float(0xc26fffff));
2781path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2782path.close();
2783
2784 SkPath path1(path);
2785 path.reset();
2786 path.setFillType((SkPathFillType) 0);
2787path.moveTo(SkBits2Float(0x41543cce), SkBits2Float(0xc2a3ddc8));
2788path.cubicTo(SkBits2Float(0x415b4057), SkBits2Float(0xc2a3b973), SkBits2Float(0x41624181), SkBits2Float(0xc2a39350), SkBits2Float(0x41694022), SkBits2Float(0xc2a36b60));
2789path.lineTo(SkBits2Float(0x41289d63), SkBits2Float(0xc26c44e1));
2790path.cubicTo(SkBits2Float(0x41238ef8), SkBits2Float(0xc26c7e9e), SkBits2Float(0x411e7eb5), SkBits2Float(0xc26cb5c1), SkBits2Float(0x41196cbd), SkBits2Float(0xc26cea4a));
2791path.lineTo(SkBits2Float(0x41543cce), SkBits2Float(0xc2a3ddc8));
2792path.close();
2793
2794 SkPath path2(path);
2795 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2796}

◆ battleOp104()

static void battleOp104 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2798 of file PathOpsBattles.cpp.

2798 {
2799 SkPath path;
2800 path.setFillType((SkPathFillType) 0);
2801path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2802path.cubicTo(SkBits2Float(0x3dd41fb8), SkBits2Float(0xc2a5fffe), SkBits2Float(0x3e541e5b), SkBits2Float(0xc2a5ffe5), SkBits2Float(0x3e9f1657), SkBits2Float(0xc2a5ffb2));
2803path.lineTo(SkBits2Float(0x3e66012b), SkBits2Float(0xc26fff92));
2804path.cubicTo(SkBits2Float(0x3e1955e2), SkBits2Float(0xc26fffdc), SkBits2Float(0x3d99560b), SkBits2Float(0xc2700000), SkBits2Float(0x350f7780), SkBits2Float(0xc2700000));
2805path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2806path.close();
2807
2808 SkPath path1(path);
2809 path.reset();
2810 path.setFillType((SkPathFillType) 0);
2811path.moveTo(SkBits2Float(0x3e9f1626), SkBits2Float(0xc2a5ffb4));
2812path.cubicTo(SkBits2Float(0x3ea463a8), SkBits2Float(0xc2a5ffae), SkBits2Float(0x3ea9b10b), SkBits2Float(0xc2a5ffa8), SkBits2Float(0x3eaefe6d), SkBits2Float(0xc2a5ffa3));
2813path.lineTo(SkBits2Float(0x3e7d0144), SkBits2Float(0xc26fff7b));
2814path.cubicTo(SkBits2Float(0x3e75568f), SkBits2Float(0xc26fff84), SkBits2Float(0x3e6dac12), SkBits2Float(0xc26fff8c), SkBits2Float(0x3e660197), SkBits2Float(0xc26fff93));
2815path.lineTo(SkBits2Float(0x3e9f1626), SkBits2Float(0xc2a5ffb4));
2816path.close();
2817
2818 SkPath path2(path);
2819 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2820}

◆ battleOp105()

static void battleOp105 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2823 of file PathOpsBattles.cpp.

2823 {
2824 SkPath path;
2825 path.setFillType((SkPathFillType) 1);
2826path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2827path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2828path.cubicTo(SkBits2Float(0x3dd41f74), SkBits2Float(0xc2a5fffe), SkBits2Float(0x3e541e17), SkBits2Float(0xc2a5ffe5), SkBits2Float(0x3e9f1624), SkBits2Float(0xc2a5ffb2));
2829path.lineTo(SkBits2Float(0x3e9f1626), SkBits2Float(0xc2a5ffb4));
2830path.cubicTo(SkBits2Float(0x3ea463a8), SkBits2Float(0xc2a5ffae), SkBits2Float(0x3ea9b10b), SkBits2Float(0xc2a5ffa8), SkBits2Float(0x3eaefe6d), SkBits2Float(0xc2a5ffa3));
2831path.lineTo(SkBits2Float(0x3e7d0144), SkBits2Float(0xc26fff7b));
2832path.cubicTo(SkBits2Float(0x3e75568f), SkBits2Float(0xc26fff84), SkBits2Float(0x3e6dac12), SkBits2Float(0xc26fff8c), SkBits2Float(0x3e66012b), SkBits2Float(0xc26fff92));
2833path.cubicTo(SkBits2Float(0x3e1955e2), SkBits2Float(0xc26fffdc), SkBits2Float(0x3d99560b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2834path.close();
2835
2836 SkPath path1(path);
2837 path.reset();
2838 path.setFillType((SkPathFillType) 0);
2839path.moveTo(SkBits2Float(0x3eaefebc), SkBits2Float(0xc2a5ffa4));
2840path.cubicTo(SkBits2Float(0x3f0276b7), SkBits2Float(0xc2a5ff4a), SkBits2Float(0x3f2d6dea), SkBits2Float(0xc2a5feac), SkBits2Float(0x3f5864cc), SkBits2Float(0xc2a5fdcd));
2841path.lineTo(SkBits2Float(0x3f1c6df6), SkBits2Float(0xc26ffcd0));
2842path.cubicTo(SkBits2Float(0x3efabdec), SkBits2Float(0xc26ffe15), SkBits2Float(0x3ebc9f78), SkBits2Float(0xc26ffef9), SkBits2Float(0x3e7d0190), SkBits2Float(0xc26fff7c));
2843path.lineTo(SkBits2Float(0x3eaefebc), SkBits2Float(0xc2a5ffa4));
2844path.close();
2845
2846 SkPath path2(path);
2847 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2848}

◆ battleOp106()

static void battleOp106 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2851 of file PathOpsBattles.cpp.

2851 {
2852 SkPath path;
2853 path.setFillType((SkPathFillType) 0);
2854path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2855path.cubicTo(SkBits2Float(0x3ee221f0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f622166), SkBits2Float(0xc2a5fe31), SkBits2Float(0x3fa9974d), SkBits2Float(0xc2a5fa95));
2856path.lineTo(SkBits2Float(0x3f753159), SkBits2Float(0xc26ff82c));
2857path.cubicTo(SkBits2Float(0x3f237814), SkBits2Float(0xc26ffd64), SkBits2Float(0x3ea3787a), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa50), SkBits2Float(0xc2700000));
2858path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2859path.close();
2860
2861 SkPath path1(path);
2862 path.reset();
2863 path.setFillType((SkPathFillType) 0);
2864path.moveTo(SkBits2Float(0x3fa99777), SkBits2Float(0xc2a5fa96));
2865path.cubicTo(SkBits2Float(0x3faf3e7a), SkBits2Float(0xc2a5fa39), SkBits2Float(0x3fb4e596), SkBits2Float(0xc2a5f9d8), SkBits2Float(0x3fba8cad), SkBits2Float(0xc2a5f972));
2866path.lineTo(SkBits2Float(0x3f86dad5), SkBits2Float(0xc26ff687));
2867path.cubicTo(SkBits2Float(0x3f82c4d9), SkBits2Float(0xc26ff71a), SkBits2Float(0x3f7d5da4), SkBits2Float(0xc26ff7a6), SkBits2Float(0x3f753191), SkBits2Float(0xc26ff82c));
2868path.lineTo(SkBits2Float(0x3fa99777), SkBits2Float(0xc2a5fa96));
2869path.close();
2870
2871 SkPath path2(path);
2872 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2873}

◆ battleOp107()

static void battleOp107 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2876 of file PathOpsBattles.cpp.

2876 {
2877 SkPath path;
2878 path.setFillType((SkPathFillType) 1);
2879path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2880path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2881path.cubicTo(SkBits2Float(0x3ee221f0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f622166), SkBits2Float(0xc2a5fe31), SkBits2Float(0x3fa99777), SkBits2Float(0xc2a5fa96));
2882path.cubicTo(SkBits2Float(0x3faf3e7a), SkBits2Float(0xc2a5fa39), SkBits2Float(0x3fb4e596), SkBits2Float(0xc2a5f9d8), SkBits2Float(0x3fba8cad), SkBits2Float(0xc2a5f972));
2883path.lineTo(SkBits2Float(0x3f86dad5), SkBits2Float(0xc26ff687));
2884path.cubicTo(SkBits2Float(0x3f82c4d9), SkBits2Float(0xc26ff71a), SkBits2Float(0x3f7d5da4), SkBits2Float(0xc26ff7a6), SkBits2Float(0x3f753159), SkBits2Float(0xc26ff82c));
2885path.cubicTo(SkBits2Float(0x3f237814), SkBits2Float(0xc26ffd64), SkBits2Float(0x3ea3787a), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2886path.close();
2887
2888 SkPath path1(path);
2889 path.reset();
2890 path.setFillType((SkPathFillType) 0);
2891path.moveTo(SkBits2Float(0x3fba8c96), SkBits2Float(0xc2a5f973));
2892path.cubicTo(SkBits2Float(0x400b1301), SkBits2Float(0xc2a5f303), SkBits2Float(0x4038dc7e), SkBits2Float(0xc2a5e7d6), SkBits2Float(0x40669fe4), SkBits2Float(0xc2a5d7ed));
2893path.lineTo(SkBits2Float(0x4026b765), SkBits2Float(0xc26fc611));
2894path.cubicTo(SkBits2Float(0x4005a27d), SkBits2Float(0xc26fdd13), SkBits2Float(0x3fc9123c), SkBits2Float(0xc26fed3b), SkBits2Float(0x3f86daf1), SkBits2Float(0xc26ff689));
2895path.lineTo(SkBits2Float(0x3fba8c96), SkBits2Float(0xc2a5f973));
2896path.close();
2897
2898 SkPath path2(path);
2899 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2900}

◆ battleOp108()

static void battleOp108 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2903 of file PathOpsBattles.cpp.

2903 {
2904 SkPath path;
2905 path.setFillType((SkPathFillType) 0);
2906path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2907path.cubicTo(SkBits2Float(0x3f587304), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fd8713e), SkBits2Float(0xc2a5f962), SkBits2Float(0x40224ed5), SkBits2Float(0xc2a5ec27));
2908path.lineTo(SkBits2Float(0x3feaa996), SkBits2Float(0xc26fe350));
2909path.cubicTo(SkBits2Float(0x3f9c76e4), SkBits2Float(0xc26ff671), SkBits2Float(0x3f1c780b), SkBits2Float(0xc2700000), SkBits2Float(0xb5510538), SkBits2Float(0xc2700000));
2910path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2911path.close();
2912
2913 SkPath path1(path);
2914 path.reset();
2915 path.setFillType((SkPathFillType) 0);
2916path.moveTo(SkBits2Float(0x40224ee4), SkBits2Float(0xc2a5ec28));
2917path.cubicTo(SkBits2Float(0x4027b77a), SkBits2Float(0xc2a5ead6), SkBits2Float(0x402d1ffd), SkBits2Float(0xc2a5e972), SkBits2Float(0x4032886f), SkBits2Float(0xc2a5e7fe));
2918path.lineTo(SkBits2Float(0x40010f64), SkBits2Float(0xc26fdd4a));
2919path.cubicTo(SkBits2Float(0x3ffa4d23), SkBits2Float(0xc26fdf64), SkBits2Float(0x3ff27b6d), SkBits2Float(0xc26fe166), SkBits2Float(0x3feaa9a1), SkBits2Float(0xc26fe350));
2920path.lineTo(SkBits2Float(0x40224ee4), SkBits2Float(0xc2a5ec28));
2921path.close();
2922
2923 SkPath path2(path);
2924 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2925}

◆ battleOp109()

static void battleOp109 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2928 of file PathOpsBattles.cpp.

2928 {
2929 SkPath path;
2930 path.setFillType((SkPathFillType) 1);
2931path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2932path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2933path.cubicTo(SkBits2Float(0x3f587304), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fd8713e), SkBits2Float(0xc2a5f962), SkBits2Float(0x40224ee4), SkBits2Float(0xc2a5ec28));
2934path.cubicTo(SkBits2Float(0x4027b77a), SkBits2Float(0xc2a5ead6), SkBits2Float(0x402d1ffd), SkBits2Float(0xc2a5e972), SkBits2Float(0x4032886f), SkBits2Float(0xc2a5e7fe));
2935path.lineTo(SkBits2Float(0x40010f64), SkBits2Float(0xc26fdd4a));
2936path.cubicTo(SkBits2Float(0x3ffa4d23), SkBits2Float(0xc26fdf64), SkBits2Float(0x3ff27b6d), SkBits2Float(0xc26fe166), SkBits2Float(0x3feaa996), SkBits2Float(0xc26fe350));
2937path.cubicTo(SkBits2Float(0x3f9c76e4), SkBits2Float(0xc26ff671), SkBits2Float(0x3f1c780b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2938path.close();
2939
2940 SkPath path1(path);
2941 path.reset();
2942 path.setFillType((SkPathFillType) 0);
2943path.moveTo(SkBits2Float(0x4032887d), SkBits2Float(0xc2a5e7fe));
2944path.cubicTo(SkBits2Float(0x4085166b), SkBits2Float(0xc2a5d069), SkBits2Float(0x40b0dd8e), SkBits2Float(0xc2a5a77a), SkBits2Float(0x40dc8f53), SkBits2Float(0xc2a56d38));
2945path.lineTo(SkBits2Float(0x409f70d9), SkBits2Float(0xc26f2bca));
2946path.cubicTo(SkBits2Float(0x407fb58c), SkBits2Float(0xc26f8005), SkBits2Float(0x40406a74), SkBits2Float(0xc26fbb35), SkBits2Float(0x40010f5f), SkBits2Float(0xc26fdd4b));
2947path.lineTo(SkBits2Float(0x4032887d), SkBits2Float(0xc2a5e7fe));
2948path.close();
2949
2950 SkPath path2(path);
2951 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2952}

◆ battleOp11()

static void battleOp11 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 356 of file PathOpsBattles.cpp.

356 {
357 SkPath path;
358 path.setFillType((SkPathFillType) 1);
359path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
360path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
361path.cubicTo(SkBits2Float(0x3ddcd524), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e5cd462), SkBits2Float(0xc2a5ffe3), SkBits2Float(0x3ea59f9c), SkBits2Float(0xc2a5ffad));
362path.lineTo(SkBits2Float(0x3eb62fe9), SkBits2Float(0xc2a5ff9b));
363path.lineTo(SkBits2Float(0x3e83b355), SkBits2Float(0xc26fff6f));
364path.cubicTo(SkBits2Float(0x3e7f6bf0), SkBits2Float(0xc26fff79), SkBits2Float(0x3e77704b), SkBits2Float(0xc26fff81), SkBits2Float(0x3e6f74a3), SkBits2Float(0xc26fff89));
365path.cubicTo(SkBits2Float(0x3e1fa33e), SkBits2Float(0xc26fffd9), SkBits2Float(0x3d9fa303), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
366path.close();
367path.moveTo(SkBits2Float(0x3e7ee007), SkBits2Float(0xc27f7413));
368path.lineTo(SkBits2Float(0x3e6f7465), SkBits2Float(0xc26fff8a));
369path.lineTo(SkBits2Float(0x3e6f74a4), SkBits2Float(0xc26fff8a));
370path.lineTo(SkBits2Float(0x3e7ee007), SkBits2Float(0xc27f7413));
371path.close();
372
373 SkPath path1(path);
374 path.reset();
375 path.setFillType((SkPathFillType) 0);
376path.moveTo(SkBits2Float(0x3eb62f8c), SkBits2Float(0xc2a5ff9c));
377path.cubicTo(SkBits2Float(0x3f07d31d), SkBits2Float(0xc2a5ff3a), SkBits2Float(0x3f348e3e), SkBits2Float(0xc2a5fe8f), SkBits2Float(0x3f614904), SkBits2Float(0xc2a5fd9c));
378path.lineTo(SkBits2Float(0x3f22db6c), SkBits2Float(0xc26ffc8c));
379path.cubicTo(SkBits2Float(0x3f0285bf), SkBits2Float(0xc26ffdeb), SkBits2Float(0x3ec45fa5), SkBits2Float(0xc26ffee1), SkBits2Float(0x3e83b387), SkBits2Float(0xc26fff6f));
380path.lineTo(SkBits2Float(0x3eb62f8c), SkBits2Float(0xc2a5ff9c));
381path.close();
382
383 SkPath path2(path);
384 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
385}

◆ battleOp110()

static void battleOp110 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2955 of file PathOpsBattles.cpp.

2955 {
2956 SkPath path;
2957 path.setFillType((SkPathFillType) 0);
2958path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2959path.cubicTo(SkBits2Float(0x400cf1ae), SkBits2Float(0xc2a5ffff), SkBits2Float(0x408cea87), SkBits2Float(0xc2a5d31f), SkBits2Float(0x40d32a40), SkBits2Float(0xc2a57979));
2960path.lineTo(SkBits2Float(0x4098a645), SkBits2Float(0xc26f3d83));
2961path.cubicTo(SkBits2Float(0x404bbc01), SkBits2Float(0xc26fbf1e), SkBits2Float(0x3fcbc669), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff59), SkBits2Float(0xc26fffff));
2962path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2963path.close();
2964
2965 SkPath path1(path);
2966 path.reset();
2967 path.setFillType((SkPathFillType) 0);
2968path.moveTo(SkBits2Float(0x40d32a46), SkBits2Float(0xc2a5797a));
2969path.cubicTo(SkBits2Float(0x40da306e), SkBits2Float(0xc2a57083), SkBits2Float(0x40e135fe), SkBits2Float(0xc2a5671a), SkBits2Float(0x40e83aef), SkBits2Float(0xc2a55d3f));
2970path.lineTo(SkBits2Float(0x40a7e090), SkBits2Float(0xc26f14b1));
2971path.cubicTo(SkBits2Float(0x40a2cd8d), SkBits2Float(0xc26f22f4), SkBits2Float(0x409dba1d), SkBits2Float(0xc26f308e), SkBits2Float(0x4098a641), SkBits2Float(0xc26f3d84));
2972path.lineTo(SkBits2Float(0x40d32a46), SkBits2Float(0xc2a5797a));
2973path.close();
2974
2975 SkPath path2(path);
2976 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2977}

◆ battleOp111()

static void battleOp111 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2980 of file PathOpsBattles.cpp.

2980 {
2981 SkPath path;
2982 path.setFillType((SkPathFillType) 1);
2983path.moveTo(SkBits2Float(0x3697ff59), SkBits2Float(0xc26fffff));
2984path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2985path.cubicTo(SkBits2Float(0x400cf1ae), SkBits2Float(0xc2a5ffff), SkBits2Float(0x408cea87), SkBits2Float(0xc2a5d31f), SkBits2Float(0x40d32a46), SkBits2Float(0xc2a5797a));
2986path.cubicTo(SkBits2Float(0x40da306e), SkBits2Float(0xc2a57083), SkBits2Float(0x40e135fe), SkBits2Float(0xc2a5671a), SkBits2Float(0x40e83aef), SkBits2Float(0xc2a55d3f));
2987path.lineTo(SkBits2Float(0x40a7e090), SkBits2Float(0xc26f14b1));
2988path.cubicTo(SkBits2Float(0x40a2cd8f), SkBits2Float(0xc26f22f4), SkBits2Float(0x409dba20), SkBits2Float(0xc26f308e), SkBits2Float(0x4098a645), SkBits2Float(0xc26f3d83));
2989path.cubicTo(SkBits2Float(0x404bbc01), SkBits2Float(0xc26fbf1e), SkBits2Float(0x3fcbc669), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff59), SkBits2Float(0xc26fffff));
2990path.close();
2991path.moveTo(SkBits2Float(0x40b5a39a), SkBits2Float(0xc28e5650));
2992path.lineTo(SkBits2Float(0x4098a641), SkBits2Float(0xc26f3d84));
2993path.lineTo(SkBits2Float(0x4098a646), SkBits2Float(0xc26f3d84));
2994path.lineTo(SkBits2Float(0x40b5a39a), SkBits2Float(0xc28e5650));
2995path.close();
2996
2997 SkPath path1(path);
2998 path.reset();
2999 path.setFillType((SkPathFillType) 0);
3000path.moveTo(SkBits2Float(0x40e83ae9), SkBits2Float(0xc2a55d3f));
3001path.cubicTo(SkBits2Float(0x412d0232), SkBits2Float(0xc2a4bd73), SkBits2Float(0x4165854a), SkBits2Float(0xc2a3a860), SkBits2Float(0x418ea651), SkBits2Float(0xc2a21fbf));
3002path.lineTo(SkBits2Float(0x414e3d91), SkBits2Float(0xc26a656a));
3003path.cubicTo(SkBits2Float(0x4125eb27), SkBits2Float(0xc26c9d13), SkBits2Float(0x40fa2207), SkBits2Float(0xc26e2daa), SkBits2Float(0x40a7e094), SkBits2Float(0xc26f14b2));
3004path.lineTo(SkBits2Float(0x40e83ae9), SkBits2Float(0xc2a55d3f));
3005path.close();
3006
3007 SkPath path2(path);
3008 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3009}

◆ battleOp112()

static void battleOp112 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3012 of file PathOpsBattles.cpp.

3012 {
3013 SkPath path;
3014 path.setFillType((SkPathFillType) 0);
3015path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3016path.cubicTo(SkBits2Float(0x4035711d), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40b561d9), SkBits2Float(0xc2a5b5a1), SkBits2Float(0x4107d050), SkBits2Float(0xc2a5212f));
3017path.lineTo(SkBits2Float(0x40c45b76), SkBits2Float(0xc26ebddb));
3018path.cubicTo(SkBits2Float(0x40831ea4), SkBits2Float(0xc26f947a), SkBits2Float(0x400329ad), SkBits2Float(0xc26fffff), SkBits2Float(0x35bbfd46), SkBits2Float(0xc26fffff));
3019path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3020path.close();
3021
3022 SkPath path1(path);
3023 path.reset();
3024 path.setFillType((SkPathFillType) 0);
3025path.moveTo(SkBits2Float(0x4107d054), SkBits2Float(0xc2a5212f));
3026path.cubicTo(SkBits2Float(0x410c5332), SkBits2Float(0xc2a51258), SkBits2Float(0x4110d578), SkBits2Float(0xc2a502c3), SkBits2Float(0x41155714), SkBits2Float(0xc2a4f271));
3027path.lineTo(SkBits2Float(0x40d7e9e2), SkBits2Float(0xc26e7a46));
3028path.cubicTo(SkBits2Float(0x40d16605), SkBits2Float(0xc26e91e0), SkBits2Float(0x40cae131), SkBits2Float(0xc26ea866), SkBits2Float(0x40c45b7a), SkBits2Float(0xc26ebddc));
3029path.lineTo(SkBits2Float(0x4107d054), SkBits2Float(0xc2a5212f));
3030path.close();
3031
3032 SkPath path2(path);
3033 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3034}

◆ battleOp113()

static void battleOp113 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3037 of file PathOpsBattles.cpp.

3037 {
3038 SkPath path;
3039 path.setFillType((SkPathFillType) 1);
3040path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
3041path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3042path.cubicTo(SkBits2Float(0x4035711d), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40b561d9), SkBits2Float(0xc2a5b5a1), SkBits2Float(0x4107d054), SkBits2Float(0xc2a5212f));
3043path.cubicTo(SkBits2Float(0x410c5332), SkBits2Float(0xc2a51258), SkBits2Float(0x4110d578), SkBits2Float(0xc2a502c3), SkBits2Float(0x41155714), SkBits2Float(0xc2a4f271));
3044path.lineTo(SkBits2Float(0x40d7e9e2), SkBits2Float(0xc26e7a46));
3045path.cubicTo(SkBits2Float(0x40d16605), SkBits2Float(0xc26e91e0), SkBits2Float(0x40cae131), SkBits2Float(0xc26ea866), SkBits2Float(0x40c45b76), SkBits2Float(0xc26ebddb));
3046path.cubicTo(SkBits2Float(0x40831ea4), SkBits2Float(0xc26f947a), SkBits2Float(0x400329ad), SkBits2Float(0xc26fffff), SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
3047path.close();
3048
3049 SkPath path1(path);
3050 path.reset();
3051 path.setFillType((SkPathFillType) 0);
3052path.moveTo(SkBits2Float(0x4115571a), SkBits2Float(0xc2a4f271));
3053path.cubicTo(SkBits2Float(0x415e6818), SkBits2Float(0xc2a3e9d4), SkBits2Float(0x41935478), SkBits2Float(0xc2a21f7a), SkBits2Float(0x41b6ad74), SkBits2Float(0xc29f981d));
3054path.lineTo(SkBits2Float(0x41840e5b), SkBits2Float(0xc266bd14));
3055path.cubicTo(SkBits2Float(0x415501d6), SkBits2Float(0xc26a6507), SkBits2Float(0x4120c6a0), SkBits2Float(0xc26cfbb4), SkBits2Float(0x40d7e9e6), SkBits2Float(0xc26e7a47));
3056path.lineTo(SkBits2Float(0x4115571a), SkBits2Float(0xc2a4f271));
3057path.close();
3058
3059 SkPath path2(path);
3060 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3061}

◆ battleOp114()

static void battleOp114 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3064 of file PathOpsBattles.cpp.

3064 {
3065 SkPath path;
3066 path.setFillType((SkPathFillType) 0);
3067path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3068path.cubicTo(SkBits2Float(0x405f6414), SkBits2Float(0xc2a60000), SkBits2Float(0x40df4798), SkBits2Float(0xc2a58f44), SkBits2Float(0x41270b42), SkBits2Float(0xc2a4ae78));
3069path.lineTo(SkBits2Float(0x40f1826b), SkBits2Float(0xc26e1801));
3070path.cubicTo(SkBits2Float(0x40a16831), SkBits2Float(0xc26f5d03), SkBits2Float(0x40217cc8), SkBits2Float(0xc2700000), SkBits2Float(0x3507fa94), SkBits2Float(0xc2700000));
3071path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3072path.close();
3073
3074 SkPath path1(path);
3075 path.reset();
3076 path.setFillType((SkPathFillType) 0);
3077path.moveTo(SkBits2Float(0x41270b46), SkBits2Float(0xc2a4ae78));
3078path.cubicTo(SkBits2Float(0x412c952a), SkBits2Float(0xc2a497ff), SkBits2Float(0x41321de3), SkBits2Float(0xc2a48068), SkBits2Float(0x4137a563), SkBits2Float(0xc2a467b4));
3079path.lineTo(SkBits2Float(0x4104c195), SkBits2Float(0xc26db1b1));
3080path.cubicTo(SkBits2Float(0x4100c256), SkBits2Float(0xc26dd569), SkBits2Float(0x40f98465), SkBits2Float(0xc26df784), SkBits2Float(0x40f18273), SkBits2Float(0xc26e1801));
3081path.lineTo(SkBits2Float(0x41270b46), SkBits2Float(0xc2a4ae78));
3082path.close();
3083
3084 SkPath path2(path);
3085 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3086}

◆ battleOp115()

static void battleOp115 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3089 of file PathOpsBattles.cpp.

3089 {
3090 SkPath path;
3091 path.setFillType((SkPathFillType) 1);
3092path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3093path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3094path.cubicTo(SkBits2Float(0x405f6414), SkBits2Float(0xc2a60000), SkBits2Float(0x40df4798), SkBits2Float(0xc2a58f44), SkBits2Float(0x41270b46), SkBits2Float(0xc2a4ae78));
3095path.cubicTo(SkBits2Float(0x412c952a), SkBits2Float(0xc2a497ff), SkBits2Float(0x41321de3), SkBits2Float(0xc2a48068), SkBits2Float(0x4137a563), SkBits2Float(0xc2a467b4));
3096path.lineTo(SkBits2Float(0x4104c195), SkBits2Float(0xc26db1b1));
3097path.cubicTo(SkBits2Float(0x4100c256), SkBits2Float(0xc26dd569), SkBits2Float(0x40f98465), SkBits2Float(0xc26df784), SkBits2Float(0x40f1826b), SkBits2Float(0xc26e1801));
3098path.cubicTo(SkBits2Float(0x40a16831), SkBits2Float(0xc26f5d03), SkBits2Float(0x40217cc8), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3099path.close();
3100
3101 SkPath path1(path);
3102 path.reset();
3103 path.setFillType((SkPathFillType) 0);
3104path.moveTo(SkBits2Float(0x4137a563), SkBits2Float(0xc2a467b4));
3105path.cubicTo(SkBits2Float(0x4188a9bf), SkBits2Float(0xc2a2d700), SkBits2Float(0x41b4bec4), SkBits2Float(0xc2a021d5), SkBits2Float(0x41df619b), SkBits2Float(0xc29c5308));
3106path.lineTo(SkBits2Float(0x41a17afe), SkBits2Float(0xc26202d7));
3107path.cubicTo(SkBits2Float(0x4182a8c1), SkBits2Float(0xc2678433), SkBits2Float(0x414595cf), SkBits2Float(0xc26b6e5e), SkBits2Float(0x4104c197), SkBits2Float(0xc26db1b2));
3108path.lineTo(SkBits2Float(0x4137a563), SkBits2Float(0xc2a467b4));
3109path.close();
3110
3111 SkPath path2(path);
3112 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3113}

◆ battleOp116()

static void battleOp116 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3116 of file PathOpsBattles.cpp.

3116 {
3117 SkPath path;
3118 path.setFillType((SkPathFillType) 0);
3119path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3120path.cubicTo(SkBits2Float(0x40894a00), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41092f84), SkBits2Float(0xc2a555af), SkBits2Float(0x414d01d5), SkBits2Float(0xc2a40295));
3121path.lineTo(SkBits2Float(0x411432a9), SkBits2Float(0xc26d1f80));
3122path.cubicTo(SkBits2Float(0x40c65728), SkBits2Float(0xc26f09c3), SkBits2Float(0x40467d64), SkBits2Float(0xc2700000), SkBits2Float(0xb5600574), SkBits2Float(0xc2700000));
3123path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3124path.close();
3125
3126 SkPath path1(path);
3127 path.reset();
3128 path.setFillType((SkPathFillType) 0);
3129path.moveTo(SkBits2Float(0x414d01d1), SkBits2Float(0xc2a40296));
3130path.cubicTo(SkBits2Float(0x4153c92e), SkBits2Float(0xc2a3e0b1), SkBits2Float(0x415a8e6d), SkBits2Float(0xc2a3bd1e), SkBits2Float(0x41615162), SkBits2Float(0xc2a397de));
3131path.lineTo(SkBits2Float(0x4122e164), SkBits2Float(0xc26c8535));
3132path.cubicTo(SkBits2Float(0x411dfe19), SkBits2Float(0xc26cbb11), SkBits2Float(0x41191928), SkBits2Float(0xc26cee7f), SkBits2Float(0x411432ab), SkBits2Float(0xc26d1f80));
3133path.lineTo(SkBits2Float(0x414d01d1), SkBits2Float(0xc2a40296));
3134path.close();
3135
3136 SkPath path2(path);
3137 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3138}

◆ battleOp117()

static void battleOp117 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3141 of file PathOpsBattles.cpp.

3141 {
3142 SkPath path;
3143 path.setFillType((SkPathFillType) 1);
3144path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3145path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3146path.cubicTo(SkBits2Float(0x408949fd), SkBits2Float(0xc2a60000), SkBits2Float(0x41092f81), SkBits2Float(0xc2a555af), SkBits2Float(0x414d01d0), SkBits2Float(0xc2a40295));
3147path.lineTo(SkBits2Float(0x414d01d1), SkBits2Float(0xc2a40296));
3148path.cubicTo(SkBits2Float(0x4153c92e), SkBits2Float(0xc2a3e0b1), SkBits2Float(0x415a8e6d), SkBits2Float(0xc2a3bd1e), SkBits2Float(0x41615162), SkBits2Float(0xc2a397de));
3149path.lineTo(SkBits2Float(0x4122e164), SkBits2Float(0xc26c8535));
3150path.cubicTo(SkBits2Float(0x411dfe19), SkBits2Float(0xc26cbb11), SkBits2Float(0x41191928), SkBits2Float(0xc26cee7f), SkBits2Float(0x411432a9), SkBits2Float(0xc26d1f80));
3151path.cubicTo(SkBits2Float(0x40c65728), SkBits2Float(0xc26f09c3), SkBits2Float(0x40467d64), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3152path.close();
3153
3154 SkPath path1(path);
3155 path.reset();
3156 path.setFillType((SkPathFillType) 0);
3157path.moveTo(SkBits2Float(0x41615164), SkBits2Float(0xc2a397de));
3158path.cubicTo(SkBits2Float(0x41a78432), SkBits2Float(0xc2a13b6d), SkBits2Float(0x41dcf7f2), SkBits2Float(0xc29d27e8), SkBits2Float(0x4207e0f5), SkBits2Float(0xc29775db));
3159path.lineTo(SkBits2Float(0x41c47380), SkBits2Float(0xc25afa96));
3160path.cubicTo(SkBits2Float(0x419fbc7e), SkBits2Float(0xc263369d), SkBits2Float(0x41723143), SkBits2Float(0xc2691b52), SkBits2Float(0x4122e168), SkBits2Float(0xc26c8537));
3161path.lineTo(SkBits2Float(0x41615164), SkBits2Float(0xc2a397de));
3162path.close();
3163
3164 SkPath path2(path);
3165 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3166}

◆ battleOp118()

static void battleOp118 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3169 of file PathOpsBattles.cpp.

3169 {
3170 SkPath path;
3171 path.setFillType((SkPathFillType) 0);
3172path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3173path.cubicTo(SkBits2Float(0x40a2e582), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4122b94f), SkBits2Float(0xc2a51039), SkBits2Float(0x4172cca0), SkBits2Float(0xc2a333b4));
3174path.lineTo(SkBits2Float(0x412f847d), SkBits2Float(0xc26bf464));
3175path.cubicTo(SkBits2Float(0x40eb4376), SkBits2Float(0xc26ea556), SkBits2Float(0x406b836d), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
3176path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3177path.close();
3178
3179 SkPath path1(path);
3180 path.reset();
3181 path.setFillType((SkPathFillType) 0);
3182path.moveTo(SkBits2Float(0x4172cc9b), SkBits2Float(0xc2a333b4));
3183path.cubicTo(SkBits2Float(0x417acd1a), SkBits2Float(0xc2a30415), SkBits2Float(0x41816508), SkBits2Float(0xc2a2d21d), SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcb));
3184path.lineTo(SkBits2Float(0x4140d724), SkBits2Float(0xc26b1ba8));
3185path.cubicTo(SkBits2Float(0x413b139d), SkBits2Float(0xc26b674c), SkBits2Float(0x41354d54), SkBits2Float(0xc26baf8b), SkBits2Float(0x412f847c), SkBits2Float(0xc26bf463));
3186path.lineTo(SkBits2Float(0x4172cc9b), SkBits2Float(0xc2a333b4));
3187path.close();
3188
3189 SkPath path2(path);
3190 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3191}

◆ battleOp119()

static void battleOp119 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3194 of file PathOpsBattles.cpp.

3194 {
3195 SkPath path;
3196 path.setFillType((SkPathFillType) 1);
3197path.moveTo(SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
3198path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3199path.cubicTo(SkBits2Float(0x40a2e57f), SkBits2Float(0xc2a60000), SkBits2Float(0x4122b94c), SkBits2Float(0xc2a51039), SkBits2Float(0x4172cc9b), SkBits2Float(0xc2a333b4));
3200path.lineTo(SkBits2Float(0x4172cca0), SkBits2Float(0xc2a333b4));
3201path.cubicTo(SkBits2Float(0x417acd1d), SkBits2Float(0xc2a30415), SkBits2Float(0x41816509), SkBits2Float(0xc2a2d21d), SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcb));
3202path.lineTo(SkBits2Float(0x4140d724), SkBits2Float(0xc26b1ba8));
3203path.cubicTo(SkBits2Float(0x413b139d), SkBits2Float(0xc26b674c), SkBits2Float(0x41354d54), SkBits2Float(0xc26baf8b), SkBits2Float(0x412f847c), SkBits2Float(0xc26bf463));
3204path.lineTo(SkBits2Float(0x412f847d), SkBits2Float(0xc26bf464));
3205path.cubicTo(SkBits2Float(0x40eb4376), SkBits2Float(0xc26ea556), SkBits2Float(0x406b836d), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
3206path.close();
3207
3208 SkPath path1(path);
3209 path.reset();
3210 path.setFillType((SkPathFillType) 0);
3211path.moveTo(SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcc));
3212path.cubicTo(SkBits2Float(0x41c61a92), SkBits2Float(0xc29f4c69), SkBits2Float(0x42023dd6), SkBits2Float(0xc299958f), SkBits2Float(0x421f3a98), SkBits2Float(0xc291a994));
3213path.lineTo(SkBits2Float(0x41e635e1), SkBits2Float(0xc25298a5));
3214path.cubicTo(SkBits2Float(0x41bc4d11), SkBits2Float(0xc25e0caa), SkBits2Float(0x418f3524), SkBits2Float(0xc2664fa2), SkBits2Float(0x4140d729), SkBits2Float(0xc26b1ba9));
3215path.lineTo(SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcc));
3216path.close();
3217
3218 SkPath path2(path);
3219 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3220}

◆ battleOp12()

static void battleOp12 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 388 of file PathOpsBattles.cpp.

388 { // crashed
389 SkPath path;
390 path.setFillType((SkPathFillType) 0);
391path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
392path.cubicTo(SkBits2Float(0x3ecc43bf), SkBits2Float(0xc2a60000), SkBits2Float(0x3f4c4385), SkBits2Float(0xc2a5fe87), SkBits2Float(0x3f993163), SkBits2Float(0xc2a5fb95));
393path.lineTo(SkBits2Float(0x3f5d7bc4), SkBits2Float(0xc26ff99d));
394path.cubicTo(SkBits2Float(0x3f13a919), SkBits2Float(0xc26ffdde), SkBits2Float(0x3e93a998), SkBits2Float(0xc26fffff), SkBits2Float(0x367b7ed0), SkBits2Float(0xc26fffff));
395path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
396path.close();
397
398 SkPath path1(path);
399 path.reset();
400 path.setFillType((SkPathFillType) 0);
401path.moveTo(SkBits2Float(0x3f993156), SkBits2Float(0xc2a5fb95));
402path.cubicTo(SkBits2Float(0x3f9e4c7a), SkBits2Float(0xc2a5fb49), SkBits2Float(0x3fa36794), SkBits2Float(0xc2a5fafa), SkBits2Float(0x3fa882aa), SkBits2Float(0xc2a5faa7));
403path.lineTo(SkBits2Float(0x3f73a149), SkBits2Float(0xc26ff845));
404path.cubicTo(SkBits2Float(0x3f6c3f64), SkBits2Float(0xc26ff8bf), SkBits2Float(0x3f64dd9d), SkBits2Float(0xc26ff931), SkBits2Float(0x3f5d7bcf), SkBits2Float(0xc26ff99f));
405path.lineTo(SkBits2Float(0x3f993156), SkBits2Float(0xc2a5fb95));
406path.close();
407
408 SkPath path2(path);
409 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
410}

◆ battleOp120()

static void battleOp120 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3223 of file PathOpsBattles.cpp.

3223 {
3224 SkPath path;
3225 path.setFillType((SkPathFillType) 0);
3226path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3227path.cubicTo(SkBits2Float(0x40c39389), SkBits2Float(0xc2a60000), SkBits2Float(0x414346f4), SkBits2Float(0xc2a4a65f), SkBits2Float(0x419158cf), SkBits2Float(0xc2a1f965));
3228path.lineTo(SkBits2Float(0x415223e0), SkBits2Float(0xc26a2df8));
3229path.cubicTo(SkBits2Float(0x410d2a0c), SkBits2Float(0xc26e0c4b), SkBits2Float(0x408d616c), SkBits2Float(0xc2700000), SkBits2Float(0x35bbfd46), SkBits2Float(0xc2700000));
3230path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3231path.close();
3232
3233 SkPath path1(path);
3234 path.reset();
3235 path.setFillType((SkPathFillType) 0);
3236path.moveTo(SkBits2Float(0x419158d0), SkBits2Float(0xc2a1f965));
3237path.cubicTo(SkBits2Float(0x41961cea), SkBits2Float(0xc2a1b4f6), SkBits2Float(0x419addf6), SkBits2Float(0xc2a16d2c), SkBits2Float(0x419f9bbb), SkBits2Float(0xc2a12207));
3238path.lineTo(SkBits2Float(0x4166c251), SkBits2Float(0xc268f69a));
3239path.cubicTo(SkBits2Float(0x415fe778), SkBits2Float(0xc269633e), SkBits2Float(0x415907e2), SkBits2Float(0xc269cb09), SkBits2Float(0x415223e0), SkBits2Float(0xc26a2df8));
3240path.lineTo(SkBits2Float(0x419158d0), SkBits2Float(0xc2a1f965));
3241path.close();
3242
3243 SkPath path2(path);
3244 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3245}

◆ battleOp121()

static void battleOp121 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3248 of file PathOpsBattles.cpp.

3248 {
3249 SkPath path;
3250 path.setFillType((SkPathFillType) 1);
3251path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3252path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3253path.cubicTo(SkBits2Float(0x40c39389), SkBits2Float(0xc2a60000), SkBits2Float(0x414346f4), SkBits2Float(0xc2a4a65f), SkBits2Float(0x419158d0), SkBits2Float(0xc2a1f965));
3254path.cubicTo(SkBits2Float(0x41961cea), SkBits2Float(0xc2a1b4f6), SkBits2Float(0x419addf6), SkBits2Float(0xc2a16d2c), SkBits2Float(0x419f9bbb), SkBits2Float(0xc2a12207));
3255path.lineTo(SkBits2Float(0x4166c251), SkBits2Float(0xc268f69a));
3256path.cubicTo(SkBits2Float(0x415fe778), SkBits2Float(0xc269633e), SkBits2Float(0x415907e2), SkBits2Float(0xc269cb09), SkBits2Float(0x415223e0), SkBits2Float(0xc26a2df8));
3257path.cubicTo(SkBits2Float(0x410d2a0c), SkBits2Float(0xc26e0c4b), SkBits2Float(0x408d616c), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3258path.close();
3259
3260 SkPath path1(path);
3261 path.reset();
3262 path.setFillType((SkPathFillType) 0);
3263path.moveTo(SkBits2Float(0x419f9bbc), SkBits2Float(0xc2a12208));
3264path.cubicTo(SkBits2Float(0x41eca53e), SkBits2Float(0xc29c5d1a), SkBits2Float(0x421ad1be), SkBits2Float(0xc2942e2b), SkBits2Float(0x423b8fe1), SkBits2Float(0xc288f8a3));
3265path.lineTo(SkBits2Float(0x42079647), SkBits2Float(0xc24607dc));
3266path.cubicTo(SkBits2Float(0x41dfd5cc), SkBits2Float(0xc2563c94), SkBits2Float(0x41ab11aa), SkBits2Float(0xc2621167), SkBits2Float(0x4166c24e), SkBits2Float(0xc268f69b));
3267path.lineTo(SkBits2Float(0x419f9bbc), SkBits2Float(0xc2a12208));
3268path.close();
3269
3270 SkPath path2(path);
3271 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3272}

◆ battleOp122()

static void battleOp122 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3275 of file PathOpsBattles.cpp.

3275 {
3276 SkPath path;
3277 path.setFillType((SkPathFillType) 0);
3278path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3279path.cubicTo(SkBits2Float(0x410a1653), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4189aa2f), SkBits2Float(0xc2a34ed0), SkBits2Float(0x41cb63be), SkBits2Float(0xc29e054b));
3280path.lineTo(SkBits2Float(0x41930758), SkBits2Float(0xc26476b2));
3281path.cubicTo(SkBits2Float(0x41470896), SkBits2Float(0xc26c1b98), SkBits2Float(0x40c7a4f2), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea3), SkBits2Float(0xc2700000));
3282path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3283path.close();
3284
3285 SkPath path1(path);
3286 path.reset();
3287 path.setFillType((SkPathFillType) 0);
3288path.moveTo(SkBits2Float(0x41cb63c3), SkBits2Float(0xc29e054c));
3289path.cubicTo(SkBits2Float(0x41d1f2f3), SkBits2Float(0xc29d7e37), SkBits2Float(0x41d879a0), SkBits2Float(0xc29cf09c), SkBits2Float(0x41def72d), SkBits2Float(0xc29c5c87));
3290path.lineTo(SkBits2Float(0x41a12e10), SkBits2Float(0xc2621091));
3291path.cubicTo(SkBits2Float(0x419c7cee), SkBits2Float(0xc262e6aa), SkBits2Float(0x4197c536), SkBits2Float(0xc263b366), SkBits2Float(0x41930757), SkBits2Float(0xc26476b3));
3292path.lineTo(SkBits2Float(0x41cb63c3), SkBits2Float(0xc29e054c));
3293path.close();
3294
3295 SkPath path2(path);
3296 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3297}

◆ battleOp123()

static void battleOp123 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3300 of file PathOpsBattles.cpp.

3300 {
3301 SkPath path;
3302 path.setFillType((SkPathFillType) 1);
3303path.moveTo(SkBits2Float(0x3637fea3), SkBits2Float(0xc2700000));
3304path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3305path.cubicTo(SkBits2Float(0x410a1653), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4189aa2f), SkBits2Float(0xc2a34ed0), SkBits2Float(0x41cb63be), SkBits2Float(0xc29e054b));
3306path.lineTo(SkBits2Float(0x41cb63c3), SkBits2Float(0xc29e054c));
3307path.cubicTo(SkBits2Float(0x41d1f2f3), SkBits2Float(0xc29d7e37), SkBits2Float(0x41d879a0), SkBits2Float(0xc29cf09c), SkBits2Float(0x41def72d), SkBits2Float(0xc29c5c87));
3308path.lineTo(SkBits2Float(0x41a12e10), SkBits2Float(0xc2621091));
3309path.cubicTo(SkBits2Float(0x419c7cee), SkBits2Float(0xc262e6aa), SkBits2Float(0x4197c536), SkBits2Float(0xc263b366), SkBits2Float(0x41930757), SkBits2Float(0xc26476b3));
3310path.lineTo(SkBits2Float(0x41930758), SkBits2Float(0xc26476b2));
3311path.cubicTo(SkBits2Float(0x41470896), SkBits2Float(0xc26c1b98), SkBits2Float(0x40c7a4f2), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea3), SkBits2Float(0xc2700000));
3312path.close();
3313
3314 SkPath path1(path);
3315 path.reset();
3316 path.setFillType((SkPathFillType) 0);
3317path.moveTo(SkBits2Float(0x41def730), SkBits2Float(0xc29c5c87));
3318path.cubicTo(SkBits2Float(0x422459f2), SkBits2Float(0xc292f017), SkBits2Float(0x42539427), SkBits2Float(0xc282f764), SkBits2Float(0x4278c050), SkBits2Float(0xc25be110));
3319path.lineTo(SkBits2Float(0x4233d1f5), SkBits2Float(0xc21ef2e3));
3320path.cubicTo(SkBits2Float(0x4218f2cf), SkBits2Float(0xc23d5956), SkBits2Float(0x41ed9dce), SkBits2Float(0xc25470b6), SkBits2Float(0x41a12e11), SkBits2Float(0xc2621092));
3321path.lineTo(SkBits2Float(0x41def730), SkBits2Float(0xc29c5c87));
3322path.close();
3323
3324 SkPath path2(path);
3325 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3326}

◆ battleOp124()

static void battleOp124 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3329 of file PathOpsBattles.cpp.

3329 {
3330 SkPath path;
3331 path.setFillType((SkPathFillType) 0);
3332path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3333path.cubicTo(SkBits2Float(0x411fc00b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x419f1845), SkBits2Float(0xc2a265a5), SkBits2Float(0x41e9da2b), SkBits2Float(0xc29b5d43));
3334path.lineTo(SkBits2Float(0x41a90cc1), SkBits2Float(0xc2609f84));
3335path.cubicTo(SkBits2Float(0x41660440), SkBits2Float(0xc26aca7c), SkBits2Float(0x40e6f6cd), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa8c), SkBits2Float(0xc2700000));
3336path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3337path.close();
3338
3339 SkPath path1(path);
3340 path.reset();
3341 path.setFillType((SkPathFillType) 0);
3342path.moveTo(SkBits2Float(0x41e9da2e), SkBits2Float(0xc29b5d44));
3343path.cubicTo(SkBits2Float(0x41f14eda), SkBits2Float(0xc29aa9b5), SkBits2Float(0x41f8b671), SkBits2Float(0xc299ed94), SkBits2Float(0x42000805), SkBits2Float(0xc29928f7));
3344path.lineTo(SkBits2Float(0x41b91b05), SkBits2Float(0xc25d6faa));
3345path.cubicTo(SkBits2Float(0x41b3cad4), SkBits2Float(0xc25e8bec), SkBits2Float(0x41ae7086), SkBits2Float(0xc25f9beb), SkBits2Float(0x41a90cc3), SkBits2Float(0xc2609f85));
3346path.lineTo(SkBits2Float(0x41e9da2e), SkBits2Float(0xc29b5d44));
3347path.close();
3348
3349 SkPath path2(path);
3350 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3351}

◆ battleOp125()

static void battleOp125 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3354 of file PathOpsBattles.cpp.

3354 {
3355 SkPath path;
3356 path.setFillType((SkPathFillType) 1);
3357path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3358path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3359path.cubicTo(SkBits2Float(0x411fc00b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x419f1845), SkBits2Float(0xc2a265a5), SkBits2Float(0x41e9da2e), SkBits2Float(0xc29b5d44));
3360path.cubicTo(SkBits2Float(0x41f14eda), SkBits2Float(0xc29aa9b5), SkBits2Float(0x41f8b671), SkBits2Float(0xc299ed94), SkBits2Float(0x42000805), SkBits2Float(0xc29928f7));
3361path.lineTo(SkBits2Float(0x41b91b05), SkBits2Float(0xc25d6faa));
3362path.cubicTo(SkBits2Float(0x41b3cad4), SkBits2Float(0xc25e8bec), SkBits2Float(0x41ae7086), SkBits2Float(0xc25f9beb), SkBits2Float(0x41a90cc1), SkBits2Float(0xc2609f84));
3363path.cubicTo(SkBits2Float(0x41660440), SkBits2Float(0xc26aca7c), SkBits2Float(0x40e6f6cd), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3364path.close();
3365
3366 SkPath path1(path);
3367 path.reset();
3368 path.setFillType((SkPathFillType) 0);
3369path.moveTo(SkBits2Float(0x42000806), SkBits2Float(0xc29928f8));
3370path.cubicTo(SkBits2Float(0x423c0231), SkBits2Float(0xc28ca034), SkBits2Float(0x426f4e95), SkBits2Float(0xc26f2095), SkBits2Float(0x4289c821), SkBits2Float(0xc2392c12));
3371path.lineTo(SkBits2Float(0x424733db), SkBits2Float(0xc205dc02));
3372path.cubicTo(SkBits2Float(0x422cfe35), SkBits2Float(0xc22cdcf5), SkBits2Float(0x4207e8ea), SkBits2Float(0xc24b507f), SkBits2Float(0x41b91b06), SkBits2Float(0xc25d6faa));
3373path.lineTo(SkBits2Float(0x42000806), SkBits2Float(0xc29928f8));
3374path.close();
3375
3376 SkPath path2(path);
3377 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3378}

◆ battleOp126()

static void battleOp126 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3381 of file PathOpsBattles.cpp.

3381 {
3382 SkPath path;
3383 path.setFillType((SkPathFillType) 0);
3384path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3385path.cubicTo(SkBits2Float(0x41379cd4), SkBits2Float(0xc2a60000), SkBits2Float(0x41b69d77), SkBits2Float(0xc2a13d93), SkBits2Float(0x42055871), SkBits2Float(0xc29805ae));
3386path.lineTo(SkBits2Float(0x41c0c9e6), SkBits2Float(0xc25bca86));
3387path.cubicTo(SkBits2Float(0x418402cc), SkBits2Float(0xc2691e6b), SkBits2Float(0x4104bb66), SkBits2Float(0xc26fffff), SkBits2Float(0x3673fea5), SkBits2Float(0xc26fffff));
3388path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3389path.close();
3390
3391 SkPath path1(path);
3392 path.reset();
3393 path.setFillType((SkPathFillType) 0);
3394path.moveTo(SkBits2Float(0x42055872), SkBits2Float(0xc29805ae));
3395path.cubicTo(SkBits2Float(0x420988d2), SkBits2Float(0xc2971a85), SkBits2Float(0x420daf5c), SkBits2Float(0xc296244f), SkBits2Float(0x4211cb64), SkBits2Float(0xc2952332));
3396path.lineTo(SkBits2Float(0x41d2c988), SkBits2Float(0xc2579ed7));
3397path.cubicTo(SkBits2Float(0x41ccd887), SkBits2Float(0xc2591291), SkBits2Float(0x41c6d852), SkBits2Float(0xc25a7689), SkBits2Float(0x41c0c9e6), SkBits2Float(0xc25bca86));
3398path.lineTo(SkBits2Float(0x42055872), SkBits2Float(0xc29805ae));
3399path.close();
3400
3401 SkPath path2(path);
3402 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3403}

◆ battleOp127()

static void battleOp127 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3406 of file PathOpsBattles.cpp.

3406 {
3407 SkPath path;
3408 path.setFillType((SkPathFillType) 1);
3409path.moveTo(SkBits2Float(0x3673fea5), SkBits2Float(0xc26fffff));
3410path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3411path.cubicTo(SkBits2Float(0x41379cd4), SkBits2Float(0xc2a60000), SkBits2Float(0x41b69d77), SkBits2Float(0xc2a13d93), SkBits2Float(0x42055872), SkBits2Float(0xc29805ae));
3412path.cubicTo(SkBits2Float(0x420988d2), SkBits2Float(0xc2971a85), SkBits2Float(0x420daf5c), SkBits2Float(0xc296244f), SkBits2Float(0x4211cb64), SkBits2Float(0xc2952332));
3413path.lineTo(SkBits2Float(0x41d2c988), SkBits2Float(0xc2579ed7));
3414path.cubicTo(SkBits2Float(0x41ccd887), SkBits2Float(0xc2591291), SkBits2Float(0x41c6d852), SkBits2Float(0xc25a7689), SkBits2Float(0x41c0c9e6), SkBits2Float(0xc25bca86));
3415path.cubicTo(SkBits2Float(0x418402cc), SkBits2Float(0xc2691e6b), SkBits2Float(0x4104bb66), SkBits2Float(0xc26fffff), SkBits2Float(0x3673fea5), SkBits2Float(0xc26fffff));
3416path.close();
3417
3418 SkPath path1(path);
3419 path.reset();
3420 path.setFillType((SkPathFillType) 0);
3421path.moveTo(SkBits2Float(0x4211cb65), SkBits2Float(0xc2952332));
3422path.cubicTo(SkBits2Float(0x42550406), SkBits2Float(0xc284b578), SkBits2Float(0x42859569), SkBits2Float(0xc252d13a), SkBits2Float(0x4295bbf4), SkBits2Float(0xc20f53bf));
3423path.lineTo(SkBits2Float(0x42587bb2), SkBits2Float(0xc1cf3850));
3424path.cubicTo(SkBits2Float(0x4241220a), SkBits2Float(0xc21865e8), SkBits2Float(0x4219fcbd), SkBits2Float(0xc23fde48), SkBits2Float(0x41d2c988), SkBits2Float(0xc2579ed8));
3425path.lineTo(SkBits2Float(0x4211cb65), SkBits2Float(0xc2952332));
3426path.close();
3427
3428 SkPath path2(path);
3429 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3430}

◆ battleOp128()

static void battleOp128 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3433 of file PathOpsBattles.cpp.

3433 {
3434 SkPath path;
3435 path.setFillType((SkPathFillType) 0);
3436path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3437path.cubicTo(SkBits2Float(0x4151cd59), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41d04f3f), SkBits2Float(0xc29fc954), SkBits2Float(0x4216e058), SkBits2Float(0xc293de54));
3438path.lineTo(SkBits2Float(0x41da226b), SkBits2Float(0xc255c926));
3439path.cubicTo(SkBits2Float(0x419695d1), SkBits2Float(0xc267043d), SkBits2Float(0x4117aa0a), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
3440path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3441path.close();
3442
3443 SkPath path1(path);
3444 path.reset();
3445 path.setFillType((SkPathFillType) 0);
3446path.moveTo(SkBits2Float(0x4216e057), SkBits2Float(0xc293de54));
3447path.cubicTo(SkBits2Float(0x421b86ea), SkBits2Float(0xc292aea0), SkBits2Float(0x42201eff), SkBits2Float(0xc29170ed), SkBits2Float(0x4224a79b), SkBits2Float(0xc290257e));
3448path.lineTo(SkBits2Float(0x41ee0e15), SkBits2Float(0xc2506790));
3449path.cubicTo(SkBits2Float(0x41e78019), SkBits2Float(0xc25246bf), SkBits2Float(0x41e0dbbc), SkBits2Float(0xc2541212), SkBits2Float(0x41da226b), SkBits2Float(0xc255c927));
3450path.lineTo(SkBits2Float(0x4216e057), SkBits2Float(0xc293de54));
3451path.close();
3452
3453 SkPath path2(path);
3454 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3455}

◆ battleOp129()

static void battleOp129 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3458 of file PathOpsBattles.cpp.

3458 {
3459 SkPath path;
3460 path.setFillType((SkPathFillType) 1);
3461path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
3462path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3463path.cubicTo(SkBits2Float(0x4151cd58), SkBits2Float(0xc2a60000), SkBits2Float(0x41d04f3d), SkBits2Float(0xc29fc954), SkBits2Float(0x4216e057), SkBits2Float(0xc293de54));
3464path.lineTo(SkBits2Float(0x4216e058), SkBits2Float(0xc293de54));
3465path.cubicTo(SkBits2Float(0x421b86eb), SkBits2Float(0xc292aea0), SkBits2Float(0x42201eff), SkBits2Float(0xc29170ed), SkBits2Float(0x4224a79b), SkBits2Float(0xc290257e));
3466path.lineTo(SkBits2Float(0x41ee0e15), SkBits2Float(0xc2506790));
3467path.cubicTo(SkBits2Float(0x41e78019), SkBits2Float(0xc25246bf), SkBits2Float(0x41e0dbbc), SkBits2Float(0xc2541212), SkBits2Float(0x41da226b), SkBits2Float(0xc255c927));
3468path.lineTo(SkBits2Float(0x41da226b), SkBits2Float(0xc255c926));
3469path.cubicTo(SkBits2Float(0x419695d1), SkBits2Float(0xc267043d), SkBits2Float(0x4117aa0a), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
3470path.close();
3471
3472 SkPath path1(path);
3473 path.reset();
3474 path.setFillType((SkPathFillType) 0);
3475path.moveTo(SkBits2Float(0x4224a79b), SkBits2Float(0xc290257f));
3476path.cubicTo(SkBits2Float(0x426f06c3), SkBits2Float(0xc275d105), SkBits2Float(0x42930d85), SkBits2Float(0xc2303df6), SkBits2Float(0x429f3103), SkBits2Float(0xc1bc373f));
3477path.lineTo(SkBits2Float(0x42662806), SkBits2Float(0xc1880f44));
3478path.cubicTo(SkBits2Float(0x42549b44), SkBits2Float(0xc1fececc), SkBits2Float(0x422cca4c), SkBits2Float(0xc231b2de), SkBits2Float(0x41ee0e18), SkBits2Float(0xc2506792));
3479path.lineTo(SkBits2Float(0x4224a79b), SkBits2Float(0xc290257f));
3480path.close();
3481
3482 SkPath path2(path);
3483 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3484}

◆ battleOp13()

static void battleOp13 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 413 of file PathOpsBattles.cpp.

413 {
414 SkPath path;
415 path.setFillType((SkPathFillType) 0);
416path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
417path.cubicTo(SkBits2Float(0x3ddcd524), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e5cd462), SkBits2Float(0xc2a5ffe3), SkBits2Float(0x3ea59eff), SkBits2Float(0xc2a5ffac));
418path.lineTo(SkBits2Float(0x3e6f74a3), SkBits2Float(0xc26fff89));
419path.cubicTo(SkBits2Float(0x3e1fa33e), SkBits2Float(0xc26fffd9), SkBits2Float(0x3d9fa303), SkBits2Float(0xc2700000), SkBits2Float(0xb580e440), SkBits2Float(0xc2700000));
420path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
421path.close();
422
423 SkPath path1(path);
424 path.reset();
425 path.setFillType((SkPathFillType) 0);
426path.moveTo(SkBits2Float(0x3ea59f9c), SkBits2Float(0xc2a5ffad));
427path.cubicTo(SkBits2Float(0x3eab24c0), SkBits2Float(0xc2a5ffa7), SkBits2Float(0x3eb0aa54), SkBits2Float(0xc2a5ffa1), SkBits2Float(0x3eb62fe9), SkBits2Float(0xc2a5ff9b));
428path.lineTo(SkBits2Float(0x3e83b355), SkBits2Float(0xc26fff6f));
429path.cubicTo(SkBits2Float(0x3e7f6bdb), SkBits2Float(0xc26fff79), SkBits2Float(0x3e777021), SkBits2Float(0xc26fff81), SkBits2Float(0x3e6f7465), SkBits2Float(0xc26fff8a));
430path.lineTo(SkBits2Float(0x3ea59f9c), SkBits2Float(0xc2a5ffad));
431path.close();
432
433 SkPath path2(path);
434 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
435}

◆ battleOp130()

static void battleOp130 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3487 of file PathOpsBattles.cpp.

3487 {
3488 SkPath path;
3489 path.setFillType((SkPathFillType) 0);
3490path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3491path.cubicTo(SkBits2Float(0x417054a2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41ee1405), SkBits2Float(0xc29dd904), SkBits2Float(0x422a9595), SkBits2Float(0xc28e6989));
3492path.lineTo(SkBits2Float(0x41f6a0c0), SkBits2Float(0xc24de5b0));
3493path.cubicTo(SkBits2Float(0x41ac1ad0), SkBits2Float(0xc26436ad), SkBits2Float(0x412dbba0), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
3494path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3495path.close();
3496
3497 SkPath path1(path);
3498 path.reset();
3499 path.setFillType((SkPathFillType) 0);
3500path.moveTo(SkBits2Float(0x422a9596), SkBits2Float(0xc28e6989));
3501path.cubicTo(SkBits2Float(0x422fb535), SkBits2Float(0xc28ce0c4), SkBits2Float(0x4234bf65), SkBits2Float(0xc28b465e), SkBits2Float(0x4239b2bc), SkBits2Float(0xc2899acc));
3502path.lineTo(SkBits2Float(0x42063d5a), SkBits2Float(0xc246f24e));
3503path.cubicTo(SkBits2Float(0x4202a934), SkBits2Float(0xc2495c7c), SkBits2Float(0x41fe0912), SkBits2Float(0xc24badd5), SkBits2Float(0x41f6a0c0), SkBits2Float(0xc24de5b1));
3504path.lineTo(SkBits2Float(0x422a9596), SkBits2Float(0xc28e6989));
3505path.close();
3506
3507 SkPath path2(path);
3508 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3509}

◆ battleOp131()

static void battleOp131 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3512 of file PathOpsBattles.cpp.

3512 {
3513 SkPath path;
3514 path.setFillType((SkPathFillType) 1);
3515path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
3516path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3517path.cubicTo(SkBits2Float(0x417054a2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41ee1405), SkBits2Float(0xc29dd904), SkBits2Float(0x422a9596), SkBits2Float(0xc28e6989));
3518path.cubicTo(SkBits2Float(0x422fb535), SkBits2Float(0xc28ce0c4), SkBits2Float(0x4234bf65), SkBits2Float(0xc28b465e), SkBits2Float(0x4239b2bc), SkBits2Float(0xc2899acc));
3519path.lineTo(SkBits2Float(0x42063d5a), SkBits2Float(0xc246f24e));
3520path.cubicTo(SkBits2Float(0x4202a934), SkBits2Float(0xc2495c7c), SkBits2Float(0x41fe0912), SkBits2Float(0xc24badd5), SkBits2Float(0x41f6a0c0), SkBits2Float(0xc24de5b0));
3521path.cubicTo(SkBits2Float(0x41ac1ad0), SkBits2Float(0xc26436ad), SkBits2Float(0x412dbba0), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
3522path.close();
3523
3524 SkPath path1(path);
3525 path.reset();
3526 path.setFillType((SkPathFillType) 0);
3527path.moveTo(SkBits2Float(0x4239b2bd), SkBits2Float(0xc2899acc));
3528path.cubicTo(SkBits2Float(0x42859c2b), SkBits2Float(0xc25c33ca), SkBits2Float(0x42a01474), SkBits2Float(0xc203e23a), SkBits2Float(0x42a51fce), SkBits2Float(0xc1083bae));
3529path.lineTo(SkBits2Float(0x426ebbdb), SkBits2Float(0xc0c4f6ab));
3530path.cubicTo(SkBits2Float(0x426770d9), SkBits2Float(0xc1beacda), SkBits2Float(0x42412bce), SkBits2Float(0xc21f2eb0), SkBits2Float(0x42063d5a), SkBits2Float(0xc246f24e));
3531path.lineTo(SkBits2Float(0x4239b2bd), SkBits2Float(0xc2899acc));
3532path.close();
3533
3534 SkPath path2(path);
3535 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3536}

◆ battleOp132()

static void battleOp132 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3539 of file PathOpsBattles.cpp.

3539 {
3540 SkPath path;
3541 path.setFillType((SkPathFillType) 0);
3542path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3543path.cubicTo(SkBits2Float(0x4187e175), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42063ec3), SkBits2Float(0xc29b93fb), SkBits2Float(0x423df6fd), SkBits2Float(0xc2882410));
3544path.lineTo(SkBits2Float(0x420952ef), SkBits2Float(0xc244d488));
3545path.cubicTo(SkBits2Float(0x41c216e4), SkBits2Float(0xc260eea0), SkBits2Float(0x4144743c), SkBits2Float(0xc26fffff), SkBits2Float(0x357ffa94), SkBits2Float(0xc26fffff));
3546path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3547path.close();
3548
3549 SkPath path1(path);
3550 path.reset();
3551 path.setFillType((SkPathFillType) 0);
3552path.moveTo(SkBits2Float(0x423df6fe), SkBits2Float(0xc2882411));
3553path.cubicTo(SkBits2Float(0x42437e7a), SkBits2Float(0xc286364a), SkBits2Float(0x4248e78f), SkBits2Float(0xc2843312), SkBits2Float(0x424e304d), SkBits2Float(0xc2821b20));
3554path.lineTo(SkBits2Float(0x42150d53), SkBits2Float(0xc23c1ae0));
3555path.cubicTo(SkBits2Float(0x42113b72), SkBits2Float(0xc23f21be), SkBits2Float(0x420d522e), SkBits2Float(0xc2420aa4), SkBits2Float(0x420952ef), SkBits2Float(0xc244d48a));
3556path.lineTo(SkBits2Float(0x423df6fe), SkBits2Float(0xc2882411));
3557path.close();
3558
3559 SkPath path2(path);
3560 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3561}

◆ battleOp133()

static void battleOp133 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3564 of file PathOpsBattles.cpp.

3564 {
3565 SkPath path;
3566 path.setFillType((SkPathFillType) 1);
3567path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
3568path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3569path.cubicTo(SkBits2Float(0x4187e175), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42063ec3), SkBits2Float(0xc29b93fb), SkBits2Float(0x423df6fe), SkBits2Float(0xc2882411));
3570path.cubicTo(SkBits2Float(0x42437e7a), SkBits2Float(0xc286364a), SkBits2Float(0x4248e78f), SkBits2Float(0xc2843312), SkBits2Float(0x424e304d), SkBits2Float(0xc2821b20));
3571path.lineTo(SkBits2Float(0x42150d53), SkBits2Float(0xc23c1ae0));
3572path.cubicTo(SkBits2Float(0x42113b72), SkBits2Float(0xc23f21be), SkBits2Float(0x420d522e), SkBits2Float(0xc2420aa4), SkBits2Float(0x420952ef), SkBits2Float(0xc244d48a));
3573path.lineTo(SkBits2Float(0x420952ef), SkBits2Float(0xc244d488));
3574path.cubicTo(SkBits2Float(0x41c216e4), SkBits2Float(0xc260eea0), SkBits2Float(0x4144743c), SkBits2Float(0xc26fffff), SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
3575path.close();
3576
3577 SkPath path1(path);
3578 path.reset();
3579 path.setFillType((SkPathFillType) 0);
3580path.moveTo(SkBits2Float(0x424e304d), SkBits2Float(0xc2821b20));
3581path.cubicTo(SkBits2Float(0x4292cbf1), SkBits2Float(0xc23ef41d), SkBits2Float(0x42aa31a6), SkBits2Float(0xc1a4e14c), SkBits2Float(0x42a56158), SkBits2Float(0x40e54b3a));
3582path.lineTo(SkBits2Float(0x426f1a9e), SkBits2Float(0x40a5c12f));
3583path.cubicTo(SkBits2Float(0x42761044), SkBits2Float(0xc16e617c), SkBits2Float(0x42543c73), SkBits2Float(0xc20a09ea), SkBits2Float(0x42150d54), SkBits2Float(0xc23c1ae1));
3584path.lineTo(SkBits2Float(0x424e304d), SkBits2Float(0xc2821b20));
3585path.close();
3586
3587 SkPath path2(path);
3588 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3589}

◆ battleOp134()

static void battleOp134 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3592 of file PathOpsBattles.cpp.

3592 {
3593 SkPath path;
3594 path.setFillType((SkPathFillType) 0);
3595path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3596path.cubicTo(SkBits2Float(0x419c5b1f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4219d929), SkBits2Float(0xc29834b3), SkBits2Float(0x4255ae76), SkBits2Float(0xc27e184c));
3597path.lineTo(SkBits2Float(0x421a77f2), SkBits2Float(0xc237aede));
3598path.cubicTo(SkBits2Float(0x41de6e66), SkBits2Float(0xc25c0e82), SkBits2Float(0x41620e8a), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
3599path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3600path.close();
3601
3602 SkPath path1(path);
3603 path.reset();
3604 path.setFillType((SkPathFillType) 0);
3605path.moveTo(SkBits2Float(0x4255ae76), SkBits2Float(0xc27e184c));
3606path.cubicTo(SkBits2Float(0x425b9ab5), SkBits2Float(0xc2791d33), SkBits2Float(0x426159ea), SkBits2Float(0xc273ed7b), SkBits2Float(0x4266e960), SkBits2Float(0xc26e8b92));
3607path.lineTo(SkBits2Float(0x4226ec90), SkBits2Float(0xc22c713c));
3608path.cubicTo(SkBits2Float(0x4222e78d), SkBits2Float(0xc2305550), SkBits2Float(0x421ec008), SkBits2Float(0xc234151d), SkBits2Float(0x421a77f3), SkBits2Float(0xc237aedd));
3609path.lineTo(SkBits2Float(0x4255ae76), SkBits2Float(0xc27e184c));
3610path.close();
3611
3612 SkPath path2(path);
3613 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3614}

◆ battleOp135()

static void battleOp135 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3617 of file PathOpsBattles.cpp.

3617 {
3618 SkPath path;
3619 path.setFillType((SkPathFillType) 1);
3620path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
3621path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3622path.cubicTo(SkBits2Float(0x419c5b1f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4219d929), SkBits2Float(0xc29834b3), SkBits2Float(0x4255ae76), SkBits2Float(0xc27e184c));
3623path.cubicTo(SkBits2Float(0x425b9ab5), SkBits2Float(0xc2791d33), SkBits2Float(0x426159ea), SkBits2Float(0xc273ed7b), SkBits2Float(0x4266e960), SkBits2Float(0xc26e8b92));
3624path.lineTo(SkBits2Float(0x4226ec90), SkBits2Float(0xc22c713c));
3625path.cubicTo(SkBits2Float(0x4222e78d), SkBits2Float(0xc2305550), SkBits2Float(0x421ec008), SkBits2Float(0xc234151d), SkBits2Float(0x421a77f2), SkBits2Float(0xc237aede));
3626path.cubicTo(SkBits2Float(0x41de6e66), SkBits2Float(0xc25c0e82), SkBits2Float(0x41620e8a), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
3627path.close();
3628
3629 SkPath path1(path);
3630 path.reset();
3631 path.setFillType((SkPathFillType) 0);
3632path.moveTo(SkBits2Float(0x4266e961), SkBits2Float(0xc26e8b93));
3633path.cubicTo(SkBits2Float(0x42a1bfce), SkBits2Float(0xc214ebcf), SkBits2Float(0x42b1ee5a), SkBits2Float(0xc05d1412), SkBits2Float(0x429cf75a), SkBits2Float(0x41d80f2c));
3634path.lineTo(SkBits2Float(0x4262f06b), SkBits2Float(0x419c2ffb));
3635path.cubicTo(SkBits2Float(0x42809ff9), SkBits2Float(0xc01fd0e5), SkBits2Float(0x4269dab8), SkBits2Float(0xc1d74ec6), SkBits2Float(0x4226ec91), SkBits2Float(0xc22c713d));
3636path.lineTo(SkBits2Float(0x4266e961), SkBits2Float(0xc26e8b93));
3637path.close();
3638
3639 SkPath path2(path);
3640 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3641}

◆ battleOp136()

static void battleOp136 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3644 of file PathOpsBattles.cpp.

3644 {
3645 SkPath path;
3646 path.setFillType((SkPathFillType) 0);
3647path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3648path.cubicTo(SkBits2Float(0x41ae0130), SkBits2Float(0xc2a5ffff), SkBits2Float(0x422a8737), SkBits2Float(0xc294ec91), SkBits2Float(0x42689b67), SkBits2Float(0xc26ce46c));
3649path.lineTo(SkBits2Float(0x42282651), SkBits2Float(0xc22b3f58));
3650path.cubicTo(SkBits2Float(0x41f68bfb), SkBits2Float(0xc2574fdc), SkBits2Float(0x417b92b3), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
3651path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3652path.close();
3653
3654 SkPath path1(path);
3655 path.reset();
3656 path.setFillType((SkPathFillType) 0);
3657path.moveTo(SkBits2Float(0x42689b68), SkBits2Float(0xc26ce46d));
3658path.cubicTo(SkBits2Float(0x426ebcd2), SkBits2Float(0xc266df67), SkBits2Float(0x4274a1d2), SkBits2Float(0xc2609e09), SkBits2Float(0x427a4701), SkBits2Float(0xc25a23f2));
3659path.lineTo(SkBits2Float(0x4234ec64), SkBits2Float(0xc21db11e));
3660path.cubicTo(SkBits2Float(0x4230d7ae), SkBits2Float(0xc2225fbc), SkBits2Float(0x422c94d6), SkBits2Float(0xc226e55a), SkBits2Float(0x42282652), SkBits2Float(0xc22b3f58));
3661path.lineTo(SkBits2Float(0x42689b68), SkBits2Float(0xc26ce46d));
3662path.close();
3663
3664 SkPath path2(path);
3665 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3666}

◆ battleOp137()

static void battleOp137 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3669 of file PathOpsBattles.cpp.

3669 {
3670 SkPath path;
3671 path.setFillType((SkPathFillType) 1);
3672path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3673path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3674path.cubicTo(SkBits2Float(0x41ae0130), SkBits2Float(0xc2a5ffff), SkBits2Float(0x422a8737), SkBits2Float(0xc294ec91), SkBits2Float(0x42689b68), SkBits2Float(0xc26ce46d));
3675path.cubicTo(SkBits2Float(0x426ebcd2), SkBits2Float(0xc266df67), SkBits2Float(0x4274a1d2), SkBits2Float(0xc2609e09), SkBits2Float(0x427a4701), SkBits2Float(0xc25a23f2));
3676path.lineTo(SkBits2Float(0x4234ec64), SkBits2Float(0xc21db11e));
3677path.cubicTo(SkBits2Float(0x4230d7ae), SkBits2Float(0xc2225fbc), SkBits2Float(0x422c94d6), SkBits2Float(0xc226e55a), SkBits2Float(0x42282651), SkBits2Float(0xc22b3f58));
3678path.cubicTo(SkBits2Float(0x41f68bfb), SkBits2Float(0xc2574fdc), SkBits2Float(0x417b92b3), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3679path.close();
3680
3681 SkPath path1(path);
3682 path.reset();
3683 path.setFillType((SkPathFillType) 0);
3684path.moveTo(SkBits2Float(0x427a4702), SkBits2Float(0xc25a23f2));
3685path.cubicTo(SkBits2Float(0x42ac7185), SkBits2Float(0xc1db2f83), SkBits2Float(0x42b35ed0), SkBits2Float(0x413e447a), SkBits2Float(0x428e4a3d), SkBits2Float(0x422afde8));
3686path.lineTo(SkBits2Float(0x424db871), SkBits2Float(0x41f73799));
3687path.cubicTo(SkBits2Float(0x4281aa54), SkBits2Float(0x41098afa), SkBits2Float(0x427950da), SkBits2Float(0xc19e728d), SkBits2Float(0x4234ec66), SkBits2Float(0xc21db120));
3688path.lineTo(SkBits2Float(0x427a4702), SkBits2Float(0xc25a23f2));
3689path.close();
3690
3691 SkPath path2(path);
3692 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3693}

◆ battleOp138()

static void battleOp138 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3696 of file PathOpsBattles.cpp.

3696 {
3697 SkPath path;
3698 path.setFillType((SkPathFillType) 0);
3699path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3700path.cubicTo(SkBits2Float(0x41c2602d), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423d7ece), SkBits2Float(0xc290b51a), SkBits2Float(0x427c92bc), SkBits2Float(0xc2577a5f));
3701path.lineTo(SkBits2Float(0x42369543), SkBits2Float(0xc21bc469));
3702path.cubicTo(SkBits2Float(0x4208fc10), SkBits2Float(0xc2513731), SkBits2Float(0x418c8338), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
3703path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3704path.close();
3705
3706 SkPath path1(path);
3707 path.reset();
3708 path.setFillType((SkPathFillType) 0);
3709path.moveTo(SkBits2Float(0x427c92be), SkBits2Float(0xc2577a5f));
3710path.cubicTo(SkBits2Float(0x42816448), SkBits2Float(0xc25032db), SkBits2Float(0x42845689), SkBits2Float(0xc248a77c), SkBits2Float(0x42871e08), SkBits2Float(0xc240ddaa));
3711path.lineTo(SkBits2Float(0x424359af), SkBits2Float(0xc20b6bce));
3712path.cubicTo(SkBits2Float(0x423f5505), SkBits2Float(0xc2110d1f), SkBits2Float(0x423b1287), SkBits2Float(0xc216814b), SkBits2Float(0x42369543), SkBits2Float(0xc21bc46a));
3713path.lineTo(SkBits2Float(0x427c92be), SkBits2Float(0xc2577a5f));
3714path.close();
3715
3716 SkPath path2(path);
3717 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3718}

◆ battleOp139()

static void battleOp139 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3721 of file PathOpsBattles.cpp.

3721 {
3722 SkPath path;
3723 path.setFillType((SkPathFillType) 1);
3724path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3725path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3726path.cubicTo(SkBits2Float(0x41c2602d), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423d7ece), SkBits2Float(0xc290b51a), SkBits2Float(0x427c92bc), SkBits2Float(0xc2577a5f));
3727path.lineTo(SkBits2Float(0x427c92be), SkBits2Float(0xc2577a5f));
3728path.cubicTo(SkBits2Float(0x42816448), SkBits2Float(0xc25032db), SkBits2Float(0x42845689), SkBits2Float(0xc248a77c), SkBits2Float(0x42871e08), SkBits2Float(0xc240ddaa));
3729path.lineTo(SkBits2Float(0x424359af), SkBits2Float(0xc20b6bce));
3730path.cubicTo(SkBits2Float(0x423f5505), SkBits2Float(0xc2110d1f), SkBits2Float(0x423b1287), SkBits2Float(0xc216814a), SkBits2Float(0x42369543), SkBits2Float(0xc21bc469));
3731path.lineTo(SkBits2Float(0x42369543), SkBits2Float(0xc21bc46a));
3732path.cubicTo(SkBits2Float(0x4208fc10), SkBits2Float(0xc2513732), SkBits2Float(0x418c8337), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3733path.close();
3734
3735 SkPath path1(path);
3736 path.reset();
3737 path.setFillType((SkPathFillType) 0);
3738path.moveTo(SkBits2Float(0x42871e08), SkBits2Float(0xc240ddaa));
3739path.cubicTo(SkBits2Float(0x42b615a2), SkBits2Float(0xc174ff4e), SkBits2Float(0x42aecf41), SkBits2Float(0x41edcc49), SkBits2Float(0x426bc7a7), SkBits2Float(0x4269bc09));
3740path.lineTo(SkBits2Float(0x422a717e), SkBits2Float(0x4228f6f7));
3741path.cubicTo(SkBits2Float(0x427cbca0), SkBits2Float(0x41abe6f4), SkBits2Float(0x4283a09b), SkBits2Float(0xc1311b44), SkBits2Float(0x424359af), SkBits2Float(0xc20b6bcd));
3742path.lineTo(SkBits2Float(0x42871e08), SkBits2Float(0xc240ddaa));
3743path.close();
3744
3745 SkPath path2(path);
3746 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3747}

◆ battleOp1390()

static void battleOp1390 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9951 of file PathOpsBattles.cpp.

9951 {
9952 SkPath path;
9953 path.setFillType((SkPathFillType) 1);
9954path.moveTo(SkBits2Float(0xb7240057), SkBits2Float(0xc2700000));
9955path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9956path.cubicTo(SkBits2Float(0x420377ff), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427a8dc0), SkBits2Float(0xc27e6c2f), SkBits2Float(0x4297d760), SkBits2Float(0xc2062ad2));
9957path.cubicTo(SkBits2Float(0x42b267e1), SkBits2Float(0xc05e974f), SkBits2Float(0x42a6fcda), SkBits2Float(0x41fcbb92), SkBits2Float(0x42757289), SkBits2Float(0x425f8fa5));
9958path.cubicTo(SkBits2Float(0x426437a0), SkBits2Float(0x42727a5f), SkBits2Float(0x4250dbaa), SkBits2Float(0x4281ab79), SkBits2Float(0x423bc155), SkBits2Float(0x4288e7b2));
9959path.lineTo(SkBits2Float(0x4207ba06), SkBits2Float(0x4245ef5e));
9960path.cubicTo(SkBits2Float(0x4216fb52), SkBits2Float(0x423b7973), SkBits2Float(0x4224f9f2), SkBits2Float(0x422f490a), SkBits2Float(0x42316e8e), SkBits2Float(0x42219c46));
9961path.cubicTo(SkBits2Float(0x42716d91), SkBits2Float(0x41b6b2c9), SkBits2Float(0x4280f7d1), SkBits2Float(0xc020e8c8), SkBits2Float(0x425b8794), SkBits2Float(0xc1c1fa0e));
9962path.cubicTo(SkBits2Float(0x42351f87), SkBits2Float(0xc237eb83), SkBits2Float(0x41be1342), SkBits2Float(0xc2700002), SkBits2Float(0xb7240057), SkBits2Float(0xc2700000));
9963path.close();
9964
9965 SkPath path1(path);
9966 path.reset();
9967 path.setFillType((SkPathFillType) 0);
9968path.moveTo(SkBits2Float(0x423bc156), SkBits2Float(0x4288e7b2));
9969path.cubicTo(SkBits2Float(0x418c1984), SkBits2Float(0x42b142da), SkBits2Float(0xc1ac2314), SkBits2Float(0x42af7d21), SkBits2Float(0xc247fd43), SkBits2Float(0x428480ce));
9970path.cubicTo(SkBits2Float(0xc29cf47f), SkBits2Float(0x423308f3), SkBits2Float(0xc2b411dd), SkBits2Float(0x40ef0242), SkBits2Float(0xc29d6757), SkBits2Float(0xc1d2e807));
9971path.cubicTo(SkBits2Float(0xc286bcd2), SkBits2Float(0xc270c84c), SkBits2Float(0xc20eb9e2), SkBits2Float(0xc2a5ffaa), SkBits2Float(0xbac6f0ca), SkBits2Float(0xc2a5ffff));
9972path.lineTo(SkBits2Float(0xba901698), SkBits2Float(0xc2700000));
9973path.cubicTo(SkBits2Float(0xc1ce59d7), SkBits2Float(0xc26fff83), SkBits2Float(0xc242cd21), SkBits2Float(0xc22e0f3f), SkBits2Float(0xc263924f), SkBits2Float(0xc1987661));
9974path.cubicTo(SkBits2Float(0xc2822bbf), SkBits2Float(0x40acc6fd), SkBits2Float(0xc262ec43), SkBits2Float(0x42016c3b), SkBits2Float(0xc2109210), SkBits2Float(0x423f921c));
9975path.cubicTo(SkBits2Float(0xc178df72), SkBits2Float(0x427db7fc), SkBits2Float(0x414a8dba), SkBits2Float(0x428023fd), SkBits2Float(0x4207ba05), SkBits2Float(0x4245ef60));
9976path.lineTo(SkBits2Float(0x423bc156), SkBits2Float(0x4288e7b2));
9977path.close();
9978
9979 SkPath path2(path);
9980 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9981}

◆ battleOp1391()

static void battleOp1391 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9984 of file PathOpsBattles.cpp.

9984 {
9985 SkPath path;
9986 path.setFillType((SkPathFillType) 0);
9987path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9988path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9989path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9990path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9991path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9992path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9993path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9994path.close();
9995
9996 SkPath path1(path);
9997 path.reset();
9998 path.setFillType((SkPathFillType) 0);
9999path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10000path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10001path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10002path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10003path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10004path.close();
10005
10006 SkPath path2(path);
10007 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10008}

◆ battleOp1392()

static void battleOp1392 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10011 of file PathOpsBattles.cpp.

10011 {
10012 SkPath path;
10013 path.setFillType((SkPathFillType) 1);
10014path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10015path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10016path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10017path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10018path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10019path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10020path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10021path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10022path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10023path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10024path.close();
10025
10026 SkPath path1(path);
10027 path.reset();
10028 path.setFillType((SkPathFillType) 0);
10029path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10030path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
10031path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
10032path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
10033path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
10034path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
10035path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
10036path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10037path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10038path.close();
10039
10040 SkPath path2(path);
10041 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10042}

◆ battleOp1393()

static void battleOp1393 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10045 of file PathOpsBattles.cpp.

10045 {
10046 SkPath path;
10047 path.setFillType((SkPathFillType) 0);
10048path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10049path.cubicTo(SkBits2Float(0x3c436965), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3cc36072), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d128619), SkBits2Float(0xc2a5fffe));
10050path.lineTo(SkBits2Float(0x3cd3db06), SkBits2Float(0xc26fffff));
10051path.cubicTo(SkBits2Float(0x3c8d3d03), SkBits2Float(0xc2700000), SkBits2Float(0x3c0d4407), SkBits2Float(0xc2700000), SkBits2Float(0x36606a00), SkBits2Float(0xc2700000));
10052path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10053path.close();
10054
10055 SkPath path1(path);
10056 path.reset();
10057 path.setFillType((SkPathFillType) 0);
10058path.moveTo(SkBits2Float(0x3d12888d), SkBits2Float(0xc2a5ffff));
10059path.cubicTo(SkBits2Float(0x3d176d55), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d1c4dcb), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d212e40), SkBits2Float(0xc2a5ffff));
10060path.lineTo(SkBits2Float(0x3ce90a84), SkBits2Float(0xc26ffffe));
10061path.cubicTo(SkBits2Float(0x3ce1ffb6), SkBits2Float(0xc26ffffe), SkBits2Float(0x3cdaedb6), SkBits2Float(0xc26fffff), SkBits2Float(0x3cd3dbb7), SkBits2Float(0xc26fffff));
10062path.lineTo(SkBits2Float(0x3d12888d), SkBits2Float(0xc2a5ffff));
10063path.close();
10064
10065 SkPath path2(path);
10066 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10067}

◆ battleOp1394()

static void battleOp1394 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10070 of file PathOpsBattles.cpp.

10070 {
10071 SkPath path;
10072 path.setFillType((SkPathFillType) 1);
10073path.moveTo(SkBits2Float(0x36606a00), SkBits2Float(0xc2700000));
10074path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10075path.cubicTo(SkBits2Float(0x3c436965), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3cc36072), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d128619), SkBits2Float(0xc2a5fffe));
10076path.lineTo(SkBits2Float(0x3d12888d), SkBits2Float(0xc2a5ffff));
10077path.lineTo(SkBits2Float(0x3d212e40), SkBits2Float(0xc2a5ffff));
10078path.lineTo(SkBits2Float(0x3ce90a84), SkBits2Float(0xc26ffffe));
10079path.cubicTo(SkBits2Float(0x3ce1ffb6), SkBits2Float(0xc26ffffe), SkBits2Float(0x3cdaedb6), SkBits2Float(0xc26fffff), SkBits2Float(0x3cd3db06), SkBits2Float(0xc26fffff));
10080path.cubicTo(SkBits2Float(0x3c8d3d03), SkBits2Float(0xc2700000), SkBits2Float(0x3c0d4407), SkBits2Float(0xc2700000), SkBits2Float(0x36606a00), SkBits2Float(0xc2700000));
10081path.close();
10082
10083 SkPath path1(path);
10084 path.reset();
10085 path.setFillType((SkPathFillType) 0);
10086path.moveTo(SkBits2Float(0x3d212fd0), SkBits2Float(0xc2a5ffff));
10087path.cubicTo(SkBits2Float(0x3d705530), SkBits2Float(0xc2a5fffe), SkBits2Float(0x3d9fbf82), SkBits2Float(0xc2a5fffc), SkBits2Float(0x3dc7546b), SkBits2Float(0xc2a5fffa));
10088path.lineTo(SkBits2Float(0x3d901696), SkBits2Float(0xc26ffff5));
10089path.cubicTo(SkBits2Float(0x3d66f230), SkBits2Float(0xc26ffff9), SkBits2Float(0x3d2dbab1), SkBits2Float(0xc26ffffc), SkBits2Float(0x3ce90664), SkBits2Float(0xc26ffffe));
10090path.lineTo(SkBits2Float(0x3d212fd0), SkBits2Float(0xc2a5ffff));
10091path.close();
10092
10093 SkPath path2(path);
10094 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10095}

◆ battleOp1395()

static void battleOp1395 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10098 of file PathOpsBattles.cpp.

10098 {
10099 SkPath path;
10100 path.setFillType((SkPathFillType) 0);
10101path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10102path.cubicTo(SkBits2Float(0x3e06023f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e860192), SkBits2Float(0xc2a5ffd6), SkBits2Float(0x3ec901db), SkBits2Float(0xc2a5ff85));
10103path.lineTo(SkBits2Float(0x3e914e16), SkBits2Float(0xc26fff50));
10104path.cubicTo(SkBits2Float(0x3e41bddf), SkBits2Float(0xc26fffc5), SkBits2Float(0x3dc1be4c), SkBits2Float(0xc26fffff), SkBits2Float(0x35c55da0), SkBits2Float(0xc26fffff));
10105path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10106path.close();
10107
10108 SkPath path1(path);
10109 path.reset();
10110 path.setFillType((SkPathFillType) 0);
10111path.moveTo(SkBits2Float(0x3ec9015b), SkBits2Float(0xc2a5ff86));
10112path.cubicTo(SkBits2Float(0x3ecfb4f0), SkBits2Float(0xc2a5ff7d), SkBits2Float(0x3ed66842), SkBits2Float(0xc2a5ff75), SkBits2Float(0x3edd1b92), SkBits2Float(0xc2a5ff6c));
10113path.lineTo(SkBits2Float(0x3e9fd5de), SkBits2Float(0xc26fff2b));
10114path.cubicTo(SkBits2Float(0x3e9afe3a), SkBits2Float(0xc26fff39), SkBits2Float(0x3e96263d), SkBits2Float(0xc26fff45), SkBits2Float(0x3e914e41), SkBits2Float(0xc26fff51));
10115path.lineTo(SkBits2Float(0x3ec9015b), SkBits2Float(0xc2a5ff86));
10116path.close();
10117
10118 SkPath path2(path);
10119 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10120}

◆ battleOp1396()

static void battleOp1396 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10123 of file PathOpsBattles.cpp.

10123 {
10124 SkPath path;
10125 path.setFillType((SkPathFillType) 1);
10126path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
10127path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10128path.cubicTo(SkBits2Float(0x3e0601e9), SkBits2Float(0xc2a60000), SkBits2Float(0x3e86013c), SkBits2Float(0xc2a5ffd6), SkBits2Float(0x3ec9015a), SkBits2Float(0xc2a5ff85));
10129path.lineTo(SkBits2Float(0x3ec9015b), SkBits2Float(0xc2a5ff86));
10130path.cubicTo(SkBits2Float(0x3ecfb4f0), SkBits2Float(0xc2a5ff7d), SkBits2Float(0x3ed66842), SkBits2Float(0xc2a5ff75), SkBits2Float(0x3edd1b92), SkBits2Float(0xc2a5ff6c));
10131path.lineTo(SkBits2Float(0x3e9fd5de), SkBits2Float(0xc26fff2b));
10132path.cubicTo(SkBits2Float(0x3e9afe3a), SkBits2Float(0xc26fff39), SkBits2Float(0x3e96263d), SkBits2Float(0xc26fff45), SkBits2Float(0x3e914e16), SkBits2Float(0xc26fff50));
10133path.cubicTo(SkBits2Float(0x3e41bddf), SkBits2Float(0xc26fffc5), SkBits2Float(0x3dc1be4c), SkBits2Float(0xc26fffff), SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
10134path.close();
10135
10136 SkPath path1(path);
10137 path.reset();
10138 path.setFillType((SkPathFillType) 0);
10139path.moveTo(SkBits2Float(0x3edd1b0d), SkBits2Float(0xc2a5ff6d));
10140path.cubicTo(SkBits2Float(0x3f24d70e), SkBits2Float(0xc2a5fedc), SkBits2Float(0x3f5b204e), SkBits2Float(0xc2a5fde1), SkBits2Float(0x3f88b475), SkBits2Float(0xc2a5fc7b));
10141path.lineTo(SkBits2Float(0x3f45a57e), SkBits2Float(0xc26ffaea));
10142path.cubicTo(SkBits2Float(0x3f1e67a6), SkBits2Float(0xc26ffcf1), SkBits2Float(0x3eee52e7), SkBits2Float(0xc26ffe5c), SkBits2Float(0x3e9fd606), SkBits2Float(0xc26fff2d));
10143path.lineTo(SkBits2Float(0x3edd1b0d), SkBits2Float(0xc2a5ff6d));
10144path.close();
10145
10146 SkPath path2(path);
10147 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10148}

◆ battleOp14()

static void battleOp14 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 438 of file PathOpsBattles.cpp.

438 {
439 SkPath path;
440 path.setFillType((SkPathFillType) 1);
441path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
442path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
443path.cubicTo(SkBits2Float(0x3ddcd524), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e5cd462), SkBits2Float(0xc2a5ffe3), SkBits2Float(0x3ea59f9c), SkBits2Float(0xc2a5ffad));
444path.lineTo(SkBits2Float(0x3eb62fe9), SkBits2Float(0xc2a5ff9b));
445path.lineTo(SkBits2Float(0x3e83b355), SkBits2Float(0xc26fff6f));
446path.cubicTo(SkBits2Float(0x3e7f6bf0), SkBits2Float(0xc26fff79), SkBits2Float(0x3e77704b), SkBits2Float(0xc26fff81), SkBits2Float(0x3e6f74a3), SkBits2Float(0xc26fff89));
447path.cubicTo(SkBits2Float(0x3e1fa33e), SkBits2Float(0xc26fffd9), SkBits2Float(0x3d9fa303), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
448path.close();
449path.moveTo(SkBits2Float(0x3e7ee007), SkBits2Float(0xc27f7413));
450path.lineTo(SkBits2Float(0x3e6f7465), SkBits2Float(0xc26fff8a));
451path.lineTo(SkBits2Float(0x3e6f74a4), SkBits2Float(0xc26fff8a));
452path.lineTo(SkBits2Float(0x3e7ee007), SkBits2Float(0xc27f7413));
453path.close();
454
455 SkPath path1(path);
456 path.reset();
457 path.setFillType((SkPathFillType) 0);
458path.moveTo(SkBits2Float(0x3eb62f8c), SkBits2Float(0xc2a5ff9c));
459path.cubicTo(SkBits2Float(0x3f07d31d), SkBits2Float(0xc2a5ff3a), SkBits2Float(0x3f348e3e), SkBits2Float(0xc2a5fe8f), SkBits2Float(0x3f614904), SkBits2Float(0xc2a5fd9c));
460path.lineTo(SkBits2Float(0x3f22db6c), SkBits2Float(0xc26ffc8c));
461path.cubicTo(SkBits2Float(0x3f0285bf), SkBits2Float(0xc26ffdeb), SkBits2Float(0x3ec45fa5), SkBits2Float(0xc26ffee1), SkBits2Float(0x3e83b387), SkBits2Float(0xc26fff6f));
462path.lineTo(SkBits2Float(0x3eb62f8c), SkBits2Float(0xc2a5ff9c));
463path.close();
464
465 SkPath path2(path);
466 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
467}

◆ battleOp140()

static void battleOp140 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3750 of file PathOpsBattles.cpp.

3750 {
3751 SkPath path;
3752 path.setFillType((SkPathFillType) 0);
3753path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3754path.cubicTo(SkBits2Float(0x41d9e52a), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4252f644), SkBits2Float(0xc28b460f), SkBits2Float(0x42887c98), SkBits2Float(0xc23cf83b));
3755path.lineTo(SkBits2Float(0x42455485), SkBits2Float(0xc2089ac5));
3756path.cubicTo(SkBits2Float(0x421880ae), SkBits2Float(0xc2495c0a), SkBits2Float(0x419d83bb), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
3757path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3758path.close();
3759
3760 SkPath path1(path);
3761 path.reset();
3762 path.setFillType((SkPathFillType) 0);
3763path.moveTo(SkBits2Float(0x42887c98), SkBits2Float(0xc23cf83b));
3764path.cubicTo(SkBits2Float(0x428b8706), SkBits2Float(0xc2342f4a), SkBits2Float(0x428e5ab7), SkBits2Float(0xc22b1c84), SkBits2Float(0x4290f525), SkBits2Float(0xc221c800));
3765path.lineTo(SkBits2Float(0x425193c7), SkBits2Float(0xc1e9e68d));
3766path.cubicTo(SkBits2Float(0x424dd044), SkBits2Float(0xc1f763d3), SkBits2Float(0x4249b9f6), SkBits2Float(0xc2024108), SkBits2Float(0x42455485), SkBits2Float(0xc2089ac6));
3767path.lineTo(SkBits2Float(0x42887c98), SkBits2Float(0xc23cf83b));
3768path.close();
3769
3770 SkPath path2(path);
3771 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3772}

◆ battleOp141()

static void battleOp141 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3775 of file PathOpsBattles.cpp.

3775 {
3776 SkPath path;
3777 path.setFillType((SkPathFillType) 1);
3778path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3779path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3780path.cubicTo(SkBits2Float(0x41d9e52a), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4252f644), SkBits2Float(0xc28b460f), SkBits2Float(0x42887c98), SkBits2Float(0xc23cf83b));
3781path.cubicTo(SkBits2Float(0x428b8706), SkBits2Float(0xc2342f4a), SkBits2Float(0x428e5ab7), SkBits2Float(0xc22b1c84), SkBits2Float(0x4290f525), SkBits2Float(0xc221c800));
3782path.lineTo(SkBits2Float(0x425193c7), SkBits2Float(0xc1e9e68d));
3783path.cubicTo(SkBits2Float(0x424dd044), SkBits2Float(0xc1f763d3), SkBits2Float(0x4249b9f6), SkBits2Float(0xc2024107), SkBits2Float(0x42455485), SkBits2Float(0xc2089ac5));
3784path.lineTo(SkBits2Float(0x42455485), SkBits2Float(0xc2089ac6));
3785path.cubicTo(SkBits2Float(0x421880ae), SkBits2Float(0xc2495c0b), SkBits2Float(0x419d83ba), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3786path.close();
3787
3788 SkPath path1(path);
3789 path.reset();
3790 path.setFillType((SkPathFillType) 0);
3791path.moveTo(SkBits2Float(0x4290f526), SkBits2Float(0xc221c800));
3792path.cubicTo(SkBits2Float(0x42bd6cdd), SkBits2Float(0xbf1a1474), SkBits2Float(0x42a13baa), SkBits2Float(0x4246de93), SkBits2Float(0x4223add7), SkBits2Float(0x42906c8a));
3793path.lineTo(SkBits2Float(0x41eca4f8), SkBits2Float(0x4250ce48));
3794path.cubicTo(SkBits2Float(0x42691bac), SkBits2Float(0x420fc2d7), SkBits2Float(0x4288ef16), SkBits2Float(0xbedec420), SkBits2Float(0x425193c9), SkBits2Float(0xc1e9e690));
3795path.lineTo(SkBits2Float(0x4290f526), SkBits2Float(0xc221c800));
3796path.close();
3797
3798 SkPath path2(path);
3799 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3800}

◆ battleOp142()

static void battleOp142 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3803 of file PathOpsBattles.cpp.

3803 {
3804 SkPath path;
3805 path.setFillType((SkPathFillType) 0);
3806path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3807path.cubicTo(SkBits2Float(0x41f6a97d), SkBits2Float(0xc2a60000), SkBits2Float(0x426c7f9e), SkBits2Float(0xc283d12f), SkBits2Float(0x4292f07c), SkBits2Float(0xc21a76e5));
3808path.lineTo(SkBits2Float(0x42547147), SkBits2Float(0xc1df5274));
3809path.cubicTo(SkBits2Float(0x422af677), SkBits2Float(0xc23e9438), SkBits2Float(0x41b24f58), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
3810path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3811path.close();
3812
3813 SkPath path1(path);
3814 path.reset();
3815 path.setFillType((SkPathFillType) 0);
3816path.moveTo(SkBits2Float(0x4292f07c), SkBits2Float(0xc21a76e5));
3817path.cubicTo(SkBits2Float(0x4295bcf6), SkBits2Float(0xc20fd099), SkBits2Float(0x42983ed1), SkBits2Float(0xc204de6d), SkBits2Float(0x429a7333), SkBits2Float(0xc1f3598c));
3818path.lineTo(SkBits2Float(0x425f4d1c), SkBits2Float(0xc1afea60));
3819path.cubicTo(SkBits2Float(0x425c1d22), SkBits2Float(0xc1c0197b), SkBits2Float(0x42587d28), SkBits2Float(0xc1cfecd2), SkBits2Float(0x42547148), SkBits2Float(0xc1df5275));
3820path.lineTo(SkBits2Float(0x4292f07c), SkBits2Float(0xc21a76e5));
3821path.close();
3822
3823 SkPath path2(path);
3824 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3825}

◆ battleOp143()

static void battleOp143 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3828 of file PathOpsBattles.cpp.

3828 {
3829 SkPath path;
3830 path.setFillType((SkPathFillType) 1);
3831path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3832path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3833path.cubicTo(SkBits2Float(0x41f6a97d), SkBits2Float(0xc2a60000), SkBits2Float(0x426c7f9e), SkBits2Float(0xc283d12f), SkBits2Float(0x4292f07c), SkBits2Float(0xc21a76e5));
3834path.cubicTo(SkBits2Float(0x4295bcf6), SkBits2Float(0xc20fd099), SkBits2Float(0x42983ed1), SkBits2Float(0xc204de6d), SkBits2Float(0x429a7333), SkBits2Float(0xc1f3598c));
3835path.lineTo(SkBits2Float(0x425f4d1c), SkBits2Float(0xc1afea60));
3836path.cubicTo(SkBits2Float(0x425c1d22), SkBits2Float(0xc1c0197b), SkBits2Float(0x42587d28), SkBits2Float(0xc1cfecd2), SkBits2Float(0x42547147), SkBits2Float(0xc1df5274));
3837path.cubicTo(SkBits2Float(0x422af677), SkBits2Float(0xc23e9438), SkBits2Float(0x41b24f58), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3838path.close();
3839
3840 SkPath path1(path);
3841 path.reset();
3842 path.setFillType((SkPathFillType) 0);
3843path.moveTo(SkBits2Float(0x429a7334), SkBits2Float(0xc1f3598d));
3844path.cubicTo(SkBits2Float(0x42ac9a56), SkBits2Float(0xc0ec08d5), SkBits2Float(0x42a93a4b), SkBits2Float(0x4194209c), SkBits2Float(0x42913f11), SkBits2Float(0x4220bdeb));
3845path.cubicTo(SkBits2Float(0x427287b0), SkBits2Float(0x42776b87), SkBits2Float(0x421e5dc6), SkBits2Float(0x429a1372), SkBits2Float(0x4173f4a4), SkBits2Float(0x42a32ccd));
3846path.lineTo(SkBits2Float(0x41305a7f), SkBits2Float(0x426bea6b));
3847path.cubicTo(SkBits2Float(0x41e4f69e), SkBits2Float(0x425ec2af), SkBits2Float(0x422f52ad), SkBits2Float(0x4232db9e), SkBits2Float(0x4251feaa), SkBits2Float(0x41e865df));
3848path.cubicTo(SkBits2Float(0x4274aaa7), SkBits2Float(0x41562902), SkBits2Float(0x42798bdd), SkBits2Float(0xc0aaa09a), SkBits2Float(0x425f4d1d), SkBits2Float(0xc1afea60));
3849path.lineTo(SkBits2Float(0x429a7334), SkBits2Float(0xc1f3598d));
3850path.close();
3851
3852 SkPath path2(path);
3853 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3854}

◆ battleOp144()

static void battleOp144 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3857 of file PathOpsBattles.cpp.

3857 {
3858 SkPath path;
3859 path.setFillType((SkPathFillType) 0);
3860path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3861path.cubicTo(SkBits2Float(0x42079c39), SkBits2Float(0xc2a60000), SkBits2Float(0x4280cb64), SkBits2Float(0xc279860f), SkBits2Float(0x429a0d79), SkBits2Float(0xc1f758df));
3862path.lineTo(SkBits2Float(0x425eba08), SkBits2Float(0xc1b2ce1f));
3863path.cubicTo(SkBits2Float(0x423a357b), SkBits2Float(0xc23460ea), SkBits2Float(0x41c41023), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
3864path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3865path.close();
3866
3867 SkPath path1(path);
3868 path.reset();
3869 path.setFillType((SkPathFillType) 0);
3870path.moveTo(SkBits2Float(0x429a0d79), SkBits2Float(0xc1f758de));
3871path.cubicTo(SkBits2Float(0x429c811b), SkBits2Float(0xc1deea6e), SkBits2Float(0x429e9731), SkBits2Float(0xc1c5ec3a), SkBits2Float(0x42a04ce7), SkBits2Float(0xc1ac8024));
3872path.lineTo(SkBits2Float(0x4267c277), SkBits2Float(0xc17965fc));
3873path.cubicTo(SkBits2Float(0x426549a1), SkBits2Float(0xc18f13a3), SkBits2Float(0x42624575), SkBits2Float(0xc1a124d8), SkBits2Float(0x425eba09), SkBits2Float(0xc1b2ce1e));
3874path.lineTo(SkBits2Float(0x429a0d79), SkBits2Float(0xc1f758de));
3875path.close();
3876
3877 SkPath path2(path);
3878 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3879}

◆ battleOp145()

static void battleOp145 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3882 of file PathOpsBattles.cpp.

3882 {
3883 SkPath path;
3884 path.setFillType((SkPathFillType) 1);
3885path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3886path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3887path.cubicTo(SkBits2Float(0x42079c39), SkBits2Float(0xc2a60000), SkBits2Float(0x4280cb64), SkBits2Float(0xc279860f), SkBits2Float(0x429a0d79), SkBits2Float(0xc1f758df));
3888path.lineTo(SkBits2Float(0x42a04ce7), SkBits2Float(0xc1ac8024));
3889path.lineTo(SkBits2Float(0x4267c277), SkBits2Float(0xc17965fc));
3890path.cubicTo(SkBits2Float(0x426549a1), SkBits2Float(0xc18f13a3), SkBits2Float(0x42624575), SkBits2Float(0xc1a124d8), SkBits2Float(0x425eba09), SkBits2Float(0xc1b2ce1e));
3891path.lineTo(SkBits2Float(0x425eba08), SkBits2Float(0xc1b2ce1f));
3892path.cubicTo(SkBits2Float(0x423a357b), SkBits2Float(0xc23460ea), SkBits2Float(0x41c41023), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3893path.close();
3894
3895 SkPath path1(path);
3896 path.reset();
3897 path.setFillType((SkPathFillType) 0);
3898path.moveTo(SkBits2Float(0x42a04ce8), SkBits2Float(0xc1ac8024));
3899path.cubicTo(SkBits2Float(0x42ae6ca1), SkBits2Float(0x4095ff41), SkBits2Float(0x42a1f1fa), SkBits2Float(0x4202ed54), SkBits2Float(0x427dc9de), SkBits2Float(0x42560b98));
3900path.cubicTo(SkBits2Float(0x4237afc7), SkBits2Float(0x429494ee), SkBits2Float(0x419aa752), SkBits2Float(0x42aa57e8), SkBits2Float(0xc0f777b3), SkBits2Float(0x42a54724));
3901path.lineTo(SkBits2Float(0xc0b2e472), SkBits2Float(0x426ef4bb));
3902path.cubicTo(SkBits2Float(0x415f9870), SkBits2Float(0x42764794), SkBits2Float(0x4204c916), SkBits2Float(0x4256d126), SkBits2Float(0x4237762a), SkBits2Float(0x421abb46));
3903path.cubicTo(SkBits2Float(0x426a233f), SkBits2Float(0x41bd4acb), SkBits2Float(0x427c2e04), SkBits2Float(0x4058dcfe), SkBits2Float(0x4267c279), SkBits2Float(0xc17965fc));
3904path.lineTo(SkBits2Float(0x42a04ce8), SkBits2Float(0xc1ac8024));
3905path.close();
3906
3907 SkPath path2(path);
3908 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3909}

◆ battleOp146()

static void battleOp146 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3912 of file PathOpsBattles.cpp.

3912 {
3913 SkPath path;
3914 path.setFillType((SkPathFillType) 0);
3915path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3916path.cubicTo(SkBits2Float(0x421472e7), SkBits2Float(0xc2a5ffff), SkBits2Float(0x428b6da4), SkBits2Float(0xc26973d7), SkBits2Float(0x429fb179), SkBits2Float(0xc1b54986));
3917path.lineTo(SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
3918path.cubicTo(SkBits2Float(0x42499544), SkBits2Float(0xc228c2c8), SkBits2Float(0x41d69ff6), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
3919path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3920path.close();
3921
3922 SkPath path1(path);
3923 path.reset();
3924 path.setFillType((SkPathFillType) 0);
3925path.moveTo(SkBits2Float(0x429fb179), SkBits2Float(0xc1b54988));
3926path.cubicTo(SkBits2Float(0x42a1a632), SkBits2Float(0xc199b837), SkBits2Float(0x42a3282f), SkBits2Float(0xc17b594e), SkBits2Float(0x42a43501), SkBits2Float(0xc142a7ba));
3927path.lineTo(SkBits2Float(0x426d6865), SkBits2Float(0xc10cb6f0));
3928path.cubicTo(SkBits2Float(0x426be3bc), SkBits2Float(0xc135b2ae), SkBits2Float(0x4269b5af), SkBits2Float(0xc15e3ec8), SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
3929path.lineTo(SkBits2Float(0x429fb179), SkBits2Float(0xc1b54988));
3930path.close();
3931
3932 SkPath path2(path);
3933 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3934}

◆ battleOp147()

static void battleOp147 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3937 of file PathOpsBattles.cpp.

3937 {
3938 SkPath path;
3939 path.setFillType((SkPathFillType) 1);
3940path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3941path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3942path.cubicTo(SkBits2Float(0x421472e7), SkBits2Float(0xc2a60000), SkBits2Float(0x428b6da4), SkBits2Float(0xc26973d8), SkBits2Float(0x429fb179), SkBits2Float(0xc1b54988));
3943path.lineTo(SkBits2Float(0x429fb179), SkBits2Float(0xc1b54986));
3944path.cubicTo(SkBits2Float(0x42a1a632), SkBits2Float(0xc199b836), SkBits2Float(0x42a3282f), SkBits2Float(0xc17b594d), SkBits2Float(0x42a43501), SkBits2Float(0xc142a7ba));
3945path.lineTo(SkBits2Float(0x426d6865), SkBits2Float(0xc10cb6f0));
3946path.cubicTo(SkBits2Float(0x426be3bc), SkBits2Float(0xc135b2ae), SkBits2Float(0x4269b5af), SkBits2Float(0xc15e3ec8), SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
3947path.cubicTo(SkBits2Float(0x42499544), SkBits2Float(0xc228c2c8), SkBits2Float(0x41d69ff6), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3948path.close();
3949
3950 SkPath path1(path);
3951 path.reset();
3952 path.setFillType((SkPathFillType) 0);
3953path.moveTo(SkBits2Float(0x42a43502), SkBits2Float(0xc142a7bb));
3954path.cubicTo(SkBits2Float(0x42ace9b0), SkBits2Float(0x4189ae79), SkBits2Float(0x429590d6), SkBits2Float(0x423ab1c1), SkBits2Float(0x424df762), SkBits2Float(0x428231a6));
3955path.cubicTo(SkBits2Float(0x41e19a31), SkBits2Float(0x42a70a69), SkBits2Float(0xc04a3289), SkBits2Float(0x42b03133), SkBits2Float(0xc1f5f36e), SkBits2Float(0x429a3139));
3956path.lineTo(SkBits2Float(0xc1b1cbb9), SkBits2Float(0x425eedb9));
3957path.cubicTo(SkBits2Float(0xc0122aac), SkBits2Float(0x427ebc5a), SkBits2Float(0x41a31606), SkBits2Float(0x42718130), SkBits2Float(0x4214e430), SkBits2Float(0x423c3b73));
3958path.cubicTo(SkBits2Float(0x42583d5c), SkBits2Float(0x4206f5b6), SkBits2Float(0x4279fe97), SkBits2Float(0x41470ec8), SkBits2Float(0x426d6866), SkBits2Float(0xc10cb6eb));
3959path.lineTo(SkBits2Float(0x42a43502), SkBits2Float(0xc142a7bb));
3960path.close();
3961
3962 SkPath path2(path);
3963 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3964}

◆ battleOp148()

static void battleOp148 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3967 of file PathOpsBattles.cpp.

3967 {
3968 SkPath path;
3969 path.setFillType((SkPathFillType) 0);
3970path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3971path.cubicTo(SkBits2Float(0x42216831), SkBits2Float(0xc2a60000), SkBits2Float(0x4295b6bc), SkBits2Float(0xc257ea44), SkBits2Float(0x42a38b53), SkBits2Float(0xc1639572));
3972path.lineTo(SkBits2Float(0x426c7311), SkBits2Float(0xc12484b9));
3973path.cubicTo(SkBits2Float(0x42587424), SkBits2Float(0xc21c154e), SkBits2Float(0x41e95c08), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
3974path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
3975path.close();
3976
3977 SkPath path1(path);
3978 path.reset();
3979 path.setFillType((SkPathFillType) 0);
3980path.moveTo(SkBits2Float(0x42a38b52), SkBits2Float(0xc1639578));
3981path.cubicTo(SkBits2Float(0x42a4def8), SkBits2Float(0xc1269090), SkBits2Float(0x42a5a99a), SkBits2Float(0xc0d1c16f), SkBits2Float(0x42a5e9be), SkBits2Float(0xc02be63c));
3982path.lineTo(SkBits2Float(0x426fdfd2), SkBits2Float(0xbff8877d));
3983path.cubicTo(SkBits2Float(0x426f8319), SkBits2Float(0xc097a16e), SkBits2Float(0x426e5e22), SkBits2Float(0xc0f0d105), SkBits2Float(0x426c7311), SkBits2Float(0xc12484ba));
3984path.lineTo(SkBits2Float(0x42a38b52), SkBits2Float(0xc1639578));
3985path.close();
3986
3987 SkPath path2(path);
3988 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
3989}

◆ battleOp149()

static void battleOp149 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3992 of file PathOpsBattles.cpp.

3992 {
3993 SkPath path;
3994 path.setFillType((SkPathFillType) 1);
3995path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
3996path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
3997path.cubicTo(SkBits2Float(0x42216831), SkBits2Float(0xc2a60000), SkBits2Float(0x4295b6bc), SkBits2Float(0xc257ea44), SkBits2Float(0x42a38b52), SkBits2Float(0xc1639578));
3998path.lineTo(SkBits2Float(0x426c7311), SkBits2Float(0xc12484ba));
3999path.cubicTo(SkBits2Float(0x42587424), SkBits2Float(0xc21c154e), SkBits2Float(0x41e95c08), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4000path.close();
4001
4002 SkPath path1(path);
4003 path.reset();
4004 path.setFillType((SkPathFillType) 0);
4005path.moveTo(SkBits2Float(0x42a5e9be), SkBits2Float(0xc02be63f));
4006path.cubicTo(SkBits2Float(0x42a7ff8e), SkBits2Float(0x41ec1faa), SkBits2Float(0x42849fff), SkBits2Float(0x426da4e1), SkBits2Float(0x4216595b), SkBits2Float(0x429400af));
4007path.cubicTo(SkBits2Float(0x410dcade), SkBits2Float(0x42b12eec), SkBits2Float(0xc1cdb135), SkBits2Float(0x42aa7b1c), SkBits2Float(0xc24c6646), SkBits2Float(0x4282cf52));
4008path.lineTo(SkBits2Float(0xc213c238), SkBits2Float(0x423d1f66));
4009path.cubicTo(SkBits2Float(0xc194b176), SkBits2Float(0x42767a79), SkBits2Float(0x40cd0045), SkBits2Float(0x42801597), SkBits2Float(0x41d95f44), SkBits2Float(0x4255fad4));
4010path.cubicTo(SkBits2Float(0x423fbf3c), SkBits2Float(0x422bca7a), SkBits2Float(0x4272e39a), SkBits2Float(0x41aab11f), SkBits2Float(0x426fdfd3), SkBits2Float(0xbff88758));
4011path.lineTo(SkBits2Float(0x42a5e9be), SkBits2Float(0xc02be63f));
4012path.close();
4013
4014 SkPath path2(path);
4015 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4016}

◆ battleOp15()

static void battleOp15 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 470 of file PathOpsBattles.cpp.

470 {
471 SkPath path;
472 path.setFillType((SkPathFillType) 0);
473path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
474path.cubicTo(SkBits2Float(0x3f19f03c), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f99ef95), SkBits2Float(0xc2a5fca7), SkBits2Float(0x3fe6e2fa), SkBits2Float(0xc2a5f5f7));
475path.lineTo(SkBits2Float(0x3fa6e80c), SkBits2Float(0xc26ff17d));
476path.cubicTo(SkBits2Float(0x3f5e8ed4), SkBits2Float(0xc26ffb2a), SkBits2Float(0x3ede8fc6), SkBits2Float(0xc2700000), SkBits2Float(0x35d9fd64), SkBits2Float(0xc2700000));
477path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
478path.close();
479
480 SkPath path1(path);
481 path.reset();
482 path.setFillType((SkPathFillType) 0);
483path.moveTo(SkBits2Float(0x3fe6e322), SkBits2Float(0xc2a5f5f7));
484path.cubicTo(SkBits2Float(0x3fee94fb), SkBits2Float(0xc2a5f54c), SkBits2Float(0x3ff646db), SkBits2Float(0xc2a5f497), SkBits2Float(0x3ffdf8ad), SkBits2Float(0xc2a5f3db));
485path.lineTo(SkBits2Float(0x3fb79813), SkBits2Float(0xc26fee71));
486path.cubicTo(SkBits2Float(0x3fb20800), SkBits2Float(0xc26fef82), SkBits2Float(0x3fac77ff), SkBits2Float(0xc26ff085), SkBits2Float(0x3fa6e7f4), SkBits2Float(0xc26ff17d));
487path.lineTo(SkBits2Float(0x3fe6e322), SkBits2Float(0xc2a5f5f7));
488path.close();
489
490 SkPath path2(path);
491 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
492}

◆ battleOp150()

static void battleOp150 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4019 of file PathOpsBattles.cpp.

4019 {
4020 SkPath path;
4021 path.setFillType((SkPathFillType) 0);
4022path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4023path.cubicTo(SkBits2Float(0x422dab0f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x429efeec), SkBits2Float(0xc2462810), SkBits2Float(0x42a58789), SkBits2Float(0xc0c7d837));
4024path.lineTo(SkBits2Float(0x426f51d5), SkBits2Float(0xc0907750));
4025path.cubicTo(SkBits2Float(0x4265df9a), SkBits2Float(0xc20f3ee4), SkBits2Float(0x41fb162c), SkBits2Float(0xc26ffffe), SkBits2Float(0x3637fea5), SkBits2Float(0xc26fffff));
4026path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4027path.close();
4028
4029 SkPath path1(path);
4030 path.reset();
4031 path.setFillType((SkPathFillType) 0);
4032path.moveTo(SkBits2Float(0x42a58789), SkBits2Float(0xc0c7d840));
4033path.cubicTo(SkBits2Float(0x42a626ff), SkBits2Float(0xc0078454), SkBits2Float(0x42a62824), SkBits2Float(0x4001c6d5), SkBits2Float(0x42a58af5), SkBits2Float(0x40c4fc3c));
4034path.lineTo(SkBits2Float(0x426f56ca), SkBits2Float(0x408e6626));
4035path.cubicTo(SkBits2Float(0x42703a0b), SkBits2Float(0x3fbba106), SkBits2Float(0x42703864), SkBits2Float(0xbfc3ed93), SkBits2Float(0x426f51d4), SkBits2Float(0xc090774f));
4036path.lineTo(SkBits2Float(0x42a58789), SkBits2Float(0xc0c7d840));
4037path.close();
4038
4039 SkPath path2(path);
4040 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4041}

◆ battleOp151()

static void battleOp151 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4044 of file PathOpsBattles.cpp.

4044 {
4045 SkPath path;
4046 path.setFillType((SkPathFillType) 1);
4047path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc26fffff));
4048path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4049path.cubicTo(SkBits2Float(0x422dab0f), SkBits2Float(0xc2a60000), SkBits2Float(0x429efeec), SkBits2Float(0xc2462811), SkBits2Float(0x42a58789), SkBits2Float(0xc0c7d840));
4050path.lineTo(SkBits2Float(0x42a58789), SkBits2Float(0xc0c7d837));
4051path.cubicTo(SkBits2Float(0x42a626ff), SkBits2Float(0xc0078448), SkBits2Float(0x42a62824), SkBits2Float(0x4001c6db), SkBits2Float(0x42a58af5), SkBits2Float(0x40c4fc3c));
4052path.lineTo(SkBits2Float(0x426f56ca), SkBits2Float(0x408e6626));
4053path.cubicTo(SkBits2Float(0x42703a0b), SkBits2Float(0x3fbba106), SkBits2Float(0x42703864), SkBits2Float(0xbfc3ed93), SkBits2Float(0x426f51d4), SkBits2Float(0xc090774f));
4054path.lineTo(SkBits2Float(0x426f51d5), SkBits2Float(0xc0907750));
4055path.cubicTo(SkBits2Float(0x4265df9a), SkBits2Float(0xc20f3ee4), SkBits2Float(0x41fb162c), SkBits2Float(0xc26ffffe), SkBits2Float(0x3637fea5), SkBits2Float(0xc26fffff));
4056path.close();
4057
4058 SkPath path1(path);
4059 path.reset();
4060 path.setFillType((SkPathFillType) 0);
4061path.moveTo(SkBits2Float(0x42a58af6), SkBits2Float(0x40c4fc3d));
4062path.cubicTo(SkBits2Float(0x42a06986), SkBits2Float(0x422298c3), SkBits2Float(0x42621341), SkBits2Float(0x428bdf10), SkBits2Float(0x41ba9762), SkBits2Float(0x429f4f99));
4063path.cubicTo(SkBits2Float(0xc11def80), SkBits2Float(0x42b2c022), SkBits2Float(0xc236745f), SkBits2Float(0x429afb1c), SkBits2Float(0xc284c1e2), SkBits2Float(0x4247504a));
4064path.lineTo(SkBits2Float(0xc23ff038), SkBits2Float(0x42101509));
4065path.cubicTo(SkBits2Float(0xc203e517), SkBits2Float(0x4260119e), SkBits2Float(0xc0e45731), SkBits2Float(0x428137a0), SkBits2Float(0x4186e2a5), SkBits2Float(0x42665443));
4066path.cubicTo(SkBits2Float(0x42236d8c), SkBits2Float(0x424a3945), SkBits2Float(0x4267ebda), SkBits2Float(0x41eb1462), SkBits2Float(0x426f56cb), SkBits2Float(0x408e661a));
4067path.lineTo(SkBits2Float(0x42a58af6), SkBits2Float(0x40c4fc3d));
4068path.close();
4069
4070 SkPath path2(path);
4071 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4072}

◆ battleOp152()

static void battleOp152 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4075 of file PathOpsBattles.cpp.

4075 {
4076 SkPath path;
4077 path.setFillType((SkPathFillType) 0);
4078path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4079path.cubicTo(SkBits2Float(0x41b12ed4), SkBits2Float(0xc2a60000), SkBits2Float(0x422d822c), SkBits2Float(0xc2944bde), SkBits2Float(0x426bdb91), SkBits2Float(0xc269a7f3));
4080path.cubicTo(SkBits2Float(0x42951a7b), SkBits2Float(0xc22ab829), SkBits2Float(0x42a66879), SkBits2Float(0xc1aaf2b1), SkBits2Float(0x42a5fe21), SkBits2Float(0x3f4744a4));
4081path.lineTo(SkBits2Float(0x426ffd4c), SkBits2Float(0x3f100c99));
4082path.cubicTo(SkBits2Float(0x4270970c), SkBits2Float(0xc177275d), SkBits2Float(0x4257923d), SkBits2Float(0xc1f6d2bd), SkBits2Float(0x422a7fe2), SkBits2Float(0xc228e872));
4083path.cubicTo(SkBits2Float(0x41fadb0b), SkBits2Float(0xc2566785), SkBits2Float(0x41801584), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
4084path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4085path.close();
4086
4087 SkPath path1(path);
4088 path.reset();
4089 path.setFillType((SkPathFillType) 0);
4090path.moveTo(SkBits2Float(0x42a5fe22), SkBits2Float(0x3f4744a1));
4091path.cubicTo(SkBits2Float(0x42a5e921), SkBits2Float(0x40a4df91), SkBits2Float(0x42a52322), SkBits2Float(0x411841f7), SkBits2Float(0x42a3adfe), SkBits2Float(0x415d43d0));
4092path.lineTo(SkBits2Float(0x426ca531), SkBits2Float(0x411ff355));
4093path.cubicTo(SkBits2Float(0x426ec0ad), SkBits2Float(0x40dc21ae), SkBits2Float(0x426fdeef), SkBits2Float(0x406e5efe), SkBits2Float(0x426ffd4d), SkBits2Float(0x3f100c9b));
4094path.lineTo(SkBits2Float(0x42a5fe22), SkBits2Float(0x3f4744a1));
4095path.close();
4096
4097 SkPath path2(path);
4098 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4099}

◆ battleOp153()

static void battleOp153 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4102 of file PathOpsBattles.cpp.

4102 {
4103 SkPath path;
4104 path.setFillType((SkPathFillType) 1);
4105path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4106path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4107path.cubicTo(SkBits2Float(0x41b12ed4), SkBits2Float(0xc2a60000), SkBits2Float(0x422d822c), SkBits2Float(0xc2944bde), SkBits2Float(0x426bdb91), SkBits2Float(0xc269a7f3));
4108path.cubicTo(SkBits2Float(0x42951a7b), SkBits2Float(0xc22ab829), SkBits2Float(0x42a66879), SkBits2Float(0xc1aaf2b1), SkBits2Float(0x42a5fe21), SkBits2Float(0x3f4744a0));
4109path.lineTo(SkBits2Float(0x426ffd4c), SkBits2Float(0x3f100c99));
4110path.cubicTo(SkBits2Float(0x4270970c), SkBits2Float(0xc177275d), SkBits2Float(0x4257923d), SkBits2Float(0xc1f6d2bd), SkBits2Float(0x422a7fe2), SkBits2Float(0xc228e872));
4111path.cubicTo(SkBits2Float(0x41fadb0b), SkBits2Float(0xc2566785), SkBits2Float(0x41801584), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4112path.close();
4113
4114 SkPath path1(path);
4115 path.reset();
4116 path.setFillType((SkPathFillType) 0);
4117path.moveTo(SkBits2Float(0x42a3adfe), SkBits2Float(0x415d43d0));
4118path.cubicTo(SkBits2Float(0x42977493), SkBits2Float(0x42480062), SkBits2Float(0x423a617c), SkBits2Float(0x429bbd03), SkBits2Float(0x4123044a), SkBits2Float(0x42a4be9a));
4119path.cubicTo(SkBits2Float(0xc1d1beaf), SkBits2Float(0x42adc030), SkBits2Float(0xc2750d30), SkBits2Float(0x4285e3a3), SkBits2Float(0xc2980208), SkBits2Float(0x42056911));
4120path.lineTo(SkBits2Float(0xc25bc541), SkBits2Float(0x41c0e1ed));
4121path.cubicTo(SkBits2Float(0xc231254e), SkBits2Float(0x42419328), SkBits2Float(0xc1979f72), SkBits2Float(0x427b34be), SkBits2Float(0x40ebafde), SkBits2Float(0x426e2f5c));
4122path.cubicTo(SkBits2Float(0x4206bbb1), SkBits2Float(0x426129fa), SkBits2Float(0x425af8c2), SkBits2Float(0x42109457), SkBits2Float(0x426ca533), SkBits2Float(0x411ff35b));
4123path.lineTo(SkBits2Float(0x42a3adfe), SkBits2Float(0x415d43d0));
4124path.close();
4125
4126 SkPath path2(path);
4127 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4128}

◆ battleOp154()

static void battleOp154 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4131 of file PathOpsBattles.cpp.

4131 {
4132 SkPath path;
4133 path.setFillType((SkPathFillType) 0);
4134path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4135path.cubicTo(SkBits2Float(0x41bb5603), SkBits2Float(0xc2a60000), SkBits2Float(0x4236fa4e), SkBits2Float(0xc2923760), SkBits2Float(0x4275e892), SkBits2Float(0xc25f0dc8));
4136path.cubicTo(SkBits2Float(0x429a6b6b), SkBits2Float(0xc219acd0), SkBits2Float(0x42a9c473), SkBits2Float(0xc173c3a6), SkBits2Float(0x42a5369d), SkBits2Float(0x410121d8));
4137path.lineTo(SkBits2Float(0x426edcd8), SkBits2Float(0x40bab276));
4138path.cubicTo(SkBits2Float(0x42757264), SkBits2Float(0xc1303715), SkBits2Float(0x425f41dd), SkBits2Float(0xc1de2e4a), SkBits2Float(0x4231c3e2), SkBits2Float(0xc2213e66));
4139path.cubicTo(SkBits2Float(0x420445e8), SkBits2Float(0xc25365a8), SkBits2Float(0x41876c72), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
4140path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4141path.close();
4142
4143 SkPath path1(path);
4144 path.reset();
4145 path.setFillType((SkPathFillType) 0);
4146path.moveTo(SkBits2Float(0x42a5369e), SkBits2Float(0x410121d6));
4147path.cubicTo(SkBits2Float(0x42a450b5), SkBits2Float(0x414aab85), SkBits2Float(0x42a2a6cd), SkBits2Float(0x4189bd6e), SkBits2Float(0x42a03d57), SkBits2Float(0x41ad66e6));
4148path.lineTo(SkBits2Float(0x4267abf7), SkBits2Float(0x417ab39f));
4149path.cubicTo(SkBits2Float(0x426b28ae), SkBits2Float(0x41472463), SkBits2Float(0x426d9071), SkBits2Float(0x41128229), SkBits2Float(0x426edcd8), SkBits2Float(0x40bab277));
4150path.lineTo(SkBits2Float(0x42a5369e), SkBits2Float(0x410121d6));
4151path.close();
4152
4153 SkPath path2(path);
4154 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4155}

◆ battleOp155()

static void battleOp155 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4158 of file PathOpsBattles.cpp.

4158 {
4159 SkPath path;
4160 path.setFillType((SkPathFillType) 1);
4161path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4162path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4163path.cubicTo(SkBits2Float(0x41bb5603), SkBits2Float(0xc2a60000), SkBits2Float(0x4236fa4e), SkBits2Float(0xc2923760), SkBits2Float(0x4275e892), SkBits2Float(0xc25f0dc8));
4164path.cubicTo(SkBits2Float(0x429a6b6b), SkBits2Float(0xc219acd0), SkBits2Float(0x42a9c473), SkBits2Float(0xc173c3a8), SkBits2Float(0x42a5369d), SkBits2Float(0x410121d5));
4165path.lineTo(SkBits2Float(0x42a5369e), SkBits2Float(0x410121d6));
4166path.cubicTo(SkBits2Float(0x42a450b5), SkBits2Float(0x414aab85), SkBits2Float(0x42a2a6cd), SkBits2Float(0x4189bd6e), SkBits2Float(0x42a03d57), SkBits2Float(0x41ad66e6));
4167path.lineTo(SkBits2Float(0x4267abf7), SkBits2Float(0x417ab39f));
4168path.cubicTo(SkBits2Float(0x426b28ae), SkBits2Float(0x41472463), SkBits2Float(0x426d9071), SkBits2Float(0x41128229), SkBits2Float(0x426edcd8), SkBits2Float(0x40bab276));
4169path.cubicTo(SkBits2Float(0x42757264), SkBits2Float(0xc1303715), SkBits2Float(0x425f41dd), SkBits2Float(0xc1de2e4a), SkBits2Float(0x4231c3e2), SkBits2Float(0xc2213e66));
4170path.cubicTo(SkBits2Float(0x420445e8), SkBits2Float(0xc25365a8), SkBits2Float(0x41876c72), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4171path.close();
4172
4173 SkPath path1(path);
4174 path.reset();
4175 path.setFillType((SkPathFillType) 0);
4176path.moveTo(SkBits2Float(0x42a03d58), SkBits2Float(0x41ad66e7));
4177path.cubicTo(SkBits2Float(0x428bedd4), SkBits2Float(0x426cda0a), SkBits2Float(0x420c6f35), SkBits2Float(0x42a955c4), SkBits2Float(0xc06f4c79), SkBits2Float(0x42a5d4d6));
4178path.cubicTo(SkBits2Float(0xc22a58c2), SkBits2Float(0x42a253e8), SkBits2Float(0xc2960525), SkBits2Float(0x4252b394), SkBits2Float(0xc2a37db3), SkBits2Float(0x41660422));
4179path.lineTo(SkBits2Float(0xc26c5f63), SkBits2Float(0x412646cf));
4180path.cubicTo(SkBits2Float(0xc258e58a), SkBits2Float(0x4218507a), SkBits2Float(0xc1f648da), SkBits2Float(0x426ab0dc), SkBits2Float(0xc02cfcc3), SkBits2Float(0x426fc1a0));
4181path.cubicTo(SkBits2Float(0x41cb09aa), SkBits2Float(0x4274d265), SkBits2Float(0x424a4e9e), SkBits2Float(0x422b37da), SkBits2Float(0x4267abf8), SkBits2Float(0x417ab398));
4182path.lineTo(SkBits2Float(0x42a03d58), SkBits2Float(0x41ad66e7));
4183path.close();
4184
4185 SkPath path2(path);
4186 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4187}

◆ battleOp156()

static void battleOp156 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4190 of file PathOpsBattles.cpp.

4190 {
4191 SkPath path;
4192 path.setFillType((SkPathFillType) 0);
4193path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4194path.cubicTo(SkBits2Float(0x41c3ae1a), SkBits2Float(0xc2a60000), SkBits2Float(0x423eb2d3), SkBits2Float(0xc2906c00), SkBits2Float(0x427dc7c2), SkBits2Float(0xc2560e13));
4195path.cubicTo(SkBits2Float(0x429e6e58), SkBits2Float(0xc20b4426), SkBits2Float(0x42abdf2b), SkBits2Float(0xc121d7a7), SkBits2Float(0x42a39f93), SkBits2Float(0x415fea21));
4196path.lineTo(SkBits2Float(0x426c905a), SkBits2Float(0x4121ddae));
4197path.cubicTo(SkBits2Float(0x42787d42), SkBits2Float(0xc0e9fd34), SkBits2Float(0x42650e94), SkBits2Float(0xc1c95949), SkBits2Float(0x423774a6), SkBits2Float(0xc21abd13));
4198path.cubicTo(SkBits2Float(0x4209dab9), SkBits2Float(0xc250cd81), SkBits2Float(0x418d749b), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
4199path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4200path.close();
4201
4202 SkPath path1(path);
4203 path.reset();
4204 path.setFillType((SkPathFillType) 0);
4205path.moveTo(SkBits2Float(0x42a39f93), SkBits2Float(0x415fea20));
4206path.cubicTo(SkBits2Float(0x42a1ffad), SkBits2Float(0x4195f252), SkBits2Float(0x429f8ce1), SkBits2Float(0x41bb4c45), SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969a));
4207path.lineTo(SkBits2Float(0x4261fbff), SkBits2Float(0x41a1a14e));
4208path.cubicTo(SkBits2Float(0x4266acd9), SkBits2Float(0x41876566), SkBits2Float(0x426a370e), SkBits2Float(0x4158ca4c), SkBits2Float(0x426c905b), SkBits2Float(0x4121ddaf));
4209path.lineTo(SkBits2Float(0x42a39f93), SkBits2Float(0x415fea20));
4210path.close();
4211
4212 SkPath path2(path);
4213 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4214}

◆ battleOp157()

static void battleOp157 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4217 of file PathOpsBattles.cpp.

4217 {
4218 SkPath path;
4219 path.setFillType((SkPathFillType) 1);
4220path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4221path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4222path.cubicTo(SkBits2Float(0x41c3ae1a), SkBits2Float(0xc2a60000), SkBits2Float(0x423eb2d3), SkBits2Float(0xc2906c00), SkBits2Float(0x427dc7c2), SkBits2Float(0xc2560e13));
4223path.cubicTo(SkBits2Float(0x429e6e58), SkBits2Float(0xc20b4426), SkBits2Float(0x42abdf2b), SkBits2Float(0xc121d7a8), SkBits2Float(0x42a39f93), SkBits2Float(0x415fea20));
4224path.lineTo(SkBits2Float(0x42a39f93), SkBits2Float(0x415fea21));
4225path.cubicTo(SkBits2Float(0x42a1ffad), SkBits2Float(0x4195f252), SkBits2Float(0x429f8ce1), SkBits2Float(0x41bb4c45), SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969a));
4226path.lineTo(SkBits2Float(0x4261fbff), SkBits2Float(0x41a1a14e));
4227path.cubicTo(SkBits2Float(0x4266acd9), SkBits2Float(0x41876566), SkBits2Float(0x426a370e), SkBits2Float(0x4158ca4c), SkBits2Float(0x426c905b), SkBits2Float(0x4121ddaf));
4228path.lineTo(SkBits2Float(0x426c905a), SkBits2Float(0x4121ddae));
4229path.cubicTo(SkBits2Float(0x42787d42), SkBits2Float(0xc0e9fd34), SkBits2Float(0x42650e94), SkBits2Float(0xc1c95949), SkBits2Float(0x423774a6), SkBits2Float(0xc21abd13));
4230path.cubicTo(SkBits2Float(0x4209dab9), SkBits2Float(0xc250cd81), SkBits2Float(0x418d749b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4231path.close();
4232
4233 SkPath path1(path);
4234 path.reset();
4235 path.setFillType((SkPathFillType) 0);
4236path.moveTo(SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969b));
4237path.cubicTo(SkBits2Float(0x4280e391), SkBits2Float(0x4284903f), SkBits2Float(0x41c7a851), SkBits2Float(0x42b2072e), SkBits2Float(0xc1713833), SkBits2Float(0x42a33d14));
4238path.cubicTo(SkBits2Float(0xc25c7040), SkBits2Float(0x429472fb), SkBits2Float(0xc2a7bda2), SkBits2Float(0x421b8b2e), SkBits2Float(0xc2a5f5d6), SkBits2Float(0xbfe85110));
4239path.lineTo(SkBits2Float(0xc26ff14f), SkBits2Float(0xbfa7f00b));
4240path.cubicTo(SkBits2Float(0xc272844c), SkBits2Float(0x41e0e1f3), SkBits2Float(0xc21f5a65), SkBits2Float(0x4256a019), SkBits2Float(0xc12e6015), SkBits2Float(0x426c01f9));
4241path.cubicTo(SkBits2Float(0x419054b7), SkBits2Float(0x4280b1ec), SkBits2Float(0x423a5877), SkBits2Float(0x423fa872), SkBits2Float(0x4261fc02), SkBits2Float(0x41a1a142));
4242path.lineTo(SkBits2Float(0x429c4e4c), SkBits2Float(0x41df969b));
4243path.close();
4244
4245 SkPath path2(path);
4246 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4247}

◆ battleOp158()

static void battleOp158 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4250 of file PathOpsBattles.cpp.

4250 {
4251 SkPath path;
4252 path.setFillType((SkPathFillType) 0);
4253path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4254path.cubicTo(SkBits2Float(0x41cb677f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4245cb36), SkBits2Float(0xc28eb15b), SkBits2Float(0x42825fc2), SkBits2Float(0xc24d8299));
4255path.cubicTo(SkBits2Float(0x42a1d9e8), SkBits2Float(0xc1fb44f8), SkBits2Float(0x42ad4967), SkBits2Float(0xc0aa7cf8), SkBits2Float(0x42a1679f), SkBits2Float(0x419b26cf));
4256path.lineTo(SkBits2Float(0x42695b36), SkBits2Float(0x416050ca));
4257path.cubicTo(SkBits2Float(0x427a88f8), SkBits2Float(0xc0767d2a), SkBits2Float(0x426a0074), SkBits2Float(0xc1b5a3f9), SkBits2Float(0x423c7e1d), SkBits2Float(0xc2148fc2));
4258path.cubicTo(SkBits2Float(0x420efbc6), SkBits2Float(0xc24e4d87), SkBits2Float(0x41930a0e), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
4259path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4260path.close();
4261
4262 SkPath path1(path);
4263 path.reset();
4264 path.setFillType((SkPathFillType) 0);
4265path.moveTo(SkBits2Float(0x42a1679f), SkBits2Float(0x419b26d0));
4266path.cubicTo(SkBits2Float(0x429f113c), SkBits2Float(0x41c20ede), SkBits2Float(0x429bdafe), SkBits2Float(0x41e80a2e), SkBits2Float(0x4297ceee), SkBits2Float(0x42065107));
4267path.lineTo(SkBits2Float(0x425b7b5f), SkBits2Float(0x41c2314a));
4268path.cubicTo(SkBits2Float(0x4261554b), SkBits2Float(0x41a7bd56), SkBits2Float(0x4265fa14), SkBits2Float(0x418c4870), SkBits2Float(0x42695b37), SkBits2Float(0x416050cb));
4269path.lineTo(SkBits2Float(0x42a1679f), SkBits2Float(0x419b26d0));
4270path.close();
4271
4272 SkPath path2(path);
4273 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4274}

◆ battleOp159()

static void battleOp159 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4277 of file PathOpsBattles.cpp.

4277 {
4278 SkPath path;
4279 path.setFillType((SkPathFillType) 1);
4280path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4281path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4282path.cubicTo(SkBits2Float(0x41cb677f), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4245cb36), SkBits2Float(0xc28eb15b), SkBits2Float(0x42825fc2), SkBits2Float(0xc24d8299));
4283path.cubicTo(SkBits2Float(0x42a1d9e8), SkBits2Float(0xc1fb44f8), SkBits2Float(0x42ad4967), SkBits2Float(0xc0aa7cf8), SkBits2Float(0x42a1679f), SkBits2Float(0x419b26d0));
4284path.cubicTo(SkBits2Float(0x429f113c), SkBits2Float(0x41c20ede), SkBits2Float(0x429bdafe), SkBits2Float(0x41e80a2e), SkBits2Float(0x4297ceee), SkBits2Float(0x42065107));
4285path.lineTo(SkBits2Float(0x425b7b5f), SkBits2Float(0x41c2314a));
4286path.cubicTo(SkBits2Float(0x4261554b), SkBits2Float(0x41a7bd56), SkBits2Float(0x4265fa14), SkBits2Float(0x418c4870), SkBits2Float(0x42695b36), SkBits2Float(0x416050ca));
4287path.cubicTo(SkBits2Float(0x427a88f8), SkBits2Float(0xc0767d2a), SkBits2Float(0x426a0074), SkBits2Float(0xc1b5a3f9), SkBits2Float(0x423c7e1d), SkBits2Float(0xc2148fc2));
4288path.cubicTo(SkBits2Float(0x420efbc6), SkBits2Float(0xc24e4d87), SkBits2Float(0x41930a0e), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4289path.close();
4290
4291 SkPath path1(path);
4292 path.reset();
4293 path.setFillType((SkPathFillType) 0);
4294path.moveTo(SkBits2Float(0x4297ceef), SkBits2Float(0x42065107));
4295path.cubicTo(SkBits2Float(0x426afc81), SkBits2Float(0x4290b9e3), SkBits2Float(0x4171c53f), SkBits2Float(0x42b7f2c1), SkBits2Float(0xc1ca446b), SkBits2Float(0x429e1c54));
4296path.cubicTo(SkBits2Float(0xc2835add), SkBits2Float(0x428445e8), SkBits2Float(0xc2b3ab9e), SkBits2Float(0x41c6c009), SkBits2Float(0xc2a29b10), SkBits2Float(0xc18596e4));
4297path.lineTo(SkBits2Float(0xc26b17b4), SkBits2Float(0xc141242b));
4298path.cubicTo(SkBits2Float(0xc281e1de), SkBits2Float(0x418faccb), SkBits2Float(0xc23de932), SkBits2Float(0x423f3d09), SkBits2Float(0xc19237aa), SkBits2Float(0x42649810));
4299path.cubicTo(SkBits2Float(0x412ec628), SkBits2Float(0x4284f98c), SkBits2Float(0x4229deab), SkBits2Float(0x42513e23), SkBits2Float(0x425b7b62), SkBits2Float(0x41c23147));
4300path.lineTo(SkBits2Float(0x4297ceef), SkBits2Float(0x42065107));
4301path.close();
4302
4303 SkPath path2(path);
4304 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4305}

◆ battleOp16()

static void battleOp16 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 495 of file PathOpsBattles.cpp.

495 {
496 SkPath path;
497 path.setFillType((SkPathFillType) 1);
498path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
499path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
500path.cubicTo(SkBits2Float(0x3f19f03c), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f99ef95), SkBits2Float(0xc2a5fca7), SkBits2Float(0x3fe6e322), SkBits2Float(0xc2a5f5f7));
501path.cubicTo(SkBits2Float(0x3fee94fb), SkBits2Float(0xc2a5f54c), SkBits2Float(0x3ff646db), SkBits2Float(0xc2a5f497), SkBits2Float(0x3ffdf8ad), SkBits2Float(0xc2a5f3db));
502path.lineTo(SkBits2Float(0x3fb79813), SkBits2Float(0xc26fee71));
503path.cubicTo(SkBits2Float(0x3fb20808), SkBits2Float(0xc26fef82), SkBits2Float(0x3fac780f), SkBits2Float(0xc26ff085), SkBits2Float(0x3fa6e80c), SkBits2Float(0xc26ff17d));
504path.lineTo(SkBits2Float(0x3fa6e7f4), SkBits2Float(0xc26ff17d));
505path.cubicTo(SkBits2Float(0x3f5e8eb4), SkBits2Float(0xc26ffb2a), SkBits2Float(0x3ede8fa6), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
506path.close();
507
508 SkPath path1(path);
509 path.reset();
510 path.setFillType((SkPathFillType) 0);
511path.moveTo(SkBits2Float(0x3ffdf8c6), SkBits2Float(0xc2a5f3db));
512path.cubicTo(SkBits2Float(0x403d5556), SkBits2Float(0xc2a5e7ed), SkBits2Float(0x407ba65a), SkBits2Float(0xc2a5d338), SkBits2Float(0x409cf3fe), SkBits2Float(0xc2a5b5bc));
513path.lineTo(SkBits2Float(0x4062eb8a), SkBits2Float(0xc26f94a1));
514path.cubicTo(SkBits2Float(0x4035ea63), SkBits2Float(0xc26fbf44), SkBits2Float(0x4008de16), SkBits2Float(0xc26fdd35), SkBits2Float(0x3fb79810), SkBits2Float(0xc26fee74));
515path.lineTo(SkBits2Float(0x3ffdf8c6), SkBits2Float(0xc2a5f3db));
516path.close();
517
518 SkPath path2(path);
519 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
520}

◆ battleOp160()

static void battleOp160 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4308 of file PathOpsBattles.cpp.

4308 {
4309 SkPath path;
4310 path.setFillType((SkPathFillType) 0);
4311path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4312path.cubicTo(SkBits2Float(0x41d3ccce), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424d7252), SkBits2Float(0xc28cbd55), SkBits2Float(0x4285fbcc), SkBits2Float(0xc244010c));
4313path.cubicTo(SkBits2Float(0x42a53e6e), SkBits2Float(0xc1dd0edd), SkBits2Float(0x42ae3d82), SkBits2Float(0xbdb630d0), SkBits2Float(0x429e3366), SkBits2Float(0x41c92323));
4314path.lineTo(SkBits2Float(0x4264b95a), SkBits2Float(0x41916681));
4315path.cubicTo(SkBits2Float(0x427be9e4), SkBits2Float(0xbd83b620), SkBits2Float(0x426ee823), SkBits2Float(0xc19fcd11), SkBits2Float(0x4241b610), SkBits2Float(0xc20db091));
4316path.cubicTo(SkBits2Float(0x421483fd), SkBits2Float(0xc24b7a9a), SkBits2Float(0x41991bc1), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
4317path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4318path.close();
4319
4320 SkPath path1(path);
4321 path.reset();
4322 path.setFillType((SkPathFillType) 0);
4323path.moveTo(SkBits2Float(0x429e3367), SkBits2Float(0x41c92322));
4324path.cubicTo(SkBits2Float(0x429b0cbc), SkBits2Float(0x41f0ca9b), SkBits2Float(0x4296f94f), SkBits2Float(0x420b9629), SkBits2Float(0x429206e2), SkBits2Float(0x421de34f));
4325path.lineTo(SkBits2Float(0x42531f8a), SkBits2Float(0x41e4458f));
4326path.cubicTo(SkBits2Float(0x425a4685), SkBits2Float(0x41c9cfd9), SkBits2Float(0x42602b18), SkBits2Float(0x41ae10ed), SkBits2Float(0x4264b95a), SkBits2Float(0x41916682));
4327path.lineTo(SkBits2Float(0x429e3367), SkBits2Float(0x41c92322));
4328path.close();
4329
4330 SkPath path2(path);
4331 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4332}

◆ battleOp161()

static void battleOp161 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4335 of file PathOpsBattles.cpp.

4335 {
4336 SkPath path;
4337 path.setFillType((SkPathFillType) 1);
4338path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
4339path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4340path.cubicTo(SkBits2Float(0x41d3ccce), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424d7252), SkBits2Float(0xc28cbd55), SkBits2Float(0x4285fbcc), SkBits2Float(0xc244010c));
4341path.cubicTo(SkBits2Float(0x42a53e6e), SkBits2Float(0xc1dd0edd), SkBits2Float(0x42ae3d82), SkBits2Float(0xbdb630d0), SkBits2Float(0x429e3367), SkBits2Float(0x41c92322));
4342path.cubicTo(SkBits2Float(0x429b0cbc), SkBits2Float(0x41f0ca9b), SkBits2Float(0x4296f94f), SkBits2Float(0x420b9629), SkBits2Float(0x429206e2), SkBits2Float(0x421de34f));
4343path.lineTo(SkBits2Float(0x42531f8a), SkBits2Float(0x41e4458f));
4344path.cubicTo(SkBits2Float(0x425a4685), SkBits2Float(0x41c9cfd9), SkBits2Float(0x42602b18), SkBits2Float(0x41ae10ed), SkBits2Float(0x4264b95a), SkBits2Float(0x41916681));
4345path.cubicTo(SkBits2Float(0x427be9e4), SkBits2Float(0xbd83b620), SkBits2Float(0x426ee823), SkBits2Float(0xc19fcd11), SkBits2Float(0x4241b610), SkBits2Float(0xc20db091));
4346path.cubicTo(SkBits2Float(0x421483fd), SkBits2Float(0xc24b7a9a), SkBits2Float(0x41991bc1), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
4347path.close();
4348
4349 SkPath path1(path);
4350 path.reset();
4351 path.setFillType((SkPathFillType) 0);
4352path.moveTo(SkBits2Float(0x429206e2), SkBits2Float(0x421de34f));
4353path.cubicTo(SkBits2Float(0x424fd7be), SkBits2Float(0x429cd433), SkBits2Float(0x40819da9), SkBits2Float(0x42bbf605), SkBits2Float(0xc20f7b98), SkBits2Float(0x4295b271));
4354path.cubicTo(SkBits2Float(0xc2979573), SkBits2Float(0x425eddba), SkBits2Float(0xc2bb57fe), SkBits2Float(0x4109ef62), SkBits2Float(0xc2990315), SkBits2Float(0xc200bcbb));
4355path.lineTo(SkBits2Float(0xc25d38e3), SkBits2Float(0xc1ba2048));
4356path.cubicTo(SkBits2Float(0xc2876de1), SkBits2Float(0x40c76c9c), SkBits2Float(0xc25b2842), SkBits2Float(0x42211baa), SkBits2Float(0xc1cf71e5), SkBits2Float(0x42586df1));
4357path.cubicTo(SkBits2Float(0x403b65b7), SkBits2Float(0x4287e01c), SkBits2Float(0x42163f6f), SkBits2Float(0x4262bd95), SkBits2Float(0x42531f8c), SkBits2Float(0x41e4458b));
4358path.lineTo(SkBits2Float(0x429206e2), SkBits2Float(0x421de34f));
4359path.close();
4360
4361 SkPath path2(path);
4362 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4363}

◆ battleOp162()

static void battleOp162 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4366 of file PathOpsBattles.cpp.

4366 {
4367 SkPath path;
4368 path.setFillType((SkPathFillType) 0);
4369path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4370path.cubicTo(SkBits2Float(0x41da3d7f), SkBits2Float(0xc2a60000), SkBits2Float(0x425345ee), SkBits2Float(0xc28b3082), SkBits2Float(0x4288a01b), SkBits2Float(0xc23c9177));
4371path.cubicTo(SkBits2Float(0x42a79d3f), SkBits2Float(0xc1c583d9), SkBits2Float(0x42ae8eeb), SkBits2Float(0x407c6461), SkBits2Float(0x429b333a), SkBits2Float(0x41eb9731));
4372path.lineTo(SkBits2Float(0x426062bb), SkBits2Float(0x41aa4e75));
4373path.cubicTo(SkBits2Float(0x427c5f9a), SkBits2Float(0x403673d5), SkBits2Float(0x4272557b), SkBits2Float(0xc18ec82c), SkBits2Float(0x424587e0), SkBits2Float(0xc208507b));
4374path.cubicTo(SkBits2Float(0x4218ba46), SkBits2Float(0xc2493ce1), SkBits2Float(0x419dc399), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
4375path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4376path.close();
4377
4378 SkPath path1(path);
4379 path.reset();
4380 path.setFillType((SkPathFillType) 0);
4381path.moveTo(SkBits2Float(0x429b3339), SkBits2Float(0x41eb9733));
4382path.cubicTo(SkBits2Float(0x429766b3), SkBits2Float(0x4209d0f3), SkBits2Float(0x4292a485), SkBits2Float(0x421d0e17), SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e33));
4383path.lineTo(SkBits2Float(0x424bd7ac), SkBits2Float(0x41fd5d06));
4384path.cubicTo(SkBits2Float(0x42540374), SkBits2Float(0x41e3114e), SkBits2Float(0x425ae4ae), SkBits2Float(0x41c7409b), SkBits2Float(0x426062bc), SkBits2Float(0x41aa4e76));
4385path.lineTo(SkBits2Float(0x429b3339), SkBits2Float(0x41eb9733));
4386path.close();
4387
4388 SkPath path2(path);
4389 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4390}

◆ battleOp163()

static void battleOp163 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4393 of file PathOpsBattles.cpp.

4393 {
4394 SkPath path;
4395 path.setFillType((SkPathFillType) 1);
4396path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
4397path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4398path.cubicTo(SkBits2Float(0x41da3d7f), SkBits2Float(0xc2a60000), SkBits2Float(0x425345ee), SkBits2Float(0xc28b3082), SkBits2Float(0x4288a01b), SkBits2Float(0xc23c9177));
4399path.cubicTo(SkBits2Float(0x42a79d3f), SkBits2Float(0xc1c583d9), SkBits2Float(0x42ae8eeb), SkBits2Float(0x407c6461), SkBits2Float(0x429b3339), SkBits2Float(0x41eb9733));
4400path.cubicTo(SkBits2Float(0x429766b3), SkBits2Float(0x4209d0f3), SkBits2Float(0x4292a485), SkBits2Float(0x421d0e17), SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e33));
4401path.lineTo(SkBits2Float(0x424bd7ac), SkBits2Float(0x41fd5d06));
4402path.cubicTo(SkBits2Float(0x42540374), SkBits2Float(0x41e3114e), SkBits2Float(0x425ae4ae), SkBits2Float(0x41c7409b), SkBits2Float(0x426062bb), SkBits2Float(0x41aa4e75));
4403path.cubicTo(SkBits2Float(0x427c5f9a), SkBits2Float(0x403673d5), SkBits2Float(0x4272557b), SkBits2Float(0xc18ec82c), SkBits2Float(0x424587e0), SkBits2Float(0xc208507b));
4404path.cubicTo(SkBits2Float(0x4218ba46), SkBits2Float(0xc2493ce1), SkBits2Float(0x419dc399), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
4405path.close();
4406
4407 SkPath path1(path);
4408 path.reset();
4409 path.setFillType((SkPathFillType) 0);
4410path.moveTo(SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e36));
4411path.cubicTo(SkBits2Float(0x42397b9c), SkBits2Float(0x42a54202), SkBits2Float(0xc0931849), SkBits2Float(0x42bd474f), SkBits2Float(0xc22e0fe8), SkBits2Float(0x428d5ab7));
4412path.cubicTo(SkBits2Float(0xc2a4de63), SkBits2Float(0x423adc3f), SkBits2Float(0xc2bd50df), SkBits2Float(0xc08673c0), SkBits2Float(0xc28db7cd), SkBits2Float(0xc22ce1b4));
4413path.lineTo(SkBits2Float(0xc24ce4bb), SkBits2Float(0xc1f9f306));
4414path.cubicTo(SkBits2Float(0xc288db72), SkBits2Float(0xc0426216), SkBits2Float(0xc26e5ec8), SkBits2Float(0x42071590), SkBits2Float(0xc1fba9c9), SkBits2Float(0x424c5fa5));
4415path.cubicTo(SkBits2Float(0xc054b001), SkBits2Float(0x4288d4dc), SkBits2Float(0x420615fc), SkBits2Float(0x426eee67), SkBits2Float(0x424bd7af), SkBits2Float(0x41fd5d01));
4416path.lineTo(SkBits2Float(0x428cfdb5), SkBits2Float(0x422f3e36));
4417path.close();
4418
4419 SkPath path2(path);
4420 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4421}

◆ battleOp164()

static void battleOp164 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4424 of file PathOpsBattles.cpp.

4424 {
4425 SkPath path;
4426 path.setFillType((SkPathFillType) 0);
4427path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4428path.cubicTo(SkBits2Float(0x41e183ec), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4259cec4), SkBits2Float(0xc2896274), SkBits2Float(0x428b79bc), SkBits2Float(0xc2340753));
4429path.cubicTo(SkBits2Float(0x42aa0c16), SkBits2Float(0xc1aa937d), SkBits2Float(0x42ae7c71), SkBits2Float(0x41080a55), SkBits2Float(0x42974339), SkBits2Float(0x4208c1d5));
4430path.lineTo(SkBits2Float(0x425ab161), SkBits2Float(0x41c5b8a2));
4431path.cubicTo(SkBits2Float(0x427c44e4), SkBits2Float(0x40c4af5a), SkBits2Float(0x4275d9f7), SkBits2Float(0xc1769dba), SkBits2Float(0x4249a6c2), SkBits2Float(0xc2022424));
4432path.cubicTo(SkBits2Float(0x421d738b), SkBits2Float(0xc246a0db), SkBits2Float(0x41a305f1), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
4433path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4434path.close();
4435
4436 SkPath path1(path);
4437 path.reset();
4438 path.setFillType((SkPathFillType) 0);
4439path.moveTo(SkBits2Float(0x42974339), SkBits2Float(0x4208c1d6));
4440path.cubicTo(SkBits2Float(0x4292b5f8), SkBits2Float(0x421ce537), SkBits2Float(0x428d2a3f), SkBits2Float(0x42301305), SkBits2Float(0x4286b52e), SkBits2Float(0x4242022c));
4441path.lineTo(SkBits2Float(0x4242c218), SkBits2Float(0x420c3f43));
4442path.cubicTo(SkBits2Float(0x424c1813), SkBits2Float(0x41fe90b7), SkBits2Float(0x42541cae), SkBits2Float(0x41e2d634), SkBits2Float(0x425ab162), SkBits2Float(0x41c5b8a3));
4443path.lineTo(SkBits2Float(0x42974339), SkBits2Float(0x4208c1d6));
4444path.close();
4445
4446 SkPath path2(path);
4447 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4448}

◆ battleOp165()

static void battleOp165 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4451 of file PathOpsBattles.cpp.

4451 {
4452 SkPath path;
4453 path.setFillType((SkPathFillType) 1);
4454path.moveTo(SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
4455path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4456path.cubicTo(SkBits2Float(0x41e183ec), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4259cec4), SkBits2Float(0xc2896274), SkBits2Float(0x428b79bc), SkBits2Float(0xc2340753));
4457path.cubicTo(SkBits2Float(0x42aa0c16), SkBits2Float(0xc1aa937d), SkBits2Float(0x42ae7c71), SkBits2Float(0x41080a55), SkBits2Float(0x42974339), SkBits2Float(0x4208c1d6));
4458path.cubicTo(SkBits2Float(0x4292b5f8), SkBits2Float(0x421ce537), SkBits2Float(0x428d2a3f), SkBits2Float(0x42301305), SkBits2Float(0x4286b52e), SkBits2Float(0x4242022c));
4459path.lineTo(SkBits2Float(0x4242c218), SkBits2Float(0x420c3f43));
4460path.cubicTo(SkBits2Float(0x424c1813), SkBits2Float(0x41fe90b7), SkBits2Float(0x42541cae), SkBits2Float(0x41e2d634), SkBits2Float(0x425ab161), SkBits2Float(0x41c5b8a2));
4461path.cubicTo(SkBits2Float(0x427c44e4), SkBits2Float(0x40c4af5a), SkBits2Float(0x4275d9f7), SkBits2Float(0xc1769dba), SkBits2Float(0x4249a6c2), SkBits2Float(0xc2022424));
4462path.cubicTo(SkBits2Float(0x421d738b), SkBits2Float(0xc246a0db), SkBits2Float(0x41a305f1), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
4463path.close();
4464
4465 SkPath path1(path);
4466 path.reset();
4467 path.setFillType((SkPathFillType) 0);
4468path.moveTo(SkBits2Float(0x4286b52e), SkBits2Float(0x4242022d));
4469path.cubicTo(SkBits2Float(0x4245f9c6), SkBits2Float(0x42929b97), SkBits2Float(0x419b96e9), SkBits2Float(0x42ac9135), SkBits2Float(0xc12da222), SkBits2Float(0x42a4933a));
4470path.cubicTo(SkBits2Float(0xc2249c85), SkBits2Float(0x429c9540), SkBits2Float(0xc2859c99), SkBits2Float(0x4267dd85), SkBits2Float(0xc29b4028), SkBits2Float(0x41eb0f05));
4471path.cubicTo(SkBits2Float(0xc2b0e3b8), SkBits2Float(0x3f4c608a), SkBits2Float(0xc2a55c16), SkBits2Float(0xc1fb5a07), SkBits2Float(0xc27a7a78), SkBits2Float(0xc259e8d8));
4472path.lineTo(SkBits2Float(0xc2351199), SkBits2Float(0xc21d8664));
4473path.cubicTo(SkBits2Float(0xc26f12eb), SkBits2Float(0xc1b5b32d), SkBits2Float(0xc27fbe43), SkBits2Float(0x3f13bb74), SkBits2Float(0xc2607541), SkBits2Float(0x41a9ebcd));
4474path.cubicTo(SkBits2Float(0xc2412c3e), SkBits2Float(0x42279ce1), SkBits2Float(0xc1edfdc7), SkBits2Float(0x4262625e), SkBits2Float(0xc0fb089d), SkBits2Float(0x426df06d));
4475path.cubicTo(SkBits2Float(0x4160f2f1), SkBits2Float(0x42797e7c), SkBits2Float(0x420f1d6a), SkBits2Float(0x4253f671), SkBits2Float(0x4242c21c), SkBits2Float(0x420c3f41));
4476path.lineTo(SkBits2Float(0x4286b52e), SkBits2Float(0x4242022d));
4477path.close();
4478
4479 SkPath path2(path);
4480 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4481}

◆ battleOp166()

static void battleOp166 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4484 of file PathOpsBattles.cpp.

4484 {
4485 SkPath path;
4486 path.setFillType((SkPathFillType) 0);
4487path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4488path.cubicTo(SkBits2Float(0x41e5cd16), SkBits2Float(0xc2a60000), SkBits2Float(0x425da203), SkBits2Float(0xc2884b73), SkBits2Float(0x428d165b), SkBits2Float(0xc22eeec9));
4489path.cubicTo(SkBits2Float(0x42ab5bb4), SkBits2Float(0xc19a8d5b), SkBits2Float(0x42ae3add), SkBits2Float(0x4132f7c2), SkBits2Float(0x4294adf4), SkBits2Float(0x4213a75b));
4490path.lineTo(SkBits2Float(0x4256f554), SkBits2Float(0x41d579ab));
4491path.cubicTo(SkBits2Float(0x427be612), SkBits2Float(0x41015fcf), SkBits2Float(0x4277bf2e), SkBits2Float(0xc15f72f6), SkBits2Float(0x424bfb4d), SkBits2Float(0xc1fcea38));
4492path.cubicTo(SkBits2Float(0x4220376c), SkBits2Float(0xc2450d7a), SkBits2Float(0x41a61f08), SkBits2Float(0xc2700000), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
4493path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4494path.close();
4495
4496 SkPath path1(path);
4497 path.reset();
4498 path.setFillType((SkPathFillType) 0);
4499path.moveTo(SkBits2Float(0x4294adf4), SkBits2Float(0x4213a75b));
4500path.cubicTo(SkBits2Float(0x428facea), SkBits2Float(0x4227cf1b), SkBits2Float(0x4289a8e5), SkBits2Float(0x423ae500), SkBits2Float(0x4282b9a7), SkBits2Float(0x424c9dab));
4501path.lineTo(SkBits2Float(0x423d0015), SkBits2Float(0x4213ea45));
4502path.cubicTo(SkBits2Float(0x424706b3), SkBits2Float(0x42071ac0), SkBits2Float(0x424fb93a), SkBits2Float(0x41f29d8f), SkBits2Float(0x4256f555), SkBits2Float(0x41d579ac));
4503path.lineTo(SkBits2Float(0x4294adf4), SkBits2Float(0x4213a75b));
4504path.close();
4505
4506 SkPath path2(path);
4507 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4508}

◆ battleOp167()

static void battleOp167 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4511 of file PathOpsBattles.cpp.

4511 {
4512 SkPath path;
4513 path.setFillType((SkPathFillType) 1);
4514path.moveTo(SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
4515path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4516path.cubicTo(SkBits2Float(0x41e5cd16), SkBits2Float(0xc2a60000), SkBits2Float(0x425da203), SkBits2Float(0xc2884b73), SkBits2Float(0x428d165b), SkBits2Float(0xc22eeec9));
4517path.cubicTo(SkBits2Float(0x42ab5bb4), SkBits2Float(0xc19a8d5b), SkBits2Float(0x42ae3add), SkBits2Float(0x4132f7c2), SkBits2Float(0x4294adf4), SkBits2Float(0x4213a75b));
4518path.cubicTo(SkBits2Float(0x428facea), SkBits2Float(0x4227cf1b), SkBits2Float(0x4289a8e5), SkBits2Float(0x423ae500), SkBits2Float(0x4282b9a7), SkBits2Float(0x424c9dab));
4519path.lineTo(SkBits2Float(0x423d0015), SkBits2Float(0x4213ea45));
4520path.cubicTo(SkBits2Float(0x424706b3), SkBits2Float(0x42071ac0), SkBits2Float(0x424fb93a), SkBits2Float(0x41f29d8f), SkBits2Float(0x4256f554), SkBits2Float(0x41d579ab));
4521path.cubicTo(SkBits2Float(0x427be612), SkBits2Float(0x41015fcf), SkBits2Float(0x4277bf2e), SkBits2Float(0xc15f72f6), SkBits2Float(0x424bfb4d), SkBits2Float(0xc1fcea38));
4522path.cubicTo(SkBits2Float(0x4220376c), SkBits2Float(0xc2450d7a), SkBits2Float(0x41a61f08), SkBits2Float(0xc2700000), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
4523path.close();
4524
4525 SkPath path1(path);
4526 path.reset();
4527 path.setFillType((SkPathFillType) 0);
4528path.moveTo(SkBits2Float(0x4282b9a8), SkBits2Float(0x424c9dac));
4529path.cubicTo(SkBits2Float(0x4238a98e), SkBits2Float(0x42975dcd), SkBits2Float(0x416d9db4), SkBits2Float(0x42aecc7f), SkBits2Float(0xc17bb856), SkBits2Float(0x42a2fd9a));
4530path.cubicTo(SkBits2Float(0xc2394396), SkBits2Float(0x42972eb6), SkBits2Float(0xc28e09e8), SkBits2Float(0x42543e5a), SkBits2Float(0xc29f69c3), SkBits2Float(0x41b9307a));
4531path.cubicTo(SkBits2Float(0xc2b0c99f), SkBits2Float(0xc0d86efe), SkBits2Float(0xc29f345f), SkBits2Float(0xc21c161b), SkBits2Float(0xc263c1d4), SkBits2Float(0xc2718f13));
4532path.lineTo(SkBits2Float(0xc224a4cd), SkBits2Float(0xc22e9eef));
4533path.cubicTo(SkBits2Float(0xc2662cd7), SkBits2Float(0xc1e1aab7), SkBits2Float(0xc27f98a3), SkBits2Float(0xc09c754c), SkBits2Float(0xc26679fe), SkBits2Float(0x4185df20));
4534path.cubicTo(SkBits2Float(0xc24d5b58), SkBits2Float(0x42196dcb), SkBits2Float(0xc205ecef), SkBits2Float(0x425a93a6), SkBits2Float(0xc135f72f), SkBits2Float(0x426ba619));
4535path.cubicTo(SkBits2Float(0x412bc560), SkBits2Float(0x427cb88a), SkBits2Float(0x42057da8), SkBits2Float(0x425ad7c5), SkBits2Float(0x423d0018), SkBits2Float(0x4213ea45));
4536path.lineTo(SkBits2Float(0x4282b9a8), SkBits2Float(0x424c9dac));
4537path.close();
4538
4539 SkPath path2(path);
4540 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4541}

◆ battleOp168()

static void battleOp168 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4544 of file PathOpsBattles.cpp.

4544 {
4545 SkPath path;
4546 path.setFillType((SkPathFillType) 0);
4547path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4548path.cubicTo(SkBits2Float(0x41ea54b9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4261a7de), SkBits2Float(0xc2871f16), SkBits2Float(0x428ebc81), SkBits2Float(0xc2297f4d));
4549path.cubicTo(SkBits2Float(0x42aca513), SkBits2Float(0xc18980da), SkBits2Float(0x42adc9a4), SkBits2Float(0x41604127), SkBits2Float(0x4291be57), SkBits2Float(0x421eee87));
4550path.lineTo(SkBits2Float(0x4252b6a9), SkBits2Float(0x41e5c7e9));
4551path.cubicTo(SkBits2Float(0x427b4260), SkBits2Float(0x41221c9f), SkBits2Float(0x42799b62), SkBits2Float(0xc146ccc2), SkBits2Float(0x424e5da6), SkBits2Float(0xc1f50e65));
4552path.cubicTo(SkBits2Float(0x42231fea), SkBits2Float(0xc2435b34), SkBits2Float(0x41a9655c), SkBits2Float(0xc26ffffe), SkBits2Float(0x3725ffa9), SkBits2Float(0xc26fffff));
4553path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4554path.close();
4555
4556 SkPath path1(path);
4557 path.reset();
4558 path.setFillType((SkPathFillType) 0);
4559path.moveTo(SkBits2Float(0x4291be57), SkBits2Float(0x421eee8a));
4560path.cubicTo(SkBits2Float(0x428c4169), SkBits2Float(0x42330feb), SkBits2Float(0x4285bd57), SkBits2Float(0x4246005c), SkBits2Float(0x427c99ac), SkBits2Float(0x4257723d));
4561path.lineTo(SkBits2Float(0x42369a46), SkBits2Float(0x421bbe89));
4562path.cubicTo(SkBits2Float(0x42415bc7), SkBits2Float(0x420f2230), SkBits2Float(0x424ac771), SkBits2Float(0x4201714b), SkBits2Float(0x4252b6a9), SkBits2Float(0x41e5c7e9));
4563path.lineTo(SkBits2Float(0x4291be57), SkBits2Float(0x421eee8a));
4564path.close();
4565
4566 SkPath path2(path);
4567 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4568}

◆ battleOp169()

static void battleOp169 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4571 of file PathOpsBattles.cpp.

4571 {
4572 SkPath path;
4573 path.setFillType((SkPathFillType) 1);
4574path.moveTo(SkBits2Float(0x3725ffa9), SkBits2Float(0xc26fffff));
4575path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4576path.cubicTo(SkBits2Float(0x41ea54b9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4261a7de), SkBits2Float(0xc2871f16), SkBits2Float(0x428ebc81), SkBits2Float(0xc2297f4d));
4577path.cubicTo(SkBits2Float(0x42aca513), SkBits2Float(0xc18980da), SkBits2Float(0x42adc9a4), SkBits2Float(0x41604127), SkBits2Float(0x4291be57), SkBits2Float(0x421eee8a));
4578path.cubicTo(SkBits2Float(0x428c4169), SkBits2Float(0x42330feb), SkBits2Float(0x4285bd57), SkBits2Float(0x4246005c), SkBits2Float(0x427c99ac), SkBits2Float(0x4257723d));
4579path.lineTo(SkBits2Float(0x42369a46), SkBits2Float(0x421bbe89));
4580path.cubicTo(SkBits2Float(0x42415bc7), SkBits2Float(0x420f2230), SkBits2Float(0x424ac771), SkBits2Float(0x4201714b), SkBits2Float(0x4252b6a9), SkBits2Float(0x41e5c7e9));
4581path.cubicTo(SkBits2Float(0x427b4260), SkBits2Float(0x41221c9f), SkBits2Float(0x42799b62), SkBits2Float(0xc146ccc2), SkBits2Float(0x424e5da6), SkBits2Float(0xc1f50e65));
4582path.cubicTo(SkBits2Float(0x42231fea), SkBits2Float(0xc2435b34), SkBits2Float(0x41a9655c), SkBits2Float(0xc26ffffe), SkBits2Float(0x3725ffa9), SkBits2Float(0xc26fffff));
4583path.close();
4584
4585 SkPath path1(path);
4586 path.reset();
4587 path.setFillType((SkPathFillType) 0);
4588path.moveTo(SkBits2Float(0x427c99ad), SkBits2Float(0x4257723e));
4589path.cubicTo(SkBits2Float(0x422a2459), SkBits2Float(0x429c0ff6), SkBits2Float(0x411ef0c1), SkBits2Float(0x42b0a109), SkBits2Float(0xc1a68a7f), SkBits2Float(0x42a0b1a2));
4590path.cubicTo(SkBits2Float(0xc24e46af), SkBits2Float(0x4290c23b), SkBits2Float(0xc296269a), SkBits2Float(0x423e3c04), SkBits2Float(0xc2a2b82b), SkBits2Float(0x41835b51));
4591path.cubicTo(SkBits2Float(0xc2af49bc), SkBits2Float(0xc16b82d9), SkBits2Float(0xc2973524), SkBits2Float(0xc23adb29), SkBits2Float(0xc24965c6), SkBits2Float(0xc283f801));
4592path.lineTo(SkBits2Float(0xc21196ae), SkBits2Float(0xc23ecc58));
4593path.cubicTo(SkBits2Float(0xc25a9cfe), SkBits2Float(0xc20713a1), SkBits2Float(0xc27d6da1), SkBits2Float(0xc12a3fcc), SkBits2Float(0xc26b41bb), SkBits2Float(0x413de9a9));
4594path.cubicTo(SkBits2Float(0xc25915d3), SkBits2Float(0x420984c8), SkBits2Float(0xc2151d75), SkBits2Float(0x42514a1b), SkBits2Float(0xc170c819), SkBits2Float(0x4268540a));
4595path.cubicTo(SkBits2Float(0x40e5cb46), SkBits2Float(0x427f5dfa), SkBits2Float(0x41f5fd0c), SkBits2Float(0x4261a1d8), SkBits2Float(0x42369a4a), SkBits2Float(0x421bbe87));
4596path.lineTo(SkBits2Float(0x427c99ad), SkBits2Float(0x4257723e));
4597path.close();
4598
4599 SkPath path2(path);
4600 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4601}

◆ battleOp17()

static void battleOp17 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 523 of file PathOpsBattles.cpp.

523 {
524 SkPath path;
525 path.setFillType((SkPathFillType) 0);
526path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
527path.cubicTo(SkBits2Float(0x3f9860dc), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40185ea2), SkBits2Float(0xc2a5f2e2), SkBits2Float(0x40647d09), SkBits2Float(0xc2a5d8aa));
528path.lineTo(SkBits2Float(0x40252c2a), SkBits2Float(0xc26fc723));
529path.cubicTo(SkBits2Float(0x3fdc4b47), SkBits2Float(0xc26fed09), SkBits2Float(0x3f5c4ea6), SkBits2Float(0xc26ffffe), SkBits2Float(0x3664fea3), SkBits2Float(0xc26ffffe));
530path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
531path.close();
532
533 SkPath path1(path);
534 path.reset();
535 path.setFillType((SkPathFillType) 0);
536path.moveTo(SkBits2Float(0x40647d17), SkBits2Float(0xc2a5d8ab));
537path.cubicTo(SkBits2Float(0x406c19ae), SkBits2Float(0xc2a5d60b), SkBits2Float(0x4073b608), SkBits2Float(0xc2a5d34a), SkBits2Float(0x407b5230), SkBits2Float(0xc2a5d069));
538path.lineTo(SkBits2Float(0x4035ad90), SkBits2Float(0xc26fbb32));
539path.cubicTo(SkBits2Float(0x40302d3b), SkBits2Float(0xc26fbf5d), SkBits2Float(0x402aacbf), SkBits2Float(0xc26fc358), SkBits2Float(0x40252c21), SkBits2Float(0xc26fc722));
540path.lineTo(SkBits2Float(0x40647d17), SkBits2Float(0xc2a5d8ab));
541path.close();
542
543 SkPath path2(path);
544 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
545}

◆ battleOp170()

static void battleOp170 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4604 of file PathOpsBattles.cpp.

4604 {
4605 SkPath path;
4606 path.setFillType((SkPathFillType) 0);
4607path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4608path.cubicTo(SkBits2Float(0x41ef3488), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4265f5fc), SkBits2Float(0xc285d5a4), SkBits2Float(0x429072a6), SkBits2Float(0xc2239841));
4609path.cubicTo(SkBits2Float(0x42adea4e), SkBits2Float(0xc16e14e5), SkBits2Float(0x42ad1da2), SkBits2Float(0x41886b20), SkBits2Float(0x428e5adb), SkBits2Float(0x422ac68e));
4610path.lineTo(SkBits2Float(0x424dd078), SkBits2Float(0x41f6e790));
4611path.cubicTo(SkBits2Float(0x427a49b4), SkBits2Float(0x41453b4b), SkBits2Float(0x427b719d), SkBits2Float(0xc12c1b6e), SkBits2Float(0x4250d71f), SkBits2Float(0xc1ec85c5));
4612path.cubicTo(SkBits2Float(0x42263ca0), SkBits2Float(0xc2417eea), SkBits2Float(0x41aceb63), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
4613path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4614path.close();
4615
4616 SkPath path1(path);
4617 path.reset();
4618 path.setFillType((SkPathFillType) 0);
4619path.moveTo(SkBits2Float(0x428e5adb), SkBits2Float(0x422ac690));
4620path.cubicTo(SkBits2Float(0x42885732), SkBits2Float(0x423ed443), SkBits2Float(0x428148a8), SkBits2Float(0x42518e43), SkBits2Float(0x42729aa0), SkBits2Float(0x4262a4bd));
4621path.lineTo(SkBits2Float(0x422f605c), SkBits2Float(0x4223d6b5));
4622path.cubicTo(SkBits2Float(0x423aea98), SkBits2Float(0x42177c70), SkBits2Float(0x42451e76), SkBits2Float(0x4209f2e4), SkBits2Float(0x424dd078), SkBits2Float(0x41f6e792));
4623path.lineTo(SkBits2Float(0x428e5adb), SkBits2Float(0x422ac690));
4624path.close();
4625
4626 SkPath path2(path);
4627 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4628}

◆ battleOp171()

static void battleOp171 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4631 of file PathOpsBattles.cpp.

4631 {
4632 SkPath path;
4633 path.setFillType((SkPathFillType) 1);
4634path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
4635path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4636path.cubicTo(SkBits2Float(0x41ef3488), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4265f5fc), SkBits2Float(0xc285d5a4), SkBits2Float(0x429072a6), SkBits2Float(0xc2239841));
4637path.cubicTo(SkBits2Float(0x42adea4e), SkBits2Float(0xc16e14e5), SkBits2Float(0x42ad1da2), SkBits2Float(0x41886b20), SkBits2Float(0x428e5adb), SkBits2Float(0x422ac690));
4638path.cubicTo(SkBits2Float(0x42885732), SkBits2Float(0x423ed443), SkBits2Float(0x428148a8), SkBits2Float(0x42518e43), SkBits2Float(0x42729aa0), SkBits2Float(0x4262a4bd));
4639path.lineTo(SkBits2Float(0x422f605c), SkBits2Float(0x4223d6b5));
4640path.cubicTo(SkBits2Float(0x423aea98), SkBits2Float(0x42177c70), SkBits2Float(0x42451e76), SkBits2Float(0x4209f2e4), SkBits2Float(0x424dd078), SkBits2Float(0x41f6e790));
4641path.cubicTo(SkBits2Float(0x427a49b4), SkBits2Float(0x41453b4b), SkBits2Float(0x427b719d), SkBits2Float(0xc12c1b6e), SkBits2Float(0x4250d71f), SkBits2Float(0xc1ec85c5));
4642path.cubicTo(SkBits2Float(0x42263ca0), SkBits2Float(0xc2417eea), SkBits2Float(0x41aceb63), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
4643path.close();
4644
4645 SkPath path1(path);
4646 path.reset();
4647 path.setFillType((SkPathFillType) 0);
4648path.moveTo(SkBits2Float(0x42729aa1), SkBits2Float(0x4262a4be));
4649path.cubicTo(SkBits2Float(0x421a0aa1), SkBits2Float(0x42a0b8ab), SkBits2Float(0x4092ff14), SkBits2Float(0x42b1fc82), SkBits2Float(0xc1d17709), SkBits2Float(0x429d861f));
4650path.cubicTo(SkBits2Float(0xc263d6eb), SkBits2Float(0x42890fbc), SkBits2Float(0xc29dea71), SkBits2Float(0x42253dbf), SkBits2Float(0xc2a5016a), SkBits2Float(0x4111261a));
4651path.cubicTo(SkBits2Float(0xc2ac1862), SkBits2Float(0xc1b95567), SkBits2Float(0xc28cface), SkBits2Float(0xc25a1117), SkBits2Float(0xc22aafa6), SkBits2Float(0xc28e61ba));
4652path.lineTo(SkBits2Float(0xc1f6c679), SkBits2Float(0xc24dda63));
4653path.cubicTo(SkBits2Float(0xc24bd376), SkBits2Float(0xc21da377), SkBits2Float(0xc278cff1), SkBits2Float(0xc185f9db), SkBits2Float(0xc26e8fe1), SkBits2Float(0x40d1da84));
4654path.cubicTo(SkBits2Float(0xc2644fd1), SkBits2Float(0x41eee71d), SkBits2Float(0xc224b3fc), SkBits2Float(0x4246293b), SkBits2Float(0xc1976b90), SkBits2Float(0x4263becd));
4655path.cubicTo(SkBits2Float(0x405486c0), SkBits2Float(0x4280aa2f), SkBits2Float(0x41deb5f2), SkBits2Float(0x42685e3e), SkBits2Float(0x422f605e), SkBits2Float(0x4223d6b6));
4656path.lineTo(SkBits2Float(0x42729aa1), SkBits2Float(0x4262a4be));
4657path.close();
4658
4659 SkPath path2(path);
4660 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4661}

◆ battleOp172()

static void battleOp172 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4664 of file PathOpsBattles.cpp.

4664 {
4665 SkPath path;
4666 path.setFillType((SkPathFillType) 0);
4667path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4668path.cubicTo(SkBits2Float(0x41f30c96), SkBits2Float(0xc2a60000), SkBits2Float(0x426956a5), SkBits2Float(0xc284cd4a), SkBits2Float(0x4291c05e), SkBits2Float(0xc21ee718));
4669path.cubicTo(SkBits2Float(0x42aed56a), SkBits2Float(0xc150ce71), SkBits2Float(0x42ac7181), SkBits2Float(0x419b8107), SkBits2Float(0x428b8516), SkBits2Float(0x4233e422));
4670path.lineTo(SkBits2Float(0x4249b729), SkBits2Float(0x42020ab3));
4671path.cubicTo(SkBits2Float(0x427950d3), SkBits2Float(0x4160d339), SkBits2Float(0x427cc584), SkBits2Float(0xc116f1c4), SkBits2Float(0x4252b998), SkBits2Float(0xc1e5bd26));
4672path.cubicTo(SkBits2Float(0x4228adad), SkBits2Float(0xc24000b5), SkBits2Float(0x41afb2be), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
4673path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4674path.close();
4675
4676 SkPath path1(path);
4677 path.reset();
4678 path.setFillType((SkPathFillType) 0);
4679path.moveTo(SkBits2Float(0x428b8516), SkBits2Float(0x4233e422));
4680path.cubicTo(SkBits2Float(0x4285165c), SkBits2Float(0x4247d8d0), SkBits2Float(0x427b34bd), SkBits2Float(0x425a5d74), SkBits2Float(0x426a6401), SkBits2Float(0x426b20b1));
4681path.lineTo(SkBits2Float(0x42297063), SkBits2Float(0x4229f8c9));
4682path.cubicTo(SkBits2Float(0x42359840), SkBits2Float(0x421ddab1), SkBits2Float(0x42406a5a), SkBits2Float(0x421077b9), SkBits2Float(0x4249b72b), SkBits2Float(0x42020ab4));
4683path.lineTo(SkBits2Float(0x428b8516), SkBits2Float(0x4233e422));
4684path.close();
4685
4686 SkPath path2(path);
4687 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4688}

◆ battleOp173()

static void battleOp173 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4691 of file PathOpsBattles.cpp.

4691 {
4692 SkPath path;
4693 path.setFillType((SkPathFillType) 1);
4694path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4695path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4696path.cubicTo(SkBits2Float(0x41f30c96), SkBits2Float(0xc2a60000), SkBits2Float(0x426956a5), SkBits2Float(0xc284cd4a), SkBits2Float(0x4291c05e), SkBits2Float(0xc21ee718));
4697path.cubicTo(SkBits2Float(0x42aed56a), SkBits2Float(0xc150ce71), SkBits2Float(0x42ac7181), SkBits2Float(0x419b8107), SkBits2Float(0x428b8516), SkBits2Float(0x4233e422));
4698path.cubicTo(SkBits2Float(0x4285165c), SkBits2Float(0x4247d8d0), SkBits2Float(0x427b34bd), SkBits2Float(0x425a5d74), SkBits2Float(0x426a6401), SkBits2Float(0x426b20b1));
4699path.lineTo(SkBits2Float(0x42297063), SkBits2Float(0x4229f8c9));
4700path.cubicTo(SkBits2Float(0x42359840), SkBits2Float(0x421ddab1), SkBits2Float(0x42406a5a), SkBits2Float(0x421077b9), SkBits2Float(0x4249b72b), SkBits2Float(0x42020ab4));
4701path.lineTo(SkBits2Float(0x4249b729), SkBits2Float(0x42020ab3));
4702path.cubicTo(SkBits2Float(0x427950d3), SkBits2Float(0x4160d339), SkBits2Float(0x427cc584), SkBits2Float(0xc116f1c4), SkBits2Float(0x4252b998), SkBits2Float(0xc1e5bd26));
4703path.cubicTo(SkBits2Float(0x4228adad), SkBits2Float(0xc24000b5), SkBits2Float(0x41afb2be), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4704path.close();
4705
4706 SkPath path1(path);
4707 path.reset();
4708 path.setFillType((SkPathFillType) 0);
4709path.moveTo(SkBits2Float(0x426a6401), SkBits2Float(0x426b20b0));
4710path.cubicTo(SkBits2Float(0x420d0644), SkBits2Float(0x42a419c2), SkBits2Float(0x3eb79d8f), SkBits2Float(0x42b29b69), SkBits2Float(0xc1f292a7), SkBits2Float(0x429a86c6));
4711path.cubicTo(SkBits2Float(0xc27401e4), SkBits2Float(0x42827223), SkBits2Float(0xc2a34d81), SkBits2Float(0x4210aea0), SkBits2Float(0xc2a5dfaf), SkBits2Float(0x404f3106));
4712path.cubicTo(SkBits2Float(0xc2a871dd), SkBits2Float(0xc1ed90fa), SkBits2Float(0xc283ccf3), SkBits2Float(0xc27113da), SkBits2Float(0xc21101fe), SkBits2Float(0xc2955440));
4713path.lineTo(SkBits2Float(0xc1d1a65c), SkBits2Float(0xc257e5c3));
4714path.cubicTo(SkBits2Float(0xc23e8e16), SkBits2Float(0xc22e45d9), SkBits2Float(0xc27388d2), SkBits2Float(0xc1abbc0d), SkBits2Float(0xc26fd138), SkBits2Float(0x4015c6fe));
4715path.cubicTo(SkBits2Float(0xc26c199f), SkBits2Float(0x41d12dcc), SkBits2Float(0xc2306400), SkBits2Float(0x423c98a5), SkBits2Float(0xc1af5a7e), SkBits2Float(0x425f695f));
4716path.cubicTo(SkBits2Float(0x3e84bf70), SkBits2Float(0x42811d0c), SkBits2Float(0x41cbe40c), SkBits2Float(0x426d40fa), SkBits2Float(0x42297064), SkBits2Float(0x4229f8cc));
4717path.lineTo(SkBits2Float(0x426a6401), SkBits2Float(0x426b20b0));
4718path.close();
4719
4720 SkPath path2(path);
4721 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4722}

◆ battleOp174()

static void battleOp174 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4725 of file PathOpsBattles.cpp.

4725 {
4726 SkPath path;
4727 path.setFillType((SkPathFillType) 0);
4728path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4729path.cubicTo(SkBits2Float(0x41f67553), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426c5214), SkBits2Float(0xc283df7d), SkBits2Float(0x4292df93), SkBits2Float(0xc21ab724));
4730path.cubicTo(SkBits2Float(0x42af961c), SkBits2Float(0xc136bd38), SkBits2Float(0x42abbe10), SkBits2Float(0x41ac5dd5), SkBits2Float(0x4288e395), SkBits2Float(0x423bcd53));
4731path.lineTo(SkBits2Float(0x4245e96c), SkBits2Float(0x4207c2b1));
4732path.cubicTo(SkBits2Float(0x42784d66), SkBits2Float(0x41793464), SkBits2Float(0x427ddc1f), SkBits2Float(0xc10419c2), SkBits2Float(0x425458d8), SkBits2Float(0xc1dfaf58));
4733path.cubicTo(SkBits2Float(0x422ad590), SkBits2Float(0xc23ea8e8), SkBits2Float(0x41b229a4), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
4734path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4735path.close();
4736
4737 SkPath path1(path);
4738 path.reset();
4739 path.setFillType((SkPathFillType) 0);
4740path.moveTo(SkBits2Float(0x4288e396), SkBits2Float(0x423bcd52));
4741path.cubicTo(SkBits2Float(0x42821571), SkBits2Float(0x424fa4b8), SkBits2Float(0x427470be), SkBits2Float(0x4261f24c), SkBits2Float(0x4262dfb6), SkBits2Float(0x4272637b));
4742path.lineTo(SkBits2Float(0x42240156), SkBits2Float(0x422f387f));
4743path.cubicTo(SkBits2Float(0x4230b436), SkBits2Float(0x422355b8), SkBits2Float(0x423c12ab), SkBits2Float(0x42161a8d), SkBits2Float(0x4245e96e), SkBits2Float(0x4207c2b2));
4744path.lineTo(SkBits2Float(0x4288e396), SkBits2Float(0x423bcd52));
4745path.close();
4746
4747 SkPath path2(path);
4748 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4749}

◆ battleOp175()

static void battleOp175 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4752 of file PathOpsBattles.cpp.

4752 {
4753 SkPath path;
4754 path.setFillType((SkPathFillType) 1);
4755path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4756path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4757path.cubicTo(SkBits2Float(0x41f67553), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426c5214), SkBits2Float(0xc283df7d), SkBits2Float(0x4292df93), SkBits2Float(0xc21ab724));
4758path.cubicTo(SkBits2Float(0x42af961c), SkBits2Float(0xc136bd38), SkBits2Float(0x42abbe10), SkBits2Float(0x41ac5dd5), SkBits2Float(0x4288e396), SkBits2Float(0x423bcd52));
4759path.cubicTo(SkBits2Float(0x42821571), SkBits2Float(0x424fa4b8), SkBits2Float(0x427470be), SkBits2Float(0x4261f24c), SkBits2Float(0x4262dfb6), SkBits2Float(0x4272637b));
4760path.lineTo(SkBits2Float(0x42240156), SkBits2Float(0x422f387f));
4761path.cubicTo(SkBits2Float(0x4230b436), SkBits2Float(0x422355b8), SkBits2Float(0x423c12ab), SkBits2Float(0x42161a8d), SkBits2Float(0x4245e96e), SkBits2Float(0x4207c2b2));
4762path.lineTo(SkBits2Float(0x4245e96c), SkBits2Float(0x4207c2b1));
4763path.cubicTo(SkBits2Float(0x42784d66), SkBits2Float(0x41793464), SkBits2Float(0x427ddc1f), SkBits2Float(0xc10419c2), SkBits2Float(0x425458d8), SkBits2Float(0xc1dfaf58));
4764path.cubicTo(SkBits2Float(0x422ad590), SkBits2Float(0xc23ea8e8), SkBits2Float(0x41b229a4), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
4765path.close();
4766
4767 SkPath path1(path);
4768 path.reset();
4769 path.setFillType((SkPathFillType) 0);
4770path.moveTo(SkBits2Float(0x4262dfb7), SkBits2Float(0x4272637c));
4771path.cubicTo(SkBits2Float(0x4201435c), SkBits2Float(0x42a6e035), SkBits2Float(0xc05a052a), SkBits2Float(0x42b2d330), SkBits2Float(0xc207a774), SkBits2Float(0x429782c3));
4772path.cubicTo(SkBits2Float(0xc280d74a), SkBits2Float(0x427864aa), SkBits2Float(0xc2a78489), SkBits2Float(0x41fbcc10), SkBits2Float(0xc2a5f467), SkBits2Float(0xbff86670));
4773path.cubicTo(SkBits2Float(0xc2a46445), SkBits2Float(0xc20d6c6d), SkBits2Float(0xc275c9b5), SkBits2Float(0xc2821580), SkBits2Float(0xc1f2ade6), SkBits2Float(0xc29a8413));
4774path.lineTo(SkBits2Float(0xc1af6e4e), SkBits2Float(0xc25f6582));
4775path.cubicTo(SkBits2Float(0xc231ad90), SkBits2Float(0xc23c12bd), SkBits2Float(0xc26dacb3), SkBits2Float(0xc1cc77b7), SkBits2Float(0xc26fef30), SkBits2Float(0xbfb390a5));
4776path.cubicTo(SkBits2Float(0xc27231ae), SkBits2Float(0x41b605a0), SkBits2Float(0xc23a46a0), SkBits2Float(0x42338faf), SkBits2Float(0xc1c42047), SkBits2Float(0x425b0d36));
4777path.cubicTo(SkBits2Float(0xc01d9a6d), SkBits2Float(0x4281455e), SkBits2Float(0x41bae2f1), SkBits2Float(0x42714420), SkBits2Float(0x42240157), SkBits2Float(0x422f387f));
4778path.lineTo(SkBits2Float(0x4262dfb7), SkBits2Float(0x4272637c));
4779path.close();
4780
4781 SkPath path2(path);
4782 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4783}

◆ battleOp176()

static void battleOp176 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4786 of file PathOpsBattles.cpp.

4786 {
4787 SkPath path;
4788 path.setFillType((SkPathFillType) 0);
4789path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4790path.cubicTo(SkBits2Float(0x41f9cdf3), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426f3c43), SkBits2Float(0xc282f30b), SkBits2Float(0x4293f176), SkBits2Float(0xc2169536));
4791path.cubicTo(SkBits2Float(0x42b044ca), SkBits2Float(0xc11d115b), SkBits2Float(0x42aaf59e), SkBits2Float(0x41bcd986), SkBits2Float(0x428633ff), SkBits2Float(0x42436703));
4792path.lineTo(SkBits2Float(0x42420751), SkBits2Float(0x420d4138));
4793path.cubicTo(SkBits2Float(0x42772b98), SkBits2Float(0x41888496), SkBits2Float(0x427ed8af), SkBits2Float(0xc0e315f7), SkBits2Float(0x4255e4d4), SkBits2Float(0xc1d9b5cc));
4794path.cubicTo(SkBits2Float(0x422cf0fb), SkBits2Float(0xc23d530d), SkBits2Float(0x41b494e9), SkBits2Float(0xc2700000), SkBits2Float(0x3743ffa9), SkBits2Float(0xc2700000));
4795path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4796path.close();
4797
4798 SkPath path1(path);
4799 path.reset();
4800 path.setFillType((SkPathFillType) 0);
4801path.moveTo(SkBits2Float(0x428633ff), SkBits2Float(0x42436705));
4802path.cubicTo(SkBits2Float(0x427e0fd0), SkBits2Float(0x42571b29), SkBits2Float(0x426d975d), SkBits2Float(0x42692b9b), SkBits2Float(0x425b4ae0), SkBits2Float(0x427944c1));
4803path.lineTo(SkBits2Float(0x421e8652), SkBits2Float(0x423431b3));
4804path.cubicTo(SkBits2Float(0x422bc0b3), SkBits2Float(0x42288e8e), SkBits2Float(0x4237a8bb), SkBits2Float(0x421b7f95), SkBits2Float(0x42420752), SkBits2Float(0x420d4138));
4805path.lineTo(SkBits2Float(0x428633ff), SkBits2Float(0x42436705));
4806path.close();
4807
4808 SkPath path2(path);
4809 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4810}

◆ battleOp177()

static void battleOp177 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4813 of file PathOpsBattles.cpp.

4813 {
4814 SkPath path;
4815 path.setFillType((SkPathFillType) 1);
4816path.moveTo(SkBits2Float(0x3743ffa9), SkBits2Float(0xc2700000));
4817path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4818path.cubicTo(SkBits2Float(0x41f9cdf3), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426f3c43), SkBits2Float(0xc282f30b), SkBits2Float(0x4293f176), SkBits2Float(0xc2169536));
4819path.cubicTo(SkBits2Float(0x42b044ca), SkBits2Float(0xc11d115b), SkBits2Float(0x42aaf59e), SkBits2Float(0x41bcd986), SkBits2Float(0x428633ff), SkBits2Float(0x42436705));
4820path.cubicTo(SkBits2Float(0x427e0fd0), SkBits2Float(0x42571b29), SkBits2Float(0x426d975d), SkBits2Float(0x42692b9b), SkBits2Float(0x425b4ae0), SkBits2Float(0x427944c1));
4821path.lineTo(SkBits2Float(0x421e8652), SkBits2Float(0x423431b3));
4822path.cubicTo(SkBits2Float(0x422bc0b3), SkBits2Float(0x42288e8e), SkBits2Float(0x4237a8bb), SkBits2Float(0x421b7f95), SkBits2Float(0x42420751), SkBits2Float(0x420d4138));
4823path.cubicTo(SkBits2Float(0x42772b98), SkBits2Float(0x41888496), SkBits2Float(0x427ed8af), SkBits2Float(0xc0e315f7), SkBits2Float(0x4255e4d4), SkBits2Float(0xc1d9b5cc));
4824path.cubicTo(SkBits2Float(0x422cf0fb), SkBits2Float(0xc23d530d), SkBits2Float(0x41b494e9), SkBits2Float(0xc2700000), SkBits2Float(0x3743ffa9), SkBits2Float(0xc2700000));
4825path.close();
4826
4827 SkPath path1(path);
4828 path.reset();
4829 path.setFillType((SkPathFillType) 0);
4830path.moveTo(SkBits2Float(0x425b4ae0), SkBits2Float(0x427944c0));
4831path.cubicTo(SkBits2Float(0x41eb12b8), SkBits2Float(0x42a964d5), SkBits2Float(0xc0e3546a), SkBits2Float(0x42b2bc1c), SkBits2Float(0xc2157060), SkBits2Float(0x42943ba4));
4832path.cubicTo(SkBits2Float(0xc2873b19), SkBits2Float(0x426b7658), SkBits2Float(0xc2ab209f), SkBits2Float(0x41d60b1d), SkBits2Float(0xc2a5685b), SkBits2Float(0xc0e02f3c));
4833path.cubicTo(SkBits2Float(0xc29fb018), SkBits2Float(0xc223115c), SkBits2Float(0xc263001e), SkBits2Float(0xc28acd07), SkBits2Float(0xc1c2e1a0), SkBits2Float(0xc29eb07c));
4834path.lineTo(SkBits2Float(0xc18ce0d1), SkBits2Float(0xc2656e32));
4835path.cubicTo(SkBits2Float(0xc22418c2), SkBits2Float(0xc248ad0a), SkBits2Float(0xc266dfbc), SkBits2Float(0xc1ebc2b6), SkBits2Float(0xc26f24bb), SkBits2Float(0xc0a20f94));
4836path.cubicTo(SkBits2Float(0xc27769ba), SkBits2Float(0x419abaee), SkBits2Float(0xc24383ac), SkBits2Float(0x422a36b0), SkBits2Float(0xc1d80e5c), SkBits2Float(0x4256500a));
4837path.cubicTo(SkBits2Float(0xc0a45587), SkBits2Float(0x428134b2), SkBits2Float(0x41a9eeb8), SkBits2Float(0x4274e820), SkBits2Float(0x421e8655), SkBits2Float(0x423431b1));
4838path.lineTo(SkBits2Float(0x425b4ae0), SkBits2Float(0x427944c0));
4839path.close();
4840
4841 SkPath path2(path);
4842 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4843}

◆ battleOp178()

static void battleOp178 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4846 of file PathOpsBattles.cpp.

4846 {
4847 SkPath path;
4848 path.setFillType((SkPathFillType) 0);
4849path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4850path.cubicTo(SkBits2Float(0x41fc5f30), SkBits2Float(0xc2a5fffe), SkBits2Float(0x427176a0), SkBits2Float(0xc2823b95), SkBits2Float(0x4294be35), SkBits2Float(0xc21365c9));
4851path.cubicTo(SkBits2Float(0x42b0c118), SkBits2Float(0xc1095198), SkBits2Float(0x42aa4b8f), SkBits2Float(0x41c9721a), SkBits2Float(0x42841312), SkBits2Float(0x42491ec0));
4852path.lineTo(SkBits2Float(0x423ef37b), SkBits2Float(0x42116356));
4853path.cubicTo(SkBits2Float(0x427635bc), SkBits2Float(0x41919f96), SkBits2Float(0x427f8c66), SkBits2Float(0xc0c68887), SkBits2Float(0x42570cd6), SkBits2Float(0xc1d51ae4));
4854path.cubicTo(SkBits2Float(0x422e8d45), SkBits2Float(0xc23c49d3), SkBits2Float(0x41b66ffd), SkBits2Float(0xc2700000), SkBits2Float(0xb7060057), SkBits2Float(0xc26fffff));
4855path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4856path.close();
4857
4858 SkPath path1(path);
4859 path.reset();
4860 path.setFillType((SkPathFillType) 0);
4861path.moveTo(SkBits2Float(0x42841313), SkBits2Float(0x42491ebf));
4862path.cubicTo(SkBits2Float(0x42793d8e), SkBits2Float(0x425cb36e), SkBits2Float(0x4268336d), SkBits2Float(0x426e9032), SkBits2Float(0x4255582b), SkBits2Float(0x427e60c5));
4863path.lineTo(SkBits2Float(0x421a3990), SkBits2Float(0x4237e342));
4864path.cubicTo(SkBits2Float(0x4227db27), SkBits2Float(0x422c7494), SkBits2Float(0x42342c7f), SkBits2Float(0x421f8af7), SkBits2Float(0x423ef37c), SkBits2Float(0x42116357));
4865path.lineTo(SkBits2Float(0x42841313), SkBits2Float(0x42491ebf));
4866path.close();
4867
4868 SkPath path2(path);
4869 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4870}

◆ battleOp179()

static void battleOp179 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4873 of file PathOpsBattles.cpp.

4873 {
4874 SkPath path;
4875 path.setFillType((SkPathFillType) 1);
4876path.moveTo(SkBits2Float(0xb7060057), SkBits2Float(0xc26fffff));
4877path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4878path.cubicTo(SkBits2Float(0x41fc5f30), SkBits2Float(0xc2a5fffe), SkBits2Float(0x427176a0), SkBits2Float(0xc2823b95), SkBits2Float(0x4294be35), SkBits2Float(0xc21365c9));
4879path.cubicTo(SkBits2Float(0x42b0c118), SkBits2Float(0xc1095198), SkBits2Float(0x42aa4b8f), SkBits2Float(0x41c9721a), SkBits2Float(0x42841313), SkBits2Float(0x42491ebf));
4880path.cubicTo(SkBits2Float(0x42793d8e), SkBits2Float(0x425cb36e), SkBits2Float(0x4268336d), SkBits2Float(0x426e9032), SkBits2Float(0x4255582b), SkBits2Float(0x427e60c5));
4881path.lineTo(SkBits2Float(0x421a3990), SkBits2Float(0x4237e342));
4882path.cubicTo(SkBits2Float(0x4227db27), SkBits2Float(0x422c7494), SkBits2Float(0x42342c7f), SkBits2Float(0x421f8af7), SkBits2Float(0x423ef37b), SkBits2Float(0x42116356));
4883path.cubicTo(SkBits2Float(0x427635bc), SkBits2Float(0x41919f96), SkBits2Float(0x427f8c66), SkBits2Float(0xc0c68887), SkBits2Float(0x42570cd6), SkBits2Float(0xc1d51ae4));
4884path.cubicTo(SkBits2Float(0x422e8d45), SkBits2Float(0xc23c49d3), SkBits2Float(0x41b66ffd), SkBits2Float(0xc2700000), SkBits2Float(0xb7060057), SkBits2Float(0xc26fffff));
4885path.close();
4886
4887 SkPath path1(path);
4888 path.reset();
4889 path.setFillType((SkPathFillType) 0);
4890path.moveTo(SkBits2Float(0x4255582a), SkBits2Float(0x427e60c6));
4891path.cubicTo(SkBits2Float(0x41d8da26), SkBits2Float(0x42ab2f9f), SkBits2Float(0xc11f0392), SkBits2Float(0x42b2763a), SkBits2Float(0xc21fc8f1), SkBits2Float(0x4291829a));
4892path.cubicTo(SkBits2Float(0xc28be87e), SkBits2Float(0x42611df4), SkBits2Float(0xc2ad8941), SkBits2Float(0x41b88f93), SkBits2Float(0xc2a49219), SkBits2Float(0xc12de56c));
4893path.cubicTo(SkBits2Float(0xc29b9af2), SkBits2Float(0xc2333a80), SkBits2Float(0xc253c58e), SkBits2Float(0xc2910614), SkBits2Float(0xc19d7dc6), SkBits2Float(0xc2a14359));
4894path.lineTo(SkBits2Float(0xc163b2c9), SkBits2Float(0xc26926c4));
4895path.cubicTo(SkBits2Float(0xc2191685), SkBits2Float(0xc251ac40), SkBits2Float(0xc260f8ae), SkBits2Float(0xc201900e), SkBits2Float(0xc26deef7), SkBits2Float(0xc0fb6a70));
4896path.cubicTo(SkBits2Float(0xc27ae541), SkBits2Float(0x41856ae3), SkBits2Float(0xc24a46d8), SkBits2Float(0x4222bc35), SkBits2Float(0xc1e7039a), SkBits2Float(0x42526049));
4897path.cubicTo(SkBits2Float(0xc0e5e60c), SkBits2Float(0x4281022e), SkBits2Float(0x419cc2c4), SkBits2Float(0x42777f70), SkBits2Float(0x421a3996), SkBits2Float(0x4237e33e));
4898path.lineTo(SkBits2Float(0x4255582a), SkBits2Float(0x427e60c6));
4899path.close();
4900
4901 SkPath path2(path);
4902 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4903}

◆ battleOp18()

static void battleOp18 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 548 of file PathOpsBattles.cpp.

548 {
549 SkPath path;
550 path.setFillType((SkPathFillType) 1);
551path.moveTo(SkBits2Float(0x3664fea3), SkBits2Float(0xc26ffffe));
552path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
553path.cubicTo(SkBits2Float(0x3f9860dc), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40185ea2), SkBits2Float(0xc2a5f2e2), SkBits2Float(0x40647d17), SkBits2Float(0xc2a5d8ab));
554path.cubicTo(SkBits2Float(0x406c19ae), SkBits2Float(0xc2a5d60b), SkBits2Float(0x4073b608), SkBits2Float(0xc2a5d34a), SkBits2Float(0x407b5230), SkBits2Float(0xc2a5d069));
555path.lineTo(SkBits2Float(0x4035ad90), SkBits2Float(0xc26fbb32));
556path.cubicTo(SkBits2Float(0x40302d3b), SkBits2Float(0xc26fbf5d), SkBits2Float(0x402aacbf), SkBits2Float(0xc26fc358), SkBits2Float(0x40252c2a), SkBits2Float(0xc26fc723));
557path.cubicTo(SkBits2Float(0x3fdc4b47), SkBits2Float(0xc26fed09), SkBits2Float(0x3f5c4ea6), SkBits2Float(0xc26ffffe), SkBits2Float(0x3664fea3), SkBits2Float(0xc26ffffe));
558path.close();
559
560 SkPath path1(path);
561 path.reset();
562 path.setFillType((SkPathFillType) 0);
563path.moveTo(SkBits2Float(0x407b523a), SkBits2Float(0xc2a5d069));
564path.cubicTo(SkBits2Float(0x40bb53e8), SkBits2Float(0xc2a5a1ad), SkBits2Float(0x40f8dfd1), SkBits2Float(0xc2a5508e), SkBits2Float(0x411b1813), SkBits2Float(0xc2a4dd32));
565path.lineTo(SkBits2Float(0x40e03b7c), SkBits2Float(0xc26e5b8f));
566path.cubicTo(SkBits2Float(0x40b3e8bb), SkBits2Float(0xc26f0259), SkBits2Float(0x40876aeb), SkBits2Float(0xc26f77a1), SkBits2Float(0x4035ad92), SkBits2Float(0xc26fbb33));
567path.lineTo(SkBits2Float(0x407b523a), SkBits2Float(0xc2a5d069));
568path.close();
569
570 SkPath path2(path);
571 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
572}

◆ battleOp180()

static void battleOp180 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4906 of file PathOpsBattles.cpp.

4906 {
4907 SkPath path;
4908 path.setFillType((SkPathFillType) 0);
4909path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4910path.cubicTo(SkBits2Float(0x41fed5d1), SkBits2Float(0xc2a60000), SkBits2Float(0x4273981d), SkBits2Float(0xc28189e8), SkBits2Float(0x42957e40), SkBits2Float(0xc210547e));
4911path.cubicTo(SkBits2Float(0x42b13073), SkBits2Float(0xc0eca961), SkBits2Float(0x42a99b35), SkBits2Float(0x41d57c6c), SkBits2Float(0x4281fa62), SkBits2Float(0x424e82d3));
4912path.lineTo(SkBits2Float(0x423beb8b), SkBits2Float(0x421548fc));
4913path.cubicTo(SkBits2Float(0x427536c2), SkBits2Float(0x419a53c7), SkBits2Float(0x428016af), SkBits2Float(0xc0ab14a9), SkBits2Float(0x4258227d), SkBits2Float(0xc1d0ab83));
4914path.cubicTo(SkBits2Float(0x4230179a), SkBits2Float(0xc23b48ee), SkBits2Float(0x41b837da), SkBits2Float(0xc2700002), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
4915path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4916path.close();
4917
4918 SkPath path1(path);
4919 path.reset();
4920 path.setFillType((SkPathFillType) 0);
4921path.moveTo(SkBits2Float(0x4281fa62), SkBits2Float(0x424e82d5));
4922path.cubicTo(SkBits2Float(0x4274817d), SkBits2Float(0x4261f5b7), SkBits2Float(0x4262ebfa), SkBits2Float(0x42739d02), SkBits2Float(0x424f88b8), SkBits2Float(0x428191ef));
4923path.lineTo(SkBits2Float(0x4216064f), SkBits2Float(0x423b5489));
4924path.cubicTo(SkBits2Float(0x42240a35), SkBits2Float(0x42301b25), SkBits2Float(0x4230c051), SkBits2Float(0x4223582f), SkBits2Float(0x423beb8c), SkBits2Float(0x421548fc));
4925path.lineTo(SkBits2Float(0x4281fa62), SkBits2Float(0x424e82d5));
4926path.close();
4927
4928 SkPath path2(path);
4929 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4930}

◆ battleOp181()

static void battleOp181 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4933 of file PathOpsBattles.cpp.

4933 {
4934 SkPath path;
4935 path.setFillType((SkPathFillType) 1);
4936path.moveTo(SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
4937path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4938path.cubicTo(SkBits2Float(0x41fed5d1), SkBits2Float(0xc2a60000), SkBits2Float(0x4273981d), SkBits2Float(0xc28189e8), SkBits2Float(0x42957e40), SkBits2Float(0xc210547e));
4939path.cubicTo(SkBits2Float(0x42b13073), SkBits2Float(0xc0eca961), SkBits2Float(0x42a99b35), SkBits2Float(0x41d57c6c), SkBits2Float(0x4281fa62), SkBits2Float(0x424e82d5));
4940path.cubicTo(SkBits2Float(0x4274817d), SkBits2Float(0x4261f5b7), SkBits2Float(0x4262ebfa), SkBits2Float(0x42739d02), SkBits2Float(0x424f88b8), SkBits2Float(0x428191ef));
4941path.lineTo(SkBits2Float(0x4216064f), SkBits2Float(0x423b5489));
4942path.cubicTo(SkBits2Float(0x42240a35), SkBits2Float(0x42301b25), SkBits2Float(0x4230c051), SkBits2Float(0x4223582f), SkBits2Float(0x423beb8b), SkBits2Float(0x421548fc));
4943path.cubicTo(SkBits2Float(0x427536c2), SkBits2Float(0x419a53c7), SkBits2Float(0x428016af), SkBits2Float(0xc0ab14a9), SkBits2Float(0x4258227d), SkBits2Float(0xc1d0ab83));
4944path.cubicTo(SkBits2Float(0x4230179a), SkBits2Float(0xc23b48ee), SkBits2Float(0x41b837da), SkBits2Float(0xc2700002), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
4945path.close();
4946
4947 SkPath path1(path);
4948 path.reset();
4949 path.setFillType((SkPathFillType) 0);
4950path.moveTo(SkBits2Float(0x424f88ba), SkBits2Float(0x428191f0));
4951path.cubicTo(SkBits2Float(0x41c732b7), SkBits2Float(0x42acca52), SkBits2Float(0xc14a7268), SkBits2Float(0x42b208b4), SkBits2Float(0xc22982dc), SkBits2Float(0x428ebb75));
4952path.cubicTo(SkBits2Float(0xc2903490), SkBits2Float(0x4256dc6c), SkBits2Float(0xc2af8c6f), SkBits2Float(0x419be833), SkBits2Float(0xc2a36e37), SkBits2Float(0xc168c0a6));
4953path.cubicTo(SkBits2Float(0xc2974fff), SkBits2Float(0xc242546a), SkBits2Float(0xc2448acf), SkBits2Float(0xc29698ac), SkBits2Float(0xc17253d7), SkBits2Float(0xc2a33682));
4954path.lineTo(SkBits2Float(0xc12f2d38), SkBits2Float(0xc26bf872));
4955path.cubicTo(SkBits2Float(0xc20e1427), SkBits2Float(0xc259bacc), SkBits2Float(0xc25ac3d7), SkBits2Float(0xc20c7ab2), SkBits2Float(0xc26c48f7), SkBits2Float(0xc1284130));
4956path.cubicTo(SkBits2Float(0xc27dce17), SkBits2Float(0x41616864), SkBits2Float(0xc2507d50), SkBits2Float(0x421b5239), SkBits2Float(0xc1f51386), SkBits2Float(0x424e5c1e));
4957path.cubicTo(SkBits2Float(0xc11258cd), SkBits2Float(0x4280b301), SkBits2Float(0x418fffac), SkBits2Float(0x4279d13a), SkBits2Float(0x42160652), SkBits2Float(0x423b5488));
4958path.lineTo(SkBits2Float(0x424f88ba), SkBits2Float(0x428191f0));
4959path.close();
4960
4961 SkPath path2(path);
4962 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4963}

◆ battleOp182()

static void battleOp182 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4966 of file PathOpsBattles.cpp.

4966 {
4967 SkPath path;
4968 path.setFillType((SkPathFillType) 0);
4969path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4970path.cubicTo(SkBits2Float(0x420048ef), SkBits2Float(0xc2a60000), SkBits2Float(0x4275172d), SkBits2Float(0xc2810bd2), SkBits2Float(0x429602e3), SkBits2Float(0xc20e29dc));
4971path.cubicTo(SkBits2Float(0x42b17a30), SkBits2Float(0xc0d1e0a1), SkBits2Float(0x42a9174e), SkBits2Float(0x41ddef9e), SkBits2Float(0x4280787d), SkBits2Float(0x4252400e));
4972path.lineTo(SkBits2Float(0x4239bd9f), SkBits2Float(0x4217fcf6));
4973path.cubicTo(SkBits2Float(0x4274780f), SkBits2Float(0x41a06f8c), SkBits2Float(0x42804bfe), SkBits2Float(0xc097b7f0), SkBits2Float(0x4258e240), SkBits2Float(0xc1cd899e));
4974path.cubicTo(SkBits2Float(0x42312c84), SkBits2Float(0xc23a929f), SkBits2Float(0x41b978e3), SkBits2Float(0xc2700000), SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
4975path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
4976path.close();
4977
4978 SkPath path1(path);
4979 path.reset();
4980 path.setFillType((SkPathFillType) 0);
4981path.moveTo(SkBits2Float(0x4280787d), SkBits2Float(0x42524010));
4982path.cubicTo(SkBits2Float(0x42711c0e), SkBits2Float(0x42659909), SkBits2Float(0x425f24ad), SkBits2Float(0x42771864), SkBits2Float(0x424b624a), SkBits2Float(0x4283347a));
4983path.lineTo(SkBits2Float(0x42130648), SkBits2Float(0x423db1a5));
4984path.cubicTo(SkBits2Float(0x42214ef3), SkBits2Float(0x42329f82), SkBits2Float(0x422e4bcd), SkBits2Float(0x4225f96c), SkBits2Float(0x4239bd9f), SkBits2Float(0x4217fcf7));
4985path.lineTo(SkBits2Float(0x4280787d), SkBits2Float(0x42524010));
4986path.close();
4987
4988 SkPath path2(path);
4989 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
4990}

◆ battleOp183()

static void battleOp183 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4993 of file PathOpsBattles.cpp.

4993 {
4994 SkPath path;
4995 path.setFillType((SkPathFillType) 1);
4996path.moveTo(SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
4997path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
4998path.cubicTo(SkBits2Float(0x420048ef), SkBits2Float(0xc2a60000), SkBits2Float(0x4275172d), SkBits2Float(0xc2810bd2), SkBits2Float(0x429602e3), SkBits2Float(0xc20e29dc));
4999path.cubicTo(SkBits2Float(0x42b17a30), SkBits2Float(0xc0d1e0a1), SkBits2Float(0x42a9174e), SkBits2Float(0x41ddef9e), SkBits2Float(0x4280787d), SkBits2Float(0x42524010));
5000path.cubicTo(SkBits2Float(0x42711c0e), SkBits2Float(0x42659909), SkBits2Float(0x425f24ad), SkBits2Float(0x42771864), SkBits2Float(0x424b624a), SkBits2Float(0x4283347a));
5001path.lineTo(SkBits2Float(0x42130648), SkBits2Float(0x423db1a5));
5002path.cubicTo(SkBits2Float(0x42214ef3), SkBits2Float(0x42329f82), SkBits2Float(0x422e4bcd), SkBits2Float(0x4225f96c), SkBits2Float(0x4239bd9f), SkBits2Float(0x4217fcf6));
5003path.cubicTo(SkBits2Float(0x4274780f), SkBits2Float(0x41a06f8c), SkBits2Float(0x42804bfe), SkBits2Float(0xc097b7f0), SkBits2Float(0x4258e240), SkBits2Float(0xc1cd899e));
5004path.cubicTo(SkBits2Float(0x42312c84), SkBits2Float(0xc23a929f), SkBits2Float(0x41b978e3), SkBits2Float(0xc2700000), SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
5005path.close();
5006
5007 SkPath path1(path);
5008 path.reset();
5009 path.setFillType((SkPathFillType) 0);
5010path.moveTo(SkBits2Float(0x424b624a), SkBits2Float(0x42833479));
5011path.cubicTo(SkBits2Float(0x41baac2f), SkBits2Float(0x42adda12), SkBits2Float(0xc168f6a7), SkBits2Float(0x42b1a2b3), SkBits2Float(0xc2303c92), SkBits2Float(0x428cae5c));
5012path.cubicTo(SkBits2Float(0xc2931dbe), SkBits2Float(0x424f7409), SkBits2Float(0xc2b0c9d8), SkBits2Float(0x41878abe), SkBits2Float(0xc2a26e7f), SkBits2Float(0xc188ef9a));
5013path.cubicTo(SkBits2Float(0xc2941327), SkBits2Float(0xc24cb4f5), SkBits2Float(0xc2397a7c), SkBits2Float(0xc29a4742), SkBits2Float(0xc13ec328), SkBits2Float(0xc2a44746));
5014path.lineTo(SkBits2Float(0xc109e67a), SkBits2Float(0xc26d82d0));
5015path.cubicTo(SkBits2Float(0xc20614b0), SkBits2Float(0xc25f0d94), SkBits2Float(0xc2561585), SkBits2Float(0xc213fb18), SkBits2Float(0xc26ad744), SkBits2Float(0xc145fabb));
5016path.cubicTo(SkBits2Float(0xc27f9901), SkBits2Float(0x4143f6e8), SkBits2Float(0xc254b2af), SkBits2Float(0x4215f75b), SkBits2Float(0xc1feccbb), SkBits2Float(0x424b64f3));
5017path.cubicTo(SkBits2Float(0xc128682f), SkBits2Float(0x42806945), SkBits2Float(0x4186f1ba), SkBits2Float(0x427b5a1e), SkBits2Float(0x4213064f), SkBits2Float(0x423db1a2));
5018path.lineTo(SkBits2Float(0x424b624a), SkBits2Float(0x42833479));
5019path.close();
5020
5021 SkPath path2(path);
5022 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5023}

◆ battleOp184()

static void battleOp184 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5026 of file PathOpsBattles.cpp.

5026 {
5027 SkPath path;
5028 path.setFillType((SkPathFillType) 0);
5029path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5030path.cubicTo(SkBits2Float(0x42011b87), SkBits2Float(0xc2a5fffe), SkBits2Float(0x427681ab), SkBits2Float(0xc280937a), SkBits2Float(0x42967eb3), SkBits2Float(0xc20c1a94));
5031path.cubicTo(SkBits2Float(0x42b1bc91), SkBits2Float(0xc0b87191), SkBits2Float(0x42a89454), SkBits2Float(0x41e5ed6f), SkBits2Float(0x427e0902), SkBits2Float(0x4255c0a2));
5032path.lineTo(SkBits2Float(0x4237a3d0), SkBits2Float(0x421a8517));
5033path.cubicTo(SkBits2Float(0x4273bab4), SkBits2Float(0x41a63674), SkBits2Float(0x42807bfc), SkBits2Float(0xc0855530), SkBits2Float(0x42599545), SkBits2Float(0xc1ca8f4f));
5034path.cubicTo(SkBits2Float(0x42323293), SkBits2Float(0xc239e4a8), SkBits2Float(0x41baa959), SkBits2Float(0xc2700002), SkBits2Float(0xb5600574), SkBits2Float(0xc2700000));
5035path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5036path.close();
5037
5038 SkPath path1(path);
5039 path.reset();
5040 path.setFillType((SkPathFillType) 0);
5041path.moveTo(SkBits2Float(0x427e0901), SkBits2Float(0x4255c0a4));
5042path.cubicTo(SkBits2Float(0x426dd77c), SkBits2Float(0x4268ff65), SkBits2Float(0x425b838b), SkBits2Float(0x427a571f), SkBits2Float(0x42476779), SkBits2Float(0x4284b92f));
5043path.lineTo(SkBits2Float(0x421025c9), SkBits2Float(0x423fe3a3));
5044path.cubicTo(SkBits2Float(0x421eaf4b), SkBits2Float(0x4234f80b), SkBits2Float(0x422bef10), SkBits2Float(0x42286e9a), SkBits2Float(0x4237a3d2), SkBits2Float(0x421a8517));
5045path.lineTo(SkBits2Float(0x427e0901), SkBits2Float(0x4255c0a4));
5046path.close();
5047
5048 SkPath path2(path);
5049 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5050}

◆ battleOp185()

static void battleOp185 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5053 of file PathOpsBattles.cpp.

5053 {
5054 SkPath path;
5055 path.setFillType((SkPathFillType) 1);
5056path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
5057path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5058path.cubicTo(SkBits2Float(0x42011b87), SkBits2Float(0xc2a5fffe), SkBits2Float(0x427681ab), SkBits2Float(0xc280937a), SkBits2Float(0x42967eb3), SkBits2Float(0xc20c1a94));
5059path.cubicTo(SkBits2Float(0x42b1bc91), SkBits2Float(0xc0b87191), SkBits2Float(0x42a89454), SkBits2Float(0x41e5ed6f), SkBits2Float(0x427e0902), SkBits2Float(0x4255c0a2));
5060path.lineTo(SkBits2Float(0x427e0901), SkBits2Float(0x4255c0a4));
5061path.cubicTo(SkBits2Float(0x426dd77c), SkBits2Float(0x4268ff65), SkBits2Float(0x425b838b), SkBits2Float(0x427a571f), SkBits2Float(0x42476779), SkBits2Float(0x4284b92f));
5062path.lineTo(SkBits2Float(0x421025c9), SkBits2Float(0x423fe3a3));
5063path.cubicTo(SkBits2Float(0x421eaf4b), SkBits2Float(0x4234f80b), SkBits2Float(0x422bef10), SkBits2Float(0x42286e9a), SkBits2Float(0x4237a3d2), SkBits2Float(0x421a8517));
5064path.lineTo(SkBits2Float(0x4237a3d0), SkBits2Float(0x421a8517));
5065path.cubicTo(SkBits2Float(0x4273bab4), SkBits2Float(0x41a63674), SkBits2Float(0x42807bfc), SkBits2Float(0xc0855530), SkBits2Float(0x42599545), SkBits2Float(0xc1ca8f4f));
5066path.cubicTo(SkBits2Float(0x42323293), SkBits2Float(0xc239e4a8), SkBits2Float(0x41baa959), SkBits2Float(0xc2700002), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
5067path.close();
5068
5069 SkPath path1(path);
5070 path.reset();
5071 path.setFillType((SkPathFillType) 0);
5072path.moveTo(SkBits2Float(0x42476779), SkBits2Float(0x4284b92f));
5073path.cubicTo(SkBits2Float(0x41aeb99d), SkBits2Float(0x42aece6d), SkBits2Float(0xc182ebc7), SkBits2Float(0x42b12f04), SkBits2Float(0xc236847b), SkBits2Float(0x428aaa1d));
5074path.cubicTo(SkBits2Float(0xc295c989), SkBits2Float(0x42484a6d), SkBits2Float(0xc2b1d401), SkBits2Float(0x41683386), SkBits2Float(0xc2a15607), SkBits2Float(0xc19c4a77));
5075path.cubicTo(SkBits2Float(0xc290d80f), SkBits2Float(0xc2565754), SkBits2Float(0xc22ebdc1), SkBits2Float(0xc29d94aa), SkBits2Float(0xc10da15c), SkBits2Float(0xc2a50da2));
5076path.lineTo(SkBits2Float(0xc0ccc448), SkBits2Float(0xc26ea197));
5077path.cubicTo(SkBits2Float(0xc1fca350), SkBits2Float(0xc263d3da), SkBits2Float(0xc25169ba), SkBits2Float(0xc21af203), SkBits2Float(0xc26941c7), SkBits2Float(0xc161f664));
5078path.cubicTo(SkBits2Float(0xc2808cea), SkBits2Float(0x4127db45), SkBits2Float(0xc2588f4e), SkBits2Float(0x4210c9da), SkBits2Float(0xc203f0b6), SkBits2Float(0x42487a91));
5079path.cubicTo(SkBits2Float(0xc13d487f), SkBits2Float(0x428015a4), SkBits2Float(0x417c9d5c), SkBits2Float(0x427cbb65), SkBits2Float(0x421025ca), SkBits2Float(0x423fe3a2));
5080path.lineTo(SkBits2Float(0x42476779), SkBits2Float(0x4284b92f));
5081path.close();
5082
5083 SkPath path2(path);
5084 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5085}

◆ battleOp186()

static void battleOp186 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5088 of file PathOpsBattles.cpp.

5088 {
5089 SkPath path;
5090 path.setFillType((SkPathFillType) 0);
5091path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5092path.cubicTo(SkBits2Float(0x4201bd60), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427797bb), SkBits2Float(0xc2803682), SkBits2Float(0x4296dc8c), SkBits2Float(0xc20a848f));
5093path.cubicTo(SkBits2Float(0x42b1ed3b), SkBits2Float(0xc0a4e0c3), SkBits2Float(0x42a82bcd), SkBits2Float(0x41ec0db8), SkBits2Float(0x427bc56e), SkBits2Float(0x42586a20));
5094path.lineTo(SkBits2Float(0x423600d6), SkBits2Float(0x421c71bc));
5095path.cubicTo(SkBits2Float(0x42732394), SkBits2Float(0x41aaa425), SkBits2Float(0x42809f29), SkBits2Float(0xc06e60a8), SkBits2Float(0x425a1cf3), SkBits2Float(0xc1c84447));
5096path.cubicTo(SkBits2Float(0x4232fb94), SkBits2Float(0xc2395e3c), SkBits2Float(0x41bb9357), SkBits2Float(0xc2700002), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
5097path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5098path.close();
5099
5100 SkPath path1(path);
5101 path.reset();
5102 path.setFillType((SkPathFillType) 0);
5103path.moveTo(SkBits2Float(0x427bc56c), SkBits2Float(0x42586a22));
5104path.cubicTo(SkBits2Float(0x426b4cc6), SkBits2Float(0x426b93ad), SkBits2Float(0x4258b1e1), SkBits2Float(0x427ccbca), SkBits2Float(0x42445140), SkBits2Float(0x4285de6e));
5105path.lineTo(SkBits2Float(0x420dea8b), SkBits2Float(0x42418b9b));
5106path.cubicTo(SkBits2Float(0x421ca599), SkBits2Float(0x4236be7f), SkBits2Float(0x422a18a8), SkBits2Float(0x422a4be8), SkBits2Float(0x423600d6), SkBits2Float(0x421c71bc));
5107path.lineTo(SkBits2Float(0x427bc56c), SkBits2Float(0x42586a22));
5108path.close();
5109
5110 SkPath path2(path);
5111 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5112}

◆ battleOp187()

static void battleOp187 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5115 of file PathOpsBattles.cpp.

5115 {
5116 SkPath path;
5117 path.setFillType((SkPathFillType) 1);
5118path.moveTo(SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
5119path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5120path.cubicTo(SkBits2Float(0x4201bd60), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427797bb), SkBits2Float(0xc2803682), SkBits2Float(0x4296dc8c), SkBits2Float(0xc20a848f));
5121path.cubicTo(SkBits2Float(0x42b1ed3b), SkBits2Float(0xc0a4e0c3), SkBits2Float(0x42a82bcd), SkBits2Float(0x41ec0db8), SkBits2Float(0x427bc56e), SkBits2Float(0x42586a20));
5122path.lineTo(SkBits2Float(0x423600d6), SkBits2Float(0x421c71bc));
5123path.cubicTo(SkBits2Float(0x42732394), SkBits2Float(0x41aaa425), SkBits2Float(0x42809f29), SkBits2Float(0xc06e60a8), SkBits2Float(0x425a1cf3), SkBits2Float(0xc1c84447));
5124path.cubicTo(SkBits2Float(0x4232fb94), SkBits2Float(0xc2395e3c), SkBits2Float(0x41bb9357), SkBits2Float(0xc2700002), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
5125path.close();
5126path.moveTo(SkBits2Float(0x423600d6), SkBits2Float(0x421c71bc));
5127path.lineTo(SkBits2Float(0x427bc56c), SkBits2Float(0x42586a22));
5128path.cubicTo(SkBits2Float(0x426b4cc6), SkBits2Float(0x426b93ad), SkBits2Float(0x4258b1e1), SkBits2Float(0x427ccbca), SkBits2Float(0x42445140), SkBits2Float(0x4285de6e));
5129path.lineTo(SkBits2Float(0x420dea8b), SkBits2Float(0x42418b9b));
5130path.cubicTo(SkBits2Float(0x421ca599), SkBits2Float(0x4236be7f), SkBits2Float(0x422a18a8), SkBits2Float(0x422a4be8), SkBits2Float(0x423600d6), SkBits2Float(0x421c71bc));
5131path.close();
5132
5133 SkPath path1(path);
5134 path.reset();
5135 path.setFillType((SkPathFillType) 0);
5136path.moveTo(SkBits2Float(0x42445140), SkBits2Float(0x4285de6e));
5137path.cubicTo(SkBits2Float(0x41a5801a), SkBits2Float(0x42af8153), SkBits2Float(0xc18dfe3b), SkBits2Float(0x42b0c99d), SkBits2Float(0xc23b472e), SkBits2Float(0x42891183));
5138path.cubicTo(SkBits2Float(0xc297c79f), SkBits2Float(0x4242b2d1), SkBits2Float(0xc2b28961), SkBits2Float(0x414a2ba6), SkBits2Float(0xc2a0659f), SkBits2Float(0xc1ab0f22));
5139path.cubicTo(SkBits2Float(0xc28e41db), SkBits2Float(0xc25d9a0f), SkBits2Float(0xc2265613), SkBits2Float(0xc29ffd9f), SkBits2Float(0xc0cf8787), SkBits2Float(0xc2a57e12));
5140path.lineTo(SkBits2Float(0xc09605ca), SkBits2Float(0xc26f4428));
5141path.cubicTo(SkBits2Float(0xc1f07c7d), SkBits2Float(0xc2674fd1), SkBits2Float(0xc24dac50), SkBits2Float(0xc22031a9), SkBits2Float(0xc267e62b), SkBits2Float(0xc1775074));
5142path.cubicTo(SkBits2Float(0xc2811003), SkBits2Float(0x411225be), SkBits2Float(0xc25b70c1), SkBits2Float(0x420cbef2), SkBits2Float(0xc20761ad), SkBits2Float(0x42462bd0));
5143path.cubicTo(SkBits2Float(0xc14d4a68), SkBits2Float(0x427f98ac), SkBits2Float(0x416f472e), SkBits2Float(0x427dbe0b), SkBits2Float(0x420dea8f), SkBits2Float(0x42418b9b));
5144path.lineTo(SkBits2Float(0x42445140), SkBits2Float(0x4285de6e));
5145path.close();
5146
5147 SkPath path2(path);
5148 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5149}

◆ battleOp188()

static void battleOp188 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5152 of file PathOpsBattles.cpp.

5152 {
5153 SkPath path;
5154 path.setFillType((SkPathFillType) 0);
5155path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5156path.cubicTo(SkBits2Float(0x42025498), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42789b1b), SkBits2Float(0xc27fbe84), SkBits2Float(0x42973334), SkBits2Float(0xc2090897));
5157path.cubicTo(SkBits2Float(0x42b218da), SkBits2Float(0xc092954a), SkBits2Float(0x42a7c71a), SkBits2Float(0x41f1c3b5), SkBits2Float(0x4279a1de), SkBits2Float(0x425ae0d9));
5158path.lineTo(SkBits2Float(0x42347503), SkBits2Float(0x421e39ac));
5159path.cubicTo(SkBits2Float(0x427291fe), SkBits2Float(0x41aec4fe), SkBits2Float(0x4280beb1), SkBits2Float(0xc053ed89), SkBits2Float(0x425a9a3a), SkBits2Float(0xc1c61ef1));
5160path.cubicTo(SkBits2Float(0x4233b713), SkBits2Float(0xc238e018), SkBits2Float(0x41bc6df5), SkBits2Float(0xc2700002), SkBits2Float(0xb7240057), SkBits2Float(0xc2700000));
5161path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5162path.close();
5163
5164 SkPath path1(path);
5165 path.reset();
5166 path.setFillType((SkPathFillType) 0);
5167path.moveTo(SkBits2Float(0x4279a1de), SkBits2Float(0x425ae0d9));
5168path.cubicTo(SkBits2Float(0x4268e6ce), SkBits2Float(0x426df5b7), SkBits2Float(0x425609c8), SkBits2Float(0x427f0f64), SkBits2Float(0x42416967), SkBits2Float(0x4286ec0f));
5169path.lineTo(SkBits2Float(0x420bd0d2), SkBits2Float(0x42431170));
5170path.cubicTo(SkBits2Float(0x421ab9f8), SkBits2Float(0x4238617e), SkBits2Float(0x42285cd4), SkBits2Float(0x422c04e7), SkBits2Float(0x42347505), SkBits2Float(0x421e39ac));
5171path.lineTo(SkBits2Float(0x4279a1de), SkBits2Float(0x425ae0d9));
5172path.close();
5173
5174 SkPath path2(path);
5175 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5176}

◆ battleOp189()

static void battleOp189 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5179 of file PathOpsBattles.cpp.

5179 {
5180 SkPath path;
5181 path.setFillType((SkPathFillType) 1);
5182path.moveTo(SkBits2Float(0xb7240057), SkBits2Float(0xc2700000));
5183path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5184path.cubicTo(SkBits2Float(0x42025498), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42789b1b), SkBits2Float(0xc27fbe84), SkBits2Float(0x42973334), SkBits2Float(0xc2090897));
5185path.cubicTo(SkBits2Float(0x42b218da), SkBits2Float(0xc092954a), SkBits2Float(0x42a7c71a), SkBits2Float(0x41f1c3b5), SkBits2Float(0x4279a1de), SkBits2Float(0x425ae0d9));
5186path.cubicTo(SkBits2Float(0x4268e6ce), SkBits2Float(0x426df5b7), SkBits2Float(0x425609c8), SkBits2Float(0x427f0f64), SkBits2Float(0x42416967), SkBits2Float(0x4286ec0f));
5187path.lineTo(SkBits2Float(0x420bd0d2), SkBits2Float(0x42431170));
5188path.cubicTo(SkBits2Float(0x421ab9f8), SkBits2Float(0x4238617e), SkBits2Float(0x42285cd4), SkBits2Float(0x422c04e7), SkBits2Float(0x42347505), SkBits2Float(0x421e39ac));
5189path.lineTo(SkBits2Float(0x42347503), SkBits2Float(0x421e39ac));
5190path.cubicTo(SkBits2Float(0x427291fe), SkBits2Float(0x41aec4fe), SkBits2Float(0x4280beb1), SkBits2Float(0xc053ed89), SkBits2Float(0x425a9a3a), SkBits2Float(0xc1c61ef1));
5191path.cubicTo(SkBits2Float(0x4233b713), SkBits2Float(0xc238e018), SkBits2Float(0x41bc6df5), SkBits2Float(0xc2700002), SkBits2Float(0xb7240057), SkBits2Float(0xc2700000));
5192path.close();
5193
5194 SkPath path1(path);
5195 path.reset();
5196 path.setFillType((SkPathFillType) 0);
5197path.moveTo(SkBits2Float(0x42416967), SkBits2Float(0x4286ec0f));
5198path.cubicTo(SkBits2Float(0x419cd99a), SkBits2Float(0x42b02173), SkBits2Float(0xc19850b8), SkBits2Float(0x42b06117), SkBits2Float(0xc23fac11), SkBits2Float(0x42878a96));
5199path.cubicTo(SkBits2Float(0xc29997e3), SkBits2Float(0x423d682a), SkBits2Float(0xc2b3208c), SkBits2Float(0x412e025f), SkBits2Float(0xc29f71a3), SkBits2Float(0xc1b8c415));
5200path.cubicTo(SkBits2Float(0xc28bc2ba), SkBits2Float(0xc26444ae), SkBits2Float(0xc21e5e96), SkBits2Float(0xc2a223df), SkBits2Float(0xc088ac52), SkBits2Float(0xc2a5c7b3));
5201path.lineTo(SkBits2Float(0xc0459a01), SkBits2Float(0xc26fae99));
5202path.cubicTo(SkBits2Float(0xc1e4f7d0), SkBits2Float(0xc26a6b5c), SkBits2Float(0xc24a1045), SkBits2Float(0xc225035c), SkBits2Float(0xc266856e), SkBits2Float(0xc18590cd));
5203path.cubicTo(SkBits2Float(0xc2817d4a), SkBits2Float(0x40fb9475), SkBits2Float(0xc25e0ffd), SkBits2Float(0x4208ebae), SkBits2Float(0xc20a8edd), SkBits2Float(0x4243f69e));
5204path.cubicTo(SkBits2Float(0xc15c36ee), SkBits2Float(0x427f018f), SkBits2Float(0x4162c57c), SkBits2Float(0x427ea58e), SkBits2Float(0x420bd0d7), SkBits2Float(0x4243116e));
5205path.lineTo(SkBits2Float(0x42416967), SkBits2Float(0x4286ec0f));
5206path.close();
5207
5208 SkPath path2(path);
5209 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5210}

◆ battleOp19()

static void battleOp19 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 575 of file PathOpsBattles.cpp.

575 {
576 SkPath path;
577 path.setFillType((SkPathFillType) 0);
578path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
579path.cubicTo(SkBits2Float(0x40272e66), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40a7227d), SkBits2Float(0xc2a5c0db), SkBits2Float(0x40fa5a70), SkBits2Float(0xc2a542ca));
580path.lineTo(SkBits2Float(0x40b4fa6e), SkBits2Float(0xc26eee73));
581path.cubicTo(SkBits2Float(0x4071a3f5), SkBits2Float(0xc26fa4b8), SkBits2Float(0x3ff1b53c), SkBits2Float(0xc2700000), SkBits2Float(0x359dfd46), SkBits2Float(0xc2700000));
582path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
583path.close();
584
585 SkPath path1(path);
586 path.reset();
587 path.setFillType((SkPathFillType) 0);
588path.moveTo(SkBits2Float(0x40fa5a6d), SkBits2Float(0xc2a542cb));
589path.cubicTo(SkBits2Float(0x4101563b), SkBits2Float(0xc2a5362f), SkBits2Float(0x41057ec0), SkBits2Float(0xc2a528f4), SkBits2Float(0x4109a6c0), SkBits2Float(0xc2a51b18));
590path.lineTo(SkBits2Float(0x40c70391), SkBits2Float(0xc26eb50e));
591path.cubicTo(SkBits2Float(0x40c10142), SkBits2Float(0xc26ec918), SkBits2Float(0x40bafe32), SkBits2Float(0xc26edc3a), SkBits2Float(0x40b4fa70), SkBits2Float(0xc26eee73));
592path.lineTo(SkBits2Float(0x40fa5a6d), SkBits2Float(0xc2a542cb));
593path.close();
594
595 SkPath path2(path);
596 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
597}

◆ battleOp190()

static void battleOp190 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5213 of file PathOpsBattles.cpp.

5213 {
5214 SkPath path;
5215 path.setFillType((SkPathFillType) 0);
5216path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5217path.cubicTo(SkBits2Float(0x4202b56e), SkBits2Float(0xc2a60000), SkBits2Float(0x427940ff), SkBits2Float(0xc27f4e67), SkBits2Float(0x42976a2d), SkBits2Float(0xc20814ff));
5218path.cubicTo(SkBits2Float(0x42b233da), SkBits2Float(0xc086dcb5), SkBits2Float(0x42a78518), SkBits2Float(0x41f56a27), SkBits2Float(0x42784037), SkBits2Float(0x425c71a4));
5219path.lineTo(SkBits2Float(0x4233755d), SkBits2Float(0x421f5b67));
5220path.cubicTo(SkBits2Float(0x4272328d), SkBits2Float(0x41b16880), SkBits2Float(0x4280d235), SkBits2Float(0xc042fb32), SkBits2Float(0x425ae9b3), SkBits2Float(0xc1c4bebc));
5221path.cubicTo(SkBits2Float(0x42342efc), SkBits2Float(0xc2388f09), SkBits2Float(0x41bcf9fa), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5222path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5223path.close();
5224
5225 SkPath path1(path);
5226 path.reset();
5227 path.setFillType((SkPathFillType) 0);
5228path.moveTo(SkBits2Float(0x42784038), SkBits2Float(0x425c71a4));
5229path.cubicTo(SkBits2Float(0x42675aa4), SkBits2Float(0x426f78d5), SkBits2Float(0x4254535c), SkBits2Float(0x42803f48), SkBits2Float(0x423f8a54), SkBits2Float(0x4287967e));
5230path.lineTo(SkBits2Float(0x420a7682), SkBits2Float(0x424407da));
5231path.cubicTo(SkBits2Float(0x42197d0c), SkBits2Float(0x42396aed), SkBits2Float(0x42273e74), SkBits2Float(0x422d1cc3), SkBits2Float(0x4233755f), SkBits2Float(0x421f5b68));
5232path.lineTo(SkBits2Float(0x42784038), SkBits2Float(0x425c71a4));
5233path.close();
5234
5235 SkPath path2(path);
5236 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5237}

◆ battleOp191()

static void battleOp191 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5240 of file PathOpsBattles.cpp.

5240 {
5241 SkPath path;
5242 path.setFillType((SkPathFillType) 1);
5243path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5244path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5245path.cubicTo(SkBits2Float(0x4202b56e), SkBits2Float(0xc2a60000), SkBits2Float(0x427940ff), SkBits2Float(0xc27f4e67), SkBits2Float(0x42976a2d), SkBits2Float(0xc20814ff));
5246path.cubicTo(SkBits2Float(0x42b233da), SkBits2Float(0xc086dcb5), SkBits2Float(0x42a78518), SkBits2Float(0x41f56a27), SkBits2Float(0x42784038), SkBits2Float(0x425c71a4));
5247path.cubicTo(SkBits2Float(0x42675aa4), SkBits2Float(0x426f78d5), SkBits2Float(0x4254535c), SkBits2Float(0x42803f48), SkBits2Float(0x423f8a54), SkBits2Float(0x4287967e));
5248path.lineTo(SkBits2Float(0x420a7682), SkBits2Float(0x424407da));
5249path.cubicTo(SkBits2Float(0x42197d0c), SkBits2Float(0x42396aed), SkBits2Float(0x42273e74), SkBits2Float(0x422d1cc3), SkBits2Float(0x4233755f), SkBits2Float(0x421f5b68));
5250path.lineTo(SkBits2Float(0x4233755d), SkBits2Float(0x421f5b67));
5251path.cubicTo(SkBits2Float(0x4272328d), SkBits2Float(0x41b16880), SkBits2Float(0x4280d235), SkBits2Float(0xc042fb32), SkBits2Float(0x425ae9b3), SkBits2Float(0xc1c4bebc));
5252path.cubicTo(SkBits2Float(0x42342efc), SkBits2Float(0xc2388f09), SkBits2Float(0x41bcf9fa), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5253path.close();
5254
5255 SkPath path1(path);
5256 path.reset();
5257 path.setFillType((SkPathFillType) 0);
5258path.moveTo(SkBits2Float(0x423f8a55), SkBits2Float(0x4287967f));
5259path.cubicTo(SkBits2Float(0x41974ba2), SkBits2Float(0x42b0846d), SkBits2Float(0xc19ee9a3), SkBits2Float(0x42b01937), SkBits2Float(0xc2427547), SkBits2Float(0x42868bae));
5260path.cubicTo(SkBits2Float(0xc29abade), SkBits2Float(0x4239fc4c), SkBits2Float(0xc2b3780d), SkBits2Float(0x411bee16), SkBits2Float(0xc29ecbab), SkBits2Float(0xc1c17e4f));
5261path.cubicTo(SkBits2Float(0xc28a1f48), SkBits2Float(0xc26879d6), SkBits2Float(0xc2193674), SkBits2Float(0xc2a376c5), SkBits2Float(0xc0368c8c), SkBits2Float(0xc2a5e6e5));
5262path.lineTo(SkBits2Float(0xc003f6b5), SkBits2Float(0xc26fdbb6));
5263path.cubicTo(SkBits2Float(0xc1dd8323), SkBits2Float(0xc26c555a), SkBits2Float(0xc247b1d3), SkBits2Float(0xc2280e0b), SkBits2Float(0xc2659575), SkBits2Float(0xc18bdff2));
5264path.cubicTo(SkBits2Float(0xc281bc8c), SkBits2Float(0x40e170d0), SkBits2Float(0xc25fb4ae), SkBits2Float(0x42067283), SkBits2Float(0xc20c926e), SkBits2Float(0x42428613));
5265path.cubicTo(SkBits2Float(0xc165c0b5), SkBits2Float(0x427e99a3), SkBits2Float(0x415abda1), SkBits2Float(0x427f34a6), SkBits2Float(0x420a7686), SkBits2Float(0x424407d8));
5266path.lineTo(SkBits2Float(0x423f8a55), SkBits2Float(0x4287967f));
5267path.close();
5268
5269 SkPath path2(path);
5270 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5271}

◆ battleOp192()

static void battleOp192 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5274 of file PathOpsBattles.cpp.

5274 {
5275 SkPath path;
5276 path.setFillType((SkPathFillType) 0);
5277path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5278path.cubicTo(SkBits2Float(0x4202fa25), SkBits2Float(0xc2a60000), SkBits2Float(0x4279b699), SkBits2Float(0xc27efea4), SkBits2Float(0x429790ee), SkBits2Float(0xc20767f9));
5279path.cubicTo(SkBits2Float(0x42b24690), SkBits2Float(0xc07d14fa), SkBits2Float(0x42a75587), SkBits2Float(0x41f80076), SkBits2Float(0x427743d2), SkBits2Float(0x425d8c9b));
5280path.lineTo(SkBits2Float(0x4232bee9), SkBits2Float(0x422027f2));
5281path.cubicTo(SkBits2Float(0x4271edc7), SkBits2Float(0x41b34741), SkBits2Float(0x4280dfbb), SkBits2Float(0xc036f37a), SkBits2Float(0x425b21bb), SkBits2Float(0xc1c3c49a));
5282path.cubicTo(SkBits2Float(0x423483ff), SkBits2Float(0xc2385562), SkBits2Float(0x41bd5d54), SkBits2Float(0xc2700000), SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
5283path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5284path.close();
5285
5286 SkPath path1(path);
5287 path.reset();
5288 path.setFillType((SkPathFillType) 0);
5289path.moveTo(SkBits2Float(0x427743d4), SkBits2Float(0x425d8c98));
5290path.cubicTo(SkBits2Float(0x4266401a), SkBits2Float(0x427089e5), SkBits2Float(0x42531ae2), SkBits2Float(0x4280c0a0), SkBits2Float(0x423e3514), SkBits2Float(0x42880e64));
5291path.lineTo(SkBits2Float(0x42097fd1), SkBits2Float(0x4244b531));
5292path.cubicTo(SkBits2Float(0x42189b26), SkBits2Float(0x423a25ea), SkBits2Float(0x42267233), SkBits2Float(0x422de224), SkBits2Float(0x4232beea), SkBits2Float(0x422027f3));
5293path.lineTo(SkBits2Float(0x427743d4), SkBits2Float(0x425d8c98));
5294path.close();
5295
5296 SkPath path2(path);
5297 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5298}

◆ battleOp193()

static void battleOp193 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5300 of file PathOpsBattles.cpp.

5300 {
5301 SkPath path;
5302 path.setFillType((SkPathFillType) 0);
5303path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5304path.cubicTo(SkBits2Float(0x3e15a675), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e95a67a), SkBits2Float(0xc2a5ffcd), SkBits2Float(0x3ee07980), SkBits2Float(0xc2a5ff68));
5305path.lineTo(SkBits2Float(0x3ea245bb), SkBits2Float(0xc26fff25));
5306path.cubicTo(SkBits2Float(0x3e585de0), SkBits2Float(0xc26fffb9), SkBits2Float(0x3dd85f11), SkBits2Float(0xc2700000), SkBits2Float(0x3691e768), SkBits2Float(0xc2700000));
5307path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5308path.close();
5309
5310 SkPath path1(path);
5311 path.reset();
5312 path.setFillType((SkPathFillType) 0);
5313path.moveTo(SkBits2Float(0x3ee07a10), SkBits2Float(0xc2a5ff68));
5314path.cubicTo(SkBits2Float(0x3ee7f565), SkBits2Float(0xc2a5ff5d), SkBits2Float(0x3eef70d9), SkBits2Float(0xc2a5ff52), SkBits2Float(0x3ef6ec4d), SkBits2Float(0xc2a5ff47));
5315path.lineTo(SkBits2Float(0x3eb27fdb), SkBits2Float(0xc26ffef6));
5316path.cubicTo(SkBits2Float(0x3ead1768), SkBits2Float(0xc26fff07), SkBits2Float(0x3ea7aebe), SkBits2Float(0xc26fff17), SkBits2Float(0x3ea24612), SkBits2Float(0xc26fff26));
5317path.lineTo(SkBits2Float(0x3ee07a10), SkBits2Float(0xc2a5ff68));
5318path.close();
5319
5320 SkPath path2(path);
5321 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5322}

◆ battleOp194()

static void battleOp194 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5325 of file PathOpsBattles.cpp.

5325 {
5326 SkPath path;
5327 path.setFillType((SkPathFillType) 1);
5328path.moveTo(SkBits2Float(0x3691e768), SkBits2Float(0xc2700000));
5329path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5330path.cubicTo(SkBits2Float(0x3e15a675), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e95a67a), SkBits2Float(0xc2a5ffcd), SkBits2Float(0x3ee07a10), SkBits2Float(0xc2a5ff68));
5331path.lineTo(SkBits2Float(0x3ef6ec4d), SkBits2Float(0xc2a5ff47));
5332path.lineTo(SkBits2Float(0x3eb27fdb), SkBits2Float(0xc26ffef6));
5333path.cubicTo(SkBits2Float(0x3ead1768), SkBits2Float(0xc26fff07), SkBits2Float(0x3ea7aebe), SkBits2Float(0xc26fff17), SkBits2Float(0x3ea245bb), SkBits2Float(0xc26fff25));
5334path.cubicTo(SkBits2Float(0x3e585de0), SkBits2Float(0xc26fffb9), SkBits2Float(0x3dd85f11), SkBits2Float(0xc2700000), SkBits2Float(0x3691e768), SkBits2Float(0xc2700000));
5335path.close();
5336
5337 SkPath path1(path);
5338 path.reset();
5339 path.setFillType((SkPathFillType) 0);
5340path.moveTo(SkBits2Float(0x3ef6ec9b), SkBits2Float(0xc2a5ff48));
5341path.cubicTo(SkBits2Float(0x3f3816c9), SkBits2Float(0xc2a5fe94), SkBits2Float(0x3f74b6e1), SkBits2Float(0xc2a5fd5b), SkBits2Float(0x3f98ab0b), SkBits2Float(0xc2a5fb9d));
5342path.lineTo(SkBits2Float(0x3f5cb973), SkBits2Float(0xc26ff9a8));
5343path.cubicTo(SkBits2Float(0x3f30e6e7), SkBits2Float(0xc26ffc2e), SkBits2Float(0x3f05138e), SkBits2Float(0xc26ffdf2), SkBits2Float(0x3eb27fc6), SkBits2Float(0xc26ffef7));
5344path.lineTo(SkBits2Float(0x3ef6ec9b), SkBits2Float(0xc2a5ff48));
5345path.close();
5346
5347 SkPath path2(path);
5348 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5349}

◆ battleOp195()

static void battleOp195 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5352 of file PathOpsBattles.cpp.

5352 {
5353 SkPath path;
5354 path.setFillType((SkPathFillType) 0);
5355path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5356path.cubicTo(SkBits2Float(0x3f0607d9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f860760), SkBits2Float(0xc2a5fd76), SkBits2Float(0x3fc90825), SkBits2Float(0xc2a5f863));
5357path.lineTo(SkBits2Float(0x3f9152f7), SkBits2Float(0xc26ff500));
5358path.cubicTo(SkBits2Float(0x3f41c6b2), SkBits2Float(0xc26ffc55), SkBits2Float(0x3ec1c794), SkBits2Float(0xc26fffff), SkBits2Float(0x36a51f4a), SkBits2Float(0xc26fffff));
5359path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5360path.close();
5361
5362 SkPath path1(path);
5363 path.reset();
5364 path.setFillType((SkPathFillType) 0);
5365path.moveTo(SkBits2Float(0x3fc9081a), SkBits2Float(0xc2a5f864));
5366path.cubicTo(SkBits2Float(0x3fcfbb75), SkBits2Float(0xc2a5f7e2), SkBits2Float(0x3fd66eab), SkBits2Float(0xc2a5f75a), SkBits2Float(0x3fdd21d8), SkBits2Float(0xc2a5f6cb));
5367path.lineTo(SkBits2Float(0x3f9fdac0), SkBits2Float(0xc26ff2b1));
5368path.cubicTo(SkBits2Float(0x3f9b02da), SkBits2Float(0xc26ff37f), SkBits2Float(0x3f962add), SkBits2Float(0xc26ff444), SkBits2Float(0x3f9152da), SkBits2Float(0xc26ff500));
5369path.lineTo(SkBits2Float(0x3fc9081a), SkBits2Float(0xc2a5f864));
5370path.close();
5371
5372 SkPath path2(path);
5373 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5374}

◆ battleOp196()

static void battleOp196 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5377 of file PathOpsBattles.cpp.

5377 {
5378 SkPath path;
5379 path.setFillType((SkPathFillType) 1);
5380path.moveTo(SkBits2Float(0x36a51f4a), SkBits2Float(0xc26fffff));
5381path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5382path.cubicTo(SkBits2Float(0x3f0607d1), SkBits2Float(0xc2a60000), SkBits2Float(0x3f860758), SkBits2Float(0xc2a5fd76), SkBits2Float(0x3fc9081a), SkBits2Float(0xc2a5f864));
5383
5384 SkPath path1(path);
5385 path.reset();
5386 path.setFillType((SkPathFillType) 0);
5387path.moveTo(SkBits2Float(0x3fdd21ce), SkBits2Float(0xc2a5f6cb));
5388path.cubicTo(SkBits2Float(0x4024daa1), SkBits2Float(0xc2a5edc0), SkBits2Float(0x405b1f05), SkBits2Float(0xc2a5de0d), SkBits2Float(0x4088aca3), SkBits2Float(0xc2a5c7b3));
5389path.lineTo(SkBits2Float(0x40459a01), SkBits2Float(0xc26fae99));
5390path.cubicTo(SkBits2Float(0x401e66a3), SkBits2Float(0xc26fceed), SkBits2Float(0x3fee57cd), SkBits2Float(0xc26fe5a0), SkBits2Float(0x3f9fdaba), SkBits2Float(0xc26ff2b3));
5391path.lineTo(SkBits2Float(0x3fdd21ce), SkBits2Float(0xc2a5f6cb));
5392path.close();
5393
5394 SkPath path2(path);
5395 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5396}

◆ battleOp197()

static void battleOp197 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5399 of file PathOpsBattles.cpp.

5399 {
5400 SkPath path;
5401 path.setFillType((SkPathFillType) 0);
5402path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5403path.cubicTo(SkBits2Float(0x3fa0bd52), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4020babd), SkBits2Float(0xc2a5f168), SkBits2Float(0x40710446), SkBits2Float(0xc2a5d43c));
5404path.lineTo(SkBits2Float(0x402e3a94), SkBits2Float(0xc26fc0ba));
5405path.cubicTo(SkBits2Float(0x3fe86158), SkBits2Float(0xc26feae9), SkBits2Float(0x3f686554), SkBits2Float(0xc2700000), SkBits2Float(0x369bbf59), SkBits2Float(0xc2700000));
5406path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5407path.close();
5408
5409 SkPath path1(path);
5410 path.reset();
5411 path.setFillType((SkPathFillType) 0);
5412path.moveTo(SkBits2Float(0x4071043c), SkBits2Float(0xc2a5d43c));
5413path.cubicTo(SkBits2Float(0x40790b78), SkBits2Float(0xc2a5d151), SkBits2Float(0x40808943), SkBits2Float(0xc2a5ce41), SkBits2Float(0x40848cac), SkBits2Float(0xc2a5cb0c));
5414path.lineTo(SkBits2Float(0x403fa34c), SkBits2Float(0xc26fb371));
5415path.cubicTo(SkBits2Float(0x4039d5dd), SkBits2Float(0xc26fb815), SkBits2Float(0x40340849), SkBits2Float(0xc26fbc83), SkBits2Float(0x402e3a8d), SkBits2Float(0xc26fc0bb));
5416path.lineTo(SkBits2Float(0x4071043c), SkBits2Float(0xc2a5d43c));
5417path.close();
5418
5419 SkPath path2(path);
5420 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5421}

◆ battleOp198()

static void battleOp198 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5424 of file PathOpsBattles.cpp.

5424 {
5425 SkPath path;
5426 path.setFillType((SkPathFillType) 1);
5427path.moveTo(SkBits2Float(0x369bbf59), SkBits2Float(0xc2700000));
5428path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5429path.cubicTo(SkBits2Float(0x3fa0bd4b), SkBits2Float(0xc2a60000), SkBits2Float(0x4020bab6), SkBits2Float(0xc2a5f168), SkBits2Float(0x4071043c), SkBits2Float(0xc2a5d43c));
5430path.lineTo(SkBits2Float(0x40710446), SkBits2Float(0xc2a5d43c));
5431path.cubicTo(SkBits2Float(0x40790b7f), SkBits2Float(0xc2a5d151), SkBits2Float(0x40808945), SkBits2Float(0xc2a5ce41), SkBits2Float(0x40848cac), SkBits2Float(0xc2a5cb0c));
5432path.lineTo(SkBits2Float(0x403fa34c), SkBits2Float(0xc26fb371));
5433path.quadTo(SkBits2Float(0x4036ef2a), SkBits2Float(0xc26fba67), SkBits2Float(0x402e3a95), SkBits2Float(0xc26fc0bb));
5434path.lineTo(SkBits2Float(0x402e3a94), SkBits2Float(0xc26fc0ba));
5435path.cubicTo(SkBits2Float(0x3fe86158), SkBits2Float(0xc26feae9), SkBits2Float(0x3f686554), SkBits2Float(0xc2700000), SkBits2Float(0x369bbf59), SkBits2Float(0xc2700000));
5436path.close();
5437
5438 SkPath path1(path);
5439 path.reset();
5440 path.setFillType((SkPathFillType) 0);
5441path.moveTo(SkBits2Float(0x40848cae), SkBits2Float(0xc2a5cb0c));
5442path.cubicTo(SkBits2Float(0x40c597bc), SkBits2Float(0xc2a5970c), SkBits2Float(0x41033f43), SkBits2Float(0xc2a53cca), SkBits2Float(0x41238fb3), SkBits2Float(0xc2a4bc74));
5443path.lineTo(SkBits2Float(0x40ec7963), SkBits2Float(0xc26e2c38));
5444path.cubicTo(SkBits2Float(0x40bdc13f), SkBits2Float(0xc26ee5c4), SkBits2Float(0x408ed689), SkBits2Float(0xc26f6843), SkBits2Float(0x403fa341), SkBits2Float(0xc26fb372));
5445path.lineTo(SkBits2Float(0x40848cae), SkBits2Float(0xc2a5cb0c));
5446path.close();
5447
5448 SkPath path2(path);
5449 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5450}

◆ battleOp199()

static void battleOp199 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5453 of file PathOpsBattles.cpp.

5453 {
5454 SkPath path;
5455 path.setFillType((SkPathFillType) 0);
5456path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5457path.cubicTo(SkBits2Float(0x3ffdfad4), SkBits2Float(0xc2a60000), SkBits2Float(0x407df074), SkBits2Float(0xc2a5db92), SkBits2Float(0x40be4d32), SkBits2Float(0xc2a592c7));
5458path.lineTo(SkBits2Float(0x40899143), SkBits2Float(0xc26f6217));
5459path.cubicTo(SkBits2Float(0x40379219), SkBits2Float(0xc26fcb54), SkBits2Float(0x3fb799b8), SkBits2Float(0xc26fffff), SkBits2Float(0x3673fea3), SkBits2Float(0xc26fffff));
5460path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5461path.close();
5462
5463 SkPath path1(path);
5464 path.reset();
5465 path.setFillType((SkPathFillType) 0);
5466path.moveTo(SkBits2Float(0x40be4d37), SkBits2Float(0xc2a592c7));
5467path.cubicTo(SkBits2Float(0x40c4a257), SkBits2Float(0xc2a58b80), SkBits2Float(0x40caf70c), SkBits2Float(0xc2a583db), SkBits2Float(0x40d14b4e), SkBits2Float(0xc2a57bda));
5468path.lineTo(SkBits2Float(0x40974c04), SkBits2Float(0xc26f40f2));
5469path.cubicTo(SkBits2Float(0x4092b8c1), SkBits2Float(0xc26f4c86), SkBits2Float(0x408e252c), SkBits2Float(0xc26f5792), SkBits2Float(0x4089914a), SkBits2Float(0xc26f6219));
5470path.lineTo(SkBits2Float(0x40be4d37), SkBits2Float(0xc2a592c7));
5471path.close();
5472
5473 SkPath path2(path);
5474 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5475}

◆ battleOp2()

static void battleOp2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 124 of file PathOpsBattles.cpp.

124 {
125 SkPath path;
126 path.setFillType((SkPathFillType) 1);
127path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
128path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
129path.cubicTo(SkBits2Float(0x3ea4d9e6), SkBits2Float(0xc2a60000), SkBits2Float(0x3f24d99a), SkBits2Float(0xc2a5ff0a), SkBits2Float(0x3f774503), SkBits2Float(0xc2a5fd1f));
130
131 SkPath path1(path);
132 path.reset();
133 path.setFillType((SkPathFillType) 0);
134path.moveTo(SkBits2Float(0x3f87ff64), SkBits2Float(0xc2a5fc85));
135path.cubicTo(SkBits2Float(0x3fcac720), SkBits2Float(0xc2a5f91a), SkBits2Float(0x4006c62a), SkBits2Float(0xc2a5f329), SkBits2Float(0x40282667), SkBits2Float(0xc2a5eab4));
136path.lineTo(SkBits2Float(0x3ff31bb9), SkBits2Float(0xc26fe136));
137path.cubicTo(SkBits2Float(0x3fc2da88), SkBits2Float(0xc26fed71), SkBits2Float(0x3f9295ff), SkBits2Float(0xc26ff607), SkBits2Float(0x3f449f66), SkBits2Float(0xc26ffaf9));
138path.lineTo(SkBits2Float(0x3f87ff64), SkBits2Float(0xc2a5fc85));
139path.close();
140
141 SkPath path2(path);
142 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
143}

◆ battleOp20()

static void battleOp20 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 600 of file PathOpsBattles.cpp.

600 {
601 SkPath path;
602 path.setFillType((SkPathFillType) 1);
603path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
604path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
605path.cubicTo(SkBits2Float(0x40272e63), SkBits2Float(0xc2a60000), SkBits2Float(0x40a7227a), SkBits2Float(0xc2a5c0db), SkBits2Float(0x40fa5a6c), SkBits2Float(0xc2a542ca));
606path.lineTo(SkBits2Float(0x40fa5a6d), SkBits2Float(0xc2a542cb));
607path.cubicTo(SkBits2Float(0x4101563b), SkBits2Float(0xc2a5362f), SkBits2Float(0x41057ec0), SkBits2Float(0xc2a528f4), SkBits2Float(0x4109a6c0), SkBits2Float(0xc2a51b18));
608path.lineTo(SkBits2Float(0x40c70391), SkBits2Float(0xc26eb50e));
609path.cubicTo(SkBits2Float(0x40c10142), SkBits2Float(0xc26ec918), SkBits2Float(0x40bafe32), SkBits2Float(0xc26edc3a), SkBits2Float(0x40b4fa6e), SkBits2Float(0xc26eee73));
610path.cubicTo(SkBits2Float(0x4071a3f5), SkBits2Float(0xc26fa4b8), SkBits2Float(0x3ff1b53c), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
611path.close();
612
613 SkPath path1(path);
614 path.reset();
615 path.setFillType((SkPathFillType) 0);
616path.moveTo(SkBits2Float(0x4109a6bc), SkBits2Float(0xc2a51b19));
617path.cubicTo(SkBits2Float(0x414d093d), SkBits2Float(0xc2a43a61), SkBits2Float(0x4187e474), SkBits2Float(0xc2a2b4fa), SkBits2Float(0x41a8a805), SkBits2Float(0xc2a08e4d));
618path.lineTo(SkBits2Float(0x4173d72c), SkBits2Float(0xc2682105));
619path.cubicTo(SkBits2Float(0x41447890), SkBits2Float(0xc26b3d2d), SkBits2Float(0x4114380c), SkBits2Float(0xc26d702b), SkBits2Float(0x40c70392), SkBits2Float(0xc26eb510));
620path.lineTo(SkBits2Float(0x4109a6bc), SkBits2Float(0xc2a51b19));
621path.close();
622
623 SkPath path2(path);
624 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
625}

◆ battleOp200()

static void battleOp200 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5478 of file PathOpsBattles.cpp.

5478 {
5479 SkPath path;
5480 path.setFillType((SkPathFillType) 1);
5481path.moveTo(SkBits2Float(0x3673fea3), SkBits2Float(0xc26fffff));
5482path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5483path.cubicTo(SkBits2Float(0x3ffdfad4), SkBits2Float(0xc2a60000), SkBits2Float(0x407df074), SkBits2Float(0xc2a5db92), SkBits2Float(0x40be4d37), SkBits2Float(0xc2a592c7));
5484path.cubicTo(SkBits2Float(0x40c4a257), SkBits2Float(0xc2a58b80), SkBits2Float(0x40caf70c), SkBits2Float(0xc2a583db), SkBits2Float(0x40d14b4e), SkBits2Float(0xc2a57bda));
5485path.lineTo(SkBits2Float(0x40974c04), SkBits2Float(0xc26f40f2));
5486path.cubicTo(SkBits2Float(0x4092b8c1), SkBits2Float(0xc26f4c86), SkBits2Float(0x408e252c), SkBits2Float(0xc26f5792), SkBits2Float(0x4089914a), SkBits2Float(0xc26f6219));
5487path.lineTo(SkBits2Float(0x40899143), SkBits2Float(0xc26f6217));
5488path.cubicTo(SkBits2Float(0x40379219), SkBits2Float(0xc26fcb54), SkBits2Float(0x3fb799b8), SkBits2Float(0xc26fffff), SkBits2Float(0x3673fea3), SkBits2Float(0xc26fffff));
5489path.close();
5490
5491 SkPath path1(path);
5492 path.reset();
5493 path.setFillType((SkPathFillType) 0);
5494path.moveTo(SkBits2Float(0x40d14b4a), SkBits2Float(0xc2a57bdb));
5495path.cubicTo(SkBits2Float(0x411bf161), SkBits2Float(0xc2a4fa1a), SkBits2Float(0x414ef5ad), SkBits2Float(0xc2a4190e), SkBits2Float(0x4180b83e), SkBits2Float(0xc2a2d9dc));
5496path.lineTo(SkBits2Float(0x413a19cf), SkBits2Float(0xc26b727f));
5497path.cubicTo(SkBits2Float(0x41159c04), SkBits2Float(0xc26d3fff), SkBits2Float(0x40e175a8), SkBits2Float(0xc26e855c), SkBits2Float(0x40974c02), SkBits2Float(0xc26f40f4));
5498path.lineTo(SkBits2Float(0x40d14b4a), SkBits2Float(0xc2a57bdb));
5499path.close();
5500
5501 SkPath path2(path);
5502 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5503}

◆ battleOp201()

static void battleOp201 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5506 of file PathOpsBattles.cpp.

5506 {
5507 SkPath path;
5508 path.setFillType((SkPathFillType) 0);
5509path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5510path.cubicTo(SkBits2Float(0x4059d383), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40d9b918), SkBits2Float(0xc2a594d0), SkBits2Float(0x4122e820), SkBits2Float(0xc2a4bf0c));
5511path.lineTo(SkBits2Float(0x40eb871c), SkBits2Float(0xc26e2ff8));
5512path.cubicTo(SkBits2Float(0x409d63e0), SkBits2Float(0xc26f6508), SkBits2Float(0x401d76fa), SkBits2Float(0xc2700000), SkBits2Float(0x35f7fd4a), SkBits2Float(0xc2700000));
5513path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5514path.close();
5515
5516 SkPath path1(path);
5517 path.reset();
5518 path.setFillType((SkPathFillType) 0);
5519path.moveTo(SkBits2Float(0x4122e81e), SkBits2Float(0xc2a4bf0c));
5520path.cubicTo(SkBits2Float(0x41284f3c), SkBits2Float(0xc2a4a9ac), SkBits2Float(0x412db549), SkBits2Float(0xc2a4933e), SkBits2Float(0x41331a33), SkBits2Float(0xc2a47bbf));
5521path.lineTo(SkBits2Float(0x410178be), SkBits2Float(0xc26dceac));
5522path.cubicTo(SkBits2Float(0x40fb24f7), SkBits2Float(0xc26df0a4), SkBits2Float(0x40f356d1), SkBits2Float(0xc26e1114), SkBits2Float(0x40eb871f), SkBits2Float(0xc26e2ff8));
5523path.lineTo(SkBits2Float(0x4122e81e), SkBits2Float(0xc2a4bf0c));
5524path.close();
5525
5526 SkPath path2(path);
5527 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5528}

◆ battleOp202()

static void battleOp202 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5531 of file PathOpsBattles.cpp.

5531 {
5532 SkPath path;
5533 path.setFillType((SkPathFillType) 1);
5534path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
5535path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5536path.cubicTo(SkBits2Float(0x4059d380), SkBits2Float(0xc2a60000), SkBits2Float(0x40d9b915), SkBits2Float(0xc2a594d0), SkBits2Float(0x4122e81e), SkBits2Float(0xc2a4bf0c));
5537path.lineTo(SkBits2Float(0x4122e820), SkBits2Float(0xc2a4bf0c));
5538path.cubicTo(SkBits2Float(0x41284f3d), SkBits2Float(0xc2a4a9ac), SkBits2Float(0x412db54a), SkBits2Float(0xc2a4933e), SkBits2Float(0x41331a33), SkBits2Float(0xc2a47bbf));
5539path.lineTo(SkBits2Float(0x410178be), SkBits2Float(0xc26dceac));
5540path.cubicTo(SkBits2Float(0x40fb24f7), SkBits2Float(0xc26df0a4), SkBits2Float(0x40f356d1), SkBits2Float(0xc26e1114), SkBits2Float(0x40eb871f), SkBits2Float(0xc26e2ff8));
5541path.lineTo(SkBits2Float(0x40eb871c), SkBits2Float(0xc26e2ff8));
5542path.cubicTo(SkBits2Float(0x409d63e0), SkBits2Float(0xc26f6508), SkBits2Float(0x401d76fa), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
5543path.close();
5544
5545 SkPath path1(path);
5546 path.reset();
5547 path.setFillType((SkPathFillType) 0);
5548path.moveTo(SkBits2Float(0x41331a39), SkBits2Float(0xc2a47bc0));
5549path.cubicTo(SkBits2Float(0x41854b40), SkBits2Float(0xc2a2feb5), SkBits2Float(0x41b05576), SkBits2Float(0xc2a06b6c), SkBits2Float(0x41da0834), SkBits2Float(0xc29ccbb1));
5550path.lineTo(SkBits2Float(0x419d9d10), SkBits2Float(0xc262b148));
5551path.cubicTo(SkBits2Float(0x417ef0c0), SkBits2Float(0xc267ee96), SkBits2Float(0x4140b6cf), SkBits2Float(0xc26ba7c4), SkBits2Float(0x410178c0), SkBits2Float(0xc26dcead));
5552path.lineTo(SkBits2Float(0x41331a39), SkBits2Float(0xc2a47bc0));
5553path.close();
5554
5555 SkPath path2(path);
5556 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5557}

◆ battleOp203()

static void battleOp203 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5560 of file PathOpsBattles.cpp.

5560 {
5561 SkPath path;
5562 path.setFillType((SkPathFillType) 0);
5563path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5564path.cubicTo(SkBits2Float(0x4087af55), SkBits2Float(0xc2a5ffff), SkBits2Float(0x410795c5), SkBits2Float(0xc2a559a4), SkBits2Float(0x414aa20a), SkBits2Float(0xc2a40e63));
5565path.lineTo(SkBits2Float(0x41127b4b), SkBits2Float(0xc26d308f));
5566path.cubicTo(SkBits2Float(0x40c406cd), SkBits2Float(0xc26f0f7b), SkBits2Float(0x40442bc2), SkBits2Float(0xc26fffff), SkBits2Float(0x36b5ff52), SkBits2Float(0xc26fffff));
5567path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5568path.close();
5569
5570 SkPath path1(path);
5571 path.reset();
5572 path.setFillType((SkPathFillType) 0);
5573path.moveTo(SkBits2Float(0x414aa206), SkBits2Float(0xc2a40e63));
5574path.cubicTo(SkBits2Float(0x4151559c), SkBits2Float(0xc2a3ed46), SkBits2Float(0x41580726), SkBits2Float(0xc2a3ca86), SkBits2Float(0x415eb67b), SkBits2Float(0xc2a3a622));
5575path.lineTo(SkBits2Float(0x4120ff4d), SkBits2Float(0xc26c99d6));
5576path.cubicTo(SkBits2Float(0x411c2a2f), SkBits2Float(0xc26cce74), SkBits2Float(0x41175378), SkBits2Float(0xc26d00b1), SkBits2Float(0x41127b46), SkBits2Float(0xc26d308f));
5577path.lineTo(SkBits2Float(0x414aa206), SkBits2Float(0xc2a40e63));
5578path.close();
5579
5580 SkPath path2(path);
5581 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5582}

◆ battleOp204()

static void battleOp204 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5585 of file PathOpsBattles.cpp.

5585 {
5586 SkPath path;
5587 path.setFillType((SkPathFillType) 1);
5588path.moveTo(SkBits2Float(0x36b5ff52), SkBits2Float(0xc26fffff));
5589path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5590path.cubicTo(SkBits2Float(0x4087af52), SkBits2Float(0xc2a60000), SkBits2Float(0x410795c2), SkBits2Float(0xc2a559a4), SkBits2Float(0x414aa206), SkBits2Float(0xc2a40e63));
5591path.lineTo(SkBits2Float(0x414aa20a), SkBits2Float(0xc2a40e63));
5592path.cubicTo(SkBits2Float(0x4151559f), SkBits2Float(0xc2a3ed46), SkBits2Float(0x41580727), SkBits2Float(0xc2a3ca86), SkBits2Float(0x415eb67b), SkBits2Float(0xc2a3a622));
5593path.lineTo(SkBits2Float(0x4120ff4d), SkBits2Float(0xc26c99d6));
5594path.cubicTo(SkBits2Float(0x411c2a31), SkBits2Float(0xc26cce74), SkBits2Float(0x4117537b), SkBits2Float(0xc26d00b1), SkBits2Float(0x41127b4b), SkBits2Float(0xc26d308f));
5595path.lineTo(SkBits2Float(0x41127b46), SkBits2Float(0xc26d308f));
5596path.cubicTo(SkBits2Float(0x40c406c6), SkBits2Float(0xc26f0f7b), SkBits2Float(0x40442bbb), SkBits2Float(0xc26fffff), SkBits2Float(0x36b5ff52), SkBits2Float(0xc26fffff));
5597path.close();
5598
5599 SkPath path1(path);
5600 path.reset();
5601 path.setFillType((SkPathFillType) 0);
5602path.moveTo(SkBits2Float(0x415eb680), SkBits2Float(0xc2a3a623));
5603path.cubicTo(SkBits2Float(0x41a59721), SkBits2Float(0xc2a157ad), SkBits2Float(0x41da77ab), SkBits2Float(0xc29d5c25), SkBits2Float(0x420662d7), SkBits2Float(0xc297cafd));
5604path.lineTo(SkBits2Float(0x41c24b0d), SkBits2Float(0xc25b75ac));
5605path.cubicTo(SkBits2Float(0x419deda5), SkBits2Float(0xc2638226), SkBits2Float(0x416f6860), SkBits2Float(0xc269442a), SkBits2Float(0x4120ff4a), SkBits2Float(0xc26c99d9));
5606path.lineTo(SkBits2Float(0x415eb680), SkBits2Float(0xc2a3a623));
5607path.close();
5608
5609 SkPath path2(path);
5610 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5611}

◆ battleOp205()

static void battleOp205 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5614 of file PathOpsBattles.cpp.

5614 {
5615 SkPath path;
5616 path.setFillType((SkPathFillType) 0);
5617path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5618path.cubicTo(SkBits2Float(0x40a2e582), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4122b94f), SkBits2Float(0xc2a51039), SkBits2Float(0x4172cca0), SkBits2Float(0xc2a333b4));
5619path.lineTo(SkBits2Float(0x412f847d), SkBits2Float(0xc26bf464));
5620path.cubicTo(SkBits2Float(0x40eb4376), SkBits2Float(0xc26ea556), SkBits2Float(0x406b836d), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
5621path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5622path.close();
5623
5624 SkPath path1(path);
5625 path.reset();
5626 path.setFillType((SkPathFillType) 0);
5627path.moveTo(SkBits2Float(0x4172cc9b), SkBits2Float(0xc2a333b4));
5628path.cubicTo(SkBits2Float(0x417acd1a), SkBits2Float(0xc2a30415), SkBits2Float(0x41816508), SkBits2Float(0xc2a2d21d), SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcb));
5629path.lineTo(SkBits2Float(0x4140d724), SkBits2Float(0xc26b1ba8));
5630path.cubicTo(SkBits2Float(0x413b139d), SkBits2Float(0xc26b674c), SkBits2Float(0x41354d54), SkBits2Float(0xc26baf8b), SkBits2Float(0x412f847c), SkBits2Float(0xc26bf463));
5631path.lineTo(SkBits2Float(0x4172cc9b), SkBits2Float(0xc2a333b4));
5632path.close();
5633
5634 SkPath path2(path);
5635 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5636}

◆ battleOp206()

static void battleOp206 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5639 of file PathOpsBattles.cpp.

5639 {
5640 SkPath path;
5641 path.setFillType((SkPathFillType) 1);
5642path.moveTo(SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
5643path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5644path.cubicTo(SkBits2Float(0x40a2e57f), SkBits2Float(0xc2a60000), SkBits2Float(0x4122b94c), SkBits2Float(0xc2a51039), SkBits2Float(0x4172cc9b), SkBits2Float(0xc2a333b4));
5645path.lineTo(SkBits2Float(0x4172cca0), SkBits2Float(0xc2a333b4));
5646path.cubicTo(SkBits2Float(0x417acd1d), SkBits2Float(0xc2a30415), SkBits2Float(0x41816509), SkBits2Float(0xc2a2d21d), SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcb));
5647path.lineTo(SkBits2Float(0x4140d724), SkBits2Float(0xc26b1ba8));
5648path.cubicTo(SkBits2Float(0x413b139d), SkBits2Float(0xc26b674c), SkBits2Float(0x41354d54), SkBits2Float(0xc26baf8b), SkBits2Float(0x412f847c), SkBits2Float(0xc26bf463));
5649path.lineTo(SkBits2Float(0x412f847d), SkBits2Float(0xc26bf464));
5650path.cubicTo(SkBits2Float(0x40eb4376), SkBits2Float(0xc26ea556), SkBits2Float(0x406b836d), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
5651path.close();
5652
5653 SkPath path1(path);
5654 path.reset();
5655 path.setFillType((SkPathFillType) 0);
5656path.moveTo(SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcc));
5657path.cubicTo(SkBits2Float(0x41c61a92), SkBits2Float(0xc29f4c69), SkBits2Float(0x42023dd6), SkBits2Float(0xc299958f), SkBits2Float(0x421f3a98), SkBits2Float(0xc291a994));
5658path.lineTo(SkBits2Float(0x41e635e1), SkBits2Float(0xc25298a5));
5659path.cubicTo(SkBits2Float(0x41bc4d11), SkBits2Float(0xc25e0caa), SkBits2Float(0x418f3524), SkBits2Float(0xc2664fa2), SkBits2Float(0x4140d729), SkBits2Float(0xc26b1ba9));
5660path.lineTo(SkBits2Float(0x4185619b), SkBits2Float(0xc2a29dcc));
5661path.close();
5662
5663 SkPath path2(path);
5664 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5665}

◆ battleOp207()

static void battleOp207 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5668 of file PathOpsBattles.cpp.

5668 {
5669 SkPath path;
5670 path.setFillType((SkPathFillType) 0);
5671path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5672path.cubicTo(SkBits2Float(0x40c39389), SkBits2Float(0xc2a60000), SkBits2Float(0x414346f4), SkBits2Float(0xc2a4a65f), SkBits2Float(0x419158cf), SkBits2Float(0xc2a1f965));
5673path.lineTo(SkBits2Float(0x415223e0), SkBits2Float(0xc26a2df8));
5674path.cubicTo(SkBits2Float(0x410d2a0c), SkBits2Float(0xc26e0c4b), SkBits2Float(0x408d616c), SkBits2Float(0xc2700000), SkBits2Float(0x35bbfd46), SkBits2Float(0xc2700000));
5675path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5676path.close();
5677
5678 SkPath path1(path);
5679 path.reset();
5680 path.setFillType((SkPathFillType) 0);
5681path.moveTo(SkBits2Float(0x419158d0), SkBits2Float(0xc2a1f965));
5682path.cubicTo(SkBits2Float(0x41961cea), SkBits2Float(0xc2a1b4f6), SkBits2Float(0x419addf6), SkBits2Float(0xc2a16d2c), SkBits2Float(0x419f9bbb), SkBits2Float(0xc2a12207));
5683path.lineTo(SkBits2Float(0x4166c251), SkBits2Float(0xc268f69a));
5684path.cubicTo(SkBits2Float(0x415fe778), SkBits2Float(0xc269633e), SkBits2Float(0x415907e2), SkBits2Float(0xc269cb09), SkBits2Float(0x415223e0), SkBits2Float(0xc26a2df8));
5685path.lineTo(SkBits2Float(0x419158d0), SkBits2Float(0xc2a1f965));
5686path.close();
5687
5688 SkPath path2(path);
5689 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5690}

◆ battleOp208()

static void battleOp208 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5693 of file PathOpsBattles.cpp.

5693 {
5694 SkPath path;
5695 path.setFillType((SkPathFillType) 1);
5696path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
5697path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5698path.cubicTo(SkBits2Float(0x40c39389), SkBits2Float(0xc2a60000), SkBits2Float(0x414346f4), SkBits2Float(0xc2a4a65f), SkBits2Float(0x419158d0), SkBits2Float(0xc2a1f965));
5699path.cubicTo(SkBits2Float(0x41961cea), SkBits2Float(0xc2a1b4f6), SkBits2Float(0x419addf6), SkBits2Float(0xc2a16d2c), SkBits2Float(0x419f9bbb), SkBits2Float(0xc2a12207));
5700path.lineTo(SkBits2Float(0x4166c251), SkBits2Float(0xc268f69a));
5701path.cubicTo(SkBits2Float(0x415fe778), SkBits2Float(0xc269633e), SkBits2Float(0x415907e2), SkBits2Float(0xc269cb09), SkBits2Float(0x415223e0), SkBits2Float(0xc26a2df8));
5702path.cubicTo(SkBits2Float(0x410d2a0c), SkBits2Float(0xc26e0c4b), SkBits2Float(0x408d616c), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
5703path.close();
5704
5705 SkPath path1(path);
5706 path.reset();
5707 path.setFillType((SkPathFillType) 0);
5708path.moveTo(SkBits2Float(0x419f9bbc), SkBits2Float(0xc2a12208));
5709path.cubicTo(SkBits2Float(0x41eca53e), SkBits2Float(0xc29c5d1a), SkBits2Float(0x421ad1be), SkBits2Float(0xc2942e2b), SkBits2Float(0x423b8fe1), SkBits2Float(0xc288f8a3));
5710path.lineTo(SkBits2Float(0x42079647), SkBits2Float(0xc24607dc));
5711path.cubicTo(SkBits2Float(0x41dfd5cc), SkBits2Float(0xc2563c94), SkBits2Float(0x41ab11aa), SkBits2Float(0xc2621167), SkBits2Float(0x4166c24e), SkBits2Float(0xc268f69b));
5712path.lineTo(SkBits2Float(0x419f9bbc), SkBits2Float(0xc2a12208));
5713path.close();
5714
5715 SkPath path2(path);
5716 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5717}

◆ battleOp209()

static void battleOp209 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5720 of file PathOpsBattles.cpp.

5720 {
5721 SkPath path;
5722 path.setFillType((SkPathFillType) 0);
5723path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5724path.cubicTo(SkBits2Float(0x40e86425), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4167e385), SkBits2Float(0xc2a41801), SkBits2Float(0x41ac0ecd), SkBits2Float(0xc2a05484));
5725path.lineTo(SkBits2Float(0x4178c21d), SkBits2Float(0xc267cd79));
5726path.cubicTo(SkBits2Float(0x4127a168), SkBits2Float(0xc26d3e79), SkBits2Float(0x40a7fe68), SkBits2Float(0xc2700000), SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
5727path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5728path.close();
5729
5730 SkPath path1(path);
5731 path.reset();
5732 path.setFillType((SkPathFillType) 0);
5733path.moveTo(SkBits2Float(0x41ac0ecb), SkBits2Float(0xc2a05485));
5734path.cubicTo(SkBits2Float(0x41b1a941), SkBits2Float(0xc29ff44e), SkBits2Float(0x41b73ea0), SkBits2Float(0xc29f8f65), SkBits2Float(0x41bcce84), SkBits2Float(0xc29f25d1));
5735path.lineTo(SkBits2Float(0x41887c9d), SkBits2Float(0xc26617d6));
5736path.cubicTo(SkBits2Float(0x4184774a), SkBits2Float(0xc266b07c), SkBits2Float(0x41806e06), SkBits2Float(0xc2674260), SkBits2Float(0x4178c21e), SkBits2Float(0xc267cd7a));
5737path.lineTo(SkBits2Float(0x41ac0ecb), SkBits2Float(0xc2a05485));
5738path.close();
5739
5740 SkPath path2(path);
5741 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5742}

◆ battleOp21()

static void battleOp21 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 628 of file PathOpsBattles.cpp.

628 {
629 SkPath path;
630 path.setFillType((SkPathFillType) 0);
631path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
632path.cubicTo(SkBits2Float(0x404ef9c5), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40cee321), SkBits2Float(0xc2a59f3a), SkBits2Float(0x411ad5ab), SkBits2Float(0xc2a4de2c));
633path.lineTo(SkBits2Float(0x40dfdb77), SkBits2Float(0xc26e5cf8));
634path.cubicTo(SkBits2Float(0x40958e99), SkBits2Float(0xc26f7414), SkBits2Float(0x40159f04), SkBits2Float(0xc26ffffe), SkBits2Float(0x36ae7f52), SkBits2Float(0xc26ffffe));
635path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
636path.close();
637
638 SkPath path1(path);
639 path.reset();
640 path.setFillType((SkPathFillType) 0);
641path.moveTo(SkBits2Float(0x411ad5aa), SkBits2Float(0xc2a4de2c));
642path.cubicTo(SkBits2Float(0x411ff8ea), SkBits2Float(0xc2a4cadf), SkBits2Float(0x41251b3e), SkBits2Float(0xc2a4b69c), SkBits2Float(0x412a3c98), SkBits2Float(0xc2a4a163));
643path.lineTo(SkBits2Float(0x40f6200f), SkBits2Float(0xc26e0518));
644path.cubicTo(SkBits2Float(0x40eeb53e), SkBits2Float(0xc26e23c6), SkBits2Float(0x40e74902), SkBits2Float(0xc26e4112), SkBits2Float(0x40dfdb73), SkBits2Float(0xc26e5cf8));
645path.lineTo(SkBits2Float(0x411ad5aa), SkBits2Float(0xc2a4de2c));
646path.close();
647
648 SkPath path2(path);
649 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
650}

◆ battleOp210()

static void battleOp210 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5745 of file PathOpsBattles.cpp.

5745 {
5746 SkPath path;
5747 path.setFillType((SkPathFillType) 1);
5748path.moveTo(SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
5749path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5750path.cubicTo(SkBits2Float(0x40e86421), SkBits2Float(0xc2a60000), SkBits2Float(0x4167e381), SkBits2Float(0xc2a41801), SkBits2Float(0x41ac0eca), SkBits2Float(0xc2a05484));
5751path.lineTo(SkBits2Float(0x41ac0ecd), SkBits2Float(0xc2a05484));
5752path.lineTo(SkBits2Float(0x4178c21e), SkBits2Float(0xc267cd7a));
5753path.lineTo(SkBits2Float(0x41ac0ecb), SkBits2Float(0xc2a05485));
5754path.cubicTo(SkBits2Float(0x41b1a941), SkBits2Float(0xc29ff44e), SkBits2Float(0x41b73ea0), SkBits2Float(0xc29f8f65), SkBits2Float(0x41bcce84), SkBits2Float(0xc29f25d1));
5755path.lineTo(SkBits2Float(0x41887c9d), SkBits2Float(0xc26617d6));
5756path.cubicTo(SkBits2Float(0x4184774a), SkBits2Float(0xc266b07c), SkBits2Float(0x41806e06), SkBits2Float(0xc2674260), SkBits2Float(0x4178c21d), SkBits2Float(0xc267cd79));
5757path.cubicTo(SkBits2Float(0x4127a168), SkBits2Float(0xc26d3e79), SkBits2Float(0x40a7fe68), SkBits2Float(0xc2700000), SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
5758path.close();
5759
5760 SkPath path1(path);
5761 path.reset();
5762 path.setFillType((SkPathFillType) 0);
5763path.moveTo(SkBits2Float(0x41bcce83), SkBits2Float(0xc29f25d2));
5764path.cubicTo(SkBits2Float(0x420ba3b4), SkBits2Float(0xc2987080), SkBits2Float(0x42357f09), SkBits2Float(0xc28cfcb1), SkBits2Float(0x42592f07), SkBits2Float(0xc27b1ba7));
5765path.lineTo(SkBits2Float(0x421d0012), SkBits2Float(0xc235861c));
5766path.cubicTo(SkBits2Float(0x420333bc), SkBits2Float(0xc24bd636), SkBits2Float(0x41c9e36e), SkBits2Float(0xc25c64f6), SkBits2Float(0x41887c9c), SkBits2Float(0xc26617d7));
5767path.lineTo(SkBits2Float(0x41bcce83), SkBits2Float(0xc29f25d2));
5768path.close();
5769
5770 SkPath path2(path);
5771 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5772}

◆ battleOp211()

static void battleOp211 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5775 of file PathOpsBattles.cpp.

5775 {
5776 SkPath path;
5777 path.setFillType((SkPathFillType) 0);
5778path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5779path.cubicTo(SkBits2Float(0x411e5541), SkBits2Float(0xc2a5ffff), SkBits2Float(0x419db1ee), SkBits2Float(0xc2a275ef), SkBits2Float(0x41e7e0a3), SkBits2Float(0xc29b8c98));
5780path.lineTo(SkBits2Float(0x41a79f51), SkBits2Float(0xc260e3f1));
5781path.cubicTo(SkBits2Float(0x4163fe32), SkBits2Float(0xc26ae208), SkBits2Float(0x40e4ea54), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea3), SkBits2Float(0xc2700000));
5782path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5783path.close();
5784
5785 SkPath path1(path);
5786 path.reset();
5787 path.setFillType((SkPathFillType) 0);
5788path.moveTo(SkBits2Float(0x41e7e0a8), SkBits2Float(0xc29b8c98));
5789path.cubicTo(SkBits2Float(0x41ef46bb), SkBits2Float(0xc29adc20), SkBits2Float(0x41f6a013), SkBits2Float(0xc29a2338), SkBits2Float(0x41fdebc8), SkBits2Float(0xc29961f8));
5790path.lineTo(SkBits2Float(0x41b78eb0), SkBits2Float(0xc25dc215));
5791path.cubicTo(SkBits2Float(0x41b2488a), SkBits2Float(0xc25ed97a), SkBits2Float(0x41acf889), SkBits2Float(0xc25fe4cd), SkBits2Float(0x41a79f51), SkBits2Float(0xc260e3f1));
5792path.lineTo(SkBits2Float(0x41e7e0a8), SkBits2Float(0xc29b8c98));
5793path.close();
5794
5795 SkPath path2(path);
5796 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5797}

◆ battleOp212()

static void battleOp212 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5800 of file PathOpsBattles.cpp.

5800 {
5801 SkPath path;
5802 path.setFillType((SkPathFillType) 1);
5803path.moveTo(SkBits2Float(0x3637fea3), SkBits2Float(0xc2700000));
5804path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5805path.cubicTo(SkBits2Float(0x411e5541), SkBits2Float(0xc2a5ffff), SkBits2Float(0x419db1ee), SkBits2Float(0xc2a275ef), SkBits2Float(0x41e7e0a8), SkBits2Float(0xc29b8c98));
5806path.cubicTo(SkBits2Float(0x41ef46bb), SkBits2Float(0xc29adc20), SkBits2Float(0x41f6a013), SkBits2Float(0xc29a2338), SkBits2Float(0x41fdebc8), SkBits2Float(0xc29961f8));
5807path.lineTo(SkBits2Float(0x41b78eb0), SkBits2Float(0xc25dc215));
5808path.cubicTo(SkBits2Float(0x41b2488a), SkBits2Float(0xc25ed97a), SkBits2Float(0x41acf889), SkBits2Float(0xc25fe4cd), SkBits2Float(0x41a79f51), SkBits2Float(0xc260e3f1));
5809path.cubicTo(SkBits2Float(0x4163fe32), SkBits2Float(0xc26ae208), SkBits2Float(0x40e4ea54), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea3), SkBits2Float(0xc2700000));
5810path.close();
5811
5812 SkPath path1(path);
5813 path.reset();
5814 path.setFillType((SkPathFillType) 0);
5815path.moveTo(SkBits2Float(0x41fdebc9), SkBits2Float(0xc29961f9));
5816path.cubicTo(SkBits2Float(0x423a7ccd), SkBits2Float(0xc28d1085), SkBits2Float(0x426d8f8d), SkBits2Float(0xc270b4b0), SkBits2Float(0x4288fa0c), SkBits2Float(0xc23b8bbf));
5817path.lineTo(SkBits2Float(0x424609e8), SkBits2Float(0xc207934a));
5818path.cubicTo(SkBits2Float(0x422bbb0d), SkBits2Float(0xc22e0114), SkBits2Float(0x4206cf6b), SkBits2Float(0xc24bf2e1), SkBits2Float(0x41b78eaf), SkBits2Float(0xc25dc216));
5819path.lineTo(SkBits2Float(0x41fdebc9), SkBits2Float(0xc29961f9));
5820path.close();
5821
5822 SkPath path2(path);
5823 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5824}

◆ battleOp213()

static void battleOp213 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5827 of file PathOpsBattles.cpp.

5827 {
5828 SkPath path;
5829 path.setFillType((SkPathFillType) 0);
5830path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5831path.cubicTo(SkBits2Float(0x4151cd59), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41d04f3f), SkBits2Float(0xc29fc954), SkBits2Float(0x4216e058), SkBits2Float(0xc293de54));
5832path.lineTo(SkBits2Float(0x41da226b), SkBits2Float(0xc255c926));
5833path.cubicTo(SkBits2Float(0x419695d1), SkBits2Float(0xc267043d), SkBits2Float(0x4117aa0a), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
5834path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5835path.close();
5836
5837 SkPath path1(path);
5838 path.reset();
5839 path.setFillType((SkPathFillType) 0);
5840path.moveTo(SkBits2Float(0x4216e057), SkBits2Float(0xc293de54));
5841path.cubicTo(SkBits2Float(0x421b86ea), SkBits2Float(0xc292aea0), SkBits2Float(0x42201eff), SkBits2Float(0xc29170ed), SkBits2Float(0x4224a79b), SkBits2Float(0xc290257e));
5842path.lineTo(SkBits2Float(0x41ee0e15), SkBits2Float(0xc2506790));
5843path.cubicTo(SkBits2Float(0x41e78019), SkBits2Float(0xc25246bf), SkBits2Float(0x41e0dbbc), SkBits2Float(0xc2541212), SkBits2Float(0x41da226b), SkBits2Float(0xc255c927));
5844path.lineTo(SkBits2Float(0x4216e057), SkBits2Float(0xc293de54));
5845path.close();
5846
5847 SkPath path2(path);
5848 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5849}

◆ battleOp214()

static void battleOp214 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5852 of file PathOpsBattles.cpp.

5852 {
5853 SkPath path;
5854 path.setFillType((SkPathFillType) 1);
5855path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
5856path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5857path.cubicTo(SkBits2Float(0x4151cd58), SkBits2Float(0xc2a60000), SkBits2Float(0x41d04f3d), SkBits2Float(0xc29fc954), SkBits2Float(0x4216e057), SkBits2Float(0xc293de54));
5858path.lineTo(SkBits2Float(0x4216e058), SkBits2Float(0xc293de54));
5859path.cubicTo(SkBits2Float(0x421b86eb), SkBits2Float(0xc292aea0), SkBits2Float(0x42201eff), SkBits2Float(0xc29170ed), SkBits2Float(0x4224a79b), SkBits2Float(0xc290257e));
5860path.lineTo(SkBits2Float(0x41ee0e15), SkBits2Float(0xc2506790));
5861path.cubicTo(SkBits2Float(0x41e78019), SkBits2Float(0xc25246bf), SkBits2Float(0x41e0dbbc), SkBits2Float(0xc2541212), SkBits2Float(0x41da226b), SkBits2Float(0xc255c927));
5862path.lineTo(SkBits2Float(0x41da226b), SkBits2Float(0xc255c926));
5863path.cubicTo(SkBits2Float(0x419695d1), SkBits2Float(0xc267043d), SkBits2Float(0x4117aa0a), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
5864path.close();
5865
5866 SkPath path1(path);
5867 path.reset();
5868 path.setFillType((SkPathFillType) 0);
5869path.moveTo(SkBits2Float(0x4224a79b), SkBits2Float(0xc290257f));
5870path.cubicTo(SkBits2Float(0x426f06c3), SkBits2Float(0xc275d105), SkBits2Float(0x42930d85), SkBits2Float(0xc2303df6), SkBits2Float(0x429f3103), SkBits2Float(0xc1bc373f));
5871path.lineTo(SkBits2Float(0x42662806), SkBits2Float(0xc1880f44));
5872path.cubicTo(SkBits2Float(0x42549b44), SkBits2Float(0xc1fececc), SkBits2Float(0x422cca4c), SkBits2Float(0xc231b2de), SkBits2Float(0x41ee0e18), SkBits2Float(0xc2506792));
5873path.lineTo(SkBits2Float(0x4224a79b), SkBits2Float(0xc290257f));
5874path.close();
5875
5876 SkPath path2(path);
5877 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5878}

◆ battleOp215()

static void battleOp215 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5881 of file PathOpsBattles.cpp.

5881 {
5882 SkPath path;
5883 path.setFillType((SkPathFillType) 0);
5884path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5885path.cubicTo(SkBits2Float(0x41741cf0), SkBits2Float(0xc2a60000), SkBits2Float(0x41f1c060), SkBits2Float(0xc29d96da), SkBits2Float(0x422cf7a2), SkBits2Float(0xc28db11c));
5886path.lineTo(SkBits2Float(0x41fa12be), SkBits2Float(0xc24cdb0d));
5887path.cubicTo(SkBits2Float(0x41aec295), SkBits2Float(0xc263d704), SkBits2Float(0x413077a0), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5888path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5889path.close();
5890
5891 SkPath path1(path);
5892 path.reset();
5893 path.setFillType((SkPathFillType) 0);
5894path.moveTo(SkBits2Float(0x422cf7a1), SkBits2Float(0xc28db11c));
5895path.cubicTo(SkBits2Float(0x423224e7), SkBits2Float(0xc28c1ca8), SkBits2Float(0x42373bc3), SkBits2Float(0xc28a7620), SkBits2Float(0x423c3abd), SkBits2Float(0xc288bdfd));
5896path.lineTo(SkBits2Float(0x420811ca), SkBits2Float(0xc245b313));
5897path.cubicTo(SkBits2Float(0x4204753a), SkBits2Float(0xc2482f6b), SkBits2Float(0x4200c767), SkBits2Float(0xc24a924f), SkBits2Float(0x41fa12c1), SkBits2Float(0xc24cdb0e));
5898path.lineTo(SkBits2Float(0x422cf7a1), SkBits2Float(0xc28db11c));
5899path.close();
5900
5901 SkPath path2(path);
5902 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5903}

◆ battleOp216()

static void battleOp216 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5906 of file PathOpsBattles.cpp.

5906 {
5907 SkPath path;
5908 path.setFillType((SkPathFillType) 1);
5909path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5910path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5911path.cubicTo(SkBits2Float(0x41741cef), SkBits2Float(0xc2a60000), SkBits2Float(0x41f1c05e), SkBits2Float(0xc29d96da), SkBits2Float(0x422cf7a1), SkBits2Float(0xc28db11c));
5912path.lineTo(SkBits2Float(0x422cf7a2), SkBits2Float(0xc28db11c));
5913path.cubicTo(SkBits2Float(0x423224e8), SkBits2Float(0xc28c1ca8), SkBits2Float(0x42373bc3), SkBits2Float(0xc28a7620), SkBits2Float(0x423c3abd), SkBits2Float(0xc288bdfd));
5914path.lineTo(SkBits2Float(0x420811ca), SkBits2Float(0xc245b313));
5915path.cubicTo(SkBits2Float(0x4204753a), SkBits2Float(0xc2482f6b), SkBits2Float(0x4200c767), SkBits2Float(0xc24a924f), SkBits2Float(0x41fa12c1), SkBits2Float(0xc24cdb0e));
5916path.lineTo(SkBits2Float(0x41fa12be), SkBits2Float(0xc24cdb0d));
5917path.cubicTo(SkBits2Float(0x41aec295), SkBits2Float(0xc263d704), SkBits2Float(0x413077a0), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5918path.close();
5919
5920 SkPath path1(path);
5921 path.reset();
5922 path.setFillType((SkPathFillType) 0);
5923path.moveTo(SkBits2Float(0x423c3abe), SkBits2Float(0xc288bdfe));
5924path.cubicTo(SkBits2Float(0x42874551), SkBits2Float(0xc258d4f5), SkBits2Float(0x42a17ace), SkBits2Float(0xc1fc3ce7), SkBits2Float(0x42a57844), SkBits2Float(0xc0d41d22));
5925path.lineTo(SkBits2Float(0x426f3bc1), SkBits2Float(0xc09955d3));
5926path.cubicTo(SkBits2Float(0x426976f3), SkBits2Float(0xc1b65735), SkBits2Float(0x4243927c), SkBits2Float(0xc21cbef5), SkBits2Float(0x420811ca), SkBits2Float(0xc245b314));
5927path.lineTo(SkBits2Float(0x423c3abe), SkBits2Float(0xc288bdfe));
5928path.close();
5929
5930 SkPath path2(path);
5931 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5932}

◆ battleOp217()

static void battleOp217 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5935 of file PathOpsBattles.cpp.

5935 {
5936 SkPath path;
5937 path.setFillType((SkPathFillType) 0);
5938path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5939path.cubicTo(SkBits2Float(0x4188e880), SkBits2Float(0xc2a60000), SkBits2Float(0x42073c1a), SkBits2Float(0xc29b6b86), SkBits2Float(0x423f3295), SkBits2Float(0xc287b573));
5940path.lineTo(SkBits2Float(0x420a3712), SkBits2Float(0xc2443499));
5941path.cubicTo(SkBits2Float(0x41c3852b), SkBits2Float(0xc260b421), SkBits2Float(0x4145f08c), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5942path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5943path.close();
5944
5945 SkPath path1(path);
5946 path.reset();
5947 path.setFillType((SkPathFillType) 0);
5948path.moveTo(SkBits2Float(0x423f3294), SkBits2Float(0xc287b572));
5949path.cubicTo(SkBits2Float(0x4244c015), SkBits2Float(0xc285c0c3), SkBits2Float(0x424a2e84), SkBits2Float(0xc283b664), SkBits2Float(0x424f7bec), SkBits2Float(0xc281970f));
5950path.lineTo(SkBits2Float(0x4215fd0e), SkBits2Float(0xc23b5bf1));
5951path.cubicTo(SkBits2Float(0x421227cb), SkBits2Float(0xc23e6d7a), SkBits2Float(0x420e3aa9), SkBits2Float(0xc24160b8), SkBits2Float(0x420a3713), SkBits2Float(0xc2443498));
5952path.lineTo(SkBits2Float(0x423f3294), SkBits2Float(0xc287b572));
5953path.close();
5954
5955 SkPath path2(path);
5956 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5957}

◆ battleOp218()

static void battleOp218 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5960 of file PathOpsBattles.cpp.

5960 {
5961 SkPath path;
5962 path.setFillType((SkPathFillType) 1);
5963path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5964path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
5965path.cubicTo(SkBits2Float(0x4188e880), SkBits2Float(0xc2a60000), SkBits2Float(0x42073c1a), SkBits2Float(0xc29b6b86), SkBits2Float(0x423f3295), SkBits2Float(0xc287b573));
5966path.lineTo(SkBits2Float(0x424f7bec), SkBits2Float(0xc281970f));
5967path.lineTo(SkBits2Float(0x4215fd0e), SkBits2Float(0xc23b5bf1));
5968path.cubicTo(SkBits2Float(0x421227cb), SkBits2Float(0xc23e6d7a), SkBits2Float(0x420e3aa9), SkBits2Float(0xc24160b8), SkBits2Float(0x420a3713), SkBits2Float(0xc2443498));
5969path.lineTo(SkBits2Float(0x420a3712), SkBits2Float(0xc2443499));
5970path.cubicTo(SkBits2Float(0x41c3852b), SkBits2Float(0xc260b421), SkBits2Float(0x4145f08c), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
5971path.close();
5972
5973 SkPath path1(path);
5974 path.reset();
5975 path.setFillType((SkPathFillType) 0);
5976path.moveTo(SkBits2Float(0x424f7bed), SkBits2Float(0xc281970f));
5977path.cubicTo(SkBits2Float(0x42939bdb), SkBits2Float(0xc23cf22a), SkBits2Float(0x42aabb70), SkBits2Float(0xc19e30f8), SkBits2Float(0x42a530dd), SkBits2Float(0x4102f5b1));
5978path.lineTo(SkBits2Float(0x426ed486), SkBits2Float(0x40bd56e4));
5979path.cubicTo(SkBits2Float(0x4276d778), SkBits2Float(0xc164b5d6), SkBits2Float(0x4255690c), SkBits2Float(0xc2089663), SkBits2Float(0x4215fd0d), SkBits2Float(0xc23b5bf2));
5980path.lineTo(SkBits2Float(0x424f7bed), SkBits2Float(0xc281970f));
5981path.close();
5982
5983 SkPath path2(path);
5984 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5985}

◆ battleOp219()

static void battleOp219 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5988 of file PathOpsBattles.cpp.

5988 {
5989 SkPath path;
5990 path.setFillType((SkPathFillType) 0);
5991path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5992path.cubicTo(SkBits2Float(0x4198fc97), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4216a3e3), SkBits2Float(0xc298caff), SkBits2Float(0x4251e7a7), SkBits2Float(0xc2809c9b));
5993path.lineTo(SkBits2Float(0x4217bd0d), SkBits2Float(0xc239f1d8));
5994path.cubicTo(SkBits2Float(0x41d9cb04), SkBits2Float(0xc25ce7ce), SkBits2Float(0x415d2f7f), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
5995path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
5996path.close();
5997
5998 SkPath path1(path);
5999 path.reset();
6000 path.setFillType((SkPathFillType) 0);
6001path.moveTo(SkBits2Float(0x4251e7a7), SkBits2Float(0xc2809c9c));
6002path.cubicTo(SkBits2Float(0x4257c623), SkBits2Float(0xc27c6f1e), SkBits2Float(0x425d7a38), SkBits2Float(0xc27771f7), SkBits2Float(0x42630157), SkBits2Float(0xc27243fd));
6003path.lineTo(SkBits2Float(0x422419a4), SkBits2Float(0xc22f21bb));
6004path.cubicTo(SkBits2Float(0x42201aab), SkBits2Float(0xc232e046), SkBits2Float(0x421bfb30), SkBits2Float(0xc2367b84), SkBits2Float(0x4217bd0d), SkBits2Float(0xc239f1d8));
6005path.lineTo(SkBits2Float(0x4251e7a7), SkBits2Float(0xc2809c9c));
6006path.close();
6007
6008 SkPath path2(path);
6009 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6010}

◆ battleOp2193()

static void battleOp2193 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10150 of file PathOpsBattles.cpp.

10150 {
10151 SkPath path;
10152 path.setFillType((SkPathFillType) 0);
10153path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10154path.cubicTo(SkBits2Float(0x3e3881bc), SkBits2Float(0xc2a60000), SkBits2Float(0x3eb88238), SkBits2Float(0xc2a5ffb3), SkBits2Float(0x3f0a6190), SkBits2Float(0xc2a5ff19));
10155path.lineTo(SkBits2Float(0x3ec8119b), SkBits2Float(0xc26ffeb2));
10156path.cubicTo(SkBits2Float(0x3e856151), SkBits2Float(0xc26fff91), SkBits2Float(0x3e0561b2), SkBits2Float(0xc2700000), SkBits2Float(0x3629eed0), SkBits2Float(0xc2700000));
10157path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10158path.close();
10159
10160 SkPath path1(path);
10161 path.reset();
10162 path.setFillType((SkPathFillType) 0);
10163path.moveTo(SkBits2Float(0x3f0a6183), SkBits2Float(0xc2a5ff19));
10164path.cubicTo(SkBits2Float(0x3f0efe46), SkBits2Float(0xc2a5ff0a), SkBits2Float(0x3f139b44), SkBits2Float(0xc2a5fef9), SkBits2Float(0x3f183842), SkBits2Float(0xc2a5fee9));
10165path.lineTo(SkBits2Float(0x3edc1349), SkBits2Float(0xc26ffe6c));
10166path.cubicTo(SkBits2Float(0x3ed567f5), SkBits2Float(0xc26ffe84), SkBits2Float(0x3ecebccf), SkBits2Float(0xc26ffe9c), SkBits2Float(0x3ec811a8), SkBits2Float(0xc26ffeb2));
10167path.lineTo(SkBits2Float(0x3f0a6183), SkBits2Float(0xc2a5ff19));
10168path.close();
10169
10170 SkPath path2(path);
10171 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10172}

◆ battleOp2194()

static void battleOp2194 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10175 of file PathOpsBattles.cpp.

10175 {
10176 SkPath path;
10177 path.setFillType((SkPathFillType) 1);
10178path.moveTo(SkBits2Float(0x3629eed0), SkBits2Float(0xc2700000));
10179path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10180path.cubicTo(SkBits2Float(0x3e3881ab), SkBits2Float(0xc2a60000), SkBits2Float(0x3eb88227), SkBits2Float(0xc2a5ffb3), SkBits2Float(0x3f0a6183), SkBits2Float(0xc2a5ff19));
10181path.lineTo(SkBits2Float(0x3f0a6190), SkBits2Float(0xc2a5ff19));
10182path.cubicTo(SkBits2Float(0x3f0efe4f), SkBits2Float(0xc2a5ff0a), SkBits2Float(0x3f139b48), SkBits2Float(0xc2a5fef9), SkBits2Float(0x3f183842), SkBits2Float(0xc2a5fee9));
10183path.lineTo(SkBits2Float(0x3edc1349), SkBits2Float(0xc26ffe6c));
10184path.cubicTo(SkBits2Float(0x3ed567f5), SkBits2Float(0xc26ffe84), SkBits2Float(0x3ecebccf), SkBits2Float(0xc26ffe9c), SkBits2Float(0x3ec811a8), SkBits2Float(0xc26ffeb2));
10185path.lineTo(SkBits2Float(0x3ec8119b), SkBits2Float(0xc26ffeb2));
10186path.cubicTo(SkBits2Float(0x3e856151), SkBits2Float(0xc26fff91), SkBits2Float(0x3e0561b2), SkBits2Float(0xc2700000), SkBits2Float(0x3629eed0), SkBits2Float(0xc2700000));
10187path.close();
10188
10189 SkPath path1(path);
10190 path.reset();
10191 path.setFillType((SkPathFillType) 0);
10192path.moveTo(SkBits2Float(0x3f183800), SkBits2Float(0xc2a5fee9));
10193path.cubicTo(SkBits2Float(0x3f62f7a2), SkBits2Float(0xc2a5fdd7), SkBits2Float(0x3f96db12), SkBits2Float(0xc2a5fbfa), SkBits2Float(0x3fbc3981), SkBits2Float(0xc2a5f954));
10194path.lineTo(SkBits2Float(0x3f8810cc), SkBits2Float(0xc26ff65b));
10195path.cubicTo(SkBits2Float(0x3f5a1a86), SkBits2Float(0xc26ffa2f), SkBits2Float(0x3f241256), SkBits2Float(0xc26ffcdf), SkBits2Float(0x3edc1312), SkBits2Float(0xc26ffe6c));
10196path.lineTo(SkBits2Float(0x3f183800), SkBits2Float(0xc2a5fee9));
10197path.close();
10198
10199 SkPath path2(path);
10200 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10201}

◆ battleOp22()

static void battleOp22 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 653 of file PathOpsBattles.cpp.

653 {
654 SkPath path;
655 path.setFillType((SkPathFillType) 0);
656path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
657path.cubicTo(SkBits2Float(0x407fb41a), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40ff895b), SkBits2Float(0xc2a56c4b), SkBits2Float(0x413f077c), SkBits2Float(0xc2a44609));
658path.lineTo(SkBits2Float(0x410a17ee), SkBits2Float(0xc26d8104));
659path.cubicTo(SkBits2Float(0x40b8b9ab), SkBits2Float(0xc26f2a74), SkBits2Float(0x4038d88b), SkBits2Float(0xc2700000), SkBits2Float(0x337fa8c0), SkBits2Float(0xc2700000));
660path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
661path.close();
662
663 SkPath path1(path);
664 path.reset();
665 path.setFillType((SkPathFillType) 0);
666path.moveTo(SkBits2Float(0x413f0780), SkBits2Float(0xc2a44609));
667path.cubicTo(SkBits2Float(0x41455a4a), SkBits2Float(0xc2a4289f), SkBits2Float(0x414bab5a), SkBits2Float(0xc2a409bf), SkBits2Float(0x4151fa92), SkBits2Float(0xc2a3e96b));
668path.lineTo(SkBits2Float(0x4117cabb), SkBits2Float(0xc26cfb1d));
669path.cubicTo(SkBits2Float(0x41133b1d), SkBits2Float(0xc26d29dc), SkBits2Float(0x410eaa27), SkBits2Float(0xc26d567f), SkBits2Float(0x410a17f1), SkBits2Float(0xc26d8105));
670path.lineTo(SkBits2Float(0x413f0780), SkBits2Float(0xc2a44609));
671path.close();
672
673 SkPath path2(path);
674 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
675}

◆ battleOp220()

static void battleOp220 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6013 of file PathOpsBattles.cpp.

6013 {
6014 SkPath path;
6015 path.setFillType((SkPathFillType) 1);
6016path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
6017path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6018path.cubicTo(SkBits2Float(0x4198fc97), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4216a3e3), SkBits2Float(0xc298caff), SkBits2Float(0x4251e7a7), SkBits2Float(0xc2809c9c));
6019path.cubicTo(SkBits2Float(0x4257c623), SkBits2Float(0xc27c6f1e), SkBits2Float(0x425d7a38), SkBits2Float(0xc27771f7), SkBits2Float(0x42630157), SkBits2Float(0xc27243fd));
6020path.lineTo(SkBits2Float(0x422419a4), SkBits2Float(0xc22f21bb));
6021path.cubicTo(SkBits2Float(0x42201aab), SkBits2Float(0xc232e046), SkBits2Float(0x421bfb30), SkBits2Float(0xc2367b84), SkBits2Float(0x4217bd0d), SkBits2Float(0xc239f1d8));
6022path.cubicTo(SkBits2Float(0x41d9cb04), SkBits2Float(0xc25ce7ce), SkBits2Float(0x415d2f7f), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
6023path.close();
6024
6025 SkPath path1(path);
6026 path.reset();
6027 path.setFillType((SkPathFillType) 0);
6028path.moveTo(SkBits2Float(0x42630157), SkBits2Float(0xc27243ff));
6029path.cubicTo(SkBits2Float(0x429f78af), SkBits2Float(0xc21c1e80), SkBits2Float(0x42b11918), SkBits2Float(0xc0cad7ee), SkBits2Float(0x429f0274), SkBits2Float(0x41bea8f4));
6030path.lineTo(SkBits2Float(0x4265e4b4), SkBits2Float(0x4189d394));
6031path.cubicTo(SkBits2Float(0x428005cc), SkBits2Float(0xc092a249), SkBits2Float(0x42668fa3), SkBits2Float(0xc1e1b6e5), SkBits2Float(0x422419a4), SkBits2Float(0xc22f21bb));
6032path.lineTo(SkBits2Float(0x42630157), SkBits2Float(0xc27243ff));
6033path.close();
6034
6035 SkPath path2(path);
6036 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6037}

◆ battleOp221()

static void battleOp221 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6040 of file PathOpsBattles.cpp.

6040 {
6041 SkPath path;
6042 path.setFillType((SkPathFillType) 0);
6043path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6044path.cubicTo(SkBits2Float(0x41ae0130), SkBits2Float(0xc2a5ffff), SkBits2Float(0x422a8737), SkBits2Float(0xc294ec91), SkBits2Float(0x42689b67), SkBits2Float(0xc26ce46c));
6045path.lineTo(SkBits2Float(0x42282651), SkBits2Float(0xc22b3f58));
6046path.cubicTo(SkBits2Float(0x41f68bfb), SkBits2Float(0xc2574fdc), SkBits2Float(0x417b92b3), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
6047path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6048path.close();
6049
6050 SkPath path1(path);
6051 path.reset();
6052 path.setFillType((SkPathFillType) 0);
6053path.moveTo(SkBits2Float(0x42689b68), SkBits2Float(0xc26ce46d));
6054path.cubicTo(SkBits2Float(0x426ebcd2), SkBits2Float(0xc266df67), SkBits2Float(0x4274a1d2), SkBits2Float(0xc2609e09), SkBits2Float(0x427a4701), SkBits2Float(0xc25a23f2));
6055path.lineTo(SkBits2Float(0x4234ec64), SkBits2Float(0xc21db11e));
6056path.cubicTo(SkBits2Float(0x4230d7ae), SkBits2Float(0xc2225fbc), SkBits2Float(0x422c94d6), SkBits2Float(0xc226e55a), SkBits2Float(0x42282652), SkBits2Float(0xc22b3f58));
6057path.lineTo(SkBits2Float(0x42689b68), SkBits2Float(0xc26ce46d));
6058path.close();
6059
6060 SkPath path2(path);
6061 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6062}

◆ battleOp222()

static void battleOp222 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6065 of file PathOpsBattles.cpp.

6065 {
6066 SkPath path;
6067 path.setFillType((SkPathFillType) 1);
6068path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6069path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6070path.cubicTo(SkBits2Float(0x41ae0130), SkBits2Float(0xc2a5ffff), SkBits2Float(0x422a8737), SkBits2Float(0xc294ec91), SkBits2Float(0x42689b68), SkBits2Float(0xc26ce46d));
6071path.cubicTo(SkBits2Float(0x426ebcd2), SkBits2Float(0xc266df67), SkBits2Float(0x4274a1d2), SkBits2Float(0xc2609e09), SkBits2Float(0x427a4701), SkBits2Float(0xc25a23f2));
6072path.lineTo(SkBits2Float(0x4234ec64), SkBits2Float(0xc21db11e));
6073path.cubicTo(SkBits2Float(0x4230d7ae), SkBits2Float(0xc2225fbc), SkBits2Float(0x422c94d6), SkBits2Float(0xc226e55a), SkBits2Float(0x42282651), SkBits2Float(0xc22b3f58));
6074path.cubicTo(SkBits2Float(0x41f68bfb), SkBits2Float(0xc2574fdc), SkBits2Float(0x417b92b3), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6075path.close();
6076
6077 SkPath path1(path);
6078 path.reset();
6079 path.setFillType((SkPathFillType) 0);
6080path.moveTo(SkBits2Float(0x427a4702), SkBits2Float(0xc25a23f2));
6081path.cubicTo(SkBits2Float(0x42ac7185), SkBits2Float(0xc1db2f83), SkBits2Float(0x42b35ed0), SkBits2Float(0x413e447a), SkBits2Float(0x428e4a3d), SkBits2Float(0x422afde8));
6082path.lineTo(SkBits2Float(0x424db871), SkBits2Float(0x41f73799));
6083path.cubicTo(SkBits2Float(0x4281aa54), SkBits2Float(0x41098afa), SkBits2Float(0x427950da), SkBits2Float(0xc19e728d), SkBits2Float(0x4234ec66), SkBits2Float(0xc21db120));
6084path.lineTo(SkBits2Float(0x427a4702), SkBits2Float(0xc25a23f2));
6085path.close();
6086
6087 SkPath path2(path);
6088 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6089}

◆ battleOp223()

static void battleOp223 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6092 of file PathOpsBattles.cpp.

6092 {
6093 SkPath path;
6094 path.setFillType((SkPathFillType) 0);
6095path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6096path.cubicTo(SkBits2Float(0x41c50a2c), SkBits2Float(0xc2a60000), SkBits2Float(0x423ff37f), SkBits2Float(0xc2901f4e), SkBits2Float(0x427f077c), SkBits2Float(0xc25490c6));
6097path.lineTo(SkBits2Float(0x42385bc5), SkBits2Float(0xc219a96d));
6098path.cubicTo(SkBits2Float(0x420ac287), SkBits2Float(0xc2505e9c), SkBits2Float(0x418e7039), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6099path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6100path.close();
6101
6102 SkPath path1(path);
6103 path.reset();
6104 path.setFillType((SkPathFillType) 0);
6105path.moveTo(SkBits2Float(0x427f077b), SkBits2Float(0xc25490c6));
6106path.cubicTo(SkBits2Float(0x42829e52), SkBits2Float(0xc24d1e28), SkBits2Float(0x42858ec1), SkBits2Float(0xc24566d6), SkBits2Float(0x428852e3), SkBits2Float(0xc23d7081));
6107path.lineTo(SkBits2Float(0x42451839), SkBits2Float(0xc208f1b7));
6108path.cubicTo(SkBits2Float(0x4241186a), SkBits2Float(0xc20eb335), SkBits2Float(0x423cd88e), SkBits2Float(0xc2144725), SkBits2Float(0x42385bc4), SkBits2Float(0xc219a96c));
6109path.lineTo(SkBits2Float(0x427f077b), SkBits2Float(0xc25490c6));
6110path.close();
6111
6112 SkPath path2(path);
6113 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6114}

◆ battleOp224()

static void battleOp224 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6117 of file PathOpsBattles.cpp.

6117 {
6118 SkPath path;
6119 path.setFillType((SkPathFillType) 1);
6120path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6121path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6122path.cubicTo(SkBits2Float(0x41c50a2c), SkBits2Float(0xc2a60000), SkBits2Float(0x423ff37f), SkBits2Float(0xc2901f4e), SkBits2Float(0x427f077c), SkBits2Float(0xc25490c6));
6123path.lineTo(SkBits2Float(0x428852e3), SkBits2Float(0xc23d7081));
6124path.lineTo(SkBits2Float(0x42451839), SkBits2Float(0xc208f1b7));
6125path.cubicTo(SkBits2Float(0x4241186a), SkBits2Float(0xc20eb335), SkBits2Float(0x423cd88e), SkBits2Float(0xc2144725), SkBits2Float(0x42385bc4), SkBits2Float(0xc219a96c));
6126path.lineTo(SkBits2Float(0x42385bc5), SkBits2Float(0xc219a96d));
6127path.cubicTo(SkBits2Float(0x420ac287), SkBits2Float(0xc2505e9c), SkBits2Float(0x418e7039), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6128path.close();
6129
6130 SkPath path1(path);
6131 path.reset();
6132 path.setFillType((SkPathFillType) 0);
6133path.moveTo(SkBits2Float(0x428852e3), SkBits2Float(0xc23d7081));
6134path.cubicTo(SkBits2Float(0x42b71f8a), SkBits2Float(0xc15aea65), SkBits2Float(0x42adb77f), SkBits2Float(0x42002593), SkBits2Float(0x42645e8b), SkBits2Float(0x4270faee));
6135path.lineTo(SkBits2Float(0x42251616), SkBits2Float(0x422e33d9));
6136path.cubicTo(SkBits2Float(0x427b2825), SkBits2Float(0x41b945be), SkBits2Float(0x428460d4), SkBits2Float(0xc11e4099), SkBits2Float(0x4245183a), SkBits2Float(0xc208f1b8));
6137path.lineTo(SkBits2Float(0x428852e3), SkBits2Float(0xc23d7081));
6138path.close();
6139
6140 SkPath path2(path);
6141 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6142}

◆ battleOp225()

static void battleOp225 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6145 of file PathOpsBattles.cpp.

6145 {
6146 SkPath path;
6147 path.setFillType((SkPathFillType) 0);
6148path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6149path.cubicTo(SkBits2Float(0x41d8749b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4251a993), SkBits2Float(0xc28b9f9f), SkBits2Float(0x4287e789), SkBits2Float(0xc23ea40d));
6150path.lineTo(SkBits2Float(0x42447d05), SkBits2Float(0xc209d00a));
6151path.cubicTo(SkBits2Float(0x4217902d), SkBits2Float(0xc249dd89), SkBits2Float(0x419c7951), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
6152path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6153path.close();
6154
6155 SkPath path1(path);
6156 path.reset();
6157 path.setFillType((SkPathFillType) 0);
6158path.moveTo(SkBits2Float(0x4287e78a), SkBits2Float(0xc23ea40e));
6159path.cubicTo(SkBits2Float(0x428af3dc), SkBits2Float(0xc235f2f3), SkBits2Float(0x428dca5e), SkBits2Float(0xc22cf844), SkBits2Float(0x4290688d), SkBits2Float(0xc223bbef));
6160path.lineTo(SkBits2Float(0x4250c881), SkBits2Float(0xc1ecb95a));
6161path.cubicTo(SkBits2Float(0x424cff91), SkBits2Float(0xc1fa13ac), SkBits2Float(0x4248e532), SkBits2Float(0xc2038788), SkBits2Float(0x42447d06), SkBits2Float(0xc209d00a));
6162path.lineTo(SkBits2Float(0x4287e78a), SkBits2Float(0xc23ea40e));
6163path.close();
6164
6165 SkPath path2(path);
6166 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6167}

◆ battleOp226()

static void battleOp226 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6170 of file PathOpsBattles.cpp.

6170 {
6171 SkPath path;
6172 path.setFillType((SkPathFillType) 1);
6173path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6174path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6175path.cubicTo(SkBits2Float(0x41d8749b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4251a993), SkBits2Float(0xc28b9f9f), SkBits2Float(0x4287e78a), SkBits2Float(0xc23ea40e));
6176path.cubicTo(SkBits2Float(0x428af3dc), SkBits2Float(0xc235f2f3), SkBits2Float(0x428dca5e), SkBits2Float(0xc22cf844), SkBits2Float(0x4290688d), SkBits2Float(0xc223bbef));
6177path.lineTo(SkBits2Float(0x4250c881), SkBits2Float(0xc1ecb95a));
6178path.cubicTo(SkBits2Float(0x424cff91), SkBits2Float(0xc1fa13ac), SkBits2Float(0x4248e532), SkBits2Float(0xc2038788), SkBits2Float(0x42447d05), SkBits2Float(0xc209d00a));
6179path.cubicTo(SkBits2Float(0x4217902d), SkBits2Float(0xc249dd89), SkBits2Float(0x419c7951), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6180path.close();
6181
6182 SkPath path1(path);
6183 path.reset();
6184 path.setFillType((SkPathFillType) 0);
6185path.moveTo(SkBits2Float(0x4290688d), SkBits2Float(0xc223bbef));
6186path.cubicTo(SkBits2Float(0x42bd187d), SkBits2Float(0xbfc2a74a), SkBits2Float(0x42a250ed), SkBits2Float(0x42421cbf), SkBits2Float(0x42287a28), SkBits2Float(0x428f09b7));
6187path.lineTo(SkBits2Float(0x41f394da), SkBits2Float(0x424ecd48));
6188path.cubicTo(SkBits2Float(0x426aac8a), SkBits2Float(0x420c527b), SkBits2Float(0x4288b219), SkBits2Float(0xbf8cb68f), SkBits2Float(0x4250c882), SkBits2Float(0xc1ecb95c));
6189path.lineTo(SkBits2Float(0x4290688d), SkBits2Float(0xc223bbef));
6190path.close();
6191
6192 SkPath path2(path);
6193 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6194}

◆ battleOp227()

static void battleOp227 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6197 of file PathOpsBattles.cpp.

6197 {
6198 SkPath path;
6199 path.setFillType((SkPathFillType) 0);
6200path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6201path.cubicTo(SkBits2Float(0x41f1efaa), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42685cb5), SkBits2Float(0xc2851a3e), SkBits2Float(0x429160d2), SkBits2Float(0xc22043b6));
6202path.lineTo(SkBits2Float(0x42522f73), SkBits2Float(0xc1e7b52d));
6203path.cubicTo(SkBits2Float(0x4227f8ff), SkBits2Float(0xc2406ff8), SkBits2Float(0x41aee4c7), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
6204path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6205path.close();
6206
6207 SkPath path1(path);
6208 path.reset();
6209 path.setFillType((SkPathFillType) 0);
6210path.moveTo(SkBits2Float(0x429160d2), SkBits2Float(0xc22043b7));
6211path.cubicTo(SkBits2Float(0x42943aa0), SkBits2Float(0xc215eba6), SkBits2Float(0x4296cd42), SkBits2Float(0xc20b4794), SkBits2Float(0x429915e6), SkBits2Float(0xc200631e));
6212path.lineTo(SkBits2Float(0x425d5418), SkBits2Float(0xc1b99eb9));
6213path.cubicTo(SkBits2Float(0x425a06d4), SkBits2Float(0xc1c95e3a), SkBits2Float(0x42564e98), SkBits2Float(0xc1d8c0a6), SkBits2Float(0x42522f74), SkBits2Float(0xc1e7b52e));
6214path.lineTo(SkBits2Float(0x429160d2), SkBits2Float(0xc22043b7));
6215path.close();
6216
6217 SkPath path2(path);
6218 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6219}

◆ battleOp228()

static void battleOp228 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6222 of file PathOpsBattles.cpp.

6222 {
6223 SkPath path;
6224 path.setFillType((SkPathFillType) 1);
6225path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6226path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6227path.cubicTo(SkBits2Float(0x41f1efa9), SkBits2Float(0xc2a60000), SkBits2Float(0x42685cb5), SkBits2Float(0xc2851a3e), SkBits2Float(0x429160d2), SkBits2Float(0xc22043b7));
6228path.lineTo(SkBits2Float(0x429160d2), SkBits2Float(0xc22043b6));
6229path.cubicTo(SkBits2Float(0x42943aa0), SkBits2Float(0xc215eba5), SkBits2Float(0x4296cd42), SkBits2Float(0xc20b4794), SkBits2Float(0x429915e6), SkBits2Float(0xc200631e));
6230path.lineTo(SkBits2Float(0x425d5418), SkBits2Float(0xc1b99eb9));
6231path.cubicTo(SkBits2Float(0x425a06d4), SkBits2Float(0xc1c95e3a), SkBits2Float(0x42564e98), SkBits2Float(0xc1d8c0a6), SkBits2Float(0x42522f74), SkBits2Float(0xc1e7b52e));
6232path.lineTo(SkBits2Float(0x42522f73), SkBits2Float(0xc1e7b52d));
6233path.cubicTo(SkBits2Float(0x4227f8ff), SkBits2Float(0xc2406ff8), SkBits2Float(0x41aee4c7), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6234path.close();
6235
6236 SkPath path1(path);
6237 path.reset();
6238 path.setFillType((SkPathFillType) 0);
6239path.moveTo(SkBits2Float(0x429915e6), SkBits2Float(0xc200631e));
6240path.cubicTo(SkBits2Float(0x42abe101), SkBits2Float(0xc11b0235), SkBits2Float(0x42aa16bb), SkBits2Float(0x417b685c), SkBits2Float(0x42942fff), SkBits2Float(0x42159e77));
6241path.cubicTo(SkBits2Float(0x427c9284), SkBits2Float(0x426c62d8), SkBits2Float(0x422cf27d), SkBits2Float(0x4295ccdb), SkBits2Float(0x419d039e), SkBits2Float(0x42a14aca));
6242path.lineTo(SkBits2Float(0x4163022c), SkBits2Float(0x42693188));
6243path.cubicTo(SkBits2Float(0x41fa0b56), SkBits2Float(0x42589424), SkBits2Float(0x4236951c), SkBits2Float(0x422ae1ad), SkBits2Float(0x42563f3c), SkBits2Float(0x41d85112));
6244path.cubicTo(SkBits2Float(0x4275e95c), SkBits2Float(0x4135bd94), SkBits2Float(0x42787fea), SkBits2Float(0xc0e01be1), SkBits2Float(0x425d5419), SkBits2Float(0xc1b99eba));
6245path.lineTo(SkBits2Float(0x429915e6), SkBits2Float(0xc200631e));
6246path.close();
6247
6248 SkPath path2(path);
6249 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6250}

◆ battleOp229()

static void battleOp229 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6253 of file PathOpsBattles.cpp.

6253 {
6254 SkPath path;
6255 path.setFillType((SkPathFillType) 0);
6256path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6257path.cubicTo(SkBits2Float(0x4206c976), SkBits2Float(0xc2a60000), SkBits2Float(0x42801937), SkBits2Float(0xc27a823c), SkBits2Float(0x4299a0d7), SkBits2Float(0xc1fb88d1));
6258path.lineTo(SkBits2Float(0x425e1cfa), SkBits2Float(0xc1b5d505));
6259path.cubicTo(SkBits2Float(0x423933e1), SkBits2Float(0xc2351735), SkBits2Float(0x41c2df6b), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
6260path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6261path.close();
6262
6263 SkPath path1(path);
6264 path.reset();
6265 path.setFillType((SkPathFillType) 0);
6266path.moveTo(SkBits2Float(0x4299a0d8), SkBits2Float(0xc1fb88d0));
6267path.cubicTo(SkBits2Float(0x429c1b73), SkBits2Float(0xc1e34f53), SkBits2Float(0x429e39d2), SkBits2Float(0xc1ca8528), SkBits2Float(0x429ff920), SkBits2Float(0xc1b14b8c));
6268path.lineTo(SkBits2Float(0x42674955), SkBits2Float(0xc1802a45));
6269path.cubicTo(SkBits2Float(0x4264c2a3), SkBits2Float(0xc192666d), SkBits2Float(0x4261b27b), SkBits2Float(0xc1a45204), SkBits2Float(0x425e1cfb), SkBits2Float(0xc1b5d506));
6270path.lineTo(SkBits2Float(0x4299a0d8), SkBits2Float(0xc1fb88d0));
6271path.close();
6272
6273 SkPath path2(path);
6274 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6275}

◆ battleOp23()

static void battleOp23 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 678 of file PathOpsBattles.cpp.

678 {
679 SkPath path;
680 path.setFillType((SkPathFillType) 1);
681path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
682path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
683path.cubicTo(SkBits2Float(0x407fb41a), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40ff895b), SkBits2Float(0xc2a56c4b), SkBits2Float(0x413f0780), SkBits2Float(0xc2a44609));
684path.cubicTo(SkBits2Float(0x41455a4a), SkBits2Float(0xc2a4289f), SkBits2Float(0x414bab5a), SkBits2Float(0xc2a409bf), SkBits2Float(0x4151fa92), SkBits2Float(0xc2a3e96b));
685path.lineTo(SkBits2Float(0x4117cabb), SkBits2Float(0xc26cfb1d));
686path.cubicTo(SkBits2Float(0x41133b1d), SkBits2Float(0xc26d29dc), SkBits2Float(0x410eaa27), SkBits2Float(0xc26d567f), SkBits2Float(0x410a17ee), SkBits2Float(0xc26d8104));
687path.cubicTo(SkBits2Float(0x40b8b9ab), SkBits2Float(0xc26f2a74), SkBits2Float(0x4038d88b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
688path.close();
689
690 SkPath path1(path);
691 path.reset();
692 path.setFillType((SkPathFillType) 0);
693path.moveTo(SkBits2Float(0x4151fa93), SkBits2Float(0xc2a3e96b));
694path.cubicTo(SkBits2Float(0x419c2b7d), SkBits2Float(0xc2a1dce5), SkBits2Float(0x41ce36f8), SkBits2Float(0xc29e52a6), SkBits2Float(0x41fe1a0a), SkBits2Float(0xc2995d2e));
695path.lineTo(SkBits2Float(0x41b7b024), SkBits2Float(0xc25dbb29));
696path.cubicTo(SkBits2Float(0x41951228), SkBits2Float(0xc264e68b), SkBits2Float(0x4161c9b2), SkBits2Float(0xc26a04c8), SkBits2Float(0x4117cabf), SkBits2Float(0xc26cfb1e));
697path.lineTo(SkBits2Float(0x4151fa93), SkBits2Float(0xc2a3e96b));
698path.close();
699
700 SkPath path2(path);
701 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
702}

◆ battleOp230()

static void battleOp230 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6278 of file PathOpsBattles.cpp.

6278 {
6279 SkPath path;
6280 path.setFillType((SkPathFillType) 1);
6281path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6282path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6283path.cubicTo(SkBits2Float(0x4206c976), SkBits2Float(0xc2a60000), SkBits2Float(0x42801937), SkBits2Float(0xc27a823c), SkBits2Float(0x4299a0d8), SkBits2Float(0xc1fb88d0));
6284path.cubicTo(SkBits2Float(0x429c1b73), SkBits2Float(0xc1e34f53), SkBits2Float(0x429e39d2), SkBits2Float(0xc1ca8528), SkBits2Float(0x429ff920), SkBits2Float(0xc1b14b8c));
6285path.lineTo(SkBits2Float(0x42674955), SkBits2Float(0xc1802a45));
6286path.cubicTo(SkBits2Float(0x4264c2a3), SkBits2Float(0xc192666d), SkBits2Float(0x4261b27b), SkBits2Float(0xc1a45204), SkBits2Float(0x425e1cfa), SkBits2Float(0xc1b5d505));
6287path.cubicTo(SkBits2Float(0x423933e1), SkBits2Float(0xc2351735), SkBits2Float(0x41c2df6b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6288path.close();
6289
6290 SkPath path1(path);
6291 path.reset();
6292 path.setFillType((SkPathFillType) 0);
6293path.moveTo(SkBits2Float(0x429ff91f), SkBits2Float(0xc1b14b8a));
6294path.cubicTo(SkBits2Float(0x42ae673b), SkBits2Float(0x40783c41), SkBits2Float(0x42a293c2), SkBits2Float(0x41fe6960), SkBits2Float(0x4280464e), SkBits2Float(0x4252ba7b));
6295path.cubicTo(SkBits2Float(0x423bf1b3), SkBits2Float(0x42932023), SkBits2Float(0x41a5f32c), SkBits2Float(0x42a99309), SkBits2Float(0xc0c67989), SkBits2Float(0x42a5892f));
6296path.lineTo(SkBits2Float(0xc08f79c7), SkBits2Float(0x426f5437));
6297path.cubicTo(SkBits2Float(0x416fed74), SkBits2Float(0x42752af2), SkBits2Float(0x4207dcfc), SkBits2Float(0x4254b62d), SkBits2Float(0x42397512), SkBits2Float(0x42185575));
6298path.cubicTo(SkBits2Float(0x426b0d26), SkBits2Float(0x41b7e97d), SkBits2Float(0x427c2639), SkBits2Float(0x40337286), SkBits2Float(0x42674956), SkBits2Float(0xc1802a46));
6299path.lineTo(SkBits2Float(0x429ff91f), SkBits2Float(0xc1b14b8a));
6300path.close();
6301
6302 SkPath path2(path);
6303 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6304}

◆ battleOp231()

static void battleOp231 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6307 of file PathOpsBattles.cpp.

6307 {
6308 SkPath path;
6309 path.setFillType((SkPathFillType) 0);
6310path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6311path.cubicTo(SkBits2Float(0x421472e7), SkBits2Float(0xc2a5ffff), SkBits2Float(0x428b6da4), SkBits2Float(0xc26973d7), SkBits2Float(0x429fb179), SkBits2Float(0xc1b54986));
6312path.lineTo(SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
6313path.cubicTo(SkBits2Float(0x42499544), SkBits2Float(0xc228c2c8), SkBits2Float(0x41d69ff6), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
6314path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6315path.close();
6316
6317 SkPath path1(path);
6318 path.reset();
6319 path.setFillType((SkPathFillType) 0);
6320path.moveTo(SkBits2Float(0x429fb179), SkBits2Float(0xc1b54988));
6321path.cubicTo(SkBits2Float(0x42a1a632), SkBits2Float(0xc199b837), SkBits2Float(0x42a3282f), SkBits2Float(0xc17b594e), SkBits2Float(0x42a43501), SkBits2Float(0xc142a7ba));
6322path.lineTo(SkBits2Float(0x426d6865), SkBits2Float(0xc10cb6f0));
6323path.cubicTo(SkBits2Float(0x426be3bc), SkBits2Float(0xc135b2ae), SkBits2Float(0x4269b5af), SkBits2Float(0xc15e3ec8), SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
6324path.lineTo(SkBits2Float(0x429fb179), SkBits2Float(0xc1b54988));
6325path.close();
6326
6327 SkPath path2(path);
6328 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6329}

◆ battleOp232()

static void battleOp232 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6332 of file PathOpsBattles.cpp.

6332 {
6333 SkPath path;
6334 path.setFillType((SkPathFillType) 1);
6335path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6336path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6337path.cubicTo(SkBits2Float(0x421472e7), SkBits2Float(0xc2a60000), SkBits2Float(0x428b6da4), SkBits2Float(0xc26973d8), SkBits2Float(0x429fb179), SkBits2Float(0xc1b54988));
6338path.lineTo(SkBits2Float(0x429fb179), SkBits2Float(0xc1b54986));
6339path.cubicTo(SkBits2Float(0x42a1a632), SkBits2Float(0xc199b836), SkBits2Float(0x42a3282f), SkBits2Float(0xc17b594d), SkBits2Float(0x42a43501), SkBits2Float(0xc142a7ba));
6340path.lineTo(SkBits2Float(0x426d6865), SkBits2Float(0xc10cb6f0));
6341path.cubicTo(SkBits2Float(0x426be3bc), SkBits2Float(0xc135b2ae), SkBits2Float(0x4269b5af), SkBits2Float(0xc15e3ec8), SkBits2Float(0x4266e1be), SkBits2Float(0xc1830d0f));
6342path.cubicTo(SkBits2Float(0x42499544), SkBits2Float(0xc228c2c8), SkBits2Float(0x41d69ff6), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6343path.close();
6344
6345 SkPath path1(path);
6346 path.reset();
6347 path.setFillType((SkPathFillType) 0);
6348path.moveTo(SkBits2Float(0x42a43502), SkBits2Float(0xc142a7bb));
6349path.cubicTo(SkBits2Float(0x42ace9b0), SkBits2Float(0x4189ae79), SkBits2Float(0x429590d6), SkBits2Float(0x423ab1c1), SkBits2Float(0x424df762), SkBits2Float(0x428231a6));
6350path.cubicTo(SkBits2Float(0x41e19a31), SkBits2Float(0x42a70a69), SkBits2Float(0xc04a3289), SkBits2Float(0x42b03133), SkBits2Float(0xc1f5f36e), SkBits2Float(0x429a3139));
6351path.lineTo(SkBits2Float(0xc1b1cbb9), SkBits2Float(0x425eedb9));
6352path.cubicTo(SkBits2Float(0xc0122aac), SkBits2Float(0x427ebc5a), SkBits2Float(0x41a31606), SkBits2Float(0x42718130), SkBits2Float(0x4214e430), SkBits2Float(0x423c3b73));
6353path.cubicTo(SkBits2Float(0x42583d5c), SkBits2Float(0x4206f5b6), SkBits2Float(0x4279fe97), SkBits2Float(0x41470ec8), SkBits2Float(0x426d6866), SkBits2Float(0xc10cb6eb));
6354path.lineTo(SkBits2Float(0x42a43502), SkBits2Float(0xc142a7bb));
6355path.close();
6356
6357 SkPath path2(path);
6358 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6359}

◆ battleOp233()

static void battleOp233 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6362 of file PathOpsBattles.cpp.

6362 {
6363 SkPath path;
6364 path.setFillType((SkPathFillType) 0);
6365path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6366path.cubicTo(SkBits2Float(0x4220aa02), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42952310), SkBits2Float(0xc258f48d), SkBits2Float(0x42a35f68), SkBits2Float(0xc16b5614));
6367path.lineTo(SkBits2Float(0x426c3395), SkBits2Float(0xc12a1f61));
6368path.cubicTo(SkBits2Float(0x42579ea8), SkBits2Float(0xc21cd5ce), SkBits2Float(0x41e84916), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6369path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6370path.close();
6371
6372 SkPath path1(path);
6373 path.reset();
6374 path.setFillType((SkPathFillType) 0);
6375path.moveTo(SkBits2Float(0x42a35f69), SkBits2Float(0xc16b5613));
6376path.cubicTo(SkBits2Float(0x42a4bd24), SkBits2Float(0xc12ea3c2), SkBits2Float(0x42a59325), SkBits2Float(0xc0e282d6), SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
6377path.lineTo(SkBits2Float(0x426fd18d), SkBits2Float(0xc0154a48));
6378path.cubicTo(SkBits2Float(0x426f62a1), SkBits2Float(0xc0a3be33), SkBits2Float(0x426e2d39), SkBits2Float(0xc0fc7dbb), SkBits2Float(0x426c3397), SkBits2Float(0xc12a1f63));
6379path.lineTo(SkBits2Float(0x42a35f69), SkBits2Float(0xc16b5613));
6380path.close();
6381
6382 SkPath path2(path);
6383 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6384}

◆ battleOp234()

static void battleOp234 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6387 of file PathOpsBattles.cpp.

6387 {
6388 SkPath path;
6389 path.setFillType((SkPathFillType) 1);
6390path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6391path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6392path.cubicTo(SkBits2Float(0x4220aa02), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42952310), SkBits2Float(0xc258f48d), SkBits2Float(0x42a35f69), SkBits2Float(0xc16b5613));
6393path.cubicTo(SkBits2Float(0x42a4bd24), SkBits2Float(0xc12ea3c2), SkBits2Float(0x42a59325), SkBits2Float(0xc0e282d6), SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
6394path.lineTo(SkBits2Float(0x426fd18d), SkBits2Float(0xc0154a48));
6395path.cubicTo(SkBits2Float(0x426f62a1), SkBits2Float(0xc0a3be33), SkBits2Float(0x426e2d39), SkBits2Float(0xc0fc7dbb), SkBits2Float(0x426c3397), SkBits2Float(0xc12a1f63));
6396path.lineTo(SkBits2Float(0x426c3395), SkBits2Float(0xc12a1f61));
6397path.cubicTo(SkBits2Float(0x42579ea8), SkBits2Float(0xc21cd5ce), SkBits2Float(0x41e84916), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6398path.close();
6399
6400 SkPath path1(path);
6401 path.reset();
6402 path.setFillType((SkPathFillType) 0);
6403path.moveTo(SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
6404path.cubicTo(SkBits2Float(0x42a85e4f), SkBits2Float(0x41e6959e), SkBits2Float(0x4285b4e3), SkBits2Float(0x426ae44f), SkBits2Float(0x4219b105), SkBits2Float(0x42932450));
6405path.cubicTo(SkBits2Float(0x411fe111), SkBits2Float(0x42b0d679), SkBits2Float(0xc1c3966b), SkBits2Float(0x42ab1d42), SkBits2Float(0xc2482755), SkBits2Float(0x428470e8));
6406path.lineTo(SkBits2Float(0xc210b07c), SkBits2Float(0x423f7b24));
6407path.cubicTo(SkBits2Float(0xc18d6382), SkBits2Float(0x427764e8), SkBits2Float(0x40e72680), SkBits2Float(0x427fab4e), SkBits2Float(0x41de345e), SkBits2Float(0x4254bc3b));
6408path.cubicTo(SkBits2Float(0x42414f8e), SkBits2Float(0x4229cd28), SkBits2Float(0x42736c9d), SkBits2Float(0x41a6b008), SkBits2Float(0x426fd18e), SkBits2Float(0xc0154a3f));
6409path.lineTo(SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
6410path.close();
6411
6412 SkPath path2(path);
6413 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6414}

◆ battleOp235()

static void battleOp235 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6417 of file PathOpsBattles.cpp.

6417 {
6418 SkPath path;
6419 path.setFillType((SkPathFillType) 0);
6420path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6421path.cubicTo(SkBits2Float(0x422e5e2d), SkBits2Float(0xc2a5ffff), SkBits2Float(0x429f82f2), SkBits2Float(0xc2451c35), SkBits2Float(0x42a59867), SkBits2Float(0xc0b956c5));
6422path.lineTo(SkBits2Float(0x426f6a3b), SkBits2Float(0xc085fae3));
6423path.cubicTo(SkBits2Float(0x42669e7e), SkBits2Float(0xc20e7d42), SkBits2Float(0x41fc1920), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6424path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6425path.close();
6426
6427 SkPath path1(path);
6428 path.reset();
6429 path.setFillType((SkPathFillType) 0);
6430path.moveTo(SkBits2Float(0x42a59868), SkBits2Float(0xc0b956ca));
6431path.cubicTo(SkBits2Float(0x42a62cd8), SkBits2Float(0xbfd2dd07), SkBits2Float(0x42a621be), SkBits2Float(0x4020d557), SkBits2Float(0x42a57734), SkBits2Float(0x40d4ef9c));
6432path.lineTo(SkBits2Float(0x426f3a3b), SkBits2Float(0x4099edfc));
6433path.cubicTo(SkBits2Float(0x427030cb), SkBits2Float(0x3fe887ba), SkBits2Float(0x427040d6), SkBits2Float(0xbf986e77), SkBits2Float(0x426f6a3b), SkBits2Float(0xc085fae4));
6434path.lineTo(SkBits2Float(0x42a59868), SkBits2Float(0xc0b956ca));
6435path.close();
6436
6437 SkPath path2(path);
6438 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6439}

◆ battleOp236()

static void battleOp236 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6442 of file PathOpsBattles.cpp.

6442 {
6443 SkPath path;
6444 path.setFillType((SkPathFillType) 1);
6445path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6446path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6447path.cubicTo(SkBits2Float(0x422e5e2d), SkBits2Float(0xc2a5ffff), SkBits2Float(0x429f82f2), SkBits2Float(0xc2451c35), SkBits2Float(0x42a59868), SkBits2Float(0xc0b956ca));
6448path.cubicTo(SkBits2Float(0x42a62cd8), SkBits2Float(0xbfd2dd07), SkBits2Float(0x42a621be), SkBits2Float(0x4020d557), SkBits2Float(0x42a57734), SkBits2Float(0x40d4ef9c));
6449path.lineTo(SkBits2Float(0x426f3a3b), SkBits2Float(0x4099edfc));
6450path.cubicTo(SkBits2Float(0x427030cb), SkBits2Float(0x3fe887bb), SkBits2Float(0x427040d6), SkBits2Float(0xbf986e74), SkBits2Float(0x426f6a3b), SkBits2Float(0xc085fae3));
6451path.lineTo(SkBits2Float(0x426f6a3b), SkBits2Float(0xc085fae4));
6452path.cubicTo(SkBits2Float(0x42669e7e), SkBits2Float(0xc20e7d42), SkBits2Float(0x41fc1920), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6453path.close();
6454
6455 SkPath path1(path);
6456 path.reset();
6457 path.setFillType((SkPathFillType) 0);
6458path.moveTo(SkBits2Float(0x42a57735), SkBits2Float(0x40d4ef9d));
6459path.cubicTo(SkBits2Float(0x429fe5e1), SkBits2Float(0x4225104d), SkBits2Float(0x425fa7d9), SkBits2Float(0x428cf91a), SkBits2Float(0x41b3ea58), SkBits2Float(0x429fca49));
6460path.cubicTo(SkBits2Float(0xc12ef606), SkBits2Float(0x42b29b77), SkBits2Float(0xc23abc07), SkBits2Float(0x4299d29d), SkBits2Float(0xc2863a28), SkBits2Float(0x42435615));
6461path.lineTo(SkBits2Float(0xc242103b), SkBits2Float(0x420d34fa));
6462path.cubicTo(SkBits2Float(0xc206fd22), SkBits2Float(0x425e64f1), SkBits2Float(0xc0fcf4a4), SkBits2Float(0x42811d1e), SkBits2Float(0x41820f34), SkBits2Float(0x426705a2));
6463path.cubicTo(SkBits2Float(0x4221adc8), SkBits2Float(0x424bd107), SkBits2Float(0x42672d88), SkBits2Float(0x41eea576), SkBits2Float(0x426f3a3c), SkBits2Float(0x4099edfe));
6464path.lineTo(SkBits2Float(0x42a57735), SkBits2Float(0x40d4ef9d));
6465path.close();
6466
6467 SkPath path2(path);
6468 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6469}

◆ battleOp237()

static void battleOp237 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6472 of file PathOpsBattles.cpp.

6472 {
6473 SkPath path;
6474 path.setFillType((SkPathFillType) 0);
6475path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6476path.cubicTo(SkBits2Float(0x41b25a1b), SkBits2Float(0xc2a60000), SkBits2Float(0x422e9a51), SkBits2Float(0xc294100b), SkBits2Float(0x426d0a79), SkBits2Float(0xc26874a1));
6477path.cubicTo(SkBits2Float(0x4295bd51), SkBits2Float(0xc228c92e), SkBits2Float(0x42a6d6d5), SkBits2Float(0xc1a5596e), SkBits2Float(0x42a5f7e5), SkBits2Float(0x3fcf7f4c));
6478path.lineTo(SkBits2Float(0x426ff448), SkBits2Float(0x3f95ff69));
6479path.cubicTo(SkBits2Float(0x4271369b), SkBits2Float(0xc16f0f30), SkBits2Float(0x42587daa), SkBits2Float(0xc1f4071e), SkBits2Float(0x422b5ada), SkBits2Float(0xc2280a4b));
6480path.cubicTo(SkBits2Float(0x41fc7014), SkBits2Float(0xc2561107), SkBits2Float(0x4180eddd), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6481path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6482path.close();
6483
6484 SkPath path1(path);
6485 path.reset();
6486 path.setFillType((SkPathFillType) 0);
6487path.moveTo(SkBits2Float(0x42a5f7e5), SkBits2Float(0x3fcf7f2e));
6488path.cubicTo(SkBits2Float(0x42a5cbdf), SkBits2Float(0x40c0b7f8), SkBits2Float(0x42a4eca2), SkBits2Float(0x41268f7d), SkBits2Float(0x42a35c4c), SkBits2Float(0x416be04e));
6489path.lineTo(SkBits2Float(0x426c2f14), SkBits2Float(0x412a834e));
6490path.cubicTo(SkBits2Float(0x426e71e2), SkBits2Float(0x40f0cf74), SkBits2Float(0x426fb4a3), SkBits2Float(0x408b5090), SkBits2Float(0x426ff449), SkBits2Float(0x3f95ff6b));
6491path.lineTo(SkBits2Float(0x42a5f7e5), SkBits2Float(0x3fcf7f2e));
6492path.close();
6493
6494 SkPath path2(path);
6495 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6496}

◆ battleOp238()

static void battleOp238 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6499 of file PathOpsBattles.cpp.

6499 {
6500 SkPath path;
6501 path.setFillType((SkPathFillType) 1);
6502path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6503path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6504path.cubicTo(SkBits2Float(0x41b25a1b), SkBits2Float(0xc2a60000), SkBits2Float(0x422e9a51), SkBits2Float(0xc294100b), SkBits2Float(0x426d0a79), SkBits2Float(0xc26874a1));
6505path.cubicTo(SkBits2Float(0x4295bd51), SkBits2Float(0xc228c92e), SkBits2Float(0x42a6d6d5), SkBits2Float(0xc1a5596f), SkBits2Float(0x42a5f7e5), SkBits2Float(0x3fcf7f2e));
6506path.lineTo(SkBits2Float(0x426c2f14), SkBits2Float(0x412a834e));
6507path.cubicTo(SkBits2Float(0x426e71e2), SkBits2Float(0x40f0cf74), SkBits2Float(0x426fb4a3), SkBits2Float(0x408b5090), SkBits2Float(0x426ff449), SkBits2Float(0x3f95ff6b));
6508path.lineTo(SkBits2Float(0x426ff448), SkBits2Float(0x3f95ff69));
6509path.cubicTo(SkBits2Float(0x4271369b), SkBits2Float(0xc16f0f30), SkBits2Float(0x42587daa), SkBits2Float(0xc1f4071e), SkBits2Float(0x422b5ada), SkBits2Float(0xc2280a4b));
6510path.cubicTo(SkBits2Float(0x41fc7014), SkBits2Float(0xc2561107), SkBits2Float(0x4180eddd), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6511path.close();
6512
6513 SkPath path1(path);
6514 path.reset();
6515 path.setFillType((SkPathFillType) 0);
6516path.moveTo(SkBits2Float(0x42a35c4c), SkBits2Float(0x416be04e));
6517path.cubicTo(SkBits2Float(0x42963d3f), SkBits2Float(0x424c5e0d), SkBits2Float(0x42354f77), SkBits2Float(0x429d76d6), SkBits2Float(0x41096c90), SkBits2Float(0x42a51bdb));
6518path.cubicTo(SkBits2Float(0xc1e1325f), SkBits2Float(0x42acc0e0), SkBits2Float(0xc27bf938), SkBits2Float(0x4282ec23), SkBits2Float(0xc299cad8), SkBits2Float(0x41f9ecd8));
6519path.lineTo(SkBits2Float(0xc25e59b3), SkBits2Float(0x41b4ab36));
6520path.cubicTo(SkBits2Float(0xc2362649), SkBits2Float(0x423d4911), SkBits2Float(0xc1a2caf7), SkBits2Float(0x4279c398), SkBits2Float(0x40c6af7d), SkBits2Float(0x426eb62b));
6521path.cubicTo(SkBits2Float(0x4203115b), SkBits2Float(0x4263a8be), SkBits2Float(0x425936a2), SkBits2Float(0x4213bc4a), SkBits2Float(0x426c2f16), SkBits2Float(0x412a8350));
6522path.lineTo(SkBits2Float(0x42a35c4c), SkBits2Float(0x416be04e));
6523path.close();
6524
6525 SkPath path2(path);
6526 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6527}

◆ battleOp239()

static void battleOp239 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6530 of file PathOpsBattles.cpp.

6530 {
6531 SkPath path;
6532 path.setFillType((SkPathFillType) 0);
6533path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6534path.cubicTo(SkBits2Float(0x41ba3f99), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4235f79d), SkBits2Float(0xc29271cf), SkBits2Float(0x4274db3f), SkBits2Float(0xc260354d));
6535path.cubicTo(SkBits2Float(0x4299df70), SkBits2Float(0xc21b86fd), SkBits2Float(0x42a97305), SkBits2Float(0xc17e5d7a), SkBits2Float(0x42a55ba0), SkBits2Float(0x40e961b4));
6536path.lineTo(SkBits2Float(0x426f1259), SkBits2Float(0x40a8b5ae));
6537path.cubicTo(SkBits2Float(0x4274fca8), SkBits2Float(0xc137e0e1), SkBits2Float(0x425e777b), SkBits2Float(0xc1e0dbdb), SkBits2Float(0x42310131), SkBits2Float(0xc2221408));
6538path.cubicTo(SkBits2Float(0x42038ae6), SkBits2Float(0xc253ba22), SkBits2Float(0x4186a32c), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
6539path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6540path.close();
6541
6542 SkPath path1(path);
6543 path.reset();
6544 path.setFillType((SkPathFillType) 0);
6545path.moveTo(SkBits2Float(0x42a55ba0), SkBits2Float(0x40e961b9));
6546path.cubicTo(SkBits2Float(0x42a48d09), SkBits2Float(0x413de0a1), SkBits2Float(0x42a2fc74), SkBits2Float(0x41833376), SkBits2Float(0x42a0adff), SkBits2Float(0x41a6c250));
6547path.lineTo(SkBits2Float(0x42684ed9), SkBits2Float(0x417118ef));
6548path.cubicTo(SkBits2Float(0x426ba483), SkBits2Float(0x413db02f), SkBits2Float(0x426de7aa), SkBits2Float(0x410942c3), SkBits2Float(0x426f1258), SkBits2Float(0x40a8b5ad));
6549path.lineTo(SkBits2Float(0x42a55ba0), SkBits2Float(0x40e961b9));
6550path.close();
6551
6552 SkPath path2(path);
6553 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6554}

◆ battleOp24()

static void battleOp24 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 705 of file PathOpsBattles.cpp.

705 {
706 SkPath path;
707 path.setFillType((SkPathFillType) 0);
708path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
709path.cubicTo(SkBits2Float(0x409bc7b0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x411ba103), SkBits2Float(0xc2a524b6), SkBits2Float(0x4168515c), SkBits2Float(0xc2a370af));
710path.lineTo(SkBits2Float(0x4127f0cc), SkBits2Float(0xc26c4c8f));
711path.cubicTo(SkBits2Float(0x40e1017a), SkBits2Float(0xc26ec2f6), SkBits2Float(0x40613965), SkBits2Float(0xc26fffff), SkBits2Float(0x3655fea5), SkBits2Float(0xc26fffff));
712path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
713path.close();
714
715 SkPath path1(path);
716 path.reset();
717 path.setFillType((SkPathFillType) 0);
718path.moveTo(SkBits2Float(0x4168515e), SkBits2Float(0xc2a370b0));
719path.cubicTo(SkBits2Float(0x416ffb5b), SkBits2Float(0xc2a3451c), SkBits2Float(0x4177a23d), SkBits2Float(0xc2a31761), SkBits2Float(0x417f45ca), SkBits2Float(0xc2a2e77f));
720path.lineTo(SkBits2Float(0x413888ce), SkBits2Float(0xc26b8638));
721path.cubicTo(SkBits2Float(0x41330328), SkBits2Float(0xc26bcb72), SkBits2Float(0x412d7b1a), SkBits2Float(0xc26c0d90), SkBits2Float(0x4127f0cb), SkBits2Float(0xc26c4c90));
722path.lineTo(SkBits2Float(0x4168515e), SkBits2Float(0xc2a370b0));
723path.close();
724
725 SkPath path2(path);
726 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
727}

◆ battleOp240()

static void battleOp240 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6557 of file PathOpsBattles.cpp.

6557 {
6558 SkPath path;
6559 path.setFillType((SkPathFillType) 1);
6560path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6561path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6562path.cubicTo(SkBits2Float(0x41ba3f99), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4235f79d), SkBits2Float(0xc29271cf), SkBits2Float(0x4274db3f), SkBits2Float(0xc260354d));
6563path.cubicTo(SkBits2Float(0x4299df70), SkBits2Float(0xc21b86fd), SkBits2Float(0x42a97305), SkBits2Float(0xc17e5d7a), SkBits2Float(0x42a55ba0), SkBits2Float(0x40e961b9));
6564path.cubicTo(SkBits2Float(0x42a48d09), SkBits2Float(0x413de0a1), SkBits2Float(0x42a2fc74), SkBits2Float(0x41833376), SkBits2Float(0x42a0adff), SkBits2Float(0x41a6c250));
6565path.lineTo(SkBits2Float(0x42684ed9), SkBits2Float(0x417118ef));
6566path.cubicTo(SkBits2Float(0x426ba483), SkBits2Float(0x413db02f), SkBits2Float(0x426de7aa), SkBits2Float(0x410942c3), SkBits2Float(0x426f1259), SkBits2Float(0x40a8b5ae));
6567path.cubicTo(SkBits2Float(0x4274fca8), SkBits2Float(0xc137e0e1), SkBits2Float(0x425e777b), SkBits2Float(0xc1e0dbdb), SkBits2Float(0x42310131), SkBits2Float(0xc2221408));
6568path.cubicTo(SkBits2Float(0x42038ae6), SkBits2Float(0xc253ba22), SkBits2Float(0x4186a32c), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
6569path.close();
6570
6571 SkPath path1(path);
6572 path.reset();
6573 path.setFillType((SkPathFillType) 0);
6574path.moveTo(SkBits2Float(0x42a0ae00), SkBits2Float(0x41a6c250));
6575path.cubicTo(SkBits2Float(0x428d4422), SkBits2Float(0x4269069e), SkBits2Float(0x42118d33), SkBits2Float(0x42a8086f), SkBits2Float(0xc00fe376), SkBits2Float(0x42a5f066));
6576path.cubicTo(SkBits2Float(0xc22389a2), SkBits2Float(0x42a3d85e), SkBits2Float(0xc2935e5d), SkBits2Float(0x42596224), SkBits2Float(0xc2a2b39d), SkBits2Float(0x4183b53a));
6577path.lineTo(SkBits2Float(0xc26b3b33), SkBits2Float(0x413e6bca));
6578path.cubicTo(SkBits2Float(0xc2551027), SkBits2Float(0x421d2508), SkBits2Float(0xc1ec70a3), SkBits2Float(0x426ce27d), SkBits2Float(0xbfd007ff), SkBits2Float(0x426fe979));
6579path.cubicTo(SkBits2Float(0x41d26fa4), SkBits2Float(0x4272f076), SkBits2Float(0x424c3d84), SkBits2Float(0x422873d5), SkBits2Float(0x42684eda), SkBits2Float(0x417118ee));
6580path.lineTo(SkBits2Float(0x42a0ae00), SkBits2Float(0x41a6c250));
6581path.close();
6582
6583 SkPath path2(path);
6584 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6585}

◆ battleOp241()

static void battleOp241 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6588 of file PathOpsBattles.cpp.

6588 {
6589 SkPath path;
6590 path.setFillType((SkPathFillType) 0);
6591path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6592path.cubicTo(SkBits2Float(0x41c2abe0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423dc4ab), SkBits2Float(0xc290a493), SkBits2Float(0x427cd8fd), SkBits2Float(0xc25727eb));
6593path.cubicTo(SkBits2Float(0x429df6a6), SkBits2Float(0xc20d06b1), SkBits2Float(0x42aba628), SkBits2Float(0xc12bcbe5), SkBits2Float(0x42a3dc46), SkBits2Float(0x4154872f));
6594path.lineTo(SkBits2Float(0x426ce81c), SkBits2Float(0x4119a283));
6595path.cubicTo(SkBits2Float(0x42782ad8), SkBits2Float(0xc0f86165), SkBits2Float(0x42646188), SkBits2Float(0xc1cbe4ab), SkBits2Float(0x4236c80c), SkBits2Float(0xc21b88d1));
6596path.cubicTo(SkBits2Float(0x42092e8f), SkBits2Float(0xc2511f4c), SkBits2Float(0x418cb9f2), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6597path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6598path.close();
6599
6600 SkPath path1(path);
6601 path.reset();
6602 path.setFillType((SkPathFillType) 0);
6603path.moveTo(SkBits2Float(0x42a3dc46), SkBits2Float(0x41548735));
6604path.cubicTo(SkBits2Float(0x42a2537f), SkBits2Float(0x41901e3f), SkBits2Float(0x429ff996), SkBits2Float(0x41b55e92), SkBits2Float(0x429cd549), SkBits2Float(0x41d999a0));
6605path.lineTo(SkBits2Float(0x4262bf29), SkBits2Float(0x419d4d21));
6606path.cubicTo(SkBits2Float(0x42674a02), SkBits2Float(0x41831c46), SkBits2Float(0x426ab03e), SkBits2Float(0x41505d16), SkBits2Float(0x426ce81d), SkBits2Float(0x4119a283));
6607path.lineTo(SkBits2Float(0x42a3dc46), SkBits2Float(0x41548735));
6608path.close();
6609
6610 SkPath path2(path);
6611 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6612}

◆ battleOp242()

static void battleOp242 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6615 of file PathOpsBattles.cpp.

6615 {
6616 SkPath path;
6617 path.setFillType((SkPathFillType) 1);
6618path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6619path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6620path.cubicTo(SkBits2Float(0x41c2abe0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423dc4ab), SkBits2Float(0xc290a493), SkBits2Float(0x427cd8fd), SkBits2Float(0xc25727eb));
6621path.cubicTo(SkBits2Float(0x429df6a6), SkBits2Float(0xc20d06b1), SkBits2Float(0x42aba628), SkBits2Float(0xc12bcbe5), SkBits2Float(0x42a3dc46), SkBits2Float(0x41548735));
6622path.cubicTo(SkBits2Float(0x42a2537f), SkBits2Float(0x41901e3f), SkBits2Float(0x429ff996), SkBits2Float(0x41b55e92), SkBits2Float(0x429cd549), SkBits2Float(0x41d999a0));
6623path.lineTo(SkBits2Float(0x4262bf29), SkBits2Float(0x419d4d21));
6624path.cubicTo(SkBits2Float(0x42674a02), SkBits2Float(0x41831c46), SkBits2Float(0x426ab03e), SkBits2Float(0x41505d16), SkBits2Float(0x426ce81c), SkBits2Float(0x4119a283));
6625path.cubicTo(SkBits2Float(0x42782ad8), SkBits2Float(0xc0f86165), SkBits2Float(0x42646188), SkBits2Float(0xc1cbe4ab), SkBits2Float(0x4236c80c), SkBits2Float(0xc21b88d1));
6626path.cubicTo(SkBits2Float(0x42092e8f), SkBits2Float(0xc2511f4c), SkBits2Float(0x418cb9f2), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6627path.close();
6628
6629 SkPath path1(path);
6630 path.reset();
6631 path.setFillType((SkPathFillType) 0);
6632path.moveTo(SkBits2Float(0x429cd549), SkBits2Float(0x41d999a0));
6633path.cubicTo(SkBits2Float(0x42824b9e), SkBits2Float(0x4282e841), SkBits2Float(0x41d1b597), SkBits2Float(0x42b119ff), SkBits2Float(0xc15b80c3), SkBits2Float(0x42a3b776));
6634path.cubicTo(SkBits2Float(0xc2569b2d), SkBits2Float(0x429654ee), SkBits2Float(0xc2a5db0b), SkBits2Float(0x42228c64), SkBits2Float(0xc2a5ffee), SkBits2Float(0x3e172efd));
6635path.lineTo(SkBits2Float(0xc26fffe7), SkBits2Float(0x3dda91a4));
6636path.cubicTo(SkBits2Float(0xc26fca99), SkBits2Float(0x41eb0285), SkBits2Float(0xc21b2317), SkBits2Float(0x425958e5), SkBits2Float(0xc11ead4d), SkBits2Float(0x426cb2ed));
6637path.cubicTo(SkBits2Float(0x419798e1), SkBits2Float(0x4280067a), SkBits2Float(0x423c6102), SkBits2Float(0x423d4379), SkBits2Float(0x4262bf29), SkBits2Float(0x419d4d1f));
6638path.lineTo(SkBits2Float(0x429cd549), SkBits2Float(0x41d999a0));
6639path.close();
6640
6641 SkPath path2(path);
6642 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6643}

◆ battleOp243()

static void battleOp243 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6646 of file PathOpsBattles.cpp.

6646 {
6647 SkPath path;
6648 path.setFillType((SkPathFillType) 0);
6649path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6650path.cubicTo(SkBits2Float(0x41caf078), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42455e40), SkBits2Float(0xc28ecc78), SkBits2Float(0x42822b31), SkBits2Float(0xc24e07b4));
6651path.cubicTo(SkBits2Float(0x42a1a743), SkBits2Float(0xc1fcecee), SkBits2Float(0x42ad3753), SkBits2Float(0xc0b3be45), SkBits2Float(0x42a18eed), SkBits2Float(0x419892cb));
6652path.lineTo(SkBits2Float(0x42699409), SkBits2Float(0x415c9689));
6653path.cubicTo(SkBits2Float(0x427a6ed6), SkBits2Float(0xc081ef5b), SkBits2Float(0x4269b739), SkBits2Float(0xc1b6d67a), SkBits2Float(0x423c321c), SkBits2Float(0xc214effc));
6654path.cubicTo(SkBits2Float(0x420eacff), SkBits2Float(0xc24e74bc), SkBits2Float(0x4192b3ff), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
6655path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6656path.close();
6657
6658 SkPath path1(path);
6659 path.reset();
6660 path.setFillType((SkPathFillType) 0);
6661path.moveTo(SkBits2Float(0x42a18eed), SkBits2Float(0x419892ca));
6662path.cubicTo(SkBits2Float(0x429f43c9), SkBits2Float(0x41bf6e44), SkBits2Float(0x429c198b), SkBits2Float(0x41e561a5), SkBits2Float(0x42981a0b), SkBits2Float(0x4204fb6e));
6663path.lineTo(SkBits2Float(0x425be7f8), SkBits2Float(0x41c0436a));
6664path.cubicTo(SkBits2Float(0x4261afba), SkBits2Float(0x41a5d162), SkBits2Float(0x42664329), SkBits2Float(0x418a6237), SkBits2Float(0x4269940a), SkBits2Float(0x415c968a));
6665path.lineTo(SkBits2Float(0x42a18eed), SkBits2Float(0x419892ca));
6666path.close();
6667
6668 SkPath path2(path);
6669 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6670}

◆ battleOp244()

static void battleOp244 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6673 of file PathOpsBattles.cpp.

6673 {
6674 SkPath path;
6675 path.setFillType((SkPathFillType) 1);
6676path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
6677path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6678path.cubicTo(SkBits2Float(0x41caf078), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42455e40), SkBits2Float(0xc28ecc78), SkBits2Float(0x42822b31), SkBits2Float(0xc24e07b4));
6679path.cubicTo(SkBits2Float(0x42a1a743), SkBits2Float(0xc1fcecee), SkBits2Float(0x42ad3753), SkBits2Float(0xc0b3be48), SkBits2Float(0x42a18eed), SkBits2Float(0x419892ca));
6680path.lineTo(SkBits2Float(0x42a18eed), SkBits2Float(0x419892cb));
6681path.cubicTo(SkBits2Float(0x429f43c9), SkBits2Float(0x41bf6e45), SkBits2Float(0x429c198b), SkBits2Float(0x41e561a5), SkBits2Float(0x42981a0b), SkBits2Float(0x4204fb6e));
6682path.lineTo(SkBits2Float(0x425be7f8), SkBits2Float(0x41c0436a));
6683path.cubicTo(SkBits2Float(0x4261afba), SkBits2Float(0x41a5d162), SkBits2Float(0x42664329), SkBits2Float(0x418a6237), SkBits2Float(0x4269940a), SkBits2Float(0x415c968a));
6684path.lineTo(SkBits2Float(0x42699409), SkBits2Float(0x415c9689));
6685path.cubicTo(SkBits2Float(0x427a6ed6), SkBits2Float(0xc081ef5b), SkBits2Float(0x4269b739), SkBits2Float(0xc1b6d67a), SkBits2Float(0x423c321c), SkBits2Float(0xc214effc));
6686path.cubicTo(SkBits2Float(0x420eacff), SkBits2Float(0xc24e74bc), SkBits2Float(0x4192b3ff), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
6687path.close();
6688
6689 SkPath path1(path);
6690 path.reset();
6691 path.setFillType((SkPathFillType) 0);
6692path.moveTo(SkBits2Float(0x42981a0b), SkBits2Float(0x4204fb6e));
6693path.cubicTo(SkBits2Float(0x426c6b55), SkBits2Float(0x42900555), SkBits2Float(0x417b6a9f), SkBits2Float(0x42b7a6c3), SkBits2Float(0xc1c57072), SkBits2Float(0x429e7dd7));
6694path.cubicTo(SkBits2Float(0xc282258c), SkBits2Float(0x428554eb), SkBits2Float(0xc2b314c4), SkBits2Float(0x41cdbc89), SkBits2Float(0xc2a2f571), SkBits2Float(0xc17d09b6));
6695path.lineTo(SkBits2Float(0xc26b9a61), SkBits2Float(0xc136eb32));
6696path.cubicTo(SkBits2Float(0xc28174d0), SkBits2Float(0x4194b9b3), SkBits2Float(0xc23c29fc), SkBits2Float(0x4240c4dc), SkBits2Float(0xc18eba2f), SkBits2Float(0x4265250a));
6697path.cubicTo(SkBits2Float(0x4135bf41), SkBits2Float(0x4284c29d), SkBits2Float(0x422ae7d8), SkBits2Float(0x42503918), SkBits2Float(0x425be7f9), SkBits2Float(0x41c04367));
6698path.lineTo(SkBits2Float(0x42981a0b), SkBits2Float(0x4204fb6e));
6699path.close();
6700
6701 SkPath path2(path);
6702 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6703}

◆ battleOp245()

static void battleOp245 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6706 of file PathOpsBattles.cpp.

6706 {
6707 SkPath path;
6708 path.setFillType((SkPathFillType) 0);
6709path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6710path.cubicTo(SkBits2Float(0x41d28773), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424c4acf), SkBits2Float(0xc28d0a47), SkBits2Float(0x428572fc), SkBits2Float(0xc24574fc));
6711path.cubicTo(SkBits2Float(0x42a4c090), SkBits2Float(0xc1e1aad9), SkBits2Float(0x42ae2294), SkBits2Float(0xbf62367e), SkBits2Float(0x429ebce0), SkBits2Float(0x41c23fec));
6712path.lineTo(SkBits2Float(0x4265801d), SkBits2Float(0x418c6be6));
6713path.cubicTo(SkBits2Float(0x427bc2fb), SkBits2Float(0xbf238720), SkBits2Float(0x426e322e), SkBits2Float(0xc1a32211), SkBits2Float(0x4240f046), SkBits2Float(0xc20ebd71));
6714path.cubicTo(SkBits2Float(0x4213ae61), SkBits2Float(0xc24be9da), SkBits2Float(0x41983095), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6715path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6716path.close();
6717
6718 SkPath path1(path);
6719 path.reset();
6720 path.setFillType((SkPathFillType) 0);
6721path.moveTo(SkBits2Float(0x429ebce1), SkBits2Float(0x41c23fee));
6722path.cubicTo(SkBits2Float(0x429bb658), SkBits2Float(0x41e9cedc), SkBits2Float(0x4297c4ea), SkBits2Float(0x4208130e), SkBits2Float(0x4292f5c0), SkBits2Float(0x421a62d5));
6723path.lineTo(SkBits2Float(0x425478e6), SkBits2Float(0x41df3573));
6724path.cubicTo(SkBits2Float(0x425b6ce6), SkBits2Float(0x41c4bbf1), SkBits2Float(0x42612050), SkBits2Float(0x41a90494), SkBits2Float(0x4265801e), SkBits2Float(0x418c6be6));
6725path.lineTo(SkBits2Float(0x429ebce1), SkBits2Float(0x41c23fee));
6726path.close();
6727
6728 SkPath path2(path);
6729 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6730}

◆ battleOp246()

static void battleOp246 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6733 of file PathOpsBattles.cpp.

6733 {
6734 SkPath path;
6735 path.setFillType((SkPathFillType) 1);
6736path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6737path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6738path.cubicTo(SkBits2Float(0x41d28773), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424c4acf), SkBits2Float(0xc28d0a47), SkBits2Float(0x428572fc), SkBits2Float(0xc24574fc));
6739path.cubicTo(SkBits2Float(0x42a4c090), SkBits2Float(0xc1e1aad9), SkBits2Float(0x42ae2294), SkBits2Float(0xbf62367e), SkBits2Float(0x429ebce1), SkBits2Float(0x41c23fee));
6740path.cubicTo(SkBits2Float(0x429bb658), SkBits2Float(0x41e9cedc), SkBits2Float(0x4297c4ea), SkBits2Float(0x4208130e), SkBits2Float(0x4292f5c0), SkBits2Float(0x421a62d5));
6741path.lineTo(SkBits2Float(0x425478e6), SkBits2Float(0x41df3573));
6742path.cubicTo(SkBits2Float(0x425b6ce6), SkBits2Float(0x41c4bbf1), SkBits2Float(0x42612050), SkBits2Float(0x41a90494), SkBits2Float(0x4265801d), SkBits2Float(0x418c6be6));
6743path.cubicTo(SkBits2Float(0x427bc2fb), SkBits2Float(0xbf238720), SkBits2Float(0x426e322e), SkBits2Float(0xc1a32211), SkBits2Float(0x4240f046), SkBits2Float(0xc20ebd71));
6744path.cubicTo(SkBits2Float(0x4213ae61), SkBits2Float(0xc24be9da), SkBits2Float(0x41983095), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
6745path.close();
6746
6747 SkPath path1(path);
6748 path.reset();
6749 path.setFillType((SkPathFillType) 0);
6750path.moveTo(SkBits2Float(0x4292f5c1), SkBits2Float(0x421a62d6));
6751path.cubicTo(SkBits2Float(0x42541a09), SkBits2Float(0x429b1363), SkBits2Float(0x40b7c75d), SkBits2Float(0x42bb84d6), SkBits2Float(0xc2093cef), SkBits2Float(0x42972755));
6752path.cubicTo(SkBits2Float(0xc294b966), SkBits2Float(0x426593a9), SkBits2Float(0xc2ba8c7c), SkBits2Float(0x4131f51c), SkBits2Float(0xc29ad8fe), SkBits2Float(0xc1ef45cd));
6753path.lineTo(SkBits2Float(0xc25fe048), SkBits2Float(0xc1acf7d7));
6754path.cubicTo(SkBits2Float(0xc286dac7), SkBits2Float(0x4100a4f0), SkBits2Float(0xc25705ec), SkBits2Float(0x4225f597), SkBits2Float(0xc1c66aa8), SkBits2Float(0x425a891e));
6755path.cubicTo(SkBits2Float(0x4084da24), SkBits2Float(0x42878e54), SkBits2Float(0x4219539e), SkBits2Float(0x426034bf), SkBits2Float(0x425478e7), SkBits2Float(0x41df3571));
6756path.lineTo(SkBits2Float(0x4292f5c1), SkBits2Float(0x421a62d6));
6757path.close();
6758
6759 SkPath path2(path);
6760 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6761}

◆ battleOp247()

static void battleOp247 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6764 of file PathOpsBattles.cpp.

6764 {
6765 SkPath path;
6766 path.setFillType((SkPathFillType) 0);
6767path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6768path.cubicTo(SkBits2Float(0x41d91350), SkBits2Float(0xc2a5ffff), SkBits2Float(0x425238e3), SkBits2Float(0xc28b791f), SkBits2Float(0x428827e4), SkBits2Float(0xc23dec02));
6769path.cubicTo(SkBits2Float(0x42a73357), SkBits2Float(0xc1c9cb8b), SkBits2Float(0x42ae86ff), SkBits2Float(0x404daf5b), SkBits2Float(0x429bc6e8), SkBits2Float(0x41e56ae9));
6770path.lineTo(SkBits2Float(0x42613841), SkBits2Float(0x41a5d816));
6771path.cubicTo(SkBits2Float(0x427c5425), SkBits2Float(0x4014b024), SkBits2Float(0x4271bc5c), SkBits2Float(0xc191e03e), SkBits2Float(0x4244da12), SkBits2Float(0xc2094aff));
6772path.cubicTo(SkBits2Float(0x4217f7c8), SkBits2Float(0xc249a5df), SkBits2Float(0x419cec09), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
6773path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6774path.close();
6775
6776 SkPath path1(path);
6777 path.reset();
6778 path.setFillType((SkPathFillType) 0);
6779path.moveTo(SkBits2Float(0x429bc6e9), SkBits2Float(0x41e56aeb));
6780path.cubicTo(SkBits2Float(0x429818bd), SkBits2Float(0x4206b36a), SkBits2Float(0x42937671), SkBits2Float(0x4219f01e), SkBits2Float(0x428df070), SkBits2Float(0x422c2771));
6781path.lineTo(SkBits2Float(0x424d369d), SkBits2Float(0x41f8e5bf));
6782path.cubicTo(SkBits2Float(0x425532f6), SkBits2Float(0x41de8f99), SkBits2Float(0x425be616), SkBits2Float(0x41c2bf8b), SkBits2Float(0x42613843), SkBits2Float(0x41a5d816));
6783path.lineTo(SkBits2Float(0x429bc6e9), SkBits2Float(0x41e56aeb));
6784path.close();
6785
6786 SkPath path2(path);
6787 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6788}

◆ battleOp248()

static void battleOp248 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6791 of file PathOpsBattles.cpp.

6791 {
6792 SkPath path;
6793 path.setFillType((SkPathFillType) 1);
6794path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
6795path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6796path.cubicTo(SkBits2Float(0x41d91350), SkBits2Float(0xc2a5ffff), SkBits2Float(0x425238e3), SkBits2Float(0xc28b791f), SkBits2Float(0x428827e4), SkBits2Float(0xc23dec02));
6797path.cubicTo(SkBits2Float(0x42a73357), SkBits2Float(0xc1c9cb8b), SkBits2Float(0x42ae86ff), SkBits2Float(0x404daf5b), SkBits2Float(0x429bc6e9), SkBits2Float(0x41e56aeb));
6798path.cubicTo(SkBits2Float(0x429818bd), SkBits2Float(0x4206b36a), SkBits2Float(0x42937671), SkBits2Float(0x4219f01e), SkBits2Float(0x428df070), SkBits2Float(0x422c2771));
6799path.lineTo(SkBits2Float(0x424d369d), SkBits2Float(0x41f8e5bf));
6800path.cubicTo(SkBits2Float(0x425532f6), SkBits2Float(0x41de8f99), SkBits2Float(0x425be616), SkBits2Float(0x41c2bf8b), SkBits2Float(0x42613843), SkBits2Float(0x41a5d816));
6801path.lineTo(SkBits2Float(0x42613841), SkBits2Float(0x41a5d816));
6802path.cubicTo(SkBits2Float(0x427c5425), SkBits2Float(0x4014b024), SkBits2Float(0x4271bc5c), SkBits2Float(0xc191e03e), SkBits2Float(0x4244da12), SkBits2Float(0xc2094aff));
6803path.cubicTo(SkBits2Float(0x4217f7c8), SkBits2Float(0xc249a5df), SkBits2Float(0x419cec09), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
6804path.close();
6805
6806 SkPath path1(path);
6807 path.reset();
6808 path.setFillType((SkPathFillType) 0);
6809path.moveTo(SkBits2Float(0x428df071), SkBits2Float(0x422c2771));
6810path.cubicTo(SkBits2Float(0x423d9ebb), SkBits2Float(0x42a3ca6a), SkBits2Float(0xc041a78f), SkBits2Float(0x42bd279e), SkBits2Float(0xc228abe7), SkBits2Float(0x428efaad));
6811path.cubicTo(SkBits2Float(0xc2a29eac), SkBits2Float(0x42419b78), SkBits2Float(0xc2bd3710), SkBits2Float(0xbfef63d4), SkBits2Float(0xc2900003), SkBits2Float(0xc2252a98));
6812path.lineTo(SkBits2Float(0xc250315d), SkBits2Float(0xc1eecb7c));
6813path.cubicTo(SkBits2Float(0xc288c864), SkBits2Float(0xbfad0c79), SkBits2Float(0xc26b1d6b), SkBits2Float(0x420bf56b), SkBits2Float(0xc1f3dd5d), SkBits2Float(0x424eb80d));
6814path.cubicTo(SkBits2Float(0xc00bff34), SkBits2Float(0x4288bd57), SkBits2Float(0x4209134e), SkBits2Float(0x426ccea7), SkBits2Float(0x424d369e), SkBits2Float(0x41f8e5bd));
6815path.lineTo(SkBits2Float(0x428df071), SkBits2Float(0x422c2771));
6816path.close();
6817
6818 SkPath path2(path);
6819 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6820}

◆ battleOp249()

static void battleOp249 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6823 of file PathOpsBattles.cpp.

6823 {
6824 SkPath path;
6825 path.setFillType((SkPathFillType) 0);
6826path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6827path.cubicTo(SkBits2Float(0x41df6bc7), SkBits2Float(0xc2a60000), SkBits2Float(0x4257ee8b), SkBits2Float(0xc289e8f6), SkBits2Float(0x428aab73), SkBits2Float(0xc2368066));
6828path.cubicTo(SkBits2Float(0x42a95fa1), SkBits2Float(0xc1b25dc1), SkBits2Float(0x42ae8dc1), SkBits2Float(0x40e61789), SkBits2Float(0x42987459), SkBits2Float(0x42035b41));
6829path.lineTo(SkBits2Float(0x425c6a87), SkBits2Float(0x41bde9b7));
6830path.cubicTo(SkBits2Float(0x427c5dea), SkBits2Float(0x40a654db), SkBits2Float(0x4274e0a0), SkBits2Float(0xc180f082), SkBits2Float(0x42487c82), SkBits2Float(0xc203edca));
6831path.cubicTo(SkBits2Float(0x421c1865), SkBits2Float(0xc2476353), SkBits2Float(0x41a18256), SkBits2Float(0xc2700000), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
6832path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6833path.close();
6834
6835 SkPath path1(path);
6836 path.reset();
6837 path.setFillType((SkPathFillType) 0);
6838path.moveTo(SkBits2Float(0x42987459), SkBits2Float(0x42035b41));
6839path.cubicTo(SkBits2Float(0x42941f1a), SkBits2Float(0x421778e1), SkBits2Float(0x428ecdc9), SkBits2Float(0x422aae55), SkBits2Float(0x42889449), SkBits2Float(0x423cb3b9));
6840path.lineTo(SkBits2Float(0x424576c5), SkBits2Float(0x4208693e));
6841path.cubicTo(SkBits2Float(0x424e76a2), SkBits2Float(0x41f6c488), SkBits2Float(0x425626ce), SkBits2Float(0x41dafef6), SkBits2Float(0x425c6a88), SkBits2Float(0x41bde9b8));
6842path.lineTo(SkBits2Float(0x42987459), SkBits2Float(0x42035b41));
6843path.close();
6844
6845 SkPath path2(path);
6846 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6847}

◆ battleOp25()

static void battleOp25 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 730 of file PathOpsBattles.cpp.

730 {
731 SkPath path;
732 path.setFillType((SkPathFillType) 1);
733path.moveTo(SkBits2Float(0x3655fea5), SkBits2Float(0xc26fffff));
734path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
735path.cubicTo(SkBits2Float(0x409bc7b0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x411ba103), SkBits2Float(0xc2a524b6), SkBits2Float(0x4168515e), SkBits2Float(0xc2a370b0));
736path.cubicTo(SkBits2Float(0x416ffb5b), SkBits2Float(0xc2a3451c), SkBits2Float(0x4177a23d), SkBits2Float(0xc2a31761), SkBits2Float(0x417f45ca), SkBits2Float(0xc2a2e77f));
737path.lineTo(SkBits2Float(0x413888ce), SkBits2Float(0xc26b8638));
738path.cubicTo(SkBits2Float(0x41330328), SkBits2Float(0xc26bcb72), SkBits2Float(0x412d7b1a), SkBits2Float(0xc26c0d90), SkBits2Float(0x4127f0cc), SkBits2Float(0xc26c4c8f));
739path.cubicTo(SkBits2Float(0x40e1017a), SkBits2Float(0xc26ec2f6), SkBits2Float(0x40613965), SkBits2Float(0xc26fffff), SkBits2Float(0x3655fea5), SkBits2Float(0xc26fffff));
740path.close();
741
742 SkPath path1(path);
743 path.reset();
744 path.setFillType((SkPathFillType) 0);
745path.moveTo(SkBits2Float(0x417f45c8), SkBits2Float(0xc2a2e780));
746path.cubicTo(SkBits2Float(0x41bda27d), SkBits2Float(0xc29fde49), SkBits2Float(0x41f99531), SkBits2Float(0xc29aa2c4), SkBits2Float(0x4218d569), SkBits2Float(0xc2935d77));
747path.lineTo(SkBits2Float(0x41dcf6db), SkBits2Float(0xc2550ed7));
748path.cubicTo(SkBits2Float(0x41b46bda), SkBits2Float(0xc25f91e2), SkBits2Float(0x418915db), SkBits2Float(0xc2672288), SkBits2Float(0x413888d2), SkBits2Float(0xc26b8639));
749path.lineTo(SkBits2Float(0x417f45c8), SkBits2Float(0xc2a2e780));
750path.close();
751
752 SkPath path2(path);
753 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
754}

◆ battleOp250()

static void battleOp250 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6850 of file PathOpsBattles.cpp.

6850 {
6851 SkPath path;
6852 path.setFillType((SkPathFillType) 1);
6853path.moveTo(SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
6854path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6855path.cubicTo(SkBits2Float(0x41df6bc7), SkBits2Float(0xc2a60000), SkBits2Float(0x4257ee8b), SkBits2Float(0xc289e8f6), SkBits2Float(0x428aab73), SkBits2Float(0xc2368066));
6856path.cubicTo(SkBits2Float(0x42a95fa1), SkBits2Float(0xc1b25dc1), SkBits2Float(0x42ae8dc1), SkBits2Float(0x40e61789), SkBits2Float(0x42987459), SkBits2Float(0x42035b41));
6857path.cubicTo(SkBits2Float(0x42941f1a), SkBits2Float(0x421778e1), SkBits2Float(0x428ecdc9), SkBits2Float(0x422aae55), SkBits2Float(0x42889449), SkBits2Float(0x423cb3b9));
6858path.lineTo(SkBits2Float(0x424576c5), SkBits2Float(0x4208693e));
6859path.cubicTo(SkBits2Float(0x424e76a2), SkBits2Float(0x41f6c488), SkBits2Float(0x425626ce), SkBits2Float(0x41dafef6), SkBits2Float(0x425c6a87), SkBits2Float(0x41bde9b7));
6860path.cubicTo(SkBits2Float(0x427c5dea), SkBits2Float(0x40a654db), SkBits2Float(0x4274e0a0), SkBits2Float(0xc180f082), SkBits2Float(0x42487c82), SkBits2Float(0xc203edca));
6861path.cubicTo(SkBits2Float(0x421c1865), SkBits2Float(0xc2476353), SkBits2Float(0x41a18256), SkBits2Float(0xc2700000), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
6862path.close();
6863
6864 SkPath path1(path);
6865 path.reset();
6866 path.setFillType((SkPathFillType) 0);
6867path.moveTo(SkBits2Float(0x42889449), SkBits2Float(0x423cb3b8));
6868path.cubicTo(SkBits2Float(0x424c5291), SkBits2Float(0x42902c61), SkBits2Float(0x41ad609d), SkBits2Float(0x42ab4d26), SkBits2Float(0xc1072a9c), SkBits2Float(0x42a52356));
6869path.cubicTo(SkBits2Float(0xc21a459c), SkBits2Float(0x429ef985), SkBits2Float(0xc2813d9b), SkBits2Float(0x4270fef6), SkBits2Float(0xc298db30), SkBits2Float(0x420179e4));
6870path.cubicTo(SkBits2Float(0xc2b078c6), SkBits2Float(0x408fa686), SkBits2Float(0xc2a7d9d7), SkBits2Float(0xc1dcde62), SkBits2Float(0xc2825c7e), SkBits2Float(0xc24d8ae0));
6871path.lineTo(SkBits2Float(0xc23c7965), SkBits2Float(0xc21495bd));
6872path.cubicTo(SkBits2Float(0xc272ad07), SkBits2Float(0xc19fa9fe), SkBits2Float(0xc27f23bc), SkBits2Float(0x404faf9e), SkBits2Float(0xc25cff22), SkBits2Float(0x41bb31a8));
6873path.cubicTo(SkBits2Float(0xc23ada86), SkBits2Float(0x422e36b1), SkBits2Float(0xc1df0b0c), SkBits2Float(0x4265d7b2), SkBits2Float(0xc0c36b6f), SkBits2Float(0x426ec0e0));
6874path.cubicTo(SkBits2Float(0x417aaa9e), SkBits2Float(0x4277aa0e), SkBits2Float(0x4213b3f9), SkBits2Float(0x42507175), SkBits2Float(0x424576c8), SkBits2Float(0x4208693c));
6875path.lineTo(SkBits2Float(0x42889449), SkBits2Float(0x423cb3b8));
6876path.close();
6877
6878 SkPath path2(path);
6879 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6880}

◆ battleOp251()

static void battleOp251 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6883 of file PathOpsBattles.cpp.

6883 {
6884 SkPath path;
6885 path.setFillType((SkPathFillType) 0);
6886path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6887path.cubicTo(SkBits2Float(0x41e529f0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x425d10b2), SkBits2Float(0xc2887541), SkBits2Float(0x428cd9cf), SkBits2Float(0xc22fb184));
6888path.cubicTo(SkBits2Float(0x42ab2b45), SkBits2Float(0xc19cf10c), SkBits2Float(0x42ae472d), SkBits2Float(0x412c96c0), SkBits2Float(0x42951360), SkBits2Float(0x42120c0d));
6889path.lineTo(SkBits2Float(0x425787f7), SkBits2Float(0x41d32707));
6890path.cubicTo(SkBits2Float(0x427bf7e0), SkBits2Float(0x40f986c2), SkBits2Float(0x4277792b), SkBits2Float(0xc162e746), SkBits2Float(0x424ba3c8), SkBits2Float(0xc1fe03ba));
6891path.cubicTo(SkBits2Float(0x421fce66), SkBits2Float(0xc24549e8), SkBits2Float(0x41a5a922), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
6892path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6893path.close();
6894
6895 SkPath path1(path);
6896 path.reset();
6897 path.setFillType((SkPathFillType) 0);
6898path.moveTo(SkBits2Float(0x42951360), SkBits2Float(0x42120c0f));
6899path.cubicTo(SkBits2Float(0x429023a5), SkBits2Float(0x422633cd), SkBits2Float(0x428a3193), SkBits2Float(0x42394df4), SkBits2Float(0x42835484), SkBits2Float(0x424b0f7e));
6900path.lineTo(SkBits2Float(0x423ddffa), SkBits2Float(0x4212ca6e));
6901path.cubicTo(SkBits2Float(0x4247cc4f), SkBits2Float(0x4205f480), SkBits2Float(0x425064e4), SkBits2Float(0x41f04ae6), SkBits2Float(0x425787f8), SkBits2Float(0x41d32708));
6902path.lineTo(SkBits2Float(0x42951360), SkBits2Float(0x42120c0f));
6903path.close();
6904
6905 SkPath path2(path);
6906 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6907}

◆ battleOp252()

static void battleOp252 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6910 of file PathOpsBattles.cpp.

6910 {
6911 SkPath path;
6912 path.setFillType((SkPathFillType) 1);
6913path.moveTo(SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
6914path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6915path.cubicTo(SkBits2Float(0x41e529f0), SkBits2Float(0xc2a5ffff), SkBits2Float(0x425d10b2), SkBits2Float(0xc2887541), SkBits2Float(0x428cd9cf), SkBits2Float(0xc22fb184));
6916path.cubicTo(SkBits2Float(0x42ab2b45), SkBits2Float(0xc19cf10c), SkBits2Float(0x42ae472d), SkBits2Float(0x412c96c0), SkBits2Float(0x42951360), SkBits2Float(0x42120c0f));
6917path.cubicTo(SkBits2Float(0x429023a5), SkBits2Float(0x422633cd), SkBits2Float(0x428a3193), SkBits2Float(0x42394df4), SkBits2Float(0x42835484), SkBits2Float(0x424b0f7e));
6918path.lineTo(SkBits2Float(0x423ddffa), SkBits2Float(0x4212ca6e));
6919path.cubicTo(SkBits2Float(0x4247cc4f), SkBits2Float(0x4205f480), SkBits2Float(0x425064e4), SkBits2Float(0x41f04ae6), SkBits2Float(0x425787f7), SkBits2Float(0x41d32707));
6920path.cubicTo(SkBits2Float(0x427bf7e0), SkBits2Float(0x40f986c2), SkBits2Float(0x4277792b), SkBits2Float(0xc162e746), SkBits2Float(0x424ba3c8), SkBits2Float(0xc1fe03ba));
6921path.cubicTo(SkBits2Float(0x421fce66), SkBits2Float(0xc24549e8), SkBits2Float(0x41a5a922), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
6922path.close();
6923
6924 SkPath path1(path);
6925 path.reset();
6926 path.setFillType((SkPathFillType) 0);
6927path.moveTo(SkBits2Float(0x42835484), SkBits2Float(0x424b0f7e));
6928path.cubicTo(SkBits2Float(0x423aab34), SkBits2Float(0x4296ad9b), SkBits2Float(0x41789cf4), SkBits2Float(0x42ae7f70), SkBits2Float(0xc1702bd2), SkBits2Float(0x42a3434e));
6929path.cubicTo(SkBits2Float(0xc2363d27), SkBits2Float(0x4298072c), SkBits2Float(0xc28cd4c4), SkBits2Float(0x42573cf7), SkBits2Float(0xc29edb8e), SkBits2Float(0x41c0adb0));
6930path.cubicTo(SkBits2Float(0xc2b0e257), SkBits2Float(0xc0b47a14), SkBits2Float(0xc2a03550), SkBits2Float(0xc217a35b), SkBits2Float(0xc2674746), SkBits2Float(0xc26e3089));
6931path.lineTo(SkBits2Float(0xc2273070), SkBits2Float(0xc22c2f6e));
6932path.cubicTo(SkBits2Float(0xc267a050), SkBits2Float(0xc1db3c5e), SkBits2Float(0xc27fbc5f), SkBits2Float(0xc0827737), SkBits2Float(0xc265ac62), SkBits2Float(0x418b490c));
6933path.cubicTo(SkBits2Float(0xc24b9c64), SkBits2Float(0x421b97f2), SkBits2Float(0xc203bd1c), SkBits2Float(0x425bcc95), SkBits2Float(0xc12d9e08), SkBits2Float(0x426c0adc));
6934path.cubicTo(SkBits2Float(0x4133b85e), SkBits2Float(0x427c4921), SkBits2Float(0x4206f0f2), SkBits2Float(0x4259d90a), SkBits2Float(0x423ddff7), SkBits2Float(0x4212ca73));
6935path.lineTo(SkBits2Float(0x42835484), SkBits2Float(0x424b0f7e));
6936path.close();
6937
6938 SkPath path2(path);
6939 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6940}

◆ battleOp253()

static void battleOp253 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6943 of file PathOpsBattles.cpp.

6943 {
6944 SkPath path;
6945 path.setFillType((SkPathFillType) 0);
6946path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6947path.cubicTo(SkBits2Float(0x41ea9e19), SkBits2Float(0xc2a60000), SkBits2Float(0x4261e8db), SkBits2Float(0xc2870be6), SkBits2Float(0x428ed6bc), SkBits2Float(0xc22926d7));
6948path.cubicTo(SkBits2Float(0x42acb90a), SkBits2Float(0xc1886bc1), SkBits2Float(0x42adc0f7), SkBits2Float(0x41631db6), SkBits2Float(0x42918cff), SkBits2Float(0x421fa302));
6949path.lineTo(SkBits2Float(0x42526f53), SkBits2Float(0x41e6ccd4));
6950path.cubicTo(SkBits2Float(0x427b35d6), SkBits2Float(0x41242e26), SkBits2Float(0x4279b842), SkBits2Float(0xc1453c2f), SkBits2Float(0x424e8393), SkBits2Float(0xc1f48e84));
6951path.cubicTo(SkBits2Float(0x42234ee4), SkBits2Float(0xc2433f78), SkBits2Float(0x41a99a66), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6952path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
6953path.close();
6954
6955 SkPath path1(path);
6956 path.reset();
6957 path.setFillType((SkPathFillType) 0);
6958path.moveTo(SkBits2Float(0x42918d00), SkBits2Float(0x421fa301));
6959path.cubicTo(SkBits2Float(0x428c0830), SkBits2Float(0x4233c399), SkBits2Float(0x42857bfe), SkBits2Float(0x4246b13f), SkBits2Float(0x427c06a0), SkBits2Float(0x42581e30));
6960path.lineTo(SkBits2Float(0x42362ff8), SkBits2Float(0x421c3ad6));
6961path.cubicTo(SkBits2Float(0x4240fd4a), SkBits2Float(0x420fa210), SkBits2Float(0x424a74b5), SkBits2Float(0x4201f32f), SkBits2Float(0x42526f54), SkBits2Float(0x41e6ccd5));
6962path.lineTo(SkBits2Float(0x42918d00), SkBits2Float(0x421fa301));
6963path.close();
6964
6965 SkPath path2(path);
6966 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
6967}

◆ battleOp254()

static void battleOp254 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 6970 of file PathOpsBattles.cpp.

6970 {
6971 SkPath path;
6972 path.setFillType((SkPathFillType) 1);
6973path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6974path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
6975path.cubicTo(SkBits2Float(0x41ea9e19), SkBits2Float(0xc2a60000), SkBits2Float(0x4261e8db), SkBits2Float(0xc2870be6), SkBits2Float(0x428ed6bc), SkBits2Float(0xc22926d7));
6976path.cubicTo(SkBits2Float(0x42acb90a), SkBits2Float(0xc1886bc1), SkBits2Float(0x42adc0f7), SkBits2Float(0x41631db6), SkBits2Float(0x42918d00), SkBits2Float(0x421fa301));
6977path.cubicTo(SkBits2Float(0x428c0830), SkBits2Float(0x4233c399), SkBits2Float(0x42857bfe), SkBits2Float(0x4246b13f), SkBits2Float(0x427c06a0), SkBits2Float(0x42581e30));
6978path.lineTo(SkBits2Float(0x42362ff8), SkBits2Float(0x421c3ad6));
6979path.cubicTo(SkBits2Float(0x4240fd4a), SkBits2Float(0x420fa210), SkBits2Float(0x424a74b5), SkBits2Float(0x4201f32f), SkBits2Float(0x42526f53), SkBits2Float(0x41e6ccd4));
6980path.cubicTo(SkBits2Float(0x427b35d6), SkBits2Float(0x41242e26), SkBits2Float(0x4279b842), SkBits2Float(0xc1453c2f), SkBits2Float(0x424e8393), SkBits2Float(0xc1f48e84));
6981path.cubicTo(SkBits2Float(0x42234ee4), SkBits2Float(0xc2433f78), SkBits2Float(0x41a99a66), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
6982path.close();
6983
6984 SkPath path1(path);
6985 path.reset();
6986 path.setFillType((SkPathFillType) 0);
6987path.moveTo(SkBits2Float(0x427c069f), SkBits2Float(0x42581e31));
6988path.cubicTo(SkBits2Float(0x4229355f), SkBits2Float(0x429c5901), SkBits2Float(0x4119ef9b), SkBits2Float(0x42b0b9f6), SkBits2Float(0xc1a91754), SkBits2Float(0x42a086fc));
6989path.cubicTo(SkBits2Float(0xc24f933a), SkBits2Float(0x42905402), SkBits2Float(0xc296a2af), SkBits2Float(0x423cccf9), SkBits2Float(0xc2a2e3f0), SkBits2Float(0x417fd713));
6990path.cubicTo(SkBits2Float(0xc2af2532), SkBits2Float(0xc17385be), SkBits2Float(0xc296a6d5), SkBits2Float(0xc23cbfbd), SkBits2Float(0xc247a7c9), SkBits2Float(0xc284a101));
6991path.lineTo(SkBits2Float(0xc210544b), SkBits2Float(0xc23fc0ab));
6992path.cubicTo(SkBits2Float(0xc259cf4c), SkBits2Float(0xc20871e9), SkBits2Float(0xc27d38da), SkBits2Float(0xc1300a36), SkBits2Float(0xc26b810f), SkBits2Float(0x4138f1f1));
6993path.cubicTo(SkBits2Float(0xc259c944), SkBits2Float(0x42087b85), SkBits2Float(0xc2160de3), SkBits2Float(0x4250aad1), SkBits2Float(0xc174780b), SkBits2Float(0x42681670));
6994path.cubicTo(SkBits2Float(0x40de8efd), SkBits2Float(0x427f820e), SkBits2Float(0x41f4a392), SkBits2Float(0x42620b79), SkBits2Float(0x42362ffc), SkBits2Float(0x421c3ad2));
6995path.lineTo(SkBits2Float(0x427c069f), SkBits2Float(0x42581e31));
6996path.close();
6997
6998 SkPath path2(path);
6999 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7000}

◆ battleOp255()

static void battleOp255 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7003 of file PathOpsBattles.cpp.

7003 {
7004 SkPath path;
7005 path.setFillType((SkPathFillType) 0);
7006path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7007path.cubicTo(SkBits2Float(0x41eeb164), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42658277), SkBits2Float(0xc285f892), SkBits2Float(0x42904565), SkBits2Float(0xc22437b5));
7008path.cubicTo(SkBits2Float(0x42adc98d), SkBits2Float(0xc171f916), SkBits2Float(0x42ad3226), SkBits2Float(0x4185deb6), SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bae));
7009path.lineTo(SkBits2Float(0x424e5857), SkBits2Float(0x41f5204e));
7010path.cubicTo(SkBits2Float(0x427a675d), SkBits2Float(0x41418c03), SkBits2Float(0x427b4242), SkBits2Float(0xc12eeb9a), SkBits2Float(0x425095b0), SkBits2Float(0xc1ed6c50));
7011path.cubicTo(SkBits2Float(0x4225e91e), SkBits2Float(0xc241b169), SkBits2Float(0x41ac8c92), SkBits2Float(0xc2700000), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
7012path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7013path.close();
7014
7015 SkPath path1(path);
7016 path.reset();
7017 path.setFillType((SkPathFillType) 0);
7018path.moveTo(SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bad));
7019path.cubicTo(SkBits2Float(0x4288c365), SkBits2Float(0x423d9c15), SkBits2Float(0x4281c36f), SkBits2Float(0x42505c7e), SkBits2Float(0x4273ad50), SkBits2Float(0x42617d52));
7020path.lineTo(SkBits2Float(0x423026ec), SkBits2Float(0x42230126));
7021path.cubicTo(SkBits2Float(0x423b9c18), SkBits2Float(0x42169f65), SkBits2Float(0x4245bae4), SkBits2Float(0x42091136), SkBits2Float(0x424e5858), SkBits2Float(0x41f5204d));
7022path.lineTo(SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bad));
7023path.close();
7024
7025 SkPath path2(path);
7026 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7027}

◆ battleOp256()

static void battleOp256 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7030 of file PathOpsBattles.cpp.

7030 {
7031 SkPath path;
7032 path.setFillType((SkPathFillType) 1);
7033path.moveTo(SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
7034path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7035path.cubicTo(SkBits2Float(0x41eeb164), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42658277), SkBits2Float(0xc285f892), SkBits2Float(0x42904565), SkBits2Float(0xc22437b5));
7036path.cubicTo(SkBits2Float(0x42adc98d), SkBits2Float(0xc171f917), SkBits2Float(0x42ad3226), SkBits2Float(0x4185deb4), SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bad));
7037path.lineTo(SkBits2Float(0x428eb8d5), SkBits2Float(0x42298bae));
7038path.cubicTo(SkBits2Float(0x4288c365), SkBits2Float(0x423d9c16), SkBits2Float(0x4281c36f), SkBits2Float(0x42505c7e), SkBits2Float(0x4273ad50), SkBits2Float(0x42617d52));
7039path.lineTo(SkBits2Float(0x423026ec), SkBits2Float(0x42230126));
7040path.cubicTo(SkBits2Float(0x423b9c18), SkBits2Float(0x42169f65), SkBits2Float(0x4245bae4), SkBits2Float(0x42091136), SkBits2Float(0x424e5858), SkBits2Float(0x41f5204d));
7041path.cubicTo(SkBits2Float(0x427a675e), SkBits2Float(0x41418c02), SkBits2Float(0x427b4242), SkBits2Float(0xc12eeb9b), SkBits2Float(0x425095b0), SkBits2Float(0xc1ed6c50));
7042path.cubicTo(SkBits2Float(0x4225e91e), SkBits2Float(0xc241b169), SkBits2Float(0x41ac8c92), SkBits2Float(0xc2700000), SkBits2Float(0xb69400ae), SkBits2Float(0xc2700000));
7043path.close();
7044
7045 SkPath path1(path);
7046 path.reset();
7047 path.setFillType((SkPathFillType) 0);
7048path.moveTo(SkBits2Float(0x4273ad4f), SkBits2Float(0x42617d52));
7049path.cubicTo(SkBits2Float(0x421bc173), SkBits2Float(0x42a0404f), SkBits2Float(0x40a50405), SkBits2Float(0x42b1dfaa), SkBits2Float(0xc1cd0022), SkBits2Float(0x429de3fd));
7050path.cubicTo(SkBits2Float(0xc261a0a2), SkBits2Float(0x4289e850), SkBits2Float(0xc29d25ee), SkBits2Float(0x4227ed4e), SkBits2Float(0xc2a4d3d8), SkBits2Float(0x411d8f80));
7051path.cubicTo(SkBits2Float(0xc2ac81c3), SkBits2Float(0xc1b24b1c), SkBits2Float(0xc28e216c), SkBits2Float(0xc256e38c), SkBits2Float(0xc22e0453), SkBits2Float(0xc28d5ec3));
7052path.lineTo(SkBits2Float(0xc1fb9743), SkBits2Float(0xc24c63fd));
7053path.cubicTo(SkBits2Float(0xc24d7d6b), SkBits2Float(0xc21b575f), SkBits2Float(0xc279684a), SkBits2Float(0xc180e302), SkBits2Float(0xc26e4dff), SkBits2Float(0x40e3cc4e));
7054path.cubicTo(SkBits2Float(0xc26333b4), SkBits2Float(0x41f2c929), SkBits2Float(0xc2231aa4), SkBits2Float(0x42476256), SkBits2Float(0xc1943166), SkBits2Float(0x4264467e));
7055path.cubicTo(SkBits2Float(0x406e93d1), SkBits2Float(0x42809553), SkBits2Float(0x41e1305a), SkBits2Float(0x4267b03c), SkBits2Float(0x423026ed), SkBits2Float(0x42230127));
7056path.lineTo(SkBits2Float(0x4273ad4f), SkBits2Float(0x42617d52));
7057path.close();
7058
7059 SkPath path2(path);
7060 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7061}

◆ battleOp257()

static void battleOp257 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7064 of file PathOpsBattles.cpp.

7064 {
7065 SkPath path;
7066 path.setFillType((SkPathFillType) 0);
7067path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7068path.cubicTo(SkBits2Float(0x41f2d268), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426923a2), SkBits2Float(0xc284dd06), SkBits2Float(0x4291aced), SkBits2Float(0xc21f2e53));
7069path.cubicTo(SkBits2Float(0x42aec809), SkBits2Float(0xc1528a66), SkBits2Float(0x42ac7c90), SkBits2Float(0x419a60b1), SkBits2Float(0x428bb0fe), SkBits2Float(0x42335ba0));
7070path.lineTo(SkBits2Float(0x4249f6a4), SkBits2Float(0x4201a806));
7071path.cubicTo(SkBits2Float(0x427960d2), SkBits2Float(0x415f325f), SkBits2Float(0x427cb22e), SkBits2Float(0xc11832b1), SkBits2Float(0x42529d7e), SkBits2Float(0xc1e62422));
7072path.cubicTo(SkBits2Float(0x422888ce), SkBits2Float(0xc2401775), SkBits2Float(0x41af88b3), SkBits2Float(0xc2700000), SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
7073path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7074path.close();
7075
7076 SkPath path1(path);
7077 path.reset();
7078 path.setFillType((SkPathFillType) 0);
7079path.moveTo(SkBits2Float(0x428bb0ff), SkBits2Float(0x42335ba2));
7080path.cubicTo(SkBits2Float(0x4285489d), SkBits2Float(0x42475206), SkBits2Float(0x427ba631), SkBits2Float(0x4259da14), SkBits2Float(0x426ae250), SkBits2Float(0x426aa282));
7081path.lineTo(SkBits2Float(0x4229cbb3), SkBits2Float(0x42299d92));
7082path.cubicTo(SkBits2Float(0x4235ea43), SkBits2Float(0x421d7bb7), SkBits2Float(0x4240b302), SkBits2Float(0x42101649), SkBits2Float(0x4249f6a5), SkBits2Float(0x4201a807));
7083path.lineTo(SkBits2Float(0x428bb0ff), SkBits2Float(0x42335ba2));
7084path.close();
7085
7086 SkPath path2(path);
7087 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7088}

◆ battleOp258()

static void battleOp258 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7091 of file PathOpsBattles.cpp.

7091 {
7092 SkPath path;
7093 path.setFillType((SkPathFillType) 1);
7094path.moveTo(SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
7095path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7096path.cubicTo(SkBits2Float(0x41f2d268), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426923a2), SkBits2Float(0xc284dd06), SkBits2Float(0x4291aced), SkBits2Float(0xc21f2e53));
7097path.cubicTo(SkBits2Float(0x42aec809), SkBits2Float(0xc1528a66), SkBits2Float(0x42ac7c90), SkBits2Float(0x419a60b1), SkBits2Float(0x428bb0ff), SkBits2Float(0x42335ba2));
7098path.cubicTo(SkBits2Float(0x4285489d), SkBits2Float(0x42475206), SkBits2Float(0x427ba631), SkBits2Float(0x4259da14), SkBits2Float(0x426ae250), SkBits2Float(0x426aa282));
7099path.lineTo(SkBits2Float(0x4229cbb3), SkBits2Float(0x42299d92));
7100path.cubicTo(SkBits2Float(0x4235ea43), SkBits2Float(0x421d7bb7), SkBits2Float(0x4240b302), SkBits2Float(0x42101649), SkBits2Float(0x4249f6a4), SkBits2Float(0x4201a806));
7101path.cubicTo(SkBits2Float(0x427960d2), SkBits2Float(0x415f325f), SkBits2Float(0x427cb22e), SkBits2Float(0xc11832b1), SkBits2Float(0x42529d7e), SkBits2Float(0xc1e62422));
7102path.cubicTo(SkBits2Float(0x422888ce), SkBits2Float(0xc2401775), SkBits2Float(0x41af88b3), SkBits2Float(0xc2700000), SkBits2Float(0x36d3ff52), SkBits2Float(0xc2700000));
7103path.close();
7104
7105 SkPath path1(path);
7106 path.reset();
7107 path.setFillType((SkPathFillType) 0);
7108path.moveTo(SkBits2Float(0x426ae251), SkBits2Float(0x426aa281));
7109path.cubicTo(SkBits2Float(0x420dcd2c), SkBits2Float(0x42a3e87c), SkBits2Float(0x3f1c0197), SkBits2Float(0x42b294d6), SkBits2Float(0xc1f0a2ab), SkBits2Float(0x429ab731));
7110path.cubicTo(SkBits2Float(0xc27312b1), SkBits2Float(0x4282d98e), SkBits2Float(0xc2a300b1), SkBits2Float(0x4211eaa7), SkBits2Float(0xc2a5d865), SkBits2Float(0x40654aaf));
7111path.cubicTo(SkBits2Float(0xc2a8b018), SkBits2Float(0xc1ea82a2), SkBits2Float(0xc2845e8a), SkBits2Float(0xc26fc272), SkBits2Float(0xc2128ebb), SkBits2Float(0xc294f34d));
7112path.lineTo(SkBits2Float(0xc1d3e3ef), SkBits2Float(0xc2575999));
7113path.cubicTo(SkBits2Float(0xc23f6093), SkBits2Float(0xc22d51f6), SkBits2Float(0xc273e2d0), SkBits2Float(0xc1a9868a), SkBits2Float(0xc26fc6b5), SkBits2Float(0x4025c090));
7114path.cubicTo(SkBits2Float(0xc26baa9a), SkBits2Float(0x41d2f6ae), SkBits2Float(0xc22fb71e), SkBits2Float(0x423d2e2a), SkBits2Float(0xc1adf403), SkBits2Float(0x425faf61));
7115path.cubicTo(SkBits2Float(0x3ee18e9e), SkBits2Float(0x4281184d), SkBits2Float(0x41cd03a3), SkBits2Float(0x426cf9bf), SkBits2Float(0x4229cbb7), SkBits2Float(0x42299d90));
7116path.lineTo(SkBits2Float(0x426ae251), SkBits2Float(0x426aa281));
7117path.close();
7118
7119 SkPath path2(path);
7120 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7121}

◆ battleOp259()

static void battleOp259 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7124 of file PathOpsBattles.cpp.

7124 {
7125 SkPath path;
7126 path.setFillType((SkPathFillType) 0);
7127path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7128path.cubicTo(SkBits2Float(0x41f70d18), SkBits2Float(0xc2a60000), SkBits2Float(0x426cd682), SkBits2Float(0xc283b5d2), SkBits2Float(0x429310ae), SkBits2Float(0xc219fc22));
7129path.cubicTo(SkBits2Float(0x42afb61c), SkBits2Float(0xc132327f), SkBits2Float(0x42ab9c4e), SkBits2Float(0x41af4ab2), SkBits2Float(0x42886baa), SkBits2Float(0x423d2918));
7130path.lineTo(SkBits2Float(0x42453c0d), SkBits2Float(0x4208be17));
7131path.cubicTo(SkBits2Float(0x42781c98), SkBits2Float(0x417d6f0f), SkBits2Float(0x427e0a5e), SkBits2Float(0xc100d142), SkBits2Float(0x42549fd3), SkBits2Float(0xc1dea0fa));
7132path.cubicTo(SkBits2Float(0x422b3547), SkBits2Float(0xc23e6ca9), SkBits2Float(0x41b29756), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
7133path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7134path.close();
7135
7136 SkPath path1(path);
7137 path.reset();
7138 path.setFillType((SkPathFillType) 0);
7139path.moveTo(SkBits2Float(0x42886bab), SkBits2Float(0x423d2917));
7140path.cubicTo(SkBits2Float(0x42818ce6), SkBits2Float(0x4250fab6), SkBits2Float(0x42733ded), SkBits2Float(0x42633df9), SkBits2Float(0x42618b96), SkBits2Float(0x4273a01b));
7141path.lineTo(SkBits2Float(0x42230b75), SkBits2Float(0x42301d61));
7142path.cubicTo(SkBits2Float(0x422fd668), SkBits2Float(0x4224457a), SkBits2Float(0x423b4d41), SkBits2Float(0x421711c6), SkBits2Float(0x42453c0e), SkBits2Float(0x4208be17));
7143path.lineTo(SkBits2Float(0x42886bab), SkBits2Float(0x423d2917));
7144path.close();
7145
7146 SkPath path2(path);
7147 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7148}

◆ battleOp26()

static void battleOp26 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 757 of file PathOpsBattles.cpp.

757 {
758 SkPath path;
759 path.setFillType((SkPathFillType) 0);
760path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
761path.cubicTo(SkBits2Float(0x40b98c15), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41394aaf), SkBits2Float(0xc2a4c8e8), SkBits2Float(0x418a04fa), SkBits2Float(0xc2a25fd2));
762path.lineTo(SkBits2Float(0x41478bd6), SkBits2Float(0xc26ac20e));
763path.cubicTo(SkBits2Float(0x4105f224), SkBits2Float(0xc26e3e3c), SkBits2Float(0x40862167), SkBits2Float(0xc2700000), SkBits2Float(0xb4d00ae8), SkBits2Float(0xc2700000));
764path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
765path.close();
766
767 SkPath path1(path);
768 path.reset();
769 path.setFillType((SkPathFillType) 0);
770path.moveTo(SkBits2Float(0x418a04fd), SkBits2Float(0xc2a25fd2));
771path.cubicTo(SkBits2Float(0x418e8d81), SkBits2Float(0xc2a2222a), SkBits2Float(0x41931368), SkBits2Float(0xc2a1e17a), SkBits2Float(0x41979681), SkBits2Float(0xc2a19dc3));
772path.lineTo(SkBits2Float(0x415b29c8), SkBits2Float(0xc269a97e));
773path.cubicTo(SkBits2Float(0x4154a3c3), SkBits2Float(0xc26a0b66), SkBits2Float(0x414e19b0), SkBits2Float(0xc26a68ed), SkBits2Float(0x41478bd5), SkBits2Float(0xc26ac20f));
774path.lineTo(SkBits2Float(0x418a04fd), SkBits2Float(0xc2a25fd2));
775path.close();
776
777 SkPath path2(path);
778 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
779}

◆ battleOp260()

static void battleOp260 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7151 of file PathOpsBattles.cpp.

7151 {
7152 SkPath path;
7153 path.setFillType((SkPathFillType) 1);
7154path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
7155path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7156path.cubicTo(SkBits2Float(0x41f70d18), SkBits2Float(0xc2a60000), SkBits2Float(0x426cd682), SkBits2Float(0xc283b5d2), SkBits2Float(0x429310ae), SkBits2Float(0xc219fc22));
7157path.cubicTo(SkBits2Float(0x42afb61c), SkBits2Float(0xc132327f), SkBits2Float(0x42ab9c4e), SkBits2Float(0x41af4ab2), SkBits2Float(0x42886bab), SkBits2Float(0x423d2917));
7158path.cubicTo(SkBits2Float(0x42818ce6), SkBits2Float(0x4250fab6), SkBits2Float(0x42733ded), SkBits2Float(0x42633df9), SkBits2Float(0x42618b96), SkBits2Float(0x4273a01b));
7159path.lineTo(SkBits2Float(0x42230b75), SkBits2Float(0x42301d61));
7160path.cubicTo(SkBits2Float(0x422fd668), SkBits2Float(0x4224457a), SkBits2Float(0x423b4d41), SkBits2Float(0x421711c6), SkBits2Float(0x42453c0d), SkBits2Float(0x4208be17));
7161path.cubicTo(SkBits2Float(0x42781c98), SkBits2Float(0x417d6f0f), SkBits2Float(0x427e0a5e), SkBits2Float(0xc100d142), SkBits2Float(0x42549fd3), SkBits2Float(0xc1dea0fa));
7162path.cubicTo(SkBits2Float(0x422b3547), SkBits2Float(0xc23e6ca9), SkBits2Float(0x41b29756), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
7163path.close();
7164
7165 SkPath path1(path);
7166 path.reset();
7167 path.setFillType((SkPathFillType) 0);
7168path.moveTo(SkBits2Float(0x42618b95), SkBits2Float(0x4273a01c));
7169path.cubicTo(SkBits2Float(0x41fe659e), SkBits2Float(0x42a75638), SkBits2Float(0xc081f8cf), SkBits2Float(0x42b2d4b3), SkBits2Float(0xc20a1eaa), SkBits2Float(0x4296f3e7));
7170path.cubicTo(SkBits2Float(0xc281ff1e), SkBits2Float(0x42762634), SkBits2Float(0xc2a8320c), SkBits2Float(0x41f52b39), SkBits2Float(0xc2a5e71e), SkBits2Float(0xc035be80));
7171path.cubicTo(SkBits2Float(0xc2a39c30), SkBits2Float(0xc2114d6a), SkBits2Float(0xc2728d06), SkBits2Float(0xc283ad37), SkBits2Float(0xc1ea4cbe), SkBits2Float(0xc29b5279));
7172path.lineTo(SkBits2Float(0xc1a95f99), SkBits2Float(0xc2608fe9));
7173path.cubicTo(SkBits2Float(0xc22f5688), SkBits2Float(0xc23e6034), SkBits2Float(0xc26c8b72), SkBits2Float(0xc1d2135a), SkBits2Float(0xc26fdc03), SkBits2Float(0xc003615b));
7174path.cubicTo(SkBits2Float(0xc2732c96), SkBits2Float(0x41b13b02), SkBits2Float(0xc23bf25c), SkBits2Float(0x4231f06e), SkBits2Float(0xc1c7b0f0), SkBits2Float(0x425a3eb1));
7175path.cubicTo(SkBits2Float(0xc03be91a), SkBits2Float(0x4281467b), SkBits2Float(0x41b7e6c5), SkBits2Float(0x4271eec4), SkBits2Float(0x42230b77), SkBits2Float(0x42301d61));
7176path.lineTo(SkBits2Float(0x42618b95), SkBits2Float(0x4273a01c));
7177path.close();
7178
7179 SkPath path2(path);
7180 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7181}

◆ battleOp261()

static void battleOp261 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7184 of file PathOpsBattles.cpp.

7184 {
7185 SkPath path;
7186 path.setFillType((SkPathFillType) 0);
7187path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7188path.cubicTo(SkBits2Float(0x41f9750b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426eeefa), SkBits2Float(0xc2830bb8), SkBits2Float(0x4293d569), SkBits2Float(0xc2170343));
7189path.cubicTo(SkBits2Float(0x42b03354), SkBits2Float(0xc11fbc55), SkBits2Float(0x42ab0b89), SkBits2Float(0x41bb247a), SkBits2Float(0x42867c8e), SkBits2Float(0x42429f12));
7190path.lineTo(SkBits2Float(0x42427039), SkBits2Float(0x420cb0ae));
7191path.cubicTo(SkBits2Float(0x42774b4a), SkBits2Float(0x418748a6), SkBits2Float(0x427ebf70), SkBits2Float(0xc0e6f16a), SkBits2Float(0x4255bc46), SkBits2Float(0xc1da54e8));
7192path.cubicTo(SkBits2Float(0x422cb91b), SkBits2Float(0xc23d76ba), SkBits2Float(0x41b454a4), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
7193path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7194path.close();
7195
7196 SkPath path1(path);
7197 path.reset();
7198 path.setFillType((SkPathFillType) 0);
7199path.moveTo(SkBits2Float(0x42867c8e), SkBits2Float(0x42429f13));
7200path.cubicTo(SkBits2Float(0x427eb473), SkBits2Float(0x4256572c), SkBits2Float(0x426e4fbb), SkBits2Float(0x42686e49), SkBits2Float(0x425c16a2), SkBits2Float(0x427890ea));
7201path.lineTo(SkBits2Float(0x421f199c), SkBits2Float(0x4233afb3));
7202path.cubicTo(SkBits2Float(0x422c45f9), SkBits2Float(0x422805b5), SkBits2Float(0x42381fbf), SkBits2Float(0x421af1ea), SkBits2Float(0x4242703a), SkBits2Float(0x420cb0af));
7203path.lineTo(SkBits2Float(0x42867c8e), SkBits2Float(0x42429f13));
7204path.close();
7205
7206 SkPath path2(path);
7207 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7208}

◆ battleOp262()

static void battleOp262 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7211 of file PathOpsBattles.cpp.

7211 {
7212 SkPath path;
7213 path.setFillType((SkPathFillType) 1);
7214path.moveTo(SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
7215path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7216path.cubicTo(SkBits2Float(0x41f9750b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x426eeefa), SkBits2Float(0xc2830bb8), SkBits2Float(0x4293d569), SkBits2Float(0xc2170343));
7217path.cubicTo(SkBits2Float(0x42b03354), SkBits2Float(0xc11fbc55), SkBits2Float(0x42ab0b89), SkBits2Float(0x41bb247a), SkBits2Float(0x42867c8e), SkBits2Float(0x42429f13));
7218path.cubicTo(SkBits2Float(0x427eb473), SkBits2Float(0x4256572c), SkBits2Float(0x426e4fbb), SkBits2Float(0x42686e49), SkBits2Float(0x425c16a2), SkBits2Float(0x427890ea));
7219path.lineTo(SkBits2Float(0x421f199c), SkBits2Float(0x4233afb3));
7220path.cubicTo(SkBits2Float(0x422c45f9), SkBits2Float(0x422805b5), SkBits2Float(0x42381fbf), SkBits2Float(0x421af1ea), SkBits2Float(0x42427039), SkBits2Float(0x420cb0ae));
7221path.cubicTo(SkBits2Float(0x42774b4a), SkBits2Float(0x418748a6), SkBits2Float(0x427ebf70), SkBits2Float(0xc0e6f16a), SkBits2Float(0x4255bc46), SkBits2Float(0xc1da54e8));
7222path.cubicTo(SkBits2Float(0x422cb91b), SkBits2Float(0xc23d76ba), SkBits2Float(0x41b454a4), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
7223path.close();
7224
7225 SkPath path1(path);
7226 path.reset();
7227 path.setFillType((SkPathFillType) 0);
7228path.moveTo(SkBits2Float(0x425c16a1), SkBits2Float(0x427890eb));
7229path.cubicTo(SkBits2Float(0x41ed85e5), SkBits2Float(0x42a9245e), SkBits2Float(0xc0d70d9a), SkBits2Float(0x42b2c211), SkBits2Float(0xc2140612), SkBits2Float(0x42949665));
7230path.cubicTo(SkBits2Float(0xc2869539), SkBits2Float(0x426cd56f), SkBits2Float(0xc2aac701), SkBits2Float(0x41d9ff9c), SkBits2Float(0xc2a57e3b), SkBits2Float(0xc0cf6824));
7231path.cubicTo(SkBits2Float(0xc2a03574), SkBits2Float(0xc220d9d7), SkBits2Float(0xc26501e3), SkBits2Float(0xc289ed78), SkBits2Float(0xc1c7e516), SkBits2Float(0xc29e4c97));
7232path.lineTo(SkBits2Float(0xc190809e), SkBits2Float(0xc264ddc3));
7233path.cubicTo(SkBits2Float(0xc2258c2b), SkBits2Float(0xc24769d4), SkBits2Float(0xc267a08f), SkBits2Float(0xc1e88e39), SkBits2Float(0xc26f4461), SkBits2Float(0xc095eec9));
7234path.cubicTo(SkBits2Float(0xc276e835), SkBits2Float(0x419d96da), SkBits2Float(0xc24293e3), SkBits2Float(0x422b3483), SkBits2Float(0xc1d60298), SkBits2Float(0x4256d347));
7235path.cubicTo(SkBits2Float(0xc09b75b0), SkBits2Float(0x42813905), SkBits2Float(0x41abb417), SkBits2Float(0x42748af0), SkBits2Float(0x421f199e), SkBits2Float(0x4233afb2));
7236path.lineTo(SkBits2Float(0x425c16a1), SkBits2Float(0x427890eb));
7237path.close();
7238
7239 SkPath path2(path);
7240 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7241}

◆ battleOp263()

static void battleOp263 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7244 of file PathOpsBattles.cpp.

7244 {
7245 SkPath path;
7246 path.setFillType((SkPathFillType) 0);
7247path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7248path.cubicTo(SkBits2Float(0x41fc38da), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4271556b), SkBits2Float(0xc2824656), SkBits2Float(0x4294b266), SkBits2Float(0xc213956f));
7249path.cubicTo(SkBits2Float(0x42b0ba15), SkBits2Float(0xc10a78c9), SkBits2Float(0x42aa55de), SkBits2Float(0x41c8b65d), SkBits2Float(0x42843343), SkBits2Float(0x4248ca15));
7250path.lineTo(SkBits2Float(0x423f2206), SkBits2Float(0x42112621));
7251path.cubicTo(SkBits2Float(0x427644a6), SkBits2Float(0x419117e2), SkBits2Float(0x427f8241), SkBits2Float(0xc0c83353), SkBits2Float(0x4256fbc4), SkBits2Float(0xc1d55fc8));
7252path.cubicTo(SkBits2Float(0x422e7546), SkBits2Float(0xc23c595d), SkBits2Float(0x41b6544b), SkBits2Float(0xc2700002), SkBits2Float(0x357ffa8c), SkBits2Float(0xc2700000));
7253path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7254path.close();
7255
7256 SkPath path1(path);
7257 path.reset();
7258 path.setFillType((SkPathFillType) 0);
7259path.moveTo(SkBits2Float(0x42843344), SkBits2Float(0x4248ca14));
7260path.cubicTo(SkBits2Float(0x4279865a), SkBits2Float(0x425c60b2), SkBits2Float(0x426884b7), SkBits2Float(0x426e4097), SkBits2Float(0x4255b1c1), SkBits2Float(0x427e1584));
7261path.lineTo(SkBits2Float(0x421a7a55), SkBits2Float(0x4237acdc));
7262path.cubicTo(SkBits2Float(0x422815ec), SkBits2Float(0x422c3b08), SkBits2Float(0x42346121), SkBits2Float(0x421f4f28), SkBits2Float(0x423f2207), SkBits2Float(0x42112621));
7263path.lineTo(SkBits2Float(0x42843344), SkBits2Float(0x4248ca14));
7264path.close();
7265
7266 SkPath path2(path);
7267 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7268}

◆ battleOp264()

static void battleOp264 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7271 of file PathOpsBattles.cpp.

7271 {
7272 SkPath path;
7273 path.setFillType((SkPathFillType) 1);
7274path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7275path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7276path.cubicTo(SkBits2Float(0x41fc38da), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4271556b), SkBits2Float(0xc2824656), SkBits2Float(0x4294b266), SkBits2Float(0xc213956f));
7277path.cubicTo(SkBits2Float(0x42b0ba15), SkBits2Float(0xc10a78c9), SkBits2Float(0x42aa55de), SkBits2Float(0x41c8b65d), SkBits2Float(0x42843344), SkBits2Float(0x4248ca14));
7278path.cubicTo(SkBits2Float(0x4279865a), SkBits2Float(0x425c60b2), SkBits2Float(0x426884b7), SkBits2Float(0x426e4097), SkBits2Float(0x4255b1c1), SkBits2Float(0x427e1584));
7279path.lineTo(SkBits2Float(0x421a7a55), SkBits2Float(0x4237acdc));
7280path.cubicTo(SkBits2Float(0x422815ec), SkBits2Float(0x422c3b08), SkBits2Float(0x42346121), SkBits2Float(0x421f4f28), SkBits2Float(0x423f2206), SkBits2Float(0x42112621));
7281path.cubicTo(SkBits2Float(0x427644a6), SkBits2Float(0x419117e2), SkBits2Float(0x427f8241), SkBits2Float(0xc0c83353), SkBits2Float(0x4256fbc4), SkBits2Float(0xc1d55fc8));
7282path.cubicTo(SkBits2Float(0x422e7546), SkBits2Float(0xc23c595d), SkBits2Float(0x41b6544b), SkBits2Float(0xc2700002), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7283path.close();
7284
7285 SkPath path1(path);
7286 path.reset();
7287 path.setFillType((SkPathFillType) 0);
7288path.moveTo(SkBits2Float(0x4255b1c2), SkBits2Float(0x427e1586));
7289path.cubicTo(SkBits2Float(0x41d9eb88), SkBits2Float(0x42ab15b8), SkBits2Float(0xc11c5ee2), SkBits2Float(0x42b27b8c), SkBits2Float(0xc21f2fec), SkBits2Float(0x4291ac82));
7290path.cubicTo(SkBits2Float(0xc28ba40f), SkBits2Float(0x4261baf0), SkBits2Float(0xc2ad6782), SkBits2Float(0x41ba4aab), SkBits2Float(0xc2a4a120), SkBits2Float(0xc12a4d95));
7291path.cubicTo(SkBits2Float(0xc29bdabd), SkBits2Float(0xc2324c20), SkBits2Float(0xc254adab), SkBits2Float(0xc290ac19), SkBits2Float(0xc19fafc0), SkBits2Float(0xc2a120ca));
7292path.lineTo(SkBits2Float(0xc166df50), SkBits2Float(0xc268f4ce));
7293path.cubicTo(SkBits2Float(0xc219be54), SkBits2Float(0xc2512a28), SkBits2Float(0xc26154eb), SkBits2Float(0xc200e3bb), SkBits2Float(0xc26e04b2), SkBits2Float(0xc0f6387e));
7294path.cubicTo(SkBits2Float(0xc27ab479), SkBits2Float(0x4186ab35), SkBits2Float(0xc249e3ea), SkBits2Float(0x42232db1), SkBits2Float(0xc1e62664), SkBits2Float(0x42529ce0));
7295path.cubicTo(SkBits2Float(0xc0e213c9), SkBits2Float(0x42810608), SkBits2Float(0x419d8860), SkBits2Float(0x427759fd), SkBits2Float(0x421a7a58), SkBits2Float(0x4237acda));
7296path.lineTo(SkBits2Float(0x4255b1c2), SkBits2Float(0x427e1586));
7297path.close();
7298
7299 SkPath path2(path);
7300 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7301}

◆ battleOp265()

static void battleOp265 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7304 of file PathOpsBattles.cpp.

7304 {
7305 SkPath path;
7306 path.setFillType((SkPathFillType) 0);
7307path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7308path.cubicTo(SkBits2Float(0x41fe7454), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427343e8), SkBits2Float(0xc281a57b), SkBits2Float(0x429560d9), SkBits2Float(0xc210ce12));
7309path.cubicTo(SkBits2Float(0x42b11fbd), SkBits2Float(0xc0f2896e), SkBits2Float(0x42a9b750), SkBits2Float(0x41d3a0ba), SkBits2Float(0x42824e39), SkBits2Float(0x424daf12));
7310path.lineTo(SkBits2Float(0x423c64bf), SkBits2Float(0x4214afea));
7311path.cubicTo(SkBits2Float(0x42755f66), SkBits2Float(0x4198fbec), SkBits2Float(0x42800a9d), SkBits2Float(0xc0af53e2), SkBits2Float(0x4257f7fc), SkBits2Float(0xc1d15b49));
7312path.cubicTo(SkBits2Float(0x422fdabc), SkBits2Float(0xc23b70cc), SkBits2Float(0x41b7f168), SkBits2Float(0xc2700002), SkBits2Float(0xb5600574), SkBits2Float(0xc2700000));
7313path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7314path.close();
7315
7316 SkPath path1(path);
7317 path.reset();
7318 path.setFillType((SkPathFillType) 0);
7319path.moveTo(SkBits2Float(0x42824e38), SkBits2Float(0x424daf15));
7320path.cubicTo(SkBits2Float(0x42753e9a), SkBits2Float(0x4261276c), SkBits2Float(0x4263be9a), SkBits2Float(0x4272d73c), SkBits2Float(0x4250704b), SkBits2Float(0x428134df));
7321path.lineTo(SkBits2Float(0x4216adb6), SkBits2Float(0x423acdfc));
7322path.cubicTo(SkBits2Float(0x4224a276), SkBits2Float(0x422f8c2c), SkBits2Float(0x42314905), SkBits2Float(0x4222c30f), SkBits2Float(0x423c64c0), SkBits2Float(0x4214afec));
7323path.lineTo(SkBits2Float(0x42824e38), SkBits2Float(0x424daf15));
7324path.close();
7325
7326 SkPath path2(path);
7327 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7328}

◆ battleOp266()

static void battleOp266 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7331 of file PathOpsBattles.cpp.

7331 {
7332 SkPath path;
7333 path.setFillType((SkPathFillType) 1);
7334path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7335path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7336path.cubicTo(SkBits2Float(0x41fe7454), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427343e8), SkBits2Float(0xc281a57b), SkBits2Float(0x429560d9), SkBits2Float(0xc210ce12));
7337path.cubicTo(SkBits2Float(0x42b11fbd), SkBits2Float(0xc0f2896e), SkBits2Float(0x42a9b750), SkBits2Float(0x41d3a0ba), SkBits2Float(0x42824e39), SkBits2Float(0x424daf12));
7338path.lineTo(SkBits2Float(0x42824e38), SkBits2Float(0x424daf15));
7339path.cubicTo(SkBits2Float(0x42753e9a), SkBits2Float(0x4261276c), SkBits2Float(0x4263be9a), SkBits2Float(0x4272d73c), SkBits2Float(0x4250704b), SkBits2Float(0x428134df));
7340path.lineTo(SkBits2Float(0x4216adb6), SkBits2Float(0x423acdfc));
7341path.cubicTo(SkBits2Float(0x4224a276), SkBits2Float(0x422f8c2c), SkBits2Float(0x42314905), SkBits2Float(0x4222c30f), SkBits2Float(0x423c64c0), SkBits2Float(0x4214afec));
7342path.lineTo(SkBits2Float(0x423c64bf), SkBits2Float(0x4214afea));
7343path.cubicTo(SkBits2Float(0x42755f66), SkBits2Float(0x4198fbec), SkBits2Float(0x42800a9d), SkBits2Float(0xc0af53e2), SkBits2Float(0x4257f7fc), SkBits2Float(0xc1d15b49));
7344path.cubicTo(SkBits2Float(0x422fdabc), SkBits2Float(0xc23b70cc), SkBits2Float(0x41b7f168), SkBits2Float(0xc2700002), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7345path.close();
7346
7347 SkPath path1(path);
7348 path.reset();
7349 path.setFillType((SkPathFillType) 0);
7350path.moveTo(SkBits2Float(0x4250704d), SkBits2Float(0x428134e0));
7351path.cubicTo(SkBits2Float(0x41c9effb), SkBits2Float(0x42ac8cba), SkBits2Float(0xc143bd6b), SkBits2Float(0x42b21c58), SkBits2Float(0xc2280561), SkBits2Float(0x428f2c0c));
7352path.cubicTo(SkBits2Float(0xc28f8db2), SkBits2Float(0x42587782), SkBits2Float(0xc2af41ba), SkBits2Float(0x41a05b8a), SkBits2Float(0xc2a3a0d2), SkBits2Float(0xc15fb01a));
7353path.cubicTo(SkBits2Float(0xc297ffea), SkBits2Float(0xc24005d3), SkBits2Float(0xc246ef26), SkBits2Float(0xc295c2d5), SkBits2Float(0xc17d9b57), SkBits2Float(0xc2a2f1e8));
7354path.lineTo(SkBits2Float(0xc1375488), SkBits2Float(0xc26b9543));
7355path.cubicTo(SkBits2Float(0xc20fcecd), SkBits2Float(0xc25885a3), SkBits2Float(0xc25bc22e), SkBits2Float(0xc20acfc5), SkBits2Float(0xc26c9222), SkBits2Float(0xc121b3b7));
7356path.cubicTo(SkBits2Float(0xc27d6216), SkBits2Float(0x4167d7a5), SkBits2Float(0xc24f8c13), SkBits2Float(0x421c7b68), SkBits2Float(0xc1f2ebf9), SkBits2Float(0x424efee8));
7357path.cubicTo(SkBits2Float(0xc10d7f99), SkBits2Float(0x4280c134), SkBits2Float(0x4191fa9e), SkBits2Float(0x4279782f), SkBits2Float(0x4216adb8), SkBits2Float(0x423acdfc));
7358path.lineTo(SkBits2Float(0x4250704d), SkBits2Float(0x428134e0));
7359path.close();
7360
7361 SkPath path2(path);
7362 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7363}

◆ battleOp267()

static void battleOp267 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7366 of file PathOpsBattles.cpp.

7366 {
7367 SkPath path;
7368 path.setFillType((SkPathFillType) 0);
7369path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7370path.cubicTo(SkBits2Float(0x42003b3a), SkBits2Float(0xc2a60000), SkBits2Float(0x4274ff8d), SkBits2Float(0xc28113a0), SkBits2Float(0x4295fac2), SkBits2Float(0xc20e4c24));
7371path.cubicTo(SkBits2Float(0x42b175be), SkBits2Float(0xc0d38840), SkBits2Float(0x42a91fa3), SkBits2Float(0x41dd6a3d), SkBits2Float(0x42809081), SkBits2Float(0x4252054f));
7372path.lineTo(SkBits2Float(0x4239e059), SkBits2Float(0x4217d27c));
7373path.cubicTo(SkBits2Float(0x4274841b), SkBits2Float(0x41a00f1c), SkBits2Float(0x428048c8), SkBits2Float(0xc098ea38), SkBits2Float(0x4258d681), SkBits2Float(0xc1cdbb32));
7374path.cubicTo(SkBits2Float(0x42311b71), SkBits2Float(0xc23a9deb), SkBits2Float(0x41b96511), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
7375path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7376path.close();
7377
7378 SkPath path1(path);
7379 path.reset();
7380 path.setFillType((SkPathFillType) 0);
7381path.moveTo(SkBits2Float(0x42809082), SkBits2Float(0x4252054e));
7382path.cubicTo(SkBits2Float(0x4271521d), SkBits2Float(0x42655feb), SkBits2Float(0x425f60c7), SkBits2Float(0x4276e1ca), SkBits2Float(0x424ba43f), SkBits2Float(0x42831ae1));
7383path.lineTo(SkBits2Float(0x421335f7), SkBits2Float(0x423d8ca7));
7384path.cubicTo(SkBits2Float(0x42217a65), SkBits2Float(0x4232780c), SkBits2Float(0x422e72e3), SkBits2Float(0x4225d023), SkBits2Float(0x4239e05a), SkBits2Float(0x4217d27c));
7385path.lineTo(SkBits2Float(0x42809082), SkBits2Float(0x4252054e));
7386path.close();
7387
7388 SkPath path2(path);
7389 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7390}

◆ battleOp268()

static void battleOp268 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7393 of file PathOpsBattles.cpp.

7393 {
7394 SkPath path;
7395 path.setFillType((SkPathFillType) 1);
7396path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
7397path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7398path.cubicTo(SkBits2Float(0x42003b3a), SkBits2Float(0xc2a60000), SkBits2Float(0x4274ff8d), SkBits2Float(0xc28113a0), SkBits2Float(0x4295fac2), SkBits2Float(0xc20e4c24));
7399path.cubicTo(SkBits2Float(0x42b175be), SkBits2Float(0xc0d38840), SkBits2Float(0x42a91fa3), SkBits2Float(0x41dd6a3d), SkBits2Float(0x42809082), SkBits2Float(0x4252054e));
7400path.cubicTo(SkBits2Float(0x4271521d), SkBits2Float(0x42655feb), SkBits2Float(0x425f60c7), SkBits2Float(0x4276e1ca), SkBits2Float(0x424ba43f), SkBits2Float(0x42831ae1));
7401path.lineTo(SkBits2Float(0x421335f7), SkBits2Float(0x423d8ca7));
7402path.cubicTo(SkBits2Float(0x42217a65), SkBits2Float(0x4232780c), SkBits2Float(0x422e72e3), SkBits2Float(0x4225d023), SkBits2Float(0x4239e059), SkBits2Float(0x4217d27c));
7403path.cubicTo(SkBits2Float(0x4274841b), SkBits2Float(0x41a00f1c), SkBits2Float(0x428048c8), SkBits2Float(0xc098ea38), SkBits2Float(0x4258d681), SkBits2Float(0xc1cdbb32));
7404path.cubicTo(SkBits2Float(0x42311b71), SkBits2Float(0xc23a9deb), SkBits2Float(0x41b96511), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
7405path.close();
7406
7407 SkPath path1(path);
7408 path.reset();
7409 path.setFillType((SkPathFillType) 0);
7410path.moveTo(SkBits2Float(0x424ba440), SkBits2Float(0x42831ae2));
7411path.cubicTo(SkBits2Float(0x41bb72ba), SkBits2Float(0x42adc9b8), SkBits2Float(0xc16714ca), SkBits2Float(0x42b1a998), SkBits2Float(0xc22fd30d), SkBits2Float(0x428ccf5c));
7412path.cubicTo(SkBits2Float(0xc292f074), SkBits2Float(0x424fea41), SkBits2Float(0xc2b0b757), SkBits2Float(0x4188cdbd), SkBits2Float(0xc2a27f7d), SkBits2Float(0xc187abb1));
7413path.cubicTo(SkBits2Float(0xc29447a3), SkBits2Float(0xc24c1290), SkBits2Float(0xc23a2b5e), SkBits2Float(0xc29a0e93), SkBits2Float(0xc141f42b), SkBits2Float(0xc2a43853));
7414path.lineTo(SkBits2Float(0xc10c3538), SkBits2Float(0xc26d6d31));
7415path.cubicTo(SkBits2Float(0xc2069491), SkBits2Float(0xc25ebb9d), SkBits2Float(0xc2566164), SkBits2Float(0xc21385b2), SkBits2Float(0xc26aefd1), SkBits2Float(0xc1442672));
7416path.cubicTo(SkBits2Float(0xc27f7e3e), SkBits2Float(0x4145c9dc), SkBits2Float(0xc2547130), SkBits2Float(0x42164ccc), SkBits2Float(0xc1fe3427), SkBits2Float(0x424b94a6));
7417path.cubicTo(SkBits2Float(0xc1270bd9), SkBits2Float(0x42806e40), SkBits2Float(0x41878138), SkBits2Float(0x427b4278), SkBits2Float(0x421335f8), SkBits2Float(0x423d8ca8));
7418path.lineTo(SkBits2Float(0x424ba440), SkBits2Float(0x42831ae2));
7419path.close();
7420
7421 SkPath path2(path);
7422 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7423}

◆ battleOp269()

static void battleOp269 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7426 of file PathOpsBattles.cpp.

7426 {
7427 SkPath path;
7428 path.setFillType((SkPathFillType) 0);
7429path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7430path.cubicTo(SkBits2Float(0x42011047), SkBits2Float(0xc2a60000), SkBits2Float(0x42766e56), SkBits2Float(0xc28099ef), SkBits2Float(0x42967824), SkBits2Float(0xc20c36c8));
7431path.cubicTo(SkBits2Float(0x42b1b91c), SkBits2Float(0xc0b9cd9b), SkBits2Float(0x42a89b7a), SkBits2Float(0x41e5804f), SkBits2Float(0x427e310b), SkBits2Float(0x42559106));
7432path.lineTo(SkBits2Float(0x4237c0bf), SkBits2Float(0x421a62ac));
7433path.cubicTo(SkBits2Float(0x4273c506), SkBits2Float(0x41a5e791), SkBits2Float(0x4280797a), SkBits2Float(0xc08650bf), SkBits2Float(0x42598bc5), SkBits2Float(0xc1cab811));
7434path.cubicTo(SkBits2Float(0x42322494), SkBits2Float(0xc239edfa), SkBits2Float(0x41ba9913), SkBits2Float(0xc2700002), SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
7435path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7436path.close();
7437
7438 SkPath path1(path);
7439 path.reset();
7440 path.setFillType((SkPathFillType) 0);
7441path.moveTo(SkBits2Float(0x427e3109), SkBits2Float(0x42559108));
7442path.cubicTo(SkBits2Float(0x426e0477), SkBits2Float(0x4268d13b), SkBits2Float(0x425bb575), SkBits2Float(0x427a2b1d), SkBits2Float(0x42479e2a), SkBits2Float(0x4284a4a0));
7443path.lineTo(SkBits2Float(0x42104d52), SkBits2Float(0x423fc5ea));
7444path.cubicTo(SkBits2Float(0x421ed35e), SkBits2Float(0x4234d83a), SkBits2Float(0x422c0f91), SkBits2Float(0x42284d3a), SkBits2Float(0x4237c0bf), SkBits2Float(0x421a62ad));
7445path.lineTo(SkBits2Float(0x427e3109), SkBits2Float(0x42559108));
7446path.close();
7447
7448 SkPath path2(path);
7449 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7450}

◆ battleOp27()

static void battleOp27 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 782 of file PathOpsBattles.cpp.

782 {
783 SkPath path;
784 path.setFillType((SkPathFillType) 1);
785path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
786path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
787path.cubicTo(SkBits2Float(0x40b98c15), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41394aaf), SkBits2Float(0xc2a4c8e8), SkBits2Float(0x418a04fd), SkBits2Float(0xc2a25fd2));
788path.cubicTo(SkBits2Float(0x418e8d81), SkBits2Float(0xc2a2222a), SkBits2Float(0x41931368), SkBits2Float(0xc2a1e17a), SkBits2Float(0x41979681), SkBits2Float(0xc2a19dc3));
789path.lineTo(SkBits2Float(0x415b29c8), SkBits2Float(0xc269a97e));
790path.cubicTo(SkBits2Float(0x4154a3c3), SkBits2Float(0xc26a0b66), SkBits2Float(0x414e19b0), SkBits2Float(0xc26a68ed), SkBits2Float(0x41478bd6), SkBits2Float(0xc26ac20e));
791path.cubicTo(SkBits2Float(0x4105f224), SkBits2Float(0xc26e3e3c), SkBits2Float(0x40862167), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
792path.close();
793
794 SkPath path1(path);
795 path.reset();
796 path.setFillType((SkPathFillType) 0);
797path.moveTo(SkBits2Float(0x41979680), SkBits2Float(0xc2a19dc4));
798path.cubicTo(SkBits2Float(0x41e0e1b2), SkBits2Float(0xc29d51d4), SkBits2Float(0x42135c08), SkBits2Float(0xc295f036), SkBits2Float(0x42330e86), SkBits2Float(0xc28bc9b7));
799path.lineTo(SkBits2Float(0x42017048), SkBits2Float(0xc24a1a63));
800path.cubicTo(SkBits2Float(0x41d50cc4), SkBits2Float(0xc258c742), SkBits2Float(0x41a290a5), SkBits2Float(0xc263733c), SkBits2Float(0x415b29c7), SkBits2Float(0xc269a980));
801path.lineTo(SkBits2Float(0x41979680), SkBits2Float(0xc2a19dc4));
802path.close();
803
804 SkPath path2(path);
805 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
806}

◆ battleOp270()

static void battleOp270 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7453 of file PathOpsBattles.cpp.

7453 {
7454 SkPath path;
7455 path.setFillType((SkPathFillType) 1);
7456path.moveTo(SkBits2Float(0xb7060057), SkBits2Float(0xc2700000));
7457path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7458path.cubicTo(SkBits2Float(0x42011047), SkBits2Float(0xc2a60000), SkBits2Float(0x42766e56), SkBits2Float(0xc28099ef), SkBits2Float(0x42967824), SkBits2Float(0xc20c36c8));
7459path.cubicTo(SkBits2Float(0x42b1b91c), SkBits2Float(0xc0b9cd9b), SkBits2Float(0x42a89b7a), SkBits2Float(0x41e5804f), SkBits2Float(0x427e310b), SkBits2Float(0x42559106));
7460path.lineTo(SkBits2Float(0x4237c0bf), SkBits2Float(0x421a62ad));
7461
7462 SkPath path1(path);
7463 path.reset();
7464 path.setFillType((SkPathFillType) 0);
7465path.moveTo(SkBits2Float(0x42479e29), SkBits2Float(0x4284a4a0));
7466path.cubicTo(SkBits2Float(0x41af5d68), SkBits2Float(0x42aec1b4), SkBits2Float(0xc1822698), SkBits2Float(0x42b135a9), SkBits2Float(0xc2362f3e), SkBits2Float(0x428ac623));
7467path.cubicTo(SkBits2Float(0xc295a599), SkBits2Float(0x4248ad36), SkBits2Float(0xc2b1c6ab), SkBits2Float(0x416a48a9), SkBits2Float(0xc2a165f3), SkBits2Float(0xc19b42cf));
7468path.cubicTo(SkBits2Float(0xc291053c), SkBits2Float(0xc255d4f6), SkBits2Float(0xc22f520a), SkBits2Float(0xc29d68ba), SkBits2Float(0xc110422a), SkBits2Float(0xc2a50486));
7469path.lineTo(SkBits2Float(0xc0d09136), SkBits2Float(0xc26e946c));
7470path.cubicTo(SkBits2Float(0xc1fd79b9), SkBits2Float(0xc2639452), SkBits2Float(0xc251ab0b), SkBits2Float(0xc21a93c1), SkBits2Float(0xc26958c8), SkBits2Float(0xc1607927));
7471path.cubicTo(SkBits2Float(0xc2808342), SkBits2Float(0x41295cae), SkBits2Float(0xc2585b55), SkBits2Float(0x42111142), SkBits2Float(0xc203b318), SkBits2Float(0x4248a313));
7472path.cubicTo(SkBits2Float(0xc13c2b63), SkBits2Float(0x42801a73), SkBits2Float(0x417d8a30), SkBits2Float(0x427ca903), SkBits2Float(0x42104d56), SkBits2Float(0x423fc5e8));
7473path.lineTo(SkBits2Float(0x42479e29), SkBits2Float(0x4284a4a0));
7474path.close();
7475
7476 SkPath path2(path);
7477 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7478}

◆ battleOp271()

static void battleOp271 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7481 of file PathOpsBattles.cpp.

7481 {
7482 SkPath path;
7483 path.setFillType((SkPathFillType) 0);
7484path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7485path.cubicTo(SkBits2Float(0x4201b43a), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4277880a), SkBits2Float(0xc2803bc7), SkBits2Float(0x4296d747), SkBits2Float(0xc20a9b85));
7486path.cubicTo(SkBits2Float(0x42b1ea89), SkBits2Float(0xc0a5fbe3), SkBits2Float(0x42a831cc), SkBits2Float(0x41ebb52f), SkBits2Float(0x427be65b), SkBits2Float(0x425843c9));
7487path.lineTo(SkBits2Float(0x423618a6), SkBits2Float(0x421c5604));
7488path.cubicTo(SkBits2Float(0x42732c40), SkBits2Float(0x41aa6424), SkBits2Float(0x42809d37), SkBits2Float(0xc06ffa1c), SkBits2Float(0x425a1555), SkBits2Float(0xc1c8657d));
7489path.cubicTo(SkBits2Float(0x4232f03c), SkBits2Float(0xc23965db), SkBits2Float(0x41bb8620), SkBits2Float(0xc2700002), SkBits2Float(0xb5600574), SkBits2Float(0xc2700000));
7490path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7491path.close();
7492
7493 SkPath path1(path);
7494 path.reset();
7495 path.setFillType((SkPathFillType) 0);
7496path.moveTo(SkBits2Float(0x427be65e), SkBits2Float(0x425843c9));
7497path.cubicTo(SkBits2Float(0x426b71bd), SkBits2Float(0x426b6e8c), SkBits2Float(0x4258dad9), SkBits2Float(0x427ca87a), SkBits2Float(0x42447e14), SkBits2Float(0x4285cdfb));
7498path.lineTo(SkBits2Float(0x420e0af4), SkBits2Float(0x424173d3));
7499path.cubicTo(SkBits2Float(0x421cc338), SkBits2Float(0x4236a4f9), SkBits2Float(0x422a3361), SkBits2Float(0x422a3113), SkBits2Float(0x423618a6), SkBits2Float(0x421c5605));
7500path.lineTo(SkBits2Float(0x427be65e), SkBits2Float(0x425843c9));
7501path.close();
7502
7503 SkPath path2(path);
7504 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7505}

◆ battleOp272()

static void battleOp272 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7508 of file PathOpsBattles.cpp.

7508 {
7509 SkPath path;
7510 path.setFillType((SkPathFillType) 1);
7511path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7512path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7513path.cubicTo(SkBits2Float(0x4201b43a), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4277880a), SkBits2Float(0xc2803bc7), SkBits2Float(0x4296d747), SkBits2Float(0xc20a9b85));
7514path.cubicTo(SkBits2Float(0x42b1ea89), SkBits2Float(0xc0a5fbe3), SkBits2Float(0x42a831cc), SkBits2Float(0x41ebb52f), SkBits2Float(0x427be65b), SkBits2Float(0x425843c9));
7515path.lineTo(SkBits2Float(0x427be65e), SkBits2Float(0x425843c9));
7516path.cubicTo(SkBits2Float(0x426b71bd), SkBits2Float(0x426b6e8c), SkBits2Float(0x4258dad9), SkBits2Float(0x427ca87a), SkBits2Float(0x42447e14), SkBits2Float(0x4285cdfb));
7517path.lineTo(SkBits2Float(0x420e0af4), SkBits2Float(0x424173d3));
7518path.cubicTo(SkBits2Float(0x421cc338), SkBits2Float(0x4236a4f9), SkBits2Float(0x422a3361), SkBits2Float(0x422a3113), SkBits2Float(0x423618a6), SkBits2Float(0x421c5605));
7519path.lineTo(SkBits2Float(0x423618a6), SkBits2Float(0x421c5604));
7520path.cubicTo(SkBits2Float(0x42732c40), SkBits2Float(0x41aa6424), SkBits2Float(0x42809d37), SkBits2Float(0xc06ffa1c), SkBits2Float(0x425a1555), SkBits2Float(0xc1c8657d));
7521path.cubicTo(SkBits2Float(0x4232f03c), SkBits2Float(0xc23965db), SkBits2Float(0x41bb8620), SkBits2Float(0xc2700002), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7522path.close();
7523
7524 SkPath path1(path);
7525 path.reset();
7526 path.setFillType((SkPathFillType) 0);
7527path.moveTo(SkBits2Float(0x42447e16), SkBits2Float(0x4285cdfb));
7528path.cubicTo(SkBits2Float(0x41a605d7), SkBits2Float(0x42af776a), SkBits2Float(0xc18d5e26), SkBits2Float(0x42b0cfa2), SkBits2Float(0xc23b02ad), SkBits2Float(0x428928e1));
7529path.cubicTo(SkBits2Float(0xc297ab24), SkBits2Float(0x42430442), SkBits2Float(0xc2b27fa9), SkBits2Float(0x414bdf0d), SkBits2Float(0xc2a073c8), SkBits2Float(0xc1aa3a13));
7530path.cubicTo(SkBits2Float(0xc28e67e7), SkBits2Float(0xc25d31d4), SkBits2Float(0xc226d0a4), SkBits2Float(0xc29fdb7e), SkBits2Float(0xc0d3d11a), SkBits2Float(0xc2a578a5));
7531path.lineTo(SkBits2Float(0xc0991eb2), SkBits2Float(0xc26f3c4f));
7532path.cubicTo(SkBits2Float(0xc1f12d9c), SkBits2Float(0xc2671e82), SkBits2Float(0xc24de350), SkBits2Float(0xc21fe656), SkBits2Float(0xc267faa7), SkBits2Float(0xc1761c74));
7533path.cubicTo(SkBits2Float(0xc28108ff), SkBits2Float(0x4113607a), SkBits2Float(0xc25b4798), SkBits2Float(0x420cf9d1), SkBits2Float(0xc207302c), SkBits2Float(0x42464d9a));
7534path.cubicTo(SkBits2Float(0xc14c6303), SkBits2Float(0x427fa162), SkBits2Float(0x4170087f), SkBits2Float(0x427dafb7), SkBits2Float(0x420e0af6), SkBits2Float(0x424173d2));
7535path.lineTo(SkBits2Float(0x42447e16), SkBits2Float(0x4285cdfb));
7536path.close();
7537
7538 SkPath path2(path);
7539 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7540}

◆ battleOp273()

static void battleOp273 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7543 of file PathOpsBattles.cpp.

7543 {
7544 SkPath path;
7545 path.setFillType((SkPathFillType) 0);
7546path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7547path.cubicTo(SkBits2Float(0x42023f77), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427876e4), SkBits2Float(0xc27fd6f4), SkBits2Float(0x42972728), SkBits2Float(0xc2093dbb));
7548path.cubicTo(SkBits2Float(0x42b212de), SkBits2Float(0xc0952410), SkBits2Float(0x42a7d55b), SkBits2Float(0x41f0f791), SkBits2Float(0x4279eebf), SkBits2Float(0x425a890b));
7549path.lineTo(SkBits2Float(0x4234ac95), SkBits2Float(0x421dfa35));
7550path.cubicTo(SkBits2Float(0x4272a697), SkBits2Float(0x41ae3171), SkBits2Float(0x4280ba5e), SkBits2Float(0xc057a00f), SkBits2Float(0x425a88d0), SkBits2Float(0xc1c66bc2));
7551path.cubicTo(SkBits2Float(0x42339ce5), SkBits2Float(0xc238f1c1), SkBits2Float(0x41bc4f6b), SkBits2Float(0xc2700002), SkBits2Float(0xb630015d), SkBits2Float(0xc2700000));
7552path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7553path.close();
7554
7555 SkPath path1(path);
7556 path.reset();
7557 path.setFillType((SkPathFillType) 0);
7558path.moveTo(SkBits2Float(0x4279eebd), SkBits2Float(0x425a890e));
7559path.cubicTo(SkBits2Float(0x42693cf3), SkBits2Float(0x426da0dc), SkBits2Float(0x42566929), SkBits2Float(0x427ebed8), SkBits2Float(0x4241d1ac), SkBits2Float(0x4286c6a2));
7560path.lineTo(SkBits2Float(0x420c1c33), SkBits2Float(0x4242db53));
7561path.cubicTo(SkBits2Float(0x421afee9), SkBits2Float(0x42382742), SkBits2Float(0x42289b18), SkBits2Float(0x422bc78f), SkBits2Float(0x4234ac94), SkBits2Float(0x421dfa34));
7562path.lineTo(SkBits2Float(0x4279eebd), SkBits2Float(0x425a890e));
7563path.close();
7564
7565 SkPath path2(path);
7566 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7567}

◆ battleOp274()

static void battleOp274 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7570 of file PathOpsBattles.cpp.

7570 {
7571 SkPath path;
7572 path.setFillType((SkPathFillType) 1);
7573path.moveTo(SkBits2Float(0xb630015d), SkBits2Float(0xc2700000));
7574path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7575path.cubicTo(SkBits2Float(0x42023f77), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427876e4), SkBits2Float(0xc27fd6f4), SkBits2Float(0x42972728), SkBits2Float(0xc2093dbb));
7576path.cubicTo(SkBits2Float(0x42b212de), SkBits2Float(0xc0952410), SkBits2Float(0x42a7d55b), SkBits2Float(0x41f0f791), SkBits2Float(0x4279eebf), SkBits2Float(0x425a890b));
7577path.lineTo(SkBits2Float(0x4234ac95), SkBits2Float(0x421dfa35));
7578path.cubicTo(SkBits2Float(0x4272a697), SkBits2Float(0x41ae3171), SkBits2Float(0x4280ba5e), SkBits2Float(0xc057a00f), SkBits2Float(0x425a88d0), SkBits2Float(0xc1c66bc2));
7579path.cubicTo(SkBits2Float(0x42339ce5), SkBits2Float(0xc238f1c1), SkBits2Float(0x41bc4f6b), SkBits2Float(0xc2700002), SkBits2Float(0xb630015d), SkBits2Float(0xc2700000));
7580path.close();
7581
7582 SkPath path1(path);
7583 path.reset();
7584 path.setFillType((SkPathFillType) 0);
7585path.moveTo(SkBits2Float(0x4241d1ad), SkBits2Float(0x4286c6a2));
7586path.cubicTo(SkBits2Float(0x419e0f8e), SkBits2Float(0x42b00b7b), SkBits2Float(0xc196dfc4), SkBits2Float(0x42b07042), SkBits2Float(0xc23f0fa7), SkBits2Float(0x4287c1be));
7587path.cubicTo(SkBits2Float(0xc29957b6), SkBits2Float(0x423e2672), SkBits2Float(0xc2b30c7a), SkBits2Float(0x4131f351), SkBits2Float(0xc29f94d8), SkBits2Float(0xc1b6db1d));
7588path.cubicTo(SkBits2Float(0xc28c1d38), SkBits2Float(0xc26357ee), SkBits2Float(0xc21f7d48), SkBits2Float(0xc2a1d87d), SkBits2Float(0xc09294c7), SkBits2Float(0xc2a5bf3c));
7589path.lineTo(SkBits2Float(0xc053ec94), SkBits2Float(0xc26fa25d));
7590path.cubicTo(SkBits2Float(0xc1e69644), SkBits2Float(0xc269fe64), SkBits2Float(0xc24a931a), SkBits2Float(0xc224583b), SkBits2Float(0xc266b858), SkBits2Float(0xc1842f59));
7591path.cubicTo(SkBits2Float(0xc2816ecb), SkBits2Float(0x4100a388), SkBits2Float(0xc25db33b), SkBits2Float(0x42097539), SkBits2Float(0xc20a1dd2), SkBits2Float(0x4244465c));
7592path.cubicTo(SkBits2Float(0xc15a2194), SkBits2Float(0x427f177f), SkBits2Float(0x41648588), SkBits2Float(0x427e85cc), SkBits2Float(0x420c1c35), SkBits2Float(0x4242db52));
7593path.lineTo(SkBits2Float(0x4241d1ad), SkBits2Float(0x4286c6a2));
7594path.close();
7595
7596 SkPath path2(path);
7597 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7598}

◆ battleOp275()

static void battleOp275 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7601 of file PathOpsBattles.cpp.

7601 {
7602 SkPath path;
7603 path.setFillType((SkPathFillType) 0);
7604path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7605path.cubicTo(SkBits2Float(0x4202aab9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42792ea4), SkBits2Float(0xc27f5acc), SkBits2Float(0x4297641b), SkBits2Float(0xc2082fee));
7606path.cubicTo(SkBits2Float(0x42b230e5), SkBits2Float(0xc0882884), SkBits2Float(0x42a78c73), SkBits2Float(0x41f502e3), SkBits2Float(0x4278676f), SkBits2Float(0x425c4571));
7607path.lineTo(SkBits2Float(0x423391b8), SkBits2Float(0x421f3b73));
7608path.cubicTo(SkBits2Float(0x42723d33), SkBits2Float(0x41b11ddb), SkBits2Float(0x4280d014), SkBits2Float(0xc044db05), SkBits2Float(0x425ae0f2), SkBits2Float(0xc1c4e5b3));
7609path.cubicTo(SkBits2Float(0x423421be), SkBits2Float(0xc2389802), SkBits2Float(0x41bcea83), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
7610path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7611path.close();
7612
7613 SkPath path1(path);
7614 path.reset();
7615 path.setFillType((SkPathFillType) 0);
7616path.moveTo(SkBits2Float(0x42786771), SkBits2Float(0x425c4570));
7617path.cubicTo(SkBits2Float(0x42678692), SkBits2Float(0x426f4e2b), SkBits2Float(0x425483f6), SkBits2Float(0x42802b0f), SkBits2Float(0x423fbf6b), SkBits2Float(0x428783bc));
7618path.lineTo(SkBits2Float(0x420a9ce1), SkBits2Float(0x4243ecb9));
7619path.cubicTo(SkBits2Float(0x4219a02a), SkBits2Float(0x42394dac), SkBits2Float(0x42275e32), SkBits2Float(0x422cfde6), SkBits2Float(0x423391b8), SkBits2Float(0x421f3b72));
7620path.lineTo(SkBits2Float(0x42786771), SkBits2Float(0x425c4570));
7621path.close();
7622
7623 SkPath path2(path);
7624 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7625}

◆ battleOp276()

static void battleOp276 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7628 of file PathOpsBattles.cpp.

7628 {
7629 SkPath path;
7630 path.setFillType((SkPathFillType) 1);
7631path.moveTo(SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
7632path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7633path.cubicTo(SkBits2Float(0x4202aab9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42792ea4), SkBits2Float(0xc27f5acc), SkBits2Float(0x4297641b), SkBits2Float(0xc2082fee));
7634path.cubicTo(SkBits2Float(0x42b230e5), SkBits2Float(0xc0882884), SkBits2Float(0x42a78c73), SkBits2Float(0x41f502e3), SkBits2Float(0x4278676f), SkBits2Float(0x425c4571));
7635path.cubicTo(SkBits2Float(0x42678690), SkBits2Float(0x426f4e2b), SkBits2Float(0x425483f5), SkBits2Float(0x42802b0f), SkBits2Float(0x423fbf6b), SkBits2Float(0x428783bc));
7636path.lineTo(SkBits2Float(0x420a9ce1), SkBits2Float(0x4243ecb9));
7637path.cubicTo(SkBits2Float(0x4219a02a), SkBits2Float(0x42394dac), SkBits2Float(0x42275e32), SkBits2Float(0x422cfde7), SkBits2Float(0x423391b8), SkBits2Float(0x421f3b73));
7638path.lineTo(SkBits2Float(0x423391b8), SkBits2Float(0x421f3b72));
7639path.cubicTo(SkBits2Float(0x42723d33), SkBits2Float(0x41b11dd9), SkBits2Float(0x4280d014), SkBits2Float(0xc044db09), SkBits2Float(0x425ae0f2), SkBits2Float(0xc1c4e5b3));
7640path.cubicTo(SkBits2Float(0x423421be), SkBits2Float(0xc2389802), SkBits2Float(0x41bcea83), SkBits2Float(0xc2700000), SkBits2Float(0x3725ffa9), SkBits2Float(0xc2700000));
7641path.close();
7642
7643 SkPath path1(path);
7644 path.reset();
7645 path.setFillType((SkPathFillType) 0);
7646path.moveTo(SkBits2Float(0x423fbf6b), SkBits2Float(0x428783bc));
7647path.cubicTo(SkBits2Float(0x4197e908), SkBits2Float(0x42b0799e), SkBits2Float(0xc19e2f01), SkBits2Float(0x42b0215b), SkBits2Float(0xc24226b0), SkBits2Float(0x4286a80b));
7648path.cubicTo(SkBits2Float(0xc29a9aef), SkBits2Float(0x423a5d79), SkBits2Float(0xc2b36ebb), SkBits2Float(0x411dee4a), SkBits2Float(0xc29ede64), SkBits2Float(0xc1c087c1));
7649path.cubicTo(SkBits2Float(0xc28a4e0d), SkBits2Float(0xc2680353), SkBits2Float(0xc219c8f7), SkBits2Float(0xc2a351d0), SkBits2Float(0xc0409740), SkBits2Float(0xc2a5e40e));
7650path.lineTo(SkBits2Float(0xc00b391c), SkBits2Float(0xc26fd79b));
7651path.cubicTo(SkBits2Float(0xc1de5701), SkBits2Float(0xc26c1feb), SkBits2Float(0xc247f576), SkBits2Float(0xc227b85e), SkBits2Float(0xc265b08d), SkBits2Float(0xc18b2dac));
7652path.cubicTo(SkBits2Float(0xc281b5d1), SkBits2Float(0x40e45588), SkBits2Float(0xc25f8687), SkBits2Float(0x4206b8c8), SkBits2Float(0xc20c59a1), SkBits2Float(0x4242af19));
7653path.cubicTo(SkBits2Float(0xc164b2eb), SkBits2Float(0x427ea56a), SkBits2Float(0x415ba119), SkBits2Float(0x427f2508), SkBits2Float(0x420a9ce0), SkBits2Float(0x4243ecba));
7654path.lineTo(SkBits2Float(0x423fbf6b), SkBits2Float(0x428783bc));
7655path.close();
7656
7657 SkPath path2(path);
7658 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7659}

◆ battleOp277()

static void battleOp277 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7662 of file PathOpsBattles.cpp.

7662 {
7663 SkPath path;
7664 path.setFillType((SkPathFillType) 0);
7665path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7666path.cubicTo(SkBits2Float(0x4202f62b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4279afc7), SkBits2Float(0xc27f0340), SkBits2Float(0x42978eaf), SkBits2Float(0xc20771fd));
7667path.cubicTo(SkBits2Float(0x42b2457b), SkBits2Float(0xc07e0b91), SkBits2Float(0x42a7584a), SkBits2Float(0x41f7da1e), SkBits2Float(0x42775276), SkBits2Float(0x425d7c3f));
7668path.lineTo(SkBits2Float(0x4232c97e), SkBits2Float(0x42201c22));
7669path.cubicTo(SkBits2Float(0x4271f1c7), SkBits2Float(0x41b32b8d), SkBits2Float(0x4280def3), SkBits2Float(0xc037a5cf), SkBits2Float(0x425b1e7c), SkBits2Float(0xc1c3d316));
7670path.cubicTo(SkBits2Float(0x42347f10), SkBits2Float(0xc23858b9), SkBits2Float(0x41bd578b), SkBits2Float(0xc26fffff), SkBits2Float(0xb7240057), SkBits2Float(0xc26fffff));
7671path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7672path.close();
7673
7674 SkPath path1(path);
7675 path.reset();
7676 path.setFillType((SkPathFillType) 0);
7677path.moveTo(SkBits2Float(0x42775277), SkBits2Float(0x425d7c41));
7678path.cubicTo(SkBits2Float(0x4266507b), SkBits2Float(0x42707a20), SkBits2Float(0x42532cff), SkBits2Float(0x4280b928), SkBits2Float(0x423e48db), SkBits2Float(0x42880779));
7679path.lineTo(SkBits2Float(0x42098e1c), SkBits2Float(0x4244ab32));
7680path.cubicTo(SkBits2Float(0x4218a83e), SkBits2Float(0x423a1b21), SkBits2Float(0x42267e0b), SkBits2Float(0x422dd6be), SkBits2Float(0x4232c97e), SkBits2Float(0x42201c22));
7681path.lineTo(SkBits2Float(0x42775277), SkBits2Float(0x425d7c41));
7682path.close();
7683
7684 SkPath path2(path);
7685 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7686}

◆ battleOp278()

static void battleOp278 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7689 of file PathOpsBattles.cpp.

7689 {
7690 SkPath path;
7691 path.setFillType((SkPathFillType) 1);
7692path.moveTo(SkBits2Float(0xb7240057), SkBits2Float(0xc26fffff));
7693path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7694path.cubicTo(SkBits2Float(0x4202f62b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4279afc7), SkBits2Float(0xc27f0340), SkBits2Float(0x42978eaf), SkBits2Float(0xc20771fd));
7695path.cubicTo(SkBits2Float(0x42b2457b), SkBits2Float(0xc07e0b91), SkBits2Float(0x42a7584a), SkBits2Float(0x41f7da1e), SkBits2Float(0x42775276), SkBits2Float(0x425d7c3f));
7696path.lineTo(SkBits2Float(0x42775277), SkBits2Float(0x425d7c41));
7697path.cubicTo(SkBits2Float(0x4266507b), SkBits2Float(0x42707a20), SkBits2Float(0x42532cff), SkBits2Float(0x4280b928), SkBits2Float(0x423e48db), SkBits2Float(0x42880779));
7698path.lineTo(SkBits2Float(0x42098e1c), SkBits2Float(0x4244ab32));
7699path.cubicTo(SkBits2Float(0x4218a83e), SkBits2Float(0x423a1b21), SkBits2Float(0x42267e0b), SkBits2Float(0x422dd6be), SkBits2Float(0x4232c97e), SkBits2Float(0x42201c22));
7700path.cubicTo(SkBits2Float(0x4271f1c7), SkBits2Float(0x41b32b8d), SkBits2Float(0x4280def3), SkBits2Float(0xc037a5cf), SkBits2Float(0x425b1e7c), SkBits2Float(0xc1c3d316));
7701path.cubicTo(SkBits2Float(0x42347f10), SkBits2Float(0xc23858b9), SkBits2Float(0x41bd578b), SkBits2Float(0xc26fffff), SkBits2Float(0xb7240057), SkBits2Float(0xc26fffff));
7702path.close();
7703
7704 SkPath path1(path);
7705 path.reset();
7706 path.setFillType((SkPathFillType) 0);
7707path.moveTo(SkBits2Float(0x423e48db), SkBits2Float(0x4288077a));
7708path.cubicTo(SkBits2Float(0x41939344), SkBits2Float(0x42b0c509), SkBits2Float(0xc1a3515b), SkBits2Float(0x42afe6ff), SkBits2Float(0xc2444efb), SkBits2Float(0x4285df44));
7709path.cubicTo(SkBits2Float(0xc29b7aa2), SkBits2Float(0x4237af14), SkBits2Float(0xc2b3ae7d), SkBits2Float(0x410fd2d1), SkBits2Float(0xc29e5879), SkBits2Float(0xc1c74e5b));
7710path.cubicTo(SkBits2Float(0xc2890275), SkBits2Float(0xc26b4310), SkBits2Float(0xc215bdd9), SkBits2Float(0xc2a45375), SkBits2Float(0xbff3abc7), SkBits2Float(0xc2a5f4d2));
7711path.lineTo(SkBits2Float(0xbfb025f0), SkBits2Float(0xc26fefd6));
7712path.cubicTo(SkBits2Float(0xc1d87e6f), SkBits2Float(0xc26d946b), SkBits2Float(0xc246160c), SkBits2Float(0xc22a11a0), SkBits2Float(0xc264eef0), SkBits2Float(0xc190139e));
7713path.cubicTo(SkBits2Float(0xc281e3ea), SkBits2Float(0x40cff015), SkBits2Float(0xc260c9f8), SkBits2Float(0x4204c898), SkBits2Float(0xc20de8e2), SkBits2Float(0x42418cd3));
7714path.cubicTo(SkBits2Float(0xc16c1f36), SkBits2Float(0x427e510e), SkBits2Float(0x41555c9e), SkBits2Float(0x427f9213), SkBits2Float(0x42098e1b), SkBits2Float(0x4244ab33));
7715path.lineTo(SkBits2Float(0x423e48db), SkBits2Float(0x4288077a));
7716path.close();
7717
7718 SkPath path2(path);
7719 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7720}

◆ battleOp279()

static void battleOp279 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7723 of file PathOpsBattles.cpp.

7723 {
7724 SkPath path;
7725 path.setFillType((SkPathFillType) 0);
7726path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7727path.cubicTo(SkBits2Float(0x420331e6), SkBits2Float(0xc2a60000), SkBits2Float(0x427a15f4), SkBits2Float(0xc27ebdd3), SkBits2Float(0x4297b03a), SkBits2Float(0xc206db86));
7728path.cubicTo(SkBits2Float(0x42b2557a), SkBits2Float(0xc06f9378), SkBits2Float(0x42a72e7e), SkBits2Float(0x41fa194a), SkBits2Float(0x4276762d), SkBits2Float(0x425e7148));
7729path.lineTo(SkBits2Float(0x42322a40), SkBits2Float(0x4220cd43));
7730path.cubicTo(SkBits2Float(0x4271b558), SkBits2Float(0x41b4cb56), SkBits2Float(0x4280ea83), SkBits2Float(0xc02d3004), SkBits2Float(0x425b4efa), SkBits2Float(0xc1c2f986));
7731path.cubicTo(SkBits2Float(0x4234c8ee), SkBits2Float(0xc2382686), SkBits2Float(0x41bdadf1), SkBits2Float(0xc26fffff), SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
7732path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7733path.close();
7734
7735 SkPath path1(path);
7736 path.reset();
7737 path.setFillType((SkPathFillType) 0);
7738path.moveTo(SkBits2Float(0x4276762e), SkBits2Float(0x425e7147));
7739path.cubicTo(SkBits2Float(0x42655a01), SkBits2Float(0x42716669), SkBits2Float(0x42521c84), SkBits2Float(0x428128fd), SkBits2Float(0x423d1f69), SkBits2Float(0x42886f05));
7740path.lineTo(SkBits2Float(0x4208b718), SkBits2Float(0x424540e7));
7741path.cubicTo(SkBits2Float(0x4217e344), SkBits2Float(0x423abccf), SkBits2Float(0x4225cbdd), SkBits2Float(0x422e818f), SkBits2Float(0x42322a41), SkBits2Float(0x4220cd43));
7742path.lineTo(SkBits2Float(0x4276762e), SkBits2Float(0x425e7147));
7743path.close();
7744
7745 SkPath path2(path);
7746 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7747}

◆ battleOp28()

static void battleOp28 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 809 of file PathOpsBattles.cpp.

809 {
810 SkPath path;
811 path.setFillType((SkPathFillType) 0);
812path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
813path.cubicTo(SkBits2Float(0x40dd1e63), SkBits2Float(0xc2a5ffff), SkBits2Float(0x415caf98), SkBits2Float(0xc2a44632), SkBits2Float(0x41a3e96c), SkBits2Float(0xc2a0dcda));
814path.lineTo(SkBits2Float(0x416cfb1c), SkBits2Float(0xc2689294));
815path.cubicTo(SkBits2Float(0x411f8831), SkBits2Float(0xc26d8140), SkBits2Float(0x409fd849), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
816path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
817path.close();
818
819 SkPath path1(path);
820 path.reset();
821 path.setFillType((SkPathFillType) 0);
822path.moveTo(SkBits2Float(0x41a3e96b), SkBits2Float(0xc2a0dcda));
823path.cubicTo(SkBits2Float(0x41a94306), SkBits2Float(0xc2a085a1), SkBits2Float(0x41ae9839), SkBits2Float(0xc2a02a23), SkBits2Float(0x41b3e8b2), SkBits2Float(0xc29fca67));
824path.lineTo(SkBits2Float(0x41820dff), SkBits2Float(0xc26705ca));
825path.cubicTo(SkBits2Float(0x417c6d0a), SkBits2Float(0xc2679035), SkBits2Float(0x4174b742), SkBits2Float(0xc268147b), SkBits2Float(0x416cfb1d), SkBits2Float(0xc2689296));
826path.lineTo(SkBits2Float(0x41a3e96b), SkBits2Float(0xc2a0dcda));
827path.close();
828
829 SkPath path2(path);
830 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
831}

◆ battleOp280()

static void battleOp280 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7750 of file PathOpsBattles.cpp.

7750 {
7751 SkPath path;
7752 path.setFillType((SkPathFillType) 1);
7753path.moveTo(SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
7754path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7755path.cubicTo(SkBits2Float(0x420331e6), SkBits2Float(0xc2a60000), SkBits2Float(0x427a15f4), SkBits2Float(0xc27ebdd3), SkBits2Float(0x4297b03a), SkBits2Float(0xc206db86));
7756path.cubicTo(SkBits2Float(0x42b2557a), SkBits2Float(0xc06f937f), SkBits2Float(0x42a72e7e), SkBits2Float(0x41fa1948), SkBits2Float(0x4276762e), SkBits2Float(0x425e7147));
7757path.lineTo(SkBits2Float(0x4276762d), SkBits2Float(0x425e7148));
7758path.cubicTo(SkBits2Float(0x42655a00), SkBits2Float(0x4271666a), SkBits2Float(0x42521c84), SkBits2Float(0x428128fd), SkBits2Float(0x423d1f69), SkBits2Float(0x42886f05));
7759path.lineTo(SkBits2Float(0x4208b718), SkBits2Float(0x424540e7));
7760path.cubicTo(SkBits2Float(0x4217e344), SkBits2Float(0x423abccf), SkBits2Float(0x4225cbdd), SkBits2Float(0x422e818f), SkBits2Float(0x42322a41), SkBits2Float(0x4220cd43));
7761path.lineTo(SkBits2Float(0x42322a40), SkBits2Float(0x4220cd43));
7762path.cubicTo(SkBits2Float(0x4271b558), SkBits2Float(0x41b4cb56), SkBits2Float(0x4280ea83), SkBits2Float(0xc02d3004), SkBits2Float(0x425b4efa), SkBits2Float(0xc1c2f986));
7763path.cubicTo(SkBits2Float(0x4234c8ee), SkBits2Float(0xc2382686), SkBits2Float(0x41bdadf1), SkBits2Float(0xc26fffff), SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
7764path.close();
7765
7766 SkPath path1(path);
7767 path.reset();
7768 path.setFillType((SkPathFillType) 0);
7769path.moveTo(SkBits2Float(0x423d1f69), SkBits2Float(0x42886f06));
7770path.cubicTo(SkBits2Float(0x4190236c), SkBits2Float(0x42b0ff8c), SkBits2Float(0xc1a760b7), SkBits2Float(0x42afb726), SkBits2Float(0xc24601c7), SkBits2Float(0x42853ece));
7771path.cubicTo(SkBits2Float(0xc29c2998), SkBits2Float(0x42358ced), SkBits2Float(0xc2b3ddd5), SkBits2Float(0x4104a433), SkBits2Float(0xc29deb35), SkBits2Float(0xc1cca70e));
7772path.cubicTo(SkBits2Float(0xc287f895), SkBits2Float(0xc26dd020), SkBits2Float(0xc21285d2), SkBits2Float(0xc2a51ade), SkBits2Float(0xbf83a2cf), SkBits2Float(0xc2a5fcbd));
7773path.lineTo(SkBits2Float(0xbf3e53cf), SkBits2Float(0xc26ffb48));
7774path.cubicTo(SkBits2Float(0xc1d3d71b), SkBits2Float(0xc26eb4b2), SkBits2Float(0xc24495a7), SkBits2Float(0xc22be9b4), SkBits2Float(0xc26450f5), SkBits2Float(0xc193f109));
7775path.cubicTo(SkBits2Float(0xc2820621), SkBits2Float(0x40bfc558), SkBits2Float(0xc261c6ea), SkBits2Float(0x42033dc6), SkBits2Float(0xc20f2333), SkBits2Float(0x4240a4d2));
7776path.cubicTo(SkBits2Float(0xc171fde8), SkBits2Float(0x427e0bde), SkBits2Float(0x4150649d), SkBits2Float(0x427fe6ab), SkBits2Float(0x4208b71a), SkBits2Float(0x424540e8));
7777path.lineTo(SkBits2Float(0x423d1f69), SkBits2Float(0x42886f06));
7778path.close();
7779
7780 SkPath path2(path);
7781 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7782}

◆ battleOp281()

static void battleOp281 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7785 of file PathOpsBattles.cpp.

7785 {
7786 SkPath path;
7787 path.setFillType((SkPathFillType) 0);
7788path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7789path.cubicTo(SkBits2Float(0x42035955), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427a595d), SkBits2Float(0xc27e8fe6), SkBits2Float(0x4297c647), SkBits2Float(0xc206781b));
7790path.cubicTo(SkBits2Float(0x42b25fdf), SkBits2Float(0xc0660504), SkBits2Float(0x42a712a2), SkBits2Float(0x41fb94c7), SkBits2Float(0x4275e43b), SkBits2Float(0x425f1290));
7791path.lineTo(SkBits2Float(0x4231c0be), SkBits2Float(0x422141dc));
7792path.cubicTo(SkBits2Float(0x42718d10), SkBits2Float(0x41b5ddaf), SkBits2Float(0x4280f208), SkBits2Float(0xc026476c), SkBits2Float(0x425b6edc), SkBits2Float(0xc1c269cb));
7793path.cubicTo(SkBits2Float(0x4234f9ab), SkBits2Float(0xc2380553), SkBits2Float(0x41bde6f3), SkBits2Float(0xc26fffff), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
7794path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7795path.close();
7796
7797 SkPath path1(path);
7798 path.reset();
7799 path.setFillType((SkPathFillType) 0);
7800path.moveTo(SkBits2Float(0x4275e43b), SkBits2Float(0x425f1292));
7801path.cubicTo(SkBits2Float(0x4264b6c3), SkBits2Float(0x427201df), SkBits2Float(0x4251681e), SkBits2Float(0x42817283), SkBits2Float(0x423c5a8f), SkBits2Float(0x4288b309));
7802path.lineTo(SkBits2Float(0x420828ca), SkBits2Float(0x4245a33c));
7803path.cubicTo(SkBits2Float(0x421760db), SkBits2Float(0x423b2719), SkBits2Float(0x422555d9), SkBits2Float(0x422ef1ee), SkBits2Float(0x4231c0be), SkBits2Float(0x422141da));
7804path.lineTo(SkBits2Float(0x4275e43b), SkBits2Float(0x425f1292));
7805path.close();
7806
7807 SkPath path2(path);
7808 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7809}

◆ battleOp282()

static void battleOp282 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7812 of file PathOpsBattles.cpp.

7812 {
7813 SkPath path;
7814 path.setFillType((SkPathFillType) 1);
7815path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
7816path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7817path.cubicTo(SkBits2Float(0x42035955), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427a595d), SkBits2Float(0xc27e8fe6), SkBits2Float(0x4297c647), SkBits2Float(0xc206781b));
7818path.cubicTo(SkBits2Float(0x42b25fdf), SkBits2Float(0xc0660504), SkBits2Float(0x42a712a2), SkBits2Float(0x41fb94c7), SkBits2Float(0x4275e43b), SkBits2Float(0x425f1290));
7819path.lineTo(SkBits2Float(0x4275e43b), SkBits2Float(0x425f1292));
7820path.cubicTo(SkBits2Float(0x4264b6c3), SkBits2Float(0x427201df), SkBits2Float(0x4251681e), SkBits2Float(0x42817283), SkBits2Float(0x423c5a8f), SkBits2Float(0x4288b309));
7821path.lineTo(SkBits2Float(0x420828ca), SkBits2Float(0x4245a33c));
7822path.cubicTo(SkBits2Float(0x421760db), SkBits2Float(0x423b2719), SkBits2Float(0x422555d9), SkBits2Float(0x422ef1f0), SkBits2Float(0x4231c0be), SkBits2Float(0x422141dc));
7823path.cubicTo(SkBits2Float(0x42718d10), SkBits2Float(0x41b5ddaf), SkBits2Float(0x4280f208), SkBits2Float(0xc026476c), SkBits2Float(0x425b6edc), SkBits2Float(0xc1c269cb));
7824path.cubicTo(SkBits2Float(0x4234f9ab), SkBits2Float(0xc2380553), SkBits2Float(0x41bde6f3), SkBits2Float(0xc26fffff), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
7825path.close();
7826
7827 SkPath path1(path);
7828 path.reset();
7829 path.setFillType((SkPathFillType) 0);
7830path.moveTo(SkBits2Float(0x423c5a8f), SkBits2Float(0x4288b30a));
7831path.cubicTo(SkBits2Float(0x418dddd4), SkBits2Float(0x42b12599), SkBits2Float(0xc1aa0e7c), SkBits2Float(0x42af96c0), SkBits2Float(0xc2471fb7), SkBits2Float(0x4284d41e));
7832path.cubicTo(SkBits2Float(0xc29c9c18), SkBits2Float(0x423422f8), SkBits2Float(0xc2b3fb95), SkBits2Float(0x40fa8096), SkBits2Float(0xc29da17e), SkBits2Float(0xc1d02ca0));
7833path.cubicTo(SkBits2Float(0xc2874768), SkBits2Float(0xc26f7cb1), SkBits2Float(0xc2106396), SkBits2Float(0xc2a59c4c), SkBits2Float(0xbee6b152), SkBits2Float(0xc2a5ff5f));
7834path.lineTo(SkBits2Float(0xbea6c49b), SkBits2Float(0xc26fff18));
7835path.cubicTo(SkBits2Float(0xc1d0c156), SkBits2Float(0xc26f6fd8), SkBits2Float(0xc2439580), SkBits2Float(0xc22d1f86), SkBits2Float(0xc263e663), SkBits2Float(0xc1967cc0));
7836path.cubicTo(SkBits2Float(0xc2821ba4), SkBits2Float(0x40b51622), SkBits2Float(0xc2626c73), SkBits2Float(0x4202381f), SkBits2Float(0xc20ff1e5), SkBits2Float(0x42400a93));
7837path.cubicTo(SkBits2Float(0xc175dd55), SkBits2Float(0x427ddd08), SkBits2Float(0x414d1bd1), SkBits2Float(0x42800ed7), SkBits2Float(0x420828d0), SkBits2Float(0x4245a338));
7838path.lineTo(SkBits2Float(0x423c5a8f), SkBits2Float(0x4288b30a));
7839path.close();
7840
7841 SkPath path2(path);
7842 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7843}

◆ battleOp283()

static void battleOp283 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7846 of file PathOpsBattles.cpp.

7846 {
7847 SkPath path;
7848 path.setFillType((SkPathFillType) 0);
7849path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7850path.cubicTo(SkBits2Float(0x42036bf7), SkBits2Float(0xc2a60000), SkBits2Float(0x427a7934), SkBits2Float(0xc27e7a35), SkBits2Float(0x4297d0ad), SkBits2Float(0xc2064926));
7851path.cubicTo(SkBits2Float(0x42b264c0), SkBits2Float(0xc061818a), SkBits2Float(0x42a70569), SkBits2Float(0x41fc47ee), SkBits2Float(0x42759f2d), SkBits2Float(0x425f5e99));
7852path.lineTo(SkBits2Float(0x42318ed2), SkBits2Float(0x422178d2));
7853path.cubicTo(SkBits2Float(0x427179f2), SkBits2Float(0x41b65f2f), SkBits2Float(0x4280f58f), SkBits2Float(0xc0230424), SkBits2Float(0x425b7de6), SkBits2Float(0xc1c225e6));
7854path.cubicTo(SkBits2Float(0x423510af), SkBits2Float(0xc237f5a4), SkBits2Float(0x41be01e5), SkBits2Float(0xc26fffff), SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
7855path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7856path.close();
7857
7858 SkPath path1(path);
7859 path.reset();
7860 path.setFillType((SkPathFillType) 0);
7861path.moveTo(SkBits2Float(0x42759f2b), SkBits2Float(0x425f5e9b));
7862path.cubicTo(SkBits2Float(0x42646988), SkBits2Float(0x42724b20), SkBits2Float(0x425112cb), SkBits2Float(0x42819524), SkBits2Float(0x423bfd7a), SkBits2Float(0x4288d30e));
7863path.lineTo(SkBits2Float(0x4207e580), SkBits2Float(0x4245d187));
7864path.cubicTo(SkBits2Float(0x4217232e), SkBits2Float(0x423b592c), SkBits2Float(0x42251e07), SkBits2Float(0x422f26e4), SkBits2Float(0x42318ed3), SkBits2Float(0x422178d2));
7865path.lineTo(SkBits2Float(0x42759f2b), SkBits2Float(0x425f5e9b));
7866path.close();
7867
7868 SkPath path2(path);
7869 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7870}

◆ battleOp284()

static void battleOp284 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7873 of file PathOpsBattles.cpp.

7873 {
7874 SkPath path;
7875 path.setFillType((SkPathFillType) 1);
7876path.moveTo(SkBits2Float(0x3707ffa9), SkBits2Float(0xc2700000));
7877path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7878path.cubicTo(SkBits2Float(0x42036bf7), SkBits2Float(0xc2a60000), SkBits2Float(0x427a7934), SkBits2Float(0xc27e7a35), SkBits2Float(0x4297d0ad), SkBits2Float(0xc2064926));
7879path.cubicTo(SkBits2Float(0x42b264c0), SkBits2Float(0xc061818a), SkBits2Float(0x42a70569), SkBits2Float(0x41fc47ee), SkBits2Float(0x42759f2d), SkBits2Float(0x425f5e99));
7880path.lineTo(SkBits2Float(0x42318ed3), SkBits2Float(0x422178d2));
7881
7882 SkPath path1(path);
7883 path.reset();
7884 path.setFillType((SkPathFillType) 0);
7885path.moveTo(SkBits2Float(0x423bfd7a), SkBits2Float(0x4288d30e));
7886path.cubicTo(SkBits2Float(0x418ccafd), SkBits2Float(0x42b13768), SkBits2Float(0xc1ab522b), SkBits2Float(0x42af873b), SkBits2Float(0xc247a66c), SkBits2Float(0x4284a188));
7887path.cubicTo(SkBits2Float(0xc29cd1e0), SkBits2Float(0x423377ac), SkBits2Float(0xc2b40936), SkBits2Float(0x40f384e7), SkBits2Float(0xc29d7e41), SkBits2Float(0xc1d1d5b9));
7888path.cubicTo(SkBits2Float(0xc286f34a), SkBits2Float(0xc2704657), SkBits2Float(0xc20f6108), SkBits2Float(0xc2a5d8cf), SkBits2Float(0xbe35f437), SkBits2Float(0xc2a5ffe6));
7889path.lineTo(SkBits2Float(0xbe038989), SkBits2Float(0xc26fffdc));
7890path.cubicTo(SkBits2Float(0xc1cf4b80), SkBits2Float(0xc26fc755), SkBits2Float(0xc2431bdf), SkBits2Float(0xc22db14d), SkBits2Float(0xc263b36c), SkBits2Float(0xc197b016));
7891path.cubicTo(SkBits2Float(0xc282257d), SkBits2Float(0x40b009af), SkBits2Float(0xc262ba31), SkBits2Float(0x4201bc49), SkBits2Float(0xc2105343), SkBits2Float(0x423fc16f));
7892path.cubicTo(SkBits2Float(0xc177b158), SkBits2Float(0x427dc695), SkBits2Float(0x414b8e67), SkBits2Float(0x42801bb6), SkBits2Float(0x4207e581), SkBits2Float(0x4245d188));
7893path.lineTo(SkBits2Float(0x423bfd7a), SkBits2Float(0x4288d30e));
7894path.close();
7895
7896 SkPath path2(path);
7897 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7898}

◆ battleOp285()

static void battleOp285 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7901 of file PathOpsBattles.cpp.

7901 {
7902 SkPath path;
7903 path.setFillType((SkPathFillType) 0);
7904path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7905path.cubicTo(SkBits2Float(0x420374f9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427a8897), SkBits2Float(0xc27e6fb3), SkBits2Float(0x4297d5b1), SkBits2Float(0xc2063270));
7906path.cubicTo(SkBits2Float(0x42b26718), SkBits2Float(0xc05f52ba), SkBits2Float(0x42a6ff00), SkBits2Float(0x41fc9e87), SkBits2Float(0x42757dbf), SkBits2Float(0x425f8353));
7907path.lineTo(SkBits2Float(0x423176ab), SkBits2Float(0x4221935e));
7908path.cubicTo(SkBits2Float(0x427170b0), SkBits2Float(0x41b69dc5), SkBits2Float(0x4280f73f), SkBits2Float(0xc0217057), SkBits2Float(0x425b8525), SkBits2Float(0xc1c20512));
7909path.cubicTo(SkBits2Float(0x42351bcc), SkBits2Float(0xc237ee0d), SkBits2Float(0x41be0ee4), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
7910path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7911path.close();
7912
7913 SkPath path1(path);
7914 path.reset();
7915 path.setFillType((SkPathFillType) 0);
7916path.moveTo(SkBits2Float(0x42757dc1), SkBits2Float(0x425f8353));
7917path.cubicTo(SkBits2Float(0x4264442b), SkBits2Float(0x42726e80), SkBits2Float(0x4250e985), SkBits2Float(0x4281a5dc), SkBits2Float(0x423bd072), SkBits2Float(0x4288e283));
7918path.lineTo(SkBits2Float(0x4207c4f4), SkBits2Float(0x4245e7df));
7919path.cubicTo(SkBits2Float(0x42170559), SkBits2Float(0x423b7158), SkBits2Float(0x42250305), SkBits2Float(0x422f4076), SkBits2Float(0x423176ac), SkBits2Float(0x4221935e));
7920path.lineTo(SkBits2Float(0x42757dc1), SkBits2Float(0x425f8353));
7921path.close();
7922
7923 SkPath path2(path);
7924 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7925}

◆ battleOp286()

static void battleOp286 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7928 of file PathOpsBattles.cpp.

7928 {
7929 SkPath path;
7930 path.setFillType((SkPathFillType) 1);
7931path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
7932path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7933path.cubicTo(SkBits2Float(0x420374f9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427a8897), SkBits2Float(0xc27e6fb3), SkBits2Float(0x4297d5b1), SkBits2Float(0xc2063270));
7934path.cubicTo(SkBits2Float(0x42b26718), SkBits2Float(0xc05f52c1), SkBits2Float(0x42a6ff01), SkBits2Float(0x41fc9e87), SkBits2Float(0x42757dc1), SkBits2Float(0x425f8353));
7935path.cubicTo(SkBits2Float(0x4264442b), SkBits2Float(0x42726e80), SkBits2Float(0x4250e985), SkBits2Float(0x4281a5dc), SkBits2Float(0x423bd072), SkBits2Float(0x4288e283));
7936path.lineTo(SkBits2Float(0x4207c4f4), SkBits2Float(0x4245e7df));
7937path.cubicTo(SkBits2Float(0x42170559), SkBits2Float(0x423b7158), SkBits2Float(0x42250305), SkBits2Float(0x422f4076), SkBits2Float(0x423176ab), SkBits2Float(0x4221935e));
7938path.cubicTo(SkBits2Float(0x427170b0), SkBits2Float(0x41b69dc5), SkBits2Float(0x4280f73f), SkBits2Float(0xc0217057), SkBits2Float(0x425b8525), SkBits2Float(0xc1c20512));
7939path.cubicTo(SkBits2Float(0x42351bcc), SkBits2Float(0xc237ee0d), SkBits2Float(0x41be0ee4), SkBits2Float(0xc26fffff), SkBits2Float(0xb630015b), SkBits2Float(0xc26fffff));
7940path.close();
7941
7942 SkPath path1(path);
7943 path.reset();
7944 path.setFillType((SkPathFillType) 0);
7945path.moveTo(SkBits2Float(0x423bd073), SkBits2Float(0x4288e283));
7946path.cubicTo(SkBits2Float(0x418c461b), SkBits2Float(0x42b13ffc), SkBits2Float(0xc1abee9c), SkBits2Float(0x42af7fac), SkBits2Float(0xc247e775), SkBits2Float(0x42848907));
7947path.cubicTo(SkBits2Float(0xc29cebcd), SkBits2Float(0x423324c4), SkBits2Float(0xc2b40fb2), SkBits2Float(0x40f02474), SkBits2Float(0xc29d6d1c), SkBits2Float(0xc1d2a316));
7948path.cubicTo(SkBits2Float(0xc286ca87), SkBits2Float(0xc270a7a6), SkBits2Float(0xc20ee3ea), SkBits2Float(0xc2a5f5e9), SkBits2Float(0xbd3ba09e), SkBits2Float(0xc2a5fffd));
7949path.lineTo(SkBits2Float(0xbd0796d7), SkBits2Float(0xc26ffffe));
7950path.cubicTo(SkBits2Float(0xc1ce9695), SkBits2Float(0xc26ff16b), SkBits2Float(0xc242e0ee), SkBits2Float(0xc22df7a5), SkBits2Float(0xc2639aa3), SkBits2Float(0xc198448c));
7951path.cubicTo(SkBits2Float(0xc2822a2c), SkBits2Float(0x40ad98d0), SkBits2Float(0xc262dfac), SkBits2Float(0x4201805e), SkBits2Float(0xc2108243), SkBits2Float(0x423f9e03));
7952path.cubicTo(SkBits2Float(0xc178936c), SkBits2Float(0x427dbba8), SkBits2Float(0x414ace5d), SkBits2Float(0x428021e8), SkBits2Float(0x4207c4fa), SkBits2Float(0x4245e7dc));
7953path.lineTo(SkBits2Float(0x423bd073), SkBits2Float(0x4288e283));
7954path.close();
7955
7956 SkPath path2(path);
7957 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7958}

◆ battleOp287()

static void battleOp287 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7961 of file PathOpsBattles.cpp.

7961 {
7962 SkPath path;
7963 path.setFillType((SkPathFillType) 0);
7964path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7965path.cubicTo(SkBits2Float(0x420377c9), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8d67), SkBits2Float(0xc27e6c6d), SkBits2Float(0x4297d744), SkBits2Float(0xc2062b59));
7966path.cubicTo(SkBits2Float(0x42b267d3), SkBits2Float(0xc05ea43d), SkBits2Float(0x42a6fd01), SkBits2Float(0x41fcb991), SkBits2Float(0x42757351), SkBits2Float(0x425f8ecb));
7967path.lineTo(SkBits2Float(0x42316f1e), SkBits2Float(0x42219ba8));
7968path.cubicTo(SkBits2Float(0x42716dc9), SkBits2Float(0x41b6b154), SkBits2Float(0x4280f7c8), SkBits2Float(0xc020f212), SkBits2Float(0x425b876b), SkBits2Float(0xc1c1fad0));
7969path.cubicTo(SkBits2Float(0x42351f48), SkBits2Float(0xc237ebae), SkBits2Float(0x41be12f9), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
7970path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
7971path.close();
7972
7973 SkPath path1(path);
7974 path.reset();
7975 path.setFillType((SkPathFillType) 0);
7976path.moveTo(SkBits2Float(0x42757350), SkBits2Float(0x425f8ecb));
7977path.cubicTo(SkBits2Float(0x42643881), SkBits2Float(0x4272798e), SkBits2Float(0x4250dca0), SkBits2Float(0x4281ab15), SkBits2Float(0x423bc262), SkBits2Float(0x4288e756));
7978path.lineTo(SkBits2Float(0x4207bac8), SkBits2Float(0x4245eed9));
7979path.cubicTo(SkBits2Float(0x4216fc05), SkBits2Float(0x423b78e5), SkBits2Float(0x4224fa94), SkBits2Float(0x422f4874), SkBits2Float(0x42316f1f), SkBits2Float(0x42219baa));
7980path.lineTo(SkBits2Float(0x42757350), SkBits2Float(0x425f8ecb));
7981path.close();
7982
7983 SkPath path2(path);
7984 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
7985}

◆ battleOp288()

static void battleOp288 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 7988 of file PathOpsBattles.cpp.

7988 {
7989 SkPath path;
7990 path.setFillType((SkPathFillType) 1);
7991path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
7992path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
7993path.cubicTo(SkBits2Float(0x420377c9), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8d67), SkBits2Float(0xc27e6c6d), SkBits2Float(0x4297d744), SkBits2Float(0xc2062b59));
7994path.cubicTo(SkBits2Float(0x42b267d3), SkBits2Float(0xc05ea43d), SkBits2Float(0x42a6fd01), SkBits2Float(0x41fcb991), SkBits2Float(0x42757351), SkBits2Float(0x425f8ecb));
7995path.lineTo(SkBits2Float(0x423bc262), SkBits2Float(0x4288e756));
7996path.lineTo(SkBits2Float(0x4207bac8), SkBits2Float(0x4245eed9));
7997path.cubicTo(SkBits2Float(0x4216fc05), SkBits2Float(0x423b78e5), SkBits2Float(0x4224fa94), SkBits2Float(0x422f4874), SkBits2Float(0x42316f1f), SkBits2Float(0x42219baa));
7998path.lineTo(SkBits2Float(0x42316f1e), SkBits2Float(0x42219ba8));
7999path.cubicTo(SkBits2Float(0x42716dc9), SkBits2Float(0x41b6b154), SkBits2Float(0x4280f7c8), SkBits2Float(0xc020f212), SkBits2Float(0x425b876b), SkBits2Float(0xc1c1fad0));
8000path.cubicTo(SkBits2Float(0x42351f48), SkBits2Float(0xc237ebae), SkBits2Float(0x41be12f9), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8001path.close();
8002
8003 SkPath path1(path);
8004 path.reset();
8005 path.setFillType((SkPathFillType) 0);
8006path.moveTo(SkBits2Float(0x423bc261), SkBits2Float(0x4288e756));
8007path.cubicTo(SkBits2Float(0x418c1c95), SkBits2Float(0x42b142a6), SkBits2Float(0xc1ac1f7e), SkBits2Float(0x42af7d4d), SkBits2Float(0xc247fbc6), SkBits2Float(0x4284815d));
8008path.cubicTo(SkBits2Float(0xc29cf3e6), SkBits2Float(0x42330ad8), SkBits2Float(0xc2b411b5), SkBits2Float(0x40ef163d), SkBits2Float(0xc29d67bc), SkBits2Float(0xc1d2e345));
8009path.cubicTo(SkBits2Float(0xc286bdc4), SkBits2Float(0xc270c60d), SkBits2Float(0xc20ebcc7), SkBits2Float(0xc2a5feff), SkBits2Float(0xbb958372), SkBits2Float(0xc2a5ffff));
8010path.lineTo(SkBits2Float(0xbb591ee2), SkBits2Float(0xc2700000));
8011path.cubicTo(SkBits2Float(0xc1ce5e0c), SkBits2Float(0xc26ffe8b), SkBits2Float(0xc242ce80), SkBits2Float(0xc22e0d9d), SkBits2Float(0xc26392e3), SkBits2Float(0xc19872ed));
8012path.cubicTo(SkBits2Float(0xc2822ba3), SkBits2Float(0x40acd588), SkBits2Float(0xc262eb66), SkBits2Float(0x42016da1), SkBits2Float(0xc21090f8), SkBits2Float(0x423f92f0));
8013path.cubicTo(SkBits2Float(0xc178da2a), SkBits2Float(0x427db83e), SkBits2Float(0x414a923f), SkBits2Float(0x428023d8), SkBits2Float(0x4207baca), SkBits2Float(0x4245eed8));
8014path.lineTo(SkBits2Float(0x423bc261), SkBits2Float(0x4288e756));
8015path.close();
8016
8017 SkPath path2(path);
8018 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8019}

◆ battleOp289()

static void battleOp289 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8022 of file PathOpsBattles.cpp.

8022 {
8023 SkPath path;
8024 path.setFillType((SkPathFillType) 0);
8025path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8026path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8027path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8028path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8029path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8030path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8031path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8032path.close();
8033
8034 SkPath path1(path);
8035 path.reset();
8036 path.setFillType((SkPathFillType) 0);
8037path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8038path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8039path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8040path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8041path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8042path.close();
8043
8044 SkPath path2(path);
8045 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8046}

◆ battleOp29()

static void battleOp29 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 834 of file PathOpsBattles.cpp.

834 {
835 SkPath path;
836 path.setFillType((SkPathFillType) 1);
837path.moveTo(SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
838path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
839path.cubicTo(SkBits2Float(0x40dd1e62), SkBits2Float(0xc2a60000), SkBits2Float(0x415caf97), SkBits2Float(0xc2a44632), SkBits2Float(0x41a3e96b), SkBits2Float(0xc2a0dcda));
840path.lineTo(SkBits2Float(0x416cfb1d), SkBits2Float(0xc2689296));
841path.cubicTo(SkBits2Float(0x4174b742), SkBits2Float(0xc268147b), SkBits2Float(0x417c6d0a), SkBits2Float(0xc2679035), SkBits2Float(0x41820dff), SkBits2Float(0xc26705ca));
842path.lineTo(SkBits2Float(0x41b3e8b2), SkBits2Float(0xc29fca67));
843path.cubicTo(SkBits2Float(0x41ae9839), SkBits2Float(0xc2a02a23), SkBits2Float(0x41a94307), SkBits2Float(0xc2a085a1), SkBits2Float(0x41a3e96c), SkBits2Float(0xc2a0dcda));
844path.lineTo(SkBits2Float(0x416cfb1c), SkBits2Float(0xc2689294));
845path.cubicTo(SkBits2Float(0x411f8831), SkBits2Float(0xc26d8140), SkBits2Float(0x409fd849), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
846path.close();
847
848 SkPath path1(path);
849 path.reset();
850 path.setFillType((SkPathFillType) 0);
851path.moveTo(SkBits2Float(0x41b3e8b1), SkBits2Float(0xc29fca67));
852path.cubicTo(SkBits2Float(0x4205291f), SkBits2Float(0xc299b5bb), SkBits2Float(0x422d73c0), SkBits2Float(0xc28f4fcf), SkBits2Float(0x425064bf), SkBits2Float(0xc2813989));
853path.lineTo(SkBits2Float(0x4216a55b), SkBits2Float(0xc23ad4b9));
854path.cubicTo(SkBits2Float(0x41fac62f), SkBits2Float(0xc24f329e), SkBits2Float(0x41c0857c), SkBits2Float(0xc25e3b2e), SkBits2Float(0x41820dfe), SkBits2Float(0xc26705cb));
855path.lineTo(SkBits2Float(0x41b3e8b1), SkBits2Float(0xc29fca67));
856path.close();
857
858 SkPath path2(path);
859 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
860}

◆ battleOp290()

static void battleOp290 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8049 of file PathOpsBattles.cpp.

8049 {
8050 SkPath path;
8051 path.setFillType((SkPathFillType) 1);
8052path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8053path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8054path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8055path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8056path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8057path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8058path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8059path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8060path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8061path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8062path.close();
8063
8064 SkPath path1(path);
8065 path.reset();
8066 path.setFillType((SkPathFillType) 0);
8067path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8068path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8069path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8070path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8071path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8072path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8073path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8074path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8075path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8076path.close();
8077
8078 SkPath path2(path);
8079 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8080}

◆ battleOp291()

static void battleOp291 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8083 of file PathOpsBattles.cpp.

8083 {
8084 SkPath path;
8085 path.setFillType((SkPathFillType) 0);
8086path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8087path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8088path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8089path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8090path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8091path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8092path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8093path.close();
8094
8095 SkPath path1(path);
8096 path.reset();
8097 path.setFillType((SkPathFillType) 0);
8098path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8099path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8100path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8101path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8102path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8103path.close();
8104
8105 SkPath path2(path);
8106 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8107}

◆ battleOp292()

static void battleOp292 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8110 of file PathOpsBattles.cpp.

8110 {
8111 SkPath path;
8112 path.setFillType((SkPathFillType) 1);
8113path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8114path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8115path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8116path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8117path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8118path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8119path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8120path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8121path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8122path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8123path.close();
8124
8125 SkPath path1(path);
8126 path.reset();
8127 path.setFillType((SkPathFillType) 0);
8128path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8129path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8130path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8131path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8132path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8133path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8134path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8135path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8136path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8137path.close();
8138
8139 SkPath path2(path);
8140 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8141}

◆ battleOp293()

static void battleOp293 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8144 of file PathOpsBattles.cpp.

8144 {
8145 SkPath path;
8146 path.setFillType((SkPathFillType) 0);
8147path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8148path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8149path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8150path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8151path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8152path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8153path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8154path.close();
8155
8156 SkPath path1(path);
8157 path.reset();
8158 path.setFillType((SkPathFillType) 0);
8159path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8160path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8161path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8162path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8163path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8164path.close();
8165
8166 SkPath path2(path);
8167 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8168}

◆ battleOp294()

static void battleOp294 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8171 of file PathOpsBattles.cpp.

8171 {
8172 SkPath path;
8173 path.setFillType((SkPathFillType) 1);
8174path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8175path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8176path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8177path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8178path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8179path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8180path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8181path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8182path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8183path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8184path.close();
8185
8186 SkPath path1(path);
8187 path.reset();
8188 path.setFillType((SkPathFillType) 0);
8189path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8190path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8191path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8192path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8193path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8194path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8195path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8196path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8197path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8198path.close();
8199
8200 SkPath path2(path);
8201 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8202}

◆ battleOp295()

static void battleOp295 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8205 of file PathOpsBattles.cpp.

8205 {
8206 SkPath path;
8207 path.setFillType((SkPathFillType) 0);
8208path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8209path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8210path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8211path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8212path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8213path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8214path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8215path.close();
8216
8217 SkPath path1(path);
8218 path.reset();
8219 path.setFillType((SkPathFillType) 0);
8220path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8221path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8222path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8223path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8224path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8225path.close();
8226
8227 SkPath path2(path);
8228 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8229}

◆ battleOp296()

static void battleOp296 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8232 of file PathOpsBattles.cpp.

8232 {
8233 SkPath path;
8234 path.setFillType((SkPathFillType) 1);
8235path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8236path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8237path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8238path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8239path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8240path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8241path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8242path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8243path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8244path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8245path.close();
8246
8247 SkPath path1(path);
8248 path.reset();
8249 path.setFillType((SkPathFillType) 0);
8250path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8251path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8252path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8253path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8254path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8255path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8256path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8257path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8258path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8259path.close();
8260
8261 SkPath path2(path);
8262 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8263}

◆ battleOp297()

static void battleOp297 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8266 of file PathOpsBattles.cpp.

8266 {
8267 SkPath path;
8268 path.setFillType((SkPathFillType) 0);
8269path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8270path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8271path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8272path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8273path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8274path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8275path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8276path.close();
8277
8278 SkPath path1(path);
8279 path.reset();
8280 path.setFillType((SkPathFillType) 0);
8281path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8282path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8283path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8284path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8285path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8286path.close();
8287
8288 SkPath path2(path);
8289 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8290}

◆ battleOp298()

static void battleOp298 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8293 of file PathOpsBattles.cpp.

8293 {
8294 SkPath path;
8295 path.setFillType((SkPathFillType) 1);
8296path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8297path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8298path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8299path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8300path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8301path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8302path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8303path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8304path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8305path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8306path.close();
8307
8308 SkPath path1(path);
8309 path.reset();
8310 path.setFillType((SkPathFillType) 0);
8311path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8312path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8313path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8314path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8315path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8316path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8317path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8318path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8319path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8320path.close();
8321
8322 SkPath path2(path);
8323 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8324}

◆ battleOp299()

static void battleOp299 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8327 of file PathOpsBattles.cpp.

8327 {
8328 SkPath path;
8329 path.setFillType((SkPathFillType) 0);
8330path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8331path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8332path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8333path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8334path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8335path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8336path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8337path.close();
8338
8339 SkPath path1(path);
8340 path.reset();
8341 path.setFillType((SkPathFillType) 0);
8342path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8343path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8344path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8345path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8346path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8347path.close();
8348
8349 SkPath path2(path);
8350 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8351}

◆ battleOp3()

static void battleOp3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 146 of file PathOpsBattles.cpp.

146 {
147 SkPath path;
148 path.setFillType((SkPathFillType) 0);
149path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
150path.cubicTo(SkBits2Float(0x3f19f03c), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f99ef95), SkBits2Float(0xc2a5fca7), SkBits2Float(0x3fe6e2fa), SkBits2Float(0xc2a5f5f7));
151path.lineTo(SkBits2Float(0x3fa6e80c), SkBits2Float(0xc26ff17d));
152path.cubicTo(SkBits2Float(0x3f5e8ed4), SkBits2Float(0xc26ffb2a), SkBits2Float(0x3ede8fc6), SkBits2Float(0xc2700000), SkBits2Float(0x35d9fd64), SkBits2Float(0xc2700000));
153path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
154path.close();
155
156 SkPath path1(path);
157 path.reset();
158 path.setFillType((SkPathFillType) 0);
159path.moveTo(SkBits2Float(0x3fe6e322), SkBits2Float(0xc2a5f5f7));
160path.cubicTo(SkBits2Float(0x3fee94fb), SkBits2Float(0xc2a5f54c), SkBits2Float(0x3ff646db), SkBits2Float(0xc2a5f497), SkBits2Float(0x3ffdf8ad), SkBits2Float(0xc2a5f3db));
161path.lineTo(SkBits2Float(0x3fb79813), SkBits2Float(0xc26fee71));
162path.cubicTo(SkBits2Float(0x3fb20800), SkBits2Float(0xc26fef82), SkBits2Float(0x3fac77ff), SkBits2Float(0xc26ff085), SkBits2Float(0x3fa6e7f4), SkBits2Float(0xc26ff17d));
163path.lineTo(SkBits2Float(0x3fe6e322), SkBits2Float(0xc2a5f5f7));
164path.close();
165
166 SkPath path2(path);
167 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
168}

◆ battleOp30()

static void battleOp30 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 863 of file PathOpsBattles.cpp.

863 {
864 SkPath path;
865 path.setFillType((SkPathFillType) 0);
866path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
867path.cubicTo(SkBits2Float(0x41028186), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4182264a), SkBits2Float(0xc2a39869), SkBits2Float(0x41c098e8), SkBits2Float(0xc29edd15));
868path.lineTo(SkBits2Float(0x418b3a1a), SkBits2Float(0xc265aeac));
869path.cubicTo(SkBits2Float(0x413c2b06), SkBits2Float(0xc26c85fe), SkBits2Float(0x40bcaeed), SkBits2Float(0xc2700000), SkBits2Float(0x337fa8c0), SkBits2Float(0xc2700000));
870path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
871path.close();
872
873 SkPath path1(path);
874 path.reset();
875 path.setFillType((SkPathFillType) 0);
876path.moveTo(SkBits2Float(0x41c098e9), SkBits2Float(0xc29edd15));
877path.cubicTo(SkBits2Float(0x41c6d4b6), SkBits2Float(0xc29e642a), SkBits2Float(0x41cd0950), SkBits2Float(0xc29de562), SkBits2Float(0x41d33633), SkBits2Float(0xc29d60c8));
878path.lineTo(SkBits2Float(0x4198aee4), SkBits2Float(0xc26388d7));
879path.cubicTo(SkBits2Float(0x41943815), SkBits2Float(0xc264488f), SkBits2Float(0x418fbbb2), SkBits2Float(0xc264ffdc), SkBits2Float(0x418b3a19), SkBits2Float(0xc265aeae));
880path.lineTo(SkBits2Float(0x41c098e9), SkBits2Float(0xc29edd15));
881path.close();
882
883 SkPath path2(path);
884 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
885}

◆ battleOp300()

static void battleOp300 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8354 of file PathOpsBattles.cpp.

8354 {
8355 SkPath path;
8356 path.setFillType((SkPathFillType) 1);
8357path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8358path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8359path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8360path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8361path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8362path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8363path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8364path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8365path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8366path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8367path.close();
8368
8369 SkPath path1(path);
8370 path.reset();
8371 path.setFillType((SkPathFillType) 0);
8372path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8373path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8374path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8375path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8376path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8377path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8378path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8379path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8380path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8381path.close();
8382
8383 SkPath path2(path);
8384 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8385}

◆ battleOp301()

static void battleOp301 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8388 of file PathOpsBattles.cpp.

8388 {
8389 SkPath path;
8390 path.setFillType((SkPathFillType) 0);
8391path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8392path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8393path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8394path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8395path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8396path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8397path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8398path.close();
8399
8400 SkPath path1(path);
8401 path.reset();
8402 path.setFillType((SkPathFillType) 0);
8403path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8404path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8405path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8406path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8407path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8408path.close();
8409
8410 SkPath path2(path);
8411 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8412}

◆ battleOp302()

static void battleOp302 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8415 of file PathOpsBattles.cpp.

8415 {
8416 SkPath path;
8417 path.setFillType((SkPathFillType) 1);
8418path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8419path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8420path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8421path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8422path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8423path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8424path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8425path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8426path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8427path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8428path.close();
8429
8430 SkPath path1(path);
8431 path.reset();
8432 path.setFillType((SkPathFillType) 0);
8433path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8434path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8435path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8436path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8437path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8438path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8439path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8440path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8441path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8442path.close();
8443
8444 SkPath path2(path);
8445 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8446}

◆ battleOp303()

static void battleOp303 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8449 of file PathOpsBattles.cpp.

8449 {
8450 SkPath path;
8451 path.setFillType((SkPathFillType) 0);
8452path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8453path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8454path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8455path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8456path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8457path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8458path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8459path.close();
8460
8461 SkPath path1(path);
8462 path.reset();
8463 path.setFillType((SkPathFillType) 0);
8464path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8465path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8466path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8467path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8468path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8469path.close();
8470
8471 SkPath path2(path);
8472 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8473}

◆ battleOp304()

static void battleOp304 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8476 of file PathOpsBattles.cpp.

8476 {
8477 SkPath path;
8478 path.setFillType((SkPathFillType) 1);
8479path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8480path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8481path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8482path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8483path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8484path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8485path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8486path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8487path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8488path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8489path.close();
8490
8491 SkPath path1(path);
8492 path.reset();
8493 path.setFillType((SkPathFillType) 0);
8494path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8495path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8496path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8497path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8498path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8499path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8500path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8501path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8502path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8503path.close();
8504
8505 SkPath path2(path);
8506 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8507}

◆ battleOp305()

static void battleOp305 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8510 of file PathOpsBattles.cpp.

8510 {
8511 SkPath path;
8512 path.setFillType((SkPathFillType) 0);
8513path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8514path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8515path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8516path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8517path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8518path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8519path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8520path.close();
8521
8522 SkPath path1(path);
8523 path.reset();
8524 path.setFillType((SkPathFillType) 0);
8525path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8526path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8527path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8528path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8529path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8530path.close();
8531
8532 SkPath path2(path);
8533 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8534}

◆ battleOp306()

static void battleOp306 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8537 of file PathOpsBattles.cpp.

8537 {
8538 SkPath path;
8539 path.setFillType((SkPathFillType) 1);
8540path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8541path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8542path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8543path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8544path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8545path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8546path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8547path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8548path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8549path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8550path.close();
8551
8552 SkPath path1(path);
8553 path.reset();
8554 path.setFillType((SkPathFillType) 0);
8555path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8556path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8557path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8558path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8559path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8560path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8561path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8562path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8563path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8564path.close();
8565
8566 SkPath path2(path);
8567 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8568}

◆ battleOp307()

static void battleOp307 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8571 of file PathOpsBattles.cpp.

8571 {
8572 SkPath path;
8573 path.setFillType((SkPathFillType) 0);
8574path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8575path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8576path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8577path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8578path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8579path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8580path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8581path.close();
8582
8583 SkPath path1(path);
8584 path.reset();
8585 path.setFillType((SkPathFillType) 0);
8586path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8587path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8588path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8589path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8590path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8591path.close();
8592
8593 SkPath path2(path);
8594 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8595}

◆ battleOp308()

static void battleOp308 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8598 of file PathOpsBattles.cpp.

8598 {
8599 SkPath path;
8600 path.setFillType((SkPathFillType) 1);
8601path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8602path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8603path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8604path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8605path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8606path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8607path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8608path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8609path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8610path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8611path.close();
8612
8613 SkPath path1(path);
8614 path.reset();
8615 path.setFillType((SkPathFillType) 0);
8616path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8617path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8618path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8619path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8620path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8621path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8622path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8623path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8624path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8625path.close();
8626
8627 SkPath path2(path);
8628 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8629}

◆ battleOp309()

static void battleOp309 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8632 of file PathOpsBattles.cpp.

8632 {
8633 SkPath path;
8634 path.setFillType((SkPathFillType) 0);
8635path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8636path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8637path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8638path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8639path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8640path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8641path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8642path.close();
8643
8644 SkPath path1(path);
8645 path.reset();
8646 path.setFillType((SkPathFillType) 0);
8647path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8648path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8649path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8650path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8651path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8652path.close();
8653
8654 SkPath path2(path);
8655 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8656}

◆ battleOp31()

static void battleOp31 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 888 of file PathOpsBattles.cpp.

888 {
889 SkPath path;
890 path.setFillType((SkPathFillType) 1);
891path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
892path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
893path.cubicTo(SkBits2Float(0x41028186), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4182264a), SkBits2Float(0xc2a39869), SkBits2Float(0x41c098e9), SkBits2Float(0xc29edd15));
894path.cubicTo(SkBits2Float(0x41c6d4b6), SkBits2Float(0xc29e642a), SkBits2Float(0x41cd0950), SkBits2Float(0xc29de562), SkBits2Float(0x41d33633), SkBits2Float(0xc29d60c8));
895path.lineTo(SkBits2Float(0x4198aee4), SkBits2Float(0xc26388d7));
896path.cubicTo(SkBits2Float(0x41943816), SkBits2Float(0xc264488f), SkBits2Float(0x418fbbb2), SkBits2Float(0xc264ffda), SkBits2Float(0x418b3a1a), SkBits2Float(0xc265aeac));
897path.cubicTo(SkBits2Float(0x413c2b06), SkBits2Float(0xc26c85fe), SkBits2Float(0x40bcaeed), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
898path.close();
899
900 SkPath path1(path);
901 path.reset();
902 path.setFillType((SkPathFillType) 0);
903path.moveTo(SkBits2Float(0x41d33633), SkBits2Float(0xc29d60c8));
904path.cubicTo(SkBits2Float(0x421be102), SkBits2Float(0xc294f1be), SkBits2Float(0x4249615f), SkBits2Float(0xc2869cbc), SkBits2Float(0x426e4d45), SkBits2Float(0xc26729aa));
905path.lineTo(SkBits2Float(0x422c4432), SkBits2Float(0xc2271b0a));
906path.cubicTo(SkBits2Float(0x42119380), SkBits2Float(0xc2429ec2), SkBits2Float(0x41e15dfd), SkBits2Float(0xc257575a), SkBits2Float(0x4198aee4), SkBits2Float(0xc26388d8));
907path.lineTo(SkBits2Float(0x41d33633), SkBits2Float(0xc29d60c8));
908path.close();
909
910 SkPath path2(path);
911 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
912}

◆ battleOp310()

static void battleOp310 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8659 of file PathOpsBattles.cpp.

8659 {
8660 SkPath path;
8661 path.setFillType((SkPathFillType) 1);
8662path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8663path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8664path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8665path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8666path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8667path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8668path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8669path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8670path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8671path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8672path.close();
8673
8674 SkPath path1(path);
8675 path.reset();
8676 path.setFillType((SkPathFillType) 0);
8677path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8678path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8679path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8680path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8681path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8682path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8683path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8684path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8685path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8686path.close();
8687
8688 SkPath path2(path);
8689 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8690}

◆ battleOp311()

static void battleOp311 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8693 of file PathOpsBattles.cpp.

8693 {
8694 SkPath path;
8695 path.setFillType((SkPathFillType) 0);
8696path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8697path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8698path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8699path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8700path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8701path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8702path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8703path.close();
8704
8705 SkPath path1(path);
8706 path.reset();
8707 path.setFillType((SkPathFillType) 0);
8708path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8709path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8710path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8711path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8712path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8713path.close();
8714
8715 SkPath path2(path);
8716 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8717}

◆ battleOp312()

static void battleOp312 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8720 of file PathOpsBattles.cpp.

8720 {
8721 SkPath path;
8722 path.setFillType((SkPathFillType) 1);
8723path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8724path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8725path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8726path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8727path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8728path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8729path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8730path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8731path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8732path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8733path.close();
8734
8735 SkPath path1(path);
8736 path.reset();
8737 path.setFillType((SkPathFillType) 0);
8738path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8739path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8740path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8741path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8742path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8743path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8744path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8745path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8746path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8747path.close();
8748
8749 SkPath path2(path);
8750 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8751}

◆ battleOp313()

static void battleOp313 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8754 of file PathOpsBattles.cpp.

8754 {
8755 SkPath path;
8756 path.setFillType((SkPathFillType) 0);
8757path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8758path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8759path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8760path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8761path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8762path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8763path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8764path.close();
8765
8766 SkPath path1(path);
8767 path.reset();
8768 path.setFillType((SkPathFillType) 0);
8769path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8770path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8771path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8772path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8773path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8774path.close();
8775
8776 SkPath path2(path);
8777 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8778}

◆ battleOp314()

static void battleOp314 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8781 of file PathOpsBattles.cpp.

8781 {
8782 SkPath path;
8783 path.setFillType((SkPathFillType) 1);
8784path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8785path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8786path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8787path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8788path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8789path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8790path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8791path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8792path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8793path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8794path.close();
8795
8796 SkPath path1(path);
8797 path.reset();
8798 path.setFillType((SkPathFillType) 0);
8799path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8800path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8801path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8802path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8803path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8804path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8805path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8806path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8807path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8808path.close();
8809
8810 SkPath path2(path);
8811 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8812}

◆ battleOp315()

static void battleOp315 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8815 of file PathOpsBattles.cpp.

8815 {
8816 SkPath path;
8817 path.setFillType((SkPathFillType) 0);
8818path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8819path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8820path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8821path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8822path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8823path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8824path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8825path.close();
8826
8827 SkPath path1(path);
8828 path.reset();
8829 path.setFillType((SkPathFillType) 0);
8830path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8831path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8832path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8833path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8834path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8835path.close();
8836
8837 SkPath path2(path);
8838 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8839}

◆ battleOp316()

static void battleOp316 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8842 of file PathOpsBattles.cpp.

8842 {
8843 SkPath path;
8844 path.setFillType((SkPathFillType) 1);
8845path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8846path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8847path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8848path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8849path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8850path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8851path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8852path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8853path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8854path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8855path.close();
8856
8857 SkPath path1(path);
8858 path.reset();
8859 path.setFillType((SkPathFillType) 0);
8860path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8861path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8862path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8863path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8864path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8865path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8866path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8867path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8868path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8869path.close();
8870
8871 SkPath path2(path);
8872 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8873}

◆ battleOp317()

static void battleOp317 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8876 of file PathOpsBattles.cpp.

8876 {
8877 SkPath path;
8878 path.setFillType((SkPathFillType) 0);
8879path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8880path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8881path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8882path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8883path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8884path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8885path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8886path.close();
8887
8888 SkPath path1(path);
8889 path.reset();
8890 path.setFillType((SkPathFillType) 0);
8891path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8892path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8893path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8894path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8895path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8896path.close();
8897
8898 SkPath path2(path);
8899 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8900}

◆ battleOp318()

static void battleOp318 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8903 of file PathOpsBattles.cpp.

8903 {
8904 SkPath path;
8905 path.setFillType((SkPathFillType) 1);
8906path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8907path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8908path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8909path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8910path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8911path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8912path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8913path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8914path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8915path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8916path.close();
8917
8918 SkPath path1(path);
8919 path.reset();
8920 path.setFillType((SkPathFillType) 0);
8921path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8922path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8923path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8924path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8925path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8926path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8927path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8928path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8929path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8930path.close();
8931
8932 SkPath path2(path);
8933 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8934}

◆ battleOp319()

static void battleOp319 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8937 of file PathOpsBattles.cpp.

8937 {
8938 SkPath path;
8939 path.setFillType((SkPathFillType) 0);
8940path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8941path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8942path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8943path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8944path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8945path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
8946path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
8947path.close();
8948
8949 SkPath path1(path);
8950 path.reset();
8951 path.setFillType((SkPathFillType) 0);
8952path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8953path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8954path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8955path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8956path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
8957path.close();
8958
8959 SkPath path2(path);
8960 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8961}

◆ battleOp32()

static void battleOp32 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 915 of file PathOpsBattles.cpp.

915 {
916 SkPath path;
917 path.setFillType((SkPathFillType) 0);
918path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
919path.cubicTo(SkBits2Float(0x4118c001), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41982d6e), SkBits2Float(0xc2a2b4b2), SkBits2Float(0x41e01284), SkBits2Float(0xc29c4333));
920path.lineTo(SkBits2Float(0x41a1fae3), SkBits2Float(0xc261ebf5));
921path.cubicTo(SkBits2Float(0x415c0406), SkBits2Float(0xc26b3cc7), SkBits2Float(0x40dcd7ee), SkBits2Float(0xc2700000), SkBits2Float(0x35f7fd46), SkBits2Float(0xc2700000));
922path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
923path.close();
924
925 SkPath path1(path);
926 path.reset();
927 path.setFillType((SkPathFillType) 0);
928path.moveTo(SkBits2Float(0x41e01286), SkBits2Float(0xc29c4334));
929path.cubicTo(SkBits2Float(0x41e73e86), SkBits2Float(0xc29b9ea8), SkBits2Float(0x41ee5f11), SkBits2Float(0xc29af239), SkBits2Float(0x41f57356), SkBits2Float(0xc29a3dfa));
930path.lineTo(SkBits2Float(0x41b16f25), SkBits2Float(0xc25f0029));
931path.cubicTo(SkBits2Float(0x41ac5112), SkBits2Float(0xc26004c3), SkBits2Float(0x41a72a20), SkBits2Float(0xc260fe11), SkBits2Float(0x41a1fae3), SkBits2Float(0xc261ebf7));
932path.lineTo(SkBits2Float(0x41e01286), SkBits2Float(0xc29c4334));
933path.close();
934
935 SkPath path2(path);
936 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
937}

◆ battleOp320()

static void battleOp320 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8964 of file PathOpsBattles.cpp.

8964 {
8965 SkPath path;
8966 path.setFillType((SkPathFillType) 1);
8967path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8968path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
8969path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
8970path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
8971path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8972path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8973path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
8974path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
8975path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
8976path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
8977path.close();
8978
8979 SkPath path1(path);
8980 path.reset();
8981 path.setFillType((SkPathFillType) 0);
8982path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8983path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
8984path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
8985path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
8986path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
8987path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
8988path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
8989path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
8990path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
8991path.close();
8992
8993 SkPath path2(path);
8994 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
8995}

◆ battleOp321()

static void battleOp321 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8998 of file PathOpsBattles.cpp.

8998 {
8999 SkPath path;
9000 path.setFillType((SkPathFillType) 0);
9001path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9002path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9003path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9004path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9005path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9006path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9007path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9008path.close();
9009
9010 SkPath path1(path);
9011 path.reset();
9012 path.setFillType((SkPathFillType) 0);
9013path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9014path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9015path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9016path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9017path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9018path.close();
9019
9020 SkPath path2(path);
9021 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9022}

◆ battleOp322()

static void battleOp322 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9025 of file PathOpsBattles.cpp.

9025 {
9026 SkPath path;
9027 path.setFillType((SkPathFillType) 1);
9028path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9029path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9030path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9031path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9032path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9033path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9034path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9035path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9036path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9037path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9038path.close();
9039
9040 SkPath path1(path);
9041 path.reset();
9042 path.setFillType((SkPathFillType) 0);
9043path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9044path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9045path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9046path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9047path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9048path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9049path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9050path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9051path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9052path.close();
9053
9054 SkPath path2(path);
9055 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9056}

◆ battleOp323()

static void battleOp323 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9059 of file PathOpsBattles.cpp.

9059 {
9060 SkPath path;
9061 path.setFillType((SkPathFillType) 0);
9062path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9063path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9064path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9065path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9066path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9067path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9068path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9069path.close();
9070
9071 SkPath path1(path);
9072 path.reset();
9073 path.setFillType((SkPathFillType) 0);
9074path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9075path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9076path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9077path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9078path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9079path.close();
9080
9081 SkPath path2(path);
9082 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9083}

◆ battleOp324()

static void battleOp324 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9086 of file PathOpsBattles.cpp.

9086 {
9087 SkPath path;
9088 path.setFillType((SkPathFillType) 1);
9089path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9090path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9091path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9092path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9093path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9094path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9095path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9096path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9097path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9098path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9099path.close();
9100
9101 SkPath path1(path);
9102 path.reset();
9103 path.setFillType((SkPathFillType) 0);
9104path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9105path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9106path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9107path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9108path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9109path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9110path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9111path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9112path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9113path.close();
9114
9115 SkPath path2(path);
9116 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9117}

◆ battleOp325()

static void battleOp325 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9120 of file PathOpsBattles.cpp.

9120 {
9121 SkPath path;
9122 path.setFillType((SkPathFillType) 0);
9123path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9124path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9125path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9126path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9127path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9128path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9129path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9130path.close();
9131
9132 SkPath path1(path);
9133 path.reset();
9134 path.setFillType((SkPathFillType) 0);
9135path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9136path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9137path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9138path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9139path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9140path.close();
9141
9142 SkPath path2(path);
9143 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9144}

◆ battleOp326()

static void battleOp326 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9147 of file PathOpsBattles.cpp.

9147 {
9148 SkPath path;
9149 path.setFillType((SkPathFillType) 1);
9150path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9151path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9152path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9153path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9154path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9155path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9156path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9157path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9158path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9159path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9160path.close();
9161
9162 SkPath path1(path);
9163 path.reset();
9164 path.setFillType((SkPathFillType) 0);
9165path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9166path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9167path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9168path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9169path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9170path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9171path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9172path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9173path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9174path.close();
9175
9176 SkPath path2(path);
9177 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9178}

◆ battleOp327()

static void battleOp327 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9181 of file PathOpsBattles.cpp.

9181 {
9182 SkPath path;
9183 path.setFillType((SkPathFillType) 0);
9184path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9185path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9186path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9187path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9188path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9189path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9190path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9191path.close();
9192
9193 SkPath path1(path);
9194 path.reset();
9195 path.setFillType((SkPathFillType) 0);
9196path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9197path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9198path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9199path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9200path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9201path.close();
9202
9203 SkPath path2(path);
9204 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9205}

◆ battleOp328()

static void battleOp328 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9208 of file PathOpsBattles.cpp.

9208 {
9209 SkPath path;
9210 path.setFillType((SkPathFillType) 1);
9211path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9212path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9213path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9214path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9215path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9216path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9217path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9218path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9219path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9220path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9221path.close();
9222
9223 SkPath path1(path);
9224 path.reset();
9225 path.setFillType((SkPathFillType) 0);
9226path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9227path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9228path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9229path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9230path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9231path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9232path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9233path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9234path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9235path.close();
9236
9237 SkPath path2(path);
9238 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9239}

◆ battleOp329()

static void battleOp329 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9242 of file PathOpsBattles.cpp.

9242 {
9243 SkPath path;
9244 path.setFillType((SkPathFillType) 0);
9245path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9246path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9247path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9248path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9249path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9250path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9251path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9252path.close();
9253
9254 SkPath path1(path);
9255 path.reset();
9256 path.setFillType((SkPathFillType) 0);
9257path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9258path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9259path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9260path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9261path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9262path.close();
9263
9264 SkPath path2(path);
9265 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9266}

◆ battleOp33()

static void battleOp33 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 940 of file PathOpsBattles.cpp.

940 {
941 SkPath path;
942 path.setFillType((SkPathFillType) 1);
943path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
944path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
945path.cubicTo(SkBits2Float(0x4118c001), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41982d6e), SkBits2Float(0xc2a2b4b2), SkBits2Float(0x41e01286), SkBits2Float(0xc29c4334));
946path.cubicTo(SkBits2Float(0x41e73e86), SkBits2Float(0xc29b9ea8), SkBits2Float(0x41ee5f11), SkBits2Float(0xc29af239), SkBits2Float(0x41f57356), SkBits2Float(0xc29a3dfa));
947path.lineTo(SkBits2Float(0x41b16f25), SkBits2Float(0xc25f0029));
948path.cubicTo(SkBits2Float(0x41ac5112), SkBits2Float(0xc26004c3), SkBits2Float(0x41a72a20), SkBits2Float(0xc260fe11), SkBits2Float(0x41a1fae3), SkBits2Float(0xc261ebf7));
949path.lineTo(SkBits2Float(0x41a1fae3), SkBits2Float(0xc261ebf5));
950path.cubicTo(SkBits2Float(0x415c0406), SkBits2Float(0xc26b3cc7), SkBits2Float(0x40dcd7ee), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
951path.close();
952
953 SkPath path1(path);
954 path.reset();
955 path.setFillType((SkPathFillType) 0);
956path.moveTo(SkBits2Float(0x41f57359), SkBits2Float(0xc29a3dfa));
957path.cubicTo(SkBits2Float(0x42347528), SkBits2Float(0xc28ec218), SkBits2Float(0x42669614), SkBits2Float(0xc276cf04), SkBits2Float(0x4285b481), SkBits2Float(0xc244c364));
958path.lineTo(SkBits2Float(0x42414f00), SkBits2Float(0xc20e3d0e));
959path.cubicTo(SkBits2Float(0x4226b05a), SkBits2Float(0xc2326a79), SkBits2Float(0x4202738a), SkBits2Float(0xc24e65b9), SkBits2Float(0x41b16f25), SkBits2Float(0xc25f0028));
960path.lineTo(SkBits2Float(0x41f57359), SkBits2Float(0xc29a3dfa));
961path.close();
962
963 SkPath path2(path);
964 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
965}

◆ battleOp330()

static void battleOp330 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9269 of file PathOpsBattles.cpp.

9269 {
9270 SkPath path;
9271 path.setFillType((SkPathFillType) 1);
9272path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9273path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9274path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9275path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9276path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9277path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9278path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9279path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9280path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9281path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9282path.close();
9283
9284 SkPath path1(path);
9285 path.reset();
9286 path.setFillType((SkPathFillType) 0);
9287path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9288path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9289path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9290path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9291path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9292path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9293path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9294path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9295path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9296path.close();
9297
9298 SkPath path2(path);
9299 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9300}

◆ battleOp331()

static void battleOp331 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9303 of file PathOpsBattles.cpp.

9303 {
9304 SkPath path;
9305 path.setFillType((SkPathFillType) 0);
9306path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9307path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9308path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9309path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9310path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9311path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9312path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9313path.close();
9314
9315 SkPath path1(path);
9316 path.reset();
9317 path.setFillType((SkPathFillType) 0);
9318path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9319path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9320path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9321path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9322path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9323path.close();
9324
9325 SkPath path2(path);
9326 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9327}

◆ battleOp332()

static void battleOp332 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9330 of file PathOpsBattles.cpp.

9330 {
9331 SkPath path;
9332 path.setFillType((SkPathFillType) 1);
9333path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9334path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9335path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9336path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9337path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9338path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9339path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9340path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9341path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9342path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9343path.close();
9344
9345 SkPath path1(path);
9346 path.reset();
9347 path.setFillType((SkPathFillType) 0);
9348path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9349path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9350path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9351path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9352path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9353path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9354path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9355path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9356path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9357path.close();
9358
9359 SkPath path2(path);
9360 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9361}

◆ battleOp333()

static void battleOp333 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9364 of file PathOpsBattles.cpp.

9364 {
9365 SkPath path;
9366 path.setFillType((SkPathFillType) 0);
9367path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9368path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9369path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9370path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9371path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9372path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9373path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9374path.close();
9375
9376 SkPath path1(path);
9377 path.reset();
9378 path.setFillType((SkPathFillType) 0);
9379path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9380path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9381path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9382path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9383path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9384path.close();
9385
9386 SkPath path2(path);
9387 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9388}

◆ battleOp334()

static void battleOp334 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9391 of file PathOpsBattles.cpp.

9391 {
9392 SkPath path;
9393 path.setFillType((SkPathFillType) 1);
9394path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9395path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9396path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9397path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9398path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9399path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9400path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9401path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9402path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9403path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9404path.close();
9405
9406 SkPath path1(path);
9407 path.reset();
9408 path.setFillType((SkPathFillType) 0);
9409path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9410path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9411path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9412path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9413path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9414path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9415path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9416path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9417path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9418path.close();
9419
9420 SkPath path2(path);
9421 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9422}

◆ battleOp335()

static void battleOp335 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9425 of file PathOpsBattles.cpp.

9425 {
9426 SkPath path;
9427 path.setFillType((SkPathFillType) 0);
9428path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9429path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9430path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9431path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9432path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9433path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9434path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9435path.close();
9436
9437 SkPath path1(path);
9438 path.reset();
9439 path.setFillType((SkPathFillType) 0);
9440path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9441path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9442path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9443path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9444path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9445path.close();
9446
9447 SkPath path2(path);
9448 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9449}

◆ battleOp336()

static void battleOp336 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9452 of file PathOpsBattles.cpp.

9452 {
9453 SkPath path;
9454 path.setFillType((SkPathFillType) 1);
9455path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9456path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9457path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9458path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9459path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9460path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9461path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9462path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9463path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9464path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9465path.close();
9466
9467 SkPath path1(path);
9468 path.reset();
9469 path.setFillType((SkPathFillType) 0);
9470path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9471path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9472path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9473path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9474path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9475path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9476path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9477path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9478path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9479path.close();
9480
9481 SkPath path2(path);
9482 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9483}

◆ battleOp3368()

static void battleOp3368 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10203 of file PathOpsBattles.cpp.

10203 {
10204 SkPath path;
10205 path.setFillType((SkPathFillType) 1);
10206path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10207path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10208path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10209path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10210path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10211path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10212path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10213path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10214path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10215path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10216path.close();
10217
10218 SkPath path1(path);
10219 path.reset();
10220 path.setFillType((SkPathFillType) 0);
10221path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10222path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
10223path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
10224path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
10225path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
10226path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
10227path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
10228path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10229path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10230path.close();
10231
10232 SkPath path2(path);
10233 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10234}

◆ battleOp3369()

static void battleOp3369 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10237 of file PathOpsBattles.cpp.

10237 {
10238 SkPath path;
10239 path.setFillType((SkPathFillType) 0);
10240path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10241path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10242path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10243path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10244path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10245path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
10246path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10247path.close();
10248
10249 SkPath path1(path);
10250 path.reset();
10251 path.setFillType((SkPathFillType) 0);
10252path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10253path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10254path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10255path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10256path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10257path.close();
10258
10259 SkPath path2(path);
10260 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10261}

◆ battleOp337()

static void battleOp337 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9486 of file PathOpsBattles.cpp.

9486 {
9487 SkPath path;
9488 path.setFillType((SkPathFillType) 0);
9489path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9490path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9491path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9492path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9493path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9494path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9495path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9496path.close();
9497
9498 SkPath path1(path);
9499 path.reset();
9500 path.setFillType((SkPathFillType) 0);
9501path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9502path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9503path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9504path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9505path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9506path.close();
9507
9508 SkPath path2(path);
9509 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9510}

◆ battleOp3370()

static void battleOp3370 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10264 of file PathOpsBattles.cpp.

10264 {
10265 SkPath path;
10266 path.setFillType((SkPathFillType) 1);
10267path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10268path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10269path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10270path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10271path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10272path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10273path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10274path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10275path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10276path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10277path.close();
10278
10279 SkPath path1(path);
10280 path.reset();
10281 path.setFillType((SkPathFillType) 0);
10282path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10283path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
10284path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
10285path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
10286path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
10287path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
10288path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
10289path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10290path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10291path.close();
10292
10293 SkPath path2(path);
10294 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10295}

◆ battleOp3371()

static void battleOp3371 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10298 of file PathOpsBattles.cpp.

10298 {
10299 SkPath path;
10300 path.setFillType((SkPathFillType) 0);
10301path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10302path.cubicTo(SkBits2Float(0x3c85f8a2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d05fda5), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d48fefa), SkBits2Float(0xc2a5fffd));
10303path.lineTo(SkBits2Float(0x3d114e3a), SkBits2Float(0xc26ffffd));
10304path.cubicTo(SkBits2Float(0x3cc1c2c0), SkBits2Float(0xc26fffff), SkBits2Float(0x3c41c57e), SkBits2Float(0xc26fffff), SkBits2Float(0x35afaa00), SkBits2Float(0xc26fffff));
10305path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10306path.close();
10307
10308 SkPath path1(path);
10309 path.reset();
10310 path.setFillType((SkPathFillType) 0);
10311path.moveTo(SkBits2Float(0x3d49018c), SkBits2Float(0xc2a5fffe));
10312path.cubicTo(SkBits2Float(0x3d4fb7df), SkBits2Float(0xc2a5fffd), SkBits2Float(0x3d5667bf), SkBits2Float(0xc2a5fffd), SkBits2Float(0x3d5d179f), SkBits2Float(0xc2a5fffd));
10313path.lineTo(SkBits2Float(0x3d1fd60d), SkBits2Float(0xc26ffffd));
10314path.cubicTo(SkBits2Float(0x3d1afde4), SkBits2Float(0xc26fffff), SkBits2Float(0x3d162864), SkBits2Float(0xc26fffff), SkBits2Float(0x3d1152e4), SkBits2Float(0xc26fffff));
10315path.lineTo(SkBits2Float(0x3d49018c), SkBits2Float(0xc2a5fffe));
10316path.close();
10317
10318 SkPath path2(path);
10319 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10320}

◆ battleOp3372()

static void battleOp3372 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10323 of file PathOpsBattles.cpp.

10323 {
10324 SkPath path;
10325 path.setFillType((SkPathFillType) 1);
10326path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
10327path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10328path.cubicTo(SkBits2Float(0x3c85f8a2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d05fda5), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d48fefa), SkBits2Float(0xc2a5fffd));
10329path.lineTo(SkBits2Float(0x3d49018c), SkBits2Float(0xc2a5fffe));
10330path.cubicTo(SkBits2Float(0x3d4fb7df), SkBits2Float(0xc2a5fffd), SkBits2Float(0x3d5667bf), SkBits2Float(0xc2a5fffd), SkBits2Float(0x3d5d179f), SkBits2Float(0xc2a5fffd));
10331path.lineTo(SkBits2Float(0x3d1fd60d), SkBits2Float(0xc26ffffd));
10332path.cubicTo(SkBits2Float(0x3d1afde4), SkBits2Float(0xc26fffff), SkBits2Float(0x3d162864), SkBits2Float(0xc26fffff), SkBits2Float(0x3d1152e4), SkBits2Float(0xc26fffff));
10333path.lineTo(SkBits2Float(0x3d114e3a), SkBits2Float(0xc26ffffd));
10334path.cubicTo(SkBits2Float(0x3cc1c2c0), SkBits2Float(0xc26fffff), SkBits2Float(0x3c41c57e), SkBits2Float(0xc26fffff), SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
10335path.close();
10336
10337 SkPath path1(path);
10338 path.reset();
10339 path.setFillType((SkPathFillType) 0);
10340path.moveTo(SkBits2Float(0x3d5d1b4e), SkBits2Float(0xc2a5fffe));
10341path.cubicTo(SkBits2Float(0x3da4d661), SkBits2Float(0xc2a5fffc), SkBits2Float(0x3ddb1fb1), SkBits2Float(0xc2a5fff8), SkBits2Float(0x3e08b47e), SkBits2Float(0xc2a5fff2));
10342path.lineTo(SkBits2Float(0x3dc5a6e0), SkBits2Float(0xc26fffec));
10343path.cubicTo(SkBits2Float(0x3d9e671d), SkBits2Float(0xc26ffff6), SkBits2Float(0x3d6e51bc), SkBits2Float(0xc26ffffb), SkBits2Float(0x3d1fd53d), SkBits2Float(0xc26ffffe));
10344path.lineTo(SkBits2Float(0x3d5d1b4e), SkBits2Float(0xc2a5fffe));
10345path.close();
10346
10347 SkPath path2(path);
10348 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10349}

◆ battleOp338()

static void battleOp338 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9513 of file PathOpsBattles.cpp.

9513 {
9514 SkPath path;
9515 path.setFillType((SkPathFillType) 1);
9516path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9517path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9518path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9519path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9520path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9521path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9522path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9523path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9524path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9525path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9526path.close();
9527
9528 SkPath path1(path);
9529 path.reset();
9530 path.setFillType((SkPathFillType) 0);
9531path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9532path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9533path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9534path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9535path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9536path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9537path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9538path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9539path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9540path.close();
9541
9542 SkPath path2(path);
9543 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9544}

◆ battleOp339()

static void battleOp339 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9547 of file PathOpsBattles.cpp.

9547 {
9548 SkPath path;
9549 path.setFillType((SkPathFillType) 0);
9550path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9551path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9552path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9553path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9554path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9555path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9556path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9557path.close();
9558
9559 SkPath path1(path);
9560 path.reset();
9561 path.setFillType((SkPathFillType) 0);
9562path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9563path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9564path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9565path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9566path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9567path.close();
9568
9569 SkPath path2(path);
9570 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9571}

◆ battleOp34()

static void battleOp34 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 968 of file PathOpsBattles.cpp.

968 {
969 SkPath path;
970 path.setFillType((SkPathFillType) 0);
971path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
972path.cubicTo(SkBits2Float(0x41360dec), SkBits2Float(0xc2a60000), SkBits2Float(0x41b5150e), SkBits2Float(0xc2a1522b), SkBits2Float(0x42044925), SkBits2Float(0xc29840e5));
973path.lineTo(SkBits2Float(0x41bf41a8), SkBits2Float(0xc25c2022));
974path.cubicTo(SkBits2Float(0x4182e721), SkBits2Float(0xc2693c30), SkBits2Float(0x41039b08), SkBits2Float(0xc2700000), SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
975path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
976path.close();
977
978 SkPath path1(path);
979 path.reset();
980 path.setFillType((SkPathFillType) 0);
981path.moveTo(SkBits2Float(0x42044925), SkBits2Float(0xc29840e4));
982path.cubicTo(SkBits2Float(0x4208721a), SkBits2Float(0xc2975992), SkBits2Float(0x420c9178), SkBits2Float(0xc296675c), SkBits2Float(0x4210a695), SkBits2Float(0xc2956a6a));
983path.lineTo(SkBits2Float(0x41d1222e), SkBits2Float(0xc25805ce));
984path.cubicTo(SkBits2Float(0x41cb3b2f), SkBits2Float(0xc2597382), SkBits2Float(0x41c5455b), SkBits2Float(0xc25ad1b2), SkBits2Float(0x41bf41a9), SkBits2Float(0xc25c2023));
985path.lineTo(SkBits2Float(0x42044925), SkBits2Float(0xc29840e4));
986path.close();
987
988 SkPath path2(path);
989 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
990}

◆ battleOp340()

static void battleOp340 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9574 of file PathOpsBattles.cpp.

9574 {
9575 SkPath path;
9576 path.setFillType((SkPathFillType) 1);
9577path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9578path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9579path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9580path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9581path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9582path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9583path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9584path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9585path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9586path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9587path.close();
9588
9589 SkPath path1(path);
9590 path.reset();
9591 path.setFillType((SkPathFillType) 0);
9592path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9593path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9594path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9595path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9596path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9597path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9598path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9599path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9600path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9601path.close();
9602
9603 SkPath path2(path);
9604 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9605}

◆ battleOp341()

static void battleOp341 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9608 of file PathOpsBattles.cpp.

9608 {
9609 SkPath path;
9610 path.setFillType((SkPathFillType) 0);
9611path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9612path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9613path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9614path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9615path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9616path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9617path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9618path.close();
9619
9620 SkPath path1(path);
9621 path.reset();
9622 path.setFillType((SkPathFillType) 0);
9623path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9624path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9625path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9626path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9627path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9628path.close();
9629
9630 SkPath path2(path);
9631 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9632}

◆ battleOp342()

static void battleOp342 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9635 of file PathOpsBattles.cpp.

9635 {
9636 SkPath path;
9637 path.setFillType((SkPathFillType) 1);
9638path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9639path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9640path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9641path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9642path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9643path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9644path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9645path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9646path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9647path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9648path.close();
9649
9650 SkPath path1(path);
9651 path.reset();
9652 path.setFillType((SkPathFillType) 0);
9653path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9654path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9655path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9656path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9657path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9658path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9659path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9660path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9661path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9662path.close();
9663
9664 SkPath path2(path);
9665 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9666}

◆ battleOp343()

static void battleOp343 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9669 of file PathOpsBattles.cpp.

9669 {
9670 SkPath path;
9671 path.setFillType((SkPathFillType) 0);
9672path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9673path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9674path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9675path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9676path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9677path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9678path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9679path.close();
9680
9681 SkPath path1(path);
9682 path.reset();
9683 path.setFillType((SkPathFillType) 0);
9684path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9685path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9686path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9687path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9688path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9689path.close();
9690
9691 SkPath path2(path);
9692 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9693}

◆ battleOp344()

static void battleOp344 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9696 of file PathOpsBattles.cpp.

9696 {
9697 SkPath path;
9698 path.setFillType((SkPathFillType) 1);
9699path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9700path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9701path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9702path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9703path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9704path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9705path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9706path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9707path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9708path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9709path.close();
9710
9711 SkPath path1(path);
9712 path.reset();
9713 path.setFillType((SkPathFillType) 0);
9714path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9715path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9716path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9717path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9718path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9719path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9720path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9721path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9722path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9723path.close();
9724
9725 SkPath path2(path);
9726 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9727}

◆ battleOp345()

static void battleOp345 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9730 of file PathOpsBattles.cpp.

9730 {
9731 SkPath path;
9732 path.setFillType((SkPathFillType) 0);
9733path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9734path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9735path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9736path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9737path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9738path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
9739path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9740path.close();
9741
9742 SkPath path1(path);
9743 path.reset();
9744 path.setFillType((SkPathFillType) 0);
9745path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9746path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9747path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9748path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9749path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
9750path.close();
9751
9752 SkPath path2(path);
9753 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9754}

◆ battleOp346()

static void battleOp346 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9757 of file PathOpsBattles.cpp.

9757 {
9758 SkPath path;
9759 path.setFillType((SkPathFillType) 1);
9760path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9761path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9762path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
9763path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
9764path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9765path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9766path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
9767path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
9768path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
9769path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9770path.close();
9771
9772 SkPath path1(path);
9773 path.reset();
9774 path.setFillType((SkPathFillType) 0);
9775path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9776path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
9777path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
9778path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
9779path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
9780path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
9781path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
9782path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
9783path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
9784path.close();
9785
9786 SkPath path2(path);
9787 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9788}

◆ battleOp347()

static void battleOp347 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9791 of file PathOpsBattles.cpp.

9791 {
9792 SkPath path;
9793 path.setFillType((SkPathFillType) 0);
9794path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9795path.cubicTo(SkBits2Float(0x3d570205), SkBits2Float(0xc2a60000), SkBits2Float(0x3dd7026d), SkBits2Float(0xc2a5fffa), SkBits2Float(0x3e2141e6), SkBits2Float(0xc2a5ffed));
9796path.lineTo(SkBits2Float(0x3de92565), SkBits2Float(0xc26fffe4));
9797path.cubicTo(SkBits2Float(0x3d9b6fac), SkBits2Float(0xc26ffff9), SkBits2Float(0x3d1b715b), SkBits2Float(0xc2700002), SkBits2Float(0x365677c0), SkBits2Float(0xc2700002));
9798path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9799path.close();
9800
9801 SkPath path1(path);
9802 path.reset();
9803 path.setFillType((SkPathFillType) 0);
9804path.moveTo(SkBits2Float(0x3e214267), SkBits2Float(0xc2a5ffec));
9805path.cubicTo(SkBits2Float(0x3e26a1f2), SkBits2Float(0xc2a5ffeb), SkBits2Float(0x3e2c025b), SkBits2Float(0xc2a5ffe9), SkBits2Float(0x3e3162c6), SkBits2Float(0xc2a5ffe7));
9806path.lineTo(SkBits2Float(0x3e003af5), SkBits2Float(0xc26fffde));
9807path.cubicTo(SkBits2Float(0x3df8b0d2), SkBits2Float(0xc26fffe0), SkBits2Float(0x3df0ead2), SkBits2Float(0xc26fffe2), SkBits2Float(0x3de924d4), SkBits2Float(0xc26fffe4));
9808path.lineTo(SkBits2Float(0x3e214267), SkBits2Float(0xc2a5ffec));
9809path.close();
9810
9811 SkPath path2(path);
9812 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9813}

◆ battleOp348()

static void battleOp348 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9816 of file PathOpsBattles.cpp.

9816 {
9817 SkPath path;
9818 path.setFillType((SkPathFillType) 1);
9819path.moveTo(SkBits2Float(0x365677c0), SkBits2Float(0xc2700002));
9820path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9821path.cubicTo(SkBits2Float(0x3d570205), SkBits2Float(0xc2a60000), SkBits2Float(0x3dd7026d), SkBits2Float(0xc2a5fffa), SkBits2Float(0x3e2141e6), SkBits2Float(0xc2a5ffed));
9822path.lineTo(SkBits2Float(0x3e0492ca), SkBits2Float(0xc28878a2));
9823path.lineTo(SkBits2Float(0x3e214267), SkBits2Float(0xc2a5ffec));
9824path.cubicTo(SkBits2Float(0x3e26a1f2), SkBits2Float(0xc2a5ffeb), SkBits2Float(0x3e2c025b), SkBits2Float(0xc2a5ffe9), SkBits2Float(0x3e3162c6), SkBits2Float(0xc2a5ffe7));
9825path.lineTo(SkBits2Float(0x3e003af5), SkBits2Float(0xc26fffde));
9826path.lineTo(SkBits2Float(0x3de92565), SkBits2Float(0xc26fffe4));
9827path.lineTo(SkBits2Float(0x3de924d4), SkBits2Float(0xc26fffe4));
9828path.cubicTo(SkBits2Float(0x3d9b6f4b), SkBits2Float(0xc26ffff9), SkBits2Float(0x3d1b70fa), SkBits2Float(0xc2700002), SkBits2Float(0x365677c0), SkBits2Float(0xc2700002));
9829path.close();
9830
9831 SkPath path1(path);
9832 path.reset();
9833 path.setFillType((SkPathFillType) 0);
9834path.moveTo(SkBits2Float(0x3e3162a4), SkBits2Float(0xc2a5ffe8));
9835path.cubicTo(SkBits2Float(0x3e843f51), SkBits2Float(0xc2a5ffd1), SkBits2Float(0x3eafcce9), SkBits2Float(0xc2a5ffa8), SkBits2Float(0x3edb5a6f), SkBits2Float(0xc2a5ff6f));
9836path.lineTo(SkBits2Float(0x3e9e9160), SkBits2Float(0xc26fff2e));
9837path.cubicTo(SkBits2Float(0x3e7e2aec), SkBits2Float(0xc26fff82), SkBits2Float(0x3e3f3306), SkBits2Float(0xc26fffbd), SkBits2Float(0x3e003b0e), SkBits2Float(0xc26fffdf));
9838path.lineTo(SkBits2Float(0x3e3162a4), SkBits2Float(0xc2a5ffe8));
9839path.close();
9840
9841 SkPath path2(path);
9842 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9843}

◆ battleOp349()

static void battleOp349 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9846 of file PathOpsBattles.cpp.

9846 {
9847 SkPath path;
9848 path.setFillType((SkPathFillType) 0);
9849path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9850path.cubicTo(SkBits2Float(0x3e678fda), SkBits2Float(0xc2a60000), SkBits2Float(0x3ee78f7d), SkBits2Float(0xc2a5ff87), SkBits2Float(0x3f2dab18), SkBits2Float(0xc2a5fe96));
9851path.lineTo(SkBits2Float(0x3efb15d4), SkBits2Float(0xc26ffdf3));
9852path.cubicTo(SkBits2Float(0x3ea764ab), SkBits2Float(0xc26fff52), SkBits2Float(0x3e2764f3), SkBits2Float(0xc2700000), SkBits2Float(0x35c73da0), SkBits2Float(0xc2700000));
9853path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9854path.close();
9855
9856 SkPath path1(path);
9857 path.reset();
9858 path.setFillType((SkPathFillType) 0);
9859path.moveTo(SkBits2Float(0x3f2daad3), SkBits2Float(0xc2a5fe95));
9860path.cubicTo(SkBits2Float(0x3f3374d8), SkBits2Float(0xc2a5fe7b), SkBits2Float(0x3f393eae), SkBits2Float(0xc2a5fe62), SkBits2Float(0x3f3f0885), SkBits2Float(0xc2a5fe46));
9861path.lineTo(SkBits2Float(0x3f0a18b8), SkBits2Float(0xc26ffd84));
9862path.cubicTo(SkBits2Float(0x3f05e964), SkBits2Float(0xc26ffdad), SkBits2Float(0x3f01ba2f), SkBits2Float(0xc26ffdd1), SkBits2Float(0x3efb15f0), SkBits2Float(0xc26ffdf5));
9863path.lineTo(SkBits2Float(0x3f2daad3), SkBits2Float(0xc2a5fe95));
9864path.close();
9865
9866 SkPath path2(path);
9867 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9868}

◆ battleOp35()

static void battleOp35 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 993 of file PathOpsBattles.cpp.

993 {
994 SkPath path;
995 path.setFillType((SkPathFillType) 1);
996path.moveTo(SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
997path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
998path.cubicTo(SkBits2Float(0x41360dec), SkBits2Float(0xc2a60000), SkBits2Float(0x41b5150e), SkBits2Float(0xc2a1522b), SkBits2Float(0x42044925), SkBits2Float(0xc29840e5));
999path.lineTo(SkBits2Float(0x4210a695), SkBits2Float(0xc2956a6a));
1000path.lineTo(SkBits2Float(0x41d1222e), SkBits2Float(0xc25805ce));
1001path.cubicTo(SkBits2Float(0x41cb3b2f), SkBits2Float(0xc2597382), SkBits2Float(0x41c5455b), SkBits2Float(0xc25ad1b2), SkBits2Float(0x41bf41a9), SkBits2Float(0xc25c2023));
1002path.lineTo(SkBits2Float(0x41bf41a8), SkBits2Float(0xc25c2022));
1003path.cubicTo(SkBits2Float(0x4182e721), SkBits2Float(0xc2693c30), SkBits2Float(0x41039b08), SkBits2Float(0xc2700000), SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
1004path.close();
1005
1006 SkPath path1(path);
1007 path.reset();
1008 path.setFillType((SkPathFillType) 0);
1009path.moveTo(SkBits2Float(0x4210a693), SkBits2Float(0xc2956a6a));
1010path.cubicTo(SkBits2Float(0x42536b4d), SkBits2Float(0xc2854182), SkBits2Float(0x4284b863), SkBits2Float(0xc254c33a), SkBits2Float(0x42950c68), SkBits2Float(0xc2122882));
1011path.lineTo(SkBits2Float(0x42577de3), SkBits2Float(0xc1d35027));
1012path.cubicTo(SkBits2Float(0x423fe27d), SkBits2Float(0xc219cde7), SkBits2Float(0x4218d548), SkBits2Float(0xc240a8bd), SkBits2Float(0x41d1222f), SkBits2Float(0xc25805ce));
1013path.lineTo(SkBits2Float(0x4210a693), SkBits2Float(0xc2956a6a));
1014path.close();
1015
1016 SkPath path2(path);
1017 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1018}

◆ battleOp350()

static void battleOp350 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9871 of file PathOpsBattles.cpp.

9871 {
9872 SkPath path;
9873 path.setFillType((SkPathFillType) 1);
9874path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9875path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9876path.cubicTo(SkBits2Float(0x3e678fda), SkBits2Float(0xc2a60000), SkBits2Float(0x3ee78f7d), SkBits2Float(0xc2a5ff87), SkBits2Float(0x3f2dab18), SkBits2Float(0xc2a5fe96));
9877path.cubicTo(SkBits2Float(0x3f3374d8), SkBits2Float(0xc2a5fe7b), SkBits2Float(0x3f393eae), SkBits2Float(0xc2a5fe62), SkBits2Float(0x3f3f0885), SkBits2Float(0xc2a5fe46));
9878path.lineTo(SkBits2Float(0x3f0a18b8), SkBits2Float(0xc26ffd84));
9879path.cubicTo(SkBits2Float(0x3f05e964), SkBits2Float(0xc26ffdad), SkBits2Float(0x3f01ba2f), SkBits2Float(0xc26ffdd1), SkBits2Float(0x3efb15f0), SkBits2Float(0xc26ffdf5));
9880path.lineTo(SkBits2Float(0x3efb15d4), SkBits2Float(0xc26ffdf3));
9881path.cubicTo(SkBits2Float(0x3ea764ab), SkBits2Float(0xc26fff52), SkBits2Float(0x3e2764f3), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9882path.close();
9883
9884 SkPath path1(path);
9885 path.reset();
9886 path.setFillType((SkPathFillType) 0);
9887path.moveTo(SkBits2Float(0x3f3f0899), SkBits2Float(0xc2a5fe48));
9888path.cubicTo(SkBits2Float(0x3f8e6b81), SkBits2Float(0xc2a5fc98), SkBits2Float(0x3fbd51fb), SkBits2Float(0xc2a5f9aa), SkBits2Float(0x3fec36d3), SkBits2Float(0xc2a5f57e));
9889path.lineTo(SkBits2Float(0x3faac1d7), SkBits2Float(0xc26ff0d0));
9890path.cubicTo(SkBits2Float(0x3f88dbac), SkBits2Float(0xc26ff6d7), SkBits2Float(0x3f4de8bb), SkBits2Float(0xc26ffb13), SkBits2Float(0x3f0a18e7), SkBits2Float(0xc26ffd83));
9891path.lineTo(SkBits2Float(0x3f3f0899), SkBits2Float(0xc2a5fe48));
9892path.close();
9893
9894 SkPath path2(path);
9895 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9896}

◆ battleOp351()

static void battleOp351 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9899 of file PathOpsBattles.cpp.

9899 {
9900 SkPath path;
9901 path.setFillType((SkPathFillType) 0);
9902path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9903path.cubicTo(SkBits2Float(0x403f62fc), SkBits2Float(0xc2a60000), SkBits2Float(0x40bf510b), SkBits2Float(0xc2a5ad41), SkBits2Float(0x410f39cc), SkBits2Float(0xc2a50821));
9904path.lineTo(SkBits2Float(0x40cf12cc), SkBits2Float(0xc26e99a0));
9905path.cubicTo(SkBits2Float(0x408a4d18), SkBits2Float(0xc26f885f), SkBits2Float(0x400a5a13), SkBits2Float(0xc2700000), SkBits2Float(0x36a6ff52), SkBits2Float(0xc2700000));
9906path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
9907path.close();
9908
9909 SkPath path1(path);
9910 path.reset();
9911 path.setFillType((SkPathFillType) 0);
9912path.moveTo(SkBits2Float(0x410f39cd), SkBits2Float(0xc2a50820));
9913path.cubicTo(SkBits2Float(0x4113fb3b), SkBits2Float(0xc2a4f79d), SkBits2Float(0x4118bbf1), SkBits2Float(0xc2a4e648), SkBits2Float(0x411d7be1), SkBits2Float(0xc2a4d421));
9914path.lineTo(SkBits2Float(0x40e3b008), SkBits2Float(0xc26e4e75));
9915path.cubicTo(SkBits2Float(0x40dcd206), SkBits2Float(0xc26e68b4), SkBits2Float(0x40d5f2eb), SkBits2Float(0xc26e81c3), SkBits2Float(0x40cf12c6), SkBits2Float(0xc26e99a1));
9916path.lineTo(SkBits2Float(0x410f39cd), SkBits2Float(0xc2a50820));
9917path.close();
9918
9919 SkPath path2(path);
9920 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9921}

◆ battleOp352()

static void battleOp352 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9923 of file PathOpsBattles.cpp.

9923 {
9924 SkPath path;
9925 path.setFillType((SkPathFillType) 1);
9926path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9927path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
9928path.cubicTo(SkBits2Float(0x3e0b17a8), SkBits2Float(0xc2a60000), SkBits2Float(0x3e8b179e), SkBits2Float(0xc2a5ffd4), SkBits2Float(0x3ed0a337), SkBits2Float(0xc2a5ff7c));
9929path.lineTo(SkBits2Float(0x3ed0a338), SkBits2Float(0xc2a5ff7d));
9930path.cubicTo(SkBits2Float(0x3ed797a0), SkBits2Float(0xc2a5ff73), SkBits2Float(0x3ede8c36), SkBits2Float(0xc2a5ff6a), SkBits2Float(0x3ee580cb), SkBits2Float(0xc2a5ff60));
9931path.lineTo(SkBits2Float(0x3ea5e78a), SkBits2Float(0xc26fff1b));
9932path.cubicTo(SkBits2Float(0x3ea0e0bb), SkBits2Float(0xc26fff29), SkBits2Float(0x3e9bd9a1), SkBits2Float(0xc26fff36), SkBits2Float(0x3e96d286), SkBits2Float(0xc26fff43));
9933path.lineTo(SkBits2Float(0x3e96d285), SkBits2Float(0xc26fff42));
9934path.cubicTo(SkBits2Float(0x3e491945), SkBits2Float(0xc26fffc2), SkBits2Float(0x3dc91958), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
9935path.close();
9936
9937 SkPath path1(path);
9938 path.reset();
9939 path.setFillType((SkPathFillType) 0);
9940path.moveTo(SkBits2Float(0x3ee58048), SkBits2Float(0xc2a5ff61));
9941path.cubicTo(SkBits2Float(0x3f2b1987), SkBits2Float(0xc2a5fec4), SkBits2Float(0x3f637253), SkBits2Float(0xc2a5fdb6), SkBits2Float(0x3f8de535), SkBits2Float(0xc2a5fc35));
9942path.lineTo(SkBits2Float(0x3f4d269a), SkBits2Float(0xc26ffa85));
9943path.cubicTo(SkBits2Float(0x3f246b51), SkBits2Float(0xc26ffcb3), SkBits2Float(0x3ef75f30), SkBits2Float(0xc26ffe3a), SkBits2Float(0x3ea5e737), SkBits2Float(0xc26fff1c));
9944path.lineTo(SkBits2Float(0x3ee58048), SkBits2Float(0xc2a5ff61));
9945path.close();
9946
9947 SkPath path2(path);
9948 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
9949}

◆ battleOp36()

static void battleOp36 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1021 of file PathOpsBattles.cpp.

1021 {
1022 SkPath path;
1023 path.setFillType((SkPathFillType) 0);
1024path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1025path.cubicTo(SkBits2Float(0x414e6589), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41ccf9e5), SkBits2Float(0xc29ffc89), SkBits2Float(0x4214a0bb), SkBits2Float(0xc2946fc8));
1026path.lineTo(SkBits2Float(0x41d6e236), SkBits2Float(0xc2569b72));
1027path.cubicTo(SkBits2Float(0x41942cf0), SkBits2Float(0xc2674e45), SkBits2Float(0x411533d1), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1028path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1029path.close();
1030
1031 SkPath path1(path);
1032 path.reset();
1033 path.setFillType((SkPathFillType) 0);
1034path.moveTo(SkBits2Float(0x4214a0bb), SkBits2Float(0xc2946fc9));
1035path.cubicTo(SkBits2Float(0x421938a6), SkBits2Float(0xc293496b), SkBits2Float(0x421dc2c1), SkBits2Float(0xc2921574), SkBits2Float(0x42223e19), SkBits2Float(0xc290d421));
1036path.lineTo(SkBits2Float(0x41ea914d), SkBits2Float(0xc251640c));
1037path.cubicTo(SkBits2Float(0x41e4167f), SkBits2Float(0xc253349e), SkBits2Float(0x41dd8659), SkBits2Float(0xc254f1de), SkBits2Float(0x41d6e239), SkBits2Float(0xc2569b73));
1038path.lineTo(SkBits2Float(0x4214a0bb), SkBits2Float(0xc2946fc9));
1039path.close();
1040
1041 SkPath path2(path);
1042 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1043}

◆ battleOp37()

static void battleOp37 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1046 of file PathOpsBattles.cpp.

1046 {
1047 SkPath path;
1048 path.setFillType((SkPathFillType) 1);
1049path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1050path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1051path.cubicTo(SkBits2Float(0x414e6589), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41ccf9e5), SkBits2Float(0xc29ffc89), SkBits2Float(0x4214a0bb), SkBits2Float(0xc2946fc9));
1052path.cubicTo(SkBits2Float(0x421938a6), SkBits2Float(0xc293496b), SkBits2Float(0x421dc2c1), SkBits2Float(0xc2921574), SkBits2Float(0x42223e19), SkBits2Float(0xc290d421));
1053path.lineTo(SkBits2Float(0x41ea914d), SkBits2Float(0xc251640c));
1054path.cubicTo(SkBits2Float(0x41e4167f), SkBits2Float(0xc253349e), SkBits2Float(0x41dd8659), SkBits2Float(0xc254f1de), SkBits2Float(0x41d6e239), SkBits2Float(0xc2569b73));
1055path.lineTo(SkBits2Float(0x41d6e236), SkBits2Float(0xc2569b72));
1056path.cubicTo(SkBits2Float(0x41942cf0), SkBits2Float(0xc2674e45), SkBits2Float(0x411533d1), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1057path.close();
1058
1059 SkPath path1(path);
1060 path.reset();
1061 path.setFillType((SkPathFillType) 0);
1062path.moveTo(SkBits2Float(0x42223e19), SkBits2Float(0xc290d422));
1063path.cubicTo(SkBits2Float(0x426bbc38), SkBits2Float(0xc2787e1d), SkBits2Float(0x42916a94), SkBits2Float(0xc234ee59), SkBits2Float(0x429e2fac), SkBits2Float(0xc1c951fc));
1064path.lineTo(SkBits2Float(0x4264b3f7), SkBits2Float(0xc191885f));
1065path.cubicTo(SkBits2Float(0x42523d91), SkBits2Float(0xc202cb25), SkBits2Float(0x422a6939), SkBits2Float(0xc233a21b), SkBits2Float(0x41ea914d), SkBits2Float(0xc251640d));
1066path.lineTo(SkBits2Float(0x42223e19), SkBits2Float(0xc290d422));
1067path.close();
1068
1069 SkPath path2(path);
1070 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1071}

◆ battleOp38()

static void battleOp38 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1074 of file PathOpsBattles.cpp.

1074 {
1075 SkPath path;
1076 path.setFillType((SkPathFillType) 0);
1077path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1078path.cubicTo(SkBits2Float(0x416c96cf), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41ea70fe), SkBits2Float(0xc29e1973), SkBits2Float(0x422836c6), SkBits2Float(0xc28f1d8a));
1079path.lineTo(SkBits2Float(0x41f3336d), SkBits2Float(0xc24ee9f1));
1080path.cubicTo(SkBits2Float(0x41a979c6), SkBits2Float(0xc26493d6), SkBits2Float(0x412b073c), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1081path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1082path.close();
1083
1084 SkPath path1(path);
1085 path.reset();
1086 path.setFillType((SkPathFillType) 0);
1087path.moveTo(SkBits2Float(0x422836c5), SkBits2Float(0xc28f1d8b));
1088path.cubicTo(SkBits2Float(0x422d4896), SkBits2Float(0xc28da02f), SkBits2Float(0x423245ea), SkBits2Float(0xc28c11a8), SkBits2Float(0x42372d65), SkBits2Float(0xc28a7261));
1089path.lineTo(SkBits2Float(0x42046ad7), SkBits2Float(0xc24829ff));
1090path.cubicTo(SkBits2Float(0x4200df44), SkBits2Float(0xc24a8267), SkBits2Float(0x41fa87ca), SkBits2Float(0xc24cc296), SkBits2Float(0x41f3336d), SkBits2Float(0xc24ee9f1));
1091path.lineTo(SkBits2Float(0x422836c5), SkBits2Float(0xc28f1d8b));
1092path.close();
1093
1094 SkPath path2(path);
1095 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1096}

◆ battleOp39()

static void battleOp39 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1099 of file PathOpsBattles.cpp.

1099 {
1100 SkPath path;
1101 path.setFillType((SkPathFillType) 1);
1102path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1103path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1104path.cubicTo(SkBits2Float(0x416c96cf), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41ea70fe), SkBits2Float(0xc29e1973), SkBits2Float(0x422836c5), SkBits2Float(0xc28f1d8b));
1105path.cubicTo(SkBits2Float(0x422d4896), SkBits2Float(0xc28da02f), SkBits2Float(0x423245ea), SkBits2Float(0xc28c11a8), SkBits2Float(0x42372d65), SkBits2Float(0xc28a7261));
1106path.lineTo(SkBits2Float(0x42046ad7), SkBits2Float(0xc24829ff));
1107path.cubicTo(SkBits2Float(0x4200df44), SkBits2Float(0xc24a8267), SkBits2Float(0x41fa87ca), SkBits2Float(0xc24cc296), SkBits2Float(0x41f3336d), SkBits2Float(0xc24ee9f1));
1108path.cubicTo(SkBits2Float(0x41a979c6), SkBits2Float(0xc26493d6), SkBits2Float(0x412b073c), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1109path.close();
1110
1111 SkPath path1(path);
1112 path.reset();
1113 path.setFillType((SkPathFillType) 0);
1114path.moveTo(SkBits2Float(0x42372d65), SkBits2Float(0xc28a7262));
1115path.cubicTo(SkBits2Float(0x4283f2b3), SkBits2Float(0xc25f7e9c), SkBits2Float(0x429ea5c2), SkBits2Float(0xc2098801), SkBits2Float(0x42a4b292), SkBits2Float(0xc12607b1));
1116path.lineTo(SkBits2Float(0x426e1def), SkBits2Float(0xc0f00b21));
1117path.cubicTo(SkBits2Float(0x42655eb1), SkBits2Float(0xc1c6d725), SkBits2Float(0x423ec4ad), SkBits2Float(0xc2218ff6), SkBits2Float(0x42046ad7), SkBits2Float(0xc2482a00));
1118path.lineTo(SkBits2Float(0x42372d65), SkBits2Float(0xc28a7262));
1119path.close();
1120
1121 SkPath path2(path);
1122 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1123}

◆ battleOp4()

static void battleOp4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 171 of file PathOpsBattles.cpp.

171 {
172 SkPath path;
173 path.setFillType((SkPathFillType) 1);
174path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
175path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
176path.cubicTo(SkBits2Float(0x3f19f03c), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f99ef95), SkBits2Float(0xc2a5fca7), SkBits2Float(0x3fe6e322), SkBits2Float(0xc2a5f5f7));
177path.cubicTo(SkBits2Float(0x3fee94fb), SkBits2Float(0xc2a5f54c), SkBits2Float(0x3ff646db), SkBits2Float(0xc2a5f497), SkBits2Float(0x3ffdf8ad), SkBits2Float(0xc2a5f3db));
178path.lineTo(SkBits2Float(0x3fb79813), SkBits2Float(0xc26fee71));
179path.cubicTo(SkBits2Float(0x3fb20808), SkBits2Float(0xc26fef82), SkBits2Float(0x3fac780f), SkBits2Float(0xc26ff085), SkBits2Float(0x3fa6e80c), SkBits2Float(0xc26ff17d));
180path.lineTo(SkBits2Float(0x3fa6e7f4), SkBits2Float(0xc26ff17d));
181path.cubicTo(SkBits2Float(0x3f5e8eb4), SkBits2Float(0xc26ffb2a), SkBits2Float(0x3ede8fa6), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
182path.close();
183
184 SkPath path1(path);
185 path.reset();
186 path.setFillType((SkPathFillType) 0);
187path.moveTo(SkBits2Float(0x3ffdf8c6), SkBits2Float(0xc2a5f3db));
188path.cubicTo(SkBits2Float(0x403d5556), SkBits2Float(0xc2a5e7ed), SkBits2Float(0x407ba65a), SkBits2Float(0xc2a5d338), SkBits2Float(0x409cf3fe), SkBits2Float(0xc2a5b5bc));
189path.lineTo(SkBits2Float(0x4062eb8a), SkBits2Float(0xc26f94a1));
190path.cubicTo(SkBits2Float(0x4035ea63), SkBits2Float(0xc26fbf44), SkBits2Float(0x4008de16), SkBits2Float(0xc26fdd35), SkBits2Float(0x3fb79810), SkBits2Float(0xc26fee74));
191path.lineTo(SkBits2Float(0x3ffdf8c6), SkBits2Float(0xc2a5f3db));
192path.close();
193
194 SkPath path2(path);
195 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
196}

◆ battleOp40()

static void battleOp40 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1126 of file PathOpsBattles.cpp.

1126 {
1127 SkPath path;
1128 path.setFillType((SkPathFillType) 0);
1129path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1130path.cubicTo(SkBits2Float(0x4184d4a8), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42034ddf), SkBits2Float(0xc29c0a4c), SkBits2Float(0x423a47b2), SkBits2Float(0xc289686d));
1131path.lineTo(SkBits2Float(0x4206a908), SkBits2Float(0xc246a97c));
1132path.cubicTo(SkBits2Float(0x41bdd65f), SkBits2Float(0xc26199af), SkBits2Float(0x41400b5c), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
1133path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1134path.close();
1135
1136 SkPath path1(path);
1137 path.reset();
1138 path.setFillType((SkPathFillType) 0);
1139path.moveTo(SkBits2Float(0x423a47b2), SkBits2Float(0xc289686d));
1140path.cubicTo(SkBits2Float(0x423fbcc3), SkBits2Float(0xc2878eef), SkBits2Float(0x4245154e), SkBits2Float(0xc285a0be), SkBits2Float(0x424a4f85), SkBits2Float(0xc2839e81));
1141path.lineTo(SkBits2Float(0x42123fa7), SkBits2Float(0xc23e4af2));
1142path.cubicTo(SkBits2Float(0x420e7846), SkBits2Float(0xc241326c), SkBits2Float(0x420a9af5), SkBits2Float(0xc243fcec), SkBits2Float(0x4206a907), SkBits2Float(0xc246a97c));
1143path.lineTo(SkBits2Float(0x423a47b2), SkBits2Float(0xc289686d));
1144path.close();
1145
1146 SkPath path2(path);
1147 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1148}

◆ battleOp402()

static void battleOp402 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10613 of file PathOpsBattles.cpp.

10613 {
10614 SkPath path;
10615 path.setFillType((SkPathFillType) 1);
10616path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10617path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10618path.cubicTo(SkBits2Float(0x3e0b17a8), SkBits2Float(0xc2a60000), SkBits2Float(0x3e8b179e), SkBits2Float(0xc2a5ffd4), SkBits2Float(0x3ed0a337), SkBits2Float(0xc2a5ff7c));
10619path.lineTo(SkBits2Float(0x3ed0a338), SkBits2Float(0xc2a5ff7d));
10620path.cubicTo(SkBits2Float(0x3ed797a0), SkBits2Float(0xc2a5ff73), SkBits2Float(0x3ede8c36), SkBits2Float(0xc2a5ff6a), SkBits2Float(0x3ee580cb), SkBits2Float(0xc2a5ff60));
10621path.lineTo(SkBits2Float(0x3ea5e78a), SkBits2Float(0xc26fff1b));
10622path.cubicTo(SkBits2Float(0x3ea0e0bb), SkBits2Float(0xc26fff29), SkBits2Float(0x3e9bd9a1), SkBits2Float(0xc26fff36), SkBits2Float(0x3e96d286), SkBits2Float(0xc26fff43));
10623path.lineTo(SkBits2Float(0x3e96d285), SkBits2Float(0xc26fff42));
10624path.cubicTo(SkBits2Float(0x3e491945), SkBits2Float(0xc26fffc2), SkBits2Float(0x3dc91958), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10625path.close();
10626
10627 SkPath path1(path);
10628 path.reset();
10629 path.setFillType((SkPathFillType) 0);
10630path.moveTo(SkBits2Float(0x3ee58048), SkBits2Float(0xc2a5ff61));
10631path.cubicTo(SkBits2Float(0x3f2b1987), SkBits2Float(0xc2a5fec4), SkBits2Float(0x3f637253), SkBits2Float(0xc2a5fdb6), SkBits2Float(0x3f8de535), SkBits2Float(0xc2a5fc35));
10632path.lineTo(SkBits2Float(0x3f4d269a), SkBits2Float(0xc26ffa85));
10633path.cubicTo(SkBits2Float(0x3f246b51), SkBits2Float(0xc26ffcb3), SkBits2Float(0x3ef75f30), SkBits2Float(0xc26ffe3a), SkBits2Float(0x3ea5e737), SkBits2Float(0xc26fff1c));
10634path.lineTo(SkBits2Float(0x3ee58048), SkBits2Float(0xc2a5ff61));
10635path.close();
10636
10637 SkPath path2(path);
10638 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10639}

◆ battleOp41()

static void battleOp41 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1151 of file PathOpsBattles.cpp.

1151 {
1152 SkPath path;
1153 path.setFillType((SkPathFillType) 0);
1154path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1155path.cubicTo(SkBits2Float(0x4196c4f9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42148669), SkBits2Float(0xc2992c23), SkBits2Float(0x424f6452), SkBits2Float(0xc281a081));
1156path.lineTo(SkBits2Float(0x4215ebfd), SkBits2Float(0xc23b6999));
1157path.cubicTo(SkBits2Float(0x41d6bc2a), SkBits2Float(0xc25d7441), SkBits2Float(0x4159fada), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
1158path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1159path.close();
1160
1161 SkPath path1(path);
1162 path.reset();
1163 path.setFillType((SkPathFillType) 0);
1164path.moveTo(SkBits2Float(0x424f6452), SkBits2Float(0xc281a081));
1165path.cubicTo(SkBits2Float(0x42553921), SkBits2Float(0xc27e96d1), SkBits2Float(0x425ae53b), SkBits2Float(0xc279ba9d), SkBits2Float(0x42606622), SkBits2Float(0xc274ae80));
1166path.lineTo(SkBits2Float(0x42223753), SkBits2Float(0xc230e0d8));
1167path.cubicTo(SkBits2Float(0x421e3cd8), SkBits2Float(0xc23486e8), SkBits2Float(0x421a2322), SkBits2Float(0xc2380a55), SkBits2Float(0x4215ebfe), SkBits2Float(0xc23b6999));
1168path.lineTo(SkBits2Float(0x424f6452), SkBits2Float(0xc281a081));
1169path.close();
1170
1171 SkPath path2(path);
1172 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1173}

◆ battleOp42()

static void battleOp42 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1176 of file PathOpsBattles.cpp.

1176 {
1177 SkPath path;
1178 path.setFillType((SkPathFillType) 1);
1179path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1180path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1181path.cubicTo(SkBits2Float(0x4196c4f9), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42148669), SkBits2Float(0xc2992c23), SkBits2Float(0x424f6452), SkBits2Float(0xc281a081));
1182path.cubicTo(SkBits2Float(0x42553921), SkBits2Float(0xc27e96d1), SkBits2Float(0x425ae53b), SkBits2Float(0xc279ba9d), SkBits2Float(0x42606622), SkBits2Float(0xc274ae80));
1183path.lineTo(SkBits2Float(0x42223753), SkBits2Float(0xc230e0d8));
1184path.cubicTo(SkBits2Float(0x421e3cd8), SkBits2Float(0xc23486e8), SkBits2Float(0x421a2322), SkBits2Float(0xc2380a55), SkBits2Float(0x4215ebfd), SkBits2Float(0xc23b6999));
1185path.cubicTo(SkBits2Float(0x41d6bc2a), SkBits2Float(0xc25d7441), SkBits2Float(0x4159fada), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1186path.close();
1187
1188 SkPath path1(path);
1189 path.reset();
1190 path.setFillType((SkPathFillType) 0);
1191path.moveTo(SkBits2Float(0x42606622), SkBits2Float(0xc274ae80));
1192path.cubicTo(SkBits2Float(0x429deeac), SkBits2Float(0xc220cc44), SkBits2Float(0x42b0742c), SkBits2Float(0xc1039d5c), SkBits2Float(0x42a03731), SkBits2Float(0x41adc1b3));
1193path.lineTo(SkBits2Float(0x4267a314), SkBits2Float(0x417b36e3));
1194path.cubicTo(SkBits2Float(0x427f1d2c), SkBits2Float(0xc0be4950), SkBits2Float(0x426455fc), SkBits2Float(0xc1e87a9a), SkBits2Float(0x42223754), SkBits2Float(0xc230e0d7));
1195path.lineTo(SkBits2Float(0x42606622), SkBits2Float(0xc274ae80));
1196path.close();
1197
1198 SkPath path2(path);
1199 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1200}

◆ battleOp4290()

static void battleOp4290 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10351 of file PathOpsBattles.cpp.

10351 {
10352 SkPath path;
10353 path.setFillType((SkPathFillType) 1);
10354path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10355path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10356path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10357path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10358path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10359path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10360path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10361path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10362path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10363path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10364path.close();
10365
10366 SkPath path1(path);
10367 path.reset();
10368 path.setFillType((SkPathFillType) 0);
10369path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10370path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
10371path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
10372path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
10373path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
10374path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
10375path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
10376path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10377path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10378path.close();
10379
10380 SkPath path2(path);
10381 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10382}

◆ battleOp4291()

static void battleOp4291 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10385 of file PathOpsBattles.cpp.

10385 {
10386 SkPath path;
10387 path.setFillType((SkPathFillType) 0);
10388path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10389path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10390path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10391path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10392path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10393path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
10394path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10395path.close();
10396
10397 SkPath path1(path);
10398 path.reset();
10399 path.setFillType((SkPathFillType) 0);
10400path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10401path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10402path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10403path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10404path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10405path.close();
10406
10407 SkPath path2(path);
10408 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10409}

◆ battleOp4292()

static void battleOp4292 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10412 of file PathOpsBattles.cpp.

10412 {
10413 SkPath path;
10414 path.setFillType((SkPathFillType) 1);
10415path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10416path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10417path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10418path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10419path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10420path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10421path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10422path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10423path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10424path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10425path.close();
10426
10427 SkPath path1(path);
10428 path.reset();
10429 path.setFillType((SkPathFillType) 0);
10430path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10431path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
10432path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
10433path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
10434path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
10435path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
10436path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
10437path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10438path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10439path.close();
10440
10441 SkPath path2(path);
10442 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10443}

◆ battleOp4293()

static void battleOp4293 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10446 of file PathOpsBattles.cpp.

10446 {
10447 SkPath path;
10448 path.setFillType((SkPathFillType) 0);
10449path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10450path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10451path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10452path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10453path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10454path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
10455path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10456path.close();
10457
10458 SkPath path1(path);
10459 path.reset();
10460 path.setFillType((SkPathFillType) 0);
10461path.moveTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10462path.cubicTo(SkBits2Float(0x42643732), SkBits2Float(0x42727ac8), SkBits2Float(0x4250db30), SkBits2Float(0x4281abaa), SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10463path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10464path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10465path.lineTo(SkBits2Float(0x42757226), SkBits2Float(0x425f9012));
10466path.close();
10467
10468 SkPath path2(path);
10469 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10470}

◆ battleOp4294()

static void battleOp4294 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10473 of file PathOpsBattles.cpp.

10473 {
10474 SkPath path;
10475 path.setFillType((SkPathFillType) 1);
10476path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10477path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10478path.cubicTo(SkBits2Float(0x42037818), SkBits2Float(0xc2a60000), SkBits2Float(0x427a8dee), SkBits2Float(0xc27e6c10), SkBits2Float(0x4297d76f), SkBits2Float(0xc2062a8f));
10479path.cubicTo(SkBits2Float(0x42b267e8), SkBits2Float(0xc05e90e8), SkBits2Float(0x42a6fcc7), SkBits2Float(0x41fcbc94), SkBits2Float(0x42757227), SkBits2Float(0x425f9011));
10480path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10481path.lineTo(SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10482path.cubicTo(SkBits2Float(0x4216fafb), SkBits2Float(0x423b79ba), SkBits2Float(0x4224f9a4), SkBits2Float(0x422f4956), SkBits2Float(0x42316e48), SkBits2Float(0x42219c94));
10483path.lineTo(SkBits2Float(0x42316e47), SkBits2Float(0x42219c94));
10484path.cubicTo(SkBits2Float(0x42716d77), SkBits2Float(0x41b6b381), SkBits2Float(0x4280f7d6), SkBits2Float(0xc020e418), SkBits2Float(0x425b87ab), SkBits2Float(0xc1c1f9ac));
10485path.cubicTo(SkBits2Float(0x42351faa), SkBits2Float(0xc237eb6b), SkBits2Float(0x41be136b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10486path.close();
10487
10488 SkPath path1(path);
10489 path.reset();
10490 path.setFillType((SkPathFillType) 0);
10491path.moveTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10492path.cubicTo(SkBits2Float(0x418c17fd), SkBits2Float(0x42b142f1), SkBits2Float(0xc1ac24e4), SkBits2Float(0x42af7d09), SkBits2Float(0xc247fe03), SkBits2Float(0x42848083));
10493path.cubicTo(SkBits2Float(0xc29cf4c9), SkBits2Float(0x423307fa), SkBits2Float(0xc2b411ee), SkBits2Float(0x40eef84a), SkBits2Float(0xc29d6723), SkBits2Float(0xc1d2ea61));
10494path.cubicTo(SkBits2Float(0xc286bc59), SkBits2Float(0xc270c968), SkBits2Float(0xc20eb871), SkBits2Float(0xc2a5ffff), SkBits2Float(0xb5c727ee), SkBits2Float(0xc2a5ffff));
10495path.lineTo(SkBits2Float(0x293e5cb4), SkBits2Float(0xc2700000));
10496path.cubicTo(SkBits2Float(0xc1ce57c4), SkBits2Float(0xc2700000), SkBits2Float(0xc242cc76), SkBits2Float(0xc22e100c), SkBits2Float(0xc2639208), SkBits2Float(0xc1987810));
10497path.cubicTo(SkBits2Float(0xc2822bcd), SkBits2Float(0x40acbfe2), SkBits2Float(0xc262ecb3), SkBits2Float(0x42016b8c), SkBits2Float(0xc210929c), SkBits2Float(0x423f91b4));
10498path.cubicTo(SkBits2Float(0xc178e211), SkBits2Float(0x427db7dc), SkBits2Float(0x414a8b85), SkBits2Float(0x4280240f), SkBits2Float(0x4207b9a6), SkBits2Float(0x4245efa0));
10499path.lineTo(SkBits2Float(0x423bc0d1), SkBits2Float(0x4288e7e0));
10500path.close();
10501
10502 SkPath path2(path);
10503 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10504}

◆ battleOp4295()

static void battleOp4295 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10507 of file PathOpsBattles.cpp.

10507 {
10508 SkPath path;
10509 path.setFillType((SkPathFillType) 0);
10510path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10511path.cubicTo(SkBits2Float(0x3e3881bc), SkBits2Float(0xc2a60000), SkBits2Float(0x3eb88238), SkBits2Float(0xc2a5ffb3), SkBits2Float(0x3f0a6190), SkBits2Float(0xc2a5ff19));
10512path.lineTo(SkBits2Float(0x3ec8119b), SkBits2Float(0xc26ffeb2));
10513path.cubicTo(SkBits2Float(0x3e856151), SkBits2Float(0xc26fff91), SkBits2Float(0x3e0561b2), SkBits2Float(0xc2700000), SkBits2Float(0x3629eed0), SkBits2Float(0xc2700000));
10514path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10515path.close();
10516
10517 SkPath path1(path);
10518 path.reset();
10519 path.setFillType((SkPathFillType) 0);
10520path.moveTo(SkBits2Float(0x3f0a6183), SkBits2Float(0xc2a5ff19));
10521path.cubicTo(SkBits2Float(0x3f0efe46), SkBits2Float(0xc2a5ff0a), SkBits2Float(0x3f139b44), SkBits2Float(0xc2a5fef9), SkBits2Float(0x3f183842), SkBits2Float(0xc2a5fee9));
10522path.lineTo(SkBits2Float(0x3edc1349), SkBits2Float(0xc26ffe6c));
10523path.cubicTo(SkBits2Float(0x3ed567f5), SkBits2Float(0xc26ffe84), SkBits2Float(0x3ecebccf), SkBits2Float(0xc26ffe9c), SkBits2Float(0x3ec811a8), SkBits2Float(0xc26ffeb2));
10524path.lineTo(SkBits2Float(0x3f0a6183), SkBits2Float(0xc2a5ff19));
10525path.close();
10526
10527 SkPath path2(path);
10528 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10529}

◆ battleOp4296()

static void battleOp4296 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10532 of file PathOpsBattles.cpp.

10532 {
10533 SkPath path;
10534 path.setFillType((SkPathFillType) 1);
10535path.moveTo(SkBits2Float(0x3629eed0), SkBits2Float(0xc2700000));
10536path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10537path.cubicTo(SkBits2Float(0x3e3881ab), SkBits2Float(0xc2a60000), SkBits2Float(0x3eb88227), SkBits2Float(0xc2a5ffb3), SkBits2Float(0x3f0a6183), SkBits2Float(0xc2a5ff19));
10538path.lineTo(SkBits2Float(0x3f0a6190), SkBits2Float(0xc2a5ff19));
10539path.cubicTo(SkBits2Float(0x3f0efe4f), SkBits2Float(0xc2a5ff0a), SkBits2Float(0x3f139b48), SkBits2Float(0xc2a5fef9), SkBits2Float(0x3f183842), SkBits2Float(0xc2a5fee9));
10540path.lineTo(SkBits2Float(0x3edc1349), SkBits2Float(0xc26ffe6c));
10541path.cubicTo(SkBits2Float(0x3ed567f5), SkBits2Float(0xc26ffe84), SkBits2Float(0x3ecebccf), SkBits2Float(0xc26ffe9c), SkBits2Float(0x3ec811a8), SkBits2Float(0xc26ffeb2));
10542path.lineTo(SkBits2Float(0x3ec8119b), SkBits2Float(0xc26ffeb2));
10543path.cubicTo(SkBits2Float(0x3e856151), SkBits2Float(0xc26fff91), SkBits2Float(0x3e0561b2), SkBits2Float(0xc2700000), SkBits2Float(0x3629eed0), SkBits2Float(0xc2700000));
10544path.close();
10545
10546 SkPath path1(path);
10547 path.reset();
10548 path.setFillType((SkPathFillType) 0);
10549path.moveTo(SkBits2Float(0x3f183800), SkBits2Float(0xc2a5fee9));
10550path.cubicTo(SkBits2Float(0x3f62f7a2), SkBits2Float(0xc2a5fdd7), SkBits2Float(0x3f96db12), SkBits2Float(0xc2a5fbfa), SkBits2Float(0x3fbc3981), SkBits2Float(0xc2a5f954));
10551path.lineTo(SkBits2Float(0x3f8810cc), SkBits2Float(0xc26ff65b));
10552path.cubicTo(SkBits2Float(0x3f5a1a86), SkBits2Float(0xc26ffa2f), SkBits2Float(0x3f241256), SkBits2Float(0xc26ffcdf), SkBits2Float(0x3edc1312), SkBits2Float(0xc26ffe6c));
10553path.lineTo(SkBits2Float(0x3f183800), SkBits2Float(0xc2a5fee9));
10554path.close();
10555
10556 SkPath path2(path);
10557 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10558}

◆ battleOp43()

static void battleOp43 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1203 of file PathOpsBattles.cpp.

1203 {
1204 SkPath path;
1205 path.setFillType((SkPathFillType) 0);
1206path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1207path.cubicTo(SkBits2Float(0x41aa5d9e), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42271b56), SkBits2Float(0xc295a109), SkBits2Float(0x4264d340), SkBits2Float(0xc2708c1d));
1208path.lineTo(SkBits2Float(0x42256a74), SkBits2Float(0xc22de3bf));
1209path.cubicTo(SkBits2Float(0x41f199ac), SkBits2Float(0xc25854c9), SkBits2Float(0x41764fdb), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1210path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1211path.close();
1212
1213 SkPath path1(path);
1214 path.reset();
1215 path.setFillType((SkPathFillType) 0);
1216path.moveTo(SkBits2Float(0x4264d342), SkBits2Float(0xc2708c1d));
1217path.cubicTo(SkBits2Float(0x426aec59), SkBits2Float(0xc26abf16), SkBits2Float(0x4270cc6c), SkBits2Float(0xc264b73d), SkBits2Float(0x42767031), SkBits2Float(0xc25e77e8));
1218path.lineTo(SkBits2Float(0x423225ec), SkBits2Float(0xc220d20e));
1219path.cubicTo(SkBits2Float(0x422e123c), SkBits2Float(0xc2255633), SkBits2Float(0x4229d2f5), SkBits2Float(0xc229b23c), SkBits2Float(0x42256a74), SkBits2Float(0xc22de3c0));
1220path.lineTo(SkBits2Float(0x4264d342), SkBits2Float(0xc2708c1d));
1221path.close();
1222
1223 SkPath path2(path);
1224 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1225}

◆ battleOp44()

static void battleOp44 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1228 of file PathOpsBattles.cpp.

1228 {
1229 SkPath path;
1230 path.setFillType((SkPathFillType) 1);
1231path.moveTo(SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1232path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1233path.cubicTo(SkBits2Float(0x41aa5d9e), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42271b56), SkBits2Float(0xc295a109), SkBits2Float(0x4264d340), SkBits2Float(0xc2708c1d));
1234path.lineTo(SkBits2Float(0x4264d342), SkBits2Float(0xc2708c1d));
1235path.cubicTo(SkBits2Float(0x426aec59), SkBits2Float(0xc26abf16), SkBits2Float(0x4270cc6c), SkBits2Float(0xc264b73d), SkBits2Float(0x42767031), SkBits2Float(0xc25e77e8));
1236path.lineTo(SkBits2Float(0x423225ec), SkBits2Float(0xc220d20e));
1237path.cubicTo(SkBits2Float(0x422e123c), SkBits2Float(0xc2255633), SkBits2Float(0x4229d2f5), SkBits2Float(0xc229b23c), SkBits2Float(0x42256a74), SkBits2Float(0xc22de3c0));
1238path.lineTo(SkBits2Float(0x42256a74), SkBits2Float(0xc22de3bf));
1239path.cubicTo(SkBits2Float(0x41f199ac), SkBits2Float(0xc25854c9), SkBits2Float(0x41764fdb), SkBits2Float(0xc2700000), SkBits2Float(0x3637fea5), SkBits2Float(0xc2700000));
1240path.close();
1241
1242 SkPath path1(path);
1243 path.reset();
1244 path.setFillType((SkPathFillType) 0);
1245path.moveTo(SkBits2Float(0x42767032), SkBits2Float(0xc25e77e8));
1246path.cubicTo(SkBits2Float(0x42aa697a), SkBits2Float(0xc1ebd370), SkBits2Float(0x42b37ad4), SkBits2Float(0x410b48c2), SkBits2Float(0x4291d766), SkBits2Float(0x421e927b));
1247path.lineTo(SkBits2Float(0x4252dae4), SkBits2Float(0x41e542d2));
1248path.cubicTo(SkBits2Float(0x4281be95), SkBits2Float(0x40c95ff9), SkBits2Float(0x427660fe), SkBits2Float(0xc1aa7a03), SkBits2Float(0x423225ed), SkBits2Float(0xc220d20e));
1249path.lineTo(SkBits2Float(0x42767032), SkBits2Float(0xc25e77e8));
1250path.close();
1251
1252 SkPath path2(path);
1253 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1254}

◆ battleOp45()

static void battleOp45 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1257 of file PathOpsBattles.cpp.

1257 {
1258 SkPath path;
1259 path.setFillType((SkPathFillType) 0);
1260path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1261path.cubicTo(SkBits2Float(0x41bfbd07), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423b0ef1), SkBits2Float(0xc2914772), SkBits2Float(0x427a1b1d), SkBits2Float(0xc25a5641));
1262path.lineTo(SkBits2Float(0x4234ccaa), SkBits2Float(0xc21dd57d));
1263path.cubicTo(SkBits2Float(0x42073912), SkBits2Float(0xc2520ac5), SkBits2Float(0x418a9b2a), SkBits2Float(0xc26fffff), SkBits2Float(0x3697ff52), SkBits2Float(0xc26fffff));
1264path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1265path.close();
1266
1267 SkPath path1(path);
1268 path.reset();
1269 path.setFillType((SkPathFillType) 0);
1270path.moveTo(SkBits2Float(0x427a1b1e), SkBits2Float(0xc25a5642));
1271path.cubicTo(SkBits2Float(0x4280286a), SkBits2Float(0xc253393c), SkBits2Float(0x42831c11), SkBits2Float(0xc24bd939), SkBits2Float(0x4285e673), SkBits2Float(0xc2443b5f));
1272path.lineTo(SkBits2Float(0x42419733), SkBits2Float(0xc20ddaba));
1273path.cubicTo(SkBits2Float(0x423d8e5d), SkBits2Float(0xc2135c44), SkBits2Float(0x423949dc), SkBits2Float(0xc218b118), SkBits2Float(0x4234ccac), SkBits2Float(0xc21dd57e));
1274path.lineTo(SkBits2Float(0x427a1b1e), SkBits2Float(0xc25a5642));
1275path.close();
1276
1277 SkPath path2(path);
1278 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1279}

◆ battleOp46()

static void battleOp46 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1282 of file PathOpsBattles.cpp.

1282 {
1283 SkPath path;
1284 path.setFillType((SkPathFillType) 1);
1285path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc26fffff));
1286path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1287path.cubicTo(SkBits2Float(0x41bfbd07), SkBits2Float(0xc2a5ffff), SkBits2Float(0x423b0ef1), SkBits2Float(0xc2914772), SkBits2Float(0x427a1b1e), SkBits2Float(0xc25a5642));
1288path.cubicTo(SkBits2Float(0x4280286a), SkBits2Float(0xc253393c), SkBits2Float(0x42831c11), SkBits2Float(0xc24bd939), SkBits2Float(0x4285e673), SkBits2Float(0xc2443b5f));
1289path.lineTo(SkBits2Float(0x42419733), SkBits2Float(0xc20ddaba));
1290path.cubicTo(SkBits2Float(0x423d8e5d), SkBits2Float(0xc2135c44), SkBits2Float(0x423949dc), SkBits2Float(0xc218b118), SkBits2Float(0x4234ccac), SkBits2Float(0xc21dd57e));
1291path.lineTo(SkBits2Float(0x4234ccaa), SkBits2Float(0xc21dd57d));
1292path.cubicTo(SkBits2Float(0x42073912), SkBits2Float(0xc2520ac5), SkBits2Float(0x418a9b2a), SkBits2Float(0xc26fffff), SkBits2Float(0x3697ff52), SkBits2Float(0xc26fffff));
1293path.close();
1294
1295 SkPath path1(path);
1296 path.reset();
1297 path.setFillType((SkPathFillType) 0);
1298path.moveTo(SkBits2Float(0x4285e672), SkBits2Float(0xc2443b5f));
1299path.cubicTo(SkBits2Float(0x42b50145), SkBits2Float(0xc1875361), SkBits2Float(0x42afc74e), SkBits2Float(0x41db6d5e), SkBits2Float(0x4272e616), SkBits2Float(0x426253de));
1300path.lineTo(SkBits2Float(0x422f96e8), SkBits2Float(0x42239c3e));
1301path.cubicTo(SkBits2Float(0x427e233c), SkBits2Float(0x419e9f42), SkBits2Float(0x4282d8d3), SkBits2Float(0xc143a6d1), SkBits2Float(0x42419734), SkBits2Float(0xc20ddabb));
1302path.lineTo(SkBits2Float(0x4285e672), SkBits2Float(0xc2443b5f));
1303path.close();
1304
1305 SkPath path2(path);
1306 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1307}

◆ battleOp47()

static void battleOp47 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1310 of file PathOpsBattles.cpp.

1310 {
1311 SkPath path;
1312 path.setFillType((SkPathFillType) 0);
1313path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1314path.cubicTo(SkBits2Float(0x41d59904), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424f13ae), SkBits2Float(0xc28c4fb7), SkBits2Float(0x4286bb70), SkBits2Float(0xc241f0ca));
1315path.lineTo(SkBits2Float(0x4242cb24), SkBits2Float(0xc20c32b1));
1316path.cubicTo(SkBits2Float(0x4215b1b4), SkBits2Float(0xc24adc20), SkBits2Float(0x419a6875), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
1317path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1318path.close();
1319
1320 SkPath path1(path);
1321 path.reset();
1322 path.setFillType((SkPathFillType) 0);
1323path.moveTo(SkBits2Float(0x4286bb71), SkBits2Float(0xc241f0ca));
1324path.cubicTo(SkBits2Float(0x4289cb2b), SkBits2Float(0xc2396eee), SkBits2Float(0x428ca6e5), SkBits2Float(0xc230a410), SkBits2Float(0x428f4c27), SkBits2Float(0xc22797c0));
1325path.lineTo(SkBits2Float(0x424f2d54), SkBits2Float(0xc1f24d85));
1326path.cubicTo(SkBits2Float(0x424b5a2a), SkBits2Float(0xc1ff6268), SkBits2Float(0x42473840), SkBits2Float(0xc2060c56), SkBits2Float(0x4242cb25), SkBits2Float(0xc20c32b2));
1327path.lineTo(SkBits2Float(0x4286bb71), SkBits2Float(0xc241f0ca));
1328path.close();
1329
1330 SkPath path2(path);
1331 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1332}

◆ battleOp48()

static void battleOp48 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1335 of file PathOpsBattles.cpp.

1335 {
1336 SkPath path;
1337 path.setFillType((SkPathFillType) 1);
1338path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1339path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1340path.cubicTo(SkBits2Float(0x41d59904), SkBits2Float(0xc2a5ffff), SkBits2Float(0x424f13ae), SkBits2Float(0xc28c4fb7), SkBits2Float(0x4286bb71), SkBits2Float(0xc241f0ca));
1341path.cubicTo(SkBits2Float(0x4289cb2b), SkBits2Float(0xc2396eee), SkBits2Float(0x428ca6e5), SkBits2Float(0xc230a410), SkBits2Float(0x428f4c27), SkBits2Float(0xc22797c0));
1342path.lineTo(SkBits2Float(0x424f2d54), SkBits2Float(0xc1f24d85));
1343path.cubicTo(SkBits2Float(0x424b5a2a), SkBits2Float(0xc1ff6268), SkBits2Float(0x42473840), SkBits2Float(0xc2060c56), SkBits2Float(0x4242cb24), SkBits2Float(0xc20c32b1));
1344path.cubicTo(SkBits2Float(0x4215b1b4), SkBits2Float(0xc24adc20), SkBits2Float(0x419a6875), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1345path.close();
1346
1347 SkPath path1(path);
1348 path.reset();
1349 path.setFillType((SkPathFillType) 0);
1350path.moveTo(SkBits2Float(0x428f4c27), SkBits2Float(0xc22797c0));
1351path.cubicTo(SkBits2Float(0x42bc6513), SkBits2Float(0xc055a915), SkBits2Float(0x42a45eb2), SkBits2Float(0x42389acf), SkBits2Float(0x4231df29), SkBits2Float(0x428c2a69));
1352path.lineTo(SkBits2Float(0x420094fc), SkBits2Float(0x424aa62f));
1353path.cubicTo(SkBits2Float(0x426da4ad), SkBits2Float(0x42057300), SkBits2Float(0x42883065), SkBits2Float(0xc01a7416), SkBits2Float(0x424f2d56), SkBits2Float(0xc1f24d87));
1354path.lineTo(SkBits2Float(0x428f4c27), SkBits2Float(0xc22797c0));
1355path.close();
1356
1357 SkPath path2(path);
1358 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1359}

◆ battleOp49()

static void battleOp49 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1362 of file PathOpsBattles.cpp.

1362 {
1363 SkPath path;
1364 path.setFillType((SkPathFillType) 0);
1365path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1366path.cubicTo(SkBits2Float(0x41eed329), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4265a038), SkBits2Float(0xc285ef96), SkBits2Float(0x42905111), SkBits2Float(0xc2240eac));
1367path.lineTo(SkBits2Float(0x4250a68d), SkBits2Float(0xc1ed30fa));
1368path.cubicTo(SkBits2Float(0x4225fe9e), SkBits2Float(0xc241a46c), SkBits2Float(0x41aca4fc), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
1369path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1370path.close();
1371
1372 SkPath path1(path);
1373 path.reset();
1374 path.setFillType((SkPathFillType) 0);
1375path.moveTo(SkBits2Float(0x42905111), SkBits2Float(0xc2240ead));
1376path.cubicTo(SkBits2Float(0x429332f8), SkBits2Float(0xc219ea36), SkBits2Float(0x4295cfef), SkBits2Float(0xc20f79c4), SkBits2Float(0x4298252c), SkBits2Float(0xc204c875));
1377path.lineTo(SkBits2Float(0x425bf80f), SkBits2Float(0xc1bff9b9));
1378path.cubicTo(SkBits2Float(0x42589896), SkBits2Float(0xc1cf6f48), SkBits2Float(0x4254d168), SkBits2Float(0xc1de8710), SkBits2Float(0x4250a68e), SkBits2Float(0xc1ed30fc));
1379path.lineTo(SkBits2Float(0x42905111), SkBits2Float(0xc2240ead));
1380path.close();
1381
1382 SkPath path2(path);
1383 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1384}

◆ battleOp5()

static void battleOp5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 199 of file PathOpsBattles.cpp.

199 {
200 SkPath path;
201 path.setFillType((SkPathFillType) 0);
202path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
203path.cubicTo(SkBits2Float(0x3fe06a9b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40606368), SkBits2Float(0xc2a5e38e), SkBits2Float(0x40a82f8a), SkBits2Float(0xc2a5aab6));
204path.lineTo(SkBits2Float(0x40732902), SkBits2Float(0xc26f84b2));
205path.cubicTo(SkBits2Float(0x4022355b), SkBits2Float(0xc26fd6e1), SkBits2Float(0x3fa23a8f), SkBits2Float(0xc2700000), SkBits2Float(0xb5600574), SkBits2Float(0xc2700000));
206path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
207path.close();
208
209 SkPath path1(path);
210 path.reset();
211 path.setFillType((SkPathFillType) 0);
212path.moveTo(SkBits2Float(0x40a82f91), SkBits2Float(0xc2a5aab7));
213path.cubicTo(SkBits2Float(0x40adc8dc), SkBits2Float(0xc2a5a508), SkBits2Float(0x40b361d8), SkBits2Float(0xc2a59f10), SkBits2Float(0x40b8fa82), SkBits2Float(0xc2a598d0));
214path.lineTo(SkBits2Float(0x4085b825), SkBits2Float(0xc26f6ad0));
215path.cubicTo(SkBits2Float(0x4081ac7b), SkBits2Float(0xc26f73dc), SkBits2Float(0x407b412c), SkBits2Float(0xc26f7c7c), SkBits2Float(0x407328f8), SkBits2Float(0xc26f84b3));
216path.lineTo(SkBits2Float(0x40a82f91), SkBits2Float(0xc2a5aab7));
217path.close();
218
219 SkPath path2(path);
220 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
221}

◆ battleOp50()

static void battleOp50 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1387 of file PathOpsBattles.cpp.

1387 {
1388 SkPath path;
1389 path.setFillType((SkPathFillType) 1);
1390path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1391path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1392path.cubicTo(SkBits2Float(0x41eed328), SkBits2Float(0xc2a60000), SkBits2Float(0x4265a038), SkBits2Float(0xc285ef96), SkBits2Float(0x42905111), SkBits2Float(0xc2240ead));
1393path.lineTo(SkBits2Float(0x42905111), SkBits2Float(0xc2240eac));
1394path.cubicTo(SkBits2Float(0x429332f8), SkBits2Float(0xc219ea35), SkBits2Float(0x4295cfef), SkBits2Float(0xc20f79c4), SkBits2Float(0x4298252c), SkBits2Float(0xc204c875));
1395path.lineTo(SkBits2Float(0x425bf80f), SkBits2Float(0xc1bff9b9));
1396path.cubicTo(SkBits2Float(0x42589896), SkBits2Float(0xc1cf6f48), SkBits2Float(0x4254d168), SkBits2Float(0xc1de8710), SkBits2Float(0x4250a68d), SkBits2Float(0xc1ed30fa));
1397path.cubicTo(SkBits2Float(0x4225fe9e), SkBits2Float(0xc241a46c), SkBits2Float(0x41aca4fc), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1398path.close();
1399
1400 SkPath path1(path);
1401 path.reset();
1402 path.setFillType((SkPathFillType) 0);
1403path.moveTo(SkBits2Float(0x4298252d), SkBits2Float(0xc204c875));
1404path.cubicTo(SkBits2Float(0x42ab560c), SkBits2Float(0xc1334da0), SkBits2Float(0x42aa8ee6), SkBits2Float(0x415dbf57), SkBits2Float(0x4296030d), SkBits2Float(0x420e292a));
1405path.cubicTo(SkBits2Float(0x42817734), SkBits2Float(0x4264e27f), SkBits2Float(0x42365290), SkBits2Float(0x4292cae0), SkBits2Float(0x41b3e39e), SkBits2Float(0x429fcac3));
1406path.lineTo(SkBits2Float(0x41820a52), SkBits2Float(0x4267064e));
1407path.cubicTo(SkBits2Float(0x4203cca7), SkBits2Float(0x42543ae9), SkBits2Float(0x423b2de4), SkBits2Float(0x42257578), SkBits2Float(0x4258e27d), SkBits2Float(0x41cd88a1));
1408path.cubicTo(SkBits2Float(0x42769717), SkBits2Float(0x41204ca2), SkBits2Float(0x4277b705), SkBits2Float(0xc1019de9), SkBits2Float(0x425bf810), SkBits2Float(0xc1bff9bb));
1409path.lineTo(SkBits2Float(0x4298252d), SkBits2Float(0xc204c875));
1410path.close();
1411
1412 SkPath path2(path);
1413 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1414}

◆ battleOp51()

static void battleOp51 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1417 of file PathOpsBattles.cpp.

1417 {
1418 SkPath path;
1419 path.setFillType((SkPathFillType) 0);
1420path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1421path.cubicTo(SkBits2Float(0x42044d64), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427bf9ef), SkBits2Float(0xc27d72ab), SkBits2Float(0x42984d42), SkBits2Float(0xc2041029));
1422path.lineTo(SkBits2Float(0x425c3202), SkBits2Float(0xc1beef44));
1423path.cubicTo(SkBits2Float(0x423626cb), SkBits2Float(0xc2373722), SkBits2Float(0x41bf47cb), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
1424path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1425path.close();
1426
1427 SkPath path1(path);
1428 path.reset();
1429 path.setFillType((SkPathFillType) 0);
1430path.moveTo(SkBits2Float(0x42984d42), SkBits2Float(0xc2041029));
1431path.cubicTo(SkBits2Float(0x429adc06), SkBits2Float(0xc1f08771), SkBits2Float(0x429d127e), SkBits2Float(0xc1d85b80), SkBits2Float(0x429eedcc), SkBits2Float(0xc1bfbbc5));
1432path.lineTo(SkBits2Float(0x4265c6d6), SkBits2Float(0xc18a9a3f));
1433path.cubicTo(SkBits2Float(0x426317a7), SkBits2Float(0xc19c6729), SkBits2Float(0x425fe4aa), SkBits2Float(0xc1ade05f), SkBits2Float(0x425c3203), SkBits2Float(0xc1beef45));
1434path.lineTo(SkBits2Float(0x42984d42), SkBits2Float(0xc2041029));
1435path.close();
1436
1437 SkPath path2(path);
1438 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1439}

◆ battleOp5193()

static void battleOp5193 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10560 of file PathOpsBattles.cpp.

10560 {
10561 SkPath path;
10562 path.setFillType((SkPathFillType) 0);
10563path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10564path.cubicTo(SkBits2Float(0x3e0b17ea), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e8b17df), SkBits2Float(0xc2a5ffd4), SkBits2Float(0x3ed0a399), SkBits2Float(0xc2a5ff7c));
10565path.lineTo(SkBits2Float(0x3e96d285), SkBits2Float(0xc26fff42));
10566path.cubicTo(SkBits2Float(0x3e491945), SkBits2Float(0xc26fffc2), SkBits2Float(0x3dc91958), SkBits2Float(0xc2700000), SkBits2Float(0x340ae940), SkBits2Float(0xc2700000));
10567path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10568path.close();
10569
10570 SkPath path1(path);
10571 path.reset();
10572 path.setFillType((SkPathFillType) 0);
10573path.moveTo(SkBits2Float(0x3ed0a338), SkBits2Float(0xc2a5ff7d));
10574path.cubicTo(SkBits2Float(0x3ed797a0), SkBits2Float(0xc2a5ff73), SkBits2Float(0x3ede8c36), SkBits2Float(0xc2a5ff6a), SkBits2Float(0x3ee580cb), SkBits2Float(0xc2a5ff60));
10575path.lineTo(SkBits2Float(0x3ea5e78a), SkBits2Float(0xc26fff1b));
10576path.cubicTo(SkBits2Float(0x3ea0e0aa), SkBits2Float(0xc26fff29), SkBits2Float(0x3e9bd97e), SkBits2Float(0xc26fff36), SkBits2Float(0x3e96d252), SkBits2Float(0xc26fff43));
10577path.lineTo(SkBits2Float(0x3ed0a338), SkBits2Float(0xc2a5ff7d));
10578path.close();
10579
10580 SkPath path2(path);
10581 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10582}

◆ battleOp5194()

static void battleOp5194 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10585 of file PathOpsBattles.cpp.

10585 {
10586 SkPath path;
10587 path.setFillType((SkPathFillType) 1);
10588path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10589path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10590path.cubicTo(SkBits2Float(0x3e0b17a8), SkBits2Float(0xc2a60000), SkBits2Float(0x3e8b179e), SkBits2Float(0xc2a5ffd4), SkBits2Float(0x3ed0a337), SkBits2Float(0xc2a5ff7c));
10591path.lineTo(SkBits2Float(0x3ed0a338), SkBits2Float(0xc2a5ff7d));
10592path.cubicTo(SkBits2Float(0x3ed797a0), SkBits2Float(0xc2a5ff73), SkBits2Float(0x3ede8c36), SkBits2Float(0xc2a5ff6a), SkBits2Float(0x3ee580cb), SkBits2Float(0xc2a5ff60));
10593path.lineTo(SkBits2Float(0x3ea5e78a), SkBits2Float(0xc26fff1b));
10594path.cubicTo(SkBits2Float(0x3ea0e0bb), SkBits2Float(0xc26fff29), SkBits2Float(0x3e9bd9a1), SkBits2Float(0xc26fff36), SkBits2Float(0x3e96d286), SkBits2Float(0xc26fff43));
10595path.lineTo(SkBits2Float(0x3e96d285), SkBits2Float(0xc26fff42));
10596path.cubicTo(SkBits2Float(0x3e491945), SkBits2Float(0xc26fffc2), SkBits2Float(0x3dc91958), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
10597path.close();
10598
10599 SkPath path1(path);
10600 path.reset();
10601 path.setFillType((SkPathFillType) 0);
10602path.moveTo(SkBits2Float(0x3ee58048), SkBits2Float(0xc2a5ff61));
10603path.cubicTo(SkBits2Float(0x3f2b1987), SkBits2Float(0xc2a5fec4), SkBits2Float(0x3f637253), SkBits2Float(0xc2a5fdb6), SkBits2Float(0x3f8de535), SkBits2Float(0xc2a5fc35));
10604path.lineTo(SkBits2Float(0x3f4d269a), SkBits2Float(0xc26ffa85));
10605path.cubicTo(SkBits2Float(0x3f246b51), SkBits2Float(0xc26ffcb3), SkBits2Float(0x3ef75f30), SkBits2Float(0xc26ffe3a), SkBits2Float(0x3ea5e737), SkBits2Float(0xc26fff1c));
10606path.lineTo(SkBits2Float(0x3ee58048), SkBits2Float(0xc2a5ff61));
10607path.close();
10608
10609 SkPath path2(path);
10610 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10611}

◆ battleOp52()

static void battleOp52 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1442 of file PathOpsBattles.cpp.

1442 {
1443 SkPath path;
1444 path.setFillType((SkPathFillType) 1);
1445path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1446path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1447path.cubicTo(SkBits2Float(0x42044d64), SkBits2Float(0xc2a5ffff), SkBits2Float(0x427bf9ef), SkBits2Float(0xc27d72ab), SkBits2Float(0x42984d42), SkBits2Float(0xc2041029));
1448path.cubicTo(SkBits2Float(0x429adc06), SkBits2Float(0xc1f08771), SkBits2Float(0x429d127e), SkBits2Float(0xc1d85b80), SkBits2Float(0x429eedcc), SkBits2Float(0xc1bfbbc5));
1449path.lineTo(SkBits2Float(0x4265c6d6), SkBits2Float(0xc18a9a3f));
1450path.cubicTo(SkBits2Float(0x426317a7), SkBits2Float(0xc19c6729), SkBits2Float(0x425fe4aa), SkBits2Float(0xc1ade05f), SkBits2Float(0x425c3202), SkBits2Float(0xc1beef44));
1451path.cubicTo(SkBits2Float(0x423626cb), SkBits2Float(0xc2373722), SkBits2Float(0x41bf47cb), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1452path.close();
1453
1454 SkPath path1(path);
1455 path.reset();
1456 path.setFillType((SkPathFillType) 0);
1457path.moveTo(SkBits2Float(0x429eedcc), SkBits2Float(0xc1bfbbc6));
1458path.cubicTo(SkBits2Float(0x42ae408c), SkBits2Float(0x3fb7daeb), SkBits2Float(0x42a45c89), SkBits2Float(0x41e7c57e), SkBits2Float(0x42845101), SkBits2Float(0x42487bac));
1459path.cubicTo(SkBits2Float(0x42488af1), SkBits2Float(0x428e8a4c), SkBits2Float(0x41c7bd0e), SkBits2Float(0x42a6f806), SkBits2Float(0xbfc7d871), SkBits2Float(0x42a5f87b));
1460path.lineTo(SkBits2Float(0xbf90777c), SkBits2Float(0x426ff521));
1461path.cubicTo(SkBits2Float(0x419063a9), SkBits2Float(0x42716698), SkBits2Float(0x4210f87e), SkBits2Float(0x424e1511), SkBits2Float(0x423f4d05), SkBits2Float(0x4210ed75));
1462path.cubicTo(SkBits2Float(0x426da18c), SkBits2Float(0x41a78bb1), SkBits2Float(0x427bee4d), SkBits2Float(0x3f84e856), SkBits2Float(0x4265c6d8), SkBits2Float(0xc18a9a40));
1463path.lineTo(SkBits2Float(0x429eedcc), SkBits2Float(0xc1bfbbc6));
1464path.close();
1465
1466 SkPath path2(path);
1467 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1468}

◆ battleOp53()

static void battleOp53 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1471 of file PathOpsBattles.cpp.

1471 {
1472 SkPath path;
1473 path.setFillType((SkPathFillType) 0);
1474path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1475path.cubicTo(SkBits2Float(0x421216db), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4289817d), SkBits2Float(0xc26c814f), SkBits2Float(0x429ecb3a), SkBits2Float(0xc1c183ed));
1476path.lineTo(SkBits2Float(0x426594dc), SkBits2Float(0xc18be3fc));
1477path.cubicTo(SkBits2Float(0x4246cdba), SkBits2Float(0xc22af7b1), SkBits2Float(0x41d336a3), SkBits2Float(0xc2700000), SkBits2Float(0x357ffa94), SkBits2Float(0xc2700000));
1478path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1479path.close();
1480
1481 SkPath path1(path);
1482 path.reset();
1483 path.setFillType((SkPathFillType) 0);
1484path.moveTo(SkBits2Float(0x429ecb3a), SkBits2Float(0xc1c183e9));
1485path.cubicTo(SkBits2Float(0x42a0d9cb), SkBits2Float(0xc1a68281), SkBits2Float(0x42a27999), SkBits2Float(0xc18b01ce), SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595d));
1486path.lineTo(SkBits2Float(0x426c9cb2), SkBits2Float(0xc120bbfa));
1487path.cubicTo(SkBits2Float(0x426ae754), SkBits2Float(0xc148f95c), SkBits2Float(0x42688e2a), SkBits2Float(0xc170bcb0), SkBits2Float(0x426594dd), SkBits2Float(0xc18be3fd));
1488path.lineTo(SkBits2Float(0x429ecb3a), SkBits2Float(0xc1c183e9));
1489path.close();
1490
1491 SkPath path2(path);
1492 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1493}

◆ battleOp54()

static void battleOp54 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1496 of file PathOpsBattles.cpp.

1496 {
1497 SkPath path;
1498 path.setFillType((SkPathFillType) 1);
1499path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1500path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1501path.cubicTo(SkBits2Float(0x421216db), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4289817d), SkBits2Float(0xc26c814f), SkBits2Float(0x429ecb3a), SkBits2Float(0xc1c183ed));
1502path.lineTo(SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595d));
1503path.lineTo(SkBits2Float(0x426c9cb2), SkBits2Float(0xc120bbfa));
1504path.cubicTo(SkBits2Float(0x426ae754), SkBits2Float(0xc148f95c), SkBits2Float(0x42688e2a), SkBits2Float(0xc170bcb0), SkBits2Float(0x426594dd), SkBits2Float(0xc18be3fd));
1505path.lineTo(SkBits2Float(0x426594dc), SkBits2Float(0xc18be3fc));
1506path.cubicTo(SkBits2Float(0x4246cdba), SkBits2Float(0xc22af7b1), SkBits2Float(0x41d336a3), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1507path.close();
1508
1509 SkPath path1(path);
1510 path.reset();
1511 path.setFillType((SkPathFillType) 0);
1512path.moveTo(SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595e));
1513path.cubicTo(SkBits2Float(0x42ad725e), SkBits2Float(0x416ed313), SkBits2Float(0x42982fa2), SkBits2Float(0x4230cc44), SkBits2Float(0x42575fca), SkBits2Float(0x427ca963));
1514path.cubicTo(SkBits2Float(0x41fcc0a1), SkBits2Float(0x42a44341), SkBits2Float(0x3f80ed4e), SkBits2Float(0x42affc4e), SkBits2Float(0xc1d56b7f), SkBits2Float(0x429d3115));
1515path.lineTo(SkBits2Float(0xc19a478e), SkBits2Float(0x426343e2));
1516path.cubicTo(SkBits2Float(0x3f3a6666), SkBits2Float(0x427e6fe0), SkBits2Float(0x41b6b66f), SkBits2Float(0x426d7d04), SkBits2Float(0x421bb135), SkBits2Float(0x4236a5a5));
1517path.cubicTo(SkBits2Float(0x425c0733), SkBits2Float(0x41ff9c8c), SkBits2Float(0x427ac435), SkBits2Float(0x412ca4f2), SkBits2Float(0x426c9cb3), SkBits2Float(0xc120bbf8));
1518path.lineTo(SkBits2Float(0x42a3a81d), SkBits2Float(0xc15e595e));
1519path.close();
1520
1521 SkPath path2(path);
1522 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1523}

◆ battleOp55()

static void battleOp55 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1526 of file PathOpsBattles.cpp.

1526 {
1527 SkPath path;
1528 path.setFillType((SkPathFillType) 0);
1529path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1530path.cubicTo(SkBits2Float(0x4220aa02), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42952310), SkBits2Float(0xc258f48d), SkBits2Float(0x42a35f68), SkBits2Float(0xc16b5614));
1531path.lineTo(SkBits2Float(0x426c3395), SkBits2Float(0xc12a1f61));
1532path.cubicTo(SkBits2Float(0x42579ea8), SkBits2Float(0xc21cd5ce), SkBits2Float(0x41e84916), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
1533path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1534path.close();
1535
1536 SkPath path1(path);
1537 path.reset();
1538 path.setFillType((SkPathFillType) 0);
1539path.moveTo(SkBits2Float(0x42a35f69), SkBits2Float(0xc16b5613));
1540path.cubicTo(SkBits2Float(0x42a4bd24), SkBits2Float(0xc12ea3c2), SkBits2Float(0x42a59325), SkBits2Float(0xc0e282d6), SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
1541path.lineTo(SkBits2Float(0x426fd18d), SkBits2Float(0xc0154a48));
1542path.cubicTo(SkBits2Float(0x426f62a1), SkBits2Float(0xc0a3be33), SkBits2Float(0x426e2d39), SkBits2Float(0xc0fc7dbb), SkBits2Float(0x426c3397), SkBits2Float(0xc12a1f63));
1543path.lineTo(SkBits2Float(0x42a35f69), SkBits2Float(0xc16b5613));
1544path.close();
1545
1546 SkPath path2(path);
1547 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1548}

◆ battleOp56()

static void battleOp56 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1551 of file PathOpsBattles.cpp.

1551 {
1552 SkPath path;
1553 path.setFillType((SkPathFillType) 1);
1554path.moveTo(SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
1555path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1556path.cubicTo(SkBits2Float(0x4220aa02), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42952310), SkBits2Float(0xc258f48d), SkBits2Float(0x42a35f69), SkBits2Float(0xc16b5613));
1557path.cubicTo(SkBits2Float(0x42a4bd24), SkBits2Float(0xc12ea3c2), SkBits2Float(0x42a59325), SkBits2Float(0xc0e282d6), SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
1558path.lineTo(SkBits2Float(0x426fd18d), SkBits2Float(0xc0154a48));
1559path.cubicTo(SkBits2Float(0x426f62a1), SkBits2Float(0xc0a3be33), SkBits2Float(0x426e2d39), SkBits2Float(0xc0fc7dbb), SkBits2Float(0x426c3397), SkBits2Float(0xc12a1f63));
1560path.lineTo(SkBits2Float(0x426c3395), SkBits2Float(0xc12a1f61));
1561path.cubicTo(SkBits2Float(0x42579ea8), SkBits2Float(0xc21cd5ce), SkBits2Float(0x41e84916), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
1562path.close();
1563
1564 SkPath path1(path);
1565 path.reset();
1566 path.setFillType((SkPathFillType) 0);
1567path.moveTo(SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
1568path.cubicTo(SkBits2Float(0x42a85e4f), SkBits2Float(0x41e6959e), SkBits2Float(0x4285b4e3), SkBits2Float(0x426ae44f), SkBits2Float(0x4219b105), SkBits2Float(0x42932450));
1569path.cubicTo(SkBits2Float(0x411fe111), SkBits2Float(0x42b0d679), SkBits2Float(0xc1c3966b), SkBits2Float(0x42ab1d42), SkBits2Float(0xc2482755), SkBits2Float(0x428470e8));
1570path.lineTo(SkBits2Float(0xc210b07c), SkBits2Float(0x423f7b24));
1571path.cubicTo(SkBits2Float(0xc18d6382), SkBits2Float(0x427764e8), SkBits2Float(0x40e72680), SkBits2Float(0x427fab4e), SkBits2Float(0x41de345e), SkBits2Float(0x4254bc3b));
1572path.cubicTo(SkBits2Float(0x42414f8e), SkBits2Float(0x4229cd28), SkBits2Float(0x42736c9d), SkBits2Float(0x41a6b008), SkBits2Float(0x426fd18e), SkBits2Float(0xc0154a3f));
1573path.lineTo(SkBits2Float(0x42a5dfdf), SkBits2Float(0xc04e84a0));
1574path.close();
1575
1576 SkPath path2(path);
1577 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1578}

◆ battleOp57()

static void battleOp57 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1581 of file PathOpsBattles.cpp.

1581 {
1582 SkPath path;
1583 path.setFillType((SkPathFillType) 0);
1584path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1585path.cubicTo(SkBits2Float(0x422b8e0b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x429d6dbc), SkBits2Float(0xc2494bad), SkBits2Float(0x42a54cb6), SkBits2Float(0xc0f3b760));
1586path.lineTo(SkBits2Float(0x426efcca), SkBits2Float(0xc0b02e2c));
1587path.cubicTo(SkBits2Float(0x42639b94), SkBits2Float(0xc21183d2), SkBits2Float(0x41f807f9), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
1588path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1589path.close();
1590
1591 SkPath path1(path);
1592 path.reset();
1593 path.setFillType((SkPathFillType) 0);
1594path.moveTo(SkBits2Float(0x42a54cb7), SkBits2Float(0xc0f3b757));
1595path.cubicTo(SkBits2Float(0x42a60d08), SkBits2Float(0xc0628d9e), SkBits2Float(0x42a632b1), SkBits2Float(0x3f0efcd8), SkBits2Float(0x42a5bd61), SkBits2Float(0x4094a90a));
1596path.lineTo(SkBits2Float(0x426f9faf), SkBits2Float(0x4056ee3d));
1597path.cubicTo(SkBits2Float(0x42704949), SkBits2Float(0x3ecebaba), SkBits2Float(0x427012d8), SkBits2Float(0xc023c5fe), SkBits2Float(0x426efccb), SkBits2Float(0xc0b02e2d));
1598path.lineTo(SkBits2Float(0x42a54cb7), SkBits2Float(0xc0f3b757));
1599path.close();
1600
1601 SkPath path2(path);
1602 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1603}

◆ battleOp58()

static void battleOp58 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1606 of file PathOpsBattles.cpp.

1606 {
1607 SkPath path;
1608 path.setFillType((SkPathFillType) 1);
1609path.moveTo(SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
1610path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1611path.cubicTo(SkBits2Float(0x422b8e0b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x429d6dbc), SkBits2Float(0xc2494bad), SkBits2Float(0x42a54cb7), SkBits2Float(0xc0f3b757));
1612path.cubicTo(SkBits2Float(0x42a60d08), SkBits2Float(0xc0628d9e), SkBits2Float(0x42a632b1), SkBits2Float(0x3f0efcd8), SkBits2Float(0x42a5bd61), SkBits2Float(0x4094a90a));
1613path.lineTo(SkBits2Float(0x426f9faf), SkBits2Float(0x4056ee3d));
1614path.cubicTo(SkBits2Float(0x42704949), SkBits2Float(0x3ecebaba), SkBits2Float(0x427012d8), SkBits2Float(0xc023c5fe), SkBits2Float(0x426efcca), SkBits2Float(0xc0b02e2c));
1615path.cubicTo(SkBits2Float(0x42639b94), SkBits2Float(0xc21183d2), SkBits2Float(0x41f807f9), SkBits2Float(0xc2700000), SkBits2Float(0xb630015b), SkBits2Float(0xc2700000));
1616path.close();
1617
1618 SkPath path1(path);
1619 path.reset();
1620 path.setFillType((SkPathFillType) 0);
1621path.moveTo(SkBits2Float(0x42a5bd62), SkBits2Float(0x4094a90c));
1622path.cubicTo(SkBits2Float(0x42a1e9d4), SkBits2Float(0x421b17cd), SkBits2Float(0x426944f3), SkBits2Float(0x428879ea), SkBits2Float(0x41ceac14), SkBits2Float(0x429dc116));
1623path.cubicTo(SkBits2Float(0xc0d4c6f5), SkBits2Float(0x42b30843), SkBits2Float(0xc2295516), SkBits2Float(0x429e4e8b), SkBits2Float(0xc2802142), SkBits2Float(0x4253148e));
1624path.lineTo(SkBits2Float(0xc2393f81), SkBits2Float(0x42189693));
1625path.cubicTo(SkBits2Float(0xc1f4d162), SkBits2Float(0x4264e09b), SkBits2Float(0xc099d099), SkBits2Float(0x42816bc3), SkBits2Float(0x419566d0), SkBits2Float(0x42641418));
1626path.cubicTo(SkBits2Float(0x4228a0e3), SkBits2Float(0x424550a9), SkBits2Float(0x426a177b), SkBits2Float(0x41e03b19), SkBits2Float(0x426f9fb0), SkBits2Float(0x4056ee3a));
1627path.lineTo(SkBits2Float(0x42a5bd62), SkBits2Float(0x4094a90c));
1628path.close();
1629
1630 SkPath path2(path);
1631 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1632}

◆ battleOp59()

static void battleOp59 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1635 of file PathOpsBattles.cpp.

1635 { // hung
1636 SkPath path;
1637 path.setFillType((SkPathFillType) 0);
1638path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1639path.cubicTo(SkBits2Float(0x423693bc), SkBits2Float(0xc2a5ffff), SkBits2Float(0x42a57249), SkBits2Float(0xc2389374), SkBits2Float(0x42a5ff3a), SkBits2Float(0xbf002494));
1640path.lineTo(SkBits2Float(0x426ffee2), SkBits2Float(0xbeb944c3));
1641path.cubicTo(SkBits2Float(0x426f331d), SkBits2Float(0xc2056daf), SkBits2Float(0x4203fbc4), SkBits2Float(0xc2700000), SkBits2Float(0xb560056c), SkBits2Float(0xc2700000));
1642path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1643path.close();
1644
1645 SkPath path1(path);
1646 path.reset();
1647 path.setFillType((SkPathFillType) 0);
1648path.moveTo(SkBits2Float(0x42a5ff3a), SkBits2Float(0xbf0024e6));
1649path.cubicTo(SkBits2Float(0x42a60c9b), SkBits2Float(0x40752b0d), SkBits2Float(0x42a56c5d), SkBits2Float(0x410284fd), SkBits2Float(0x42a41ffb), SkBits2Float(0x414709fb));
1650path.lineTo(SkBits2Float(0x426d49ff), SkBits2Float(0x410fe233));
1651path.cubicTo(SkBits2Float(0x426f2a8e), SkBits2Float(0x40bcb3f0), SkBits2Float(0x42701239), SkBits2Float(0x40313ae3), SkBits2Float(0x426ffee3), SkBits2Float(0xbeb944c6));
1652path.lineTo(SkBits2Float(0x42a5ff3a), SkBits2Float(0xbf0024e6));
1653path.close();
1654
1655 SkPath path2(path);
1656 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1657}

◆ battleOp6()

static void battleOp6 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 224 of file PathOpsBattles.cpp.

224 {
225 SkPath path;
226 path.setFillType((SkPathFillType) 1);
227path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
228path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
229path.cubicTo(SkBits2Float(0x3fe06a9b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40606368), SkBits2Float(0xc2a5e38e), SkBits2Float(0x40a82f91), SkBits2Float(0xc2a5aab7));
230path.cubicTo(SkBits2Float(0x40adc8dc), SkBits2Float(0xc2a5a508), SkBits2Float(0x40b361d8), SkBits2Float(0xc2a59f10), SkBits2Float(0x40b8fa82), SkBits2Float(0xc2a598d0));
231path.lineTo(SkBits2Float(0x4085b825), SkBits2Float(0xc26f6ad0));
232path.cubicTo(SkBits2Float(0x4081ac7d), SkBits2Float(0xc26f73dc), SkBits2Float(0x407b4133), SkBits2Float(0xc26f7c7c), SkBits2Float(0x40732902), SkBits2Float(0xc26f84b2));
233path.cubicTo(SkBits2Float(0x4022355b), SkBits2Float(0xc26fd6e1), SkBits2Float(0x3fa23a8f), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
234path.close();
235path.moveTo(SkBits2Float(0x408fea52), SkBits2Float(0xc28dc28a));
236path.lineTo(SkBits2Float(0x407328f8), SkBits2Float(0xc26f84b3));
237path.lineTo(SkBits2Float(0x40732903), SkBits2Float(0xc26f84b3));
238path.lineTo(SkBits2Float(0x408fea52), SkBits2Float(0xc28dc28a));
239path.close();
240
241 SkPath path1(path);
242 path.reset();
243 path.setFillType((SkPathFillType) 0);
244path.moveTo(SkBits2Float(0x40b8fa77), SkBits2Float(0xc2a598d0));
245path.cubicTo(SkBits2Float(0x4109d7e9), SkBits2Float(0xc2a5337c), SkBits2Float(0x4137014a), SkBits2Float(0xc2a483b2), SkBits2Float(0x4163cbb6), SkBits2Float(0xc2a38a24));
246path.lineTo(SkBits2Float(0x4124abf0), SkBits2Float(0xc26c715c));
247path.cubicTo(SkBits2Float(0x41044af8), SkBits2Float(0xc26dda2b), SkBits2Float(0x40c74ab0), SkBits2Float(0xc26ed852), SkBits2Float(0x4085b82e), SkBits2Float(0xc26f6ad1));
248path.lineTo(SkBits2Float(0x40b8fa77), SkBits2Float(0xc2a598d0));
249path.close();
250
251 SkPath path2(path);
252 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
253}

◆ battleOp60()

static void battleOp60 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1659 of file PathOpsBattles.cpp.

1659 {
1660 SkPath path;
1661 path.setFillType((SkPathFillType) 0);
1662path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1663path.cubicTo(SkBits2Float(0x3e9334c2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f13342a), SkBits2Float(0xc2a5ff3c), SkBits2Float(0x3f5ccd0d), SkBits2Float(0xc2a5fdb4));
1664path.lineTo(SkBits2Float(0x3f1f9d85), SkBits2Float(0xc26ffcaf));
1665path.cubicTo(SkBits2Float(0x3ed4d324), SkBits2Float(0xc26ffee7), SkBits2Float(0x3e54d404), SkBits2Float(0xc2700000), SkBits2Float(0x36b23f68), SkBits2Float(0xc2700000));
1666path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1667path.close();
1668
1669 SkPath path1(path);
1670 path.reset();
1671 path.setFillType((SkPathFillType) 0);
1672path.moveTo(SkBits2Float(0x3f5ccd1a), SkBits2Float(0xc2a5fdb5));
1673path.cubicTo(SkBits2Float(0x3f642956), SkBits2Float(0xc2a5fd8c), SkBits2Float(0x3f6b855d), SkBits2Float(0xc2a5fd63), SkBits2Float(0x3f72e163), SkBits2Float(0xc2a5fd38));
1674path.lineTo(SkBits2Float(0x3f2f9381), SkBits2Float(0xc26ffbfc));
1675path.cubicTo(SkBits2Float(0x3f2a4188), SkBits2Float(0xc26ffc3b), SkBits2Float(0x3f24ef95), SkBits2Float(0xc26ffc76), SkBits2Float(0x3f1f9da0), SkBits2Float(0xc26ffcb0));
1676path.lineTo(SkBits2Float(0x3f5ccd1a), SkBits2Float(0xc2a5fdb5));
1677path.close();
1678
1679 SkPath path2(path);
1680 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1681}

◆ battleOp6000()

static void battleOp6000 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10641 of file PathOpsBattles.cpp.

10641 {
10642 SkPath path;
10643 path.setFillType((SkPathFillType) 0);
10644path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10645path.cubicTo(SkBits2Float(0x3c9b2383), SkBits2Float(0xc2a60000), SkBits2Float(0x3d1b200b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d68ae54), SkBits2Float(0xc2a5fffd));
10646path.lineTo(SkBits2Float(0x3d283599), SkBits2Float(0xc26ffffc));
10647path.cubicTo(SkBits2Float(0x3ce049ca), SkBits2Float(0xc26ffffe), SkBits2Float(0x3c604794), SkBits2Float(0xc26fffff), SkBits2Float(0xb58d9000), SkBits2Float(0xc26fffff));
10648path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
10649path.close();
10650
10651 SkPath path1(path);
10652 path.reset();
10653 path.setFillType((SkPathFillType) 0);
10654path.moveTo(SkBits2Float(0x3d68b08b), SkBits2Float(0xc2a5fffd));
10655path.cubicTo(SkBits2Float(0x3d707589), SkBits2Float(0xc2a5fffd), SkBits2Float(0x3d783329), SkBits2Float(0xc2a5fffd), SkBits2Float(0x3d7ff0c9), SkBits2Float(0xc2a5fffd));
10656path.lineTo(SkBits2Float(0x3d3907c2), SkBits2Float(0xc26ffffc));
10657path.cubicTo(SkBits2Float(0x3d336bee), SkBits2Float(0xc26ffffd), SkBits2Float(0x3d2dd36e), SkBits2Float(0xc26ffffd), SkBits2Float(0x3d283aee), SkBits2Float(0xc26ffffd));
10658path.lineTo(SkBits2Float(0x3d68b08b), SkBits2Float(0xc2a5fffd));
10659path.close();
10660
10661 SkPath path2(path);
10662 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10663}

◆ battleOp6001()

static void battleOp6001 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10665 of file PathOpsBattles.cpp.

10665 {
10666 SkPath path;
10667 path.setFillType((SkPathFillType) 1);
10668path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
10669path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
10670path.cubicTo(SkBits2Float(0x3c9b2383), SkBits2Float(0xc2a60000), SkBits2Float(0x3d1b200b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3d68ae54), SkBits2Float(0xc2a5fffd));
10671path.lineTo(SkBits2Float(0x3d7ff0c9), SkBits2Float(0xc2a5fffd));
10672path.lineTo(SkBits2Float(0x3d3907c2), SkBits2Float(0xc26ffffc));
10673path.cubicTo(SkBits2Float(0x3d336bee), SkBits2Float(0xc26ffffd), SkBits2Float(0x3d2dd36e), SkBits2Float(0xc26ffffd), SkBits2Float(0x3d283aee), SkBits2Float(0xc26ffffd));
10674path.lineTo(SkBits2Float(0x3d283599), SkBits2Float(0xc26ffffc));
10675path.cubicTo(SkBits2Float(0x3ce049ca), SkBits2Float(0xc26ffffe), SkBits2Float(0x3c604794), SkBits2Float(0xc26fffff), SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
10676path.close();
10677
10678 SkPath path1(path);
10679 path.reset();
10680 path.setFillType((SkPathFillType) 0);
10681path.moveTo(SkBits2Float(0x3d7ff566), SkBits2Float(0xc2a5fffd));
10682path.cubicTo(SkBits2Float(0x3dbed1a5), SkBits2Float(0xc2a5fffa), SkBits2Float(0x3dfda9cc), SkBits2Float(0xc2a5fff4), SkBits2Float(0x3e1e40f8), SkBits2Float(0xc2a5ffed));
10683path.lineTo(SkBits2Float(0x3de4ce81), SkBits2Float(0xc26fffe5));
10684path.cubicTo(SkBits2Float(0x3db75eff), SkBits2Float(0xc26ffff0), SkBits2Float(0x3d89f101), SkBits2Float(0xc26ffff8), SkBits2Float(0x3d390604), SkBits2Float(0xc26ffffc));
10685path.lineTo(SkBits2Float(0x3d7ff566), SkBits2Float(0xc2a5fffd));
10686path.close();
10687
10688 SkPath path2(path);
10689 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
10690}

◆ battleOp61()

static void battleOp61 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1684 of file PathOpsBattles.cpp.

1684 {
1685 SkPath path;
1686 path.setFillType((SkPathFillType) 1);
1687path.moveTo(SkBits2Float(0x36b23f68), SkBits2Float(0xc2700000));
1688path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1689path.cubicTo(SkBits2Float(0x3e9334c2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f13342a), SkBits2Float(0xc2a5ff3c), SkBits2Float(0x3f5ccd1a), SkBits2Float(0xc2a5fdb5));
1690path.cubicTo(SkBits2Float(0x3f642956), SkBits2Float(0xc2a5fd8c), SkBits2Float(0x3f6b855d), SkBits2Float(0xc2a5fd63), SkBits2Float(0x3f72e163), SkBits2Float(0xc2a5fd38));
1691path.lineTo(SkBits2Float(0x3f2f9381), SkBits2Float(0xc26ffbfc));
1692path.cubicTo(SkBits2Float(0x3f2a4188), SkBits2Float(0xc26ffc3b), SkBits2Float(0x3f24ef95), SkBits2Float(0xc26ffc76), SkBits2Float(0x3f1f9d85), SkBits2Float(0xc26ffcaf));
1693path.cubicTo(SkBits2Float(0x3ed4d324), SkBits2Float(0xc26ffee7), SkBits2Float(0x3e54d404), SkBits2Float(0xc2700000), SkBits2Float(0x36b23f68), SkBits2Float(0xc2700000));
1694path.close();
1695
1696 SkPath path1(path);
1697 path.reset();
1698 path.setFillType((SkPathFillType) 0);
1699path.moveTo(SkBits2Float(0x3f72e162), SkBits2Float(0xc2a5fd39));
1700path.cubicTo(SkBits2Float(0x3fb51288), SkBits2Float(0xc2a5fa80), SkBits2Float(0x3ff0b297), SkBits2Float(0xc2a5f5c4), SkBits2Float(0x401627a5), SkBits2Float(0xc2a5ef06));
1701path.lineTo(SkBits2Float(0x3fd9177b), SkBits2Float(0xc26fe773));
1702path.cubicTo(SkBits2Float(0x3fadff90), SkBits2Float(0xc26ff134), SkBits2Float(0x3f82e54e), SkBits2Float(0xc26ff80c), SkBits2Float(0x3f2f9393), SkBits2Float(0xc26ffbfc));
1703path.lineTo(SkBits2Float(0x3f72e162), SkBits2Float(0xc2a5fd39));
1704path.close();
1705
1706 SkPath path2(path);
1707 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1708}

◆ battleOp62()

static void battleOp62 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1711 of file PathOpsBattles.cpp.

1711 {
1712 SkPath path;
1713 path.setFillType((SkPathFillType) 0);
1714path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1715path.cubicTo(SkBits2Float(0x3f614848), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fe14683), SkBits2Float(0xc2a5f8d5), SkBits2Float(0x4028ee0f), SkBits2Float(0xc2a5ea81));
1716path.lineTo(SkBits2Float(0x3ff43c76), SkBits2Float(0xc26fe0ec));
1717path.cubicTo(SkBits2Float(0x3fa2d98a), SkBits2Float(0xc26ff5a4), SkBits2Float(0x3f22dad5), SkBits2Float(0xc2700000), SkBits2Float(0xb5420574), SkBits2Float(0xc2700000));
1718path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1719path.close();
1720
1721 SkPath path1(path);
1722 path.reset();
1723 path.setFillType((SkPathFillType) 0);
1724path.moveTo(SkBits2Float(0x4028ee15), SkBits2Float(0xc2a5ea81));
1725path.cubicTo(SkBits2Float(0x402e8f25), SkBits2Float(0xc2a5e912), SkBits2Float(0x40343026), SkBits2Float(0xc2a5e791), SkBits2Float(0x4039d111), SkBits2Float(0xc2a5e5fd));
1726path.lineTo(SkBits2Float(0x4006533c), SkBits2Float(0xc26fda66));
1727path.cubicTo(SkBits2Float(0x4002419e), SkBits2Float(0xc26fdcaf), SkBits2Float(0x3ffc5fdb), SkBits2Float(0xc26fdedc), SkBits2Float(0x3ff43c61), SkBits2Float(0xc26fe0ed));
1728path.lineTo(SkBits2Float(0x4028ee15), SkBits2Float(0xc2a5ea81));
1729path.close();
1730
1731 SkPath path2(path);
1732 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1733}

◆ battleOp63()

static void battleOp63 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1736 of file PathOpsBattles.cpp.

1736 {
1737 SkPath path;
1738 path.setFillType((SkPathFillType) 1);
1739path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1740path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1741path.cubicTo(SkBits2Float(0x3f614848), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fe14683), SkBits2Float(0xc2a5f8d5), SkBits2Float(0x4028ee15), SkBits2Float(0xc2a5ea81));
1742path.cubicTo(SkBits2Float(0x402e8f25), SkBits2Float(0xc2a5e912), SkBits2Float(0x40343026), SkBits2Float(0xc2a5e791), SkBits2Float(0x4039d111), SkBits2Float(0xc2a5e5fd));
1743path.lineTo(SkBits2Float(0x4006533c), SkBits2Float(0xc26fda66));
1744path.cubicTo(SkBits2Float(0x400241a2), SkBits2Float(0xc26fdcaf), SkBits2Float(0x3ffc5fea), SkBits2Float(0xc26fdedc), SkBits2Float(0x3ff43c76), SkBits2Float(0xc26fe0ec));
1745path.cubicTo(SkBits2Float(0x3fa2d98a), SkBits2Float(0xc26ff5a4), SkBits2Float(0x3f22dad5), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
1746path.close();
1747path.moveTo(SkBits2Float(0x40186abb), SkBits2Float(0xc295b297));
1748path.lineTo(SkBits2Float(0x3ff43c61), SkBits2Float(0xc26fe0ed));
1749path.lineTo(SkBits2Float(0x3ff43c77), SkBits2Float(0xc26fe0ed));
1750path.lineTo(SkBits2Float(0x40186abb), SkBits2Float(0xc295b297));
1751path.close();
1752
1753 SkPath path1(path);
1754 path.reset();
1755 path.setFillType((SkPathFillType) 0);
1756path.moveTo(SkBits2Float(0x4039d102), SkBits2Float(0xc2a5e5fe));
1757path.cubicTo(SkBits2Float(0x408a83ff), SkBits2Float(0xc2a5cc72), SkBits2Float(0x40b8130f), SkBits2Float(0xc2a5a01a), SkBits2Float(0x40e58a06), SkBits2Float(0xc2a56100));
1758path.lineTo(SkBits2Float(0x40a5ee90), SkBits2Float(0xc26f1a20));
1759path.cubicTo(SkBits2Float(0x408510de), SkBits2Float(0xc26f755e), SkBits2Float(0x40484386), SkBits2Float(0xc26fb57a), SkBits2Float(0x40065347), SkBits2Float(0xc26fda68));
1760path.lineTo(SkBits2Float(0x4039d102), SkBits2Float(0xc2a5e5fe));
1761path.close();
1762
1763 SkPath path2(path);
1764 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1765}

◆ battleOp64()

static void battleOp64 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1768 of file PathOpsBattles.cpp.

1768 {
1769 SkPath path;
1770 path.setFillType((SkPathFillType) 0);
1771path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1772path.cubicTo(SkBits2Float(0x3faf587e), SkBits2Float(0xc2a5ffff), SkBits2Float(0x402f5505), SkBits2Float(0xc2a5eea1), SkBits2Float(0x408372de), SkBits2Float(0xc2a5cbeb));
1773path.lineTo(SkBits2Float(0x403e0bd0), SkBits2Float(0xc26fb4b6));
1774path.cubicTo(SkBits2Float(0x3ffd7de6), SkBits2Float(0xc26fe6e6), SkBits2Float(0x3f7d82fb), SkBits2Float(0xc2700000), SkBits2Float(0x363f7eb2), SkBits2Float(0xc2700000));
1775path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1776path.close();
1777
1778 SkPath path1(path);
1779 path.reset();
1780 path.setFillType((SkPathFillType) 0);
1781path.moveTo(SkBits2Float(0x408372d6), SkBits2Float(0xc2a5cbec));
1782path.cubicTo(SkBits2Float(0x4087d39d), SkBits2Float(0xc2a5c874), SkBits2Float(0x408c3440), SkBits2Float(0xc2a5c4cf), SkBits2Float(0x409094bd), SkBits2Float(0xc2a5c0fe));
1783path.lineTo(SkBits2Float(0x40510866), SkBits2Float(0xc26fa4e7));
1784path.cubicTo(SkBits2Float(0x404ab468), SkBits2Float(0xc26faa6c), SkBits2Float(0x40446037), SkBits2Float(0xc26fafb2), SkBits2Float(0x403e0bd2), SkBits2Float(0xc26fb4b7));
1785path.lineTo(SkBits2Float(0x408372d6), SkBits2Float(0xc2a5cbec));
1786path.close();
1787
1788 SkPath path2(path);
1789 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1790}

◆ battleOp65()

static void battleOp65 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1793 of file PathOpsBattles.cpp.

1793 {
1794 SkPath path;
1795 path.setFillType((SkPathFillType) 1);
1796path.moveTo(SkBits2Float(0x363f7eb2), SkBits2Float(0xc2700000));
1797path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1798path.cubicTo(SkBits2Float(0x3faf5872), SkBits2Float(0xc2a60000), SkBits2Float(0x402f54f9), SkBits2Float(0xc2a5eea1), SkBits2Float(0x408372d5), SkBits2Float(0xc2a5cbeb));
1799path.lineTo(SkBits2Float(0x408372d6), SkBits2Float(0xc2a5cbec));
1800path.cubicTo(SkBits2Float(0x4087d39d), SkBits2Float(0xc2a5c874), SkBits2Float(0x408c3440), SkBits2Float(0xc2a5c4cf), SkBits2Float(0x409094bd), SkBits2Float(0xc2a5c0fe));
1801path.lineTo(SkBits2Float(0x40510866), SkBits2Float(0xc26fa4e7));
1802path.cubicTo(SkBits2Float(0x404ab468), SkBits2Float(0xc26faa6c), SkBits2Float(0x40446037), SkBits2Float(0xc26fafb2), SkBits2Float(0x403e0bd0), SkBits2Float(0xc26fb4b6));
1803path.cubicTo(SkBits2Float(0x3ffd7de6), SkBits2Float(0xc26fe6e6), SkBits2Float(0x3f7d82fb), SkBits2Float(0xc2700000), SkBits2Float(0x363f7eb2), SkBits2Float(0xc2700000));
1804path.close();
1805
1806 SkPath path1(path);
1807 path.reset();
1808 path.setFillType((SkPathFillType) 0);
1809path.moveTo(SkBits2Float(0x409094be), SkBits2Float(0xc2a5c0fe));
1810path.cubicTo(SkBits2Float(0x40d784bb), SkBits2Float(0xc2a5831d), SkBits2Float(0x410f22d3), SkBits2Float(0xc2a517ba), SkBits2Float(0x413255ec), SkBits2Float(0xc2a47f15));
1811path.lineTo(SkBits2Float(0x4100ead4), SkBits2Float(0xc26dd37e));
1812path.cubicTo(SkBits2Float(0x40cef193), SkBits2Float(0xc26eb02f), SkBits2Float(0x409bcbdf), SkBits2Float(0xc26f4b72), SkBits2Float(0x40510859), SkBits2Float(0xc26fa4e8));
1813path.lineTo(SkBits2Float(0x409094be), SkBits2Float(0xc2a5c0fe));
1814path.close();
1815
1816 SkPath path2(path);
1817 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1818}

◆ battleOp66()

static void battleOp66 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1821 of file PathOpsBattles.cpp.

1821 {
1822 SkPath path;
1823 path.setFillType((SkPathFillType) 0);
1824path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1825path.cubicTo(SkBits2Float(0x4037e518), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40b7d534), SkBits2Float(0xc2a5b39a), SkBits2Float(0x4109a47d), SkBits2Float(0xc2a51b1f));
1826path.lineTo(SkBits2Float(0x40c70051), SkBits2Float(0xc26eb519));
1827path.cubicTo(SkBits2Float(0x4084e427), SkBits2Float(0xc26f918c), SkBits2Float(0x4004efa4), SkBits2Float(0xc26fffff), SkBits2Float(0x3543fa8c), SkBits2Float(0xc26fffff));
1828path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1829path.close();
1830
1831 SkPath path1(path);
1832 path.reset();
1833 path.setFillType((SkPathFillType) 0);
1834path.moveTo(SkBits2Float(0x4109a47c), SkBits2Float(0xc2a51b20));
1835path.cubicTo(SkBits2Float(0x410e36d1), SkBits2Float(0xc2a50be2), SkBits2Float(0x4112c883), SkBits2Float(0xc2a4fbe1), SkBits2Float(0x41175985), SkBits2Float(0xc2a4eb1d));
1836path.lineTo(SkBits2Float(0x40dad196), SkBits2Float(0xc26e6faf));
1837path.cubicTo(SkBits2Float(0x40d4377d), SkBits2Float(0xc26e87ed), SkBits2Float(0x40cd9c5c), SkBits2Float(0xc26e9f10), SkBits2Float(0x40c7004e), SkBits2Float(0xc26eb51a));
1838path.lineTo(SkBits2Float(0x4109a47c), SkBits2Float(0xc2a51b20));
1839path.close();
1840
1841 SkPath path2(path);
1842 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1843}

◆ battleOp67()

static void battleOp67 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1846 of file PathOpsBattles.cpp.

1846 { // crashed
1847 SkPath path;
1848 path.setFillType((SkPathFillType) 1);
1849path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
1850path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1851path.cubicTo(SkBits2Float(0x4037e518), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40b7d534), SkBits2Float(0xc2a5b39a), SkBits2Float(0x4109a47c), SkBits2Float(0xc2a51b20));
1852path.cubicTo(SkBits2Float(0x410e36d1), SkBits2Float(0xc2a50be2), SkBits2Float(0x4112c883), SkBits2Float(0xc2a4fbe1), SkBits2Float(0x41175985), SkBits2Float(0xc2a4eb1d));
1853path.lineTo(SkBits2Float(0x40dad196), SkBits2Float(0xc26e6faf));
1854path.cubicTo(SkBits2Float(0x40d4377e), SkBits2Float(0xc26e87ed), SkBits2Float(0x40cd9c5f), SkBits2Float(0xc26e9f10), SkBits2Float(0x40c70052), SkBits2Float(0xc26eb51a));
1855path.lineTo(SkBits2Float(0x40c70051), SkBits2Float(0xc26eb519));
1856path.cubicTo(SkBits2Float(0x4084e427), SkBits2Float(0xc26f918c), SkBits2Float(0x4004efa4), SkBits2Float(0xc26fffff), SkBits2Float(0x00000000), SkBits2Float(0xc26fffff));
1857path.close();
1858
1859 SkPath path1(path);
1860 path.reset();
1861 path.setFillType((SkPathFillType) 0);
1862path.moveTo(SkBits2Float(0x4117597f), SkBits2Float(0xc2a4eb1d));
1863path.cubicTo(SkBits2Float(0x41616445), SkBits2Float(0xc2a3db51), SkBits2Float(0x41954b2d), SkBits2Float(0xc2a2048b), SkBits2Float(0x41b914a4), SkBits2Float(0xc29f6bcb));
1864path.lineTo(SkBits2Float(0x4185cb10), SkBits2Float(0xc2667d00));
1865path.cubicTo(SkBits2Float(0x4157d8a2), SkBits2Float(0xc26a3e17), SkBits2Float(0x4122ef07), SkBits2Float(0xc26ce6b9), SkBits2Float(0x40dad195), SkBits2Float(0xc26e6faf));
1866path.lineTo(SkBits2Float(0x4117597f), SkBits2Float(0xc2a4eb1d));
1867path.close();
1868
1869 SkPath path2(path);
1870 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1871}

◆ battleOp68()

static void battleOp68 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1873 of file PathOpsBattles.cpp.

1873 {
1874 SkPath path;
1875 path.setFillType((SkPathFillType) 0);
1876path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1877path.cubicTo(SkBits2Float(0x3e1b2207), SkBits2Float(0xc2a60000), SkBits2Float(0x3e9b2105), SkBits2Float(0xc2a5ffca), SkBits2Float(0x3ee8b0c0), SkBits2Float(0xc2a5ff5d));
1878path.lineTo(SkBits2Float(0x3ea83563), SkBits2Float(0xc26fff14));
1879path.cubicTo(SkBits2Float(0x3e60486a), SkBits2Float(0xc26fffb2), SkBits2Float(0x3de049e3), SkBits2Float(0xc2700000), SkBits2Float(0x36b67768), SkBits2Float(0xc2700000));
1880path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1881path.close();
1882
1883 SkPath path1(path);
1884 path.reset();
1885 path.setFillType((SkPathFillType) 0);
1886path.moveTo(SkBits2Float(0x3ee8b040), SkBits2Float(0xc2a5ff5d));
1887path.cubicTo(SkBits2Float(0x3ef0720a), SkBits2Float(0xc2a5ff52), SkBits2Float(0x3ef83386), SkBits2Float(0xc2a5ff47), SkBits2Float(0x3efff501), SkBits2Float(0xc2a5ff3b));
1888path.lineTo(SkBits2Float(0x3eb90778), SkBits2Float(0xc26ffee3));
1889path.cubicTo(SkBits2Float(0x3eb36c27), SkBits2Float(0xc26ffef6), SkBits2Float(0x3eadd0dd), SkBits2Float(0xc26fff07), SkBits2Float(0x3ea83592), SkBits2Float(0xc26fff16));
1890path.lineTo(SkBits2Float(0x3ee8b040), SkBits2Float(0xc2a5ff5d));
1891path.close();
1892
1893 SkPath path2(path);
1894 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1895}

◆ battleOp69()

static void battleOp69 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1898 of file PathOpsBattles.cpp.

1898 {
1899 SkPath path;
1900 path.setFillType((SkPathFillType) 1);
1901path.moveTo(SkBits2Float(0x36b67768), SkBits2Float(0xc2700000));
1902path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1903path.cubicTo(SkBits2Float(0x3e1b21b2), SkBits2Float(0xc2a60000), SkBits2Float(0x3e9b20b0), SkBits2Float(0xc2a5ffca), SkBits2Float(0x3ee8b040), SkBits2Float(0xc2a5ff5d));
1904path.cubicTo(SkBits2Float(0x3ef0720a), SkBits2Float(0xc2a5ff52), SkBits2Float(0x3ef83386), SkBits2Float(0xc2a5ff47), SkBits2Float(0x3efff501), SkBits2Float(0xc2a5ff3b));
1905path.lineTo(SkBits2Float(0x3eb90778), SkBits2Float(0xc26ffee3));
1906path.lineTo(SkBits2Float(0x3ea83592), SkBits2Float(0xc26fff16));
1907path.lineTo(SkBits2Float(0x3ea83563), SkBits2Float(0xc26fff14));
1908path.cubicTo(SkBits2Float(0x3e60486a), SkBits2Float(0xc26fffb2), SkBits2Float(0x3de049e3), SkBits2Float(0xc2700000), SkBits2Float(0x36b67768), SkBits2Float(0xc2700000));
1909path.close();
1910
1911 SkPath path1(path);
1912 path.reset();
1913 path.setFillType((SkPathFillType) 0);
1914path.moveTo(SkBits2Float(0x3efff501), SkBits2Float(0xc2a5ff3b));
1915path.cubicTo(SkBits2Float(0x3f3ed289), SkBits2Float(0xc2a5fe79), SkBits2Float(0x3f7daa5c), SkBits2Float(0xc2a5fd28), SkBits2Float(0x3f9e4099), SkBits2Float(0xc2a5fb49));
1916path.lineTo(SkBits2Float(0x3f64cc5f), SkBits2Float(0xc26ff92f));
1917path.cubicTo(SkBits2Float(0x3f375f8f), SkBits2Float(0xc26ffbe5), SkBits2Float(0x3f09f1cf), SkBits2Float(0xc26ffdcc), SkBits2Float(0x3eb9075f), SkBits2Float(0xc26ffee4));
1918path.lineTo(SkBits2Float(0x3efff501), SkBits2Float(0xc2a5ff3b));
1919path.close();
1920
1921 SkPath path2(path);
1922 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1923}

◆ battleOp7()

static void battleOp7 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 255 of file PathOpsBattles.cpp.

255 {
256 SkPath path;
257 path.setFillType((SkPathFillType) 0);
258path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
259path.cubicTo(SkBits2Float(0x3de5c884), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e65c882), SkBits2Float(0xc2a5ffe2), SkBits2Float(0x3eac5645), SkBits2Float(0xc2a5ffa7));
260path.lineTo(SkBits2Float(0x3e79297e), SkBits2Float(0xc26fff7f));
261path.cubicTo(SkBits2Float(0x3e261bbd), SkBits2Float(0xc26fffd7), SkBits2Float(0x3da61bbf), SkBits2Float(0xc2700000), SkBits2Float(0xb3244c00), SkBits2Float(0xc2700000));
262path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
263path.close();
264
265 SkPath path1(path);
266 path.reset();
267 path.setFillType((SkPathFillType) 0);
268path.moveTo(SkBits2Float(0x3eac564d), SkBits2Float(0xc2a5ffa7));
269path.cubicTo(SkBits2Float(0x3eb21458), SkBits2Float(0xc2a5ffa1), SkBits2Float(0x3eb7d2fc), SkBits2Float(0xc2a5ff9b), SkBits2Float(0x3ebd91a0), SkBits2Float(0xc2a5ff94));
270path.lineTo(SkBits2Float(0x3e8909ff), SkBits2Float(0xc26fff64));
271path.cubicTo(SkBits2Float(0x3e84e2cf), SkBits2Float(0xc26fff6d), SkBits2Float(0x3e80bc02), SkBits2Float(0xc26fff76), SkBits2Float(0x3e792a69), SkBits2Float(0xc26fff7f));
272path.lineTo(SkBits2Float(0x3eac564d), SkBits2Float(0xc2a5ffa7));
273path.close();
274
275 SkPath path2(path);
276 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
277}

◆ battleOp70()

static void battleOp70 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1926 of file PathOpsBattles.cpp.

1926 {
1927 SkPath path;
1928 path.setFillType((SkPathFillType) 0);
1929path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1930path.cubicTo(SkBits2Float(0x3f0938d2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f893841), SkBits2Float(0xc2a5fd56), SkBits2Float(0x3fcdd137), SkBits2Float(0xc2a5f805));
1931path.lineTo(SkBits2Float(0x3f94c89b), SkBits2Float(0xc26ff478));
1932path.cubicTo(SkBits2Float(0x3f4663c1), SkBits2Float(0xc26ffc29), SkBits2Float(0x3ec6647d), SkBits2Float(0xc2700000), SkBits2Float(0x360ebeb2), SkBits2Float(0xc2700000));
1933path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1934path.close();
1935
1936 SkPath path1(path);
1937 path.reset();
1938 path.setFillType((SkPathFillType) 0);
1939path.moveTo(SkBits2Float(0x3fcdd13c), SkBits2Float(0xc2a5f806));
1940path.cubicTo(SkBits2Float(0x3fd4ad55), SkBits2Float(0xc2a5f77d), SkBits2Float(0x3fdb895f), SkBits2Float(0xc2a5f6ef), SkBits2Float(0x3fe26560), SkBits2Float(0xc2a5f659));
1941path.lineTo(SkBits2Float(0x3fa3a8ea), SkBits2Float(0xc26ff20c));
1942path.cubicTo(SkBits2Float(0x3f9eb37e), SkBits2Float(0xc26ff2e6), SkBits2Float(0x3f99be11), SkBits2Float(0xc26ff3b4), SkBits2Float(0x3f94c89e), SkBits2Float(0xc26ff479));
1943path.lineTo(SkBits2Float(0x3fcdd13c), SkBits2Float(0xc2a5f806));
1944path.close();
1945
1946 SkPath path2(path);
1947 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1948}

◆ battleOp71()

static void battleOp71 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1951 of file PathOpsBattles.cpp.

1951 {
1952 SkPath path;
1953 path.setFillType((SkPathFillType) 1);
1954path.moveTo(SkBits2Float(0x360ebeb2), SkBits2Float(0xc2700000));
1955path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
1956path.cubicTo(SkBits2Float(0x3f0938d2), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f893841), SkBits2Float(0xc2a5fd56), SkBits2Float(0x3fcdd13c), SkBits2Float(0xc2a5f806));
1957path.cubicTo(SkBits2Float(0x3fd4ad55), SkBits2Float(0xc2a5f77d), SkBits2Float(0x3fdb895f), SkBits2Float(0xc2a5f6ef), SkBits2Float(0x3fe26560), SkBits2Float(0xc2a5f659));
1958path.lineTo(SkBits2Float(0x3fa3a8ea), SkBits2Float(0xc26ff20c));
1959path.cubicTo(SkBits2Float(0x3f9eb37e), SkBits2Float(0xc26ff2e6), SkBits2Float(0x3f99be11), SkBits2Float(0xc26ff3b4), SkBits2Float(0x3f94c89b), SkBits2Float(0xc26ff478));
1960path.cubicTo(SkBits2Float(0x3f4663c1), SkBits2Float(0xc26ffc29), SkBits2Float(0x3ec6647d), SkBits2Float(0xc2700000), SkBits2Float(0x360ebeb2), SkBits2Float(0xc2700000));
1961path.close();
1962
1963 SkPath path1(path);
1964 path.reset();
1965 path.setFillType((SkPathFillType) 0);
1966path.moveTo(SkBits2Float(0x3fe26566), SkBits2Float(0xc2a5f65a));
1967path.cubicTo(SkBits2Float(0x4028c729), SkBits2Float(0xc2a5ecdf), SkBits2Float(0x406055f2), SkBits2Float(0xc2a5dc6a), SkBits2Float(0x408beceb), SkBits2Float(0xc2a5c4fb));
1968path.lineTo(SkBits2Float(0x404a4d47), SkBits2Float(0xc26faaae));
1969path.cubicTo(SkBits2Float(0x40222b9c), SkBits2Float(0xc26fcc90), SkBits2Float(0x3ff40427), SkBits2Float(0xc26fe45b), SkBits2Float(0x3fa3a8ee), SkBits2Float(0xc26ff20e));
1970path.lineTo(SkBits2Float(0x3fe26566), SkBits2Float(0xc2a5f65a));
1971path.close();
1972
1973 SkPath path2(path);
1974 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
1975}

◆ battleOp72()

static void battleOp72 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1978 of file PathOpsBattles.cpp.

1978 {
1979 SkPath path;
1980 path.setFillType((SkPathFillType) 0);
1981path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1982path.cubicTo(SkBits2Float(0x3f73aa4a), SkBits2Float(0xc2a60000), SkBits2Float(0x3ff3a7f0), SkBits2Float(0xc2a5f79e), SkBits2Float(0x4036b54b), SkBits2Float(0xc2a5e6db));
1983path.lineTo(SkBits2Float(0x40041412), SkBits2Float(0xc26fdba5));
1984path.cubicTo(SkBits2Float(0x3fb0230c), SkBits2Float(0xc26ff3e0), SkBits2Float(0x3f3024c1), SkBits2Float(0xc26fffff), SkBits2Float(0x359dfd4a), SkBits2Float(0xc26fffff));
1985path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
1986path.close();
1987
1988 SkPath path1(path);
1989 path.reset();
1990 path.setFillType((SkPathFillType) 0);
1991path.moveTo(SkBits2Float(0x4036b55d), SkBits2Float(0xc2a5e6db));
1992path.cubicTo(SkBits2Float(0x403ccbdf), SkBits2Float(0xc2a5e52d), SkBits2Float(0x4042e24c), SkBits2Float(0xc2a5e36a), SkBits2Float(0x4048f89e), SkBits2Float(0xc2a5e192));
1993path.lineTo(SkBits2Float(0x401147bc), SkBits2Float(0xc26fd403));
1994path.cubicTo(SkBits2Float(0x400ce144), SkBits2Float(0xc26fd6ae), SkBits2Float(0x40087ab2), SkBits2Float(0xc26fd939), SkBits2Float(0x4004140f), SkBits2Float(0xc26fdba5));
1995path.lineTo(SkBits2Float(0x4036b55d), SkBits2Float(0xc2a5e6db));
1996path.close();
1997
1998 SkPath path2(path);
1999 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2000}

◆ battleOp73()

static void battleOp73 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2003 of file PathOpsBattles.cpp.

2003 {
2004 SkPath path;
2005 path.setFillType((SkPathFillType) 0);
2006path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2007path.cubicTo(SkBits2Float(0x40447e19), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40c46ab2), SkBits2Float(0xc2a5a8c7), SkBits2Float(0x4113078c), SkBits2Float(0xc2a4fabe));
2008path.lineTo(SkBits2Float(0x40d4929e), SkBits2Float(0xc26e8647));
2009path.cubicTo(SkBits2Float(0x408dfcf1), SkBits2Float(0xc26f81e6), SkBits2Float(0x400e0af8), SkBits2Float(0xc2700000), SkBits2Float(0x3655fea5), SkBits2Float(0xc2700000));
2010path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2011path.close();
2012
2013 SkPath path1(path);
2014 path.reset();
2015 path.setFillType((SkPathFillType) 0);
2016path.moveTo(SkBits2Float(0x4113078b), SkBits2Float(0xc2a4fabe));
2017path.cubicTo(SkBits2Float(0x4117e908), SkBits2Float(0xc2a4e957), SkBits2Float(0x411cc9c0), SkBits2Float(0xc2a4d714), SkBits2Float(0x4121a9a1), SkBits2Float(0xc2a4c3f3));
2018path.lineTo(SkBits2Float(0x40e9baad), SkBits2Float(0xc26e370e));
2019path.cubicTo(SkBits2Float(0x40e2ae85), SkBits2Float(0xc26e52b6), SkBits2Float(0x40dba120), SkBits2Float(0xc26e6d20), SkBits2Float(0x40d4929a), SkBits2Float(0xc26e8647));
2020path.lineTo(SkBits2Float(0x4113078b), SkBits2Float(0xc2a4fabe));
2021path.close();
2022
2023 SkPath path2(path);
2024 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2025}

◆ battleOp74()

static void battleOp74 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2028 of file PathOpsBattles.cpp.

2028 {
2029 SkPath path;
2030 path.setFillType((SkPathFillType) 0);
2031path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2032path.cubicTo(SkBits2Float(0x406db78d), SkBits2Float(0xc2a60000), SkBits2Float(0x40ed953d), SkBits2Float(0xc2a58058), SkBits2Float(0x4131afb7), SkBits2Float(0xc2a481e4));
2033path.lineTo(SkBits2Float(0x410072b2), SkBits2Float(0xc26dd78e));
2034path.cubicTo(SkBits2Float(0x40abbf2e), SkBits2Float(0xc26f4770), SkBits2Float(0x402bd807), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2035path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2036path.close();
2037
2038 SkPath path1(path);
2039 path.reset();
2040 path.setFillType((SkPathFillType) 0);
2041path.moveTo(SkBits2Float(0x4131afba), SkBits2Float(0xc2a481e4));
2042path.cubicTo(SkBits2Float(0x413792dd), SkBits2Float(0xc2a46874), SkBits2Float(0x413d74a2), SkBits2Float(0xc2a44dc1), SkBits2Float(0x414354e9), SkBits2Float(0xc2a431ca));
2043path.lineTo(SkBits2Float(0x410d3424), SkBits2Float(0xc26d63c0));
2044path.cubicTo(SkBits2Float(0x4108f4b6), SkBits2Float(0xc26d8c2e), SkBits2Float(0x4104b435), SkBits2Float(0xc26db2c8), SkBits2Float(0x410072b4), SkBits2Float(0xc26dd78e));
2045path.lineTo(SkBits2Float(0x4131afba), SkBits2Float(0xc2a481e4));
2046path.close();
2047
2048 SkPath path2(path);
2049 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2050}

◆ battleOp75()

static void battleOp75 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2053 of file PathOpsBattles.cpp.

2053 {
2054 SkPath path;
2055 path.setFillType((SkPathFillType) 1);
2056path.moveTo(SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2057path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2058path.cubicTo(SkBits2Float(0x406db78d), SkBits2Float(0xc2a60000), SkBits2Float(0x40ed953d), SkBits2Float(0xc2a58058), SkBits2Float(0x4131afba), SkBits2Float(0xc2a481e4));
2059path.cubicTo(SkBits2Float(0x413792dd), SkBits2Float(0xc2a46874), SkBits2Float(0x413d74a2), SkBits2Float(0xc2a44dc1), SkBits2Float(0x414354e9), SkBits2Float(0xc2a431ca));
2060path.lineTo(SkBits2Float(0x410d3424), SkBits2Float(0xc26d63c0));
2061path.cubicTo(SkBits2Float(0x4108f4b6), SkBits2Float(0xc26d8c2e), SkBits2Float(0x4104b435), SkBits2Float(0xc26db2c8), SkBits2Float(0x410072b2), SkBits2Float(0xc26dd78e));
2062path.cubicTo(SkBits2Float(0x40abbf2e), SkBits2Float(0xc26f4770), SkBits2Float(0x402bd807), SkBits2Float(0xc2700000), SkBits2Float(0x36b5ff52), SkBits2Float(0xc2700000));
2063path.close();
2064
2065 SkPath path1(path);
2066 path.reset();
2067 path.setFillType((SkPathFillType) 0);
2068path.moveTo(SkBits2Float(0x414354ed), SkBits2Float(0xc2a431cb));
2069path.cubicTo(SkBits2Float(0x419152e5), SkBits2Float(0xc2a26c3a), SkBits2Float(0x41c0119b), SkBits2Float(0xc29f5c06), SkBits2Float(0x41ed1335), SkBits2Float(0xc29b0f0a));
2070path.lineTo(SkBits2Float(0x41ab612b), SkBits2Float(0xc2602e6b));
2071path.cubicTo(SkBits2Float(0x418ad84d), SkBits2Float(0xc2666635), SkBits2Float(0x41521b54), SkBits2Float(0xc26ad3fe), SkBits2Float(0x410d3426), SkBits2Float(0xc26d63c0));
2072path.lineTo(SkBits2Float(0x414354ed), SkBits2Float(0xc2a431cb));
2073path.close();
2074
2075 SkPath path2(path);
2076 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2077}

◆ battleOp76()

static void battleOp76 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2080 of file PathOpsBattles.cpp.

2080 {
2081 SkPath path;
2082 path.setFillType((SkPathFillType) 0);
2083path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2084path.cubicTo(SkBits2Float(0x40932e58), SkBits2Float(0xc2a5ffff), SkBits2Float(0x41130dbc), SkBits2Float(0xc2a53c41), SkBits2Float(0x415ba178), SkBits2Float(0xc2a3b6ca));
2085path.lineTo(SkBits2Float(0x411ec4eb), SkBits2Float(0xc26cb1eb));
2086path.cubicTo(SkBits2Float(0x40d49b93), SkBits2Float(0xc26ee4ff), SkBits2Float(0x4054cab9), SkBits2Float(0xc26fffff), SkBits2Float(0x35f7fd46), SkBits2Float(0xc26fffff));
2087path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2088path.close();
2089
2090 SkPath path1(path);
2091 path.reset();
2092 path.setFillType((SkPathFillType) 0);
2093path.moveTo(SkBits2Float(0x415ba178), SkBits2Float(0xc2a3b6cb));
2094path.cubicTo(SkBits2Float(0x4162e261), SkBits2Float(0xc2a38fde), SkBits2Float(0x416a20aa), SkBits2Float(0xc2a36704), SkBits2Float(0x41715c23), SkBits2Float(0xc2a33c3e));
2095path.lineTo(SkBits2Float(0x412e7a25), SkBits2Float(0xc26c00bd));
2096path.cubicTo(SkBits2Float(0x41293fb6), SkBits2Float(0xc26c3e94), SkBits2Float(0x41240342), SkBits2Float(0xc26c79a4), SkBits2Float(0x411ec4e8), SkBits2Float(0xc26cb1eb));
2097path.lineTo(SkBits2Float(0x415ba178), SkBits2Float(0xc2a3b6cb));
2098path.close();
2099
2100 SkPath path2(path);
2101 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2102}

◆ battleOp77()

static void battleOp77 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2105 of file PathOpsBattles.cpp.

2105 {
2106 SkPath path;
2107 path.setFillType((SkPathFillType) 0);
2108path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2109path.cubicTo(SkBits2Float(0x40d0158a), SkBits2Float(0xc2a60000), SkBits2Float(0x414fb944), SkBits2Float(0xc2a478c0), SkBits2Float(0x419a74b5), SkBits2Float(0xc2a1724b));
2110path.lineTo(SkBits2Float(0x415f4f4c), SkBits2Float(0xc2696aa5));
2111path.cubicTo(SkBits2Float(0x41162967), SkBits2Float(0xc26dca57), SkBits2Float(0x40966c1f), SkBits2Float(0xc2700000), SkBits2Float(0x3655fea3), SkBits2Float(0xc2700000));
2112path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2113path.close();
2114
2115 SkPath path1(path);
2116 path.reset();
2117 path.setFillType((SkPathFillType) 0);
2118path.moveTo(SkBits2Float(0x419a74b6), SkBits2Float(0xc2a1724b));
2119path.cubicTo(SkBits2Float(0x419f8274), SkBits2Float(0xc2a124ef), SkBits2Float(0x41a48c82), SkBits2Float(0xc2a0d3c9), SkBits2Float(0x41a9929f), SkBits2Float(0xc2a07edb));
2120path.lineTo(SkBits2Float(0x41752a58), SkBits2Float(0xc2680ab0));
2121path.cubicTo(SkBits2Float(0x416de6e6), SkBits2Float(0xc268857b), SkBits2Float(0x41669dc0), SkBits2Float(0xc268facf), SkBits2Float(0x415f4f4b), SkBits2Float(0xc2696aa6));
2122path.lineTo(SkBits2Float(0x419a74b6), SkBits2Float(0xc2a1724b));
2123path.close();
2124
2125 SkPath path2(path);
2126 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2127}

◆ battleOp78()

static void battleOp78 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2130 of file PathOpsBattles.cpp.

2130 {
2131 SkPath path;
2132 path.setFillType((SkPathFillType) 1);
2133path.moveTo(SkBits2Float(0x3655fea3), SkBits2Float(0xc2700000));
2134path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2135path.cubicTo(SkBits2Float(0x40d0158a), SkBits2Float(0xc2a60000), SkBits2Float(0x414fb944), SkBits2Float(0xc2a478c0), SkBits2Float(0x419a74b6), SkBits2Float(0xc2a1724b));
2136path.cubicTo(SkBits2Float(0x419f8274), SkBits2Float(0xc2a124ef), SkBits2Float(0x41a48c82), SkBits2Float(0xc2a0d3c9), SkBits2Float(0x41a9929f), SkBits2Float(0xc2a07edb));
2137path.lineTo(SkBits2Float(0x41752a58), SkBits2Float(0xc2680ab0));
2138path.cubicTo(SkBits2Float(0x416de6e6), SkBits2Float(0xc268857b), SkBits2Float(0x41669dc0), SkBits2Float(0xc268facf), SkBits2Float(0x415f4f4c), SkBits2Float(0xc2696aa5));
2139path.cubicTo(SkBits2Float(0x41162967), SkBits2Float(0xc26dca57), SkBits2Float(0x40966c1f), SkBits2Float(0xc2700000), SkBits2Float(0x3655fea3), SkBits2Float(0xc2700000));
2140path.close();
2141
2142 SkPath path1(path);
2143 path.reset();
2144 path.setFillType((SkPathFillType) 0);
2145path.moveTo(SkBits2Float(0x41a9929f), SkBits2Float(0xc2a07edc));
2146path.cubicTo(SkBits2Float(0x41fb3aee), SkBits2Float(0xc29b1a71), SkBits2Float(0x422402f4), SkBits2Float(0xc291ddaf), SkBits2Float(0x4245eaa6), SkBits2Float(0xc2854763));
2147path.lineTo(SkBits2Float(0x420f1280), SkBits2Float(0xc240b13c));
2148path.cubicTo(SkBits2Float(0x41ed200b), SkBits2Float(0xc252e3f9), SkBits2Float(0x41b59cbb), SkBits2Float(0xc2603ee8), SkBits2Float(0x41752a58), SkBits2Float(0xc2680aaf));
2149path.lineTo(SkBits2Float(0x41a9929f), SkBits2Float(0xc2a07edc));
2150path.close();
2151
2152 SkPath path2(path);
2153 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2154}

◆ battleOp79()

static void battleOp79 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2157 of file PathOpsBattles.cpp.

2157 { //crashed
2158 SkPath path;
2159 path.setFillType((SkPathFillType) 0);
2160path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2161path.cubicTo(SkBits2Float(0x4110a0cc), SkBits2Float(0xc2a60000), SkBits2Float(0x4190247a), SkBits2Float(0xc2a30bfe), SkBits2Float(0x41d4a5dc), SkBits2Float(0xc29d41d4));
2162path.lineTo(SkBits2Float(0x4199b8a9), SkBits2Float(0xc2635c16));
2163path.cubicTo(SkBits2Float(0x4150660f), SkBits2Float(0xc26bbaf8), SkBits2Float(0x40d119d0), SkBits2Float(0xc2700000), SkBits2Float(0x3673fea3), SkBits2Float(0xc2700000));
2164path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2165path.close();
2166
2167 SkPath path1(path);
2168 path.reset();
2169 path.setFillType((SkPathFillType) 0);
2170path.moveTo(SkBits2Float(0x41d4a5d9), SkBits2Float(0xc29d41d4));
2171path.cubicTo(SkBits2Float(0x41db7bbd), SkBits2Float(0xc29cadef), SkBits2Float(0x41e247df), SkBits2Float(0xc29c12ec), SkBits2Float(0x41e9098d), SkBits2Float(0xc29b70d9));
2172path.lineTo(SkBits2Float(0x41a875f1), SkBits2Float(0xc260bbd5));
2173path.cubicTo(SkBits2Float(0x41a39393), SkBits2Float(0xc261a627), SkBits2Float(0x419ea9a6), SkBits2Float(0xc2628645), SkBits2Float(0x4199b8ab), SkBits2Float(0xc2635c17));
2174path.lineTo(SkBits2Float(0x41d4a5d9), SkBits2Float(0xc29d41d4));
2175path.close();
2176
2177 SkPath path2(path);
2178 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2179}

◆ battleOp8()

static void battleOp8 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 280 of file PathOpsBattles.cpp.

280 {
281 SkPath path;
282 path.setFillType((SkPathFillType) 1);
283path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
284path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
285path.cubicTo(SkBits2Float(0x3de5c884), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e65c882), SkBits2Float(0xc2a5ffe2), SkBits2Float(0x3eac564d), SkBits2Float(0xc2a5ffa7));
286path.cubicTo(SkBits2Float(0x3eb21458), SkBits2Float(0xc2a5ffa1), SkBits2Float(0x3eb7d2fc), SkBits2Float(0xc2a5ff9b), SkBits2Float(0x3ebd91a0), SkBits2Float(0xc2a5ff94));
287path.lineTo(SkBits2Float(0x3e8909ff), SkBits2Float(0xc26fff64));
288path.lineTo(SkBits2Float(0x3e792a69), SkBits2Float(0xc26fff7f));
289path.cubicTo(SkBits2Float(0x3e261bbd), SkBits2Float(0xc26fffd7), SkBits2Float(0x3da61bbf), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
290path.close();
291
292 SkPath path1(path);
293 path.reset();
294 path.setFillType((SkPathFillType) 0);
295path.moveTo(SkBits2Float(0x3ebd921a), SkBits2Float(0xc2a5ff94));
296path.cubicTo(SkBits2Float(0x3f0d545f), SkBits2Float(0xc2a5ff29), SkBits2Float(0x3f3bdfbd), SkBits2Float(0xc2a5fe71), SkBits2Float(0x3f6a6ab6), SkBits2Float(0xc2a5fd69));
297path.lineTo(SkBits2Float(0x3f297558), SkBits2Float(0xc26ffc43));
298path.cubicTo(SkBits2Float(0x3f07d00d), SkBits2Float(0xc26ffdc0), SkBits2Float(0x3ecc550f), SkBits2Float(0xc26ffecc), SkBits2Float(0x3e8909b7), SkBits2Float(0xc26fff65));
299path.lineTo(SkBits2Float(0x3ebd921a), SkBits2Float(0xc2a5ff94));
300path.close();
301
302 SkPath path2(path);
303 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
304}

◆ battleOp80()

static void battleOp80 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2181 of file PathOpsBattles.cpp.

2181 {
2182 SkPath path;
2183 path.setFillType((SkPathFillType) 0);
2184path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2185path.cubicTo(SkBits2Float(0x3e15a675), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e95a67a), SkBits2Float(0xc2a5ffcd), SkBits2Float(0x3ee07980), SkBits2Float(0xc2a5ff68));
2186path.lineTo(SkBits2Float(0x3ea245bb), SkBits2Float(0xc26fff25));
2187path.cubicTo(SkBits2Float(0x3e585de0), SkBits2Float(0xc26fffb9), SkBits2Float(0x3dd85f11), SkBits2Float(0xc2700000), SkBits2Float(0x3691e768), SkBits2Float(0xc2700000));
2188path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2189path.close();
2190
2191 SkPath path1(path);
2192 path.reset();
2193 path.setFillType((SkPathFillType) 0);
2194path.moveTo(SkBits2Float(0x3ee07a10), SkBits2Float(0xc2a5ff68));
2195path.cubicTo(SkBits2Float(0x3ee7f565), SkBits2Float(0xc2a5ff5d), SkBits2Float(0x3eef70d9), SkBits2Float(0xc2a5ff52), SkBits2Float(0x3ef6ec4d), SkBits2Float(0xc2a5ff47));
2196path.lineTo(SkBits2Float(0x3eb27fdb), SkBits2Float(0xc26ffef6));
2197path.cubicTo(SkBits2Float(0x3ead1768), SkBits2Float(0xc26fff07), SkBits2Float(0x3ea7aebe), SkBits2Float(0xc26fff17), SkBits2Float(0x3ea24612), SkBits2Float(0xc26fff26));
2198path.lineTo(SkBits2Float(0x3ee07a10), SkBits2Float(0xc2a5ff68));
2199path.close();
2200
2201 SkPath path2(path);
2202 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2203}

◆ battleOp81()

static void battleOp81 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2206 of file PathOpsBattles.cpp.

2206 {
2207 SkPath path;
2208 path.setFillType((SkPathFillType) 1);
2209path.moveTo(SkBits2Float(0x3691e768), SkBits2Float(0xc2700000));
2210path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2211path.cubicTo(SkBits2Float(0x3e15a675), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3e95a67a), SkBits2Float(0xc2a5ffcd), SkBits2Float(0x3ee07a10), SkBits2Float(0xc2a5ff68));
2212path.lineTo(SkBits2Float(0x3ef6ec4d), SkBits2Float(0xc2a5ff47));
2213path.lineTo(SkBits2Float(0x3eb27fdb), SkBits2Float(0xc26ffef6));
2214path.cubicTo(SkBits2Float(0x3ead1768), SkBits2Float(0xc26fff07), SkBits2Float(0x3ea7aebe), SkBits2Float(0xc26fff17), SkBits2Float(0x3ea245bb), SkBits2Float(0xc26fff25));
2215path.cubicTo(SkBits2Float(0x3e585de0), SkBits2Float(0xc26fffb9), SkBits2Float(0x3dd85f11), SkBits2Float(0xc2700000), SkBits2Float(0x3691e768), SkBits2Float(0xc2700000));
2216path.close();
2217
2218 SkPath path1(path);
2219 path.reset();
2220 path.setFillType((SkPathFillType) 0);
2221path.moveTo(SkBits2Float(0x3ef6ec9b), SkBits2Float(0xc2a5ff48));
2222path.cubicTo(SkBits2Float(0x3f3816c9), SkBits2Float(0xc2a5fe94), SkBits2Float(0x3f74b6e1), SkBits2Float(0xc2a5fd5b), SkBits2Float(0x3f98ab0b), SkBits2Float(0xc2a5fb9d));
2223path.lineTo(SkBits2Float(0x3f5cb973), SkBits2Float(0xc26ff9a8));
2224path.cubicTo(SkBits2Float(0x3f30e6e7), SkBits2Float(0xc26ffc2e), SkBits2Float(0x3f05138e), SkBits2Float(0xc26ffdf2), SkBits2Float(0x3eb27fc6), SkBits2Float(0xc26ffef7));
2225path.lineTo(SkBits2Float(0x3ef6ec9b), SkBits2Float(0xc2a5ff48));
2226path.close();
2227
2228 SkPath path2(path);
2229 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2230}

◆ battleOp82()

static void battleOp82 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2233 of file PathOpsBattles.cpp.

2233 {
2234 SkPath path;
2235 path.setFillType((SkPathFillType) 0);
2236path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2237path.cubicTo(SkBits2Float(0x3eff98a5), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f7f97b3), SkBits2Float(0xc2a5fdb1), SkBits2Float(0x3fbfaf38), SkBits2Float(0xc2a5f914));
2238path.lineTo(SkBits2Float(0x3f8a9112), SkBits2Float(0xc26ff600));
2239path.cubicTo(SkBits2Float(0x3f38c3e7), SkBits2Float(0xc26ffcab), SkBits2Float(0x3eb8c475), SkBits2Float(0xc2700000), SkBits2Float(0x35877d28), SkBits2Float(0xc2700000));
2240path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2241path.close();
2242
2243 SkPath path1(path);
2244 path.reset();
2245 path.setFillType((SkPathFillType) 0);
2246path.moveTo(SkBits2Float(0x3fbfaf15), SkBits2Float(0xc2a5f915));
2247path.cubicTo(SkBits2Float(0x3fc612b4), SkBits2Float(0xc2a5f8a0), SkBits2Float(0x3fcc7634), SkBits2Float(0xc2a5f824), SkBits2Float(0x3fd2d9ad), SkBits2Float(0xc2a5f7a2));
2248path.lineTo(SkBits2Float(0x3f986bef), SkBits2Float(0xc26ff3e6));
2249path.cubicTo(SkBits2Float(0x3f93cdb9), SkBits2Float(0xc26ff4a2), SkBits2Float(0x3f8f2f70), SkBits2Float(0xc26ff556), SkBits2Float(0x3f8a9121), SkBits2Float(0xc26ff601));
2250path.lineTo(SkBits2Float(0x3fbfaf15), SkBits2Float(0xc2a5f915));
2251path.close();
2252
2253 SkPath path2(path);
2254 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2255}

◆ battleOp83()

static void battleOp83 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2258 of file PathOpsBattles.cpp.

2258 {
2259 SkPath path;
2260 path.setFillType((SkPathFillType) 1);
2261path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2262path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2263path.cubicTo(SkBits2Float(0x3eff9875), SkBits2Float(0xc2a60000), SkBits2Float(0x3f7f9783), SkBits2Float(0xc2a5fdb1), SkBits2Float(0x3fbfaf14), SkBits2Float(0xc2a5f914));
2264path.lineTo(SkBits2Float(0x3fbfaf15), SkBits2Float(0xc2a5f915));
2265path.cubicTo(SkBits2Float(0x3fc612b4), SkBits2Float(0xc2a5f8a0), SkBits2Float(0x3fcc7634), SkBits2Float(0xc2a5f824), SkBits2Float(0x3fd2d9ad), SkBits2Float(0xc2a5f7a2));
2266path.lineTo(SkBits2Float(0x3f986bef), SkBits2Float(0xc26ff3e6));
2267path.cubicTo(SkBits2Float(0x3f93cdb9), SkBits2Float(0xc26ff4a2), SkBits2Float(0x3f8f2f70), SkBits2Float(0xc26ff556), SkBits2Float(0x3f8a9112), SkBits2Float(0xc26ff600));
2268path.cubicTo(SkBits2Float(0x3f38c3e7), SkBits2Float(0xc26ffcab), SkBits2Float(0x3eb8c475), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2269path.close();
2270
2271 SkPath path1(path);
2272 path.reset();
2273 path.setFillType((SkPathFillType) 0);
2274path.moveTo(SkBits2Float(0x3fd2d994), SkBits2Float(0xc2a5f7a1));
2275path.cubicTo(SkBits2Float(0x401d305c), SkBits2Float(0xc2a5ef69), SkBits2Float(0x4050ef71), SkBits2Float(0xc2a5e123), SkBits2Float(0x408252dc), SkBits2Float(0xc2a5ccd0));
2276path.lineTo(SkBits2Float(0x403c6b7d), SkBits2Float(0xc26fb5fe));
2277path.cubicTo(SkBits2Float(0x401709a2), SkBits2Float(0xc26fd362), SkBits2Float(0x3fe342dd), SkBits2Float(0xc26fe805), SkBits2Float(0x3f986be0), SkBits2Float(0xc26ff3e7));
2278path.lineTo(SkBits2Float(0x3fd2d994), SkBits2Float(0xc2a5f7a1));
2279path.close();
2280
2281 SkPath path2(path);
2282 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2283}

◆ battleOp84()

static void battleOp84 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2286 of file PathOpsBattles.cpp.

2286 {
2287 SkPath path;
2288 path.setFillType((SkPathFillType) 0);
2289path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2290path.cubicTo(SkBits2Float(0x3f541e8b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fd41d19), SkBits2Float(0xc2a5f9a6), SkBits2Float(0x401f1022), SkBits2Float(0xc2a5ecf2));
2291path.lineTo(SkBits2Float(0x3fe5f882), SkBits2Float(0xc26fe473));
2292path.cubicTo(SkBits2Float(0x3f9955cf), SkBits2Float(0xc26ff6d2), SkBits2Float(0x3f1956dc), SkBits2Float(0xc2700000), SkBits2Float(0xb5bb02d8), SkBits2Float(0xc2700000));
2293path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2294path.close();
2295
2296 SkPath path1(path);
2297 path.reset();
2298 path.setFillType((SkPathFillType) 0);
2299path.moveTo(SkBits2Float(0x401f1027), SkBits2Float(0xc2a5ecf2));
2300path.cubicTo(SkBits2Float(0x40245d21), SkBits2Float(0xc2a5ebac), SkBits2Float(0x4029aa04), SkBits2Float(0xc2a5ea57), SkBits2Float(0x402ef6d6), SkBits2Float(0xc2a5e8f1));
2301path.lineTo(SkBits2Float(0x3ffcf5ba), SkBits2Float(0xc26fdeaa));
2302path.cubicTo(SkBits2Float(0x3ff54c2d), SkBits2Float(0xc26fe0b0), SkBits2Float(0x3feda268), SkBits2Float(0xc26fe29e), SkBits2Float(0x3fe5f88e), SkBits2Float(0xc26fe474));
2303path.lineTo(SkBits2Float(0x401f1027), SkBits2Float(0xc2a5ecf2));
2304path.close();
2305
2306 SkPath path2(path);
2307 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2308}

◆ battleOp85()

static void battleOp85 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2311 of file PathOpsBattles.cpp.

2311 {
2312 SkPath path;
2313 path.setFillType((SkPathFillType) 1);
2314path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2315path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2316path.cubicTo(SkBits2Float(0x3f541e8b), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3fd41d19), SkBits2Float(0xc2a5f9a6), SkBits2Float(0x401f1027), SkBits2Float(0xc2a5ecf2));
2317path.cubicTo(SkBits2Float(0x40245d21), SkBits2Float(0xc2a5ebac), SkBits2Float(0x4029aa04), SkBits2Float(0xc2a5ea57), SkBits2Float(0x402ef6d6), SkBits2Float(0xc2a5e8f1));
2318path.lineTo(SkBits2Float(0x3ffcf5ba), SkBits2Float(0xc26fdeaa));
2319path.cubicTo(SkBits2Float(0x3ff54c2d), SkBits2Float(0xc26fe0b0), SkBits2Float(0x3feda268), SkBits2Float(0xc26fe29e), SkBits2Float(0x3fe5f882), SkBits2Float(0xc26fe473));
2320path.cubicTo(SkBits2Float(0x3f9955cf), SkBits2Float(0xc26ff6d2), SkBits2Float(0x3f1956dc), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2321path.close();
2322
2323 SkPath path1(path);
2324 path.reset();
2325 path.setFillType((SkPathFillType) 0);
2326path.moveTo(SkBits2Float(0x402ef6c3), SkBits2Float(0xc2a5e8f1));
2327path.cubicTo(SkBits2Float(0x40826d68), SkBits2Float(0xc2a5d24c), SkBits2Float(0x40ad550a), SkBits2Float(0xc2a5aafb), SkBits2Float(0x40d82890), SkBits2Float(0xc2a57308));
2328path.lineTo(SkBits2Float(0x409c425c), SkBits2Float(0xc26f3430));
2329path.cubicTo(SkBits2Float(0x407a99d8), SkBits2Float(0xc26f8515), SkBits2Float(0x403c91e6), SkBits2Float(0xc26fbded), SkBits2Float(0x3ffcf5ca), SkBits2Float(0xc26fdeaa));
2330path.lineTo(SkBits2Float(0x402ef6c3), SkBits2Float(0xc2a5e8f1));
2331path.close();
2332
2333 SkPath path2(path);
2334 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2335}

◆ battleOp86()

static void battleOp86 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2338 of file PathOpsBattles.cpp.

2338 {
2339 SkPath path;
2340 path.setFillType((SkPathFillType) 0);
2341path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2342path.cubicTo(SkBits2Float(0x40155bee), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40955364), SkBits2Float(0xc2a5cd99), SkBits2Float(0x40dfbd5f), SkBits2Float(0xc2a568f2));
2343path.lineTo(SkBits2Float(0x40a1bd53), SkBits2Float(0xc26f259d));
2344path.cubicTo(SkBits2Float(0x4057e483), SkBits2Float(0xc26fb724), SkBits2Float(0x3fd7f0d9), SkBits2Float(0xc2700000), SkBits2Float(0x3619fea3), SkBits2Float(0xc2700000));
2345path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2346path.close();
2347
2348 SkPath path1(path);
2349 path.reset();
2350 path.setFillType((SkPathFillType) 0);
2351path.moveTo(SkBits2Float(0x40dfbd5e), SkBits2Float(0xc2a568f3));
2352path.cubicTo(SkBits2Float(0x40e72e1b), SkBits2Float(0xc2a55ee2), SkBits2Float(0x40ee9e1c), SkBits2Float(0xc2a55452), SkBits2Float(0x40f60d62), SkBits2Float(0xc2a54941));
2353path.lineTo(SkBits2Float(0x40b1de84), SkBits2Float(0xc26ef7c9));
2354path.cubicTo(SkBits2Float(0x40ac7ea0), SkBits2Float(0xc26f07cb), SkBits2Float(0x40a71e37), SkBits2Float(0xc26f1712), SkBits2Float(0x40a1bd4f), SkBits2Float(0xc26f259f));
2355path.lineTo(SkBits2Float(0x40dfbd5e), SkBits2Float(0xc2a568f3));
2356path.close();
2357
2358 SkPath path2(path);
2359 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2360}

◆ battleOp87()

static void battleOp87 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2363 of file PathOpsBattles.cpp.

2363 {
2364 SkPath path;
2365 path.setFillType((SkPathFillType) 1);
2366path.moveTo(SkBits2Float(0x3619fea3), SkBits2Float(0xc2700000));
2367path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2368path.cubicTo(SkBits2Float(0x40155bee), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40955364), SkBits2Float(0xc2a5cd99), SkBits2Float(0x40dfbd5e), SkBits2Float(0xc2a568f3));
2369path.cubicTo(SkBits2Float(0x40e72e1b), SkBits2Float(0xc2a55ee2), SkBits2Float(0x40ee9e1c), SkBits2Float(0xc2a55452), SkBits2Float(0x40f60d62), SkBits2Float(0xc2a54941));
2370path.lineTo(SkBits2Float(0x40b1de84), SkBits2Float(0xc26ef7c9));
2371path.cubicTo(SkBits2Float(0x40ac7ea2), SkBits2Float(0xc26f07cb), SkBits2Float(0x40a71e3a), SkBits2Float(0xc26f1712), SkBits2Float(0x40a1bd54), SkBits2Float(0xc26f259f));
2372path.lineTo(SkBits2Float(0x40a1bd53), SkBits2Float(0xc26f259d));
2373path.cubicTo(SkBits2Float(0x4057e483), SkBits2Float(0xc26fb724), SkBits2Float(0x3fd7f0d9), SkBits2Float(0xc2700000), SkBits2Float(0x3619fea3), SkBits2Float(0xc2700000));
2374path.close();
2375
2376 SkPath path1(path);
2377 path.reset();
2378 path.setFillType((SkPathFillType) 0);
2379path.moveTo(SkBits2Float(0x40f60d69), SkBits2Float(0xc2a54941));
2380path.cubicTo(SkBits2Float(0x41374a21), SkBits2Float(0xc2a495d5), SkBits2Float(0x41731962), SkBits2Float(0xc2a35eca), SkBits2Float(0x419704b1), SkBits2Float(0xc2a1a64c));
2381path.lineTo(SkBits2Float(0x415a56f5), SkBits2Float(0xc269b5d4));
2382path.cubicTo(SkBits2Float(0x412fbbfb), SkBits2Float(0xc26c32af), SkBits2Float(0x41047f9a), SkBits2Float(0xc26df463), SkBits2Float(0x40b1de7e), SkBits2Float(0xc26ef7cb));
2383path.lineTo(SkBits2Float(0x40f60d69), SkBits2Float(0xc2a54941));
2384path.close();
2385
2386 SkPath path2(path);
2387 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2388}

◆ battleOp88()

static void battleOp88 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2391 of file PathOpsBattles.cpp.

2391 { // crashed
2392 SkPath path;
2393 path.setFillType((SkPathFillType) 0);
2394path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2395path.cubicTo(SkBits2Float(0x4059d383), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40d9b918), SkBits2Float(0xc2a594d0), SkBits2Float(0x4122e820), SkBits2Float(0xc2a4bf0c));
2396path.lineTo(SkBits2Float(0x40eb871c), SkBits2Float(0xc26e2ff8));
2397path.cubicTo(SkBits2Float(0x409d63e0), SkBits2Float(0xc26f6508), SkBits2Float(0x401d76fa), SkBits2Float(0xc2700000), SkBits2Float(0x35f7fd4a), SkBits2Float(0xc2700000));
2398path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2399path.close();
2400
2401 SkPath path1(path);
2402 path.reset();
2403 path.setFillType((SkPathFillType) 0);
2404path.moveTo(SkBits2Float(0x4122e81e), SkBits2Float(0xc2a4bf0c));
2405path.cubicTo(SkBits2Float(0x41284f3c), SkBits2Float(0xc2a4a9ac), SkBits2Float(0x412db549), SkBits2Float(0xc2a4933e), SkBits2Float(0x41331a33), SkBits2Float(0xc2a47bbf));
2406path.lineTo(SkBits2Float(0x410178be), SkBits2Float(0xc26dceac));
2407path.cubicTo(SkBits2Float(0x40fb24f7), SkBits2Float(0xc26df0a4), SkBits2Float(0x40f356d1), SkBits2Float(0xc26e1114), SkBits2Float(0x40eb871f), SkBits2Float(0xc26e2ff8));
2408path.lineTo(SkBits2Float(0x4122e81e), SkBits2Float(0xc2a4bf0c));
2409path.close();
2410
2411 SkPath path2(path);
2412 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2413}

◆ battleOp89()

static void battleOp89 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2415 of file PathOpsBattles.cpp.

2415 {
2416 SkPath path;
2417 path.setFillType((SkPathFillType) 0);
2418path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2419path.cubicTo(SkBits2Float(0x3dd41fb8), SkBits2Float(0xc2a5fffe), SkBits2Float(0x3e541e5b), SkBits2Float(0xc2a5ffe5), SkBits2Float(0x3e9f1657), SkBits2Float(0xc2a5ffb2));
2420path.lineTo(SkBits2Float(0x3e66012b), SkBits2Float(0xc26fff92));
2421path.cubicTo(SkBits2Float(0x3e1955e2), SkBits2Float(0xc26fffdc), SkBits2Float(0x3d99560b), SkBits2Float(0xc2700000), SkBits2Float(0x350f7780), SkBits2Float(0xc2700000));
2422path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2423path.close();
2424
2425 SkPath path1(path);
2426 path.reset();
2427 path.setFillType((SkPathFillType) 0);
2428path.moveTo(SkBits2Float(0x3e9f1626), SkBits2Float(0xc2a5ffb4));
2429path.cubicTo(SkBits2Float(0x3ea463a8), SkBits2Float(0xc2a5ffae), SkBits2Float(0x3ea9b10b), SkBits2Float(0xc2a5ffa8), SkBits2Float(0x3eaefe6d), SkBits2Float(0xc2a5ffa3));
2430path.lineTo(SkBits2Float(0x3e7d0144), SkBits2Float(0xc26fff7b));
2431path.cubicTo(SkBits2Float(0x3e75568f), SkBits2Float(0xc26fff84), SkBits2Float(0x3e6dac12), SkBits2Float(0xc26fff8c), SkBits2Float(0x3e660197), SkBits2Float(0xc26fff93));
2432path.lineTo(SkBits2Float(0x3e9f1626), SkBits2Float(0xc2a5ffb4));
2433path.close();
2434
2435 SkPath path2(path);
2436 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2437}

◆ battleOp9()

static void battleOp9 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 307 of file PathOpsBattles.cpp.

307 { // crashes
308 SkPath path;
309 path.setFillType((SkPathFillType) 0);
310path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
311path.cubicTo(SkBits2Float(0x3ecc43bf), SkBits2Float(0xc2a60000), SkBits2Float(0x3f4c4385), SkBits2Float(0xc2a5fe87), SkBits2Float(0x3f993163), SkBits2Float(0xc2a5fb95));
312path.lineTo(SkBits2Float(0x3f5d7bc4), SkBits2Float(0xc26ff99d));
313path.cubicTo(SkBits2Float(0x3f13a919), SkBits2Float(0xc26ffdde), SkBits2Float(0x3e93a998), SkBits2Float(0xc26fffff), SkBits2Float(0x367b7ed0), SkBits2Float(0xc26fffff));
314path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
315path.close();
316
317 SkPath path1(path);
318 path.reset();
319 path.setFillType((SkPathFillType) 0);
320path.moveTo(SkBits2Float(0x3f993156), SkBits2Float(0xc2a5fb95));
321path.cubicTo(SkBits2Float(0x3f9e4c7a), SkBits2Float(0xc2a5fb49), SkBits2Float(0x3fa36794), SkBits2Float(0xc2a5fafa), SkBits2Float(0x3fa882aa), SkBits2Float(0xc2a5faa7));
322path.lineTo(SkBits2Float(0x3f73a149), SkBits2Float(0xc26ff845));
323path.cubicTo(SkBits2Float(0x3f6c3f64), SkBits2Float(0xc26ff8bf), SkBits2Float(0x3f64dd9d), SkBits2Float(0xc26ff931), SkBits2Float(0x3f5d7bcf), SkBits2Float(0xc26ff99f));
324path.lineTo(SkBits2Float(0x3f993156), SkBits2Float(0xc2a5fb95));
325path.close();
326
327 SkPath path2(path);
328 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
329}

◆ battleOp90()

static void battleOp90 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2440 of file PathOpsBattles.cpp.

2440 {
2441 SkPath path;
2442 path.setFillType((SkPathFillType) 1);
2443path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2444path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2445path.cubicTo(SkBits2Float(0x3dd41f74), SkBits2Float(0xc2a5fffe), SkBits2Float(0x3e541e17), SkBits2Float(0xc2a5ffe5), SkBits2Float(0x3e9f1624), SkBits2Float(0xc2a5ffb2));
2446path.lineTo(SkBits2Float(0x3e9f1626), SkBits2Float(0xc2a5ffb4));
2447path.cubicTo(SkBits2Float(0x3ea463a8), SkBits2Float(0xc2a5ffae), SkBits2Float(0x3ea9b10b), SkBits2Float(0xc2a5ffa8), SkBits2Float(0x3eaefe6d), SkBits2Float(0xc2a5ffa3));
2448path.lineTo(SkBits2Float(0x3e7d0144), SkBits2Float(0xc26fff7b));
2449path.cubicTo(SkBits2Float(0x3e75568f), SkBits2Float(0xc26fff84), SkBits2Float(0x3e6dac12), SkBits2Float(0xc26fff8c), SkBits2Float(0x3e66012b), SkBits2Float(0xc26fff92));
2450path.cubicTo(SkBits2Float(0x3e1955e2), SkBits2Float(0xc26fffdc), SkBits2Float(0x3d99560b), SkBits2Float(0xc2700000), SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2451path.close();
2452
2453 SkPath path1(path);
2454 path.reset();
2455 path.setFillType((SkPathFillType) 0);
2456path.moveTo(SkBits2Float(0x3eaefebc), SkBits2Float(0xc2a5ffa4));
2457path.cubicTo(SkBits2Float(0x3f0276b7), SkBits2Float(0xc2a5ff4a), SkBits2Float(0x3f2d6dea), SkBits2Float(0xc2a5feac), SkBits2Float(0x3f5864cc), SkBits2Float(0xc2a5fdcd));
2458path.lineTo(SkBits2Float(0x3f1c6df6), SkBits2Float(0xc26ffcd0));
2459path.cubicTo(SkBits2Float(0x3efabdec), SkBits2Float(0xc26ffe15), SkBits2Float(0x3ebc9f78), SkBits2Float(0xc26ffef9), SkBits2Float(0x3e7d0190), SkBits2Float(0xc26fff7c));
2460path.lineTo(SkBits2Float(0x3eaefebc), SkBits2Float(0xc2a5ffa4));
2461path.close();
2462
2463 SkPath path2(path);
2464 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2465}

◆ battleOp91()

static void battleOp91 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2468 of file PathOpsBattles.cpp.

2468 { // crashed
2469 SkPath path;
2470 path.setFillType((SkPathFillType) 0);
2471path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2472path.cubicTo(SkBits2Float(0x3ec1e1ad), SkBits2Float(0xc2a5ffff), SkBits2Float(0x3f41e136), SkBits2Float(0xc2a5feac), SkBits2Float(0x3f9167c6), SkBits2Float(0xc2a5fc05));
2473path.lineTo(SkBits2Float(0x3f523979), SkBits2Float(0xc26ffa3f));
2474path.cubicTo(SkBits2Float(0x3f0c2737), SkBits2Float(0xc26ffe17), SkBits2Float(0x3e8c2756), SkBits2Float(0xc2700000), SkBits2Float(0xb5b74260), SkBits2Float(0xc2700000));
2475path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2476path.close();
2477
2478 SkPath path1(path);
2479 path.reset();
2480 path.setFillType((SkPathFillType) 0);
2481path.moveTo(SkBits2Float(0x3f9167c1), SkBits2Float(0xc2a5fc05));
2482path.cubicTo(SkBits2Float(0x3f96406f), SkBits2Float(0xc2a5fbc1), SkBits2Float(0x3f9b1917), SkBits2Float(0xc2a5fb79), SkBits2Float(0x3f9ff1bc), SkBits2Float(0xc2a5fb2f));
2483path.lineTo(SkBits2Float(0x3f673ed7), SkBits2Float(0xc26ff909));
2484path.cubicTo(SkBits2Float(0x3f603cf4), SkBits2Float(0xc26ff977), SkBits2Float(0x3f593b3c), SkBits2Float(0xc26ff9dd), SkBits2Float(0x3f52397f), SkBits2Float(0xc26ffa3f));
2485path.lineTo(SkBits2Float(0x3f9167c1), SkBits2Float(0xc2a5fc05));
2486path.close();
2487
2488 SkPath path2(path);
2489 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2490}

◆ battleOp92()

static void battleOp92 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2492 of file PathOpsBattles.cpp.

2492 {
2493 SkPath path;
2494 path.setFillType((SkPathFillType) 0);
2495path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2496path.cubicTo(SkBits2Float(0x3e2c5962), SkBits2Float(0xc2a60000), SkBits2Float(0x3eac58ef), SkBits2Float(0xc2a5ffbd), SkBits2Float(0x3f014269), SkBits2Float(0xc2a5ff37));
2497path.lineTo(SkBits2Float(0x3ebae1ca), SkBits2Float(0xc26ffedd));
2498path.cubicTo(SkBits2Float(0x3e792d51), SkBits2Float(0xc26fff9f), SkBits2Float(0x3df92dfa), SkBits2Float(0xc2700000), SkBits2Float(0x36163ed0), SkBits2Float(0xc2700000));
2499path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2500path.close();
2501
2502 SkPath path1(path);
2503 path.reset();
2504 path.setFillType((SkPathFillType) 0);
2505path.moveTo(SkBits2Float(0x3f014292), SkBits2Float(0xc2a5ff37));
2506path.cubicTo(SkBits2Float(0x3f0591a2), SkBits2Float(0xc2a5ff28), SkBits2Float(0x3f09e09b), SkBits2Float(0xc2a5ff1a), SkBits2Float(0x3f0e2f92), SkBits2Float(0xc2a5ff0b));
2507path.lineTo(SkBits2Float(0x3ecd91e5), SkBits2Float(0xc26ffea0));
2508path.cubicTo(SkBits2Float(0x3ec75718), SkBits2Float(0xc26ffeb6), SkBits2Float(0x3ec11c70), SkBits2Float(0xc26ffeca), SkBits2Float(0x3ebae1c7), SkBits2Float(0xc26ffedd));
2509path.lineTo(SkBits2Float(0x3f014292), SkBits2Float(0xc2a5ff37));
2510path.close();
2511
2512 SkPath path2(path);
2513 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2514}

◆ battleOp93()

static void battleOp93 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2517 of file PathOpsBattles.cpp.

2517 {
2518 SkPath path;
2519 path.setFillType((SkPathFillType) 1);
2520path.moveTo(SkBits2Float(0x36163ed0), SkBits2Float(0xc2700000));
2521path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2522path.quadTo(SkBits2Float(0x3e81430a), SkBits2Float(0xc2a60000), SkBits2Float(0x3f014292), SkBits2Float(0xc2a5ff37));
2523path.cubicTo(SkBits2Float(0x3f0591a2), SkBits2Float(0xc2a5ff28), SkBits2Float(0x3f09e09b), SkBits2Float(0xc2a5ff1a), SkBits2Float(0x3f0e2f92), SkBits2Float(0xc2a5ff0b));
2524path.lineTo(SkBits2Float(0x3ecd91e5), SkBits2Float(0xc26ffea0));
2525path.cubicTo(SkBits2Float(0x3ec75719), SkBits2Float(0xc26ffeb6), SkBits2Float(0x3ec11c72), SkBits2Float(0xc26ffeca), SkBits2Float(0x3ebae1ca), SkBits2Float(0xc26ffedd));
2526path.quadTo(SkBits2Float(0x3e3ae230), SkBits2Float(0xc2700000), SkBits2Float(0x36163ed0), SkBits2Float(0xc2700000));
2527path.close();
2528
2529 SkPath path1(path);
2530 path.reset();
2531 path.setFillType((SkPathFillType) 0);
2532path.moveTo(SkBits2Float(0x3f0e2f94), SkBits2Float(0xc2a5ff0c));
2533path.cubicTo(SkBits2Float(0x3f5401b9), SkBits2Float(0xc2a5fe1c), SkBits2Float(0x3f8ce9a3), SkBits2Float(0xc2a5fc7d), SkBits2Float(0x3fafd1bd), SkBits2Float(0xc2a5fa2d));
2534path.lineTo(SkBits2Float(0x3f7e3238), SkBits2Float(0xc26ff796));
2535path.cubicTo(SkBits2Float(0x3f4bbaca), SkBits2Float(0xc26ffaee), SkBits2Float(0x3f194226), SkBits2Float(0xc26ffd46), SkBits2Float(0x3ecd9202), SkBits2Float(0xc26ffea0));
2536path.lineTo(SkBits2Float(0x3f0e2f94), SkBits2Float(0xc2a5ff0c));
2537path.close();
2538
2539 SkPath path2(path);
2540 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2541}

◆ battleOp94()

static void battleOp94 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2544 of file PathOpsBattles.cpp.

2544 {
2545 SkPath path;
2546 path.setFillType((SkPathFillType) 0);
2547path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2548path.cubicTo(SkBits2Float(0x3f167e4a), SkBits2Float(0xc2a60000), SkBits2Float(0x3f967d97), SkBits2Float(0xc2a5fcce), SkBits2Float(0x3fe1b83b), SkBits2Float(0xc2a5f668));
2549path.lineTo(SkBits2Float(0x3fa32ba2), SkBits2Float(0xc26ff222));
2550path.cubicTo(SkBits2Float(0x3f599370), SkBits2Float(0xc26ffb61), SkBits2Float(0x3ed9943c), SkBits2Float(0xc2700000), SkBits2Float(0x3437e940), SkBits2Float(0xc2700000));
2551path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2552path.close();
2553
2554 SkPath path1(path);
2555 path.reset();
2556 path.setFillType((SkPathFillType) 0);
2557path.moveTo(SkBits2Float(0x3fe1b817), SkBits2Float(0xc2a5f668));
2558path.cubicTo(SkBits2Float(0x3fe93dd6), SkBits2Float(0xc2a5f5c4), SkBits2Float(0x3ff0c3a7), SkBits2Float(0xc2a5f518), SkBits2Float(0x3ff8496b), SkBits2Float(0xc2a5f464));
2559path.lineTo(SkBits2Float(0x3fb37c11), SkBits2Float(0xc26fef38));
2560path.cubicTo(SkBits2Float(0x3fae0bf9), SkBits2Float(0xc26ff03c), SkBits2Float(0x3fa89bd2), SkBits2Float(0xc26ff134), SkBits2Float(0x3fa32ba2), SkBits2Float(0xc26ff222));
2561path.lineTo(SkBits2Float(0x3fe1b817), SkBits2Float(0xc2a5f668));
2562path.close();
2563
2564 SkPath path2(path);
2565 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2566}

◆ battleOp95()

static void battleOp95 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2569 of file PathOpsBattles.cpp.

2569 {
2570 SkPath path;
2571 path.setFillType((SkPathFillType) 1);
2572path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xc2700000));
2573path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2574path.cubicTo(SkBits2Float(0x3f167e32), SkBits2Float(0xc2a60000), SkBits2Float(0x3f967d7f), SkBits2Float(0xc2a5fcce), SkBits2Float(0x3fe1b817), SkBits2Float(0xc2a5f668));
2575
2576 SkPath path1(path);
2577 path.reset();
2578 path.setFillType((SkPathFillType) 0);
2579path.moveTo(SkBits2Float(0x3ff8497f), SkBits2Float(0xc2a5f465));
2580path.cubicTo(SkBits2Float(0x40391895), SkBits2Float(0xc2a5e8fe), SkBits2Float(0x407604f1), SkBits2Float(0xc2a5d533), SkBits2Float(0x40997177), SkBits2Float(0xc2a5b905));
2581path.lineTo(SkBits2Float(0x405dd87f), SkBits2Float(0xc26f9962));
2582path.cubicTo(SkBits2Float(0x4031d867), SkBits2Float(0xc26fc221), SkBits2Float(0x4005cdec), SkBits2Float(0xc26fdebf), SkBits2Float(0x3fb37c22), SkBits2Float(0xc26fef39));
2583path.lineTo(SkBits2Float(0x3ff8497f), SkBits2Float(0xc2a5f465));
2584path.close();
2585
2586 SkPath path2(path);
2587 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2588}

◆ battleOp96()

static void battleOp96 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2591 of file PathOpsBattles.cpp.

2591 {
2592 SkPath path;
2593 path.setFillType((SkPathFillType) 0);
2594path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2595path.cubicTo(SkBits2Float(0x3fa966bb), SkBits2Float(0xc2a5ffff), SkBits2Float(0x402963a4), SkBits2Float(0xc2a5efcb), SkBits2Float(0x407dfe39), SkBits2Float(0xc2a5cf64));
2596path.lineTo(SkBits2Float(0x40379c05), SkBits2Float(0xc26fb9ba));
2597path.cubicTo(SkBits2Float(0x3ff4e689), SkBits2Float(0xc26fe893), SkBits2Float(0x3f74eb1f), SkBits2Float(0xc2700000), SkBits2Float(0x363f7e94), SkBits2Float(0xc2700000));
2598path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2599path.close();
2600
2601 SkPath path1(path);
2602 path.reset();
2603 path.setFillType((SkPathFillType) 0);
2604path.moveTo(SkBits2Float(0x407dfe3a), SkBits2Float(0xc2a5cf65));
2605path.cubicTo(SkBits2Float(0x40833a01), SkBits2Float(0xc2a5cc27), SkBits2Float(0x408774bf), SkBits2Float(0xc2a5c8c0), SkBits2Float(0x408baf5a), SkBits2Float(0xc2a5c52f));
2606path.lineTo(SkBits2Float(0x4049f448), SkBits2Float(0xc26faaf9));
2607path.cubicTo(SkBits2Float(0x4043d713), SkBits2Float(0xc26fb022), SkBits2Float(0x403db99f), SkBits2Float(0xc26fb50d), SkBits2Float(0x40379bfe), SkBits2Float(0xc26fb9bc));
2608path.lineTo(SkBits2Float(0x407dfe3a), SkBits2Float(0xc2a5cf65));
2609path.close();
2610
2611 SkPath path2(path);
2612 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2613}

◆ battleOp97()

static void battleOp97 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2616 of file PathOpsBattles.cpp.

2616 {
2617 SkPath path;
2618 path.setFillType((SkPathFillType) 1);
2619path.moveTo(SkBits2Float(0x363f7e94), SkBits2Float(0xc2700000));
2620path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2621path.cubicTo(SkBits2Float(0x3fa966bb), SkBits2Float(0xc2a5ffff), SkBits2Float(0x402963a4), SkBits2Float(0xc2a5efcb), SkBits2Float(0x407dfe3a), SkBits2Float(0xc2a5cf65));
2622path.cubicTo(SkBits2Float(0x40833a01), SkBits2Float(0xc2a5cc27), SkBits2Float(0x408774bf), SkBits2Float(0xc2a5c8c0), SkBits2Float(0x408baf5a), SkBits2Float(0xc2a5c52f));
2623path.lineTo(SkBits2Float(0x4049f448), SkBits2Float(0xc26faaf9));
2624path.cubicTo(SkBits2Float(0x4043d716), SkBits2Float(0xc26fb022), SkBits2Float(0x403db9a5), SkBits2Float(0xc26fb50d), SkBits2Float(0x40379c07), SkBits2Float(0xc26fb9bc));
2625path.lineTo(SkBits2Float(0x40379c05), SkBits2Float(0xc26fb9ba));
2626path.cubicTo(SkBits2Float(0x3ff4e689), SkBits2Float(0xc26fe893), SkBits2Float(0x3f74eb1f), SkBits2Float(0xc2700000), SkBits2Float(0x363f7e94), SkBits2Float(0xc2700000));
2627path.close();
2628
2629 SkPath path1(path);
2630 path.reset();
2631 path.setFillType((SkPathFillType) 0);
2632path.moveTo(SkBits2Float(0x408baf5c), SkBits2Float(0xc2a5c530));
2633path.cubicTo(SkBits2Float(0x40d03963), SkBits2Float(0xc2a58b6e), SkBits2Float(0x410a4c7d), SkBits2Float(0xc2a52732), SkBits2Float(0x412c535f), SkBits2Float(0xc2a498b2));
2634path.lineTo(SkBits2Float(0x40f9253d), SkBits2Float(0xc26df886));
2635path.cubicTo(SkBits2Float(0x40c7f32d), SkBits2Float(0xc26ec68d), SkBits2Float(0x409685fb), SkBits2Float(0xc26f577a), SkBits2Float(0x4049f441), SkBits2Float(0xc26faafa));
2636path.lineTo(SkBits2Float(0x408baf5c), SkBits2Float(0xc2a5c530));
2637path.close();
2638
2639 SkPath path2(path);
2640 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2641}

◆ battleOp98()

static void battleOp98 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2644 of file PathOpsBattles.cpp.

2644 {
2645 SkPath path;
2646 path.setFillType((SkPathFillType) 0);
2647path.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2648path.cubicTo(SkBits2Float(0x40155bee), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40955364), SkBits2Float(0xc2a5cd99), SkBits2Float(0x40dfbd5f), SkBits2Float(0xc2a568f2));
2649path.lineTo(SkBits2Float(0x40a1bd53), SkBits2Float(0xc26f259d));
2650path.cubicTo(SkBits2Float(0x4057e483), SkBits2Float(0xc26fb724), SkBits2Float(0x3fd7f0d9), SkBits2Float(0xc2700000), SkBits2Float(0x3619fea3), SkBits2Float(0xc2700000));
2651path.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
2652path.close();
2653
2654 SkPath path1(path);
2655 path.reset();
2656 path.setFillType((SkPathFillType) 0);
2657path.moveTo(SkBits2Float(0x40dfbd5e), SkBits2Float(0xc2a568f3));
2658path.cubicTo(SkBits2Float(0x40e72e1b), SkBits2Float(0xc2a55ee2), SkBits2Float(0x40ee9e1c), SkBits2Float(0xc2a55452), SkBits2Float(0x40f60d62), SkBits2Float(0xc2a54941));
2659path.lineTo(SkBits2Float(0x40b1de84), SkBits2Float(0xc26ef7c9));
2660path.cubicTo(SkBits2Float(0x40ac7ea0), SkBits2Float(0xc26f07cb), SkBits2Float(0x40a71e37), SkBits2Float(0xc26f1712), SkBits2Float(0x40a1bd4f), SkBits2Float(0xc26f259f));
2661path.lineTo(SkBits2Float(0x40dfbd5e), SkBits2Float(0xc2a568f3));
2662path.close();
2663
2664 SkPath path2(path);
2665 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2666}

◆ battleOp99()

static void battleOp99 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2669 of file PathOpsBattles.cpp.

2669 {
2670 SkPath path;
2671 path.setFillType((SkPathFillType) 1);
2672path.moveTo(SkBits2Float(0x3619fea3), SkBits2Float(0xc2700000));
2673path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
2674path.cubicTo(SkBits2Float(0x40155bee), SkBits2Float(0xc2a5ffff), SkBits2Float(0x40955364), SkBits2Float(0xc2a5cd99), SkBits2Float(0x40dfbd5e), SkBits2Float(0xc2a568f3));
2675path.cubicTo(SkBits2Float(0x40e72e1b), SkBits2Float(0xc2a55ee2), SkBits2Float(0x40ee9e1c), SkBits2Float(0xc2a55452), SkBits2Float(0x40f60d62), SkBits2Float(0xc2a54941));
2676path.lineTo(SkBits2Float(0x40b1de84), SkBits2Float(0xc26ef7c9));
2677path.cubicTo(SkBits2Float(0x40ac7ea2), SkBits2Float(0xc26f07cb), SkBits2Float(0x40a71e3a), SkBits2Float(0xc26f1712), SkBits2Float(0x40a1bd54), SkBits2Float(0xc26f259f));
2678path.lineTo(SkBits2Float(0x40a1bd53), SkBits2Float(0xc26f259d));
2679path.cubicTo(SkBits2Float(0x4057e483), SkBits2Float(0xc26fb724), SkBits2Float(0x3fd7f0d9), SkBits2Float(0xc2700000), SkBits2Float(0x3619fea3), SkBits2Float(0xc2700000));
2680path.close();
2681
2682 SkPath path1(path);
2683 path.reset();
2684 path.setFillType((SkPathFillType) 0);
2685path.moveTo(SkBits2Float(0x40f60d69), SkBits2Float(0xc2a54941));
2686path.cubicTo(SkBits2Float(0x41374a21), SkBits2Float(0xc2a495d5), SkBits2Float(0x41731962), SkBits2Float(0xc2a35eca), SkBits2Float(0x419704b1), SkBits2Float(0xc2a1a64c));
2687path.lineTo(SkBits2Float(0x415a56f5), SkBits2Float(0xc269b5d4));
2688path.cubicTo(SkBits2Float(0x412fbbfb), SkBits2Float(0xc26c32af), SkBits2Float(0x41047f9a), SkBits2Float(0xc26df463), SkBits2Float(0x40b1de7e), SkBits2Float(0xc26ef7cb));
2689path.lineTo(SkBits2Float(0x40f60d69), SkBits2Float(0xc2a54941));
2690path.close();
2691
2692 SkPath path2(path);
2693 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
2694}

◆ DEF_TEST()

DEF_TEST ( PathOpsBattle  ,
reporter   
)

Definition at line 11130 of file PathOpsBattles.cpp.

11130 {
11131 RunTestSet(reporter, tests, testCount, firstTest, nullptr, stopTest, runReverse);
11132}
testCount
static const size_t testCount
Definition: PathOpsBattles.cpp:11126
stopTest
static void(* stopTest)(skiatest::Reporter *, const char *filename)
Definition: PathOpsBattles.cpp:10693
tests
static struct TestDesc tests[]
Definition: PathOpsBattles.cpp:10695
firstTest
static void(* firstTest)(skiatest::Reporter *, const char *filename)
Definition: PathOpsBattles.cpp:10692
runReverse
static bool runReverse
Definition: PathOpsBattles.cpp:11128
RunTestSet
void RunTestSet(skiatest::Reporter *reporter, TestDesc tests[], size_t count, void(*firstTest)(skiatest::Reporter *, const char *filename), void(*skipTest)(skiatest::Reporter *, const char *filename), void(*stopTest)(skiatest::Reporter *, const char *filename), bool reverse)
Definition: PathOpsExtendedTest.cpp:691

◆ issue414409()

static void issue414409 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 20 of file PathOpsBattles.cpp.

20 {
21 SkPath path1, path2;
22
23 // one fill 1
24 path1.moveTo(9.53595e-07f, -60);
25 path1.lineTo(5.08228e-15f, -83);
26 path1.cubicTo(32.8673f, -83, 62.6386f, -63.6055f, 75.9208f, -33.5416f);
27 path1.cubicTo(89.2029f, -3.47759f, 83.4937f, 31.5921f, 61.3615f, 55.8907f);
28 path1.lineTo(46.9383f, 68.4529f);
29 path1.lineTo(33.9313f, 49.484f);
30 path1.cubicTo(37.7451f, 46.8689f, 41.2438f, 43.8216f, 44.3577f, 40.4029f);
31 path1.lineTo(44.3577f, 40.4029f);
32 path1.cubicTo(60.3569f, 22.8376f, 64.4841f, -2.51392f, 54.8825f, -24.2469f);
33 path1.cubicTo(45.2809f, -45.9799f, 23.7595f, -60, 9.53595e-07f, -60);
34 path1.close();
35
36 // two fill 0
37 path2.moveTo(46.9383f, 68.4529f);
38 path2.cubicTo(17.5117f, 88.6307f, -21.518f, 87.7442f, -49.9981f, 66.251f);
39 path2.cubicTo(-78.4781f, 44.7578f, -90.035f, 7.46781f, -78.7014f, -26.3644f);
40 path2.cubicTo(-67.3679f, -60.1967f, -35.6801f, -83, -1.48383e-06f, -83);
41 path2.lineTo(4.22689e-14f, -60);
42 path2.cubicTo(-25.7929f, -60, -48.6997f, -43.5157f, -56.8926f, -19.0586f);
43 path2.cubicTo(-65.0855f, 5.39842f, -56.7312f, 32.355f, -36.1432f, 47.8923f);
44 path2.cubicTo(-15.5552f, 63.4296f, 12.6591f, 64.0704f, 33.9313f, 49.484f);
45 path2.lineTo(46.9383f, 68.4529f);
46 path2.close();
47 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
48}
kUnion_SkPathOp
@ kUnion_SkPathOp
union (inclusive-or) the two paths
Definition: SkPathOps.h:25
SkPath::moveTo
SkPath & moveTo(SkScalar x, SkScalar y)
Definition: SkPath.cpp:688
SkPath::lineTo
SkPath & lineTo(SkScalar x, SkScalar y)
Definition: SkPath.cpp:728
SkPath::cubicTo
SkPath & cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
Definition: SkPath.cpp:799
SkPath::close
SkPath & close()
Definition: SkPath.cpp:823

◆ issue414409b()

static void issue414409b ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 50 of file PathOpsBattles.cpp.

50 {
51 SkPath path1, path2;
52 // one fill=0 op=2
53path1.setFillType((SkPathFillType) 0);
54path1.moveTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
55path1.cubicTo(SkBits2Float(0x41f12edc), SkBits2Float(0xc2a5ffff), SkBits2Float(0x4267b362), SkBits2Float(0xc2854e1f), SkBits2Float(0x42911faa), SkBits2Float(0xc2212f3b));
56path1.cubicTo(SkBits2Float(0x42ae65a2), SkBits2Float(0xc15f08de), SkBits2Float(0x42acc913), SkBits2Float(0x41923f59), SkBits2Float(0x428ce9f0), SkBits2Float(0x422f7dc4));
57path1.lineTo(SkBits2Float(0x424bbb16), SkBits2Float(0x41fdb8ed));
58path1.cubicTo(SkBits2Float(0x4279cf6e), SkBits2Float(0x41537137), SkBits2Float(0x427c23ea), SkBits2Float(0xc1213ad2), SkBits2Float(0x4251d142), SkBits2Float(0xc1e909ae));
59path1.cubicTo(SkBits2Float(0x42277e9a), SkBits2Float(0xc240baf8), SkBits2Float(0x41ae5968), SkBits2Float(0xc2700000), SkBits2Float(0x3697ff52), SkBits2Float(0xc2700000));
60path1.lineTo(SkBits2Float(0x27b71bcd), SkBits2Float(0xc2a60000));
61path1.close();
62
63path2.setFillType((SkPathFillType) 1);
64path2.moveTo(SkBits2Float(0x428ce9ef), SkBits2Float(0x422f7dc6));
65path2.cubicTo(SkBits2Float(0x4286af43), SkBits2Float(0x42437fa7), SkBits2Float(0x427ed0d6), SkBits2Float(0x42561f5a), SkBits2Float(0x426e69d2), SkBits2Float(0x42670c39));
66path2.lineTo(SkBits2Float(0x422c58d6), SkBits2Float(0x422705c1));
67path2.cubicTo(SkBits2Float(0x42383446), SkBits2Float(0x421ac98f), SkBits2Float(0x4242b98a), SkBits2Float(0x420d5308), SkBits2Float(0x424bbb17), SkBits2Float(0x41fdb8ee));
68path2.lineTo(SkBits2Float(0x428ce9ef), SkBits2Float(0x422f7dc6));
69path2.close();
70 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
71}
SkPath::setFillType
void setFillType(SkPathFillType ft)
Definition: SkPath.h:235

◆ issue414409c()

static void issue414409c ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 73 of file PathOpsBattles.cpp.

73 {
74 SkPath path1, path2;
75path1.setFillType((SkPathFillType) 1);
76path1.moveTo(SkBits2Float(0x36961ef0), SkBits2Float(0xc2700000));
77path1.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xc2a60000));
78path1.cubicTo(SkBits2Float(0x3df86648), SkBits2Float(0xc2a60000), SkBits2Float(0x3e786777), SkBits2Float(0xc2a5ffdc), SkBits2Float(0x3eba4dc2), SkBits2Float(0xc2a5ff96));
79path1.lineTo(SkBits2Float(0x3eba4dc3), SkBits2Float(0xc2a5ff97));
80path1.cubicTo(SkBits2Float(0x3ec08370), SkBits2Float(0xc2a5ff8f), SkBits2Float(0x3ec6b964), SkBits2Float(0xc2a5ff88), SkBits2Float(0x3eccef58), SkBits2Float(0xc2a5ff80));
81path1.lineTo(SkBits2Float(0x3e942522), SkBits2Float(0xc26fff49));
82path1.cubicTo(SkBits2Float(0x3e8fa7da), SkBits2Float(0xc26fff56), SkBits2Float(0x3e8b2acd), SkBits2Float(0xc26fff61), SkBits2Float(0x3e86adc0), SkBits2Float(0xc26fff6b));
83path1.lineTo(SkBits2Float(0x3e86ad6a), SkBits2Float(0xc26fff69));
84path1.cubicTo(SkBits2Float(0x3e3391e9), SkBits2Float(0xc26fffce), SkBits2Float(0x3db3931e), SkBits2Float(0xc2700000), SkBits2Float(0x36961ef0), SkBits2Float(0xc2700000));
85path1.close();
86
87path2.setFillType((SkPathFillType) 0);
88path2.moveTo(SkBits2Float(0x3eccef1a), SkBits2Float(0xc2a5ff81));
89path2.cubicTo(SkBits2Float(0x3f18c8a9), SkBits2Float(0xc2a5ff04), SkBits2Float(0x3f4b19b0), SkBits2Float(0xc2a5fe2d), SkBits2Float(0x3f7d6a37), SkBits2Float(0xc2a5fcfa));
90path2.lineTo(SkBits2Float(0x3f3730f2), SkBits2Float(0xc26ffba1));
91path2.cubicTo(SkBits2Float(0x3f12d1c8), SkBits2Float(0xc26ffd5d), SkBits2Float(0x3edce4b4), SkBits2Float(0xc26ffe95), SkBits2Float(0x3e942577), SkBits2Float(0xc26fff49));
92path2.lineTo(SkBits2Float(0x3eccef1a), SkBits2Float(0xc2a5ff81));
93path2.close();
94
95testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
96}

Variable Documentation

◆ firstTest

void(* firstTest) (skiatest::Reporter *, const char *filename) ( skiatest::Reporter *  ,
const char *  filename 
) = battleOp183
static

Definition at line 10692 of file PathOpsBattles.cpp.

◆ runReverse

bool runReverse = false
static

Definition at line 11128 of file PathOpsBattles.cpp.

◆ stopTest

void(* stopTest) (skiatest::Reporter *, const char *filename) ( skiatest::Reporter *  ,
const char *  filename 
) = nullptr
static

Definition at line 10693 of file PathOpsBattles.cpp.

◆ testCount

const size_t testCount = std::size(tests)
static

Definition at line 11126 of file PathOpsBattles.cpp.

◆ tests

struct TestDesc tests[]
static

Definition at line 10695 of file PathOpsBattles.cpp.

Generated on Sun Jun 23 2024 21:57:32 for Flutter Engine by doxygen 1.9.4