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