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