X-Git-Url: https://git.tokkee.org/?p=sysdb.git;a=blobdiff_plain;f=t%2Funit%2Fcore%2Fdata_test.c;h=1955528e919a8c753b1c1c99842a15296890b716;hp=a848756a185385ae1431fb43c9119fc855bfe181;hb=6f1ea6365001d494aa358727ac031966dad4d426;hpb=d0ca7dd7178ff194a2510115702f69b1c6f66786 diff --git a/t/unit/core/data_test.c b/t/unit/core/data_test.c index a848756..1955528 100644 --- a/t/unit/core/data_test.c +++ b/t/unit/core/data_test.c @@ -25,8 +25,12 @@ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#if HAVE_CONFIG_H +# include "config.h" +#endif + #include "core/data.h" -#include "libsysdb_test.h" +#include "testutils.h" #include #include @@ -38,10 +42,23 @@ START_TEST(test_data) sdb_data_t d1, d2; int check; + bool bool_values[] = { true, false, false, true }; int64_t int_values[] = { 47, 11, 23 }; char *string_values[] = { "foo", "bar", "qux" "baz" }; size_t i; + d2.type = SDB_TYPE_BOOLEAN; + d2.data.boolean = true; + memset(&d1, 0, sizeof(d1)); + check = sdb_data_copy(&d1, &d2); + fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check); + fail_unless(d1.type == d2.type, + "sdb_data_copy() didn't copy type; got: %i; expected: %i", + d1.type, d2.type); + fail_unless(d1.data.boolean == d2.data.boolean, + "sdb_data_copy() didn't copy boolean data: got: %d; expected: %d", + d1.data.boolean, d2.data.boolean); + d2.type = SDB_TYPE_INTEGER; d2.data.integer = 4711; memset(&d1, 0, sizeof(d1)); @@ -179,6 +196,26 @@ START_TEST(test_data) "sdb_data_copy() didn't copy type; got: %i; expected: %i", d1.type, d2.type); + d2.type = SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN; + d2.data.array.length = SDB_STATIC_ARRAY_LEN(bool_values); + d2.data.array.values = bool_values; + check = sdb_data_copy(&d1, &d2); + fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check); + fail_unless(d1.type == d2.type, + "sdb_data_copy() didn't copy type; got: %i; expected: %i", + d1.type, d2.type); + fail_unless(d1.data.array.values != d2.data.array.values, + "sdb_data_copy() didn't copy values: got: %p; expected: %p", + d1.data.array.values, d2.data.array.values); + for (i = 0; i < SDB_STATIC_ARRAY_LEN(bool_values); ++i) { + bool *b1 = d1.data.array.values; + bool *b2 = d2.data.array.values; + fail_unless(b1[i] == b2[i], + "sdb_data_copy() modified boolean value %d: " + "got: %d; expected: %d", i, b1[i], b2[i]); + } + sdb_data_free_datum(&d1); + d2.type = SDB_TYPE_ARRAY | SDB_TYPE_INTEGER; d2.data.array.length = SDB_STATIC_ARRAY_LEN(int_values); d2.data.array.values = int_values; @@ -225,16 +262,64 @@ END_TEST START_TEST(test_cmp) { + regex_t dummy_re; + bool bool_values1[] = { true, false, false, true }; + bool bool_values2[] = { true, false, true, false }; int64_t int_values1[] = { 1, 2, 3 }; int64_t int_values2[] = { 1, 3, 2 }; + double dec_values1[] = { 12.34, 47.11 }; + double dec_values2[] = { 47.11, 12.34 }; char *string_values1[] = { "a", "b", "c" }; char *string_values2[] = { "a", "c", "b" }; + sdb_time_t dt_values1[] = { 4711, 1234567890123456789L }; + sdb_time_t dt_values2[] = { 1234567890123456789L, 4711 }; + struct { + size_t length; + unsigned char *datum; + } bin_values1[] = { + { 3, (unsigned char *)"\x1\x2\x3" }, + { 4, (unsigned char *)"\x42\x0\xa\x1b" }, + }; + struct { + size_t length; + unsigned char *datum; + } bin_values2[] = { + { 4, (unsigned char *)"\x42\x0\xa\x1b" }, + { 3, (unsigned char *)"\x1\x2\x3" }, + }; + struct { + char *raw; + regex_t regex; + } re_values1[] = { + { "dummy regex A", dummy_re }, + }; + struct { + char *raw; + regex_t regex; + } re_values2[] = { + { "dummy regex B", dummy_re }, + }; struct { sdb_data_t d1; sdb_data_t d2; int expected; } golden_data[] = { + { + { SDB_TYPE_BOOLEAN, { .boolean = false } }, + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + -1, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + 0, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BOOLEAN, { .boolean = false } }, + 1, + }, { { SDB_TYPE_INTEGER, { .integer = 47 } }, { SDB_TYPE_INTEGER, { .integer = 4711 } }, @@ -400,11 +485,65 @@ START_TEST(test_cmp) { SDB_TYPE_REGEX, { .re = { "b", empty_re } } }, -1, }, + { + { SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, { .array = { 0, NULL } } }, + { SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, { .array = { 0, NULL } } }, + 0, + }, { { SDB_TYPE_REGEX, { .re = { "b", empty_re } } }, { SDB_TYPE_REGEX, { .re = { "a", empty_re } } }, 1, }, + { + { SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, { .array = { 0, NULL } } }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values1), bool_values1 } }, + }, + -1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values1), bool_values1 } }, + }, + { SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, { .array = { 0, NULL } } }, + 1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values1), bool_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values1), bool_values1 } }, + }, + 0, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values1), bool_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values2), bool_values2 } }, + }, + -1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values2), bool_values2 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values1), bool_values1 } }, + }, + 1, + }, { { SDB_TYPE_ARRAY | SDB_TYPE_INTEGER, { .array = { 0, NULL } } }, { SDB_TYPE_ARRAY | SDB_TYPE_INTEGER, { .array = { 0, NULL } } }, @@ -459,6 +598,39 @@ START_TEST(test_cmp) }, 1, }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL, + { .array = { SDB_STATIC_ARRAY_LEN(dec_values1), dec_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL, + { .array = { SDB_STATIC_ARRAY_LEN(dec_values1), dec_values1 } }, + }, + 0, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL, + { .array = { SDB_STATIC_ARRAY_LEN(dec_values1), dec_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL, + { .array = { SDB_STATIC_ARRAY_LEN(dec_values2), dec_values2 } }, + }, + -1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL, + { .array = { SDB_STATIC_ARRAY_LEN(dec_values2), dec_values2 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL, + { .array = { SDB_STATIC_ARRAY_LEN(dec_values1), dec_values1 } }, + }, + 1, + }, { { SDB_TYPE_ARRAY | SDB_TYPE_STRING, { .array = { 0, NULL } } }, { SDB_TYPE_ARRAY | SDB_TYPE_STRING, { .array = { 0, NULL } } }, @@ -513,6 +685,105 @@ START_TEST(test_cmp) }, 1, }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_DATETIME, + { .array = { SDB_STATIC_ARRAY_LEN(dt_values1), dt_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_DATETIME, + { .array = { SDB_STATIC_ARRAY_LEN(dt_values1), dt_values1 } }, + }, + 0, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_DATETIME, + { .array = { SDB_STATIC_ARRAY_LEN(dt_values1), dt_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_DATETIME, + { .array = { SDB_STATIC_ARRAY_LEN(dt_values2), dt_values2 } }, + }, + -1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_DATETIME, + { .array = { SDB_STATIC_ARRAY_LEN(dt_values2), dt_values2 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_DATETIME, + { .array = { SDB_STATIC_ARRAY_LEN(dt_values1), dt_values1 } }, + }, + 1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BINARY, + { .array = { SDB_STATIC_ARRAY_LEN(bin_values1), bin_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BINARY, + { .array = { SDB_STATIC_ARRAY_LEN(bin_values1), bin_values1 } }, + }, + 0, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BINARY, + { .array = { SDB_STATIC_ARRAY_LEN(bin_values1), bin_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BINARY, + { .array = { SDB_STATIC_ARRAY_LEN(bin_values2), bin_values2 } }, + }, + -1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BINARY, + { .array = { SDB_STATIC_ARRAY_LEN(bin_values2), bin_values2 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BINARY, + { .array = { SDB_STATIC_ARRAY_LEN(bin_values1), bin_values1 } }, + }, + 1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_REGEX, + { .array = { SDB_STATIC_ARRAY_LEN(re_values1), re_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_REGEX, + { .array = { SDB_STATIC_ARRAY_LEN(re_values1), re_values1 } }, + }, + 0, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_REGEX, + { .array = { SDB_STATIC_ARRAY_LEN(re_values1), re_values1 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_REGEX, + { .array = { SDB_STATIC_ARRAY_LEN(re_values2), re_values2 } }, + }, + -1, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_REGEX, + { .array = { SDB_STATIC_ARRAY_LEN(re_values2), re_values2 } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_REGEX, + { .array = { SDB_STATIC_ARRAY_LEN(re_values1), re_values1 } }, + }, + 1, + }, }; size_t i; @@ -543,6 +814,21 @@ START_TEST(test_strcmp) /* same data as for the sdb_data_cmp test; in case the types match, * both functions should behave the same (except for some loss in * precision, e.g. when formatting datetime values) */ + { + { SDB_TYPE_BOOLEAN, { .boolean = false } }, + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + -1, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + 0, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BOOLEAN, { .boolean = false } }, + 1, + }, { { SDB_TYPE_INTEGER, { .integer = 47 } }, { SDB_TYPE_INTEGER, { .integer = 4711 } }, @@ -714,6 +1000,16 @@ START_TEST(test_strcmp) 1, }, /* type mismatches */ + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_INTEGER, { .integer = 1 } }, + 1, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_STRING, { .string = "true" } }, + 0, + }, { { SDB_TYPE_INTEGER, { .integer = 123 } }, { SDB_TYPE_STRING, { .string = "123" } }, @@ -772,6 +1068,10 @@ END_TEST START_TEST(test_inarray) { + bool bool_values[] = { true, false, true }; + bool bool_values2[] = { false, true }; + bool bool_values3[] = { true, true, true }; + bool bool_values4[] = { false, false }; int64_t int_values[] = { 47, 11, 64 }; int64_t int_values2[] = { 64, 11 }; int64_t int_values3[] = { 47, 11, 42 }; @@ -782,6 +1082,22 @@ START_TEST(test_inarray) char *string_values2[] = { "qux", "bar" }; char *string_values3[] = { "foo", "bar", "qux", "baz", "bay" }; + sdb_data_t bool_array = { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } } + }; + sdb_data_t bool_array2 = { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values2), bool_values2 } } + }; + sdb_data_t bool_array3 = { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values3), bool_values3 } } + }; + sdb_data_t bool_array4 = { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values4), bool_values4 } } + }; sdb_data_t int_array = { SDB_TYPE_ARRAY | SDB_TYPE_INTEGER, { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } } @@ -824,6 +1140,9 @@ START_TEST(test_inarray) sdb_data_t array; _Bool expected; } golden_data[] = { + { { SDB_TYPE_BOOLEAN, { .boolean = true } }, bool_array, 1 }, + { { SDB_TYPE_BOOLEAN, { .boolean = true } }, bool_array4, 0 }, + { { SDB_TYPE_BOOLEAN, { .boolean = false } }, bool_array, 1 }, { { SDB_TYPE_INTEGER, { .integer = 47 } }, int_array, 1 }, { { SDB_TYPE_INTEGER, { .integer = 11 } }, int_array, 1 }, { { SDB_TYPE_INTEGER, { .integer = 64 } }, int_array, 1 }, @@ -844,7 +1163,17 @@ START_TEST(test_inarray) { { SDB_TYPE_STRING, { .string = "ba" } }, string_array, 0 }, { { SDB_TYPE_STRING, { .string = "abc" } }, string_array, 0 }, { { SDB_TYPE_NULL, { .integer = 0 } }, string_array, 0 }, + { bool_array, { SDB_TYPE_BOOLEAN, { .boolean = true } }, 0 }, { int_array, { SDB_TYPE_INTEGER, { .integer = 47 } }, 0 }, + { bool_array, bool_array, 1 }, + { bool_array2, bool_array, 1 }, + { bool_array, bool_array2, 1 }, + { bool_array, bool_array3, 0 }, + { bool_array, bool_array4, 0 }, + { bool_array2, bool_array3, 0 }, + { bool_array2, bool_array4, 0 }, + { bool_array3, bool_array4, 0 }, + { bool_array4, bool_array3, 0 }, { int_array, int_array, 1 }, { int_array2, int_array, 1 }, { int_array3, int_array, 0 }, @@ -907,10 +1236,15 @@ END_TEST START_TEST(test_array_get) { + bool bool_values[] = { true, false, false }; int64_t int_values[] = { 47, 11, 64 }; double dec_values[] = { 12.3, 47.11, 64.0 }; char *string_values[] = { "foo", "bar", "qux", "baz" }; + sdb_data_t bool_array = { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } } + }; sdb_data_t int_array = { SDB_TYPE_ARRAY | SDB_TYPE_INTEGER, { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } } @@ -929,6 +1263,10 @@ START_TEST(test_array_get) size_t i; sdb_data_t expected; } golden_data[] = { + { bool_array, 0, { SDB_TYPE_BOOLEAN, { .boolean = true } } }, + { bool_array, 1, { SDB_TYPE_BOOLEAN, { .boolean = false } } }, + { bool_array, 2, { SDB_TYPE_BOOLEAN, { .boolean = false } } }, + { bool_array, 3, { -1, { .integer = 0 } } }, { int_array, 0, { SDB_TYPE_INTEGER, { .integer = 47 } } }, { int_array, 1, { SDB_TYPE_INTEGER, { .integer = 11 } } }, { int_array, 2, { SDB_TYPE_INTEGER, { .integer = 64 } } }, @@ -1033,6 +1371,10 @@ START_TEST(test_expr_eval) { sdb_data_t err = { -1, { .integer = 0 } }; + bool bool_values[] = { true, false, true }; + bool expected_bool_append[] = { true, false, true, true }; + bool expected_bool_prepend[] = { true, true, false, true }; + bool expected_bool_concat[] = { true, false, true, true, false, true }; int64_t int_values[] = { 47, 11, 23 }; int64_t expected_int_append[] = { 47, 11, 23, 42 }; int64_t expected_int_prepend[] = { 42, 47, 11, 23 }; @@ -1053,6 +1395,16 @@ START_TEST(test_expr_eval) sdb_data_t expected_mod; sdb_data_t expected_concat; } golden_data[] = { + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BOOLEAN, { .boolean = false } }, + err, + err, + err, + err, + err, + err, + }, { { SDB_TYPE_INTEGER, { .integer = 4711 } }, { SDB_TYPE_INTEGER, { .integer = 47 } }, @@ -1182,6 +1534,66 @@ START_TEST(test_expr_eval) err, err, }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } }, + }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } }, + }, + err, + err, + err, + err, + err, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { + SDB_STATIC_ARRAY_LEN(expected_bool_concat), + expected_bool_concat + } }, + }, + }, + { + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } }, + }, + { SDB_TYPE_BOOLEAN, { .boolean = true }, }, + err, + err, + err, + err, + err, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { + SDB_STATIC_ARRAY_LEN(expected_bool_append), + expected_bool_append + } }, + }, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true }, }, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } }, + }, + err, + err, + err, + err, + err, + { + SDB_TYPE_ARRAY | SDB_TYPE_BOOLEAN, + { .array = { + SDB_STATIC_ARRAY_LEN(expected_bool_prepend), + expected_bool_prepend + } }, + }, + }, { { SDB_TYPE_ARRAY | SDB_TYPE_INTEGER, @@ -1542,6 +1954,41 @@ START_TEST(test_expr_eval) err, }, /* unsupported type-mismatches */ + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_DECIMAL, { .decimal = 20.0 } }, + err, err, err, err, err, err, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_STRING, { .string = "20" } }, + err, err, err, err, err, err, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } }, + err, err, err, err, err, err, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } }, + err, err, err, err, err, err, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_REGEX, { .re = { ".", empty_re } } }, + err, err, err, err, err, err, + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + { SDB_TYPE_REGEX + 1, { .boolean = 0 } }, + err, err, err, err, err, err, + }, + { + { SDB_TYPE_DECIMAL, { .decimal = 20.0 } }, + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + err, err, err, err, err, err, + }, { { SDB_TYPE_INTEGER, { .integer = 20 } }, { SDB_TYPE_DECIMAL, { .decimal = 20.0 } }, @@ -1858,6 +2305,7 @@ END_TEST START_TEST(test_format) { + bool bool_values[] = { false, true, false }; int64_t int_values[] = { 47, 11, 23 }; char *string_values[] = { "foo", "bar", "qux", "baz" }; @@ -1865,6 +2313,18 @@ START_TEST(test_format) sdb_data_t datum; const char *expected; } golden_data[] = { + { + { SDB_TYPE_NULL, { .integer = 0 } }, + "NULL", + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = true } }, + "true", + }, + { + { SDB_TYPE_BOOLEAN, { .boolean = false } }, + "false", + }, { { SDB_TYPE_INTEGER, { .integer = 4711 } }, "4711", @@ -1912,6 +2372,13 @@ START_TEST(test_format) { SDB_TYPE_INTEGER | SDB_TYPE_ARRAY, { .array = { 0, NULL } } }, "[]", }, + { + { + SDB_TYPE_BOOLEAN | SDB_TYPE_ARRAY, + { .array = { SDB_STATIC_ARRAY_LEN(bool_values), bool_values } }, + }, + "[false, true, false]", + }, { { SDB_TYPE_INTEGER | SDB_TYPE_ARRAY, @@ -1933,10 +2400,11 @@ START_TEST(test_format) for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) { sdb_data_t *datum = &golden_data[i].datum; char buf[sdb_data_strlen(datum) + 2]; - int check; + size_t check_null, check; memset(buf, (int)'A', sizeof(buf)); + check_null = sdb_data_format(datum, NULL, 0, SDB_DOUBLE_QUOTED); check = sdb_data_format(datum, buf, sizeof(buf) - 1, SDB_DOUBLE_QUOTED); fail_unless(check > 0, @@ -1946,7 +2414,17 @@ START_TEST(test_format) "sdb_data_format(type=%s) used wrong format: %s; expected: %s", SDB_TYPE_TO_STRING(datum->type), buf, golden_data[i].expected); - fail_unless((size_t)check <= sizeof(buf) - 2, + fail_unless(check_null == check, + "sdb_data_format(type=%s, NULL) = %d; " + "expected %d (matching sdb_data_format(type=%s, ))", + SDB_TYPE_TO_STRING(datum->type), check_null, + check, SDB_TYPE_TO_STRING(datum->type)); + fail_unless(check == strlen(golden_data[i].expected), + "sdb_data_format(type=%s) = %d; expected %zu (strlen)", + SDB_TYPE_TO_STRING(datum->type), check, + strlen(golden_data[i].expected)); + + fail_unless(check <= sizeof(buf) - 2, "sdb_data_format(type=%s) wrote %d bytes; " "expected <= %zu based on sdb_data_strlen()", SDB_TYPE_TO_STRING(datum->type), check, sizeof(buf) - 2); @@ -1968,6 +2446,9 @@ START_TEST(test_parse) sdb_data_t result; int expected; } golden_data[] = { + { "true", { SDB_TYPE_BOOLEAN, { .boolean = true } }, 0 }, + { "FALSE", { SDB_TYPE_BOOLEAN, { .boolean = false } }, 0 }, + { "yes", { SDB_TYPE_BOOLEAN, { .boolean = false } }, -1 }, { "4711", { SDB_TYPE_INTEGER, { .integer = 4711 } }, 0 }, { "0x10", { SDB_TYPE_INTEGER, { .integer = 16 } }, 0 }, { "010", { SDB_TYPE_INTEGER, { .integer = 8 } }, 0 }, @@ -2005,30 +2486,25 @@ START_TEST(test_parse) golden_data[i].input, type); if (type == SDB_TYPE_STRING) - fail_unless(golden_data[i].input == result.data.string, - "sdb_data_parse(%s, %d, ) modified input string", + fail_unless(golden_data[i].input != result.data.string, + "sdb_data_parse(%s, %d, ) copied input string", golden_data[i].input, type); if (type == SDB_TYPE_BINARY) - fail_unless(golden_data[i].input == (char *)result.data.binary.datum, - "sdb_data_parse(%s, %d, ) modified input string", + fail_unless(golden_data[i].input != (char *)result.data.binary.datum, + "sdb_data_parse(%s, %d, ) copied input string", golden_data[i].input, type); - if (type == SDB_TYPE_REGEX) { + if (type == SDB_TYPE_REGEX) fail_unless(golden_data[i].input != result.data.re.raw, "sdb_data_parse(%s, %d, ) copied input string", golden_data[i].input, type); - sdb_data_free_datum(&result); - } + sdb_data_free_datum(&result); } } END_TEST -Suite * -core_data_suite(void) +TEST_MAIN("core::data") { - Suite *s = suite_create("core::data"); - TCase *tc; - - tc = tcase_create("core"); + TCase *tc = tcase_create("core"); tcase_add_test(tc, test_data); tcase_add_test(tc, test_cmp); tcase_add_test(tc, test_strcmp); @@ -2038,10 +2514,9 @@ core_data_suite(void) tcase_add_test(tc, test_expr_eval); tcase_add_test(tc, test_format); tcase_add_test(tc, test_parse); - suite_add_tcase(s, tc); - - return s; -} /* core_data_suite */ + ADD_TCASE(tc); +} +TEST_MAIN_END /* vim: set tw=78 sw=4 ts=4 noexpandtab : */