text: //===----------------------------------------------------------------------===//
  //
  // 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
  //
  //      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 <cuda/std/type_traits>
  #include "test_macros.h"
  
  //  Test all six comparison operations for sanity
  template <class T, class U = T>
  __host__ __device__
  TEST_CONSTEXPR_CXX14 bool testComparisons6(const T& t1, const U& 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>
  __host__ __device__
  TEST_CONSTEXPR_CXX14 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, class U = T>
  __host__ __device__
  void AssertComparisons6AreNoexcept()
  {
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() == cuda::std::declval<const U&>());
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() != cuda::std::declval<const U&>());
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() <  cuda::std::declval<const U&>());
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() <= cuda::std::declval<const U&>());
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() >  cuda::std::declval<const U&>());
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() >= cuda::std::declval<const U&>());
  }
  
  template <class T, class U = T>
  __host__ __device__
  void AssertComparisons6ReturnBool()
  {
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() == cuda::std::declval<const U&>()), bool);
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() != cuda::std::declval<const U&>()), bool);
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() <  cuda::std::declval<const U&>()), bool);
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() <= cuda::std::declval<const U&>()), bool);
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() >  cuda::std::declval<const U&>()), bool);
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() >= cuda::std::declval<const U&>()), bool);
  }
  
  
  template <class T, class U = T>
  __host__ __device__
  void AssertComparisons6ConvertibleToBool()
  {
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() == cuda::std::declval<const U&>()), bool>::value), "");
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() != cuda::std::declval<const U&>()), bool>::value), "");
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() <  cuda::std::declval<const U&>()), bool>::value), "");
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() <= cuda::std::declval<const U&>()), bool>::value), "");
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() >  cuda::std::declval<const U&>()), bool>::value), "");
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() >= cuda::std::declval<const U&>()), bool>::value), "");
  }
  
  //  Test all two comparison operations for sanity
  template <class T, class U = T>
  __host__ __device__
  TEST_CONSTEXPR_CXX14 bool testComparisons2(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>
  __host__ __device__
  TEST_CONSTEXPR_CXX14 bool testComparisons2Values(Param val1, Param val2)
  {
      const bool isEqual = val1 == val2;
  
      return testComparisons2(T(val1), T(val2), isEqual);
  }
  
  template <class T, class U = T>
  __host__ __device__
  void AssertComparisons2AreNoexcept()
  {
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() == cuda::std::declval<const U&>());
      ASSERT_NOEXCEPT(cuda::std::declval<const T&>() != cuda::std::declval<const U&>());
  }
  
  template <class T, class U = T>
  __host__ __device__
  void AssertComparisons2ReturnBool()
  {
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() == cuda::std::declval<const U&>()), bool);
      ASSERT_SAME_TYPE(decltype(cuda::std::declval<const T&>() != cuda::std::declval<const U&>()), bool);
  }
  
  
  template <class T, class U = T>
  __host__ __device__
  void AssertComparisons2ConvertibleToBool()
  {
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() == cuda::std::declval<const U&>()), bool>::value), "");
      static_assert((cuda::std::is_convertible<decltype(cuda::std::declval<const T&>() != cuda::std::declval<const U&>()), bool>::value), "");
  }
  
  #endif // TEST_COMPARISONS_H
  