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 static int success_init(void) { return 0; }
  29 static int success_clean(void) { return 0; }
  30
  31 static void testSuccess1(void) { CU_ASSERT(1); }
  32 static void testSuccess2(void) { CU_ASSERT(1); }
  33 static void testSuccess3(void) { CU_ASSERT(1); }
  34
  35 static int group_failure_init(void) { return 1;}
  36 static int group_failure_clean(void) { return 1; }
  37
  38 static void testGroupFailure1(void) { CU_ASSERT(0); }
  39 static void testGroupFailure2(void) { CU_ASSERT(2); }
  40
  41 static void testfailure1(void) { CU_ASSERT(12 <= 10); }
  42 static void testfailure2(void) { CU_ASSERT(2); }
  43 static void testfailure3(void) { CU_ASSERT(3); }
  44 /*
  45 static void test1(void)
  46 {
  47         CU_ASSERT((char *)2 != "THis is positive test.");
  48         CU_ASSERT((char *)2 == "THis is negative test. test 1");
  49 }
  50
  51 static void test2(void)
  52 {
  53         CU_ASSERT((char *)2 != "THis is positive test.");
  54         CU_ASSERT((char *)3 == "THis is negative test. test 2");
  55 }
  56 */
  57 static void TestCreateBuf(void)
  58 {
  59         StrBuf *Buf;
  60         StrBuf *Buf2;
  61         long len;
  62         long i;
  63
  64         Buf = NewStrBuf();
  65         CU_ASSERT(Buf != NULL);
  66         FreeStrBuf(&Buf);
  67
  68         CU_ASSERT(Buf == NULL);
  69         Buf = NewStrBufPlain(HKEY("ABC"));
  70         CU_ASSERT(StrLength(Buf) == 3);
  71         CU_ASSERT_NSTRING_EQUAL("ABC", ChrPtr(Buf), 3);
  72
  73         len = StrLength(Buf);
  74         for (i=0; i< 500; i ++)
  75         {
  76                 StrBufAppendBufPlain(Buf, HKEY("ABC"), 0);
  77                 len += 3;
  78                 CU_ASSERT(StrLength(Buf) == len);
  79         }
  80         StrBufShrinkToFit(Buf, 1);
  81         FreeStrBuf(&Buf);
  82         CU_ASSERT(Buf == NULL);
  83
  84         Buf = NewStrBufPlain(HKEY("ABC"));
  85         len = StrLength(Buf);
  86         for (i=0; i< 500; i ++)
  87         {
  88                 StrBufAppendPrintf(Buf, "%s", "ABC");
  89                 len += 3;
  90                 CU_ASSERT(StrLength(Buf) == len);
  91         }
  92         StrBufShrinkToFit(Buf, 1);
  93
  94         Buf2 = NewStrBufDup(Buf);
  95         CU_ASSERT(StrLength(Buf) == StrLength(Buf2));
  96
  97         CU_ASSERT_NSTRING_EQUAL(ChrPtr(Buf2), ChrPtr(Buf), StrLength(Buf2));
  98
  99         CU_ASSERT(StrBufIsNumber(Buf) == 0);
 100
 101         FlushStrBuf(Buf2);
 102         CU_ASSERT(StrLength(Buf2) == 0);
 103
 104         FLUSHStrBuf(Buf);
 105         CU_ASSERT(StrLength(Buf) == 0);
 106
 107         FreeStrBuf(&Buf);
 108         FreeStrBuf(&Buf2);
 109         CU_ASSERT(Buf == NULL);
 110         CU_ASSERT(Buf2 == NULL);
 111
 112
 113         Buf = NewStrBufPlain(HKEY("123456"));
 114 ///     CU_ASSERT(StrBufIsNumber(Buf) == 1); Todo: this is buggy.
 115         FreeStrBuf(&Buf);
 116
 117 }
 118
 119 static void NextTokenizerIterateBuf(StrBuf *Buf, int NTokens)
 120 {
 121         const char *pCh = NULL;
 122         char *NotNull;
 123         StrBuf *Buf2;
 124         long CountTokens = 0;
 125         long HaveNextToken = 0;
 126         long HaveNextTokenF = 0;
 127
 128         NotNull = NULL;
 129         NotNull --;
 130
 131         printf("\n\nTemplate: >%s<\n", ChrPtr(Buf));
 132
 133         Buf2 = NewStrBuf();
 134         while (HaveNextToken = StrBufHaveNextToken(Buf, &pCh),
 135                HaveNextTokenF = StrBufExtract_NextToken(Buf2, Buf, &pCh, ','),
 136                (HaveNextTokenF>= 0))
 137         {
 138                 CountTokens++;
 139
 140                 printf("Token: >%s< >%s< %ld:%ld\n",
 141                        ChrPtr(Buf2),
 142                        ((pCh != NULL) && (pCh != NotNull))? pCh : "N/A",
 143                        HaveNextToken,
 144                        HaveNextTokenF);
 145                 CU_ASSERT(HaveNextToken == (HaveNextTokenF >= 0));
 146
 147                 CU_ASSERT(CountTokens <= NTokens);
 148         }
 149         CU_ASSERT(HaveNextToken == (HaveNextTokenF >= 0));
 150 }
 151
 152 static void TestNextTokenizer_EndWithEmpty(void)
 153 {
 154         StrBuf *Buf;
 155
 156         Buf = NewStrBufPlain(HKEY("abc,abc, 1, ,,"));
 157         NextTokenizerIterateBuf(Buf, 7);
 158         FreeStrBuf(&Buf);
 159 }
 160
 161 static void TestNextTokenizer_StartWithEmpty(void)
 162 {
 163         StrBuf *Buf;
 164
 165         Buf = NewStrBufPlain(HKEY(",cde,abc, 1, ,,bbb"));
 166         NextTokenizerIterateBuf(Buf, 8);
 167         FreeStrBuf(&Buf);
 168 }
 169
 170 static void TestNextTokenizer_Empty(void)
 171 {
 172         StrBuf *Buf;
 173
 174         Buf = NewStrBufPlain(HKEY(""));
 175         NextTokenizerIterateBuf(Buf, 8);
 176         FreeStrBuf(&Buf);
 177 }
 178
 179 static void TestNextTokenizer_TwoEmpty(void)
 180 {
 181         StrBuf *Buf;
 182
 183         Buf = NewStrBufPlain(HKEY(","));
 184         NextTokenizerIterateBuf(Buf, 8);
 185         FreeStrBuf(&Buf);
 186 }
 187
 188 static void TestNextTokenizer_One(void)
 189 {
 190         StrBuf *Buf;
 191
 192         Buf = NewStrBufPlain(HKEY("one"));
 193         NextTokenizerIterateBuf(Buf, 8);
 194         FreeStrBuf(&Buf);
 195 }
 196
 197
 198
 199 static void testSuccessAssertTrue(void)
 200 {
 201         CU_ASSERT_TRUE(CU_TRUE);
 202         CU_ASSERT_TRUE(!CU_FALSE);
 203 }
 204
 205 static void testSuccessAssertFalse(void)
 206 {
 207         CU_ASSERT_FALSE(CU_FALSE);
 208         CU_ASSERT_FALSE(!CU_TRUE);
 209 }
 210
 211 static void testSuccessAssertEqual(void)
 212 {
 213         CU_ASSERT_EQUAL(10, 10);
 214         CU_ASSERT_EQUAL(0, 0);
 215         CU_ASSERT_EQUAL(0, -0);
 216         CU_ASSERT_EQUAL(-12, -12);
 217 }
 218
 219 static void testSuccessAssertNotEqual(void)
 220 {
 221         CU_ASSERT_NOT_EQUAL(10, 11);
 222         CU_ASSERT_NOT_EQUAL(0, -1);
 223         CU_ASSERT_NOT_EQUAL(-12, -11);
 224 }
 225
 226 static void testSuccessAssertPtrEqual(void)
 227 {
 228         CU_ASSERT_PTR_EQUAL((void*)0x100, (void*)0x100);
 229 }
 230
 231 static void testSuccessAssertPtrNotEqual(void)
 232 {
 233         CU_ASSERT_PTR_NOT_EQUAL((void*)0x100, (void*)0x101);
 234 }
 235
 236 static void testSuccessAssertPtrNull(void)
 237 {
 238         CU_ASSERT_PTR_NULL(NULL);
 239         CU_ASSERT_PTR_NULL(0x0);
 240 }
 241
 242 static void testSuccessAssertPtrNotNull(void)
 243 {
 244         CU_ASSERT_PTR_NOT_NULL((void*)0x23);
 245 }
 246
 247 static void testSuccessAssertStringEqual(void)
 248 {
 249         char str1[] = "test" ;
 250         char str2[] = "test" ;
 251
 252         CU_ASSERT_STRING_EQUAL(str1, str2);
 253 }
 254
 255 static void testSuccessAssertStringNotEqual(void)
 256 {
 257         char str1[] = "test" ;
 258         char str2[] = "testtsg" ;
 259
 260         CU_ASSERT_STRING_NOT_EQUAL(str1, str2);
 261 }
 262
 263 static void testSuccessAssertNStringEqual(void)
 264 {
 265         char str1[] = "test" ;
 266         char str2[] = "testgfsg" ;
 267
 268         CU_ASSERT_NSTRING_EQUAL(str1, str2, strlen(str1));
 269         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1));
 270         CU_ASSERT_NSTRING_EQUAL(str1, str1, strlen(str1) + 1);
 271 }
 272
 273 static void testSuccessAssertNStringNotEqual(void)
 274 {
 275         char str1[] = "test" ;
 276         char str2[] = "teet" ;
 277         char str3[] = "testgfsg" ;
 278
 279         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str2, 3);
 280         CU_ASSERT_NSTRING_NOT_EQUAL(str1, str3, strlen(str1) + 1);
 281 }
 282
 283 static void testSuccessAssertDoubleEqual(void)
 284 {
 285         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, 0.0001);
 286         CU_ASSERT_DOUBLE_EQUAL(10, 10.0001, -0.0001);
 287         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, 0.0001);
 288         CU_ASSERT_DOUBLE_EQUAL(-10, -10.0001, -0.0001);
 289 }
 290
 291 static void testSuccessAssertDoubleNotEqual(void)
 292 {
 293         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, 0.0001);
 294         CU_ASSERT_DOUBLE_NOT_EQUAL(10, 10.001, -0.0001);
 295         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, 0.0001);
 296         CU_ASSERT_DOUBLE_NOT_EQUAL(-10, -10.001, -0.0001);
 297 }
 298
 299 static void AddTests(void)
 300 {
 301         CU_pSuite pGroup = NULL;
 302         CU_pTest pTest = NULL;
 303
 304         pGroup = CU_add_suite("Sucess", success_init, success_clean);
 305         pTest = CU_add_test(pGroup, "testSuccess1", testSuccess1);
 306         pTest = CU_add_test(pGroup, "testSuccess2", testSuccess2);
 307         pTest = CU_add_test(pGroup, "testSuccess3", testSuccess3);
 308
 309         pGroup = CU_add_suite("failure", NULL, NULL);
 310         pTest = CU_add_test(pGroup, "testfailure1", testfailure1);
 311         pTest = CU_add_test(pGroup, "testfailure2", testfailure2);
 312         pTest = CU_add_test(pGroup, "testfailure3", testfailure3);
 313
 314         pGroup = CU_add_suite("group_failure", group_failure_init, group_failure_clean);
 315         pTest = CU_add_test(pGroup, "testGroupFailure1", testGroupFailure1);
 316         pTest = CU_add_test(pGroup, "testGroupFailure2", testGroupFailure2);
 317 }
 318
 319 static void AddStrBufSimlpeTests(void)
 320 {
 321         CU_pSuite pGroup = NULL;
 322         CU_pTest pTest = NULL;
 323
 324         pGroup = CU_add_suite("TestStringBufSimpleAppenders", NULL, NULL);
 325         pTest = CU_add_test(pGroup, "testCreateBuf", TestCreateBuf);
 326
 327         pGroup = CU_add_suite("TestStringTokenizer", NULL, NULL);
 328         pTest = CU_add_test(pGroup, "testNextTokenizer_EndWithEmpty", TestNextTokenizer_EndWithEmpty);
 329         pTest = CU_add_test(pGroup, "testNextTokenizer_StartWithEmpty", TestNextTokenizer_StartWithEmpty);
 330         pTest = CU_add_test(pGroup, "testNextTokenizer_StartWithEmpty", TestNextTokenizer_StartWithEmpty);
 331         pTest = CU_add_test(pGroup, "testNextTokenizer_Empty", TestNextTokenizer_Empty);
 332         pTest = CU_add_test(pGroup, "testNextTokenizer_TwoEmpty", TestNextTokenizer_TwoEmpty);
 333         pTest = CU_add_test(pGroup, "testNextTokenizer_One", TestNextTokenizer_One);
 334
 335
 336 /*
 337         pGroup = CU_add_suite("TestBooleanAssert", NULL, NULL);
 338         pTest = CU_add_test(pGroup, "testSuccessAssertTrue", testSuccessAssertTrue);
 339         pTest = CU_add_test(pGroup, "testSuccessAssertFalse", testSuccessAssertFalse);
 340
 341         pGroup = CU_add_suite("TestEqualityAssert", NULL, NULL);
 342         pTest = CU_add_test(pGroup, "testSuccessAssertEqual", testSuccessAssertEqual);
 343         pTest = CU_add_test(pGroup, "testSuccessAssertNotEqual", testSuccessAssertNotEqual);
 344
 345         pGroup = CU_add_suite("TestPointerAssert", NULL, NULL);
 346         pTest = CU_add_test(pGroup, "testSuccessAssertPtrEqual", testSuccessAssertPtrEqual);
 347         pTest = CU_add_test(pGroup, "testSuccessAssertPtrNotEqual", testSuccessAssertPtrNotEqual);
 348
 349         pGroup = CU_add_suite("TestNullnessAssert", NULL, NULL);
 350         pTest = CU_add_test(pGroup, "testSuccessAssertPtrNull", testSuccessAssertPtrNull);
 351         pTest = CU_add_test(pGroup, "testSuccessAssertPtrNotNull", testSuccessAssertPtrNotNull);
 352
 353         pGroup = CU_add_suite("TestStringAssert", NULL, NULL);
 354         pTest = CU_add_test(pGroup, "testSuccessAssertStringEqual", testSuccessAssertStringEqual);
 355         pTest = CU_add_test(pGroup, "testSuccessAssertStringNotEqual", testSuccessAssertStringNotEqual);
 356
 357         pGroup = CU_add_suite("TestNStringAssert", NULL, NULL);
 358         pTest = CU_add_test(pGroup, "testSuccessAssertNStringEqual", testSuccessAssertNStringEqual);
 359         pTest = CU_add_test(pGroup, "testSuccessAssertNStringNotEqual", testSuccessAssertNStringNotEqual);
 360
 361         pGroup = CU_add_suite("TestDoubleAssert", NULL, NULL);
 362         pTest = CU_add_test(pGroup, "testSuccessAssertDoubleEqual", testSuccessAssertDoubleEqual);
 363         pTest = CU_add_test(pGroup, "testSuccessAssertDoubleNotEqual", testSuccessAssertDoubleNotEqual);
 364 */
 365 }
 366
 367
 368 int main(int argc, char* argv[])
 369 {
 370         setvbuf(stdout, NULL, _IONBF, 0);
 371
 372         StartLibCitadel(8);
 373         if (argc > 1) {
 374                 CU_BOOL Run = CU_FALSE ;
 375
 376                 CU_set_output_filename("TestAutomated");
 377                 if (CU_initialize_registry()) {
 378                         printf("\nInitialize of test Registry failed.");
 379                 }
 380
 381                 if (!strcmp("--test", argv[1])) {
 382                         Run = CU_TRUE ;
 383                         AddTests();
 384                 }
 385                 else if (!strcmp("--atest", argv[1])) {
 386                         Run = CU_TRUE ;
 387                         AddStrBufSimlpeTests();
 388                 }
 389                 else if (!strcmp("--alltest", argv[1])) {
 390                         Run = CU_TRUE ;
 391                         AddTests();
 392 //                      AddAssertTests();
 393                 }
 394
 395                 if (CU_TRUE == Run) {
 396                         //CU_console_run_tests();
 397     printf("\nTests completed with return value %d.\n", CU_basic_run_tests());
 398
 399                         ///CU_automated_run_tests();
 400                 }
 401
 402                 CU_cleanup_registry();
 403         }
 404
 405         return 0;
 406 }