diff options
Diffstat (limited to 'test/std/language.support/support.limits/limits')
38 files changed, 2168 insertions, 0 deletions
diff --git a/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp b/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp new file mode 100644 index 000000000000..c6731fcc8e92 --- /dev/null +++ b/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// float_round_style + +#include <limits> + +typedef char one; +struct two {one _[2];}; + +one test(std::float_round_style); +two test(int); + +int main() +{ + static_assert(std::round_indeterminate == -1, + "std::round_indeterminate == -1"); + static_assert(std::round_toward_zero == 0, + "std::round_toward_zero == 0"); + static_assert(std::round_to_nearest == 1, + "std::round_to_nearest == 1"); + static_assert(std::round_toward_infinity == 2, + "std::round_toward_infinity == 2"); + static_assert(std::round_toward_neg_infinity == 3, + "std::round_toward_neg_infinity == 3"); + static_assert(sizeof(test(std::round_to_nearest)) == 1, + "sizeof(test(std::round_to_nearest)) == 1"); + static_assert(sizeof(test(1)) == 2, + "sizeof(test(1)) == 2"); +} diff --git a/test/std/language.support/support.limits/limits/is_specialized.pass.cpp b/test/std/language.support/support.limits/limits/is_specialized.pass.cpp new file mode 100644 index 000000000000..ff5c1a2c0b8d --- /dev/null +++ b/test/std/language.support/support.limits/limits/is_specialized.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// Specializations shall be provided for each arithmetic type, both floating +// point and integer, including bool. The member is_specialized shall be +// true for all such specializations of numeric_limits. + +// Non-arithmetic standard types, such as complex<T> (26.3.2), shall not +// have specializations. + +// From [numeric.limits]: + +// The value of each member of a specialization of numeric_limits on a cv +// -qualified type cv T shall be equal to the value of the corresponding +// member of the specialization on the unqualified type T. + +// More convenient to test it here. + +#include <limits> +#include <complex> + +template <class T> +void test() +{ + static_assert(std::numeric_limits<T>::is_specialized, + "std::numeric_limits<T>::is_specialized"); + static_assert(std::numeric_limits<const T>::is_specialized, + "std::numeric_limits<const T>::is_specialized"); + static_assert(std::numeric_limits<volatile T>::is_specialized, + "std::numeric_limits<volatile T>::is_specialized"); + static_assert(std::numeric_limits<const volatile T>::is_specialized, + "std::numeric_limits<const volatile T>::is_specialized"); +} + +int main() +{ + test<bool>(); + test<char>(); + test<wchar_t>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(); + test<char32_t>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<signed char>(); + test<unsigned char>(); + test<signed short>(); + test<unsigned short>(); + test<signed int>(); + test<unsigned int>(); + test<signed long>(); + test<unsigned long>(); + test<signed long long>(); + test<unsigned long long>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(); + test<__uint128_t>(); +#endif + test<float>(); + test<double>(); + test<long double>(); + static_assert(!std::numeric_limits<std::complex<double> >::is_specialized, + "!std::numeric_limits<std::complex<double> >::is_specialized"); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp new file mode 100644 index 000000000000..bbead15da64f --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp @@ -0,0 +1,199 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +#include <limits> + +/* +<limits>: + numeric_limits + is_specialized + digits + digits10 + max_digits10 + is_signed + is_integer + is_exact + radix + min_exponent + min_exponent10 + max_exponent + max_exponent10 + has_infinity + has_quiet_NaN + has_signaling_NaN + has_denorm + has_denorm_loss + is_iec559 + is_bounded + is_modulo + traps + tinyness_before + round_style +*/ + +template <class _Tp> +void test(const _Tp &) {} + +#define TEST_NUMERIC_LIMITS(type) \ + test(std::numeric_limits<type>::is_specialized); \ + test(std::numeric_limits<type>::digits); \ + test(std::numeric_limits<type>::digits10); \ + test(std::numeric_limits<type>::max_digits10); \ + test(std::numeric_limits<type>::is_signed); \ + test(std::numeric_limits<type>::is_integer); \ + test(std::numeric_limits<type>::is_exact); \ + test(std::numeric_limits<type>::radix); \ + test(std::numeric_limits<type>::min_exponent); \ + test(std::numeric_limits<type>::min_exponent10); \ + test(std::numeric_limits<type>::max_exponent); \ + test(std::numeric_limits<type>::max_exponent10); \ + test(std::numeric_limits<type>::has_infinity); \ + test(std::numeric_limits<type>::has_quiet_NaN); \ + test(std::numeric_limits<type>::has_signaling_NaN); \ + test(std::numeric_limits<type>::has_denorm); \ + test(std::numeric_limits<type>::has_denorm_loss); \ + test(std::numeric_limits<type>::is_iec559); \ + test(std::numeric_limits<type>::is_bounded); \ + test(std::numeric_limits<type>::is_modulo); \ + test(std::numeric_limits<type>::traps); \ + test(std::numeric_limits<type>::tinyness_before); \ + test(std::numeric_limits<type>::round_style); + +struct other {}; + +int main() +{ + // bool + TEST_NUMERIC_LIMITS(bool) + TEST_NUMERIC_LIMITS(const bool) + TEST_NUMERIC_LIMITS(volatile bool) + TEST_NUMERIC_LIMITS(const volatile bool) + + // char + TEST_NUMERIC_LIMITS(char) + TEST_NUMERIC_LIMITS(const char) + TEST_NUMERIC_LIMITS(volatile char) + TEST_NUMERIC_LIMITS(const volatile char) + + // signed char + TEST_NUMERIC_LIMITS(signed char) + TEST_NUMERIC_LIMITS(const signed char) + TEST_NUMERIC_LIMITS(volatile signed char) + TEST_NUMERIC_LIMITS(const volatile signed char) + + // unsigned char + TEST_NUMERIC_LIMITS(unsigned char) + TEST_NUMERIC_LIMITS(const unsigned char) + TEST_NUMERIC_LIMITS(volatile unsigned char) + TEST_NUMERIC_LIMITS(const volatile unsigned char) + + // wchar_t + TEST_NUMERIC_LIMITS(wchar_t) + TEST_NUMERIC_LIMITS(const wchar_t) + TEST_NUMERIC_LIMITS(volatile wchar_t) + TEST_NUMERIC_LIMITS(const volatile wchar_t) + + // char16_t + TEST_NUMERIC_LIMITS(char16_t) + TEST_NUMERIC_LIMITS(const char16_t) + TEST_NUMERIC_LIMITS(volatile char16_t) + TEST_NUMERIC_LIMITS(const volatile char16_t) + + // char32_t + TEST_NUMERIC_LIMITS(char32_t) + TEST_NUMERIC_LIMITS(const char32_t) + TEST_NUMERIC_LIMITS(volatile char32_t) + TEST_NUMERIC_LIMITS(const volatile char32_t) + + // short + TEST_NUMERIC_LIMITS(short) + TEST_NUMERIC_LIMITS(const short) + TEST_NUMERIC_LIMITS(volatile short) + TEST_NUMERIC_LIMITS(const volatile short) + + // int + TEST_NUMERIC_LIMITS(int) + TEST_NUMERIC_LIMITS(const int) + TEST_NUMERIC_LIMITS(volatile int) + TEST_NUMERIC_LIMITS(const volatile int) + + // long + TEST_NUMERIC_LIMITS(long) + TEST_NUMERIC_LIMITS(const long) + TEST_NUMERIC_LIMITS(volatile long) + TEST_NUMERIC_LIMITS(const volatile long) + +#ifndef _LIBCPP_HAS_NO_INT128 + TEST_NUMERIC_LIMITS(__int128_t) + TEST_NUMERIC_LIMITS(const __int128_t) + TEST_NUMERIC_LIMITS(volatile __int128_t) + TEST_NUMERIC_LIMITS(const volatile __int128_t) +#endif + + // long long + TEST_NUMERIC_LIMITS(long long) + TEST_NUMERIC_LIMITS(const long long) + TEST_NUMERIC_LIMITS(volatile long long) + TEST_NUMERIC_LIMITS(const volatile long long) + + // unsigned short + TEST_NUMERIC_LIMITS(unsigned short) + TEST_NUMERIC_LIMITS(const unsigned short) + TEST_NUMERIC_LIMITS(volatile unsigned short) + TEST_NUMERIC_LIMITS(const volatile unsigned short) + + // unsigned int + TEST_NUMERIC_LIMITS(unsigned int) + TEST_NUMERIC_LIMITS(const unsigned int) + TEST_NUMERIC_LIMITS(volatile unsigned int) + TEST_NUMERIC_LIMITS(const volatile unsigned int) + + // unsigned long + TEST_NUMERIC_LIMITS(unsigned long) + TEST_NUMERIC_LIMITS(const unsigned long) + TEST_NUMERIC_LIMITS(volatile unsigned long) + TEST_NUMERIC_LIMITS(const volatile unsigned long) + + // unsigned long long + TEST_NUMERIC_LIMITS(unsigned long long) + TEST_NUMERIC_LIMITS(const unsigned long long) + TEST_NUMERIC_LIMITS(volatile unsigned long long) + TEST_NUMERIC_LIMITS(const volatile unsigned long long) + +#ifndef _LIBCPP_HAS_NO_INT128 + TEST_NUMERIC_LIMITS(__uint128_t) + TEST_NUMERIC_LIMITS(const __uint128_t) + TEST_NUMERIC_LIMITS(volatile __uint128_t) + TEST_NUMERIC_LIMITS(const volatile __uint128_t) +#endif + + // float + TEST_NUMERIC_LIMITS(float) + TEST_NUMERIC_LIMITS(const float) + TEST_NUMERIC_LIMITS(volatile float) + TEST_NUMERIC_LIMITS(const volatile float) + + // double + TEST_NUMERIC_LIMITS(double) + TEST_NUMERIC_LIMITS(const double) + TEST_NUMERIC_LIMITS(volatile double) + TEST_NUMERIC_LIMITS(const volatile double) + + // long double + TEST_NUMERIC_LIMITS(long double) + TEST_NUMERIC_LIMITS(const long double) + TEST_NUMERIC_LIMITS(volatile long double) + TEST_NUMERIC_LIMITS(const volatile long double) + + // other + TEST_NUMERIC_LIMITS(other) + TEST_NUMERIC_LIMITS(const other) + TEST_NUMERIC_LIMITS(volatile other) + TEST_NUMERIC_LIMITS(const volatile other) +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp new file mode 100644 index 000000000000..a452d4e9949d --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// denorm_min() + +#include <limits> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::denorm_min() == expected); + assert(std::numeric_limits<const T>::denorm_min() == expected); + assert(std::numeric_limits<volatile T>::denorm_min() == expected); + assert(std::numeric_limits<const volatile T>::denorm_min() == expected); +} + +int main() +{ + test<bool>(false); + test<char>(0); + test<signed char>(0); + test<unsigned char>(0); + test<wchar_t>(0); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(0); + test<char32_t>(0); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(0); + test<unsigned short>(0); + test<int>(0); + test<unsigned int>(0); + test<long>(0); + test<unsigned long>(0); + test<long long>(0); + test<unsigned long long>(0); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(0); + test<__uint128_t>(0); +#endif + test<float>(__FLT_DENORM_MIN__); + test<double>(__DBL_DENORM_MIN__); + test<long double>(__LDBL_DENORM_MIN__); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp new file mode 100644 index 000000000000..2dfea084b11d --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// digits + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::digits == expected, "digits test 1"); + static_assert(std::numeric_limits<const T>::digits == expected, "digits test 2"); + static_assert(std::numeric_limits<volatile T>::digits == expected, "digits test 3"); + static_assert(std::numeric_limits<const volatile T>::digits == expected, "digits test 4"); +} + +int main() +{ + test<bool, 1>(); + test<char, std::numeric_limits<char>::is_signed ? 7 : 8>(); + test<signed char, 7>(); + test<unsigned char, 8>(); + test<wchar_t, std::numeric_limits<wchar_t>::is_signed ? sizeof(wchar_t)*8-1 : sizeof(wchar_t)*8>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 16>(); + test<char32_t, 32>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 15>(); + test<unsigned short, 16>(); + test<int, 31>(); + test<unsigned int, 32>(); + test<long, sizeof(long) == 4 ? 31 : 63>(); + test<unsigned long, sizeof(long) == 4 ? 32 : 64>(); + test<long long, 63>(); + test<unsigned long long, 64>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 127>(); + test<__uint128_t, 128>(); +#endif + test<float, FLT_MANT_DIG>(); + test<double, DBL_MANT_DIG>(); + test<long double, LDBL_MANT_DIG>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp new file mode 100644 index 000000000000..2c5302cd6334 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// digits10 + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::digits10 == expected, "digits10 test 1"); + static_assert(std::numeric_limits<T>::is_bounded, "digits10 test 5"); + static_assert(std::numeric_limits<const T>::digits10 == expected, "digits10 test 2"); + static_assert(std::numeric_limits<const T>::is_bounded, "digits10 test 6"); + static_assert(std::numeric_limits<volatile T>::digits10 == expected, "digits10 test 3"); + static_assert(std::numeric_limits<volatile T>::is_bounded, "digits10 test 7"); + static_assert(std::numeric_limits<const volatile T>::digits10 == expected, "digits10 test 4"); + static_assert(std::numeric_limits<const volatile T>::is_bounded, "digits10 test 8"); +} + +int main() +{ + test<bool, 0>(); + test<char, 2>(); + test<signed char, 2>(); + test<unsigned char, 2>(); + test<wchar_t, 5*sizeof(wchar_t)/2-1>(); // 4 -> 9 and 2 -> 4 +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 4>(); + test<char32_t, 9>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 4>(); + test<unsigned short, 4>(); + test<int, 9>(); + test<unsigned int, 9>(); + test<long, sizeof(long) == 4 ? 9 : 18>(); + test<unsigned long, sizeof(long) == 4 ? 9 : 19>(); + test<long long, 18>(); + test<unsigned long long, 19>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 38>(); + test<__uint128_t, 38>(); +#endif + test<float, FLT_DIG>(); + test<double, DBL_DIG>(); + test<long double, LDBL_DIG>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp new file mode 100644 index 000000000000..0cce4848187d --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// epsilon() + +#include <limits> +#include <cfloat> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::epsilon() == expected); + assert(std::numeric_limits<const T>::epsilon() == expected); + assert(std::numeric_limits<volatile T>::epsilon() == expected); + assert(std::numeric_limits<const volatile T>::epsilon() == expected); +} + +int main() +{ + test<bool>(false); + test<char>(0); + test<signed char>(0); + test<unsigned char>(0); + test<wchar_t>(0); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(0); + test<char32_t>(0); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(0); + test<unsigned short>(0); + test<int>(0); + test<unsigned int>(0); + test<long>(0); + test<unsigned long>(0); + test<long long>(0); + test<unsigned long long>(0); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(0); + test<__uint128_t>(0); +#endif + test<float>(FLT_EPSILON); + test<double>(DBL_EPSILON); + test<long double>(LDBL_EPSILON); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp new file mode 100644 index 000000000000..e61802054d18 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// has_denorm + +#include <limits> + +template <class T, std::float_denorm_style expected> +void +test() +{ + static_assert(std::numeric_limits<T>::has_denorm == expected, "has_denorm test 1"); + static_assert(std::numeric_limits<const T>::has_denorm == expected, "has_denorm test 2"); + static_assert(std::numeric_limits<volatile T>::has_denorm == expected, "has_denorm test 3"); + static_assert(std::numeric_limits<const volatile T>::has_denorm == expected, "has_denorm test 4"); +} + +int main() +{ + test<bool, std::denorm_absent>(); + test<char, std::denorm_absent>(); + test<signed char, std::denorm_absent>(); + test<unsigned char, std::denorm_absent>(); + test<wchar_t, std::denorm_absent>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, std::denorm_absent>(); + test<char32_t, std::denorm_absent>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, std::denorm_absent>(); + test<unsigned short, std::denorm_absent>(); + test<int, std::denorm_absent>(); + test<unsigned int, std::denorm_absent>(); + test<long, std::denorm_absent>(); + test<unsigned long, std::denorm_absent>(); + test<long long, std::denorm_absent>(); + test<unsigned long long, std::denorm_absent>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, std::denorm_absent>(); + test<__uint128_t, std::denorm_absent>(); +#endif + test<float, std::denorm_present>(); + test<double, std::denorm_present>(); + test<long double, std::denorm_present>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp new file mode 100644 index 000000000000..660ecf5036d3 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// has_denorm_loss + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::has_denorm_loss == expected, "has_denorm_loss test 1"); + static_assert(std::numeric_limits<const T>::has_denorm_loss == expected, "has_denorm_loss test 2"); + static_assert(std::numeric_limits<volatile T>::has_denorm_loss == expected, "has_denorm_loss test 3"); + static_assert(std::numeric_limits<const volatile T>::has_denorm_loss == expected, "has_denorm_loss test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, false>(); + test<signed char, false>(); + test<unsigned char, false>(); + test<wchar_t, false>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, false>(); + test<int, false>(); + test<unsigned int, false>(); + test<long, false>(); + test<unsigned long, false>(); + test<long long, false>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, false>(); +#endif + test<float, false>(); + test<double, false>(); + test<long double, false>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp new file mode 100644 index 000000000000..f8ca2059d46a --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// has_infinity + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::has_infinity == expected, "has_infinity test 1"); + static_assert(std::numeric_limits<const T>::has_infinity == expected, "has_infinity test 2"); + static_assert(std::numeric_limits<volatile T>::has_infinity == expected, "has_infinity test 3"); + static_assert(std::numeric_limits<const volatile T>::has_infinity == expected, "has_infinity test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, false>(); + test<signed char, false>(); + test<unsigned char, false>(); + test<wchar_t, false>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, false>(); + test<int, false>(); + test<unsigned int, false>(); + test<long, false>(); + test<unsigned long, false>(); + test<long long, false>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, false>(); +#endif + test<float, true>(); + test<double, true>(); + test<long double, true>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp new file mode 100644 index 000000000000..7592171695fb --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// has_quiet_NaN + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::has_quiet_NaN == expected, "has_quiet_NaN test 1"); + static_assert(std::numeric_limits<const T>::has_quiet_NaN == expected, "has_quiet_NaN test 2"); + static_assert(std::numeric_limits<volatile T>::has_quiet_NaN == expected, "has_quiet_NaN test 3"); + static_assert(std::numeric_limits<const volatile T>::has_quiet_NaN == expected, "has_quiet_NaN test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, false>(); + test<signed char, false>(); + test<unsigned char, false>(); + test<wchar_t, false>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, false>(); + test<int, false>(); + test<unsigned int, false>(); + test<long, false>(); + test<unsigned long, false>(); + test<long long, false>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, false>(); +#endif + test<float, true>(); + test<double, true>(); + test<long double, true>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp new file mode 100644 index 000000000000..d68cd5d78878 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// has_signaling_NaN + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::has_signaling_NaN == expected, "has_signaling_NaN test 1"); + static_assert(std::numeric_limits<const T>::has_signaling_NaN == expected, "has_signaling_NaN test 2"); + static_assert(std::numeric_limits<volatile T>::has_signaling_NaN == expected, "has_signaling_NaN test 3"); + static_assert(std::numeric_limits<const volatile T>::has_signaling_NaN == expected, "has_signaling_NaN test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, false>(); + test<signed char, false>(); + test<unsigned char, false>(); + test<wchar_t, false>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, false>(); + test<int, false>(); + test<unsigned int, false>(); + test<long, false>(); + test<unsigned long, false>(); + test<long long, false>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, false>(); +#endif + test<float, true>(); + test<double, true>(); + test<long double, true>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp new file mode 100644 index 000000000000..a2ccca333cc6 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// infinity() + +#include <limits> +#include <cfloat> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::infinity() == expected); + assert(std::numeric_limits<const T>::infinity() == expected); + assert(std::numeric_limits<volatile T>::infinity() == expected); + assert(std::numeric_limits<const volatile T>::infinity() == expected); +} + +extern float zero; + +int main() +{ + test<bool>(false); + test<char>(0); + test<signed char>(0); + test<unsigned char>(0); + test<wchar_t>(0); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(0); + test<char32_t>(0); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(0); + test<unsigned short>(0); + test<int>(0); + test<unsigned int>(0); + test<long>(0); + test<unsigned long>(0); + test<long long>(0); + test<unsigned long long>(0); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(0); + test<__uint128_t>(0); +#endif + test<float>(1./zero); + test<double>(1./zero); + test<long double>(1./zero); +} + +float zero = 0; diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp new file mode 100644 index 000000000000..fa714d5d1506 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// is_bounded + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::is_bounded == expected, "is_bounded test 1"); + static_assert(std::numeric_limits<const T>::is_bounded == expected, "is_bounded test 2"); + static_assert(std::numeric_limits<volatile T>::is_bounded == expected, "is_bounded test 3"); + static_assert(std::numeric_limits<const volatile T>::is_bounded == expected, "is_bounded test 4"); +} + +int main() +{ + test<bool, true>(); + test<char, true>(); + test<signed char, true>(); + test<unsigned char, true>(); + test<wchar_t, true>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, true>(); + test<char32_t, true>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, true>(); + test<unsigned short, true>(); + test<int, true>(); + test<unsigned int, true>(); + test<long, true>(); + test<unsigned long, true>(); + test<long long, true>(); + test<unsigned long long, true>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, true>(); + test<__uint128_t, true>(); +#endif + test<float, true>(); + test<double, true>(); + test<long double, true>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp new file mode 100644 index 000000000000..b96a0e7fc5f5 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// is_exact + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::is_exact == expected, "is_exact test 1"); + static_assert(std::numeric_limits<const T>::is_exact == expected, "is_exact test 2"); + static_assert(std::numeric_limits<volatile T>::is_exact == expected, "is_exact test 3"); + static_assert(std::numeric_limits<const volatile T>::is_exact == expected, "is_exact test 4"); +} + +int main() +{ + test<bool, true>(); + test<char, true>(); + test<signed char, true>(); + test<unsigned char, true>(); + test<wchar_t, true>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, true>(); + test<char32_t, true>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, true>(); + test<unsigned short, true>(); + test<int, true>(); + test<unsigned int, true>(); + test<long, true>(); + test<unsigned long, true>(); + test<long long, true>(); + test<unsigned long long, true>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, true>(); + test<__uint128_t, true>(); +#endif + test<float, false>(); + test<double, false>(); + test<long double, false>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp new file mode 100644 index 000000000000..4408714c1a1d --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp @@ -0,0 +1,56 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// is_iec559 + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::is_iec559 == expected, "is_iec559 test 1"); + static_assert(std::numeric_limits<const T>::is_iec559 == expected, "is_iec559 test 2"); + static_assert(std::numeric_limits<volatile T>::is_iec559 == expected, "is_iec559 test 3"); + static_assert(std::numeric_limits<const volatile T>::is_iec559 == expected, "is_iec559 test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, false>(); + test<signed char, false>(); + test<unsigned char, false>(); + test<wchar_t, false>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, false>(); + test<int, false>(); + test<unsigned int, false>(); + test<long, false>(); + test<unsigned long, false>(); + test<long long, false>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, false>(); +#endif + test<float, true>(); + test<double, true>(); +#if (defined(__ppc__) || defined(__ppc64__)) + test<long double, false>(); +#else + test<long double, true>(); +#endif +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp new file mode 100644 index 000000000000..79bc5867ec63 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// is_integer + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::is_integer == expected, "is_integer test 1"); + static_assert(std::numeric_limits<const T>::is_integer == expected, "is_integer test 2"); + static_assert(std::numeric_limits<volatile T>::is_integer == expected, "is_integer test 3"); + static_assert(std::numeric_limits<const volatile T>::is_integer == expected, "is_integer test 4"); +} + +int main() +{ + test<bool, true>(); + test<char, true>(); + test<signed char, true>(); + test<unsigned char, true>(); + test<wchar_t, true>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, true>(); + test<char32_t, true>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, true>(); + test<unsigned short, true>(); + test<int, true>(); + test<unsigned int, true>(); + test<long, true>(); + test<unsigned long, true>(); + test<long long, true>(); + test<unsigned long long, true>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, true>(); + test<__uint128_t, true>(); +#endif + test<float, false>(); + test<double, false>(); + test<long double, false>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp new file mode 100644 index 000000000000..6a609963d04c --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// is_modulo + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::is_modulo == expected, "is_modulo test 1"); + static_assert(std::numeric_limits<const T>::is_modulo == expected, "is_modulo test 2"); + static_assert(std::numeric_limits<volatile T>::is_modulo == expected, "is_modulo test 3"); + static_assert(std::numeric_limits<const volatile T>::is_modulo == expected, "is_modulo test 4"); +} + +int main() +{ + test<bool, false>(); +// test<char, false>(); // don't know + test<signed char, false>(); + test<unsigned char, true>(); +// test<wchar_t, false>(); // don't know +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, true>(); + test<char32_t, true>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, true>(); + test<int, false>(); + test<unsigned int, true>(); + test<long, false>(); + test<unsigned long, true>(); + test<long long, false>(); + test<unsigned long long, true>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, true>(); +#endif + test<float, false>(); + test<double, false>(); + test<long double, false>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp new file mode 100644 index 000000000000..28570fd22790 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// is_signed + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::is_signed == expected, "is_signed test 1"); + static_assert(std::numeric_limits<const T>::is_signed == expected, "is_signed test 2"); + static_assert(std::numeric_limits<volatile T>::is_signed == expected, "is_signed test 3"); + static_assert(std::numeric_limits<const volatile T>::is_signed == expected, "is_signed test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, char(-1) < char(0)>(); + test<signed char, true>(); + test<unsigned char, false>(); + test<wchar_t, wchar_t(-1) < wchar_t(0)>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, true>(); + test<unsigned short, false>(); + test<int, true>(); + test<unsigned int, false>(); + test<long, true>(); + test<unsigned long, false>(); + test<long long, true>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, true>(); + test<__uint128_t, false>(); +#endif + test<float, true>(); + test<double, true>(); + test<long double, true>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp new file mode 100644 index 000000000000..21090aa9c4c1 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// lowest() + +#include <limits> +#include <climits> +#include <cwchar> +#include <cfloat> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::lowest() == expected); + assert(std::numeric_limits<T>::is_bounded); + assert(std::numeric_limits<const T>::lowest() == expected); + assert(std::numeric_limits<const T>::is_bounded); + assert(std::numeric_limits<volatile T>::lowest() == expected); + assert(std::numeric_limits<volatile T>::is_bounded); + assert(std::numeric_limits<const volatile T>::lowest() == expected); + assert(std::numeric_limits<const volatile T>::is_bounded); +} + +int main() +{ + test<bool>(false); + test<char>(CHAR_MIN); + test<signed char>(SCHAR_MIN); + test<unsigned char>(0); + test<wchar_t>(WCHAR_MIN); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(0); + test<char32_t>(0); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(SHRT_MIN); + test<unsigned short>(0); + test<int>(INT_MIN); + test<unsigned int>(0); + test<long>(LONG_MIN); + test<unsigned long>(0); + test<long long>(LLONG_MIN); + test<unsigned long long>(0); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(-__int128_t(__uint128_t(-1)/2) - 1); + test<__uint128_t>(0); +#endif + test<float>(-FLT_MAX); + test<double>(-DBL_MAX); + test<long double>(-LDBL_MAX); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp new file mode 100644 index 000000000000..7517aaa192c1 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// max() + +#include <limits> +#include <climits> +#include <cwchar> +#include <cfloat> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::max() == expected); + assert(std::numeric_limits<T>::is_bounded); + assert(std::numeric_limits<const T>::max() == expected); + assert(std::numeric_limits<const T>::is_bounded); + assert(std::numeric_limits<volatile T>::max() == expected); + assert(std::numeric_limits<volatile T>::is_bounded); + assert(std::numeric_limits<const volatile T>::max() == expected); + assert(std::numeric_limits<const volatile T>::is_bounded); +} + +int main() +{ + test<bool>(true); + test<char>(CHAR_MAX); + test<signed char>(SCHAR_MAX); + test<unsigned char>(UCHAR_MAX); + test<wchar_t>(WCHAR_MAX); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(USHRT_MAX); + test<char32_t>(UINT_MAX); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(SHRT_MAX); + test<unsigned short>(USHRT_MAX); + test<int>(INT_MAX); + test<unsigned int>(UINT_MAX); + test<long>(LONG_MAX); + test<unsigned long>(ULONG_MAX); + test<long long>(LLONG_MAX); + test<unsigned long long>(ULLONG_MAX); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(__int128_t(__uint128_t(-1)/2)); + test<__uint128_t>(__uint128_t(-1)); +#endif + test<float>(FLT_MAX); + test<double>(DBL_MAX); + test<long double>(LDBL_MAX); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp new file mode 100644 index 000000000000..de771ebe3b42 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// max_digits10 + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::max_digits10 == expected, "max_digits10 test 1"); + static_assert(std::numeric_limits<const T>::max_digits10 == expected, "max_digits10 test 2"); + static_assert(std::numeric_limits<volatile T>::max_digits10 == expected, "max_digits10 test 3"); + static_assert(std::numeric_limits<const volatile T>::max_digits10 == expected, "max_digits10 test 4"); +} + +int main() +{ + test<bool, 0>(); + test<char, 0>(); + test<signed char, 0>(); + test<unsigned char, 0>(); + test<wchar_t, 0>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 0>(); + test<char32_t, 0>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 0>(); + test<unsigned short, 0>(); + test<int, 0>(); + test<unsigned int, 0>(); + test<long, 0>(); + test<unsigned long, 0>(); + test<long long, 0>(); + test<unsigned long long, 0>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 0>(); + test<__uint128_t, 0>(); +#endif + test<float, 2+(FLT_MANT_DIG * 30103)/100000>(); + test<double, 2+(DBL_MANT_DIG * 30103)/100000>(); + test<long double, 2+(LDBL_MANT_DIG * 30103)/100000>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp new file mode 100644 index 000000000000..6b61f7ba4331 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// max_exponent + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::max_exponent == expected, "max_exponent test 1"); + static_assert(std::numeric_limits<const T>::max_exponent == expected, "max_exponent test 2"); + static_assert(std::numeric_limits<volatile T>::max_exponent == expected, "max_exponent test 3"); + static_assert(std::numeric_limits<const volatile T>::max_exponent == expected, "max_exponent test 4"); +} + +int main() +{ + test<bool, 0>(); + test<char, 0>(); + test<signed char, 0>(); + test<unsigned char, 0>(); + test<wchar_t, 0>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 0>(); + test<char32_t, 0>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 0>(); + test<unsigned short, 0>(); + test<int, 0>(); + test<unsigned int, 0>(); + test<long, 0>(); + test<unsigned long, 0>(); + test<long long, 0>(); + test<unsigned long long, 0>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 0>(); + test<__uint128_t, 0>(); +#endif + test<float, FLT_MAX_EXP>(); + test<double, DBL_MAX_EXP>(); + test<long double, LDBL_MAX_EXP>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp new file mode 100644 index 000000000000..927585e9468b --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// max_exponent10 + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::max_exponent10 == expected, "max_exponent10 test 1"); + static_assert(std::numeric_limits<const T>::max_exponent10 == expected, "max_exponent10 test 2"); + static_assert(std::numeric_limits<volatile T>::max_exponent10 == expected, "max_exponent10 test 3"); + static_assert(std::numeric_limits<const volatile T>::max_exponent10 == expected, "max_exponent10 test 4"); +} + +int main() +{ + test<bool, 0>(); + test<char, 0>(); + test<signed char, 0>(); + test<unsigned char, 0>(); + test<wchar_t, 0>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 0>(); + test<char32_t, 0>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 0>(); + test<unsigned short, 0>(); + test<int, 0>(); + test<unsigned int, 0>(); + test<long, 0>(); + test<unsigned long, 0>(); + test<long long, 0>(); + test<unsigned long long, 0>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 0>(); + test<__uint128_t, 0>(); +#endif + test<float, FLT_MAX_10_EXP>(); + test<double, DBL_MAX_10_EXP>(); + test<long double, LDBL_MAX_10_EXP>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp new file mode 100644 index 000000000000..e72fbba10512 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// min() + +#include <limits> +#include <climits> +#include <cwchar> +#include <cfloat> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::min() == expected); + assert(std::numeric_limits<T>::is_bounded || !std::numeric_limits<T>::is_signed); + assert(std::numeric_limits<const T>::min() == expected); + assert(std::numeric_limits<const T>::is_bounded || !std::numeric_limits<const T>::is_signed); + assert(std::numeric_limits<volatile T>::min() == expected); + assert(std::numeric_limits<volatile T>::is_bounded || !std::numeric_limits<volatile T>::is_signed); + assert(std::numeric_limits<const volatile T>::min() == expected); + assert(std::numeric_limits<const volatile T>::is_bounded || !std::numeric_limits<const volatile T>::is_signed); +} + +int main() +{ + test<bool>(false); + test<char>(CHAR_MIN); + test<signed char>(SCHAR_MIN); + test<unsigned char>(0); + test<wchar_t>(WCHAR_MIN); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(0); + test<char32_t>(0); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(SHRT_MIN); + test<unsigned short>(0); + test<int>(INT_MIN); + test<unsigned int>(0); + test<long>(LONG_MIN); + test<unsigned long>(0); + test<long long>(LLONG_MIN); + test<unsigned long long>(0); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(-__int128_t(__uint128_t(-1)/2) - 1); + test<__uint128_t>(0); +#endif + test<float>(FLT_MIN); + test<double>(DBL_MIN); + test<long double>(LDBL_MIN); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp new file mode 100644 index 000000000000..245e8441499d --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// min_exponent + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::min_exponent == expected, "min_exponent test 1"); + static_assert(std::numeric_limits<const T>::min_exponent == expected, "min_exponent test 2"); + static_assert(std::numeric_limits<volatile T>::min_exponent == expected, "min_exponent test 3"); + static_assert(std::numeric_limits<const volatile T>::min_exponent == expected, "min_exponent test 4"); +} + +int main() +{ + test<bool, 0>(); + test<char, 0>(); + test<signed char, 0>(); + test<unsigned char, 0>(); + test<wchar_t, 0>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 0>(); + test<char32_t, 0>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 0>(); + test<unsigned short, 0>(); + test<int, 0>(); + test<unsigned int, 0>(); + test<long, 0>(); + test<unsigned long, 0>(); + test<long long, 0>(); + test<unsigned long long, 0>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 0>(); + test<__uint128_t, 0>(); +#endif + test<float, FLT_MIN_EXP>(); + test<double, DBL_MIN_EXP>(); + test<long double, LDBL_MIN_EXP>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp new file mode 100644 index 000000000000..b54d46fd52e8 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// min_exponent10 + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::min_exponent10 == expected, "min_exponent10 test 1"); + static_assert(std::numeric_limits<const T>::min_exponent10 == expected, "min_exponent10 test 2"); + static_assert(std::numeric_limits<volatile T>::min_exponent10 == expected, "min_exponent10 test 3"); + static_assert(std::numeric_limits<const volatile T>::min_exponent10 == expected, "min_exponent10 test 4"); +} + +int main() +{ + test<bool, 0>(); + test<char, 0>(); + test<signed char, 0>(); + test<unsigned char, 0>(); + test<wchar_t, 0>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 0>(); + test<char32_t, 0>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 0>(); + test<unsigned short, 0>(); + test<int, 0>(); + test<unsigned int, 0>(); + test<long, 0>(); + test<unsigned long, 0>(); + test<long long, 0>(); + test<unsigned long long, 0>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 0>(); + test<__uint128_t, 0>(); +#endif + test<float, FLT_MIN_10_EXP>(); + test<double, DBL_MIN_10_EXP>(); + test<long double, LDBL_MIN_10_EXP>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp new file mode 100644 index 000000000000..97166f0c3209 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// quiet_NaN() + +#include <limits> +#include <cmath> +#include <type_traits> +#include <cassert> + +template <class T> +void +test_imp(std::true_type) +{ + assert(std::isnan(std::numeric_limits<T>::quiet_NaN())); + assert(std::isnan(std::numeric_limits<const T>::quiet_NaN())); + assert(std::isnan(std::numeric_limits<volatile T>::quiet_NaN())); + assert(std::isnan(std::numeric_limits<const volatile T>::quiet_NaN())); +} + +template <class T> +void +test_imp(std::false_type) +{ + assert(std::numeric_limits<T>::quiet_NaN() == T()); + assert(std::numeric_limits<const T>::quiet_NaN() == T()); + assert(std::numeric_limits<volatile T>::quiet_NaN() == T()); + assert(std::numeric_limits<const volatile T>::quiet_NaN() == T()); +} + +template <class T> +inline +void +test() +{ + test_imp<T>(std::is_floating_point<T>()); +} + +int main() +{ + test<bool>(); + test<char>(); + test<signed char>(); + test<unsigned char>(); + test<wchar_t>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(); + test<char32_t>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(); + test<unsigned short>(); + test<int>(); + test<unsigned int>(); + test<long>(); + test<unsigned long>(); + test<long long>(); + test<unsigned long long>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(); + test<__uint128_t>(); +#endif + test<float>(); + test<double>(); + test<long double>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp new file mode 100644 index 000000000000..98a2a53d192e --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// radix + +#include <limits> +#include <cfloat> + +template <class T, int expected> +void +test() +{ + static_assert(std::numeric_limits<T>::radix == expected, "radix test 1"); + static_assert(std::numeric_limits<const T>::radix == expected, "radix test 2"); + static_assert(std::numeric_limits<volatile T>::radix == expected, "radix test 3"); + static_assert(std::numeric_limits<const volatile T>::radix == expected, "radix test 4"); +} + +int main() +{ + test<bool, 2>(); + test<char, 2>(); + test<signed char, 2>(); + test<unsigned char, 2>(); + test<wchar_t, 2>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, 2>(); + test<char32_t, 2>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, 2>(); + test<unsigned short, 2>(); + test<int, 2>(); + test<unsigned int, 2>(); + test<long, 2>(); + test<unsigned long, 2>(); + test<long long, 2>(); + test<unsigned long long, 2>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, 2>(); + test<__uint128_t, 2>(); +#endif + test<float, FLT_RADIX>(); + test<double, FLT_RADIX>(); + test<long double, FLT_RADIX>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp new file mode 100644 index 000000000000..5da5c9513a86 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// round_error() + +#include <limits> +#include <cfloat> +#include <cassert> + +template <class T> +void +test(T expected) +{ + assert(std::numeric_limits<T>::round_error() == expected); + assert(std::numeric_limits<const T>::round_error() == expected); + assert(std::numeric_limits<volatile T>::round_error() == expected); + assert(std::numeric_limits<const volatile T>::round_error() == expected); +} + +int main() +{ + test<bool>(false); + test<char>(0); + test<signed char>(0); + test<unsigned char>(0); + test<wchar_t>(0); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(0); + test<char32_t>(0); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(0); + test<unsigned short>(0); + test<int>(0); + test<unsigned int>(0); + test<long>(0); + test<unsigned long>(0); + test<long long>(0); + test<unsigned long long>(0); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(0); + test<__uint128_t>(0); +#endif + test<float>(0.5); + test<double>(0.5); + test<long double>(0.5); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp new file mode 100644 index 000000000000..645f6f7df76a --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// round_style + +#include <limits> + +template <class T, std::float_round_style expected> +void +test() +{ + static_assert(std::numeric_limits<T>::round_style == expected, "round_style test 1"); + static_assert(std::numeric_limits<const T>::round_style == expected, "round_style test 2"); + static_assert(std::numeric_limits<volatile T>::round_style == expected, "round_style test 3"); + static_assert(std::numeric_limits<const volatile T>::round_style == expected, "round_style test 4"); +} + +int main() +{ + test<bool, std::round_toward_zero>(); + test<char, std::round_toward_zero>(); + test<signed char, std::round_toward_zero>(); + test<unsigned char, std::round_toward_zero>(); + test<wchar_t, std::round_toward_zero>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, std::round_toward_zero>(); + test<char32_t, std::round_toward_zero>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, std::round_toward_zero>(); + test<unsigned short, std::round_toward_zero>(); + test<int, std::round_toward_zero>(); + test<unsigned int, std::round_toward_zero>(); + test<long, std::round_toward_zero>(); + test<unsigned long, std::round_toward_zero>(); + test<long long, std::round_toward_zero>(); + test<unsigned long long, std::round_toward_zero>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, std::round_toward_zero>(); + test<__uint128_t, std::round_toward_zero>(); +#endif + test<float, std::round_to_nearest>(); + test<double, std::round_to_nearest>(); + test<long double, std::round_to_nearest>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp new file mode 100644 index 000000000000..d9df999ddb70 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// signaling_NaN() + +#include <limits> +#include <cmath> +#include <type_traits> +#include <cassert> + +template <class T> +void +test_imp(std::true_type) +{ + assert(std::isnan(std::numeric_limits<T>::signaling_NaN())); + assert(std::isnan(std::numeric_limits<const T>::signaling_NaN())); + assert(std::isnan(std::numeric_limits<volatile T>::signaling_NaN())); + assert(std::isnan(std::numeric_limits<const volatile T>::signaling_NaN())); +} + +template <class T> +void +test_imp(std::false_type) +{ + assert(std::numeric_limits<T>::signaling_NaN() == T()); + assert(std::numeric_limits<const T>::signaling_NaN() == T()); + assert(std::numeric_limits<volatile T>::signaling_NaN() == T()); + assert(std::numeric_limits<const volatile T>::signaling_NaN() == T()); +} + +template <class T> +inline +void +test() +{ + test_imp<T>(std::is_floating_point<T>()); +} + +int main() +{ + test<bool>(); + test<char>(); + test<signed char>(); + test<unsigned char>(); + test<wchar_t>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t>(); + test<char32_t>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short>(); + test<unsigned short>(); + test<int>(); + test<unsigned int>(); + test<long>(); + test<unsigned long>(); + test<long long>(); + test<unsigned long long>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t>(); + test<__uint128_t>(); +#endif + test<float>(); + test<double>(); + test<long double>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp new file mode 100644 index 000000000000..9e2a8431a4e0 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// tinyness_before + +#include <limits> + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::tinyness_before == expected, "tinyness_before test 1"); + static_assert(std::numeric_limits<const T>::tinyness_before == expected, "tinyness_before test 2"); + static_assert(std::numeric_limits<volatile T>::tinyness_before == expected, "tinyness_before test 3"); + static_assert(std::numeric_limits<const volatile T>::tinyness_before == expected, "tinyness_before test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, false>(); + test<signed char, false>(); + test<unsigned char, false>(); + test<wchar_t, false>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, false>(); + test<char32_t, false>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, false>(); + test<unsigned short, false>(); + test<int, false>(); + test<unsigned int, false>(); + test<long, false>(); + test<unsigned long, false>(); + test<long long, false>(); + test<unsigned long long, false>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, false>(); + test<__uint128_t, false>(); +#endif + test<float, false>(); + test<double, false>(); + test<long double, false>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp new file mode 100644 index 000000000000..af93e78c0e91 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// traps + +#include <limits> + +#if defined(__i386__) || defined(__x86_64__) || defined(__pnacl__) +static const bool integral_types_trap = true; +#else +static const bool integral_types_trap = false; +#endif + +template <class T, bool expected> +void +test() +{ + static_assert(std::numeric_limits<T>::traps == expected, "traps test 1"); + static_assert(std::numeric_limits<const T>::traps == expected, "traps test 2"); + static_assert(std::numeric_limits<volatile T>::traps == expected, "traps test 3"); + static_assert(std::numeric_limits<const volatile T>::traps == expected, "traps test 4"); +} + +int main() +{ + test<bool, false>(); + test<char, integral_types_trap>(); + test<signed char, integral_types_trap>(); + test<unsigned char, integral_types_trap>(); + test<wchar_t, integral_types_trap>(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test<char16_t, integral_types_trap>(); + test<char32_t, integral_types_trap>(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test<short, integral_types_trap>(); + test<unsigned short, integral_types_trap>(); + test<int, integral_types_trap>(); + test<unsigned int, integral_types_trap>(); + test<long, integral_types_trap>(); + test<unsigned long, integral_types_trap>(); + test<long long, integral_types_trap>(); + test<unsigned long long, integral_types_trap>(); +#ifndef _LIBCPP_HAS_NO_INT128 + test<__int128_t, integral_types_trap>(); + test<__uint128_t, integral_types_trap>(); +#endif + test<float, false>(); + test<double, false>(); + test<long double, false>(); +} diff --git a/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp new file mode 100644 index 000000000000..6cf5681d82ba --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp @@ -0,0 +1,83 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// The default numeric_limits<T> template shall have all members, but with +// 0 or false values. + +#include <limits> +#include <cassert> + +struct A +{ + A(int i = 0) : data_(i) {} + int data_; +}; + +bool operator == (const A& x, const A& y) {return x.data_ == y.data_;} + +int main() +{ + static_assert(std::numeric_limits<A>::is_specialized == false, + "std::numeric_limits<A>::is_specialized == false"); + assert(std::numeric_limits<A>::min() == A()); + assert(std::numeric_limits<A>::max() == A()); + assert(std::numeric_limits<A>::lowest() == A()); + static_assert(std::numeric_limits<A>::digits == 0, + "std::numeric_limits<A>::digits == 0"); + static_assert(std::numeric_limits<A>::digits10 == 0, + "std::numeric_limits<A>::digits10 == 0"); + static_assert(std::numeric_limits<A>::max_digits10 == 0, + "std::numeric_limits<A>::max_digits10 == 0"); + static_assert(std::numeric_limits<A>::is_signed == false, + "std::numeric_limits<A>::is_signed == false"); + static_assert(std::numeric_limits<A>::is_integer == false, + "std::numeric_limits<A>::is_integer == false"); + static_assert(std::numeric_limits<A>::is_exact == false, + "std::numeric_limits<A>::is_exact == false"); + static_assert(std::numeric_limits<A>::radix == 0, + "std::numeric_limits<A>::radix == 0"); + assert(std::numeric_limits<A>::epsilon() == A()); + assert(std::numeric_limits<A>::round_error() == A()); + static_assert(std::numeric_limits<A>::min_exponent == 0, + "std::numeric_limits<A>::min_exponent == 0"); + static_assert(std::numeric_limits<A>::min_exponent10 == 0, + "std::numeric_limits<A>::min_exponent10 == 0"); + static_assert(std::numeric_limits<A>::max_exponent == 0, + "std::numeric_limits<A>::max_exponent == 0"); + static_assert(std::numeric_limits<A>::max_exponent10 == 0, + "std::numeric_limits<A>::max_exponent10 == 0"); + static_assert(std::numeric_limits<A>::has_infinity == false, + "std::numeric_limits<A>::has_infinity == false"); + static_assert(std::numeric_limits<A>::has_quiet_NaN == false, + "std::numeric_limits<A>::has_quiet_NaN == false"); + static_assert(std::numeric_limits<A>::has_signaling_NaN == false, + "std::numeric_limits<A>::has_signaling_NaN == false"); + static_assert(std::numeric_limits<A>::has_denorm == std::denorm_absent, + "std::numeric_limits<A>::has_denorm == std::denorm_absent"); + static_assert(std::numeric_limits<A>::has_denorm_loss == false, + "std::numeric_limits<A>::has_denorm_loss == false"); + assert(std::numeric_limits<A>::infinity() == A()); + assert(std::numeric_limits<A>::quiet_NaN() == A()); + assert(std::numeric_limits<A>::signaling_NaN() == A()); + assert(std::numeric_limits<A>::denorm_min() == A()); + static_assert(std::numeric_limits<A>::is_iec559 == false, + "std::numeric_limits<A>::is_iec559 == false"); + static_assert(std::numeric_limits<A>::is_bounded == false, + "std::numeric_limits<A>::is_bounded == false"); + static_assert(std::numeric_limits<A>::is_modulo == false, + "std::numeric_limits<A>::is_modulo == false"); + static_assert(std::numeric_limits<A>::traps == false, + "std::numeric_limits<A>::traps == false"); + static_assert(std::numeric_limits<A>::tinyness_before == false, + "std::numeric_limits<A>::tinyness_before == false"); + static_assert(std::numeric_limits<A>::round_style == std::round_toward_zero, + "std::numeric_limits<A>::round_style == std::round_toward_zero"); +} diff --git a/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp b/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp new file mode 100644 index 000000000000..b58f5c55b643 --- /dev/null +++ b/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} diff --git a/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp b/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp new file mode 100644 index 000000000000..d6c70c4cf230 --- /dev/null +++ b/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// test numeric_limits + +// float_denorm_style + +#include <limits> + +typedef char one; +struct two {one _[2];}; + +one test(std::float_denorm_style); +two test(int); + +int main() +{ + static_assert(std::denorm_indeterminate == -1, + "std::denorm_indeterminate == -1"); + static_assert(std::denorm_absent == 0, + "std::denorm_absent == 0"); + static_assert(std::denorm_present == 1, + "std::denorm_present == 1"); + static_assert(sizeof(test(std::denorm_present)) == 1, + "sizeof(test(std::denorm_present)) == 1"); + static_assert(sizeof(test(1)) == 2, + "sizeof(test(1)) == 2"); +} diff --git a/test/std/language.support/support.limits/limits/version.pass.cpp b/test/std/language.support/support.limits/limits/version.pass.cpp new file mode 100644 index 000000000000..0cb3f6f52a4e --- /dev/null +++ b/test/std/language.support/support.limits/limits/version.pass.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// <limits> + +#include <limits> + +#ifndef _LIBCPP_VERSION +#error _LIBCPP_VERSION not defined +#endif + +int main() +{ +} |