aboutsummaryrefslogtreecommitdiff
path: root/iniparser-4.1/test
diff options
context:
space:
mode:
Diffstat (limited to 'iniparser-4.1/test')
-rw-r--r--iniparser-4.1/test/CuTest.c348
-rw-r--r--iniparser-4.1/test/CuTest.h121
-rw-r--r--iniparser-4.1/test/CuTest_license.txt38
-rw-r--r--iniparser-4.1/test/Makefile35
-rwxr-xr-xiniparser-4.1/test/make-tests.sh56
-rw-r--r--iniparser-4.1/test/ressources/bad_ini/ends_well.ini6
-rw-r--r--iniparser-4.1/test/ressources/bad_ini/twisted-errors.ini9
-rw-r--r--iniparser-4.1/test/ressources/bad_ini/twisted-ofkey.ini66
-rw-r--r--iniparser-4.1/test/ressources/bad_ini/twisted-ofval.ini56
-rw-r--r--iniparser-4.1/test/ressources/good_ini/empty.ini0
-rw-r--r--iniparser-4.1/test/ressources/good_ini/spaced.ini16
-rw-r--r--iniparser-4.1/test/ressources/good_ini/spaced2.ini20
-rw-r--r--iniparser-4.1/test/ressources/good_ini/twisted.ini131
-rw-r--r--iniparser-4.1/test/test_dictionary.c237
-rw-r--r--iniparser-4.1/test/test_iniparser.c698
15 files changed, 1837 insertions, 0 deletions
diff --git a/iniparser-4.1/test/CuTest.c b/iniparser-4.1/test/CuTest.c
new file mode 100644
index 0000000..463f170
--- /dev/null
+++ b/iniparser-4.1/test/CuTest.c
@@ -0,0 +1,348 @@
+#include <assert.h>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "CuTest.h"
+
+/*-------------------------------------------------------------------------*
+ * CuStr
+ *-------------------------------------------------------------------------*/
+
+char* CuStrAlloc(int size)
+{
+ char* newStr = (char*) malloc( sizeof(char) * (size) );
+ return newStr;
+}
+
+char* CuStrCopy(const char* old)
+{
+ int len = strlen(old);
+ char* newStr = CuStrAlloc(len + 1);
+ strcpy(newStr, old);
+ return newStr;
+}
+
+/*-------------------------------------------------------------------------*
+ * CuString
+ *-------------------------------------------------------------------------*/
+
+void CuStringInit(CuString* str)
+{
+ str->length = 0;
+ str->size = STRING_MAX;
+ str->buffer = (char*) malloc(sizeof(char) * str->size);
+ str->buffer[0] = '\0';
+}
+
+CuString* CuStringNew(void)
+{
+ CuString* str = (CuString*) malloc(sizeof(CuString));
+ str->length = 0;
+ str->size = STRING_MAX;
+ str->buffer = (char*) malloc(sizeof(char) * str->size);
+ str->buffer[0] = '\0';
+ return str;
+}
+
+void CuStringDelete(CuString *str)
+{
+ if (!str) return;
+ free(str->buffer);
+ free(str);
+}
+
+void CuStringResize(CuString* str, int newSize)
+{
+ str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize);
+ str->size = newSize;
+}
+
+void CuStringAppend(CuString* str, const char* text)
+{
+ int length;
+
+ if (text == NULL) {
+ text = "NULL";
+ }
+
+ length = strlen(text);
+ if (str->length + length + 1 >= str->size)
+ CuStringResize(str, str->length + length + 1 + STRING_INC);
+ str->length += length;
+ strcat(str->buffer, text);
+}
+
+void CuStringAppendChar(CuString* str, char ch)
+{
+ char text[2];
+ text[0] = ch;
+ text[1] = '\0';
+ CuStringAppend(str, text);
+}
+
+void CuStringAppendFormat(CuString* str, const char* format, ...)
+{
+ va_list argp;
+ char buf[HUGE_STRING_LEN];
+ va_start(argp, format);
+ vsprintf(buf, format, argp);
+ va_end(argp);
+ CuStringAppend(str, buf);
+}
+
+void CuStringInsert(CuString* str, const char* text, int pos)
+{
+ int length = strlen(text);
+ if (pos > str->length)
+ pos = str->length;
+ if (str->length + length + 1 >= str->size)
+ CuStringResize(str, str->length + length + 1 + STRING_INC);
+ memmove(str->buffer + pos + length, str->buffer + pos, (str->length - pos) + 1);
+ str->length += length;
+ memcpy(str->buffer + pos, text, length);
+}
+
+/*-------------------------------------------------------------------------*
+ * CuTest
+ *-------------------------------------------------------------------------*/
+
+void CuTestInit(CuTest* t, const char* name, TestFunction function)
+{
+ t->name = CuStrCopy(name);
+ t->failed = 0;
+ t->ran = 0;
+ t->message = NULL;
+ t->function = function;
+ t->jumpBuf = NULL;
+}
+
+CuTest* CuTestNew(const char* name, TestFunction function)
+{
+ CuTest* tc = CU_ALLOC(CuTest);
+ CuTestInit(tc, name, function);
+ return tc;
+}
+
+void CuTestDelete(CuTest *t)
+{
+ if (!t) return;
+ free(t->name);
+ free(t);
+}
+
+void CuTestRun(CuTest* tc)
+{
+ jmp_buf buf;
+ tc->jumpBuf = &buf;
+ if (setjmp(buf) == 0)
+ {
+ tc->ran = 1;
+ (tc->function)(tc);
+ }
+ tc->jumpBuf = 0;
+}
+
+static void CuFailInternal(CuTest* tc, const char* file, int line, CuString* string)
+{
+ char buf[HUGE_STRING_LEN];
+
+ sprintf(buf, "%s:%d: ", file, line);
+ CuStringInsert(string, buf, 0);
+
+ tc->failed = 1;
+ tc->message = string->buffer;
+ if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0);
+}
+
+void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message)
+{
+ CuString string;
+
+ CuStringInit(&string);
+ if (message2 != NULL)
+ {
+ CuStringAppend(&string, message2);
+ CuStringAppend(&string, ": ");
+ }
+ CuStringAppend(&string, message);
+ CuFailInternal(tc, file, line, &string);
+}
+
+void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition)
+{
+ if (condition) return;
+ CuFail_Line(tc, file, line, NULL, message);
+}
+
+void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
+ const char* expected, const char* actual)
+{
+ CuString string;
+ if ((expected == NULL && actual == NULL) ||
+ (expected != NULL && actual != NULL &&
+ strcmp(expected, actual) == 0))
+ {
+ return;
+ }
+
+ CuStringInit(&string);
+ if (message != NULL)
+ {
+ CuStringAppend(&string, message);
+ CuStringAppend(&string, ": ");
+ }
+ CuStringAppend(&string, "expected <");
+ CuStringAppend(&string, expected);
+ CuStringAppend(&string, "> but was <");
+ CuStringAppend(&string, actual);
+ CuStringAppend(&string, ">");
+ CuFailInternal(tc, file, line, &string);
+}
+
+void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
+ int expected, int actual)
+{
+ char buf[STRING_MAX];
+ if (expected == actual) return;
+ sprintf(buf, "expected <%d> but was <%d>", expected, actual);
+ CuFail_Line(tc, file, line, message, buf);
+}
+
+void CuAssertLongIntEquals_LineMsg(CuTest *tc, const char *file, int line, const char *message,
+ long int expected, long int actual)
+{
+ char buf[STRING_MAX];
+ if (expected == actual) return;
+ sprintf(buf, "expected <%ld> but was <%ld>", expected, actual);
+ CuFail_Line(tc, file, line, message, buf);
+}
+
+void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
+ double expected, double actual, double delta)
+{
+ char buf[STRING_MAX];
+ if (fabs(expected - actual) <= delta) return;
+ sprintf(buf, "expected <%f> but was <%f>", expected, actual);
+
+ CuFail_Line(tc, file, line, message, buf);
+}
+
+void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
+ const void* expected, const void* actual)
+{
+ char buf[STRING_MAX];
+ if (expected == actual) return;
+ sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual);
+ CuFail_Line(tc, file, line, message, buf);
+}
+
+
+/*-------------------------------------------------------------------------*
+ * CuSuite
+ *-------------------------------------------------------------------------*/
+
+void CuSuiteInit(CuSuite* testSuite)
+{
+ testSuite->count = 0;
+ testSuite->failCount = 0;
+ memset(testSuite->list, 0, sizeof(testSuite->list));
+}
+
+CuSuite* CuSuiteNew(void)
+{
+ CuSuite* testSuite = CU_ALLOC(CuSuite);
+ CuSuiteInit(testSuite);
+ return testSuite;
+}
+
+void CuSuiteDelete(CuSuite *testSuite)
+{
+ unsigned int n;
+ for (n=0; n < MAX_TEST_CASES; n++)
+ {
+ if (testSuite->list[n])
+ {
+ CuTestDelete(testSuite->list[n]);
+ }
+ }
+ free(testSuite);
+
+}
+
+void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase)
+{
+ assert(testSuite->count < MAX_TEST_CASES);
+ testSuite->list[testSuite->count] = testCase;
+ testSuite->count++;
+}
+
+void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2)
+{
+ int i;
+ for (i = 0 ; i < testSuite2->count ; ++i)
+ {
+ CuTest* testCase = testSuite2->list[i];
+ CuSuiteAdd(testSuite, testCase);
+ }
+}
+
+void CuSuiteRun(CuSuite* testSuite)
+{
+ int i;
+ for (i = 0 ; i < testSuite->count ; ++i)
+ {
+ CuTest* testCase = testSuite->list[i];
+ CuTestRun(testCase);
+ if (testCase->failed) { testSuite->failCount += 1; }
+ }
+}
+
+void CuSuiteSummary(CuSuite* testSuite, CuString* summary)
+{
+ int i;
+ for (i = 0 ; i < testSuite->count ; ++i)
+ {
+ CuTest* testCase = testSuite->list[i];
+ CuStringAppend(summary, testCase->failed ? "F" : ".");
+ }
+ CuStringAppend(summary, "\n\n");
+}
+
+void CuSuiteDetails(CuSuite* testSuite, CuString* details)
+{
+ int i;
+ int failCount = 0;
+
+ if (testSuite->failCount == 0)
+ {
+ int passCount = testSuite->count - testSuite->failCount;
+ const char* testWord = passCount == 1 ? "test" : "tests";
+ CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord);
+ }
+ else
+ {
+ if (testSuite->failCount == 1)
+ CuStringAppend(details, "There was 1 failure:\n");
+ else
+ CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount);
+
+ for (i = 0 ; i < testSuite->count ; ++i)
+ {
+ CuTest* testCase = testSuite->list[i];
+ if (testCase->failed)
+ {
+ failCount++;
+ CuStringAppendFormat(details, "%d) %s: %s\n",
+ failCount, testCase->name, testCase->message);
+ }
+ }
+ CuStringAppend(details, "\n!!!FAILURES!!!\n");
+
+ CuStringAppendFormat(details, "Runs: %d ", testSuite->count);
+ CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount);
+ CuStringAppendFormat(details, "Fails: %d\n", testSuite->failCount);
+ }
+}
diff --git a/iniparser-4.1/test/CuTest.h b/iniparser-4.1/test/CuTest.h
new file mode 100644
index 0000000..0f58592
--- /dev/null
+++ b/iniparser-4.1/test/CuTest.h
@@ -0,0 +1,121 @@
+#ifndef CU_TEST_H
+#define CU_TEST_H
+
+#include <setjmp.h>
+#include <stdarg.h>
+
+#define CUTEST_VERSION "CuTest 1.5"
+
+/* CuString */
+
+char* CuStrAlloc(int size);
+char* CuStrCopy(const char* old);
+
+#define CU_ALLOC(TYPE) ((TYPE*) malloc(sizeof(TYPE)))
+
+#define HUGE_STRING_LEN 8192
+#define STRING_MAX 256
+#define STRING_INC 256
+
+typedef struct
+{
+ int length;
+ int size;
+ char* buffer;
+} CuString;
+
+void CuStringInit(CuString* str);
+CuString* CuStringNew(void);
+void CuStringRead(CuString* str, const char* path);
+void CuStringAppend(CuString* str, const char* text);
+void CuStringAppendChar(CuString* str, char ch);
+void CuStringAppendFormat(CuString* str, const char* format, ...);
+void CuStringInsert(CuString* str, const char* text, int pos);
+void CuStringResize(CuString* str, int newSize);
+void CuStringDelete(CuString* str);
+
+/* CuTest */
+
+typedef struct CuTest CuTest;
+
+typedef void (*TestFunction)(CuTest *);
+
+struct CuTest
+{
+ char* name;
+ TestFunction function;
+ int failed;
+ int ran;
+ const char* message;
+ jmp_buf *jumpBuf;
+};
+
+void CuTestInit(CuTest* t, const char* name, TestFunction function);
+CuTest* CuTestNew(const char* name, TestFunction function);
+void CuTestRun(CuTest* tc);
+void CuTestDelete(CuTest *t);
+
+/* Internal versions of assert functions -- use the public versions */
+void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message);
+void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition);
+void CuAssertStrEquals_LineMsg(CuTest* tc,
+ const char* file, int line, const char* message,
+ const char* expected, const char* actual);
+void CuAssertIntEquals_LineMsg(CuTest* tc,
+ const char* file, int line, const char* message,
+ int expected, int actual);
+void CuAssertLongIntEquals_LineMsg(CuTest *tc,
+ const char *file, int line, const char *message,
+ long int expected, long int actual);
+void CuAssertDblEquals_LineMsg(CuTest* tc,
+ const char* file, int line, const char* message,
+ double expected, double actual, double delta);
+void CuAssertPtrEquals_LineMsg(CuTest* tc,
+ const char* file, int line, const char* message,
+ const void* expected, const void* actual);
+
+/* public assert functions */
+
+#define CuFail(tc, ms) CuFail_Line( (tc), __FILE__, __LINE__, NULL, (ms))
+#define CuAssert(tc, ms, cond) CuAssert_Line((tc), __FILE__, __LINE__, (ms), (cond))
+#define CuAssertTrue(tc, cond) CuAssert_Line((tc), __FILE__, __LINE__, "assert failed", (cond))
+
+#define CuAssertStrEquals(tc,ex,ac) CuAssertStrEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac))
+#define CuAssertStrEquals_Msg(tc,ms,ex,ac) CuAssertStrEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac))
+#define CuAssertIntEquals(tc,ex,ac) CuAssertIntEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac))
+#define CuAssertIntEquals_Msg(tc,ms,ex,ac) CuAssertIntEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac))
+#define CuAssertLongIntEquals(tc,ex,ac) CuAssertLongIntEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac))
+#define CuAssertLongIntEquals_Msg(tc,ms,ex,ac) CuAssertLongIntEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac))
+#define CuAssertDblEquals(tc,ex,ac,dl) CuAssertDblEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac),(dl))
+#define CuAssertDblEquals_Msg(tc,ms,ex,ac,dl) CuAssertDblEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac),(dl))
+#define CuAssertPtrEquals(tc,ex,ac) CuAssertPtrEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac))
+#define CuAssertPtrEquals_Msg(tc,ms,ex,ac) CuAssertPtrEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac))
+
+#define CuAssertPtrNotNull(tc,p) CuAssert_Line((tc),__FILE__,__LINE__,"null pointer unexpected",(p != NULL))
+#define CuAssertPtrNotNullMsg(tc,msg,p) CuAssert_Line((tc),__FILE__,__LINE__,(msg),(p != NULL))
+
+/* CuSuite */
+
+#define MAX_TEST_CASES 1024
+
+#define SUITE_ADD_TEST(SUITE,TEST) CuSuiteAdd(SUITE, CuTestNew(#TEST, TEST))
+
+typedef struct
+{
+ int count;
+ CuTest* list[MAX_TEST_CASES];
+ int failCount;
+
+} CuSuite;
+
+
+void CuSuiteInit(CuSuite* testSuite);
+CuSuite* CuSuiteNew(void);
+void CuSuiteDelete(CuSuite *testSuite);
+void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase);
+void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2);
+void CuSuiteRun(CuSuite* testSuite);
+void CuSuiteSummary(CuSuite* testSuite, CuString* summary);
+void CuSuiteDetails(CuSuite* testSuite, CuString* details);
+
+#endif /* CU_TEST_H */
diff --git a/iniparser-4.1/test/CuTest_license.txt b/iniparser-4.1/test/CuTest_license.txt
new file mode 100644
index 0000000..5f053ba
--- /dev/null
+++ b/iniparser-4.1/test/CuTest_license.txt
@@ -0,0 +1,38 @@
+NOTE
+
+The license is based on the zlib/libpng license. For more details see
+http://www.opensource.org/licenses/zlib-license.html. The intent of the
+license is to:
+
+- keep the license as simple as possible
+- encourage the use of CuTest in both free and commercial applications
+ and libraries
+- keep the source code together
+- give credit to the CuTest contributors for their work
+
+If you ship CuTest in source form with your source distribution, the
+following license document must be included with it in unaltered form.
+If you find CuTest useful we would like to hear about it.
+
+LICENSE
+
+Copyright (c) 2003 Asim Jalis
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software in
+a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not
+be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
diff --git a/iniparser-4.1/test/Makefile b/iniparser-4.1/test/Makefile
new file mode 100644
index 0000000..15a8d26
--- /dev/null
+++ b/iniparser-4.1/test/Makefile
@@ -0,0 +1,35 @@
+CC ?= gcc
+
+ifndef V
+QUIET_CC = @echo "CC $@";
+QUIET_MAKE_TESTS = @echo "GN Alltests.c";
+endif
+
+DEPS = $(shell ls ../src/*.[ch])
+
+SRC = $(shell ls *.c | sed 's/AllTests.c//')
+OBJ = $(SRC:.c=.o)
+
+INCLUDE = -I../src
+CFLAGS += -pipe -ansi -pedantic -Wall -Wextra -g
+LDFLAGS +=
+
+all: check
+
+check: testrun
+ @./testrun
+
+testrun: AllTests.o $(OBJ)
+ $(QUIET_CC)$(CC) -o $@ AllTests.o $(OBJ) $(LDFLAGS)
+
+AllTests.o: $(OBJ)
+ $(QUIET_MAKE_TESTS)./make-tests.sh > AllTests.c
+ $(QUIET_CC)$(CC) -c -o AllTests.o AllTests.c $(CFLAGS) $(INCLUDE)
+
+%.o: %.c $(DEPS)
+ $(QUIET_CC)$(CC) -c -o $@ $< $(CFLAGS) $(INCLUDE)
+
+clean veryclean:
+ rm -rf AllTests.c
+ rm -rf $(OBJ) AllTests.o
+ rm -rf testrun
diff --git a/iniparser-4.1/test/make-tests.sh b/iniparser-4.1/test/make-tests.sh
new file mode 100755
index 0000000..f2a3f2a
--- /dev/null
+++ b/iniparser-4.1/test/make-tests.sh
@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Auto generate single AllTests file for CuTest.
+# Searches through all *.c files in the current directory.
+# Prints to stdout.
+# Author: Asim Jalis
+# Date: 01/08/2003
+
+if test $# -eq 0 ; then FILES=*.c ; else FILES=$* ; fi
+
+echo '
+
+/* This is auto-generated code. Edit at your own peril. */
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "CuTest.h"
+
+'
+
+cat $FILES | grep '^void Test' |
+ sed -e 's/(.*$//' \
+ -e 's/$/(CuTest*);/' \
+ -e 's/^/extern /'
+
+echo \
+'
+
+void RunAllTests(void)
+{
+ CuString *output = CuStringNew();
+ CuSuite* suite = CuSuiteNew();
+
+'
+cat $FILES | grep '^void Test' |
+ sed -e 's/^void //' \
+ -e 's/(.*$//' \
+ -e 's/^/ SUITE_ADD_TEST(suite, /' \
+ -e 's/$/);/'
+
+echo \
+'
+ CuSuiteRun(suite);
+ CuSuiteSummary(suite, output);
+ CuSuiteDetails(suite, output);
+ printf("%s\n", output->buffer);
+ CuStringDelete(output);
+ CuSuiteDelete(suite);
+}
+
+int main(void)
+{
+ RunAllTests();
+ return 0;
+}
+'
diff --git a/iniparser-4.1/test/ressources/bad_ini/ends_well.ini b/iniparser-4.1/test/ressources/bad_ini/ends_well.ini
new file mode 100644
index 0000000..3f920c7
--- /dev/null
+++ b/iniparser-4.1/test/ressources/bad_ini/ends_well.ini
@@ -0,0 +1,6 @@
+#
+# This dict contains an error but ends up with a correct entry
+#
+[section]
+error is here
+a = b
diff --git a/iniparser-4.1/test/ressources/bad_ini/twisted-errors.ini b/iniparser-4.1/test/ressources/bad_ini/twisted-errors.ini
new file mode 100644
index 0000000..4dc3bbe
--- /dev/null
+++ b/iniparser-4.1/test/ressources/bad_ini/twisted-errors.ini
@@ -0,0 +1,9 @@
+#
+# All of these should trigger syntax errors
+#
+[section]
+hello
+world
+hello \
+world
+a + b ;
diff --git a/iniparser-4.1/test/ressources/bad_ini/twisted-ofkey.ini b/iniparser-4.1/test/ressources/bad_ini/twisted-ofkey.ini
new file mode 100644
index 0000000..4f2e72e
--- /dev/null
+++ b/iniparser-4.1/test/ressources/bad_ini/twisted-ofkey.ini
@@ -0,0 +1,66 @@
+# Stress testing buffers for overflows
+[long]
+# Shitload key size
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=1
+
diff --git a/iniparser-4.1/test/ressources/bad_ini/twisted-ofval.ini b/iniparser-4.1/test/ressources/bad_ini/twisted-ofval.ini
new file mode 100644
index 0000000..2a3cedf
--- /dev/null
+++ b/iniparser-4.1/test/ressources/bad_ini/twisted-ofval.ini
@@ -0,0 +1,56 @@
+# Shitload data size
+[long]
+a=\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\
+1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890;
+
diff --git a/iniparser-4.1/test/ressources/good_ini/empty.ini b/iniparser-4.1/test/ressources/good_ini/empty.ini
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/iniparser-4.1/test/ressources/good_ini/empty.ini
diff --git a/iniparser-4.1/test/ressources/good_ini/spaced.ini b/iniparser-4.1/test/ressources/good_ini/spaced.ini
new file mode 100644
index 0000000..8e78e3b
--- /dev/null
+++ b/iniparser-4.1/test/ressources/good_ini/spaced.ini
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/iniparser-4.1/test/ressources/good_ini/spaced2.ini b/iniparser-4.1/test/ressources/good_ini/spaced2.ini
new file mode 100644
index 0000000..2acbd74
--- /dev/null
+++ b/iniparser-4.1/test/ressources/good_ini/spaced2.ini
@@ -0,0 +1,20 @@
+
+# spaced2.ini
+
+[blanks]
+
+
+
+
+
+
+
+
+
+
+
+a=1
+b=1;
+c=1; comment
+d=1# comment
+ \ No newline at end of file
diff --git a/iniparser-4.1/test/ressources/good_ini/twisted.ini b/iniparser-4.1/test/ressources/good_ini/twisted.ini
new file mode 100644
index 0000000..86e549f
--- /dev/null
+++ b/iniparser-4.1/test/ressources/good_ini/twisted.ini
@@ -0,0 +1,131 @@
+#
+# Twisted.ini
+# This file is meant for regression tests
+
+# Different blank settings around the equal sign
+[blanks]
+a=1
+b=1;
+c=1; comment
+d=1# comment
+
+e =1
+f =1;
+g =1; comment
+h =1# comment
+
+i= 1
+j= 1;
+k= 1; comment
+l= 1# comment
+
+m = 1
+n = 1;
+o = 1; comment
+p = 1# comment
+
+q=1 ;
+r=1 ; comment
+s=1 ;comment
+t=1 #comment
+
+# Empty values
+[empty]
+a = ''
+b = ""
+
+c = '' ;
+d = "" ;
+
+e = '' ; comment
+f = "" ; comment
+
+g =
+h = ;
+i = ; comment
+j = # comment
+
+k=
+l=;
+m=;comment
+n=#
+
+# Peculiar values
+[peculiar]
+a=';';
+b='#'#
+c=';';comment
+d='#'#comment
+e=\;
+f=\#
+g=\;comment
+h=\#comment
+i=;;
+j=##
+k=;;;;;;;;;;
+l=##########
+
+# Quotes
+[quotes]
+s1='
+s2=''
+s3='''
+s4=''''
+
+d1="
+d2=""
+d3="""
+d4=""""
+
+m1='"'
+m2="'"
+
+h1=hello'world
+h2='hello'world
+h3='hello'world'
+
+h4=hello"world
+h5="hello"world
+h6="hello"world"
+
+# Section names
+[a]
+[ b]
+[c ]
+[ d ]
+[ begin end ]
+[ open[ ]
+
+# Multi-line inputs
+[multi]
+a = begin\
+end
+b = begin \
+end
+c = begin \
+ end
+d = 1\
+2\
+3\
+4
+e = 1 \
+ 2 \
+ 3 \
+ 4
+f = 1 ; \
+hidden = because of the preceding backslash multi-lining the comment ;
+visible = 1
+g = 1 #\
+and now this comment is hidden too \
+and this one too
+h = 1
+multi \
+line \
+key = 1
+multi \
+line \
+key = \
+multi \
+line \
+value ;
+# end of file
diff --git a/iniparser-4.1/test/test_dictionary.c b/iniparser-4.1/test/test_dictionary.c
new file mode 100644
index 0000000..f89f1c1
--- /dev/null
+++ b/iniparser-4.1/test/test_dictionary.c
@@ -0,0 +1,237 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "CuTest.h"
+
+/* We need to directly insert the .c file in order to test the */
+/* static functions as well */
+#include "dictionary.c"
+
+void Test_xstrdup(CuTest *tc)
+{
+ size_t i;
+ char *dup_str;
+ const char *strings[] = {
+ "",
+ "test",
+ " "
+ };
+ char *string_very_long;
+
+ /* NULL test */
+ CuAssertPtrEquals(tc, NULL, xstrdup(NULL));
+
+ for (i = 0 ; i < sizeof(strings) / sizeof(char *) ; ++i) {
+ dup_str = xstrdup(strings[i]);
+ CuAssertStrEquals(tc, strings[i], dup_str);
+ free(dup_str);
+ }
+
+ /* test a overflowing string */
+ string_very_long = (char*) malloc(10 * 1024);
+ memset(string_very_long, '#', 10 * 1024);
+ string_very_long[10 * 1024 - 1] = '\0';
+ dup_str = xstrdup(string_very_long);
+ CuAssertStrEquals(tc, string_very_long, dup_str);
+
+ free(string_very_long);
+ free(dup_str);
+}
+
+void Test_dictionary_grow(CuTest *tc)
+{
+ unsigned i;
+ dictionary *dic;
+
+ dic = dictionary_new(DICTMINSZ);
+ CuAssertPtrNotNull(tc, dic);
+ CuAssertIntEquals(tc, 0, dic->n);
+ CuAssertIntEquals(tc, DICTMINSZ, dic->size);
+
+ for (i = 1 ; i < 10 ; ++i) {
+ CuAssertIntEquals(tc, 0, dictionary_grow(dic));
+ CuAssertIntEquals(tc, 0, dic->n);
+ CuAssertIntEquals(tc, (1 << i) * DICTMINSZ, dic->size);
+ }
+}
+
+void Test_dictionary_hash(CuTest *tc)
+{
+ /* NULL test */
+ CuAssertIntEquals(tc, 0, dictionary_hash(NULL));
+}
+
+void Test_dictionary_growing(CuTest *tc)
+{
+ int i, j;
+ char sec_name[32];
+ char key_name[64];
+ dictionary *dic;
+
+ dic = dictionary_new(DICTMINSZ);
+ CuAssertPtrNotNull(tc, dic);
+ CuAssertIntEquals(tc, 0, dic->n);
+
+ /* Makes the dictionary grow */
+ for (i = 1 ; i < 101; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ CuAssertIntEquals(tc, 0, dictionary_set(dic, sec_name, ""));
+ for (j = 1 ; j < 11; ++j) {
+ sprintf(key_name, "%s:key%d", sec_name, j);
+ CuAssertIntEquals(tc, 0, dictionary_set(dic, key_name, "dummy_value"));
+ CuAssertIntEquals(tc, i + (i - 1) * 10 + j, dic->n);
+ }
+ }
+
+ /* Shrink the dictionary */
+ for (i = 100 ; i > 0; --i) {
+ sprintf(sec_name, "sec%d", i);
+ for (j = 10 ; j > 0; --j) {
+ sprintf(key_name, "%s:key%d", sec_name, j);
+ dictionary_unset(dic, key_name);
+ }
+ dictionary_unset(dic, sec_name);
+ CuAssertIntEquals(tc, (i - 1) * (11), dic->n);
+ }
+
+ dictionary_del(dic);
+}
+
+static char *get_dump(dictionary *d)
+{
+ FILE *fd;
+ char *dump_buff;
+ int dump_size;
+
+ /* Dump the dictionary in temporary file */
+ fd = tmpfile();
+ if (fd == NULL)
+ return NULL;
+ dictionary_dump(d, fd);
+
+ /* Retrieve the dump file */
+ dump_size = ftell(fd);
+ if (dump_size == -1) {
+ fclose(fd);
+ return NULL;
+ }
+ rewind(fd);
+
+ dump_buff = (char*) calloc(1, dump_size + 1);
+ if (dump_buff == NULL) {
+ fclose(fd);
+ return NULL;
+ }
+ if (fread(dump_buff, 1, dump_size, fd) != (size_t)dump_size) {
+ fclose(fd);
+ return NULL;
+ }
+
+ fclose(fd);
+ return dump_buff;
+}
+
+void Test_dictionary_unset(CuTest *tc)
+{
+ int i, j;
+ char sec_name[32];
+ char key_name[64];
+ dictionary *dic1;
+ dictionary *dic2;
+ char *dic1_dump;
+ char *dic2_dump;
+
+ /* try dummy unsets */
+ dictionary_unset(NULL, NULL);
+ dictionary_unset(NULL, key_name);
+
+ /* Generate two similar dictionaries */
+ dic1 = dictionary_new(DICTMINSZ);
+ CuAssertPtrNotNull(tc, dic1);
+ for (i = 1 ; i < 10; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ dictionary_set(dic1, sec_name, "");
+ for (j = 1 ; j < 10; ++j) {
+ sprintf(key_name, "%s:key%d", sec_name, j);
+ dictionary_set(dic1, key_name, "dummy_value");
+ }
+ }
+ dic2 = dictionary_new(DICTMINSZ);
+ CuAssertPtrNotNull(tc, dic2);
+ for (i = 1 ; i < 10; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ dictionary_set(dic2, sec_name, "");
+ for (j = 1 ; j < 10; ++j) {
+ sprintf(key_name, "%s:key%d", sec_name, j);
+ dictionary_set(dic2, key_name, "dummy_value");
+ }
+ }
+
+ /* Make sure the dictionaries are the same */
+ dic1_dump = get_dump(dic1);
+ dic2_dump = get_dump(dic2);
+ CuAssertStrEquals(tc, dic1_dump, dic2_dump);
+ free(dic1_dump);
+ free(dic2_dump);
+
+ /* Those tests should not change the dictionary */
+ dictionary_unset(dic2, NULL);
+ dictionary_unset(dic2, "bad_key");
+
+ /* dic1 and dic2 must still be the same */
+ dic1_dump = get_dump(dic1);
+ dic2_dump = get_dump(dic2);
+ CuAssertStrEquals(tc, dic1_dump, dic2_dump);
+ free(dic1_dump);
+ free(dic2_dump);
+}
+
+void Test_dictionary_dump(CuTest *tc)
+{
+ int i, j;
+ char sec_name[32];
+ char key_name[64];
+ dictionary *dic;
+ char *dump_buff;
+ const char dump_real[] = "\
+ sec1\t[]\n\
+ sec1:key1\t[dummy_value]\n\
+ sec1:key2\t[dummy_value]\n\
+ sec1:key3\t[dummy_value]\n\
+ sec1:key4\t[dummy_value]\n\
+ sec2\t[]\n\
+ sec2:key1\t[dummy_value]\n\
+ sec2:key2\t[dummy_value]\n\
+ sec2:key3\t[dummy_value]\n\
+ sec2:key4\t[dummy_value]\n\
+";
+
+ dic = dictionary_new(DICTMINSZ);
+ CuAssertPtrNotNull(tc, dic);
+
+ /* Try dummy values */
+ dictionary_dump(NULL, NULL);
+ dictionary_dump(dic, NULL);
+
+ /* Try with empty dictionary first */
+ dump_buff = get_dump(dic);
+ CuAssertStrEquals(tc, "empty dictionary\n", dump_buff);
+ free(dump_buff);
+
+ /* Populate the dictionary */
+ for (i = 1 ; i < 3; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ dictionary_set(dic, sec_name, "");
+ for (j = 1 ; j < 5; ++j) {
+ sprintf(key_name, "%s:key%d", sec_name, j);
+ dictionary_set(dic, key_name, "dummy_value");
+ }
+ }
+
+ /* Check the dump file */
+ dump_buff = get_dump(dic);
+ CuAssertStrEquals(tc, dump_real, dump_buff);
+ free(dump_buff);
+
+ dictionary_del(dic);
+}
diff --git a/iniparser-4.1/test/test_iniparser.c b/iniparser-4.1/test/test_iniparser.c
new file mode 100644
index 0000000..c76529c
--- /dev/null
+++ b/iniparser-4.1/test/test_iniparser.c
@@ -0,0 +1,698 @@
+#include <stdio.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <stdarg.h>
+
+#include "CuTest.h"
+#include "dictionary.h"
+
+/* We need to directly insert the .c file in order to test the */
+/* static functions as well */
+#include "iniparser.c"
+
+#define GOOD_INI_PATH "ressources/good_ini"
+#define BAD_INI_PATH "ressources/bad_ini"
+
+
+/* Tool function to create and populate a generic non-empty dictionary */
+static dictionary * generate_dictionary(unsigned sections, unsigned entries_per_section)
+{
+ unsigned i, j ;
+ dictionary * dic;
+ char sec_name[32];
+ char key_name[64];
+ char key_value[32];
+
+ dic = dictionary_new(sections + sections * entries_per_section);
+ if (dic == NULL)
+ return NULL;
+
+ /* Insert the sections */
+ for (i = 0; i < sections; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ dictionary_set(dic, sec_name, "");
+ for (j = 0; j < entries_per_section; ++j) {
+ /* Populate the section with the entries */
+ sprintf(key_name, "%s:key%d", sec_name, j);
+ sprintf(key_value, "value-%d/%d", i, j);
+ dictionary_set(dic, key_name, key_value);
+ }
+ }
+
+ return dic;
+}
+
+void Test_iniparser_strlwc(CuTest *tc)
+{
+ char out_buffer[128];
+
+ /* NULL ptr as input */
+ CuAssertPtrEquals(tc, NULL, strlwc(NULL, NULL, 0));
+ CuAssertPtrEquals(tc, NULL, strlwc(NULL, out_buffer, sizeof (out_buffer)));
+ CuAssertPtrEquals(tc, NULL, strlwc("", NULL, sizeof (out_buffer)));
+ CuAssertPtrEquals(tc, NULL, strlwc("", out_buffer, 0));
+ CuAssertPtrEquals(tc, NULL, strlwc(NULL, NULL, 0));
+
+ /* empty string */
+ CuAssertStrEquals(tc, "", strlwc("", out_buffer, sizeof (out_buffer)));
+
+ CuAssertStrEquals(tc, " ", strlwc(" ", out_buffer, sizeof (out_buffer)));
+ CuAssertStrEquals(tc, "test", strlwc("test", out_buffer, sizeof (out_buffer)));
+ CuAssertStrEquals(tc, "test", strlwc("TEST", out_buffer, sizeof (out_buffer)));
+ CuAssertStrEquals(tc, "test", strlwc("TeSt", out_buffer, sizeof (out_buffer)));
+ CuAssertStrEquals(tc, "test test",
+ strlwc("TEST TEST", out_buffer, sizeof (out_buffer)));
+ CuAssertStrEquals(tc, "very long string !!!!!!!",
+ strlwc("very long string !!!!!!!", out_buffer, sizeof (out_buffer)));
+ CuAssertStrEquals(tc, "cutted string", strlwc("cutted string<---here", out_buffer, 14));
+
+ /* test using same buffer as input and output */
+ strcpy(out_buffer, "OVERWRITE ME !");
+ CuAssertPtrNotNull(tc, strlwc(out_buffer, out_buffer, sizeof(out_buffer)));
+ CuAssertStrEquals(tc, "overwrite me !", out_buffer);
+}
+
+void Test_iniparser_strstrip(CuTest *tc)
+{
+ /* First element in the array is the expected stripping result */
+ const char *strings_empty[] = {
+ "",
+ " ",
+ "\n\n\n\n",
+ "\t\t\t\t",
+ "\n \t\n\t\n "
+ };
+ const char *strings_test[] = {
+ "test",
+ "test ",
+ "test ",
+ " test",
+ " test ",
+ "\ttest\t",
+ "\ttest\n"
+
+ };
+ const char *test_with_spaces = "I am a test with\tspaces.";
+ char stripped[ASCIILINESZ+1];
+ char error_msg[128];
+ unsigned i;
+
+ /* NULL ptr as input */
+ strstrip(NULL);
+
+ /* empty string */
+ for (i = 0 ; i < sizeof (strings_empty) / sizeof (char *) ; ++i) {
+ strcpy(stripped, strings_empty[i]);
+ strstrip(stripped);
+ sprintf(error_msg, "Bad stripping : strstrip(\"%s\") ==> \"%s\"",
+ strings_empty[i], stripped);
+ CuAssertStrEquals_Msg(tc, error_msg, stripped, strings_empty[0]);
+ }
+
+ /* test string */
+ for (i = 0 ; i < sizeof (strings_test) / sizeof (char *) ; ++i) {
+ strcpy(stripped, strings_test[i]);
+ strstrip(stripped);
+ sprintf(error_msg, "Bad stripping : strstrip(\"%s\") ==> \"%s\"",
+ strings_test[i], stripped);
+ CuAssertStrEquals_Msg(tc, error_msg, strings_test[0], stripped);
+ }
+ strcpy(stripped, ".");
+ strstrip(stripped);
+ CuAssertStrEquals(tc, ".", stripped);
+
+ /* string containing spaces */
+ strcpy(stripped, test_with_spaces);
+ strstrip(stripped);
+ CuAssertStrEquals(tc, test_with_spaces, stripped);
+}
+
+void Test_iniparser_getnsec(CuTest *tc)
+{
+ int i;
+ char sec_name[32];
+ dictionary *dic;
+
+ /* NULL test */
+ CuAssertIntEquals(tc, -1, iniparser_getnsec(NULL));
+
+ /* Empty dictionary */
+ dic = dictionary_new(10);
+ CuAssertIntEquals(tc, 0, iniparser_getnsec(dic));
+ dictionary_del(dic);
+
+ /* Regular dictionary */
+ dic = generate_dictionary(512, 0);
+ CuAssertIntEquals(tc, 512, iniparser_getnsec(dic));
+
+ /* Check after removing sections */
+ for (i = 1; i < 512; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ dictionary_unset(dic, sec_name);
+ CuAssertIntEquals(tc, 512 - i, iniparser_getnsec(dic));
+ }
+ dictionary_del(dic);
+
+ /* Mix sections and regular keys */
+ dic = generate_dictionary(10, 512);
+ CuAssertIntEquals(tc, 10, iniparser_getnsec(dic));
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getsecname(CuTest *tc)
+{
+ unsigned i;
+ char sec_name[32];
+ dictionary *dic;
+ /* NULL test */
+ CuAssertTrue(tc, iniparser_getsecname(NULL, 0) == NULL);
+
+ /* Empty dictionary */
+ dic = dictionary_new(10);
+ CuAssertPtrEquals(tc, NULL, iniparser_getsecname(dic, 0));
+ dictionary_del(dic);
+
+ /* Sections without entries dictionary */
+ dic = generate_dictionary(100, 0);
+ for (i = 0; i < 100; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ CuAssertStrEquals(tc, sec_name, iniparser_getsecname(dic, i));
+ }
+ dictionary_del(dic);
+
+ /* Generic dictionary */
+ dic = generate_dictionary(10, 100);
+ for (i = 0; i < 10; ++i) {
+ sprintf(sec_name, "sec%d", i);
+ CuAssertStrEquals(tc, sec_name, iniparser_getsecname(dic, i));
+ }
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getseckeys(CuTest *tc)
+{
+ unsigned i;
+ char key_name[64];
+ dictionary *dic;
+ int nkeys;
+ const char * keys[10]; /* At most 10 elements per section */
+ /* NULL test */
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, NULL, NULL));
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy", NULL));
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy", keys));
+
+ /* Empty dictionary */
+ dic = dictionary_new(10);
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL, keys));
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy", keys));
+ dictionary_del(dic);
+
+ /* Generic dictionary */
+
+ dic = generate_dictionary(100, 10);
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL, keys));
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy", keys));
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec0", NULL));
+ nkeys = iniparser_getsecnkeys(dic, "sec42");
+ CuAssertIntEquals(tc, nkeys, 10);
+ CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec42", keys));
+ for (i = 0; i < 10; ++i) {
+ sprintf(key_name, "sec42:key%d", i);
+ CuAssertStrEquals(tc, key_name, keys[i]);
+ }
+
+ /* Remove some keys to make the dictionary more real */
+ dictionary_unset(dic, "sec42");
+ dictionary_unset(dic, "sec99:key9");
+ dictionary_unset(dic, "sec0:key0");
+ dictionary_unset(dic, "sec0:key1");
+ dictionary_unset(dic, "sec0:key2");
+
+ CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec42", keys));
+ nkeys = iniparser_getsecnkeys(dic, "Sec99");
+ CuAssertIntEquals(tc, nkeys, 9);
+ CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "Sec99", keys));
+ for (i = 0; i < 9; ++i) {
+ sprintf(key_name, "sec99:key%d", i);
+ CuAssertStrEquals(tc, key_name, keys[i]);
+ }
+
+ nkeys = iniparser_getsecnkeys(dic, "sec0");
+ CuAssertIntEquals(tc, nkeys, 7);
+ CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec0", keys));
+ for (i = 0; i < 7; ++i) {
+ sprintf(key_name, "sec0:key%d", i + 3);
+ CuAssertStrEquals(tc, key_name, keys[i]);
+ }
+
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getstring(CuTest *tc)
+{
+ dictionary *dic;
+ /* NULL test */
+ CuAssertPtrEquals(tc, NULL, iniparser_getstring(NULL, NULL, NULL));
+ CuAssertPtrEquals(tc, NULL, iniparser_getstring(NULL, "dummy", NULL));
+
+ /* Check the def return element */
+ dic = dictionary_new(10);
+ CuAssertPtrEquals(tc, NULL, iniparser_getstring(dic, "dummy", NULL));
+ CuAssertStrEquals(tc, "def", iniparser_getstring(dic, NULL, "def"));
+ CuAssertStrEquals(tc, "def", iniparser_getstring(dic, "dummy", "def"));
+ dictionary_del(dic);
+
+ /* Generic dictionary */
+ dic = generate_dictionary(100, 10);
+ CuAssertStrEquals(tc, "value-0/0",
+ iniparser_getstring(dic, "sec0:key0", NULL));
+ CuAssertStrEquals(tc, "value-42/5",
+ iniparser_getstring(dic, "sec42:key5", NULL));
+ CuAssertStrEquals(tc, "value-99/9",
+ iniparser_getstring(dic, "sec99:key9", NULL));
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getint(CuTest *tc)
+{
+ unsigned i;
+ char key_name[64];
+ dictionary *dic;
+ const struct { int num; const char *value; } good_val[] = {
+ { 0, "0" },
+ { 1, "1" },
+ { -1, "-1" },
+ { 1000, "1000" },
+ { 077, "077" },
+ { -01000, "-01000" },
+ { 0xFFFF, "0xFFFF" },
+ { -0xFFFF, "-0xFFFF" },
+ { 0x4242, "0x4242" },
+ { 0, NULL} /* must be last */
+ };
+ const char *bad_val[] = {
+ "",
+ "notanumber",
+ "0x",
+ "k2000",
+ " ",
+ "0xG1"
+ };
+ /* NULL test */
+ CuAssertIntEquals(tc, -42, iniparser_getint(NULL, NULL, -42));
+ CuAssertIntEquals(tc, -42, iniparser_getint(NULL, "dummy", -42));
+
+ /* Check the def return element */
+ dic = dictionary_new(10);
+ CuAssertIntEquals(tc, 42, iniparser_getint(dic, "dummy", 42));
+ CuAssertIntEquals(tc, 0xFFFF, iniparser_getint(dic, NULL, 0xFFFF));
+ CuAssertIntEquals(tc, -0xFFFF, iniparser_getint(dic, "dummy", -0xFFFF));
+ dictionary_del(dic);
+
+ /* Generic dictionary */
+ dic = dictionary_new(10);
+ for (i = 0; good_val[i].value != NULL; ++i) {
+ sprintf(key_name, "int:value%d", i);
+ dictionary_set(dic, key_name, good_val[i].value);
+ }
+ for (i = 0; good_val[i].value != NULL; ++i) {
+ sprintf(key_name, "int:value%d", i);
+ CuAssertIntEquals(tc, good_val[i].num,
+ iniparser_getint(dic, key_name, 0));
+ }
+ dictionary_del(dic);
+
+ /* Test bad names */
+ dic = dictionary_new(10);
+ for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
+ sprintf(key_name, "int:bad%d", i);
+ dictionary_set(dic, key_name, bad_val[i]);
+ }
+ for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
+ sprintf(key_name, "int:bad%d", i);
+ CuAssertIntEquals(tc, 0,
+ iniparser_getint(dic, key_name, 0));
+ }
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getlongint(CuTest *tc)
+{
+ unsigned i;
+ char key_name[64];
+ dictionary *dic;
+ const struct { long int num; const char *value; } good_val[] = {
+ { 0, "0" },
+ { 1, "1" },
+ { -1, "-1" },
+ { 1000, "1000" },
+ { 077, "077" },
+ { -01000, "-01000" },
+ { 0x7FFFFFFFFFFFFFFF, "0x7FFFFFFFFFFFFFFF" },
+ { -0x7FFFFFFFFFFFFFFF, "-0x7FFFFFFFFFFFFFFF" },
+ { 0x4242, "0x4242" },
+ { 0, NULL} /* must be last */
+ };
+ const char *bad_val[] = {
+ "",
+ "notanumber",
+ "0x",
+ "k2000",
+ " ",
+ "0xG1"
+ };
+ /* NULL test */
+ CuAssertLongIntEquals(tc, -42, iniparser_getlongint(NULL, NULL, -42));
+ CuAssertLongIntEquals(tc, -42, iniparser_getlongint(NULL, "dummy", -42));
+
+ /* Check the def return element */
+ dic = dictionary_new(10);
+ CuAssertLongIntEquals(tc, 42, iniparser_getlongint(dic, "dummy", 42));
+ CuAssertLongIntEquals(tc, 0x7FFFFFFFFFFFFFFF, iniparser_getlongint(dic, NULL, 0x7FFFFFFFFFFFFFFF));
+ CuAssertLongIntEquals(tc, -0x7FFFFFFFFFFFFFFF, iniparser_getlongint(dic, "dummy", -0x7FFFFFFFFFFFFFFF));
+ dictionary_del(dic);
+
+ /* Generic dictionary */
+ dic = dictionary_new(10);
+ for (i = 0; good_val[i].value != NULL; ++i) {
+ sprintf(key_name, "longint:value%d", i);
+ dictionary_set(dic, key_name, good_val[i].value);
+ }
+ for (i = 0; good_val[i].value != NULL; ++i) {
+ sprintf(key_name, "longint:value%d", i);
+ CuAssertLongIntEquals(tc, good_val[i].num,
+ iniparser_getlongint(dic, key_name, 0));
+ }
+ dictionary_del(dic);
+
+ /* Test bad names */
+ dic = dictionary_new(10);
+ for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
+ sprintf(key_name, "longint:bad%d", i);
+ dictionary_set(dic, key_name, bad_val[i]);
+ }
+ for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
+ sprintf(key_name, "longint:bad%d", i);
+ CuAssertLongIntEquals(tc, 0,
+ iniparser_getlongint(dic, key_name, 0));
+ }
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getdouble(CuTest *tc)
+{
+ dictionary *dic;
+
+ /* NULL test */
+ CuAssertDblEquals(tc, -42, iniparser_getdouble(NULL, NULL, -42), 0);
+ CuAssertDblEquals(tc, 4.2, iniparser_getdouble(NULL, "dummy", 4.2), 0);
+
+ /* Check the def return element */
+ dic = dictionary_new(10);
+ CuAssertDblEquals(tc, 3.1415, iniparser_getdouble(dic, "dummy", 3.1415), 0);
+ CuAssertDblEquals(tc, 0xFFFFFFFF, iniparser_getdouble(dic, NULL, 0xFFFFFFFF), 0);
+ CuAssertDblEquals(tc, -0xFFFFFFFF, iniparser_getdouble(dic, "dummy", -0xFFFFFFFF), 0);
+
+ /* Insert some values */
+ dictionary_set(dic, "double", "");
+ dictionary_set(dic, "double:good0", "0");
+ dictionary_set(dic, "double:good1", "-0");
+ dictionary_set(dic, "double:good2", "1.0");
+ dictionary_set(dic, "double:good3", "3.1415");
+ dictionary_set(dic, "double:good4", "6.6655957");
+ dictionary_set(dic, "double:good5", "-123456789.123456789");
+
+ /* Add dummy stuff too */
+ dictionary_set(dic, "double:bad0", "foo");
+
+ /* Get back the values */
+ CuAssertDblEquals(tc, 0, iniparser_getdouble(dic, "double:good0", 0xFF), 0);
+ CuAssertDblEquals(tc, 0, iniparser_getdouble(dic, "double:good1", 0xFF), 0);
+ CuAssertDblEquals(tc, 1.0, iniparser_getdouble(dic, "double:good2", 0xFF), 0);
+ CuAssertDblEquals(tc, 3.1415, iniparser_getdouble(dic, "double:good3", 0xFF), 0);
+ CuAssertDblEquals(tc, 6.6655957, iniparser_getdouble(dic, "double:good4", 0xFF), 0);
+ CuAssertDblEquals(tc, -123456789.123456789,
+ iniparser_getdouble(dic, "double:good5", 0xFF), 0);
+
+ CuAssertDblEquals(tc, 0, iniparser_getdouble(dic, "double:bad0", 42.42), 0);
+
+ dictionary_del(dic);
+}
+
+void Test_iniparser_getboolean(CuTest *tc)
+{
+ unsigned i;
+ char key_name[64];
+
+ dictionary *dic;
+ const char *token_true[] = {
+ "1",
+ "true",
+ "t",
+ "TRUE",
+ "T",
+ "yes",
+ "y",
+ "YES"
+ "Y",
+ NULL
+ };
+ const char *token_false[] = {
+ "0",
+ "false",
+ "f",
+ "FALSE",
+ "F",
+ "no",
+ "n",
+ "NO",
+ "N",
+ NULL
+ };
+
+ /* NULL test */
+ CuAssertIntEquals(tc, 1, iniparser_getboolean(NULL, NULL, 1));
+ CuAssertIntEquals(tc, 1, iniparser_getboolean(NULL, "dummy", 1));
+
+ /* Check the def return element */
+ dic = dictionary_new(10);
+ CuAssertIntEquals(tc, 1, iniparser_getboolean(dic, "dummy", 1));
+ CuAssertIntEquals(tc, 0, iniparser_getboolean(dic, NULL, 0));
+ CuAssertIntEquals(tc, 1, iniparser_getboolean(dic, "dummy", 1));
+
+ for (i = 0; token_true[i] != NULL; ++i) {
+ sprintf(key_name, "bool:true%d", i);
+ iniparser_set(dic, key_name, token_true[i]);
+ }
+ for (i = 0; token_false[i] != NULL; ++i) {
+ sprintf(key_name, "bool:false%d", i);
+ iniparser_set(dic, key_name, token_false[i]);
+ }
+
+ for (i = 0; token_true[i] != NULL; ++i) {
+ sprintf(key_name, "bool:true%d", i);
+ CuAssertIntEquals(tc, 1, iniparser_getboolean(dic, key_name, 0));
+ }
+ for (i = 0; token_false[i] != NULL; ++i) {
+ sprintf(key_name, "bool:false%d", i);
+ CuAssertIntEquals(tc, 0, iniparser_getboolean(dic, key_name, 1));
+ }
+
+ /* Test bad boolean */
+ iniparser_set(dic, "bool:bad0", "");
+ iniparser_set(dic, "bool:bad1", "m'kay");
+ iniparser_set(dic, "bool:bad2", "42");
+ iniparser_set(dic, "bool:bad3", "_true");
+ CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad0", 0xFF));
+ CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad1", 0xFF));
+ CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad2", 0xFF));
+ CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad3", 0xFF));
+
+ dictionary_del(dic);
+}
+
+void Test_iniparser_line(CuTest *tc)
+{
+ char section [ASCIILINESZ+1] ;
+ char key [ASCIILINESZ+1] ;
+ char val [ASCIILINESZ+1] ;
+
+ /* Test empty line */
+ CuAssertIntEquals(tc, LINE_EMPTY, iniparser_line("", section, key, val));
+ CuAssertIntEquals(tc, LINE_EMPTY, iniparser_line(" ", section, key, val));
+ CuAssertIntEquals(tc, LINE_EMPTY, iniparser_line("\t", section, key, val));
+
+ /* Test valid syntax */
+ CuAssertIntEquals(tc, LINE_SECTION, iniparser_line("[s]", section, key, val));
+ CuAssertStrEquals(tc, "s", section);
+
+ CuAssertIntEquals(tc, LINE_SECTION, iniparser_line("[ section ]", section, key, val));
+ CuAssertStrEquals(tc, "section", section);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("k=1", section, key, val));
+ CuAssertStrEquals(tc, "k", key);
+ CuAssertStrEquals(tc, "1", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key = 0x42", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, "0x42", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key= value with spaces", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, "value with spaces", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("k =_!<>''", section, key, val));
+ CuAssertStrEquals(tc, "k", key);
+ CuAssertStrEquals(tc, "_!<>''", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("empty_value =", section, key, val));
+ CuAssertStrEquals(tc, "empty_value", key);
+ CuAssertStrEquals(tc, "", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("empty_value = \t\n", section, key, val));
+ CuAssertStrEquals(tc, "empty_value", key);
+ CuAssertStrEquals(tc, "", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key =\tval # comment", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, "val", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key \n\n = \n val", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, "val", val);
+
+ CuAssertIntEquals(tc, LINE_COMMENT, iniparser_line(";comment", section, key, val));
+ CuAssertIntEquals(tc, LINE_COMMENT, iniparser_line(" # comment", section, key, val));
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key = \" do_not_strip \"", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, " do_not_strip ", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key = ' '", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, " ", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key = \"\"", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, "", val);
+
+ CuAssertIntEquals(tc, LINE_VALUE, iniparser_line("key = ''", section, key, val));
+ CuAssertStrEquals(tc, "key", key);
+ CuAssertStrEquals(tc, "", val);
+
+ /* Test syntax error */
+ CuAssertIntEquals(tc, LINE_ERROR, iniparser_line("empty_value", section, key, val));
+ CuAssertIntEquals(tc, LINE_ERROR, iniparser_line("not finished\\", section, key, val));
+ CuAssertIntEquals(tc, LINE_ERROR, iniparser_line("0x42 / 0b101010", section, key, val));
+
+}
+
+void Test_iniparser_load(CuTest *tc)
+{
+ DIR *dir;
+ struct dirent *curr;
+ struct stat curr_stat;
+ dictionary *dic;
+ char ini_path[256];
+
+ /* Dummy tests */
+ dic = iniparser_load("/you/shall/not/path");
+ CuAssertPtrEquals(tc, NULL, dic);
+
+ /* Test all the good .ini files */
+ dir = opendir(GOOD_INI_PATH);
+ CuAssertPtrNotNullMsg(tc, "Cannot open good .ini conf directory", dir);
+ for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
+ sprintf(ini_path, "%s/%s", GOOD_INI_PATH, curr->d_name);
+ stat(ini_path, &curr_stat);
+ if (S_ISREG(curr_stat.st_mode)) {
+ dic = iniparser_load(ini_path);
+ CuAssertPtrNotNullMsg(tc, ini_path, dic);
+ dictionary_del(dic);
+ }
+ }
+ closedir(dir);
+
+ /* Test all the bad .ini files */
+ dir = opendir(BAD_INI_PATH);
+ CuAssertPtrNotNullMsg(tc, "Cannot open bad .ini conf directory", dir);
+ for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
+ sprintf(ini_path, "%s/%s", BAD_INI_PATH, curr->d_name);
+ stat(ini_path, &curr_stat);
+ if (S_ISREG(curr_stat.st_mode)) {
+ dic = iniparser_load(ini_path);
+ CuAssertPtrEquals_Msg(tc, ini_path, NULL, dic);
+ dictionary_del(dic);
+ }
+ }
+ closedir(dir);
+}
+
+void Test_dictionary_wrapper(CuTest *tc)
+{
+ dictionary *dic;
+
+ dic = dictionary_new(10);
+
+ CuAssertIntEquals(tc, -1, iniparser_set(dic, NULL, NULL));
+ CuAssertIntEquals(tc, -1, iniparser_set(NULL, "section", "value"));
+
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section", NULL));
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", "value"));
+
+ CuAssertStrEquals(tc, "value", iniparser_getstring(dic, "section:key", NULL));
+ /* reset the key's value*/
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", NULL));
+ CuAssertStrEquals(tc, NULL, iniparser_getstring(dic, "section:key", "dummy"));
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", "value"));
+ CuAssertStrEquals(tc, "value", iniparser_getstring(dic, "section:key", NULL));
+
+ iniparser_unset(dic, "section:key");
+ CuAssertStrEquals(tc, "dummy", iniparser_getstring(dic, "section:key", "dummy"));
+ CuAssertStrEquals(tc, NULL, iniparser_getstring(dic, "section", "dummy"));
+
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", NULL));
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key1", NULL));
+ CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key2", NULL));
+
+ iniparser_unset(dic, "section");
+ CuAssertStrEquals(tc, NULL, iniparser_getstring(dic, "section", NULL));
+
+ iniparser_freedict(dic);
+}
+
+static char _last_error[1024];
+static int _error_callback(const char *format, ...)
+{
+ int ret;
+ va_list argptr;
+ va_start(argptr, format);
+ ret = vsprintf(_last_error, format, argptr);
+ va_end(argptr);
+ return ret;
+
+}
+
+void Test_iniparser_error_callback(CuTest *tc)
+{
+ dictionary *dic;
+
+ /* Specify our custom error_callback */
+ iniparser_set_error_callback(_error_callback);
+
+ /* Trigger an error and check it was written on the right output */
+ dic = iniparser_load("/path/to/nowhere.ini");
+ CuAssertPtrEquals(tc, NULL, dic);
+ CuAssertStrEquals(tc, "iniparser: cannot open /path/to/nowhere.ini\n", _last_error);
+
+ /* Reset erro_callback */
+ _last_error[0] = '\0';
+ iniparser_set_error_callback(NULL);
+
+ /* Make sure custom callback is no more called */
+ dic = iniparser_load("/path/to/nowhere.ini");
+ CuAssertPtrEquals(tc, NULL, dic);
+ CuAssertStrEquals(tc, "", _last_error);
+}
generated by cgit