//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// A set of routines for testing the comparison operators of a type
//
// FooOrder<expected-ordering> All seven comparison operators, requires C++20 or newer.
// FooComparison All six pre-C++20 comparison operators
// FooEquality Equality operators operator== and operator!=
//
// AssertXAreNoexcept static_asserts that the operations are all noexcept.
// AssertXReturnBool static_asserts that the operations return bool.
// AssertOrderReturn static_asserts that the pre-C++20 comparison operations
// return bool and operator<=> returns the proper type.
// AssertXConvertibleToBool static_asserts that the operations return something convertible to bool.
// testXValues returns the result of the comparison of all operations.
//
// AssertOrderConvertibleToBool doesn't exist yet. It will be implemented when needed.
#ifndef TEST_COMPARISONS_H
#define TEST_COMPARISONS_H
#include <cassert>
#include <compare>
#include <concepts>
#include <limits>
#include <type_traits>
#include <utility>
#include "test_macros.h"
// Test the consistency of the six basic comparison operators for values that are ordered or unordered.
template <class T, class U = T>
TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool
testComparisonsComplete(const T& t1, const U& t2, bool isEqual, bool isLess, bool isGreater) {
assert(((isEqual ? 1 : 0) + (isLess ? 1 : 0) + (isGreater ? 1 : 0) <= 1) &&
"at most one of isEqual, isLess, and isGreater can be true");
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 if (isGreater) {
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 { // unordered
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;
}
// Test the six basic comparison operators for ordered values.
template <class T, class U = T>
TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess) {
assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
bool isGreater = !isEqual && !isLess;
return testComparisonsComplete(t1, t2, isEqual, isLess, isGreater);
}
// Easy call when you can init from something already comparable.
template <class T, class Param>
TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testComparisonsValues(Param val1, Param val2)
{
const bool isEqual = val1 == val2;
const bool isLess = val1 < val2;
const bool isGreater = val1 > val2;
return testComparisonsComplete(T(val1), T(val2), isEqual, isLess, isGreater);
}
template <class T, class U = T>
TEST_CONSTEXPR_CXX14 void AssertComparisonsAreNoexcept() {
ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
ASSERT_NOEXCEPT(std::declval<const T&>() < std::declval<const U&>());
ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());
ASSERT_NOEXCEPT(std::declval<const T&>() > std::declval<const U&>());
ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const U&>());
}
template <class T, class U = T>
TEST_CONSTEXPR_CXX14 void AssertComparisonsReturnBool() {
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() < std::declval<const U&>()), bool);
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const U&>()), bool);
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() > std::declval<const U&>()), bool);
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const U&>()), bool);
}
template <class T, class U = T>
void AssertComparisonsConvertibleToBool()
{
static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
static_assert((std::is_convertible<decltype(std::declval<const T&>() < std::declval<const U&>()), bool>::value), "");
static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const U&>()), bool>::value), "");
static_assert((std::is_convertible<decltype(std::declval<const T&>() > std::declval<const U&>()), bool>::value), "");
static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const U&>()), bool>::value), "");
}
#if TEST_STD_VER > 17
template <class T, class U = T>
constexpr void AssertOrderAreNoexcept() {
AssertComparisonsAreNoexcept<T, U>();
ASSERT_NOEXCEPT(std::declval<const T&>() <=> std::declval<const U&>());
}
template <class Order, class T, class U = T>
constexpr void AssertOrderReturn() {
AssertComparisonsReturnBool<T, U>();
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <=> std::declval<const U&>()), Order);
}
template <class Order, class T, class U = T>
TEST_NODISCARD constexpr bool testOrder(const T& t1, const U& t2, Order order) {
bool equal = order == Order::equivalent;
bool less = order == Order::less;
bool greater = order == Order::greater;
return (t1 <=> t2 == order) && testComparisonsComplete(t1, t2, equal, less, greater);
}
template <class T, class Param>
TEST_NODISCARD constexpr bool testOrderValues(Param val1, Param val2) {
return testOrder(T(val1), T(val2), val1 <=> val2);
}
#endif
// Test all two comparison operations for sanity
template <class T, class U = T>
TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testEquality(const T& t1, const U& 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 /* not equal */
{
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>
TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testEqualityValues(Param val1, Param val2)
{
const bool isEqual = val1 == val2;
return testEquality(T(val1), T(val2), isEqual);
}
template <class T, class U = T>
void AssertEqualityAreNoexcept()
{
ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
}
template <class T, class U = T>
TEST_CONSTEXPR_CXX14 void AssertEqualityReturnBool() {
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
}
template <class T, class U = T>
void AssertEqualityConvertibleToBool()
{
static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
}
struct LessAndEqComp {
int value;
TEST_CONSTEXPR_CXX14 LessAndEqComp(int v) : value(v) {}
friend TEST_CONSTEXPR_CXX14 bool operator<(const LessAndEqComp& lhs, const LessAndEqComp& rhs) {
return lhs.value < rhs.value;
}
friend TEST_CONSTEXPR_CXX14 bool operator==(const LessAndEqComp& lhs, const LessAndEqComp& rhs) {
return lhs.value == rhs.value;
}
};
#if TEST_STD_VER >= 20
struct StrongOrder {
int value;
constexpr StrongOrder(int v) : value(v) {}
friend std::strong_ordering operator<=>(StrongOrder, StrongOrder) = default;
};
struct WeakOrder {
int value;
constexpr WeakOrder(int v) : value(v) {}
friend std::weak_ordering operator<=>(WeakOrder, WeakOrder) = default;
};
struct PartialOrder {
int value;
constexpr PartialOrder(int v) : value(v) {}
friend constexpr std::partial_ordering operator<=>(PartialOrder lhs, PartialOrder rhs) {
if (lhs.value == std::numeric_limits<int>::min() || rhs.value == std::numeric_limits<int>::min())
return std::partial_ordering::unordered;
if (lhs.value == std::numeric_limits<int>::max() || rhs.value == std::numeric_limits<int>::max())
return std::partial_ordering::unordered;
return lhs.value <=> rhs.value;
}
friend constexpr bool operator==(PartialOrder lhs, PartialOrder rhs) {
return (lhs <=> rhs) == std::partial_ordering::equivalent;
}
};
#endif
#endif // TEST_COMPARISONS_H
Codebase Browser
llvm