maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

New test support for comparisons. Reviewed as https://reviews.llvm.org/D49773 

llvm-svn: 337885
This commit is contained in:
Marshall Clow 2018-07-25 04:21:21 +00:00
parent 5baf73c354
commit c17628fb15
1 changed files with 175 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
libcxx/test/support/test_comparisons.h Normal file
View File

@ -0,0 +1,175 @@
//===----------------------------------------------------------------------===//
//
// 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>
TEST_CONSTEXPR_CXX14 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>
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>
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>
TEST_CONSTEXPR_CXX14 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>
TEST_CONSTEXPR_CXX14 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