libcitadel/tests/stringbuf_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 void TestRevalidateStrBuf(StrBuf *Buf)
  30 {
  31         CU_ASSERT(strlen(ChrPtr(Buf)) == StrLength(Buf));
  32 }
  33
  34
  35 static void TestCreateBuf(void)
  36 {
  37         StrBuf *Buf;
  38         StrBuf *Buf2;
  39         long len;
  40         long i;
  41         char *ch;
  42
  43         Buf = NewStrBuf();
  44         CU_ASSERT(Buf != NULL);
  45         FreeStrBuf(&Buf);
  46
  47         Buf = NewStrBufPlain(ChrPtr(NULL), StrLength(NULL));
  48         CU_ASSERT(Buf != NULL);
  49         FreeStrBuf(&Buf);
  50
  51
  52         Buf = NewStrBufDup(NULL);
  53         CU_ASSERT(Buf != NULL);
  54         StrBufPlain(Buf, "abc", -1);
  55         TestRevalidateStrBuf(Buf);
  56         StrBufPlain(Buf, HKEY("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
  57         TestRevalidateStrBuf(Buf);
  58         FreeStrBuf(&Buf);
  59
  60         FlushStrBuf(NULL);
  61         FLUSHStrBuf(NULL);
  62
  63         CU_ASSERT(Buf == NULL);
  64         Buf = NewStrBufPlain(HKEY("ABC"));
  65         TestRevalidateStrBuf(Buf);
  66         CU_ASSERT(StrLength(Buf) == 3);
  67         CU_ASSERT_NSTRING_EQUAL("ABC", ChrPtr(Buf), 3);
  68
  69         len = StrLength(Buf);
  70         for (i=0; i< 500; i ++)
  71         {
  72                 StrBufAppendBufPlain(Buf, HKEY("ABC"), 0);
  73                 len += 3;
  74                 CU_ASSERT(StrLength(Buf) == len);
  75         }
  76         StrBufShrinkToFit(Buf, 1);
  77         FlushStrBuf(Buf);
  78         CU_ASSERT(StrLength(Buf) == 0);
  79         ReAdjustEmptyBuf(Buf, 1, 1);
  80         TestRevalidateStrBuf(Buf);
  81         FreeStrBuf(&Buf);
  82         CU_ASSERT(Buf == NULL);
  83
  84         Buf = NewStrBufPlain(HKEY("ABC"));
  85         TestRevalidateStrBuf(Buf);
  86         len = StrLength(Buf);
  87         for (i=0; i< 500; i ++)
  88         {
  89                 StrBufAppendPrintf(Buf, "%s", "ABC");
  90                 len += 3;
  91                 CU_ASSERT(StrLength(Buf) == len);
  92         }
  93         TestRevalidateStrBuf(Buf);
  94         StrBufShrinkToFit(Buf, 1);
  95         TestRevalidateStrBuf(Buf);
  96
  97         Buf2 = NewStrBufDup(Buf);
  98         CU_ASSERT(StrLength(Buf) == StrLength(Buf2));
  99
 100         CU_ASSERT_NSTRING_EQUAL(ChrPtr(Buf2), ChrPtr(Buf), StrLength(Buf2));
 101
 102         CU_ASSERT(StrBufIsNumber(Buf) == 0);
 103
 104         FlushStrBuf(Buf2);
 105         CU_ASSERT(StrLength(Buf2) == 0);
 106
 107         FLUSHStrBuf(Buf);
 108         CU_ASSERT(StrLength(Buf) == 0);
 109
 110         FreeStrBuf(&Buf);
 111         HFreeStrBuf(Buf2);
 112         CU_ASSERT(Buf == NULL);
 113         CU_ASSERT(Buf2 != NULL);
 114
 115
 116         Buf2 = NewStrBuf();
 117         Buf = NewStrBufPlain(HKEY("123456"));
 118         CU_ASSERT(StrBufIsNumber(Buf) == 1); ///Todo: this is buggy.
 119         CU_ASSERT(StrBufIsNumber(NULL) == 0);
 120         CU_ASSERT(StrBufIsNumber(Buf2) == 0);
 121
 122         CU_ASSERT(StrTol(Buf) == 123456);
 123         CU_ASSERT(StrTol(NULL) == 0);
 124         CU_ASSERT(StrTol(Buf2) == 0);
 125
 126         CU_ASSERT(StrToi(Buf) == 123456);
 127         CU_ASSERT(StrToi(NULL) == 0);
 128         CU_ASSERT(StrToi(Buf2) == 0);
 129         ch = SmashStrBuf(NULL);
 130         CU_ASSERT(ch == NULL);
 131         i = StrLength(Buf);
 132         ch = SmashStrBuf(&Buf);
 133         CU_ASSERT(strlen(ch) == i);
 134         free(ch);
 135         FreeStrBuf(&Buf2);
 136 }
 137
 138 static void NextTokenizerIterateBuf(StrBuf *Buf, int NTokens)
 139 {
 140         const char *pCh = NULL;
 141         StrBuf *Buf2;
 142         long CountTokens = 0;
 143         long HaveNextToken = 0;
 144         long HaveNextTokenF = 0;
 145
 146         printf("\n\nTemplate: >%s<\n", ChrPtr(Buf));
 147         TestRevalidateStrBuf(Buf);
 148
 149         Buf2 = NewStrBuf();
 150         while (HaveNextToken = StrBufHaveNextToken(Buf, &pCh),
 151                HaveNextTokenF = StrBufExtract_NextToken(Buf2, Buf, &pCh, ','),
 152                (HaveNextTokenF>= 0))
 153         {
 154                 CountTokens++;
 155
 156                 printf("Token: >%s< >%s< %ld:%ld\n",
 157                        ChrPtr(Buf2),
 158                        ((pCh != NULL) && (pCh != StrBufNOTNULL))? pCh : "N/A",
 159                        HaveNextToken,
 160                        HaveNextTokenF);
 161                 TestRevalidateStrBuf(Buf2);
 162
 163                 CU_ASSERT(HaveNextToken == (HaveNextTokenF >= 0));
 164
 165                 CU_ASSERT(CountTokens <= NTokens);
 166         }
 167         CU_ASSERT(HaveNextToken == (HaveNextTokenF >= 0));
 168         FreeStrBuf(&Buf2);
 169 }
 170
 171
 172
 173 static void TestNextTokenizer_EndWithEmpty(void)
 174 {
 175         StrBuf *Buf;
 176
 177         Buf = NewStrBufPlain(HKEY("abc,abc, 1, ,,"));
 178         NextTokenizerIterateBuf(Buf, 7);
 179         FreeStrBuf(&Buf);
 180 }
 181
 182 static void TestNextTokenizer_StartWithEmpty(void)
 183 {
 184         StrBuf *Buf;
 185
 186         Buf = NewStrBufPlain(HKEY(",cde,abc, 1, ,,bbb"));
 187         NextTokenizerIterateBuf(Buf, 8);
 188         FreeStrBuf(&Buf);
 189 }
 190
 191 static void TestNextTokenizer_Empty(void)
 192 {
 193         StrBuf *Buf;
 194
 195         Buf = NewStrBufPlain(HKEY(""));
 196         NextTokenizerIterateBuf(Buf, 8);
 197         FreeStrBuf(&Buf);
 198 }
 199
 200 static void TestNextTokenizer_TwoEmpty(void)
 201 {
 202         StrBuf *Buf;
 203
 204         Buf = NewStrBufPlain(HKEY(","));
 205         NextTokenizerIterateBuf(Buf, 8);
 206         FreeStrBuf(&Buf);
 207 }
 208
 209 static void TestNextTokenizer_One(void)
 210 {
 211         StrBuf *Buf;
 212
 213         Buf = NewStrBufPlain(HKEY("one"));
 214         NextTokenizerIterateBuf(Buf, 8);
 215         FreeStrBuf(&Buf);
 216 }
 217
 218 static void TestNextTokenizer_Sequence(void)
 219 {
 220         StrBuf *Buf;
 221         char *teststring = "40:24524,24662,24673,27869:27935,28393,28426,31247:31258,31731,31749,31761,31778,31782,31801:31803,31813,31904,31915,33708,33935,34619,34672,34720:34723,34766,34835,37594,38854,39235,39942,40030,40142,40520,40815,40907,41201,41578,41781,41954,42292,43110,43565,43801,43998,44180,44241,44295,44401,44561,44635,44798,44861,44946,45022,45137:45148,45166,45179,45707,47114,47141:47157,47194,47314,47349,47386,47489,47496,47534:47543,54460,54601,54637:54652";
 222         Buf = NewStrBufPlain(teststring, -1);
 223         NextTokenizerIterateBuf(Buf, 67);
 224         FreeStrBuf(&Buf);
 225 }
 226
 227
 228
 229 static void NextLineterateBuf(StrBuf *Buf, int NLines)
 230 {
 231         int n = 0;
 232         const char *pCh = NULL;
 233         StrBuf *OneLine;
 234         StrBuf *ConcatenatedLines;
 235         long CountTokens = 0;
 236
 237         TestRevalidateStrBuf(Buf);
 238
 239         OneLine = NewStrBuf();
 240         ConcatenatedLines = NewStrBuf();
 241
 242         printf("\n");
 243
 244         if (StrLength(Buf) > 0)
 245                 do
 246                 {
 247                         n = StrBufSipLine(OneLine, Buf, &pCh);
 248
 249                         CountTokens++;
 250
 251                         printf("Line: >%s< >%s<\n",
 252                                ChrPtr(OneLine),
 253                                ((pCh != NULL) && (pCh != StrBufNOTNULL))? pCh : "N/A");
 254                         TestRevalidateStrBuf(OneLine);
 255                         CU_ASSERT(CountTokens <= NLines);
 256                         StrBufAppendBuf(ConcatenatedLines, OneLine, 0);
 257
 258                         if ((pCh == StrBufNOTNULL) &&
 259                             (*(ChrPtr(Buf) + StrLength(Buf) - 1) != '\n'))
 260                         {
 261                         }
 262                         else
 263                                 StrBufAppendBufPlain(ConcatenatedLines, HKEY("\n"), 0);
 264
 265                 }
 266                 while ((pCh != StrBufNOTNULL) &&
 267                        (pCh != NULL));
 268
 269
 270         printf("\n\nTemplate: >%s<\n", ChrPtr(Buf));
 271         printf("\n\nAfter: >%s<\n", ChrPtr(ConcatenatedLines));
 272         CU_ASSERT_NSTRING_EQUAL(ChrPtr(ConcatenatedLines),
 273                                 ChrPtr(Buf),
 274                                 StrLength(Buf));
 275
 276         FreeStrBuf(&OneLine);
 277         FreeStrBuf(&ConcatenatedLines);
 278 }
 279
 280
 281 static void TestNextLine_Empty(void)
 282 {
 283         StrBuf *Buf;
 284
 285         Buf = NewStrBufPlain(HKEY(""));
 286         NextLineterateBuf(Buf, 0);
 287         FreeStrBuf(&Buf);
 288 }
 289
 290
 291 static void TestNextLine_OneLine(void)
 292 {
 293         StrBuf *Buf;
 294
 295         Buf = NewStrBufPlain(HKEY("abc\n"));
 296         NextLineterateBuf(Buf, 1);
 297         FreeStrBuf(&Buf);
 298 }
 299
 300
 301 static void TestNextLine_TwoLinesMissingCR(void)
 302 {
 303         StrBuf *Buf;
 304
 305         Buf = NewStrBufPlain(HKEY("abc\ncde"));
 306         NextLineterateBuf(Buf, 2);
 307         FreeStrBuf(&Buf);
 308 }
 309
 310
 311 static void TestNextLine_twolines(void)
 312 {
 313         StrBuf *Buf;
 314
 315         Buf = NewStrBufPlain(HKEY("abc\ncde\n"));
 316         NextLineterateBuf(Buf, 2);
 317         FreeStrBuf(&Buf);
 318 }
 319
 320 static void TestNextLine_LongLine(void)
 321 {
 322         StrBuf *Buf;
 323
 324         Buf = NewStrBufPlain(HKEY("abcde\n1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\n"));
 325         NextLineterateBuf(Buf, 2);
 326         FreeStrBuf(&Buf);
 327 }
 328
 329
 330 static void TestStrBufRemove_token_NotThere(void)
 331 {
 332 //      StrBuf *Test = NewStrBufPlain(HKEY(" 127.0.0.1"));
 333         StrBuf *Test = NewStrBufPlain(HKEY(" 10.122.44.30, 10.122.44.30"));
 334         StrBufRemove_token(Test, 0, ',');
 335         TestRevalidateStrBuf(Test);
 336         FreeStrBuf(&Test);
 337 }
 338
 339
 340 static void TestStrBufUrlescAppend(void)
 341 {
 342         const char *expect = "%20%2B%23%26%3B%60%27%7C%2A%3F%2D%7E%3C%3E%5E%28%29%5B%5D%7B%7D%2F%24%22%5C";
 343         StrBuf *In = NewStrBufPlain(HKEY( " +#&;`'|*?-~<>^()[]{}/$\"\\"));
 344         StrBuf *Out = NewStrBuf();
 345
 346         StrBufUrlescAppend (Out, In, NULL);
 347         printf ("%s<\n%s<\n%s\n", ChrPtr(In), ChrPtr(Out), expect);
 348         CU_ASSERT_STRING_EQUAL(ChrPtr(Out), expect);
 349         FreeStrBuf(&In);
 350         FreeStrBuf(&Out);
 351 }
 352
 353 /*
 354 Some samples from the original...
 355         CU_ASSERT_EQUAL(10, 10);
 356         CU_ASSERT_EQUAL(0, -0);
 357         CU_ASSERT_EQUAL(-12, -12);
 358         CU_ASSERT_NOT_EQUAL(10, 11);
 359         CU_ASSERT_NOT_EQUAL(0, -1);
 360         CU_ASSERT_NOT_EQUAL(-12, -11);
 361         CU_ASSERT_PTR_EQUAL((void*)0x100, (void*)0x100);
 362         CU_ASSERT_PTR_NOT_EQUAL((void*)0x100, (void*)0x101);
 363         CU_ASSERT_PTR_NULL(NULL);
 364         CU_ASSERT_PTR_NULL(0x0);
 365         CU_ASSERT_PTR_NOT_NULL((void*)0x23);
 366         CU_ASSERT_STRING_EQUAL(str1, str2);
 367         CU_ASSERT_STRING_NOT_EQUAL(str1, str2);
 368         CU_ASSERT_NSTRING_EQUAL(str1, str2, strlen(str1));
 369         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1));
 370         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1) + 1);
 371         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str2, 3);
 372         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str3, strlen(str1) + 1);
 373         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, 0.0001);
 374         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, -0.0001);
 375         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, 0.0001);
 376         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, -0.0001);
 377         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, 0.0001);
 378         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, -0.0001);
 379         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, 0.0001);
 380         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, -0.0001);
 381 */
 382
 383
 384
 385
 386
 387 static void AddStrBufSimlpeTests(void)
 388 {
 389         CU_pSuite pGroup = NULL;
 390         CU_pTest pTest = NULL;
 391
 392         pGroup = CU_add_suite("TestStringBufSimpleAppenders", NULL, NULL);
 393         pTest = CU_add_test(pGroup, "testCreateBuf", TestCreateBuf);
 394
 395         pGroup = CU_add_suite("TestStringTokenizer", NULL, NULL);
 396         pTest = CU_add_test(pGroup, "testNextTokenizer_EndWithEmpty", TestNextTokenizer_EndWithEmpty);
 397         pTest = CU_add_test(pGroup, "testNextTokenizer_StartWithEmpty", TestNextTokenizer_StartWithEmpty);
 398         pTest = CU_add_test(pGroup, "testNextTokenizer_StartWithEmpty", TestNextTokenizer_StartWithEmpty);
 399         pTest = CU_add_test(pGroup, "testNextTokenizer_Empty", TestNextTokenizer_Empty);
 400         pTest = CU_add_test(pGroup, "testNextTokenizer_TwoEmpty", TestNextTokenizer_TwoEmpty);
 401         pTest = CU_add_test(pGroup, "testNextTokenizer_One", TestNextTokenizer_One);
 402         pTest = CU_add_test(pGroup, "testNextTokenizer_Sequence", TestNextTokenizer_Sequence);
 403
 404
 405         pGroup = CU_add_suite("TestStrBufSipLine", NULL, NULL);
 406         pTest = CU_add_test(pGroup, "TestNextLine_Empty", TestNextLine_Empty);
 407         pTest = CU_add_test(pGroup, "TestNextLine_OneLine", TestNextLine_OneLine);
 408         pTest = CU_add_test(pGroup, "TestNextLine_TwoLinesMissingCR", TestNextLine_TwoLinesMissingCR);
 409         pTest = CU_add_test(pGroup, "TestNextLine_twolines", TestNextLine_twolines);
 410         pTest = CU_add_test(pGroup, "TestNextLine_LongLine", TestNextLine_LongLine);
 411
 412         pGroup = CU_add_suite("TestStrBufRemove_token", NULL, NULL);
 413         pTest = CU_add_test(pGroup, "TestStrBufRemove_token_NotThere", TestStrBufRemove_token_NotThere);
 414
 415         pGroup = CU_add_suite("TestStrBuf_escapers", NULL, NULL);
 416         pTest = CU_add_test(pGroup, "TestStrBufUrlescAppend", TestStrBufUrlescAppend);
 417 }
 418
 419
 420 int main(int argc, char* argv[])
 421 {
 422         setvbuf(stdout, NULL, _IONBF, 0);
 423
 424         StartLibCitadel(8);
 425         CU_BOOL Run = CU_FALSE ;
 426
 427         CU_set_output_filename("TestAutomated");
 428         if (CU_initialize_registry()) {
 429                 printf("\nInitialize of test Registry failed.");
 430         }
 431
 432         Run = CU_TRUE ;
 433         AddStrBufSimlpeTests();
 434
 435         if (CU_TRUE == Run) {
 436                 //CU_console_run_tests();
 437     printf("\nTests completed with return value %d.\n", CU_basic_run_tests());
 438
 439     ///CU_automated_run_tests();
 440         }
 441
 442         CU_cleanup_registry();
 443
 444         return 0;
 445 }