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