index 3555495d79e4dfd681cf5ad5dc6220ade578a5ea..9f486836aaec3daf85818ed07c7d17c67c327c63 100644 (file)
# include "config.h"
#endif
+#include "core/plugin.h"
#include "core/store.h"
#include "core/store-private.h"
-#include "frontend/parser.h"
+#include "parser/parser.h"
#include "testutils.h"
-#include <assert.h>
-
#include <check.h>
#include <string.h>
+static sdb_store_t *store;
+
static void
populate(void)
{
size_t i;
+ store = sdb_store_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_store_host(store, hosts[i], 1);
fail_unless(status == 0,
"sdb_store_host(%s, 1) = %d; expected: 0",
hosts[i], status);
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(metrics); ++i) {
- int status = sdb_store_metric(metrics[i].host,
+ int status = sdb_store_metric(store, metrics[i].host,
metrics[i].metric, /* store */ NULL, 1);
fail_unless(status == 0,
"sdb_store_metric(%s, %s, NULL, 1) = %d; expected: 0",
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(services); ++i) {
- int status = sdb_store_service(services[i].host,
+ int status = sdb_store_service(store, services[i].host,
services[i].service, 1);
fail_unless(status == 0,
"sdb_store_service(%s, %s, 1) = %d; expected: 0",
}
for (i = 0; i < SDB_STATIC_ARRAY_LEN(attrs); ++i) {
- int status = sdb_store_attribute(attrs[i].host,
+ int status = sdb_store_attribute(store, attrs[i].host,
attrs[i].name, &attrs[i].value, 1);
fail_unless(status == 0,
"sdb_store_attribute(%s, %s, <val>, 1) = %d; expected: 0",
}
} /* populate */
+static void
+turndown(void)
+{
+ sdb_object_deref(SDB_OBJ(store));
+ store = NULL;
+} /* turndown */
+
struct {
int type;
char *name;
sdb_store_matcher_t *m, *n;
int status;
- host = sdb_store_get_host("a");
+ host = sdb_store_get_host(store, "a");
fail_unless(host != NULL,
"sdb_store_get_host(a) = NULL; expected: <host>");
};
const char *op_str[] = { "<", "<=", "=", ">=", ">" };
- assert(SDB_STATIC_ARRAY_LEN(tests) == SDB_STATIC_ARRAY_LEN(op_str));
+ ck_assert(SDB_STATIC_ARRAY_LEN(tests) == SDB_STATIC_ARRAY_LEN(op_str));
- host = sdb_store_get_host("a");
+ host = sdb_store_get_host(store, "a");
fail_unless(host != NULL,
"sdb_store_get_host(a) = NULL; expected: <host>");
};
char *op_str[] = { "<", "<=", "=", ">=", ">" };
- assert(SDB_STATIC_ARRAY_LEN(tests) == SDB_STATIC_ARRAY_LEN(op_str));
+ ck_assert(SDB_STATIC_ARRAY_LEN(tests) == SDB_STATIC_ARRAY_LEN(op_str));
- host = sdb_store_get_host(cmp_obj_data[_i].host);
+ host = sdb_store_get_host(store, cmp_obj_data[_i].host);
fail_unless(host != NULL,
"sdb_store_get_host(%s) = NULL; expected: <host>",
cmp_obj_data[_i].host);
sdb_data_t d = { SDB_TYPE_STRING, { .string = "a" } };
sdb_store_expr_t *e = sdb_store_expr_constvalue(&d);
- sdb_store_matcher_t *always = sdb_store_isnnull_matcher(e);
sdb_store_matcher_t *never = sdb_store_isnull_matcher(e);
+ sdb_store_matcher_t *always = sdb_store_inv_matcher(never);
struct {
const char *op;
int status;
size_t i;
- obj = sdb_store_get_host("a");
+ obj = sdb_store_get_host(store, "a");
status = sdb_store_matcher_matches(always, obj, /* filter */ NULL);
fail_unless(status == 1,
NULL, 1 },
{ "host.attribute['x1'] IS NULL",
NULL, 3 },
+ /* not a boolean so neither TRUE nor FALSE: */
+ { "attribute['k1'] IS TRUE", NULL, 0 },
+ { "attribute['k1'] IS FALSE", NULL, 0 },
{ "attribute['k1'] = 'v1'", NULL, 1 },
{ "attribute['k1'] = 'v1'",
"name != 'k1'", 0 },
{ "attribute['x1'] !~ 'v'", NULL, 0 },
{ "attribute['k1'] IS NULL", NULL, 1 },
{ "attribute['x1'] IS NULL", NULL, 3 },
+ { "attribute['k1'] IS TRUE", NULL, 0 },
+ { "attribute['x1'] IS TRUE", NULL, 0 },
+ { "attribute['k1'] IS FALSE", NULL, 0 },
+ { "attribute['x1'] IS FALSE", NULL, 0 },
{ "attribute['k1'] IS NOT NULL", NULL, 2 },
{ "attribute['x1'] IS NOT NULL", NULL, 0 },
+ { "attribute['x1'] IS NOT TRUE", NULL, 3 },
{ "attribute['k2'] < 123", NULL, 0 },
{ "attribute['k2'] <= 123", NULL, 1 },
{ "attribute['k2'] >= 123", NULL, 1 },
{
sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
sdb_store_matcher_t *m, *filter = NULL;
+ sdb_ast_node_t *ast;
int check, n;
n = 0;
- check = sdb_store_scan(SDB_HOST, /* matcher */ NULL, /* filter */ NULL,
+ check = sdb_store_scan(store, SDB_HOST,
+ /* matcher */ NULL, /* filter */ NULL,
scan_cb, &n);
fail_unless(check == 0,
"sdb_store_scan() = %d; expected: 0", check);
fail_unless(n == 3,
"sdb_store_scan called callback %d times; expected: 3", (int)n);
- m = sdb_fe_parse_matcher(scan_data[_i].query, -1, errbuf);
+ ast = sdb_parser_parse_conditional(scan_data[_i].query, -1, errbuf);
+ m = sdb_store_query_prepare_matcher(ast);
+ sdb_object_deref(SDB_OBJ(ast));
fail_unless(m != NULL,
- "sdb_fe_parse_matcher(%s, -1) = NULL; expected: <matcher> "
+ "sdb_parser_parse_conditional(%s, -1) = NULL; expected: <ast> "
"(parser error: %s)", scan_data[_i].query,
sdb_strbuf_string(errbuf));
if (scan_data[_i].filter) {
- filter = sdb_fe_parse_matcher(scan_data[_i].filter, -1, errbuf);
+ ast = sdb_parser_parse_conditional(scan_data[_i].filter, -1, errbuf);
+ filter = sdb_store_query_prepare_matcher(ast);
+ sdb_object_deref(SDB_OBJ(ast));
fail_unless(filter != NULL,
- "sdb_fe_parse_matcher(%s, -1) = NULL; "
- "expected: <matcher> (parser error: %s)",
+ "sdb_parser_parse_conditional(%s, -1) = NULL; "
+ "expected: <ast> (parser error: %s)",
scan_data[_i].filter, sdb_strbuf_string(errbuf));
}
n = 0;
- sdb_store_scan(SDB_HOST, m, filter, scan_cb, &n);
+ sdb_store_scan(store, SDB_HOST, m, filter, scan_cb, &n);
fail_unless(n == scan_data[_i].expected,
"sdb_store_scan(HOST, matcher{%s}, filter{%s}) "
"found %d hosts; expected: %d", scan_data[_i].query,
TEST_MAIN("core::store_lookup")
{
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, cmp_name);
TC_ADD_LOOP_TEST(tc, cmp_attr);
TC_ADD_LOOP_TEST(tc, cmp_obj);