generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move test into test/std subdirectory.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2014-12-20 01:40:03 +00:00
parent 669a8a5a19
commit a90c6dd460
4817 changed files with 13 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp Normal file
View File

@@ -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)
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp Normal file
View File

@@ -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__);
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp Normal file
View File

@@ -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>();
}

57
test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp Normal file
View File

@@ -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>();
}

54
test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp Normal file
View File

@@ -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);
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp Normal file
View File

@@ -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>();
}

58
test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp Normal file
View File

@@ -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;

52
test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp Normal file
View File

@@ -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>();
}

56
test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp Normal file
View File

@@ -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
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp Normal file
View File

@@ -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>();
}

60
test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp Normal file
View File

@@ -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);
}

60
test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp Normal file
View File

@@ -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);
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp Normal file
View File

@@ -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>();
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp Normal file
View File

@@ -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>();
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp Normal file
View File

@@ -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>();
}

60
test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp Normal file
View File

@@ -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);
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp Normal file
View File

@@ -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>();
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp Normal file
View File

@@ -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>();
}

73
test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp Normal file
View File

@@ -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>();
}

53
test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp Normal file
View File

@@ -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>();
}

54
test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp Normal file
View File

@@ -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);
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp Normal file
View File

@@ -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>();
}

73
test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp Normal file
View File

@@ -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>();
}

52
test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp Normal file
View File

@@ -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>();
}

58
test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp Normal file
View File

@@ -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>();
}