Warning and 'using' cleanup.

(bzr r6970)

6 files changed, 59 insertions, 73 deletions

diff --git a/src/libnr/nr-matrix-test.h b/src/libnr/nr-matrix-test.h
index b5c15b60b..d4267ffa5 100644
--- a/src/libnr/nr-matrix-test.h
+++ b/src/libnr/nr-matrix-test.h
@@ -13,14 +13,11 @@
 #include <libnr/nr-translate.h>
 #include <libnr/nr-translate-ops.h>
 #include <libnr/nr-translate-scale-ops.h>
-using NR::Matrix;
-using NR::X;
-using NR::Y;
 
 inline bool point_equalp(NR::Point const &a, NR::Point const &b)
 {
-    return ( NR_DF_TEST_CLOSE(a[X], b[X], 1e-5) &&
-             NR_DF_TEST_CLOSE(a[Y], b[Y], 1e-5)   );
+    return ( NR_DF_TEST_CLOSE(a[NR::X], b[NR::X], 1e-5) &&
+             NR_DF_TEST_CLOSE(a[NR::Y], b[NR::Y], 1e-5)   );
 }
 
 class NrMatrixTest : public CxxTest::TestSuite
@@ -47,10 +44,10 @@ public:
     static NrMatrixTest *createSuite() { return new NrMatrixTest(); }
     static void destroySuite( NrMatrixTest *suite ) { delete suite; }
 
-    Matrix const m_id;
+    NR::Matrix const m_id;
     NR::rotate const r_id;
     NR::translate const t_id;
-    Matrix const c16;
+    NR::Matrix const c16;
     NR::rotate const r86;
     NR::Matrix const mr86;
     NR::translate const t23;
@@ -61,8 +58,8 @@ public:
 
     void testCtorsAssignmentOp(void)
     {
-        Matrix const c16_copy(c16);
-        Matrix c16_eq(m_id);
+        NR::Matrix const c16_copy(c16);
+        NR::Matrix c16_eq(m_id);
         c16_eq = c16;
         for(unsigned i = 0; i < 6; ++i) {
             TS_ASSERT_EQUALS( c16[i], 1.0 + i );
@@ -89,7 +86,7 @@ public:
         TS_ASSERT_EQUALS( p0 * mr86, NR::Point(.8, .6) );
         TS_ASSERT_EQUALS( p90 * r86, NR::Point(-.6, .8) );
         TS_ASSERT_EQUALS( p90 * mr86, NR::Point(-.6, .8) );
-        TS_ASSERT( matrix_equalp(Matrix( r86 * r86 ),
+        TS_ASSERT( matrix_equalp(NR::Matrix( r86 * r86 ),
                                  mr86 * mr86,
                                  1e-14) );
     }
@@ -104,26 +101,26 @@ public:
     void testIdentity(void)
     {
         TS_ASSERT( m_id.test_identity() );
-        TS_ASSERT( Matrix(t_id).test_identity() );
-        TS_ASSERT( !(Matrix(NR::translate(-2, 3)).test_identity()) );
-        TS_ASSERT( Matrix(r_id).test_identity() );
+        TS_ASSERT( NR::Matrix(t_id).test_identity() );
+        TS_ASSERT( !(NR::Matrix(NR::translate(-2, 3)).test_identity()) );
+        TS_ASSERT( NR::Matrix(r_id).test_identity() );
         NR::rotate const rot180(NR::Point(-1, 0));
-        TS_ASSERT( !(Matrix(rot180).test_identity()) );
-        TS_ASSERT( Matrix(s_id).test_identity() );
-        TS_ASSERT( !(Matrix(NR::scale(1.0, 0.0)).test_identity()) );
-        TS_ASSERT( !(Matrix(NR::scale(0.0, 1.0)).test_identity()) );
-        TS_ASSERT( !(Matrix(NR::scale(1.0, -1.0)).test_identity()) );
-        TS_ASSERT( !(Matrix(NR::scale(-1.0, -1.0)).test_identity()) );
+        TS_ASSERT( !(NR::Matrix(rot180).test_identity()) );
+        TS_ASSERT( NR::Matrix(s_id).test_identity() );
+        TS_ASSERT( !(NR::Matrix(NR::scale(1.0, 0.0)).test_identity()) );
+        TS_ASSERT( !(NR::Matrix(NR::scale(0.0, 1.0)).test_identity()) );
+        TS_ASSERT( !(NR::Matrix(NR::scale(1.0, -1.0)).test_identity()) );
+        TS_ASSERT( !(NR::Matrix(NR::scale(-1.0, -1.0)).test_identity()) );
     }
 
     void testInverse(void)
     {
         TS_ASSERT_EQUALS( m_id.inverse(), m_id );
-        TS_ASSERT_EQUALS( Matrix(t23).inverse(), Matrix(NR::translate(-2.0, -3.0)) );
+        TS_ASSERT_EQUALS( NR::Matrix(t23).inverse(), NR::Matrix(NR::translate(-2.0, -3.0)) );
         NR::scale const s2(-4.0, 2.0);
         NR::scale const sp5(-.25, .5);
-        TS_ASSERT_EQUALS( Matrix(s2).inverse(), Matrix(sp5) );
-        TS_ASSERT_EQUALS( Matrix(sp5).inverse(), Matrix(s2) );
+        TS_ASSERT_EQUALS( NR::Matrix(s2).inverse(), NR::Matrix(sp5) );
+        TS_ASSERT_EQUALS( NR::Matrix(sp5).inverse(), NR::Matrix(s2) );
     }
 
     void testEllipticQuadraticForm(void)
diff --git a/src/libnr/nr-point-fns-test.h b/src/libnr/nr-point-fns-test.h
index bd6605802..7d28c9c0e 100644
--- a/src/libnr/nr-point-fns-test.h
+++ b/src/libnr/nr-point-fns-test.h
@@ -9,8 +9,6 @@
 #include "libnr/nr-point-fns.h"
 #include "2geom/isnan.h"
 
-using NR::Point;
-
 class NrPointFnsTest : public CxxTest::TestSuite
 {
 public:
@@ -46,16 +44,16 @@ public:
     }
 
     bool setupValid;
-    Point const p3n4;
-    Point const p0;
+    NR::Point const p3n4;
+    NR::Point const p0;
     double const small;
     double const inf;
     double const nan;
 
-    Point const small_left;
-    Point const small_n3_4;
-    Point const part_nan;
-    Point const inf_left;
+    NR::Point const small_left;
+    NR::Point const small_n3_4;
+    NR::Point const part_nan;
+    NR::Point const inf_left;
 
 
     void testL1(void)
@@ -107,9 +105,9 @@ public:
 
     void testUnitVector(void)
     {
-        TS_ASSERT_EQUALS( NR::unit_vector(p3n4), Point(.6, -0.8) );
-        TS_ASSERT_EQUALS( NR::unit_vector(small_left), Point(-1.0, 0.0) );
-        TS_ASSERT_EQUALS( NR::unit_vector(small_n3_4), Point(-.6, 0.8) );
+        TS_ASSERT_EQUALS( NR::unit_vector(p3n4), NR::Point(.6, -0.8) );
+        TS_ASSERT_EQUALS( NR::unit_vector(small_left), NR::Point(-1.0, 0.0) );
+        TS_ASSERT_EQUALS( NR::unit_vector(small_n3_4), NR::Point(-.6, 0.8) );
     }
 
     void testIsUnitVector(void)
@@ -119,13 +117,13 @@ public:
         TS_ASSERT( !NR::is_unit_vector(small_n3_4) );
         TS_ASSERT( !NR::is_unit_vector(part_nan) );
         TS_ASSERT( !NR::is_unit_vector(inf_left) );
-        TS_ASSERT( !NR::is_unit_vector(Point(.5, 0.5)) );
-        TS_ASSERT( NR::is_unit_vector(Point(.6, -0.8)) );
-        TS_ASSERT( NR::is_unit_vector(Point(-.6, 0.8)) );
-        TS_ASSERT( NR::is_unit_vector(Point(-1.0, 0.0)) );
-        TS_ASSERT( NR::is_unit_vector(Point(1.0, 0.0)) );
-        TS_ASSERT( NR::is_unit_vector(Point(0.0, -1.0)) );
-        TS_ASSERT( NR::is_unit_vector(Point(0.0, 1.0)) );
+        TS_ASSERT( !NR::is_unit_vector(NR::Point(.5, 0.5)) );
+        TS_ASSERT( NR::is_unit_vector(NR::Point(.6, -0.8)) );
+        TS_ASSERT( NR::is_unit_vector(NR::Point(-.6, 0.8)) );
+        TS_ASSERT( NR::is_unit_vector(NR::Point(-1.0, 0.0)) );
+        TS_ASSERT( NR::is_unit_vector(NR::Point(1.0, 0.0)) );
+        TS_ASSERT( NR::is_unit_vector(NR::Point(0.0, -1.0)) );
+        TS_ASSERT( NR::is_unit_vector(NR::Point(0.0, 1.0)) );
     }
 };
 
diff --git a/src/libnr/nr-rotate-test.h b/src/libnr/nr-rotate-test.h
index 252b25022..5514d09d1 100644
--- a/src/libnr/nr-rotate-test.h
+++ b/src/libnr/nr-rotate-test.h
@@ -8,8 +8,6 @@
 #include <libnr/nr-rotate.h>
 #include <libnr/nr-rotate-fns.h>
 #include <libnr/nr-rotate-ops.h>
-using NR::X;
-using NR::Y;
 
 
 class NrRotateTest : public CxxTest::TestSuite
diff --git a/src/libnr/nr-scale-test.h b/src/libnr/nr-scale-test.h
index dc5e6ef28..938e8e14d 100644
--- a/src/libnr/nr-scale-test.h
+++ b/src/libnr/nr-scale-test.h
@@ -2,8 +2,6 @@
 
 #include <libnr/nr-scale.h>
 #include <libnr/nr-scale-ops.h>
-using NR::X;
-using NR::Y;
 
 class NrScaleTest : public CxxTest::TestSuite
 {
@@ -30,8 +28,8 @@ public:
 
     void testXY_CtorArrayOperator(void)
     {
-        TS_ASSERT_EQUALS( sa[X], 1.5 );
-        TS_ASSERT_EQUALS( sa[Y], 2.0 );
+        TS_ASSERT_EQUALS( sa[NR::X], 1.5 );
+        TS_ASSERT_EQUALS( sa[NR::Y], 2.0 );
         TS_ASSERT_EQUALS( sa[0u], 1.5 );
         TS_ASSERT_EQUALS( sa[1u], 2.0 );
     }
@@ -54,8 +52,8 @@ public:
 
     void testPointCtor(void)
     {
-        TS_ASSERT_EQUALS( sb[X], b[X] );
-        TS_ASSERT_EQUALS( sb[Y], b[Y] );
+        TS_ASSERT_EQUALS( sb[NR::X], b[NR::X] );
+        TS_ASSERT_EQUALS( sb[NR::Y], b[NR::Y] );
     }
 
     void testOpStarPointScale(void)
diff --git a/src/libnr/nr-translate-test.h b/src/libnr/nr-translate-test.h
index 20b537a45..630f43523 100644
--- a/src/libnr/nr-translate-test.h
+++ b/src/libnr/nr-translate-test.h
@@ -7,8 +7,6 @@
 #include <libnr/nr-point-matrix-ops.h>
 #include <libnr/nr-translate.h>
 #include <libnr/nr-translate-ops.h>
-using NR::X;
-using NR::Y;
 
 class NrTranslateTest : public CxxTest::TestSuite
 {
@@ -40,11 +38,11 @@ public:
 
     void testCtorsArrayOperator(void)
     {
-        TS_ASSERT_EQUALS( tc[X], -3.0 );
-        TS_ASSERT_EQUALS( tc[Y], -2.0 );
+        TS_ASSERT_EQUALS( tc[NR::X], -3.0 );
+        TS_ASSERT_EQUALS( tc[NR::Y], -2.0 );
 
-        TS_ASSERT_EQUALS( tb[0], b[X] );
-        TS_ASSERT_EQUALS( tb[1], b[Y] );
+        TS_ASSERT_EQUALS( tb[0], b[NR::X] );
+        TS_ASSERT_EQUALS( tb[1], b[NR::Y] );
     }
 
     void testAssignmentOperator(void)
diff --git a/src/libnr/nr-types-test.h b/src/libnr/nr-types-test.h
index d51db1be7..e472c2d29 100644
--- a/src/libnr/nr-types-test.h
+++ b/src/libnr/nr-types-test.h
@@ -4,9 +4,6 @@
 #include "libnr/nr-types.h"
 #include "libnr/nr-point-fns.h"
 #include <cmath>
-using NR::Point;
-using NR::X;
-using NR::Y;
 
 class NrTypesTest : public CxxTest::TestSuite
 {
@@ -30,20 +27,20 @@ public:
     NR::Point const b;
     NR::Point const ab;
     double const small;
-    Point const small_left;
-    Point const smallish_3_neg4;
+    NR::Point const small_left;
+    NR::Point const smallish_3_neg4;
 
 
     void testXYValues( void )
     {
-        TS_ASSERT_EQUALS( X, 0 );
-        TS_ASSERT_EQUALS( Y, 1 );
+        TS_ASSERT_EQUALS( NR::X, 0 );
+        TS_ASSERT_EQUALS( NR::Y, 1 );
     }
 
     void testXYCtorAndArrayConst(void)
     {
-        TS_ASSERT_EQUALS( a[X], 1.5 );
-        TS_ASSERT_EQUALS( a[Y], 2.0 );
+        TS_ASSERT_EQUALS( a[NR::X], 1.5 );
+        TS_ASSERT_EQUALS( a[NR::Y], 2.0 );
     }
 
     void testCopyCtor(void)
@@ -57,10 +54,10 @@ public:
     void testNonConstArrayOperator(void)
     {
         NR::Point a_copy(a);
-        a_copy[X] = -2.0;
+        a_copy[NR::X] = -2.0;
         TS_ASSERT_DIFFERS( a_copy, a );
         TS_ASSERT_DIFFERS( a_copy, b );
-        a_copy[Y] = 3.0;
+        a_copy[NR::Y] = 3.0;
         TS_ASSERT_EQUALS( a_copy, b );
     }
 
@@ -75,7 +72,7 @@ public:
 
     void testUnaryMinus(void)
     {
-        TS_ASSERT_EQUALS( -a, Point(-a[X], -a[Y]) );
+        TS_ASSERT_EQUALS( -a, NR::Point(-a[NR::X], -a[NR::Y]) );
     }
 
     void tetScaleDivide(void)
@@ -87,8 +84,8 @@ public:
 
     void testDot(void)
     {
-        TS_ASSERT_EQUALS( dot(a, b), ( a[X] * b[X]  +
-                                       a[Y] * b[Y] ) );
+        TS_ASSERT_EQUALS( dot(a, b), ( a[NR::X] * b[NR::X]  +
+                                       a[NR::Y] * b[NR::Y] ) );
         TS_ASSERT_EQUALS( dot(a, NR::rot90(a)), 0.0 );
         TS_ASSERT_EQUALS( dot(-a, NR::rot90(a)), 0.0 );
     }
@@ -108,27 +105,27 @@ public:
 
     void testOperatorPlusEquals(void)
     {
-        Point x(a);
+        NR::Point x(a);
         x += b;
         TS_ASSERT_EQUALS( x, ab );
     }
 
     void tetOperatorDivEquals(void)
     {
-        Point x(a);
+        NR::Point x(a);
         x /= .5;
         TS_ASSERT_EQUALS( x, a + a );
     }
 
     void testNormalize(void)
     {
-        Point x(small_left);
+        NR::Point x(small_left);
         x.normalize();
-        TS_ASSERT_EQUALS( x, Point(-1.0, 0.0) );
+        TS_ASSERT_EQUALS( x, NR::Point(-1.0, 0.0) );
 
         x = smallish_3_neg4;
         x.normalize();
-        TS_ASSERT_EQUALS( x, Point(0.6, -0.8) );
+        TS_ASSERT_EQUALS( x, NR::Point(0.6, -0.8) );
     }
 
 };