You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1787 lines
50 KiB

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

/*
* 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);
}