1 /* 2 * File test program for CUPS. 3 * 4 * Copyright 2007-2015 by Apple Inc. 5 * Copyright 1997-2007 by Easy Software Products. 6 * 7 * These coded instructions, statements, and computer programs are the 8 * property of Apple Inc. and are protected by Federal copyright 9 * law. Distribution and use rights are outlined in the file "LICENSE.txt" 10 * which should have been included with this file. If this file is 11 * missing or damaged, see the license at "http://www.cups.org/". 12 * 13 * This file is subject to the Apple OS-Developed Software exception. 14 */ 15 16 /* 17 * Include necessary headers... 18 */ 19 20 #include "string-private.h" 21 #include "debug-private.h" 22 #include "file.h" 23 #include <stdlib.h> 24 #include <time.h> 25 #ifdef HAVE_LIBZ 26 # include <zlib.h> 27 #endif /* HAVE_LIBZ */ 28 #ifdef WIN32 29 # include <io.h> 30 #else 31 # include <unistd.h> 32 #endif /* WIN32 */ 33 #include <fcntl.h> 34 35 36 /* 37 * Local functions... 38 */ 39 40 static int count_lines(cups_file_t *fp); 41 static int random_tests(void); 42 static int read_write_tests(int compression); 43 44 45 /* 46 * 'main()' - Main entry. 47 */ 48 49 int /* O - Exit status */ 50 main(int argc, /* I - Number of command-line arguments */ 51 char *argv[]) /* I - Command-line arguments */ 52 { 53 int status; /* Exit status */ 54 char filename[1024]; /* Filename buffer */ 55 cups_file_t *fp; /* File pointer */ 56 #ifndef WIN32 57 int fds[2]; /* Open file descriptors */ 58 cups_file_t *fdfile; /* File opened with cupsFileOpenFd() */ 59 #endif /* !WIN32 */ 60 int count; /* Number of lines in file */ 61 62 63 if (argc == 1) 64 { 65 /* 66 * Do uncompressed file tests... 67 */ 68 69 status = read_write_tests(0); 70 71 #ifdef HAVE_LIBZ 72 /* 73 * Do compressed file tests... 74 */ 75 76 putchar('\n'); 77 78 status += read_write_tests(1); 79 #endif /* HAVE_LIBZ */ 80 81 /* 82 * Do uncompressed random I/O tests... 83 */ 84 85 status += random_tests(); 86 87 #ifndef WIN32 88 /* 89 * Test fdopen and close without reading... 90 */ 91 92 pipe(fds); 93 close(fds[1]); 94 95 fputs("\ncupsFileOpenFd(fd, \"r\"): ", stdout); 96 fflush(stdout); 97 98 if ((fdfile = cupsFileOpenFd(fds[0], "r")) == NULL) 99 { 100 puts("FAIL"); 101 status ++; 102 } 103 else 104 { 105 /* 106 * Able to open file, now close without reading. If we don't return 107 * before the alarm fires, that is a failure and we will crash on the 108 * alarm signal... 109 */ 110 111 puts("PASS"); 112 fputs("cupsFileClose(no read): ", stdout); 113 fflush(stdout); 114 115 alarm(5); 116 cupsFileClose(fdfile); 117 alarm(0); 118 119 puts("PASS"); 120 } 121 #endif /* !WIN32 */ 122 123 /* 124 * Count lines in psglyphs, rewind, then count again. 125 */ 126 127 fputs("\ncupsFileOpen(\"../data/media.defs\", \"r\"): ", stdout); 128 129 if ((fp = cupsFileOpen("../data/media.defs", "r")) == NULL) 130 { 131 puts("FAIL"); 132 status ++; 133 } 134 else 135 { 136 puts("PASS"); 137 fputs("cupsFileGets: ", stdout); 138 139 if ((count = count_lines(fp)) != 201) 140 { 141 printf("FAIL (got %d lines, expected 201)\n", count); 142 status ++; 143 } 144 else 145 { 146 puts("PASS"); 147 fputs("cupsFileRewind: ", stdout); 148 149 if (cupsFileRewind(fp) != 0) 150 { 151 puts("FAIL"); 152 status ++; 153 } 154 else 155 { 156 puts("PASS"); 157 fputs("cupsFileGets: ", stdout); 158 159 if ((count = count_lines(fp)) != 201) 160 { 161 printf("FAIL (got %d lines, expected 201)\n", count); 162 status ++; 163 } 164 else 165 puts("PASS"); 166 } 167 } 168 169 cupsFileClose(fp); 170 } 171 172 /* 173 * Test path functions... 174 */ 175 176 fputs("\ncupsFileFind: ", stdout); 177 #ifdef WIN32 178 if (cupsFileFind("notepad.exe", "C:/WINDOWS", 1, filename, sizeof(filename)) && 179 cupsFileFind("notepad.exe", "C:/WINDOWS;C:/WINDOWS/SYSTEM32", 1, filename, sizeof(filename))) 180 #else 181 if (cupsFileFind("cat", "/bin", 1, filename, sizeof(filename)) && 182 cupsFileFind("cat", "/bin:/usr/bin", 1, filename, sizeof(filename))) 183 #endif /* WIN32 */ 184 printf("PASS (%s)\n", filename); 185 else 186 { 187 puts("FAIL"); 188 status ++; 189 } 190 191 /* 192 * Summarize the results and return... 193 */ 194 195 if (!status) 196 puts("\nALL TESTS PASSED!"); 197 else 198 printf("\n%d TEST(S) FAILED!\n", status); 199 } 200 else 201 { 202 /* 203 * Cat the filename on the command-line... 204 */ 205 206 char line[8192]; /* Line from file */ 207 208 if ((fp = cupsFileOpen(argv[1], "r")) == NULL) 209 { 210 perror(argv[1]); 211 status = 1; 212 } 213 else if (argc == 2) 214 { 215 status = 0; 216 217 while (cupsFileGets(fp, line, sizeof(line))) 218 puts(line); 219 220 if (!cupsFileEOF(fp)) 221 perror(argv[1]); 222 223 cupsFileClose(fp); 224 } 225 else 226 { 227 status = 0; 228 ssize_t bytes; 229 230 while ((bytes = cupsFileRead(fp, line, sizeof(line))) > 0) 231 printf("%s: %d bytes\n", argv[1], (int)bytes); 232 233 if (cupsFileEOF(fp)) 234 printf("%s: EOF\n", argv[1]); 235 else 236 perror(argv[1]); 237 238 cupsFileClose(fp); 239 } 240 } 241 242 return (status); 243 } 244 245 246 /* 247 * 'count_lines()' - Count the number of lines in a file. 248 */ 249 250 static int /* O - Number of lines */ 251 count_lines(cups_file_t *fp) /* I - File to read from */ 252 { 253 int count; /* Number of lines */ 254 char line[1024]; /* Line buffer */ 255 256 257 for (count = 0; cupsFileGets(fp, line, sizeof(line)); count ++); 258 259 return (count); 260 } 261 262 263 /* 264 * 'random_tests()' - Do random access tests. 265 */ 266 267 static int /* O - Status */ 268 random_tests(void) 269 { 270 int status, /* Status of tests */ 271 pass, /* Current pass */ 272 count, /* Number of records read */ 273 record, /* Current record */ 274 num_records; /* Number of records */ 275 off_t pos; /* Position in file */ 276 ssize_t expected; /* Expected position in file */ 277 cups_file_t *fp; /* File */ 278 char buffer[512]; /* Data buffer */ 279 280 281 /* 282 * Run 4 passes, each time appending to a data file and then reopening the 283 * file for reading to validate random records in the file. 284 */ 285 286 for (status = 0, pass = 0; pass < 4; pass ++) 287 { 288 /* 289 * cupsFileOpen(append) 290 */ 291 292 printf("\ncupsFileOpen(append %d): ", pass); 293 294 if ((fp = cupsFileOpen("testfile.dat", "a")) == NULL) 295 { 296 printf("FAIL (%s)\n", strerror(errno)); 297 status ++; 298 break; 299 } 300 else 301 puts("PASS"); 302 303 /* 304 * cupsFileTell() 305 */ 306 307 expected = 256 * (ssize_t)sizeof(buffer) * pass; 308 309 fputs("cupsFileTell(): ", stdout); 310 if ((pos = cupsFileTell(fp)) != (off_t)expected) 311 { 312 printf("FAIL (" CUPS_LLFMT " instead of " CUPS_LLFMT ")\n", 313 CUPS_LLCAST pos, CUPS_LLCAST expected); 314 status ++; 315 break; 316 } 317 else 318 puts("PASS"); 319 320 /* 321 * cupsFileWrite() 322 */ 323 324 fputs("cupsFileWrite(256 512-byte records): ", stdout); 325 for (record = 0; record < 256; record ++) 326 { 327 memset(buffer, record, sizeof(buffer)); 328 if (cupsFileWrite(fp, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) 329 break; 330 } 331 332 if (record < 256) 333 { 334 printf("FAIL (%d: %s)\n", record, strerror(errno)); 335 status ++; 336 break; 337 } 338 else 339 puts("PASS"); 340 341 /* 342 * cupsFileTell() 343 */ 344 345 expected += 256 * (ssize_t)sizeof(buffer); 346 347 fputs("cupsFileTell(): ", stdout); 348 if ((pos = cupsFileTell(fp)) != (off_t)expected) 349 { 350 printf("FAIL (" CUPS_LLFMT " instead of " CUPS_LLFMT ")\n", 351 CUPS_LLCAST pos, CUPS_LLCAST expected); 352 status ++; 353 break; 354 } 355 else 356 puts("PASS"); 357 358 cupsFileClose(fp); 359 360 /* 361 * cupsFileOpen(read) 362 */ 363 364 printf("\ncupsFileOpen(read %d): ", pass); 365 366 if ((fp = cupsFileOpen("testfile.dat", "r")) == NULL) 367 { 368 printf("FAIL (%s)\n", strerror(errno)); 369 status ++; 370 break; 371 } 372 else 373 puts("PASS"); 374 375 /* 376 * cupsFileSeek, cupsFileRead 377 */ 378 379 fputs("cupsFileSeek(), cupsFileRead(): ", stdout); 380 381 for (num_records = (pass + 1) * 256, count = (pass + 1) * 256, record = ((int)CUPS_RAND() & 65535) % num_records; 382 count > 0; 383 count --, record = (record + ((int)CUPS_RAND() & 31) - 16 + num_records) % num_records) 384 { 385 /* 386 * The last record is always the first... 387 */ 388 389 if (count == 1) 390 record = 0; 391 392 /* 393 * Try reading the data for the specified record, and validate the 394 * contents... 395 */ 396 397 expected = (ssize_t)sizeof(buffer) * record; 398 399 if ((pos = cupsFileSeek(fp, expected)) != expected) 400 { 401 printf("FAIL (" CUPS_LLFMT " instead of " CUPS_LLFMT ")\n", 402 CUPS_LLCAST pos, CUPS_LLCAST expected); 403 status ++; 404 break; 405 } 406 else 407 { 408 if (cupsFileRead(fp, buffer, sizeof(buffer)) != sizeof(buffer)) 409 { 410 printf("FAIL (%s)\n", strerror(errno)); 411 status ++; 412 break; 413 } 414 else if ((buffer[0] & 255) != (record & 255) || 415 memcmp(buffer, buffer + 1, sizeof(buffer) - 1)) 416 { 417 printf("FAIL (Bad Data - %d instead of %d)\n", buffer[0] & 255, 418 record & 255); 419 status ++; 420 break; 421 } 422 } 423 } 424 425 if (count == 0) 426 puts("PASS"); 427 428 cupsFileClose(fp); 429 } 430 431 /* 432 * Remove the test file... 433 */ 434 435 unlink("testfile.dat"); 436 437 /* 438 * Return the test status... 439 */ 440 441 return (status); 442 } 443 444 445 /* 446 * 'read_write_tests()' - Perform read/write tests. 447 */ 448 449 static int /* O - Status */ 450 read_write_tests(int compression) /* I - Use compression? */ 451 { 452 int i; /* Looping var */ 453 cups_file_t *fp; /* File */ 454 int status; /* Exit status */ 455 char line[1024], /* Line from file */ 456 *value; /* Directive value from line */ 457 int linenum; /* Line number */ 458 unsigned char readbuf[8192], /* Read buffer */ 459 writebuf[8192]; /* Write buffer */ 460 int byte; /* Byte from file */ 461 ssize_t bytes; /* Number of bytes read/written */ 462 off_t length; /* Length of file */ 463 static const char *partial_line = "partial line"; 464 /* Partial line */ 465 466 467 /* 468 * No errors so far... 469 */ 470 471 status = 0; 472 473 /* 474 * Initialize the write buffer with random data... 475 */ 476 477 CUPS_SRAND((unsigned)time(NULL)); 478 479 for (i = 0; i < (int)sizeof(writebuf); i ++) 480 writebuf[i] = (unsigned char)CUPS_RAND(); 481 482 /* 483 * cupsFileOpen(write) 484 */ 485 486 printf("cupsFileOpen(write%s): ", compression ? " compressed" : ""); 487 488 fp = cupsFileOpen(compression ? "testfile.dat.gz" : "testfile.dat", 489 compression ? "w9" : "w"); 490 if (fp) 491 { 492 puts("PASS"); 493 494 /* 495 * cupsFileCompression() 496 */ 497 498 fputs("cupsFileCompression(): ", stdout); 499 500 if (cupsFileCompression(fp) == compression) 501 puts("PASS"); 502 else 503 { 504 printf("FAIL (Got %d, expected %d)\n", cupsFileCompression(fp), 505 compression); 506 status ++; 507 } 508 509 /* 510 * cupsFilePuts() 511 */ 512 513 fputs("cupsFilePuts(): ", stdout); 514 515 if (cupsFilePuts(fp, "# Hello, World\n") > 0) 516 puts("PASS"); 517 else 518 { 519 printf("FAIL (%s)\n", strerror(errno)); 520 status ++; 521 } 522 523 /* 524 * cupsFilePrintf() 525 */ 526 527 fputs("cupsFilePrintf(): ", stdout); 528 529 for (i = 0; i < 1000; i ++) 530 if (cupsFilePrintf(fp, "TestLine %03d\n", i) < 0) 531 break; 532 533 if (i >= 1000) 534 puts("PASS"); 535 else 536 { 537 printf("FAIL (%s)\n", strerror(errno)); 538 status ++; 539 } 540 541 /* 542 * cupsFilePutChar() 543 */ 544 545 fputs("cupsFilePutChar(): ", stdout); 546 547 for (i = 0; i < 256; i ++) 548 if (cupsFilePutChar(fp, i) < 0) 549 break; 550 551 if (i >= 256) 552 puts("PASS"); 553 else 554 { 555 printf("FAIL (%s)\n", strerror(errno)); 556 status ++; 557 } 558 559 /* 560 * cupsFileWrite() 561 */ 562 563 fputs("cupsFileWrite(): ", stdout); 564 565 for (i = 0; i < 10000; i ++) 566 if (cupsFileWrite(fp, (char *)writebuf, sizeof(writebuf)) < 0) 567 break; 568 569 if (i >= 10000) 570 puts("PASS"); 571 else 572 { 573 printf("FAIL (%s)\n", strerror(errno)); 574 status ++; 575 } 576 577 /* 578 * cupsFilePuts() with partial line... 579 */ 580 581 fputs("cupsFilePuts(\"partial line\"): ", stdout); 582 583 if (cupsFilePuts(fp, partial_line) > 0) 584 puts("PASS"); 585 else 586 { 587 printf("FAIL (%s)\n", strerror(errno)); 588 status ++; 589 } 590 591 /* 592 * cupsFileTell() 593 */ 594 595 fputs("cupsFileTell(): ", stdout); 596 597 if ((length = cupsFileTell(fp)) == 81933283) 598 puts("PASS"); 599 else 600 { 601 printf("FAIL (" CUPS_LLFMT " instead of 81933283)\n", CUPS_LLCAST length); 602 status ++; 603 } 604 605 /* 606 * cupsFileClose() 607 */ 608 609 fputs("cupsFileClose(): ", stdout); 610 611 if (!cupsFileClose(fp)) 612 puts("PASS"); 613 else 614 { 615 printf("FAIL (%s)\n", strerror(errno)); 616 status ++; 617 } 618 } 619 else 620 { 621 printf("FAIL (%s)\n", strerror(errno)); 622 status ++; 623 } 624 625 /* 626 * cupsFileOpen(read) 627 */ 628 629 fputs("\ncupsFileOpen(read): ", stdout); 630 631 fp = cupsFileOpen(compression ? "testfile.dat.gz" : "testfile.dat", "r"); 632 if (fp) 633 { 634 puts("PASS"); 635 636 /* 637 * cupsFileGets() 638 */ 639 640 fputs("cupsFileGets(): ", stdout); 641 642 if (cupsFileGets(fp, line, sizeof(line))) 643 { 644 if (line[0] == '#') 645 puts("PASS"); 646 else 647 { 648 printf("FAIL (Got line \"%s\", expected comment line)\n", line); 649 status ++; 650 } 651 } 652 else 653 { 654 printf("FAIL (%s)\n", strerror(errno)); 655 status ++; 656 } 657 658 /* 659 * cupsFileCompression() 660 */ 661 662 fputs("cupsFileCompression(): ", stdout); 663 664 if (cupsFileCompression(fp) == compression) 665 puts("PASS"); 666 else 667 { 668 printf("FAIL (Got %d, expected %d)\n", cupsFileCompression(fp), 669 compression); 670 status ++; 671 } 672 673 /* 674 * cupsFileGetConf() 675 */ 676 677 linenum = 1; 678 679 fputs("cupsFileGetConf(): ", stdout); 680 681 for (i = 0, value = NULL; i < 1000; i ++) 682 if (!cupsFileGetConf(fp, line, sizeof(line), &value, &linenum)) 683 break; 684 else if (_cups_strcasecmp(line, "TestLine") || !value || atoi(value) != i || 685 linenum != (i + 2)) 686 break; 687 688 if (i >= 1000) 689 puts("PASS"); 690 else if (line[0]) 691 { 692 printf("FAIL (Line %d, directive \"%s\", value \"%s\")\n", linenum, 693 line, value ? value : "(null)"); 694 status ++; 695 } 696 else 697 { 698 printf("FAIL (%s)\n", strerror(errno)); 699 status ++; 700 } 701 702 /* 703 * cupsFileGetChar() 704 */ 705 706 fputs("cupsFileGetChar(): ", stdout); 707 708 for (i = 0, byte = 0; i < 256; i ++) 709 if ((byte = cupsFileGetChar(fp)) != i) 710 break; 711 712 if (i >= 256) 713 puts("PASS"); 714 else if (byte >= 0) 715 { 716 printf("FAIL (Got %d, expected %d)\n", byte, i); 717 status ++; 718 } 719 else 720 { 721 printf("FAIL (%s)\n", strerror(errno)); 722 status ++; 723 } 724 725 /* 726 * cupsFileRead() 727 */ 728 729 fputs("cupsFileRead(): ", stdout); 730 731 for (i = 0, bytes = 0; i < 10000; i ++) 732 if ((bytes = cupsFileRead(fp, (char *)readbuf, sizeof(readbuf))) < 0) 733 break; 734 else if (memcmp(readbuf, writebuf, sizeof(readbuf))) 735 break; 736 737 if (i >= 10000) 738 puts("PASS"); 739 else if (bytes > 0) 740 { 741 printf("FAIL (Pass %d, ", i); 742 743 for (i = 0; i < (int)sizeof(readbuf); i ++) 744 if (readbuf[i] != writebuf[i]) 745 break; 746 747 printf("match failed at offset %d - got %02X, expected %02X)\n", 748 i, readbuf[i], writebuf[i]); 749 } 750 else 751 { 752 printf("FAIL (%s)\n", strerror(errno)); 753 status ++; 754 } 755 756 /* 757 * cupsFileGetChar() with partial line... 758 */ 759 760 fputs("cupsFileGetChar(partial line): ", stdout); 761 762 for (i = 0; i < (int)strlen(partial_line); i ++) 763 if ((byte = cupsFileGetChar(fp)) < 0) 764 break; 765 else if (byte != partial_line[i]) 766 break; 767 768 if (!partial_line[i]) 769 puts("PASS"); 770 else 771 { 772 printf("FAIL (got '%c', expected '%c')\n", byte, partial_line[i]); 773 status ++; 774 } 775 776 /* 777 * cupsFileTell() 778 */ 779 780 fputs("cupsFileTell(): ", stdout); 781 782 if ((length = cupsFileTell(fp)) == 81933283) 783 puts("PASS"); 784 else 785 { 786 printf("FAIL (" CUPS_LLFMT " instead of 81933283)\n", CUPS_LLCAST length); 787 status ++; 788 } 789 790 /* 791 * cupsFileClose() 792 */ 793 794 fputs("cupsFileClose(): ", stdout); 795 796 if (!cupsFileClose(fp)) 797 puts("PASS"); 798 else 799 { 800 printf("FAIL (%s)\n", strerror(errno)); 801 status ++; 802 } 803 } 804 else 805 { 806 printf("FAIL (%s)\n", strerror(errno)); 807 status ++; 808 } 809 810 /* 811 * Remove the test file... 812 */ 813 814 if (!status) 815 unlink(compression ? "testfile.dat.gz" : "testfile.dat"); 816 817 /* 818 * Return the test status... 819 */ 820 821 return (status); 822 } 823
