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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 60 - (show 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 /*
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 #ifdef __WIN32__
26 #include <io.h>
27 #endif
28 #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