cups/testpwg.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   PWG test program for CUPS.
   5  *
   6  *   Copyright 2009-2011 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 && 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   return (status);
 264 }
 265
 266
 267 /*
 268  * 'test_pagesize()' - Test the PWG mapping functions.
 269  */
 270
 271 static int                              /* O - 1 on failure, 0 on success */
 272 test_pagesize(_ppd_cache_t *pc,         /* I - PWG mapping data */
 273               ppd_file_t   *ppd,        /* I - PPD file */
 274               const char   *ppdsize)    /* I - PPD page size */
 275 {
 276   int           status = 0;             /* Return status */
 277   ipp_t         *job;                   /* Job attributes */
 278   const char    *pagesize;              /* PageSize value */
 279
 280
 281   if (ppdPageSize(ppd, ppdsize))
 282   {
 283     printf("_ppdCacheGetPageSize(keyword=%s): ", ppdsize);
 284     fflush(stdout);
 285
 286     if ((pagesize = _ppdCacheGetPageSize(pc, NULL, ppdsize, NULL)) == NULL)
 287     {
 288       puts("FAIL (Not Found)");
 289       status = 1;
 290     }
 291     else if (strcasecmp(pagesize, ppdsize))
 292     {
 293       printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
 294       status = 1;
 295     }
 296     else
 297       puts("PASS");
 298
 299     job = ippNew();
 300     ippAddString(job, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media", NULL, ppdsize);
 301
 302     printf("_ppdCacheGetPageSize(media=%s): ", ppdsize);
 303     fflush(stdout);
 304
 305     if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
 306     {
 307       puts("FAIL (Not Found)");
 308       status = 1;
 309     }
 310     else if (strcasecmp(pagesize, ppdsize))
 311     {
 312       printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
 313       status = 1;
 314     }
 315     else
 316       puts("PASS");
 317
 318     ippDelete(job);
 319   }
 320
 321   return (status);
 322 }
 323
 324
 325 /*
 326  * 'test_ppd_cache()' - Test the PPD cache functions.
 327  */
 328
 329 static int                              /* O - 1 on failure, 0 on success */
 330 test_ppd_cache(_ppd_cache_t *pc,        /* I - PWG mapping data */
 331                ppd_file_t   *ppd)       /* I - PPD file */
 332 {
 333   int           i,                      /* Looping var */
 334                 status = 0;             /* Return status */
 335   _ppd_cache_t  *pc2;                   /* Loaded data */
 336   _pwg_size_t   *size,                  /* Size from original */
 337                 *size2;                 /* Size from saved */
 338   _pwg_map_t    *map,                   /* Map from original */
 339                 *map2;                  /* Map from saved */
 340
 341
 342  /*
 343   * Verify that we can write and read back the same data...
 344   */
 345
 346   fputs("_ppdCacheWriteFile(test.pwg): ", stdout);
 347   if (!_ppdCacheWriteFile(pc, "test.pwg", NULL))
 348   {
 349     puts("FAIL");
 350     status ++;
 351   }
 352   else
 353     puts("PASS");
 354
 355   fputs("_ppdCacheCreateWithFile(test.pwg): ", stdout);
 356   if ((pc2 = _ppdCacheCreateWithFile("test.pwg", NULL)) == NULL)
 357   {
 358     puts("FAIL");
 359     status ++;
 360   }
 361   else
 362   {
 363     // TODO: FINISH ADDING ALL VALUES IN STRUCTURE
 364     if (pc2->num_sizes != pc->num_sizes)
 365     {
 366       if (!status)
 367         puts("FAIL");
 368
 369       printf("    SAVED num_sizes=%d, ORIG num_sizes=%d\n", pc2->num_sizes,
 370              pc->num_sizes);
 371
 372       status ++;
 373     }
 374     else
 375     {
 376       for (i = pc->num_sizes, size = pc->sizes, size2 = pc2->sizes;
 377            i > 0;
 378            i --, size ++, size2 ++)
 379       {
 380         if (strcmp(size2->map.pwg, size->map.pwg) ||
 381             strcmp(size2->map.ppd, size->map.ppd) ||
 382             size2->width != size->width ||
 383             size2->length != size->length ||
 384             size2->left != size->left ||
 385             size2->bottom != size->bottom ||
 386             size2->right != size->right ||
 387             size2->top != size->top)
 388         {
 389           if (!status)
 390             puts("FAIL");
 391
 392           if (strcmp(size->map.pwg, size2->map.pwg))
 393             printf("    SAVED size->map.pwg=\"%s\", ORIG "
 394                    "size->map.pwg=\"%s\"\n", size2->map.pwg, size->map.pwg);
 395
 396           if (strcmp(size2->map.ppd, size->map.ppd))
 397             printf("    SAVED size->map.ppd=\"%s\", ORIG "
 398                    "size->map.ppd=\"%s\"\n", size2->map.ppd, size->map.ppd);
 399
 400           if (size2->width != size->width)
 401             printf("    SAVED size->width=%d, ORIG size->width=%d\n",
 402                    size2->width, size->width);
 403
 404           if (size2->length != size->length)
 405             printf("    SAVED size->length=%d, ORIG size->length=%d\n",
 406                    size2->length, size->length);
 407
 408           if (size2->left != size->left)
 409             printf("    SAVED size->left=%d, ORIG size->left=%d\n",
 410                    size2->left, size->left);
 411
 412           if (size2->bottom != size->bottom)
 413             printf("    SAVED size->bottom=%d, ORIG size->bottom=%d\n",
 414                    size2->bottom, size->bottom);
 415
 416           if (size2->right != size->right)
 417             printf("    SAVED size->right=%d, ORIG size->right=%d\n",
 418                    size2->right, size->right);
 419
 420           if (size2->top != size->top)
 421             printf("    SAVED size->top=%d, ORIG size->top=%d\n",
 422                    size2->top, size->top);
 423
 424           status ++;
 425           break;
 426         }
 427       }
 428
 429       for (i = pc->num_sources, map = pc->sources, map2 = pc2->sources;
 430            i > 0;
 431            i --, map ++, map2 ++)
 432       {
 433         if (strcmp(map2->pwg, map->pwg) ||
 434             strcmp(map2->ppd, map->ppd))
 435         {
 436           if (!status)
 437             puts("FAIL");
 438
 439           if (strcmp(map->pwg, map2->pwg))
 440             printf("    SAVED source->pwg=\"%s\", ORIG source->pwg=\"%s\"\n",
 441                    map2->pwg, map->pwg);
 442
 443           if (strcmp(map2->ppd, map->ppd))
 444             printf("    SAVED source->ppd=\"%s\", ORIG source->ppd=\"%s\"\n",
 445                    map2->ppd, map->ppd);
 446
 447           status ++;
 448           break;
 449         }
 450       }
 451
 452       for (i = pc->num_types, map = pc->types, map2 = pc2->types;
 453            i > 0;
 454            i --, map ++, map2 ++)
 455       {
 456         if (strcmp(map2->pwg, map->pwg) ||
 457             strcmp(map2->ppd, map->ppd))
 458         {
 459           if (!status)
 460             puts("FAIL");
 461
 462           if (strcmp(map->pwg, map2->pwg))
 463             printf("    SAVED type->pwg=\"%s\", ORIG type->pwg=\"%s\"\n",
 464                    map2->pwg, map->pwg);
 465
 466           if (strcmp(map2->ppd, map->ppd))
 467             printf("    SAVED type->ppd=\"%s\", ORIG type->ppd=\"%s\"\n",
 468                    map2->ppd, map->ppd);
 469
 470           status ++;
 471           break;
 472         }
 473       }
 474     }
 475
 476     if (!status)
 477       puts("PASS");
 478
 479     _ppdCacheDestroy(pc2);
 480   }
 481
 482  /*
 483   * Test PageSize mapping code...
 484   */
 485
 486   status += test_pagesize(pc, ppd, "Letter");
 487   status += test_pagesize(pc, ppd, "na-letter");
 488   status += test_pagesize(pc, ppd, "A4");
 489   status += test_pagesize(pc, ppd, "iso-a4");
 490
 491   return (status);
 492 }
 493
 494
 495 /*
 496  * End of "$Id$".
 497  */