Add new file test/support/test_comparisons.h

[mclow.lists]

Summary

As I've been plowing through the <chrono> stuff, I found myself writing tests to make sure that the comparisons for a bunch of different types are "sane".

So I factored them out into something that can be used over and over.

[mclow.lists]

Usage looks like this:

AssertComparisons6AreNoexcept<month>();
AssertComparisons6ReturnBool<month>();

static_assert(testComparisons6Values<month>( 5U,  5U), "");
static_assert(testComparisons6Values<month>( 5U, 10U), "");

[EricWF]

Some of this stuff is marked constexpr despite it requiring C++14 constexpr semantics. Can they be non-constexpr in C++11 and still function? Or should the header explicitly require C++14 to be included?

[mclow.lists]

Can they be non-constexpr in C++11 and still function?

Sure. I'll fix that.

[EricWF]

Otherwise, I'm quite happy with this patch.

The only downside I see is if testComparisons6 fails, it will report the source of the failure as being in the header, and not provide information about the callee.
But I think having simpler tests to read and write is more important. Hopefully they shouldn't be falling too often anyway :-P

[mclow.lists]

Committed as 337885 after changing constexpr -> TEST_CONSTEXPR_CXX14

test/support/test_comparisons.h

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  A set of routines for testing the comparison operators of a type
+//
+//      XXXX6 tests all six comparison operators
+//      XXXX2 tests only op== and op!=
+//
+//      AssertComparisonsXAreNoexcept       static_asserts that the operations are all noexcept.
+//      AssertComparisonsXReturnBool        static_asserts that the operations return bool.
+//      AssertComparisonsXConvertibleToBool static_asserts that the operations return something convertible to bool.
+
+
+#ifndef TEST_COMPARISONS_H
+#define TEST_COMPARISONS_H
+
+#include <type_traits>
+#include "test_macros.h"
+
+//  Test all six comparison operations for sanity
+template <class T>
+constexpr bool testComparisons6(const T& t1, const T& t2, bool isEqual, bool isLess)
+{
+    if (isEqual)
+        {
+        if (!(t1 == t2)) return false;
+        if (!(t2 == t1)) return false;
+        if ( (t1 != t2)) return false;
+        if ( (t2 != t1)) return false;
+        if ( (t1  < t2)) return false;
+        if ( (t2  < t1)) return false;
+        if (!(t1 <= t2)) return false;
+        if (!(t2 <= t1)) return false;
+        if ( (t1  > t2)) return false;
+        if ( (t2  > t1)) return false;
+        if (!(t1 >= t2)) return false;
+        if (!(t2 >= t1)) return false;
+        }
+    else if (isLess)
+        {
+        if ( (t1 == t2)) return false;
+        if ( (t2 == t1)) return false;
+        if (!(t1 != t2)) return false;
+        if (!(t2 != t1)) return false;
+        if (!(t1  < t2)) return false;
+        if ( (t2  < t1)) return false;
+        if (!(t1 <= t2)) return false;
+        if ( (t2 <= t1)) return false;
+        if ( (t1  > t2)) return false;
+        if (!(t2  > t1)) return false;
+        if ( (t1 >= t2)) return false;
+        if (!(t2 >= t1)) return false;
+        }
+    else /* greater */
+        {
+        if ( (t1 == t2)) return false;
+        if ( (t2 == t1)) return false;
+        if (!(t1 != t2)) return false;
+        if (!(t2 != t1)) return false;
+        if ( (t1  < t2)) return false;
+        if (!(t2  < t1)) return false;
+        if ( (t1 <= t2)) return false;
+        if (!(t2 <= t1)) return false;
+        if (!(t1  > t2)) return false;
+        if ( (t2  > t1)) return false;
+        if (!(t1 >= t2)) return false;
+        if ( (t2 >= t1)) return false;
+        }
+
+    return true;
+}
+
+//  Easy call when you can init from something already comparable.
+template <class T, class Param>
+constexpr bool testComparisons6Values(Param val1, Param val2)
+{
+    const bool isEqual = val1 == val2;
+    const bool isLess  = val1  < val2;
+    
+    return testComparisons6(T{val1}, T{val2}, isEqual, isLess);
+}
+
+template <class T>
+void AssertComparisons6AreNoexcept()
+{
+    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const T&>());
+}
+
+template <class T>
+void AssertComparisons6ReturnBool()
+{
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const T&>()), bool);
+}
+
+
+template <class T>
+void AssertComparisons6ConvertibleToBool()
+{
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const T&>()), bool>::value), "");
+}
+
+//  Test all six comparison operations for sanity
+template <class T>
+constexpr bool testComparisons2(const T& t1, const T& t2, bool isEqual)
+{
+    if (isEqual)
+        {
+        if (!(t1 == t2)) return false;
+        if (!(t2 == t1)) return false;
+        if ( (t1 != t2)) return false;
+        if ( (t2 != t1)) return false;
+        }
+    else /* greater */
+        {
+        if ( (t1 == t2)) return false;
+        if ( (t2 == t1)) return false;
+        if (!(t1 != t2)) return false;
+        if (!(t2 != t1)) return false;
+        }
+
+    return true;
+}
+
+//  Easy call when you can init from something already comparable.
+template <class T, class Param>
+constexpr bool testComparisons2Values(Param val1, Param val2)
+{
+    const bool isEqual = val1 == val2;
+    
+    return testComparisons2(T{val1}, T{val2}, isEqual);
+}
+
+template <class T>
+void AssertComparisons2AreNoexcept()
+{
+    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const T&>());
+}
+
+template <class T>
+void AssertComparisons2ReturnBool()
+{
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const T&>()), bool);
+}
+
+
+template <class T>
+void AssertComparisons2ConvertibleToBool()
+{
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const T&>()), bool>::value), "");
+}
+
+#endif // TEST_COMPARISONS_H