![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index f9c3e93f3987313d5704ad62ebed2e0898469915..e7cb9f5a6438cfb9ba1cc30ed90835ab5dbcaeb1 100644 (file)
sdb_strbuf_t *b = NULL;
va_list ap;
+ size_t check;
+
/* check that methods don't crash */
sdb_strbuf_destroy(b);
sdb_strbuf_skip(b, 0, 0);
"sdb_strbuf_read(NULL) didn't report failure");
fail_unless(sdb_strbuf_chomp(b) < 0,
"sdb_strbuf_chomp(NULL) didn't report failure");
+
+ /* check that methods return no used space */
+ check = sdb_strbuf_len(b);
+ fail_unless(check == 0,
+ "sdb_strbuf_len(NULL) = %zi; expected: 0", check);
+ check = sdb_strbuf_cap(b);
+ fail_unless(check == 0,
+ "sdb_strbuf_cap(NULL) = %zi; expected: 0", check);
}
END_TEST
{
sdb_strbuf_t *b = sdb_strbuf_create(0);
const char *data;
- size_t len;
+ size_t check;
/* check that methods don't crash */
sdb_strbuf_skip(b, 1, 1);
data = sdb_strbuf_string(b);
fail_unless(data && (*data == '\0'),
"sdb_strbuf_string(<empty>) = '%s'; expected: ''", data);
- len = sdb_strbuf_len(b);
- fail_unless(len == 0,
- "sdb_strbuf_len(<empty>) = %zu; expected: 0", len);
+ check = sdb_strbuf_len(b);
+ fail_unless(check == 0,
+ "sdb_strbuf_len(<empty>) = %zu; expected: 0", check);
+ check = sdb_strbuf_cap(b);
+ fail_unless(check == 0,
+ "sdb_strbuf_cap(<empty>) = %zu; expected: 0", check);
sdb_strbuf_destroy(b);
}
END_TEST
-START_TEST(test_sdb_strbuf_create)
+START_TEST(test_create)
{
sdb_strbuf_t *s;
- size_t len;
+ size_t check;
s = sdb_strbuf_create(0);
fail_unless(s != NULL,
"sdb_strbuf_create() = NULL; expected strbuf object");
- len = sdb_strbuf_len(s);
- fail_unless(len == 0,
+ check = sdb_strbuf_len(s);
+ fail_unless(check == 0,
"sdb_strbuf_create() created buffer with len = %zu; "
- "expected: 0", len);
+ "expected: 0", check);
+ check = sdb_strbuf_cap(s);
+ fail_unless(check == 0,
+ "sdb_strbuf_create() created buffer with cap = %zu; "
+ "expected: 0", check);
sdb_strbuf_destroy(s);
s = sdb_strbuf_create(128);
fail_unless(s != NULL,
"sdb_strbuf_create() = NULL; expected strbuf object");
- len = sdb_strbuf_len(s);
+ check = sdb_strbuf_len(s);
/* len still has to be 0 -- there's no content */
- fail_unless(len == 0,
+ fail_unless(check == 0,
"sdb_strbuf_create() created buffer with len = %zu; "
- "expected: 0", len);
+ "expected: 0", check);
+ check = sdb_strbuf_cap(s);
+ fail_unless(check == 128,
+ "sdb_strbuf_create() created buffer with cap = %zu; "
+ "expected: 128", check);
sdb_strbuf_destroy(s);
}
END_TEST
-START_TEST(test_sdb_strbuf_append)
+START_TEST(test_append)
{
- ssize_t n, expected;
- size_t len;
+ ssize_t n;
+ size_t len, total = 0;
const char *test;
- n = sdb_strbuf_append(buf, "1234567890");
- fail_unless(n == 10,
- "sdb_strbuf_append() appended %zi bytes; expected: 10", n);
- len = sdb_strbuf_len(buf);
- fail_unless(len == 10,
- "sdb_strbuf_append() left behind buffer with len = %zu; "
- "expected: 10", len);
+ struct {
+ const char *input;
+ const char *result;
+ } golden_data[] = {
+ { "1234567890", "1234567890" },
+ { "ABCDE", "1234567890ABCDE" },
+ { "", "1234567890ABCDE" },
+ { "-", "1234567890ABCDE-" },
+ /* when adding anything to this array, the last check has to be
+ * updated accordingly */
+ };
- n = sdb_strbuf_append(buf, "ABCDE");
- fail_unless(n == 5,
- "sdb_strbuf_append() appended %zi bytes; expected: 5", n);
- len = sdb_strbuf_len(buf);
- fail_unless(len == 15,
- "sdb_strbuf_append() left behind buffer with len = %zu; "
- "expected: 15", len);
+ size_t i;
- test = sdb_strbuf_string(buf);
- fail_unless(test[len] == '\0',
- "sdb_strbuf_append() did not nil-terminate the string");
- fail_unless(!strcmp(test, "1234567890ABCDE"),
- "sdb_strbuf_append() did not correctly concatenate two string; "
- "got: %s; expected: 1234567890ABCDE", test);
-
- n = sdb_strbuf_append(buf, "%zu; %5.4f", len, (double)len / 10.0);
- expected = /* len */ 2 + /* "; " */ 2 + /* decimal len/10 */ 6;
- fail_unless(n == expected,
- "sdb_strbuf_append() appended %zi bytes; expected: %zi",
- n, expected);
+ for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
+ n = sdb_strbuf_append(buf, "%s", golden_data[i].input);
+ fail_unless((size_t)n == strlen(golden_data[i].input),
+ "sdb_strbuf_append() appended %zi bytes; expected: %zu",
+ n, strlen(golden_data[i].input));
+ total += n;
+ len = sdb_strbuf_len(buf);
+ fail_unless(len == total,
+ "sdb_strbuf_append() left behind buffer with len = %zu; "
+ "expected: %zu", len, total);
+
+ test = sdb_strbuf_string(buf);
+ fail_unless(test[len] == '\0',
+ "sdb_strbuf_append() did not nil-terminate the string");
+
+ test = sdb_strbuf_string(buf);
+ fail_unless(!strcmp(test, golden_data[i].result),
+ "sdb_strbuf_append() did not correctly concatenate "
+ "the input; got: %s; expected: %s",
+ test, golden_data[i].result);
+ }
+
+ n = sdb_strbuf_append(buf, "%zu; %5.4f", (size_t)42, 4.2);
+ fail_unless(n == 10,
+ "sdb_strbuf_append() appended %zi bytes; expected: 10", n);
+ total += n;
len = sdb_strbuf_len(buf);
- fail_unless(len == 15 + (size_t)expected,
+ fail_unless(len == total,
"sdb_strbuf_append() left behind buffer with len = %zu; "
- "expected: %zu", len, 15 + (size_t)expected);
+ "expected: %zu", len, total);
test = sdb_strbuf_string(buf);
fail_unless(test[len] == '\0',
"sdb_strbuf_append() did not nil-terminate the string");
- fail_unless(!strcmp(test, "1234567890ABCDE15; 1.5000"),
- "sdb_strbuf_append() did not correctly concatenate two string; "
- "got: %s; expected: 1234567890ABCDE15; 1.5000", test);
+ fail_unless(!strcmp(test, "1234567890ABCDE-42; 4.2000"),
+ "sdb_strbuf_append() did not correctly concatenate the input; "
+ "got: %s; expected: 1234567890ABCDE-42; 4.2000", test);
}
END_TEST
-START_TEST(test_sdb_strbuf_sprintf)
+START_TEST(test_sprintf)
{
- ssize_t n, expected;
- size_t len;
+ ssize_t n;
+ size_t check;
const char *test;
- n = sdb_strbuf_sprintf(buf, "1234567890");
- fail_unless(n == 10,
- "sdb_strbuf_sprintf() wrote %zi bytes; expected: 10", n);
- len = sdb_strbuf_len(buf);
- fail_unless(len == 10,
- "sdb_strbuf_sprintf() left behind buffer with len = %zu; "
- "expected: 10", len);
+ const char *golden_data[] = {
+ "1234567890",
+ "ABCDE",
+ "",
+ "-",
+ "123456789012345678901234567890",
+ "--",
+ };
- n = sdb_strbuf_sprintf(buf, "ABCDE");
- fail_unless(n == 5,
- "sdb_strbuf_sprintf() wrote %zi bytes; expected: 5", n);
- len = sdb_strbuf_len(buf);
- fail_unless(len == 5,
- "sdb_strbuf_sprintf() left behind buffer with len = %zu; "
- "expected: 5", len);
+ size_t i;
- test = sdb_strbuf_string(buf);
- fail_unless(test[len] == '\0',
- "sdb_strbuf_sprintf() did not nil-terminate the string");
- fail_unless(!strcmp(test, "ABCDE"),
- "sdb_strbuf_sprintf() did not format string correctly; "
- "got: %s; expected: ABCDE", test);
+ for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
+ n = sdb_strbuf_sprintf(buf, "%s", golden_data[i]);
+ fail_unless((size_t)n == strlen(golden_data[i]),
+ "sdb_strbuf_sprintf() wrote %zi bytes; expected: %zu",
+ n, strlen(golden_data[i]));
+ check = sdb_strbuf_len(buf);
+ fail_unless(check == (size_t)n,
+ "sdb_strbuf_sprintf() left behind buffer with len = %zu; "
+ "expected: %zi", check, n);
+
+ test = sdb_strbuf_string(buf);
+ fail_unless(test[check] == '\0',
+ "sdb_strbuf_sprintf() did not nil-terminate the string");
+ fail_unless(!strcmp(test, golden_data[i]),
+ "sdb_strbuf_sprintf() did not format string correctly; "
+ "got: %s; expected: %s", test, golden_data[i]);
+
+ check = sdb_strbuf_cap(buf);
+ if (n) /* 3 times the current len is the threshold for shrinking */
+ fail_unless(((size_t)n < check) && (check < (size_t)n * 3),
+ "sdb_strbuf_sprintf() did not resize the buffer "
+ "correctly (got size %zu; expected %zi < <size> < %d)",
+ check, n, n / 3);
+ }
- n = sdb_strbuf_sprintf(buf, "%zu; %5.4f", len, (double)len / 10.0);
- expected = /* len */ 1 + /* "; " */ 2 + /* decimal len/10 */ 6;
- fail_unless(n == expected,
- "sdb_strbuf_sprintf() wrote %zi bytes; expected: %zi",
- n, expected);
- len = sdb_strbuf_len(buf);
- fail_unless(len == (size_t)expected,
+ n = sdb_strbuf_sprintf(buf, "%zu; %5.4f", (size_t)42, 4.2);
+ fail_unless(n == 10,
+ "sdb_strbuf_sprintf() wrote %zi bytes; expected: 10", n);
+ check = sdb_strbuf_len(buf);
+ fail_unless(check == 10,
"sdb_strbuf_sprintf() left behind buffer with len = %zu; "
- "expected: %zu", len, (size_t)expected);
+ "expected: 10", check);
test = sdb_strbuf_string(buf);
- fail_unless(test[len] == '\0',
+ fail_unless(test[check] == '\0',
"sdb_strbuf_sprintf() did not nil-terminate the string");
- fail_unless(!strcmp(test, "5; 0.5000"),
+ fail_unless(!strcmp(test, "42; 4.2000"),
"sdb_strbuf_sprintf() did not format string correctly; "
- "got: %s; expected: 5; 0.5000", test);
+ "got: %s; expected: 42; 4.2000", test);
}
END_TEST
START_TEST(test_incremental)
{
+ const char *data;
+
ssize_t n;
- size_t i;
+ size_t i, check;
sdb_strbuf_destroy(buf);
buf = sdb_strbuf_create(1024);
fail_unless(n == 1, "sdb_strbuf_append() = %zi; expected: 1", n);
}
+ check = sdb_strbuf_cap(buf);
+ fail_unless(check == 1024,
+ "sdb_strbuf_append() resizes the buffer too early "
+ "(got size %zu; expected: 1024)", check);
+
/* 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);
+ check = sdb_strbuf_cap(buf);
+ /* the exact size doesn't matter but is an implementation detail */
+ fail_unless(check > 1024,
+ "sdb_strbuf_append() did not resize the buffer");
+
/* write more bytes; this should trigger at least one more resize but
- * that's an implementation detail */
+ * that's an implementation detail as well */
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);
+
+ data = sdb_strbuf_string(buf);
+ for (i = 0; i < 2048; ++i)
+ fail_unless(data[i] == '.',
+ "After sdb_strbuf_append(), found character %x "
+ "at position %zi; expected %x (.)",
+ (int)data[i], i, '.');
+ fail_unless(data[i] == '\0',
+ "After sdb_strbuf_append(), found character %x at end of string; "
+ "expected '\\0'", (int)data[i]);
}
END_TEST
+/* used by test_memcpy and test_memappend */
static struct {
const char *input;
size_t size;
{ "", 0 },
};
-START_TEST(test_sdb_strbuf_memcpy)
+START_TEST(test_memcpy)
{
size_t i;
fail_unless(!memcmp(check, mem_golden_data[i].input,
mem_golden_data[i].size),
"sdb_strbuf_memcpy() did not set the buffer correctly");
+
+ n = (ssize_t)sdb_strbuf_cap(buf);
+ fail_unless((size_t)n > mem_golden_data[i].size,
+ "sdb_strbuf_memcpy() did not resize the buffer correctly "
+ "(got size %zi; expected: > %zu)", n,
+ mem_golden_data[i].size);
}
}
END_TEST
-START_TEST(test_sdb_strbuf_memappend)
+START_TEST(test_memappend)
{
size_t i;
fail_unless(check[total] == '\0',
"sdb_strbuf_memappend() did not nil-terminate the data");
+
+ n = (ssize_t)sdb_strbuf_cap(buf);
+ fail_unless((size_t)n > total,
+ "sdb_strbuf_memappend() did not resize the buffer correctly "
+ "(got size %zi; expected: > %zu)", n, total);
}
}
END_TEST
-static struct {
- const char *input;
- ssize_t expected;
- const char *expected_string;
-} chomp_golden_data[] = {
- { NULL, 0, "" },
- { "\n", 1, "" },
- { "\n\n", 2, "" },
- { "12345\n\n\n", 3, "12345" },
- { "abcd", 0, "abcd" },
-};
-
-START_TEST(test_sdb_strbuf_chomp)
+START_TEST(test_chomp)
{
+ struct {
+ const char *input;
+ ssize_t expected;
+ const char *expected_string;
+ } golden_data[] = {
+ { NULL, 0, "" },
+ { "\n", 1, "" },
+ { "\n\n", 2, "" },
+ { "12345\n\n\n", 3, "12345" },
+ { "abcd", 0, "abcd" },
+ };
+
size_t i;
- for (i = 0; i < SDB_STATIC_ARRAY_LEN(chomp_golden_data); ++i) {
+ for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
ssize_t n;
const char *check;
- if (chomp_golden_data[i].input)
- sdb_strbuf_sprintf(buf, chomp_golden_data[i].input);
+ if (golden_data[i].input)
+ sdb_strbuf_sprintf(buf, "%s", golden_data[i].input);
/* empty buffer */
n = sdb_strbuf_chomp(buf);
- fail_unless(n == chomp_golden_data[i].expected,
+ fail_unless(n == golden_data[i].expected,
"sdb_strbuf_chomp() = %zi; expected: %zi", n,
- chomp_golden_data[i].expected);
+ golden_data[i].expected);
check = sdb_strbuf_string(buf);
- fail_unless(!strcmp(check, chomp_golden_data[i].expected_string),
+ fail_unless(!strcmp(check, golden_data[i].expected_string),
"sdb_strbuf_chomp() did not correctly remove newlines; "
"got string '%s'; expected: '%s'", check,
- chomp_golden_data[i].expected_string);
+ golden_data[i].expected_string);
}
}
END_TEST
-/* input is "1234567890" */
-static struct {
- size_t offset;
- size_t n;
- const char *expected;
- size_t expected_len;
-} skip_golden_data[] = {
- { 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 },
- { 2, 0, "1234567890", 10 },
- { 2, 1, "124567890", 9 },
- { 2, 2, "12567890", 8 },
- { 2, 3, "1267890", 7 },
- { 2, 4, "127890", 6 },
- { 2, 5, "12890", 5 },
- { 2, 6, "1290", 4 },
- { 2, 7, "120", 3 },
- { 2, 8, "12", 2 },
- { 2, 9, "12", 2 },
- { 2, 10, "12", 2 },
- { 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)
+START_TEST(test_skip)
{
const char *input = "1234567890";
+ struct {
+ size_t offset;
+ size_t n;
+ const char *expected;
+ size_t expected_len;
+ } golden_data[] = {
+ { 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 },
+ { 2, 0, "1234567890", 10 },
+ { 2, 1, "124567890", 9 },
+ { 2, 2, "12567890", 8 },
+ { 2, 3, "1267890", 7 },
+ { 2, 4, "127890", 6 },
+ { 2, 5, "12890", 5 },
+ { 2, 6, "1290", 4 },
+ { 2, 7, "120", 3 },
+ { 2, 8, "12", 2 },
+ { 2, 9, "12", 2 },
+ { 2, 10, "12", 2 },
+ { 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 },
+ };
+
size_t i;
- for (i = 0; i < SDB_STATIC_ARRAY_LEN(skip_golden_data); ++i) {
+ for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
const char *check;
size_t n;
- sdb_strbuf_sprintf(buf, input);
- sdb_strbuf_skip(buf, skip_golden_data[i].offset,
- skip_golden_data[i].n);
+ sdb_strbuf_sprintf(buf, "%s", input);
+ sdb_strbuf_skip(buf, golden_data[i].offset,
+ golden_data[i].n);
n = sdb_strbuf_len(buf);
- fail_unless(n == skip_golden_data[i].expected_len,
+ fail_unless(n == golden_data[i].expected_len,
"sdb_strbuf_len() = %zu (after skip); expected: %zu",
- n, skip_golden_data[i].expected_len);
+ n, golden_data[i].expected_len);
check = sdb_strbuf_string(buf);
fail_unless(!!check,
fail_unless(check[n] == '\0',
"sdb_strbuf_skip() did not nil-terminate the string");
- fail_unless(! strcmp(skip_golden_data[i].expected, check),
+ fail_unless(! strcmp(golden_data[i].expected, check),
"sdb_strbuf_skip('%s', %zu) did not skip correctly; "
"got string '%s'; expected: '%s'", input,
- skip_golden_data[i].n, check, skip_golden_data[i].expected);
+ golden_data[i].n, check, golden_data[i].expected);
}
}
END_TEST
-START_TEST(test_sdb_strbuf_clear)
+START_TEST(test_clear)
{
const char *data;
size_t len;
}
END_TEST
-static struct {
- const char *input;
- const char *expected;
-} string_golden_data[] = {
- { NULL, "" },
- { "a", "a" },
- { "abcdef", "abcdef" },
-};
-
-START_TEST(test_sdb_strbuf_string)
+START_TEST(test_string)
{
+ struct {
+ const char *input;
+ const char *expected;
+ } golden_data[] = {
+ { NULL, "" },
+ { "a", "a" },
+ { "abcdef", "abcdef" },
+ };
+
size_t i;
- for (i = 0; i < SDB_STATIC_ARRAY_LEN(string_golden_data); ++i) {
+ for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
const char *check;
- if (string_golden_data[i].input)
- sdb_strbuf_sprintf(buf, string_golden_data[i].input);
+ if (golden_data[i].input)
+ sdb_strbuf_sprintf(buf, "%s", golden_data[i].input);
check = sdb_strbuf_string(buf);
- fail_unless(!strcmp(check, string_golden_data[i].expected),
+ fail_unless(!strcmp(check, golden_data[i].expected),
"sdb_strbuf_string() = '%s'; expected: '%s'",
- check, string_golden_data[i].expected);
+ check, golden_data[i].expected);
}
}
END_TEST
-static struct {
- const char *input;
- size_t expected;
-} len_golden_data[] = {
- { NULL, 0 },
- { "a", 1 },
- { "12345", 5 },
-};
-
-START_TEST(test_sdb_strbuf_len)
+START_TEST(test_len)
{
+ struct {
+ const char *input;
+ size_t expected;
+ } golden_data[] = {
+ { NULL, 0 },
+ { "a", 1 },
+ { "12345", 5 },
+ };
+
size_t i;
- for (i = 0; i < SDB_STATIC_ARRAY_LEN(len_golden_data); ++i) {
+ for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
size_t check;
- if (len_golden_data[i].input)
- sdb_strbuf_sprintf(buf, len_golden_data[i].input);
+ if (golden_data[i].input)
+ sdb_strbuf_sprintf(buf, "%s", golden_data[i].input);
check = sdb_strbuf_len(buf);
- fail_unless(check == len_golden_data[i].expected,
+ fail_unless(check == golden_data[i].expected,
"sdb_strbuf_len() = %zu; expected: %zu",
- check, len_golden_data[i].expected);
+ check, golden_data[i].expected);
}
}
END_TEST
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_create);
+ tcase_add_test(tc, test_append);
+ tcase_add_test(tc, test_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);
- tcase_add_test(tc, test_sdb_strbuf_skip);
- tcase_add_test(tc, test_sdb_strbuf_clear);
- tcase_add_test(tc, test_sdb_strbuf_string);
- tcase_add_test(tc, test_sdb_strbuf_len);
+ tcase_add_test(tc, test_memcpy);
+ tcase_add_test(tc, test_memappend);
+ tcase_add_test(tc, test_chomp);
+ tcase_add_test(tc, test_skip);
+ tcase_add_test(tc, test_clear);
+ tcase_add_test(tc, test_string);
+ tcase_add_test(tc, test_len);
suite_add_tcase(s, tc);
return s;