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