plugin: Record all loaded plugins and use that for improved error messages.

[sysdb.git] / t / utils / strbuf_test.c

diff --git a/t/utils/strbuf_test.c b/t/utils/strbuf_test.c
index 3b88b5844e1e8c3904afe1ef6c8f0e98a453f562..c68a23efcf22df1157d2ac4adb02ceaf5f3b7f38 100644 (file)
--- a/t/utils/strbuf_test.c
+++ b/t/utils/strbuf_test.c
@@ -55,6 +55,37 @@ teardown(void)
  * tests
  */
 
+START_TEST(test_empty)
+{
+       sdb_strbuf_t *b = NULL;
+       va_list ap;
+
+       /* check that methods don't crash */
+       sdb_strbuf_destroy(b);
+       sdb_strbuf_skip(b, 0, 0);
+       sdb_strbuf_skip(b, 0, 10);
+       sdb_strbuf_skip(b, 10, 10);
+
+       /* check that methods return an error */
+       fail_unless(sdb_strbuf_vappend(b, "test", ap) < 0,
+                       "sdb_strbuf_vappend(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_append(b, "test") < 0,
+                       "sdb_strbuf_append(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_vsprintf(b, "test", ap) < 0,
+                       "sdb_strbuf_vsprintf(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_sprintf(b, "test") < 0,
+                       "sdb_strbuf_sprintf(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_memcpy(b, "test", 4) < 0,
+                       "sdb_strbuf_memcpy(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_memappend(b, "test", 4) < 0,
+                       "sdb_strbuf_memappend(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_read(b, 0, 32) < 0,
+                       "sdb_strbuf_read(NULL) didn't report failure");
+       fail_unless(sdb_strbuf_chomp(b) < 0,
+                       "sdb_strbuf_chomp(NULL) didn't report failure");
+}
+END_TEST
+
 START_TEST(test_sdb_strbuf_create)
 {
        sdb_strbuf_t *s;
@@ -177,6 +208,36 @@ START_TEST(test_sdb_strbuf_sprintf)
 }
 END_TEST
 
+START_TEST(test_incremental)
+{
+       ssize_t n;
+       size_t i;
+
+       sdb_strbuf_destroy(buf);
+       buf = sdb_strbuf_create(1024);
+
+       /* fill buffer one by one; leave room for nul-byte */
+       for (i = 0; i < 1023; ++i) {
+               n = sdb_strbuf_append(buf, ".");
+               fail_unless(n == 1, "sdb_strbuf_append() = %zi; expected: 1", n);
+       }
+
+       /* write another byte; this has to trigger a resize */
+       n = sdb_strbuf_append(buf, ".");
+       fail_unless(n == 1, "sdb_strbuf_append() = %zi; expected: 1", n);
+
+       /* write more bytes; this should trigger at least one more resize but
+        * that's an implementation detail */
+       for (i = 0; i < 1024; ++i) {
+               n = sdb_strbuf_append(buf, ".");
+               fail_unless(n == 1, "sdb_strbuf_append() = %zi; expected: 1", n);
+       }
+
+       n = (ssize_t)sdb_strbuf_len(buf);
+       fail_unless(n == 2048, "sdb_strbuf_len() = %zi; expectd: 2048", n);
+}
+END_TEST
+
 static struct {
        const char *input;
        size_t size;
@@ -306,17 +367,28 @@ END_TEST
 
 /* input is "1234567890" */
 static struct {
+       size_t offset;
        size_t n;
        const char *expected;
        size_t expected_len;
 } skip_golden_data[] = {
-       { 0, "1234567890", 10 },
-       { 1, "234567890", 9 },
-       { 2, "34567890", 8 },
-       { 9, "0", 1 },
-       { 10, "", 0 },
-       { 11, "", 0 },
-       { 100, "", 0 },
+       { 0, 0, "1234567890", 10 },
+       { 0, 1, "234567890", 9 },
+       { 0, 2, "34567890", 8 },
+       { 0, 9, "0", 1 },
+       { 0, 10, "", 0 },
+       { 0, 11, "", 0 },
+       { 0, 100, "", 0 },
+       { 1, 0, "1234567890", 10 },
+       { 1, 1, "134567890", 9 },
+       { 1, 2, "14567890", 8 },
+       { 8, 1, "123456780", 9 },
+       { 8, 2, "12345678", 8 },
+       { 8, 3, "12345678", 8 },
+       { 9, 1, "123456789", 9 },
+       { 9, 2, "123456789", 9 },
+       { 10, 1, "1234567890", 10 },
+       { 10, 2, "1234567890", 10 },
 };
 
 START_TEST(test_sdb_strbuf_skip)
@@ -329,7 +401,8 @@ START_TEST(test_sdb_strbuf_skip)
                size_t n;
 
                sdb_strbuf_sprintf(buf, input);
-               sdb_strbuf_skip(buf, skip_golden_data[i].n);
+               sdb_strbuf_skip(buf, skip_golden_data[i].offset,
+                               skip_golden_data[i].n);
 
                n = sdb_strbuf_len(buf);
                fail_unless(n == skip_golden_data[i].expected_len,
@@ -409,11 +482,16 @@ util_strbuf_suite(void)
        Suite *s = suite_create("utils::strbuf");
        TCase *tc;
 
+       tc = tcase_create("empty");
+       tcase_add_test(tc, test_empty);
+       suite_add_tcase(s, tc);
+
        tc = tcase_create("core");
        tcase_add_checked_fixture(tc, setup, teardown);
        tcase_add_test(tc, test_sdb_strbuf_create);
        tcase_add_test(tc, test_sdb_strbuf_append);
        tcase_add_test(tc, test_sdb_strbuf_sprintf);
+       tcase_add_test(tc, test_incremental);
        tcase_add_test(tc, test_sdb_strbuf_memcpy);
        tcase_add_test(tc, test_sdb_strbuf_memappend);
        tcase_add_test(tc, test_sdb_strbuf_chomp);