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/* 52 test ftruncate() function 53 */ 54static int test_ftruncate(void) 55{ 56 struct stat st; 57 int fd; 58 const int size = 1234; 59 printf("test: ftruncate\n"); 60 unlink(TESTFILE); 61 fd = open(TESTFILE, O_RDWR|O_CREAT, 0600); 62 if (fd == -1) { 63 printf("failure: ftruncate [\n" 64 "creating '%s' failed - %s\n]\n", TESTFILE, strerror(errno)); 65 return false; 66 } 67 if (ftruncate(fd, size) != 0) { 68 printf("failure: ftruncate [\n%s\n]\n", strerror(errno)); 69 return false; 70 } 71 if (fstat(fd, &st) != 0) { 72 printf("failure: ftruncate [\nfstat failed - %s\n]\n", strerror(errno)); 73 return false; 74 } 75 if (st.st_size != size) { 76 printf("failure: ftruncate [\ngave wrong size %d - expected %d\n]\n", 77 (int)st.st_size, size); 78 return false; 79 } 80 unlink(TESTFILE); 81 printf("success: ftruncate\n"); 82 return true; 83} 84 85/* 86 test strlcpy() function. 87 see http://www.gratisoft.us/todd/papers/strlcpy.html 88 */ 89static int test_strlcpy(void) 90{ 91 char buf[4]; 92 const struct { 93 const char *src; 94 size_t result; 95 } tests[] = { 96 { "abc", 3 }, 97 { "abcdef", 6 }, 98 { "abcd", 4 }, 99 { "", 0 }, 100 { NULL, 0 } 101 }; 102 int i; 103 printf("test: strlcpy\n"); 104 for (i=0;tests[i].src;i++) { 105 if (strlcpy(buf, tests[i].src, sizeof(buf)) != tests[i].result) { 106 printf("failure: strlcpy [\ntest %d failed\n]\n", i); 107 return false; 108 } 109 } 110 printf("success: strlcpy\n"); 111 return true; 112} 113 114static int test_strlcat(void) 115{ 116 char tmp[10]; 117 printf("test: strlcat\n"); 118 strlcpy(tmp, "", sizeof(tmp)); 119 if (strlcat(tmp, "bla", 3) != 3) { 120 printf("failure: strlcat [\ninvalid return code\n]\n"); 121 return false; 122 } 123 if (strcmp(tmp, "bl") != 0) { 124 printf("failure: strlcat [\nexpected \"bl\", got \"%s\"\n]\n", 125 tmp); 126 return false; 127 } 128 129 strlcpy(tmp, "da", sizeof(tmp)); 130 if (strlcat(tmp, "me", 4) != 4) { 131 printf("failure: strlcat [\nexpected \"dam\", got \"%s\"\n]\n", 132 tmp); 133 return false; 134 } 135 136 printf("success: strlcat\n"); 137 return true; 138} 139 140static int test_mktime(void) 141{ 142 /* FIXME */ 143 return true; 144} 145 146static int test_initgroups(void) 147{ 148 /* FIXME */ 149 return true; 150} 151 152static int test_memmove(void) 153{ 154 /* FIXME */ 155 return true; 156} 157 158static int test_strdup(void) 159{ 160 char *x; 161 printf("test: strdup\n"); 162 x = strdup("bla"); 163 if (strcmp("bla", x) != 0) { 164 printf("failure: strdup [\nfailed: expected \"bla\", got \"%s\"\n]\n", 165 x); 166 return false; 167 } 168 free(x); 169 printf("success: strdup\n"); 170 return true; 171} 172 173static int test_setlinebuf(void) 174{ 175 printf("test: setlinebuf\n"); 176 setlinebuf(stdout); 177 printf("success: setlinebuf\n"); 178 return true; 179} 180 181static int test_vsyslog(void) 182{ 183 /* FIXME */ 184 return true; 185} 186 187static int test_timegm(void) 188{ 189 /* FIXME */ 190 return true; 191} 192 193static int test_setenv(void) 194{ 195#define TEST_SETENV(key, value, overwrite, result) do { \ 196 int _ret; \ 197 char *_v; \ 198 _ret = setenv(key, value, overwrite); \ 199 if (_ret != 0) { \ 200 printf("failure: setenv [\n" \ 201 "setenv(%s, %s, %d) failed\n" \ 202 "]\n", \ 203 key, value, overwrite); \ 204 return false; \ 205 } \ 206 _v=getenv(key); \ 207 if (!_v) { \ 208 printf("failure: setenv [\n" \ 209 "getenv(%s) returned NULL\n" \ 210 "]\n", \ 211 key); \ 212 return false; \ 213 } \ 214 if (strcmp(result, _v) != 0) { \ 215 printf("failure: setenv [\n" \ 216 "getenv(%s): '%s' != '%s'\n" \ 217 "]\n", \ 218 key, result, _v); \ 219 return false; \ 220 } \ 221} while(0) 222 223#define TEST_UNSETENV(key) do { \ 224 char *_v; \ 225 unsetenv(key); \ 226 _v=getenv(key); \ 227 if (_v) { \ 228 printf("failure: setenv [\n" \ 229 "getenv(%s): NULL != '%s'\n" \ 230 "]\n", \ 231 SETENVTEST_KEY, _v); \ 232 return false; \ 233 } \ 234} while (0) 235 236#define SETENVTEST_KEY "SETENVTESTKEY" 237#define SETENVTEST_VAL "SETENVTESTVAL" 238 239 printf("test: setenv\n"); 240 TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"1", 0, SETENVTEST_VAL"1"); 241 TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"2", 0, SETENVTEST_VAL"1"); 242 TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"3", 1, SETENVTEST_VAL"3"); 243 TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"4", 1, SETENVTEST_VAL"4"); 244 TEST_UNSETENV(SETENVTEST_KEY); 245 TEST_UNSETENV(SETENVTEST_KEY); 246 TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"5", 0, SETENVTEST_VAL"5"); 247 TEST_UNSETENV(SETENVTEST_KEY); 248 TEST_UNSETENV(SETENVTEST_KEY); 249 printf("success: setenv\n"); 250 return true; 251} 252 253static int test_strndup(void) 254{ 255 char *x; 256 printf("test: strndup\n"); 257 x = strndup("bla", 0); 258 if (strcmp(x, "") != 0) { 259 printf("failure: strndup [\ninvalid\n]\n"); 260 return false; 261 } 262 free(x); 263 x = strndup("bla", 2); 264 if (strcmp(x, "bl") != 0) { 265 printf("failure: strndup [\ninvalid\n]\n"); 266 return false; 267 } 268 free(x); 269 x = strndup("bla", 10); 270 if (strcmp(x, "bla") != 0) { 271 printf("failure: strndup [\ninvalid\n]\n"); 272 return false; 273 } 274 free(x); 275 printf("success: strndup\n"); 276 return true; 277} 278 279static int test_strnlen(void) 280{ 281 printf("test: strnlen\n"); 282 if (strnlen("bla", 2) != 2) { 283 printf("failure: strnlen [\nunexpected length\n]\n"); 284 return false; 285 } 286 287 if (strnlen("some text\n", 0) != 0) { 288 printf("failure: strnlen [\nunexpected length\n]\n"); 289 return false; 290 } 291 292 if (strnlen("some text", 20) != 9) { 293 printf("failure: strnlen [\nunexpected length\n]\n"); 294 return false; 295 } 296 297 printf("success: strnlen\n"); 298 return true; 299} 300 301static int test_waitpid(void) 302{ 303 /* FIXME */ 304 return true; 305} 306 307static int test_seteuid(void) 308{ 309 /* FIXME */ 310 return true; 311} 312 313static int test_setegid(void) 314{ 315 /* FIXME */ 316 return true; 317} 318 319static int test_asprintf(void) 320{ 321 char *x; 322 printf("test: asprintf\n"); 323 if (asprintf(&x, "%d", 9) != 1) { 324 printf("failure: asprintf [\ngenerate asprintf\n]\n"); 325 return false; 326 } 327 if (strcmp(x, "9") != 0) { 328 printf("failure: asprintf [\ngenerate asprintf\n]\n"); 329 return false; 330 } 331 if (asprintf(&x, "dat%s", "a") != 4) { 332 printf("failure: asprintf [\ngenerate asprintf\n]\n"); 333 return false; 334 } 335 if (strcmp(x, "data") != 0) { 336 printf("failure: asprintf [\ngenerate asprintf\n]\n"); 337 return false; 338 } 339 printf("success: asprintf\n"); 340 return true; 341} 342 343static int test_snprintf(void) 344{ 345 char tmp[10]; 346 printf("test: snprintf\n"); 347 if (snprintf(tmp, 3, "foo%d", 9) != 4) { 348 printf("failure: snprintf [\nsnprintf return code failed\n]\n"); 349 return false; 350 } 351 352 if (strcmp(tmp, "fo") != 0) { 353 printf("failure: snprintf [\nsnprintf failed\n]\n"); 354 return false; 355 } 356 357 printf("success: snprintf\n"); 358 return true; 359} 360 361static int test_vasprintf(void) 362{ 363 /* FIXME */ 364 return true; 365} 366 367static int test_vsnprintf(void) 368{ 369 /* FIXME */ 370 return true; 371} 372 373static int test_opendir(void) 374{ 375 /* FIXME */ 376 return true; 377} 378 379extern int test_readdir_os2_delete(void); 380 381static int test_readdir(void) 382{ 383 printf("test: readdir\n"); 384 if (test_readdir_os2_delete() != 0) { 385 return false; 386 } 387 printf("success: readdir\n"); 388 return true; 389} 390 391static int test_telldir(void) 392{ 393 /* FIXME */ 394 return true; 395} 396 397static int test_seekdir(void) 398{ 399 /* FIXME */ 400 return true; 401} 402 403static int test_dlopen(void) 404{ 405 /* FIXME: test dlopen, dlsym, dlclose, dlerror */ 406 return true; 407} 408 409 410static int test_chroot(void) 411{ 412 /* FIXME: chroot() */ 413 return true; 414} 415 416static int test_bzero(void) 417{ 418 /* FIXME: bzero */ 419 return true; 420} 421 422static int test_strerror(void) 423{ 424 /* FIXME */ 425 return true; 426} 427 428static int test_errno(void) 429{ 430 printf("test: errno\n"); 431 errno = 3; 432 if (errno != 3) { 433 printf("failure: errno [\nerrno failed\n]\n"); 434 return false; 435 } 436 437 printf("success: errno\n"); 438 return true; 439} 440 441static int test_mkdtemp(void) 442{ 443 /* FIXME */ 444 return true; 445} 446 447static int test_mkstemp(void) 448{ 449 /* FIXME */ 450 return true; 451} 452 453static int test_pread(void) 454{ 455 /* FIXME */ 456 return true; 457} 458 459static int test_pwrite(void) 460{ 461 /* FIXME */ 462 return true; 463} 464 465static int test_getpass(void) 466{ 467 /* FIXME */ 468 return true; 469} 470 471static 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 517static 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 616static 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/* 750FIXME: 751Types: 752bool 753socklen_t 754uint_t 755uint{8,16,32,64}_t 756int{8,16,32,64}_t 757intptr_t 758 759Constants: 760PATH_NAME_MAX 761UINT{16,32,64}_MAX 762INT32_MAX 763*/ 764 765static int test_va_copy(void) 766{ 767 /* FIXME */ 768 return true; 769} 770 771static int test_FUNCTION(void) 772{ 773 printf("test: FUNCTION\n"); 774 if (strcmp(__FUNCTION__, "test_FUNCTION") != 0) { 775 printf("failure: FAILURE [\nFAILURE invalid\n]\n"); 776 return false; 777 } 778 printf("success: FUNCTION\n"); 779 return true; 780} 781 782static int test_MIN(void) 783{ 784 printf("test: MIN\n"); 785 if (MIN(20, 1) != 1) { 786 printf("failure: MIN [\nMIN invalid\n]\n"); 787 return false; 788 } 789 if (MIN(1, 20) != 1) { 790 printf("failure: MIN [\nMIN invalid\n]\n"); 791 return false; 792 } 793 printf("success: MIN\n"); 794 return true; 795} 796 797static int test_MAX(void) 798{ 799 printf("test: MAX\n"); 800 if (MAX(20, 1) != 20) { 801 printf("failure: MAX [\nMAX invalid\n]\n"); 802 return false; 803 } 804 if (MAX(1, 20) != 20) { 805 printf("failure: MAX [\nMAX invalid\n]\n"); 806 return false; 807 } 808 printf("success: MAX\n"); 809 return true; 810} 811 812static int test_socketpair(void) 813{ 814 int sock[2]; 815 char buf[20]; 816 817 printf("test: socketpair\n"); 818 819 if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock) == -1) { 820 printf("failure: socketpair [\n" 821 "socketpair() failed\n" 822 "]\n"); 823 return false; 824 } 825 826 if (write(sock[1], "automatisch", 12) == -1) { 827 printf("failure: socketpair [\n" 828 "write() failed: %s\n" 829 "]\n", strerror(errno)); 830 return false; 831 } 832 833 if (read(sock[0], buf, 12) == -1) { 834 printf("failure: socketpair [\n" 835 "read() failed: %s\n" 836 "]\n", strerror(errno)); 837 return false; 838 } 839 840 if (strcmp(buf, "automatisch") != 0) { 841 printf("failure: socketpair [\n" 842 "expected: automatisch, got: %s\n" 843 "]\n", buf); 844 return false; 845 } 846 847 printf("success: socketpair\n"); 848 849 return true; 850} 851 852extern int libreplace_test_strptime(void); 853 854static int test_strptime(void) 855{ 856 return libreplace_test_strptime(); 857} 858 859extern int getifaddrs_test(void); 860 861static int test_getifaddrs(void) 862{ 863 864 printf("test: getifaddrs\n"); 865 866 if (getifaddrs_test() != 0) { 867 printf("failure: getifaddrs\n"); 868 return false; 869 } 870 871 printf("success: getifaddrs\n"); 872 return true; 873} 874 875static int test_utime(void) 876{ 877 struct utimbuf u; 878 struct stat st1, st2, st3; 879 int fd; 880 881 printf("test: utime\n"); 882 unlink(TESTFILE); 883 884 fd = open(TESTFILE, O_RDWR|O_CREAT, 0600); 885 if (fd == -1) { 886 printf("failure: utime [\n" 887 "creating '%s' failed - %s\n]\n", 888 TESTFILE, strerror(errno)); 889 return false; 890 } 891 892 if (fstat(fd, &st1) != 0) { 893 printf("failure: utime [\n" 894 "fstat (1) failed - %s\n]\n", 895 strerror(errno)); 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 return false; 906 } 907 908 if (fstat(fd, &st2) != 0) { 909 printf("failure: utime [\n" 910 "fstat (2) failed - %s\n]\n", 911 strerror(errno)); 912 return false; 913 } 914 915 if (utime(TESTFILE, NULL) != 0) { 916 printf("failure: utime [\n" 917 "utime(NULL) failed - %s\n]\n", 918 strerror(errno)); 919 return false; 920 } 921 922 if (fstat(fd, &st3) != 0) { 923 printf("failure: utime [\n" 924 "fstat (3) failed - %s\n]\n", 925 strerror(errno)); 926 return false; 927 } 928 929#define CMP_VAL(a,c,b) do { \ 930 if (a c b) { \ 931 printf("failure: utime [\n" \ 932 "%s: %s(%d) %s %s(%d)\n]\n", \ 933 __location__, \ 934 #a, (int)a, #c, #b, (int)b); \ 935 return false; \ 936 } \ 937} while(0) 938#define EQUAL_VAL(a,b) CMP_VAL(a,!=,b) 939#define GREATER_VAL(a,b) CMP_VAL(a,<=,b) 940#define LESSER_VAL(a,b) CMP_VAL(a,>=,b) 941 942 EQUAL_VAL(st2.st_atime, st1.st_atime + 300); 943 EQUAL_VAL(st2.st_mtime, st1.st_mtime - 300); 944 LESSER_VAL(st3.st_atime, st2.st_atime); 945 GREATER_VAL(st3.st_mtime, st2.st_mtime); 946 947#undef CMP_VAL 948#undef EQUAL_VAL 949#undef GREATER_VAL 950#undef LESSER_VAL 951 952 unlink(TESTFILE); 953 printf("success: utime\n"); 954 return true; 955} 956 957static int test_utimes(void) 958{ 959 struct timeval tv[2]; 960 struct stat st1, st2; 961 int fd; 962 963 printf("test: utimes\n"); 964 unlink(TESTFILE); 965 966 fd = open(TESTFILE, O_RDWR|O_CREAT, 0600); 967 if (fd == -1) { 968 printf("failure: utimes [\n" 969 "creating '%s' failed - %s\n]\n", 970 TESTFILE, strerror(errno)); 971 return false; 972 } 973 974 if (fstat(fd, &st1) != 0) { 975 printf("failure: utimes [\n" 976 "fstat (1) failed - %s\n]\n", 977 strerror(errno)); 978 return false; 979 } 980 981 ZERO_STRUCT(tv); 982 tv[0].tv_sec = st1.st_atime + 300; 983 tv[1].tv_sec = st1.st_mtime - 300; 984 if (utimes(TESTFILE, tv) != 0) { 985 printf("failure: utimes [\n" 986 "utimes(tv) failed - %s\n]\n", 987 strerror(errno)); 988 return false; 989 } 990 991 if (fstat(fd, &st2) != 0) { 992 printf("failure: utimes [\n" 993 "fstat (2) failed - %s\n]\n", 994 strerror(errno)); 995 return false; 996 } 997 998#define EQUAL_VAL(a,b) do { \ 999 if (a != b) { \ 1000 printf("failure: utimes [\n" \ 1001 "%s: %s(%d) != %s(%d)\n]\n", \ 1002 __location__, \ 1003 #a, (int)a, #b, (int)b); \ 1004 return false; \ 1005 } \ 1006} while(0) 1007 1008 EQUAL_VAL(st2.st_atime, st1.st_atime + 300); 1009 EQUAL_VAL(st2.st_mtime, st1.st_mtime - 300); 1010 1011#undef EQUAL_VAL 1012 1013 unlink(TESTFILE); 1014 printf("success: utimes\n"); 1015 return true; 1016} 1017 1018struct torture_context; 1019bool torture_local_replace(struct torture_context *ctx) 1020{ 1021 bool ret = true; 1022 ret &= test_ftruncate(); 1023 ret &= test_strlcpy(); 1024 ret &= test_strlcat(); 1025 ret &= test_mktime(); 1026 ret &= test_initgroups(); 1027 ret &= test_memmove(); 1028 ret &= test_strdup(); 1029 ret &= test_setlinebuf(); 1030 ret &= test_vsyslog(); 1031 ret &= test_timegm(); 1032 ret &= test_setenv(); 1033 ret &= test_strndup(); 1034 ret &= test_strnlen(); 1035 ret &= test_waitpid(); 1036 ret &= test_seteuid(); 1037 ret &= test_setegid(); 1038 ret &= test_asprintf(); 1039 ret &= test_snprintf(); 1040 ret &= test_vasprintf(); 1041 ret &= test_vsnprintf(); 1042 ret &= test_opendir(); 1043 ret &= test_readdir(); 1044 ret &= test_telldir(); 1045 ret &= test_seekdir(); 1046 ret &= test_dlopen(); 1047 ret &= test_chroot(); 1048 ret &= test_bzero(); 1049 ret &= test_strerror(); 1050 ret &= test_errno(); 1051 ret &= test_mkdtemp(); 1052 ret &= test_mkstemp(); 1053 ret &= test_pread(); 1054 ret &= test_pwrite(); 1055 ret &= test_getpass(); 1056 ret &= test_inet_ntoa(); 1057 ret &= test_strtoll(); 1058 ret &= test_strtoull(); 1059 ret &= test_va_copy(); 1060 ret &= test_FUNCTION(); 1061 ret &= test_MIN(); 1062 ret &= test_MAX(); 1063 ret &= test_socketpair(); 1064 ret &= test_strptime(); 1065 ret &= test_getifaddrs(); 1066 ret &= test_utime(); 1067 ret &= test_utimes(); 1068 1069 return ret; 1070} 1071