Test all other current arithmetic operations.

test/opaque_typedef_adhoc_arithmatic_test.cxx

@@ -43,7 +43,7 @@ void PrintTo(mps const & ot, std::ostream * os) {
 }
 
 // Actual Test Bodies
-TEST(OpaqueTypedefArithmaticTest, CanDefineExternalFunctionsForTypeMerging) {
+TEST(OpaqueTypedefTest, CanDefineExternalFunctionsForTypeMerging) {
   meters m{10.0};
   seconds s{0.5};
 

test/opaque_typedef_arithmatic_test.cxx

@@ -23,12 +23,19 @@ template <typename T> void operator++(T, int);
 template <typename T> void operator++(T);
 template <typename T> void operator--(T, int);
 template <typename T> void operator--(T);
+template <typename T> void operator-(T, T);
+template <typename T> void operator-(T);
+template <typename T> void operator*(T, T);
+template <typename T> void operator/(T, T);
 
 // Types for Test Cases
 using namespace types;
 using counter = opaque_typedef<uint32_t, struct counter_tag, Incrementable>;
 using countdown = opaque_typedef<uint32_t, struct countdown_tag, Decrementable>;
 using idx = opaque_typedef<uint32_t, struct idx_tag, Incrementable, Decrementable>;
+using timer = opaque_typedef<double, struct timer_tag, Addable>;
+using price = opaque_typedef<double, struct price_tag, Arithmatic>;
+using shares = opaque_typedef<double, struct shares_tag, Numeric>;
 
 // Actual Test Bodies
 TEST(OpaqueTypedefDecrementableTest, CannotDecrement) {
@@ -67,10 +74,64 @@ TEST(OpaqueTypedefDecrementableTest, CanPreDecrement) {
   EXPECT_THAT(c, testing::Eq(countdown{9}));
 }
 
-TEST(OpaqueTypedefArithmaticTest, CanMergeIncrementAndDecrement) {
+TEST(OpaqueTypedefTest, CanMergeIncrementAndDecrement) {
   idx i{1};
   EXPECT_TRUE((testing::StaticAssertTypeEq<idx, decltype(i--)>()));
   EXPECT_TRUE((testing::StaticAssertTypeEq<idx&, decltype(--i)>()));
   EXPECT_TRUE((testing::StaticAssertTypeEq<idx, decltype(i++)>()));
   EXPECT_TRUE((testing::StaticAssertTypeEq<idx&, decltype(++i)>()));
 }
+
+TEST(OpaqueTypedefAddableTest, CannotSubtractOrNegate) {
+  timer t{5.0};
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(t-t)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(-t)>()));
+}
+
+TEST(OpaqueTypedefAddableTest, CanPerformAddition) {
+  timer t{5.0};
+  EXPECT_TRUE((testing::StaticAssertTypeEq<timer, decltype(t+t)>()));
+}
+
+TEST(OpaqueTypedefAddableTest, AddPassesThroughToBase) {
+  timer t{5.0};
+  EXPECT_THAT(t+t, testing::Eq(timer(10.0)));
+}
+
+TEST(OpaqueTypedefArithmaticTest, CannotMultiplyOrDivide) {
+  price p{99.99};
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(p*p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<void, decltype(p/p)>()));
+}
+
+TEST(OpaqueTypedefArithmaticTest, CanAddSubtractAndNegate) {
+  price p{99.99};
+  EXPECT_TRUE((testing::StaticAssertTypeEq<price, decltype(p+p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<price, decltype(p-p)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<price, decltype(-p)>()));
+}
+
+TEST(OpaqueTypedefArithmaticTest, PassesThroughToBase) {
+  price p{50.0};
+  EXPECT_THAT(p+p, testing::Eq(price(100.0)));
+  EXPECT_THAT(p-p, testing::Eq(price(0.0)));
+  EXPECT_THAT(-p, testing::Eq(price(-50.0)));
+}
+
+TEST(OpaqueTypedefNumericTest, CanPerformAllBinaryOpsAndNegation) {
+  shares s{100.0};
+  EXPECT_TRUE((testing::StaticAssertTypeEq<shares, decltype(s+s)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<shares, decltype(s-s)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<shares, decltype(s*s)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<shares, decltype(s/s)>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<shares, decltype(-s)>()));
+}
+
+TEST(OpaqueTypedefNumericTest, PassesThroughToBase) {
+  shares s{100.0};
+  EXPECT_THAT(s+s, testing::Eq(shares(200.0)));
+  EXPECT_THAT(s-s, testing::Eq(shares(0.0)));
+  EXPECT_THAT(s*s, testing::Eq(shares(10000.0)));
+  EXPECT_THAT(s/s, testing::Eq(shares(1.0)));
+  EXPECT_THAT(-s, testing::Eq(shares(-100.0)));
+}