Re-order test files to be cleaner, eliminate most using declarations.

test/opaque_typedef_adhoc_arithmatic_test.cxx

@@ -12,9 +12,15 @@
 #include "opaque_typedef/arithmatic.hpp"
 #include "opaque_typedef/opaque_typedef.hpp"
 
-using namespace types;
-using testing::StaticAssertTypeEq;
 
+// Allow Eq() checks without needing the Skill EqualityComparable
+template <typename T>
+bool operator==(T const & lhs, T const & rhs) {
+  return lhs.get() == rhs.get();
+}
+
+// Types for Test Cases
+using namespace types;
 using meters = opaque_typedef<double, struct meters_tag>;
 using seconds = opaque_typedef<double, struct seconds_tag>;
 using mps = opaque_typedef<double, struct mps_tag>;
@@ -23,6 +29,7 @@ mps operator/(meters m, seconds s) {
   return mps{m.get() / s.get()};
 }
 
+// Testing Printers
 std::ostream & operator<<(std::ostream & os, meters const & ot) {
   return os << double(ot) << "m";
 }
@@ -35,15 +42,12 @@ void PrintTo(mps const & ot, std::ostream * os) {
   (*os) << double(ot) << "m/s";
 }
 
-template <typename T>
-bool operator==(T const & lhs, T const & rhs) {
-  return lhs.get() == rhs.get();
-}
-
+// Actual Test Bodies
 TEST(OpaqueTypedefArithmaticTest, CanDefineExternalFunctionsForTypeMerging) {
   meters m{10.0};
   seconds s{0.5};
 
-  EXPECT_TRUE((StaticAssertTypeEq<mps, decltype(m/s)>()));
-  EXPECT_THAT((m/s), mps(20.0)) << "     lhs: " << m << "\n     rhs: " <<  s;
+  EXPECT_TRUE((testing::StaticAssertTypeEq<mps, decltype(m/s)>()));
+  EXPECT_THAT((m/s), testing::Eq(mps(20.0)))
+    << "     lhs: " << m << "\n     rhs: " <<  s;
 }

test/opaque_typedef_comparable_test.cxx

@@ -8,14 +8,25 @@
 
 #include <gmock/gmock.h>
 
+#include "opaque_typedef/comparable.hpp"
 #include "opaque_typedef/opaque_typedef.hpp"
 
-using namespace types;
+// Make compilation (but not linking) possible for StaticAssertTypeEq to check
+// 'does a real version of this function exist'
+template <typename T> void operator==(T const &, T const &);
+template <typename T> void operator!=(T const &, T const &);
+template <typename T> void operator<(T const &, T const &);
+template <typename T> void operator<=(T const &, T const &);
+template <typename T> void operator>(T const &, T const &);
+template <typename T> void operator>=(T const &, T const &);
 
+// Types for Test Cases
+using namespace types;
 using incomparible = opaque_typedef<int, struct incomparible_tag>;
 using port = opaque_typedef<int, struct port_tag, EqualityComparable>;
 using x_pos = opaque_typedef<int, struct x_pos_tag, Comparable>;
 
+// Testing Printers
 void PrintTo(incomparible const & ot, std::ostream * os) {
   (*os) << "incomparible";
 }
@@ -28,71 +39,61 @@ void PrintTo(x_pos const & ot, std::ostream * os) {
   (*os) << "x:" << int(ot);
 }
 
-using testing::StaticAssertTypeEq;
-using testing::Eq;
-using testing::Ne;
-using testing::Gt;
-using testing::Ge;
-using testing::Lt;
-using testing::Le;
-
-template <typename T> void operator==(T const &, T const &);
-template <typename T> void operator!=(T const &, T const &);
-template <typename T> void operator<(T const &, T const &);
-template <typename T> void operator<=(T const &, T const &);
-template <typename T> void operator>(T const &, T const &);
-template <typename T> void operator>=(T const &, T const &);
-
-TEST(OpaqueTypedefCompareTest, CannotCompareWithoutSkill) {
+// Actual Test Bodies
+TEST(OpaqueTypedefNotComparableTest, CannotCompareAny) {
   incomparible i(1);
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(i == i)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(i != i)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(i < i)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(i <= i)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(i > i)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(i >= i)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(i == i)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(i != i)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(i < i)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(i <= i)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(i > i)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(i >= i)>()));
 }
 
-TEST(OpaqueTypedefCompareTest, CanCheckEqWithEqCompSkill) {
+TEST(OpaqueTypedefEqualityComparableTest, CanCheckEq) {
   port p(80);
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(p == p)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(p != p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(p == p)>()));
 }
 
-TEST(OpaqueTypedefCompareTest, CannotOrderWithoutComparableSkill) {
+TEST(OpaqueTypedefEqualityComparableTest, CanCheckNotEq) {
   port p(80);
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(p < p)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(p <= p)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(p > p)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<void, decltype(p >= p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(p != p)>()));
 }
 
-TEST(OpaqueTypedefCompareTest, CanOrderWithComparableSkill) {
-  x_pos x(0);
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(x == x)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(x != x)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(x < x)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(x <= x)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(x > x)>()));
-  EXPECT_TRUE((StaticAssertTypeEq<bool, decltype(x >= x)>()));
+TEST(OpaqueTypedefEqualityComparableTest, CannotCompareOrder) {
+  port p(80);
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(p < p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(p <= p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(p > p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(p >= p)>()));
 }
 
-TEST(OpaqueTypedefCompareTest, CanCompareEqualityWithEqCompSkill) {
+TEST(OpaqueTypedefEqualityComparableTest, EqAndNePassThroughToBaseType) {
   port http{80};
   port https{443};
-  EXPECT_THAT(http, Eq(port{80}));
-  EXPECT_THAT(http, Ne(https));
+  EXPECT_THAT(http, testing::Eq(port{80}));
+  EXPECT_THAT(http, testing::Ne(https));
+}
+
+TEST(OpaqueTypedefCompareableTest, CanCompareAll) {
+  x_pos x(0);
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(x == x)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(x != x)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(x < x)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(x <= x)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(x > x)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<bool, decltype(x >= x)>()));
 }
 
-TEST(OpaqueTypedefCompareTest, CanCompareOrderingWithCompSkill) {
+TEST(OpaqueTypedefCompareableTest, ComparePassesThroughToBaseType) {
   x_pos x1{0};
   x_pos x2{1};
-  EXPECT_THAT(x1, Eq(x1));
-  EXPECT_THAT(x1, Ne(x2));
-  EXPECT_THAT(x1, Lt(x2));
-  EXPECT_THAT(x1, Le(x2));
-  EXPECT_THAT(x1, Le(x1));
-  EXPECT_THAT(x2, Gt(x1));
-  EXPECT_THAT(x2, Ge(x1));
-  EXPECT_THAT(x1, Ge(x1));
+  EXPECT_THAT(x1, testing::Eq(x1));
+  EXPECT_THAT(x1, testing::Ne(x2));
+  EXPECT_THAT(x1, testing::Lt(x2));
+  EXPECT_THAT(x1, testing::Le(x2));
+  EXPECT_THAT(x1, testing::Le(x1));
+  EXPECT_THAT(x2, testing::Gt(x1));
+  EXPECT_THAT(x2, testing::Ge(x1));
+  EXPECT_THAT(x1, testing::Ge(x1));
 }

test/opaque_typedef_conversion_test.cxx

@@ -9,8 +9,14 @@
 
 #include "opaque_typedef/opaque_typedef.hpp"
 
-using namespace types;
+// Allow Eq() checks without needing the Skill EqualityComparable
+template <typename T>
+bool operator==(T const & lhs, T const & rhs) {
+  return lhs.get() == rhs.get();
+}
 
+// Types for Test Cases
+using namespace types;
 using degree = opaque_typedef<double, struct degree_tag>;
 using radian = opaque_typedef<double, struct radian_tag>;
 
@@ -20,6 +26,7 @@ template <> template <> radian::opaque_typedef(degree const & other)
 template <> template <> degree::opaque_typedef(radian const & other)
     : degree(other.get() * 90.0 / M_PI_2) {}
 
+// Testing Printers
 void PrintTo(radian const & ot, std::ostream * os) {
   (*os) << double(ot)/M_PI << "π";
 }
@@ -28,24 +35,19 @@ void PrintTo(degree const & ot, std::ostream * os) {
   (*os) << double(ot) << "°";
 }
 
-template <typename T>
-bool operator==(T const & lhs, T const & rhs) {
-  return lhs.get() == rhs.get();
-}
-
+// Actual Test Bodies
 TEST(OpaqueTypedefConversionTest, CanCastObjects) {
   degree deg{90.0};
   radian rad{M_PI_2};
   
-  EXPECT_THAT(radian(deg), rad);
-  EXPECT_THAT(degree(rad), deg);
+  EXPECT_THAT(radian(deg), testing::Eq(rad));
+  EXPECT_THAT(degree(rad), testing::Eq(deg));
 }
 
 TEST(OpaqueTypedefConversionTest, ManualConversionDoesNotScale) {
-  using testing::Not;
   degree deg{90.0};
   radian rad{M_PI_2};
   
-  EXPECT_THAT(radian(double(deg)), Not(rad));
-  EXPECT_THAT(degree(double(rad)), Not(deg));
+  EXPECT_THAT(radian(double(deg)), testing::Not(rad));
+  EXPECT_THAT(degree(double(rad)), testing::Not(deg));
 }