luna - iniparser/test/test

   1#include <dirent.h>
   2#include <sys/stat.h>
   3
   4#include <unity.h>
   5#include "dictionary.h"
   6
   7/* We need to directly insert the .c file in order to test the */
   8/* static functions as well */
   9#include "iniparser.c"
  10
  11#define GOOD_INI_PATH "ressources/good_ini"
  12#define BAD_INI_PATH "ressources/bad_ini"
  13#define OLD_INI_PATH "ressources/old.ini"
  14#define NEW_INI_PATH "ressources/new.ini"
  15#define TEST_INI_PATH "ressources/test.ini"
  16#define TEST_TXT_PATH "ressources/test.txt"
  17#define GRUEZI_INI_PATH "ressources/gruezi.ini"
  18#define UTF8_INI_PATH "ressources/utf8.ini"
  19#define TMP_INI_PATH "ressources/tmp.ini"
  20#define MISFORMED_INI_SEC0 "[12345"
  21#define MISFORMED_INI_SEC1 "12345]"
  22#define MISFORMED_INI_SEC2 "123]45"
  23#define MISFORMED_INI_ATTR "1111"
  24#define QUOTES_INI_PATH "ressources/quotes.ini"
  25#define QUOTES_INI_SEC "quotes"
  26#define QUOTES_INI_ATTR0 "string0"
  27#define QUOTES_INI_ATTR1 "string1"
  28#define QUOTES_INI_ATTR2 "string2"
  29#define QUOTES_INI_ATTR3 "string3"
  30#define QUOTES_INI_ATTR4 "string4"
  31#define QUOTES_INI_ATTR5 "string5"
  32#define QUOTES_INI_VAL0 "str\"ing"
  33#define QUOTES_INI_VAL1 "str;ing"
  34#define QUOTES_INI_VAL2 "str#ing"
  35
  36#define stringify_2(x)     #x
  37#define stringify(x)       stringify_2(x)
  38
  39static dictionary *dic = NULL;
  40static FILE *ini;
  41static DIR *dir;
  42
  43void setUp(void)
  44{
  45}
  46
  47void tearDown(void)
  48{
  49    if(dic)
  50        dictionary_del(dic);
  51    dic = NULL;
  52    if(ini)
  53        fclose(ini);
  54    ini = NULL;
  55    if(dir)
  56        closedir(dir);
  57    dir = NULL;
  58}
  59
  60/* Tool function to create and populate a generic non-empty dictionary */
  61static dictionary * generate_dictionary(unsigned sections, unsigned entries_per_section)
  62{
  63    unsigned i, j ;
  64    dictionary * dic;
  65    char sec_name[32];
  66    char key_name[64];
  67    char key_value[32];
  68
  69    dic = dictionary_new(sections + sections * entries_per_section);
  70    if (dic == NULL)
  71        return NULL;
  72
  73    /* Insert the sections */
  74    for (i = 0; i < sections; ++i) {
  75        sprintf(sec_name, "sec%d", i);
  76        dictionary_set(dic, sec_name, "");
  77        for (j = 0; j < entries_per_section; ++j) {
  78            /* Populate the section with the entries */
  79            sprintf(key_name, "%s:key%d", sec_name, j);
  80            sprintf(key_value, "value-%d/%d", i, j);
  81            dictionary_set(dic, key_name, key_value);
  82        }
  83    }
  84
  85    return dic;
  86}
  87
  88void test_iniparser_strlwc(void)
  89{
  90    char out_buffer[128];
  91
  92    /* NULL ptr as input */
  93    TEST_ASSERT_NULL(strlwc(NULL, NULL, 0));
  94    TEST_ASSERT_NULL(strlwc(NULL, out_buffer, sizeof (out_buffer)));
  95    TEST_ASSERT_NULL(strlwc("", NULL, sizeof (out_buffer)));
  96    TEST_ASSERT_NULL(strlwc("", out_buffer, 0));
  97    TEST_ASSERT_NULL(strlwc(NULL, NULL, 0));
  98
  99    /* empty string */
 100    TEST_ASSERT_EQUAL_STRING("", strlwc("", out_buffer, sizeof (out_buffer)));
 101    TEST_ASSERT_EQUAL_STRING("  ",
 102                             strlwc("  ", out_buffer, sizeof (out_buffer)));
 103    TEST_ASSERT_EQUAL_STRING("test",
 104                             strlwc("test", out_buffer, sizeof (out_buffer)));
 105    TEST_ASSERT_EQUAL_STRING("test",
 106                             strlwc("TEST", out_buffer, sizeof (out_buffer)));
 107    TEST_ASSERT_EQUAL_STRING("test",
 108                             strlwc("TeSt", out_buffer, sizeof (out_buffer)));
 109    TEST_ASSERT_EQUAL_STRING("test test",
 110                             strlwc("TEST TEST", out_buffer,
 111                                    sizeof (out_buffer)));
 112    TEST_ASSERT_EQUAL_STRING("very long string !!!!!!!",
 113                             strlwc("very long string !!!!!!!", out_buffer,
 114                                    sizeof (out_buffer)));
 115    TEST_ASSERT_EQUAL_STRING("cutted string",
 116                             strlwc("cutted string<---here", out_buffer, 14));
 117
 118    /* test using same buffer as input and output */
 119    strcpy(out_buffer, "OVERWRITE ME !");
 120    TEST_ASSERT_NOT_NULL(strlwc(out_buffer, out_buffer, sizeof(out_buffer)));
 121    TEST_ASSERT_EQUAL_STRING("overwrite me !", out_buffer);
 122}
 123
 124void test_iniparser_strstrip(void)
 125{
 126    /* First element in the array is the expected stripping result */
 127    const char *strings_empty[] = {
 128        "",
 129        "       ",
 130        "\n\n\n\n",
 131        "\t\t\t\t",
 132        "\n     \t\n\t\n    "
 133    };
 134    const char *strings_test[] = {
 135        "test",
 136        "test ",
 137        "test          ",
 138        " test",
 139        "   test    ",
 140        "\ttest\t",
 141        "\ttest\n"
 142
 143    };
 144    const char *test_with_spaces = "I am a test with\tspaces.";
 145    char stripped[ASCIILINESZ+1];
 146    char error_msg[1060];
 147    unsigned i;
 148
 149    /* NULL ptr as input */
 150    strstrip(NULL);
 151
 152    /* empty string */
 153    for (i = 0 ; i < sizeof (strings_empty) / sizeof (char *) ; ++i) {
 154        strcpy(stripped, strings_empty[i]);
 155        strstrip(stripped);
 156        sprintf(error_msg, "Bad stripping : strstrip(\"%s\") ==> \"%s\"",
 157                strings_empty[i], stripped);
 158        TEST_ASSERT_EQUAL_STRING_MESSAGE(stripped, strings_empty[0], error_msg);
 159    }
 160
 161    /* test string */
 162    for (i = 0 ; i < sizeof (strings_test) / sizeof (char *) ; ++i) {
 163        strcpy(stripped, strings_test[i]);
 164        strstrip(stripped);
 165        sprintf(error_msg, "Bad stripping : strstrip(\"%s\") ==> \"%s\"",
 166                strings_test[i], stripped);
 167        TEST_ASSERT_EQUAL_STRING_MESSAGE(strings_test[0], stripped, error_msg);
 168    }
 169    strcpy(stripped, ".");
 170    strstrip(stripped);
 171    TEST_ASSERT_EQUAL_STRING(".", stripped);
 172
 173    /* string containing spaces */
 174    strcpy(stripped, test_with_spaces);
 175    strstrip(stripped);
 176    TEST_ASSERT_EQUAL_STRING(test_with_spaces, stripped);
 177}
 178
 179void test_iniparser_getnsec(void)
 180{
 181    int i;
 182    char sec_name[32];
 183
 184    /* NULL test */
 185    TEST_ASSERT_EQUAL(-1, iniparser_getnsec(NULL));
 186
 187    /* Empty dictionary */
 188    dic = dictionary_new(10);
 189    TEST_ASSERT_NOT_NULL(dic);
 190    TEST_ASSERT_EQUAL(0, iniparser_getnsec(dic));
 191    dictionary_del(dic);
 192    dic = NULL;
 193
 194    /* Regular dictionary */
 195    dic = generate_dictionary(512, 0);
 196    TEST_ASSERT_NOT_NULL(dic);
 197    TEST_ASSERT_EQUAL(512, iniparser_getnsec(dic));
 198
 199    /* Check after removing sections */
 200    for (i = 1; i < 512; ++i) {
 201        sprintf(sec_name, "sec%d", i);
 202        dictionary_unset(dic, sec_name);
 203        TEST_ASSERT_EQUAL(512 - i, iniparser_getnsec(dic));
 204    }
 205    dictionary_del(dic);
 206    dic = NULL;
 207
 208    /* Mix sections and regular keys */
 209    dic = generate_dictionary(10, 512);
 210    TEST_ASSERT_NOT_NULL(dic);
 211    TEST_ASSERT_EQUAL(10, iniparser_getnsec(dic));
 212    dictionary_del(dic);
 213    dic = NULL;
 214}
 215
 216void test_iniparser_getsecname(void)
 217{
 218    unsigned i;
 219    char sec_name[32];
 220    /* NULL test */
 221    TEST_ASSERT_NULL(iniparser_getsecname(NULL, 0));
 222
 223    /* Empty dictionary */
 224    dic = dictionary_new(10);
 225    TEST_ASSERT_NOT_NULL(dic);
 226    TEST_ASSERT_NULL(iniparser_getsecname(dic, 0));
 227    dictionary_del(dic);
 228    dic = NULL;
 229
 230    /* Sections without entries dictionary */
 231    dic = generate_dictionary(100, 0);
 232    TEST_ASSERT_NOT_NULL(dic);
 233    for (i = 0; i < 100; ++i) {
 234        sprintf(sec_name, "sec%d", i);
 235        TEST_ASSERT_EQUAL_STRING(sec_name, iniparser_getsecname(dic, i));
 236    }
 237    dictionary_del(dic);
 238    dic = NULL;
 239
 240    /* Generic dictionary */
 241    dic = generate_dictionary(10, 100);
 242    TEST_ASSERT_NOT_NULL(dic);
 243    for (i = 0; i < 10; ++i) {
 244        sprintf(sec_name, "sec%d", i);
 245        TEST_ASSERT_EQUAL_STRING(sec_name, iniparser_getsecname(dic, i));
 246    }
 247    dictionary_del(dic);
 248    dic = NULL;
 249}
 250
 251void test_iniparser_getseckeys(void)
 252{
 253    unsigned i;
 254    char key_name[64];
 255    int nkeys;
 256    const char * keys[10]; /* At most 10 elements per section */
 257    /* NULL test */
 258    TEST_ASSERT_NULL(iniparser_getseckeys(NULL, NULL, NULL));
 259    TEST_ASSERT_NULL(iniparser_getseckeys(NULL, "dummy", NULL));
 260    TEST_ASSERT_NULL(iniparser_getseckeys(NULL, "dummy", keys));
 261
 262    /* Empty dictionary */
 263    dic = dictionary_new(10);
 264    TEST_ASSERT_NOT_NULL(dic);
 265    TEST_ASSERT_NULL(iniparser_getseckeys(dic, NULL, keys));
 266    TEST_ASSERT_NULL(iniparser_getseckeys(dic, "dummy", keys));
 267    dictionary_del(dic);
 268    dic = NULL;
 269
 270    /* Generic dictionary */
 271
 272    dic = generate_dictionary(100, 10);
 273    TEST_ASSERT_NOT_NULL(dic);
 274    TEST_ASSERT_NULL(iniparser_getseckeys(dic, NULL, keys));
 275    TEST_ASSERT_NULL(iniparser_getseckeys(dic, "dummy", keys));
 276    TEST_ASSERT_NULL(iniparser_getseckeys(dic, "sec0", NULL));
 277    nkeys = iniparser_getsecnkeys(dic, "sec42");
 278    TEST_ASSERT_EQUAL(nkeys, 10);
 279    TEST_ASSERT_EQUAL_STRING(keys, iniparser_getseckeys(dic, "sec42", keys));
 280    for (i = 0; i < 10; ++i) {
 281        sprintf(key_name, "sec42:key%d", i);
 282        TEST_ASSERT_EQUAL_STRING(key_name, keys[i]);
 283    }
 284
 285    /* Remove some keys to make the dictionary more real */
 286    dictionary_unset(dic, "sec42");
 287    dictionary_unset(dic, "sec99:key9");
 288    dictionary_unset(dic, "sec0:key0");
 289    dictionary_unset(dic, "sec0:key1");
 290    dictionary_unset(dic, "sec0:key2");
 291
 292    TEST_ASSERT_NULL(iniparser_getseckeys(dic, "sec42", keys));
 293    nkeys = iniparser_getsecnkeys(dic, "Sec99");
 294    TEST_ASSERT_EQUAL(nkeys, 9);
 295    TEST_ASSERT_EQUAL_STRING(keys, iniparser_getseckeys(dic, "Sec99", keys));
 296    for (i = 0; i < 9; ++i) {
 297        sprintf(key_name, "sec99:key%d", i);
 298        TEST_ASSERT_EQUAL_STRING(key_name, keys[i]);
 299    }
 300
 301    nkeys = iniparser_getsecnkeys(dic, "sec0");
 302    TEST_ASSERT_EQUAL(nkeys, 7);
 303    TEST_ASSERT_EQUAL_STRING(keys, iniparser_getseckeys(dic, "sec0", keys));
 304    for (i = 0; i < 7; ++i) {
 305        sprintf(key_name, "sec0:key%d", i + 3);
 306        TEST_ASSERT_EQUAL_STRING(key_name, keys[i]);
 307    }
 308
 309    dictionary_del(dic);
 310    dic = NULL;
 311}
 312
 313void test_iniparser_getstring(void)
 314{
 315    /* NULL test */
 316    TEST_ASSERT_NULL(iniparser_getstring(NULL, NULL, NULL));
 317    TEST_ASSERT_NULL(iniparser_getstring(NULL, "dummy", NULL));
 318
 319    /* Check the def return element */
 320    dic = dictionary_new(10);
 321    TEST_ASSERT_NOT_NULL(dic);
 322    TEST_ASSERT_NULL(iniparser_getstring(dic, "dummy", NULL));
 323    TEST_ASSERT_EQUAL_STRING("def", iniparser_getstring(dic, NULL, "def"));
 324    TEST_ASSERT_EQUAL_STRING("def", iniparser_getstring(dic, "dummy", "def"));
 325    dictionary_del(dic);
 326    dic = NULL;
 327
 328    /* Generic dictionary */
 329    dic = generate_dictionary(100, 10);
 330    TEST_ASSERT_NOT_NULL(dic);
 331    TEST_ASSERT_EQUAL_STRING("value-0/0",
 332                             iniparser_getstring(dic, "sec0:key0", NULL));
 333    TEST_ASSERT_EQUAL_STRING("value-42/5",
 334                             iniparser_getstring(dic, "sec42:key5", NULL));
 335    TEST_ASSERT_EQUAL_STRING("value-99/9",
 336                             iniparser_getstring(dic, "sec99:key9", NULL));
 337    dictionary_del(dic);
 338    dic = NULL;
 339}
 340
 341void test_iniparser_getint(void)
 342{
 343    unsigned i;
 344    char key_name[64];
 345    const struct {
 346        int num;
 347        const char *value;
 348    } good_val[] = {
 349        { 0, "0" },
 350        { 1, "1" },
 351        { -1, "-1" },
 352        { 1000, "1000" },
 353        { 077, "077" },
 354        { -01000, "-01000" },
 355        { 0xFFFF, "0xFFFF" },
 356        { -0xFFFF, "-0xFFFF" },
 357        { 0x4242, "0x4242" },
 358        { 0, NULL} /* must be last */
 359    };
 360    const char *bad_val[] = {
 361        "",
 362        "notanumber",
 363        "0x",
 364        "k2000",
 365        " ",
 366        "0xG1"
 367    };
 368    /* NULL test */
 369    TEST_ASSERT_EQUAL(-42, iniparser_getint(NULL, NULL, -42));
 370    TEST_ASSERT_EQUAL(-42, iniparser_getint(NULL, "dummy", -42));
 371
 372    /* Check the def return element */
 373    dic = dictionary_new(10);
 374    TEST_ASSERT_NOT_NULL(dic);
 375    TEST_ASSERT_EQUAL(42, iniparser_getint(dic, "dummy", 42));
 376    TEST_ASSERT_EQUAL_HEX(0xFFFF, iniparser_getint(dic, NULL, 0xFFFF));
 377    TEST_ASSERT_EQUAL_HEX(-0xFFFF, iniparser_getint(dic, "dummy", -0xFFFF));
 378    dictionary_del(dic);
 379    dic = NULL;
 380
 381    /* Generic dictionary */
 382    dic = dictionary_new(10);
 383    TEST_ASSERT_NOT_NULL(dic);
 384    for (i = 0; good_val[i].value != NULL; ++i) {
 385        sprintf(key_name, "int:value%d", i);
 386        dictionary_set(dic, key_name, good_val[i].value);
 387    }
 388    for (i = 0; good_val[i].value != NULL; ++i) {
 389        sprintf(key_name, "int:value%d", i);
 390        TEST_ASSERT_EQUAL(good_val[i].num,
 391                          iniparser_getint(dic, key_name, 0));
 392    }
 393    dictionary_del(dic);
 394    dic = NULL;
 395
 396    /* Test bad names */
 397    dic = dictionary_new(10);
 398    TEST_ASSERT_NOT_NULL(dic);
 399    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 400        sprintf(key_name, "int:bad%d", i);
 401        dictionary_set(dic, key_name, bad_val[i]);
 402    }
 403    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 404        sprintf(key_name, "int:bad%d", i);
 405        TEST_ASSERT_EQUAL(0,
 406                          iniparser_getint(dic, key_name, 0));
 407    }
 408    dictionary_del(dic);
 409    dic = NULL;
 410}
 411
 412void test_iniparser_getlongint(void)
 413{
 414    unsigned i;
 415    char key_name[64];
 416    const struct {
 417        long int num;
 418        const char *value;
 419    } good_val[] = {
 420        { 0, "0" },
 421        { 1, "1" },
 422        { -1, "-1" },
 423        { 1000, "1000" },
 424        { 077, "077" },
 425        { -01000, "-01000" },
 426        { LONG_MAX, stringify(LONG_MAX) },
 427        { -LONG_MAX, stringify(-LONG_MAX) },
 428        { 0x4242, "0x4242" },
 429        { 0, NULL} /* must be last */
 430    };
 431    const char *bad_val[] = {
 432        "",
 433        "notanumber",
 434        "0x",
 435        "k2000",
 436        " ",
 437        "0xG1"
 438    };
 439    /* NULL test */
 440    TEST_ASSERT_EQUAL(-42, iniparser_getlongint(NULL, NULL, -42));
 441    TEST_ASSERT_EQUAL(-42, iniparser_getlongint(NULL, "dummy", -42));
 442
 443    /* Check the def return element */
 444    dic = dictionary_new(10);
 445    TEST_ASSERT_NOT_NULL(dic);
 446    TEST_ASSERT_EQUAL(42, iniparser_getlongint(dic, "dummy", 42));
 447    TEST_ASSERT_EQUAL(LONG_MAX, iniparser_getlongint(dic, NULL, LONG_MAX));
 448    TEST_ASSERT_EQUAL(-LONG_MAX, iniparser_getlongint(dic, "dummy", -LONG_MAX));
 449    dictionary_del(dic);
 450    dic = NULL;
 451
 452    /* Generic dictionary */
 453    dic = dictionary_new(10);
 454    TEST_ASSERT_NOT_NULL(dic);
 455    for (i = 0; good_val[i].value != NULL; ++i) {
 456        sprintf(key_name, "longint:value%d", i);
 457        dictionary_set(dic, key_name, good_val[i].value);
 458    }
 459    for (i = 0; good_val[i].value != NULL; ++i) {
 460        sprintf(key_name, "longint:value%d", i);
 461        TEST_ASSERT_EQUAL(good_val[i].num,
 462                          iniparser_getlongint(dic, key_name, 0));
 463    }
 464    dictionary_del(dic);
 465    dic = NULL;
 466
 467    /* Test bad names */
 468    dic = dictionary_new(10);
 469    TEST_ASSERT_NOT_NULL(dic);
 470    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 471        sprintf(key_name, "longint:bad%d", i);
 472        dictionary_set(dic, key_name, bad_val[i]);
 473    }
 474    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 475        sprintf(key_name, "longint:bad%d", i);
 476        TEST_ASSERT_EQUAL(0,
 477                          iniparser_getlongint(dic, key_name, 0));
 478    }
 479    dictionary_del(dic);
 480    dic = NULL;
 481}
 482
 483void test_iniparser_getint64(void)
 484{
 485    unsigned i;
 486    char key_name[64];
 487    const struct {
 488        int64_t num;
 489        const char *value;
 490    } good_val[] = {
 491        { 0, "0" },
 492        { 1, "1" },
 493        { -1, "-1" },
 494        { 1000, "1000" },
 495        { 077, "077" },
 496        { -01000, "-01000" },
 497        { 0x7FFFFFFFFFFFFFFF, "0x7FFFFFFFFFFFFFFF" },
 498        { -0x7FFFFFFFFFFFFFFF, "-0x7FFFFFFFFFFFFFFF" },
 499        { 0x4242, "0x4242" },
 500        { 0, NULL} /* must be last */
 501    };
 502    const char *bad_val[] = {
 503        "",
 504        "notanumber",
 505        "0x",
 506        "k2000",
 507        " ",
 508        "0xG1"
 509    };
 510    /* NULL test */
 511    TEST_ASSERT_EQUAL_INT64(-42, iniparser_getint64(NULL, NULL, -42));
 512    TEST_ASSERT_EQUAL_INT64(-42, iniparser_getint64(NULL, "dummy", -42));
 513
 514    /* Check the def return element */
 515    dic = dictionary_new(10);
 516    TEST_ASSERT_NOT_NULL(dic);
 517    TEST_ASSERT_EQUAL_INT64(42, iniparser_getint64(dic, "dummy", 42));
 518    TEST_ASSERT_EQUAL_HEX64(0x7FFFFFFFFFFFFFFF,
 519                            iniparser_getint64(dic, NULL, 0x7FFFFFFFFFFFFFFF));
 520    TEST_ASSERT_EQUAL_HEX64(-0x7FFFFFFFFFFFFFFF,
 521                            iniparser_getint64(dic, "dummy",
 522                                -0x7FFFFFFFFFFFFFFF));
 523    dictionary_del(dic);
 524    dic = NULL;
 525
 526    /* Generic dictionary */
 527    dic = dictionary_new(10);
 528    TEST_ASSERT_NOT_NULL(dic);
 529    for (i = 0; good_val[i].value != NULL; ++i) {
 530        sprintf(key_name, "longint:value%d", i);
 531        dictionary_set(dic, key_name, good_val[i].value);
 532    }
 533    for (i = 0; good_val[i].value != NULL; ++i) {
 534        sprintf(key_name, "longint:value%d", i);
 535        TEST_ASSERT_EQUAL_INT64(good_val[i].num,
 536                                iniparser_getint64(dic, key_name, 0));
 537    }
 538    dictionary_del(dic);
 539    dic = NULL;
 540
 541    /* Test bad names */
 542    dic = dictionary_new(10);
 543    TEST_ASSERT_NOT_NULL(dic);
 544    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 545        sprintf(key_name, "longint:bad%d", i);
 546        dictionary_set(dic, key_name, bad_val[i]);
 547    }
 548    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 549        sprintf(key_name, "longint:bad%d", i);
 550        TEST_ASSERT_EQUAL_INT64(0,
 551                                iniparser_getint64(dic, key_name, 0));
 552    }
 553    dictionary_del(dic);
 554    dic = NULL;
 555}
 556
 557void test_iniparser_getuint64(void)
 558{
 559    unsigned i;
 560    char key_name[64];
 561    const struct {
 562        uint64_t num;
 563        const char *value;
 564    } good_val[] = {
 565        { 0, "0" },
 566        { 1, "1" },
 567        { -1, "-1" },
 568        { 1000, "1000" },
 569        { 077, "077" },
 570        { -01000, "-01000" },
 571        { 0xFFFFFFFFFFFFFFFF, "0xFFFFFFFFFFFFFFFF" },
 572        { -0xFFFFFFFFFFFFFFFF, "-0xFFFFFFFFFFFFFFFF" },
 573        { 0x4242, "0x4242" },
 574        { 0, NULL} /* must be last */
 575    };
 576    const char *bad_val[] = {
 577        "",
 578        "notanumber",
 579        "0x",
 580        "k2000",
 581        " ",
 582        "0xG1"
 583    };
 584    /* NULL test */
 585    TEST_ASSERT_EQUAL_UINT64(-42, iniparser_getuint64(NULL, NULL, -42));
 586    TEST_ASSERT_EQUAL_UINT64(-42, iniparser_getuint64(NULL, "dummy", -42));
 587
 588    /* Check the def return element */
 589    dic = dictionary_new(10);
 590    TEST_ASSERT_NOT_NULL(dic);
 591    TEST_ASSERT_EQUAL_UINT64(42, iniparser_getuint64(dic, "dummy", 42));
 592    TEST_ASSERT_EQUAL_HEX64(0xFFFFFFFFFFFFFFFF,
 593                            iniparser_getuint64(dic, NULL, 0xFFFFFFFFFFFFFFFF));
 594    TEST_ASSERT_EQUAL_HEX64(-0xFFFFFFFFFFFFFFFF,
 595                            iniparser_getuint64(dic, "dummy",
 596                                -0xFFFFFFFFFFFFFFFF));
 597    dictionary_del(dic);
 598    dic = NULL;
 599
 600    /* Generic dictionary */
 601    dic = dictionary_new(10);
 602    TEST_ASSERT_NOT_NULL(dic);
 603    for (i = 0; good_val[i].value != NULL; ++i) {
 604        sprintf(key_name, "longint:value%d", i);
 605        dictionary_set(dic, key_name, good_val[i].value);
 606    }
 607    for (i = 0; good_val[i].value != NULL; ++i) {
 608        sprintf(key_name, "longint:value%d", i);
 609        TEST_ASSERT_EQUAL_UINT64(good_val[i].num,
 610                                 iniparser_getuint64(dic, key_name, 0));
 611    }
 612    dictionary_del(dic);
 613    dic = NULL;
 614
 615    /* Test bad names */
 616    dic = dictionary_new(10);
 617    TEST_ASSERT_NOT_NULL(dic);
 618    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 619        sprintf(key_name, "longint:bad%d", i);
 620        dictionary_set(dic, key_name, bad_val[i]);
 621    }
 622    for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
 623        sprintf(key_name, "longint:bad%d", i);
 624        TEST_ASSERT_EQUAL_UINT64(0,
 625                                 iniparser_getuint64(dic, key_name, 0));
 626    }
 627    dictionary_del(dic);
 628    dic = NULL;
 629}
 630
 631void test_iniparser_getdouble(void)
 632{
 633
 634    /* NULL test */
 635    TEST_ASSERT_EQUAL_DOUBLE(-42, iniparser_getdouble(NULL, NULL, -42));
 636    TEST_ASSERT_EQUAL_DOUBLE(4.2, iniparser_getdouble(NULL, "dummy", 4.2));
 637
 638    /* Check the def return element */
 639    dic = dictionary_new(10);
 640    TEST_ASSERT_NOT_NULL(dic);
 641    TEST_ASSERT_EQUAL_DOUBLE(3.1415,
 642                             iniparser_getdouble(dic, "dummy", 3.1415));
 643    TEST_ASSERT_EQUAL_DOUBLE(0xFFFFFFFF,
 644                             iniparser_getdouble(dic, NULL, 0xFFFFFFFF));
 645    TEST_ASSERT_EQUAL_DOUBLE(-0xFFFFFFFF,
 646                             iniparser_getdouble(dic, "dummy", -0xFFFFFFFF));
 647
 648    /* Insert some values */
 649    dictionary_set(dic, "double", "");
 650    dictionary_set(dic, "double:good0", "0");
 651    dictionary_set(dic, "double:good1", "-0");
 652    dictionary_set(dic, "double:good2", "1.0");
 653    dictionary_set(dic, "double:good3", "3.1415");
 654    dictionary_set(dic, "double:good4", "6.6655957");
 655    dictionary_set(dic, "double:good5", "-123456789.123456789");
 656
 657    /* Add dummy stuff too */
 658    dictionary_set(dic, "double:bad0", "foo");
 659
 660    /* Get back the values */
 661    TEST_ASSERT_EQUAL_DOUBLE(0, iniparser_getdouble(dic, "double:good0", 0xFF));
 662    TEST_ASSERT_EQUAL_DOUBLE(0, iniparser_getdouble(dic, "double:good1", 0xFF));
 663    TEST_ASSERT_EQUAL_DOUBLE(1.0,
 664                             iniparser_getdouble(dic, "double:good2", 0xFF));
 665    TEST_ASSERT_EQUAL_DOUBLE(3.1415,
 666                             iniparser_getdouble(dic, "double:good3", 0xFF));
 667    TEST_ASSERT_EQUAL_DOUBLE(6.6655957,
 668                             iniparser_getdouble(dic, "double:good4", 0xFF));
 669    TEST_ASSERT_EQUAL_DOUBLE(-123456789.123456789,
 670                             iniparser_getdouble(dic, "double:good5", 0xFF));
 671
 672    TEST_ASSERT_EQUAL_DOUBLE(0, iniparser_getdouble(dic, "double:bad0", 42.42));
 673
 674    dictionary_del(dic);
 675    dic = NULL;
 676}
 677
 678void test_iniparser_getboolean(void)
 679{
 680    unsigned i;
 681    char key_name[64];
 682
 683    const char *token_true[] = {
 684        "1",
 685        "true",
 686        "t",
 687        "TRUE",
 688        "T",
 689        "yes",
 690        "y",
 691        "YES",
 692        "Y",
 693        NULL
 694    };
 695    const char *token_false[] = {
 696        "0",
 697        "false",
 698        "f",
 699        "FALSE",
 700        "F",
 701        "no",
 702        "n",
 703        "NO",
 704        "N",
 705        NULL
 706    };
 707
 708    /* NULL test */
 709    TEST_ASSERT_EQUAL(1, iniparser_getboolean(NULL, NULL, 1));
 710    TEST_ASSERT_EQUAL(1, iniparser_getboolean(NULL, "dummy", 1));
 711
 712    /* Check the def return element */
 713    dic = dictionary_new(10);
 714    TEST_ASSERT_NOT_NULL(dic);
 715    TEST_ASSERT_EQUAL(1, iniparser_getboolean(dic, "dummy", 1));
 716    TEST_ASSERT_EQUAL(0, iniparser_getboolean(dic, NULL, 0));
 717    TEST_ASSERT_EQUAL(1, iniparser_getboolean(dic, "dummy", 1));
 718
 719    for (i = 0; token_true[i] != NULL; ++i) {
 720        sprintf(key_name, "bool:true%d", i);
 721        iniparser_set(dic, key_name, token_true[i]);
 722    }
 723    for (i = 0; token_false[i] != NULL; ++i) {
 724        sprintf(key_name, "bool:false%d", i);
 725        iniparser_set(dic, key_name, token_false[i]);
 726    }
 727
 728    for (i = 0; token_true[i] != NULL; ++i) {
 729        sprintf(key_name, "bool:true%d", i);
 730        TEST_ASSERT_EQUAL(1, iniparser_getboolean(dic, key_name, 0));
 731    }
 732    for (i = 0; token_false[i] != NULL; ++i) {
 733        sprintf(key_name, "bool:false%d", i);
 734        TEST_ASSERT_EQUAL(0, iniparser_getboolean(dic, key_name, 1));
 735    }
 736
 737    /* Test bad boolean */
 738    iniparser_set(dic, "bool:bad0", "");
 739    iniparser_set(dic, "bool:bad1", "m'kay");
 740    iniparser_set(dic, "bool:bad2", "42");
 741    iniparser_set(dic, "bool:bad3", "_true");
 742    TEST_ASSERT_EQUAL_HEX(0xFF, iniparser_getboolean(dic, "bool:bad0", 0xFF));
 743    TEST_ASSERT_EQUAL_HEX(0xFF, iniparser_getboolean(dic, "bool:bad1", 0xFF));
 744    TEST_ASSERT_EQUAL_HEX(0xFF, iniparser_getboolean(dic, "bool:bad2", 0xFF));
 745    TEST_ASSERT_EQUAL_HEX(0xFF, iniparser_getboolean(dic, "bool:bad3", 0xFF));
 746
 747    dictionary_del(dic);
 748    dic = NULL;
 749}
 750
 751void test_iniparser_line(void)
 752{
 753    char section [ASCIILINESZ+1] ;
 754    char key     [ASCIILINESZ+1] ;
 755    char val     [ASCIILINESZ+1] ;
 756
 757    /* Test empty line */
 758    TEST_ASSERT_EQUAL(LINE_EMPTY, iniparser_line("", section, key, val));
 759    TEST_ASSERT_EQUAL(LINE_EMPTY, iniparser_line("    ", section, key, val));
 760    TEST_ASSERT_EQUAL(LINE_EMPTY, iniparser_line("\t", section, key, val));
 761
 762    /* Test valid syntax */
 763    TEST_ASSERT_EQUAL(LINE_SECTION, iniparser_line("[s]", section, key, val));
 764    TEST_ASSERT_EQUAL_STRING("s", section);
 765
 766    TEST_ASSERT_EQUAL(LINE_SECTION, iniparser_line("[section 0]", section, key, val));
 767    TEST_ASSERT_EQUAL_STRING("section 0", section);
 768
 769    TEST_ASSERT_EQUAL(LINE_SECTION, iniparser_line("[ section 0 ]", section, key, val));
 770    TEST_ASSERT_EQUAL_STRING("section 0", section);
 771
 772    TEST_ASSERT_EQUAL(LINE_SECTION, iniparser_line("[ section ]", section, key, val));
 773    TEST_ASSERT_EQUAL_STRING("section", section);
 774
 775    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("k=1", section, key, val));
 776    TEST_ASSERT_EQUAL_STRING("k", key);
 777    TEST_ASSERT_EQUAL_STRING("1", val);
 778
 779    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key = 0x42", section, key, val));
 780    TEST_ASSERT_EQUAL_STRING("key", key);
 781    TEST_ASSERT_EQUAL_STRING("0x42", val);
 782
 783    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key= value with spaces", section, key, val));
 784    TEST_ASSERT_EQUAL_STRING("key", key);
 785    TEST_ASSERT_EQUAL_STRING("value with spaces", val);
 786
 787    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("k =_!<>''", section, key, val));
 788    TEST_ASSERT_EQUAL_STRING("k", key);
 789    TEST_ASSERT_EQUAL_STRING("_!<>''", val);
 790
 791    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("empty_value =", section, key, val));
 792    TEST_ASSERT_EQUAL_STRING("empty_value", key);
 793    TEST_ASSERT_EQUAL_STRING("", val);
 794
 795    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("empty_value =        \t\n", section, key, val));
 796    TEST_ASSERT_EQUAL_STRING("empty_value", key);
 797    TEST_ASSERT_EQUAL_STRING("", val);
 798
 799    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key =\tval # comment", section, key, val));
 800    TEST_ASSERT_EQUAL_STRING("key", key);
 801    TEST_ASSERT_EQUAL_STRING("val", val);
 802
 803    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key \n\n = \n val", section, key, val));
 804    TEST_ASSERT_EQUAL_STRING("key", key);
 805    TEST_ASSERT_EQUAL_STRING("val", val);
 806
 807    TEST_ASSERT_EQUAL(LINE_COMMENT, iniparser_line(";comment", section, key, val));
 808    TEST_ASSERT_EQUAL(LINE_COMMENT, iniparser_line(" # comment", section, key, val));
 809
 810    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key = \"  do_not_strip  \"", section, key, val));
 811    TEST_ASSERT_EQUAL_STRING("key", key);
 812    TEST_ASSERT_EQUAL_STRING("  do_not_strip  ", val);
 813
 814    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key = '    '", section, key, val));
 815    TEST_ASSERT_EQUAL_STRING("key", key);
 816    TEST_ASSERT_EQUAL_STRING("    ", val);
 817
 818    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key = \"\"", section, key, val));
 819    TEST_ASSERT_EQUAL_STRING("key", key);
 820    TEST_ASSERT_EQUAL_STRING("", val);
 821
 822    TEST_ASSERT_EQUAL(LINE_VALUE, iniparser_line("key = ''", section, key, val));
 823    TEST_ASSERT_EQUAL_STRING("key", key);
 824    TEST_ASSERT_EQUAL_STRING("", val);
 825
 826    /* Test syntax error */
 827    TEST_ASSERT_EQUAL(LINE_ERROR, iniparser_line("empty_value", section, key, val));
 828    TEST_ASSERT_EQUAL(LINE_ERROR, iniparser_line("not finished\\", section, key, val));
 829    TEST_ASSERT_EQUAL(LINE_ERROR, iniparser_line("0x42 / 0b101010", section, key, val));
 830
 831}
 832
 833void test_iniparser_load(void)
 834{
 835    struct dirent *curr;
 836    struct stat curr_stat;
 837    char ini_path[276];
 838
 839    /* Dummy tests */
 840    dic = iniparser_load("/you/shall/not/path");
 841    TEST_ASSERT_NULL(dic);
 842
 843    /* Test all the good .ini files */
 844    dir = opendir(GOOD_INI_PATH);
 845    TEST_ASSERT_NOT_NULL_MESSAGE(dir, "cannot open " GOOD_INI_PATH);
 846    for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
 847        sprintf(ini_path, "%s/%s", GOOD_INI_PATH, curr->d_name);
 848        stat(ini_path, &curr_stat);
 849        if (S_ISREG(curr_stat.st_mode)) {
 850            dic = iniparser_load(ini_path);
 851            TEST_ASSERT_NOT_NULL_MESSAGE(dic, ini_path);
 852            dictionary_del(dic);
 853            dic = NULL;
 854        }
 855    }
 856    closedir(dir);
 857    dir = NULL;
 858
 859    /* Test all the bad .ini files */
 860    dir = opendir(BAD_INI_PATH);
 861    TEST_ASSERT_NOT_NULL_MESSAGE(dir, "cannot open " BAD_INI_PATH);
 862    for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
 863        sprintf(ini_path, "%s/%s", BAD_INI_PATH, curr->d_name);
 864        stat(ini_path, &curr_stat);
 865        if (S_ISREG(curr_stat.st_mode)) {
 866            dic = iniparser_load(ini_path);
 867            TEST_ASSERT_EQUAL_PTR_MESSAGE(NULL, dic, ini_path);
 868            dictionary_del(dic);
 869            dic = NULL;
 870        }
 871    }
 872    closedir(dir);
 873    dir = NULL;
 874}
 875
 876void test_dictionary_wrapper(void)
 877{
 878    dic = dictionary_new(10);
 879    TEST_ASSERT_NOT_NULL(dic);
 880
 881    TEST_ASSERT_EQUAL(-1, iniparser_set(dic, NULL, NULL));
 882    TEST_ASSERT_EQUAL(-1, iniparser_set(NULL, "section", "value"));
 883
 884    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section", NULL));
 885    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section:key", "value"));
 886
 887    TEST_ASSERT_EQUAL_STRING("value", iniparser_getstring(dic, "section:key", NULL));
 888    /* reset the key's value*/
 889    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section:key", NULL));
 890    TEST_ASSERT_NULL(iniparser_getstring(dic, "section:key", "dummy"));
 891    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section:key", "value"));
 892    TEST_ASSERT_EQUAL_STRING("value", iniparser_getstring(dic, "section:key", NULL));
 893
 894    iniparser_unset(dic, "section:key");
 895    TEST_ASSERT_EQUAL_STRING("dummy", iniparser_getstring(dic, "section:key", "dummy"));
 896    TEST_ASSERT_NULL(iniparser_getstring(dic, "section", "dummy"));
 897
 898    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section:key", NULL));
 899    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section:key1", NULL));
 900    TEST_ASSERT_EQUAL(0, iniparser_set(dic, "section:key2", NULL));
 901
 902    iniparser_unset(dic, "section");
 903    TEST_ASSERT_NULL(iniparser_getstring(dic, "section", NULL));
 904
 905    iniparser_freedict(dic);
 906    dic = NULL;
 907}
 908
 909static char _last_error[1024];
 910static int _error_callback(const char *format, ...)
 911{
 912    int ret;
 913    va_list argptr;
 914    va_start(argptr, format);
 915    ret = vsprintf(_last_error, format, argptr);
 916    va_end(argptr);
 917    return ret;
 918
 919}
 920
 921void test_iniparser_error_callback(void)
 922{
 923    /* Specify our custom error_callback */
 924    iniparser_set_error_callback(_error_callback);
 925
 926    /* Trigger an error and check it was written on the right output */
 927    dic = iniparser_load("/path/to/nowhere.ini");
 928    TEST_ASSERT_NULL(dic);
 929    TEST_ASSERT_EQUAL_STRING("iniparser: cannot open /path/to/nowhere.ini\n",
 930                             _last_error);
 931
 932    /* Reset erro_callback */
 933    _last_error[0] = '\0';
 934    iniparser_set_error_callback(NULL);
 935
 936    /* Make sure custom callback is no more called */
 937    dic = iniparser_load("/path/to/nowhere.ini");
 938    TEST_ASSERT_NULL(dic);
 939    TEST_ASSERT_EQUAL_STRING("", _last_error);
 940}
 941
 942void test_iniparser_dump(void)
 943{
 944    char buff[255];
 945    const char *str;
 946
 947    /*loading old.ini*/
 948    dic = iniparser_load(OLD_INI_PATH);
 949    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " OLD_INI_PATH);
 950    /*check the data of old.ini*/
 951    str = iniparser_getstring(dic,"section:key_01",NULL);
 952    TEST_ASSERT_EQUAL_STRING("hello world", str);
 953    str = iniparser_getstring(dic,"section:key1",NULL);
 954    TEST_ASSERT_EQUAL_STRING("321abc", str);
 955    /*open test.txt*/
 956    ini = fopen(TEST_TXT_PATH,"w");
 957    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TEST_TXT_PATH);
 958    /*dump the data of old.ini to new.ini*/
 959    iniparser_dump(dic,ini);
 960    fclose(ini);
 961    ini = NULL;
 962    iniparser_freedict(dic);
 963    dic = NULL;
 964    /*read the data of test.txt*/
 965    ini = fopen(TEST_TXT_PATH,"r");
 966    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TEST_TXT_PATH);
 967    str = fgets(buff,100,ini);
 968    (void)str;
 969    /*remove '\n'*/
 970    if(buff[strlen(buff)-1] == '\n')
 971    {
 972        buff[strlen(buff)-1] = '\0';
 973    }
 974    TEST_ASSERT_EQUAL_STRING("[section]=UNDEF",buff);
 975    str = fgets(buff,100,ini);
 976    (void)str;
 977    if(buff[strlen(buff)-1] == '\n')
 978    {
 979        buff[strlen(buff)-1] = '\0';
 980    }
 981    TEST_ASSERT_EQUAL_STRING("[section:key_01]=[hello world]",buff);
 982    str = fgets(buff,100,ini);
 983    (void)str;
 984    if(buff[strlen(buff)-1] == '\n')
 985    {
 986        buff[strlen(buff)-1] = '\0';
 987    }
 988    TEST_ASSERT_EQUAL_STRING("[section:key1]=[321abc]",buff);
 989    fclose(ini);
 990    ini = NULL;
 991}
 992
 993void test_iniparser_dump_ini(void)
 994{
 995    const char *str;
 996    char val[4096] = {};
 997    int ret;
 998
 999    /*loading old.ini*/
1000    dic = iniparser_load(OLD_INI_PATH);
1001    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " OLD_INI_PATH);
1002    /*check the data of old.ini*/
1003    str = iniparser_getstring(dic,"section:key_01",NULL);
1004    TEST_ASSERT_EQUAL_STRING("hello world", str);
1005    str = iniparser_getstring(dic,"section:key1",NULL);
1006    TEST_ASSERT_EQUAL_STRING("321abc", str);
1007    /*open new.ini*/
1008    ini = fopen(NEW_INI_PATH,"w");
1009    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " NEW_INI_PATH);
1010    /*dump the data of old.ini to new.ini*/
1011    iniparser_dump_ini(dic,ini);
1012    fclose(ini);
1013    ini = NULL;
1014    iniparser_freedict(dic);
1015    dic = NULL;
1016    /*loading new.ini*/
1017    dic = iniparser_load(NEW_INI_PATH);
1018    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " NEW_INI_PATH);
1019    /*check the data of new.ini*/
1020    str = iniparser_getstring(dic,"section:key_01",NULL);
1021    TEST_ASSERT_EQUAL_STRING("hello world", str);
1022    str = iniparser_getstring(dic,"section:key1",NULL);
1023    TEST_ASSERT_EQUAL_STRING("321abc", str);
1024    iniparser_freedict(dic);
1025    dic = NULL;
1026    /*test extra large values*/
1027    dic = dictionary_new(0);
1028    TEST_ASSERT_NOT_NULL(dic);
1029    memset(val, '\\', sizeof(val)-1);
1030    ret = iniparser_set(dic, ":key1", val);
1031    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set :key1"
1032                                         " in: " TMP_INI_PATH);
1033    ini = fopen(TMP_INI_PATH, "wt");
1034    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1035    iniparser_dump_ini(dic, ini);
1036    fclose(ini);
1037    ini = NULL;
1038    iniparser_freedict(dic);
1039    dic = NULL;
1040}
1041
1042void test_iniparser_dumpsection_ini(void)
1043{
1044    const char *str;
1045    char key[4096] = {};
1046    int ret;
1047
1048    /*loading old.ini*/
1049    dic = iniparser_load(OLD_INI_PATH);
1050    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " OLD_INI_PATH);
1051    /*check the data of old.ini*/
1052    str = iniparser_getstring(dic,"section:key_01",NULL);
1053    TEST_ASSERT_EQUAL_STRING("hello world", str);
1054    str = iniparser_getstring(dic,"section:key1",NULL);
1055    TEST_ASSERT_EQUAL_STRING("321abc", str);
1056    /*open test.ini*/
1057    ini = fopen(TEST_INI_PATH,"w");
1058    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TEST_INI_PATH);
1059    /*dump the data of old.ini to test.ini*/
1060    iniparser_dumpsection_ini(dic,"section",ini);
1061    fclose(ini);
1062    ini = NULL;
1063    iniparser_freedict(dic);
1064    dic = NULL;
1065    /*loading test.ini*/
1066    dic = iniparser_load(TEST_INI_PATH);
1067    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TEST_INI_PATH);
1068    /*check the data of test.ini*/
1069    str = iniparser_getstring(dic,"section:key_01",NULL);
1070    TEST_ASSERT_EQUAL_STRING("hello world", str);
1071    str = iniparser_getstring(dic,"section:key1",NULL);
1072    TEST_ASSERT_EQUAL_STRING("321abc", str);
1073    iniparser_freedict(dic);
1074    dic = NULL;
1075    /*test extra large keys*/
1076    dic = dictionary_new(0);
1077    TEST_ASSERT_NOT_NULL(dic);
1078    memset(key, 'a', sizeof(key)-1);
1079    ret = iniparser_set(dic, key, "dummy");
1080    TEST_ASSERT_GREATER_OR_EQUAL(0, ret);
1081    ini = fopen(TMP_INI_PATH, "wt");
1082    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1083    /*dump the data of old.ini to test.ini*/
1084    iniparser_dumpsection_ini(dic,key,ini);
1085    fclose(ini);
1086    ini = NULL;
1087    iniparser_freedict(dic);
1088    dic = NULL;
1089}
1090
1091void test_iniparser_find_entry(void)
1092{
1093    int i, ret;
1094
1095    /* NULL test */
1096    ret = iniparser_find_entry(NULL, NULL);
1097    TEST_ASSERT_EQUAL(0, ret);
1098    ret = iniparser_find_entry(NULL, "dummy");
1099    TEST_ASSERT_EQUAL(0, ret);
1100
1101    /* Empty dictionary test*/
1102    dic = dictionary_new(10);
1103    TEST_ASSERT_NOT_NULL(dic);
1104    ret = iniparser_find_entry(dic, NULL);
1105    TEST_ASSERT_EQUAL(0, ret);
1106    ret = iniparser_find_entry(dic, "dummy");
1107    TEST_ASSERT_EQUAL(0, ret);
1108    dictionary_del(dic);
1109    dic = NULL;
1110
1111    /*Regular dictionary */
1112    dic = generate_dictionary(1, 8);
1113    TEST_ASSERT_NOT_NULL(dic);
1114    for (i = 1; i < 8; i++)
1115    {
1116        ret = iniparser_find_entry(dic, dic->key[i]);
1117        TEST_ASSERT_EQUAL(1, ret);
1118    }
1119    ret = iniparser_find_entry(dic, "dummy");
1120    TEST_ASSERT_EQUAL(0, ret);
1121
1122    iniparser_freedict(dic);
1123    dic = NULL;
1124}
1125
1126void test_iniparser_utf8(void)
1127{
1128    const char *str;
1129    int ret;
1130
1131    dic = iniparser_load(GRUEZI_INI_PATH);
1132    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " GRUEZI_INI_PATH);
1133
1134    /* Generic dictionary */
1135    str = iniparser_getstring(dic, "Chuchichäschtli:10.123", NULL);
1136    TEST_ASSERT_EQUAL_STRING("example", str);
1137    str = iniparser_getstring(dic, "Chuchichäschtli:Gruss", NULL);
1138    TEST_ASSERT_EQUAL_STRING("Grüzi", str);
1139    dictionary_del(dic);
1140    dic = iniparser_load(UTF8_INI_PATH);
1141    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " UTF8_INI_PATH);
1142
1143    /* Generic dictionary */
1144    ret = iniparser_getboolean(dic, "拉麺:叉焼", -1);
1145    TEST_ASSERT_EQUAL(0, ret);
1146    ret = iniparser_getboolean(dic, "拉麺:味噌", -1);
1147    TEST_ASSERT_EQUAL(1, ret);
1148    ret = iniparser_getboolean(dic, "拉麺:海苔", -1);
1149    TEST_ASSERT_EQUAL(0, ret);
1150    str = iniparser_getstring(dic, "拉麺:メンマ", NULL);
1151    TEST_ASSERT_EQUAL_STRING("そうだね", str);
1152    dictionary_del(dic);
1153    dic = NULL;
1154}
1155
1156static void create_empty_ini_file(const char *filename)
1157{
1158    ini = fopen(filename, "w");
1159    TEST_ASSERT_NOT_NULL_MESSAGE(ini, filename);
1160    fclose(ini);
1161    ini = NULL;
1162}
1163
1164void test_iniparser_misformed(void)
1165{
1166    int ret;
1167
1168    create_empty_ini_file(TMP_INI_PATH);
1169    dic = iniparser_load(TMP_INI_PATH);
1170    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1171
1172    ret = iniparser_set(dic, MISFORMED_INI_SEC0, NULL);
1173    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set section "
1174                                         MISFORMED_INI_SEC0 " in: "
1175                                         TMP_INI_PATH);
1176    iniparser_set(dic, MISFORMED_INI_SEC0 ":" MISFORMED_INI_ATTR, "2222");
1177    /* test dictionary */
1178    ret = iniparser_getint(dic, MISFORMED_INI_SEC0 ":" MISFORMED_INI_ATTR, -1);
1179    TEST_ASSERT_EQUAL(2222, ret);
1180    ini = fopen(TMP_INI_PATH, "w+");
1181    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1182
1183    iniparser_dump_ini(dic, ini);
1184    fclose(ini);
1185    ini = NULL;
1186    dictionary_del(dic);
1187    /* check if section has been written as expected */
1188    dic = iniparser_load(TMP_INI_PATH);
1189    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1190
1191    ret = iniparser_getint(dic, MISFORMED_INI_SEC0 ":" MISFORMED_INI_ATTR, -1);
1192    TEST_ASSERT_EQUAL(2222, ret);
1193    dictionary_del(dic);
1194    dic = NULL;
1195    ret = remove(TMP_INI_PATH);
1196    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1197
1198    create_empty_ini_file(TMP_INI_PATH);
1199    dic = iniparser_load(TMP_INI_PATH);
1200    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1201
1202    ret = iniparser_set(dic, MISFORMED_INI_SEC1, NULL);
1203    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set section "
1204                                         MISFORMED_INI_SEC1 " in: "
1205                                         TMP_INI_PATH);
1206
1207    iniparser_set(dic, MISFORMED_INI_SEC1 ":" MISFORMED_INI_ATTR, "2222");
1208    /* test dictionary */
1209    ret = iniparser_getint(dic, MISFORMED_INI_SEC1 ":" MISFORMED_INI_ATTR, -1);
1210    TEST_ASSERT_EQUAL(2222, ret);
1211    ini = fopen(TMP_INI_PATH, "w+");
1212    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1213
1214    iniparser_dump_ini(dic, ini);
1215    fclose(ini);
1216    ini = NULL;
1217    dictionary_del(dic);
1218    /* check if section has been written as expected */
1219    dic = iniparser_load(TMP_INI_PATH);
1220    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1221
1222    ret = iniparser_getint(dic, MISFORMED_INI_SEC1 ":" MISFORMED_INI_ATTR, -1);
1223    TEST_ASSERT_EQUAL(2222, ret);
1224    dictionary_del(dic);
1225    dic = NULL;
1226    ret = remove(TMP_INI_PATH);
1227    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1228
1229    create_empty_ini_file(TMP_INI_PATH);
1230    dic = iniparser_load(TMP_INI_PATH);
1231    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1232
1233    ret = iniparser_set(dic, MISFORMED_INI_SEC2, NULL);
1234    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set section "
1235                                         MISFORMED_INI_SEC2 " in: "
1236                                         TMP_INI_PATH);
1237
1238    iniparser_set(dic, MISFORMED_INI_SEC2 ":" MISFORMED_INI_ATTR, "2222");
1239    /* test dictionary */
1240    ret = iniparser_getint(dic, MISFORMED_INI_SEC2 ":" MISFORMED_INI_ATTR, -1);
1241    TEST_ASSERT_EQUAL(2222, ret);
1242    ini = fopen(TMP_INI_PATH, "w+");
1243    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1244
1245    iniparser_dump_ini(dic, ini);
1246    fclose(ini);
1247    ini = NULL;
1248    dictionary_del(dic);
1249    /* check if section has been written as expected */
1250    dic = iniparser_load(TMP_INI_PATH);
1251    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1252
1253    ret = iniparser_getint(dic, MISFORMED_INI_SEC2 ":" MISFORMED_INI_ATTR, -1);
1254    TEST_ASSERT_EQUAL(2222, ret);
1255    dictionary_del(dic);
1256    dic = NULL;
1257    ret = remove(TMP_INI_PATH);
1258    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1259}
1260
1261void test_iniparser_quotes(void)
1262{
1263    const char *str;
1264    int ret;
1265
1266    /**
1267     * Test iniparser_load()
1268     */
1269    /* check if section has been written as expected */
1270    dic = iniparser_load(QUOTES_INI_PATH);
1271    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load "  QUOTES_INI_PATH);
1272
1273    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR0, NULL);
1274    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1275    /*
1276     * iniparser_load() supports semicolon and hash in values if they are
1277     * quoted
1278     */
1279    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR1, NULL);
1280    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL1, str);
1281    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR2, NULL);
1282    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL2, str);
1283    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR3, NULL);
1284    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1285    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR4, NULL);
1286    TEST_ASSERT_EQUAL_STRING("str", str);
1287    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR5, NULL);
1288    TEST_ASSERT_EQUAL_STRING("str", str);
1289    /*
1290     * iniparser_load() supports quotes in attributes
1291     */
1292    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str\"ing", NULL);
1293    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1294    /*
1295     * iniparser_load() does not support semicolon or hash in attributes
1296     */
1297    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str;ing", NULL);
1298    TEST_ASSERT_NULL(str);
1299    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str#ing", NULL);
1300    TEST_ASSERT_NULL(str);
1301    /*
1302     * iniparser_load() does support colon in attributes
1303     */
1304    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str:ing", NULL);
1305    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1306    ini = fopen(TMP_INI_PATH, "w+");
1307    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1308
1309    /**
1310     * Test iniparser_dump_ini()
1311     */
1312    iniparser_dump_ini(dic, ini);
1313    fclose(ini);
1314    ini = NULL;
1315    dictionary_del(dic);
1316    dic = iniparser_load(TMP_INI_PATH);
1317
1318    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR0, NULL);
1319    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1320    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR1, NULL);
1321    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL1, str);
1322    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR2, NULL);
1323    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL2, str);
1324    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR3, NULL);
1325    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1326    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR4, NULL);
1327    TEST_ASSERT_EQUAL_STRING("str", str);
1328    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR5, NULL);
1329    TEST_ASSERT_EQUAL_STRING("str", str);
1330    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str\"ing", NULL);
1331    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1332    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str;ing", NULL);
1333    TEST_ASSERT_NULL(str);
1334    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str#ing", NULL);
1335    TEST_ASSERT_NULL(str);
1336    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" "str:ing", NULL);
1337    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1338    dictionary_del(dic);
1339    dic = NULL;
1340    ret = remove(TMP_INI_PATH);
1341    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1342    /**
1343     * test iniparser_set()
1344     */
1345    create_empty_ini_file(TMP_INI_PATH);
1346    dic = iniparser_load(TMP_INI_PATH);
1347    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1348
1349    ret = iniparser_set(dic, QUOTES_INI_SEC, NULL);
1350    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set " QUOTES_INI_SEC
1351                                         " in: " TMP_INI_PATH);
1352
1353    /* test dictionary */
1354    iniparser_set(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR0, QUOTES_INI_VAL0);
1355    /* iniparser_set() supports quotes in values */
1356    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR0, NULL);
1357    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1358    ini = fopen(TMP_INI_PATH, "w+");
1359    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1360
1361    iniparser_dump_ini(dic, ini);
1362    fclose(ini);
1363    ini = NULL;
1364    dictionary_del(dic);
1365    /* check if section has been written as expected */
1366    dic = iniparser_load(TMP_INI_PATH);
1367    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1368
1369    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR0, NULL);
1370    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL0, str);
1371    dictionary_del(dic);
1372    dic = NULL;
1373    ret = remove(TMP_INI_PATH);
1374    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1375
1376    /*
1377     * test semicolon comment
1378     */
1379    create_empty_ini_file(TMP_INI_PATH);
1380    dic = iniparser_load(TMP_INI_PATH);
1381    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1382
1383    ret = iniparser_set(dic, QUOTES_INI_SEC, NULL);
1384    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set " QUOTES_INI_SEC
1385                                         " in: " TMP_INI_PATH);
1386
1387    /* test dictionary */
1388    iniparser_set(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR1, QUOTES_INI_VAL1);
1389    /* iniparser_set() supports ; in values */
1390    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR1, NULL);
1391    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL1, str);
1392    ini = fopen(TMP_INI_PATH, "w+");
1393    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1394
1395    iniparser_dump_ini(dic, ini);
1396    fclose(ini);
1397    ini = NULL;
1398    dictionary_del(dic);
1399    /* check if section has been written as expected */
1400    dic = iniparser_load(TMP_INI_PATH);
1401    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1402
1403    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR1, NULL);
1404    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL1, str);
1405    dictionary_del(dic);
1406    dic = NULL;
1407    ret = remove(TMP_INI_PATH);
1408    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1409
1410    /*
1411     * test hash comment
1412     */
1413    create_empty_ini_file(TMP_INI_PATH);
1414    dic = iniparser_load(TMP_INI_PATH);
1415    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1416
1417    ret = iniparser_set(dic, QUOTES_INI_SEC, NULL);
1418    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot set " QUOTES_INI_SEC
1419                                         " in: " TMP_INI_PATH);
1420
1421    /* test dictionary */
1422    iniparser_set(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR2, QUOTES_INI_VAL2);
1423    /* iniparser_set() supports # in values */
1424    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR2, NULL);
1425    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL2, str);
1426    ini = fopen(TMP_INI_PATH, "w+");
1427    TEST_ASSERT_NOT_NULL_MESSAGE(ini, "cannot open " TMP_INI_PATH);
1428
1429    iniparser_dump_ini(dic, ini);
1430    fclose(ini);
1431    ini = NULL;
1432    dictionary_del(dic);
1433    /* check if section has been written as expected */
1434    dic = iniparser_load(TMP_INI_PATH);
1435    TEST_ASSERT_NOT_NULL_MESSAGE(dic, "cannot load " TMP_INI_PATH);
1436
1437    str = iniparser_getstring(dic, QUOTES_INI_SEC ":" QUOTES_INI_ATTR2, NULL);
1438    TEST_ASSERT_EQUAL_STRING(QUOTES_INI_VAL2, str);
1439    dictionary_del(dic);
1440    dic = NULL;
1441    ret = remove(TMP_INI_PATH);
1442    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(0, ret, "cannot remove " TMP_INI_PATH);
1443}