experimental path-builder

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 "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkParse.h"
 #include "SkParsePath.h"
 #include "SkPathPriv.h"
 #include "SkPathEffect.h"
 #include "SkRRect.h"
 #include "SkRandom.h"
 #include "SkReader32.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkTypes.h"
 #include "SkWriter32.h"
 #include "Test.h"
 
+#include "SkPathIter.h"
+
+static void test_2_iters(const SkPath& path) {
+    SkPath::RawIter iter0(path);
+    SkPathIter      iter1(path);
+    
+    SkPoint pts[4];
+    SkPath::Verb verb;
+    while ((verb = iter0.next(pts)) != SkPath::kDone_Verb) {
+        SkASSERT(iter1.next());
+        SkASSERT(!iter1.done());
+        SkASSERT(iter1.currVerb() == (SkPathVerb)verb);
+        int n = 0;
+        switch (verb) {
+            case SkPath::kMove_Verb: n = 1; break;
+            case SkPath::kLine_Verb: n = 2; break;
+            case SkPath::kQuad_Verb: n = 3; break;
+            case SkPath::kConic_Verb: n = 3; break;
+            case SkPath::kCubic_Verb: n = 4; break;
+            case SkPath::kClose_Verb: n = 0; break;
+            default:
+                SkASSERT(!"unexpected");
+        }
+        for (int i = 0; i < n; ++i) {
+            SkASSERT(pts[i] == iter1.currPts()[i]);
+        }
+    }
+    SkASSERT(iter1.done());
+    SkDebugf("test_2_iters\n");
+}
+
 static void set_radii(SkVector radii[4], int index, float rad) {
     sk_bzero(radii, sizeof(SkVector) * 4);
     radii[index].set(rad, rad);
 }
 
 static void test_add_rrect(skiatest::Reporter* reporter, const SkRect& bounds,
                            const SkVector radii[4]) {
     SkRRect rrect;
     rrect.setRectRadii(bounds, radii);
     REPORTER_ASSERT(reporter, bounds == rrect.rect());
@@ skipping 784 matching lines @@
 
 // assert that we always
 //  start with a moveTo
 //  only have 1 moveTo
 //  only have Lines after that
 //  end with a single close
 //  only have (at most) 1 close
 //
 static void test_poly(skiatest::Reporter* reporter, const SkPath& path,
                       const SkPoint srcPts[], bool expectClose) {
+    test_2_iters(path);
     SkPath::RawIter iter(path);
     SkPoint         pts[4];
 
     bool firstTime = true;
     bool foundClose = false;
     for (;;) {
         switch (iter.next(pts)) {
             case SkPath::kMove_Verb:
                 REPORTER_ASSERT(reporter, firstTime);
                 REPORTER_ASSERT(reporter, pts[0] == srcPts[0]);
@@ skipping 65 matching lines @@
     rec.setStrokeStyle(0, true);
     REPORTER_ASSERT(reporter, SkStrokeRec::kFill_Style == rec.getStyle());
 }
 
 // Set this for paths that don't have a consistent direction such as a bowtie.
 // (cheapComputeDirection is not expected to catch these.)
 const SkPathPriv::FirstDirection kDontCheckDir = static_cast<SkPathPriv::FirstDirection>(-1);
 
 static void check_direction(skiatest::Reporter* reporter, const SkPath& path,
                             SkPathPriv::FirstDirection expected) {
+    test_2_iters(path);
     if (expected == kDontCheckDir) {
         return;
     }
     SkPath copy(path); // we make a copy so that we don't cache the result on the passed in path.
 
     SkPathPriv::FirstDirection dir;
     if (SkPathPriv::CheapComputeFirstDirection(copy, &dir)) {
         REPORTER_ASSERT(reporter, dir == expected);
     } else {
         REPORTER_ASSERT(reporter, SkPathPriv::kUnknown_FirstDirection == expected);
@@ skipping 3017 matching lines @@
     PathTest_Private::TestPathTo(reporter);
     PathRefTest_Private::TestPathRef(reporter);
     PathTest_Private::TestPathrefListeners(reporter);
     test_dump(reporter);
     test_path_crbug389050(reporter);
     test_path_crbugskia2820(reporter);
     test_skbug_3469(reporter);
     test_skbug_3239(reporter);
     test_bounds_crbug_513799(reporter);
 }