lib/replace/test/testsuite.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    libreplace tests
   5
   6    Copyright (C) Jelmer Vernooij 2006
   7
   8      ** NOTE! The following LGPL license applies to the talloc
   9      ** library. This does NOT imply that all of Samba is released
  10      ** under the LGPL
  11
  12    This library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Lesser General Public
  14    License as published by the Free Software Foundation; either
  15    version 3 of the License, or (at your option) any later version.
  16
  17    This library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Lesser General Public License for more details.
  21
  22    You should have received a copy of the GNU Lesser General Public
  23    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "replace.h"
  27
  28 /*
  29   we include all the system/ include files here so that libreplace tests
  30   them in the build farm
  31 */
  32 #include "system/capability.h"
  33 #include "system/dir.h"
  34 #include "system/filesys.h"
  35 #include "system/glob.h"
  36 #include "system/iconv.h"
  37 #include "system/locale.h"
  38 #include "system/network.h"
  39 #include "system/passwd.h"
  40 #include "system/readline.h"
  41 #include "system/select.h"
  42 #include "system/shmem.h"
  43 #include "system/syslog.h"
  44 #include "system/terminal.h"
  45 #include "system/time.h"
  46 #include "system/wait.h"
  47 #include "system/aio.h"
  48
  49 #define TESTFILE "testfile.dat"
  50
  51 struct torture_context;
  52 bool torture_local_replace(struct torture_context *ctx);
  53
  54 /*
  55   test ftruncate() function
  56  */
  57 static int test_ftruncate(void)
  58 {
  59         struct stat st;
  60         int fd;
  61         const int size = 1234;
  62         printf("test: ftruncate\n");
  63         unlink(TESTFILE);
  64         fd = open(TESTFILE, O_RDWR|O_CREAT, 0600);
  65         if (fd == -1) {
  66                 printf("failure: ftruncate [\n"
  67                            "creating '%s' failed - %s\n]\n", TESTFILE, strerror(errno));
  68                 return false;
  69         }
  70         if (ftruncate(fd, size) != 0) {
  71                 printf("failure: ftruncate [\n%s\n]\n", strerror(errno));
  72                 return false;
  73         }
  74         if (fstat(fd, &st) != 0) {
  75                 printf("failure: ftruncate [\nfstat failed - %s\n]\n", strerror(errno));
  76                 return false;
  77         }
  78         if (st.st_size != size) {
  79                 printf("failure: ftruncate [\ngave wrong size %d - expected %d\n]\n",
  80                        (int)st.st_size, size);
  81                 return false;
  82         }
  83         unlink(TESTFILE);
  84         printf("success: ftruncate\n");
  85         return true;
  86 }
  87
  88 /*
  89   test strlcpy() function.
  90   see http://www.gratisoft.us/todd/papers/strlcpy.html
  91  */
  92 static int test_strlcpy(void)
  93 {
  94         char buf[4];
  95         const struct {
  96                 const char *src;
  97                 size_t result;
  98         } tests[] = {
  99                 { "abc", 3 },
 100                 { "abcdef", 6 },
 101                 { "abcd", 4 },
 102                 { "", 0 },
 103                 { NULL, 0 }
 104         };
 105         int i;
 106         printf("test: strlcpy\n");
 107         for (i=0;tests[i].src;i++) {
 108                 if (strlcpy(buf, tests[i].src, sizeof(buf)) != tests[i].result) {
 109                         printf("failure: strlcpy [\ntest %d failed\n]\n", i);
 110                         return false;
 111                 }
 112         }
 113         printf("success: strlcpy\n");
 114         return true;
 115 }
 116
 117 static int test_strlcat(void)
 118 {
 119         char tmp[10];
 120         printf("test: strlcat\n");
 121         strlcpy(tmp, "", sizeof(tmp));
 122         if (strlcat(tmp, "bla", 3) != 3) {
 123                 printf("failure: strlcat [\ninvalid return code\n]\n");
 124                 return false;
 125         }
 126         if (strcmp(tmp, "bl") != 0) {
 127                 printf("failure: strlcat [\nexpected \"bl\", got \"%s\"\n]\n",
 128                            tmp);
 129                 return false;
 130         }
 131
 132         strlcpy(tmp, "da", sizeof(tmp));
 133         if (strlcat(tmp, "me", 4) != 4) {
 134                 printf("failure: strlcat [\nexpected \"dam\", got \"%s\"\n]\n",
 135                            tmp);
 136                 return false;
 137         }
 138
 139         printf("success: strlcat\n");
 140         return true;
 141 }
 142
 143 static int test_mktime(void)
 144 {
 145         /* FIXME */
 146         return true;
 147 }
 148
 149 static int test_initgroups(void)
 150 {
 151         /* FIXME */
 152         return true;
 153 }
 154
 155 static int test_memmove(void)
 156 {
 157         /* FIXME */
 158         return true;
 159 }
 160
 161 static int test_strdup(void)
 162 {
 163         char *x;
 164         printf("test: strdup\n");
 165         x = strdup("bla");
 166         if (strcmp("bla", x) != 0) {
 167                 printf("failure: strdup [\nfailed: expected \"bla\", got \"%s\"\n]\n",
 168                            x);
 169                 return false;
 170         }
 171         free(x);
 172         printf("success: strdup\n");
 173         return true;
 174 }
 175
 176 static int test_setlinebuf(void)
 177 {
 178         printf("test: setlinebuf\n");
 179         setlinebuf(stdout);
 180         printf("success: setlinebuf\n");
 181         return true;
 182 }
 183
 184 static int test_vsyslog(void)
 185 {
 186         /* FIXME */
 187         return true;
 188 }
 189
 190 static int test_timegm(void)
 191 {
 192         /* FIXME */
 193         return true;
 194 }
 195
 196 static int test_setenv(void)
 197 {
 198 #define TEST_SETENV(key, value, overwrite, result) do { \
 199         int _ret; \
 200         char *_v; \
 201         _ret = setenv(key, value, overwrite); \
 202         if (_ret != 0) { \
 203                 printf("failure: setenv [\n" \
 204                         "setenv(%s, %s, %d) failed\n" \
 205                         "]\n", \
 206                         key, value, overwrite); \
 207                 return false; \
 208         } \
 209         _v=getenv(key); \
 210         if (!_v) { \
 211                 printf("failure: setenv [\n" \
 212                         "getenv(%s) returned NULL\n" \
 213                         "]\n", \
 214                         key); \
 215                 return false; \
 216         } \
 217         if (strcmp(result, _v) != 0) { \
 218                 printf("failure: setenv [\n" \
 219                         "getenv(%s): '%s' != '%s'\n" \
 220                         "]\n", \
 221                         key, result, _v); \
 222                 return false; \
 223         } \
 224 } while(0)
 225
 226 #define TEST_UNSETENV(key) do { \
 227         char *_v; \
 228         unsetenv(key); \
 229         _v=getenv(key); \
 230         if (_v) { \
 231                 printf("failure: setenv [\n" \
 232                         "getenv(%s): NULL != '%s'\n" \
 233                         "]\n", \
 234                         SETENVTEST_KEY, _v); \
 235                 return false; \
 236         } \
 237 } while (0)
 238
 239 #define SETENVTEST_KEY "SETENVTESTKEY"
 240 #define SETENVTEST_VAL "SETENVTESTVAL"
 241
 242         printf("test: setenv\n");
 243         TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"1", 0, SETENVTEST_VAL"1");
 244         TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"2", 0, SETENVTEST_VAL"1");
 245         TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"3", 1, SETENVTEST_VAL"3");
 246         TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"4", 1, SETENVTEST_VAL"4");
 247         TEST_UNSETENV(SETENVTEST_KEY);
 248         TEST_UNSETENV(SETENVTEST_KEY);
 249         TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"5", 0, SETENVTEST_VAL"5");
 250         TEST_UNSETENV(SETENVTEST_KEY);
 251         TEST_UNSETENV(SETENVTEST_KEY);
 252         printf("success: setenv\n");
 253         return true;
 254 }
 255
 256 static int test_strndup(void)
 257 {
 258         char *x;
 259         printf("test: strndup\n");
 260         x = strndup("bla", 0);
 261         if (strcmp(x, "") != 0) {
 262                 printf("failure: strndup [\ninvalid\n]\n");
 263                 return false;
 264         }
 265         free(x);
 266         x = strndup("bla", 2);
 267         if (strcmp(x, "bl") != 0) {
 268                 printf("failure: strndup [\ninvalid\n]\n");
 269                 return false;
 270         }
 271         free(x);
 272         x = strndup("bla", 10);
 273         if (strcmp(x, "bla") != 0) {
 274                 printf("failure: strndup [\ninvalid\n]\n");
 275                 return false;
 276         }
 277         free(x);
 278         printf("success: strndup\n");
 279         return true;
 280 }
 281
 282 static int test_strnlen(void)
 283 {
 284         printf("test: strnlen\n");
 285         if (strnlen("bla", 2) != 2) {
 286                 printf("failure: strnlen [\nunexpected length\n]\n");
 287                 return false;
 288         }
 289
 290         if (strnlen("some text\n", 0) != 0) {
 291                 printf("failure: strnlen [\nunexpected length\n]\n");
 292                 return false;
 293         }
 294
 295         if (strnlen("some text", 20) != 9) {
 296                 printf("failure: strnlen [\nunexpected length\n]\n");
 297                 return false;
 298         }
 299
 300         printf("success: strnlen\n");
 301         return true;
 302 }
 303
 304 static int test_waitpid(void)
 305 {
 306         /* FIXME */
 307         return true;
 308 }
 309
 310 static int test_seteuid(void)
 311 {
 312         /* FIXME */
 313         return true;
 314 }
 315
 316 static int test_setegid(void)
 317 {
 318         /* FIXME */
 319         return true;
 320 }
 321
 322 static int test_asprintf(void)
 323 {
 324         char *x;
 325         printf("test: asprintf\n");
 326         if (asprintf(&x, "%d", 9) != 1) {
 327                 printf("failure: asprintf [\ngenerate asprintf\n]\n");
 328                 return false;
 329         }
 330         if (strcmp(x, "9") != 0) {
 331                 printf("failure: asprintf [\ngenerate asprintf\n]\n");
 332                 return false;
 333         }
 334         if (asprintf(&x, "dat%s", "a") != 4) {
 335                 printf("failure: asprintf [\ngenerate asprintf\n]\n");
 336                 return false;
 337         }
 338         if (strcmp(x, "data") != 0) {
 339                 printf("failure: asprintf [\ngenerate asprintf\n]\n");
 340                 return false;
 341         }
 342         printf("success: asprintf\n");
 343         return true;
 344 }
 345
 346 static int test_snprintf(void)
 347 {
 348         char tmp[10];
 349         printf("test: snprintf\n");
 350         if (snprintf(tmp, 3, "foo%d", 9) != 4) {
 351                 printf("failure: snprintf [\nsnprintf return code failed\n]\n");
 352                 return false;
 353         }
 354
 355         if (strcmp(tmp, "fo") != 0) {
 356                 printf("failure: snprintf [\nsnprintf failed\n]\n");
 357                 return false;
 358         }
 359
 360         printf("success: snprintf\n");
 361         return true;
 362 }
 363
 364 static int test_vasprintf(void)
 365 {
 366         /* FIXME */
 367         return true;
 368 }
 369
 370 static int test_vsnprintf(void)
 371 {
 372         /* FIXME */
 373         return true;
 374 }
 375
 376 static int test_opendir(void)
 377 {
 378         /* FIXME */
 379         return true;
 380 }
 381
 382 extern int test_readdir_os2_delete(void);
 383
 384 static int test_readdir(void)
 385 {
 386         printf("test: readdir\n");
 387         if (test_readdir_os2_delete() != 0) {
 388                 return false;
 389         }
 390         printf("success: readdir\n");
 391         return true;
 392 }
 393
 394 static int test_telldir(void)
 395 {
 396         /* FIXME */
 397         return true;
 398 }
 399
 400 static int test_seekdir(void)
 401 {
 402         /* FIXME */
 403         return true;
 404 }
 405
 406 static int test_dlopen(void)
 407 {
 408         /* FIXME: test dlopen, dlsym, dlclose, dlerror */
 409         return true;
 410 }
 411
 412
 413 static int test_chroot(void)
 414 {
 415         /* FIXME: chroot() */
 416         return true;
 417 }
 418
 419 static int test_bzero(void)
 420 {
 421         /* FIXME: bzero */
 422         return true;
 423 }
 424
 425 static int test_strerror(void)
 426 {
 427         /* FIXME */
 428         return true;
 429 }
 430
 431 static int test_errno(void)
 432 {
 433         printf("test: errno\n");
 434         errno = 3;
 435         if (errno != 3) {
 436                 printf("failure: errno [\nerrno failed\n]\n");
 437                 return false;
 438         }
 439
 440         printf("success: errno\n");
 441         return true;
 442 }
 443
 444 static int test_mkdtemp(void)
 445 {
 446         /* FIXME */
 447         return true;
 448 }
 449
 450 static int test_mkstemp(void)
 451 {
 452         /* FIXME */
 453         return true;
 454 }
 455
 456 static int test_pread(void)
 457 {
 458         /* FIXME */
 459         return true;
 460 }
 461
 462 static int test_pwrite(void)
 463 {
 464         /* FIXME */
 465         return true;
 466 }
 467
 468 static int test_getpass(void)
 469 {
 470         /* FIXME */
 471         return true;
 472 }
 473
 474 static int test_inet_ntoa(void)
 475 {
 476         /* FIXME */
 477         return true;
 478 }
 479
 480 #define TEST_STRTO_X(type,fmt,func,str,base,res,diff,rrnoo) do {\
 481         type _v; \
 482         char _s[64]; \
 483         char *_p = NULL;\
 484         char *_ep = NULL; \
 485         strlcpy(_s, str, sizeof(_s));\
 486         if (diff >= 0) { \
 487                 _ep = &_s[diff]; \
 488         } \
 489         errno = 0; \
 490         _v = func(_s, &_p, base); \
 491         if (errno != rrnoo) { \
 492                 printf("failure: %s [\n" \
 493                        "\t%s\n" \
 494                        "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
 495                        "\terrno: %d != %d\n" \
 496                        "]\n", \
 497                         __STRING(func), __location__, __STRING(func), \
 498                        str, diff, base, res, _v, rrnoo, errno); \
 499                 return false; \
 500         } else if (_v != res) { \
 501                 printf("failure: %s [\n" \
 502                        "\t%s\n" \
 503                        "\t%s(\"%s\",%d,%d): " fmt " != " fmt "\n" \
 504                        "]\n", \
 505                        __STRING(func), __location__, __STRING(func), \
 506                        str, diff, base, res, _v); \
 507                 return false; \
 508         } else if (_p != _ep) { \
 509                 printf("failure: %s [\n" \
 510                        "\t%s\n" \
 511                        "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
 512                        "\tptr: %p - %p = %d != %d\n" \
 513                        "]\n", \
 514                        __STRING(func), __location__, __STRING(func), \
 515                        str, diff, base, res, _v, _ep, _p, (int)(diff - (_ep - _p)), diff); \
 516                 return false; \
 517         } \
 518 } while (0)
 519
 520 static int test_strtoll(void)
 521 {
 522         printf("test: strtoll\n");
 523
 524 #define TEST_STRTOLL(str,base,res,diff,errnoo) TEST_STRTO_X(long long int, "%lld", strtoll,str,base,res,diff,errnoo)
 525
 526         TEST_STRTOLL("15",      10,     15LL,   2, 0);
 527         TEST_STRTOLL("  15",    10,     15LL,   4, 0);
 528         TEST_STRTOLL("15",      0,      15LL,   2, 0);
 529         TEST_STRTOLL(" 15 ",    0,      15LL,   3, 0);
 530         TEST_STRTOLL("+15",     10,     15LL,   3, 0);
 531         TEST_STRTOLL("  +15",   10,     15LL,   5, 0);
 532         TEST_STRTOLL("+15",     0,      15LL,   3, 0);
 533         TEST_STRTOLL(" +15 ",   0,      15LL,   4, 0);
 534         TEST_STRTOLL("-15",     10,     -15LL,  3, 0);
 535         TEST_STRTOLL("  -15",   10,     -15LL,  5, 0);
 536         TEST_STRTOLL("-15",     0,      -15LL,  3, 0);
 537         TEST_STRTOLL(" -15 ",   0,      -15LL,  4, 0);
 538         TEST_STRTOLL("015",     10,     15LL,   3, 0);
 539         TEST_STRTOLL("  015",   10,     15LL,   5, 0);
 540         TEST_STRTOLL("015",     0,      13LL,   3, 0);
 541         TEST_STRTOLL("  015",   0,      13LL,   5, 0);
 542         TEST_STRTOLL("0x15",    10,     0LL,    1, 0);
 543         TEST_STRTOLL("  0x15",  10,     0LL,    3, 0);
 544         TEST_STRTOLL("0x15",    0,      21LL,   4, 0);
 545         TEST_STRTOLL("  0x15",  0,      21LL,   6, 0);
 546
 547         TEST_STRTOLL("10",      16,     16LL,   2, 0);
 548         TEST_STRTOLL("  10 ",   16,     16LL,   4, 0);
 549         TEST_STRTOLL("0x10",    16,     16LL,   4, 0);
 550         TEST_STRTOLL("0x10",    0,      16LL,   4, 0);
 551         TEST_STRTOLL(" 0x10 ",  0,      16LL,   5, 0);
 552         TEST_STRTOLL("+10",     16,     16LL,   3, 0);
 553         TEST_STRTOLL("  +10 ",  16,     16LL,   5, 0);
 554         TEST_STRTOLL("+0x10",   16,     16LL,   5, 0);
 555         TEST_STRTOLL("+0x10",   0,      16LL,   5, 0);
 556         TEST_STRTOLL(" +0x10 ", 0,      16LL,   6, 0);
 557         TEST_STRTOLL("-10",     16,     -16LL,  3, 0);
 558         TEST_STRTOLL("  -10 ",  16,     -16LL,  5, 0);
 559         TEST_STRTOLL("-0x10",   16,     -16LL,  5, 0);
 560         TEST_STRTOLL("-0x10",   0,      -16LL,  5, 0);
 561         TEST_STRTOLL(" -0x10 ", 0,      -16LL,  6, 0);
 562         TEST_STRTOLL("010",     16,     16LL,   3, 0);
 563         TEST_STRTOLL("  010 ",  16,     16LL,   5, 0);
 564         TEST_STRTOLL("-010",    16,     -16LL,  4, 0);
 565
 566         TEST_STRTOLL("11",      8,      9LL,    2, 0);
 567         TEST_STRTOLL("011",     8,      9LL,    3, 0);
 568         TEST_STRTOLL("011",     0,      9LL,    3, 0);
 569         TEST_STRTOLL("-11",     8,      -9LL,   3, 0);
 570         TEST_STRTOLL("-011",    8,      -9LL,   4, 0);
 571         TEST_STRTOLL("-011",    0,      -9LL,   4, 0);
 572
 573         TEST_STRTOLL("011",     8,      9LL,    3, 0);
 574         TEST_STRTOLL("011",     0,      9LL,    3, 0);
 575         TEST_STRTOLL("-11",     8,      -9LL,   3, 0);
 576         TEST_STRTOLL("-011",    8,      -9LL,   4, 0);
 577         TEST_STRTOLL("-011",    0,      -9LL,   4, 0);
 578
 579         TEST_STRTOLL("Text",    0,      0LL,    0, 0);
 580
 581         TEST_STRTOLL("9223372036854775807",     10,     9223372036854775807LL,  19, 0);
 582         TEST_STRTOLL("9223372036854775807",     0,      9223372036854775807LL,  19, 0);
 583         TEST_STRTOLL("9223372036854775808",     0,      9223372036854775807LL,  19, ERANGE);
 584         TEST_STRTOLL("9223372036854775808",     10,     9223372036854775807LL,  19, ERANGE);
 585         TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",      0,      9223372036854775807LL,  18, 0);
 586         TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",      16,     9223372036854775807LL,  18, 0);
 587         TEST_STRTOLL("7FFFFFFFFFFFFFFF",        16,     9223372036854775807LL,  16, 0);
 588         TEST_STRTOLL("0x8000000000000000",      0,      9223372036854775807LL,  18, ERANGE);
 589         TEST_STRTOLL("0x8000000000000000",      16,     9223372036854775807LL,  18, ERANGE);
 590         TEST_STRTOLL("80000000000000000",       16,     9223372036854775807LL,  17, ERANGE);
 591         TEST_STRTOLL("0777777777777777777777",  0,      9223372036854775807LL,  22, 0);
 592         TEST_STRTOLL("0777777777777777777777",  8,      9223372036854775807LL,  22, 0);
 593         TEST_STRTOLL("777777777777777777777",   8,      9223372036854775807LL,  21, 0);
 594         TEST_STRTOLL("01000000000000000000000", 0,      9223372036854775807LL,  23, ERANGE);
 595         TEST_STRTOLL("01000000000000000000000", 8,      9223372036854775807LL,  23, ERANGE);
 596         TEST_STRTOLL("1000000000000000000000",  8,      9223372036854775807LL,  22, ERANGE);
 597
 598         TEST_STRTOLL("-9223372036854775808",    10,     -9223372036854775807LL -1,      20, 0);
 599         TEST_STRTOLL("-9223372036854775808",    0,      -9223372036854775807LL -1,      20, 0);
 600         TEST_STRTOLL("-9223372036854775809",    0,      -9223372036854775807LL -1,      20, ERANGE);
 601         TEST_STRTOLL("-9223372036854775809",    10,     -9223372036854775807LL -1,      20, ERANGE);
 602         TEST_STRTOLL("-0x8000000000000000",     0,      -9223372036854775807LL -1,      19, 0);
 603         TEST_STRTOLL("-0x8000000000000000",     16,     -9223372036854775807LL -1,      19, 0);
 604         TEST_STRTOLL("-8000000000000000",       16,     -9223372036854775807LL -1,      17, 0);
 605         TEST_STRTOLL("-0x8000000000000001",     0,      -9223372036854775807LL -1,      19, ERANGE);
 606         TEST_STRTOLL("-0x8000000000000001",     16,     -9223372036854775807LL -1,      19, ERANGE);
 607         TEST_STRTOLL("-80000000000000001",      16,     -9223372036854775807LL -1,      18, ERANGE);
 608         TEST_STRTOLL("-01000000000000000000000",0,      -9223372036854775807LL -1,      24, 0);
 609         TEST_STRTOLL("-01000000000000000000000",8,      -9223372036854775807LL -1,      24, 0);
 610         TEST_STRTOLL("-1000000000000000000000", 8,      -9223372036854775807LL -1,      23, 0);
 611         TEST_STRTOLL("-01000000000000000000001",0,      -9223372036854775807LL -1,      24, ERANGE);
 612         TEST_STRTOLL("-01000000000000000000001",8,      -9223372036854775807LL -1,      24, ERANGE);
 613         TEST_STRTOLL("-1000000000000000000001", 8,      -9223372036854775807LL -1,      23, ERANGE);
 614
 615         printf("success: strtoll\n");
 616         return true;
 617 }
 618
 619 static int test_strtoull(void)
 620 {
 621         printf("test: strtoull\n");
 622
 623 #define TEST_STRTOULL(str,base,res,diff,errnoo) TEST_STRTO_X(long long unsigned int,"%llu",strtoull,str,base,res,diff,errnoo)
 624
 625         TEST_STRTOULL("15",     10,     15LLU,  2, 0);
 626         TEST_STRTOULL("  15",   10,     15LLU,  4, 0);
 627         TEST_STRTOULL("15",     0,      15LLU,  2, 0);
 628         TEST_STRTOULL(" 15 ",   0,      15LLU,  3, 0);
 629         TEST_STRTOULL("+15",    10,     15LLU,  3, 0);
 630         TEST_STRTOULL("  +15",  10,     15LLU,  5, 0);
 631         TEST_STRTOULL("+15",    0,      15LLU,  3, 0);
 632         TEST_STRTOULL(" +15 ",  0,      15LLU,  4, 0);
 633         TEST_STRTOULL("-15",    10,     18446744073709551601LLU,        3, 0);
 634         TEST_STRTOULL("  -15",  10,     18446744073709551601LLU,        5, 0);
 635         TEST_STRTOULL("-15",    0,      18446744073709551601LLU,        3, 0);
 636         TEST_STRTOULL(" -15 ",  0,      18446744073709551601LLU,        4, 0);
 637         TEST_STRTOULL("015",    10,     15LLU,  3, 0);
 638         TEST_STRTOULL("  015",  10,     15LLU,  5, 0);
 639         TEST_STRTOULL("015",    0,      13LLU,  3, 0);
 640         TEST_STRTOULL("  015",  0,      13LLU,  5, 0);
 641         TEST_STRTOULL("0x15",   10,     0LLU,   1, 0);
 642         TEST_STRTOULL("  0x15", 10,     0LLU,   3, 0);
 643         TEST_STRTOULL("0x15",   0,      21LLU,  4, 0);
 644         TEST_STRTOULL("  0x15", 0,      21LLU,  6, 0);
 645
 646         TEST_STRTOULL("10",     16,     16LLU,  2, 0);
 647         TEST_STRTOULL("  10 ",  16,     16LLU,  4, 0);
 648         TEST_STRTOULL("0x10",   16,     16LLU,  4, 0);
 649         TEST_STRTOULL("0x10",   0,      16LLU,  4, 0);
 650         TEST_STRTOULL(" 0x10 ", 0,      16LLU,  5, 0);
 651         TEST_STRTOULL("+10",    16,     16LLU,  3, 0);
 652         TEST_STRTOULL("  +10 ", 16,     16LLU,  5, 0);
 653         TEST_STRTOULL("+0x10",  16,     16LLU,  5, 0);
 654         TEST_STRTOULL("+0x10",  0,      16LLU,  5, 0);
 655         TEST_STRTOULL(" +0x10 ",        0,      16LLU,  6, 0);
 656         TEST_STRTOULL("-10",    16,     -16LLU, 3, 0);
 657         TEST_STRTOULL("  -10 ", 16,     -16LLU, 5, 0);
 658         TEST_STRTOULL("-0x10",  16,     -16LLU, 5, 0);
 659         TEST_STRTOULL("-0x10",  0,      -16LLU, 5, 0);
 660         TEST_STRTOULL(" -0x10 ",        0,      -16LLU, 6, 0);
 661         TEST_STRTOULL("010",    16,     16LLU,  3, 0);
 662         TEST_STRTOULL("  010 ", 16,     16LLU,  5, 0);
 663         TEST_STRTOULL("-010",   16,     -16LLU, 4, 0);
 664
 665         TEST_STRTOULL("11",     8,      9LLU,   2, 0);
 666         TEST_STRTOULL("011",    8,      9LLU,   3, 0);
 667         TEST_STRTOULL("011",    0,      9LLU,   3, 0);
 668         TEST_STRTOULL("-11",    8,      -9LLU,  3, 0);
 669         TEST_STRTOULL("-011",   8,      -9LLU,  4, 0);
 670         TEST_STRTOULL("-011",   0,      -9LLU,  4, 0);
 671
 672         TEST_STRTOULL("011",    8,      9LLU,   3, 0);
 673         TEST_STRTOULL("011",    0,      9LLU,   3, 0);
 674         TEST_STRTOULL("-11",    8,      -9LLU,  3, 0);
 675         TEST_STRTOULL("-011",   8,      -9LLU,  4, 0);
 676         TEST_STRTOULL("-011",   0,      -9LLU,  4, 0);
 677
 678         TEST_STRTOULL("Text",   0,      0LLU,   0, 0);
 679
 680         TEST_STRTOULL("9223372036854775807",    10,     9223372036854775807LLU, 19, 0);
 681         TEST_STRTOULL("9223372036854775807",    0,      9223372036854775807LLU, 19, 0);
 682         TEST_STRTOULL("9223372036854775808",    0,      9223372036854775808LLU, 19, 0);
 683         TEST_STRTOULL("9223372036854775808",    10,     9223372036854775808LLU, 19, 0);
 684         TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",     0,      9223372036854775807LLU, 18, 0);
 685         TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",     16,     9223372036854775807LLU, 18, 0);
 686         TEST_STRTOULL("7FFFFFFFFFFFFFFF",       16,     9223372036854775807LLU, 16, 0);
 687         TEST_STRTOULL("0x8000000000000000",     0,      9223372036854775808LLU, 18, 0);
 688         TEST_STRTOULL("0x8000000000000000",     16,     9223372036854775808LLU, 18, 0);
 689         TEST_STRTOULL("8000000000000000",       16,     9223372036854775808LLU, 16, 0);
 690         TEST_STRTOULL("0777777777777777777777", 0,      9223372036854775807LLU, 22, 0);
 691         TEST_STRTOULL("0777777777777777777777", 8,      9223372036854775807LLU, 22, 0);
 692         TEST_STRTOULL("777777777777777777777",  8,      9223372036854775807LLU, 21, 0);
 693         TEST_STRTOULL("01000000000000000000000",0,      9223372036854775808LLU, 23, 0);
 694         TEST_STRTOULL("01000000000000000000000",8,      9223372036854775808LLU, 23, 0);
 695         TEST_STRTOULL("1000000000000000000000", 8,      9223372036854775808LLU, 22, 0);
 696
 697         TEST_STRTOULL("-9223372036854775808",   10,     9223372036854775808LLU, 20, 0);
 698         TEST_STRTOULL("-9223372036854775808",   0,      9223372036854775808LLU, 20, 0);
 699         TEST_STRTOULL("-9223372036854775809",   0,      9223372036854775807LLU, 20, 0);
 700         TEST_STRTOULL("-9223372036854775809",   10,     9223372036854775807LLU, 20, 0);
 701         TEST_STRTOULL("-0x8000000000000000",    0,      9223372036854775808LLU, 19, 0);
 702         TEST_STRTOULL("-0x8000000000000000",    16,     9223372036854775808LLU, 19, 0);
 703         TEST_STRTOULL("-8000000000000000",      16,     9223372036854775808LLU, 17, 0);
 704         TEST_STRTOULL("-0x8000000000000001",    0,      9223372036854775807LLU, 19, 0);
 705         TEST_STRTOULL("-0x8000000000000001",    16,     9223372036854775807LLU, 19, 0);
 706         TEST_STRTOULL("-8000000000000001",      16,     9223372036854775807LLU, 17, 0);
 707         TEST_STRTOULL("-01000000000000000000000",0,     9223372036854775808LLU, 24, 0);
 708         TEST_STRTOULL("-01000000000000000000000",8,     9223372036854775808LLU, 24, 0);
 709         TEST_STRTOULL("-1000000000000000000000",8,      9223372036854775808LLU, 23, 0);
 710         TEST_STRTOULL("-01000000000000000000001",0,     9223372036854775807LLU, 24, 0);
 711         TEST_STRTOULL("-01000000000000000000001",8,     9223372036854775807LLU, 24, 0);
 712         TEST_STRTOULL("-1000000000000000000001",8,      9223372036854775807LLU, 23, 0);
 713
 714         TEST_STRTOULL("18446744073709551615",   0,      18446744073709551615LLU,        20, 0);
 715         TEST_STRTOULL("18446744073709551615",   10,     18446744073709551615LLU,        20, 0);
 716         TEST_STRTOULL("18446744073709551616",   0,      18446744073709551615LLU,        20, ERANGE);
 717         TEST_STRTOULL("18446744073709551616",   10,     18446744073709551615LLU,        20, ERANGE);
 718         TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",     0,      18446744073709551615LLU,        18, 0);
 719         TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",     16,     18446744073709551615LLU,        18, 0);
 720         TEST_STRTOULL("FFFFFFFFFFFFFFFF",       16,     18446744073709551615LLU,        16, 0);
 721         TEST_STRTOULL("0x10000000000000000",    0,      18446744073709551615LLU,        19, ERANGE);
 722         TEST_STRTOULL("0x10000000000000000",    16,     18446744073709551615LLU,        19, ERANGE);
 723         TEST_STRTOULL("10000000000000000",      16,     18446744073709551615LLU,        17, ERANGE);
 724         TEST_STRTOULL("01777777777777777777777",0,      18446744073709551615LLU,        23, 0);
 725         TEST_STRTOULL("01777777777777777777777",8,      18446744073709551615LLU,        23, 0);
 726         TEST_STRTOULL("1777777777777777777777", 8,      18446744073709551615LLU,        22, 0);
 727         TEST_STRTOULL("02000000000000000000000",0,      18446744073709551615LLU,        23, ERANGE);
 728         TEST_STRTOULL("02000000000000000000000",8,      18446744073709551615LLU,        23, ERANGE);
 729         TEST_STRTOULL("2000000000000000000000", 8,      18446744073709551615LLU,        22, ERANGE);
 730
 731         TEST_STRTOULL("-18446744073709551615",  0,      1LLU,                           21, 0);
 732         TEST_STRTOULL("-18446744073709551615",  10,     1LLU,                           21, 0);
 733         TEST_STRTOULL("-18446744073709551616",  0,      18446744073709551615LLU,        21, ERANGE);
 734         TEST_STRTOULL("-18446744073709551616",  10,     18446744073709551615LLU,        21, ERANGE);
 735         TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",    0,      1LLU,                           19, 0);
 736         TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",    16,     1LLU,                           19, 0);
 737         TEST_STRTOULL("-FFFFFFFFFFFFFFFF",      16,     1LLU,                           17, 0);
 738         TEST_STRTOULL("-0x10000000000000000",   0,      18446744073709551615LLU,        20, ERANGE);
 739         TEST_STRTOULL("-0x10000000000000000",   16,     18446744073709551615LLU,        20, ERANGE);
 740         TEST_STRTOULL("-10000000000000000",     16,     18446744073709551615LLU,        18, ERANGE);
 741         TEST_STRTOULL("-01777777777777777777777",0,     1LLU,                           24, 0);
 742         TEST_STRTOULL("-01777777777777777777777",8,     1LLU,                           24, 0);
 743         TEST_STRTOULL("-1777777777777777777777",8,      1LLU,                           23, 0);
 744         TEST_STRTOULL("-02000000000000000000000",0,     18446744073709551615LLU,        24, ERANGE);
 745         TEST_STRTOULL("-02000000000000000000000",8,     18446744073709551615LLU,        24, ERANGE);
 746         TEST_STRTOULL("-2000000000000000000000",8,      18446744073709551615LLU,        23, ERANGE);
 747
 748         printf("success: strtoull\n");
 749         return true;
 750 }
 751
 752 /*
 753 FIXME:
 754 Types:
 755 bool
 756 socklen_t
 757 uint{8,16,32,64}_t
 758 int{8,16,32,64}_t
 759 intptr_t
 760
 761 Constants:
 762 PATH_NAME_MAX
 763 UINT{16,32,64}_MAX
 764 INT32_MAX
 765 */
 766
 767 static int test_va_copy(void)
 768 {
 769         /* FIXME */
 770         return true;
 771 }
 772
 773 static int test_FUNCTION(void)
 774 {
 775         printf("test: FUNCTION\n");
 776         if (strcmp(__FUNCTION__, "test_FUNCTION") != 0) {
 777                 printf("failure: FUNCTION [\nFUNCTION invalid\n]\n");
 778                 return false;
 779         }
 780         printf("success: FUNCTION\n");
 781         return true;
 782 }
 783
 784 static int test_MIN(void)
 785 {
 786         printf("test: MIN\n");
 787         if (MIN(20, 1) != 1) {
 788                 printf("failure: MIN [\nMIN invalid\n]\n");
 789                 return false;
 790         }
 791         if (MIN(1, 20) != 1) {
 792                 printf("failure: MIN [\nMIN invalid\n]\n");
 793                 return false;
 794         }
 795         printf("success: MIN\n");
 796         return true;
 797 }
 798
 799 static int test_MAX(void)
 800 {
 801         printf("test: MAX\n");
 802         if (MAX(20, 1) != 20) {
 803                 printf("failure: MAX [\nMAX invalid\n]\n");
 804                 return false;
 805         }
 806         if (MAX(1, 20) != 20) {
 807                 printf("failure: MAX [\nMAX invalid\n]\n");
 808                 return false;
 809         }
 810         printf("success: MAX\n");
 811         return true;
 812 }
 813
 814 static int test_socketpair(void)
 815 {
 816         int sock[2];
 817         char buf[20];
 818
 819         printf("test: socketpair\n");
 820
 821         if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock) == -1) {
 822                 printf("failure: socketpair [\n"
 823                            "socketpair() failed\n"
 824                            "]\n");
 825                 return false;
 826         }
 827
 828         if (write(sock[1], "automatisch", 12) == -1) {
 829                 printf("failure: socketpair [\n"
 830                            "write() failed: %s\n"
 831                            "]\n", strerror(errno));
 832                 return false;
 833         }
 834
 835         if (read(sock[0], buf, 12) == -1) {
 836                 printf("failure: socketpair [\n"
 837                            "read() failed: %s\n"
 838                            "]\n", strerror(errno));
 839                 return false;
 840         }
 841
 842         if (strcmp(buf, "automatisch") != 0) {
 843                 printf("failure: socketpair [\n"
 844                            "expected: automatisch, got: %s\n"
 845                            "]\n", buf);
 846                 return false;
 847         }
 848
 849         printf("success: socketpair\n");
 850
 851         return true;
 852 }
 853
 854 extern int libreplace_test_strptime(void);
 855
 856 static int test_strptime(void)
 857 {
 858         return libreplace_test_strptime();
 859 }
 860
 861 extern int getifaddrs_test(void);
 862
 863 static int test_getifaddrs(void)
 864 {
 865
 866         printf("test: getifaddrs\n");
 867
 868         if (getifaddrs_test() != 0) {
 869                 printf("failure: getifaddrs\n");
 870                 return false;
 871         }
 872
 873         printf("success: getifaddrs\n");
 874         return true;
 875 }
 876
 877 static int test_utime(void)
 878 {
 879         struct utimbuf u;
 880         struct stat st1, st2, st3;
 881         int fd;
 882
 883         printf("test: utime\n");
 884         unlink(TESTFILE);
 885
 886         fd = open(TESTFILE, O_RDWR|O_CREAT, 0600);
 887         if (fd == -1) {
 888                 printf("failure: utime [\n"
 889                        "creating '%s' failed - %s\n]\n",
 890                        TESTFILE, strerror(errno));
 891                 return false;
 892         }
 893
 894         if (fstat(fd, &st1) != 0) {
 895                 printf("failure: utime [\n"
 896                        "fstat (1) failed - %s\n]\n",
 897                        strerror(errno));
 898                 return false;
 899         }
 900
 901         u.actime = st1.st_atime + 300;
 902         u.modtime = st1.st_mtime - 300;
 903         if (utime(TESTFILE, &u) != 0) {
 904                 printf("failure: utime [\n"
 905                        "utime(&u) failed - %s\n]\n",
 906                        strerror(errno));
 907                 return false;
 908         }
 909
 910         if (fstat(fd, &st2) != 0) {
 911                 printf("failure: utime [\n"
 912                        "fstat (2) failed - %s\n]\n",
 913                        strerror(errno));
 914                 return false;
 915         }
 916
 917         if (utime(TESTFILE, NULL) != 0) {
 918                 printf("failure: utime [\n"
 919                        "utime(NULL) failed - %s\n]\n",
 920                        strerror(errno));
 921                 return false;
 922         }
 923
 924         if (fstat(fd, &st3) != 0) {
 925                 printf("failure: utime [\n"
 926                        "fstat (3) failed - %s\n]\n",
 927                        strerror(errno));
 928                 return false;
 929         }
 930
 931 #define CMP_VAL(a,c,b) do { \
 932         if (a c b) { \
 933                 printf("failure: utime [\n" \
 934                        "%s: %s(%d) %s %s(%d)\n]\n", \
 935                        __location__, \
 936                        #a, (int)a, #c, #b, (int)b); \
 937                 return false; \
 938         } \
 939 } while(0)
 940 #define EQUAL_VAL(a,b) CMP_VAL(a,!=,b)
 941 #define GREATER_VAL(a,b) CMP_VAL(a,<=,b)
 942 #define LESSER_VAL(a,b) CMP_VAL(a,>=,b)
 943
 944         EQUAL_VAL(st2.st_atime, st1.st_atime + 300);
 945         EQUAL_VAL(st2.st_mtime, st1.st_mtime - 300);
 946         LESSER_VAL(st3.st_atime, st2.st_atime);
 947         GREATER_VAL(st3.st_mtime, st2.st_mtime);
 948
 949 #undef CMP_VAL
 950 #undef EQUAL_VAL
 951 #undef GREATER_VAL
 952 #undef LESSER_VAL
 953
 954         unlink(TESTFILE);
 955         printf("success: utime\n");
 956         return true;
 957 }
 958
 959 static int test_utimes(void)
 960 {
 961         struct timeval tv[2];
 962         struct stat st1, st2;
 963         int fd;
 964
 965         printf("test: utimes\n");
 966         unlink(TESTFILE);
 967
 968         fd = open(TESTFILE, O_RDWR|O_CREAT, 0600);
 969         if (fd == -1) {
 970                 printf("failure: utimes [\n"
 971                        "creating '%s' failed - %s\n]\n",
 972                        TESTFILE, strerror(errno));
 973                 return false;
 974         }
 975
 976         if (fstat(fd, &st1) != 0) {
 977                 printf("failure: utimes [\n"
 978                        "fstat (1) failed - %s\n]\n",
 979                        strerror(errno));
 980                 return false;
 981         }
 982
 983         ZERO_STRUCT(tv);
 984         tv[0].tv_sec = st1.st_atime + 300;
 985         tv[1].tv_sec = st1.st_mtime - 300;
 986         if (utimes(TESTFILE, tv) != 0) {
 987                 printf("failure: utimes [\n"
 988                        "utimes(tv) failed - %s\n]\n",
 989                        strerror(errno));
 990                 return false;
 991         }
 992
 993         if (fstat(fd, &st2) != 0) {
 994                 printf("failure: utimes [\n"
 995                        "fstat (2) failed - %s\n]\n",
 996                        strerror(errno));
 997                 return false;
 998         }
 999
1000 #define EQUAL_VAL(a,b) do { \
1001         if (a != b) { \
1002                 printf("failure: utimes [\n" \
1003                        "%s: %s(%d) != %s(%d)\n]\n", \
1004                        __location__, \
1005                        #a, (int)a, #b, (int)b); \
1006                 return false; \
1007         } \
1008 } while(0)
1009
1010         EQUAL_VAL(st2.st_atime, st1.st_atime + 300);
1011         EQUAL_VAL(st2.st_mtime, st1.st_mtime - 300);
1012
1013 #undef EQUAL_VAL
1014
1015         unlink(TESTFILE);
1016         printf("success: utimes\n");
1017         return true;
1018 }
1019
1020 static int test_memmem(void)
1021 {
1022         char *s;
1023
1024         printf("test: memmem\n");
1025
1026         s = (char *)memmem("foo", 3, "fo", 2);
1027         if (strcmp(s, "foo") != 0) {
1028                 printf(__location__ ": Failed memmem\n");
1029                 return false;
1030         }
1031
1032         s = (char *)memmem("foo", 3, "", 0);
1033         /* it is allowable for this to return NULL (as happens on
1034            FreeBSD) */
1035         if (s && strcmp(s, "foo") != 0) {
1036                 printf(__location__ ": Failed memmem\n");
1037                 return false;
1038         }
1039
1040         s = (char *)memmem("foo", 4, "o", 1);
1041         if (strcmp(s, "oo") != 0) {
1042                 printf(__location__ ": Failed memmem\n");
1043                 return false;
1044         }
1045
1046         s = (char *)memmem("foobarfodx", 11, "fod", 3);
1047         if (strcmp(s, "fodx") != 0) {
1048                 printf(__location__ ": Failed memmem\n");
1049                 return false;
1050         }
1051
1052         printf("success: memmem\n");
1053
1054         return true;
1055 }
1056
1057
1058 bool torture_local_replace(struct torture_context *ctx)
1059 {
1060         bool ret = true;
1061         ret &= test_ftruncate();
1062         ret &= test_strlcpy();
1063         ret &= test_strlcat();
1064         ret &= test_mktime();
1065         ret &= test_initgroups();
1066         ret &= test_memmove();
1067         ret &= test_strdup();
1068         ret &= test_setlinebuf();
1069         ret &= test_vsyslog();
1070         ret &= test_timegm();
1071         ret &= test_setenv();
1072         ret &= test_strndup();
1073         ret &= test_strnlen();
1074         ret &= test_waitpid();
1075         ret &= test_seteuid();
1076         ret &= test_setegid();
1077         ret &= test_asprintf();
1078         ret &= test_snprintf();
1079         ret &= test_vasprintf();
1080         ret &= test_vsnprintf();
1081         ret &= test_opendir();
1082         ret &= test_readdir();
1083         ret &= test_telldir();
1084         ret &= test_seekdir();
1085         ret &= test_dlopen();
1086         ret &= test_chroot();
1087         ret &= test_bzero();
1088         ret &= test_strerror();
1089         ret &= test_errno();
1090         ret &= test_mkdtemp();
1091         ret &= test_mkstemp();
1092         ret &= test_pread();
1093         ret &= test_pwrite();
1094         ret &= test_getpass();
1095         ret &= test_inet_ntoa();
1096         ret &= test_strtoll();
1097         ret &= test_strtoull();
1098         ret &= test_va_copy();
1099         ret &= test_FUNCTION();
1100         ret &= test_MIN();
1101         ret &= test_MAX();
1102         ret &= test_socketpair();
1103         ret &= test_strptime();
1104         ret &= test_getifaddrs();
1105         ret &= test_utime();
1106         ret &= test_utimes();
1107         ret &= test_memmem();
1108
1109         return ret;
1110 }