[thirdparty/cups.git] / cups / testpwg.c

/*
 * "$Id$"
 *
 *   PWG test program for CUPS.
 *
 *   Copyright 2009-2013 by Apple Inc.
 *
 *   These coded instructions, statements, and computer programs are the
 *   property of Apple Inc. and are protected by Federal copyright
 *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
 *   which should have been included with this file.  If this file is
 *   file is missing or damaged, see the license at "http://www.cups.org/".
 *
 *   This file is subject to the Apple OS-Developed Software exception.
 *
 * Contents:
 *
 *   main()           - Main entry.
 *   test_pagesize()  - Test the PWG mapping functions.
 *   test_ppd_cache() - Test the PPD cache functions.
 */

/*
 * Include necessary headers...
 */

#include "ppd-private.h"
#include "file-private.h"


/*
 * Local functions...
 */

static int	test_pagesize(_ppd_cache_t *pc, ppd_file_t *ppd,
		              const char *ppdsize);
static int	test_ppd_cache(_ppd_cache_t *pc, ppd_file_t *ppd);


/*
 * 'main()' - Main entry.
 */

int					/* O - Exit status */
main(int  argc,				/* I - Number of command-line args */
     char *argv[])			/* I - Command-line arguments */
{
  int		status;			/* Status of tests (0 = success, 1 = fail) */
  const char	*ppdfile;		/* PPD filename */
  ppd_file_t	*ppd;			/* PPD file */
  _ppd_cache_t	*pc;			/* PPD cache and PWG mapping data */
  pwg_media_t	*pwgmedia;		/* PWG media size */


  status = 0;

  if (argc < 2 || argc > 3)
  {
    puts("Usage: ./testpwg filename.ppd [jobfile]");
    return (1);
  }

  ppdfile = argv[1];

  printf("ppdOpenFile(%s): ", ppdfile);
  if ((ppd = ppdOpenFile(ppdfile)) == NULL)
  {
    ppd_status_t err;			/* Last error in file */
    int		line;			/* Line number in file */


    err = ppdLastError(&line);

    printf("FAIL (%s on line %d)\n", ppdErrorString(err), line);

    return (1);
  }
  else
    puts("PASS");

  fputs("_ppdCacheCreateWithPPD(ppd): ", stdout);
  if ((pc = _ppdCacheCreateWithPPD(ppd)) == NULL)
  {
    puts("FAIL");
    status ++;
  }
  else
  {
    puts("PASS");
    status += test_ppd_cache(pc, ppd);

    if (argc == 3)
    {
     /*
      * Test PageSize mapping code.
      */

      int		fd;		/* Job file descriptor */
      const char	*pagesize;	/* PageSize value */
      ipp_t		*job;		/* Job attributes */
      ipp_attribute_t	*media;		/* Media attribute */

      if ((fd = open(argv[2], O_RDONLY)) >= 0)
      {
	job = ippNew();
	ippReadFile(fd, job);
	close(fd);

        if ((media = ippFindAttribute(job, "media", IPP_TAG_ZERO)) != NULL &&
	    media->value_tag != IPP_TAG_NAME &&
	    media->value_tag != IPP_TAG_KEYWORD)
	  media = NULL;

	if (media)
	  printf("_ppdCacheGetPageSize(media=%s): ",
	         media->values[0].string.text);
	else
	  fputs("_ppdCacheGetPageSize(media-col): ", stdout);

        fflush(stdout);

	if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
	{
	  puts("FAIL (Not Found)");
	  status = 1;
	}
	else if (media && _cups_strcasecmp(pagesize, media->values[0].string.text))
	{
	  printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize,
		 media->values[0].string.text);
	  status = 1;
	}
	else
	  printf("PASS (%s)\n", pagesize);

	ippDelete(job);
      }
      else
      {
        perror(argv[2]);
	status = 1;
      }
    }

   /*
    * _ppdCacheDestroy should never fail...
    */

    fputs("_ppdCacheDestroy(pc): ", stdout);
    _ppdCacheDestroy(pc);
    puts("PASS");
  }

  fputs("pwgMediaForPWG(\"iso_a4_210x297mm\"): ", stdout);
  if ((pwgmedia = pwgMediaForPWG("iso_a4_210x297mm")) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "iso_a4_210x297mm"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else if (pwgmedia->width != 21000 || pwgmedia->length != 29700)
  {
    printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
    status ++;
  }
  else
    puts("PASS");

  fputs("pwgMediaForPWG(\"roll_max_36.1025x3622.0472in\"): ", stdout);
  if ((pwgmedia = pwgMediaForPWG("roll_max_36.1025x3622.0472in")) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (pwgmedia->width != 91700 || pwgmedia->length != 9199999)
  {
    printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
    status ++;
  }
  else
    printf("PASS (%dx%d)\n", pwgmedia->width, pwgmedia->length);

  fputs("pwgMediaForLegacy(\"na-letter\"): ", stdout);
  if ((pwgmedia = pwgMediaForLegacy("na-letter")) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "na_letter_8.5x11in"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else if (pwgmedia->width != 21590 || pwgmedia->length != 27940)
  {
    printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
    status ++;
  }
  else
    puts("PASS");

  fputs("pwgMediaForPPD(\"4x6\"): ", stdout);
  if ((pwgmedia = pwgMediaForPPD("4x6")) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "na_index-4x6_4x6in"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else if (pwgmedia->width != 10160 || pwgmedia->length != 15240)
  {
    printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
    status ++;
  }
  else
    puts("PASS");

  fputs("pwgMediaForPPD(\"10x15cm\"): ", stdout);
  if ((pwgmedia = pwgMediaForPPD("10x15cm")) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "om_100x150mm_100x150mm"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else if (pwgmedia->width != 10000 || pwgmedia->length != 15000)
  {
    printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
    status ++;
  }
  else
    puts("PASS");

  fputs("pwgMediaForPPD(\"Custom.10x15cm\"): ", stdout);
  if ((pwgmedia = pwgMediaForPPD("Custom.10x15cm")) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "custom_10x15cm_100x150mm"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else if (pwgmedia->width != 10000 || pwgmedia->length != 15000)
  {
    printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
    status ++;
  }
  else
    puts("PASS");

  fputs("pwgMediaForSize(29700, 42000): ", stdout);
  if ((pwgmedia = pwgMediaForSize(29700, 42000)) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "iso_a3_297x420mm"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else
    puts("PASS");

  fputs("pwgMediaForSize(9842, 19050): ", stdout);
  if ((pwgmedia = pwgMediaForSize(9842, 19050)) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "na_monarch_3.875x7.5in"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else
    printf("PASS (%s)\n", pwgmedia->pwg);

  fputs("pwgMediaForSize(9800, 19000): ", stdout);
  if ((pwgmedia = pwgMediaForSize(9800, 19000)) == NULL)
  {
    puts("FAIL (not found)");
    status ++;
  }
  else if (strcmp(pwgmedia->pwg, "jpn_you6_98x190mm"))
  {
    printf("FAIL (%s)\n", pwgmedia->pwg);
    status ++;
  }
  else
    printf("PASS (%s)\n", pwgmedia->pwg);

  return (status);
}


/*
 * 'test_pagesize()' - Test the PWG mapping functions.
 */

static int				/* O - 1 on failure, 0 on success */
test_pagesize(_ppd_cache_t *pc,		/* I - PWG mapping data */
              ppd_file_t   *ppd,	/* I - PPD file */
	      const char   *ppdsize)	/* I - PPD page size */
{
  int		status = 0;		/* Return status */
  ipp_t		*job;			/* Job attributes */
  const char	*pagesize;		/* PageSize value */


  if (ppdPageSize(ppd, ppdsize))
  {
    printf("_ppdCacheGetPageSize(keyword=%s): ", ppdsize);
    fflush(stdout);

    if ((pagesize = _ppdCacheGetPageSize(pc, NULL, ppdsize, NULL)) == NULL)
    {
      puts("FAIL (Not Found)");
      status = 1;
    }
    else if (_cups_strcasecmp(pagesize, ppdsize))
    {
      printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
      status = 1;
    }
    else
      puts("PASS");

    job = ippNew();
    ippAddString(job, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media", NULL, ppdsize);

    printf("_ppdCacheGetPageSize(media=%s): ", ppdsize);
    fflush(stdout);

    if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
    {
      puts("FAIL (Not Found)");
      status = 1;
    }
    else if (_cups_strcasecmp(pagesize, ppdsize))
    {
      printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
      status = 1;
    }
    else
      puts("PASS");

    ippDelete(job);
  }

  return (status);
}


/*
 * 'test_ppd_cache()' - Test the PPD cache functions.
 */

static int				/* O - 1 on failure, 0 on success */
test_ppd_cache(_ppd_cache_t *pc,	/* I - PWG mapping data */
               ppd_file_t   *ppd)	/* I - PPD file */
{
  int		i,			/* Looping var */
		status = 0;		/* Return status */
  _ppd_cache_t	*pc2;			/* Loaded data */
  pwg_size_t	*size,			/* Size from original */
		*size2;			/* Size from saved */
  pwg_map_t	*map,			/* Map from original */
		*map2;			/* Map from saved */


 /*
  * Verify that we can write and read back the same data...
  */

  fputs("_ppdCacheWriteFile(test.pwg): ", stdout);
  if (!_ppdCacheWriteFile(pc, "test.pwg", NULL))
  {
    puts("FAIL");
    status ++;
  }
  else
    puts("PASS");

  fputs("_ppdCacheCreateWithFile(test.pwg): ", stdout);
  if ((pc2 = _ppdCacheCreateWithFile("test.pwg", NULL)) == NULL)
  {
    puts("FAIL");
    status ++;
  }
  else
  {
    // TODO: FINISH ADDING ALL VALUES IN STRUCTURE
    if (pc2->num_sizes != pc->num_sizes)
    {
      if (!status)
        puts("FAIL");

      printf("    SAVED num_sizes=%d, ORIG num_sizes=%d\n", pc2->num_sizes,
             pc->num_sizes);

      status ++;
    }
    else
    {
      for (i = pc->num_sizes, size = pc->sizes, size2 = pc2->sizes;
           i > 0;
	   i --, size ++, size2 ++)
      {
        if (strcmp(size2->map.pwg, size->map.pwg) ||
	    strcmp(size2->map.ppd, size->map.ppd) ||
	    size2->width != size->width ||
	    size2->length != size->length ||
	    size2->left != size->left ||
	    size2->bottom != size->bottom ||
	    size2->right != size->right ||
	    size2->top != size->top)
	{
	  if (!status)
	    puts("FAIL");

	  if (strcmp(size->map.pwg, size2->map.pwg))
	    printf("    SAVED size->map.pwg=\"%s\", ORIG "
	           "size->map.pwg=\"%s\"\n", size2->map.pwg, size->map.pwg);

	  if (strcmp(size2->map.ppd, size->map.ppd))
	    printf("    SAVED size->map.ppd=\"%s\", ORIG "
	           "size->map.ppd=\"%s\"\n", size2->map.ppd, size->map.ppd);

	  if (size2->width != size->width)
	    printf("    SAVED size->width=%d, ORIG size->width=%d\n",
		   size2->width, size->width);

	  if (size2->length != size->length)
	    printf("    SAVED size->length=%d, ORIG size->length=%d\n",
		   size2->length, size->length);

	  if (size2->left != size->left)
	    printf("    SAVED size->left=%d, ORIG size->left=%d\n",
		   size2->left, size->left);

	  if (size2->bottom != size->bottom)
	    printf("    SAVED size->bottom=%d, ORIG size->bottom=%d\n",
		   size2->bottom, size->bottom);

	  if (size2->right != size->right)
	    printf("    SAVED size->right=%d, ORIG size->right=%d\n",
		   size2->right, size->right);

	  if (size2->top != size->top)
	    printf("    SAVED size->top=%d, ORIG size->top=%d\n",
		   size2->top, size->top);

	  status ++;
	  break;
	}
      }

      for (i = pc->num_sources, map = pc->sources, map2 = pc2->sources;
           i > 0;
	   i --, map ++, map2 ++)
      {
        if (strcmp(map2->pwg, map->pwg) ||
	    strcmp(map2->ppd, map->ppd))
	{
	  if (!status)
	    puts("FAIL");

	  if (strcmp(map->pwg, map2->pwg))
	    printf("    SAVED source->pwg=\"%s\", ORIG source->pwg=\"%s\"\n",
	           map2->pwg, map->pwg);

	  if (strcmp(map2->ppd, map->ppd))
	    printf("    SAVED source->ppd=\"%s\", ORIG source->ppd=\"%s\"\n",
	           map2->ppd, map->ppd);

	  status ++;
	  break;
	}
      }

      for (i = pc->num_types, map = pc->types, map2 = pc2->types;
           i > 0;
	   i --, map ++, map2 ++)
      {
        if (strcmp(map2->pwg, map->pwg) ||
	    strcmp(map2->ppd, map->ppd))
	{
	  if (!status)
	    puts("FAIL");

	  if (strcmp(map->pwg, map2->pwg))
	    printf("    SAVED type->pwg=\"%s\", ORIG type->pwg=\"%s\"\n",
	           map2->pwg, map->pwg);

	  if (strcmp(map2->ppd, map->ppd))
	    printf("    SAVED type->ppd=\"%s\", ORIG type->ppd=\"%s\"\n",
	           map2->ppd, map->ppd);

	  status ++;
	  break;
	}
      }
    }

    if (!status)
      puts("PASS");

    _ppdCacheDestroy(pc2);
  }

 /*
  * Test PageSize mapping code...
  */

  status += test_pagesize(pc, ppd, "Letter");
  status += test_pagesize(pc, ppd, "na-letter");
  status += test_pagesize(pc, ppd, "A4");
  status += test_pagesize(pc, ppd, "iso-a4");

  return (status);
}


/*
 * End of "$Id$".
 */
Commit	Line	Data
54afec33 MS	1	/*
	2	* "$Id$"
	3	*
	4	* PWG test program for CUPS.
	5	*
6961465f	6	* Copyright 2009-2013 by Apple Inc.
54afec33 MS	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	*
f14324a7 MS	18	* main() - Main entry.
	19	* test_pagesize() - Test the PWG mapping functions.
	20	* test_ppd_cache() - Test the PPD cache functions.
54afec33 MS	21	*/
	22
	23	/*
	24	* Include necessary headers...
	25	*/
	26
aaf19ab0	27	#include "ppd-private.h"
6c48a6ca	28	#include "file-private.h"
54afec33 MS	29
	30
	31	/*
	32	* Local functions...
	33	*/
	34
f14324a7	35	static int test_pagesize(_ppd_cache_t pc, ppd_file_t ppd,
6c48a6ca	36	const char *ppdsize);
f14324a7	37	static int test_ppd_cache(_ppd_cache_t pc, ppd_file_t ppd);
54afec33 MS	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 */
f14324a7	51	_ppd_cache_t pc; / PPD cache and PWG mapping data */
6961465f	52	pwg_media_t pwgmedia; / PWG media size */
54afec33 MS	53
	54
	55	status = 0;
	56
6c48a6ca	57	if (argc < 2 \|\| argc > 3)
54afec33	58	{
6c48a6ca	59	puts("Usage: ./testpwg filename.ppd [jobfile]");
54afec33 MS	60	return (1);
54afec33 MS	61	}
6c48a6ca MS	62
6c48a6ca MS	63	ppdfile = argv[1];
54afec33 MS	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
f14324a7 MS	81	fputs("_ppdCacheCreateWithPPD(ppd): ", stdout);
f14324a7 MS	82	if ((pc = _ppdCacheCreateWithPPD(ppd)) == NULL)
54afec33 MS	83	{
	84	puts("FAIL");
	85	status ++;
	86	}
	87	else
	88	{
	89	puts("PASS");
f14324a7	90	status += test_ppd_cache(pc, ppd);
6c48a6ca MS	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)
f14324a7 MS	115	printf("_ppdCacheGetPageSize(media=%s): ",
f14324a7 MS	116	media->values[0].string.text);
6c48a6ca	117	else
f14324a7	118	fputs("_ppdCacheGetPageSize(media-col): ", stdout);
6c48a6ca MS	119
	120	fflush(stdout);
	121
f14324a7	122	if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
6c48a6ca MS	123	{
	124	puts("FAIL (Not Found)");
	125	status = 1;
	126	}
88f9aafc	127	else if (media && _cups_strcasecmp(pagesize, media->values[0].string.text))
6c48a6ca MS	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	}
54afec33 MS	144
54afec33 MS	145	/*
f14324a7	146	* _ppdCacheDestroy should never fail...
54afec33 MS	147	*/
54afec33 MS	148
f14324a7 MS	149	fputs("_ppdCacheDestroy(pc): ", stdout);
f14324a7 MS	150	_ppdCacheDestroy(pc);
54afec33 MS	151	puts("PASS");
	152	}
	153
6961465f MS	154	fputs("pwgMediaForPWG(\"iso_a4_210x297mm\"): ", stdout);
6961465f MS	155	if ((pwgmedia = pwgMediaForPWG("iso_a4_210x297mm")) == NULL)
7cf5915e MS	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
4ffc4197 MS	173	fputs("pwgMediaForPWG(\"roll_max_36.1025x3622.0472in\"): ", stdout);
	174	if ((pwgmedia = pwgMediaForPWG("roll_max_36.1025x3622.0472in")) == NULL)
	175	{
	176	puts("FAIL (not found)");
	177	status ++;
	178	}
	179	else if (pwgmedia->width != 91700 \|\| pwgmedia->length != 9199999)
	180	{
	181	printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
	182	status ++;
	183	}
	184	else
	185	printf("PASS (%dx%d)\n", pwgmedia->width, pwgmedia->length);
	186
6961465f MS	187	fputs("pwgMediaForLegacy(\"na-letter\"): ", stdout);
6961465f MS	188	if ((pwgmedia = pwgMediaForLegacy("na-letter")) == NULL)
7cf5915e MS	189	{
	190	puts("FAIL (not found)");
	191	status ++;
	192	}
	193	else if (strcmp(pwgmedia->pwg, "na_letter_8.5x11in"))
	194	{
	195	printf("FAIL (%s)\n", pwgmedia->pwg);
	196	status ++;
	197	}
	198	else if (pwgmedia->width != 21590 \|\| pwgmedia->length != 27940)
	199	{
	200	printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
	201	status ++;
	202	}
	203	else
	204	puts("PASS");
	205
6961465f MS	206	fputs("pwgMediaForPPD(\"4x6\"): ", stdout);
6961465f MS	207	if ((pwgmedia = pwgMediaForPPD("4x6")) == NULL)
7cf5915e MS	208	{
	209	puts("FAIL (not found)");
	210	status ++;
	211	}
	212	else if (strcmp(pwgmedia->pwg, "na_index-4x6_4x6in"))
	213	{
	214	printf("FAIL (%s)\n", pwgmedia->pwg);
	215	status ++;
	216	}
	217	else if (pwgmedia->width != 10160 \|\| pwgmedia->length != 15240)
	218	{
	219	printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
	220	status ++;
	221	}
	222	else
	223	puts("PASS");
	224
6961465f MS	225	fputs("pwgMediaForPPD(\"10x15cm\"): ", stdout);
6961465f MS	226	if ((pwgmedia = pwgMediaForPPD("10x15cm")) == NULL)
7cf5915e MS	227	{
	228	puts("FAIL (not found)");
	229	status ++;
	230	}
	231	else if (strcmp(pwgmedia->pwg, "om_100x150mm_100x150mm"))
	232	{
	233	printf("FAIL (%s)\n", pwgmedia->pwg);
	234	status ++;
	235	}
	236	else if (pwgmedia->width != 10000 \|\| pwgmedia->length != 15000)
	237	{
	238	printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
	239	status ++;
	240	}
	241	else
	242	puts("PASS");
	243
6961465f MS	244	fputs("pwgMediaForPPD(\"Custom.10x15cm\"): ", stdout);
6961465f MS	245	if ((pwgmedia = pwgMediaForPPD("Custom.10x15cm")) == NULL)
7cf5915e MS	246	{
	247	puts("FAIL (not found)");
	248	status ++;
	249	}
	250	else if (strcmp(pwgmedia->pwg, "custom_10x15cm_100x150mm"))
	251	{
	252	printf("FAIL (%s)\n", pwgmedia->pwg);
	253	status ++;
	254	}
	255	else if (pwgmedia->width != 10000 \|\| pwgmedia->length != 15000)
	256	{
	257	printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
	258	status ++;
	259	}
	260	else
	261	puts("PASS");
	262
6961465f MS	263	fputs("pwgMediaForSize(29700, 42000): ", stdout);
6961465f MS	264	if ((pwgmedia = pwgMediaForSize(29700, 42000)) == NULL)
54afec33 MS	265	{
	266	puts("FAIL (not found)");
	267	status ++;
	268	}
	269	else if (strcmp(pwgmedia->pwg, "iso_a3_297x420mm"))
	270	{
	271	printf("FAIL (%s)\n", pwgmedia->pwg);
	272	status ++;
	273	}
	274	else
	275	puts("PASS");
	276
6961465f MS	277	fputs("pwgMediaForSize(9842, 19050): ", stdout);
6961465f MS	278	if ((pwgmedia = pwgMediaForSize(9842, 19050)) == NULL)
f3c17241 MS	279	{
	280	puts("FAIL (not found)");
	281	status ++;
	282	}
	283	else if (strcmp(pwgmedia->pwg, "na_monarch_3.875x7.5in"))
	284	{
	285	printf("FAIL (%s)\n", pwgmedia->pwg);
	286	status ++;
	287	}
	288	else
	289	printf("PASS (%s)\n", pwgmedia->pwg);
	290
6961465f MS	291	fputs("pwgMediaForSize(9800, 19000): ", stdout);
6961465f MS	292	if ((pwgmedia = pwgMediaForSize(9800, 19000)) == NULL)
f3c17241 MS	293	{
	294	puts("FAIL (not found)");
	295	status ++;
	296	}
	297	else if (strcmp(pwgmedia->pwg, "jpn_you6_98x190mm"))
	298	{
	299	printf("FAIL (%s)\n", pwgmedia->pwg);
	300	status ++;
	301	}
	302	else
	303	printf("PASS (%s)\n", pwgmedia->pwg);
	304
54afec33 MS	305	return (status);
	306	}
	307
	308
6c48a6ca MS	309	/*
	310	* 'test_pagesize()' - Test the PWG mapping functions.
	311	*/
	312
	313	static int /* O - 1 on failure, 0 on success */
f14324a7 MS	314	test_pagesize(_ppd_cache_t pc, / I - PWG mapping data */
	315	ppd_file_t ppd, / I - PPD file */
	316	const char ppdsize) / I - PPD page size */
6c48a6ca MS	317	{
	318	int status = 0; /* Return status */
	319	ipp_t job; / Job attributes */
	320	const char pagesize; / PageSize value */
	321
	322
	323	if (ppdPageSize(ppd, ppdsize))
	324	{
f14324a7	325	printf("_ppdCacheGetPageSize(keyword=%s): ", ppdsize);
6c48a6ca MS	326	fflush(stdout);
6c48a6ca MS	327
f14324a7	328	if ((pagesize = _ppdCacheGetPageSize(pc, NULL, ppdsize, NULL)) == NULL)
6c48a6ca MS	329	{
	330	puts("FAIL (Not Found)");
	331	status = 1;
	332	}
88f9aafc	333	else if (_cups_strcasecmp(pagesize, ppdsize))
6c48a6ca MS	334	{
	335	printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
	336	status = 1;
	337	}
	338	else
	339	puts("PASS");
	340
	341	job = ippNew();
	342	ippAddString(job, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media", NULL, ppdsize);
	343
f14324a7	344	printf("_ppdCacheGetPageSize(media=%s): ", ppdsize);
6c48a6ca MS	345	fflush(stdout);
6c48a6ca MS	346
f14324a7	347	if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
6c48a6ca MS	348	{
	349	puts("FAIL (Not Found)");
	350	status = 1;
	351	}
88f9aafc	352	else if (_cups_strcasecmp(pagesize, ppdsize))
6c48a6ca MS	353	{
	354	printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
	355	status = 1;
	356	}
	357	else
	358	puts("PASS");
	359
	360	ippDelete(job);
	361	}
	362
	363	return (status);
	364	}
	365
	366
54afec33	367	/*
f14324a7	368	* 'test_ppd_cache()' - Test the PPD cache functions.
54afec33 MS	369	*/
	370
	371	static int /* O - 1 on failure, 0 on success */
f14324a7 MS	372	test_ppd_cache(_ppd_cache_t pc, / I - PWG mapping data */
f14324a7 MS	373	ppd_file_t ppd) / I - PPD file */
54afec33 MS	374	{
	375	int i, /* Looping var */
	376	status = 0; /* Return status */
f14324a7	377	_ppd_cache_t pc2; / Loaded data */
6961465f	378	pwg_size_t size, / Size from original */
54afec33	379	size2; / Size from saved */
6961465f	380	pwg_map_t map, / Map from original */
54afec33 MS	381	map2; / Map from saved */
	382
	383
	384	/*
	385	* Verify that we can write and read back the same data...
	386	*/
	387
f14324a7 MS	388	fputs("_ppdCacheWriteFile(test.pwg): ", stdout);
f14324a7 MS	389	if (!_ppdCacheWriteFile(pc, "test.pwg", NULL))
54afec33 MS	390	{
	391	puts("FAIL");
	392	status ++;
	393	}
	394	else
	395	puts("PASS");
	396
f14324a7 MS	397	fputs("_ppdCacheCreateWithFile(test.pwg): ", stdout);
f14324a7 MS	398	if ((pc2 = _ppdCacheCreateWithFile("test.pwg", NULL)) == NULL)
54afec33 MS	399	{
	400	puts("FAIL");
	401	status ++;
	402	}
	403	else
	404	{
f14324a7 MS	405	// TODO: FINISH ADDING ALL VALUES IN STRUCTURE
f14324a7 MS	406	if (pc2->num_sizes != pc->num_sizes)
54afec33 MS	407	{
	408	if (!status)
	409	puts("FAIL");
	410
f14324a7 MS	411	printf(" SAVED num_sizes=%d, ORIG num_sizes=%d\n", pc2->num_sizes,
f14324a7 MS	412	pc->num_sizes);
54afec33 MS	413
	414	status ++;
	415	}
	416	else
	417	{
f14324a7	418	for (i = pc->num_sizes, size = pc->sizes, size2 = pc2->sizes;
54afec33 MS	419	i > 0;
	420	i --, size ++, size2 ++)
	421	{
	422	if (strcmp(size2->map.pwg, size->map.pwg) \|\|
	423	strcmp(size2->map.ppd, size->map.ppd) \|\|
	424	size2->width != size->width \|\|
	425	size2->length != size->length \|\|
	426	size2->left != size->left \|\|
	427	size2->bottom != size->bottom \|\|
	428	size2->right != size->right \|\|
	429	size2->top != size->top)
	430	{
	431	if (!status)
	432	puts("FAIL");
	433
	434	if (strcmp(size->map.pwg, size2->map.pwg))
	435	printf(" SAVED size->map.pwg=\"%s\", ORIG "
	436	"size->map.pwg=\"%s\"\n", size2->map.pwg, size->map.pwg);
	437
	438	if (strcmp(size2->map.ppd, size->map.ppd))
	439	printf(" SAVED size->map.ppd=\"%s\", ORIG "
	440	"size->map.ppd=\"%s\"\n", size2->map.ppd, size->map.ppd);
	441
	442	if (size2->width != size->width)
	443	printf(" SAVED size->width=%d, ORIG size->width=%d\n",
	444	size2->width, size->width);
	445
	446	if (size2->length != size->length)
	447	printf(" SAVED size->length=%d, ORIG size->length=%d\n",
	448	size2->length, size->length);
	449
	450	if (size2->left != size->left)
	451	printf(" SAVED size->left=%d, ORIG size->left=%d\n",
	452	size2->left, size->left);
	453
	454	if (size2->bottom != size->bottom)
	455	printf(" SAVED size->bottom=%d, ORIG size->bottom=%d\n",
	456	size2->bottom, size->bottom);
	457
	458	if (size2->right != size->right)
	459	printf(" SAVED size->right=%d, ORIG size->right=%d\n",
	460	size2->right, size->right);
	461
	462	if (size2->top != size->top)
	463	printf(" SAVED size->top=%d, ORIG size->top=%d\n",
	464	size2->top, size->top);
	465
	466	status ++;
	467	break;
	468	}
	469	}
	470
f14324a7	471	for (i = pc->num_sources, map = pc->sources, map2 = pc2->sources;
54afec33 MS	472	i > 0;
	473	i --, map ++, map2 ++)
	474	{
	475	if (strcmp(map2->pwg, map->pwg) \|\|
	476	strcmp(map2->ppd, map->ppd))
	477	{
	478	if (!status)
	479	puts("FAIL");
	480
	481	if (strcmp(map->pwg, map2->pwg))
	482	printf(" SAVED source->pwg=\"%s\", ORIG source->pwg=\"%s\"\n",
	483	map2->pwg, map->pwg);
	484
	485	if (strcmp(map2->ppd, map->ppd))
	486	printf(" SAVED source->ppd=\"%s\", ORIG source->ppd=\"%s\"\n",
	487	map2->ppd, map->ppd);
	488
	489	status ++;
	490	break;
	491	}
	492	}
	493
f14324a7	494	for (i = pc->num_types, map = pc->types, map2 = pc2->types;
54afec33 MS	495	i > 0;
	496	i --, map ++, map2 ++)
	497	{
	498	if (strcmp(map2->pwg, map->pwg) \|\|
	499	strcmp(map2->ppd, map->ppd))
	500	{
	501	if (!status)
	502	puts("FAIL");
	503
	504	if (strcmp(map->pwg, map2->pwg))
	505	printf(" SAVED type->pwg=\"%s\", ORIG type->pwg=\"%s\"\n",
	506	map2->pwg, map->pwg);
	507
	508	if (strcmp(map2->ppd, map->ppd))
	509	printf(" SAVED type->ppd=\"%s\", ORIG type->ppd=\"%s\"\n",
	510	map2->ppd, map->ppd);
	511
	512	status ++;
	513	break;
	514	}
	515	}
	516	}
	517
	518	if (!status)
	519	puts("PASS");
6c48a6ca	520
f14324a7	521	_ppdCacheDestroy(pc2);
54afec33 MS	522	}
54afec33 MS	523
6c48a6ca MS	524	/*
	525	* Test PageSize mapping code...
	526	*/
	527
f14324a7 MS	528	status += test_pagesize(pc, ppd, "Letter");
	529	status += test_pagesize(pc, ppd, "na-letter");
	530	status += test_pagesize(pc, ppd, "A4");
	531	status += test_pagesize(pc, ppd, "iso-a4");
6c48a6ca	532
54afec33 MS	533	return (status);
	534	}
	535
	536
	537	/*
	538	* End of "$Id$".
	539	*/