frontend/grammar: Implement '<obj> <op> <expr>' using new-style matchers.

[sysdb.git] / t / unit / frontend / parser_test.c

diff --git a/t/unit/frontend/parser_test.c b/t/unit/frontend/parser_test.c
index bcf00b22088ca27e3a3c3f1906cd660b665a91f5..6b9e86e95fd44d70d714276088c016ce9e577ed9 100644 (file)
--- a/t/unit/frontend/parser_test.c
+++ b/t/unit/frontend/parser_test.c
@@ -306,22 +306,27 @@ START_TEST(test_parse_matcher)
                { "",                             -1, -1 },
 
                /* valid expressions */
-               { "host = 'localhost'",           -1,  MATCHER_NAME },
-               { "host != 'localhost'",          -1,  MATCHER_NOT },
-               { "host =~ 'host'",               -1,  MATCHER_NAME },
-               { "host !~ 'host'",               -1,  MATCHER_NOT },
-               { "host = 'localhost' -- foo",    -1,  MATCHER_NAME },
-               { "host = 'host' <garbage>",      13,  MATCHER_NAME },
+               { "host = 'localhost'",           -1,  MATCHER_EQ },
+               { "host != 'localhost'",          -1,  MATCHER_NE },
+               { "host =~ 'host'",               -1,  MATCHER_REGEX },
+               { "host !~ 'host'",               -1,  MATCHER_NREGEX },
+               { "host = 'localhost' -- foo",    -1,  MATCHER_EQ },
+               { "host = 'host' <garbage>",      13,  MATCHER_EQ },
                /* match hosts by service */
-               { "service = 'name'",             -1,  MATCHER_NAME },
-               { "service != 'name'",            -1,  MATCHER_NOT },
-               { "service =~ 'pattern'",         -1,  MATCHER_NAME },
-               { "service !~ 'pattern'",         -1,  MATCHER_NOT },
+               { "service = 'name'",             -1,  MATCHER_SERVICE },
+               { "service != 'name'",            -1,  MATCHER_SERVICE },
+               { "service =~ 'pattern'",         -1,  MATCHER_SERVICE },
+               { "service !~ 'pattern'",         -1,  MATCHER_SERVICE },
+               /* match hosts by metric */
+               { "metric = 'name'",              -1,  MATCHER_METRIC },
+               { "metric != 'name'",             -1,  MATCHER_METRIC },
+               { "metric =~ 'pattern'",          -1,  MATCHER_METRIC },
+               { "metric !~ 'pattern'",          -1,  MATCHER_METRIC },
                /* match hosts by attribute */
-               { "attribute = 'name'",           -1,  MATCHER_NAME },
-               { "attribute != 'name'",          -1,  MATCHER_NOT },
-               { "attribute =~ 'pattern'",       -1,  MATCHER_NAME },
-               { "attribute !~ 'pattern'",       -1,  MATCHER_NOT },
+               { "attribute = 'name'",           -1,  MATCHER_ATTRIBUTE },
+               { "attribute != 'name'",          -1,  MATCHER_ATTRIBUTE },
+               { "attribute =~ 'pattern'",       -1,  MATCHER_ATTRIBUTE },
+               { "attribute !~ 'pattern'",       -1,  MATCHER_ATTRIBUTE },
                /* composite expressions */
                { "host =~ 'pattern' AND "
                  "service =~ 'pattern'",         -1,  MATCHER_AND },
@@ -329,39 +334,61 @@ START_TEST(test_parse_matcher)
                  "service =~ 'pattern'",         -1,  MATCHER_OR },
                { "NOT host = 'host'",            -1,  MATCHER_NOT },
                /* numeric expressions */
-               { "attribute['foo'] < 123",       -1,  MATCHER_CMP_LT },
-               { "attribute['foo'] <= 123",      -1,  MATCHER_CMP_LE },
-               { "attribute['foo'] = 123",       -1,  MATCHER_CMP_EQ },
-               { "attribute['foo'] >= 123",      -1,  MATCHER_CMP_GE },
-               { "attribute['foo'] > 123",       -1,  MATCHER_CMP_GT },
+               { "attribute['foo'] < 123",       -1,  MATCHER_LT },
+               { "attribute['foo'] <= 123",      -1,  MATCHER_LE },
+               { "attribute['foo'] = 123",       -1,  MATCHER_EQ },
+               { "attribute['foo'] >= 123",      -1,  MATCHER_GE },
+               { "attribute['foo'] > 123",       -1,  MATCHER_GT },
                /* datetime expressions */
                { "attribute['foo'] = "
-                 "2014-08-16",                   -1,  MATCHER_CMP_EQ },
+                 "2014-08-16",                   -1,  MATCHER_EQ },
                { "attribute['foo'] = "
-                 "17:23",                        -1,  MATCHER_CMP_EQ },
+                 "17:23",                        -1,  MATCHER_EQ },
                { "attribute['foo'] = "
-                 "17:23:53",                     -1,  MATCHER_CMP_EQ },
+                 "17:23:53",                     -1,  MATCHER_EQ },
                { "attribute['foo'] = "
-                 "17:23:53.123",                 -1,  MATCHER_CMP_EQ },
+                 "17:23:53.123",                 -1,  MATCHER_EQ },
                { "attribute['foo'] = "
-                 "17:23:53.123456789",           -1,  MATCHER_CMP_EQ },
+                 "17:23:53.123456789",           -1,  MATCHER_EQ },
                { "attribute['foo'] = "
-                 "2014-08-16 17:23",             -1,  MATCHER_CMP_EQ },
+                 "2014-08-16 17:23",             -1,  MATCHER_EQ },
                { "attribute['foo'] = "
-                 "2014-08-16 17:23:53",          -1,  MATCHER_CMP_EQ },
+                 "2014-08-16 17:23:53",          -1,  MATCHER_EQ },
                /* NULL; while this is an implementation detail,
                 * IS NULL currently maps to an equality matcher */
                { "attribute['foo'] IS NULL",     -1,  MATCHER_ISNULL },
                { "attribute['foo'] IS NOT NULL", -1,  MATCHER_ISNNULL },
 
                /* object field matchers */
-               { ".last_update < 10s",           -1,  MATCHER_CMP_LT },
-               { ".AGE <= 1m",                   -1,  MATCHER_CMP_LE },
-               { ".interval = 10h",              -1,  MATCHER_CMP_EQ },
-               { ".Last_Update >= 24D",          -1,  MATCHER_CMP_GE },
-               { ".age > 1M",                    -1,  MATCHER_CMP_GT },
-               { ".age != 20Y",                  -1,  MATCHER_CMP_NE },
-               { ".age <= 2 * .interval",        -1,  MATCHER_CMP_LE },
+               { ".name < 'a'",                  -1,  MATCHER_LT },
+               { ".name <= 'a'",                 -1,  MATCHER_LE },
+               { ".name = 'a'",                  -1,  MATCHER_EQ },
+               { ".name != 'a'",                 -1,  MATCHER_NE },
+               { ".name >= 'a'",                 -1,  MATCHER_GE },
+               { ".name > 'a'",                  -1,  MATCHER_GT },
+               { ".last_update < 2014-10-01",    -1,  MATCHER_LT },
+               { ".last_update <= 2014-10-01",   -1,  MATCHER_LE },
+               { ".last_update = 2014-10-01",    -1,  MATCHER_EQ },
+               { ".last_update != 2014-10-01",   -1,  MATCHER_NE },
+               { ".last_update >= 2014-10-01",   -1,  MATCHER_GE },
+               { ".last_update > 2014-10-01",    -1,  MATCHER_GT },
+               { ".Last_Update >= 24D",          -1,  MATCHER_GE },
+               { ".age < 20s",                   -1,  MATCHER_LT },
+               { ".age <= 20s",                  -1,  MATCHER_LE },
+               { ".age = 20s",                   -1,  MATCHER_EQ },
+               { ".age != 20s",                  -1,  MATCHER_NE },
+               { ".age >= 20s",                  -1,  MATCHER_GE },
+               { ".age > 20s",                   -1,  MATCHER_GT },
+               { ".AGE <= 1m",                   -1,  MATCHER_LE },
+               { ".age > 1M",                    -1,  MATCHER_GT },
+               { ".age != 20Y",                  -1,  MATCHER_NE },
+               { ".age <= 2 * .interval",        -1,  MATCHER_LE },
+               { ".interval < 20s",              -1,  MATCHER_LT },
+               { ".interval <= 20s",             -1,  MATCHER_LE },
+               { ".interval = 20s",              -1,  MATCHER_EQ },
+               { ".interval != 20s",             -1,  MATCHER_NE },
+               { ".interval >= 20s",             -1,  MATCHER_GE },
+               { ".interval > 20s",              -1,  MATCHER_GT },
                { "'be' IN .backend",             -1,  MATCHER_IN },
 
                /* check operator precedence */