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 00:22
       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           6 : 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           6 :     forktest_only;
      37             : 
      38           4 :     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           3 : START_TEST(clusterlst_initialized_add) {
     398           3 :     clusterrecord_t* first=clusterlistfirst;
     399           3 :     clusterrecord_t* last=clusterlistlast;
     400           3 :     clusterrecord_t* cursor=clusterlistcursor;
     401           3 :     void       (*f_add)(cluster_t* cluster)=clusterlist_add;
     402           3 :     cluster_t* (*f_find) (const char* host)=clusterlist_find;
     403           3 :     cluster_t* (*f_first)()=clusterlist_first;
     404           3 :     cluster_t* (*f_next)()=clusterlist_next;
     405           3 :     cluster_t* (*f_get)()=clusterlist_get;
     406             :     cluster_t* cluster;
     407             : 
     408             :     /* Currently leaked */
     409           3 :     if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
     410           0 :         perror("clusterlst_uninitialized_add");
     411           0 :         abort();
     412             :     }
     413           3 :     cluster->host=NULL;
     414           3 :     cluster->user=NULL;
     415           3 :     cluster->pass=NULL;
     416           3 :     cluster->insecure=NULL;
     417           3 :     cluster->cacert=NULL;
     418           3 :     clusterlist_add(cluster);
     419             : 
     420           3 :     ck_assert(first==clusterlistfirst);
     421           3 :     ck_assert(last!=clusterlistlast);
     422           3 :     ck_assert(cursor==clusterlistcursor);
     423           3 :     ck_assert(f_add==clusterlist_add);
     424           3 :     ck_assert(f_find==clusterlist_find);
     425           3 :     ck_assert(f_first==clusterlist_first);
     426           3 :     ck_assert(f_next==clusterlist_next);
     427           3 :     ck_assert(f_get==clusterlist_get);
     428             : 
     429           3 :     ck_assert(clusterlistfirst!=clusterlistlast);
     430           3 :     ck_assert(NULL!=clusterlistfirst->cluster);
     431           3 :     ck_assert(NULL==clusterlistfirst->cluster->host);
     432           3 :     ck_assert(NULL!=clusterlistfirst->next);
     433           3 :     ck_assert(NULL==clusterlistfirst->next->cluster);
     434           3 :     ck_assert(NULL==clusterlistlast->cluster);
     435           3 :     ck_assert(NULL!=clusterlistcursor->cluster);
     436           3 : }
     437             : END_TEST
     438             : 
     439           3 : START_TEST(clusterlst_initialized_find) {
     440             :     /* Find in empty list */
     441             :     /* Create a list */
     442             :     /* "", a, b, c, NULL */
     443             :     /* Find first, middle, last, nonexistant */
     444           3 : }
     445             : END_TEST
     446             : 
     447           3 : START_TEST(clusterlst_initialized_next) {
     448             :     /* Next in empty list */
     449             :     /* Create a list */
     450             :     /* "", a, b, c, NULL */
     451             :     /* Next, next, next, next, next */
     452           3 : }
     453             : END_TEST
     454             : 
     455             : /************************************************************************/
     456             : /* Begining of test (potentially in child) */
     457          21 : void clusterlst_checked_uninitialized_setup() {
     458          21 :     signals_catch();
     459          21 :     forktest_gprofdir();
     460          21 : }
     461             : 
     462             : /* Begining of test (potentially in child) */
     463          12 : void clusterlst_checked_initialized_setup() {
     464          12 :     signals_catch();
     465          12 :     forktest_gprofdir();
     466          12 :     clusterlist_init();
     467          12 : }
     468             : 
     469             : /* End of test (potentially in child) */
     470          29 : void clusterlst_checked_uninitialized_teardown() {
     471          29 :     signals_release();
     472          29 : }
     473             : /************************************************************************/
     474          36 : void clusterlst_unchecked_common_setup() {
     475          36 :     forktest_init();
     476          36 : }
     477          14 : void clusterlst_unchecked_common_teardown() {
     478          14 : }
     479             : /************************************************************************/
     480          26 : Suite* clusterlst_suite() {
     481             :     Suite *s;
     482             :     TCase *tc;
     483             : 
     484          26 :     s = suite_create("Clusterlst");
     485             : 
     486          26 :     tc = tcase_create("ClusterlstUninitialized");
     487          26 :     tcase_set_tags(tc,"ClusterlstTag ClusterlstTag2");
     488             :     /* tcase_set_timeout(tc,5); */ /* seconds */
     489          26 :     tcase_add_checked_fixture(tc, clusterlst_checked_uninitialized_setup, clusterlst_checked_uninitialized_teardown);
     490          26 :     tcase_add_unchecked_fixture(tc, clusterlst_unchecked_common_setup, clusterlst_unchecked_common_teardown);
     491          26 :     suite_add_tcase(s, tc);
     492          26 :     tcase_add_test_raise_signal(tc, clusterlst_test,6);
     493          26 :     tcase_add_test(tc, clusterlst_uninitialized_init);
     494          26 :     tcase_add_test(tc, clusterlst_uninitialized_add);
     495          26 :     tcase_add_test(tc, clusterlst_uninitialized_find);
     496          26 :     tcase_add_test(tc, clusterlst_uninitialized_first);
     497          26 :     tcase_add_test(tc, clusterlst_uninitialized_next);
     498          26 :     tcase_add_test(tc, clusterlst_uninitialized_get);
     499             : 
     500          26 :     tc = tcase_create("ClusterlstInitialized");
     501          26 :     tcase_set_tags(tc,"ClusterlstTag ClusterlstTag2");
     502             :     /* tcase_set_timeout(tc,5); */ /* seconds */
     503          26 :     tcase_add_checked_fixture(tc, clusterlst_checked_initialized_setup, clusterlst_checked_uninitialized_teardown);
     504          26 :     tcase_add_unchecked_fixture(tc, clusterlst_unchecked_common_setup, clusterlst_unchecked_common_teardown);
     505          26 :     suite_add_tcase(s, tc);
     506          26 :     tcase_add_test_raise_signal(tc, clusterlst_test,6);
     507          26 :     tcase_add_test(tc, clusterlst_initialized_add);
     508          26 :     tcase_add_test(tc, clusterlst_initialized_find);
     509          26 :     tcase_add_test(tc, clusterlst_initialized_next);
     510             : 
     511          26 :     return s;
     512             : }
     513             : /* vim: set tw=80: */