Code

store, frontend: Make IS (NOT) NULL an unary operator on expressions.
[sysdb.git] / t / unit / core / store_lookup_test.c
index a2b159557142b0534fdf3dbf3e523f851e85eac9..2e1e6d8b1a536dddffd341cde2e4f0a50611c76b 100644 (file)
@@ -371,6 +371,12 @@ START_TEST(test_obj_cond)
                const sdb_data_t value;
                int expected_lt, expected_le, expected_eq, expected_ge, expected_gt;
        } golden_data[] = {
+               { "b", SDB_FIELD_NAME,
+                       { SDB_TYPE_STRING, { .string = "a" } },   0, 0, 0, 1, 1 },
+               { "b", SDB_FIELD_NAME,
+                       { SDB_TYPE_STRING, { .string = "b" } },   0, 1, 1, 1, 0 },
+               { "b", SDB_FIELD_NAME,
+                       { SDB_TYPE_STRING, { .string = "c" } },   1, 1, 0, 0, 0 },
                /* last-update = 1 for all objects */
                { "a", SDB_FIELD_LAST_UPDATE,
                        { SDB_TYPE_DATETIME, { .datetime = 1 } }, 0, 1, 1, 1, 0 },
@@ -453,7 +459,7 @@ START_TEST(test_obj_cond)
 
                        status = sdb_store_matcher_matches(m, obj, /* filter */ NULL);
                        fail_unless(status == tests[j].expected,
-                                       "sdb_store_matcher_matches(%s, <obj>, NULL) = %d; "
+                                       "sdb_store_matcher_matches(%s, <host '%s'>, NULL) = %d; "
                                        "expected: %d",
                                        sdb_store_matcher_tostring(m, m_str, sizeof(m_str)),
                                        status, tests[j].expected);
@@ -618,8 +624,6 @@ START_TEST(test_parse_cmp)
 /*             { "attribute", "attr", "=",  &attrname,   MATCHER_EQ }, */
                { "attribute", "attr", ">=", &attrname,   MATCHER_GE },
                { "attribute", "attr", ">",  &attrname,   MATCHER_GT },
-               { "attribute", "attr", "IS", NULL,        MATCHER_ISNULL },
-               { "attribute", "attr", "IS", &attrname,   -1 },
                { "foo",       NULL,   "=",  &attrname,   -1 },
                { "foo",       "attr", "=",  &attrname,   -1 },
        };
@@ -651,7 +655,7 @@ START_TEST(test_parse_cmp)
 
                fail_unless(check != NULL,
                                "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) = %p; "
-                               "expected: NULL", golden_data[i].obj_type,
+                               "expected: <expr>", golden_data[i].obj_type,
                                golden_data[i].attr, golden_data[i].op, buf, check);
                fail_unless(M(check)->type == golden_data[i].expected,
                                "sdb_store_matcher_parse_cmp(%s, %s, %s, %s) returned matcher "
@@ -675,6 +679,12 @@ START_TEST(test_parse_field_cmp)
                const sdb_data_t *value;
                int expected;
        } golden_data[] = {
+               { "name",        "<",  &string,   MATCHER_LT },
+               { "name",        "<=", &string,   MATCHER_LE },
+               { "name",        "=",  &string,   MATCHER_EQ },
+               { "name",        ">=", &string,   MATCHER_GE },
+               { "name",        ">",  &string,   MATCHER_GT },
+               { "name",        "!=", &string,   MATCHER_NOT },
                { "last_update", "<",  &datetime, MATCHER_LT },
                { "last_update", "<=", &datetime, MATCHER_LE },
                { "last_update", "=",  &datetime, MATCHER_EQ },
@@ -695,7 +705,7 @@ START_TEST(test_parse_field_cmp)
                { "interval",    "!=", &datetime, MATCHER_NOT },
                { "backend",     "=",  &string,   MATCHER_EQ },
                { "backend",     "!=", &string,   MATCHER_NOT },
-               /* the behavior for other operators on :backend
+               /* the behavior for other operators on .backend
                 * is currently unspecified */
                { "last_update", "=",  NULL,      -1 },
                { "last_update", "IS", NULL,      -1 },
@@ -773,80 +783,80 @@ START_TEST(test_scan)
                int expected;
                const char *tostring_re;
        } golden_data[] = {
-               { "host = 'a'", NULL,               1,
+               { "host = 'a'", NULL,                1,
                        "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
-               { "host = 'a'", "host = 'x'",       0, /* filter never matches */
+               { "host = 'a'", "host = 'x'",        0, /* filter never matches */
                        "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
                { "host = 'a'",
-                       "NOT attribute.x = ''",         1, /* filter always matches */
+                       "NOT attribute[x] = ''",         1, /* filter always matches */
                        "OBJ\\[host\\]\\{ NAME\\{ 'a', \\(nil\\) \\} \\}" },
-               { "host =~ 'a|b'", NULL,            2,
+               { "host =~ 'a|b'", NULL,             2,
                        "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
-               { "host =~ 'host'", NULL,           0,
+               { "host =~ 'host'", NULL,            0,
                        "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
-               { "host =~ '.'", NULL,              3,
+               { "host =~ '.'", NULL,               3,
                        "OBJ\\[host\\]\\{ NAME\\{ NULL, "PTR_RE" \\} \\}" },
-               { "metric = 'm1'", NULL,            2,
+               { "metric = 'm1'", NULL,             2,
                        "OBJ\\[metric\\]\\{ NAME\\{ 'm1', \\(nil\\) } \\}" },
-               { "metric= 'm1'", "host = 'x'",     0, /* filter never matches */
+               { "metric= 'm1'", "host = 'x'",      0, /* filter never matches */
                        "OBJ\\[metric\\]\\{ NAME\\{ 'm1', \\(nil\\) } \\}" },
                { "metric = 'm1'",
-                       "NOT attribute.x = ''",         2, /* filter always matches */
+                       "NOT attribute[x] = ''",         2, /* filter always matches */
                        "OBJ\\[metric\\]\\{ NAME\\{ 'm1', \\(nil\\) } \\}" },
-               { "metric =~ 'm'", NULL,            2,
+               { "metric =~ 'm'", NULL,             2,
                        "OBJ\\[metric\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
-               { "metric !~ 'm'", NULL,            1,
+               { "metric !~ 'm'", NULL,             1,
                        "\\(NOT, OBJ\\[metric\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}\\)" },
-               { "metric =~ 'x'", NULL,            0,
+               { "metric =~ 'x'", NULL,             0,
                        "OBJ\\[metric\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
-               { "service = 's1'", NULL,           2,
+               { "service = 's1'", NULL,            2,
                        "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
-               { "service = 's1'", "host = 'x'",   0, /* filter never matches */
+               { "service = 's1'", "host = 'x'",    0, /* filter never matches */
                        "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
                { "service = 's1'",
-                       "NOT attribute.x = ''",         2, /* filter always matches */
+                       "NOT attribute[x] = ''",         2, /* filter always matches */
                        "OBJ\\[service\\]\\{ NAME\\{ 's1', \\(nil\\) } \\}" },
-               { "service =~ 's'", NULL,           2,
+               { "service =~ 's'", NULL,            2,
                        "OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}" },
-               { "service !~ 's'", NULL,           1,
+               { "service !~ 's'", NULL,            1,
                        "\\(NOT, OBJ\\[service\\]\\{ NAME\\{ NULL, "PTR_RE" } \\}\\)" },
-               { "attribute = 'k1'", NULL,         1,
+               { "attribute = 'k1'", NULL,          1,
                        "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
-               { "attribute = 'k1'", "host = 'x'", 0, /* filter never matches */
+               { "attribute = 'k1'", "host = 'x'",  0, /* filter never matches */
                        "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
                { "attribute = 'k1'",
-                       "NOT attribute.x = ''",         1, /* filter always matches */
+                       "NOT attribute[x] = ''",         1, /* filter always matches */
                        "OBJ\\[attribute\\]\\{ NAME\\{ 'k1', \\(nil\\) \\} " },
-               { "attribute = 'x'", NULL,          0,
+               { "attribute = 'x'", NULL,           0,
                        "OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\}" },
-               { "attribute.k1 = 'v1'", NULL,      1,
+               { "attribute[k1] = 'v1'", NULL,      1,
                        "ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}" },
-               { "attribute.k1 IS NULL", NULL,     2,
-                       "\\(IS NULL, ATTR\\[k1\\]\\)" },
-               { "attribute.x1 IS NULL", NULL,     3,
-                       "\\(IS NULL, ATTR\\[x1\\]\\)" },
-               { "attribute.k1 IS NOT NULL", NULL, 1,
-                       "\\(NOT, \\(IS NULL, ATTR\\[k1\\]\\)\\)" },
-               { "attribute.x1 IS NOT NULL", NULL, 0,
-                       "\\(NOT, \\(IS NULL, ATTR\\[x1\\]\\)\\)" },
-               { "attribute.k2 < 123", NULL,       0,
+               { "attribute[k1] IS NULL", NULL,     2,
+                       "\\(IS NULL\\)" },
+               { "attribute[x1] IS NULL", NULL,     3,
+                       "\\(IS NULL\\)" },
+               { "attribute[k1] IS NOT NULL", NULL, 1,
+                       "\\(IS NOT NULL\\)" },
+               { "attribute[x1] IS NOT NULL", NULL, 0,
+                       "\\(IS NOT NULL\\)" },
+               { "attribute[k2] < 123", NULL,       0,
                        "ATTR\\[k2\\]\\{ < 123 \\}" },
-               { "attribute.k2 <= 123", NULL,      1,
+               { "attribute[k2] <= 123", NULL,      1,
                        "ATTR\\[k2\\]\\{ <= 123 \\}" },
-               { "attribute.k2 >= 123", NULL,      1,
+               { "attribute[k2] >= 123", NULL,      1,
                        "ATTR\\[k2\\]\\{ >= 123 \\}" },
-               { "attribute.k2 > 123", NULL,       0,
+               { "attribute[k2] > 123", NULL,       0,
                        "ATTR\\[k2\\]\\{ > 123 \\}" },
-               { "attribute.k2 = 123", NULL,       1,
+               { "attribute[k2] = 123", NULL,       1,
                        "ATTR\\[k2\\]\\{ = 123 \\}" },
-               { "attribute.k2 != 123", NULL,      2,
+               { "attribute[k2] != 123", NULL,      2,
                        "\\(NOT, ATTR\\[k2\\]\\{ = 123 \\}\\)" },
-               { "attribute.k1 != 'v1'", NULL,     2,
+               { "attribute[k1] != 'v1'", NULL,     2,
                        "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}\\)" },
-               { "attribute.k1 != 'v2'", NULL,     3,
+               { "attribute[k1] != 'v2'", NULL,     3,
                        "\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v2', \\(nil\\) \\} \\}\\)" },
                { "attribute != 'x' "
-                 "AND attribute.y !~ 'x'", NULL,   3,
+                 "AND attribute[y] !~ 'x'", NULL,   3,
                        "\\(AND, "
                                "\\(NOT, OBJ\\[attribute\\]\\{ NAME\\{ 'x', \\(nil\\) \\} \\}\\), "
                                "\\(NOT, ATTR\\[y\\]\\{ VALUE\\{ NULL, "PTR_RE" \\} \\}\\)\\)" },