From 9c81cffc32a5e88ac9f81fe3d08c2a670efa79d2 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@gmail.com>
Date: Thu, 2 Jan 2020 12:48:57 +0100
Subject: new_type: implement multiplication

---
 test/src/arithmetic_suite.cpp | 49 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

(limited to 'test')

diff --git a/test/src/arithmetic_suite.cpp b/test/src/arithmetic_suite.cpp
index b7713e0..e77c1dd 100644
--- a/test/src/arithmetic_suite.cpp
+++ b/test/src/arithmetic_suite.cpp
@@ -111,7 +111,7 @@ inline namespace subtraction_tests
   auto subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type() -> void
   {
     using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>;
-    ASSERT((std::is_same_v<type_alias, decltype(std::declval<type_alias const &>() + std::declval<type_alias const &>())>));
+    ASSERT((std::is_same_v<type_alias, decltype(std::declval<type_alias const &>() - std::declval<type_alias const &>())>));
   }
 
   auto subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type() -> void
@@ -124,6 +124,45 @@ inline namespace subtraction_tests
 
 }  // namespace subtraction_tests
 
+inline namespace multiplication_tests
+{
+
+  auto a_new__type_not_deriving_arithmetic_is_not_multipliable_with_instances_of_itself() -> void
+  {
+    using type_alias = nt::new_type<int, struct tag>;
+    ASSERT(!(nt::impl::is_multipliable_v<type_alias>));
+  }
+
+  auto a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself() -> void
+  {
+    using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>;
+    ASSERT(nt::impl::is_multipliable_v<type_alias>);
+  }
+
+  template<typename T>
+  auto a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable() -> void
+  {
+    static_assert(nt::impl::is_multipliable_v<T>, "Sanity Check");
+    using type_alias = nt::new_type<T, struct tag, deriving(nt::Arithmetic)>;
+    ASSERT_EQUAL(nt::impl::is_multipliable_v<T>, nt::impl::is_multipliable_v<type_alias>);
+  }
+
+  auto multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type() -> void
+  {
+    using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>;
+    ASSERT((std::is_same_v<type_alias, decltype(std::declval<type_alias const &>() * std::declval<type_alias const &>())>));
+  }
+
+  auto multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type() -> void
+  {
+    using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>;
+    auto lhs = type_alias{24};
+    auto rhs = type_alias{18};
+    ASSERT_EQUAL(24 * 18, (lhs * rhs).decay());
+  }
+
+}  // namespace multiplication_tests
+
 auto arithmetic_suite() -> std::pair<cute::suite, std::string>
 {
   return {
@@ -143,6 +182,14 @@ auto arithmetic_suite() -> std::pair<cute::suite, std::string>
           KAWAII(a_new__type_deriving_arithmetic_is_subtractable_with_instances_of_itself_if_the_base_type_is_subtractable<subtractable_type>),
           KAWAII(subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type),
           KAWAII(subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type),
+
+          /// Multiplication Tests
+          KAWAII(a_new__type_not_deriving_arithmetic_is_not_multipliable_with_instances_of_itself),
+          KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself),
+          KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable<int>),
+          KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable<multipliable_type>),
+          KAWAII(multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type),
+          KAWAII(multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type),
       },
       "Arithmetic Operators Tests"};
 }
\ No newline at end of file
-- 
cgit v1.2.3