X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=t%2Funit%2Fcore%2Fstore_lookup_test.c;h=f9ffabe6d08d39632bb6823cc728af8eb9b6f465;hb=241a7b9ab622e84960471bc9c70fbedccbbdff2d;hp=b356fa0dd7b95858bddc93767a26ce4890136d23;hpb=dd74510898e5a480fc18a1acad7aa4196f732efe;p=sysdb.git

diff --git a/t/unit/core/store_lookup_test.c b/t/unit/core/store_lookup_test.c
index b356fa0..f9ffabe 100644
--- a/t/unit/core/store_lookup_test.c
+++ b/t/unit/core/store_lookup_test.c
@@ -64,6 +64,7 @@ populate(void)
 	} attrs[] = {
 		{ "a", "k1", { SDB_TYPE_STRING, { .string = "v1" } } },
 		{ "a", "k2", { SDB_TYPE_INTEGER, { .integer = 123 } } },
+		{ "b", "k1", { SDB_TYPE_STRING, { .string = "v2" } } },
 	};
 
 	size_t i;
@@ -287,6 +288,7 @@ START_TEST(test_attr_cond)
 		{ "k1", { SDB_TYPE_STRING,  { .string  = "v1" } },  0, 1, 1, 1, 0 },
 		{ "k1", { SDB_TYPE_STRING,  { .string  = "v2" } },  1, 1, 0, 0, 0 },
 		{ "k1", { SDB_TYPE_STRING,  { .string  = "v0" } },  0, 0, 0, 1, 1 },
+		{ "k1", { SDB_TYPE_STRING,  { .string  = "0" } },   0, 0, 0, 1, 1 },
 		{ "k2", { SDB_TYPE_INTEGER, { .integer = 123 } },   0, 1, 1, 1, 0 },
 		{ "k2", { SDB_TYPE_INTEGER, { .integer = 124 } },   1, 1, 0, 0, 0 },
 		{ "k2", { SDB_TYPE_INTEGER, { .integer = 122 } },   0, 0, 0, 1, 1 },
@@ -295,8 +297,8 @@ START_TEST(test_attr_cond)
 		{ "k3", { SDB_TYPE_STRING,  { .string  = "123" } }, 0, 0, 0, 0, 0 },
 		{ "k3", { SDB_TYPE_INTEGER, { .integer = 123 } },   0, 0, 0, 0, 0 },
 		/* type mismatch */
-		{ "k1", { SDB_TYPE_INTEGER, { .integer = 0 } },     0, 0, 0, 0, 0 },
-		{ "k2", { SDB_TYPE_STRING,  { .string  = "123" } }, 0, 0, 0, 0, 0 },
+		{ "k1", { SDB_TYPE_INTEGER, { .integer = 0 } },     0, 0, 0, 1, 1 },
+		{ "k2", { SDB_TYPE_STRING,  { .string  = "123" } }, 0, 1, 1, 1, 0 },
 	};
 
 	int status;
@@ -370,6 +372,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 },
@@ -394,6 +402,12 @@ START_TEST(test_obj_cond)
 			{ SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
 		{ "a", SDB_FIELD_BACKEND,
 			{ SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
+		{ "a", SDB_FIELD_BACKEND,
+			{ SDB_TYPE_INTEGER, { .integer = 0 } }, 0, 0, 0, 0, 0 },
+		/* (64bit) integer value without zero-bytes */
+		{ "a", SDB_FIELD_BACKEND,
+			{ SDB_TYPE_INTEGER, { .integer = 0xffffffffffffffffL } },
+			0, 0, 0, 0, 0 },
 	};
 
 	int status;
@@ -446,7 +460,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);
@@ -532,10 +546,11 @@ END_TEST
 
 START_TEST(test_parse_cmp)
 {
-	sdb_data_t hostname   = { SDB_TYPE_STRING, { .string = "hostname" } };
-	sdb_data_t metricname = { SDB_TYPE_STRING, { .string = "metricname" } };
-	sdb_data_t srvname    = { SDB_TYPE_STRING, { .string = "srvname" } };
-	sdb_data_t attrname   = { SDB_TYPE_STRING, { .string = "attrname" } };
+	sdb_data_t hostname   = { SDB_TYPE_STRING,  { .string  = "hostname" } };
+	sdb_data_t metricname = { SDB_TYPE_STRING,  { .string  = "metricname" } };
+	sdb_data_t srvname    = { SDB_TYPE_STRING,  { .string  = "srvname" } };
+	sdb_data_t attrname   = { SDB_TYPE_STRING,  { .string  = "attrname" } };
+	sdb_data_t attrvalue  = { SDB_TYPE_INTEGER, { .integer = 4711 } };
 
 	sdb_store_matcher_t *check;
 
@@ -554,6 +569,8 @@ START_TEST(test_parse_cmp)
 		{ "host",      NULL,   "!~", &hostname,   MATCHER_NOT },
 		{ "host",      "attr", "=",  &hostname,   -1 },
 		{ "host",      "attr", "!=", &hostname,   -1 },
+		{ "host",      "attr", "!=", &attrvalue,  -1 },
+		{ "host",      "attr", "<=", &attrvalue,  -1 },
 		{ "host",      NULL,   "&^", &hostname,   -1 },
 		{ "host",      NULL,   "<",  &hostname,   -1 },
 		{ "host",      NULL,   "<=", &hostname,   -1 },
@@ -566,6 +583,8 @@ START_TEST(test_parse_cmp)
 		{ "metric",    NULL,   "!~", &metricname, MATCHER_NOT },
 		{ "metric",    "attr", "=",  &metricname, -1 },
 		{ "metric",    "attr", "!=", &metricname, -1 },
+		{ "metric",    "attr", "!=", &attrvalue,  -1 },
+		{ "metric",    "attr", "<=", &attrvalue,  -1 },
 		{ "metric",    NULL,   "&^", &metricname, -1 },
 		{ "metric",    NULL,   "<",  &metricname, -1 },
 		{ "metric",    NULL,   "<=", &metricname, -1 },
@@ -578,6 +597,8 @@ START_TEST(test_parse_cmp)
 		{ "service",   NULL,   "!~", &srvname,    MATCHER_NOT },
 		{ "service",   "attr", "=",  &srvname,    -1 },
 		{ "service",   "attr", "!=", &srvname,    -1 },
+		{ "service",   "attr", "!=", &attrvalue,  -1 },
+		{ "service",   "attr", "<=", &attrvalue,  -1 },
 		{ "service",   NULL,   "&^", &srvname,    -1 },
 		{ "service",   NULL,   "<",  &srvname,    -1 },
 		{ "service",   NULL,   "<=", &srvname,    -1 },
@@ -604,8 +625,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 },
 	};
@@ -637,7 +656,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 "
@@ -661,6 +680,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 },
@@ -681,7 +706,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 },
@@ -759,83 +784,83 @@ 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,            2,
 			"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'] = ''",         2, /* 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,
-			"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,
-			"ATTR\\[k2\\]\\{ < 123 \\}" },
-		{ "attribute.k2 <= 123", NULL,      1,
-			"ATTR\\[k2\\]\\{ <= 123 \\}" },
-		{ "attribute.k2 >= 123", NULL,      1,
-			"ATTR\\[k2\\]\\{ >= 123 \\}" },
-		{ "attribute.k2 > 123", NULL,       0,
-			"ATTR\\[k2\\]\\{ > 123 \\}" },
-		{ "attribute.k2 = 123", NULL,       1,
-			"ATTR\\[k2\\]\\{ = 123 \\}" },
-		{ "attribute.k2 != 123", NULL,      2,
-			"\\(NOT, ATTR\\[k2\\]\\{ = 123 \\}\\)" },
-		{ "attribute.k1 != 'v1'", NULL,     2,
-			"\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v1', \\(nil\\) \\} \\}\\)" },
-		{ "attribute.k1 != 'v2'", NULL,     3,
-			"\\(NOT, ATTR\\[k1\\]\\{ VALUE\\{ 'v2', \\(nil\\) \\} \\}\\)" },
+		{ "attribute['k1'] = 'v1'", NULL,      1,
+			"CMP_MATCHER\\(15\\)" },
+		{ "attribute['k1'] IS NULL", NULL,     1,
+			"\\(IS NULL\\)" },
+		{ "attribute['x1'] IS NULL", NULL,     3,
+			"\\(IS NULL\\)" },
+		{ "attribute['k1'] IS NOT NULL", NULL, 2,
+			"\\(IS NOT NULL\\)" },
+		{ "attribute['x1'] IS NOT NULL", NULL, 0,
+			"\\(IS NOT NULL\\)" },
+		{ "attribute['k2'] < 123", NULL,       0,
+			"CMP_MATCHER\\(13\\)" },
+		{ "attribute['k2'] <= 123", NULL,      1,
+			"CMP_MATCHER\\(14\\)" },
+		{ "attribute['k2'] >= 123", NULL,      1,
+			"CMP_MATCHER\\(17\\)" },
+		{ "attribute['k2'] > 123", NULL,       0,
+			"CMP_MATCHER\\(18\\)" },
+		{ "attribute['k2'] = 123", NULL,       1,
+			"CMP_MATCHER\\(15\\)" },
+		{ "attribute['k2'] != 123", NULL,      0,
+			"CMP_MATCHER\\(16\\)" },
+		{ "attribute['k1'] != 'v1'", NULL,     1,
+			"CMP_MATCHER\\(16\\)" },
+		{ "attribute['k1'] != 'v2'", NULL,     1,
+			"CMP_MATCHER\\(16\\)" },
 		{ "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" \\} \\}\\)\\)" },
+				"CMP_MATCHER\\(21\\)" },
 	};
 
 	int check, n;