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-12 19:48
       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           3 : 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           3 :     forktest_only;
      37             : 
      38           2 :     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           3 : }
      63             : END_TEST
      64             : 
      65           3 : START_TEST(clusterlst_uninitialized_add) {
      66             :     /* Need to have a forked env to start uninitialized */
      67           3 :     forktest_only;
      68             : 
      69           2 :     clusterrecord_t* first=clusterlistfirst;
      70           2 :     clusterrecord_t* last=clusterlistlast;
      71           2 :     clusterrecord_t* cursor=clusterlistcursor;
      72           2 :     void       (*f_add)(cluster_t* cluster)=clusterlist_add;
      73           2 :     cluster_t* (*f_find) (const char* host)=clusterlist_find;
      74           2 :     cluster_t* (*f_first)()=clusterlist_first;
      75           2 :     cluster_t* (*f_next)()=clusterlist_next;
      76           2 :     cluster_t* (*f_get)()=clusterlist_get;
      77             :     cluster_t* cluster;
      78             : 
      79           2 :     if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
      80           0 :         perror("clusterlst_uninitialized_add");
      81           0 :         abort();
      82             :     }
      83           2 :     cluster->host=NULL;
      84           2 :     cluster->user=NULL;
      85           2 :     cluster->pass=NULL;
      86           2 :     cluster->insecure=NULL;
      87           2 :     cluster->cacert=NULL;
      88           2 :     clusterlist_add(cluster);
      89             : 
      90           2 :     ck_assert(first!=clusterlistfirst);
      91           2 :     ck_assert(last!=clusterlistlast);
      92           2 :     ck_assert(cursor!=clusterlistcursor);
      93           2 :     ck_assert(f_add!=clusterlist_add);
      94           2 :     ck_assert(f_find!=clusterlist_find);
      95           2 :     ck_assert(f_first!=clusterlist_first);
      96           2 :     ck_assert(f_next!=clusterlist_next);
      97           2 :     ck_assert(f_get!=clusterlist_get);
      98             : 
      99             :     /* Second run should not invoke init and change the pointers and functors */
     100           2 :     first=clusterlistfirst;
     101           2 :     last=clusterlistlast;
     102           2 :     cursor=clusterlistcursor;
     103           2 :     f_add=clusterlist_add;
     104           2 :     f_find=clusterlist_find;
     105           2 :     f_first=clusterlist_first;
     106           2 :     f_next=clusterlist_next;
     107           2 :     f_get=clusterlist_get;
     108             : 
     109           2 :     if (NULL==(cluster=malloc(sizeof(struct cluster_s)))) {
     110           0 :         perror("clusterlst_uninitialized_add");
     111           0 :         abort();
     112             :     }
     113           2 :     cluster->host=NULL;
     114           2 :     cluster->user=NULL;
     115           2 :     cluster->pass=NULL;
     116           2 :     cluster->insecure=NULL;
     117           2 :     cluster->cacert=NULL;
     118           2 :     clusterlist_add(cluster);
     119             : 
     120           2 :     ck_assert(first==clusterlistfirst);
     121             :     /* Change expected ck_assert(last==clusterlistlast);*/
     122           2 :     ck_assert(cursor==clusterlistcursor);
     123           2 :     ck_assert(f_add==clusterlist_add);
     124           2 :     ck_assert(f_find==clusterlist_find);
     125           2 :     ck_assert(f_first==clusterlist_first);
     126           2 :     ck_assert(f_next==clusterlist_next);
     127           2 :     ck_assert(f_get==clusterlist_get);
     128             : }
     129             : END_TEST
     130             : 
     131           3 : START_TEST(clusterlst_uninitialized_find) {
     132             :     /* Need to have a forked env to start uninitialized */
     133           3 :     forktest_only;
     134             : 
     135           2 :     clusterrecord_t* first=clusterlistfirst;
     136           2 :     clusterrecord_t* last=clusterlistlast;
     137           2 :     clusterrecord_t* cursor=clusterlistcursor;
     138           2 :     void       (*f_add)(cluster_t* cluster)=clusterlist_add;
     139           2 :     cluster_t* (*f_find) (const char* host)=clusterlist_find;
     140           2 :     cluster_t* (*f_first)()=clusterlist_first;
     141           2 :     cluster_t* (*f_next)()=clusterlist_next;
     142           2 :     cluster_t* (*f_get)()=clusterlist_get;
     143             :     cluster_t* cluster;
     144             : 
     145           2 :     cluster = clusterlist_find("");
     146             : 
     147           2 :     ck_assert(first!=clusterlistfirst);
     148           2 :     ck_assert(last!=clusterlistlast);
     149           2 :     ck_assert(cursor!=clusterlistcursor);
     150           2 :     ck_assert(f_add!=clusterlist_add);
     151           2 :     ck_assert(f_find!=clusterlist_find);
     152           2 :     ck_assert(f_first!=clusterlist_first);
     153           2 :     ck_assert(f_next!=clusterlist_next);
     154           2 :     ck_assert(f_get!=clusterlist_get);
     155           2 :     ck_assert(NULL==cluster);
     156             : 
     157             :     /* Second run should not invoke init and change the pointers and functors */
     158           2 :     first=clusterlistfirst;
     159           2 :     last=clusterlistlast;
     160           2 :     cursor=clusterlistcursor;
     161           2 :     f_add=clusterlist_add;
     162           2 :     f_find=clusterlist_find;
     163           2 :     f_first=clusterlist_first;
     164           2 :     f_next=clusterlist_next;
     165           2 :     f_get=clusterlist_get;
     166             : 
     167           2 :     cluster = clusterlist_find("");
     168             : 
     169           2 :     ck_assert(first==clusterlistfirst);
     170             :     /* Change expected ck_assert(last==clusterlistlast);*/
     171           2 :     ck_assert(cursor==clusterlistcursor);
     172           2 :     ck_assert(f_add==clusterlist_add);
     173           2 :     ck_assert(f_find==clusterlist_find);
     174           2 :     ck_assert(f_first==clusterlist_first);
     175           2 :     ck_assert(f_next==clusterlist_next);
     176           2 :     ck_assert(f_get==clusterlist_get);
     177           2 :     f_get=clusterlist_get;
     178             : }
     179             : END_TEST
     180             : 
     181           3 : START_TEST(clusterlst_uninitialized_first) {
     182             :     /* Need to have a forked env to start uninitialized */
     183           3 :     forktest_only;
     184             : 
     185           2 :     clusterrecord_t* first=clusterlistfirst;
     186           2 :     clusterrecord_t* last=clusterlistlast;
     187           2 :     clusterrecord_t* cursor=clusterlistcursor;
     188           2 :     void       (*f_add)(cluster_t* cluster)=clusterlist_add;
     189           2 :     cluster_t* (*f_find) (const char* host)=clusterlist_find;
     190           2 :     cluster_t* (*f_first)()=clusterlist_first;
     191           2 :     cluster_t* (*f_next)()=clusterlist_next;
     192           2 :     cluster_t* (*f_get)()=clusterlist_get;
     193             :     cluster_t* cluster;
     194             : 
     195           2 :     cluster = clusterlist_first();
     196             : 
     197           2 :     ck_assert(first!=clusterlistfirst);
     198           2 :     ck_assert(last!=clusterlistlast);
     199           2 :     ck_assert(cursor!=clusterlistcursor);
     200           2 :     ck_assert(f_add!=clusterlist_add);
     201           2 :     ck_assert(f_find!=clusterlist_find);
     202           2 :     ck_assert(f_first!=clusterlist_first);
     203           2 :     ck_assert(f_next!=clusterlist_next);
     204           2 :     ck_assert(f_get!=clusterlist_get);
     205           2 :     ck_assert(NULL==cluster);
     206             : 
     207             :     /* Second run should not invoke init and change the pointers and functors */
     208           2 :     first=clusterlistfirst;
     209           2 :     last=clusterlistlast;
     210           2 :     cursor=clusterlistcursor;
     211           2 :     f_add=clusterlist_add;
     212           2 :     f_find=clusterlist_find;
     213           2 :     f_first=clusterlist_first;
     214           2 :     f_next=clusterlist_next;
     215           2 :     f_get=clusterlist_get;
     216             : 
     217           2 :     cluster = clusterlist_first();
     218             : 
     219           2 :     ck_assert(first==clusterlistfirst);
     220             :     /* Change expected ck_assert(last==clusterlistlast);*/
     221           2 :     ck_assert(cursor==clusterlistcursor);
     222           2 :     ck_assert(f_add==clusterlist_add);
     223           2 :     ck_assert(f_find==clusterlist_find);
     224           2 :     ck_assert(f_first==clusterlist_first);
     225           2 :     ck_assert(f_next==clusterlist_next);
     226           2 :     ck_assert(f_get==clusterlist_get);
     227           2 :     f_get=clusterlist_get;
     228             : }
     229             : END_TEST
     230             : 
     231           3 : START_TEST(clusterlst_uninitialized_next) {
     232             :     /* Need to have a forked env to start uninitialized */
     233           3 :     forktest_only;
     234             : 
     235           2 :     clusterrecord_t* first=clusterlistfirst;
     236           2 :     clusterrecord_t* last=clusterlistlast;
     237           2 :     clusterrecord_t* cursor=clusterlistcursor;
     238           2 :     void       (*f_add)(cluster_t* cluster)=clusterlist_add;
     239           2 :     cluster_t* (*f_find) (const char* host)=clusterlist_find;
     240           2 :     cluster_t* (*f_first)()=clusterlist_first;
     241           2 :     cluster_t* (*f_next)()=clusterlist_next;
     242           2 :     cluster_t* (*f_get)()=clusterlist_get;
     243             :     cluster_t* cluster;
     244             : 
     245           2 :     cluster = clusterlist_next();
     246             : 
     247           2 :     ck_assert(first!=clusterlistfirst);
     248           2 :     ck_assert(last!=clusterlistlast);
     249           2 :     ck_assert(cursor!=clusterlistcursor);
     250           2 :     ck_assert(f_add!=clusterlist_add);
     251           2 :     ck_assert(f_find!=clusterlist_find);
     252           2 :     ck_assert(f_first!=clusterlist_first);
     253           2 :     ck_assert(f_next!=clusterlist_next);
     254           2 :     ck_assert(f_get!=clusterlist_get);
     255           2 :     ck_assert(NULL==cluster);
     256             : 
     257             :     /* Second run should not invoke init and change the pointers and functors */
     258           2 :     first=clusterlistfirst;
     259           2 :     last=clusterlistlast;
     260           2 :     cursor=clusterlistcursor;
     261           2 :     f_add=clusterlist_add;
     262           2 :     f_find=clusterlist_find;
     263           2 :     f_first=clusterlist_first;
     264           2 :     f_next=clusterlist_next;
     265           2 :     f_get=clusterlist_get;
     266             : 
     267           2 :     cluster = clusterlist_next();
     268             : 
     269           2 :     ck_assert(first==clusterlistfirst);
     270             :     /* Change expected ck_assert(last==clusterlistlast);*/
     271           2 :     ck_assert(cursor==clusterlistcursor);
     272           2 :     ck_assert(f_add==clusterlist_add);
     273           2 :     ck_assert(f_find==clusterlist_find);
     274           2 :     ck_assert(f_first==clusterlist_first);
     275           2 :     ck_assert(f_next==clusterlist_next);
     276           2 :     ck_assert(f_get==clusterlist_get);
     277           2 :     f_get=clusterlist_get;
     278             : }
     279             : END_TEST
     280             : 
     281           3 : START_TEST(clusterlst_uninitialized_get) {
     282             :     /* Need to have a forked env to start uninitialized */
     283           3 :     forktest_only;
     284             : 
     285           2 :     clusterrecord_t* first=clusterlistfirst;
     286           2 :     clusterrecord_t* last=clusterlistlast;
     287           2 :     clusterrecord_t* cursor=clusterlistcursor;
     288           2 :     void       (*f_add)(cluster_t* cluster)=clusterlist_add;
     289           2 :     cluster_t* (*f_find) (const char* host)=clusterlist_find;
     290           2 :     cluster_t* (*f_first)()=clusterlist_first;
     291           2 :     cluster_t* (*f_next)()=clusterlist_next;
     292           2 :     cluster_t* (*f_get)()=clusterlist_get;
     293             :     cluster_t* cluster;
     294             : 
     295           2 :     cluster = clusterlist_get();
     296             : 
     297           2 :     ck_assert(first!=clusterlistfirst);
     298           2 :     ck_assert(last!=clusterlistlast);
     299           2 :     ck_assert(cursor!=clusterlistcursor);
     300           2 :     ck_assert(f_add!=clusterlist_add);
     301           2 :     ck_assert(f_find!=clusterlist_find);
     302           2 :     ck_assert(f_first!=clusterlist_first);
     303           2 :     ck_assert(f_next!=clusterlist_next);
     304           2 :     ck_assert(f_get!=clusterlist_get);
     305           2 :     ck_assert(NULL==cluster);
     306             : 
     307             :     /* Second run should not invoke init and change the pointers and functors */
     308           2 :     first=clusterlistfirst;
     309           2 :     last=clusterlistlast;
     310           2 :     cursor=clusterlistcursor;
     311           2 :     f_add=clusterlist_add;
     312           2 :     f_find=clusterlist_find;
     313           2 :     f_first=clusterlist_first;
     314           2 :     f_next=clusterlist_next;
     315           2 :     f_get=clusterlist_get;
     316             : 
     317           2 :     cluster = clusterlist_get();
     318             : 
     319           2 :     ck_assert(first==clusterlistfirst);
     320             :     /* Change expected ck_assert(last==clusterlistlast);*/
     321           2 :     ck_assert(cursor==clusterlistcursor);
     322           2 :     ck_assert(f_add==clusterlist_add);
     323           2 :     ck_assert(f_find==clusterlist_find);
     324           2 :     ck_assert(f_first==clusterlist_first);
     325           2 :     ck_assert(f_next==clusterlist_next);
     326           2 :     ck_assert(f_get==clusterlist_get);
     327           2 :     f_get=clusterlist_get;
     328             : }
     329             : END_TEST
     330             : 
     331             : /************************************************************************/
     332             : /* Begining of test (potentially in child) */
     333          21 : void clusterlst_checked_uninitialized_setup() {
     334          21 :     signals_catch();
     335          21 :     forktest_gprofdir();
     336          21 : }
     337             : 
     338             : /* End of test (potentially in child) */
     339          19 : void clusterlst_checked_uninitialized_teardown() {
     340          19 :     signals_release();
     341          19 : }
     342             : /************************************************************************/
     343          17 : void clusterlst_unchecked_common_setup() {
     344          17 :     forktest_init();
     345          17 : }
     346           3 : void clusterlst_unchecked_common_teardown() {
     347           3 : }
     348             : /************************************************************************/
     349          18 : Suite* clusterlst_suite() {
     350             :     Suite *s;
     351             :     TCase *tc;
     352             : 
     353          18 :     s = suite_create("Clusterlst");
     354             : 
     355          18 :     tc = tcase_create("ClusterlstUninitialized");
     356          18 :     tcase_set_tags(tc,"ClusterlstTag ClusterlstTag2");
     357             :     /* tcase_set_timeout(tc,5); */ /* seconds */
     358          18 :     tcase_add_checked_fixture(tc, clusterlst_checked_uninitialized_setup, clusterlst_checked_uninitialized_teardown);
     359          18 :     tcase_add_unchecked_fixture(tc, clusterlst_unchecked_common_setup, clusterlst_unchecked_common_teardown);
     360          18 :     suite_add_tcase(s, tc);
     361          18 :     tcase_add_test_raise_signal(tc, clusterlst_test,6);
     362          18 :     tcase_add_test(tc, clusterlst_uninitialized_init);
     363          18 :     tcase_add_test(tc, clusterlst_uninitialized_add);
     364          18 :     tcase_add_test(tc, clusterlst_uninitialized_find);
     365          18 :     tcase_add_test(tc, clusterlst_uninitialized_first);
     366          18 :     tcase_add_test(tc, clusterlst_uninitialized_next);
     367          18 :     tcase_add_test(tc, clusterlst_uninitialized_get);
     368             : 
     369          18 :     return s;
     370             : }
     371             : /* vim: set tw=80: */