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         "65",
 180         "1,65,77",
 181         "1:65,77,80:*",
 182         NULL
 183 };
 184
 185 #define InMSet 0
 186 #define NotInMSet 1
 187 const long MessageNumbers[4][2][10] = {
 188 /* First MSet */
 189         {
 190                 {65, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* In */
 191                 {1, 64, 66, 0, 0, 0, 0, 0, 0, 0} /* NotIn */
 192         },
 193
 194         {
 195                 {1, 65, 77, 0, 0, 0, 0, 0, 0, 0}, /* In */
 196                 {2, 64, 66, 76, 78, 0, 0, 0, 0, 0} /* NotIn */
 197         },
 198         {
 199                 {1, 2, 30, 64, 65, 77, 80, 81, 222222, 0}, /* In */
 200                 {66, 76, 78, 79, 0, 0, 0, 0, 0, 0} /* NotIn */
 201         },
 202         {
 203                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* In */
 204                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} /* NotIn */
 205         }
 206 };
 207
 208
 209
 210 static void TestMSetHashlist (void)
 211 {
 212         int nTest = 0;
 213         int j;
 214         StrBuf *MSetStr;
 215         StrBuf *Assert;
 216         MSet *OneMSet;
 217
 218
 219         MSetStr = NewStrBuf();
 220         Assert = NewStrBuf();
 221         while (MSetStrings[nTest] != NULL)
 222         {
 223                 StrBufPlain(MSetStr, MSetStrings[nTest], -1);
 224                 ParseMSet(&OneMSet, MSetStr);
 225
 226 #ifdef VERBOSE_TEST
 227                 printf("---%s---\n", ChrPtr(MSetStr));
 228                 {
 229                         const char *HashKey;
 230                         long HKLen;
 231                         HashList *ScanMe = (HashList*) OneMSet;
 232                         HashPos *at;
 233                         void *vMsg;
 234                         long *end;
 235
 236                         at = GetNewHashPos(ScanMe, 0);
 237                         while (GetNextHashPos(ScanMe, at, &HKLen, &HashKey, &vMsg)) {
 238                                 /* Are you a new message, or an old message? */
 239                                 end = (long*) vMsg;
 240                                 printf("[%ld][%ld]\n", *(long*)HashKey, *end);
 241                         }
 242                         DeleteHashPos(&at);
 243                 }
 244 #endif
 245
 246                 j = 0;
 247                 while (MessageNumbers[nTest][InMSet][j] != 0)
 248                 {
 249                         if (!IsInMSetList(OneMSet, MessageNumbers[nTest][InMSet][j]))
 250                         {
 251                                 StrBufPrintf(Assert, "InFail: %s <-> %ld\n",
 252                                              ChrPtr(MSetStr),
 253                                              MessageNumbers[nTest][InMSet][j]);
 254                                 CU_FAIL(ChrPtr(Assert));
 255                         }
 256                         else
 257                         {
 258                                 StrBufPrintf(Assert, "InPass: %s <-> %ld\n",
 259                                              ChrPtr(MSetStr),
 260                                              MessageNumbers[nTest][InMSet][j]);
 261                                 CU_PASS(ChrPtr(Assert));
 262                         }
 263                         j++;
 264                 }
 265                 j = 0;
 266                 while (MessageNumbers[nTest][NotInMSet][j] != 0)
 267                 {
 268                         if (IsInMSetList(OneMSet, MessageNumbers[nTest][NotInMSet][j]))
 269                         {
 270                                 StrBufPrintf(Assert, "NOT-InFail: %s <-> %ld\n",
 271                                              ChrPtr(MSetStr),
 272                                              MessageNumbers[nTest][NotInMSet][j]);
 273                                 CU_FAIL(ChrPtr(Assert));
 274                         }
 275                         else
 276                         {
 277                                 StrBufPrintf(Assert, "NOT-InPass: %s <-> %ld\n",
 278                                              ChrPtr(MSetStr),
 279                                              MessageNumbers[nTest][InMSet][j]);
 280                                 CU_PASS(ChrPtr(Assert));
 281                         }
 282                         j++;
 283                 }
 284
 285
 286                 DeleteMSet(&OneMSet);
 287                 nTest++;
 288
 289         }
 290         FreeStrBuf(&MSetStr);
 291         FreeStrBuf(&Assert);
 292 }
 293
 294
 295
 296 static void AddHashlistTests(void)
 297 {
 298         CU_pSuite pGroup = NULL;
 299         CU_pTest pTest = NULL;
 300
 301         pGroup = CU_add_suite("TestStringBufSimpleAppenders", NULL, NULL);
 302         pTest = CU_add_test(pGroup, "TestHashListIteratorForward", TestHashlistIteratorForward);
 303         pTest = CU_add_test(pGroup, "TestHashlistAddDelete", TestHashlistAddDelete);
 304         pTest = CU_add_test(pGroup, "TestMSetHashlist", TestMSetHashlist);
 305 }
 306
 307
 308 int main(int argc, char* argv[])
 309 {
 310         setvbuf(stdout, NULL, _IONBF, 0);
 311
 312         StartLibCitadel(8);
 313         CU_BOOL Run = CU_FALSE ;
 314
 315         CU_set_output_filename("TestAutomated");
 316         if (CU_initialize_registry()) {
 317                 printf("\nInitialize of test Registry failed.");
 318         }
 319
 320         Run = CU_TRUE ;
 321         AddHashlistTests();
 322
 323         if (CU_TRUE == Run) {
 324                 //CU_console_run_tests();
 325     printf("\nTests completed with return value %d.\n", CU_basic_run_tests());
 326
 327     ///CU_automated_run_tests();
 328         }
 329
 330         CU_cleanup_registry();
 331
 332         return 0;
 333 }