/[ascend]/trunk/base/generic/utilities/test/test_ascEnvVar.c
ViewVC logotype

Annotation of /trunk/base/generic/utilities/test/test_ascEnvVar.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 60 - (hide annotations) (download) (as text)
Mon Oct 31 03:39:15 2005 UTC (18 years, 7 months ago) by jds
File MIME type: text/x-csrc
File size: 30260 byte(s)
- jam build up and limping on Linux (finally).
- fixes to CUnit test suite to compile on Linux (still not operable, though).
1 jds 59 /*
2     * Unit test functions for ASCEND: utilities/ascEnvVar.c
3     *
4     * Copyright (C) 2005 Jerry St.Clair
5     *
6     * This file is part of the Ascend Environment.
7     *
8     * The Ascend Environment is free software; you can redistribute it
9     * and/or modify it under the terms of the GNU General Public License as
10     * published by the Free Software Foundation; either version 2 of the
11     * License, or (at your option) any later version.
12     *
13     * The Ascend Environment is distributed in hope that it will be useful,
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16     * General Public License for more details.
17     *
18     * You should have received a copy of the GNU General Public License
19     * along with the program; if not, write to the Free Software Foundation,
20     * Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
21     * COPYING.
22     */
23    
24     #include <stdio.h>
25 jds 60 #ifdef __WIN32__
26 jds 59 #include <io.h>
27 jds 60 #endif
28 jds 59 #include "utilities/ascConfig.h"
29     #include "utilities/ascEnvVar.h"
30     #include "utilities/ascMalloc.h"
31     #include "general/list.h"
32     #include "CUnit/CUnit.h"
33     #include "test_ascEnvVar.h"
34    
35     #ifdef __WIN32__
36     #define SLASH '\\'
37     #define PATHDIV ';'
38     #else /* ! __WIN32__ */
39     #define SLASH '/'
40     #define PATHDIV ':'
41     #endif
42    
43     #define STR_LEN 250
44    
45     /* compare function for strings used in this test function */
46     static
47     int compare_strings(CONST VOIDPTR p1, CONST VOIDPTR p2)
48     {
49     return strcmp((char *)p1, (char *)p2);
50     }
51    
52     static void test_ascEnvVar(void)
53     {
54     char str_path[STR_LEN];
55     char str_path_ss1[STR_LEN];
56     char str_path_ss2[STR_LEN];
57     char str_path_ss3[STR_LEN];
58    
59     char str_pathbig[MAX_ENV_VAR_LENGTH*3];
60     char str_pathbig_ss1[MAX_ENV_VAR_LENGTH*3];
61     char str_pathbig_ss2[MAX_ENV_VAR_LENGTH*3];
62    
63     int elem_count;
64     char **paths;
65     struct gl_list_t *name_list;
66     int i;
67     char test_ext_varname[] = "TEST_ASCENVVAR_EXTERNAL_ENV_VAR";
68     char *str_env;
69     int i_initialized_lists = FALSE;
70     unsigned long prior_meminuse;
71    
72     prior_meminuse = ascmeminuse(); /* save meminuse() at start of test function */
73    
74     /* make sure list system is initialized */
75     if (FALSE == gl_pool_initialized()) {
76     gl_init();
77     gl_init_pool();
78     i_initialized_lists = TRUE;
79     }
80    
81     /* test Asc_InitEnvironment() */
82     CU_TEST(0 == Asc_InitEnvironment(0)); /* init with 0 */
83     CU_TEST(1 == Asc_InitEnvironment(0)); /* should not be able to initialize again */
84     Asc_DestroyEnvironment();
85    
86     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
87     CU_TEST(1 == Asc_InitEnvironment(10)); /* should not be able to initialize again */
88     Asc_DestroyEnvironment();
89    
90     /* test Asc_SetPathList() */
91    
92     CU_TEST(1 == Asc_SetPathList("envar1", str_path)); /* not initialized */
93    
94     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
95    
96     CU_TEST(1 == Asc_SetPathList(NULL, str_path)); /* NULL var */
97     CU_TEST(1 == Asc_SetPathList("envar1", NULL)); /* NULL path */
98     CU_TEST(1 == Asc_SetPathList("", str_path)); /* empty var */
99     CU_TEST(1 == Asc_SetPathList("envar1", "")); /* empty path */
100     CU_TEST(1 == Asc_SetPathList("envar 1", str_path)); /* embedded space in var */
101    
102     memset(str_pathbig, '.', MAX_ENV_VAR_LENGTH);
103     str_pathbig[MAX_ENV_VAR_LENGTH] = '\0';
104    
105     CU_TEST(1 == Asc_SetPathList(str_pathbig, str_path)); /* var too big */
106    
107     Asc_DestroyEnvironment(); /* start clean in case failure cases left vars */
108     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
109    
110     snprintf(str_path, STR_LEN-1, "%s", "ThisStringHasNoSpaces!");
111    
112     CU_TEST(0 == Asc_SetPathList("envar1", str_path)); /* single path element */
113     paths = Asc_GetPathList("envar1", &elem_count);
114     CU_TEST_FATAL(NULL != paths);
115     CU_TEST_FATAL(1 == elem_count);
116     CU_TEST(!strcmp(paths[0], str_path));
117     ascfree(paths);
118    
119     snprintf(str_path, STR_LEN-1, "%s%c%s", "ThisStringHasNoSpaces+",
120     PATHDIV,
121     "this one does, huh?");
122     snprintf(str_path_ss1, STR_LEN-1, "%s", "ThisStringHasNoSpaces+");
123     snprintf(str_path_ss2, STR_LEN-1, "%s", "this one does, huh?");
124    
125     CU_TEST(0 == Asc_SetPathList("envar2", str_path)); /* 2 path elements */
126     paths = Asc_GetPathList("envar2", &elem_count);
127     CU_TEST_FATAL(NULL != paths);
128     CU_TEST_FATAL(2 == elem_count);
129     CU_TEST(!strcmp(paths[0], str_path_ss1));
130     CU_TEST(!strcmp(paths[1], str_path_ss2));
131     ascfree(paths);
132    
133     snprintf(str_path, STR_LEN-1, "%c%s", PATHDIV, " ThisStringHasNoSpaces! ");
134     snprintf(str_path_ss1, STR_LEN-1, "%s", "ThisStringHasNoSpaces!");
135    
136     CU_TEST(0 == Asc_SetPathList("envar2e1", str_path)); /* 2 elements, 1 empty */
137     paths = Asc_GetPathList("envar2e1", &elem_count);
138     CU_TEST_FATAL(NULL != paths);
139     CU_TEST_FATAL(1 == elem_count);
140     CU_TEST(!strcmp(paths[0], str_path_ss1));
141     ascfree(paths);
142    
143     snprintf(str_path, STR_LEN-1, "%s%c", "< I DO have spaces > ", PATHDIV);
144     snprintf(str_path_ss1, STR_LEN-1, "%s", "< I DO have spaces >");
145    
146     CU_TEST(0 == Asc_SetPathList("envar2e2", str_path)); /* 2 elements, other empty */
147     paths = Asc_GetPathList("envar2e2", &elem_count);
148     CU_TEST_FATAL(NULL != paths);
149     CU_TEST_FATAL(1 == elem_count);
150     CU_TEST(!strcmp(paths[0], str_path_ss1));
151     ascfree(paths);
152    
153     snprintf(str_path, STR_LEN-1, "%c", PATHDIV);
154    
155     CU_TEST(0 == Asc_SetPathList("envar2e3", str_path)); /* 2 elements, both empty */
156     paths = Asc_GetPathList("envar2e3", &elem_count);
157     CU_TEST_FATAL(NULL != paths);
158     CU_TEST(paths[0] == '\0');
159     CU_TEST(0 == elem_count);
160     if (NULL != paths) ascfree(paths);
161    
162     snprintf(str_path, STR_LEN-1, " %c ", PATHDIV);
163    
164     CU_TEST(0 == Asc_SetPathList("envar2e4", str_path)); /* 2 elements, both empty with ws */
165     paths = Asc_GetPathList("envar2e4", &elem_count);
166     CU_TEST_FATAL(NULL != paths);
167     CU_TEST(paths[0] == '\0');
168     CU_TEST(0 == elem_count);
169     if (NULL != paths) ascfree(paths);
170    
171     snprintf(str_path, STR_LEN-1, "%s%c%s%c%s", "< spaces >",
172     PATHDIV,
173     "~NoSpaces~ ",
174     PATHDIV,
175     " another one . ~ $ ");
176     snprintf(str_path_ss1, STR_LEN-1, "%s", "< spaces >");
177     snprintf(str_path_ss2, STR_LEN-1, "%s", "~NoSpaces~");
178     snprintf(str_path_ss3, STR_LEN-1, "%s", "another one . ~ $");
179    
180     CU_TEST(0 == Asc_SetPathList("envar3", str_path)); /* 3 path elements */
181     paths = Asc_GetPathList("envar3", &elem_count);
182     CU_TEST_FATAL(NULL != paths);
183     CU_TEST_FATAL(3 == elem_count);
184     CU_TEST(!strcmp(paths[0], str_path_ss1));
185     CU_TEST(!strcmp(paths[1], str_path_ss2));
186     CU_TEST(!strcmp(paths[2], str_path_ss3));
187     ascfree(paths);
188    
189     snprintf(str_path, STR_LEN-1, "%s%c%c%s", " < spaces > ",
190     PATHDIV,
191     PATHDIV,
192     " another one . ~ $ ");
193     snprintf(str_path_ss1, STR_LEN-1, "%s", "< spaces >");
194     snprintf(str_path_ss2, STR_LEN-1, "%s", "another one . ~ $");
195    
196     CU_TEST(0 == Asc_SetPathList("envar3e1", str_path)); /* 3 elements - middle empty */
197     paths = Asc_GetPathList("envar3e1", &elem_count);
198     CU_TEST_FATAL(NULL != paths);
199     CU_TEST_FATAL(2 == elem_count);
200     CU_TEST(!strcmp(paths[0], str_path_ss1));
201     CU_TEST(!strcmp(paths[1], str_path_ss2));
202     ascfree(paths);
203    
204     snprintf(str_path, STR_LEN-1, "%c%s%c", PATHDIV,
205     " \t - =ASCEND rocks || \t",
206     PATHDIV);
207     snprintf(str_path_ss1, STR_LEN-1, "%s", "- =ASCEND rocks ||");
208    
209     CU_TEST(0 == Asc_SetPathList("envar3e2", str_path)); /* 3 elements - 1st & 3rd empty */
210     paths = Asc_GetPathList("envar3e2", &elem_count);
211     CU_TEST_FATAL(NULL != paths);
212     CU_TEST_FATAL(1 == elem_count);
213     CU_TEST(!strcmp(paths[0], str_path_ss1));
214     ascfree(paths);
215    
216     snprintf(str_path, STR_LEN-1, "%c %c ", PATHDIV, PATHDIV);
217    
218     CU_TEST(0 == Asc_SetPathList("envar3e3", str_path)); /* 3 elements - all empty */
219     paths = Asc_GetPathList("envar3e3", &elem_count);
220     CU_TEST_FATAL(NULL != paths);
221     CU_TEST(paths[0] == '\0');
222     CU_TEST(0 == elem_count);
223     if (NULL != paths) ascfree(paths);
224    
225     memset(str_pathbig, '.', MAX_ENV_VAR_LENGTH-2);
226     str_pathbig[MAX_ENV_VAR_LENGTH-2] = '\0';
227    
228     CU_TEST(0 == Asc_SetPathList("envar4", str_pathbig)); /* large string at max length */
229     paths = Asc_GetPathList("envar4", &elem_count);
230     CU_TEST_FATAL(NULL != paths);
231     CU_TEST_FATAL(1 == elem_count);
232     CU_TEST(!strcmp(paths[0], str_pathbig));
233     ascfree(paths);
234    
235     memset(str_pathbig_ss1, '%', MAX_ENV_VAR_LENGTH-1);
236     str_pathbig_ss1[MAX_ENV_VAR_LENGTH-1] = '\0';
237     memset(str_pathbig_ss2, '@', MAX_ENV_VAR_LENGTH-1);
238     str_pathbig_ss2[MAX_ENV_VAR_LENGTH-1] = '\0';
239    
240     snprintf(str_pathbig, MAX_ENV_VAR_LENGTH*3, "%s%c%s",
241     str_pathbig_ss1,
242     PATHDIV,
243     str_pathbig_ss2);
244    
245     CU_TEST(0 == Asc_SetPathList("envar5", str_pathbig)); /* multiple large strings */
246     paths = Asc_GetPathList("envar5", &elem_count);
247     CU_TEST_FATAL(NULL != paths);
248     CU_TEST_FATAL(2 == elem_count);
249     CU_TEST(!strcmp(paths[0], str_pathbig_ss1));
250     CU_TEST(!strcmp(paths[1], str_pathbig_ss2));
251     ascfree(paths);
252    
253     memset(str_pathbig, '`', MAX_ENV_VAR_LENGTH*2);
254     str_pathbig[MAX_ENV_VAR_LENGTH*2] = '\0';
255     memset(str_pathbig_ss1, '`', MAX_ENV_VAR_LENGTH-1);
256     str_pathbig_ss1[MAX_ENV_VAR_LENGTH-1] = '\0';
257    
258     CU_TEST(0 == Asc_SetPathList("envar6", str_pathbig)); /* large string over max length */
259     paths = Asc_GetPathList("envar6", &elem_count);
260     CU_TEST_FATAL(NULL != paths);
261     CU_TEST_FATAL(1 == elem_count);
262     CU_TEST(!strcmp(paths[0], str_pathbig_ss1));
263     ascfree(paths);
264    
265     memset(str_pathbig, 'a', MAX_ENV_VAR_LENGTH-2);
266     str_pathbig[MAX_ENV_VAR_LENGTH-2] = '\0';
267    
268     CU_TEST(0 == Asc_SetPathList(str_pathbig, "\t\teasy\t\t")); /* var name at max length */
269     paths = Asc_GetPathList(str_pathbig, &elem_count);
270     CU_TEST_FATAL(NULL != paths);
271     CU_TEST_FATAL(1 == elem_count);
272     CU_TEST(!strcmp(paths[0], "easy"));
273     ascfree(paths);
274    
275     name_list = gl_create(15);
276     CU_TEST_FATAL(NULL != name_list);
277     gl_append_ptr(name_list, "envar1");
278     gl_append_ptr(name_list, "envar2");
279     gl_append_ptr(name_list, "envar2e1");
280     gl_append_ptr(name_list, "envar2e2");
281     gl_append_ptr(name_list, "envar2e3");
282     gl_append_ptr(name_list, "envar2e4");
283     gl_append_ptr(name_list, "envar3");
284     gl_append_ptr(name_list, "envar3e1");
285     gl_append_ptr(name_list, "envar3e2");
286     gl_append_ptr(name_list, "envar3e3");
287     gl_append_ptr(name_list, "envar4");
288     gl_append_ptr(name_list, "envar5");
289     gl_append_ptr(name_list, "envar6");
290     gl_append_ptr(name_list, str_pathbig);
291    
292     paths = Asc_EnvNames(&elem_count); /* check the registered names */
293     CU_TEST(NULL != paths);
294     CU_TEST(14 == elem_count);
295     for (i=0 ; i<elem_count ; ++i) {
296     if (0 == gl_search(name_list, paths[i], compare_strings)) {
297     snprintf(str_pathbig, MAX_ENV_VAR_LENGTH*3, "Environment variable name not registered: %s",
298     paths[i]);
299     CU_FAIL(str_pathbig);
300     }
301     }
302     ascfree(paths);
303     gl_destroy(name_list);
304    
305     Asc_DestroyEnvironment();
306    
307     /* test Asc_PutEnv() */
308    
309     snprintf(str_path, STR_LEN-1, "envar1=This is my string");
310    
311     CU_TEST(1 == Asc_PutEnv(str_path)); /* not initialized */
312    
313     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
314    
315     CU_TEST(1 == Asc_PutEnv(NULL)); /* NULL string */
316     CU_TEST(1 == Asc_PutEnv("")); /* empty string */
317     CU_TEST(1 == Asc_PutEnv("=my_path_is_silly")); /* empty var name */
318     CU_TEST(1 == Asc_PutEnv("envar 1=my_path_is_silly")); /* embedded space in var */
319     CU_TEST(1 == Asc_PutEnv("my_path_is_silly")); /* no '=' */
320    
321     memset(str_pathbig, '.', MAX_ENV_VAR_LENGTH-1);
322     str_pathbig[MAX_ENV_VAR_LENGTH-1] = '=';
323     sprintf(str_pathbig+MAX_ENV_VAR_LENGTH-1, "path");
324    
325     CU_TEST(1 == Asc_PutEnv(str_pathbig)); /* var name too big */
326    
327     Asc_DestroyEnvironment(); /* start clean in case failure cases left vars */
328     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
329    
330     snprintf(str_path, STR_LEN-1, "%s", "envar1=ThisStringHasNoSpaces!");
331     snprintf(str_path_ss1, STR_LEN-1, "%s", "ThisStringHasNoSpaces!");
332    
333     CU_TEST(0 == Asc_PutEnv(str_path)); /* single path element */
334     paths = Asc_GetPathList("envar1", &elem_count);
335     CU_TEST_FATAL(NULL != paths);
336     CU_TEST_FATAL(1 == elem_count);
337     CU_TEST(!strcmp(paths[0], str_path_ss1));
338     ascfree(paths);
339    
340     snprintf(str_path, STR_LEN-1, "envar2 =\t %s%c%s", "ThisStringHasNoSpaces+",
341     PATHDIV,
342     "this one does, huh?");
343     snprintf(str_path_ss1, STR_LEN-1, "%s", "ThisStringHasNoSpaces+");
344     snprintf(str_path_ss2, STR_LEN-1, "%s", "this one does, huh?");
345    
346     CU_TEST(0 == Asc_PutEnv(str_path)); /* 2 path elements */
347     paths = Asc_GetPathList("envar2", &elem_count);
348     CU_TEST_FATAL(NULL != paths);
349     CU_TEST_FATAL(2 == elem_count);
350     CU_TEST(!strcmp(paths[0], str_path_ss1));
351     CU_TEST(!strcmp(paths[1], str_path_ss2));
352     ascfree(paths);
353    
354     snprintf(str_path, STR_LEN-1, " envar2e1 = %c%s", PATHDIV, " ThisStringHasNoSpaces! ");
355     snprintf(str_path_ss1, STR_LEN-1, "%s", "ThisStringHasNoSpaces!");
356    
357     CU_TEST(0 == Asc_PutEnv(str_path)); /* 2 elements, 1 empty */
358     paths = Asc_GetPathList("envar2e1", &elem_count);
359     CU_TEST_FATAL(NULL != paths);
360     CU_TEST_FATAL(1 == elem_count);
361     CU_TEST(!strcmp(paths[0], str_path_ss1));
362     ascfree(paths);
363    
364     snprintf(str_path, STR_LEN-1, "envar2e2= %s%c ", "< I DO have spaces > ", PATHDIV);
365     snprintf(str_path_ss1, STR_LEN-1, "%s", "< I DO have spaces >");
366    
367     CU_TEST(0 == Asc_PutEnv(str_path)); /* 2 elements, other empty */
368     paths = Asc_GetPathList("envar2e2", &elem_count);
369     CU_TEST_FATAL(NULL != paths);
370     CU_TEST_FATAL(1 == elem_count);
371     CU_TEST(!strcmp(paths[0], str_path_ss1));
372     ascfree(paths);
373    
374     snprintf(str_path, STR_LEN-1, "envar2e3=%c", PATHDIV);
375    
376     CU_TEST(0 == Asc_PutEnv(str_path)); /* 2 elements, both empty */
377     paths = Asc_GetPathList("envar2e3", &elem_count);
378     CU_TEST_FATAL(NULL != paths);
379     CU_TEST(paths[0] == '\0');
380     CU_TEST(0 == elem_count);
381     if (NULL != paths) ascfree(paths);
382    
383     snprintf(str_path, STR_LEN-1, "\t envar2e4 = %c ", PATHDIV);
384    
385     CU_TEST(0 == Asc_PutEnv(str_path)); /* 2 elements, both empty with ws */
386     paths = Asc_GetPathList("envar2e4", &elem_count);
387     CU_TEST_FATAL(NULL != paths);
388     CU_TEST(paths[0] == '\0');
389     CU_TEST(0 == elem_count);
390     if (NULL != paths) ascfree(paths);
391    
392     snprintf(str_path, STR_LEN-1, "envar3=%s%c%s%c%s", "< spaces >",
393     PATHDIV,
394     "~NoSpaces~ ",
395     PATHDIV,
396     " another one . ~ $ ");
397     snprintf(str_path_ss1, STR_LEN-1, "%s", "< spaces >");
398     snprintf(str_path_ss2, STR_LEN-1, "%s", "~NoSpaces~");
399     snprintf(str_path_ss3, STR_LEN-1, "%s", "another one . ~ $");
400    
401     CU_TEST(0 == Asc_PutEnv(str_path)); /* 3 path elements */
402     paths = Asc_GetPathList("envar3", &elem_count);
403     CU_TEST_FATAL(NULL != paths);
404     CU_TEST_FATAL(3 == elem_count);
405     CU_TEST(!strcmp(paths[0], str_path_ss1));
406     CU_TEST(!strcmp(paths[1], str_path_ss2));
407     CU_TEST(!strcmp(paths[2], str_path_ss3));
408     ascfree(paths);
409    
410     snprintf(str_path, STR_LEN-1, "envar3e1\t=%s%c%c%s", " < spaces > ",
411     PATHDIV,
412     PATHDIV,
413     " another one . ~ $ ");
414     snprintf(str_path_ss1, STR_LEN-1, "%s", "< spaces >");
415     snprintf(str_path_ss2, STR_LEN-1, "%s", "another one . ~ $");
416    
417     CU_TEST(0 == Asc_PutEnv(str_path)); /* 3 elements - middle empty */
418     paths = Asc_GetPathList("envar3e1", &elem_count);
419     CU_TEST_FATAL(NULL != paths);
420     CU_TEST_FATAL(2 == elem_count);
421     CU_TEST(!strcmp(paths[0], str_path_ss1));
422     CU_TEST(!strcmp(paths[1], str_path_ss2));
423     ascfree(paths);
424    
425     snprintf(str_path, STR_LEN-1, "envar3e2=%c%s%c", PATHDIV,
426     " \t - =ASCEND rocks || \t",
427     PATHDIV);
428     snprintf(str_path_ss1, STR_LEN-1, "%s", "- =ASCEND rocks ||");
429    
430     CU_TEST(0 == Asc_PutEnv(str_path)); /* 3 elements - 1st & 3rd empty */
431     paths = Asc_GetPathList("envar3e2", &elem_count);
432     CU_TEST_FATAL(NULL != paths);
433     CU_TEST_FATAL(1 == elem_count);
434     CU_TEST(!strcmp(paths[0], str_path_ss1));
435     ascfree(paths);
436    
437     snprintf(str_path, STR_LEN-1, "envar3e3=%c %c ", PATHDIV, PATHDIV);
438    
439     CU_TEST(0 == Asc_PutEnv(str_path)); /* 3 elements - all empty */
440     paths = Asc_GetPathList("envar3e3", &elem_count);
441     CU_TEST_FATAL(NULL != paths);
442     CU_TEST(paths[0] == '\0');
443     CU_TEST(0 == elem_count);
444     if (NULL != paths) ascfree(paths);
445    
446     memset(str_pathbig_ss1, '.', MAX_ENV_VAR_LENGTH-9);
447     str_pathbig_ss1[MAX_ENV_VAR_LENGTH-9] = '\0';
448     snprintf(str_pathbig, MAX_ENV_VAR_LENGTH-1, "envar4=%s", str_pathbig_ss1);
449    
450     CU_TEST(0 == Asc_PutEnv(str_pathbig)); /* large string at max length */
451     paths = Asc_GetPathList("envar4", &elem_count);
452     CU_TEST_FATAL(NULL != paths);
453     CU_TEST_FATAL(1 == elem_count);
454     CU_TEST(!strcmp(paths[0], str_pathbig_ss1));
455     ascfree(paths);
456    
457     memset(str_pathbig_ss1, 'a', MAX_ENV_VAR_LENGTH-3);
458     str_pathbig_ss1[MAX_ENV_VAR_LENGTH-3] = '\0';
459     snprintf(str_pathbig, MAX_ENV_VAR_LENGTH, "%s=1", str_pathbig_ss1);
460    
461     CU_TEST(0 == Asc_PutEnv(str_pathbig)); /* large string at max length */
462     paths = Asc_GetPathList(str_pathbig_ss1, &elem_count);
463     CU_TEST_FATAL(NULL != paths);
464     CU_TEST_FATAL(1 == elem_count);
465     CU_TEST(!strcmp(paths[0], "1"));
466     ascfree(paths);
467    
468     name_list = gl_create(15);
469     CU_TEST_FATAL(NULL != name_list);
470     gl_append_ptr(name_list, "envar1");
471     gl_append_ptr(name_list, "envar2");
472     gl_append_ptr(name_list, "envar2e1");
473     gl_append_ptr(name_list, "envar2e2");
474     gl_append_ptr(name_list, "envar2e3");
475     gl_append_ptr(name_list, "envar2e4");
476     gl_append_ptr(name_list, "envar3");
477     gl_append_ptr(name_list, "envar3e1");
478     gl_append_ptr(name_list, "envar3e2");
479     gl_append_ptr(name_list, "envar3e3");
480     gl_append_ptr(name_list, "envar4");
481     gl_append_ptr(name_list, str_pathbig_ss1);
482    
483     paths = Asc_EnvNames(&elem_count); /* check the registered names */
484     CU_TEST(NULL != paths);
485     CU_TEST(12 == elem_count);
486     for (i=0 ; i<elem_count ; ++i) {
487     if (0 == gl_search(name_list, paths[i], compare_strings)) {
488     snprintf(str_pathbig, MAX_ENV_VAR_LENGTH*3, "Environment variable name not registered: %s",
489     paths[i]);
490     CU_FAIL(str_pathbig);
491     }
492     }
493     ascfree(paths);
494     gl_destroy(name_list);
495    
496     Asc_DestroyEnvironment(); /* clean up */
497    
498     /* test Asc_ImportPathList() */
499    
500     CU_TEST(1 == Asc_ImportPathList("envar1")); /* not initialized */
501    
502     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
503    
504     CU_TEST(1 == Asc_ImportPathList(NULL)); /* NULL varname */
505     CU_TEST(1 == Asc_ImportPathList("")); /* empty varname */
506    
507     Asc_DestroyEnvironment(); /* start with a clean list */
508     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
509    
510     if (NULL != getenv(test_ext_varname)) { /* make sure our external env var doesn't exist */
511     snprintf(str_path, STR_LEN-1,
512     "External environment variable '%s' already exists. Aborting test of Asc_ImportPathList().",
513     test_ext_varname);
514     str_path[STR_LEN-1] = '\0';
515     CU_FAIL(str_path);
516     }
517     else {
518    
519     CU_TEST(1 == Asc_ImportPathList(test_ext_varname)); /* non-existent external env var */
520    
521     snprintf(str_path_ss1, STR_LEN-1, "%s", "iHaveNoSpaces");
522     snprintf(str_path, STR_LEN-1, "%s=%s", test_ext_varname, str_path_ss1);
523     CU_TEST_FATAL(0 == putenv(str_path));
524    
525     CU_TEST(0 == Asc_ImportPathList(test_ext_varname)); /* import single path env var */
526     paths = Asc_GetPathList(test_ext_varname, &elem_count);
527     CU_TEST_FATAL(NULL != paths);
528     CU_TEST_FATAL(1 == elem_count);
529     CU_TEST(!strcmp(paths[0], str_path_ss1));
530     if (NULL != paths) ascfree(paths);
531    
532     snprintf(str_path_ss1, STR_LEN-1, "%s", "~This one has spaces~");
533     snprintf(str_path_ss2, STR_LEN-1, "%s", "<>NotMe<>");
534     snprintf(str_path, STR_LEN-1, "%s=%s%c%s",
535     test_ext_varname,
536     str_path_ss1,
537     PATHDIV,
538     str_path_ss2);
539     CU_TEST_FATAL(0 == putenv(str_path));
540    
541     CU_TEST(0 == Asc_ImportPathList(test_ext_varname)); /* import double path env var */
542     paths = Asc_GetPathList(test_ext_varname, &elem_count);
543     CU_TEST_FATAL(NULL != paths);
544     CU_TEST_FATAL(2 == elem_count);
545     CU_TEST(!strcmp(paths[0], str_path_ss1));
546     CU_TEST(!strcmp(paths[1], str_path_ss2));
547     if (NULL != paths) ascfree(paths);
548    
549     snprintf(str_path_ss1, STR_LEN-1, "%cusr%clocal%clib", SLASH, SLASH, SLASH);
550     snprintf(str_path_ss2, STR_LEN-1, "%cc%cWindows%cTemp", SLASH, SLASH, SLASH);
551     snprintf(str_path_ss3, STR_LEN-1, "server%c%caccount%csubfolder", SLASH, SLASH, SLASH);
552     snprintf(str_path, STR_LEN-1, "%s=%s%c%s%c%s",
553     test_ext_varname,
554     str_path_ss1,
555     PATHDIV,
556     str_path_ss2,
557     PATHDIV,
558     str_path_ss3);
559     CU_TEST_FATAL(0 == putenv(str_path));
560    
561     CU_TEST(0 == Asc_ImportPathList(test_ext_varname)); /* import double path env var */
562     paths = Asc_GetPathList(test_ext_varname, &elem_count);
563     CU_TEST_FATAL(NULL != paths);
564     CU_TEST_FATAL(3 == elem_count);
565     CU_TEST(!strcmp(paths[0], str_path_ss1));
566     CU_TEST(!strcmp(paths[1], str_path_ss2));
567     CU_TEST(!strcmp(paths[2], str_path_ss3));
568     if (NULL != paths) ascfree(paths);
569     }
570    
571     snprintf(str_path, STR_LEN-1, "%s=", test_ext_varname); /* clear the temporary external env var */
572     CU_TEST(0 == putenv(str_path));
573     Asc_DestroyEnvironment(); /* clean up */
574    
575     /* test Asc_AppendPath() */
576    
577     CU_TEST(1 == Asc_AppendPath("envar1", str_path)); /* not initialized */
578    
579     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
580    
581     CU_TEST(1 == Asc_AppendPath(NULL, str_path)); /* NULL var */
582     CU_TEST(1 == Asc_AppendPath("envar1", NULL)); /* NULL path */
583     CU_TEST(1 == Asc_AppendPath("", str_path)); /* empty var */
584     CU_TEST(1 == Asc_AppendPath("envar1", "")); /* empty path */
585    
586     Asc_DestroyEnvironment(); /* start clean in case failure cases left vars */
587     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
588    
589     snprintf(str_path_ss1, STR_LEN-1, "path/with\\many;unusual:chars");
590     snprintf(str_path_ss2, STR_LEN-1, " What should I test next? ");
591     snprintf(str_path_ss3, STR_LEN-1, "T");
592    
593     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss1)); /* append a path to a new variable */
594     paths = Asc_GetPathList("envar1", &elem_count);
595     CU_TEST_FATAL(NULL != paths);
596     CU_TEST_FATAL(1 == elem_count);
597     CU_TEST(!strcmp(paths[0], str_path_ss1));
598     ascfree(paths);
599    
600     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss1)); /* append a path 2nd time */
601     paths = Asc_GetPathList("envar1", &elem_count);
602     CU_TEST_FATAL(NULL != paths);
603     CU_TEST_FATAL(2 == elem_count);
604     CU_TEST(!strcmp(paths[0], str_path_ss1));
605     CU_TEST(!strcmp(paths[1], str_path_ss1));
606     ascfree(paths);
607    
608     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss2)); /* append a new path */
609     paths = Asc_GetPathList("envar1", &elem_count);
610     CU_TEST_FATAL(NULL != paths);
611     CU_TEST_FATAL(3 == elem_count);
612     CU_TEST(!strcmp(paths[0], str_path_ss1));
613     CU_TEST(!strcmp(paths[1], str_path_ss1));
614     CU_TEST(!strcmp(paths[2], str_path_ss2));
615     ascfree(paths);
616    
617     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss1)); /* append a path a 3rd time */
618     paths = Asc_GetPathList("envar1", &elem_count);
619     CU_TEST_FATAL(NULL != paths);
620     CU_TEST_FATAL(4 == elem_count);
621     CU_TEST(!strcmp(paths[0], str_path_ss1));
622     CU_TEST(!strcmp(paths[1], str_path_ss1));
623     CU_TEST(!strcmp(paths[2], str_path_ss2));
624     CU_TEST(!strcmp(paths[3], str_path_ss1));
625     ascfree(paths);
626    
627     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss3)); /* append a new path */
628     paths = Asc_GetPathList("envar1", &elem_count);
629     CU_TEST_FATAL(NULL != paths);
630     CU_TEST_FATAL(5 == elem_count);
631     CU_TEST(!strcmp(paths[0], str_path_ss1));
632     CU_TEST(!strcmp(paths[1], str_path_ss1));
633     CU_TEST(!strcmp(paths[2], str_path_ss2));
634     CU_TEST(!strcmp(paths[3], str_path_ss1));
635     CU_TEST(!strcmp(paths[4], str_path_ss3));
636     ascfree(paths);
637    
638     Asc_DestroyEnvironment(); /* clean up */
639    
640     /* test Asc_GetPathList() - test unusual cases - main use covered in other tests */
641    
642     paths = Asc_GetPathList("envar1", &elem_count); /* not initialized */
643     CU_TEST(-1 == elem_count);
644     CU_TEST(NULL == paths);
645    
646     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
647    
648     paths = Asc_GetPathList(NULL, &elem_count); /* NULL var */
649     CU_TEST(-1 == elem_count);
650     CU_TEST(NULL == paths);
651    
652     paths = Asc_GetPathList("envar1", NULL); /* NULL argcPtr */
653     CU_TEST(-1 == elem_count);
654     CU_TEST(NULL == paths);
655    
656     paths = Asc_GetPathList("", &elem_count); /* empty var */
657     CU_TEST(0 == elem_count);
658     CU_TEST(NULL == paths);
659    
660     paths = Asc_GetPathList("envar1", &elem_count); /* non-existent var */
661     CU_TEST(0 == elem_count);
662     CU_TEST(NULL == paths);
663    
664     Asc_DestroyEnvironment(); /* start clean in case failure cases left vars */
665    
666     /* test Asc_GetEnv() */
667    
668     str_env = Asc_GetEnv("envar1"); /* not initialized */
669     CU_TEST(NULL == str_env);
670    
671     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
672    
673     str_env = Asc_GetEnv(NULL); /* NULL var */
674     CU_TEST(NULL == str_env);
675    
676     str_env = Asc_GetEnv(""); /* empty var */
677     CU_TEST(NULL == str_env);
678    
679     str_env = Asc_GetEnv("envar1"); /* non-existent var */
680     CU_TEST(NULL == str_env);
681    
682     snprintf(str_path_ss1, STR_LEN-1, "path/with\\many;unusual:chars");
683     snprintf(str_path_ss2, STR_LEN-1, " What should I test next? ");
684     snprintf(str_path_ss3, STR_LEN-1, "T");
685     snprintf(str_path, STR_LEN-1, "%s%c%s%c%s", str_path_ss1, PATHDIV, str_path_ss2, PATHDIV, str_path_ss3);
686    
687     CU_TEST(0 == Asc_SetPathList("envar1", str_path_ss1));
688     str_env = Asc_GetEnv("envar1");
689     CU_TEST_FATAL(NULL != str_env);
690     CU_TEST(!strcmp(str_env, str_path_ss1));
691     ascfree(str_env);
692    
693     CU_TEST(0 == Asc_SetPathList("envar1", str_path_ss3));
694     str_env = Asc_GetEnv("envar1");
695     CU_TEST_FATAL(NULL != str_env);
696     CU_TEST(!strcmp(str_env, str_path_ss3));
697     ascfree(str_env);
698    
699     CU_TEST(0 == Asc_SetPathList("envar1", str_path_ss1));
700     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss2));
701     CU_TEST(0 == Asc_AppendPath("envar1", str_path_ss3));
702     str_env = Asc_GetEnv("envar1");
703     CU_TEST_FATAL(NULL != str_env);
704     CU_TEST(!strcmp(str_env, str_path));
705     ascfree(str_env);
706    
707     Asc_DestroyEnvironment(); /* clean up */
708    
709     /* test Asc_EnvNames() */
710    
711     paths = Asc_EnvNames(&elem_count); /* not initialized */
712     CU_TEST(NULL == paths);
713     CU_TEST(-1 == elem_count);
714    
715     CU_TEST(0 == Asc_InitEnvironment(10)); /* init with typical number */
716    
717     paths = Asc_EnvNames(&elem_count); /* empty environment list */
718     CU_TEST_FATAL(NULL != paths);
719     CU_TEST(0 == elem_count);
720     ascfree(paths);
721    
722     Asc_SetPathList("envar1", "my val 1");
723     paths = Asc_EnvNames(&elem_count); /* 1 environment var */
724     CU_TEST_FATAL(NULL != paths);
725     CU_TEST_FATAL(1 == elem_count);
726     CU_TEST(!strcmp(paths[0], "envar1"));
727     ascfree(paths);
728    
729     Asc_SetPathList("envar2", "my val 2");
730     paths = Asc_EnvNames(&elem_count); /* 2 environment var */
731     CU_TEST_FATAL(NULL != paths);
732     CU_TEST_FATAL(2 == elem_count);
733     CU_TEST(!strcmp(paths[0], "envar1"));
734     CU_TEST(!strcmp(paths[1], "envar2"));
735     ascfree(paths);
736    
737     Asc_SetPathList("envar3", "my val 3");
738     paths = Asc_EnvNames(&elem_count); /* 2 environment var */
739     CU_TEST_FATAL(NULL != paths);
740     CU_TEST_FATAL(3 == elem_count);
741     CU_TEST(!strcmp(paths[0], "envar1"));
742     CU_TEST(!strcmp(paths[1], "envar2"));
743     CU_TEST(!strcmp(paths[2], "envar3"));
744     ascfree(paths);
745    
746     Asc_DestroyEnvironment(); /* start with a clean list */
747    
748     if (TRUE == i_initialized_lists) {
749     gl_destroy_pool();
750     }
751    
752     CU_TEST(prior_meminuse == ascmeminuse()); /* make sure we cleaned up after ourselves */
753     }
754    
755     /*===========================================================================*/
756     /* Registration information */
757    
758     static CU_TestInfo ascEnvVar_test_list[] = {
759     {"test_ascEnvVar", test_ascEnvVar},
760     CU_TEST_INFO_NULL
761     };
762    
763     static CU_SuiteInfo suites[] = {
764     {"test_utilities_ascEnvVar", NULL, NULL, ascEnvVar_test_list},
765     CU_SUITE_INFO_NULL
766     };
767    
768     /*-------------------------------------------------------------------*/
769     CU_ErrorCode test_register_utilities_ascEnvVar(void)
770     {
771     return CU_register_suites(suites);
772     }

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22