libcxx/test/std/depr/depr.c.headers/stdint_h.pass.cpp

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