Line data Source code
1 : /** \file suite_modmgr-searchpath.c
2 : * \brief Check ModMgr search path management
3 : * \author François Cerbelle (Fanfan), francois@cerbelle.net
4 : *
5 : * \internal
6 : * Created: 29/01/2024
7 : * Revision: none
8 : * Last modified: 2024-07-21 12:50
9 : * Compiler: gcc
10 : * Organization: Cerbelle.net
11 : * Copyright: Copyright (c) 2024, François Cerbelle
12 : *
13 : * This source code is released for free distribution under the terms of the
14 : * GNU General Public License as published by the Free Software Foundation.
15 : */
16 :
17 : #ifdef HAVE_CONFIG_H
18 : #include "config.h"
19 : #endif
20 :
21 : #include "modmgr.h"
22 : #include "oom.h" /* OOM simulation */
23 : #include <check.h>
24 : #include <unistd.h> /* pid_t getpid() */
25 : #include <sys/stat.h> /* mkdir(), chdir(), mode_t */
26 : #include <stdio.h> /* fprintf */
27 : #include <stdlib.h> /* abort() */
28 : #include <string.h> /* strdup (with XOPEN_SOURCE >=500 */
29 : #include <linux/limits.h> /* PATH_MAX */
30 : #include "checktools.inc"
31 :
32 : /*
33 : * Module management :
34 : * - from = uninitialized, empty, 1 module (mkmod1), 1 module (mkmod1:2),
35 : * 3 modules (mkmod1, mkmod2, mkmod3)
36 : * 3 modules (mkmod1:2, mkmod2, mkmod3)
37 : * 3 modules (mkmod1, mkmod2:2, mkmod3)
38 : * 3 modules (mkmod1, mkmod2, mkmod3:2)
39 : * 3 modules (mkmod1:2, mkmod2:2, mkmod3)
40 : * 3 modules (mkmod1:2, mkmod2, mkmod3:2)
41 : * 3 modules (mkmod1:2, mkmod2:2, mkmod3:2)
42 : *
43 : * load (normal, OOM, overflow)
44 : * - modfile = NULL, empty, missing, normal, subfolder, PATH_MAX+1, noOnLoad, noOnUnload, noGetSymbol, badInfos, badAPI
45 : *
46 : * getsymbol (normal, OOM, overflow)
47 : * - module = NULL, normal, noOnLoad, noOnUnload, noGetSymbol, badInfos, badAPI
48 : * - szSymbol = NULL, empty, missing, normal,
49 : *
50 : * unload (normal, OOM, overflow)
51 : * - module = NULL, normal, noOnLoad, noOnUnload, noGetSymbol, badInfos, badAPI
52 : *
53 : * */
54 :
55 : /**************************************************************************/
56 : /* Helper functions */
57 :
58 : /** Simulate what we want the real addpath function to achieve
59 : */
60 1640 : char* simul_insertpath(const char* currentpath, const char* before, const char* value)
61 : {
62 : uint16_t pos;
63 : char* retval;
64 :
65 : /* Prepare return value strlen current+value+colon+terminator */
66 1640 : retval=malloc(
67 1640 : strlen(NULL!=currentpath?currentpath:"")
68 1640 : +strlen(NULL!=value?value:"")
69 : +2);
70 1640 : pos=0;
71 1640 : retval[pos] = 0;
72 :
73 : /* If there is an existing currentpath, copy from currentpath to
74 : * currentpath+before */
75 1640 : if (NULL!=currentpath) {
76 1884875 : while ((0!=(currentpath+pos)[0])&&((currentpath+pos)!=before)) {
77 1883855 : retval[pos]=currentpath[pos];
78 1883855 : pos++;
79 : }
80 : }
81 1640 : retval[pos]=0;
82 :
83 : /* Add the value to insert */
84 1640 : if ((NULL!=value)&&(0!=value[0])) {
85 : /* if nothing was copied before, no need for a colon, if something was copied,
86 : * colon was already copied, except if adding at the very end of an existing
87 : * string with before==NULL */
88 531 : if ((NULL!=currentpath)&&(NULL==before))
89 291 : strcat(retval,":");
90 531 : strcat(retval,value);
91 : /* Insert a separator before the remaining of the string if needed */
92 : /* If insertion was not at the very end (before==NULL), there is something
93 : * to add after with a colon separator */
94 531 : if ((NULL!=currentpath)&&(NULL!=before))
95 0 : strcat(retval,":");
96 : }
97 :
98 : /* Copy the remaining path */
99 1640 : if (NULL!=currentpath)
100 1020 : strcat(retval,currentpath+pos);
101 :
102 : /* lt_dlgetpath does not store empty strings and returns NULL */
103 1640 : if (0==retval[0]) {
104 380 : free(retval);
105 380 : retval=NULL;
106 : }
107 :
108 1640 : return retval;
109 : }
110 :
111 : /**************************************************************************/
112 : /* set/getpath tests */
113 192 : START_TEST(set_null)
114 : {
115 192 : int result = 0; /* Return code */
116 : char* oldVal; /* Value before*/
117 : char* newVal; /* Value after */
118 : char* expVal; /* Expected value */
119 :
120 : /* Stringify potential NULL and get rid of const qualifier */
121 192 : oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");
122 :
123 192 : oomtest_fill(_i,2);
124 192 : result = modmgr_setpath(NULL);
125 192 : oomtest_free();
126 :
127 192 : ck_assert((0==result)||(oomtest_enabled()));
128 :
129 : /* Stringify potential NULL and get rid of const qualifier */
130 192 : newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
131 192 : expVal = strdup("");
132 :
133 192 : if (0==result)
134 192 : ck_assert_msg(0 == strcmp(newVal,expVal),"modmgr_setpath(NULL)");
135 : else
136 0 : ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(NULL)");
137 :
138 192 : free(oldVal);
139 192 : free(newVal);
140 192 : free(expVal);
141 192 : }
142 : END_TEST
143 :
144 192 : START_TEST(set_empty)
145 : {
146 192 : int result = 0; /* Return code */
147 : char* oldVal; /* Value before*/
148 : char* newVal; /* Value after */
149 : char* expVal; /* Expected value */
150 :
151 : /* Stringify potential NULL and get rid of const qualifier */
152 192 : oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");
153 :
154 192 : oomtest_fill(_i,2);
155 192 : result=modmgr_setpath("");
156 192 : oomtest_free();
157 :
158 192 : ck_assert((0==result)||(oomtest_enabled()));
159 :
160 : /* Stringify potential NULL and get rid of const qualifier */
161 192 : newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
162 192 : expVal = strdup("");
163 :
164 192 : if (0==result)
165 192 : ck_assert_msg(0 == strcmp(newVal,expVal),"modmgr_setpath(\"\")");
166 : else
167 0 : ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(\"\")");
168 :
169 192 : free(oldVal);
170 192 : free(newVal);
171 192 : free(expVal);
172 192 : }
173 : END_TEST
174 :
175 192 : START_TEST(set_value)
176 : {
177 192 : int result = 0; /* Return code */
178 : char* oldVal; /* Value before*/
179 : char* newVal; /* Value after */
180 : char* expVal; /* Expected value */
181 :
182 : /* Stringify potential NULL and get rid of const qualifier */
183 192 : oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");
184 :
185 192 : oomtest_fill(_i,2);
186 192 : result=modmgr_setpath("abc:def:ghi");
187 192 : oomtest_free();
188 :
189 192 : ck_assert((0==result)||(oomtest_enabled()));
190 :
191 : /* Stringify potential NULL and get rid of const qualifier */
192 192 : newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
193 192 : expVal = strdup("abc:def:ghi");
194 :
195 192 : if (0==result)
196 156 : ck_assert_msg(0 == strcmp(newVal,expVal),"modmgr_setpath(\"abc:def:ghi\")");
197 : else
198 36 : ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(\"abc:def:ghi\")");
199 :
200 192 : free(oldVal);
201 192 : free(newVal);
202 192 : free(expVal);
203 192 : }
204 : END_TEST
205 :
206 192 : START_TEST(set_bigvalue)
207 : {
208 192 : int result = 0; /* Return code */
209 : char* oldVal; /* Value before*/
210 : char* newVal; /* Value after */
211 : char tmpVal[PATH_MAX]; /* Temporary value */
212 :
213 : /* Stringify potential NULL and get rid of const qualifier */
214 192 : oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");
215 :
216 192 : memset(tmpVal, 65, PATH_MAX-1);
217 192 : tmpVal[PATH_MAX-1]=0;
218 :
219 192 : oomtest_fill(_i,2);
220 192 : result = modmgr_setpath(tmpVal);
221 192 : oomtest_free();
222 :
223 192 : ck_assert((0==result)||(oomtest_enabled()));
224 :
225 : /* Stringify potential NULL and get rid of const qualifier */
226 192 : newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
227 :
228 192 : if (0==result)
229 57 : ck_assert_msg(0 == strcmp(newVal,tmpVal),"modmgr_setpath(bigvalue)");
230 : else
231 135 : ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(bigvalue)");
232 :
233 192 : free(oldVal);
234 192 : free(newVal);
235 192 : }
236 : END_TEST
237 :
238 192 : START_TEST(set_hugevalue)
239 : {
240 192 : int result = 0; /* Return code */
241 : char* oldVal; /* Value before*/
242 : char* newVal; /* Value after */
243 : char tmpVal[PATH_MAX+5]; /* Temporary value */
244 :
245 : /* Stringify potential NULL and get rid of const qualifier */
246 192 : oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");
247 :
248 192 : memset(tmpVal, 65, PATH_MAX+5-1);
249 192 : tmpVal[PATH_MAX+5-1]=0;
250 :
251 192 : oomtest_fill(_i,2);
252 192 : result = modmgr_setpath(tmpVal);
253 192 : oomtest_free();
254 :
255 192 : ck_assert((0==result)||(oomtest_enabled()));
256 :
257 : /* Stringify potential NULL and get rid of const qualifier */
258 192 : newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
259 :
260 192 : if (0==result)
261 57 : ck_assert_msg(0 == strcmp(newVal,tmpVal),"modmgr_setpath(hugevalue)");
262 : else
263 135 : ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(hugevalue)");
264 :
265 192 : free(oldVal);
266 192 : free(newVal);
267 192 : }
268 : END_TEST
269 :
270 : /**************************************************************************/
271 : /** Generic insertpath function, same for all tests
272 : */
273 1640 : void test_insertpath(const unsigned int minHeap, const char* pos, const char* tmpVal)
274 : {
275 1640 : int result = 0; /* Return code */
276 : char* oldVal; /* Value before*/
277 : const char* newVal; /* Value after */
278 : char* expVal; /* Expected value */
279 :
280 : /* Preserve the current value */
281 1640 : oldVal = (modmgr_getpath()?strdup(modmgr_getpath()):NULL);
282 :
283 : /* Run the test */
284 1640 : oomtest_fill(minHeap,2);
285 1640 : result = modmgr_insertpath(pos,tmpVal);
286 1640 : oomtest_free();
287 :
288 : /* Test should succeed, except potentially if RAM was filled */
289 1640 : ck_assert((0==result)||(oomtest_enabled()));
290 :
291 : /* Fetch the resulting value */
292 1640 : newVal = modmgr_getpath();
293 :
294 : /* Evaluate what should be the resulting value */
295 1640 : expVal = simul_insertpath(oldVal, pos, tmpVal);
296 :
297 : /* Validate function results against simulation results */
298 1640 : if (0==result) {
299 : /* Test succeeded either with oom or without oom enabled */
300 1145 : if (NULL==expVal)
301 380 : ck_assert_msg(NULL==newVal, "modmgr_addpath(null,null)");
302 : else {
303 765 : ck_assert_msg(NULL!=newVal, "modmgr_addpath(null,null)");
304 765 : ck_assert_msg((0==strcmp(newVal,expVal)), "modmgr_addpath(null,null)");
305 : }
306 : } else {
307 : /* Test failed only if oom was enabled */
308 495 : ck_assert_msg(
309 : ((NULL==newVal)&&(NULL==oldVal))
310 : ||((NULL!=newVal)&&(NULL!=oldVal)&&(0==strcmp(oldVal,newVal)))
311 : ,"modmgr_addpath(null,null)");
312 : }
313 :
314 1640 : free(oldVal);
315 1640 : free(expVal);
316 1640 : }
317 :
318 192 : START_TEST(add_null)
319 : {
320 192 : test_insertpath(_i,NULL,NULL);
321 192 : }
322 : END_TEST
323 :
324 192 : START_TEST(add_empty)
325 : {
326 192 : test_insertpath(_i,NULL,"");
327 192 : }
328 : END_TEST
329 :
330 192 : START_TEST(add_value)
331 : {
332 192 : test_insertpath(_i,NULL,"abc:def:ghi");
333 192 : }
334 : END_TEST
335 :
336 192 : START_TEST(add_bigvalue)
337 : {
338 : char tmpVal[PATH_MAX]; /* Temporary value */
339 :
340 192 : memset(tmpVal, 65, PATH_MAX-1);
341 192 : tmpVal[PATH_MAX-1]=0;
342 :
343 192 : test_insertpath(_i,NULL,tmpVal);
344 192 : }
345 : END_TEST
346 :
347 147 : START_TEST(add_hugevalue)
348 : {
349 : char tmpVal[PATH_MAX+5]; /* Temporary value */
350 :
351 147 : memset(tmpVal, 65, PATH_MAX+5-1);
352 147 : tmpVal[PATH_MAX+5-1]=0;
353 :
354 147 : test_insertpath(_i,NULL,tmpVal);
355 147 : }
356 : END_TEST
357 :
358 192 : START_TEST(insert_null_at_null)
359 : {
360 192 : test_insertpath(_i,NULL,NULL);
361 192 : }
362 : END_TEST
363 :
364 192 : START_TEST(insert_null_at_first)
365 : {
366 192 : test_insertpath(_i,modmgr_getpath(),NULL);
367 192 : }
368 : END_TEST
369 :
370 192 : START_TEST(insert_null_at_second)
371 : {
372 : const char* currentpath; /* Pointer to current path string */
373 : char* insertposition; /* Pointer to insert position */
374 :
375 : /* Get the current path string */
376 192 : currentpath = modmgr_getpath();
377 :
378 : /* Check if current path allow this test */
379 192 : if (NULL==currentpath)
380 95 : return;
381 :
382 : /* Find the first separator */
383 97 : insertposition = strchr(currentpath,':');
384 :
385 : /* Discard test if not enough paths in the string */
386 97 : if (NULL==insertposition)
387 48 : return;
388 :
389 : /* Go to the first char of the next path */
390 49 : insertposition++;
391 :
392 : /* Check if next path exists (colon was not the last char) */
393 49 : if (0==insertposition[0])
394 0 : return;
395 :
396 : /* Try the insertion */
397 49 : test_insertpath(_i,insertposition,NULL);
398 : }
399 : END_TEST
400 :
401 192 : START_TEST(insert_null_at_colon)
402 : {
403 : const char* currentpath; /* Pointer to current path string */
404 : char* insertposition; /* Pointer to insert position */
405 :
406 : /* Get the current path string */
407 192 : currentpath = modmgr_getpath();
408 :
409 : /* Check if current path allow this test */
410 192 : if (NULL==currentpath)
411 95 : return;
412 :
413 : /* Find the first separator */
414 97 : insertposition = strchr(currentpath,':');
415 :
416 : /* Discard test if not enough paths in the string */
417 97 : if (NULL==insertposition)
418 48 : return;
419 :
420 : /* Check if next path exists (colon was not the last char) */
421 49 : if (0==insertposition[0])
422 0 : return;
423 : /* Try the insertion */
424 49 : test_insertpath(_i,insertposition,NULL);
425 : }
426 : END_TEST
427 :
428 192 : START_TEST(insert_null_at_middle)
429 : {
430 : const char* currentpath; /* Pointer to current path string */
431 : char* insertposition; /* Pointer to insert position */
432 :
433 : /* Get the current path string */
434 192 : currentpath = modmgr_getpath();
435 :
436 : /* Check if current path allow this test */
437 192 : if (NULL==currentpath)
438 95 : return;
439 :
440 : /* Find the first separator */
441 97 : insertposition = strchr(currentpath,':');
442 :
443 : /* Discard test if not enough paths in the string */
444 97 : if (NULL==insertposition)
445 48 : return;
446 :
447 : /* Go to the first char of the next path */
448 49 : insertposition++;
449 :
450 : /* Check if next path exists (colon was not the last char) */
451 49 : if (0==insertposition[0])
452 0 : return;
453 :
454 : /* Go to the second char of the next path */
455 49 : insertposition++;
456 :
457 : /* Check if next path exists and is not a separator */
458 49 : if ((0==insertposition[0])||(':'==insertposition[0]))
459 0 : return;
460 : /* Try the insertion */
461 49 : test_insertpath(_i,insertposition,NULL);
462 : }
463 : END_TEST
464 :
465 192 : START_TEST(insert_null_at_end)
466 : {
467 : const char* currentpath; /* Pointer to current path string */
468 : char* insertposition; /* Pointer to insert position */
469 :
470 : /* Get the current path string */
471 192 : currentpath = modmgr_getpath();
472 :
473 : /* Check if current path allow this test */
474 192 : if (NULL==currentpath)
475 95 : return;
476 :
477 : /* Find the end */
478 97 : insertposition = strchr(currentpath,0);
479 :
480 : /* Try the insertion */
481 97 : test_insertpath(_i,insertposition,NULL);
482 : }
483 : END_TEST
484 :
485 192 : START_TEST(insert_null_at_outside)
486 : {
487 : const char* currentpath; /* Pointer to current path string */
488 : char* insertposition; /* Pointer to insert position */
489 :
490 : /* Get the current path string */
491 192 : currentpath = modmgr_getpath();
492 :
493 : /* Check if current path allow this test */
494 192 : if (NULL==currentpath)
495 95 : return;
496 :
497 : /* Find the end */
498 97 : insertposition = strchr(currentpath,0);
499 97 : insertposition++;
500 :
501 : /* Try the insertion */
502 97 : test_insertpath(_i,insertposition,NULL);
503 : }
504 : END_TEST
505 :
506 :
507 :
508 : /************************************************************************/
509 2151 : void setpath_uninitialized_unchecked_setup()
510 : {
511 2151 : forktest_init();
512 2151 : }
513 51 : void setpath_uninitialized_checked_setup()
514 : {
515 51 : signals_catch();
516 51 : forktest_gprofdir();
517 51 : }
518 51 : void setpath_uninitialized_checked_teardown()
519 : {
520 51 : signals_release();
521 51 : }
522 2117 : void setpath_uninitialized_unchecked_teardown() { }
523 :
524 : /************************************************************************/
525 2117 : void setpath_empty_unchecked_setup()
526 : {
527 2117 : forktest_init();
528 2117 : }
529 51 : void setpath_empty_checked_setup()
530 : {
531 51 : signals_catch();
532 51 : forktest_gprofdir();
533 51 : modmgr_setpath(NULL);
534 51 : ck_assert_msg(NULL == modmgr_getpath(),"modmgr_getpath!=NULL");
535 51 : }
536 51 : void setpath_empty_checked_teardown()
537 : {
538 51 : signals_release();
539 51 : }
540 2083 : void setpath_empty_unchecked_teardown() { }
541 :
542 : /************************************************************************/
543 2083 : void setpath_withdata_unchecked_setup()
544 : {
545 2083 : forktest_init();
546 2083 : }
547 51 : void setpath_withdata_checked_setup()
548 : {
549 51 : signals_catch();
550 51 : forktest_gprofdir();
551 51 : modmgr_setpath("abc:def");
552 51 : ck_assert_msg(0 == strcmp("abc:def",modmgr_getpath()),"modmgr_getpath!=withdata");
553 51 : }
554 51 : void setpath_withdata_checked_teardown()
555 : {
556 51 : signals_release();
557 51 : }
558 2049 : void setpath_withdata_unchecked_teardown() { }
559 :
560 : /************************************************************************/
561 2049 : void setpath_pathmax_unchecked_setup()
562 : {
563 2049 : forktest_init();
564 2049 : }
565 51 : void setpath_pathmax_checked_setup()
566 : {
567 : char modulePath[PATH_MAX];
568 51 : signals_catch();
569 51 : forktest_gprofdir();
570 51 : memset(modulePath, 65, PATH_MAX-1);
571 51 : modulePath[PATH_MAX-1]=0;
572 51 : modmgr_setpath(modulePath);
573 51 : ck_assert_msg(0 == strcmp(modulePath,modmgr_getpath()),"modmgr_getpath!=bigval");
574 51 : }
575 51 : void setpath_pathmax_checked_teardown()
576 : {
577 51 : signals_release();
578 51 : }
579 2015 : void setpath_pathmax_unchecked_teardown() { }
580 :
581 : /************************************************************************/
582 2015 : void setpath_uninitialized_oom_unchecked_setup()
583 : {
584 2015 : forktest_init();
585 2015 : }
586 720 : void setpath_uninitialized_oom_checked_setup()
587 : {
588 720 : signals_catch();
589 720 : forktest_gprofdir();
590 720 : oomtest_enable(RAMLIMIT_SOFT);
591 720 : }
592 720 : void setpath_uninitialized_oom_checked_teardown()
593 : {
594 720 : signals_release();
595 720 : }
596 1535 : void setpath_uninitialized_oom_unchecked_teardown() { }
597 :
598 : /************************************************************************/
599 1535 : void setpath_empty_oom_unchecked_setup()
600 : {
601 1535 : forktest_init();
602 1535 : }
603 765 : void setpath_empty_oom_checked_setup()
604 : {
605 765 : signals_catch();
606 765 : forktest_gprofdir();
607 765 : modmgr_setpath(NULL);
608 765 : ck_assert_msg(NULL == modmgr_getpath(),"modmgr_getpath!=NULL");
609 765 : oomtest_enable(RAMLIMIT_SOFT);
610 765 : }
611 765 : void setpath_empty_oom_checked_teardown()
612 : {
613 765 : signals_release();
614 765 : }
615 1025 : void setpath_empty_oom_unchecked_teardown() { }
616 :
617 : /************************************************************************/
618 1025 : void setpath_withdata_oom_unchecked_setup()
619 : {
620 1025 : forktest_init();
621 1025 : }
622 765 : void setpath_withdata_oom_checked_setup()
623 : {
624 765 : signals_catch();
625 765 : forktest_gprofdir();
626 765 : modmgr_setpath("abc:def");
627 765 : ck_assert_msg(0 == strcmp("abc:def",modmgr_getpath()),"modmgr_getpath!=withdata");
628 765 : oomtest_enable(RAMLIMIT_SOFT);
629 765 : }
630 765 : void setpath_withdata_oom_checked_teardown()
631 : {
632 765 : signals_release();
633 765 : }
634 515 : void setpath_withdata_oom_unchecked_teardown() { }
635 :
636 : /************************************************************************/
637 515 : void setpath_pathmax_oom_unchecked_setup()
638 : {
639 515 : forktest_init();
640 515 : }
641 765 : void setpath_pathmax_oom_checked_setup()
642 : {
643 : char modulePath[PATH_MAX];
644 765 : signals_catch();
645 765 : forktest_gprofdir();
646 765 : memset(modulePath, 65, PATH_MAX-1);
647 765 : modulePath[PATH_MAX-1]=0;
648 765 : modmgr_setpath(modulePath);
649 765 : ck_assert_msg(0 == strcmp(modulePath,modmgr_getpath()),"modmgr_getpath!=bigval");
650 765 : oomtest_enable(RAMLIMIT_SOFT);
651 765 : }
652 765 : void setpath_pathmax_oom_checked_teardown()
653 : {
654 765 : signals_release();
655 765 : }
656 5 : void setpath_pathmax_oom_unchecked_teardown() { }
657 :
658 2155 : Suite* modmgr_searchpath_suite()
659 : {
660 : Suite *s;
661 : TCase *tc;
662 :
663 2155 : s = suite_create("ModMgr-SearchPath");
664 :
665 2155 : tc = tcase_create("Uninitialized");
666 2155 : tcase_add_checked_fixture(tc, setpath_uninitialized_checked_setup, setpath_uninitialized_checked_teardown);
667 2155 : tcase_add_unchecked_fixture(tc, setpath_uninitialized_unchecked_setup, setpath_uninitialized_unchecked_teardown);
668 2155 : suite_add_tcase(s, tc);
669 2155 : tcase_add_test(tc, set_null);
670 2155 : tcase_add_test(tc, set_empty);
671 2155 : tcase_add_test(tc, set_value);
672 2155 : tcase_add_test(tc, set_bigvalue);
673 2155 : tcase_add_test(tc, set_hugevalue);
674 2155 : tcase_add_test(tc, add_null);
675 2155 : tcase_add_test(tc, add_empty);
676 2155 : tcase_add_test(tc, add_value);
677 2155 : tcase_add_test(tc, add_bigvalue);
678 2155 : tcase_add_test(tc, add_hugevalue);
679 2155 : tcase_add_test(tc, insert_null_at_null);
680 2155 : tcase_add_test(tc, insert_null_at_first);
681 2155 : tcase_add_test(tc, insert_null_at_second);
682 2155 : tcase_add_test(tc, insert_null_at_colon);
683 2155 : tcase_add_test(tc, insert_null_at_middle);
684 2155 : tcase_add_test(tc, insert_null_at_end);
685 2155 : tcase_add_test(tc, insert_null_at_outside);
686 :
687 2155 : tc = tcase_create("Empty");
688 2155 : tcase_add_checked_fixture(tc, setpath_empty_checked_setup, setpath_empty_checked_teardown);
689 2155 : tcase_add_unchecked_fixture(tc, setpath_empty_unchecked_setup, setpath_empty_unchecked_teardown);
690 2155 : suite_add_tcase(s, tc);
691 2155 : tcase_add_test(tc, set_null);
692 2155 : tcase_add_test(tc, set_empty);
693 2155 : tcase_add_test(tc, set_value);
694 2155 : tcase_add_test(tc, set_bigvalue);
695 2155 : tcase_add_test(tc, set_hugevalue);
696 2155 : tcase_add_test(tc, add_null);
697 2155 : tcase_add_test(tc, add_empty);
698 2155 : tcase_add_test(tc, add_value);
699 2155 : tcase_add_test(tc, add_bigvalue);
700 2155 : tcase_add_test(tc, add_hugevalue);
701 2155 : tcase_add_test(tc, insert_null_at_null);
702 2155 : tcase_add_test(tc, insert_null_at_first);
703 2155 : tcase_add_test(tc, insert_null_at_second);
704 2155 : tcase_add_test(tc, insert_null_at_colon);
705 2155 : tcase_add_test(tc, insert_null_at_middle);
706 2155 : tcase_add_test(tc, insert_null_at_end);
707 2155 : tcase_add_test(tc, insert_null_at_outside);
708 :
709 2155 : tc = tcase_create("WithData");
710 2155 : tcase_add_checked_fixture(tc, setpath_withdata_checked_setup, setpath_withdata_checked_teardown);
711 2155 : tcase_add_unchecked_fixture(tc, setpath_withdata_unchecked_setup, setpath_withdata_unchecked_teardown);
712 2155 : suite_add_tcase(s, tc);
713 2155 : tcase_add_test(tc, set_null);
714 2155 : tcase_add_test(tc, set_empty);
715 2155 : tcase_add_test(tc, set_value);
716 2155 : tcase_add_test(tc, set_bigvalue);
717 2155 : tcase_add_test(tc, set_hugevalue);
718 2155 : tcase_add_test(tc, add_null);
719 2155 : tcase_add_test(tc, add_empty);
720 2155 : tcase_add_test(tc, add_value);
721 2155 : tcase_add_test(tc, add_bigvalue);
722 2155 : tcase_add_test(tc, add_hugevalue);
723 2155 : tcase_add_test(tc, insert_null_at_null);
724 2155 : tcase_add_test(tc, insert_null_at_first);
725 2155 : tcase_add_test(tc, insert_null_at_second);
726 2155 : tcase_add_test(tc, insert_null_at_colon);
727 2155 : tcase_add_test(tc, insert_null_at_middle);
728 2155 : tcase_add_test(tc, insert_null_at_end);
729 2155 : tcase_add_test(tc, insert_null_at_outside);
730 :
731 2155 : tc = tcase_create("PathMax");
732 2155 : tcase_add_checked_fixture(tc, setpath_pathmax_checked_setup, setpath_pathmax_checked_teardown);
733 2155 : tcase_add_unchecked_fixture(tc, setpath_pathmax_unchecked_setup, setpath_pathmax_unchecked_teardown);
734 2155 : suite_add_tcase(s, tc);
735 2155 : tcase_add_test(tc, set_null);
736 2155 : tcase_add_test(tc, set_empty);
737 2155 : tcase_add_test(tc, set_value);
738 2155 : tcase_add_test(tc, set_bigvalue);
739 2155 : tcase_add_test(tc, set_hugevalue);
740 2155 : tcase_add_test(tc, add_null);
741 2155 : tcase_add_test(tc, add_empty);
742 2155 : tcase_add_test(tc, add_value);
743 2155 : tcase_add_test(tc, add_bigvalue);
744 2155 : tcase_add_test(tc, add_hugevalue);
745 2155 : tcase_add_test(tc, insert_null_at_null);
746 2155 : tcase_add_test(tc, insert_null_at_first);
747 2155 : tcase_add_test(tc, insert_null_at_second);
748 2155 : tcase_add_test(tc, insert_null_at_colon);
749 2155 : tcase_add_test(tc, insert_null_at_middle);
750 2155 : tcase_add_test(tc, insert_null_at_end);
751 2155 : tcase_add_test(tc, insert_null_at_outside);
752 :
753 :
754 2155 : tc = tcase_create("Uninitialized-OOM");
755 2155 : tcase_set_tags(tc,"oom");
756 2155 : tcase_add_checked_fixture(tc, setpath_uninitialized_oom_checked_setup, setpath_uninitialized_oom_checked_teardown);
757 2155 : tcase_add_unchecked_fixture(tc, setpath_uninitialized_oom_unchecked_setup, setpath_uninitialized_oom_unchecked_teardown);
758 2155 : suite_add_tcase(s, tc);
759 2155 : tcase_add_loop_test(tc, set_null, 0, 15);
760 2155 : tcase_add_loop_test(tc, set_empty, 0, 15);
761 2155 : tcase_add_loop_test(tc, set_value, 0, 15);
762 2155 : tcase_add_loop_test(tc, set_bigvalue, 0, 15);
763 2155 : tcase_add_loop_test(tc, set_hugevalue, 0, 15);
764 2155 : tcase_add_loop_test(tc, add_null, 0, 15);
765 2155 : tcase_add_loop_test(tc, add_empty, 0, 15);
766 2155 : tcase_add_loop_test(tc, add_value, 0, 15);
767 2155 : tcase_add_loop_test(tc, add_bigvalue, 0, 15);
768 : /* tcase_add_loop_test(tc, add_hugevalue, 0, 15);
769 : */
770 2155 : tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
771 2155 : tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
772 2155 : tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
773 2155 : tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
774 2155 : tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
775 2155 : tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
776 2155 : tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);
777 :
778 2155 : tc = tcase_create("Empty-OOM");
779 2155 : tcase_set_tags(tc,"oom");
780 2155 : tcase_add_checked_fixture(tc, setpath_empty_oom_checked_setup, setpath_empty_oom_checked_teardown);
781 2155 : tcase_add_unchecked_fixture(tc, setpath_empty_oom_unchecked_setup, setpath_empty_oom_unchecked_teardown);
782 2155 : suite_add_tcase(s, tc);
783 2155 : tcase_add_loop_test(tc, set_null, 0, 15);
784 2155 : tcase_add_loop_test(tc, set_empty, 0, 15);
785 2155 : tcase_add_loop_test(tc, set_value, 0, 15);
786 2155 : tcase_add_loop_test(tc, set_bigvalue, 0, 15);
787 2155 : tcase_add_loop_test(tc, set_hugevalue, 0, 15);
788 2155 : tcase_add_loop_test(tc, add_null, 0, 15);
789 2155 : tcase_add_loop_test(tc, add_empty, 0, 15);
790 2155 : tcase_add_loop_test(tc, add_value, 0, 15);
791 2155 : tcase_add_loop_test(tc, add_bigvalue, 0, 15);
792 2155 : tcase_add_loop_test(tc, add_hugevalue, 0, 15);
793 2155 : tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
794 2155 : tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
795 2155 : tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
796 2155 : tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
797 2155 : tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
798 2155 : tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
799 2155 : tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);
800 :
801 2155 : tc = tcase_create("WithData-OOM");
802 2155 : tcase_set_tags(tc,"oom");
803 2155 : tcase_add_checked_fixture(tc, setpath_withdata_oom_checked_setup, setpath_withdata_oom_checked_teardown);
804 2155 : tcase_add_unchecked_fixture(tc, setpath_withdata_oom_unchecked_setup, setpath_withdata_oom_unchecked_teardown);
805 2155 : suite_add_tcase(s, tc);
806 2155 : tcase_add_loop_test(tc, set_null, 0, 15);
807 2155 : tcase_add_loop_test(tc, set_empty, 0, 15);
808 2155 : tcase_add_loop_test(tc, set_value, 0, 15);
809 2155 : tcase_add_loop_test(tc, set_bigvalue, 0, 15);
810 2155 : tcase_add_loop_test(tc, set_hugevalue, 0, 15);
811 2155 : tcase_add_loop_test(tc, add_null, 0, 15);
812 2155 : tcase_add_loop_test(tc, add_empty, 0, 15);
813 2155 : tcase_add_loop_test(tc, add_value, 0, 15);
814 2155 : tcase_add_loop_test(tc, add_bigvalue, 0, 15);
815 2155 : tcase_add_loop_test(tc, add_hugevalue, 0, 15);
816 2155 : tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
817 2155 : tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
818 2155 : tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
819 2155 : tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
820 2155 : tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
821 2155 : tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
822 2155 : tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);
823 :
824 2155 : tc = tcase_create("PathMax-OOM");
825 2155 : tcase_set_tags(tc,"oom");
826 2155 : tcase_add_checked_fixture(tc, setpath_pathmax_oom_checked_setup, setpath_pathmax_oom_checked_teardown);
827 2155 : tcase_add_unchecked_fixture(tc, setpath_pathmax_oom_unchecked_setup, setpath_pathmax_oom_unchecked_teardown);
828 2155 : suite_add_tcase(s, tc);
829 2155 : tcase_add_loop_test(tc, set_null, 0, 15);
830 2155 : tcase_add_loop_test(tc, set_empty, 0, 15);
831 2155 : tcase_add_loop_test(tc, set_value, 0, 15);
832 2155 : tcase_add_loop_test(tc, set_bigvalue, 0, 15);
833 2155 : tcase_add_loop_test(tc, set_hugevalue, 0, 15);
834 2155 : tcase_add_loop_test(tc, add_null, 0, 15);
835 2155 : tcase_add_loop_test(tc, add_empty, 0, 15);
836 2155 : tcase_add_loop_test(tc, add_value, 0, 15);
837 2155 : tcase_add_loop_test(tc, add_bigvalue, 0, 15);
838 2155 : tcase_add_loop_test(tc, add_hugevalue, 0, 15);
839 2155 : tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
840 2155 : tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
841 2155 : tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
842 2155 : tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
843 2155 : tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
844 2155 : tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
845 2155 : tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);
846 :
847 2155 : return s;
848 : }
849 :
|
