Home | History | Annotate | Download | only in cstdint.syn 
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // test <cstdint>
     11 
     12 #include <cstdint>
     13 #include <cstddef>
     14 #include <cwchar>
     15 #include <csignal>
     16 #include <cwctype>
     17 #include <climits>
     18 #include <type_traits>
     19 #include <limits>
     20 #include <cassert>
     21 
     22 int main()
     23 {
     24     // typedef std::int8_t
     25     static_assert(sizeof(std::int8_t)*CHAR_BIT == 8,
     26                  "sizeof(std::int8_t)*CHAR_BIT == 8");
     27     static_assert(std::is_signed<std::int8_t>::value,
     28                  "std::is_signed<std::int8_t>::value");
     29     // typedef std::int16_t
     30     static_assert(sizeof(std::int16_t)*CHAR_BIT == 16,
     31                  "sizeof(std::int16_t)*CHAR_BIT == 16");
     32     static_assert(std::is_signed<std::int16_t>::value,
     33                  "std::is_signed<std::int16_t>::value");
     34     // typedef std::int32_t
     35     static_assert(sizeof(std::int32_t)*CHAR_BIT == 32,
     36                  "sizeof(std::int32_t)*CHAR_BIT == 32");
     37     static_assert(std::is_signed<std::int32_t>::value,
     38                  "std::is_signed<std::int32_t>::value");
     39     // typedef std::int64_t
     40     static_assert(sizeof(std::int64_t)*CHAR_BIT == 64,
     41                  "sizeof(std::int64_t)*CHAR_BIT == 64");
     42     static_assert(std::is_signed<std::int64_t>::value,
     43                  "std::is_signed<std::int64_t>::value");
     44 
     45     // typedef std::uint8_t
     46     static_assert(sizeof(std::uint8_t)*CHAR_BIT == 8,
     47                  "sizeof(std::uint8_t)*CHAR_BIT == 8");
     48     static_assert(std::is_unsigned<std::uint8_t>::value,
     49                  "std::is_unsigned<std::uint8_t>::value");
     50     // typedef std::uint16_t
     51     static_assert(sizeof(std::uint16_t)*CHAR_BIT == 16,
     52                  "sizeof(std::uint16_t)*CHAR_BIT == 16");
     53     static_assert(std::is_unsigned<std::uint16_t>::value,
     54                  "std::is_unsigned<std::uint16_t>::value");
     55     // typedef std::uint32_t
     56     static_assert(sizeof(std::uint32_t)*CHAR_BIT == 32,
     57                  "sizeof(std::uint32_t)*CHAR_BIT == 32");
     58     static_assert(std::is_unsigned<std::uint32_t>::value,
     59                  "std::is_unsigned<std::uint32_t>::value");
     60     // typedef std::uint64_t
     61     static_assert(sizeof(std::uint64_t)*CHAR_BIT == 64,
     62                  "sizeof(std::uint64_t)*CHAR_BIT == 64");
     63     static_assert(std::is_unsigned<std::uint64_t>::value,
     64                  "std::is_unsigned<std::uint64_t>::value");
     65 
     66     // typedef std::int_least8_t
     67     static_assert(sizeof(std::int_least8_t)*CHAR_BIT >= 8,
     68                  "sizeof(std::int_least8_t)*CHAR_BIT >= 8");
     69     static_assert(std::is_signed<std::int_least8_t>::value,
     70                  "std::is_signed<std::int_least8_t>::value");
     71     // typedef std::int_least16_t
     72     static_assert(sizeof(std::int_least16_t)*CHAR_BIT >= 16,
     73                  "sizeof(std::int_least16_t)*CHAR_BIT >= 16");
     74     static_assert(std::is_signed<std::int_least16_t>::value,
     75                  "std::is_signed<std::int_least16_t>::value");
     76     // typedef std::int_least32_t
     77     static_assert(sizeof(std::int_least32_t)*CHAR_BIT >= 32,
     78                  "sizeof(std::int_least32_t)*CHAR_BIT >= 32");
     79     static_assert(std::is_signed<std::int_least32_t>::value,
     80                  "std::is_signed<std::int_least32_t>::value");
     81     // typedef std::int_least64_t
     82     static_assert(sizeof(std::int_least64_t)*CHAR_BIT >= 64,
     83                  "sizeof(std::int_least64_t)*CHAR_BIT >= 64");
     84     static_assert(std::is_signed<std::int_least64_t>::value,
     85                  "std::is_signed<std::int_least64_t>::value");
     86 
     87     // typedef std::uint_least8_t
     88     static_assert(sizeof(std::uint_least8_t)*CHAR_BIT >= 8,
     89                  "sizeof(std::uint_least8_t)*CHAR_BIT >= 8");
     90     static_assert(std::is_unsigned<std::uint_least8_t>::value,
     91                  "std::is_unsigned<std::uint_least8_t>::value");
     92     // typedef std::uint_least16_t
     93     static_assert(sizeof(std::uint_least16_t)*CHAR_BIT >= 16,
     94                  "sizeof(std::uint_least16_t)*CHAR_BIT >= 16");
     95     static_assert(std::is_unsigned<std::uint_least16_t>::value,
     96                  "std::is_unsigned<std::uint_least16_t>::value");
     97     // typedef std::uint_least32_t
     98     static_assert(sizeof(std::uint_least32_t)*CHAR_BIT >= 32,
     99                  "sizeof(std::uint_least32_t)*CHAR_BIT >= 32");
    100     static_assert(std::is_unsigned<std::uint_least32_t>::value,
    101                  "std::is_unsigned<std::uint_least32_t>::value");
    102     // typedef std::uint_least64_t
    103     static_assert(sizeof(std::uint_least64_t)*CHAR_BIT >= 64,
    104                  "sizeof(std::uint_least64_t)*CHAR_BIT >= 64");
    105     static_assert(std::is_unsigned<std::uint_least64_t>::value,
    106                  "std::is_unsigned<std::uint_least64_t>::value");
    107 
    108     // typedef std::int_fast8_t
    109     static_assert(sizeof(std::int_fast8_t)*CHAR_BIT >= 8,
    110                  "sizeof(std::int_fast8_t)*CHAR_BIT >= 8");
    111     static_assert(std::is_signed<std::int_fast8_t>::value,
    112                  "std::is_signed<std::int_fast8_t>::value");
    113     // typedef std::int_fast16_t
    114     static_assert(sizeof(std::int_fast16_t)*CHAR_BIT >= 16,
    115                  "sizeof(std::int_fast16_t)*CHAR_BIT >= 16");
    116     static_assert(std::is_signed<std::int_fast16_t>::value,
    117                  "std::is_signed<std::int_fast16_t>::value");
    118     // typedef std::int_fast32_t
    119     static_assert(sizeof(std::int_fast32_t)*CHAR_BIT >= 32,
    120                  "sizeof(std::int_fast32_t)*CHAR_BIT >= 32");
    121     static_assert(std::is_signed<std::int_fast32_t>::value,
    122                  "std::is_signed<std::int_fast32_t>::value");
    123     // typedef std::int_fast64_t
    124     static_assert(sizeof(std::int_fast64_t)*CHAR_BIT >= 64,
    125                  "sizeof(std::int_fast64_t)*CHAR_BIT >= 64");
    126     static_assert(std::is_signed<std::int_fast64_t>::value,
    127                  "std::is_signed<std::int_fast64_t>::value");
    128 
    129     // typedef std::uint_fast8_t
    130     static_assert(sizeof(std::uint_fast8_t)*CHAR_BIT >= 8,
    131                  "sizeof(std::uint_fast8_t)*CHAR_BIT >= 8");
    132     static_assert(std::is_unsigned<std::uint_fast8_t>::value,
    133                  "std::is_unsigned<std::uint_fast8_t>::value");
    134     // typedef std::uint_fast16_t
    135     static_assert(sizeof(std::uint_fast16_t)*CHAR_BIT >= 16,
    136                  "sizeof(std::uint_fast16_t)*CHAR_BIT >= 16");
    137     static_assert(std::is_unsigned<std::uint_fast16_t>::value,
    138                  "std::is_unsigned<std::uint_fast16_t>::value");
    139     // typedef std::uint_fast32_t
    140     static_assert(sizeof(std::uint_fast32_t)*CHAR_BIT >= 32,
    141                  "sizeof(std::uint_fast32_t)*CHAR_BIT >= 32");
    142     static_assert(std::is_unsigned<std::uint_fast32_t>::value,
    143                  "std::is_unsigned<std::uint_fast32_t>::value");
    144     // typedef std::uint_fast64_t
    145     static_assert(sizeof(std::uint_fast64_t)*CHAR_BIT >= 64,
    146                  "sizeof(std::uint_fast64_t)*CHAR_BIT >= 64");
    147     static_assert(std::is_unsigned<std::uint_fast64_t>::value,
    148                  "std::is_unsigned<std::uint_fast64_t>::value");
    149 
    150     // typedef std::intptr_t
    151     static_assert(sizeof(std::intptr_t) >= sizeof(void*),
    152                  "sizeof(std::intptr_t) >= sizeof(void*)");
    153     static_assert(std::is_signed<std::intptr_t>::value,
    154                  "std::is_signed<std::intptr_t>::value");
    155     // typedef std::uintptr_t
    156     static_assert(sizeof(std::uintptr_t) >= sizeof(void*),
    157                  "sizeof(std::uintptr_t) >= sizeof(void*)");
    158     static_assert(std::is_unsigned<std::uintptr_t>::value,
    159                  "std::is_unsigned<std::uintptr_t>::value");
    160 
    161     // typedef std::intmax_t
    162     static_assert(sizeof(std::intmax_t) >= sizeof(long long),
    163                  "sizeof(std::intmax_t) >= sizeof(long long)");
    164     static_assert(std::is_signed<std::intmax_t>::value,
    165                  "std::is_signed<std::intmax_t>::value");
    166     // typedef std::uintmax_t
    167     static_assert(sizeof(std::uintmax_t) >= sizeof(unsigned long long),
    168                  "sizeof(std::uintmax_t) >= sizeof(unsigned long long)");
    169     static_assert(std::is_unsigned<std::uintmax_t>::value,
    170                  "std::is_unsigned<std::uintmax_t>::value");
    171 
    172     // INTN_MIN
    173     static_assert(INT8_MIN == -128, "INT8_MIN == -128");
    174     static_assert(INT16_MIN == -32768, "INT16_MIN == -32768");
    175     static_assert(INT32_MIN == -2147483647 - 1, "INT32_MIN == -2147483648");
    176     static_assert(INT64_MIN == -9223372036854775807LL - 1, "INT64_MIN == -9223372036854775808LL");
    177 
    178     // INTN_MAX
    179     static_assert(INT8_MAX == 127, "INT8_MAX == 127");
    180     static_assert(INT16_MAX == 32767, "INT16_MAX == 32767");
    181     static_assert(INT32_MAX == 2147483647, "INT32_MAX == 2147483647");
    182     static_assert(INT64_MAX == 9223372036854775807LL, "INT64_MAX == 9223372036854775807LL");
    183 
    184     // UINTN_MAX
    185     static_assert(UINT8_MAX == 255, "UINT8_MAX == 255");
    186     static_assert(UINT16_MAX == 65535, "UINT16_MAX == 65535");
    187     static_assert(UINT32_MAX == 4294967295U, "UINT32_MAX == 4294967295");
    188     static_assert(UINT64_MAX == 18446744073709551615ULL, "UINT64_MAX == 18446744073709551615ULL");
    189 
    190     // INT_FASTN_MIN
    191     static_assert(INT_FAST8_MIN <= -128, "INT_FAST8_MIN <= -128");
    192     static_assert(INT_FAST16_MIN <= -32768, "INT_FAST16_MIN <= -32768");
    193     static_assert(INT_FAST32_MIN <= -2147483647 - 1, "INT_FAST32_MIN <= -2147483648");
    194     static_assert(INT_FAST64_MIN <= -9223372036854775807LL - 1, "INT_FAST64_MIN <= -9223372036854775808LL");
    195 
    196     // INT_FASTN_MAX
    197     static_assert(INT_FAST8_MAX >= 127, "INT_FAST8_MAX >= 127");
    198     static_assert(INT_FAST16_MAX >= 32767, "INT_FAST16_MAX >= 32767");
    199     static_assert(INT_FAST32_MAX >= 2147483647, "INT_FAST32_MAX >= 2147483647");
    200     static_assert(INT_FAST64_MAX >= 9223372036854775807LL, "INT_FAST64_MAX >= 9223372036854775807LL");
    201 
    202     // UINT_FASTN_MAX
    203     static_assert(UINT_FAST8_MAX >= 255, "UINT_FAST8_MAX >= 255");
    204     static_assert(UINT_FAST16_MAX >= 65535, "UINT_FAST16_MAX >= 65535");
    205     static_assert(UINT_FAST32_MAX >= 4294967295U, "UINT_FAST32_MAX >= 4294967295");
    206     static_assert(UINT_FAST64_MAX >= 18446744073709551615ULL, "UINT_FAST64_MAX >= 18446744073709551615ULL");
    207 
    208     // INTPTR_MIN
    209     assert(INTPTR_MIN == std::numeric_limits<std::intptr_t>::min());
    210 
    211     // INTPTR_MAX
    212     assert(INTPTR_MAX == std::numeric_limits<std::intptr_t>::max());
    213 
    214     // UINTPTR_MAX
    215     assert(UINTPTR_MAX == std::numeric_limits<std::uintptr_t>::max());
    216 
    217     // INTMAX_MIN
    218     assert(INTMAX_MIN == std::numeric_limits<std::intmax_t>::min());
    219 
    220     // INTMAX_MAX
    221     assert(INTMAX_MAX == std::numeric_limits<std::intmax_t>::max());
    222 
    223     // UINTMAX_MAX
    224     assert(UINTMAX_MAX == std::numeric_limits<std::uintmax_t>::max());
    225 
    226     // PTRDIFF_MIN
    227     assert(PTRDIFF_MIN == std::numeric_limits<std::ptrdiff_t>::min());
    228 
    229     // PTRDIFF_MAX
    230     assert(PTRDIFF_MAX == std::numeric_limits<std::ptrdiff_t>::max());
    231 
    232     // SIG_ATOMIC_MIN
    233     assert(SIG_ATOMIC_MIN == std::numeric_limits<std::sig_atomic_t>::min());
    234 
    235     // SIG_ATOMIC_MAX
    236     assert(SIG_ATOMIC_MAX == std::numeric_limits<std::sig_atomic_t>::max());
    237 
    238     // SIZE_MAX
    239     assert(SIZE_MAX == std::numeric_limits<std::size_t>::max());
    240 
    241     // WCHAR_MIN
    242     assert(WCHAR_MIN == std::numeric_limits<wchar_t>::min());
    243 
    244     // WCHAR_MAX
    245     assert(WCHAR_MAX == std::numeric_limits<wchar_t>::max());
    246 
    247     // WINT_MIN
    248     assert(WINT_MIN == std::numeric_limits<std::wint_t>::min());
    249 
    250     // WINT_MAX
    251     assert(WINT_MAX == std::numeric_limits<std::wint_t>::max());
    252 
    253 #ifndef INT8_C
    254 #error INT8_C not defined
    255 #endif
    256 
    257 #ifndef INT16_C
    258 #error INT16_C not defined
    259 #endif
    260 
    261 #ifndef INT32_C
    262 #error INT32_C not defined
    263 #endif
    264 
    265 #ifndef INT64_C
    266 #error INT64_C not defined
    267 #endif
    268 
    269 #ifndef UINT8_C
    270 #error UINT8_C not defined
    271 #endif
    272 
    273 #ifndef UINT16_C
    274 #error UINT16_C not defined
    275 #endif
    276 
    277 #ifndef UINT32_C
    278 #error UINT32_C not defined
    279 #endif
    280 
    281 #ifndef UINT64_C
    282 #error UINT64_C not defined
    283 #endif
    284 
    285 #ifndef INTMAX_C
    286 #error INTMAX_C not defined
    287 #endif
    288 
    289 #ifndef UINTMAX_C
    290 #error UINTMAX_C not defined
    291 #endif
    292 }
    293