xref: /llvm-project/libcxx/test/support/test_comparisons.h (revision 0b46606ca5b52aa515c5359ed6f24fb18d825b50)

//===----------------------------------------------------------------------===//
//
// 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