1/* 2 * Copyright 2012 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8#include "include/core/SkString.h" 9#include "include/private/SkMacros.h" 10#include "tests/PathOpsExtendedTest.h" 11#include "tests/PathOpsThreadedCommon.h" 12 13// four rects, of four sizes 14// for 3 smaller sizes, tall, wide 15 // top upper mid lower bottom aligned (3 bits, 5 values) 16 // same with x (3 bits, 5 values) 17// not included, square, tall, wide (2 bits) 18// cw or ccw (1 bit) 19 20static void testSimplify4x4RectsMain(PathOpsThreadState* data) 21{ 22 SkASSERT(data); 23 PathOpsThreadState& state = *data; 24 int aShape = state.fA & 0x03; 25 SkPathDirection aCW = state.fA >> 2 ? SkPathDirection::kCCW : SkPathDirection::kCW; 26 int bShape = state.fB & 0x03; 27 SkPathDirection bCW = state.fB >> 2 ? SkPathDirection::kCCW : SkPathDirection::kCW; 28 int cShape = state.fC & 0x03; 29 SkPathDirection cCW = state.fC >> 2 ? SkPathDirection::kCCW : SkPathDirection::kCW; 30 int dShape = state.fD & 0x03; 31 SkPathDirection dCW = state.fD >> 2 ? SkPathDirection::kCCW : SkPathDirection::kCW; 32 for (int aXAlign = 0; aXAlign < 5; ++aXAlign) { 33 for (int aYAlign = 0; aYAlign < 5; ++aYAlign) { 34 for (int bXAlign = 0; bXAlign < 5; ++bXAlign) { 35 for (int bYAlign = 0; bYAlign < 5; ++bYAlign) { 36 for (int cXAlign = 0; cXAlign < 5; ++cXAlign) { 37 for (int cYAlign = 0; cYAlign < 5; ++cYAlign) { 38 for (int dXAlign = 0; dXAlign < 5; ++dXAlign) { 39 for (int dYAlign = 0; dYAlign < 5; ++dYAlign) { 40 SkString pathStr; 41 SkPath path, out; 42 int l SK_INIT_TO_AVOID_WARNING, t SK_INIT_TO_AVOID_WARNING, 43 r SK_INIT_TO_AVOID_WARNING, b SK_INIT_TO_AVOID_WARNING; 44 if (aShape) { 45 switch (aShape) { 46 case 1: // square 47 l = 0; r = 60; 48 t = 0; b = 60; 49 aXAlign = 5; 50 aYAlign = 5; 51 break; 52 case 2: 53 l = aXAlign * 12; 54 r = l + 30; 55 t = 0; b = 60; 56 aYAlign = 5; 57 break; 58 case 3: 59 l = 0; r = 60; 60 t = aYAlign * 12; 61 b = l + 30; 62 aXAlign = 5; 63 break; 64 } 65 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b), 66 aCW); 67 if (state.fReporter->verbose()) { 68 pathStr.appendf(" path.addRect(%d, %d, %d, %d," 69 " SkPathDirection::kC%sW);\n", l, t, r, b, 70 aCW == SkPathDirection::kCCW ? "C" : ""); 71 } 72 } else { 73 aXAlign = 5; 74 aYAlign = 5; 75 } 76 if (bShape) { 77 switch (bShape) { 78 case 1: // square 79 l = bXAlign * 10; 80 r = l + 20; 81 t = bYAlign * 10; 82 b = l + 20; 83 break; 84 case 2: 85 l = bXAlign * 10; 86 r = l + 20; 87 t = 10; b = 40; 88 bYAlign = 5; 89 break; 90 case 3: 91 l = 10; r = 40; 92 t = bYAlign * 10; 93 b = l + 20; 94 bXAlign = 5; 95 break; 96 } 97 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b), 98 bCW); 99 if (state.fReporter->verbose()) { 100 pathStr.appendf(" path.addRect(%d, %d, %d, %d," 101 " SkPathDirection::kC%sW);\n", l, t, r, b, 102 bCW == SkPathDirection::kCCW ? "C" : ""); 103 } 104 } else { 105 bXAlign = 5; 106 bYAlign = 5; 107 } 108 if (cShape) { 109 switch (cShape) { 110 case 1: // square 111 l = cXAlign * 6; 112 r = l + 12; 113 t = cYAlign * 6; 114 b = l + 12; 115 break; 116 case 2: 117 l = cXAlign * 6; 118 r = l + 12; 119 t = 20; b = 30; 120 cYAlign = 5; 121 break; 122 case 3: 123 l = 20; r = 30; 124 t = cYAlign * 6; 125 b = l + 20; 126 cXAlign = 5; 127 break; 128 } 129 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b), 130 cCW); 131 if (state.fReporter->verbose()) { 132 pathStr.appendf(" path.addRect(%d, %d, %d, %d," 133 " SkPathDirection::kC%sW);\n", l, t, r, b, 134 cCW == SkPathDirection::kCCW ? "C" : ""); 135 } 136 } else { 137 cXAlign = 5; 138 cYAlign = 5; 139 } 140 if (dShape) { 141 switch (dShape) { 142 case 1: // square 143 l = dXAlign * 4; 144 r = l + 9; 145 t = dYAlign * 4; 146 b = l + 9; 147 break; 148 case 2: 149 l = dXAlign * 6; 150 r = l + 9; 151 t = 32; b = 36; 152 dYAlign = 5; 153 break; 154 case 3: 155 l = 32; r = 36; 156 t = dYAlign * 6; 157 b = l + 9; 158 dXAlign = 5; 159 break; 160 } 161 path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b), 162 dCW); 163 if (state.fReporter->verbose()) { 164 pathStr.appendf(" path.addRect(%d, %d, %d, %d," 165 " SkPathDirection::kC%sW);\n", l, t, r, b, 166 dCW == SkPathDirection::kCCW ? "C" : ""); 167 } 168 } else { 169 dXAlign = 5; 170 dYAlign = 5; 171 } 172 path.close(); 173 if (state.fReporter->verbose()) { 174 state.outputProgress(pathStr.c_str(), SkPathFillType::kWinding); 175 } 176 testSimplify(path, false, out, state, pathStr.c_str()); 177 if (state.fReporter->verbose()) { 178 state.outputProgress(pathStr.c_str(), SkPathFillType::kEvenOdd); 179 } 180 testSimplify(path, true, out, state, pathStr.c_str()); 181 } 182 } 183 } 184 } 185 } 186 } 187 } 188 } 189} 190 191DEF_TEST(PathOpsSimplifyRectsThreaded, reporter) { 192 initializeTests(reporter, "testLine"); 193 PathOpsThreadedTestRunner testRunner(reporter); 194 for (int a = 0; a < 8; ++a) { // outermost 195 for (int b = a ; b < 8; ++b) { 196 for (int c = b ; c < 8; ++c) { 197 for (int d = c; d < 8; ++d) { 198 *testRunner.fRunnables.append() = new PathOpsThreadedRunnable( 199 &testSimplify4x4RectsMain, a, b, c, d, &testRunner); 200 } 201 if (!reporter->allowExtendedTest()) goto finish; 202 } 203 } 204 } 205finish: 206 testRunner.render(); 207} 208