[lmi-commits] [lmi] odd/move_semantics 03e061cf 2/5: Replace run-time with compile-time tests

[Greg Chicares]

branch: odd/move_semantics
commit 03e061cf60d2c609115ea5779b877a591c5b4b24
Author: Gregory W. Chicares <gchicares@sbcglobal.net>
Commit: Gregory W. Chicares <gchicares@sbcglobal.net>

    Replace run-time with compile-time tests
    
    Changed /LMI_TEST/static_assert/ everywhere, necessarily making all
    predicates 'constexpr'. Removed doubled parentheses that had been
    required because LMI_TEST is a macro, to shield commas as in:
    -    LMI_TEST((!std::is_constructible_v<A0000,ambiguator<A0000>>));
                                                 ^ not two macro arguments
    +    static_assert(!std::is_constructible_v<A0000,ambiguator<A0000>>);
                                                     ^ okay
---
 sandbox_test.cpp | 166 +++++++++++++++++++++++++++----------------------------
 1 file changed, 83 insertions(+), 83 deletions(-)

diff --git a/sandbox_test.cpp b/sandbox_test.cpp
index eea2157a..a84b89b4 100644
--- a/sandbox_test.cpp
+++ b/sandbox_test.cpp
@@ -50,27 +50,27 @@ struct ambiguator
     operator T&&();
 };
 
-template<typename T> bool equiplausible_construct()
+template<typename T> constexpr bool equiplausible_construct()
 {
     return !std::is_constructible_v<T,ambiguator<T>>;
 }
 
-template<typename T> bool equiplausible_assign()
+template<typename T> constexpr bool equiplausible_assign()
 {
     return !std::is_assignable_v<T,ambiguator<T>>;
 }
 
-template<typename T> bool copyable()
+template<typename T> constexpr bool copyable()
 {
     return std::is_copy_constructible_v<T>;
 }
 
-template<typename T> bool a_moveable() // assign-moveable
+template<typename T> constexpr bool a_moveable() // assign-moveable
 {
     return std::is_move_assignable_v<T> && equiplausible_assign<T>();
 }
 
-template<typename T> bool c_moveable() // copy-moveable
+template<typename T> constexpr bool c_moveable() // copy-moveable
 {
     return std::is_move_constructible_v<T> && equiplausible_construct<T>();
 }
@@ -206,84 +206,84 @@ void test_classes()
 //   +    -    -    -    -    -    +   y: move assign has move semantics
 //   +    +    -    -    +    +    +   z: move compiles without error
 
-    LMI_TEST( std::is_copy_constructible_v<A0000>);
-    LMI_TEST( std::is_move_constructible_v<A0000>);
-    LMI_TEST((!std::is_constructible_v<A0000,ambiguator<A0000>>));
-    LMI_TEST( copyable<A0000>());
-    LMI_TEST( c_moveable<A0000>());
-    LMI_TEST( a_moveable<A0000>());
-
-    LMI_TEST( std::is_copy_constructible_v<A0000>);
-    LMI_TEST( std::is_copy_constructible_v<A0101>);
-    LMI_TEST( std::is_copy_constructible_v<A0202>);
-    LMI_TEST( std::is_copy_constructible_v<A0303>);
-    LMI_TEST( std::is_copy_constructible_v<A0404>);
-    LMI_TEST( std::is_copy_constructible_v<A0505>);
-    LMI_TEST(!std::is_copy_constructible_v<A3030>);
-
-    LMI_TEST( std::is_move_constructible_v<A0000>);
-    LMI_TEST( std::is_move_constructible_v<A0101>);
-    LMI_TEST(!std::is_move_constructible_v<A0202>);
-    LMI_TEST(!std::is_move_constructible_v<A0303>);
-    LMI_TEST( std::is_move_constructible_v<A0404>);
-    LMI_TEST( std::is_move_constructible_v<A0505>);
-    LMI_TEST( std::is_move_constructible_v<A3030>);
-
-    LMI_TEST( std::is_move_assignable_v<A0000>);
-    LMI_TEST( std::is_move_assignable_v<A0101>);
-    LMI_TEST(!std::is_move_assignable_v<A0202>);
-    LMI_TEST(!std::is_move_assignable_v<A0303>);
-    LMI_TEST( std::is_move_assignable_v<A0404>);
-    LMI_TEST(!std::is_move_assignable_v<A0505>);
-    LMI_TEST( std::is_move_assignable_v<A3030>);
-
-    LMI_TEST((!std::is_constructible_v<A0000,ambiguator<A0000>>));
-    LMI_TEST(( std::is_constructible_v<A0101,ambiguator<A0101>>));
-    LMI_TEST((!std::is_constructible_v<A0202,ambiguator<A0202>>));
-    LMI_TEST((!std::is_constructible_v<A0303,ambiguator<A0303>>));
-    LMI_TEST(( std::is_constructible_v<A0404,ambiguator<A0404>>));
-    LMI_TEST((!std::is_constructible_v<A0505,ambiguator<A0505>>));
-    LMI_TEST((!std::is_constructible_v<A3030,ambiguator<A3030>>));
-
-    LMI_TEST( equiplausible_construct<A0000>());
-    LMI_TEST(!equiplausible_construct<A0101>());
-    LMI_TEST( equiplausible_construct<A0202>());
-    LMI_TEST( equiplausible_construct<A0303>());
-    LMI_TEST(!equiplausible_construct<A0404>());
-    LMI_TEST( equiplausible_construct<A0505>());
-    LMI_TEST( equiplausible_construct<A3030>());
-
-    LMI_TEST( equiplausible_assign<A0000>());
-    LMI_TEST(!equiplausible_assign<A0101>());
-    LMI_TEST( equiplausible_assign<A0202>());
-    LMI_TEST( equiplausible_assign<A0303>());
-    LMI_TEST(!equiplausible_assign<A0404>());
-    LMI_TEST( equiplausible_assign<A0505>());
-    LMI_TEST( equiplausible_assign<A3030>());
-
-    LMI_TEST( copyable<A0000>());
-    LMI_TEST( copyable<A0101>());
-    LMI_TEST( copyable<A0202>());
-    LMI_TEST( copyable<A0303>());
-    LMI_TEST( copyable<A0404>());
-    LMI_TEST( copyable<A0505>());
-    LMI_TEST(!copyable<A3030>());
-
-    LMI_TEST( c_moveable<A0000>());
-    LMI_TEST(!c_moveable<A0101>());
-    LMI_TEST(!c_moveable<A0202>());
-    LMI_TEST(!c_moveable<A0303>());
-    LMI_TEST(!c_moveable<A0404>());
-    LMI_TEST( c_moveable<A0505>()); // move-constructible; not move-assignable
-    LMI_TEST( c_moveable<A3030>());
-
-    LMI_TEST( a_moveable<A0000>());
-    LMI_TEST(!a_moveable<A0101>());
-    LMI_TEST(!a_moveable<A0202>());
-    LMI_TEST(!a_moveable<A0303>());
-    LMI_TEST(!a_moveable<A0404>());
-    LMI_TEST(!a_moveable<A0505>()); // move-constructible; not move-assignable
-    LMI_TEST( a_moveable<A3030>());
+    static_assert( std::is_copy_constructible_v<A0000>);
+    static_assert( std::is_move_constructible_v<A0000>);
+    static_assert(!std::is_constructible_v<A0000,ambiguator<A0000>>);
+    static_assert( copyable<A0000>());
+    static_assert( c_moveable<A0000>());
+    static_assert( a_moveable<A0000>());
+
+    static_assert( std::is_copy_constructible_v<A0000>);
+    static_assert( std::is_copy_constructible_v<A0101>);
+    static_assert( std::is_copy_constructible_v<A0202>);
+    static_assert( std::is_copy_constructible_v<A0303>);
+    static_assert( std::is_copy_constructible_v<A0404>);
+    static_assert( std::is_copy_constructible_v<A0505>);
+    static_assert(!std::is_copy_constructible_v<A3030>);
+
+    static_assert( std::is_move_constructible_v<A0000>);
+    static_assert( std::is_move_constructible_v<A0101>);
+    static_assert(!std::is_move_constructible_v<A0202>);
+    static_assert(!std::is_move_constructible_v<A0303>);
+    static_assert( std::is_move_constructible_v<A0404>);
+    static_assert( std::is_move_constructible_v<A0505>);
+    static_assert( std::is_move_constructible_v<A3030>);
+
+    static_assert( std::is_move_assignable_v<A0000>);
+    static_assert( std::is_move_assignable_v<A0101>);
+    static_assert(!std::is_move_assignable_v<A0202>);
+    static_assert(!std::is_move_assignable_v<A0303>);
+    static_assert( std::is_move_assignable_v<A0404>);
+    static_assert(!std::is_move_assignable_v<A0505>);
+    static_assert( std::is_move_assignable_v<A3030>);
+
+    static_assert(!std::is_constructible_v<A0000,ambiguator<A0000>>);
+    static_assert( std::is_constructible_v<A0101,ambiguator<A0101>>);
+    static_assert(!std::is_constructible_v<A0202,ambiguator<A0202>>);
+    static_assert(!std::is_constructible_v<A0303,ambiguator<A0303>>);
+    static_assert( std::is_constructible_v<A0404,ambiguator<A0404>>);
+    static_assert(!std::is_constructible_v<A0505,ambiguator<A0505>>);
+    static_assert(!std::is_constructible_v<A3030,ambiguator<A3030>>);
+
+    static_assert( equiplausible_construct<A0000>());
+    static_assert(!equiplausible_construct<A0101>());
+    static_assert( equiplausible_construct<A0202>());
+    static_assert( equiplausible_construct<A0303>());
+    static_assert(!equiplausible_construct<A0404>());
+    static_assert( equiplausible_construct<A0505>());
+    static_assert( equiplausible_construct<A3030>());
+
+    static_assert( equiplausible_assign<A0000>());
+    static_assert(!equiplausible_assign<A0101>());
+    static_assert( equiplausible_assign<A0202>());
+    static_assert( equiplausible_assign<A0303>());
+    static_assert(!equiplausible_assign<A0404>());
+    static_assert( equiplausible_assign<A0505>());
+    static_assert( equiplausible_assign<A3030>());
+
+    static_assert( copyable<A0000>());
+    static_assert( copyable<A0101>());
+    static_assert( copyable<A0202>());
+    static_assert( copyable<A0303>());
+    static_assert( copyable<A0404>());
+    static_assert( copyable<A0505>());
+    static_assert(!copyable<A3030>());
+
+    static_assert( c_moveable<A0000>());
+    static_assert(!c_moveable<A0101>());
+    static_assert(!c_moveable<A0202>());
+    static_assert(!c_moveable<A0303>());
+    static_assert(!c_moveable<A0404>());
+    static_assert( c_moveable<A0505>()); // move-constructible; not 
move-assignable
+    static_assert( c_moveable<A3030>());
+
+    static_assert( a_moveable<A0000>());
+    static_assert(!a_moveable<A0101>());
+    static_assert(!a_moveable<A0202>());
+    static_assert(!a_moveable<A0303>());
+    static_assert(!a_moveable<A0404>());
+    static_assert(!a_moveable<A0505>()); // move-constructible; not 
move-assignable
+    static_assert( a_moveable<A3030>());
 
     A0000 a0000 {};
     A0101 a0101 {};