stdlib/tst-strtol-binary-main.c

   1 /* Test strtol functions with C23 binary integers.
   2    Copyright (C) 2022-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <inttypes.h>
  20 #include <limits.h>
  21 #include <locale.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <wchar.h>
  26
  27 #include <support/check.h>
  28 #if TEST_LOCALE
  29 # include <support/support.h>
  30 #endif
  31
  32 #define CONCAT_(X, Y) X ## Y
  33 #define CONCAT(X, Y) CONCAT_ (X, Y)
  34 #define FNX(FN) CONCAT (FNPFX, FN)
  35
  36 #if WIDE
  37 # define STRCHR wcschr
  38 #else
  39 # define STRCHR strchr
  40 #endif
  41
  42 #define CHECK_RES(ARG, RES, EP, EXPECTED, EXPECTED_EP)                  \
  43   do                                                                    \
  44     {                                                                   \
  45       if (TEST_C23)                                                     \
  46         {                                                               \
  47           TEST_COMPARE ((RES), EXPECTED);                               \
  48           TEST_VERIFY ((EP) == EXPECTED_EP);                            \
  49         }                                                               \
  50       else                                                              \
  51         {                                                               \
  52           TEST_COMPARE ((RES), 0);                                      \
  53           TEST_VERIFY ((EP) == ((ARG)[0] == L_('-')                     \
  54                                 ? (ARG) + 2                             \
  55                                 : (ARG) + 1));                          \
  56         }                                                               \
  57     }                                                                   \
  58   while (0)
  59
  60 static void
  61 one_check (const CHAR *s, const CHAR *expected_p, long int expected_l,
  62            unsigned long int expected_ul, long long int expected_ll,
  63            unsigned long long int expected_ull)
  64 {
  65   expected_p = expected_p == NULL ? STRCHR (s, '\0') : expected_p;
  66
  67   CHAR *ep;
  68   long int ret_l;
  69   unsigned long int ret_ul;
  70   long long int ret_ll;
  71   unsigned long long int ret_ull;
  72   ret_l = FNX (l) (s, &ep, 0);
  73   CHECK_RES (s, ret_l, ep, expected_l, expected_p);
  74   ret_l = FNX (l) (s, &ep, 2);
  75   CHECK_RES (s, ret_l, ep, expected_l, expected_p);
  76   ret_ul = FNX (ul) (s, &ep, 0);
  77   CHECK_RES (s, ret_ul, ep, expected_ul, expected_p);
  78   ret_ul = FNX (ul) (s, &ep, 2);
  79   CHECK_RES (s, ret_ul, ep, expected_ul, expected_p);
  80   ret_ll = FNX (ll) (s, &ep, 0);
  81   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
  82   ret_ll = FNX (ll) (s, &ep, 2);
  83   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
  84   ret_ull = FNX (ull) (s, &ep, 0);
  85   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
  86   ret_ull = FNX (ull) (s, &ep, 2);
  87   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
  88   ret_ll = FNX (imax) (s, &ep, 0);
  89   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
  90   ret_ll = FNX (imax) (s, &ep, 2);
  91   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
  92   ret_ull = FNX (umax) (s, &ep, 0);
  93   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
  94   ret_ull = FNX (umax) (s, &ep, 2);
  95   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
  96 #if TEST_Q
  97   ret_ll = FNX (q) (s, &ep, 0);
  98   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
  99   ret_ll = FNX (q) (s, &ep, 2);
 100   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
 101   ret_ull = FNX (uq) (s, &ep, 0);
 102   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
 103   ret_ull = FNX (uq) (s, &ep, 2);
 104   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
 105 #endif
 106 #if TEST_LOCALE
 107   locale_t loc = xnewlocale (LC_NUMERIC_MASK, "C", (locale_t) 0);
 108   ret_l = FNX (l_l) (s, &ep, 0, loc);
 109   CHECK_RES (s, ret_l, ep, expected_l, expected_p);
 110   ret_l = FNX (l_l) (s, &ep, 2, loc);
 111   CHECK_RES (s, ret_l, ep, expected_l, expected_p);
 112   ret_ul = FNX (ul_l) (s, &ep, 0, loc);
 113   CHECK_RES (s, ret_ul, ep, expected_ul, expected_p);
 114   ret_ul = FNX (ul_l) (s, &ep, 2, loc);
 115   CHECK_RES (s, ret_ul, ep, expected_ul, expected_p);
 116   ret_ll = FNX (ll_l) (s, &ep, 0, loc);
 117   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
 118   ret_ll = FNX (ll_l) (s, &ep, 2, loc);
 119   CHECK_RES (s, ret_ll, ep, expected_ll, expected_p);
 120   ret_ull = FNX (ull_l) (s, &ep, 0, loc);
 121   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
 122   ret_ull = FNX (ull_l) (s, &ep, 2, loc);
 123   CHECK_RES (s, ret_ull, ep, expected_ull, expected_p);
 124 #endif
 125 }
 126
 127 static int
 128 do_test (void)
 129 {
 130   {
 131     const CHAR *input = L_("0b");
 132     one_check (input, input + 1, 0L, 0UL, 0LL, 0ULL);
 133   }
 134   one_check (L_("0b101"), NULL, 5, 5, 5, 5);
 135   one_check (L_("0B101"), NULL, 5, 5, 5, 5);
 136   one_check (L_("-0b11111"), NULL, -31, -31, -31, -31);
 137   one_check (L_("-0B11111"), NULL, -31, -31, -31, -31);
 138   one_check (L_("0b111111111111111111111111111111111"), NULL,
 139              LONG_MAX >= 0x1ffffffffLL ? (long int) 0x1ffffffffLL : LONG_MAX,
 140              (ULONG_MAX >= 0x1ffffffffULL
 141               ? (unsigned long int) 0x1ffffffffULL
 142               : ULONG_MAX),
 143              0x1ffffffffLL, 0x1ffffffffULL);
 144   one_check (L_("0B111111111111111111111111111111111"), NULL,
 145              LONG_MAX >= 0x1ffffffffLL ? (long int) 0x1ffffffffLL : LONG_MAX,
 146              (ULONG_MAX >= 0x1ffffffffULL
 147               ? (unsigned long int) 0x1ffffffffULL
 148               : ULONG_MAX),
 149              0x1ffffffffLL, 0x1ffffffffULL);
 150   one_check (L_("-0b111111111111111111111111111111111"), NULL,
 151              LONG_MIN <= -0x1ffffffffLL ? (long int) -0x1ffffffffLL : LONG_MIN,
 152              (ULONG_MAX >= 0x1ffffffffULL
 153               ? (unsigned long int) -0x1ffffffffULL
 154               : ULONG_MAX),
 155              -0x1ffffffffLL, -0x1ffffffffULL);
 156   one_check (L_("-0B111111111111111111111111111111111"), NULL,
 157              LONG_MIN <= -0x1ffffffffLL ? (long int) -0x1ffffffffLL : LONG_MIN,
 158              (ULONG_MAX >= 0x1ffffffffULL
 159               ? (unsigned long int) -0x1ffffffffULL
 160               : ULONG_MAX),
 161              -0x1ffffffffLL, -0x1ffffffffULL);
 162   return 0;
 163 }
 164
 165 #include <support/test-driver.c>