1 /*
2 * Raster test program routines for CUPS.
3 *
4 * Copyright 2007-2016 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 <cups/raster-private.h>
21 #include <cups/ppd.h>
22 #include <math.h>
23
24
25 /*
26 * Test PS commands and header...
27 */
28
29 static const char *dsc_code =
30 "[{\n"
31 "%%BeginFeature: *PageSize Tabloid\n"
32 "<</PageSize[792 1224]>>setpagedevice\n"
33 "%%EndFeature\n"
34 "} stopped cleartomark\n";
35 static const char *setpagedevice_code =
36 "<<"
37 "/MediaClass(Media Class)"
38 "/MediaColor((Media Color))"
39 "/MediaType(Media\\\\Type)"
40 "/OutputType<416263>"
41 "/AdvanceDistance 1000"
42 "/AdvanceMedia 1"
43 "/Collate false"
44 "/CutMedia 2"
45 "/Duplex true"
46 "/HWResolution[100 200]"
47 "/InsertSheet true"
48 "/Jog 3"
49 "/LeadingEdge 1"
50 "/ManualFeed true"
51 "/MediaPosition 8#777"
52 "/MediaWeight 16#fe01"
53 "/MirrorPrint true"
54 "/NegativePrint true"
55 "/NumCopies 1"
56 "/Orientation 1"
57 "/OutputFaceUp true"
58 "/PageSize[612 792.1]"
59 "/Separations true"
60 "/TraySwitch true"
61 "/Tumble true"
62 "/cupsMediaType 2"
63 "/cupsColorOrder 1"
64 "/cupsColorSpace 1"
65 "/cupsCompression 1"
66 "/cupsRowCount 1"
67 "/cupsRowFeed 1"
68 "/cupsRowStep 1"
69 "/cupsBorderlessScalingFactor 1.001"
70 "/cupsInteger0 1"
71 "/cupsInteger1 2"
72 "/cupsInteger2 3"
73 "/cupsInteger3 4"
74 "/cupsInteger4 5"
75 "/cupsInteger5 6"
76 "/cupsInteger6 7"
77 "/cupsInteger7 8"
78 "/cupsInteger8 9"
79 "/cupsInteger9 10"
80 "/cupsInteger10 11"
81 "/cupsInteger11 12"
82 "/cupsInteger12 13"
83 "/cupsInteger13 14"
84 "/cupsInteger14 15"
85 "/cupsInteger15 16"
86 "/cupsReal0 1.1"
87 "/cupsReal1 2.1"
88 "/cupsReal2 3.1"
89 "/cupsReal3 4.1"
90 "/cupsReal4 5.1"
91 "/cupsReal5 6.1"
92 "/cupsReal6 7.1"
93 "/cupsReal7 8.1"
94 "/cupsReal8 9.1"
95 "/cupsReal9 10.1"
96 "/cupsReal10 11.1"
97 "/cupsReal11 12.1"
98 "/cupsReal12 13.1"
99 "/cupsReal13 14.1"
100 "/cupsReal14 15.1"
101 "/cupsReal15 16.1"
102 "/cupsString0(1)"
103 "/cupsString1(2)"
104 "/cupsString2(3)"
105 "/cupsString3(4)"
106 "/cupsString4(5)"
107 "/cupsString5(6)"
108 "/cupsString6(7)"
109 "/cupsString7(8)"
110 "/cupsString8(9)"
111 "/cupsString9(10)"
112 "/cupsString10(11)"
113 "/cupsString11(12)"
114 "/cupsString12(13)"
115 "/cupsString13(14)"
116 "/cupsString14(15)"
117 "/cupsString15(16)"
118 "/cupsMarkerType(Marker Type)"
119 "/cupsRenderingIntent(Rendering Intent)"
120 "/cupsPageSizeName(Letter)"
121 "/cupsPreferredBitsPerColor 17"
122 ">> setpagedevice";
123
124 static cups_page_header2_t setpagedevice_header =
125 {
126 "Media Class", /* MediaClass */
127 "(Media Color)", /* MediaColor */
128 "Media\\Type", /* MediaType */
129 "Abc", /* OutputType */
130 1000, /* AdvanceDistance */
131 CUPS_ADVANCE_FILE, /* AdvanceMedia */
132 CUPS_FALSE, /* Collate */
133 CUPS_CUT_JOB, /* CutMedia */
134 CUPS_TRUE, /* Duplex */
135 { 100, 200 }, /* HWResolution */
136 { 0, 0, 0, 0 }, /* ImagingBoundingBox */
137 CUPS_TRUE, /* InsertSheet */
138 CUPS_JOG_SET, /* Jog */
139 CUPS_EDGE_RIGHT, /* LeadingEdge */
140 { 0, 0 }, /* Margins */
141 CUPS_TRUE, /* ManualFeed */
142 0777, /* MediaPosition */
143 0xfe01, /* MediaWeight */
144 CUPS_TRUE, /* MirrorPrint */
145 CUPS_TRUE, /* NegativePrint */
146 1, /* NumCopies */
147 CUPS_ORIENT_90, /* Orientation */
148 CUPS_TRUE, /* OutputFaceUp */
149 { 612, 792 }, /* PageSize */
150 CUPS_TRUE, /* Separations */
151 CUPS_TRUE, /* TraySwitch */
152 CUPS_TRUE, /* Tumble */
153 0, /* cupsWidth */
154 0, /* cupsHeight */
155 2, /* cupsMediaType */
156 0, /* cupsBitsPerColor */
157 0, /* cupsBitsPerPixel */
158 0, /* cupsBytesPerLine */
159 CUPS_ORDER_BANDED, /* cupsColorOrder */
160 CUPS_CSPACE_RGB, /* cupsColorSpace */
161 1, /* cupsCompression */
162 1, /* cupsRowCount */
163 1, /* cupsRowFeed */
164 1, /* cupsRowStep */
165 0, /* cupsNumColors */
166 1.001f, /* cupsBorderlessScalingFactor */
167 { 612.0f, 792.1f }, /* cupsPageSize */
168 { 0.0f, 0.0f, 0.0f, 0.0f }, /* cupsImagingBBox */
169 { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
170 /* cupsInteger[16] */
171 { 1.1f, 2.1f, 3.1f, 4.1f, 5.1f, 6.1f, 7.1f, 8.1f, 9.1f, 10.1f, 11.1f, 12.1f, 13.1f, 14.1f, 15.1f, 16.1f }, /* cupsReal[16] */
172 { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13",
173 "14", "15", "16" }, /* cupsString[16] */
174 "Marker Type", /* cupsMarkerType */
175 "Rendering Intent", /* cupsRenderingIntent */
176 "Letter" /* cupsPageSizeName */
177 };
178
179
180 /*
181 * Local functions...
182 */
183
184 static int do_ppd_tests(const char *filename, int num_options,
185 cups_option_t *options);
186 static int do_ps_tests(void);
187 static int do_ras_file(const char *filename);
188 static int do_raster_tests(cups_mode_t mode);
189 static void print_changes(cups_page_header2_t *header,
190 cups_page_header2_t *expected);
191
192
193 /*
194 * 'main()' - Test the raster functions.
195 */
196
197 int /* O - Exit status */
main(int argc,char * argv[])198 main(int argc, /* I - Number of command-line args */
199 char *argv[]) /* I - Command-line arguments */
200 {
201 int errors; /* Number of errors */
202 const char *ext; /* Filename extension */
203
204
205 if (argc == 1)
206 {
207 errors = do_ps_tests();
208 errors += do_raster_tests(CUPS_RASTER_WRITE);
209 errors += do_raster_tests(CUPS_RASTER_WRITE_COMPRESSED);
210 errors += do_raster_tests(CUPS_RASTER_WRITE_PWG);
211 errors += do_raster_tests(CUPS_RASTER_WRITE_APPLE);
212 }
213 else
214 {
215 int i; /* Looping var */
216 int num_options; /* Number of options */
217 cups_option_t *options; /* Options */
218
219
220 for (errors = 0, num_options = 0, options = NULL, i = 1; i < argc; i ++)
221 {
222 if (argv[i][0] == '-')
223 {
224 if (argv[i][1] == 'o')
225 {
226 if (argv[i][2])
227 num_options = cupsParseOptions(argv[i] + 2, num_options, &options);
228 else
229 {
230 i ++;
231 if (i < argc)
232 num_options = cupsParseOptions(argv[i], num_options, &options);
233 else
234 {
235 puts("Usage: testraster [-o name=value ...] [filename.ppd ...]");
236 puts(" testraster [filename.ras ...]");
237 return (1);
238 }
239 }
240 }
241 else
242 {
243 puts("Usage: testraster [-o name=value ...] [filename.ppd ...]");
244 puts(" testraster [filename.ras ...]");
245 return (1);
246 }
247 }
248 else if ((ext = strrchr(argv[i], '.')) != NULL)
249 {
250 if (!strcmp(ext, ".ppd"))
251 errors += do_ppd_tests(argv[i], num_options, options);
252 else
253 errors += do_ras_file(argv[i]);
254 }
255 else
256 {
257 puts("Usage: testraster [-o name=value ...] [filename.ppd ...]");
258 puts(" testraster [filename.ras ...]");
259 return (1);
260 }
261 }
262
263 cupsFreeOptions(num_options, options);
264 }
265
266 return (errors);
267 }
268
269
270 /*
271 * 'do_ppd_tests()' - Test the default option commands in a PPD file.
272 */
273
274 static int /* O - Number of errors */
do_ppd_tests(const char * filename,int num_options,cups_option_t * options)275 do_ppd_tests(const char *filename, /* I - PPD file */
276 int num_options, /* I - Number of options */
277 cups_option_t *options) /* I - Options */
278 {
279 ppd_file_t *ppd; /* PPD file data */
280 cups_page_header2_t header; /* Page header */
281
282
283 printf("\"%s\": ", filename);
284 fflush(stdout);
285
286 if ((ppd = ppdOpenFile(filename)) == NULL)
287 {
288 ppd_status_t status; /* Status from PPD loader */
289 int line; /* Line number containing error */
290
291
292 status = ppdLastError(&line);
293
294 puts("FAIL (bad PPD file)");
295 printf(" %s on line %d\n", ppdErrorString(status), line);
296
297 return (1);
298 }
299
300 ppdMarkDefaults(ppd);
301 cupsMarkOptions(ppd, num_options, options);
302
303 if (cupsRasterInterpretPPD(&header, ppd, 0, NULL, NULL))
304 {
305 puts("FAIL (error from function)");
306 puts(cupsRasterErrorString());
307
308 return (1);
309 }
310 else
311 {
312 puts("PASS");
313
314 return (0);
315 }
316 }
317
318
319 /*
320 * 'do_ps_tests()' - Test standard PostScript commands.
321 */
322
323 static int
do_ps_tests(void)324 do_ps_tests(void)
325 {
326 cups_page_header2_t header; /* Page header */
327 int preferred_bits; /* Preferred bits */
328 int errors = 0; /* Number of errors */
329
330
331 /*
332 * Test PS exec code...
333 */
334
335 fputs("_cupsRasterExecPS(\"setpagedevice\"): ", stdout);
336 fflush(stdout);
337
338 memset(&header, 0, sizeof(header));
339 header.Collate = CUPS_TRUE;
340 preferred_bits = 0;
341
342 if (_cupsRasterExecPS(&header, &preferred_bits, setpagedevice_code))
343 {
344 puts("FAIL (error from function)");
345 puts(cupsRasterErrorString());
346 errors ++;
347 }
348 else if (preferred_bits != 17 ||
349 memcmp(&header, &setpagedevice_header, sizeof(header)))
350 {
351 puts("FAIL (bad header)");
352
353 if (preferred_bits != 17)
354 printf(" cupsPreferredBitsPerColor %d, expected 17\n",
355 preferred_bits);
356
357 print_changes(&setpagedevice_header, &header);
358 errors ++;
359 }
360 else
361 puts("PASS");
362
363 fputs("_cupsRasterExecPS(\"roll\"): ", stdout);
364 fflush(stdout);
365
366 if (_cupsRasterExecPS(&header, &preferred_bits,
367 "792 612 0 0 0\n"
368 "pop pop pop\n"
369 "<</PageSize[5 -2 roll]/ImagingBBox null>>"
370 "setpagedevice\n"))
371 {
372 puts("FAIL (error from function)");
373 puts(cupsRasterErrorString());
374 errors ++;
375 }
376 else if (header.PageSize[0] != 792 || header.PageSize[1] != 612)
377 {
378 printf("FAIL (PageSize [%d %d], expected [792 612])\n", header.PageSize[0],
379 header.PageSize[1]);
380 errors ++;
381 }
382 else
383 puts("PASS");
384
385 fputs("_cupsRasterExecPS(\"dup index\"): ", stdout);
386 fflush(stdout);
387
388 if (_cupsRasterExecPS(&header, &preferred_bits,
389 "true false dup\n"
390 "<</Collate 4 index"
391 "/Duplex 5 index"
392 "/Tumble 6 index>>setpagedevice\n"
393 "pop pop pop"))
394 {
395 puts("FAIL (error from function)");
396 puts(cupsRasterErrorString());
397 errors ++;
398 }
399 else
400 {
401 if (!header.Collate)
402 {
403 printf("FAIL (Collate false, expected true)\n");
404 errors ++;
405 }
406
407 if (header.Duplex)
408 {
409 printf("FAIL (Duplex true, expected false)\n");
410 errors ++;
411 }
412
413 if (header.Tumble)
414 {
415 printf("FAIL (Tumble true, expected false)\n");
416 errors ++;
417 }
418
419 if(header.Collate && !header.Duplex && !header.Tumble)
420 puts("PASS");
421 }
422
423 fputs("_cupsRasterExecPS(\"%%Begin/EndFeature code\"): ", stdout);
424 fflush(stdout);
425
426 if (_cupsRasterExecPS(&header, &preferred_bits, dsc_code))
427 {
428 puts("FAIL (error from function)");
429 puts(cupsRasterErrorString());
430 errors ++;
431 }
432 else if (header.PageSize[0] != 792 || header.PageSize[1] != 1224)
433 {
434 printf("FAIL (bad PageSize [%d %d], expected [792 1224])\n",
435 header.PageSize[0], header.PageSize[1]);
436 errors ++;
437 }
438 else
439 puts("PASS");
440
441 return (errors);
442 }
443
444
445 /*
446 * 'do_ras_file()' - Test reading of a raster file.
447 */
448
449 static int /* O - Number of errors */
do_ras_file(const char * filename)450 do_ras_file(const char *filename) /* I - Filename */
451 {
452 unsigned y; /* Looping vars */
453 int fd; /* File descriptor */
454 cups_raster_t *ras; /* Raster stream */
455 cups_page_header2_t header; /* Page header */
456 unsigned char *data; /* Raster data */
457 int errors = 0; /* Number of errors */
458 unsigned pages = 0; /* Number of pages */
459
460
461 if ((fd = open(filename, O_RDONLY)) < 0)
462 {
463 printf("%s: %s\n", filename, strerror(errno));
464 return (1);
465 }
466
467 if ((ras = cupsRasterOpen(fd, CUPS_RASTER_READ)) == NULL)
468 {
469 printf("%s: cupsRasterOpen failed.\n", filename);
470 close(fd);
471 return (1);
472 }
473
474 printf("%s:\n", filename);
475
476 while (cupsRasterReadHeader2(ras, &header))
477 {
478 pages ++;
479 data = malloc(header.cupsBytesPerLine);
480
481 printf(" Page %u: %ux%ux%u@%ux%udpi", pages,
482 header.cupsWidth, header.cupsHeight, header.cupsBitsPerPixel,
483 header.HWResolution[0], header.HWResolution[1]);
484 fflush(stdout);
485
486 for (y = 0; y < header.cupsHeight; y ++)
487 if (cupsRasterReadPixels(ras, data, header.cupsBytesPerLine) <
488 header.cupsBytesPerLine)
489 break;
490
491 if (y < header.cupsHeight)
492 printf(" ERROR AT LINE %d\n", y);
493 else
494 putchar('\n');
495
496 free(data);
497 }
498
499 printf("EOF at %ld\n", (long)lseek(fd, SEEK_CUR, 0));
500
501 cupsRasterClose(ras);
502 close(fd);
503
504 return (errors);
505 }
506
507
508 /*
509 * 'do_raster_tests()' - Test reading and writing of raster data.
510 */
511
512 static int /* O - Number of errors */
do_raster_tests(cups_mode_t mode)513 do_raster_tests(cups_mode_t mode) /* O - Write mode */
514 {
515 unsigned page, x, y; /* Looping vars */
516 FILE *fp; /* Raster file */
517 cups_raster_t *r; /* Raster stream */
518 cups_page_header2_t header, /* Page header */
519 expected; /* Expected page header */
520 unsigned char data[2048]; /* Raster data */
521 int errors = 0; /* Number of errors */
522
523
524 /*
525 * Test writing...
526 */
527
528 printf("cupsRasterOpen(%s): ",
529 mode == CUPS_RASTER_WRITE ? "CUPS_RASTER_WRITE" :
530 mode == CUPS_RASTER_WRITE_COMPRESSED ? "CUPS_RASTER_WRITE_COMPRESSED" :
531 mode == CUPS_RASTER_WRITE_PWG ? "CUPS_RASTER_WRITE_PWG" :
532 "CUPS_RASTER_WRITE_APPLE");
533 fflush(stdout);
534
535 if ((fp = fopen("test.raster", "wb")) == NULL)
536 {
537 printf("FAIL (%s)\n", strerror(errno));
538 return (1);
539 }
540
541 if ((r = cupsRasterOpen(fileno(fp), mode)) == NULL)
542 {
543 printf("FAIL (%s)\n", strerror(errno));
544 fclose(fp);
545 return (1);
546 }
547
548 puts("PASS");
549
550 for (page = 0; page < 4; page ++)
551 {
552 memset(&header, 0, sizeof(header));
553 header.cupsWidth = 256;
554 header.cupsHeight = 256;
555 header.cupsBytesPerLine = 256;
556 header.HWResolution[0] = 64;
557 header.HWResolution[1] = 64;
558 header.PageSize[0] = 288;
559 header.PageSize[1] = 288;
560 header.cupsPageSize[0] = 288.0f;
561 header.cupsPageSize[1] = 288.0f;
562
563 if (page & 1)
564 {
565 header.cupsBytesPerLine *= 4;
566 header.cupsColorSpace = CUPS_CSPACE_CMYK;
567 header.cupsColorOrder = CUPS_ORDER_CHUNKED;
568 header.cupsNumColors = 4;
569 }
570 else
571 {
572 header.cupsColorSpace = CUPS_CSPACE_W;
573 header.cupsColorOrder = CUPS_ORDER_CHUNKED;
574 header.cupsNumColors = 1;
575 }
576
577 if (page & 2)
578 {
579 header.cupsBytesPerLine *= 2;
580 header.cupsBitsPerColor = 16;
581 header.cupsBitsPerPixel = (page & 1) ? 64 : 16;
582 }
583 else
584 {
585 header.cupsBitsPerColor = 8;
586 header.cupsBitsPerPixel = (page & 1) ? 32 : 8;
587 }
588
589 if (cupsRasterWriteHeader2(r, &header))
590 puts("cupsRasterWriteHeader2: PASS");
591 else
592 {
593 puts("cupsRasterWriteHeader2: FAIL");
594 errors ++;
595 }
596
597 fputs("cupsRasterWritePixels: ", stdout);
598 fflush(stdout);
599
600 memset(data, 0, header.cupsBytesPerLine);
601 for (y = 0; y < 64; y ++)
602 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
603 break;
604
605 if (y < 64)
606 {
607 puts("FAIL");
608 errors ++;
609 }
610 else
611 {
612 for (x = 0; x < header.cupsBytesPerLine; x ++)
613 data[x] = (unsigned char)x;
614
615 for (y = 0; y < 64; y ++)
616 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
617 break;
618
619 if (y < 64)
620 {
621 puts("FAIL");
622 errors ++;
623 }
624 else
625 {
626 memset(data, 255, header.cupsBytesPerLine);
627 for (y = 0; y < 64; y ++)
628 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
629 break;
630
631 if (y < 64)
632 {
633 puts("FAIL");
634 errors ++;
635 }
636 else
637 {
638 for (x = 0; x < header.cupsBytesPerLine; x ++)
639 data[x] = (unsigned char)(x / 4);
640
641 for (y = 0; y < 64; y ++)
642 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
643 break;
644
645 if (y < 64)
646 {
647 puts("FAIL");
648 errors ++;
649 }
650 else
651 puts("PASS");
652 }
653 }
654 }
655 }
656
657 cupsRasterClose(r);
658 fclose(fp);
659
660 /*
661 * Test reading...
662 */
663
664 fputs("cupsRasterOpen(CUPS_RASTER_READ): ", stdout);
665 fflush(stdout);
666
667 if ((fp = fopen("test.raster", "rb")) == NULL)
668 {
669 printf("FAIL (%s)\n", strerror(errno));
670 return (1);
671 }
672
673 if ((r = cupsRasterOpen(fileno(fp), CUPS_RASTER_READ)) == NULL)
674 {
675 printf("FAIL (%s)\n", strerror(errno));
676 fclose(fp);
677 return (1);
678 }
679
680 puts("PASS");
681
682 for (page = 0; page < 4; page ++)
683 {
684 memset(&expected, 0, sizeof(expected));
685 expected.cupsWidth = 256;
686 expected.cupsHeight = 256;
687 expected.cupsBytesPerLine = 256;
688 expected.HWResolution[0] = 64;
689 expected.HWResolution[1] = 64;
690 expected.PageSize[0] = 288;
691 expected.PageSize[1] = 288;
692
693 if (mode != CUPS_RASTER_WRITE_PWG)
694 {
695 expected.cupsPageSize[0] = 288.0f;
696 expected.cupsPageSize[1] = 288.0f;
697 }
698
699 if (mode >= CUPS_RASTER_WRITE_PWG)
700 {
701 strlcpy(expected.MediaClass, "PwgRaster", sizeof(expected.MediaClass));
702 expected.cupsInteger[7] = 0xffffff;
703 }
704
705 if (page & 1)
706 {
707 expected.cupsBytesPerLine *= 4;
708 expected.cupsColorSpace = CUPS_CSPACE_CMYK;
709 expected.cupsColorOrder = CUPS_ORDER_CHUNKED;
710 expected.cupsNumColors = 4;
711 }
712 else
713 {
714 expected.cupsColorSpace = CUPS_CSPACE_W;
715 expected.cupsColorOrder = CUPS_ORDER_CHUNKED;
716 expected.cupsNumColors = 1;
717 }
718
719 if (page & 2)
720 {
721 expected.cupsBytesPerLine *= 2;
722 expected.cupsBitsPerColor = 16;
723 expected.cupsBitsPerPixel = (page & 1) ? 64 : 16;
724 }
725 else
726 {
727 expected.cupsBitsPerColor = 8;
728 expected.cupsBitsPerPixel = (page & 1) ? 32 : 8;
729 }
730
731 fputs("cupsRasterReadHeader2: ", stdout);
732 fflush(stdout);
733
734 if (!cupsRasterReadHeader2(r, &header))
735 {
736 puts("FAIL (read error)");
737 errors ++;
738 break;
739 }
740
741 if (memcmp(&header, &expected, sizeof(header)))
742 {
743 puts("FAIL (bad page header)");
744 errors ++;
745 print_changes(&header, &expected);
746 }
747
748 fputs("cupsRasterReadPixels: ", stdout);
749 fflush(stdout);
750
751 for (y = 0; y < 64; y ++)
752 {
753 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
754 {
755 puts("FAIL (read error)");
756 errors ++;
757 break;
758 }
759
760 if (data[0] != 0 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
761 {
762 printf("FAIL (raster line %d corrupt)\n", y);
763 errors ++;
764 break;
765 }
766 }
767
768 if (y == 64)
769 {
770 for (y = 0; y < 64; y ++)
771 {
772 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
773 {
774 puts("FAIL (read error)");
775 errors ++;
776 break;
777 }
778
779 for (x = 0; x < header.cupsBytesPerLine; x ++)
780 if (data[x] != (x & 255))
781 break;
782
783 if (x < header.cupsBytesPerLine)
784 {
785 printf("FAIL (raster line %d corrupt)\n", y + 64);
786 errors ++;
787 break;
788 }
789 }
790
791 if (y == 64)
792 {
793 for (y = 0; y < 64; y ++)
794 {
795 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
796 {
797 puts("FAIL (read error)");
798 errors ++;
799 break;
800 }
801
802 if (data[0] != 255 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
803 {
804 printf("fail (raster line %d corrupt)\n", y + 128);
805 errors ++;
806 break;
807 }
808 }
809
810 if (y == 64)
811 {
812 for (y = 0; y < 64; y ++)
813 {
814 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
815 {
816 puts("FAIL (read error)");
817 errors ++;
818 break;
819 }
820
821 for (x = 0; x < header.cupsBytesPerLine; x ++)
822 if (data[x] != ((x / 4) & 255))
823 break;
824
825 if (x < header.cupsBytesPerLine)
826 {
827 printf("FAIL (raster line %d corrupt)\n", y + 192);
828 errors ++;
829 break;
830 }
831 }
832
833 if (y == 64)
834 puts("PASS");
835 }
836 }
837 }
838 }
839
840 cupsRasterClose(r);
841 fclose(fp);
842
843 return (errors);
844 }
845
846
847 /*
848 * 'print_changes()' - Print differences in the page header.
849 */
850
851 static void
print_changes(cups_page_header2_t * header,cups_page_header2_t * expected)852 print_changes(
853 cups_page_header2_t *header, /* I - Actual page header */
854 cups_page_header2_t *expected) /* I - Expected page header */
855 {
856 int i; /* Looping var */
857
858
859 if (strcmp(header->MediaClass, expected->MediaClass))
860 printf(" MediaClass (%s), expected (%s)\n", header->MediaClass,
861 expected->MediaClass);
862
863 if (strcmp(header->MediaColor, expected->MediaColor))
864 printf(" MediaColor (%s), expected (%s)\n", header->MediaColor,
865 expected->MediaColor);
866
867 if (strcmp(header->MediaType, expected->MediaType))
868 printf(" MediaType (%s), expected (%s)\n", header->MediaType,
869 expected->MediaType);
870
871 if (strcmp(header->OutputType, expected->OutputType))
872 printf(" OutputType (%s), expected (%s)\n", header->OutputType,
873 expected->OutputType);
874
875 if (header->AdvanceDistance != expected->AdvanceDistance)
876 printf(" AdvanceDistance %d, expected %d\n", header->AdvanceDistance,
877 expected->AdvanceDistance);
878
879 if (header->AdvanceMedia != expected->AdvanceMedia)
880 printf(" AdvanceMedia %d, expected %d\n", header->AdvanceMedia,
881 expected->AdvanceMedia);
882
883 if (header->Collate != expected->Collate)
884 printf(" Collate %d, expected %d\n", header->Collate,
885 expected->Collate);
886
887 if (header->CutMedia != expected->CutMedia)
888 printf(" CutMedia %d, expected %d\n", header->CutMedia,
889 expected->CutMedia);
890
891 if (header->Duplex != expected->Duplex)
892 printf(" Duplex %d, expected %d\n", header->Duplex,
893 expected->Duplex);
894
895 if (header->HWResolution[0] != expected->HWResolution[0] ||
896 header->HWResolution[1] != expected->HWResolution[1])
897 printf(" HWResolution [%d %d], expected [%d %d]\n",
898 header->HWResolution[0], header->HWResolution[1],
899 expected->HWResolution[0], expected->HWResolution[1]);
900
901 if (memcmp(header->ImagingBoundingBox, expected->ImagingBoundingBox,
902 sizeof(header->ImagingBoundingBox)))
903 printf(" ImagingBoundingBox [%d %d %d %d], expected [%d %d %d %d]\n",
904 header->ImagingBoundingBox[0],
905 header->ImagingBoundingBox[1],
906 header->ImagingBoundingBox[2],
907 header->ImagingBoundingBox[3],
908 expected->ImagingBoundingBox[0],
909 expected->ImagingBoundingBox[1],
910 expected->ImagingBoundingBox[2],
911 expected->ImagingBoundingBox[3]);
912
913 if (header->InsertSheet != expected->InsertSheet)
914 printf(" InsertSheet %d, expected %d\n", header->InsertSheet,
915 expected->InsertSheet);
916
917 if (header->Jog != expected->Jog)
918 printf(" Jog %d, expected %d\n", header->Jog,
919 expected->Jog);
920
921 if (header->LeadingEdge != expected->LeadingEdge)
922 printf(" LeadingEdge %d, expected %d\n", header->LeadingEdge,
923 expected->LeadingEdge);
924
925 if (header->Margins[0] != expected->Margins[0] ||
926 header->Margins[1] != expected->Margins[1])
927 printf(" Margins [%d %d], expected [%d %d]\n",
928 header->Margins[0], header->Margins[1],
929 expected->Margins[0], expected->Margins[1]);
930
931 if (header->ManualFeed != expected->ManualFeed)
932 printf(" ManualFeed %d, expected %d\n", header->ManualFeed,
933 expected->ManualFeed);
934
935 if (header->MediaPosition != expected->MediaPosition)
936 printf(" MediaPosition %d, expected %d\n", header->MediaPosition,
937 expected->MediaPosition);
938
939 if (header->MediaWeight != expected->MediaWeight)
940 printf(" MediaWeight %d, expected %d\n", header->MediaWeight,
941 expected->MediaWeight);
942
943 if (header->MirrorPrint != expected->MirrorPrint)
944 printf(" MirrorPrint %d, expected %d\n", header->MirrorPrint,
945 expected->MirrorPrint);
946
947 if (header->NegativePrint != expected->NegativePrint)
948 printf(" NegativePrint %d, expected %d\n", header->NegativePrint,
949 expected->NegativePrint);
950
951 if (header->NumCopies != expected->NumCopies)
952 printf(" NumCopies %d, expected %d\n", header->NumCopies,
953 expected->NumCopies);
954
955 if (header->Orientation != expected->Orientation)
956 printf(" Orientation %d, expected %d\n", header->Orientation,
957 expected->Orientation);
958
959 if (header->OutputFaceUp != expected->OutputFaceUp)
960 printf(" OutputFaceUp %d, expected %d\n", header->OutputFaceUp,
961 expected->OutputFaceUp);
962
963 if (header->PageSize[0] != expected->PageSize[0] ||
964 header->PageSize[1] != expected->PageSize[1])
965 printf(" PageSize [%d %d], expected [%d %d]\n",
966 header->PageSize[0], header->PageSize[1],
967 expected->PageSize[0], expected->PageSize[1]);
968
969 if (header->Separations != expected->Separations)
970 printf(" Separations %d, expected %d\n", header->Separations,
971 expected->Separations);
972
973 if (header->TraySwitch != expected->TraySwitch)
974 printf(" TraySwitch %d, expected %d\n", header->TraySwitch,
975 expected->TraySwitch);
976
977 if (header->Tumble != expected->Tumble)
978 printf(" Tumble %d, expected %d\n", header->Tumble,
979 expected->Tumble);
980
981 if (header->cupsWidth != expected->cupsWidth)
982 printf(" cupsWidth %d, expected %d\n", header->cupsWidth,
983 expected->cupsWidth);
984
985 if (header->cupsHeight != expected->cupsHeight)
986 printf(" cupsHeight %d, expected %d\n", header->cupsHeight,
987 expected->cupsHeight);
988
989 if (header->cupsMediaType != expected->cupsMediaType)
990 printf(" cupsMediaType %d, expected %d\n", header->cupsMediaType,
991 expected->cupsMediaType);
992
993 if (header->cupsBitsPerColor != expected->cupsBitsPerColor)
994 printf(" cupsBitsPerColor %d, expected %d\n", header->cupsBitsPerColor,
995 expected->cupsBitsPerColor);
996
997 if (header->cupsBitsPerPixel != expected->cupsBitsPerPixel)
998 printf(" cupsBitsPerPixel %d, expected %d\n", header->cupsBitsPerPixel,
999 expected->cupsBitsPerPixel);
1000
1001 if (header->cupsBytesPerLine != expected->cupsBytesPerLine)
1002 printf(" cupsBytesPerLine %d, expected %d\n", header->cupsBytesPerLine,
1003 expected->cupsBytesPerLine);
1004
1005 if (header->cupsColorOrder != expected->cupsColorOrder)
1006 printf(" cupsColorOrder %d, expected %d\n", header->cupsColorOrder,
1007 expected->cupsColorOrder);
1008
1009 if (header->cupsColorSpace != expected->cupsColorSpace)
1010 printf(" cupsColorSpace %d, expected %d\n", header->cupsColorSpace,
1011 expected->cupsColorSpace);
1012
1013 if (header->cupsCompression != expected->cupsCompression)
1014 printf(" cupsCompression %d, expected %d\n", header->cupsCompression,
1015 expected->cupsCompression);
1016
1017 if (header->cupsRowCount != expected->cupsRowCount)
1018 printf(" cupsRowCount %d, expected %d\n", header->cupsRowCount,
1019 expected->cupsRowCount);
1020
1021 if (header->cupsRowFeed != expected->cupsRowFeed)
1022 printf(" cupsRowFeed %d, expected %d\n", header->cupsRowFeed,
1023 expected->cupsRowFeed);
1024
1025 if (header->cupsRowStep != expected->cupsRowStep)
1026 printf(" cupsRowStep %d, expected %d\n", header->cupsRowStep,
1027 expected->cupsRowStep);
1028
1029 if (header->cupsNumColors != expected->cupsNumColors)
1030 printf(" cupsNumColors %d, expected %d\n", header->cupsNumColors,
1031 expected->cupsNumColors);
1032
1033 if (fabs(header->cupsBorderlessScalingFactor - expected->cupsBorderlessScalingFactor) > 0.001)
1034 printf(" cupsBorderlessScalingFactor %g, expected %g\n",
1035 header->cupsBorderlessScalingFactor,
1036 expected->cupsBorderlessScalingFactor);
1037
1038 if (fabs(header->cupsPageSize[0] - expected->cupsPageSize[0]) > 0.001 ||
1039 fabs(header->cupsPageSize[1] - expected->cupsPageSize[1]) > 0.001)
1040 printf(" cupsPageSize [%g %g], expected [%g %g]\n",
1041 header->cupsPageSize[0], header->cupsPageSize[1],
1042 expected->cupsPageSize[0], expected->cupsPageSize[1]);
1043
1044 if (fabs(header->cupsImagingBBox[0] - expected->cupsImagingBBox[0]) > 0.001 ||
1045 fabs(header->cupsImagingBBox[1] - expected->cupsImagingBBox[1]) > 0.001 ||
1046 fabs(header->cupsImagingBBox[2] - expected->cupsImagingBBox[2]) > 0.001 ||
1047 fabs(header->cupsImagingBBox[3] - expected->cupsImagingBBox[3]) > 0.001)
1048 printf(" cupsImagingBBox [%g %g %g %g], expected [%g %g %g %g]\n",
1049 header->cupsImagingBBox[0], header->cupsImagingBBox[1],
1050 header->cupsImagingBBox[2], header->cupsImagingBBox[3],
1051 expected->cupsImagingBBox[0], expected->cupsImagingBBox[1],
1052 expected->cupsImagingBBox[2], expected->cupsImagingBBox[3]);
1053
1054 for (i = 0; i < 16; i ++)
1055 if (header->cupsInteger[i] != expected->cupsInteger[i])
1056 printf(" cupsInteger%d %d, expected %d\n", i, header->cupsInteger[i],
1057 expected->cupsInteger[i]);
1058
1059 for (i = 0; i < 16; i ++)
1060 if (fabs(header->cupsReal[i] - expected->cupsReal[i]) > 0.001)
1061 printf(" cupsReal%d %g, expected %g\n", i, header->cupsReal[i],
1062 expected->cupsReal[i]);
1063
1064 for (i = 0; i < 16; i ++)
1065 if (strcmp(header->cupsString[i], expected->cupsString[i]))
1066 printf(" cupsString%d (%s), expected (%s)\n", i,
1067 header->cupsString[i], expected->cupsString[i]);
1068
1069 if (strcmp(header->cupsMarkerType, expected->cupsMarkerType))
1070 printf(" cupsMarkerType (%s), expected (%s)\n", header->cupsMarkerType,
1071 expected->cupsMarkerType);
1072
1073 if (strcmp(header->cupsRenderingIntent, expected->cupsRenderingIntent))
1074 printf(" cupsRenderingIntent (%s), expected (%s)\n",
1075 header->cupsRenderingIntent,
1076 expected->cupsRenderingIntent);
1077
1078 if (strcmp(header->cupsPageSizeName, expected->cupsPageSizeName))
1079 printf(" cupsPageSizeName (%s), expected (%s)\n",
1080 header->cupsPageSizeName,
1081 expected->cupsPageSizeName);
1082 }
1083