Line data Source code
1 : /** @file suite_clusterlst.c
2 : * @brief Check testsuite for clusterlst functions
3 : * @author François Cerbelle (Fanfan), francois@cerbelle.net
4 : *
5 : * @internal
6 : * Created: 20/03/2022
7 : * Revision: none
8 : * Last modified: 2024-11-13 18:51
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 <check.h>
22 : #include <stdlib.h>
23 : #include "checktools.inc"
24 :
25 : #include "clusterlst.c"
26 :
27 : /** Dummy test to trigger fixtures
28 : *
29 : * This test is defined and added to all testcases in order to execute at
30 : * least one test test in each testcase of the testsuite, trigger the
31 : * fixtures and have a decent coverage report.
32 : */
33 9 : START_TEST(clusterlst_test) {
34 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
35 : * whole testsuite if not caught or not in a child process */
36 9 : forktest_only;
37 :
38 6 : abort();
39 : }
40 : END_TEST
41 :
42 3 : START_TEST(clusterlst_uninitialized_init) {
43 3 : clusterrecord_t* first=clusterlistfirst;
44 3 : clusterrecord_t* last=clusterlistlast;
45 3 : clusterrecord_t* cursor=clusterlistcursor;
46 3 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
47 3 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
48 3 : cluster_t* (*f_first)()=clusterlist_first;
49 3 : cluster_t* (*f_next)()=clusterlist_next;
50 3 : cluster_t* (*f_get)()=clusterlist_get;
51 :
52 3 : clusterlist_init();
53 :
54 3 : ck_assert(first!=clusterlistfirst);
55 3 : ck_assert(last!=clusterlistlast);
56 3 : ck_assert(cursor!=clusterlistcursor);
57 3 : ck_assert(f_add!=clusterlist_add);
58 3 : ck_assert(f_find!=clusterlist_find);
59 3 : ck_assert(f_first!=clusterlist_first);
60 3 : ck_assert(f_next!=clusterlist_next);
61 3 : ck_assert(f_get!=clusterlist_get);
62 :
63 3 : ck_assert(clusterlistfirst==clusterlistlast);
64 3 : ck_assert(NULL==clusterlistfirst->cluster);
65 3 : ck_assert(NULL==clusterlistlast->cluster);
66 3 : ck_assert(NULL==clusterlistcursor->cluster);
67 3 : }
68 : END_TEST
69 :
70 3 : START_TEST(clusterlst_uninitialized_add) {
71 : /* Need to have a forked env to start uninitialized */
72 3 : forktest_only;
73 :
74 2 : clusterrecord_t* first=clusterlistfirst;
75 2 : clusterrecord_t* last=clusterlistlast;
76 2 : clusterrecord_t* cursor=clusterlistcursor;
77 2 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
78 2 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
79 2 : cluster_t* (*f_first)()=clusterlist_first;
80 2 : cluster_t* (*f_next)()=clusterlist_next;
81 2 : cluster_t* (*f_get)()=clusterlist_get;
82 : cluster_t* cluster;
83 :
84 : /* Currently leaked */
85 2 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
86 0 : perror("clusterlst_uninitialized_add");
87 0 : abort();
88 : }
89 2 : cluster->host=NULL;
90 2 : cluster->user=NULL;
91 2 : cluster->pass=NULL;
92 2 : cluster->insecure=NULL;
93 2 : cluster->cacert=NULL;
94 2 : clusterlist_add(cluster);
95 :
96 2 : ck_assert(clusterlistfirst->cluster);
97 2 : ck_assert(NULL==clusterlistlast->cluster);
98 2 : ck_assert(clusterlistcursor->cluster);
99 :
100 2 : ck_assert(first!=clusterlistfirst);
101 2 : ck_assert(last!=clusterlistlast);
102 2 : ck_assert(cursor!=clusterlistcursor);
103 2 : ck_assert(f_add!=clusterlist_add);
104 2 : ck_assert(f_find!=clusterlist_find);
105 2 : ck_assert(f_first!=clusterlist_first);
106 2 : ck_assert(f_next!=clusterlist_next);
107 2 : ck_assert(f_get!=clusterlist_get);
108 :
109 2 : ck_assert(clusterlistfirst!=clusterlistlast);
110 2 : ck_assert(NULL==clusterlistfirst->cluster->host);
111 :
112 : /* Second run should not invoke init and change the pointers and functors */
113 2 : first=clusterlistfirst;
114 2 : last=clusterlistlast;
115 2 : cursor=clusterlistcursor;
116 2 : f_add=clusterlist_add;
117 2 : f_find=clusterlist_find;
118 2 : f_first=clusterlist_first;
119 2 : f_next=clusterlist_next;
120 2 : f_get=clusterlist_get;
121 :
122 : /* Currently leaked */
123 2 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
124 0 : perror("clusterlst_uninitialized_add");
125 0 : abort();
126 : }
127 2 : cluster->host=NULL;
128 2 : cluster->user=NULL;
129 2 : cluster->pass=NULL;
130 2 : cluster->insecure=NULL;
131 2 : cluster->cacert=NULL;
132 2 : clusterlist_add(cluster);
133 :
134 2 : ck_assert(clusterlistfirst->cluster);
135 :
136 2 : ck_assert(first==clusterlistfirst);
137 2 : ck_assert(last!=clusterlistlast);
138 2 : ck_assert(cursor==clusterlistcursor);
139 2 : ck_assert(f_add==clusterlist_add);
140 2 : ck_assert(f_find==clusterlist_find);
141 2 : ck_assert(f_first==clusterlist_first);
142 2 : ck_assert(f_next==clusterlist_next);
143 2 : ck_assert(f_get==clusterlist_get);
144 :
145 2 : ck_assert(clusterlistfirst!=clusterlistlast);
146 2 : ck_assert(NULL!=clusterlistfirst->cluster);
147 2 : ck_assert(NULL==clusterlistfirst->cluster->host);
148 2 : ck_assert(NULL!=clusterlistfirst->next);
149 2 : ck_assert(NULL!=clusterlistfirst->next->cluster);
150 2 : ck_assert(NULL==clusterlistfirst->next->cluster->host);
151 2 : ck_assert(NULL==clusterlistlast->cluster);
152 2 : ck_assert(NULL!=clusterlistcursor->cluster);
153 : }
154 : END_TEST
155 :
156 3 : START_TEST(clusterlst_uninitialized_find) {
157 : /* Need to have a forked env to start uninitialized */
158 3 : forktest_only;
159 :
160 2 : clusterrecord_t* first=clusterlistfirst;
161 2 : clusterrecord_t* last=clusterlistlast;
162 2 : clusterrecord_t* cursor=clusterlistcursor;
163 2 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
164 2 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
165 2 : cluster_t* (*f_first)()=clusterlist_first;
166 2 : cluster_t* (*f_next)()=clusterlist_next;
167 2 : cluster_t* (*f_get)()=clusterlist_get;
168 : cluster_t* cluster;
169 :
170 2 : cluster = clusterlist_find("");
171 :
172 2 : ck_assert(first!=clusterlistfirst);
173 2 : ck_assert(last!=clusterlistlast);
174 2 : ck_assert(cursor!=clusterlistcursor);
175 2 : ck_assert(f_add!=clusterlist_add);
176 2 : ck_assert(f_find!=clusterlist_find);
177 2 : ck_assert(f_first!=clusterlist_first);
178 2 : ck_assert(f_next!=clusterlist_next);
179 2 : ck_assert(f_get!=clusterlist_get);
180 :
181 2 : ck_assert(clusterlistfirst==clusterlistlast);
182 2 : ck_assert(NULL==clusterlistfirst->cluster);
183 2 : ck_assert(NULL==clusterlistlast->cluster);
184 2 : ck_assert(NULL==clusterlistcursor->cluster);
185 2 : ck_assert(NULL==cluster);
186 :
187 : /* Second run should not invoke init and change the pointers and functors */
188 2 : first=clusterlistfirst;
189 2 : last=clusterlistlast;
190 2 : cursor=clusterlistcursor;
191 2 : f_add=clusterlist_add;
192 2 : f_find=clusterlist_find;
193 2 : f_first=clusterlist_first;
194 2 : f_next=clusterlist_next;
195 2 : f_get=clusterlist_get;
196 :
197 2 : cluster = clusterlist_find("");
198 :
199 2 : ck_assert(first==clusterlistfirst);
200 : /* Change expected ck_assert(last==clusterlistlast);*/
201 2 : ck_assert(cursor==clusterlistcursor);
202 2 : ck_assert(f_add==clusterlist_add);
203 2 : ck_assert(f_find==clusterlist_find);
204 2 : ck_assert(f_first==clusterlist_first);
205 2 : ck_assert(f_next==clusterlist_next);
206 2 : ck_assert(f_get==clusterlist_get);
207 :
208 2 : ck_assert(clusterlistfirst==clusterlistlast);
209 2 : ck_assert(NULL==clusterlistfirst->cluster);
210 2 : ck_assert(NULL==clusterlistlast->cluster);
211 2 : ck_assert(NULL==clusterlistcursor->cluster);
212 2 : ck_assert(NULL==cluster);
213 : }
214 : END_TEST
215 :
216 3 : START_TEST(clusterlst_uninitialized_first) {
217 : /* Need to have a forked env to start uninitialized */
218 3 : forktest_only;
219 :
220 2 : clusterrecord_t* first=clusterlistfirst;
221 2 : clusterrecord_t* last=clusterlistlast;
222 2 : clusterrecord_t* cursor=clusterlistcursor;
223 2 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
224 2 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
225 2 : cluster_t* (*f_first)()=clusterlist_first;
226 2 : cluster_t* (*f_next)()=clusterlist_next;
227 2 : cluster_t* (*f_get)()=clusterlist_get;
228 : cluster_t* cluster;
229 :
230 2 : cluster = clusterlist_first();
231 :
232 2 : ck_assert(first!=clusterlistfirst);
233 2 : ck_assert(last!=clusterlistlast);
234 2 : ck_assert(cursor!=clusterlistcursor);
235 :
236 2 : ck_assert(f_add!=clusterlist_add);
237 2 : ck_assert(f_find!=clusterlist_find);
238 2 : ck_assert(f_first!=clusterlist_first);
239 2 : ck_assert(f_next!=clusterlist_next);
240 2 : ck_assert(f_get!=clusterlist_get);
241 :
242 2 : ck_assert(clusterlistfirst==clusterlistlast);
243 2 : ck_assert(NULL==clusterlistfirst->cluster);
244 2 : ck_assert(NULL==clusterlistlast->cluster);
245 2 : ck_assert(NULL==clusterlistcursor->cluster);
246 2 : ck_assert(NULL==cluster);
247 :
248 : /* Second run should not invoke init and change the pointers and functors */
249 2 : first=clusterlistfirst;
250 2 : last=clusterlistlast;
251 2 : cursor=clusterlistcursor;
252 2 : f_add=clusterlist_add;
253 2 : f_find=clusterlist_find;
254 2 : f_first=clusterlist_first;
255 2 : f_next=clusterlist_next;
256 2 : f_get=clusterlist_get;
257 :
258 2 : cluster = clusterlist_first();
259 :
260 2 : ck_assert(first==clusterlistfirst);
261 : /* Change expected ck_assert(last==clusterlistlast);*/
262 2 : ck_assert(cursor==clusterlistcursor);
263 2 : ck_assert(f_add==clusterlist_add);
264 2 : ck_assert(f_find==clusterlist_find);
265 2 : ck_assert(f_first==clusterlist_first);
266 2 : ck_assert(f_next==clusterlist_next);
267 2 : ck_assert(f_get==clusterlist_get);
268 :
269 2 : ck_assert(clusterlistfirst==clusterlistlast);
270 2 : ck_assert(NULL==clusterlistfirst->cluster);
271 2 : ck_assert(NULL==clusterlistlast->cluster);
272 2 : ck_assert(NULL==clusterlistcursor->cluster);
273 2 : ck_assert(NULL==cluster);
274 : }
275 : END_TEST
276 :
277 3 : START_TEST(clusterlst_uninitialized_next) {
278 : /* Need to have a forked env to start uninitialized */
279 3 : forktest_only;
280 :
281 2 : clusterrecord_t* first=clusterlistfirst;
282 2 : clusterrecord_t* last=clusterlistlast;
283 2 : clusterrecord_t* cursor=clusterlistcursor;
284 2 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
285 2 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
286 2 : cluster_t* (*f_first)()=clusterlist_first;
287 2 : cluster_t* (*f_next)()=clusterlist_next;
288 2 : cluster_t* (*f_get)()=clusterlist_get;
289 : cluster_t* cluster;
290 :
291 2 : cluster = clusterlist_next();
292 :
293 2 : ck_assert(first!=clusterlistfirst);
294 2 : ck_assert(last!=clusterlistlast);
295 2 : ck_assert(cursor!=clusterlistcursor);
296 2 : ck_assert(f_add!=clusterlist_add);
297 2 : ck_assert(f_find!=clusterlist_find);
298 2 : ck_assert(f_first!=clusterlist_first);
299 2 : ck_assert(f_next!=clusterlist_next);
300 2 : ck_assert(f_get!=clusterlist_get);
301 :
302 2 : ck_assert(clusterlistfirst==clusterlistlast);
303 2 : ck_assert(NULL==clusterlistfirst->cluster);
304 2 : ck_assert(NULL==clusterlistlast->cluster);
305 2 : ck_assert(NULL==clusterlistcursor->cluster);
306 2 : ck_assert(NULL==cluster);
307 :
308 : /* Second run should not invoke init and change the pointers and functors */
309 2 : first=clusterlistfirst;
310 2 : last=clusterlistlast;
311 2 : cursor=clusterlistcursor;
312 2 : f_add=clusterlist_add;
313 2 : f_find=clusterlist_find;
314 2 : f_first=clusterlist_first;
315 2 : f_next=clusterlist_next;
316 2 : f_get=clusterlist_get;
317 :
318 2 : cluster = clusterlist_next();
319 :
320 2 : ck_assert(first==clusterlistfirst);
321 : /* Change expected ck_assert(last==clusterlistlast);*/
322 2 : ck_assert(cursor==clusterlistcursor);
323 2 : ck_assert(f_add==clusterlist_add);
324 2 : ck_assert(f_find==clusterlist_find);
325 2 : ck_assert(f_first==clusterlist_first);
326 2 : ck_assert(f_next==clusterlist_next);
327 2 : ck_assert(f_get==clusterlist_get);
328 :
329 2 : ck_assert(clusterlistfirst==clusterlistlast);
330 2 : ck_assert(NULL==clusterlistfirst->cluster);
331 2 : ck_assert(NULL==clusterlistlast->cluster);
332 2 : ck_assert(NULL==clusterlistcursor->cluster);
333 2 : ck_assert(NULL==cluster);
334 : }
335 : END_TEST
336 :
337 3 : START_TEST(clusterlst_uninitialized_get) {
338 : /* Need to have a forked env to start uninitialized */
339 3 : forktest_only;
340 :
341 2 : clusterrecord_t* first=clusterlistfirst;
342 2 : clusterrecord_t* last=clusterlistlast;
343 2 : clusterrecord_t* cursor=clusterlistcursor;
344 2 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
345 2 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
346 2 : cluster_t* (*f_first)()=clusterlist_first;
347 2 : cluster_t* (*f_next)()=clusterlist_next;
348 2 : cluster_t* (*f_get)()=clusterlist_get;
349 : cluster_t* cluster;
350 :
351 2 : cluster = clusterlist_get();
352 :
353 2 : ck_assert(first!=clusterlistfirst);
354 2 : ck_assert(last!=clusterlistlast);
355 2 : ck_assert(cursor!=clusterlistcursor);
356 2 : ck_assert(f_add!=clusterlist_add);
357 2 : ck_assert(f_find!=clusterlist_find);
358 2 : ck_assert(f_first!=clusterlist_first);
359 2 : ck_assert(f_next!=clusterlist_next);
360 2 : ck_assert(f_get!=clusterlist_get);
361 :
362 2 : ck_assert(clusterlistfirst==clusterlistlast);
363 2 : ck_assert(NULL==clusterlistfirst->cluster);
364 2 : ck_assert(NULL==clusterlistlast->cluster);
365 2 : ck_assert(NULL==clusterlistcursor->cluster);
366 2 : ck_assert(NULL==cluster);
367 :
368 : /* Second run should not invoke init and change the pointers and functors */
369 2 : first=clusterlistfirst;
370 2 : last=clusterlistlast;
371 2 : cursor=clusterlistcursor;
372 2 : f_add=clusterlist_add;
373 2 : f_find=clusterlist_find;
374 2 : f_first=clusterlist_first;
375 2 : f_next=clusterlist_next;
376 2 : f_get=clusterlist_get;
377 :
378 2 : cluster = clusterlist_get();
379 :
380 2 : ck_assert(first==clusterlistfirst);
381 : /* Change expected ck_assert(last==clusterlistlast);*/
382 2 : ck_assert(cursor==clusterlistcursor);
383 2 : ck_assert(f_add==clusterlist_add);
384 2 : ck_assert(f_find==clusterlist_find);
385 2 : ck_assert(f_first==clusterlist_first);
386 2 : ck_assert(f_next==clusterlist_next);
387 2 : ck_assert(f_get==clusterlist_get);
388 :
389 2 : ck_assert(clusterlistfirst==clusterlistlast);
390 2 : ck_assert(NULL==clusterlistfirst->cluster);
391 2 : ck_assert(NULL==clusterlistlast->cluster);
392 2 : ck_assert(NULL==clusterlistcursor->cluster);
393 2 : ck_assert(NULL==cluster);
394 : }
395 : END_TEST
396 :
397 6 : START_TEST(clusterlst_initialized_add) {
398 6 : clusterrecord_t* first=clusterlistfirst;
399 6 : clusterrecord_t* last=clusterlistlast;
400 6 : clusterrecord_t* cursor=clusterlistcursor;
401 6 : void (*f_add)(cluster_t* cluster)=clusterlist_add;
402 6 : cluster_t* (*f_find) (const char* host)=clusterlist_find;
403 6 : cluster_t* (*f_first)()=clusterlist_first;
404 6 : cluster_t* (*f_next)()=clusterlist_next;
405 6 : cluster_t* (*f_get)()=clusterlist_get;
406 : cluster_t* cluster;
407 :
408 : /* Currently leaked */
409 6 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
410 0 : perror("clusterlst_uninitialized_add");
411 0 : abort();
412 : }
413 6 : cluster->host=NULL;
414 6 : cluster->user=NULL;
415 6 : cluster->pass=NULL;
416 6 : cluster->insecure=NULL;
417 6 : cluster->cacert=NULL;
418 6 : clusterlist_add(cluster);
419 :
420 6 : ck_assert(first==clusterlistfirst);
421 6 : ck_assert(last!=clusterlistlast);
422 6 : ck_assert(cursor==clusterlistcursor);
423 6 : ck_assert(f_add==clusterlist_add);
424 6 : ck_assert(f_find==clusterlist_find);
425 6 : ck_assert(f_first==clusterlist_first);
426 6 : ck_assert(f_next==clusterlist_next);
427 6 : ck_assert(f_get==clusterlist_get);
428 :
429 6 : ck_assert(clusterlistfirst!=clusterlistlast);
430 6 : ck_assert(NULL!=clusterlistfirst->cluster);
431 6 : ck_assert(NULL==clusterlistfirst->cluster->host);
432 6 : ck_assert(NULL!=clusterlistfirst->next);
433 6 : ck_assert(NULL==clusterlistlast->cluster);
434 6 : ck_assert(NULL!=clusterlistcursor->cluster);
435 6 : }
436 : END_TEST
437 :
438 3 : START_TEST(clusterlst_initialized_find) {
439 : /* Find in empty list */
440 3 : ck_assert(NULL==clusterlist_find(NULL));
441 3 : ck_assert(NULL==clusterlist_find(""));
442 3 : ck_assert(NULL==clusterlist_find("a"));
443 3 : }
444 : END_TEST
445 :
446 3 : START_TEST(clusterlst_populated_find) {
447 : /* Find in NULL,"","a","b","",NULL */
448 : /* Find first, middle, last, nonexistant, duplicate */
449 3 : ck_assert(clusterlistfirst->cluster==clusterlist_find(NULL));
450 3 : ck_assert(clusterlistfirst->next->cluster==clusterlist_find(""));
451 3 : ck_assert(clusterlistfirst->next->next->cluster==clusterlist_find("a"));
452 3 : ck_assert(NULL==clusterlist_find("c"));
453 3 : }
454 : END_TEST
455 :
456 6 : START_TEST(clusterlst_initialized_firstnextget) {
457 6 : clusterrecord_t* i = clusterlistfirst;
458 6 : ck_assert(i->cluster==clusterlist_first());
459 6 : ck_assert(clusterlistfirst==clusterlistcursor);
460 30 : while (i) {
461 24 : ck_assert(i==clusterlistcursor);
462 24 : ck_assert(i->cluster==clusterlist_get());
463 24 : ck_assert( (i->next==NULL)||(i->next->cluster == clusterlist_next()));
464 24 : ck_assert((i->next!=NULL)||(i==clusterlistlast));
465 24 : i = i->next;
466 : }
467 6 : }
468 : END_TEST
469 :
470 : /************************************************************************/
471 : /* Begining of test (potentially in child) */
472 21 : void clusterlst_checked_uninitialized_setup() {
473 21 : signals_catch();
474 21 : forktest_gprofdir();
475 21 : }
476 :
477 : /* Begining of test (potentially in child) */
478 12 : void clusterlst_checked_initialized_setup() {
479 12 : signals_catch();
480 12 : forktest_gprofdir();
481 12 : clusterlist_init();
482 12 : }
483 :
484 : /* Begining of test (potentially in child) */
485 12 : void clusterlst_checked_populated_setup() {
486 : cluster_t* cluster;
487 :
488 12 : signals_catch();
489 12 : forktest_gprofdir();
490 12 : clusterlist_init();
491 :
492 : /* Currently leaked */
493 12 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
494 0 : perror("clusterlst_uninitialized_add");
495 0 : abort();
496 : }
497 12 : cluster->host=NULL;
498 12 : clusterlist_add(cluster);
499 :
500 : /* Currently leaked */
501 12 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
502 0 : perror("clusterlst_uninitialized_add");
503 0 : abort();
504 : }
505 12 : cluster->host=strdup("");
506 12 : clusterlist_add(cluster);
507 :
508 : /* Currently leaked */
509 12 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
510 0 : perror("clusterlst_uninitialized_add");
511 0 : abort();
512 : }
513 12 : cluster->host=strdup("a");
514 12 : clusterlist_add(cluster);
515 :
516 : /* Currently leaked */
517 12 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
518 0 : perror("clusterlst_uninitialized_add");
519 0 : abort();
520 : }
521 12 : cluster->host=strdup("b");
522 12 : clusterlist_add(cluster);
523 :
524 : /* Currently leaked */
525 12 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
526 0 : perror("clusterlst_uninitialized_add");
527 0 : abort();
528 : }
529 12 : cluster->host=strdup("");
530 12 : clusterlist_add(cluster);
531 :
532 : /* Currently leaked */
533 12 : if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
534 0 : perror("clusterlst_uninitialized_add");
535 0 : abort();
536 : }
537 12 : cluster->host=NULL;
538 12 : clusterlist_add(cluster);
539 12 : }
540 :
541 : /* End of test (potentially in child) */
542 39 : void clusterlst_checked_uninitialized_teardown() {
543 39 : signals_release();
544 39 : }
545 : /************************************************************************/
546 63 : void clusterlst_unchecked_common_setup() {
547 63 : forktest_init();
548 63 : }
549 33 : void clusterlst_unchecked_common_teardown() {
550 33 : }
551 : /************************************************************************/
552 34 : Suite* clusterlst_suite() {
553 : Suite *s;
554 : TCase *tc;
555 :
556 34 : s = suite_create("Clusterlst");
557 :
558 34 : tc = tcase_create("ClusterlstUninitialized");
559 34 : tcase_set_tags(tc,"ClusterlstTag ClusterlstTag2");
560 : /* tcase_set_timeout(tc,5); */ /* seconds */
561 34 : tcase_add_checked_fixture(tc, clusterlst_checked_uninitialized_setup, clusterlst_checked_uninitialized_teardown);
562 34 : tcase_add_unchecked_fixture(tc, clusterlst_unchecked_common_setup, clusterlst_unchecked_common_teardown);
563 34 : suite_add_tcase(s, tc);
564 34 : tcase_add_test_raise_signal(tc, clusterlst_test,6);
565 34 : tcase_add_test(tc, clusterlst_uninitialized_init);
566 34 : tcase_add_test(tc, clusterlst_uninitialized_add);
567 34 : tcase_add_test(tc, clusterlst_uninitialized_find);
568 34 : tcase_add_test(tc, clusterlst_uninitialized_first);
569 34 : tcase_add_test(tc, clusterlst_uninitialized_next);
570 34 : tcase_add_test(tc, clusterlst_uninitialized_get);
571 :
572 34 : tc = tcase_create("ClusterlstInitialized");
573 34 : tcase_set_tags(tc,"ClusterlstTag ClusterlstTag2");
574 : /* tcase_set_timeout(tc,5); */ /* seconds */
575 34 : tcase_add_checked_fixture(tc, clusterlst_checked_initialized_setup, clusterlst_checked_uninitialized_teardown);
576 34 : tcase_add_unchecked_fixture(tc, clusterlst_unchecked_common_setup, clusterlst_unchecked_common_teardown);
577 34 : suite_add_tcase(s, tc);
578 34 : tcase_add_test_raise_signal(tc, clusterlst_test,6);
579 34 : tcase_add_test(tc, clusterlst_initialized_add);
580 34 : tcase_add_test(tc, clusterlst_initialized_find);
581 34 : tcase_add_test(tc, clusterlst_initialized_firstnextget);
582 :
583 34 : tc = tcase_create("ClusterlstPopulated");
584 34 : tcase_set_tags(tc,"ClusterlstTag ClusterlstTag2");
585 : /* tcase_set_timeout(tc,5); */ /* seconds */
586 34 : tcase_add_checked_fixture(tc, clusterlst_checked_populated_setup, clusterlst_checked_uninitialized_teardown);
587 34 : tcase_add_unchecked_fixture(tc, clusterlst_unchecked_common_setup, clusterlst_unchecked_common_teardown);
588 34 : suite_add_tcase(s, tc);
589 34 : tcase_add_test_raise_signal(tc, clusterlst_test,6);
590 34 : tcase_add_test(tc, clusterlst_initialized_add);
591 34 : tcase_add_test(tc, clusterlst_populated_find);
592 34 : tcase_add_test(tc, clusterlst_initialized_firstnextget);
593 :
594 34 : return s;
595 : }
596 : /* vim: set tw=80: */
|
