1 /*
2 * Raster test program routines for CUPS.
3 *
4 * Copyright © 2020-2024 by OpenPrinting.
5 * Copyright © 2007-2019 by Apple Inc.
6 * Copyright © 1997-2007 by Easy Software Products.
7 *
8 * Licensed under Apache License v2.0. See the file "LICENSE" for more
9 * information.
10 */
11
12 /*
13 * Include necessary headers...
14 */
15
16 #include <cups/raster-private.h>
17 #include <math.h>
18
19
20 /*
21 * Local functions...
22 */
23
24 static int do_ras_file(const char *filename);
25 static int do_raster_tests(cups_mode_t mode);
26 static void print_changes(cups_page_header2_t *header, cups_page_header2_t *expected);
27
28
29 /*
30 * 'main()' - Test the raster functions.
31 */
32
33 int /* O - Exit status */
main(int argc,char * argv[])34 main(int argc, /* I - Number of command-line args */
35 char *argv[]) /* I - Command-line arguments */
36 {
37 int errors = 0; /* Number of errors */
38
39
40 if (argc == 1)
41 {
42 errors += do_raster_tests(CUPS_RASTER_WRITE);
43 errors += do_raster_tests(CUPS_RASTER_WRITE_COMPRESSED);
44 errors += do_raster_tests(CUPS_RASTER_WRITE_PWG);
45 errors += do_raster_tests(CUPS_RASTER_WRITE_APPLE);
46 }
47 else
48 {
49 int i; /* Looping var */
50
51 for (i = 1; i < argc; i ++)
52 errors += do_ras_file(argv[i]);
53 }
54
55 return (errors);
56 }
57
58
59 /*
60 * 'do_ras_file()' - Test reading of a raster file.
61 */
62
63 static int /* O - Number of errors */
do_ras_file(const char * filename)64 do_ras_file(const char *filename) /* I - Filename */
65 {
66 unsigned y; /* Looping vars */
67 int fd; /* File descriptor */
68 cups_raster_t *ras; /* Raster stream */
69 cups_page_header2_t header; /* Page header */
70 unsigned char *data; /* Raster data */
71 int errors = 0; /* Number of errors */
72 unsigned pages = 0; /* Number of pages */
73
74
75 if ((fd = open(filename, O_RDONLY)) < 0)
76 {
77 printf("%s: %s\n", filename, strerror(errno));
78 return (1);
79 }
80
81 if ((ras = cupsRasterOpen(fd, CUPS_RASTER_READ)) == NULL)
82 {
83 printf("%s: cupsRasterOpen failed.\n", filename);
84 close(fd);
85 return (1);
86 }
87
88 printf("%s:\n", filename);
89
90 while (cupsRasterReadHeader2(ras, &header))
91 {
92 pages ++;
93 data = malloc(header.cupsBytesPerLine);
94
95 printf(" Page %u: %ux%ux%u@%ux%udpi", pages,
96 header.cupsWidth, header.cupsHeight, header.cupsBitsPerPixel,
97 header.HWResolution[0], header.HWResolution[1]);
98 fflush(stdout);
99
100 for (y = 0; y < header.cupsHeight; y ++)
101 if (cupsRasterReadPixels(ras, data, header.cupsBytesPerLine) <
102 header.cupsBytesPerLine)
103 break;
104
105 if (y < header.cupsHeight)
106 printf(" ERROR AT LINE %d\n", y);
107 else
108 putchar('\n');
109
110 free(data);
111 }
112
113 printf("EOF at %ld\n", (long)lseek(fd, SEEK_CUR, 0));
114
115 cupsRasterClose(ras);
116 close(fd);
117
118 return (errors);
119 }
120
121
122 /*
123 * 'do_raster_tests()' - Test reading and writing of raster data.
124 */
125
126 static int /* O - Number of errors */
do_raster_tests(cups_mode_t mode)127 do_raster_tests(cups_mode_t mode) /* O - Write mode */
128 {
129 unsigned page, x, y, count;/* Looping vars */
130 FILE *fp; /* Raster file */
131 cups_raster_t *r; /* Raster stream */
132 cups_page_header2_t header, /* Page header */
133 expected; /* Expected page header */
134 unsigned char data[2048]; /* Raster data */
135 int errors = 0; /* Number of errors */
136
137
138 /*
139 * Test writing...
140 */
141
142 printf("cupsRasterOpen(%s): ",
143 mode == CUPS_RASTER_WRITE ? "CUPS_RASTER_WRITE" :
144 mode == CUPS_RASTER_WRITE_COMPRESSED ? "CUPS_RASTER_WRITE_COMPRESSED" :
145 mode == CUPS_RASTER_WRITE_PWG ? "CUPS_RASTER_WRITE_PWG" :
146 "CUPS_RASTER_WRITE_APPLE");
147 fflush(stdout);
148
149 if ((fp = fopen("test.raster", "wb")) == NULL)
150 {
151 printf("FAIL (%s)\n", strerror(errno));
152 return (1);
153 }
154
155 if ((r = cupsRasterOpen(fileno(fp), mode)) == NULL)
156 {
157 printf("FAIL (%s)\n", strerror(errno));
158 fclose(fp);
159 return (1);
160 }
161
162 puts("PASS");
163
164 for (page = 0; page < 4; page ++)
165 {
166 memset(&header, 0, sizeof(header));
167 header.cupsWidth = 256;
168 header.cupsHeight = 256;
169 header.cupsBytesPerLine = 256;
170 header.HWResolution[0] = 64;
171 header.HWResolution[1] = 64;
172 header.PageSize[0] = 288;
173 header.PageSize[1] = 288;
174 header.cupsPageSize[0] = 288.0f;
175 header.cupsPageSize[1] = 288.0f;
176
177 strlcpy(header.MediaType, "auto", sizeof(header.MediaType));
178
179 if (page & 1)
180 {
181 header.cupsBytesPerLine *= 4;
182 header.cupsColorSpace = CUPS_CSPACE_CMYK;
183 header.cupsColorOrder = CUPS_ORDER_CHUNKED;
184 header.cupsNumColors = 4;
185 }
186 else
187 {
188 header.cupsColorSpace = CUPS_CSPACE_W;
189 header.cupsColorOrder = CUPS_ORDER_CHUNKED;
190 header.cupsNumColors = 1;
191 }
192
193 if (page & 2)
194 {
195 header.cupsBytesPerLine *= 2;
196 header.cupsBitsPerColor = 16;
197 header.cupsBitsPerPixel = (page & 1) ? 64 : 16;
198 }
199 else
200 {
201 header.cupsBitsPerColor = 8;
202 header.cupsBitsPerPixel = (page & 1) ? 32 : 8;
203 }
204
205 printf("cupsRasterWriteHeader2(page %d): ", page + 1);
206
207 if (cupsRasterWriteHeader2(r, &header))
208 {
209 puts("PASS");
210 }
211 else
212 {
213 puts("FAIL");
214 errors ++;
215 }
216
217 fputs("cupsRasterWritePixels: ", stdout);
218 fflush(stdout);
219
220 memset(data, 0, header.cupsBytesPerLine);
221 for (y = 0; y < 64; y ++)
222 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
223 break;
224
225 if (y < 64)
226 {
227 puts("FAIL");
228 errors ++;
229 }
230 else
231 {
232 for (x = 0; x < header.cupsBytesPerLine; x ++)
233 data[x] = (unsigned char)x;
234
235 for (y = 0; y < 64; y ++)
236 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
237 break;
238
239 if (y < 64)
240 {
241 puts("FAIL");
242 errors ++;
243 }
244 else
245 {
246 memset(data, 255, header.cupsBytesPerLine);
247 for (y = 0; y < 64; y ++)
248 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
249 break;
250
251 if (y < 64)
252 {
253 puts("FAIL");
254 errors ++;
255 }
256 else
257 {
258 for (x = 0; x < header.cupsBytesPerLine; x ++)
259 data[x] = (unsigned char)(x / 4);
260
261 for (y = 0; y < 64; y ++)
262 if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
263 break;
264
265 if (y < 64)
266 {
267 puts("FAIL");
268 errors ++;
269 }
270 else
271 puts("PASS");
272 }
273 }
274 }
275 }
276
277 cupsRasterClose(r);
278 fclose(fp);
279
280 /*
281 * Test reading...
282 */
283
284 fputs("cupsRasterOpen(CUPS_RASTER_READ): ", stdout);
285 fflush(stdout);
286
287 if ((fp = fopen("test.raster", "rb")) == NULL)
288 {
289 printf("FAIL (%s)\n", strerror(errno));
290 return (1);
291 }
292
293 if ((r = cupsRasterOpen(fileno(fp), CUPS_RASTER_READ)) == NULL)
294 {
295 printf("FAIL (%s)\n", strerror(errno));
296 fclose(fp);
297 return (1);
298 }
299
300 puts("PASS");
301
302 for (page = 0; page < 4; page ++)
303 {
304 memset(&expected, 0, sizeof(expected));
305 expected.cupsWidth = 256;
306 expected.cupsHeight = 256;
307 expected.cupsBytesPerLine = 256;
308 expected.HWResolution[0] = 64;
309 expected.HWResolution[1] = 64;
310 expected.PageSize[0] = 288;
311 expected.PageSize[1] = 288;
312
313 strlcpy(expected.MediaType, "auto", sizeof(expected.MediaType));
314
315 if (mode != CUPS_RASTER_WRITE_PWG)
316 {
317 expected.cupsPageSize[0] = 288.0f;
318 expected.cupsPageSize[1] = 288.0f;
319 }
320
321 if (mode >= CUPS_RASTER_WRITE_PWG)
322 {
323 strlcpy(expected.MediaClass, "PwgRaster", sizeof(expected.MediaClass));
324 expected.cupsInteger[7] = 0xffffff;
325 }
326
327 if (page & 1)
328 {
329 expected.cupsBytesPerLine *= 4;
330 expected.cupsColorSpace = CUPS_CSPACE_CMYK;
331 expected.cupsColorOrder = CUPS_ORDER_CHUNKED;
332 expected.cupsNumColors = 4;
333 }
334 else
335 {
336 expected.cupsColorSpace = CUPS_CSPACE_W;
337 expected.cupsColorOrder = CUPS_ORDER_CHUNKED;
338 expected.cupsNumColors = 1;
339 }
340
341 if (page & 2)
342 {
343 expected.cupsBytesPerLine *= 2;
344 expected.cupsBitsPerColor = 16;
345 expected.cupsBitsPerPixel = (page & 1) ? 64 : 16;
346 }
347 else
348 {
349 expected.cupsBitsPerColor = 8;
350 expected.cupsBitsPerPixel = (page & 1) ? 32 : 8;
351 }
352
353 printf("cupsRasterReadHeader2(page %d): ", page + 1);
354 fflush(stdout);
355
356 if (!cupsRasterReadHeader2(r, &header))
357 {
358 puts("FAIL (read error)");
359 errors ++;
360 break;
361 }
362 else if (memcmp(&header, &expected, sizeof(header)))
363 {
364 puts("FAIL (bad page header)");
365 errors ++;
366 print_changes(&header, &expected);
367 }
368 else
369 puts("PASS");
370
371 fputs("cupsRasterReadPixels: ", stdout);
372 fflush(stdout);
373
374 for (y = 0; y < 64; y ++)
375 {
376 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
377 {
378 puts("FAIL (read error)");
379 errors ++;
380 break;
381 }
382
383 if (data[0] != 0 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
384 {
385 printf("FAIL (raster line %d corrupt)\n", y);
386
387 for (x = 0, count = 0; x < header.cupsBytesPerLine && count < 10; x ++)
388 {
389 if (data[x])
390 {
391 count ++;
392
393 if (count == 10)
394 puts(" ...");
395 else
396 printf(" %4u %02X (expected %02X)\n", x, data[x], 0);
397 }
398 }
399
400 errors ++;
401 break;
402 }
403 }
404
405 if (y == 64)
406 {
407 for (y = 0; y < 64; y ++)
408 {
409 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
410 {
411 puts("FAIL (read error)");
412 errors ++;
413 break;
414 }
415
416 for (x = 0; x < header.cupsBytesPerLine; x ++)
417 if (data[x] != (x & 255))
418 break;
419
420 if (x < header.cupsBytesPerLine)
421 {
422 printf("FAIL (raster line %d corrupt)\n", y + 64);
423
424 for (x = 0, count = 0; x < header.cupsBytesPerLine && count < 10; x ++)
425 {
426 if (data[x] != (x & 255))
427 {
428 count ++;
429
430 if (count == 10)
431 puts(" ...");
432 else
433 printf(" %4u %02X (expected %02X)\n", x, data[x], x & 255);
434 }
435 }
436
437 errors ++;
438 break;
439 }
440 }
441
442 if (y == 64)
443 {
444 for (y = 0; y < 64; y ++)
445 {
446 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
447 {
448 puts("FAIL (read error)");
449 errors ++;
450 break;
451 }
452
453 if (data[0] != 255 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
454 {
455 printf("fail (raster line %d corrupt)\n", y + 128);
456
457 for (x = 0, count = 0; x < header.cupsBytesPerLine && count < 10; x ++)
458 {
459 if (data[x] != 255)
460 {
461 count ++;
462
463 if (count == 10)
464 puts(" ...");
465 else
466 printf(" %4u %02X (expected %02X)\n", x, data[x], 255);
467 }
468 }
469
470 errors ++;
471 break;
472 }
473 }
474
475 if (y == 64)
476 {
477 for (y = 0; y < 64; y ++)
478 {
479 if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
480 {
481 puts("FAIL (read error)");
482 errors ++;
483 break;
484 }
485
486 for (x = 0; x < header.cupsBytesPerLine; x ++)
487 if (data[x] != ((x / 4) & 255))
488 break;
489
490 if (x < header.cupsBytesPerLine)
491 {
492 printf("FAIL (raster line %d corrupt)\n", y + 192);
493
494 for (x = 0, count = 0; x < header.cupsBytesPerLine && count < 10; x ++)
495 {
496 if (data[x] != ((x / 4) & 255))
497 {
498 count ++;
499
500 if (count == 10)
501 puts(" ...");
502 else
503 printf(" %4u %02X (expected %02X)\n", x, data[x], (x / 4) & 255);
504 }
505 }
506
507 errors ++;
508 break;
509 }
510 }
511
512 if (y == 64)
513 puts("PASS");
514 }
515 }
516 }
517 }
518
519 cupsRasterClose(r);
520 fclose(fp);
521
522 return (errors);
523 }
524
525
526 /*
527 * 'print_changes()' - Print differences in the page header.
528 */
529
530 static void
print_changes(cups_page_header2_t * header,cups_page_header2_t * expected)531 print_changes(
532 cups_page_header2_t *header, /* I - Actual page header */
533 cups_page_header2_t *expected) /* I - Expected page header */
534 {
535 int i; /* Looping var */
536
537
538 if (strcmp(header->MediaClass, expected->MediaClass))
539 printf(" MediaClass (%s), expected (%s)\n", header->MediaClass,
540 expected->MediaClass);
541
542 if (strcmp(header->MediaColor, expected->MediaColor))
543 printf(" MediaColor (%s), expected (%s)\n", header->MediaColor,
544 expected->MediaColor);
545
546 if (strcmp(header->MediaType, expected->MediaType))
547 printf(" MediaType (%s), expected (%s)\n", header->MediaType,
548 expected->MediaType);
549
550 if (strcmp(header->OutputType, expected->OutputType))
551 printf(" OutputType (%s), expected (%s)\n", header->OutputType,
552 expected->OutputType);
553
554 if (header->AdvanceDistance != expected->AdvanceDistance)
555 printf(" AdvanceDistance %d, expected %d\n", header->AdvanceDistance,
556 expected->AdvanceDistance);
557
558 if (header->AdvanceMedia != expected->AdvanceMedia)
559 printf(" AdvanceMedia %d, expected %d\n", header->AdvanceMedia,
560 expected->AdvanceMedia);
561
562 if (header->Collate != expected->Collate)
563 printf(" Collate %d, expected %d\n", header->Collate,
564 expected->Collate);
565
566 if (header->CutMedia != expected->CutMedia)
567 printf(" CutMedia %d, expected %d\n", header->CutMedia,
568 expected->CutMedia);
569
570 if (header->Duplex != expected->Duplex)
571 printf(" Duplex %d, expected %d\n", header->Duplex,
572 expected->Duplex);
573
574 if (header->HWResolution[0] != expected->HWResolution[0] ||
575 header->HWResolution[1] != expected->HWResolution[1])
576 printf(" HWResolution [%d %d], expected [%d %d]\n",
577 header->HWResolution[0], header->HWResolution[1],
578 expected->HWResolution[0], expected->HWResolution[1]);
579
580 if (memcmp(header->ImagingBoundingBox, expected->ImagingBoundingBox,
581 sizeof(header->ImagingBoundingBox)))
582 printf(" ImagingBoundingBox [%d %d %d %d], expected [%d %d %d %d]\n",
583 header->ImagingBoundingBox[0],
584 header->ImagingBoundingBox[1],
585 header->ImagingBoundingBox[2],
586 header->ImagingBoundingBox[3],
587 expected->ImagingBoundingBox[0],
588 expected->ImagingBoundingBox[1],
589 expected->ImagingBoundingBox[2],
590 expected->ImagingBoundingBox[3]);
591
592 if (header->InsertSheet != expected->InsertSheet)
593 printf(" InsertSheet %d, expected %d\n", header->InsertSheet,
594 expected->InsertSheet);
595
596 if (header->Jog != expected->Jog)
597 printf(" Jog %d, expected %d\n", header->Jog,
598 expected->Jog);
599
600 if (header->LeadingEdge != expected->LeadingEdge)
601 printf(" LeadingEdge %d, expected %d\n", header->LeadingEdge,
602 expected->LeadingEdge);
603
604 if (header->Margins[0] != expected->Margins[0] ||
605 header->Margins[1] != expected->Margins[1])
606 printf(" Margins [%d %d], expected [%d %d]\n",
607 header->Margins[0], header->Margins[1],
608 expected->Margins[0], expected->Margins[1]);
609
610 if (header->ManualFeed != expected->ManualFeed)
611 printf(" ManualFeed %d, expected %d\n", header->ManualFeed,
612 expected->ManualFeed);
613
614 if (header->MediaPosition != expected->MediaPosition)
615 printf(" MediaPosition %d, expected %d\n", header->MediaPosition,
616 expected->MediaPosition);
617
618 if (header->MediaWeight != expected->MediaWeight)
619 printf(" MediaWeight %d, expected %d\n", header->MediaWeight,
620 expected->MediaWeight);
621
622 if (header->MirrorPrint != expected->MirrorPrint)
623 printf(" MirrorPrint %d, expected %d\n", header->MirrorPrint,
624 expected->MirrorPrint);
625
626 if (header->NegativePrint != expected->NegativePrint)
627 printf(" NegativePrint %d, expected %d\n", header->NegativePrint,
628 expected->NegativePrint);
629
630 if (header->NumCopies != expected->NumCopies)
631 printf(" NumCopies %d, expected %d\n", header->NumCopies,
632 expected->NumCopies);
633
634 if (header->Orientation != expected->Orientation)
635 printf(" Orientation %d, expected %d\n", header->Orientation,
636 expected->Orientation);
637
638 if (header->OutputFaceUp != expected->OutputFaceUp)
639 printf(" OutputFaceUp %d, expected %d\n", header->OutputFaceUp,
640 expected->OutputFaceUp);
641
642 if (header->PageSize[0] != expected->PageSize[0] ||
643 header->PageSize[1] != expected->PageSize[1])
644 printf(" PageSize [%d %d], expected [%d %d]\n",
645 header->PageSize[0], header->PageSize[1],
646 expected->PageSize[0], expected->PageSize[1]);
647
648 if (header->Separations != expected->Separations)
649 printf(" Separations %d, expected %d\n", header->Separations,
650 expected->Separations);
651
652 if (header->TraySwitch != expected->TraySwitch)
653 printf(" TraySwitch %d, expected %d\n", header->TraySwitch,
654 expected->TraySwitch);
655
656 if (header->Tumble != expected->Tumble)
657 printf(" Tumble %d, expected %d\n", header->Tumble,
658 expected->Tumble);
659
660 if (header->cupsWidth != expected->cupsWidth)
661 printf(" cupsWidth %d, expected %d\n", header->cupsWidth,
662 expected->cupsWidth);
663
664 if (header->cupsHeight != expected->cupsHeight)
665 printf(" cupsHeight %d, expected %d\n", header->cupsHeight,
666 expected->cupsHeight);
667
668 if (header->cupsMediaType != expected->cupsMediaType)
669 printf(" cupsMediaType %d, expected %d\n", header->cupsMediaType,
670 expected->cupsMediaType);
671
672 if (header->cupsBitsPerColor != expected->cupsBitsPerColor)
673 printf(" cupsBitsPerColor %d, expected %d\n", header->cupsBitsPerColor,
674 expected->cupsBitsPerColor);
675
676 if (header->cupsBitsPerPixel != expected->cupsBitsPerPixel)
677 printf(" cupsBitsPerPixel %d, expected %d\n", header->cupsBitsPerPixel,
678 expected->cupsBitsPerPixel);
679
680 if (header->cupsBytesPerLine != expected->cupsBytesPerLine)
681 printf(" cupsBytesPerLine %d, expected %d\n", header->cupsBytesPerLine,
682 expected->cupsBytesPerLine);
683
684 if (header->cupsColorOrder != expected->cupsColorOrder)
685 printf(" cupsColorOrder %d, expected %d\n", header->cupsColorOrder,
686 expected->cupsColorOrder);
687
688 if (header->cupsColorSpace != expected->cupsColorSpace)
689 printf(" cupsColorSpace %d, expected %d\n", header->cupsColorSpace,
690 expected->cupsColorSpace);
691
692 if (header->cupsCompression != expected->cupsCompression)
693 printf(" cupsCompression %d, expected %d\n", header->cupsCompression,
694 expected->cupsCompression);
695
696 if (header->cupsRowCount != expected->cupsRowCount)
697 printf(" cupsRowCount %d, expected %d\n", header->cupsRowCount,
698 expected->cupsRowCount);
699
700 if (header->cupsRowFeed != expected->cupsRowFeed)
701 printf(" cupsRowFeed %d, expected %d\n", header->cupsRowFeed,
702 expected->cupsRowFeed);
703
704 if (header->cupsRowStep != expected->cupsRowStep)
705 printf(" cupsRowStep %d, expected %d\n", header->cupsRowStep,
706 expected->cupsRowStep);
707
708 if (header->cupsNumColors != expected->cupsNumColors)
709 printf(" cupsNumColors %d, expected %d\n", header->cupsNumColors,
710 expected->cupsNumColors);
711
712 if (fabs(header->cupsBorderlessScalingFactor - expected->cupsBorderlessScalingFactor) > 0.001)
713 printf(" cupsBorderlessScalingFactor %g, expected %g\n",
714 header->cupsBorderlessScalingFactor,
715 expected->cupsBorderlessScalingFactor);
716
717 if (fabs(header->cupsPageSize[0] - expected->cupsPageSize[0]) > 0.001 ||
718 fabs(header->cupsPageSize[1] - expected->cupsPageSize[1]) > 0.001)
719 printf(" cupsPageSize [%g %g], expected [%g %g]\n",
720 header->cupsPageSize[0], header->cupsPageSize[1],
721 expected->cupsPageSize[0], expected->cupsPageSize[1]);
722
723 if (fabs(header->cupsImagingBBox[0] - expected->cupsImagingBBox[0]) > 0.001 ||
724 fabs(header->cupsImagingBBox[1] - expected->cupsImagingBBox[1]) > 0.001 ||
725 fabs(header->cupsImagingBBox[2] - expected->cupsImagingBBox[2]) > 0.001 ||
726 fabs(header->cupsImagingBBox[3] - expected->cupsImagingBBox[3]) > 0.001)
727 printf(" cupsImagingBBox [%g %g %g %g], expected [%g %g %g %g]\n",
728 header->cupsImagingBBox[0], header->cupsImagingBBox[1],
729 header->cupsImagingBBox[2], header->cupsImagingBBox[3],
730 expected->cupsImagingBBox[0], expected->cupsImagingBBox[1],
731 expected->cupsImagingBBox[2], expected->cupsImagingBBox[3]);
732
733 for (i = 0; i < 16; i ++)
734 if (header->cupsInteger[i] != expected->cupsInteger[i])
735 printf(" cupsInteger%d %d, expected %d\n", i, header->cupsInteger[i],
736 expected->cupsInteger[i]);
737
738 for (i = 0; i < 16; i ++)
739 if (fabs(header->cupsReal[i] - expected->cupsReal[i]) > 0.001)
740 printf(" cupsReal%d %g, expected %g\n", i, header->cupsReal[i],
741 expected->cupsReal[i]);
742
743 for (i = 0; i < 16; i ++)
744 if (strcmp(header->cupsString[i], expected->cupsString[i]))
745 printf(" cupsString%d (%s), expected (%s)\n", i,
746 header->cupsString[i], expected->cupsString[i]);
747
748 if (strcmp(header->cupsMarkerType, expected->cupsMarkerType))
749 printf(" cupsMarkerType (%s), expected (%s)\n", header->cupsMarkerType,
750 expected->cupsMarkerType);
751
752 if (strcmp(header->cupsRenderingIntent, expected->cupsRenderingIntent))
753 printf(" cupsRenderingIntent (%s), expected (%s)\n",
754 header->cupsRenderingIntent,
755 expected->cupsRenderingIntent);
756
757 if (strcmp(header->cupsPageSizeName, expected->cupsPageSizeName))
758 printf(" cupsPageSizeName (%s), expected (%s)\n",
759 header->cupsPageSizeName,
760 expected->cupsPageSizeName);
761 }
762