cups/testpwg.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   PWG test program for CUPS.
   5  *
   6  *   Copyright 2009-2013 by Apple Inc.
   7  *
   8  *   These coded instructions, statements, and computer programs are the
   9  *   property of Apple Inc. and are protected by Federal copyright
  10  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  11  *   which should have been included with this file.  If this file is
  12  *   file is missing or damaged, see the license at "http://www.cups.org/".
  13  *
  14  *   This file is subject to the Apple OS-Developed Software exception.
  15  *
  16  * Contents:
  17  *
  18  *   main()           - Main entry.
  19  *   test_pagesize()  - Test the PWG mapping functions.
  20  *   test_ppd_cache() - Test the PPD cache functions.
  21  */
  22
  23 /*
  24  * Include necessary headers...
  25  */
  26
  27 #include "ppd-private.h"
  28 #include "file-private.h"
  29
  30
  31 /*
  32  * Local functions...
  33  */
  34
  35 static int      test_pagesize(_ppd_cache_t *pc, ppd_file_t *ppd,
  36                               const char *ppdsize);
  37 static int      test_ppd_cache(_ppd_cache_t *pc, ppd_file_t *ppd);
  38
  39
  40 /*
  41  * 'main()' - Main entry.
  42  */
  43
  44 int                                     /* O - Exit status */
  45 main(int  argc,                         /* I - Number of command-line args */
  46      char *argv[])                      /* I - Command-line arguments */
  47 {
  48   int           status;                 /* Status of tests (0 = success, 1 = fail) */
  49   const char    *ppdfile;               /* PPD filename */
  50   ppd_file_t    *ppd;                   /* PPD file */
  51   _ppd_cache_t  *pc;                    /* PPD cache and PWG mapping data */
  52   pwg_media_t   *pwgmedia;              /* PWG media size */
  53
  54
  55   status = 0;
  56
  57   if (argc < 2 || argc > 3)
  58   {
  59     puts("Usage: ./testpwg filename.ppd [jobfile]");
  60     return (1);
  61   }
  62
  63   ppdfile = argv[1];
  64
  65   printf("ppdOpenFile(%s): ", ppdfile);
  66   if ((ppd = ppdOpenFile(ppdfile)) == NULL)
  67   {
  68     ppd_status_t err;                   /* Last error in file */
  69     int         line;                   /* Line number in file */
  70
  71
  72     err = ppdLastError(&line);
  73
  74     printf("FAIL (%s on line %d)\n", ppdErrorString(err), line);
  75
  76     return (1);
  77   }
  78   else
  79     puts("PASS");
  80
  81   fputs("_ppdCacheCreateWithPPD(ppd): ", stdout);
  82   if ((pc = _ppdCacheCreateWithPPD(ppd)) == NULL)
  83   {
  84     puts("FAIL");
  85     status ++;
  86   }
  87   else
  88   {
  89     puts("PASS");
  90     status += test_ppd_cache(pc, ppd);
  91
  92     if (argc == 3)
  93     {
  94      /*
  95       * Test PageSize mapping code.
  96       */
  97
  98       int               fd;             /* Job file descriptor */
  99       const char        *pagesize;      /* PageSize value */
 100       ipp_t             *job;           /* Job attributes */
 101       ipp_attribute_t   *media;         /* Media attribute */
 102
 103       if ((fd = open(argv[2], O_RDONLY)) >= 0)
 104       {
 105         job = ippNew();
 106         ippReadFile(fd, job);
 107         close(fd);
 108
 109         if ((media = ippFindAttribute(job, "media", IPP_TAG_ZERO)) != NULL &&
 110             media->value_tag != IPP_TAG_NAME &&
 111             media->value_tag != IPP_TAG_KEYWORD)
 112           media = NULL;
 113
 114         if (media)
 115           printf("_ppdCacheGetPageSize(media=%s): ",
 116                  media->values[0].string.text);
 117         else
 118           fputs("_ppdCacheGetPageSize(media-col): ", stdout);
 119
 120         fflush(stdout);
 121
 122         if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
 123         {
 124           puts("FAIL (Not Found)");
 125           status = 1;
 126         }
 127         else if (media && _cups_strcasecmp(pagesize, media->values[0].string.text))
 128         {
 129           printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize,
 130                  media->values[0].string.text);
 131           status = 1;
 132         }
 133         else
 134           printf("PASS (%s)\n", pagesize);
 135
 136         ippDelete(job);
 137       }
 138       else
 139       {
 140         perror(argv[2]);
 141         status = 1;
 142       }
 143     }
 144
 145    /*
 146     * _ppdCacheDestroy should never fail...
 147     */
 148
 149     fputs("_ppdCacheDestroy(pc): ", stdout);
 150     _ppdCacheDestroy(pc);
 151     puts("PASS");
 152   }
 153
 154   fputs("pwgMediaForPWG(\"iso_a4_210x297mm\"): ", stdout);
 155   if ((pwgmedia = pwgMediaForPWG("iso_a4_210x297mm")) == NULL)
 156   {
 157     puts("FAIL (not found)");
 158     status ++;
 159   }
 160   else if (strcmp(pwgmedia->pwg, "iso_a4_210x297mm"))
 161   {
 162     printf("FAIL (%s)\n", pwgmedia->pwg);
 163     status ++;
 164   }
 165   else if (pwgmedia->width != 21000 || pwgmedia->length != 29700)
 166   {
 167     printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
 168     status ++;
 169   }
 170   else
 171     puts("PASS");
 172
 173   fputs("pwgMediaForLegacy(\"na-letter\"): ", stdout);
 174   if ((pwgmedia = pwgMediaForLegacy("na-letter")) == NULL)
 175   {
 176     puts("FAIL (not found)");
 177     status ++;
 178   }
 179   else if (strcmp(pwgmedia->pwg, "na_letter_8.5x11in"))
 180   {
 181     printf("FAIL (%s)\n", pwgmedia->pwg);
 182     status ++;
 183   }
 184   else if (pwgmedia->width != 21590 || pwgmedia->length != 27940)
 185   {
 186     printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
 187     status ++;
 188   }
 189   else
 190     puts("PASS");
 191
 192   fputs("pwgMediaForPPD(\"4x6\"): ", stdout);
 193   if ((pwgmedia = pwgMediaForPPD("4x6")) == NULL)
 194   {
 195     puts("FAIL (not found)");
 196     status ++;
 197   }
 198   else if (strcmp(pwgmedia->pwg, "na_index-4x6_4x6in"))
 199   {
 200     printf("FAIL (%s)\n", pwgmedia->pwg);
 201     status ++;
 202   }
 203   else if (pwgmedia->width != 10160 || pwgmedia->length != 15240)
 204   {
 205     printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
 206     status ++;
 207   }
 208   else
 209     puts("PASS");
 210
 211   fputs("pwgMediaForPPD(\"10x15cm\"): ", stdout);
 212   if ((pwgmedia = pwgMediaForPPD("10x15cm")) == NULL)
 213   {
 214     puts("FAIL (not found)");
 215     status ++;
 216   }
 217   else if (strcmp(pwgmedia->pwg, "om_100x150mm_100x150mm"))
 218   {
 219     printf("FAIL (%s)\n", pwgmedia->pwg);
 220     status ++;
 221   }
 222   else if (pwgmedia->width != 10000 || pwgmedia->length != 15000)
 223   {
 224     printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
 225     status ++;
 226   }
 227   else
 228     puts("PASS");
 229
 230   fputs("pwgMediaForPPD(\"Custom.10x15cm\"): ", stdout);
 231   if ((pwgmedia = pwgMediaForPPD("Custom.10x15cm")) == NULL)
 232   {
 233     puts("FAIL (not found)");
 234     status ++;
 235   }
 236   else if (strcmp(pwgmedia->pwg, "custom_10x15cm_100x150mm"))
 237   {
 238     printf("FAIL (%s)\n", pwgmedia->pwg);
 239     status ++;
 240   }
 241   else if (pwgmedia->width != 10000 || pwgmedia->length != 15000)
 242   {
 243     printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
 244     status ++;
 245   }
 246   else
 247     puts("PASS");
 248
 249   fputs("pwgMediaForSize(29700, 42000): ", stdout);
 250   if ((pwgmedia = pwgMediaForSize(29700, 42000)) == NULL)
 251   {
 252     puts("FAIL (not found)");
 253     status ++;
 254   }
 255   else if (strcmp(pwgmedia->pwg, "iso_a3_297x420mm"))
 256   {
 257     printf("FAIL (%s)\n", pwgmedia->pwg);
 258     status ++;
 259   }
 260   else
 261     puts("PASS");
 262
 263   fputs("pwgMediaForSize(9842, 19050): ", stdout);
 264   if ((pwgmedia = pwgMediaForSize(9842, 19050)) == NULL)
 265   {
 266     puts("FAIL (not found)");
 267     status ++;
 268   }
 269   else if (strcmp(pwgmedia->pwg, "na_monarch_3.875x7.5in"))
 270   {
 271     printf("FAIL (%s)\n", pwgmedia->pwg);
 272     status ++;
 273   }
 274   else
 275     printf("PASS (%s)\n", pwgmedia->pwg);
 276
 277   fputs("pwgMediaForSize(9800, 19000): ", stdout);
 278   if ((pwgmedia = pwgMediaForSize(9800, 19000)) == NULL)
 279   {
 280     puts("FAIL (not found)");
 281     status ++;
 282   }
 283   else if (strcmp(pwgmedia->pwg, "jpn_you6_98x190mm"))
 284   {
 285     printf("FAIL (%s)\n", pwgmedia->pwg);
 286     status ++;
 287   }
 288   else
 289     printf("PASS (%s)\n", pwgmedia->pwg);
 290
 291   return (status);
 292 }
 293
 294
 295 /*
 296  * 'test_pagesize()' - Test the PWG mapping functions.
 297  */
 298
 299 static int                              /* O - 1 on failure, 0 on success */
 300 test_pagesize(_ppd_cache_t *pc,         /* I - PWG mapping data */
 301               ppd_file_t   *ppd,        /* I - PPD file */
 302               const char   *ppdsize)    /* I - PPD page size */
 303 {
 304   int           status = 0;             /* Return status */
 305   ipp_t         *job;                   /* Job attributes */
 306   const char    *pagesize;              /* PageSize value */
 307
 308
 309   if (ppdPageSize(ppd, ppdsize))
 310   {
 311     printf("_ppdCacheGetPageSize(keyword=%s): ", ppdsize);
 312     fflush(stdout);
 313
 314     if ((pagesize = _ppdCacheGetPageSize(pc, NULL, ppdsize, NULL)) == NULL)
 315     {
 316       puts("FAIL (Not Found)");
 317       status = 1;
 318     }
 319     else if (_cups_strcasecmp(pagesize, ppdsize))
 320     {
 321       printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
 322       status = 1;
 323     }
 324     else
 325       puts("PASS");
 326
 327     job = ippNew();
 328     ippAddString(job, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media", NULL, ppdsize);
 329
 330     printf("_ppdCacheGetPageSize(media=%s): ", ppdsize);
 331     fflush(stdout);
 332
 333     if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
 334     {
 335       puts("FAIL (Not Found)");
 336       status = 1;
 337     }
 338     else if (_cups_strcasecmp(pagesize, ppdsize))
 339     {
 340       printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
 341       status = 1;
 342     }
 343     else
 344       puts("PASS");
 345
 346     ippDelete(job);
 347   }
 348
 349   return (status);
 350 }
 351
 352
 353 /*
 354  * 'test_ppd_cache()' - Test the PPD cache functions.
 355  */
 356
 357 static int                              /* O - 1 on failure, 0 on success */
 358 test_ppd_cache(_ppd_cache_t *pc,        /* I - PWG mapping data */
 359                ppd_file_t   *ppd)       /* I - PPD file */
 360 {
 361   int           i,                      /* Looping var */
 362                 status = 0;             /* Return status */
 363   _ppd_cache_t  *pc2;                   /* Loaded data */
 364   pwg_size_t    *size,                  /* Size from original */
 365                 *size2;                 /* Size from saved */
 366   pwg_map_t     *map,                   /* Map from original */
 367                 *map2;                  /* Map from saved */
 368
 369
 370  /*
 371   * Verify that we can write and read back the same data...
 372   */
 373
 374   fputs("_ppdCacheWriteFile(test.pwg): ", stdout);
 375   if (!_ppdCacheWriteFile(pc, "test.pwg", NULL))
 376   {
 377     puts("FAIL");
 378     status ++;
 379   }
 380   else
 381     puts("PASS");
 382
 383   fputs("_ppdCacheCreateWithFile(test.pwg): ", stdout);
 384   if ((pc2 = _ppdCacheCreateWithFile("test.pwg", NULL)) == NULL)
 385   {
 386     puts("FAIL");
 387     status ++;
 388   }
 389   else
 390   {
 391     // TODO: FINISH ADDING ALL VALUES IN STRUCTURE
 392     if (pc2->num_sizes != pc->num_sizes)
 393     {
 394       if (!status)
 395         puts("FAIL");
 396
 397       printf("    SAVED num_sizes=%d, ORIG num_sizes=%d\n", pc2->num_sizes,
 398              pc->num_sizes);
 399
 400       status ++;
 401     }
 402     else
 403     {
 404       for (i = pc->num_sizes, size = pc->sizes, size2 = pc2->sizes;
 405            i > 0;
 406            i --, size ++, size2 ++)
 407       {
 408         if (strcmp(size2->map.pwg, size->map.pwg) ||
 409             strcmp(size2->map.ppd, size->map.ppd) ||
 410             size2->width != size->width ||
 411             size2->length != size->length ||
 412             size2->left != size->left ||
 413             size2->bottom != size->bottom ||
 414             size2->right != size->right ||
 415             size2->top != size->top)
 416         {
 417           if (!status)
 418             puts("FAIL");
 419
 420           if (strcmp(size->map.pwg, size2->map.pwg))
 421             printf("    SAVED size->map.pwg=\"%s\", ORIG "
 422                    "size->map.pwg=\"%s\"\n", size2->map.pwg, size->map.pwg);
 423
 424           if (strcmp(size2->map.ppd, size->map.ppd))
 425             printf("    SAVED size->map.ppd=\"%s\", ORIG "
 426                    "size->map.ppd=\"%s\"\n", size2->map.ppd, size->map.ppd);
 427
 428           if (size2->width != size->width)
 429             printf("    SAVED size->width=%d, ORIG size->width=%d\n",
 430                    size2->width, size->width);
 431
 432           if (size2->length != size->length)
 433             printf("    SAVED size->length=%d, ORIG size->length=%d\n",
 434                    size2->length, size->length);
 435
 436           if (size2->left != size->left)
 437             printf("    SAVED size->left=%d, ORIG size->left=%d\n",
 438                    size2->left, size->left);
 439
 440           if (size2->bottom != size->bottom)
 441             printf("    SAVED size->bottom=%d, ORIG size->bottom=%d\n",
 442                    size2->bottom, size->bottom);
 443
 444           if (size2->right != size->right)
 445             printf("    SAVED size->right=%d, ORIG size->right=%d\n",
 446                    size2->right, size->right);
 447
 448           if (size2->top != size->top)
 449             printf("    SAVED size->top=%d, ORIG size->top=%d\n",
 450                    size2->top, size->top);
 451
 452           status ++;
 453           break;
 454         }
 455       }
 456
 457       for (i = pc->num_sources, map = pc->sources, map2 = pc2->sources;
 458            i > 0;
 459            i --, map ++, map2 ++)
 460       {
 461         if (strcmp(map2->pwg, map->pwg) ||
 462             strcmp(map2->ppd, map->ppd))
 463         {
 464           if (!status)
 465             puts("FAIL");
 466
 467           if (strcmp(map->pwg, map2->pwg))
 468             printf("    SAVED source->pwg=\"%s\", ORIG source->pwg=\"%s\"\n",
 469                    map2->pwg, map->pwg);
 470
 471           if (strcmp(map2->ppd, map->ppd))
 472             printf("    SAVED source->ppd=\"%s\", ORIG source->ppd=\"%s\"\n",
 473                    map2->ppd, map->ppd);
 474
 475           status ++;
 476           break;
 477         }
 478       }
 479
 480       for (i = pc->num_types, map = pc->types, map2 = pc2->types;
 481            i > 0;
 482            i --, map ++, map2 ++)
 483       {
 484         if (strcmp(map2->pwg, map->pwg) ||
 485             strcmp(map2->ppd, map->ppd))
 486         {
 487           if (!status)
 488             puts("FAIL");
 489
 490           if (strcmp(map->pwg, map2->pwg))
 491             printf("    SAVED type->pwg=\"%s\", ORIG type->pwg=\"%s\"\n",
 492                    map2->pwg, map->pwg);
 493
 494           if (strcmp(map2->ppd, map->ppd))
 495             printf("    SAVED type->ppd=\"%s\", ORIG type->ppd=\"%s\"\n",
 496                    map2->ppd, map->ppd);
 497
 498           status ++;
 499           break;
 500         }
 501       }
 502     }
 503
 504     if (!status)
 505       puts("PASS");
 506
 507     _ppdCacheDestroy(pc2);
 508   }
 509
 510  /*
 511   * Test PageSize mapping code...
 512   */
 513
 514   status += test_pagesize(pc, ppd, "Letter");
 515   status += test_pagesize(pc, ppd, "na-letter");
 516   status += test_pagesize(pc, ppd, "A4");
 517   status += test_pagesize(pc, ppd, "iso-a4");
 518
 519   return (status);
 520 }
 521
 522
 523 /*
 524  * End of "$Id$".
 525  */