new_type: implement support for nt::Relational

7 files changed, 412 insertions, 6 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b78a58e..5f28c54 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -53,6 +53,7 @@ if(BUILD_TESTING)
     "${PROJECT_SOURCE_DIR}/test/src/conversion_suite.cpp"
     "${PROJECT_SOURCE_DIR}/test/src/equality_comparison_suite.cpp"
     "${PROJECT_SOURCE_DIR}/test/src/new_type_constructor_suite.cpp"
+    "${PROJECT_SOURCE_DIR}/test/src/relational_operators_suite.cpp"
     )
 
   target_include_directories("${PROJECT_NAME}_tests" PRIVATE
diff --git a/doc/src/index.rst b/doc/src/index.rst
index e9c69c0..907b58d 100644
--- a/doc/src/index.rst
+++ b/doc/src/index.rst
@@ -132,7 +132,7 @@ Synopsis
      template<typename BaseType,
               typename TagType,
               auto DerivationClause,
-              typename = std::enable_if_t<DerivationClause(nt::Relational)>
+              typename = std::enable_if_t<DerivationClause(nt::Relational)>>
      auto constexpr operator<(new_type<BaseType, TagType, DerivationClause> const &,
                               new_type<BaseType, TagType, DerivationClause> const &) noexcept(/*see below*/)
                               -> bool;
@@ -140,7 +140,7 @@ Synopsis
      template<typename BaseType,
               typename TagType,
               auto DerivationClause,
-              typename = std::enable_if_t<DerivationClause(nt::Relational)>
+              typename = std::enable_if_t<DerivationClause(nt::Relational)>>
      auto constexpr operator>(new_type<BaseType, TagType, DerivationClause> const &,
                               new_type<BaseType, TagType, DerivationClause> const &) noexcept(/*see below*/)
                               -> bool;
@@ -148,7 +148,7 @@ Synopsis
      template<typename BaseType,
               typename TagType,
               auto DerivationClause,
-              typename = std::enable_if_t<DerivationClause(nt::Relational)>
+              typename = std::enable_if_t<DerivationClause(nt::Relational)>>
      auto constexpr operator<=(new_type<BaseType, TagType, DerivationClause> const &,
                                new_type<BaseType, TagType, DerivationClause> const &) noexcept(/*see below*/)
                                -> bool;
@@ -156,7 +156,7 @@ Synopsis
      template<typename BaseType,
               typename TagType,
               auto DerivationClause,
-              typename = std::enable_if_t<DerivationClause(nt::Relational)>
+              typename = std::enable_if_t<DerivationClause(nt::Relational)>>
      auto constexpr operator>=(new_type<BaseType, TagType, DerivationClause> const &,
                                new_type<BaseType, TagType, DerivationClause> const &) noexcept(/*see below*/)
                                -> bool;
@@ -168,7 +168,7 @@ Synopsis
               auto DerivationClause,
               typename CharType,
               typename StreamTraits,
-              typename = std::enable_if_t<DerivationClause(nt::Show)>
+              typename = std::enable_if_t<DerivationClause(nt::Show)>>
      auto operator<<(std::basic_ostream<CharType, StreamTraits> &&,
                      new_type<BaseType, TagType, DerivationClause> const &) noexcept(/*see below*/)
                      -> std::basic_ostream<CharType, StreamTraits> &;
@@ -178,7 +178,7 @@ Synopsis
               auto DerivationClause,
               typename CharType,
               typename StreamTraits,
-              typename = std::enable_if_t<DerivationClause(nt::Read)>
+              typename = std::enable_if_t<DerivationClause(nt::Read)>>
      auto operator>>(std::basic_istream<CharType, StreamTraits> &&,
                      new_type<BaseType, TagType, DerivationClause> &&) noexcept(/*see below*/)
                      -> std::basic_istream<CharType, StreamTraits> &;
diff --git a/include/newtype/derivable.hpp b/include/newtype/derivable.hpp
index 4fec2b7..157bac7 100644
--- a/include/newtype/derivable.hpp
+++ b/include/newtype/derivable.hpp
@@ -50,6 +50,13 @@ namespace nt
     auto constexpr Read = derivable<struct read_tag>{};
 
     /**
+     * A tag to enable derivation of the relational operators
+     *
+     * @since 1.0.0
+     */
+    auto constexpr Relational = derivable<struct relational_tag>{};
+
+    /**
      * A tag to enable derivation of the stream output operator
      *
      * @since 1.0.0
diff --git a/include/newtype/new_type.hpp b/include/newtype/new_type.hpp
index c0fb8d3..17959ba 100644
--- a/include/newtype/new_type.hpp
+++ b/include/newtype/new_type.hpp
@@ -153,6 +153,70 @@ namespace nt
     return lhs.decay() != rhs.decay();
   }
 
+  /**
+   * Check if one nt::new_type object is less-than an other
+   *
+   * @note This overload participates only in overload resolution if the derivation clause of this @p new_type does contain
+   * nt::Relational
+   * @return true iff. the object contained by lhs is less-than the one contained by rhs
+   */
+  template<typename BaseType, typename TagType, auto DerivationClause, typename = std::enable_if_t<DerivationClause(nt::Relational)>>
+  auto constexpr operator<(new_type<BaseType, TagType, DerivationClause> const & lhs,
+                           new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(noexcept(std::declval<BaseType const &>() <
+                                                                                                        std::declval<BaseType const &>()))
+      -> bool
+  {
+    return lhs.decay() < rhs.decay();
+  }
+
+  /**
+   * Check if one nt::new_type object is greater-than an other
+   *
+   * @note This overload participates only in overload resolution if the derivation clause of this @p new_type does contain
+   * nt::Relational
+   * @return true iff. the object contained by lhs is greater-than the one contained by rhs
+   */
+  template<typename BaseType, typename TagType, auto DerivationClause, typename = std::enable_if_t<DerivationClause(nt::Relational)>>
+  auto constexpr operator>(new_type<BaseType, TagType, DerivationClause> const & lhs,
+                           new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(noexcept(std::declval<BaseType const &>() >
+                                                                                                        std::declval<BaseType const &>()))
+      -> bool
+  {
+    return lhs.decay() > rhs.decay();
+  }
+
+  /**
+   * Check if one nt::new_type object is less-than or equal-to an other
+   *
+   * @note This overload participates only in overload resolution if the derivation clause of this @p new_type does contain
+   * nt::Relational
+   * @return true iff. the object contained by lhs is less-than or equal-to the one contained by rhs
+   */
+  template<typename BaseType, typename TagType, auto DerivationClause, typename = std::enable_if_t<DerivationClause(nt::Relational)>>
+  auto constexpr operator<=(new_type<BaseType, TagType, DerivationClause> const & lhs,
+                            new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(noexcept(std::declval<BaseType const &>() <=
+                                                                                                         std::declval<BaseType const &>()))
+      -> bool
+  {
+    return lhs.decay() <= rhs.decay();
+  }
+
+  /**
+   * Check if one nt::new_type object is greater-than or equal-to an other
+   *
+   * @note This overload participates only in overload resolution if the derivation clause of this @p new_type does contain
+   * nt::Relational
+   * @return true iff. the object contained by lhs is greater-than or equal-to the one contained by rhs
+   */
+  template<typename BaseType, typename TagType, auto DerivationClause, typename = std::enable_if_t<DerivationClause(nt::Relational)>>
+  auto constexpr operator>=(new_type<BaseType, TagType, DerivationClause> const & lhs,
+                            new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(noexcept(std::declval<BaseType const &>() >=
+                                                                                                         std::declval<BaseType const &>()))
+      -> bool
+  {
+    return lhs.decay() >= rhs.decay();
+  }
+
 }  // namespace nt
 
 #endif
diff --git a/test/include/relational_operators_suite.hpp b/test/include/relational_operators_suite.hpp
new file mode 100644
index 0000000..259834b
--- /dev/null
+++ b/test/include/relational_operators_suite.hpp
@@ -0,0 +1,11 @@
+#ifndef NEWTYPE_TEST_RELATIONAL_OPERATORS_SUITE_HPP
+#define NEWTYPE_TEST_RELATIONAL_OPERATORS_SUITE_HPP
+
+#include <cute/cute_suite.h>
+
+#include <string>
+#include <utility>
+
+auto relational_operators_suite() -> std::pair<cute::suite, std::string>;
+
+#endif
\ No newline at end of file
diff --git a/test/src/driver.cpp b/test/src/driver.cpp
index f6afe58..1ba3d68 100644
--- a/test/src/driver.cpp
+++ b/test/src/driver.cpp
@@ -2,6 +2,7 @@
 #include "derivation_clause_suite.hpp"
 #include "equality_comparison_suite.hpp"
 #include "new_type_constructor_suite.hpp"
+#include "relational_operators_suite.hpp"
 
 #include <cute/cute.h>
 #include <cute/cute_runner.h>
@@ -53,6 +54,7 @@ int main(int argc, char ** argv)
       new_type_constructor_suite(),
       conversion_suite(),
       equality_comparison_suite(),
+      relational_operators_suite(),
   };
 
   auto selectors = get_test_selectors(suites);
diff --git a/test/src/relational_operators_suite.cpp b/test/src/relational_operators_suite.cpp
new file mode 100644
index 0000000..31955dd
--- /dev/null
+++ b/test/src/relational_operators_suite.cpp
@@ -0,0 +1,321 @@
+#include "relational_operators_suite.hpp"
+
+#include "kawaii.hpp"
+#include "newtype/derivable.hpp"
+#include "newtype/deriving.hpp"
+#include "newtype/new_type.hpp"
+
+#include <cute/cute.h>
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+inline namespace traits_extensions
+{
+
+  template<typename T, typename = void>
+  struct has_less_than : std::false_type
+  {
+  };
+
+  template<typename T>
+  struct has_less_than<T, std::void_t<decltype(std::declval<T const &>() < std::declval<T const &>())>> : std::true_type
+  {
+  };
+
+  template<typename T>
+  auto constexpr has_less_than_v = has_less_than<T>::value;
+
+  template<typename T, typename = void>
+  struct has_greater_than : std::false_type
+  {
+  };
+
+  template<typename T>
+  struct has_greater_than<T, std::void_t<decltype(std::declval<T const &>() > std::declval<T const &>())>> : std::true_type
+  {
+  };
+
+  template<typename T>
+  auto constexpr has_greater_than_v = has_greater_than<T>::value;
+
+  template<typename T, typename = void>
+  struct has_less_than_equal_to : std::false_type
+  {
+  };
+
+  template<typename T>
+  struct has_less_than_equal_to<T, std::void_t<decltype(std::declval<T const &>() <= std::declval<T const &>())>> : std::true_type
+  {
+  };
+
+  template<typename T>
+  auto constexpr has_less_than_equal_to_v = has_less_than_equal_to<T>::value;
+
+  template<typename T, typename = void>
+  struct has_greater_than_equal_to : std::false_type
+  {
+  };
+
+  template<typename T>
+  struct has_greater_than_equal_to<T, std::void_t<decltype(std::declval<T const &>() >= std::declval<T const &>())>> : std::true_type
+  {
+  };
+
+  template<typename T>
+  auto constexpr has_greater_than_equal_to_v = has_greater_than_equal_to<T>::value;
+
+}  // namespace traits_extensions
+
+inline namespace relational_operator_presence_tests
+{
+
+  auto an_instance_of_new__type_has_less_than_if_its_derivation_clause_contains_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_1, deriving(nt::Relational)>;
+    ASSERT(has_less_than_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_does_not_have_less_than_if_its_derivation_clause_does_not_contain_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_2>;
+    ASSERT(!has_less_than_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_has_greater_than_if_its_derivation_clause_contains_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_3, deriving(nt::Relational)>;
+    ASSERT(has_greater_than_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_does_not_have_greater_than_if_its_derivation_clause_does_not_contain_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_4>;
+    ASSERT(!has_greater_than_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_has_less_than_or_equal_to_if_its_derivation_clause_contains_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_5, deriving(nt::Relational)>;
+    ASSERT(has_less_than_equal_to_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_does_not_have_less_than_or_equal_to_if_its_derivation_clause_does_not_contain_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_6>;
+    ASSERT(!has_less_than_equal_to_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_has_greater_than_or_equal_to_if_its_derivation_clause_contains_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_7, deriving(nt::Relational)>;
+    ASSERT(has_greater_than_equal_to_v<type_alias>);
+  }
+
+  auto an_instance_of_new__type_does_not_have_greater_than_or_equal_to_if_its_derivation_clause_does_not_contain_relational() -> void
+  {
+    using type_alias = nt::new_type<int, struct relop_presensence_test_tag_8>;
+    ASSERT(!has_greater_than_equal_to_v<type_alias>);
+  }
+
+}  // namespace relational_operator_presence_tests
+
+inline namespace less_than_tests
+{
+
+  auto two_instances_of_the_same_new__type_compare_less_than_if_both_contained_values_would_compare_less_than() -> void
+  {
+    using type_alias = nt::new_type<int, struct less_than_test_tag_9, deriving(nt::Relational)>;
+    auto constexpr lhs{21};
+    auto constexpr rhs{42};
+    static_assert(lhs < rhs, "Sanity Check");
+    ASSERT_LESS(type_alias{lhs}, type_alias{rhs});
+  }
+
+  auto two_instances_of_the_same_new__type_do_not_compare_less_than_if_both_contained_values_would_not_compare_less_than() -> void
+  {
+    using type_alias = nt::new_type<int, struct less_than_test_tag_10, deriving(nt::Relational)>;
+    auto constexpr lhs{44};
+    auto constexpr rhs{42};
+    static_assert(!(lhs < rhs), "Sanity Check");
+    ASSERT(!(type_alias{lhs} < type_alias{rhs}));
+  }
+
+  auto two_instances_of_the_same_new__type_compare_less_than_or_equal_if_both_contained_values_would_compare_less_than_or_equal() -> void
+  {
+    using type_alias = nt::new_type<int, struct less_than_test_tag_11, deriving(nt::Relational)>;
+    auto constexpr lhs{33};
+    auto constexpr rhs{42};
+    static_assert(lhs <= rhs, "Sanity Check");
+    ASSERT_LESS_EQUAL(type_alias{lhs}, type_alias{rhs});
+  }
+
+  auto two_instances_of_the_same_new__type_do_not_compare_less_than_or_equal_if_both_contained_values_would_not_compare_less_than_or_equal()
+      -> void
+  {
+    using type_alias = nt::new_type<int, struct less_than_test_tag_12, deriving(nt::Relational)>;
+    auto constexpr lhs{87};
+    auto constexpr rhs{42};
+    static_assert(!(lhs < rhs), "Sanity Check");
+    ASSERT(!(type_alias{lhs} < type_alias{rhs}));
+  }
+
+}  // namespace less_than_tests
+
+inline namespace greater_than_tests
+{
+
+  auto two_instances_of_the_same_new__type_compare_greater_than_if_both_contained_values_would_compare_greater_than() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_13, deriving(nt::Relational)>;
+    auto constexpr lhs{42};
+    auto constexpr rhs{21};
+    static_assert(lhs > rhs, "Sanity Check");
+    ASSERT_GREATER(type_alias{lhs}, type_alias{rhs});
+  }
+
+  auto two_instances_of_the_same_new__type_do_not_compare_greater_than_if_both_contained_values_would_not_compare_greater_than() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_14, deriving(nt::Relational)>;
+    auto constexpr lhs{42};
+    auto constexpr rhs{44};
+    static_assert(!(lhs > rhs), "Sanity Check");
+    ASSERT(!(type_alias{lhs} > type_alias{rhs}));
+  }
+
+  auto two_instances_of_the_same_new__type_compare_greater_than_or_equal_if_both_contained_values_would_compare_greater_than_or_equal() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_15, deriving(nt::Relational)>;
+    auto constexpr lhs{42};
+    auto constexpr rhs{33};
+    static_assert(lhs >= rhs, "Sanity Check");
+    ASSERT_GREATER_EQUAL(type_alias{lhs}, type_alias{rhs});
+  }
+
+  auto
+  two_instances_of_the_same_new__type_do_not_compare_greater_than_or_equal_if_both_contained_values_would_not_compare_greater_than_or_equal()
+      -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_16, deriving(nt::Relational)>;
+    auto constexpr lhs{42};
+    auto constexpr rhs{87};
+    static_assert(!(lhs > rhs), "Sanity Check");
+    ASSERT(!(type_alias{lhs} > type_alias{rhs}));
+  }
+
+}  // namespace greater_than_tests
+
+inline namespace relational_operator_noexcept_tests
+{
+
+  struct strange_type
+  {
+    auto constexpr operator<(strange_type const & other) const noexcept(false) -> bool;
+    auto constexpr operator>(strange_type const & other) const noexcept(false) -> bool;
+    auto constexpr operator<=(strange_type const & other) const noexcept(false) -> bool;
+    auto constexpr operator>=(strange_type const & other) const noexcept(false) -> bool;
+  };
+
+  auto less_than_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_17, deriving(nt::Relational)>;
+    static_assert(noexcept(std::declval<int const &>() < std::declval<int const &>()), "Sanity Check");
+    ASSERT(noexcept(std::declval<type_alias const &>() < std::declval<type_alias const &>()));
+  }
+
+  auto less_than_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept() -> void
+  {
+    using type_alias = nt::new_type<strange_type, struct greater_than_test_tag_18, deriving(nt::Relational)>;
+    static_assert(!noexcept(std::declval<strange_type const &>() < std::declval<strange_type const &>()), "Sanity Check");
+    ASSERT(!noexcept(std::declval<type_alias const &>() < std::declval<type_alias const &>()));
+  }
+
+  auto less_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_19, deriving(nt::Relational)>;
+    static_assert(noexcept(std::declval<int const &>() <= std::declval<int const &>()), "Sanity Check");
+    ASSERT(noexcept(std::declval<type_alias const &>() <= std::declval<type_alias const &>()));
+  }
+
+  auto less_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept()
+      -> void
+  {
+    using type_alias = nt::new_type<strange_type, struct greater_than_test_tag_20, deriving(nt::Relational)>;
+    static_assert(!noexcept(std::declval<strange_type const &>() <= std::declval<strange_type const &>()), "Sanity Check");
+    ASSERT(!noexcept(std::declval<type_alias const &>() <= std::declval<type_alias const &>()));
+  }
+
+  auto greater_than_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_21, deriving(nt::Relational)>;
+    static_assert(noexcept(std::declval<int const &>() > std::declval<int const &>()), "Sanity Check");
+    ASSERT(noexcept(std::declval<type_alias const &>() > std::declval<type_alias const &>()));
+  }
+
+  auto greater_than_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept() -> void
+  {
+    using type_alias = nt::new_type<strange_type, struct greater_than_test_tag_22, deriving(nt::Relational)>;
+    static_assert(!noexcept(std::declval<strange_type const &>() > std::declval<strange_type const &>()), "Sanity Check");
+    ASSERT(!noexcept(std::declval<type_alias const &>() > std::declval<type_alias const &>()));
+  }
+
+  auto greater_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept() -> void
+  {
+    using type_alias = nt::new_type<int, struct greater_than_test_tag_23, deriving(nt::Relational)>;
+    static_assert(noexcept(std::declval<int const &>() >= std::declval<int const &>()), "Sanity Check");
+    ASSERT(noexcept(std::declval<type_alias const &>() >= std::declval<type_alias const &>()));
+  }
+
+  auto greater_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept()
+      -> void
+  {
+    using type_alias = nt::new_type<strange_type, struct greater_than_test_tag_24, deriving(nt::Relational)>;
+    static_assert(!noexcept(std::declval<strange_type const &>() >= std::declval<strange_type const &>()), "Sanity Check");
+    ASSERT(!noexcept(std::declval<type_alias const &>() >= std::declval<type_alias const &>()));
+  }
+
+}  // namespace relational_operator_noexcept_tests
+
+auto relational_operators_suite() -> std::pair<cute::suite, std::string>
+{
+  return {
+      {
+          // clang-format off
+
+              // Relational Operator Presensence Tests
+              KAWAII(an_instance_of_new__type_has_less_than_if_its_derivation_clause_contains_relational),
+              KAWAII(an_instance_of_new__type_does_not_have_less_than_if_its_derivation_clause_does_not_contain_relational),
+              KAWAII(an_instance_of_new__type_has_greater_than_if_its_derivation_clause_contains_relational),
+              KAWAII(an_instance_of_new__type_does_not_have_greater_than_if_its_derivation_clause_does_not_contain_relational),
+              KAWAII(an_instance_of_new__type_has_less_than_or_equal_to_if_its_derivation_clause_contains_relational),
+              KAWAII(an_instance_of_new__type_does_not_have_less_than_or_equal_to_if_its_derivation_clause_does_not_contain_relational),
+              KAWAII(an_instance_of_new__type_has_greater_than_or_equal_to_if_its_derivation_clause_contains_relational),
+              KAWAII(an_instance_of_new__type_does_not_have_greater_than_or_equal_to_if_its_derivation_clause_does_not_contain_relational),
+
+              // Less-than Comparison Tests
+              KAWAII(two_instances_of_the_same_new__type_compare_less_than_if_both_contained_values_would_compare_less_than),
+              KAWAII(two_instances_of_the_same_new__type_do_not_compare_less_than_if_both_contained_values_would_not_compare_less_than),
+              KAWAII(two_instances_of_the_same_new__type_compare_less_than_or_equal_if_both_contained_values_would_compare_less_than_or_equal),
+              KAWAII(two_instances_of_the_same_new__type_do_not_compare_less_than_or_equal_if_both_contained_values_would_not_compare_less_than_or_equal),
+
+              // Greater-than Comparison Tests
+              KAWAII(two_instances_of_the_same_new__type_compare_greater_than_if_both_contained_values_would_compare_greater_than),
+              KAWAII(two_instances_of_the_same_new__type_do_not_compare_greater_than_if_both_contained_values_would_not_compare_greater_than),
+              KAWAII(two_instances_of_the_same_new__type_compare_greater_than_or_equal_if_both_contained_values_would_compare_greater_than_or_equal),
+              KAWAII(two_instances_of_the_same_new__type_do_not_compare_greater_than_or_equal_if_both_contained_values_would_not_compare_greater_than_or_equal),
+
+              // Relational Operators noexcept Tests
+              KAWAII(less_than_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept),
+              KAWAII(less_than_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept),
+              KAWAII(less_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept),
+              KAWAII(less_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept),
+              KAWAII(greater_than_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept),
+              KAWAII(greater_than_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept),
+              KAWAII(greater_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_noexcept_if_comparison_of_the_base_type_is_noexcept),
+              KAWAII(greater_than_equal_to_comparison_of_two_intances_of_the_same_new__type_is_not_noexcept_if_comparison_of_the_base_type_is_not_noexcept),
+
+          // clang-format on
+      },
+      "Relational Operators Tests"};
+}
\ No newline at end of file