![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/t/utils/dbi_test.c b/t/utils/dbi_test.c
index 59cd46bf4b9ad8f0b50ecfea9f2c4810d21be991..9d45feb24341f03235223d2b2f8fe68d6ace0d3a 100644 (file)
--- a/t/utils/dbi_test.c
+++ b/t/utils/dbi_test.c
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
#include "libsysdb_test.h"
#include "utils/dbi.h"
*/
/* field definitions */
-static struct {
- unsigned short field_types[1];
- char *field_names[1];
-} rows1[] = {
- { { DBI_TYPE_INTEGER }, { "field0" }, },
+static unsigned short field_types[] = {
+ DBI_TYPE_INTEGER,
+ DBI_TYPE_DECIMAL,
+ DBI_TYPE_STRING,
+ DBI_TYPE_DATETIME,
+ DBI_TYPE_BINARY,
+};
+static char *field_names[] = {
+ "field0",
+ "field1",
+ "field2",
+ "field3",
+ "field4",
};
-static mock_data_t golden_data[][1] = {
- { { .integer = 1234 } },
- { { .integer = 2345 } },
- { { .integer = 3456 } },
- { { .integer = 4567 } },
- { { .integer = 5678 } },
+#define DATUM(p) ((const unsigned char *)(p))
+static mock_data_t golden_data[][5] = {
+ {
+ { .integer = 1234 },
+ { .decimal = 1.234 },
+ { .string = "abcd" },
+ { .datetime = 0 },
+ { .binary = { 1, DATUM("a") } },
+ },
+ {
+ { .integer = 2345 },
+ { .decimal = 23.45 },
+ { .string = "bcde" },
+ { .datetime = 1 },
+ { .binary = { 4, DATUM("bcde") } },
+ },
+ {
+ { .integer = 3456 },
+ { .decimal = 345.6 },
+ { .string = "cd" },
+ { .datetime = 2 },
+ { .binary = { 0, DATUM(NULL) } },
+ },
+ {
+ { .integer = 4567 },
+ { .decimal = 4567 },
+ { .string = "d" },
+ { .datetime = 3 },
+ { .binary = { 13, DATUM("defghijklmnop") } },
+ },
+ {
+ { .integer = 5678 },
+ { .decimal = 56.78 },
+ { .string = "efgh" },
+ { .datetime = 4 },
+ { .binary = { 5, DATUM("efghi") } },
+ },
};
/* query definitions */
static mock_query_t mock_queries[] = {
{ "mockquery0", 5, 1, 0, NULL, NULL },
- { "mockquery1", 0, 0, 1, rows1[0].field_types, rows1[0].field_names },
- { "mockquery2", 1, 1, 1, rows1[0].field_types, rows1[0].field_names },
- { "mockquery3", 5, 1, 1, rows1[0].field_types, rows1[0].field_names },
+ { "mockquery1", 0, 0, 1, field_types, field_names },
+ { "mockquery2", 1, 1, 1, field_types, field_names },
+ { "mockquery3", 2, 1, 1, field_types, field_names },
+ { "mockquery4", 5, 1, 1, field_types, field_names },
+ { "mockquery5", 5, 1, 2, field_types, field_names },
+ { "mockquery6", 5, 1, 3, field_types, field_names },
+ { "mockquery7", 5, 1, 4, field_types, field_names },
+ { "mockquery8", 5, 1, 5, field_types, field_names },
};
static mock_query_t *current_query = NULL;
return get_golden_data(res, i).string;
} /* dbi_result_get_string_idx */
+char *
+dbi_result_get_string_copy_idx(dbi_result res, unsigned int i)
+{
+ fail_unless(current_query->field_types[i - 1] == DBI_TYPE_STRING,
+ "dbi_result_get_string_copy_idx() called for non-string "
+ "column type %u", current_query->field_types[i - 1]);
+ if (! get_golden_data(res, i).string)
+ return NULL;
+ return strdup(get_golden_data(res, i).string);
+} /* dbi_result_get_string_copy_idx */
+
time_t
dbi_result_get_datetime_idx(dbi_result res, unsigned int i)
{
return get_golden_data(res, i).binary.datum;
} /* dbi_result_get_binary_idx */
+unsigned char *
+dbi_result_get_binary_copy_idx(dbi_result res, unsigned int i)
+{
+ const char *data;
+ fail_unless(current_query->field_types[i - 1] == DBI_TYPE_BINARY,
+ "dbi_result_get_binary_copy_idx() called for non-binary "
+ "column type %u", current_query->field_types[i - 1]);
+ data = (const char *)get_golden_data(res, i).binary.datum;
+ if (! data)
+ return NULL;
+ return (unsigned char *)strdup(data);
+} /* dbi_result_get_binary_copy_idx */
+
static unsigned long long dbi_result_free_called = 0;
int
dbi_result_free(dbi_result res)
client = sdb_dbi_client_create("mockdriver", "mockdatabase");
fail_unless(client != NULL,
"sdb_dbi_client_create() = NULL; expected client object");
+
+ dbi_conn_connect_called = 0;
} /* setup */
static void
client = NULL;
} /* teardown */
-static unsigned long long test_query_callback_called = 0;
+static unsigned long long query_callback_called = 0;
static int
-test_query_callback(sdb_dbi_client_t *c,
+query_callback(sdb_dbi_client_t *c,
size_t n, sdb_data_t *data, sdb_object_t *user_data)
{
size_t i;
- ++test_query_callback_called;
+ ++query_callback_called;
fail_unless(c == client,
"query callback received unexpected client = %p; "
data[i].data.decimal, i, expected_data.decimal);
break;
case SDB_TYPE_STRING:
- fail_unless(data[i].data.string == expected_data.string,
+ fail_unless(!strcmp(data[i].data.string, expected_data.string),
"query callback received unexpected data %s "
"for column %zu; expected: %s",
data[i].data.string, i, expected_data.string);
"binary data length %zu for column %zu; "
"expected: %lli", data[i].data.binary.length, i,
expected_data.binary.length);
- fail_unless(data[i].data.binary.datum ==
+ fail_unless(!memcmp(data[i].data.binary.datum,
expected_data.binary.datum,
+ expected_data.binary.length),
"query callback received unexpected binary data %p "
"for column %zu; expected: %p",
data[i].data.binary.datum, i,
}
}
return 0;
-} /* test_query_callback */
+} /* query_callback */
/*
* tests
*/
-START_TEST(test_client_connect)
+START_TEST(test_sdb_dbi_client_connect)
{
int check = sdb_dbi_client_connect(client);
fail_unless(check == 0,
}
END_TEST
-START_TEST(test_client_check_conn)
+START_TEST(test_sdb_dbi_client_check_conn)
{
int check = sdb_dbi_client_check_conn(client);
fail_unless(check == 0,
}
END_TEST
-START_TEST(test_exec_query)
+START_TEST(test_sdb_dbi_exec_query)
{
size_t i;
- int check = sdb_dbi_exec_query(client, "mockquery0", test_query_callback,
+ int check = sdb_dbi_exec_query(client, "mockquery0", query_callback,
/* user_data = */ TEST_MAGIC, /* n = */ 0);
/* not connected yet */
fail_unless(check < 0,
unsigned long long expected_callback_calls = 0;
dbi_conn_query_called = 0;
- test_query_callback_called = 0;
+ query_callback_called = 0;
dbi_result_free_called = 0;
- check = sdb_dbi_exec_query(client, q->name, test_query_callback,
+ /* sdb_dbi_exec_query will only use as many type arguments are needed,
+ * so we can safely pass in the maximum number of arguments required
+ * on each call */
+ check = sdb_dbi_exec_query(client, q->name, query_callback,
/* user_data = */ TEST_MAGIC, /* n = */ (int)q->nfields,
- SDB_TYPE_INTEGER);
+ SDB_TYPE_INTEGER, SDB_TYPE_DECIMAL, SDB_TYPE_STRING,
+ SDB_TYPE_DATETIME, SDB_TYPE_BINARY);
fail_unless(check == 0,
"sdb_dbi_exec_query() = %i; expected: 0", check);
if (q->nfields)
expected_callback_calls = q->nrows;
- fail_unless(test_query_callback_called == expected_callback_calls,
+ fail_unless(query_callback_called == expected_callback_calls,
"sdb_dbi_exec_query() did not call the registered callback "
"for each result row; got %i call%s; expected: 0",
- test_query_callback_called,
- (test_query_callback_called == 1) ? "" : "s");
+ query_callback_called,
+ (query_callback_called == 1) ? "" : "s");
fail_unless(dbi_result_free_called == 1,
"sdb_dbi_exec_query() did not free the query result object");
tc = tcase_create("core");
tcase_add_checked_fixture(tc, setup, teardown);
- tcase_add_test(tc, test_client_connect);
- tcase_add_test(tc, test_client_check_conn);
- tcase_add_test(tc, test_exec_query);
+ tcase_add_test(tc, test_sdb_dbi_client_connect);
+ tcase_add_test(tc, test_sdb_dbi_client_check_conn);
+ tcase_add_test(tc, test_sdb_dbi_exec_query);
suite_add_tcase(s, tc);
return s;