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