![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index b15809a589bc890dd36ff5c8809bdf71b75cfd84..c73ab3475bca6eb6b17b17565edd84e6601fe88b 100644 (file)
#endif
#include "core/store.h"
-#include "core/store-private.h"
+#include "core/memstore-private.h"
#include "parser/parser.h"
#include "testutils.h"
#include <check.h>
+static sdb_memstore_t *store;
+
static void
populate(void)
{
size_t i;
- sdb_store_init();
+ store = sdb_memstore_create();
+ ck_assert(store != NULL);
for (i = 0; i < SDB_STATIC_ARRAY_LEN(hosts); ++i) {
- int status = sdb_store_host(hosts[i], 1);
+ int status = sdb_memstore_host(store, hosts[i], 1, 0);
ck_assert(status == 0);
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(metrics); ++i) {
- int status = sdb_store_metric(metrics[i].host,
- metrics[i].metric, /* store */ NULL, 1);
+ int status = sdb_memstore_metric(store, metrics[i].host,
+ metrics[i].metric, /* store */ NULL, 1, 0);
ck_assert(status == 0);
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(services); ++i) {
- int status = sdb_store_service(services[i].host,
- services[i].service, 1);
+ int status = sdb_memstore_service(store, services[i].host,
+ services[i].service, 1, 0);
ck_assert(status == 0);
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(attrs); ++i) {
- int status = sdb_store_attribute(attrs[i].host,
- attrs[i].name, &attrs[i].value, 1);
+ int status = sdb_memstore_attribute(store, attrs[i].host,
+ attrs[i].name, &attrs[i].value, 1, 0);
ck_assert(status == 0);
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(svc_attrs); ++i) {
- int status = sdb_store_service_attr(svc_attrs[i].host,
+ int status = sdb_memstore_service_attr(store, svc_attrs[i].host,
svc_attrs[i].service, svc_attrs[i].name,
- &svc_attrs[i].value, 1);
+ &svc_attrs[i].value, 1, 0);
ck_assert(status == 0);
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(metric_attrs); ++i) {
- int status = sdb_store_metric_attr(metric_attrs[i].host,
+ int status = sdb_memstore_metric_attr(store, metric_attrs[i].host,
metric_attrs[i].metric, metric_attrs[i].name,
- &metric_attrs[i].value, 1);
+ &metric_attrs[i].value, 1, 0);
ck_assert(status == 0);
}
} /* populate */
+static void
+turndown(void)
+{
+ sdb_object_deref(SDB_OBJ(store));
+ store = NULL;
+} /* turndown */
+
#define NAME { SDB_TYPE_INTEGER, { .integer = SDB_FIELD_NAME } }
#define LAST_UPDATE { SDB_TYPE_INTEGER, { .integer = SDB_FIELD_LAST_UPDATE } }
#define AGE { SDB_TYPE_INTEGER, { .integer = SDB_FIELD_AGE } }
#define SERVICES { SDB_TYPE_INTEGER, { .integer = SDB_SERVICE } }
#define METRICS { SDB_TYPE_INTEGER, { .integer = SDB_METRIC } }
#define ATTRS { SDB_TYPE_INTEGER, { .integer = SDB_ATTRIBUTE } }
-static sdb_store_expr_t namer = {
+static sdb_memstore_expr_t namer = {
SDB_OBJECT_INIT, FIELD_VALUE, -1, NULL, NULL, NAME,
};
static int64_t int_values[] = { 1, 2, 3, 4, 5 };
unsigned char *datum;
} bin_values[] = { { 4, (unsigned char *)"\3\2\0\1" } };
struct {
- sdb_store_expr_t expr;
+ sdb_memstore_expr_t expr;
bool iterable;
char *host;
{ SDB_OBJECT_INIT, TYPED_EXPR, -1, &namer, NULL, ATTRS }, true,
"a", SDB_SERVICE, "s1", NULL,
{
- { SDB_TYPE_STRING, { .string = "hostname" } },
{ SDB_TYPE_STRING, { .string = "k1" } },
{ 0 },
{ 0 },
{ 0 },
- }, 2,
+ { 0 },
+ }, 1,
},
{
{ SDB_OBJECT_INIT, TYPED_EXPR, -1, &namer, NULL, ATTRS }, true,
"a", SDB_SERVICE, "s1", "age >= 0s",
{
- { SDB_TYPE_STRING, { .string = "hostname" } },
{ SDB_TYPE_STRING, { .string = "k1" } },
{ 0 },
{ 0 },
{ 0 },
- }, 2,
+ { 0 },
+ }, 1,
},
{
{ SDB_OBJECT_INIT, TYPED_EXPR, -1, &namer, NULL, ATTRS }, true,
{ SDB_OBJECT_INIT, TYPED_EXPR, -1, &namer, NULL, ATTRS }, true,
"b", SDB_METRIC, "m2", NULL,
{
- { SDB_TYPE_STRING, { .string = "hostname" } },
{ SDB_TYPE_STRING, { .string = "k1" } },
{ SDB_TYPE_STRING, { .string = "k2" } },
{ 0 },
{ 0 },
- }, 3,
+ { 0 },
+ }, 2,
},
{
{ SDB_OBJECT_INIT, TYPED_EXPR, -1, &namer, NULL, ATTRS }, true,
"b", SDB_METRIC, "m2", "age >= 0s",
{
- { SDB_TYPE_STRING, { .string = "hostname" } },
{ SDB_TYPE_STRING, { .string = "k1" } },
{ SDB_TYPE_STRING, { .string = "k2" } },
{ 0 },
{ 0 },
- }, 3,
+ { 0 },
+ }, 2,
},
{
{ SDB_OBJECT_INIT, TYPED_EXPR, -1, &namer, NULL, ATTRS }, true,
START_TEST(test_expr_iter)
{
- sdb_store_obj_t *obj = NULL;
- sdb_store_matcher_t *filter = NULL;
+ sdb_memstore_obj_t *obj = NULL;
+ sdb_memstore_matcher_t *filter = NULL;
int context = SDB_HOST;
- bool iterable;
- sdb_store_expr_iter_t *iter;
+ sdb_memstore_expr_iter_t *iter;
size_t i;
if (expr_iter_data[_i].host) {
- obj = sdb_store_get_host(expr_iter_data[_i].host);
+ obj = sdb_memstore_get_host(store, expr_iter_data[_i].host);
ck_assert(obj != NULL);
if (expr_iter_data[_i].child) {
- sdb_store_obj_t *child = sdb_store_get_child(obj,
+ sdb_memstore_obj_t *child = sdb_memstore_get_child(obj,
expr_iter_data[_i].child_type, expr_iter_data[_i].child);
ck_assert(child != NULL);
sdb_object_deref(SDB_OBJ(obj));
if (expr_iter_data[_i].filter) {
sdb_ast_node_t *ast;
- ast = sdb_parser_parse_conditional(expr_iter_data[_i].filter, -1, NULL);
- filter = sdb_store_query_prepare_matcher(ast);
+ ast = sdb_parser_parse_conditional(context, expr_iter_data[_i].filter, -1, NULL);
+ filter = sdb_memstore_query_prepare_matcher(ast);
sdb_object_deref(SDB_OBJ(ast));
ck_assert(filter != NULL);
}
- iterable = sdb_store_expr_iterable(&expr_iter_data[_i].expr, context);
- fail_unless(iterable == expr_iter_data[_i].iterable,
- "%s expression not iterable in %s context",
- EXPR_TO_STRING(&expr_iter_data[_i].expr),
- SDB_STORE_TYPE_TO_NAME(context));
-
- iter = sdb_store_expr_iter(&expr_iter_data[_i].expr, obj, filter);
- fail_unless((iter != NULL) == iterable,
- "sdb_store_expr_iter(%s expression, %s, %s) = %s; expected: %s",
+ iter = sdb_memstore_expr_iter(&expr_iter_data[_i].expr, obj, filter);
+ fail_unless((iter != NULL) == expr_iter_data[_i].iterable,
+ "sdb_memstore_expr_iter(%s expression, %s, %s) = %s; expected: %s",
EXPR_TO_STRING(&expr_iter_data[_i].expr),
obj ? SDB_STORE_TYPE_TO_NAME(obj->type) : "<array>",
expr_iter_data[_i].filter, iter ? "<iter>" : "NULL",
- iterable ? "<iter>" : "NULL");
+ expr_iter_data[_i].iterable ? "<iter>" : "NULL");
/* the iterator will keep a reference */
sdb_object_deref(SDB_OBJ(obj)); obj = NULL;
sdb_object_deref(SDB_OBJ(filter)); filter = NULL;
i = 0;
- while (sdb_store_expr_iter_has_next(iter)) {
+ while (sdb_memstore_expr_iter_has_next(iter)) {
char v_str[64], expected_str[64];
sdb_data_t v;
SDB_STORE_TYPE_TO_NAME(context), expr_iter_data[_i].filter,
i + 1, expr_iter_data[_i].expected_len);
- v = sdb_store_expr_iter_get_next(iter);
+ v = sdb_memstore_expr_iter_get_next(iter);
sdb_data_format(&v, v_str, sizeof(v_str), SDB_DOUBLE_QUOTED);
sdb_data_format(&expr_iter_data[_i].expected[i],
expected_str, sizeof(expected_str), SDB_DOUBLE_QUOTED);
"expected: %zu", EXPR_TO_STRING(&expr_iter_data[_i].expr),
SDB_STORE_TYPE_TO_NAME(context), expr_iter_data[_i].filter,
i, expr_iter_data[_i].expected_len);
- fail_unless(sdb_store_expr_iter_get_next(iter).type == SDB_TYPE_NULL,
+ fail_unless(sdb_memstore_expr_iter_get_next(iter).type == SDB_TYPE_NULL,
"iter<%s expression, %s, %s> returned further elements "
"passed the end", EXPR_TO_STRING(&expr_iter_data[_i].expr),
SDB_STORE_TYPE_TO_NAME(context), expr_iter_data[_i].filter);
- sdb_store_expr_iter_destroy(iter);
+ sdb_memstore_expr_iter_destroy(iter);
}
END_TEST
TEST_MAIN("core::store_expr")
{
TCase *tc = tcase_create("core");
- tcase_add_checked_fixture(tc, populate, sdb_store_clear);
+ tcase_add_checked_fixture(tc, populate, turndown);
TC_ADD_LOOP_TEST(tc, expr_iter);
ADD_TCASE(tc);
}