libcitadel/tests/hashlist_test.c

   1
   2 /*
   3  *  CUnit - A Unit testing framework library for C.
   4  *  Copyright (C) 2001  Anil Kumar
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Library General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Library General Public
  17  *  License along with this library; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "stringbuf_test.h"
  26 #include "../lib/libcitadel.h"
  27
  28
  29 static HashList *GetFilledHash(int n, int stepwidth)
  30 {
  31         HashList* TestHash;
  32         int i;
  33         int *val;
  34
  35         TestHash = NewHash(1, Flathash);
  36
  37         for (i = 0; i < n;  i+=stepwidth)
  38         {
  39                 val = (int*) malloc(sizeof(int));
  40                 *val = i;
  41                 Put(TestHash, IKEY(i), val, NULL);
  42         }
  43         return TestHash;
  44 }
  45
  46
  47
  48 static void test_iterate_hash(HashList *testh, int forward, int stepwidth)
  49 {
  50         int i = 0;
  51         HashPos  *it;
  52         void *vTest;
  53         long len = 0;
  54         const char *Key;
  55         int dir = 1;
  56
  57         if (forward == 0)
  58                 dir = -1;
  59         it = GetNewHashPos(testh, dir * stepwidth);
  60         while (GetNextHashPos(testh, it, &len, &Key, &vTest) &&
  61                (vTest != NULL)) {
  62
  63                 printf("i: %d c: %d\n", i, *(int*) vTest);
  64                 i+=stepwidth;
  65         }
  66         DeleteHashPos(&it);
  67 }
  68
  69 static void ValidateBackAndForth(HashList *H)
  70 {
  71         test_iterate_hash(H, 1, 1);
  72         printf("\n");
  73
  74         test_iterate_hash(H, 0, 1);
  75         printf("\n");
  76
  77         test_iterate_hash(H, 1, 2);
  78         printf("\n");
  79
  80         test_iterate_hash(H, 0, 2);
  81         printf("\n");
  82
  83         test_iterate_hash(H, 1, 3);
  84         printf("\n");
  85
  86         test_iterate_hash(H, 0, 3);
  87         printf("\n");
  88 }
  89
  90 static void TestHashlistIteratorForward (void)
  91 {
  92         HashList *H;
  93
  94         H = GetFilledHash (10, 1);
  95
  96         ValidateBackAndForth(H);
  97
  98         DeleteHash(&H);
  99 }
 100
 101
 102 static void TestHashlistAddDelete (void)
 103 {
 104         HashList *H;
 105         HashPos *at;
 106         int *val, i;
 107
 108         H = GetFilledHash (10, 1);
 109
 110         at = GetNewHashPos(H, 0);
 111
 112         printf("Remove first\n");
 113         DeleteEntryFromHash(H, at);
 114
 115         ValidateBackAndForth(H);
 116
 117         printf("Insert 15\n");
 118         i = 15;
 119         val = (int*) malloc(sizeof(int));
 120         *val = i;
 121         Put(H, IKEY(i), val, NULL);
 122
 123         ValidateBackAndForth(H);
 124
 125         printf("Remove third\n");
 126         at = GetNewHashPos(H, 0);
 127         NextHashPos(H, at);
 128         NextHashPos(H, at);
 129         NextHashPos(H, at);
 130         DeleteEntryFromHash(H, at);
 131
 132         ValidateBackAndForth(H);
 133         printf("Insert -15\n");
 134
 135         i = -15;
 136         val = (int*) malloc(sizeof(int));
 137         *val = i;
 138         Put(H, IKEY(i), val, NULL);
 139
 140         ValidateBackAndForth(H);
 141
 142
 143         DeleteHash(&H);
 144 }
 145
 146 /*
 147 Some samples from the original...
 148         CU_ASSERT_EQUAL(10, 10);
 149         CU_ASSERT_EQUAL(0, -0);
 150         CU_ASSERT_EQUAL(-12, -12);
 151         CU_ASSERT_NOT_EQUAL(10, 11);
 152         CU_ASSERT_NOT_EQUAL(0, -1);
 153         CU_ASSERT_NOT_EQUAL(-12, -11);
 154         CU_ASSERT_PTR_EQUAL((void*)0x100, (void*)0x100);
 155         CU_ASSERT_PTR_NOT_EQUAL((void*)0x100, (void*)0x101);
 156         CU_ASSERT_PTR_NULL(NULL);
 157         CU_ASSERT_PTR_NULL(0x0);
 158         CU_ASSERT_PTR_NOT_NULL((void*)0x23);
 159         CU_ASSERT_STRING_EQUAL(str1, str2);
 160         CU_ASSERT_STRING_NOT_EQUAL(str1, str2);
 161         CU_ASSERT_NSTRING_EQUAL(str1, str2, strlen(str1));
 162         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1));
 163         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1) + 1);
 164         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str2, 3);
 165         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str3, strlen(str1) + 1);
 166         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, 0.0001);
 167         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, -0.0001);
 168         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, 0.0001);
 169         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, -0.0001);
 170         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, 0.0001);
 171         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, -0.0001);
 172         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, 0.0001);
 173         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, -0.0001);
 174 */
 175
 176
 177
 178 const char *MSetStrings[] = {
 179         "11:63",
 180         "65",
 181         "1,65,77",
 182         "1:65,77,80:*",
 183         NULL
 184 };
 185
 186 #define InMSet 0
 187 #define NotInMSet 1
 188 const long MessageNumbers[5][2][10] = {
 189 /* First MSet */
 190         {
 191                 {11, 59, 63, 0, 0, 0, 0, 0, 0, 0}, /* In */
 192                 {2, 10, 64, 65, 0, 0, 0, 0, 0, 0} /* NotIn */
 193         },
 194         {
 195                 {65, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* In */
 196                 {1, 64, 66, 0, 0, 0, 0, 0, 0, 0} /* NotIn */
 197         },
 198
 199         {
 200                 {1, 65, 77, 0, 0, 0, 0, 0, 0, 0}, /* In */
 201                 {2, 64, 66, 76, 78, 0, 0, 0, 0, 0} /* NotIn */
 202         },
 203         {
 204                 {1, 2, 30, 64, 65, 77, 80, 81, 222222, 0}, /* In */
 205                 {66, 76, 78, 79, 0, 0, 0, 0, 0, 0} /* NotIn */
 206         },
 207         {
 208                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* In */
 209                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} /* NotIn */
 210         }
 211 };
 212
 213
 214
 215 static void TestMSetHashlist (void)
 216 {
 217         int nTest = 0;
 218         int j;
 219         StrBuf *MSetStr;
 220         StrBuf *Assert;
 221         MSet *OneMSet;
 222
 223
 224         MSetStr = NewStrBuf();
 225         Assert = NewStrBuf();
 226         while (MSetStrings[nTest] != NULL)
 227         {
 228                 StrBufPlain(MSetStr, MSetStrings[nTest], -1);
 229                 ParseMSet(&OneMSet, MSetStr);
 230
 231 //#ifdef VERBOSE_TEST
 232                 printf("---%s---\n", ChrPtr(MSetStr));
 233                 {
 234                         const char *HashKey;
 235                         long HKLen;
 236                         HashList *ScanMe = (HashList*) OneMSet;
 237                         HashPos *at;
 238                         void *vMsg;
 239                         long *end;
 240
 241                         at = GetNewHashPos(ScanMe, 0);
 242                         while (GetNextHashPos(ScanMe, at, &HKLen, &HashKey, &vMsg)) {
 243                                 /* Are you a new message, or an old message? */
 244                                 end = (long*) vMsg;
 245                                 printf("[%ld][%ld]\n", *(long*)HashKey, *end);
 246                         }
 247                         DeleteHashPos(&at);
 248                 }
 249 //#endif
 250
 251                 j = 0;
 252                 while (MessageNumbers[nTest][InMSet][j] != 0)
 253                 {
 254                         if (!IsInMSetList(OneMSet, MessageNumbers[nTest][InMSet][j]))
 255                         {
 256                                 StrBufPrintf(Assert, "InFail: %s <-> %ld\n",
 257                                              ChrPtr(MSetStr),
 258                                              MessageNumbers[nTest][InMSet][j]);
 259                                 CU_FAIL(ChrPtr(Assert));
 260                                 printf(ChrPtr(Assert));
 261                         }
 262                         else
 263                         {
 264                                 StrBufPrintf(Assert, "InPass: %s <-> %ld\n",
 265                                              ChrPtr(MSetStr),
 266                                              MessageNumbers[nTest][InMSet][j]);
 267                                 CU_PASS(ChrPtr(Assert));
 268                         }
 269                         j++;
 270                 }
 271                 j = 0;
 272                 while (MessageNumbers[nTest][NotInMSet][j] != 0)
 273                 {
 274                         if (IsInMSetList(OneMSet, MessageNumbers[nTest][NotInMSet][j]))
 275                         {
 276                                 StrBufPrintf(Assert, "NOT-InFail: %s <-> %ld\n",
 277                                              ChrPtr(MSetStr),
 278                                              MessageNumbers[nTest][NotInMSet][j]);
 279                                 CU_FAIL(ChrPtr(Assert));
 280                                 printf(ChrPtr(Assert));
 281                         }
 282                         else
 283                         {
 284                                 StrBufPrintf(Assert, "NOT-InPass: %s <-> %ld\n",
 285                                              ChrPtr(MSetStr),
 286                                              MessageNumbers[nTest][InMSet][j]);
 287                                 CU_PASS(ChrPtr(Assert));
 288                         }
 289                         j++;
 290                 }
 291
 292
 293                 DeleteMSet(&OneMSet);
 294                 nTest++;
 295
 296         }
 297         FreeStrBuf(&MSetStr);
 298         FreeStrBuf(&Assert);
 299 }
 300
 301
 302
 303 static void AddHashlistTests(void)
 304 {
 305         CU_pSuite pGroup = NULL;
 306         CU_pTest pTest = NULL;
 307
 308         pGroup = CU_add_suite("TestStringBufSimpleAppenders", NULL, NULL);
 309         pTest = CU_add_test(pGroup, "TestHashListIteratorForward", TestHashlistIteratorForward);
 310         pTest = CU_add_test(pGroup, "TestHashlistAddDelete", TestHashlistAddDelete);
 311         pTest = CU_add_test(pGroup, "TestMSetHashlist", TestMSetHashlist);
 312 }
 313
 314
 315 int main(int argc, char* argv[])
 316 {
 317         setvbuf(stdout, NULL, _IONBF, 0);
 318
 319         StartLibCitadel(8);
 320         CU_BOOL Run = CU_FALSE ;
 321
 322         CU_set_output_filename("TestAutomated");
 323         if (CU_initialize_registry()) {
 324                 printf("\nInitialize of test Registry failed.");
 325         }
 326
 327         Run = CU_TRUE ;
 328         AddHashlistTests();
 329
 330         if (CU_TRUE == Run) {
 331                 //CU_console_run_tests();
 332     printf("\nTests completed with return value %d.\n", CU_basic_run_tests());
 333
 334     ///CU_automated_run_tests();
 335         }
 336
 337         CU_cleanup_registry();
 338
 339         return 0;
 340 }