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