Load cups into easysw/current.
[thirdparty/cups.git] / cups / testarray.c
1 /*
2  * "$Id: testarray.c 4903 2006-01-10 20:02:46Z mike $"
3  *
4  *   Array test program for the Common UNIX Printing System (CUPS).
5  *
6  *   Copyright 1997-2006 by Easy Software Products.
7  *
8  *   These coded instructions, statements, and computer programs are the
9  *   property of Easy Software Products and are protected by Federal
10  *   copyright law.  Distribution and use rights are outlined in the file
11  *   "LICENSE.txt" which should have been included with this file.  If this
12  *   file is missing or damaged please contact Easy Software Products
13  *   at:
14  *
15  *       Attn: CUPS Licensing Information
16  *       Easy Software Products
17  *       44141 Airport View Drive, Suite 204
18  *       Hollywood, Maryland 20636 USA
19  *
20  *       Voice: (301) 373-9600
21  *       EMail: cups-info@cups.org
22  *         WWW: http://www.cups.org
23  *
24  *   This file is subject to the Apple OS-Developed Software exception.
25  *
26  * Contents:
27  *
28  *   main()        - Main entry.
29  *   get_seconds() - Get the current time in seconds...
30  *   load_words()  - Load words from a file.
31  */
32
33 /*
34  * Include necessary headers...
35  */
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <cups/string.h>
40 #include <errno.h>
41 #include "array.h"
42 #include "dir.h"
43 #include "debug.h"
44
45
46 /*
47  * Local functions...
48  */
49
50 static double   get_seconds(void);
51 static int      load_words(const char *filename, cups_array_t *array);
52
53
54 /*
55  * 'main()' - Main entry.
56  */
57
58 int                                     /* O - Exit status */
59 main(int  argc,                         /* I - Number of command-line arguments */
60      char *argv[])                      /* I - Command-line arguments */
61 {
62   int           i;                      /* Looping var */
63   cups_array_t  *array,                 /* Test array */
64                 *dup_array;             /* Duplicate array */
65   int           status;                 /* Exit status */
66   char          *text;                  /* Text from array */
67   char          word[256];              /* Word from file */
68   double        start,                  /* Start time */
69                 end;                    /* End time */
70   cups_dir_t    *dir;                   /* Current directory */
71   cups_dentry_t *dent;                  /* Directory entry */
72   char          *saved[32];             /* Saved entries */
73
74
75  /*
76   * No errors so far...
77   */
78
79   status = 0;
80
81  /*
82   * cupsArrayNew()
83   */
84
85   fputs("cupsArrayNew: ", stdout);
86
87   array = cupsArrayNew((cups_array_func_t)strcmp, NULL);
88
89   if (array)
90     puts("PASS");
91   else
92   {
93     puts("FAIL (returned NULL, expected pointer)");
94     status ++;
95   }
96
97  /*
98   * cupsArrayAdd()
99   */
100
101   fputs("cupsArrayAdd: ", stdout);
102
103   if (!cupsArrayAdd(array, strdup("One Fish")))
104   {
105     puts("FAIL (\"One Fish\")");
106     status ++;
107   }
108   else
109   {
110 #ifdef DEBUG
111     putchar('\n');
112     for (text = (char *)cupsArrayFirst(array), i = 0;
113          text;
114          text = (char *)cupsArrayNext(array), i ++)
115       printf("    #1  array[%d]=\"%s\"\n", i, text);
116 #endif /* DEBUG */
117
118     if (!cupsArrayAdd(array, strdup("Two Fish")))
119     {
120       puts("FAIL (\"Two Fish\")");
121       status ++;
122     }
123     else
124     {
125 #ifdef DEBUG
126       for (text = (char *)cupsArrayFirst(array), i = 0;
127            text;
128            text = (char *)cupsArrayNext(array), i ++)
129         printf("    #2  array[%d]=\"%s\"\n", i, text);
130 #endif /* DEBUG */
131
132       if (!cupsArrayAdd(array, strdup("Red Fish")))
133       {
134         puts("FAIL (\"Red Fish\")");
135         status ++;
136       }
137       else
138       {
139 #ifdef DEBUG
140         for (text = (char *)cupsArrayFirst(array), i = 0;
141              text;
142              text = (char *)cupsArrayNext(array), i ++)
143           printf("    #3  array[%d]=\"%s\"\n", i, text);
144 #endif /* DEBUG */
145
146         if (!cupsArrayAdd(array, strdup("Blue Fish")))
147         {
148           puts("FAIL (\"Blue Fish\")");
149           status ++;
150         }
151         else
152         {
153 #ifdef DEBUG
154           for (text = (char *)cupsArrayFirst(array), i = 0;
155                text;
156                text = (char *)cupsArrayNext(array), i ++)
157             printf("    #4  array[%d]=\"%s\"\n", i, text);
158 #endif /* DEBUG */
159
160           puts("PASS");
161         }
162       }
163     }
164   }
165
166  /*
167   * cupsArrayCount()
168   */
169  
170   fputs("cupsArrayCount: ", stdout);
171   if (cupsArrayCount(array) == 4)
172     puts("PASS");
173   else
174   {
175     printf("FAIL (returned %d, expected 4)\n", cupsArrayCount(array));
176     status ++;
177   }
178
179  /*
180   * cupsArrayFirst()
181   */
182
183   fputs("cupsArrayFirst: ", stdout);
184   if ((text = (char *)cupsArrayFirst(array)) != NULL &&
185       !strcmp(text, "Blue Fish"))
186     puts("PASS");
187   else
188   {
189     printf("FAIL (returned \"%s\", expected \"Blue Fish\")\n", text);
190     status ++;
191   }
192
193  /*
194   * cupsArrayNext()
195   */
196
197   fputs("cupsArrayNext: ", stdout);
198   if ((text = (char *)cupsArrayNext(array)) != NULL &&
199       !strcmp(text, "One Fish"))
200     puts("PASS");
201   else
202   {
203     printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
204     status ++;
205   }
206
207  /*
208   * cupsArrayLast()
209   */
210
211   fputs("cupsArrayLast: ", stdout);
212   if ((text = (char *)cupsArrayLast(array)) != NULL &&
213       !strcmp(text, "Two Fish"))
214     puts("PASS");
215   else
216   {
217     printf("FAIL (returned \"%s\", expected \"Two Fish\")\n", text);
218     status ++;
219   }
220
221  /*
222   * cupsArrayPrev()
223   */
224
225   fputs("cupsArrayPrev: ", stdout);
226   if ((text = (char *)cupsArrayPrev(array)) != NULL &&
227       !strcmp(text, "Red Fish"))
228     puts("PASS");
229   else
230   {
231     printf("FAIL (returned \"%s\", expected \"Red Fish\")\n", text);
232     status ++;
233   }
234
235  /*
236   * cupsArrayFind()
237   */
238
239   fputs("cupsArrayFind: ", stdout);
240   if ((text = (char *)cupsArrayFind(array, (void *)"One Fish")) != NULL &&
241       !strcmp(text, "One Fish"))
242     puts("PASS");
243   else
244   {
245     printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
246     status ++;
247   }
248
249  /*
250   * cupsArrayCurrent()
251   */
252
253   fputs("cupsArrayCurrent: ", stdout);
254   if ((text = (char *)cupsArrayCurrent(array)) != NULL &&
255       !strcmp(text, "One Fish"))
256     puts("PASS");
257   else
258   {
259     printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
260     status ++;
261   }
262
263  /*
264   * cupsArrayDup()
265   */
266
267   fputs("cupsArrayDup: ", stdout);
268   if ((dup_array = cupsArrayDup(array)) != NULL &&
269       cupsArrayCount(dup_array) == 4)
270     puts("PASS");
271   else
272   {
273     printf("FAIL (returned %p with %d elements, expected pointer with 4 elements)\n",
274            dup_array, cupsArrayCount(dup_array));
275     status ++;
276   }
277
278  /*
279   * cupsArrayRemove()
280   */
281
282   fputs("cupsArrayRemove: ", stdout);
283   if (cupsArrayRemove(array, (void *)"One Fish") &&
284       cupsArrayCount(array) == 3)
285     puts("PASS");
286   else
287   {
288     printf("FAIL (returned 0 with %d elements, expected 1 with 4 elements)\n",
289            cupsArrayCount(array));
290     status ++;
291   }
292
293  /*
294   * cupsArrayClear()
295   */
296
297   fputs("cupsArrayClear: ", stdout);
298   cupsArrayClear(array);
299   if (cupsArrayCount(array) == 0)
300     puts("PASS");
301   else
302   {
303     printf("FAIL (%d elements, expected 0 elements)\n",
304            cupsArrayCount(array));
305     status ++;
306   }
307
308  /*
309   * Now load this source file and grab all of the unique words...
310   */
311
312   fputs("Load unique words: ", stdout);
313   fflush(stdout);
314
315   start = get_seconds();
316
317   if ((dir = cupsDirOpen(".")) == NULL)
318   {
319     puts("FAIL (cupsDirOpen failed)");
320     status ++;
321   }
322   else
323   {
324     while ((dent = cupsDirRead(dir)) != NULL)
325     {
326       i = strlen(dent->filename) - 2;
327
328       if (i > 0 && dent->filename[i] == '.' &&
329           (dent->filename[i + 1] == 'c' ||
330            dent->filename[i + 1] == 'h'))
331         load_words(dent->filename, array);
332     }
333
334     cupsDirClose(dir);
335
336     end = get_seconds();
337
338     printf("%d words in %.3f seconds (%.0f words/sec), ", cupsArrayCount(array),
339            end - start, cupsArrayCount(array) / (end - start));
340     fflush(stdout);
341
342     for (text = (char *)cupsArrayFirst(array); text;)
343     {
344      /*
345       * Copy this word to the word buffer (safe because we strdup'd from
346       * the same buffer in the first place... :)
347       */
348
349       strcpy(word, text);
350
351      /*
352       * Grab the next word and compare...
353       */
354
355       if ((text = (char *)cupsArrayNext(array)) == NULL)
356         break;
357
358       if (strcmp(word, text) >= 0)
359         break;
360     }
361
362     if (text)
363     {
364       printf("FAIL (\"%s\" >= \"%s\"!)\n", word, text);
365       status ++;
366     }
367     else
368       puts("PASS");
369   }
370
371  /*
372   * Test deleting with iteration...
373   */
374
375   fputs("Delete While Iterating: ", stdout);
376
377   text = (char *)cupsArrayFirst(array);
378   cupsArrayRemove(array, text);
379   free(text);
380
381   text = (char *)cupsArrayNext(array);
382   if (!text)
383   {
384     puts("FAIL (cupsArrayNext returned NULL!)");
385     status ++;
386   }
387   else
388     puts("PASS");
389
390  /*
391   * Test save/restore...
392   */
393
394   fputs("cupsArraySave: ", stdout);
395
396   for (i = 0, text = (char *)cupsArrayFirst(array);
397        i < 32;
398        i ++, text = (char *)cupsArrayNext(array))
399   {
400     saved[i] = text;
401
402     if (!cupsArraySave(array))
403       break;
404   }
405
406   if (i < 32)
407     printf("FAIL (depth = %d)\n", i);
408   else
409     puts("PASS");
410
411   fputs("cupsArrayRestore: ", stdout);
412
413   while (i > 0)
414   {
415     i --;
416
417     text = cupsArrayRestore(array);
418     if (text != saved[i])
419       break;
420   }
421
422   if (i)
423     printf("FAIL (depth = %d)\n", i);
424   else
425     puts("PASS");
426
427  /*
428   * Delete the arrays...
429   */
430
431   cupsArrayDelete(array);
432   cupsArrayDelete(dup_array);
433
434  /*
435   * Summarize the results and return...
436   */
437
438   if (!status)
439     puts("\nALL TESTS PASSED!");
440   else
441     printf("\n%d TEST(S) FAILED!\n", status);
442
443   return (status);
444 }
445
446
447 /*
448  * 'get_seconds()' - Get the current time in seconds...
449  */
450
451 #ifdef WIN32
452 #  include <windows.h>
453
454
455 static double
456 get_seconds(void)
457 {
458 }
459 #else
460 #  include <sys/time.h>
461
462
463 static double
464 get_seconds(void)
465 {
466   struct timeval        curtime;        /* Current time */
467
468
469   gettimeofday(&curtime, NULL);
470   return (curtime.tv_sec + 0.000001 * curtime.tv_usec);
471 }
472 #endif /* WIN32 */
473
474
475 /*
476  * 'load_words()' - Load words from a file.
477  */
478
479 static int                              /* O - 1 on success, 0 on failure */
480 load_words(const char   *filename,      /* I - File to load */
481            cups_array_t *array)         /* I - Array to add to */
482 {
483   FILE          *fp;                    /* Test file */
484   char          word[256];              /* Word from file */
485
486
487   DEBUG_printf(("    Loading \"%s\"...\n", filename));
488
489   if ((fp = fopen(filename, "r")) == NULL)
490   {
491     perror(filename);
492     return (0);
493   }
494
495   while (fscanf(fp, "%255s", word) == 1)
496   {
497     if (!cupsArrayFind(array, word))
498     {
499       DEBUG_printf(("    Adding \"%s\"...\n", word));
500
501       cupsArrayAdd(array, strdup(word));
502     }
503   }
504
505   fclose(fp);
506
507   return (1);
508 }
509
510
511 /*
512  * End of "$Id: testarray.c 4903 2006-01-10 20:02:46Z mike $".
513  */