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