| /* |
| * PPD test program for CUPS. |
| * |
| * Copyright © 2007-2018 by Apple Inc. |
| * Copyright © 1997-2006 by Easy Software Products. |
| * |
| * Licensed under Apache License v2.0. See the file "LICENSE" for more |
| * information. |
| */ |
| |
| /* |
| * Include necessary headers... |
| */ |
| |
| #undef _CUPS_NO_DEPRECATED |
| #include "cups-private.h" |
| #include "ppd-private.h" |
| #include "raster-private.h" |
| #include <sys/stat.h> |
| #ifdef _WIN32 |
| # include <io.h> |
| #else |
| # include <unistd.h> |
| # include <fcntl.h> |
| #endif /* _WIN32 */ |
| #include <math.h> |
| |
| |
| /* |
| * Local functions... |
| */ |
| |
| static int do_ppd_tests(const char *filename, int num_options, cups_option_t *options); |
| static int do_ps_tests(void); |
| static void print_changes(cups_page_header2_t *header, cups_page_header2_t *expected); |
| |
| |
| /* |
| * Test data... |
| */ |
| |
| static const char *dsc_code = |
| "[{\n" |
| "%%BeginFeature: *PageSize Tabloid\n" |
| "<</PageSize[792 1224]>>setpagedevice\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n"; |
| static const char *setpagedevice_code = |
| "<<" |
| "/MediaClass(Media Class)" |
| "/MediaColor((Media Color))" |
| "/MediaType(Media\\\\Type)" |
| "/OutputType<416263>" |
| "/AdvanceDistance 1000" |
| "/AdvanceMedia 1" |
| "/Collate false" |
| "/CutMedia 2" |
| "/Duplex true" |
| "/HWResolution[100 200]" |
| "/InsertSheet true" |
| "/Jog 3" |
| "/LeadingEdge 1" |
| "/ManualFeed true" |
| "/MediaPosition 8#777" |
| "/MediaWeight 16#fe01" |
| "/MirrorPrint true" |
| "/NegativePrint true" |
| "/NumCopies 1" |
| "/Orientation 1" |
| "/OutputFaceUp true" |
| "/PageSize[612 792.1]" |
| "/Separations true" |
| "/TraySwitch true" |
| "/Tumble true" |
| "/cupsMediaType 2" |
| "/cupsColorOrder 1" |
| "/cupsColorSpace 1" |
| "/cupsCompression 1" |
| "/cupsRowCount 1" |
| "/cupsRowFeed 1" |
| "/cupsRowStep 1" |
| "/cupsBorderlessScalingFactor 1.001" |
| "/cupsInteger0 1" |
| "/cupsInteger1 2" |
| "/cupsInteger2 3" |
| "/cupsInteger3 4" |
| "/cupsInteger4 5" |
| "/cupsInteger5 6" |
| "/cupsInteger6 7" |
| "/cupsInteger7 8" |
| "/cupsInteger8 9" |
| "/cupsInteger9 10" |
| "/cupsInteger10 11" |
| "/cupsInteger11 12" |
| "/cupsInteger12 13" |
| "/cupsInteger13 14" |
| "/cupsInteger14 15" |
| "/cupsInteger15 16" |
| "/cupsReal0 1.1" |
| "/cupsReal1 2.1" |
| "/cupsReal2 3.1" |
| "/cupsReal3 4.1" |
| "/cupsReal4 5.1" |
| "/cupsReal5 6.1" |
| "/cupsReal6 7.1" |
| "/cupsReal7 8.1" |
| "/cupsReal8 9.1" |
| "/cupsReal9 10.1" |
| "/cupsReal10 11.1" |
| "/cupsReal11 12.1" |
| "/cupsReal12 13.1" |
| "/cupsReal13 14.1" |
| "/cupsReal14 15.1" |
| "/cupsReal15 16.1" |
| "/cupsString0(1)" |
| "/cupsString1(2)" |
| "/cupsString2(3)" |
| "/cupsString3(4)" |
| "/cupsString4(5)" |
| "/cupsString5(6)" |
| "/cupsString6(7)" |
| "/cupsString7(8)" |
| "/cupsString8(9)" |
| "/cupsString9(10)" |
| "/cupsString10(11)" |
| "/cupsString11(12)" |
| "/cupsString12(13)" |
| "/cupsString13(14)" |
| "/cupsString14(15)" |
| "/cupsString15(16)" |
| "/cupsMarkerType(Marker Type)" |
| "/cupsRenderingIntent(Rendering Intent)" |
| "/cupsPageSizeName(Letter)" |
| "/cupsPreferredBitsPerColor 17" |
| ">> setpagedevice"; |
| |
| static cups_page_header2_t setpagedevice_header = |
| { |
| "Media Class", /* MediaClass */ |
| "(Media Color)", /* MediaColor */ |
| "Media\\Type", /* MediaType */ |
| "Abc", /* OutputType */ |
| 1000, /* AdvanceDistance */ |
| CUPS_ADVANCE_FILE, /* AdvanceMedia */ |
| CUPS_FALSE, /* Collate */ |
| CUPS_CUT_JOB, /* CutMedia */ |
| CUPS_TRUE, /* Duplex */ |
| { 100, 200 }, /* HWResolution */ |
| { 0, 0, 0, 0 }, /* ImagingBoundingBox */ |
| CUPS_TRUE, /* InsertSheet */ |
| CUPS_JOG_SET, /* Jog */ |
| CUPS_EDGE_RIGHT, /* LeadingEdge */ |
| { 0, 0 }, /* Margins */ |
| CUPS_TRUE, /* ManualFeed */ |
| 0777, /* MediaPosition */ |
| 0xfe01, /* MediaWeight */ |
| CUPS_TRUE, /* MirrorPrint */ |
| CUPS_TRUE, /* NegativePrint */ |
| 1, /* NumCopies */ |
| CUPS_ORIENT_90, /* Orientation */ |
| CUPS_TRUE, /* OutputFaceUp */ |
| { 612, 792 }, /* PageSize */ |
| CUPS_TRUE, /* Separations */ |
| CUPS_TRUE, /* TraySwitch */ |
| CUPS_TRUE, /* Tumble */ |
| 0, /* cupsWidth */ |
| 0, /* cupsHeight */ |
| 2, /* cupsMediaType */ |
| 0, /* cupsBitsPerColor */ |
| 0, /* cupsBitsPerPixel */ |
| 0, /* cupsBytesPerLine */ |
| CUPS_ORDER_BANDED, /* cupsColorOrder */ |
| CUPS_CSPACE_RGB, /* cupsColorSpace */ |
| 1, /* cupsCompression */ |
| 1, /* cupsRowCount */ |
| 1, /* cupsRowFeed */ |
| 1, /* cupsRowStep */ |
| 0, /* cupsNumColors */ |
| 1.001f, /* cupsBorderlessScalingFactor */ |
| { 612.0f, 792.1f }, /* cupsPageSize */ |
| { 0.0f, 0.0f, 0.0f, 0.0f }, /* cupsImagingBBox */ |
| { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }, |
| /* cupsInteger[16] */ |
| { 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] */ |
| { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", |
| "14", "15", "16" }, /* cupsString[16] */ |
| "Marker Type", /* cupsMarkerType */ |
| "Rendering Intent", /* cupsRenderingIntent */ |
| "Letter" /* cupsPageSizeName */ |
| }; |
| |
| static const char *default_code = |
| "[{\n" |
| "%%BeginFeature: *InstalledDuplexer False\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *PageRegion Letter\n" |
| "PageRegion=Letter\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *InputSlot Tray\n" |
| "InputSlot=Tray\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *OutputBin Tray1\n" |
| "OutputBin=Tray1\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *MediaType Plain\n" |
| "MediaType=Plain\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *IntOption None\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *StringOption None\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n"; |
| |
| static const char *custom_code = |
| "[{\n" |
| "%%BeginFeature: *InstalledDuplexer False\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *InputSlot Tray\n" |
| "InputSlot=Tray\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *MediaType Plain\n" |
| "MediaType=Plain\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *OutputBin Tray1\n" |
| "OutputBin=Tray1\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *IntOption None\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *CustomStringOption True\n" |
| "(value\\0502\\051)\n" |
| "(value 1)\n" |
| "StringOption=Custom\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *CustomPageSize True\n" |
| "400\n" |
| "500\n" |
| "0\n" |
| "0\n" |
| "0\n" |
| "PageSize=Custom\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n"; |
| |
| static const char *default2_code = |
| "[{\n" |
| "%%BeginFeature: *InstalledDuplexer False\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *InputSlot Tray\n" |
| "InputSlot=Tray\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *Quality Normal\n" |
| "Quality=Normal\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *IntOption None\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n" |
| "[{\n" |
| "%%BeginFeature: *StringOption None\n" |
| "%%EndFeature\n" |
| "} stopped cleartomark\n"; |
| |
| |
| /* |
| * 'main()' - Main entry. |
| */ |
| |
| int /* O - Exit status */ |
| main(int argc, /* I - Number of command-line arguments */ |
| char *argv[]) /* I - Command-line arguments */ |
| { |
| int i; /* Looping var */ |
| ppd_file_t *ppd = NULL; /* PPD file loaded from disk */ |
| int status; /* Status of tests (0 = success, 1 = fail) */ |
| int conflicts; /* Number of conflicts */ |
| char *s; /* String */ |
| char buffer[8192]; /* String buffer */ |
| const char *text, /* Localized text */ |
| *val; /* Option value */ |
| int num_options; /* Number of options */ |
| cups_option_t *options; /* Options */ |
| ppd_size_t minsize, /* Minimum size */ |
| maxsize, /* Maximum size */ |
| *size; /* Current size */ |
| ppd_attr_t *attr; /* Current attribute */ |
| _ppd_cache_t *pc; /* PPD cache */ |
| |
| |
| status = 0; |
| |
| if (argc == 1) |
| { |
| /* |
| * Setup directories for locale stuff... |
| */ |
| |
| if (access("locale", 0)) |
| { |
| mkdir("locale", 0777); |
| mkdir("locale/fr", 0777); |
| symlink("../../../locale/cups_fr.po", "locale/fr/cups_fr.po"); |
| mkdir("locale/zh_TW", 0777); |
| symlink("../../../locale/cups_zh_TW.po", "locale/zh_TW/cups_zh_TW.po"); |
| } |
| |
| putenv("LOCALEDIR=locale"); |
| putenv("SOFTWARE=CUPS"); |
| |
| /* |
| * Do tests with test.ppd... |
| */ |
| |
| fputs("ppdOpenFile(test.ppd): ", stdout); |
| |
| if ((ppd = _ppdOpenFile("test.ppd", _PPD_LOCALIZATION_ALL)) != NULL) |
| puts("PASS"); |
| else |
| { |
| ppd_status_t err; /* Last error in file */ |
| int line; /* Line number in file */ |
| |
| |
| status ++; |
| err = ppdLastError(&line); |
| |
| printf("FAIL (%s on line %d)\n", ppdErrorString(err), line); |
| } |
| |
| fputs("ppdFindAttr(wildcard): ", stdout); |
| if ((attr = ppdFindAttr(ppd, "cupsTest", NULL)) == NULL) |
| { |
| status ++; |
| puts("FAIL (not found)"); |
| } |
| else if (strcmp(attr->name, "cupsTest") || strcmp(attr->spec, "Foo")) |
| { |
| status ++; |
| printf("FAIL (got \"%s %s\")\n", attr->name, attr->spec); |
| } |
| else |
| puts("PASS"); |
| |
| fputs("ppdFindNextAttr(wildcard): ", stdout); |
| if ((attr = ppdFindNextAttr(ppd, "cupsTest", NULL)) == NULL) |
| { |
| status ++; |
| puts("FAIL (not found)"); |
| } |
| else if (strcmp(attr->name, "cupsTest") || strcmp(attr->spec, "Bar")) |
| { |
| status ++; |
| printf("FAIL (got \"%s %s\")\n", attr->name, attr->spec); |
| } |
| else |
| puts("PASS"); |
| |
| fputs("ppdFindAttr(Foo): ", stdout); |
| if ((attr = ppdFindAttr(ppd, "cupsTest", "Foo")) == NULL) |
| { |
| status ++; |
| puts("FAIL (not found)"); |
| } |
| else if (strcmp(attr->name, "cupsTest") || strcmp(attr->spec, "Foo")) |
| { |
| status ++; |
| printf("FAIL (got \"%s %s\")\n", attr->name, attr->spec); |
| } |
| else |
| puts("PASS"); |
| |
| fputs("ppdFindNextAttr(Foo): ", stdout); |
| if ((attr = ppdFindNextAttr(ppd, "cupsTest", "Foo")) != NULL) |
| { |
| status ++; |
| printf("FAIL (got \"%s %s\")\n", attr->name, attr->spec); |
| } |
| else |
| puts("PASS"); |
| |
| fputs("ppdMarkDefaults: ", stdout); |
| ppdMarkDefaults(ppd); |
| |
| if ((conflicts = ppdConflicts(ppd)) == 0) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (%d conflicts)\n", conflicts); |
| } |
| |
| fputs("ppdEmitString (defaults): ", stdout); |
| if ((s = ppdEmitString(ppd, PPD_ORDER_ANY, 0.0)) != NULL && |
| !strcmp(s, default_code)) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (%d bytes instead of %d)\n", s ? (int)strlen(s) : 0, |
| (int)strlen(default_code)); |
| |
| if (s) |
| puts(s); |
| } |
| |
| if (s) |
| free(s); |
| |
| fputs("ppdEmitString (custom size and string): ", stdout); |
| ppdMarkOption(ppd, "PageSize", "Custom.400x500"); |
| ppdMarkOption(ppd, "StringOption", "{String1=\"value 1\" String2=value(2)}"); |
| |
| if ((s = ppdEmitString(ppd, PPD_ORDER_ANY, 0.0)) != NULL && |
| !strcmp(s, custom_code)) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (%d bytes instead of %d)\n", s ? (int)strlen(s) : 0, |
| (int)strlen(custom_code)); |
| |
| if (s) |
| puts(s); |
| } |
| |
| if (s) |
| free(s); |
| |
| /* |
| * Test constraints... |
| */ |
| |
| fputs("cupsGetConflicts(InputSlot=Envelope): ", stdout); |
| ppdMarkOption(ppd, "PageSize", "Letter"); |
| |
| num_options = cupsGetConflicts(ppd, "InputSlot", "Envelope", &options); |
| if (num_options != 2 || |
| (val = cupsGetOption("PageRegion", num_options, options)) == NULL || |
| _cups_strcasecmp(val, "Letter") || |
| (val = cupsGetOption("PageSize", num_options, options)) == NULL || |
| _cups_strcasecmp(val, "Letter")) |
| { |
| printf("FAIL (%d options:", num_options); |
| for (i = 0; i < num_options; i ++) |
| printf(" %s=%s", options[i].name, options[i].value); |
| puts(")"); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| |
| fputs("ppdConflicts(): ", stdout); |
| ppdMarkOption(ppd, "InputSlot", "Envelope"); |
| |
| if ((conflicts = ppdConflicts(ppd)) == 2) |
| puts("PASS (2)"); |
| else |
| { |
| printf("FAIL (%d)\n", conflicts); |
| status ++; |
| } |
| |
| fputs("cupsResolveConflicts(InputSlot=Envelope): ", stdout); |
| num_options = 0; |
| options = NULL; |
| if (!cupsResolveConflicts(ppd, "InputSlot", "Envelope", &num_options, |
| &options)) |
| { |
| puts("FAIL (Unable to resolve)"); |
| status ++; |
| } |
| else if (num_options != 2 || |
| !cupsGetOption("PageSize", num_options, options)) |
| { |
| printf("FAIL (%d options:", num_options); |
| for (i = 0; i < num_options; i ++) |
| printf(" %s=%s", options[i].name, options[i].value); |
| puts(")"); |
| status ++; |
| } |
| else |
| puts("PASS (Resolved by changing PageSize)"); |
| |
| cupsFreeOptions(num_options, options); |
| |
| fputs("cupsResolveConflicts(No option/choice): ", stdout); |
| num_options = 0; |
| options = NULL; |
| if (cupsResolveConflicts(ppd, NULL, NULL, &num_options, &options) && |
| num_options == 1 && !_cups_strcasecmp(options[0].name, "InputSlot") && |
| !_cups_strcasecmp(options[0].value, "Tray")) |
| puts("PASS (Resolved by changing InputSlot)"); |
| else if (num_options > 0) |
| { |
| printf("FAIL (%d options:", num_options); |
| for (i = 0; i < num_options; i ++) |
| printf(" %s=%s", options[i].name, options[i].value); |
| puts(")"); |
| status ++; |
| } |
| else |
| { |
| puts("FAIL (Unable to resolve)"); |
| status ++; |
| } |
| cupsFreeOptions(num_options, options); |
| |
| fputs("ppdInstallableConflict(): ", stdout); |
| if (ppdInstallableConflict(ppd, "Duplex", "DuplexNoTumble") && |
| !ppdInstallableConflict(ppd, "Duplex", "None")) |
| puts("PASS"); |
| else if (!ppdInstallableConflict(ppd, "Duplex", "DuplexNoTumble")) |
| { |
| puts("FAIL (Duplex=DuplexNoTumble did not conflict)"); |
| status ++; |
| } |
| else |
| { |
| puts("FAIL (Duplex=None conflicted)"); |
| status ++; |
| } |
| |
| /* |
| * ppdPageSizeLimits |
| */ |
| |
| fputs("ppdPageSizeLimits: ", stdout); |
| if (ppdPageSizeLimits(ppd, &minsize, &maxsize)) |
| { |
| if (fabs(minsize.width - 36.0) > 0.001 || fabs(minsize.length - 36.0) > 0.001 || |
| fabs(maxsize.width - 1080.0) > 0.001 || fabs(maxsize.length - 86400.0) > 0.001) |
| { |
| printf("FAIL (got min=%.3fx%.3f, max=%.3fx%.3f, " |
| "expected min=36x36, max=1080x86400)\n", minsize.width, |
| minsize.length, maxsize.width, maxsize.length); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| } |
| else |
| { |
| puts("FAIL (returned 0)"); |
| status ++; |
| } |
| |
| /* |
| * cupsMarkOptions with PWG and IPP size names. |
| */ |
| |
| fputs("cupsMarkOptions(media=iso-a4): ", stdout); |
| num_options = cupsAddOption("media", "iso-a4", 0, &options); |
| cupsMarkOptions(ppd, num_options, options); |
| cupsFreeOptions(num_options, options); |
| |
| size = ppdPageSize(ppd, NULL); |
| if (!size || strcmp(size->name, "A4")) |
| { |
| printf("FAIL (%s)\n", size ? size->name : "unknown"); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| |
| fputs("cupsMarkOptions(media=na_letter_8.5x11in): ", stdout); |
| num_options = cupsAddOption("media", "na_letter_8.5x11in", 0, &options); |
| cupsMarkOptions(ppd, num_options, options); |
| cupsFreeOptions(num_options, options); |
| |
| size = ppdPageSize(ppd, NULL); |
| if (!size || strcmp(size->name, "Letter")) |
| { |
| printf("FAIL (%s)\n", size ? size->name : "unknown"); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| |
| fputs("cupsMarkOptions(media=oe_letter-fullbleed_8.5x11in): ", stdout); |
| num_options = cupsAddOption("media", "oe_letter-fullbleed_8.5x11in", 0, |
| &options); |
| cupsMarkOptions(ppd, num_options, options); |
| cupsFreeOptions(num_options, options); |
| |
| size = ppdPageSize(ppd, NULL); |
| if (!size || strcmp(size->name, "Letter.Fullbleed")) |
| { |
| printf("FAIL (%s)\n", size ? size->name : "unknown"); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| |
| fputs("cupsMarkOptions(media=A4): ", stdout); |
| num_options = cupsAddOption("media", "A4", 0, &options); |
| cupsMarkOptions(ppd, num_options, options); |
| cupsFreeOptions(num_options, options); |
| |
| size = ppdPageSize(ppd, NULL); |
| if (!size || strcmp(size->name, "A4")) |
| { |
| printf("FAIL (%s)\n", size ? size->name : "unknown"); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| |
| /* |
| * Custom sizes... |
| */ |
| |
| fputs("cupsMarkOptions(media=Custom.8x10in): ", stdout); |
| num_options = cupsAddOption("media", "Custom.8x10in", 0, &options); |
| cupsMarkOptions(ppd, num_options, options); |
| cupsFreeOptions(num_options, options); |
| |
| size = ppdPageSize(ppd, NULL); |
| if (!size || strcmp(size->name, "Custom") || |
| fabs(size->width - 576.0) > 0.001 || |
| fabs(size->length - 720.0) > 0.001) |
| { |
| printf("FAIL (%s - %gx%g)\n", size ? size->name : "unknown", |
| size ? size->width : 0.0, size ? size->length : 0.0); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| |
| /* |
| * Test localization... |
| */ |
| |
| fputs("ppdLocalizeIPPReason(text): ", stdout); |
| if (ppdLocalizeIPPReason(ppd, "foo", NULL, buffer, sizeof(buffer)) && |
| !strcmp(buffer, "Foo Reason")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"Foo Reason\")\n", buffer); |
| } |
| |
| fputs("ppdLocalizeIPPReason(http): ", stdout); |
| if (ppdLocalizeIPPReason(ppd, "foo", "http", buffer, sizeof(buffer)) && |
| !strcmp(buffer, "http://foo/bar.html")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"http://foo/bar.html\")\n", buffer); |
| } |
| |
| fputs("ppdLocalizeIPPReason(help): ", stdout); |
| if (ppdLocalizeIPPReason(ppd, "foo", "help", buffer, sizeof(buffer)) && |
| !strcmp(buffer, "help:anchor='foo'%20bookID=Vendor%20Help")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"help:anchor='foo'%%20bookID=Vendor%%20Help\")\n", buffer); |
| } |
| |
| fputs("ppdLocalizeIPPReason(file): ", stdout); |
| if (ppdLocalizeIPPReason(ppd, "foo", "file", buffer, sizeof(buffer)) && |
| !strcmp(buffer, "/help/foo/bar.html")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"/help/foo/bar.html\")\n", buffer); |
| } |
| |
| putenv("LANG=fr"); |
| putenv("LC_ALL=fr"); |
| putenv("LC_CTYPE=fr"); |
| putenv("LC_MESSAGES=fr"); |
| |
| fputs("ppdLocalizeIPPReason(fr text): ", stdout); |
| if (ppdLocalizeIPPReason(ppd, "foo", NULL, buffer, sizeof(buffer)) && |
| !strcmp(buffer, "La Long Foo Reason")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"La Long Foo Reason\")\n", buffer); |
| } |
| |
| putenv("LANG=zh_TW"); |
| putenv("LC_ALL=zh_TW"); |
| putenv("LC_CTYPE=zh_TW"); |
| putenv("LC_MESSAGES=zh_TW"); |
| |
| fputs("ppdLocalizeIPPReason(zh_TW text): ", stdout); |
| if (ppdLocalizeIPPReason(ppd, "foo", NULL, buffer, sizeof(buffer)) && |
| !strcmp(buffer, "Number 1 Foo Reason")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"Number 1 Foo Reason\")\n", buffer); |
| } |
| |
| /* |
| * cupsMarkerName localization... |
| */ |
| |
| putenv("LANG=en"); |
| putenv("LC_ALL=en"); |
| putenv("LC_CTYPE=en"); |
| putenv("LC_MESSAGES=en"); |
| |
| fputs("ppdLocalizeMarkerName(bogus): ", stdout); |
| |
| if ((text = ppdLocalizeMarkerName(ppd, "bogus")) != NULL) |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of NULL)\n", text); |
| } |
| else |
| puts("PASS"); |
| |
| fputs("ppdLocalizeMarkerName(cyan): ", stdout); |
| |
| if ((text = ppdLocalizeMarkerName(ppd, "cyan")) != NULL && |
| !strcmp(text, "Cyan Toner")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"Cyan Toner\")\n", |
| text ? text : "(null)"); |
| } |
| |
| putenv("LANG=fr"); |
| putenv("LC_ALL=fr"); |
| putenv("LC_CTYPE=fr"); |
| putenv("LC_MESSAGES=fr"); |
| |
| fputs("ppdLocalizeMarkerName(fr cyan): ", stdout); |
| if ((text = ppdLocalizeMarkerName(ppd, "cyan")) != NULL && |
| !strcmp(text, "La Toner Cyan")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"La Toner Cyan\")\n", |
| text ? text : "(null)"); |
| } |
| |
| putenv("LANG=zh_TW"); |
| putenv("LC_ALL=zh_TW"); |
| putenv("LC_CTYPE=zh_TW"); |
| putenv("LC_MESSAGES=zh_TW"); |
| |
| fputs("ppdLocalizeMarkerName(zh_TW cyan): ", stdout); |
| if ((text = ppdLocalizeMarkerName(ppd, "cyan")) != NULL && |
| !strcmp(text, "Number 1 Cyan Toner")) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (\"%s\" instead of \"Number 1 Cyan Toner\")\n", |
| text ? text : "(null)"); |
| } |
| |
| ppdClose(ppd); |
| |
| /* |
| * Test new constraints... |
| */ |
| |
| fputs("ppdOpenFile(test2.ppd): ", stdout); |
| |
| if ((ppd = ppdOpenFile("test2.ppd")) != NULL) |
| puts("PASS"); |
| else |
| { |
| ppd_status_t err; /* Last error in file */ |
| int line; /* Line number in file */ |
| |
| |
| status ++; |
| err = ppdLastError(&line); |
| |
| printf("FAIL (%s on line %d)\n", ppdErrorString(err), line); |
| } |
| |
| fputs("ppdMarkDefaults: ", stdout); |
| ppdMarkDefaults(ppd); |
| |
| if ((conflicts = ppdConflicts(ppd)) == 0) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (%d conflicts)\n", conflicts); |
| } |
| |
| fputs("ppdEmitString (defaults): ", stdout); |
| if ((s = ppdEmitString(ppd, PPD_ORDER_ANY, 0.0)) != NULL && |
| !strcmp(s, default2_code)) |
| puts("PASS"); |
| else |
| { |
| status ++; |
| printf("FAIL (%d bytes instead of %d)\n", s ? (int)strlen(s) : 0, |
| (int)strlen(default2_code)); |
| |
| if (s) |
| puts(s); |
| } |
| |
| if (s) |
| free(s); |
| |
| fputs("ppdConflicts(): ", stdout); |
| ppdMarkOption(ppd, "PageSize", "Env10"); |
| ppdMarkOption(ppd, "InputSlot", "Envelope"); |
| ppdMarkOption(ppd, "Quality", "Photo"); |
| |
| if ((conflicts = ppdConflicts(ppd)) == 1) |
| puts("PASS (1)"); |
| else |
| { |
| printf("FAIL (%d)\n", conflicts); |
| status ++; |
| } |
| |
| fputs("cupsResolveConflicts(Quality=Photo): ", stdout); |
| num_options = 0; |
| options = NULL; |
| if (cupsResolveConflicts(ppd, "Quality", "Photo", &num_options, |
| &options)) |
| { |
| printf("FAIL (%d options:", num_options); |
| for (i = 0; i < num_options; i ++) |
| printf(" %s=%s", options[i].name, options[i].value); |
| puts(")"); |
| status ++; |
| } |
| else |
| puts("PASS (Unable to resolve)"); |
| cupsFreeOptions(num_options, options); |
| |
| fputs("cupsResolveConflicts(No option/choice): ", stdout); |
| num_options = 0; |
| options = NULL; |
| if (cupsResolveConflicts(ppd, NULL, NULL, &num_options, &options) && |
| num_options == 1 && !_cups_strcasecmp(options->name, "Quality") && |
| !_cups_strcasecmp(options->value, "Normal")) |
| puts("PASS"); |
| else if (num_options > 0) |
| { |
| printf("FAIL (%d options:", num_options); |
| for (i = 0; i < num_options; i ++) |
| printf(" %s=%s", options[i].name, options[i].value); |
| puts(")"); |
| status ++; |
| } |
| else |
| { |
| puts("FAIL (Unable to resolve!)"); |
| status ++; |
| } |
| cupsFreeOptions(num_options, options); |
| |
| fputs("cupsResolveConflicts(loop test): ", stdout); |
| ppdMarkOption(ppd, "PageSize", "A4"); |
| ppdMarkOption(ppd, "InputSlot", "Tray"); |
| ppdMarkOption(ppd, "Quality", "Photo"); |
| num_options = 0; |
| options = NULL; |
| if (!cupsResolveConflicts(ppd, NULL, NULL, &num_options, &options)) |
| puts("PASS"); |
| else if (num_options > 0) |
| { |
| printf("FAIL (%d options:", num_options); |
| for (i = 0; i < num_options; i ++) |
| printf(" %s=%s", options[i].name, options[i].value); |
| puts(")"); |
| } |
| else |
| puts("FAIL (No conflicts!)"); |
| |
| fputs("ppdInstallableConflict(): ", stdout); |
| if (ppdInstallableConflict(ppd, "Duplex", "DuplexNoTumble") && |
| !ppdInstallableConflict(ppd, "Duplex", "None")) |
| puts("PASS"); |
| else if (!ppdInstallableConflict(ppd, "Duplex", "DuplexNoTumble")) |
| { |
| puts("FAIL (Duplex=DuplexNoTumble did not conflict)"); |
| status ++; |
| } |
| else |
| { |
| puts("FAIL (Duplex=None conflicted)"); |
| status ++; |
| } |
| |
| /* |
| * ppdPageSizeLimits |
| */ |
| |
| ppdMarkDefaults(ppd); |
| |
| fputs("ppdPageSizeLimits(default): ", stdout); |
| if (ppdPageSizeLimits(ppd, &minsize, &maxsize)) |
| { |
| if (fabs(minsize.width - 36.0) > 0.001 || fabs(minsize.length - 36.0) > 0.001 || |
| fabs(maxsize.width - 1080.0) > 0.001 || fabs(maxsize.length - 86400.0) > 0.001) |
| { |
| printf("FAIL (got min=%.0fx%.0f, max=%.0fx%.0f, " |
| "expected min=36x36, max=1080x86400)\n", minsize.width, |
| minsize.length, maxsize.width, maxsize.length); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| } |
| else |
| { |
| puts("FAIL (returned 0)"); |
| status ++; |
| } |
| |
| ppdMarkOption(ppd, "InputSlot", "Manual"); |
| |
| fputs("ppdPageSizeLimits(InputSlot=Manual): ", stdout); |
| if (ppdPageSizeLimits(ppd, &minsize, &maxsize)) |
| { |
| if (fabs(minsize.width - 100.0) > 0.001 || fabs(minsize.length - 100.0) > 0.001 || |
| fabs(maxsize.width - 1000.0) > 0.001 || fabs(maxsize.length - 1000.0) > 0.001) |
| { |
| printf("FAIL (got min=%.0fx%.0f, max=%.0fx%.0f, " |
| "expected min=100x100, max=1000x1000)\n", minsize.width, |
| minsize.length, maxsize.width, maxsize.length); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| } |
| else |
| { |
| puts("FAIL (returned 0)"); |
| status ++; |
| } |
| |
| ppdMarkOption(ppd, "Quality", "Photo"); |
| |
| fputs("ppdPageSizeLimits(Quality=Photo): ", stdout); |
| if (ppdPageSizeLimits(ppd, &minsize, &maxsize)) |
| { |
| if (fabs(minsize.width - 200.0) > 0.001 || fabs(minsize.length - 200.0) > 0.001 || |
| fabs(maxsize.width - 1000.0) > 0.001 || fabs(maxsize.length - 1000.0) > 0.001) |
| { |
| printf("FAIL (got min=%.0fx%.0f, max=%.0fx%.0f, " |
| "expected min=200x200, max=1000x1000)\n", minsize.width, |
| minsize.length, maxsize.width, maxsize.length); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| } |
| else |
| { |
| puts("FAIL (returned 0)"); |
| status ++; |
| } |
| |
| ppdMarkOption(ppd, "InputSlot", "Tray"); |
| |
| fputs("ppdPageSizeLimits(Quality=Photo): ", stdout); |
| if (ppdPageSizeLimits(ppd, &minsize, &maxsize)) |
| { |
| if (fabs(minsize.width - 300.0) > 0.001 || fabs(minsize.length - 300.0) > 0.001 || |
| fabs(maxsize.width - 1080.0) > 0.001 || fabs(maxsize.length - 86400.0) > 0.001) |
| { |
| printf("FAIL (got min=%.0fx%.0f, max=%.0fx%.0f, " |
| "expected min=300x300, max=1080x86400)\n", minsize.width, |
| minsize.length, maxsize.width, maxsize.length); |
| status ++; |
| } |
| else |
| puts("PASS"); |
| } |
| else |
| { |
| puts("FAIL (returned 0)"); |
| status ++; |
| } |
| |
| status += do_ps_tests(); |
| } |
| else if (!strcmp(argv[1], "--raster")) |
| { |
| for (status = 0, num_options = 0, options = NULL, i = 1; i < argc; i ++) |
| { |
| if (argv[i][0] == '-') |
| { |
| if (argv[i][1] == 'o') |
| { |
| if (argv[i][2]) |
| num_options = cupsParseOptions(argv[i] + 2, num_options, &options); |
| else |
| { |
| i ++; |
| if (i < argc) |
| num_options = cupsParseOptions(argv[i], num_options, &options); |
| else |
| { |
| puts("Usage: testppd --raster [-o name=value ...] [filename.ppd ...]"); |
| return (1); |
| } |
| } |
| } |
| else |
| { |
| puts("Usage: testppd --raster [-o name=value ...] [filename.ppd ...]"); |
| return (1); |
| } |
| } |
| else |
| status += do_ppd_tests(argv[i], num_options, options); |
| } |
| |
| cupsFreeOptions(num_options, options); |
| } |
| else if (!strncmp(argv[1], "ipp://", 6) || !strncmp(argv[1], "ipps://", 7)) |
| { |
| /* |
| * ipp://... or ipps://... |
| */ |
| |
| http_t *http; /* Connection to printer */ |
| ipp_t *request, /* Get-Printer-Attributes request */ |
| *response; /* Get-Printer-Attributes response */ |
| char scheme[32], /* URI scheme */ |
| userpass[256], /* Username:password */ |
| host[256], /* Hostname */ |
| resource[256]; /* Resource path */ |
| int port; /* Port number */ |
| static const char * const pattrs[] =/* Requested printer attributes */ |
| { |
| "job-template", |
| "printer-defaults", |
| "printer-description", |
| "media-col-database" |
| }; |
| |
| if (httpSeparateURI(HTTP_URI_CODING_ALL, argv[1], scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_STATUS_OK) |
| { |
| printf("Bad URI \"%s\".\n", argv[1]); |
| return (1); |
| } |
| |
| http = httpConnect2(host, port, NULL, AF_UNSPEC, !strcmp(scheme, "ipps") ? HTTP_ENCRYPTION_ALWAYS : HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL); |
| if (!http) |
| { |
| printf("Unable to connect to \"%s:%d\": %s\n", host, port, cupsLastErrorString()); |
| return (1); |
| } |
| |
| request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, argv[1]); |
| ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]), NULL, pattrs); |
| response = cupsDoRequest(http, request, resource); |
| |
| if (_ppdCreateFromIPP(buffer, sizeof(buffer), response)) |
| printf("Created PPD: %s\n", buffer); |
| else |
| puts("Unable to create PPD."); |
| |
| ippDelete(response); |
| httpClose(http); |
| return (0); |
| } |
| else |
| { |
| const char *filename; /* PPD filename */ |
| struct stat fileinfo; /* File information */ |
| |
| |
| if (strchr(argv[1], ':')) |
| { |
| /* |
| * Server PPD... |
| */ |
| |
| if ((filename = cupsGetServerPPD(CUPS_HTTP_DEFAULT, argv[1])) == NULL) |
| { |
| printf("%s: %s\n", argv[1], cupsLastErrorString()); |
| return (1); |
| } |
| } |
| else if (!strncmp(argv[1], "-d", 2)) |
| { |
| const char *printer; /* Printer name */ |
| |
| if (argv[1][2]) |
| printer = argv[1] + 2; |
| else if (argv[2]) |
| printer = argv[2]; |
| else |
| { |
| puts("Usage: ./testppd -d printer"); |
| return (1); |
| } |
| |
| filename = cupsGetPPD(printer); |
| |
| if (!filename) |
| { |
| printf("%s: %s\n", printer, cupsLastErrorString()); |
| return (1); |
| } |
| } |
| else |
| filename = argv[1]; |
| |
| if (lstat(filename, &fileinfo)) |
| { |
| printf("%s: %s\n", filename, strerror(errno)); |
| return (1); |
| } |
| |
| if (S_ISLNK(fileinfo.st_mode)) |
| { |
| char realfile[1024]; /* Real file path */ |
| ssize_t realsize; /* Size of real file path */ |
| |
| |
| if ((realsize = readlink(filename, realfile, sizeof(realfile) - 1)) < 0) |
| strlcpy(realfile, "Unknown", sizeof(realfile)); |
| else |
| realfile[realsize] = '\0'; |
| |
| if (stat(realfile, &fileinfo)) |
| printf("%s: symlink to \"%s\", %s\n", filename, realfile, |
| strerror(errno)); |
| else |
| printf("%s: symlink to \"%s\", %ld bytes\n", filename, realfile, |
| (long)fileinfo.st_size); |
| } |
| else |
| printf("%s: regular file, %ld bytes\n", filename, (long)fileinfo.st_size); |
| |
| if ((ppd = ppdOpenFile(filename)) == NULL) |
| { |
| ppd_status_t err; /* Last error in file */ |
| int line; /* Line number in file */ |
| |
| |
| status ++; |
| err = ppdLastError(&line); |
| |
| printf("%s: %s on line %d\n", argv[1], ppdErrorString(err), line); |
| } |
| else |
| { |
| int j, k; /* Looping vars */ |
| ppd_group_t *group; /* Option group */ |
| ppd_option_t *option; /* Option */ |
| ppd_coption_t *coption; /* Custom option */ |
| ppd_cparam_t *cparam; /* Custom parameter */ |
| ppd_const_t *c; /* UIConstraints */ |
| char lang[255], /* LANG environment variable */ |
| lc_all[255], /* LC_ALL environment variable */ |
| lc_ctype[255], /* LC_CTYPE environment variable */ |
| lc_messages[255];/* LC_MESSAGES environment variable */ |
| |
| |
| if (argc > 2) |
| { |
| snprintf(lang, sizeof(lang), "LANG=%s", argv[2]); |
| putenv(lang); |
| snprintf(lc_all, sizeof(lc_all), "LC_ALL=%s", argv[2]); |
| putenv(lc_all); |
| snprintf(lc_ctype, sizeof(lc_ctype), "LC_CTYPE=%s", argv[2]); |
| putenv(lc_ctype); |
| snprintf(lc_messages, sizeof(lc_messages), "LC_MESSAGES=%s", argv[2]); |
| putenv(lc_messages); |
| } |
| |
| ppdLocalize(ppd); |
| ppdMarkDefaults(ppd); |
| |
| if (argc > 3) |
| { |
| text = ppdLocalizeIPPReason(ppd, argv[3], NULL, buffer, sizeof(buffer)); |
| printf("ppdLocalizeIPPReason(%s)=%s\n", argv[3], |
| text ? text : "(null)"); |
| return (text == NULL); |
| } |
| |
| for (i = ppd->num_groups, group = ppd->groups; |
| i > 0; |
| i --, group ++) |
| { |
| printf("%s (%s):\n", group->name, group->text); |
| |
| for (j = group->num_options, option = group->options; |
| j > 0; |
| j --, option ++) |
| { |
| printf(" %s (%s):\n", option->keyword, option->text); |
| |
| for (k = 0; k < option->num_choices; k ++) |
| printf(" - %s%s (%s)\n", |
| option->choices[k].marked ? "*" : "", |
| option->choices[k].choice, option->choices[k].text); |
| |
| if ((coption = ppdFindCustomOption(ppd, option->keyword)) != NULL) |
| { |
| for (cparam = (ppd_cparam_t *)cupsArrayFirst(coption->params); |
| cparam; |
| cparam = (ppd_cparam_t *)cupsArrayNext(coption->params)) |
| { |
| switch (cparam->type) |
| { |
| case PPD_CUSTOM_UNKNOWN : |
| printf(" %s(%s): PPD_CUSTOM_UNKNOWN (error)\n", cparam->name, cparam->text); |
| break; |
| |
| case PPD_CUSTOM_CURVE : |
| printf(" %s(%s): PPD_CUSTOM_CURVE (%g to %g)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_curve, |
| cparam->maximum.custom_curve); |
| break; |
| |
| case PPD_CUSTOM_INT : |
| printf(" %s(%s): PPD_CUSTOM_INT (%d to %d)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_int, |
| cparam->maximum.custom_int); |
| break; |
| |
| case PPD_CUSTOM_INVCURVE : |
| printf(" %s(%s): PPD_CUSTOM_INVCURVE (%g to %g)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_invcurve, |
| cparam->maximum.custom_invcurve); |
| break; |
| |
| case PPD_CUSTOM_PASSCODE : |
| printf(" %s(%s): PPD_CUSTOM_PASSCODE (%d to %d)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_passcode, |
| cparam->maximum.custom_passcode); |
| break; |
| |
| case PPD_CUSTOM_PASSWORD : |
| printf(" %s(%s): PPD_CUSTOM_PASSWORD (%d to %d)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_password, |
| cparam->maximum.custom_password); |
| break; |
| |
| case PPD_CUSTOM_POINTS : |
| printf(" %s(%s): PPD_CUSTOM_POINTS (%g to %g)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_points, |
| cparam->maximum.custom_points); |
| break; |
| |
| case PPD_CUSTOM_REAL : |
| printf(" %s(%s): PPD_CUSTOM_REAL (%g to %g)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_real, |
| cparam->maximum.custom_real); |
| break; |
| |
| case PPD_CUSTOM_STRING : |
| printf(" %s(%s): PPD_CUSTOM_STRING (%d to %d)\n", |
| cparam->name, cparam->text, |
| cparam->minimum.custom_string, |
| cparam->maximum.custom_string); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| puts("\nSizes:"); |
| for (i = ppd->num_sizes, size = ppd->sizes; i > 0; i --, size ++) |
| printf(" %s = %gx%g, [%g %g %g %g]\n", size->name, size->width, |
| size->length, size->left, size->bottom, size->right, size->top); |
| |
| puts("\nConstraints:"); |
| |
| for (i = ppd->num_consts, c = ppd->consts; i > 0; i --, c ++) |
| printf(" *UIConstraints: *%s %s *%s %s\n", c->option1, c->choice1, |
| c->option2, c->choice2); |
| if (ppd->num_consts == 0) |
| puts(" NO CONSTRAINTS"); |
| |
| puts("\nFilters:"); |
| |
| for (i = 0; i < ppd->num_filters; i ++) |
| printf(" %s\n", ppd->filters[i]); |
| |
| if (ppd->num_filters == 0) |
| puts(" NO FILTERS"); |
| |
| puts("\nAttributes:"); |
| |
| for (attr = (ppd_attr_t *)cupsArrayFirst(ppd->sorted_attrs); |
| attr; |
| attr = (ppd_attr_t *)cupsArrayNext(ppd->sorted_attrs)) |
| printf(" *%s %s/%s: \"%s\"\n", attr->name, attr->spec, |
| attr->text, attr->value ? attr->value : ""); |
| |
| puts("\nPPD Cache:"); |
| if ((pc = _ppdCacheCreateWithPPD(ppd)) == NULL) |
| printf(" Unable to create: %s\n", cupsLastErrorString()); |
| else |
| { |
| _ppdCacheWriteFile(pc, "t.cache", NULL); |
| puts(" Wrote t.cache."); |
| } |
| } |
| |
| if (!strncmp(argv[1], "-d", 2)) |
| unlink(filename); |
| } |
| |
| #ifdef __APPLE__ |
| if (getenv("MallocStackLogging") && getenv("MallocStackLoggingNoCompact")) |
| { |
| char command[1024]; /* malloc_history command */ |
| |
| snprintf(command, sizeof(command), "malloc_history %d -all_by_size", |
| getpid()); |
| fflush(stdout); |
| system(command); |
| } |
| #endif /* __APPLE__ */ |
| |
| ppdClose(ppd); |
| |
| return (status); |
| } |
| |
| |
| /* |
| * 'do_ppd_tests()' - Test the default option commands in a PPD file. |
| */ |
| |
| static int /* O - Number of errors */ |
| do_ppd_tests(const char *filename, /* I - PPD file */ |
| int num_options, /* I - Number of options */ |
| cups_option_t *options) /* I - Options */ |
| { |
| ppd_file_t *ppd; /* PPD file data */ |
| cups_page_header2_t header; /* Page header */ |
| |
| |
| printf("\"%s\": ", filename); |
| fflush(stdout); |
| |
| if ((ppd = ppdOpenFile(filename)) == NULL) |
| { |
| ppd_status_t status; /* Status from PPD loader */ |
| int line; /* Line number containing error */ |
| |
| |
| status = ppdLastError(&line); |
| |
| puts("FAIL (bad PPD file)"); |
| printf(" %s on line %d\n", ppdErrorString(status), line); |
| |
| return (1); |
| } |
| |
| ppdMarkDefaults(ppd); |
| cupsMarkOptions(ppd, num_options, options); |
| |
| if (cupsRasterInterpretPPD(&header, ppd, 0, NULL, NULL)) |
| { |
| puts("FAIL (error from function)"); |
| puts(cupsRasterErrorString()); |
| |
| return (1); |
| } |
| else |
| { |
| puts("PASS"); |
| |
| return (0); |
| } |
| } |
| |
| |
| /* |
| * 'do_ps_tests()' - Test standard PostScript commands. |
| */ |
| |
| static int |
| do_ps_tests(void) |
| { |
| cups_page_header2_t header; /* Page header */ |
| int preferred_bits; /* Preferred bits */ |
| int errors = 0; /* Number of errors */ |
| |
| |
| /* |
| * Test PS exec code... |
| */ |
| |
| fputs("_cupsRasterExecPS(\"setpagedevice\"): ", stdout); |
| fflush(stdout); |
| |
| memset(&header, 0, sizeof(header)); |
| header.Collate = CUPS_TRUE; |
| preferred_bits = 0; |
| |
| if (_cupsRasterExecPS(&header, &preferred_bits, setpagedevice_code)) |
| { |
| puts("FAIL (error from function)"); |
| puts(cupsRasterErrorString()); |
| errors ++; |
| } |
| else if (preferred_bits != 17 || |
| memcmp(&header, &setpagedevice_header, sizeof(header))) |
| { |
| puts("FAIL (bad header)"); |
| |
| if (preferred_bits != 17) |
| printf(" cupsPreferredBitsPerColor %d, expected 17\n", |
| preferred_bits); |
| |
| print_changes(&setpagedevice_header, &header); |
| errors ++; |
| } |
| else |
| puts("PASS"); |
| |
| fputs("_cupsRasterExecPS(\"roll\"): ", stdout); |
| fflush(stdout); |
| |
| if (_cupsRasterExecPS(&header, &preferred_bits, |
| "792 612 0 0 0\n" |
| "pop pop pop\n" |
| "<</PageSize[5 -2 roll]/ImagingBBox null>>" |
| "setpagedevice\n")) |
| { |
| puts("FAIL (error from function)"); |
| puts(cupsRasterErrorString()); |
| errors ++; |
| } |
| else if (header.PageSize[0] != 792 || header.PageSize[1] != 612) |
| { |
| printf("FAIL (PageSize [%d %d], expected [792 612])\n", header.PageSize[0], |
| header.PageSize[1]); |
| errors ++; |
| } |
| else |
| puts("PASS"); |
| |
| fputs("_cupsRasterExecPS(\"dup index\"): ", stdout); |
| fflush(stdout); |
| |
| if (_cupsRasterExecPS(&header, &preferred_bits, |
| "true false dup\n" |
| "<</Collate 4 index" |
| "/Duplex 5 index" |
| "/Tumble 6 index>>setpagedevice\n" |
| "pop pop pop")) |
| { |
| puts("FAIL (error from function)"); |
| puts(cupsRasterErrorString()); |
| errors ++; |
| } |
| else |
| { |
| if (!header.Collate) |
| { |
| printf("FAIL (Collate false, expected true)\n"); |
| errors ++; |
| } |
| |
| if (header.Duplex) |
| { |
| printf("FAIL (Duplex true, expected false)\n"); |
| errors ++; |
| } |
| |
| if (header.Tumble) |
| { |
| printf("FAIL (Tumble true, expected false)\n"); |
| errors ++; |
| } |
| |
| if(header.Collate && !header.Duplex && !header.Tumble) |
| puts("PASS"); |
| } |
| |
| fputs("_cupsRasterExecPS(\"%%Begin/EndFeature code\"): ", stdout); |
| fflush(stdout); |
| |
| if (_cupsRasterExecPS(&header, &preferred_bits, dsc_code)) |
| { |
| puts("FAIL (error from function)"); |
| puts(cupsRasterErrorString()); |
| errors ++; |
| } |
| else if (header.PageSize[0] != 792 || header.PageSize[1] != 1224) |
| { |
| printf("FAIL (bad PageSize [%d %d], expected [792 1224])\n", |
| header.PageSize[0], header.PageSize[1]); |
| errors ++; |
| } |
| else |
| puts("PASS"); |
| |
| return (errors); |
| } |
| |
| |
| |
| |
| /* |
| * 'print_changes()' - Print differences in the page header. |
| */ |
| |
| static void |
| print_changes( |
| cups_page_header2_t *header, /* I - Actual page header */ |
| cups_page_header2_t *expected) /* I - Expected page header */ |
| { |
| int i; /* Looping var */ |
| |
| |
| if (strcmp(header->MediaClass, expected->MediaClass)) |
| printf(" MediaClass (%s), expected (%s)\n", header->MediaClass, |
| expected->MediaClass); |
| |
| if (strcmp(header->MediaColor, expected->MediaColor)) |
| printf(" MediaColor (%s), expected (%s)\n", header->MediaColor, |
| expected->MediaColor); |
| |
| if (strcmp(header->MediaType, expected->MediaType)) |
| printf(" MediaType (%s), expected (%s)\n", header->MediaType, |
| expected->MediaType); |
| |
| if (strcmp(header->OutputType, expected->OutputType)) |
| printf(" OutputType (%s), expected (%s)\n", header->OutputType, |
| expected->OutputType); |
| |
| if (header->AdvanceDistance != expected->AdvanceDistance) |
| printf(" AdvanceDistance %d, expected %d\n", header->AdvanceDistance, |
| expected->AdvanceDistance); |
| |
| if (header->AdvanceMedia != expected->AdvanceMedia) |
| printf(" AdvanceMedia %d, expected %d\n", header->AdvanceMedia, |
| expected->AdvanceMedia); |
| |
| if (header->Collate != expected->Collate) |
| printf(" Collate %d, expected %d\n", header->Collate, |
| expected->Collate); |
| |
| if (header->CutMedia != expected->CutMedia) |
| printf(" CutMedia %d, expected %d\n", header->CutMedia, |
| expected->CutMedia); |
| |
| if (header->Duplex != expected->Duplex) |
| printf(" Duplex %d, expected %d\n", header->Duplex, |
| expected->Duplex); |
| |
| if (header->HWResolution[0] != expected->HWResolution[0] || |
| header->HWResolution[1] != expected->HWResolution[1]) |
| printf(" HWResolution [%d %d], expected [%d %d]\n", |
| header->HWResolution[0], header->HWResolution[1], |
| expected->HWResolution[0], expected->HWResolution[1]); |
| |
| if (memcmp(header->ImagingBoundingBox, expected->ImagingBoundingBox, |
| sizeof(header->ImagingBoundingBox))) |
| printf(" ImagingBoundingBox [%d %d %d %d], expected [%d %d %d %d]\n", |
| header->ImagingBoundingBox[0], |
| header->ImagingBoundingBox[1], |
| header->ImagingBoundingBox[2], |
| header->ImagingBoundingBox[3], |
| expected->ImagingBoundingBox[0], |
| expected->ImagingBoundingBox[1], |
| expected->ImagingBoundingBox[2], |
| expected->ImagingBoundingBox[3]); |
| |
| if (header->InsertSheet != expected->InsertSheet) |
| printf(" InsertSheet %d, expected %d\n", header->InsertSheet, |
| expected->InsertSheet); |
| |
| if (header->Jog != expected->Jog) |
| printf(" Jog %d, expected %d\n", header->Jog, |
| expected->Jog); |
| |
| if (header->LeadingEdge != expected->LeadingEdge) |
| printf(" LeadingEdge %d, expected %d\n", header->LeadingEdge, |
| expected->LeadingEdge); |
| |
| if (header->Margins[0] != expected->Margins[0] || |
| header->Margins[1] != expected->Margins[1]) |
| printf(" Margins [%d %d], expected [%d %d]\n", |
| header->Margins[0], header->Margins[1], |
| expected->Margins[0], expected->Margins[1]); |
| |
| if (header->ManualFeed != expected->ManualFeed) |
| printf(" ManualFeed %d, expected %d\n", header->ManualFeed, |
| expected->ManualFeed); |
| |
| if (header->MediaPosition != expected->MediaPosition) |
| printf(" MediaPosition %d, expected %d\n", header->MediaPosition, |
| expected->MediaPosition); |
| |
| if (header->MediaWeight != expected->MediaWeight) |
| printf(" MediaWeight %d, expected %d\n", header->MediaWeight, |
| expected->MediaWeight); |
| |
| if (header->MirrorPrint != expected->MirrorPrint) |
| printf(" MirrorPrint %d, expected %d\n", header->MirrorPrint, |
| expected->MirrorPrint); |
| |
| if (header->NegativePrint != expected->NegativePrint) |
| printf(" NegativePrint %d, expected %d\n", header->NegativePrint, |
| expected->NegativePrint); |
| |
| if (header->NumCopies != expected->NumCopies) |
| printf(" NumCopies %d, expected %d\n", header->NumCopies, |
| expected->NumCopies); |
| |
| if (header->Orientation != expected->Orientation) |
| printf(" Orientation %d, expected %d\n", header->Orientation, |
| expected->Orientation); |
| |
| if (header->OutputFaceUp != expected->OutputFaceUp) |
| printf(" OutputFaceUp %d, expected %d\n", header->OutputFaceUp, |
| expected->OutputFaceUp); |
| |
| if (header->PageSize[0] != expected->PageSize[0] || |
| header->PageSize[1] != expected->PageSize[1]) |
| printf(" PageSize [%d %d], expected [%d %d]\n", |
| header->PageSize[0], header->PageSize[1], |
| expected->PageSize[0], expected->PageSize[1]); |
| |
| if (header->Separations != expected->Separations) |
| printf(" Separations %d, expected %d\n", header->Separations, |
| expected->Separations); |
| |
| if (header->TraySwitch != expected->TraySwitch) |
| printf(" TraySwitch %d, expected %d\n", header->TraySwitch, |
| expected->TraySwitch); |
| |
| if (header->Tumble != expected->Tumble) |
| printf(" Tumble %d, expected %d\n", header->Tumble, |
| expected->Tumble); |
| |
| if (header->cupsWidth != expected->cupsWidth) |
| printf(" cupsWidth %d, expected %d\n", header->cupsWidth, |
| expected->cupsWidth); |
| |
| if (header->cupsHeight != expected->cupsHeight) |
| printf(" cupsHeight %d, expected %d\n", header->cupsHeight, |
| expected->cupsHeight); |
| |
| if (header->cupsMediaType != expected->cupsMediaType) |
| printf(" cupsMediaType %d, expected %d\n", header->cupsMediaType, |
| expected->cupsMediaType); |
| |
| if (header->cupsBitsPerColor != expected->cupsBitsPerColor) |
| printf(" cupsBitsPerColor %d, expected %d\n", header->cupsBitsPerColor, |
| expected->cupsBitsPerColor); |
| |
| if (header->cupsBitsPerPixel != expected->cupsBitsPerPixel) |
| printf(" cupsBitsPerPixel %d, expected %d\n", header->cupsBitsPerPixel, |
| expected->cupsBitsPerPixel); |
| |
| if (header->cupsBytesPerLine != expected->cupsBytesPerLine) |
| printf(" cupsBytesPerLine %d, expected %d\n", header->cupsBytesPerLine, |
| expected->cupsBytesPerLine); |
| |
| if (header->cupsColorOrder != expected->cupsColorOrder) |
| printf(" cupsColorOrder %d, expected %d\n", header->cupsColorOrder, |
| expected->cupsColorOrder); |
| |
| if (header->cupsColorSpace != expected->cupsColorSpace) |
| printf(" cupsColorSpace %s, expected %s\n", _cupsRasterColorSpaceString(header->cupsColorSpace), |
| _cupsRasterColorSpaceString(expected->cupsColorSpace)); |
| |
| if (header->cupsCompression != expected->cupsCompression) |
| printf(" cupsCompression %d, expected %d\n", header->cupsCompression, |
| expected->cupsCompression); |
| |
| if (header->cupsRowCount != expected->cupsRowCount) |
| printf(" cupsRowCount %d, expected %d\n", header->cupsRowCount, |
| expected->cupsRowCount); |
| |
| if (header->cupsRowFeed != expected->cupsRowFeed) |
| printf(" cupsRowFeed %d, expected %d\n", header->cupsRowFeed, |
| expected->cupsRowFeed); |
| |
| if (header->cupsRowStep != expected->cupsRowStep) |
| printf(" cupsRowStep %d, expected %d\n", header->cupsRowStep, |
| expected->cupsRowStep); |
| |
| if (header->cupsNumColors != expected->cupsNumColors) |
| printf(" cupsNumColors %d, expected %d\n", header->cupsNumColors, |
| expected->cupsNumColors); |
| |
| if (fabs(header->cupsBorderlessScalingFactor - expected->cupsBorderlessScalingFactor) > 0.001) |
| printf(" cupsBorderlessScalingFactor %g, expected %g\n", |
| header->cupsBorderlessScalingFactor, |
| expected->cupsBorderlessScalingFactor); |
| |
| if (fabs(header->cupsPageSize[0] - expected->cupsPageSize[0]) > 0.001 || |
| fabs(header->cupsPageSize[1] - expected->cupsPageSize[1]) > 0.001) |
| printf(" cupsPageSize [%g %g], expected [%g %g]\n", |
| header->cupsPageSize[0], header->cupsPageSize[1], |
| expected->cupsPageSize[0], expected->cupsPageSize[1]); |
| |
| if (fabs(header->cupsImagingBBox[0] - expected->cupsImagingBBox[0]) > 0.001 || |
| fabs(header->cupsImagingBBox[1] - expected->cupsImagingBBox[1]) > 0.001 || |
| fabs(header->cupsImagingBBox[2] - expected->cupsImagingBBox[2]) > 0.001 || |
| fabs(header->cupsImagingBBox[3] - expected->cupsImagingBBox[3]) > 0.001) |
| printf(" cupsImagingBBox [%g %g %g %g], expected [%g %g %g %g]\n", |
| header->cupsImagingBBox[0], header->cupsImagingBBox[1], |
| header->cupsImagingBBox[2], header->cupsImagingBBox[3], |
| expected->cupsImagingBBox[0], expected->cupsImagingBBox[1], |
| expected->cupsImagingBBox[2], expected->cupsImagingBBox[3]); |
| |
| for (i = 0; i < 16; i ++) |
| if (header->cupsInteger[i] != expected->cupsInteger[i]) |
| printf(" cupsInteger%d %d, expected %d\n", i, header->cupsInteger[i], |
| expected->cupsInteger[i]); |
| |
| for (i = 0; i < 16; i ++) |
| if (fabs(header->cupsReal[i] - expected->cupsReal[i]) > 0.001) |
| printf(" cupsReal%d %g, expected %g\n", i, header->cupsReal[i], |
| expected->cupsReal[i]); |
| |
| for (i = 0; i < 16; i ++) |
| if (strcmp(header->cupsString[i], expected->cupsString[i])) |
| printf(" cupsString%d (%s), expected (%s)\n", i, |
| header->cupsString[i], expected->cupsString[i]); |
| |
| if (strcmp(header->cupsMarkerType, expected->cupsMarkerType)) |
| printf(" cupsMarkerType (%s), expected (%s)\n", header->cupsMarkerType, |
| expected->cupsMarkerType); |
| |
| if (strcmp(header->cupsRenderingIntent, expected->cupsRenderingIntent)) |
| printf(" cupsRenderingIntent (%s), expected (%s)\n", |
| header->cupsRenderingIntent, |
| expected->cupsRenderingIntent); |
| |
| if (strcmp(header->cupsPageSizeName, expected->cupsPageSizeName)) |
| printf(" cupsPageSizeName (%s), expected (%s)\n", |
| header->cupsPageSizeName, |
| expected->cupsPageSizeName); |
| } |