Refactor PathTest.cpp test_isNestedRects and test_isRect.

tests/PathTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
@@ skipping 1263 matching lines @@
     // passing tests (all moveTo / lineTo...
     SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
     SkPoint r2[] = {{1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint r3[] = {{1, 1}, {0, 1}, {0, 0}, {1, 0}};
     SkPoint r4[] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
     SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};
     SkPoint r6[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};
     SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};
     SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
-    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f},
-        {1, 0}, {.5f, 0}};
-    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1},
-        {0, 1}, {0, .5f}};
+    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, {1, 0}, {.5f, 0}};
+    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, {0, 1}, {0, .5f}};
     SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}};
     SkPoint rf[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, 0}};
 
     // failing tests
     SkPoint f1[] = {{0, 0}, {1, 0}, {1, 1}}; // too few points
     SkPoint f2[] = {{0, 0}, {1, 1}, {0, 1}, {1, 0}}; // diagonal
     SkPoint f3[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}, {1, 0}}; // wraps
     SkPoint f4[] = {{0, 0}, {1, 0}, {0, 0}, {1, 0}, {1, 1}, {0, 1}}; // backs up
     SkPoint f5[] = {{0, 0}, {1, 0}, {1, 1}, {2, 0}}; // end overshoots
     SkPoint f6[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 2}}; // end overshoots
     SkPoint f7[] = {{0, 0}, {1, 0}, {1, 1}, {0, 2}}; // end overshoots
     SkPoint f8[] = {{0, 0}, {1, 0}, {1, 1}, {1, 0}}; // 'L'
     SkPoint f9[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, 0}, {2, 0}}; // overlaps
     SkPoint fa[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, -1}, {1, -1}}; // non colinear gap
     SkPoint fb[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, 1}}; // falls short
 
     // failing, no close
     SkPoint c1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // close doesn't match
     SkPoint c2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}}; // ditto
 
-    size_t testLen[] = {
-        sizeof(r1), sizeof(r2), sizeof(r3), sizeof(r4), sizeof(r5), sizeof(r6),
-        sizeof(r7), sizeof(r8), sizeof(r9), sizeof(ra), sizeof(rb), sizeof(rc),
-        sizeof(rd), sizeof(re), sizeof(rf),
-        sizeof(f1), sizeof(f2), sizeof(f3), sizeof(f4), sizeof(f5), sizeof(f6),
-        sizeof(f7), sizeof(f8), sizeof(f9), sizeof(fa), sizeof(fb),
-        sizeof(c1), sizeof(c2)
+    struct IsRectTest {
+        SkPoint *fPoints;
+        size_t fPointCount;
+        bool fClose;
+        bool fIsRect;
+    } tests[] = {
+        { r1, SK_ARRAY_COUNT(r1), true, true },
+        { r2, SK_ARRAY_COUNT(r2), true, true },
+        { r3, SK_ARRAY_COUNT(r3), true, true },
+        { r4, SK_ARRAY_COUNT(r4), true, true },
+        { r5, SK_ARRAY_COUNT(r5), true, true },
+        { r6, SK_ARRAY_COUNT(r6), true, true },
+        { r7, SK_ARRAY_COUNT(r7), true, true },
+        { r8, SK_ARRAY_COUNT(r8), true, true },
+        { r9, SK_ARRAY_COUNT(r9), true, true },
+        { ra, SK_ARRAY_COUNT(ra), true, true },
+        { rb, SK_ARRAY_COUNT(rb), true, true },
+        { rc, SK_ARRAY_COUNT(rc), true, true },
+        { rd, SK_ARRAY_COUNT(rd), true, true },
+        { re, SK_ARRAY_COUNT(re), true, true },
+        { rf, SK_ARRAY_COUNT(rf), true, true },
+
+        { f1, SK_ARRAY_COUNT(f1), true, false },
+        { f2, SK_ARRAY_COUNT(f2), true, false },
+        { f3, SK_ARRAY_COUNT(f3), true, false },
+        { f4, SK_ARRAY_COUNT(f4), true, false },
+        { f5, SK_ARRAY_COUNT(f5), true, false },
+        { f6, SK_ARRAY_COUNT(f6), true, false },
+        { f7, SK_ARRAY_COUNT(f7), true, false },
+        { f8, SK_ARRAY_COUNT(f8), true, false },
+        { f9, SK_ARRAY_COUNT(f9), true, false },
+        { fa, SK_ARRAY_COUNT(fa), true, false },
+        { fb, SK_ARRAY_COUNT(fb), true, false },
+
+        { c1, SK_ARRAY_COUNT(c1), false, false },
+        { c2, SK_ARRAY_COUNT(c2), false, false },
     };
-    SkPoint* tests[] = {
-        r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf,
-        f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb,
-        c1, c2
-    };
-    SkPoint* lastPass = rf;
-    SkPoint* lastClose = fb;
-    bool fail = false;
-    bool close = true;
-    const size_t testCount = sizeof(tests) / sizeof(tests[0]);
+
+    const size_t testCount = SK_ARRAY_COUNT(tests);
     size_t index;
     for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
         SkPath path;
-        path.moveTo(tests[testIndex][0].fX, tests[testIndex][0].fY);
-        for (index = 1; index < testLen[testIndex] / sizeof(SkPoint); ++index) {
-            path.lineTo(tests[testIndex][index].fX, tests[testIndex][index].fY);
+        path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
+        for (index = 1; index < tests[testIndex].fPointCount; ++index) {
+            path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
         }
-        if (close) {
+        if (tests[testIndex].fClose) {
             path.close();
         }
-        REPORTER_ASSERT(reporter, fail ^ path.isRect(0));
-        REPORTER_ASSERT(reporter, fail ^ path.isRect(NULL, NULL));
+        REPORTER_ASSERT(reporter, tests[testIndex].fIsRect == path.isRect(NULL));
+        REPORTER_ASSERT(reporter, tests[testIndex].fIsRect == path.isRect(NULL, NULL));
 
-        if (!fail) {
+        if (tests[testIndex].fIsRect) {
             SkRect computed, expected;
-            expected.set(tests[testIndex], testLen[testIndex] / sizeof(SkPoint));
+            expected.set(tests[testIndex].fPoints, tests[testIndex].fPointCount);
             REPORTER_ASSERT(reporter, path.isRect(&computed));
             REPORTER_ASSERT(reporter, expected == computed);
 
             bool isClosed;
             SkPath::Direction direction, cheapDirection;
             REPORTER_ASSERT(reporter, path.cheapComputeDirection(&cheapDirection));
             REPORTER_ASSERT(reporter, path.isRect(&isClosed, &direction));
-            REPORTER_ASSERT(reporter, isClosed == close);
+            REPORTER_ASSERT(reporter, isClosed == tests[testIndex].fClose);
             REPORTER_ASSERT(reporter, direction == cheapDirection);
         } else {
             SkRect computed;
             computed.set(123, 456, 789, 1011);
             REPORTER_ASSERT(reporter, !path.isRect(&computed));
             REPORTER_ASSERT(reporter, computed.fLeft == 123 && computed.fTop == 456);
             REPORTER_ASSERT(reporter, computed.fRight == 789 && computed.fBottom == 1011);
 
             bool isClosed = (bool) -1;
             SkPath::Direction direction = (SkPath::Direction) -1;
             REPORTER_ASSERT(reporter, !path.isRect(&isClosed, &direction));
             REPORTER_ASSERT(reporter, isClosed == (bool) -1);
             REPORTER_ASSERT(reporter, direction == (SkPath::Direction) -1);
         }
-
-        if (tests[testIndex] == lastPass) {
-            fail = true;
-        }
-        if (tests[testIndex] == lastClose) {
-            close = false;
-        }
     }
 
     // fail, close then line
     SkPath path1;
     path1.moveTo(r1[0].fX, r1[0].fY);
-    for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+    for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     path1.lineTo(1, 0);
-    REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
+    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, move in the middle
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
-    for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+    for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         if (index == 2) {
             path1.moveTo(1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
+    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, move on the edge
     path1.reset();
-    for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+    for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         path1.moveTo(r1[index - 1].fX, r1[index - 1].fY);
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
+    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, quad
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
-    for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+    for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         if (index == 2) {
             path1.quadTo(1, .5f, 1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
+    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, cubic
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
-    for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+    for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         if (index == 2) {
             path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
+    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 }
 
 static void test_isNestedRects(skiatest::Reporter* reporter) {
     // passing tests (all moveTo / lineTo...
     SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
     SkPoint r2[] = {{1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint r3[] = {{1, 1}, {0, 1}, {0, 0}, {1, 0}};
     SkPoint r4[] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
     SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}}; // CCW
     SkPoint r6[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};
     SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};
     SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
-    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, // CCW
-        {1, 0}, {.5f, 0}};
-    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, // CW
-        {0, 1}, {0, .5f}};
+    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, {1, 0}, {.5f, 0}}; // CCW
+    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, {0, 1}, {0, .5f}}; // CW
     SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}; // CW
     SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}}; // CCW
     SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
 
     // failing tests
     SkPoint f1[] = {{0, 0}, {1, 0}, {1, 1}}; // too few points
     SkPoint f2[] = {{0, 0}, {1, 1}, {0, 1}, {1, 0}}; // diagonal
     SkPoint f3[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}, {1, 0}}; // wraps
     SkPoint f4[] = {{0, 0}, {1, 0}, {0, 0}, {1, 0}, {1, 1}, {0, 1}}; // backs up
     SkPoint f5[] = {{0, 0}, {1, 0}, {1, 1}, {2, 0}}; // end overshoots
     SkPoint f6[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 2}}; // end overshoots
     SkPoint f7[] = {{0, 0}, {1, 0}, {1, 1}, {0, 2}}; // end overshoots
     SkPoint f8[] = {{0, 0}, {1, 0}, {1, 1}, {1, 0}}; // 'L'
 
     // failing, no close
     SkPoint c1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // close doesn't match
     SkPoint c2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}}; // ditto
 
-    size_t testLen[] = {
-        sizeof(r1), sizeof(r2), sizeof(r3), sizeof(r4), sizeof(r5), sizeof(r6),
-        sizeof(r7), sizeof(r8), sizeof(r9), sizeof(ra), sizeof(rb), sizeof(rc),
-        sizeof(rd), sizeof(re),
-        sizeof(f1), sizeof(f2), sizeof(f3), sizeof(f4), sizeof(f5), sizeof(f6),
-        sizeof(f7), sizeof(f8),
-        sizeof(c1), sizeof(c2)
+    struct IsNestedRectTest {
+        SkPoint *fPoints;
+        size_t fPointCount;
+        SkPath::Direction fDirection;
+        bool fClose;
+        bool fIsNestedRect; // nests with path.addRect(-1, -1, 2, 2);
+    } tests[] = {
+        { r1, SK_ARRAY_COUNT(r1), SkPath::kCW_Direction , true, true },
+        { r2, SK_ARRAY_COUNT(r2), SkPath::kCW_Direction , true, true },
+        { r3, SK_ARRAY_COUNT(r3), SkPath::kCW_Direction , true, true },
+        { r4, SK_ARRAY_COUNT(r4), SkPath::kCW_Direction , true, true },
+        { r5, SK_ARRAY_COUNT(r5), SkPath::kCCW_Direction, true, true },
+        { r6, SK_ARRAY_COUNT(r6), SkPath::kCCW_Direction, true, true },
+        { r7, SK_ARRAY_COUNT(r7), SkPath::kCCW_Direction, true, true },
+        { r8, SK_ARRAY_COUNT(r8), SkPath::kCCW_Direction, true, true },
+        { r9, SK_ARRAY_COUNT(r9), SkPath::kCCW_Direction, true, true },
+        { ra, SK_ARRAY_COUNT(ra), SkPath::kCCW_Direction, true, true },
+        { rb, SK_ARRAY_COUNT(rb), SkPath::kCW_Direction,  true, true },
+        { rc, SK_ARRAY_COUNT(rc), SkPath::kCW_Direction,  true, true },
+        { rd, SK_ARRAY_COUNT(rd), SkPath::kCCW_Direction, true, true },
+        { re, SK_ARRAY_COUNT(re), SkPath::kCW_Direction,  true, true },
+
+        { f1, SK_ARRAY_COUNT(f1), SkPath::kUnknown_Direction, true, false },
+        { f2, SK_ARRAY_COUNT(f2), SkPath::kUnknown_Direction, true, false },
+        { f3, SK_ARRAY_COUNT(f3), SkPath::kUnknown_Direction, true, false },
+        { f4, SK_ARRAY_COUNT(f4), SkPath::kUnknown_Direction, true, false },
+        { f5, SK_ARRAY_COUNT(f5), SkPath::kUnknown_Direction, true, false },
+        { f6, SK_ARRAY_COUNT(f6), SkPath::kUnknown_Direction, true, false },
+        { f7, SK_ARRAY_COUNT(f7), SkPath::kUnknown_Direction, true, false },
+        { f8, SK_ARRAY_COUNT(f8), SkPath::kUnknown_Direction, true, false },
+
+        { c1, SK_ARRAY_COUNT(c1), SkPath::kUnknown_Direction, false, false },
+        { c2, SK_ARRAY_COUNT(c2), SkPath::kUnknown_Direction, false, false },
     };
-    SkPoint* tests[] = {
-        r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re,
-        f1, f2, f3, f4, f5, f6, f7, f8,
-        c1, c2
-    };
-    SkPath::Direction dirs[] = {
-        SkPath::kCW_Direction, SkPath::kCW_Direction, SkPath::kCW_Direction,
-        SkPath::kCW_Direction, SkPath::kCCW_Direction, SkPath::kCCW_Direction,
-        SkPath::kCCW_Direction, SkPath::kCCW_Direction, SkPath::kCCW_Direction,
-        SkPath::kCCW_Direction, SkPath::kCW_Direction, SkPath::kCW_Direction,
-        SkPath::kCCW_Direction, SkPath::kCW_Direction, SkPath::kUnknown_Direction,
-        SkPath::kUnknown_Direction, SkPath::kUnknown_Direction, SkPath::kUnknown_Direction,
-        SkPath::kUnknown_Direction, SkPath::kUnknown_Direction, SkPath::kUnknown_Direction,
-        SkPath::kUnknown_Direction, SkPath::kUnknown_Direction, SkPath::kUnknown_Direction,
-    };
-    SkASSERT(SK_ARRAY_COUNT(tests) == SK_ARRAY_COUNT(dirs));
 
-    const SkPoint* lastPass = re;
-    const SkPoint* lastClose = f8;
-    const size_t testCount = sizeof(tests) / sizeof(tests[0]);
+    const size_t testCount = SK_ARRAY_COUNT(tests);
     size_t index;
     for (int rectFirst = 0; rectFirst <= 1; ++rectFirst) {
-        bool fail = false;
-        bool close = true;
         for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
             SkPath path;
             if (rectFirst) {
                 path.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
             }
-            path.moveTo(tests[testIndex][0].fX, tests[testIndex][0].fY);
-            for (index = 1; index < testLen[testIndex] / sizeof(SkPoint); ++index) {
-                path.lineTo(tests[testIndex][index].fX, tests[testIndex][index].fY);
+            path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
+            for (index = 1; index < tests[testIndex].fPointCount; ++index) {
+                path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
             }
-            if (close) {
+            if (tests[testIndex].fClose) {
                 path.close();
             }
             if (!rectFirst) {
                 path.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
             }
-            REPORTER_ASSERT(reporter, fail ^ path.isNestedRects(0));
-            if (!fail) {
+            REPORTER_ASSERT(reporter, tests[testIndex].fIsNestedRect == path.isNestedRects(NULL));
+            if (tests[testIndex].fIsNestedRect) {
                 SkRect expected[2], computed[2];
                 SkPath::Direction expectedDirs[2], computedDirs[2];
                 SkRect testBounds;
-                testBounds.set(tests[testIndex], testLen[testIndex] / sizeof(SkPoint));
+                testBounds.set(tests[testIndex].fPoints, tests[testIndex].fPointCount);
                 expected[0] = SkRect::MakeLTRB(-1, -1, 2, 2);
                 expected[1] = testBounds;
                 if (rectFirst) {
                     expectedDirs[0] = SkPath::kCW_Direction;
                 } else {
                     expectedDirs[0] = SkPath::kCCW_Direction;
                 }
-                expectedDirs[1] = dirs[testIndex];
+                expectedDirs[1] = tests[testIndex].fDirection;
                 REPORTER_ASSERT(reporter, path.isNestedRects(computed, computedDirs));
                 REPORTER_ASSERT(reporter, expected[0] == computed[0]);
                 REPORTER_ASSERT(reporter, expected[1] == computed[1]);
                 REPORTER_ASSERT(reporter, expectedDirs[0] == computedDirs[0]);
                 REPORTER_ASSERT(reporter, expectedDirs[1] == computedDirs[1]);
             }
-            if (tests[testIndex] == lastPass) {
-                fail = true;
-            }
-            if (tests[testIndex] == lastClose) {
-                close = false;
-            }
         }
 
         // fail, close then line
         SkPath path1;
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
-        for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+        for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         path1.lineTo(1, 0);
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, fail ^ path1.isNestedRects(0));
+        REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, move in the middle
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
-        for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+        for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             if (index == 2) {
                 path1.moveTo(1, .5f);
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, fail ^ path1.isNestedRects(0));
+        REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, move on the edge
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
-        for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+        for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             path1.moveTo(r1[index - 1].fX, r1[index - 1].fY);
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, fail ^ path1.isNestedRects(0));
+        REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, quad
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
-        for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+        for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             if (index == 2) {
                 path1.quadTo(1, .5f, 1, .5f);
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, fail ^ path1.isNestedRects(0));
+        REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, cubic
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
-        for (index = 1; index < testLen[0] / sizeof(SkPoint); ++index) {
+        for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             if (index == 2) {
                 path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, fail ^ path1.isNestedRects(0));
+        REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail,  not nested
         path1.reset();
         path1.addRect(1, 1, 3, 3, SkPath::kCW_Direction);
         path1.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
-        REPORTER_ASSERT(reporter, fail ^ path1.isNestedRects(0));
+        REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
     }
 
     // pass, stroke rect
     SkPath src, dst;
     src.addRect(1, 1, 7, 7, SkPath::kCW_Direction);
     SkPaint strokePaint;
     strokePaint.setStyle(SkPaint::kStroke_Style);
     strokePaint.setStrokeWidth(2);
     strokePaint.getFillPath(src, &dst);
-    REPORTER_ASSERT(reporter, dst.isNestedRects(0));
+    REPORTER_ASSERT(reporter, dst.isNestedRects(NULL));
 }
 
 static void write_and_read_back(skiatest::Reporter* reporter,
                                 const SkPath& p) {
     SkWriter32 writer(100);
     writer.writePath(p);
     size_t size = writer.size();
     SkAutoMalloc storage(size);
     writer.flatten(storage.get());
     SkReader32 reader(storage.get(), size);
@@ skipping 893 matching lines @@
     test_clipped_cubic();
     test_crbug_170666();
     test_bad_cubic_crbug229478();
     test_bad_cubic_crbug234190();
     test_android_specific_behavior(reporter);
     test_path_close_issue1474(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Path", PathTestClass, TestPath)