Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
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
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:678
SkPath::lineTo
SkPath & lineTo(SkScalar x, SkScalar y)
Definition SkPath.cpp:718
SkPath::cubicTo
SkPath & cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
Definition SkPath.cpp:789
SkPath::close
SkPath & close()
Definition SkPath.cpp:813

◆ 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.

10695 {
10696 TEST(battleOp1),
10697 TEST(battleOp2),
10698 TEST(battleOp3),
10699 TEST(battleOp4),
10700 TEST(battleOp5),
10701 TEST(battleOp6),
10702 TEST(battleOp7),
10703 TEST(battleOp8),
10704 TEST(battleOp9),
10705 TEST(battleOp10),
10706
10707 TEST(battleOp11),
10708 TEST(battleOp12),
10709 TEST(battleOp13),
10710 TEST(battleOp14),
10711 TEST(battleOp15),
10712 TEST(battleOp16),
10713 TEST(battleOp17),
10714 TEST(battleOp18),
10715 TEST(battleOp19),
10716 TEST(battleOp20),
10717
10718 TEST(battleOp21),
10719 TEST(battleOp22),
10720 TEST(battleOp23),
10721 TEST(battleOp24),
10722 TEST(battleOp25),
10723 TEST(battleOp26),
10724 TEST(battleOp27),
10725 TEST(battleOp28),
10726 TEST(battleOp29),
10727 TEST(battleOp30),
10728
10729 TEST(battleOp31),
10730 TEST(battleOp32),
10731 TEST(battleOp33),
10732 TEST(battleOp34),
10733 TEST(battleOp35),
10734 TEST(battleOp36),
10735 TEST(battleOp37),
10736 TEST(battleOp38),
10737 TEST(battleOp39),
10738 TEST(battleOp40),
10739
10740 TEST(battleOp41),
10741 TEST(battleOp42),
10742 TEST(battleOp43),
10743 TEST(battleOp44),
10744 TEST(battleOp45),
10745 TEST(battleOp47),
10746 TEST(battleOp48),
10747 TEST(battleOp49),
10748 TEST(battleOp50),
10749
10750 TEST(battleOp51),
10751 TEST(battleOp52),
10752 TEST(battleOp53),
10753 TEST(battleOp55),
10754 TEST(battleOp56),
10755 TEST(battleOp57),
10756 TEST(battleOp58),
10757 TEST(battleOp59),
10758 TEST(battleOp60),
10759
10760 TEST(battleOp61),
10761 TEST(battleOp62),
10762 TEST(battleOp64),
10763 TEST(battleOp65),
10764 TEST(battleOp66),
10765 TEST(battleOp67),
10766 TEST(battleOp68),
10767 TEST(battleOp69),
10768 TEST(battleOp70),
10769
10770 TEST(battleOp71),
10771 TEST(battleOp72),
10772 TEST(battleOp73),
10773 TEST(battleOp74),
10774 TEST(battleOp75),
10775 TEST(battleOp76),
10776 TEST(battleOp77),
10777 TEST(battleOp78),
10778 TEST(battleOp79),
10779 TEST(battleOp80),
10780
10781 TEST(battleOp81),
10782 TEST(battleOp82),
10783 TEST(battleOp83),
10784 TEST(battleOp84),
10785 TEST(battleOp85),
10786 TEST(battleOp86),
10787 TEST(battleOp87),
10788 TEST(battleOp88),
10789 TEST(battleOp89),
10790 TEST(battleOp90),
10791
10792 TEST(battleOp91),
10793 TEST(battleOp92),
10794 TEST(battleOp93),
10795 TEST(battleOp94),
10796 TEST(battleOp95),
10797 TEST(battleOp96),
10798 TEST(battleOp97),
10799 TEST(battleOp98),
10800 TEST(battleOp99),
10801 TEST(battleOp100),
10802
10803 TEST(battleOp101),
10804 TEST(battleOp102),
10805 TEST(battleOp103),
10806 TEST(battleOp104),
10807 TEST(battleOp105),
10808 TEST(battleOp106),
10809 TEST(battleOp107),
10810 TEST(battleOp108),
10811 TEST(battleOp109),
10812 TEST(battleOp110),
10813
10814 TEST(battleOp111),
10815 TEST(battleOp112),
10816 TEST(battleOp113),
10817 TEST(battleOp114),
10818 TEST(battleOp115),
10819 TEST(battleOp116),
10820 TEST(battleOp117),
10821 TEST(battleOp118),
10822 TEST(battleOp119),
10823 TEST(battleOp120),
10824
10825 TEST(battleOp121),
10826 TEST(battleOp122),
10827 TEST(battleOp123),
10828 TEST(battleOp124),
10829 TEST(battleOp125),
10830 TEST(battleOp126),
10831 TEST(battleOp127),
10832 TEST(battleOp128),
10833 TEST(battleOp129),
10834 TEST(battleOp130),
10835
10836 TEST(battleOp131),
10837 TEST(battleOp132),
10838 TEST(battleOp133),
10839 TEST(battleOp134),
10840 TEST(battleOp135),
10841 TEST(battleOp136),
10842 TEST(battleOp137),
10843 TEST(battleOp138),
10844 TEST(battleOp139),
10845 TEST(battleOp140),
10846
10847 TEST(battleOp141),
10848 TEST(battleOp142),
10849 TEST(battleOp143),
10850 TEST(battleOp144),
10851 TEST(battleOp145),
10852 TEST(battleOp146),
10853 TEST(battleOp147),
10854 TEST(battleOp149),
10855 TEST(battleOp150),
10856
10857 TEST(battleOp151),
10858 TEST(battleOp153),
10859 TEST(battleOp154),
10860 TEST(battleOp155),
10861 TEST(battleOp156),
10862 TEST(battleOp158),
10863 TEST(battleOp159),
10864 TEST(battleOp160),
10865
10866 TEST(battleOp161),
10867 TEST(battleOp162),
10868 TEST(battleOp164),
10869 TEST(battleOp165),
10870 TEST(battleOp166),
10871 TEST(battleOp167),
10872 TEST(battleOp168),
10873 TEST(battleOp169),
10874 TEST(battleOp170),
10875
10876 TEST(battleOp171),
10877 TEST(battleOp172),
10878 TEST(battleOp173),
10879 TEST(battleOp174),
10880 TEST(battleOp175),
10881 TEST(battleOp176),
10882 TEST(battleOp177),
10883 TEST(battleOp178),
10884 TEST(battleOp179),
10885 TEST(battleOp180),
10886
10887 TEST(battleOp182),
10888 TEST(battleOp184),
10889 TEST(battleOp185),
10890 TEST(battleOp186),
10891 TEST(battleOp187),
10892 TEST(battleOp188),
10893 TEST(battleOp189),
10894 TEST(battleOp190),
10895
10896 TEST(battleOp191),
10897 TEST(battleOp192),
10898 TEST(battleOp193),
10899 TEST(battleOp194),
10900 TEST(battleOp196),
10901 TEST(battleOp197),
10902 TEST(battleOp199),
10903 TEST(battleOp200),
10904
10905 TEST(battleOp201),
10906 TEST(battleOp202),
10907 TEST(battleOp203),
10908 TEST(battleOp204),
10909 TEST(battleOp205),
10910 TEST(battleOp206),
10911 TEST(battleOp207),
10912 TEST(battleOp208),
10913 TEST(battleOp209),
10914 TEST(battleOp210),
10915
10916 TEST(battleOp211),
10917 TEST(battleOp212),
10918 TEST(battleOp213),
10919 TEST(battleOp214),
10920 TEST(battleOp215),
10921 TEST(battleOp216),
10922 TEST(battleOp217),
10923 TEST(battleOp218),
10924 TEST(battleOp219),
10925 TEST(battleOp220),
10926
10927 TEST(battleOp221),
10928 TEST(battleOp222),
10929 TEST(battleOp223),
10930 TEST(battleOp224),
10931 TEST(battleOp225),
10932 TEST(battleOp226),
10933 TEST(battleOp227),
10934 TEST(battleOp228),
10935 TEST(battleOp229),
10936
10937 TEST(battleOp231),
10938 TEST(battleOp232),
10939 TEST(battleOp233),
10940 TEST(battleOp234),
10941 TEST(battleOp235),
10942 TEST(battleOp236),
10943 TEST(battleOp237),
10944 TEST(battleOp238),
10945 TEST(battleOp239),
10946 TEST(battleOp240),
10947
10948 TEST(battleOp241),
10949 TEST(battleOp242),
10950 TEST(battleOp243),
10951 TEST(battleOp244),
10952 TEST(battleOp245),
10953 TEST(battleOp246),
10954 TEST(battleOp247),
10955 TEST(battleOp248),
10956 TEST(battleOp249),
10957 TEST(battleOp250),
10958
10959 TEST(battleOp251),
10960 TEST(battleOp252),
10961 TEST(battleOp253),
10962 TEST(battleOp254),
10963 TEST(battleOp255),
10964 TEST(battleOp257),
10965 TEST(battleOp258),
10966 TEST(battleOp259),
10967 TEST(battleOp260),
10968
10969 TEST(battleOp261),
10970 TEST(battleOp262),
10971 TEST(battleOp263),
10972 TEST(battleOp264),
10973 TEST(battleOp265),
10974 TEST(battleOp266),
10975 TEST(battleOp267),
10976 TEST(battleOp268),
10977 TEST(battleOp270),
10978
10979 TEST(battleOp271),
10980 TEST(battleOp272),
10981 TEST(battleOp274),
10982 TEST(battleOp275),
10983 TEST(battleOp276),
10984 TEST(battleOp277),
10985 TEST(battleOp278),
10986 TEST(battleOp279),
10987 TEST(battleOp280),
10988
10989 TEST(battleOp281),
10990 TEST(battleOp282),
10991 TEST(battleOp284),
10992 TEST(battleOp285),
10993 TEST(battleOp286),
10994 TEST(battleOp287),
10995 TEST(battleOp288),
10996 TEST(battleOp289),
10997 TEST(battleOp290),
10998
10999 TEST(battleOp291),
11000 TEST(battleOp292),
11001 TEST(battleOp293),
11002 TEST(battleOp294),
11003 TEST(battleOp295),
11004 TEST(battleOp296),
11005 TEST(battleOp297),
11006 TEST(battleOp298),
11007 TEST(battleOp299),
11008 TEST(battleOp300),
11009
11010 TEST(battleOp301),
11011 TEST(battleOp302),
11012 TEST(battleOp303),
11013 TEST(battleOp304),
11014 TEST(battleOp305),
11015 TEST(battleOp306),
11016 TEST(battleOp307),
11017 TEST(battleOp308),
11018 TEST(battleOp309),
11019 TEST(battleOp310),
11020
11021 TEST(battleOp311),
11022 TEST(battleOp312),
11023 TEST(battleOp313),
11024 TEST(battleOp314),
11025 TEST(battleOp315),
11026 TEST(battleOp316),
11027 TEST(battleOp317),
11028 TEST(battleOp318),
11029 TEST(battleOp319),
11030 TEST(battleOp320),
11031
11032 TEST(battleOp321),
11033 TEST(battleOp322),
11034 TEST(battleOp323),
11035 TEST(battleOp324),
11036 TEST(battleOp325),
11037 TEST(battleOp326),
11038 TEST(battleOp327),
11039 TEST(battleOp328),
11040 TEST(battleOp329),
11041 TEST(battleOp330),
11042
11043 TEST(battleOp331),
11044 TEST(battleOp332),
11045 TEST(battleOp333),
11046 TEST(battleOp334),
11047 TEST(battleOp335),
11048 TEST(battleOp336),
11049 TEST(battleOp337),
11050 TEST(battleOp338),
11051 TEST(battleOp339),
11052 TEST(battleOp340),
11053
11054 TEST(battleOp341),
11055 TEST(battleOp342),
11056 TEST(battleOp343),
11057 TEST(battleOp344),
11058 TEST(battleOp345),
11059 TEST(battleOp346),
11060 TEST(battleOp347),
11061 TEST(battleOp348),
11062 TEST(battleOp349),
11063 TEST(battleOp350),
11064
11065 TEST(battleOp351),
11066 TEST(battleOp352),
11067
11068 TEST(battleOp402),
11069
11070 TEST(battleOp1390),
11071 TEST(battleOp1391),
11072 TEST(battleOp1392),
11073 TEST(battleOp1393),
11074 TEST(battleOp1394),
11075 TEST(battleOp1395),
11076 TEST(battleOp1396),
11077
11078 TEST(battleOp2193),
11079 TEST(battleOp2194),
11080
11081 TEST(battleOp3368),
11082 TEST(battleOp3369),
11083 TEST(battleOp3370),
11084 TEST(battleOp3371),
11085 TEST(battleOp3372),
11086
11087 TEST(battleOp4290),
11088 TEST(battleOp4291),
11089 TEST(battleOp4292),
11090 TEST(battleOp4293),
11091 TEST(battleOp4294),
11092 TEST(battleOp4295),
11093 TEST(battleOp4296),
11094
11095 TEST(battleOp5193),
11096 TEST(battleOp5194),
11097
11098 TEST(battleOp6000),
11099 TEST(battleOp6001),
11100
11101 TEST(issue414409c),
11102 TEST(issue414409b),
11103 TEST(issue414409),
11104
11105 // these draw wrong
11106 TEST(battleOp46), // dropped an outer cubic incorrectly
11107 // if assembly rewrite was done, the error would be hidden
11108 TEST(battleOp54),
11109 TEST(battleOp63),
11110 TEST(battleOp152),
11111 TEST(battleOp157),
11112 TEST(battleOp163),
11113 TEST(battleOp181),
11114 TEST(battleOp183),
11115 TEST(battleOp195),
11116 TEST(battleOp198),
11117 TEST(battleOp230),
11118 TEST(battleOp256),
11119 TEST(battleOp269),
11120 TEST(battleOp273),
11121 TEST(battleOp148),
11122 TEST(battleOp283),
11123};
battleOp287
static void battleOp287(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7961
battleOp344
static void battleOp344(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9696
battleOp227
static void battleOp227(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6197
battleOp202
static void battleOp202(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5531
battleOp296
static void battleOp296(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8232
battleOp282
static void battleOp282(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7812
battleOp348
static void battleOp348(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9816
issue414409b
static void issue414409b(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:50
battleOp323
static void battleOp323(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9059
battleOp285
static void battleOp285(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7901
battleOp124
static void battleOp124(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3329
battleOp347
static void battleOp347(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9791
battleOp102
static void battleOp102(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2747
battleOp334
static void battleOp334(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9391
battleOp4293
static void battleOp4293(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10446
battleOp240
static void battleOp240(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6557
battleOp251
static void battleOp251(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6883
battleOp263
static void battleOp263(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7244
battleOp229
static void battleOp229(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6253
battleOp260
static void battleOp260(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7151
battleOp345
static void battleOp345(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9730
battleOp186
static void battleOp186(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5088
battleOp293
static void battleOp293(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8144
battleOp146
static void battleOp146(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3912
battleOp3371
static void battleOp3371(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10298
battleOp48
static void battleOp48(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1335
battleOp7
static void battleOp7(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:255
battleOp177
static void battleOp177(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4813
battleOp187
static void battleOp187(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5115
battleOp190
static void battleOp190(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5213
battleOp72
static void battleOp72(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1978
battleOp265
static void battleOp265(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7304
battleOp147
static void battleOp147(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3937
battleOp290
static void battleOp290(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8049
battleOp192
static void battleOp192(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5274
battleOp11
static void battleOp11(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:356
battleOp39
static void battleOp39(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1099
battleOp73
static void battleOp73(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2003
battleOp81
static void battleOp81(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2206
battleOp12
static void battleOp12(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:388
battleOp257
static void battleOp257(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7064
battleOp349
static void battleOp349(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9846
battleOp52
static void battleOp52(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1442
battleOp78
static void battleOp78(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2130
battleOp4292
static void battleOp4292(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10412
battleOp4295
static void battleOp4295(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10507
battleOp256
static void battleOp256(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7030
battleOp5193
static void battleOp5193(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10560
battleOp315
static void battleOp315(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8815
battleOp352
static void battleOp352(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9923
battleOp3372
static void battleOp3372(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10323
battleOp217
static void battleOp217(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5935
battleOp93
static void battleOp93(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2517
battleOp28
static void battleOp28(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:809
battleOp262
static void battleOp262(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7211
battleOp280
static void battleOp280(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7750
battleOp234
static void battleOp234(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6387
battleOp277
static void battleOp277(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7662
battleOp170
static void battleOp170(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4604
battleOp111
static void battleOp111(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2980
battleOp288
static void battleOp288(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7988
battleOp115
static void battleOp115(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3089
battleOp330
static void battleOp330(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9269
battleOp30
static void battleOp30(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:863
battleOp271
static void battleOp271(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7481
battleOp1390
static void battleOp1390(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9951
battleOp106
static void battleOp106(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2851
battleOp275
static void battleOp275(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7601
battleOp295
static void battleOp295(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8205
battleOp1392
static void battleOp1392(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10011
battleOp10
static void battleOp10(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:331
battleOp32
static void battleOp32(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:915
battleOp80
static void battleOp80(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2181
battleOp299
static void battleOp299(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8327
battleOp71
static void battleOp71(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1951
battleOp255
static void battleOp255(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7003
battleOp45
static void battleOp45(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1257
battleOp103
static void battleOp103(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2774
battleOp4291
static void battleOp4291(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10385
battleOp132
static void battleOp132(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3539
battleOp114
static void battleOp114(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3064
battleOp342
static void battleOp342(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9635
battleOp220
static void battleOp220(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6013
battleOp144
static void battleOp144(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3857
battleOp162
static void battleOp162(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4366
battleOp205
static void battleOp205(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5614
battleOp149
static void battleOp149(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3992
battleOp298
static void battleOp298(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8293
battleOp300
static void battleOp300(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8354
battleOp127
static void battleOp127(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3406
battleOp140
static void battleOp140(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3750
battleOp100
static void battleOp100(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2697
battleOp248
static void battleOp248(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6791
battleOp261
static void battleOp261(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7184
battleOp168
static void battleOp168(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4544
battleOp37
static void battleOp37(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1046
battleOp213
static void battleOp213(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5827
battleOp269
static void battleOp269(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7426
battleOp208
static void battleOp208(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5693
battleOp204
static void battleOp204(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5585
battleOp85
static void battleOp85(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2311
battleOp155
static void battleOp155(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4158
battleOp2194
static void battleOp2194(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10175
battleOp309
static void battleOp309(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8632
battleOp195
static void battleOp195(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5352
battleOp180
static void battleOp180(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4906
battleOp312
static void battleOp312(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8720
TEST
#define TEST(name)
Definition PathOpsBattles.cpp:18
battleOp27
static void battleOp27(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:782
battleOp74
static void battleOp74(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2028
battleOp179
static void battleOp179(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4873
battleOp270
static void battleOp270(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7453
battleOp173
static void battleOp173(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4691
battleOp194
static void battleOp194(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5325
battleOp211
static void battleOp211(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5775
battleOp216
static void battleOp216(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5906
battleOp94
static void battleOp94(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2544
battleOp218
static void battleOp218(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5960
battleOp267
static void battleOp267(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7366
battleOp203
static void battleOp203(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5560
battleOp237
static void battleOp237(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6472
battleOp351
static void battleOp351(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9899
battleOp13
static void battleOp13(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:413
battleOp174
static void battleOp174(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4725
battleOp221
static void battleOp221(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6040
battleOp34
static void battleOp34(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:968
battleOp159
static void battleOp159(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4277
battleOp156
static void battleOp156(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4190
battleOp61
static void battleOp61(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1684
battleOp148
static void battleOp148(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3967
battleOp346
static void battleOp346(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9757
battleOp105
static void battleOp105(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2823
battleOp9
static void battleOp9(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:307
battleOp297
static void battleOp297(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8266
battleOp226
static void battleOp226(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6170
battleOp189
static void battleOp189(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5179
battleOp231
static void battleOp231(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6307
battleOp249
static void battleOp249(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6823
battleOp38
static void battleOp38(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1074
battleOp339
static void battleOp339(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9547
battleOp35
static void battleOp35(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:993
battleOp128
static void battleOp128(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3433
battleOp199
static void battleOp199(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5453
battleOp163
static void battleOp163(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4393
battleOp332
static void battleOp332(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9330
battleOp76
static void battleOp76(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2080
battleOp273
static void battleOp273(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7543
battleOp152
static void battleOp152(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4075
battleOp264
static void battleOp264(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7271
battleOp3369
static void battleOp3369(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10237
battleOp278
static void battleOp278(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7689
battleOp1
static void battleOp1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:99
battleOp135
static void battleOp135(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3617
battleOp184
static void battleOp184(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5026
battleOp121
static void battleOp121(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3248
battleOp238
static void battleOp238(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6499
battleOp167
static void battleOp167(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4511
battleOp313
static void battleOp313(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8754
battleOp107
static void battleOp107(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2876
battleOp331
static void battleOp331(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9303
battleOp4
static void battleOp4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:171
battleOp62
static void battleOp62(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1711
battleOp47
static void battleOp47(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1310
battleOp129
static void battleOp129(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3458
battleOp49
static void battleOp49(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1362
battleOp134
static void battleOp134(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3592
battleOp266
static void battleOp266(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7331
battleOp145
static void battleOp145(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3882
battleOp150
static void battleOp150(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4019
battleOp3
static void battleOp3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:146
battleOp89
static void battleOp89(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2415
battleOp1391
static void battleOp1391(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9984
battleOp165
static void battleOp165(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4451
battleOp200
static void battleOp200(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5478
battleOp90
static void battleOp90(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2440
battleOp337
static void battleOp337(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9486
battleOp68
static void battleOp68(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1873
battleOp54
static void battleOp54(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1496
battleOp125
static void battleOp125(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3354
battleOp43
static void battleOp43(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1203
battleOp185
static void battleOp185(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5053
battleOp22
static void battleOp22(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:653
battleOp210
static void battleOp210(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5745
battleOp33
static void battleOp33(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:940
battleOp65
static void battleOp65(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1793
battleOp291
static void battleOp291(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8083
battleOp92
static void battleOp92(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2492
battleOp182
static void battleOp182(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4966
battleOp279
static void battleOp279(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7723
battleOp281
static void battleOp281(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7785
battleOp158
static void battleOp158(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4250
battleOp21
static void battleOp21(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:628
battleOp402
static void battleOp402(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10613
battleOp198
static void battleOp198(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5424
battleOp18
static void battleOp18(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:548
battleOp26
static void battleOp26(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:757
battleOp336
static void battleOp336(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9452
battleOp6
static void battleOp6(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:224
battleOp320
static void battleOp320(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8964
battleOp83
static void battleOp83(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2258
battleOp301
static void battleOp301(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8388
battleOp138
static void battleOp138(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3696
battleOp233
static void battleOp233(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6362
issue414409c
static void issue414409c(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:73
battleOp19
static void battleOp19(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:575
battleOp178
static void battleOp178(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4846
battleOp294
static void battleOp294(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8171
battleOp44
static void battleOp44(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1228
battleOp224
static void battleOp224(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6117
battleOp307
static void battleOp307(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8571
battleOp95
static void battleOp95(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2569
battleOp219
static void battleOp219(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5988
battleOp338
static void battleOp338(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9513
battleOp59
static void battleOp59(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1635
battleOp55
static void battleOp55(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1526
battleOp25
static void battleOp25(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:730
battleOp193
static void battleOp193(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5300
battleOp96
static void battleOp96(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2591
battleOp276
static void battleOp276(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7628
battleOp16
static void battleOp16(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:495
battleOp317
static void battleOp317(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8876
battleOp75
static void battleOp75(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2053
battleOp120
static void battleOp120(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3223
battleOp88
static void battleOp88(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2391
battleOp84
static void battleOp84(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2286
battleOp53
static void battleOp53(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1471
battleOp350
static void battleOp350(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9871
battleOp254
static void battleOp254(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6970
battleOp258
static void battleOp258(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7091
battleOp63
static void battleOp63(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1736
battleOp244
static void battleOp244(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6673
battleOp99
static void battleOp99(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2669
battleOp123
static void battleOp123(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3300
battleOp58
static void battleOp58(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1606
battleOp29
static void battleOp29(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:834
battleOp230
static void battleOp230(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6278
battleOp305
static void battleOp305(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8510
battleOp98
static void battleOp98(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2644
battleOp56
static void battleOp56(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1551
battleOp274
static void battleOp274(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7570
battleOp66
static void battleOp66(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1821
battleOp154
static void battleOp154(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4131
battleOp14
static void battleOp14(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:438
battleOp183
static void battleOp183(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4993
battleOp77
static void battleOp77(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2105
battleOp169
static void battleOp169(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4571
battleOp87
static void battleOp87(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2363
battleOp51
static void battleOp51(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1417
battleOp70
static void battleOp70(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1926
battleOp191
static void battleOp191(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5240
battleOp324
static void battleOp324(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9086
battleOp236
static void battleOp236(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6442
battleOp2193
static void battleOp2193(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10150
battleOp4296
static void battleOp4296(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10532
battleOp40
static void battleOp40(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1126
battleOp222
static void battleOp222(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6065
battleOp250
static void battleOp250(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6850
battleOp82
static void battleOp82(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2233
battleOp133
static void battleOp133(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3564
battleOp253
static void battleOp253(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6943
battleOp303
static void battleOp303(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8449
battleOp306
static void battleOp306(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8537
battleOp4290
static void battleOp4290(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10351
battleOp328
static void battleOp328(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9208
battleOp327
static void battleOp327(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9181
battleOp325
static void battleOp325(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9120
battleOp91
static void battleOp91(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2468
battleOp209
static void battleOp209(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5720
battleOp302
static void battleOp302(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8415
battleOp97
static void battleOp97(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2616
battleOp119
static void battleOp119(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3194
battleOp136
static void battleOp136(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3644
battleOp130
static void battleOp130(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3487
battleOp228
static void battleOp228(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6222
battleOp289
static void battleOp289(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8022
battleOp304
static void battleOp304(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8476
battleOp5
static void battleOp5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:199
battleOp206
static void battleOp206(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5639
battleOp104
static void battleOp104(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2798
battleOp3368
static void battleOp3368(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10203
battleOp67
static void battleOp67(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1846
battleOp181
static void battleOp181(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4933
battleOp235
static void battleOp235(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6417
battleOp239
static void battleOp239(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6530
battleOp225
static void battleOp225(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6145
battleOp223
static void battleOp223(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6092
battleOp50
static void battleOp50(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1387
battleOp160
static void battleOp160(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4308
battleOp171
static void battleOp171(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4631
battleOp131
static void battleOp131(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3512
issue414409
static void issue414409(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:20
battleOp8
static void battleOp8(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:280
battleOp252
static void battleOp252(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6910
battleOp31
static void battleOp31(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:888
battleOp151
static void battleOp151(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4044
battleOp116
static void battleOp116(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3116
battleOp201
static void battleOp201(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5506
battleOp117
static void battleOp117(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3141
battleOp36
static void battleOp36(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1021
battleOp283
static void battleOp283(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7846
battleOp207
static void battleOp207(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5668
battleOp69
static void battleOp69(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1898
battleOp6001
static void battleOp6001(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10665
battleOp4294
static void battleOp4294(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10473
battleOp241
static void battleOp241(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6588
battleOp176
static void battleOp176(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4786
battleOp108
static void battleOp108(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2903
battleOp310
static void battleOp310(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8659
battleOp314
static void battleOp314(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8781
battleOp308
static void battleOp308(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8598
battleOp101
static void battleOp101(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2722
battleOp341
static void battleOp341(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9608
battleOp46
static void battleOp46(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1282
battleOp141
static void battleOp141(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3775
battleOp110
static void battleOp110(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2955
battleOp247
static void battleOp247(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6764
battleOp15
static void battleOp15(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:470
battleOp113
static void battleOp113(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3037
battleOp1393
static void battleOp1393(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10045
battleOp318
static void battleOp318(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8903
battleOp333
static void battleOp333(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9364
battleOp153
static void battleOp153(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4102
battleOp319
static void battleOp319(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8937
battleOp164
static void battleOp164(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4424
battleOp3370
static void battleOp3370(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10264
battleOp23
static void battleOp23(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:678
battleOp122
static void battleOp122(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3275
battleOp243
static void battleOp243(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6646
battleOp188
static void battleOp188(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5152
battleOp1396
static void battleOp1396(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10123
battleOp118
static void battleOp118(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3169
battleOp112
static void battleOp112(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3012
battleOp212
static void battleOp212(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5800
battleOp57
static void battleOp57(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1581
battleOp166
static void battleOp166(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4484
battleOp321
static void battleOp321(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8998
battleOp316
static void battleOp316(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8842
battleOp286
static void battleOp286(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7928
battleOp175
static void battleOp175(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4752
battleOp1394
static void battleOp1394(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10070
battleOp142
static void battleOp142(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3803
battleOp126
static void battleOp126(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3381
battleOp1395
static void battleOp1395(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10098
battleOp41
static void battleOp41(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1151
battleOp335
static void battleOp335(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9425
battleOp6000
static void battleOp6000(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10641
battleOp340
static void battleOp340(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9574
battleOp215
static void battleOp215(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5881
battleOp20
static void battleOp20(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:600
battleOp139
static void battleOp139(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3721
battleOp268
static void battleOp268(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7393
battleOp242
static void battleOp242(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6615
battleOp17
static void battleOp17(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:523
battleOp329
static void battleOp329(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9242
battleOp161
static void battleOp161(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4335
battleOp5194
static void battleOp5194(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:10585
battleOp272
static void battleOp272(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7508
battleOp143
static void battleOp143(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3828
battleOp196
static void battleOp196(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5377
battleOp311
static void battleOp311(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8693
battleOp24
static void battleOp24(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:705
battleOp214
static void battleOp214(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5852
battleOp284
static void battleOp284(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7873
battleOp137
static void battleOp137(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:3669
battleOp109
static void battleOp109(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2928
battleOp42
static void battleOp42(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1176
battleOp197
static void battleOp197(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:5399
battleOp326
static void battleOp326(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9147
battleOp245
static void battleOp245(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6706
battleOp60
static void battleOp60(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1659
battleOp232
static void battleOp232(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6332
battleOp86
static void battleOp86(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2338
battleOp259
static void battleOp259(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:7124
battleOp292
static void battleOp292(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:8110
battleOp246
static void battleOp246(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:6733
battleOp157
static void battleOp157(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4217
battleOp79
static void battleOp79(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:2157
battleOp2
static void battleOp2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:124
battleOp322
static void battleOp322(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9025
battleOp172
static void battleOp172(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:4664
battleOp343
static void battleOp343(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:9669
battleOp64
static void battleOp64(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsBattles.cpp:1768
Generated on Fri Apr 26 2024 06:18:55 for Flutter Engine by doxygen 1.9.8