| //===----------------------------------------------------------------------===// |
| // |
| // 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. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // [depr.c.headers]p2: |
| // Every C header, each of which has a name of the form name.h, behaves as if |
| // each name placed in the standard library namespace by the corresponding |
| // cname header is placed within the global namespace scope. |
| // |
| // This implies that the name in the global namespace and the name in namespace |
| // std declare the same entity, so check that that is actually the case. |
| |
| // Pull in libc++'s static_assert emulation if in C++98 mode. |
| #include <ciso646> |
| |
| template<typename T, T *F, T *G> struct check { static_assert(F == G, ""); }; |
| |
| // ctype.h |
| |
| #include <ctype.h> |
| #include <cctype> |
| |
| void test_ctype() { |
| check<int(int), isalnum, std::isalnum>(); |
| check<int(int), isalpha, std::isalpha>(); |
| check<int(int), isblank, std::isblank>(); |
| check<int(int), iscntrl, std::iscntrl>(); |
| check<int(int), isdigit, std::isdigit>(); |
| check<int(int), isgraph, std::isgraph>(); |
| check<int(int), islower, std::islower>(); |
| check<int(int), isprint, std::isprint>(); |
| check<int(int), ispunct, std::ispunct>(); |
| check<int(int), isspace, std::isspace>(); |
| check<int(int), isupper, std::isupper>(); |
| check<int(int), isxdigit, std::isxdigit>(); |
| check<int(int), tolower, std::tolower>(); |
| check<int(int), toupper, std::toupper>(); |
| } |
| |
| // fenv.h |
| |
| #include <fenv.h> |
| #include <cfenv> |
| |
| void test_fenv() { |
| check<int(int), feclearexcept, std::feclearexcept>(); |
| check<int(fexcept_t *, int), fegetexceptflag, std::fegetexceptflag>(); |
| check<int(int), feraiseexcept, std::feraiseexcept>(); |
| check<int(const fexcept_t *, int), fesetexceptflag, std::fesetexceptflag>(); |
| check<int(int), fetestexcept, std::fetestexcept>(); |
| check<int(), fegetround, std::fegetround>(); |
| check<int(int), fesetround, std::fesetround>(); |
| check<int(fenv_t *), fegetenv, std::fegetenv>(); |
| check<int(fenv_t *), feholdexcept, std::feholdexcept>(); |
| check<int(const fenv_t *), fesetenv, std::fesetenv>(); |
| check<int(const fenv_t *), feupdateenv, std::feupdateenv>(); |
| } |
| |
| // inttypes.h |
| |
| #include <inttypes.h> |
| #include <cinttypes> |
| |
| // Avoid error if abs and div are not declared by <inttypes.h>. |
| struct nat {}; |
| static void abs(nat); |
| static void div(nat); |
| namespace std { |
| static void abs(nat); |
| static void div(nat); |
| } |
| |
| // These may or may not exist, depending on whether intmax_t |
| // is an extended integer type (larger than long long). |
| template<typename I = intmax_t, bool = (sizeof(I) > sizeof(long long))> |
| void test_inttypes_abs_div() { |
| check<I(I), abs, std::abs>(); |
| check<imaxdiv_t(I, I), div, std::div>(); |
| } |
| template<> void test_inttypes_abs_div<intmax_t, false>() {} |
| |
| void test_inttypes() { |
| test_inttypes_abs_div(); |
| |
| check<intmax_t(intmax_t), imaxabs, std::imaxabs>(); |
| check<imaxdiv_t(intmax_t, intmax_t), imaxdiv, std::imaxdiv>(); |
| check<intmax_t(const char *, char **, int), strtoimax, std::strtoimax>(); |
| check<uintmax_t(const char *, char **, int), strtoumax, std::strtoumax>(); |
| check<intmax_t(const wchar_t *, wchar_t **, int), wcstoimax, std::wcstoimax>(); |
| check<uintmax_t(const wchar_t *, wchar_t **, int), wcstoumax, std::wcstoumax>(); |
| } |
| |
| // locale.h |
| |
| #include <locale.h> |
| #include <clocale> |
| |
| void test_locale() { |
| check<char *(int, const char *), setlocale, std::setlocale>(); |
| check<lconv *(), localeconv, std::localeconv>(); |
| } |
| |
| // math.h |
| |
| #include <math.h> |
| #include <cmath> |
| |
| template<typename Float> |
| void test_math_float() { |
| typedef Float ff(Float); |
| typedef Float ffi(Float, int); |
| typedef Float ffpi(Float, int*); |
| typedef Float ffl(Float, long); |
| typedef Float fff(Float, Float); |
| typedef Float ffpf(Float, Float*); |
| typedef Float ffld(Float, long double); |
| typedef Float fffpi(Float, Float, int*); |
| typedef Float ffff(Float, Float, Float); |
| typedef bool bf(Float); |
| typedef bool bff(Float, Float); |
| typedef int i_f(Float); |
| typedef long lf(Float); |
| typedef long long llf(Float); |
| |
| check<ff, abs, std::abs>(); |
| check<ff, acos, std::acos>(); |
| check<ff, acosh, std::acosh>(); |
| check<ff, asin, std::asin>(); |
| check<ff, asinh, std::asinh>(); |
| check<ff, atan, std::atan>(); |
| check<fff, atan2, std::atan2>(); |
| check<ff, atanh, std::atanh>(); |
| check<ff, cbrt, std::cbrt>(); |
| check<ff, ceil, std::ceil>(); |
| check<fff, copysign, std::copysign>(); |
| check<ff, cos, std::cos>(); |
| check<ff, cosh, std::cosh>(); |
| check<ff, erf, std::erf>(); |
| check<ff, erfc, std::erfc>(); |
| check<ff, exp, std::exp>(); |
| check<ff, exp2, std::exp2>(); |
| check<ff, expm1, std::expm1>(); |
| check<ff, fabs, std::fabs>(); |
| check<fff, fdim, std::fdim>(); |
| check<ff, floor, std::floor>(); |
| check<ffff, fma, std::fma>(); |
| check<fff, fmax, std::fmax>(); |
| check<fff, fmin, std::fmin>(); |
| check<fff, fmod, std::fmod>(); |
| check<ffpi, frexp, std::frexp>(); |
| check<fff, hypot, std::hypot>(); |
| check<i_f, ilogb, std::ilogb>(); |
| check<ffi, ldexp, std::ldexp>(); |
| check<ff, lgamma, std::lgamma>(); |
| check<llf, llrint, std::llrint>(); |
| check<llf, llround, std::llround>(); |
| check<ff, log, std::log>(); |
| check<ff, log10, std::log10>(); |
| check<ff, log1p, std::log1p>(); |
| check<ff, log2, std::log2>(); |
| check<ff, logb, std::logb>(); |
| check<lf, lrint, std::lrint>(); |
| check<lf, lround, std::lround>(); |
| check<ffpf, modf, std::modf>(); |
| check<ff, nearbyint, std::nearbyint>(); |
| check<fff, nextafter, std::nextafter>(); |
| check<ffld, nexttoward, std::nexttoward>(); |
| check<fff, pow, std::pow>(); |
| check<fff, remainder, std::remainder>(); |
| check<fffpi, remquo, std::remquo>(); |
| check<ff, rint, std::rint>(); |
| check<ff, round, std::round>(); |
| check<ffl, scalbln, std::scalbln>(); |
| check<ffi, scalbn, std::scalbn>(); |
| check<ff, sin, std::sin>(); |
| check<ff, sinh, std::sinh>(); |
| check<ff, sqrt, std::sqrt>(); |
| check<ff, tan, std::tan>(); |
| check<ff, tanh, std::tanh>(); |
| check<ff, tgamma, std::tgamma>(); |
| check<ff, trunc, std::trunc>(); |
| |
| check<i_f, fpclassify, std::fpclassify>(); |
| check<bf, isfinite, std::isfinite>(); |
| check<bff, isgreater, std::isgreater>(); |
| check<bff, isgreaterequal, std::isgreaterequal>(); |
| check<bf, isinf, std::isinf>(); |
| check<bff, isless, std::isless>(); |
| check<bff, islessequal, std::islessequal>(); |
| check<bff, islessgreater, std::islessgreater>(); |
| check<bf, isnan, std::isnan>(); |
| check<bf, isnormal, std::isnormal>(); |
| check<bff, isunordered, std::isunordered>(); |
| check<bf, signbit, std::signbit>(); |
| } |
| |
| void test_math() { |
| test_math_float<float>(); |
| test_math_float<double>(); |
| test_math_float<long double>(); |
| |
| check<float(const char *), nanf, std::nanf>(); |
| check<double(const char *), nan, std::nan>(); |
| check<long double(const char *), nanl, std::nanl>(); |
| } |
| |
| // setjmp.h |
| |
| #include <setjmp.h> |
| #include <csetjmp> |
| |
| void test_setjmp() { |
| check<void(jmp_buf, int), longjmp, std::longjmp>(); |
| } |
| |
| // signal.h |
| |
| #include <signal.h> |
| #include <csignal> |
| |
| void test_signal() { |
| check<int(int), raise, std::raise>(); |
| typedef void Handler(int); |
| check<Handler *(int, Handler *), signal, std::signal>(); |
| } |
| |
| // stdio.h |
| |
| #include <stdio.h> |
| #include <cstdio> |
| |
| void test_stdio() { |
| check<void(FILE *), clearerr, std::clearerr>(); |
| check<int(FILE *), fclose, std::fclose>(); |
| check<int(FILE *), feof, std::feof>(); |
| check<int(FILE *), ferror, std::ferror>(); |
| check<int(FILE *), fflush, std::fflush>(); |
| check<int(FILE *), fgetc, std::fgetc>(); |
| check<int(FILE *, fpos_t *), fgetpos, std::fgetpos>(); |
| check<char *(char *, int, FILE *), fgets, std::fgets>(); |
| check<FILE *(const char *, const char *), fopen, std::fopen>(); |
| check<int(FILE *, const char *, ...), fprintf, std::fprintf>(); |
| check<int(int, FILE *), fputc, std::fputc>(); |
| check<int(const char *, FILE *), fputs, std::fputs>(); |
| check<size_t(void *, size_t, size_t, FILE *), fread, std::fread>(); |
| check<FILE *(const char *, const char *, FILE *), freopen, std::freopen>(); |
| check<int(FILE *, const char *, ...), fscanf, std::fscanf>(); |
| check<int(FILE *, long, int), fseek, std::fseek>(); |
| check<int(FILE *, const fpos_t *), fsetpos, std::fsetpos>(); |
| check<long(FILE *), ftell, std::ftell>(); |
| check<size_t(const void *, size_t, size_t, FILE *), fwrite, std::fwrite>(); |
| check<int(FILE *), getc, std::getc>(); |
| check<int(), getchar, std::getchar>(); |
| check<void(const char *), perror, std::perror>(); |
| check<int(const char *, ...), printf, std::printf>(); |
| check<int(int, FILE *), putc, std::putc>(); |
| check<int(int), putchar, std::putchar>(); |
| check<int(const char *), puts, std::puts>(); |
| check<int(const char *), remove, std::remove>(); |
| check<int(const char *, const char *), rename, std::rename>(); |
| check<void(FILE *), rewind, std::rewind>(); |
| check<int(const char *, ...), scanf, std::scanf>(); |
| check<void(FILE *, char *), setbuf, std::setbuf>(); |
| check<int(FILE *, char *, int, size_t), setvbuf, std::setvbuf>(); |
| check<int(char *, size_t, const char *, ...), snprintf, std::snprintf>(); |
| check<int(char *, const char *, ...), sprintf, std::sprintf>(); |
| check<int(const char *, const char *, ...), sscanf, std::sscanf>(); |
| check<FILE *(), tmpfile, std::tmpfile>(); |
| check<char *(char *), tmpnam, std::tmpnam>(); |
| check<int(int, FILE *), ungetc, std::ungetc>(); |
| check<int(FILE *, const char *, va_list), vfprintf, std::vfprintf>(); |
| check<int(const char *, va_list), vprintf, std::vprintf>(); |
| check<int(const char *, va_list), vscanf, std::vscanf>(); |
| check<int(char *, size_t, const char *, va_list), vsnprintf, std::vsnprintf>(); |
| check<int(char *, const char *, va_list), vsprintf, std::vsprintf>(); |
| check<int(const char *, const char *, va_list), vsscanf, std::vsscanf>(); |
| } |
| |
| // stdlib.h |
| |
| #include <stdlib.h> |
| #include <cstdlib> |
| |
| void test_stdlib() { |
| typedef int Comp(const void*, const void*); |
| |
| check<void(int), _Exit, std::_Exit>(); |
| check<int(void()), at_quick_exit, std::at_quick_exit>(); |
| check<void(), abort, std::abort>(); |
| check<void(int), exit, std::exit>(); |
| check<int(void()), atexit, std::atexit>(); |
| check<void(int), quick_exit, std::quick_exit>(); |
| check<char *(const char *), getenv, std::getenv>(); |
| check<int(const char *), system, std::system>(); |
| check<void *(size_t, size_t), calloc, std::calloc>(); |
| check<void(void *), free, std::free>(); |
| check<void *(size_t), malloc, std::malloc>(); |
| check<void *(void *, size_t), realloc, std::realloc>(); |
| check<double(const char *), atof, std::atof>(); |
| check<int(const char *), atoi, std::atoi>(); |
| check<long(const char *), atol, std::atol>(); |
| check<long long(const char *), atoll, std::atoll>(); |
| check<int(const char *, size_t), mblen, std::mblen>(); |
| check<int(wchar_t *, const char *, size_t), mbtowc, std::mbtowc>(); |
| check<size_t(wchar_t *, const char *, size_t), mbstowcs, std::mbstowcs>(); |
| check<double(const char *, char **), strtod, std::strtod>(); |
| check<float(const char *, char **), strtof, std::strtof>(); |
| check<long(const char *, char **, int), strtol, std::strtol>(); |
| check<long double(const char *, char **), strtold, std::strtold>(); |
| check<long long(const char *, char **, int), strtoll, std::strtoll>(); |
| check<unsigned long(const char *, char **, int), strtoul, std::strtoul>(); |
| check<unsigned long long(const char *, char **, int), strtoull, std::strtoull>(); |
| check<int(char *, wchar_t), wctomb, std::wctomb>(); |
| check<size_t(char *, const wchar_t *, size_t), wcstombs, std::wcstombs>(); |
| check<void *(const void *, const void *, size_t, size_t, Comp *), bsearch, std::bsearch>(); |
| check<void(void *, size_t, size_t, Comp *), qsort, std::qsort>(); |
| check<int(int), abs, std::abs>(); |
| check<div_t(int, int), div, std::div>(); |
| check<long(long), abs, std::abs>(); |
| check<long(long), labs, std::labs>(); |
| check<ldiv_t(long, long), div, std::div>(); |
| check<ldiv_t(long, long), ldiv, std::ldiv>(); |
| check<long long(long long), abs, std::abs>(); |
| check<long long(long long), llabs, std::llabs>(); |
| check<lldiv_t(long long, long long), div, std::div>(); |
| check<lldiv_t(long long, long long), lldiv, std::lldiv>(); |
| check<int(), rand, std::rand>(); |
| check<void(unsigned), srand, std::srand>(); |
| } |
| |
| // string.h |
| |
| #include <string.h> |
| #include <cstring> |
| |
| void test_string() { |
| check<void *(void *, int, size_t), memchr, std::memchr>(); |
| check<const void *(const void *, int, size_t), memchr, std::memchr>(); |
| check<int(const void *, const void *, size_t), memcmp, std::memcmp>(); |
| check<void *(void *, const void *, size_t), memcpy, std::memcpy>(); |
| check<void *(void *, const void *, size_t), memmove, std::memmove>(); |
| check<void *(void *, int, size_t), memset, std::memset>(); |
| check<char *(char *, const char *), strcat, std::strcat>(); |
| check<char *(char *, int), strchr, std::strchr>(); |
| check<const char *(const char *, int), strchr, std::strchr>(); |
| check<int(const char *, const char *), strcmp, std::strcmp>(); |
| check<int(const char *, const char *), strcoll, std::strcoll>(); |
| check<char *(char *, const char *), strcpy, std::strcpy>(); |
| check<size_t(const char *, const char *), strcspn, std::strcspn>(); |
| check<char *(int), strerror, std::strerror>(); |
| check<size_t(const char *), strlen, std::strlen>(); |
| check<char *(char *, const char *, size_t), strncat, std::strncat>(); |
| check<int(const char *, const char *, size_t), strncmp, std::strncmp>(); |
| check<char *(char *, const char *, size_t), strncpy, std::strncpy>(); |
| check<char *(char *, const char *), strpbrk, std::strpbrk>(); |
| check<const char *(const char *, const char *), strpbrk, std::strpbrk>(); |
| check<char *(char *, int), strrchr, std::strrchr>(); |
| check<const char *(const char *, int), strrchr, std::strrchr>(); |
| check<size_t(const char *, const char *), strspn, std::strspn>(); |
| check<char *(char *, const char *), strstr, std::strstr>(); |
| check<const char *(const char *, const char *), strstr, std::strstr>(); |
| check<char *(char *, const char *), strtok, std::strtok>(); |
| check<size_t(char *, const char *, size_t), strxfrm, std::strxfrm>(); |
| } |
| |
| // time.h |
| |
| #include <time.h> |
| #include <ctime> |
| |
| void test_time() { |
| check<char *(const tm *), asctime, std::asctime>(); |
| check<char *(const time_t *), ctime, std::ctime>(); |
| check<clock_t(), clock, std::clock>(); |
| check<tm *(const time_t *), gmtime, std::gmtime>(); |
| check<double(time_t, time_t), difftime, std::difftime>(); |
| check<time_t(tm *), mktime, std::mktime>(); |
| check<tm *(const time_t *), localtime, std::localtime>(); |
| check<time_t(time_t *), time, std::time>(); |
| check<size_t(char *, size_t, const char *, const tm *), strftime, std::strftime>(); |
| } |
| |
| #if 0 |
| // FIXME: <cuchar> and <uchar.h> are missing. |
| |
| // uchar.h |
| |
| #include <uchar.h> |
| #include <cuchar> |
| |
| void test_uchar() { |
| check<size_t(char16_t *, const char *, size_t, mbstate_t *), mbrtoc16, std::mbrtoc16>(); |
| check<size_t(char32_t *, const char *, size_t, mbstate_t *), mbrtoc32, std::mbrtoc32>(); |
| check<size_t(char *, char16_t, mbstate_t *), c16rtomb, std::c16rtomb>(); |
| check<size_t(char *, char32_t, mbstate_t *), c32rtomb, std::c32rtomb>(); |
| } |
| #endif |
| |
| // wchar.h |
| |
| #include <wchar.h> |
| #include <cwchar> |
| |
| void test_wchar() { |
| check<wint_t(int), btowc, std::btowc>(); |
| check<wint_t(FILE *), fgetwc, std::fgetwc>(); |
| check<wchar_t *(wchar_t *, int, FILE *), fgetws, std::fgetws>(); |
| check<wint_t(wchar_t, FILE *), fputwc, std::fputwc>(); |
| check<int(const wchar_t *, FILE *), fputws, std::fputws>(); |
| check<int(FILE *, int), fwide, std::fwide>(); |
| check<int(FILE *, const wchar_t *, ...), fwprintf, std::fwprintf>(); |
| check<int(FILE *, const wchar_t *, ...), fwscanf, std::fwscanf>(); |
| check<wint_t(), getwchar, std::getwchar>(); |
| check<wint_t(FILE *), getwc, std::getwc>(); |
| check<size_t(const char *, size_t, mbstate_t *), mbrlen, std::mbrlen>(); |
| check<size_t(wchar_t *, const char *, size_t, mbstate_t *), mbrtowc, std::mbrtowc>(); |
| check<int(const mbstate_t *), mbsinit, std::mbsinit>(); |
| check<size_t(wchar_t *, const char **, size_t, mbstate_t *), mbsrtowcs, std::mbsrtowcs>(); |
| check<wint_t(wchar_t), putwchar, std::putwchar>(); |
| check<wint_t(wchar_t, FILE *), putwc, std::putwc>(); |
| check<int(wchar_t *, size_t, const wchar_t *, ...), swprintf, std::swprintf>(); |
| check<int(const wchar_t *, const wchar_t *, ...), swscanf, std::swscanf>(); |
| check<wint_t(wint_t, FILE *), ungetwc, std::ungetwc>(); |
| check<int(FILE *, const wchar_t *, va_list), vfwprintf, std::vfwprintf>(); |
| check<int(FILE *, const wchar_t *, va_list), vfwscanf, std::vfwscanf>(); |
| check<int(wchar_t *, size_t, const wchar_t *, va_list), vswprintf, std::vswprintf>(); |
| check<int(const wchar_t *, const wchar_t *, va_list), vswscanf, std::vswscanf>(); |
| check<int(const wchar_t *, va_list), vwprintf, std::vwprintf>(); |
| check<int(const wchar_t *, va_list), vwscanf, std::vwscanf>(); |
| check<size_t(char *, wchar_t, mbstate_t *), wcrtomb, std::wcrtomb>(); |
| check<wchar_t *(wchar_t *, const wchar_t *), wcscat, std::wcscat>(); |
| check<wchar_t *(wchar_t *, wchar_t), wcschr, std::wcschr>(); |
| check<const wchar_t *(const wchar_t *, wchar_t), wcschr, std::wcschr>(); |
| check<int(const wchar_t *, const wchar_t *), wcscmp, std::wcscmp>(); |
| check<int(const wchar_t *, const wchar_t *), wcscoll, std::wcscoll>(); |
| check<wchar_t *(wchar_t *, const wchar_t *), wcscpy, std::wcscpy>(); |
| check<size_t(const wchar_t *, const wchar_t *), wcscspn, std::wcscspn>(); |
| check<size_t(wchar_t *, size_t, const wchar_t *, const tm *), wcsftime, std::wcsftime>(); |
| check<size_t(const wchar_t *), wcslen, std::wcslen>(); |
| check<wchar_t *(wchar_t *, const wchar_t *, size_t), wcsncat, std::wcsncat>(); |
| check<int(const wchar_t *, const wchar_t *, size_t), wcsncmp, std::wcsncmp>(); |
| check<wchar_t *(wchar_t *, const wchar_t *, size_t), wcsncpy, std::wcsncpy>(); |
| check<wchar_t *(wchar_t *, const wchar_t *), wcspbrk, std::wcspbrk>(); |
| check<const wchar_t *(const wchar_t *, const wchar_t *), wcspbrk, std::wcspbrk>(); |
| check<wchar_t *(wchar_t *, wchar_t), wcsrchr, std::wcsrchr>(); |
| check<const wchar_t *(const wchar_t *, wchar_t), wcsrchr, std::wcsrchr>(); |
| check<size_t(char *, const wchar_t **, size_t, mbstate_t *), wcsrtombs, std::wcsrtombs>(); |
| check<size_t(const wchar_t *, const wchar_t *), wcsspn, std::wcsspn>(); |
| check<wchar_t *(wchar_t *, const wchar_t *), wcsstr, std::wcsstr>(); |
| check<const wchar_t *(const wchar_t *, const wchar_t *), wcsstr, std::wcsstr>(); |
| check<double(const wchar_t *, wchar_t **), wcstod, std::wcstod>(); |
| check<float(const wchar_t *, wchar_t **), wcstof, std::wcstof>(); |
| check<wchar_t *(wchar_t *, const wchar_t *, wchar_t **), wcstok, std::wcstok>(); |
| check<long double(const wchar_t *, wchar_t **), wcstold, std::wcstold>(); |
| check<long long(const wchar_t *, wchar_t **, int), wcstoll, std::wcstoll>(); |
| check<long(const wchar_t *, wchar_t **, int), wcstol, std::wcstol>(); |
| check<unsigned long long(const wchar_t *, wchar_t **, int), wcstoull, std::wcstoull>(); |
| check<unsigned long(const wchar_t *, wchar_t **, int), wcstoul, std::wcstoul>(); |
| check<size_t(wchar_t *, const wchar_t *, size_t), wcsxfrm, std::wcsxfrm>(); |
| check<int(wint_t), wctob, std::wctob>(); |
| check<wchar_t *(wchar_t *, wchar_t, size_t), wmemchr, std::wmemchr>(); |
| check<const wchar_t *(const wchar_t *, wchar_t, size_t), wmemchr, std::wmemchr>(); |
| check<int(const wchar_t *, const wchar_t *, size_t), wmemcmp, std::wmemcmp>(); |
| check<wchar_t *(wchar_t *, const wchar_t *, size_t), wmemcpy, std::wmemcpy>(); |
| check<wchar_t *(wchar_t *, const wchar_t *, size_t), wmemmove, std::wmemmove>(); |
| check<wchar_t *(wchar_t *, wchar_t, size_t), wmemset, std::wmemset>(); |
| check<int(const wchar_t *, ...), wprintf, std::wprintf>(); |
| check<int(const wchar_t *, ...), wscanf, std::wscanf>(); |
| } |
| |
| // wctype.h |
| |
| #include <wctype.h> |
| #include <cwctype> |
| |
| void test_wctype() { |
| check<int(wint_t), iswalnum, std::iswalnum>(); |
| check<int(wint_t), iswalpha, std::iswalpha>(); |
| check<int(wint_t), iswblank, std::iswblank>(); |
| check<int(wint_t), iswcntrl, std::iswcntrl>(); |
| check<int(wint_t, wctype_t), iswctype, std::iswctype>(); |
| check<int(wint_t), iswdigit, std::iswdigit>(); |
| check<int(wint_t), iswgraph, std::iswgraph>(); |
| check<int(wint_t), iswlower, std::iswlower>(); |
| check<int(wint_t), iswprint, std::iswprint>(); |
| check<int(wint_t), iswpunct, std::iswpunct>(); |
| check<int(wint_t), iswspace, std::iswspace>(); |
| check<int(wint_t), iswupper, std::iswupper>(); |
| check<int(wint_t), iswxdigit, std::iswxdigit>(); |
| check<wint_t(wint_t, wctrans_t), towctrans, std::towctrans>(); |
| check<wint_t(wint_t), towlower, std::towlower>(); |
| check<wint_t(wint_t), towupper, std::towupper>(); |
| check<wctrans_t(const char *), wctrans, std::wctrans>(); |
| check<wctype_t(const char *), wctype, std::wctype>(); |
| } |
| |
| int main() { |
| test_ctype(); |
| test_fenv(); |
| test_inttypes(); |
| test_locale(); |
| test_math(); |
| test_setjmp(); |
| test_signal(); |
| test_stdio(); |
| test_stdlib(); |
| test_string(); |
| test_time(); |
| //test_uchar(); |
| test_wchar(); |
| test_wctype(); |
| } |