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