commit aa35831d1d0e4c798a63fe772430adc4f3a038cd
author caryclark@google.com <caryclark@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81> Tue Jan 29 20:28:49 2013 +0000
committer caryclark@google.com <caryclark@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81> Tue Jan 29 20:28:49 2013 +0000
tree 1bff42e085bfcf17f906982d9924a81b5b5a79c3
parent 81d3ce0b63bc87769fd543c2af79e7233d266d09

shape ops work in progress

git-svn-id: http://skia.googlecode.com/svn/trunk@7453 2bbb7eff-a529-9590-31e7-b0007b416f81

experimental/Intersection/QuarticRoot_Test.cpp

diff --git a/experimental/Intersection/QuarticRoot_Test.cpp b/experimental/Intersection/QuarticRoot_Test.cpp
index 027d19b..18a3a8d 100644
--- a/experimental/Intersection/QuarticRoot_Test.cpp
+++ b/experimental/Intersection/QuarticRoot_Test.cpp
@@ -1,5 +1,3 @@
-#include <assert.h>
-#include <math.h>
 #include "CubicUtilities.h"
 #include "Intersection_Tests.h"
 #include "QuadraticUtilities.h"
@@ -41,15 +39,15 @@
                 } else {
                     expected = 1 + (B != C);
                 }
-                assert(rootCount == expected);
+                SkASSERT(rootCount == expected);
                 if (!rootCount) {
                     continue;
                 }
-                assert(approximately_equal(roots[0], -B)
+                SkASSERT(approximately_equal(roots[0], -B)
                         || approximately_equal(roots[0], -C));
                 if (expected > 1) {
-                    assert(!approximately_equal(roots[0], roots[1]));
-                    assert(approximately_equal(roots[1], -B)
+                    SkASSERT(!approximately_equal(roots[0], roots[1]));
+                    SkASSERT(approximately_equal(roots[1], -B)
                             || approximately_equal(roots[1], -C));
                 }
             }
@@ -81,26 +79,26 @@
     } else {
         expected = 1 + (B != C) + (B != D && C != D);
     }
-    assert(rootCount == expected);
+    SkASSERT(rootCount == expected);
     if (!rootCount) {
         return;
     }
-    assert(approximately_equal(roots[0], -B)
+    SkASSERT(approximately_equal(roots[0], -B)
             || approximately_equal(roots[0], -C)
             || approximately_equal(roots[0], -D));
     if (expected <= 1) {
         return;
     }
-    assert(!approximately_equal(roots[0], roots[1]));
-    assert(approximately_equal(roots[1], -B)
+    SkASSERT(!approximately_equal(roots[0], roots[1]));
+    SkASSERT(approximately_equal(roots[1], -B)
             || approximately_equal(roots[1], -C)
             || approximately_equal(roots[1], -D));
     if (expected <= 2) {
         return;
     }
-    assert(!approximately_equal(roots[0], roots[2])
+    SkASSERT(!approximately_equal(roots[0], roots[2])
             && !approximately_equal(roots[1], roots[2]));
-    assert(approximately_equal(roots[2], -B)
+    SkASSERT(approximately_equal(roots[2], -B)
             || approximately_equal(roots[2], -C)
             || approximately_equal(roots[2], -D));
 }
@@ -136,35 +134,35 @@
         rootCount = quarticRootsReal(A, b, c, d, e, roots);
     }
     const int expected = 1 + (B != C) + (B != D && C != D) + (B != E && C != E && D != E);
-    assert(rootCount == expected);
-    assert(AlmostEqualUlps(roots[0], -B)
+    SkASSERT(rootCount == expected);
+    SkASSERT(AlmostEqualUlps(roots[0], -B)
             || AlmostEqualUlps(roots[0], -C)
             || AlmostEqualUlps(roots[0], -D)
             || AlmostEqualUlps(roots[0], -E));
     if (expected <= 1) {
         return;
     }
-    assert(!AlmostEqualUlps(roots[0], roots[1]));
-    assert(AlmostEqualUlps(roots[1], -B)
+    SkASSERT(!AlmostEqualUlps(roots[0], roots[1]));
+    SkASSERT(AlmostEqualUlps(roots[1], -B)
             || AlmostEqualUlps(roots[1], -C)
             || AlmostEqualUlps(roots[1], -D)
             || AlmostEqualUlps(roots[1], -E));
     if (expected <= 2) {
         return;
     }
-    assert(!AlmostEqualUlps(roots[0], roots[2])
+    SkASSERT(!AlmostEqualUlps(roots[0], roots[2])
             && !AlmostEqualUlps(roots[1], roots[2]));
-    assert(AlmostEqualUlps(roots[2], -B)
+    SkASSERT(AlmostEqualUlps(roots[2], -B)
             || AlmostEqualUlps(roots[2], -C)
             || AlmostEqualUlps(roots[2], -D)
             || AlmostEqualUlps(roots[2], -E));
     if (expected <= 3) {
         return;
     }
-    assert(!AlmostEqualUlps(roots[0], roots[3])
+    SkASSERT(!AlmostEqualUlps(roots[0], roots[3])
             && !AlmostEqualUlps(roots[1], roots[3])
             && !AlmostEqualUlps(roots[2], roots[3]));
-    assert(AlmostEqualUlps(roots[3], -B)
+    SkASSERT(AlmostEqualUlps(roots[3], -B)
             || AlmostEqualUlps(roots[3], -C)
             || AlmostEqualUlps(roots[3], -D)
             || AlmostEqualUlps(roots[3], -E));