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 #define SHOW_ME_VAPPEND_PRINTF
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdarg.h>
  26
  27 #include "stringbuf_test.h"
  28 #include "../lib/libcitadel.h"
  29
  30 int Quiet = 0;
  31 /*
  32  * Stolen from wc_printf; we need to test that other printf too...
  33  */
  34 static void TEST_StrBufAppendPrintf(StrBuf *WBuf, const char *format,...)
  35 {
  36         va_list arg_ptr;
  37
  38         if (WBuf == NULL)
  39                 return;
  40
  41         va_start(arg_ptr, format);
  42         StrBufVAppendPrintf(WBuf, format, arg_ptr);
  43         va_end(arg_ptr);
  44 }
  45
  46 static void TestRevalidateStrBuf(StrBuf *Buf)
  47 {
  48         CU_ASSERT(strlen(ChrPtr(Buf)) == StrLength(Buf));
  49 }
  50
  51
  52 static void TestCreateBuf(void)
  53 {
  54         StrBuf *Buf;
  55         StrBuf *Buf2;
  56         long len;
  57         long i;
  58
  59         Buf = NewStrBuf();
  60         CU_ASSERT(Buf != NULL);
  61         FreeStrBuf(&Buf);
  62
  63         Buf = NewStrBufPlain(ChrPtr(NULL), StrLength(NULL));
  64         CU_ASSERT(Buf != NULL);
  65         FreeStrBuf(&Buf);
  66
  67         /* make it alloc a bigger buffer... */
  68         Buf = NewStrBufPlain(NULL, SIZ);
  69         CU_ASSERT(Buf != NULL);
  70         FreeStrBuf(&Buf);
  71
  72
  73         Buf = NewStrBufDup(NULL);
  74         CU_ASSERT(Buf != NULL);
  75         StrBufPlain(Buf, "abc", -1);
  76         TestRevalidateStrBuf(Buf);
  77         StrBufPlain(Buf, HKEY("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
  78         TestRevalidateStrBuf(Buf);
  79         FreeStrBuf(&Buf);
  80
  81         FlushStrBuf(NULL);
  82         FLUSHStrBuf(NULL);
  83
  84         CU_ASSERT(Buf == NULL);
  85         Buf = NewStrBufPlain(HKEY("ABC"));
  86         TestRevalidateStrBuf(Buf);
  87         CU_ASSERT(StrLength(Buf) == 3);
  88         CU_ASSERT_NSTRING_EQUAL("ABC", ChrPtr(Buf), 3);
  89
  90         len = StrLength(Buf);
  91         for (i=0; i< 500; i ++)
  92         {
  93                 StrBufAppendBufPlain(Buf, HKEY("ABC"), 0);
  94                 len += 3;
  95                 CU_ASSERT(StrLength(Buf) == len);
  96         }
  97         StrBufShrinkToFit(Buf, 1);
  98         FlushStrBuf(Buf);
  99         CU_ASSERT(StrLength(Buf) == 0);
 100         ReAdjustEmptyBuf(Buf, 1, 1);
 101         TestRevalidateStrBuf(Buf);
 102         FreeStrBuf(&Buf);
 103         CU_ASSERT(Buf == NULL);
 104
 105         Buf = NewStrBufPlain(HKEY("ABC"));
 106         TestRevalidateStrBuf(Buf);
 107         len = StrLength(Buf);
 108         for (i=0; i< 500; i ++)
 109         {
 110                 StrBufAppendPrintf(Buf, "%s", "ABC");
 111                 len += 3;
 112                 CU_ASSERT(StrLength(Buf) == len);
 113         }
 114         TestRevalidateStrBuf(Buf);
 115         StrBufShrinkToFit(Buf, 1);
 116         TestRevalidateStrBuf(Buf);
 117         FreeStrBuf(&Buf);
 118
 119
 120         Buf = NewStrBufPlain(HKEY("ABC"));
 121         Buf2 = NewStrBufPlain(HKEY("------"));
 122         TestRevalidateStrBuf(Buf);
 123         len = StrLength(Buf);
 124         for (i=0; i< 50; i ++)
 125         {
 126                 StrBufPrintf(Buf, "%s", ChrPtr(Buf2));
 127                 CU_ASSERT(StrLength(Buf) == StrLength(Buf2));
 128
 129                 StrBufAppendBufPlain(Buf2, HKEY("ABCDEFG"), 0);
 130         }
 131         TestRevalidateStrBuf(Buf);
 132         StrBufShrinkToFit(Buf, 1);
 133         TestRevalidateStrBuf(Buf);
 134         FreeStrBuf(&Buf);
 135         FreeStrBuf(&Buf2);
 136
 137
 138         Buf = NewStrBufPlain(HKEY("ABC"));
 139         TestRevalidateStrBuf(Buf);
 140         len = StrLength(Buf);
 141         for (i=0; i< 500; i ++)
 142         {
 143                 TEST_StrBufAppendPrintf(Buf, "%s", "ABC");
 144                 len += 3;
 145                 CU_ASSERT(StrLength(Buf) == len);
 146         }
 147         TestRevalidateStrBuf(Buf);
 148         StrBufShrinkToFit(Buf, 1);
 149         TestRevalidateStrBuf(Buf);
 150
 151
 152         Buf2 = NewStrBufDup(Buf);
 153         CU_ASSERT(StrLength(Buf) == StrLength(Buf2));
 154
 155         CU_ASSERT_NSTRING_EQUAL(ChrPtr(Buf2), ChrPtr(Buf), StrLength(Buf2));
 156
 157         CU_ASSERT(StrBufIsNumber(Buf) == 0);
 158
 159         FlushStrBuf(Buf2);
 160         CU_ASSERT(StrLength(Buf2) == 0);
 161
 162         FLUSHStrBuf(Buf);
 163         CU_ASSERT(StrLength(Buf) == 0);
 164
 165         HFreeStrBuf(NULL);
 166         HFreeStrBuf(Buf2);
 167         CU_ASSERT(Buf2 != NULL);
 168
 169         FreeStrBuf(&Buf);
 170         CU_ASSERT(Buf == NULL);
 171
 172 }
 173
 174
 175
 176
 177 static void TestBufNumbers(void)
 178 {
 179         StrBuf *Buf;
 180         StrBuf *Buf2;
 181         StrBuf *Buf3;
 182         char *ch;
 183         int i;
 184
 185         Buf2 = NewStrBuf();
 186         Buf3 = NewStrBufPlain(HKEY("abcd"));
 187         Buf = NewStrBufPlain(HKEY("123456"));
 188         CU_ASSERT(StrBufIsNumber(Buf) == 1);
 189         CU_ASSERT(StrBufIsNumber(NULL) == 0);
 190         CU_ASSERT(StrBufIsNumber(Buf2) == 0);
 191         CU_ASSERT(StrBufIsNumber(Buf3) == 0);
 192
 193         CU_ASSERT(StrTol(Buf) == 123456);
 194         CU_ASSERT(StrTol(NULL) == 0);
 195         CU_ASSERT(StrTol(Buf2) == 0);
 196
 197         CU_ASSERT(StrToi(Buf) == 123456);
 198         CU_ASSERT(StrToi(NULL) == 0);
 199         CU_ASSERT(StrToi(Buf2) == 0);
 200         ch = SmashStrBuf(NULL);
 201         CU_ASSERT(ch == NULL);
 202         i = StrLength(Buf);
 203         ch = SmashStrBuf(&Buf);
 204         CU_ASSERT(strlen(ch) == i);
 205         free(ch);
 206         FreeStrBuf(&Buf2);
 207 }
 208
 209 static void TestStrBufPeek(void)
 210 {
 211         StrBuf *Buf;
 212         const char *pch;
 213
 214         Buf = NewStrBufPlain(HKEY("0123456"));
 215         pch = ChrPtr(Buf);
 216
 217         CU_ASSERT(StrBufPeek(NULL, pch + 4, -1, 'A') == -1);
 218
 219         CU_ASSERT(StrBufPeek(Buf, pch + 4, -1, 'A') == 4);
 220         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "0123A56");
 221
 222         CU_ASSERT(StrBufPeek(Buf, pch - 1, -1, 'A') == -1);
 223         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "0123A56");
 224
 225         CU_ASSERT(StrBufPeek(Buf, pch + 10, -1, 'A') == -1);
 226         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "0123A56");
 227
 228         CU_ASSERT(StrBufPeek(Buf, NULL, -1, 'A') == -1);
 229         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "0123A56");
 230
 231         CU_ASSERT(StrBufPeek(Buf, NULL, 10, 'A') == -1);
 232         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "0123A56");
 233
 234         CU_ASSERT(StrBufPeek(Buf, NULL, 5, 'A') == 5);
 235         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "0123AA6");
 236 }
 237
 238 static void TestBufStringManipulation(void)
 239 {
 240         long len, i = 0;
 241         StrBuf *dest = NewStrBuf ();
 242         StrBuf *Buf = NewStrBufPlain(HKEY("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"));
 243
 244         StrBufSub(dest, Buf, -5, i);
 245         len = StrLength(Buf);
 246         for (i = 0; i < len + 10; i++)
 247         {
 248                 StrBufSub(dest, Buf, 5, i);
 249                 if (i + 5 < len)
 250                 {
 251                         CU_ASSERT(StrLength(dest) == i);
 252                 }
 253                 else
 254                 {
 255                         CU_ASSERT(StrLength(dest) == len - 5);
 256                 }
 257         }
 258         FreeStrBuf(&dest);
 259         dest = NewStrBuf ();
 260         StrBufSub(dest, Buf, -5, 200);
 261
 262         StrBufCutLeft(Buf, 5);
 263         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"67890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
 264         CU_ASSERT(StrLength(Buf) == 95);
 265
 266         StrBufCutRight(Buf, 5);
 267         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345");
 268         CU_ASSERT(StrLength(Buf) == 90);
 269
 270         StrBufCutAt(Buf, 80, NULL);
 271         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"67890123456789012345678901234567890123456789012345678901234567890123456789012345");
 272         CU_ASSERT(StrLength(Buf) == 80);
 273
 274         StrBufCutAt(Buf, -1, ChrPtr(Buf) + 70);
 275         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"6789012345678901234567890123456789012345678901234567890123456789012345");
 276         CU_ASSERT(StrLength(Buf) == 70);
 277
 278
 279         StrBufCutAt(Buf, 0, ChrPtr(Buf) + 60);
 280         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"678901234567890123456789012345678901234567890123456789012345");
 281         CU_ASSERT(StrLength(Buf) == 60);
 282
 283         StrBufCutAt(Buf, 0, ChrPtr(Buf) + 70);
 284         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"678901234567890123456789012345678901234567890123456789012345");
 285         CU_ASSERT(StrLength(Buf) == 60);
 286
 287         StrBufCutAt(Buf, 70, NULL);
 288         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"678901234567890123456789012345678901234567890123456789012345");
 289         CU_ASSERT(StrLength(Buf) == 60);
 290
 291
 292         StrBufCutLeft(Buf, 70);
 293         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"");
 294         CU_ASSERT(StrLength(Buf) == 0);
 295
 296         StrBufPlain(Buf, HKEY("678901234567890123456789012345678901234567890123456789012345"));
 297         StrBufCutRight(Buf, 70);
 298         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"");
 299         CU_ASSERT(StrLength(Buf) == 0);
 300
 301         FreeStrBuf(&dest);
 302         FreeStrBuf(&Buf);
 303
 304         Buf = NewStrBufPlain(HKEY(" \tabc\t "));
 305         StrBufTrim(Buf);
 306         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf),"abc");
 307         CU_ASSERT(StrLength(Buf) == 3);
 308
 309         StrBufUpCase(NULL);
 310         FlushStrBuf(Buf);
 311         StrBufUpCase(Buf);
 312         StrBufPlain(Buf, HKEY("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
 313         StrBufUpCase(Buf);
 314
 315         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
 316
 317
 318         StrBufLowerCase(NULL);
 319         FlushStrBuf(Buf);
 320         StrBufLowerCase(Buf);
 321         StrBufPlain(Buf, HKEY("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
 322         StrBufLowerCase(Buf);
 323
 324         CU_ASSERT_STRING_EQUAL(ChrPtr(Buf), "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789");
 325
 326
 327         FreeStrBuf(&Buf);
 328
 329 }
 330
 331 static void NextTokenizerIterateBuf(StrBuf *Buf, int NTokens)
 332 {
 333         long FoundTokens;
 334         const char *pCh = NULL;
 335         StrBuf *Buf2;
 336         long CountTokens = 0;
 337         long HaveNextToken = 0;
 338         long HaveNextTokenF = 0;
 339
 340         TestRevalidateStrBuf(Buf);
 341         FoundTokens = StrBufNum_tokens(Buf, ',');
 342         if (!Quiet)
 343                 printf("\n\nTemplate: >%s< %d, %ld\n",
 344                        ChrPtr(Buf),
 345                        NTokens,
 346                        FoundTokens);
 347
 348         CU_ASSERT(FoundTokens == NTokens);
 349
 350         Buf2 = NewStrBuf();
 351         while (HaveNextToken = StrBufHaveNextToken(Buf, &pCh),
 352                HaveNextTokenF = StrBufExtract_NextToken(Buf2, Buf, &pCh, ','),
 353                (HaveNextTokenF>= 0))
 354         {
 355                 CountTokens++;
 356
 357                 if (!Quiet) printf("Token: >%s< >%s< %ld:%ld\n",
 358                                    ChrPtr(Buf2),
 359                                    ((pCh != NULL) && (pCh != StrBufNOTNULL))? pCh : "N/A",
 360                                    HaveNextToken,
 361                                    HaveNextTokenF);
 362                 TestRevalidateStrBuf(Buf2);
 363
 364                 CU_ASSERT(HaveNextToken == (HaveNextTokenF >= 0));
 365
 366                 CU_ASSERT(CountTokens <= NTokens);
 367         }
 368         CU_ASSERT(HaveNextToken == (HaveNextTokenF >= 0));
 369         FreeStrBuf(&Buf2);
 370 }
 371
 372
 373
 374 static void TestNextTokenizer_EndWithEmpty(void)
 375 {
 376         StrBuf *Buf;
 377
 378         Buf = NewStrBufPlain(HKEY("abc,abc, 1, ,,"));
 379         NextTokenizerIterateBuf(Buf, 6);
 380         FreeStrBuf(&Buf);
 381 }
 382
 383 static void TestNextTokenizer_StartWithEmpty(void)
 384 {
 385         StrBuf *Buf;
 386
 387         Buf = NewStrBufPlain(HKEY(",cde,abc, 1, ,,bbb"));
 388         NextTokenizerIterateBuf(Buf, 7);
 389         FreeStrBuf(&Buf);
 390 }
 391
 392 static void TestNextTokenizer_Empty(void)
 393 {
 394         StrBuf *Buf;
 395
 396         Buf = NewStrBufPlain(HKEY(""));
 397         NextTokenizerIterateBuf(Buf, 0);
 398         FreeStrBuf(&Buf);
 399 }
 400
 401 static void TestNextTokenizer_TwoEmpty(void)
 402 {
 403         StrBuf *Buf;
 404
 405         Buf = NewStrBufPlain(HKEY(","));
 406         NextTokenizerIterateBuf(Buf, 2);
 407         FreeStrBuf(&Buf);
 408 }
 409
 410 static void TestNextTokenizer_One(void)
 411 {
 412         StrBuf *Buf;
 413
 414         Buf = NewStrBufPlain(HKEY("one"));
 415         NextTokenizerIterateBuf(Buf, 1);
 416         FreeStrBuf(&Buf);
 417 }
 418
 419 static void TestNextTokenizer_Sequence(void)
 420 {
 421         StrBuf *Buf;
 422         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";
 423         Buf = NewStrBufPlain(teststring, -1);
 424         NextTokenizerIterateBuf(Buf, 67);
 425         FreeStrBuf(&Buf);
 426 }
 427
 428
 429
 430 static void NextLineterateBuf(StrBuf *Buf, int NLines)
 431 {
 432         int n = 0;
 433         const char *pCh = NULL;
 434         StrBuf *OneLine;
 435         StrBuf *ConcatenatedLines;
 436         long CountTokens = 0;
 437
 438         TestRevalidateStrBuf(Buf);
 439
 440         OneLine = NewStrBuf();
 441         ConcatenatedLines = NewStrBuf();
 442
 443         if (!Quiet) printf("\n");
 444
 445         if (StrLength(Buf) > 0)
 446                 do
 447                 {
 448                         n = StrBufSipLine(OneLine, Buf, &pCh);
 449
 450                         CountTokens++;
 451
 452                         if (!Quiet) printf("Line: >%s< >%s<\n",
 453                                            ChrPtr(OneLine),
 454                                            ((pCh != NULL) && (pCh != StrBufNOTNULL))? pCh : "N/A");
 455                         TestRevalidateStrBuf(OneLine);
 456                         CU_ASSERT(CountTokens <= NLines);
 457                         StrBufAppendBuf(ConcatenatedLines, OneLine, 0);
 458
 459                         if ((pCh == StrBufNOTNULL) &&
 460                             (*(ChrPtr(Buf) + StrLength(Buf) - 1) != '\n'))
 461                         {
 462                         }
 463                         else
 464                                 StrBufAppendBufPlain(ConcatenatedLines, HKEY("\n"), 0);
 465
 466                 }
 467                 while ((pCh != StrBufNOTNULL) &&
 468                        (pCh != NULL));
 469
 470
 471         if (!Quiet) printf("\n\nTemplate: >%s<\n", ChrPtr(Buf));
 472         if (!Quiet) printf("\n\nAfter: >%s<\n", ChrPtr(ConcatenatedLines));
 473         CU_ASSERT_NSTRING_EQUAL(ChrPtr(ConcatenatedLines),
 474                                 ChrPtr(Buf),
 475                                 StrLength(Buf));
 476
 477         FreeStrBuf(&OneLine);
 478         FreeStrBuf(&ConcatenatedLines);
 479 }
 480
 481
 482 static void TestNextLine_Empty(void)
 483 {
 484         StrBuf *Buf;
 485
 486         Buf = NewStrBufPlain(HKEY(""));
 487         NextLineterateBuf(Buf, 0);
 488         FreeStrBuf(&Buf);
 489 }
 490
 491
 492 static void TestNextLine_OneLine(void)
 493 {
 494         StrBuf *Buf;
 495
 496         Buf = NewStrBufPlain(HKEY("abc\n"));
 497         NextLineterateBuf(Buf, 1);
 498         FreeStrBuf(&Buf);
 499 }
 500
 501
 502 static void TestNextLine_TwoLinesMissingCR(void)
 503 {
 504         StrBuf *Buf;
 505
 506         Buf = NewStrBufPlain(HKEY("abc\ncde"));
 507         NextLineterateBuf(Buf, 2);
 508         FreeStrBuf(&Buf);
 509 }
 510
 511
 512 static void TestNextLine_twolines(void)
 513 {
 514         StrBuf *Buf;
 515
 516         Buf = NewStrBufPlain(HKEY("abc\ncde\n"));
 517         NextLineterateBuf(Buf, 2);
 518         FreeStrBuf(&Buf);
 519 }
 520
 521 static void TestNextLine_LongLine(void)
 522 {
 523         StrBuf *Buf;
 524
 525         Buf = NewStrBufPlain(HKEY("abcde\n1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\n"));
 526         NextLineterateBuf(Buf, 2);
 527         FreeStrBuf(&Buf);
 528 }
 529
 530
 531 static void TestStrBufRemove_token_NotThere(void)
 532 {
 533 //      StrBuf *Test = NewStrBufPlain(HKEY(" 127.0.0.1"));
 534         StrBuf *Test = NewStrBufPlain(HKEY(" 10.122.44.30, 10.122.44.30"));
 535         StrBufRemove_token(Test, 0, ',');
 536         TestRevalidateStrBuf(Test);
 537         FreeStrBuf(&Test);
 538 }
 539
 540
 541 static void TestStrBufUrlescAppend(void)
 542 {
 543         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";
 544         StrBuf *In = NewStrBufPlain(HKEY( " +#&;`'|*?-~<>^()[]{}/$\"\\"));
 545         StrBuf *Out = NewStrBuf();
 546
 547         StrBufUrlescAppend (Out, In, NULL);
 548         if (!Quiet) printf ("%s<\n%s<\n%s\n", ChrPtr(In), ChrPtr(Out), expect);
 549         CU_ASSERT_STRING_EQUAL(ChrPtr(Out), expect);
 550         FreeStrBuf(&In);
 551         FreeStrBuf(&Out);
 552 }
 553
 554 /*
 555 Some samples from the original...
 556         CU_ASSERT_EQUAL(10, 10);
 557         CU_ASSERT_EQUAL(0, -0);
 558         CU_ASSERT_EQUAL(-12, -12);
 559         CU_ASSERT_NOT_EQUAL(10, 11);
 560         CU_ASSERT_NOT_EQUAL(0, -1);
 561         CU_ASSERT_NOT_EQUAL(-12, -11);
 562         CU_ASSERT_PTR_EQUAL((void*)0x100, (void*)0x100);
 563         CU_ASSERT_PTR_NOT_EQUAL((void*)0x100, (void*)0x101);
 564         CU_ASSERT_PTR_NULL(NULL);
 565         CU_ASSERT_PTR_NULL(0x0);
 566         CU_ASSERT_PTR_NOT_NULL((void*)0x23);
 567         CU_ASSERT_STRING_EQUAL(str1, str2);
 568         CU_ASSERT_STRING_NOT_EQUAL(str1, str2);
 569         CU_ASSERT_NSTRING_EQUAL(str1, str2, strlen(str1));
 570         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1));
 571         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1) + 1);
 572         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str2, 3);
 573         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str3, strlen(str1) + 1);
 574         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, 0.0001);
 575         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, -0.0001);
 576         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, 0.0001);
 577         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, -0.0001);
 578         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, 0.0001);
 579         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, -0.0001);
 580         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, 0.0001);
 581         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, -0.0001);
 582 */
 583
 584
 585
 586
 587
 588 static void AddStrBufSimlpeTests(void)
 589 {
 590         CU_pSuite pGroup = NULL;
 591         CU_pTest pTest = NULL;
 592
 593         pGroup = CU_add_suite("TestStringBufSimpleAppenders", NULL, NULL);
 594         pTest = CU_add_test(pGroup, "testCreateBuf", TestCreateBuf);
 595         pTest = CU_add_test(pGroup, "TestBufNumbers", TestBufNumbers);
 596         pTest = CU_add_test(pGroup, "TestStrBufPeek", TestStrBufPeek);
 597         pTest = CU_add_test(pGroup, "TestBufStringManipulation", TestBufStringManipulation);
 598
 599
 600         pGroup = CU_add_suite("TestStringTokenizer", NULL, NULL);
 601         pTest = CU_add_test(pGroup, "testNextTokenizer_EndWithEmpty", TestNextTokenizer_EndWithEmpty);
 602         pTest = CU_add_test(pGroup, "testNextTokenizer_StartWithEmpty", TestNextTokenizer_StartWithEmpty);
 603         pTest = CU_add_test(pGroup, "testNextTokenizer_StartWithEmpty", TestNextTokenizer_StartWithEmpty);
 604         pTest = CU_add_test(pGroup, "testNextTokenizer_Empty", TestNextTokenizer_Empty);
 605         pTest = CU_add_test(pGroup, "testNextTokenizer_TwoEmpty", TestNextTokenizer_TwoEmpty);
 606         pTest = CU_add_test(pGroup, "testNextTokenizer_One", TestNextTokenizer_One);
 607         pTest = CU_add_test(pGroup, "testNextTokenizer_Sequence", TestNextTokenizer_Sequence);
 608
 609
 610         pGroup = CU_add_suite("TestStrBufSipLine", NULL, NULL);
 611         pTest = CU_add_test(pGroup, "TestNextLine_Empty", TestNextLine_Empty);
 612         pTest = CU_add_test(pGroup, "TestNextLine_OneLine", TestNextLine_OneLine);
 613         pTest = CU_add_test(pGroup, "TestNextLine_TwoLinesMissingCR", TestNextLine_TwoLinesMissingCR);
 614         pTest = CU_add_test(pGroup, "TestNextLine_twolines", TestNextLine_twolines);
 615         pTest = CU_add_test(pGroup, "TestNextLine_LongLine", TestNextLine_LongLine);
 616
 617         pGroup = CU_add_suite("TestStrBufRemove_token", NULL, NULL);
 618         pTest = CU_add_test(pGroup, "TestStrBufRemove_token_NotThere", TestStrBufRemove_token_NotThere);
 619
 620         pGroup = CU_add_suite("TestStrBuf_escapers", NULL, NULL);
 621         pTest = CU_add_test(pGroup, "TestStrBufUrlescAppend", TestStrBufUrlescAppend);
 622 }
 623
 624
 625 int main(int argc, char* argv[])
 626 {
 627         setvbuf(stdout, NULL, _IONBF, 0);
 628
 629         StartLibCitadel(8);
 630         CU_BOOL Run = CU_FALSE ;
 631
 632         if (argc > 0)
 633                 Quiet = 1; // todo: -q ;-)
 634
 635         CU_set_output_filename("TestAutomated");
 636         if (CU_initialize_registry()) {
 637                 printf("\nInitialize of test Registry failed.");
 638         }
 639
 640         Run = CU_TRUE ;
 641         AddStrBufSimlpeTests();
 642
 643         if (CU_TRUE == Run) {
 644                 //CU_console_run_tests();
 645                 printf("\nTests completed with return value %d.\n", CU_basic_run_tests());
 646
 647     ///CU_automated_run_tests();
 648         }
 649
 650         CU_cleanup_registry();
 651
 652         return 0;
 653 }