t/: Use ck_assert() instead of assert() in all tests.

[sysdb.git] / t / unit / core / store_lookup_test.c

diff --git a/t/unit/core/store_lookup_test.c b/t/unit/core/store_lookup_test.c
index 642af72d92bffed59364085e6556d673cddcdf6c..b4c6015b7bfb0dcfe2d338eb05af51555491efca 100644 (file)
--- a/t/unit/core/store_lookup_test.c
+++ b/t/unit/core/store_lookup_test.c
@@ -31,11 +31,9 @@
 
 #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>
 
@@ -152,7 +150,7 @@ START_TEST(test_cmp_name)
 {
        sdb_store_obj_t *host;
        sdb_data_t datum;
-       sdb_store_expr_t *obj, *value;
+       sdb_store_expr_t *obj = NULL, *value;
        sdb_store_matcher_t *m, *n;
        int status;
 
@@ -163,10 +161,12 @@ START_TEST(test_cmp_name)
        datum.type = SDB_TYPE_STRING;
        datum.data.string = cmp_name_data[_i].name;
 
-       obj = sdb_store_expr_fieldvalue(SDB_FIELD_NAME);
-       fail_unless(obj != NULL,
-                       "sdb_store_expr_fieldvalue(SDB_STORE_NAME) = NULL; "
-                       "expected: <expr>");
+       if (cmp_name_data[_i].type == SDB_HOST) {
+               obj = sdb_store_expr_fieldvalue(SDB_FIELD_NAME);
+               fail_unless(obj != NULL,
+                               "sdb_store_expr_fieldvalue(SDB_STORE_NAME) = NULL; "
+                               "expected: <expr>");
+       }
        value = sdb_store_expr_constvalue(&datum);
        fail_unless(value != NULL,
                        "sdb_store_expr_constvalue(%s) = NULL; "
@@ -176,11 +176,14 @@ START_TEST(test_cmp_name)
                m = sdb_store_regex_matcher(obj, value);
        else
                m = sdb_store_eq_matcher(obj, value);
+
        if (cmp_name_data[_i].type != SDB_HOST) {
                sdb_store_expr_t *iter;
                sdb_store_matcher_t *tmp;
+               obj = sdb_store_expr_fieldvalue(SDB_FIELD_NAME);
                iter = sdb_store_expr_typed(cmp_name_data[_i].type, obj);
                tmp = sdb_store_any_matcher(iter, m);
+               ck_assert(iter && m);
                sdb_object_deref(SDB_OBJ(iter));
                sdb_object_deref(SDB_OBJ(m));
                m = tmp;
@@ -260,7 +263,7 @@ START_TEST(test_cmp_attr)
        };
 
        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");
        fail_unless(host != NULL,
@@ -368,7 +371,7 @@ START_TEST(test_cmp_obj)
        };
        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);
        fail_unless(host != NULL,
@@ -422,8 +425,8 @@ START_TEST(test_store_match_op)
        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;
@@ -564,11 +567,17 @@ struct {
        { "ANY attribute.name = 'x'", NULL,    0 },
        { "ANY attribute.name =~ 'x'", NULL,   0 },
        { "ALL attribute.name = 'k1'", NULL,   2 },
+       { "ANY attribute.value = 'v1'", NULL,  1 },
+       { "ANY attribute.value =~ 'v'", NULL,  2 },
+       { "ANY attribute.value = 123", NULL,   1 },
        { "host.name = 'a'", NULL,             1 },
        { "host.attribute['k1'] =~ 'v1'",
                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 },
@@ -584,8 +593,13 @@ struct {
        { "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 },
@@ -602,6 +616,7 @@ START_TEST(test_scan)
 {
        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;
@@ -612,17 +627,21 @@ START_TEST(test_scan)
        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));
        }