tests/test-vasnwprintf-big.c

   1 /* Test of [v]asnwprintf() with big results.
   2    Copyright (C) 2024-2025 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2024.  */
  18
  19 #include <config.h>
  20
  21 #include "vasnwprintf.h"
  22
  23 #include "physmem.h"
  24
  25 /* Get INT_MAX.  */
  26 #include <limits.h>
  27
  28 /* Get PTRDIFF_MAX.  */
  29 #include <stdint.h>
  30
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <wchar.h>
  35
  36 #if HAVE_SETRLIMIT
  37 # include <sys/types.h>
  38 # include <sys/time.h>
  39 # include <sys/resource.h>
  40 #endif
  41
  42 #include "macros.h"
  43
  44 int
  45 main ()
  46 {
  47 #if PTRDIFF_MAX == INT_MAX
  48   fputs ("Skipping test: ptrdiff_t is not 64-bits wide\n", stderr);
  49   return 77;
  50 #else
  51   bool skipped = false;
  52   /* Disable core files that would be huge.  */
  53 # if HAVE_SETRLIMIT && defined RLIMIT_CORE
  54   struct rlimit rl;
  55   rl.rlim_cur = rl.rlim_max = 0;
  56   setrlimit (RLIMIT_CORE, &rl);
  57 # endif
  58   /* The test below needs about 40 GiB of memory:
  59        $ time /usr/bin/time -f "Max RSS: %M KiB" ./test-vasnwprintf-big
  60        Max RSS: 41944784 KiB
  61        real    5m8,508s
  62        user    4m38,035s
  63        sys     0m30,456s
  64      5 GiB for the inputs in the %s tests,
  65      or 20 GiB for the inputs in the %ls tests,
  66      and up to 20 GiB for temporary output buffers.  */
  67   double needed = 40.0 * 1024 * 1024 * 1024;
  68   double avail = physmem_claimable (1.0);
  69   printf ("memory needed = %g MiB, available = %g MiB\n",
  70           needed / 1024 / 1024, avail / 1024 / 1024);
  71   if (avail >= needed)
  72     {
  73       /* Note: The malloc() calls can fail, due to ulimit of RLIMIT_DATA.
  74          For example, on OpenBSD 7.5, the soft limit is 1.0 GiB or 1.5 GiB,
  75          and you need "ulimit -d 42991616".  */
  76
  77       /* Verify that asnwprintf() can return a string of size > 4 GiB.  */
  78       {
  79         size_t n1 = 3 * (INT_MAX / 4) + 10;
  80         size_t n2 = 3 * (INT_MAX / 4) + 20;
  81         char *s1;
  82         char *s2;
  83
  84         s1 = (char *) malloc (n1 + 1);
  85         if (s1 != NULL)
  86           {
  87             memset (s1, 'a', n1);
  88             s1[n1] = '\0';
  89
  90             s2 = (char *) malloc (n2 + 1);
  91             if (s2 != NULL)
  92               {
  93                 memset (s2, 'b', n2);
  94                 s1[n1] = '\0';
  95
  96                 size_t len;
  97                 wchar_t *s = asnwprintf (NULL, &len, L"x%sy%sz", s1, s2);
  98                 if (s == NULL)
  99                   {
 100                     ASSERT (errno == ENOMEM);
 101                     skipped = true;
 102                   }
 103                 else
 104                   {
 105                     ASSERT (wcslen (s) == len);
 106                     ASSERT (len == n1 + n2 + 3);
 107                     size_t i;
 108                     for (i = 0; i <= len; i++)
 109                       s[i] = (i == 0 ? 'x' :
 110                               i <= n1 ? 'a' :
 111                               i == n1 + 1 ? 'y' :
 112                               i <= n1 + n2 + 1 ? 'b' :
 113                               i == n1 + n2 + 2 ? 'z' :
 114                               '\0');
 115                     free (s);
 116                   }
 117                 free (s2);
 118               }
 119             free (s1);
 120           }
 121       }
 122
 123       /* Verify that asnwprintf() can take a string of size > 2 GiB, < 4 GiB
 124          as argument.  */
 125       {
 126         size_t n1 = 3 * (size_t) (INT_MAX / 2) + 10;
 127         char *s1;
 128
 129         s1 = (char *) malloc (n1 + 1);
 130         if (s1 != NULL)
 131           {
 132             memset (s1, 'a', n1);
 133             s1[n1] = '\0';
 134
 135             size_t len;
 136             wchar_t *s = asnwprintf (NULL, &len, L"x%sy", s1);
 137             if (s == NULL)
 138               {
 139                 ASSERT (errno == ENOMEM);
 140                 skipped = true;
 141               }
 142             else
 143               {
 144                 ASSERT (wcslen (s) == len);
 145                 ASSERT (len == n1 + 2);
 146                 size_t i;
 147                 for (i = 0; i <= len; i++)
 148                   s[i] = (i == 0 ? 'x' :
 149                           i <= n1 ? 'a' :
 150                           i == n1 + 1 ? 'y' :
 151                           '\0');
 152                 free (s);
 153               }
 154             free (s1);
 155           }
 156       }
 157
 158       /* Verify that asnwprintf() can take a string of size > 4 GiB
 159          as argument.  */
 160       {
 161         size_t n1 = 5 * (size_t) (INT_MAX / 2) + 10;
 162         if (n1 > (size_t) INT_MAX)
 163           {
 164             char *s1;
 165
 166             s1 = (char *) malloc (n1 + 1);
 167             if (s1 != NULL)
 168               {
 169                 memset (s1, 'a', n1);
 170                 s1[n1] = '\0';
 171
 172                 size_t len;
 173                 wchar_t *s = asnwprintf (NULL, &len, L"x%sy", s1);
 174                 if (s == NULL)
 175                   {
 176                     ASSERT (errno == ENOMEM);
 177                     skipped = true;
 178                   }
 179                 else
 180                   {
 181                     ASSERT (wcslen (s) == len);
 182                     ASSERT (len == n1 + 2);
 183                     size_t i;
 184                     for (i = 0; i <= len; i++)
 185                       s[i] = (i == 0 ? 'x' :
 186                               i <= n1 ? 'a' :
 187                               i == n1 + 1 ? 'y' :
 188                               '\0');
 189                     free (s);
 190                   }
 191                 free (s1);
 192               }
 193           }
 194       }
 195
 196       /* Verify that asnwprintf() can take a wide string with an element count
 197          > 2^31, < 2^32 as argument.  */
 198       {
 199         size_t n1 = 3 * (size_t) (INT_MAX / 2) + 10;
 200         wchar_t *s1;
 201
 202         s1 = (wchar_t *) malloc ((n1 + 1) * sizeof (wchar_t));
 203         if (s1 != NULL)
 204           {
 205             wmemset (s1, L'a', n1);
 206             s1[n1] = L'\0';
 207
 208             size_t len;
 209             wchar_t *s = asnwprintf (NULL, &len, L"x%lsy", s1);
 210             if (s == NULL)
 211               {
 212                 ASSERT (errno == ENOMEM);
 213                 skipped = true;
 214               }
 215             else
 216               {
 217                 ASSERT (wcslen (s) == len);
 218                 ASSERT (len == n1 + 2);
 219                 size_t i;
 220                 for (i = 0; i <= len; i++)
 221                   s[i] = (i == 0 ? 'x' :
 222                           i <= n1 ? 'a' :
 223                           i == n1 + 1 ? 'y' :
 224                           '\0');
 225                 free (s);
 226               }
 227             free (s1);
 228           }
 229       }
 230
 231       /* Verify that asnwprintf() can take a wide string with an element count
 232          > 2^32 as argument.  */
 233       {
 234         size_t n1 = 5 * (size_t) (INT_MAX / 2) + 10;
 235         if (n1 > (size_t) INT_MAX)
 236           {
 237             wchar_t *s1;
 238
 239             s1 = (wchar_t *) malloc ((n1 + 1) * sizeof (wchar_t));
 240             if (s1 != NULL)
 241               {
 242                 wmemset (s1, L'a', n1);
 243                 s1[n1] = L'\0';
 244
 245                 size_t len;
 246                 wchar_t *s = asnwprintf (NULL, &len, L"x%lsy", s1);
 247                 if (s == NULL)
 248                   {
 249                     ASSERT (errno == ENOMEM);
 250                     skipped = true;
 251                   }
 252                 else
 253                   {
 254                     ASSERT (wcslen (s) == len);
 255                     ASSERT (len == n1 + 2);
 256                     size_t i;
 257                     for (i = 0; i <= len; i++)
 258                       s[i] = (i == 0 ? 'x' :
 259                               i <= n1 ? 'a' :
 260                               i == n1 + 1 ? 'y' :
 261                               '\0');
 262                     free (s);
 263                   }
 264                 free (s1);
 265               }
 266           }
 267       }
 268     }
 269   else
 270     skipped = true;
 271
 272   if (test_exit_status != EXIT_SUCCESS)
 273     return test_exit_status;
 274   if (skipped)
 275     {
 276       fputs ("Skipping test: not enough memory available\n", stderr);
 277       return 77;
 278     }
 279   return 0;
 280 #endif
 281 }