| OLD | NEW |
|---|
| (Empty) |
| 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 */ | |
| 54 static 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 */ | |
| 89 static 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 | |
| 114 static 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 | |
| 140 static int test_mktime(void) | |
| 141 { | |
| 142 /* FIXME */ | |
| 143 return true; | |
| 144 } | |
| 145 | |
| 146 static int test_initgroups(void) | |
| 147 { | |
| 148 /* FIXME */ | |
| 149 return true; | |
| 150 } | |
| 151 | |
| 152 static int test_memmove(void) | |
| 153 { | |
| 154 /* FIXME */ | |
| 155 return true; | |
| 156 } | |
| 157 | |
| 158 static 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 | |
| 173 static int test_setlinebuf(void) | |
| 174 { | |
| 175 printf("test: setlinebuf\n"); | |
| 176 setlinebuf(stdout); | |
| 177 printf("success: setlinebuf\n"); | |
| 178 return true; | |
| 179 } | |
| 180 | |
| 181 static int test_vsyslog(void) | |
| 182 { | |
| 183 /* FIXME */ | |
| 184 return true; | |
| 185 } | |
| 186 | |
| 187 static int test_timegm(void) | |
| 188 { | |
| 189 /* FIXME */ | |
| 190 return true; | |
| 191 } | |
| 192 | |
| 193 static 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 | |
| 253 static 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 | |
| 279 static 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 | |
| 301 static int test_waitpid(void) | |
| 302 { | |
| 303 /* FIXME */ | |
| 304 return true; | |
| 305 } | |
| 306 | |
| 307 static int test_seteuid(void) | |
| 308 { | |
| 309 /* FIXME */ | |
| 310 return true; | |
| 311 } | |
| 312 | |
| 313 static int test_setegid(void) | |
| 314 { | |
| 315 /* FIXME */ | |
| 316 return true; | |
| 317 } | |
| 318 | |
| 319 static 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 | |
| 343 static 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 | |
| 361 static int test_vasprintf(void) | |
| 362 { | |
| 363 /* FIXME */ | |
| 364 return true; | |
| 365 } | |
| 366 | |
| 367 static int test_vsnprintf(void) | |
| 368 { | |
| 369 /* FIXME */ | |
| 370 return true; | |
| 371 } | |
| 372 | |
| 373 static int test_opendir(void) | |
| 374 { | |
| 375 /* FIXME */ | |
| 376 return true; | |
| 377 } | |
| 378 | |
| 379 extern int test_readdir_os2_delete(void); | |
| 380 | |
| 381 static 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 | |
| 391 static int test_telldir(void) | |
| 392 { | |
| 393 /* FIXME */ | |
| 394 return true; | |
| 395 } | |
| 396 | |
| 397 static int test_seekdir(void) | |
| 398 { | |
| 399 /* FIXME */ | |
| 400 return true; | |
| 401 } | |
| 402 | |
| 403 static int test_dlopen(void) | |
| 404 { | |
| 405 /* FIXME: test dlopen, dlsym, dlclose, dlerror */ | |
| 406 return true; | |
| 407 } | |
| 408 | |
| 409 | |
| 410 static int test_chroot(void) | |
| 411 { | |
| 412 /* FIXME: chroot() */ | |
| 413 return true; | |
| 414 } | |
| 415 | |
| 416 static int test_bzero(void) | |
| 417 { | |
| 418 /* FIXME: bzero */ | |
| 419 return true; | |
| 420 } | |
| 421 | |
| 422 static int test_strerror(void) | |
| 423 { | |
| 424 /* FIXME */ | |
| 425 return true; | |
| 426 } | |
| 427 | |
| 428 static 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 | |
| 441 static int test_mkdtemp(void) | |
| 442 { | |
| 443 /* FIXME */ | |
| 444 return true; | |
| 445 } | |
| 446 | |
| 447 static int test_mkstemp(void) | |
| 448 { | |
| 449 /* FIXME */ | |
| 450 return true; | |
| 451 } | |
| 452 | |
| 453 static int test_pread(void) | |
| 454 { | |
| 455 /* FIXME */ | |
| 456 return true; | |
| 457 } | |
| 458 | |
| 459 static int test_pwrite(void) | |
| 460 { | |
| 461 /* FIXME */ | |
| 462 return true; | |
| 463 } | |
| 464 | |
| 465 static int test_getpass(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_t | |
| 755 uint{8,16,32,64}_t | |
| 756 int{8,16,32,64}_t | |
| 757 intptr_t | |
| 758 | |
| 759 Constants: | |
| 760 PATH_NAME_MAX | |
| 761 UINT{16,32,64}_MAX | |
| 762 INT32_MAX | |
| 763 */ | |
| 764 | |
| 765 static int test_va_copy(void) | |
| 766 { | |
| 767 /* FIXME */ | |
| 768 return true; | |
| 769 } | |
| 770 | |
| 771 static 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 | |
| 782 static 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 | |
| 797 static 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 | |
| 812 static 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 | |
| 852 extern int libreplace_test_strptime(void); | |
| 853 | |
| 854 static int test_strptime(void) | |
| 855 { | |
| 856 return libreplace_test_strptime(); | |
| 857 } | |
| 858 | |
| 859 extern int getifaddrs_test(void); | |
| 860 | |
| 861 static 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 | |
| 875 static 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 | |
| 957 static 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 | |
| 1018 struct torture_context; | |
| 1019 bool 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2282793002:
Remove unused third_party/talloc (Closed)
