tests/ovsdb-condition.at

   1 AT_BANNER([OVSDB -- conditions])
   2
   3 OVSDB_CHECK_POSITIVE([null condition],
   4   [[parse-conditions \
   5     '{"columns": {"name": {"type": "string"}}}' \
   6     '[]']],
   7   [[[]]])
   8
   9 OVSDB_CHECK_POSITIVE([conditions on scalars],
  10   [[parse-conditions \
  11     '{"columns":
  12         {"i": {"type": "integer"},
  13          "r": {"type": "real"},
  14          "b": {"type": "boolean"},
  15          "s": {"type": "string"},
  16          "u": {"type": "uuid"}}}' \
  17     '[["i", "==", 0]]' \
  18     '[["i", "!=", 1]]' \
  19     '[["i", "<", 2]]' \
  20     '[["i", "<=", 3]]' \
  21     '[["i", ">", 4]]' \
  22     '[["i", ">=", 5]]' \
  23     '[["i", "includes", 6]]' \
  24     '[["i", "excludes", 7]]' \
  25     '[["r", "==", 0.5]]' \
  26     '[["r", "!=", 1.5]]' \
  27     '[["r", "<", 2.5]]' \
  28     '[["r", "<=", 3.5]]' \
  29     '[["r", ">", 4.5]]' \
  30     '[["r", ">=", 5.5]]' \
  31     '[["r", "includes", 6.5]]' \
  32     '[["r", "excludes", 7.5]]' \
  33     '[["b", "==", true]]' \
  34     '[["b", "!=", false]]' \
  35     '[["b", "includes", false]]' \
  36     '[["b", "excludes", true]]' \
  37     '[["s", "==", "a"]]' \
  38     '[["s", "!=", "b"]]' \
  39     '[["s", "includes", "c"]]' \
  40     '[["s", "excludes", "d"]]' \
  41     '[["u", "==", ["uuid", "b10d28f7-af18-4a67-9e78-2a6394516c59"]]]' \
  42     '[["u", "!=", ["uuid", "9179ca6d-6d65-400a-b455-3ad92783a099"]]]' \
  43     '[["u", "includes", ["uuid", "ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"]]]' \
  44     '[["u", "excludes", ["uuid", "62315898-64e0-40b9-b26f-ff74225303e6"]]]']],
  45   [[[["i","==",0]]
  46 [["i","!=",1]]
  47 [["i","<",2]]
  48 [["i","<=",3]]
  49 [["i",">",4]]
  50 [["i",">=",5]]
  51 [["i","includes",6]]
  52 [["i","excludes",7]]
  53 [["r","==",0.5]]
  54 [["r","!=",1.5]]
  55 [["r","<",2.5]]
  56 [["r","<=",3.5]]
  57 [["r",">",4.5]]
  58 [["r",">=",5.5]]
  59 [["r","includes",6.5]]
  60 [["r","excludes",7.5]]
  61 [["b","==",true]]
  62 [["b","!=",false]]
  63 [["b","includes",false]]
  64 [["b","excludes",true]]
  65 [["s","==","a"]]
  66 [["s","!=","b"]]
  67 [["s","includes","c"]]
  68 [["s","excludes","d"]]
  69 [["u","==",["uuid","b10d28f7-af18-4a67-9e78-2a6394516c59"]]]
  70 [["u","!=",["uuid","9179ca6d-6d65-400a-b455-3ad92783a099"]]]
  71 [["u","includes",["uuid","ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"]]]
  72 [["u","excludes",["uuid","62315898-64e0-40b9-b26f-ff74225303e6"]]]]],
  73   [condition])
  74
  75 AT_SETUP([disallowed conditions on scalars])
  76 AT_KEYWORDS([ovsdb negative condition])
  77 AT_CHECK([[test-ovsdb parse-conditions \
  78     '{"columns":
  79         {"i": {"type": "integer"},
  80          "r": {"type": "real"},
  81          "b": {"type": "boolean"},
  82          "s": {"type": "string"},
  83          "u": {"type": "uuid"}}}' \
  84     '[["b", ">", true]]' \
  85     '[["b", ">=", false]]' \
  86     '[["b", "<", false]]' \
  87     '[["b", "<=", false]]' \
  88     '[["s", ">", "a"]]' \
  89     '[["s", ">=", "b"]]' \
  90     '[["s", "<", "c"]]' \
  91     '[["s", "<=", "d"]]' \
  92     '[["u", ">", ["uuid", "b10d28f7-af18-4a67-9e78-2a6394516c59"]]]' \
  93     '[["u", ">=", ["uuid", "9179ca6d-6d65-400a-b455-3ad92783a099"]]]' \
  94     '[["u", "<", ["uuid", "ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"]]]' \
  95     '[["u", "<=", ["uuid", "62315898-64e0-40b9-b26f-ff74225303e6"]]]']],
  96   [1], [],
  97   [[test-ovsdb: syntax "["b",">",true]": syntax error: Type mismatch: ">" operator may not be applied to column b of type boolean.
  98 test-ovsdb: syntax "["b",">=",false]": syntax error: Type mismatch: ">=" operator may not be applied to column b of type boolean.
  99 test-ovsdb: syntax "["b","<",false]": syntax error: Type mismatch: "<" operator may not be applied to column b of type boolean.
 100 test-ovsdb: syntax "["b","<=",false]": syntax error: Type mismatch: "<=" operator may not be applied to column b of type boolean.
 101 test-ovsdb: syntax "["s",">","a"]": syntax error: Type mismatch: ">" operator may not be applied to column s of type string.
 102 test-ovsdb: syntax "["s",">=","b"]": syntax error: Type mismatch: ">=" operator may not be applied to column s of type string.
 103 test-ovsdb: syntax "["s","<","c"]": syntax error: Type mismatch: "<" operator may not be applied to column s of type string.
 104 test-ovsdb: syntax "["s","<=","d"]": syntax error: Type mismatch: "<=" operator may not be applied to column s of type string.
 105 test-ovsdb: syntax "["u",">",["uuid","b10d28f7-af18-4a67-9e78-2a6394516c59"]]": syntax error: Type mismatch: ">" operator may not be applied to column u of type uuid.
 106 test-ovsdb: syntax "["u",">=",["uuid","9179ca6d-6d65-400a-b455-3ad92783a099"]]": syntax error: Type mismatch: ">=" operator may not be applied to column u of type uuid.
 107 test-ovsdb: syntax "["u","<",["uuid","ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"]]": syntax error: Type mismatch: "<" operator may not be applied to column u of type uuid.
 108 test-ovsdb: syntax "["u","<=",["uuid","62315898-64e0-40b9-b26f-ff74225303e6"]]": syntax error: Type mismatch: "<=" operator may not be applied to column u of type uuid.
 109 ]])
 110 AT_CLEANUP
 111
 112 OVSDB_CHECK_POSITIVE([conditions on sets],
 113   [[parse-conditions \
 114     '{"columns":
 115         {"i": {"type": {"key": "integer", "min": 0, "max": "unlimited"}},
 116          "r": {"type": {"key": "real", "min": 0, "max": "unlimited"}},
 117          "b": {"type": {"key": "boolean", "min": 0, "max": "unlimited"}},
 118          "s": {"type": {"key": "string", "min": 0, "max": "unlimited"}},
 119          "u": {"type": {"key": "uuid", "min": 0, "max": "unlimited"}}}}' \
 120     '[["i", "==", ["set", []]]]' \
 121     '[["i", "!=", ["set", [1]]]]' \
 122     '[["i", "includes", ["set", [1, 2]]]]' \
 123     '[["i", "excludes", ["set", [1, 2, 3]]]]' \
 124     '[["r", "==", ["set", []]]]' \
 125     '[["r", "!=", ["set", [1.5]]]]' \
 126     '[["r", "includes", ["set", [1.5, 2.5]]]]' \
 127     '[["r", "excludes", ["set", [1.5, 2.5, 3.5]]]]' \
 128     '[["b", "==", ["set", [true]]]]' \
 129     '[["b", "!=", ["set", [false]]]]' \
 130     '[["b", "includes", ["set", [false]]]]' \
 131     '[["b", "excludes", ["set", [true, false]]]]' \
 132     '[["s", "==", ["set", ["a"]]]]' \
 133     '[["s", "!=", ["set", ["a", "b"]]]]' \
 134     '[["s", "includes", ["set", ["c"]]]]' \
 135     '[["s", "excludes", ["set", ["c", "d"]]]]' \
 136     '[["u", "==",
 137        ["set", [["uuid", "b10d28f7-af18-4a67-9e78-2a6394516c59"]]]]]' \
 138     '[["u", "==",
 139        ["set", [["uuid", "b10d28f7-af18-4a67-9e78-2a6394516c59"],
 140                 ["uuid", "9179ca6d-6d65-400a-b455-3ad92783a099"]]]]]' \
 141     '[["u", "includes",
 142        ["set", [["uuid", "b10d28f7-af18-4a67-9e78-2a6394516c59"],
 143                 ["uuid", "9179ca6d-6d65-400a-b455-3ad92783a099"],
 144                 ["uuid", "ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"]]]]]' \
 145     '[["u", "excludes",
 146        ["set", [["uuid", "b10d28f7-af18-4a67-9e78-2a6394516c59"],
 147                 ["uuid", "9179ca6d-6d65-400a-b455-3ad92783a099"],
 148                 ["uuid", "ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"],
 149                 ["uuid", "62315898-64e0-40b9-b26f-ff74225303e6"]]]]]' \
 150 ]],
 151   [[[["i","==",["set",[]]]]
 152 [["i","!=",1]]
 153 [["i","includes",["set",[1,2]]]]
 154 [["i","excludes",["set",[1,2,3]]]]
 155 [["r","==",["set",[]]]]
 156 [["r","!=",1.5]]
 157 [["r","includes",["set",[1.5,2.5]]]]
 158 [["r","excludes",["set",[1.5,2.5,3.5]]]]
 159 [["b","==",true]]
 160 [["b","!=",false]]
 161 [["b","includes",false]]
 162 [["b","excludes",["set",[false,true]]]]
 163 [["s","==","a"]]
 164 [["s","!=",["set",["a","b"]]]]
 165 [["s","includes","c"]]
 166 [["s","excludes",["set",["c","d"]]]]
 167 [["u","==",["uuid","b10d28f7-af18-4a67-9e78-2a6394516c59"]]]
 168 [["u","==",["set",[["uuid","9179ca6d-6d65-400a-b455-3ad92783a099"],["uuid","b10d28f7-af18-4a67-9e78-2a6394516c59"]]]]]
 169 [["u","includes",["set",[["uuid","9179ca6d-6d65-400a-b455-3ad92783a099"],["uuid","ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"],["uuid","b10d28f7-af18-4a67-9e78-2a6394516c59"]]]]]
 170 [["u","excludes",["set",[["uuid","62315898-64e0-40b9-b26f-ff74225303e6"],["uuid","9179ca6d-6d65-400a-b455-3ad92783a099"],["uuid","ad0fa355-8b84-4a36-a4b5-b2c1bfd91758"],["uuid","b10d28f7-af18-4a67-9e78-2a6394516c59"]]]]]]],
 171   [condition])
 172
 173 OVSDB_CHECK_POSITIVE([condition sorting],
 174   [[parse-conditions \
 175     '{"columns": {"i": {"type": "integer"}}}' \
 176     '[["i", "excludes", 7],
 177       ["i", "!=", 8],
 178       ["i", "==", 1],
 179       ["i", "includes", 2],
 180       ["i", "<=", 3],
 181       ["i", "<", 4],
 182       ["i", ">", 6],
 183       ["i", ">=", 5],
 184       ["_uuid", "==", ["uuid", "d50e85c6-8ae7-4b16-b69e-4395928bd9be"]]]']],
 185   [[[["_uuid","==",["uuid","d50e85c6-8ae7-4b16-b69e-4395928bd9be"]],["i","==",1],["i","includes",2],["i","<=",3],["i","<",4],["i",">=",5],["i",">",6],["i","excludes",7],["i","!=",8]]]])
 186
 187 OVSDB_CHECK_POSITIVE([boolean condition],
 188   [[parse-conditions \
 189     '{"columns": {"name": {"type": "string"}}}' \
 190     '[true]']],
 191   [[[true]]])
 192
 193 OVSDB_CHECK_POSITIVE([boolean condition],
 194   [[parse-conditions \
 195     '{"columns": {"name": {"type": "string"}}}' \
 196     '[false]']],
 197   [[[false]]])
 198
 199 OVSDB_CHECK_POSITIVE([evaluating null condition],
 200   [[evaluate-conditions \
 201     '{"columns": {"i": {"type": "integer"}}}' \
 202     '[[]]' \
 203     '[{"i": 0},
 204       {"i": 1},
 205       {"i": 2}']]],
 206   [condition  0: TTT])
 207
 208 OVSDB_CHECK_POSITIVE([evaluating conditions on integers],
 209   [[evaluate-conditions \
 210     '{"columns": {"i": {"type": "integer"}}}' \
 211     '[[["i", "<", 1]],
 212       [["i", "<=", 1]],
 213       [["i", "==", 1]],
 214       [["i", "!=", 1]],
 215       [["i", ">=", 1]],
 216       [["i", ">", 1]],
 217       [["i", "includes", 1]],
 218       [["i", "excludes", 1]],
 219       [["i", ">", 0], ["i", "<", 2]]]' \
 220     '[{"i": 0},
 221       {"i": 1},
 222       {"i": 2}']]],
 223   [condition  0: T--
 224 condition  1: TT-
 225 condition  2: -T-
 226 condition  3: T-T
 227 condition  4: -TT
 228 condition  5: --T
 229 condition  6: -T-
 230 condition  7: T-T
 231 condition  8: -T-], [condition])
 232
 233 OVSDB_CHECK_POSITIVE([evaluating conditions on reals],
 234   [[evaluate-conditions \
 235     '{"columns": {"r": {"type": "real"}}}' \
 236     '[[["r", "<", 5.0]],
 237       [["r", "<=", 5.0]],
 238       [["r", "==", 5.0]],
 239       [["r", "!=", 5.0]],
 240       [["r", ">=", 5.0]],
 241       [["r", ">", 5.0]],
 242       [["r", "includes", 5.0]],
 243       [["r", "excludes", 5.0]],
 244       [["r", "!=", 0], ["r", "!=", 5.1]]]' \
 245     '[{"r": 0},
 246       {"r": 5.0},
 247       {"r": 5.1}']]],
 248   [condition  0: T--
 249 condition  1: TT-
 250 condition  2: -T-
 251 condition  3: T-T
 252 condition  4: -TT
 253 condition  5: --T
 254 condition  6: -T-
 255 condition  7: T-T
 256 condition  8: -T-], [condition])
 257
 258 OVSDB_CHECK_POSITIVE([evaluating conditions on booleans],
 259   [[evaluate-conditions \
 260     '{"columns": {"b": {"type": "boolean"}}}' \
 261     '[[["b", "==", true]],
 262       [["b", "!=", true]],
 263       [["b", "includes", true]],
 264       [["b", "excludes", true]],
 265       [["b", "==", false]],
 266       [["b", "!=", false]],
 267       [["b", "includes", false]],
 268       [["b", "excludes", false]],
 269       [["b", "==", true], ["b", "==", false]]]' \
 270     '[{"b": true},
 271       {"b": false}']]],
 272   [condition  0: T-
 273 condition  1: -T
 274 condition  2: T-
 275 condition  3: -T
 276 condition  4: -T
 277 condition  5: T-
 278 condition  6: -T
 279 condition  7: T-
 280 condition  8: --], [condition])
 281
 282 OVSDB_CHECK_POSITIVE([evaluating conditions on strings],
 283   [[evaluate-conditions \
 284     '{"columns": {"s": {"type": "string"}}}' \
 285     '[[["s", "==", ""]],
 286       [["s", "!=", ""]],
 287       [["s", "includes", ""]],
 288       [["s", "excludes", ""]],
 289       [["s", "==", "foo"]],
 290       [["s", "!=", "foo"]],
 291       [["s", "includes", "foo"]],
 292       [["s", "excludes", "foo"]],
 293       [["s", "!=", "foo"], ["s", "!=", ""]]]' \
 294     '[{"s": ""},
 295       {"s": "foo"},
 296       {"s": "xxx"}']]],
 297   [condition  0: T--
 298 condition  1: -TT
 299 condition  2: T--
 300 condition  3: -TT
 301 condition  4: -T-
 302 condition  5: T-T
 303 condition  6: -T-
 304 condition  7: T-T
 305 condition  8: --T], [condition])
 306
 307 OVSDB_CHECK_POSITIVE([evaluating conditions on UUIDs],
 308   [[evaluate-conditions \
 309     '{"columns": {"u": {"type": "uuid"}}}' \
 310     '[[["u", "==", ["uuid", "8a1dbdb8-416f-4ce9-affa-3332691714b6"]]],
 311       [["u", "!=", ["uuid", "8a1dbdb8-416f-4ce9-affa-3332691714b6"]]],
 312       [["u", "includes", ["uuid", "8a1dbdb8-416f-4ce9-affa-3332691714b6"]]],
 313       [["u", "excludes", ["uuid", "8a1dbdb8-416f-4ce9-affa-3332691714b6"]]],
 314       [["u", "==", ["uuid", "06151f9d-62d6-4f59-8504-e9765107faa9"]]],
 315       [["u", "!=", ["uuid", "06151f9d-62d6-4f59-8504-e9765107faa9"]]],
 316       [["u", "includes", ["uuid", "06151f9d-62d6-4f59-8504-e9765107faa9"]]],
 317       [["u", "excludes", ["uuid", "06151f9d-62d6-4f59-8504-e9765107faa9"]]],
 318       [["u", "!=", ["uuid", "06151f9d-62d6-4f59-8504-e9765107faa9"]],
 319        ["u", "!=", ["uuid", "cb160ed6-92a6-4503-a6aa-a09a09e01f0d"]]]]' \
 320     '[{"u": ["uuid", "8a1dbdb8-416f-4ce9-affa-3332691714b6"]},
 321       {"u": ["uuid", "06151f9d-62d6-4f59-8504-e9765107faa9"]},
 322       {"u": ["uuid", "00000000-0000-0000-0000-000000000000"]}']]],
 323   [condition  0: T--
 324 condition  1: -TT
 325 condition  2: T--
 326 condition  3: -TT
 327 condition  4: -T-
 328 condition  5: T-T
 329 condition  6: -T-
 330 condition  7: T-T
 331 condition  8: T-T], [condition])
 332
 333 OVSDB_CHECK_POSITIVE([evaluating conditions on sets],
 334   [[evaluate-conditions \
 335     '{"columns": {"i": {"type": {"key": "integer", "min": 0, "max": "unlimited"}}}}' \
 336     '[[["i", "==", ["set", []]]],
 337       [["i", "==", ["set", [0]]]],
 338       [["i", "==", ["set", [1]]]],
 339       [["i", "==", ["set", [0, 1]]]],
 340       [["i", "==", ["set", [2]]]],
 341       [["i", "==", ["set", [2, 0]]]],
 342       [["i", "==", ["set", [2, 1]]]],
 343       [["i", "==", ["set", [2, 1, 0]]]],
 344       [["i", "!=", ["set", []]]],
 345       [["i", "!=", ["set", [0]]]],
 346       [["i", "!=", ["set", [1]]]],
 347       [["i", "!=", ["set", [0, 1]]]],
 348       [["i", "!=", ["set", [2]]]],
 349       [["i", "!=", ["set", [2, 0]]]],
 350       [["i", "!=", ["set", [2, 1]]]],
 351       [["i", "!=", ["set", [2, 1, 0]]]],
 352       [["i", "includes", ["set", []]]],
 353       [["i", "includes", ["set", [0]]]],
 354       [["i", "includes", ["set", [1]]]],
 355       [["i", "includes", ["set", [0, 1]]]],
 356       [["i", "includes", ["set", [2]]]],
 357       [["i", "includes", ["set", [2, 0]]]],
 358       [["i", "includes", ["set", [2, 1]]]],
 359       [["i", "includes", ["set", [2, 1, 0]]]],
 360       [["i", "excludes", ["set", []]]],
 361       [["i", "excludes", ["set", [0]]]],
 362       [["i", "excludes", ["set", [1]]]],
 363       [["i", "excludes", ["set", [0, 1]]]],
 364       [["i", "excludes", ["set", [2]]]],
 365       [["i", "excludes", ["set", [2, 0]]]],
 366       [["i", "excludes", ["set", [2, 1]]]],
 367       [["i", "excludes", ["set", [2, 1, 0]]]],
 368       [["i", "includes", ["set", [0]]],
 369        ["i", "includes", ["set", [1]]]]]' \
 370     '[{"i": ["set", []]},
 371       {"i": ["set", [0]]},
 372       {"i": ["set", [1]]},
 373       {"i": ["set", [0, 1]]},
 374       {"i": ["set", [2]]},
 375       {"i": ["set", [2, 0]]},
 376       {"i": ["set", [2, 1]]},
 377       {"i": ["set", [2, 1, 0]]}]']],
 378   [dnl
 379 condition  0: T---- ---
 380 condition  1: -T--- ---
 381 condition  2: --T-- ---
 382 condition  3: ---T- ---
 383 condition  4: ----T ---
 384 condition  5: ----- T--
 385 condition  6: ----- -T-
 386 condition  7: ----- --T
 387 condition  8: -TTTT TTT
 388 condition  9: T-TTT TTT
 389 condition 10: TT-TT TTT
 390 condition 11: TTT-T TTT
 391 condition 12: TTTT- TTT
 392 condition 13: TTTTT -TT
 393 condition 14: TTTTT T-T
 394 condition 15: TTTTT TT-
 395 condition 16: TTTTT TTT
 396 condition 17: -T-T- T-T
 397 condition 18: --TT- -TT
 398 condition 19: ---T- --T
 399 condition 20: ----T TTT
 400 condition 21: ----- T-T
 401 condition 22: ----- -TT
 402 condition 23: ----- --T
 403 condition 24: TTTTT TTT
 404 condition 25: T-T-T -T-
 405 condition 26: TT--T T--
 406 condition 27: T---T ---
 407 condition 28: TTTT- ---
 408 condition 29: T-T-- ---
 409 condition 30: TT--- ---
 410 condition 31: T---- ---
 411 condition 32: ---T- --T], [condition])
 412
 413 # This is the same as the "set" test except that it adds values,
 414 # all of which always match.
 415 OVSDB_CHECK_POSITIVE([evaluating conditions on maps (1)],
 416   [[evaluate-conditions \
 417     '{"columns": {"i": {"type": {"key": "integer",
 418                                  "value": "boolean",
 419                                  "min": 0,
 420                                  "max": "unlimited"}}}}' \
 421     '[[["i", "==", ["map", []]]],
 422       [["i", "==", ["map", [[0, true]]]]],
 423       [["i", "==", ["map", [[1, false]]]]],
 424       [["i", "==", ["map", [[0, true], [1, false]]]]],
 425       [["i", "==", ["map", [[2, true]]]]],
 426       [["i", "==", ["map", [[2, true], [0, true]]]]],
 427       [["i", "==", ["map", [[2, true], [1, false]]]]],
 428       [["i", "==", ["map", [[2, true], [1, false], [0, true]]]]],
 429       [["i", "!=", ["map", []]]],
 430       [["i", "!=", ["map", [[0, true]]]]],
 431       [["i", "!=", ["map", [[1, false]]]]],
 432       [["i", "!=", ["map", [[0, true], [1, false]]]]],
 433       [["i", "!=", ["map", [[2, true]]]]],
 434       [["i", "!=", ["map", [[2, true], [0, true]]]]],
 435       [["i", "!=", ["map", [[2, true], [1, false]]]]],
 436       [["i", "!=", ["map", [[2, true], [1, false], [0, true]]]]],
 437       [["i", "includes", ["map", []]]],
 438       [["i", "includes", ["map", [[0, true]]]]],
 439       [["i", "includes", ["map", [[1, false]]]]],
 440       [["i", "includes", ["map", [[0, true], [1, false]]]]],
 441       [["i", "includes", ["map", [[2, true]]]]],
 442       [["i", "includes", ["map", [[2, true], [0, true]]]]],
 443       [["i", "includes", ["map", [[2, true], [1, false]]]]],
 444       [["i", "includes", ["map", [[2, true], [1, false], [0, true]]]]],
 445       [["i", "excludes", ["map", []]]],
 446       [["i", "excludes", ["map", [[0, true]]]]],
 447       [["i", "excludes", ["map", [[1, false]]]]],
 448       [["i", "excludes", ["map", [[0, true], [1, false]]]]],
 449       [["i", "excludes", ["map", [[2, true]]]]],
 450       [["i", "excludes", ["map", [[2, true], [0, true]]]]],
 451       [["i", "excludes", ["map", [[2, true], [1, false]]]]],
 452       [["i", "excludes", ["map", [[2, true], [1, false], [0, true]]]]],
 453       [["i", "includes", ["map", [[0, true]]]],
 454        ["i", "includes", ["map", [[1, false]]]]]]' \
 455     '[{"i": ["map", []]},
 456       {"i": ["map", [[0, true]]]},
 457       {"i": ["map", [[1, false]]]},
 458       {"i": ["map", [[0, true], [1, false]]]},
 459       {"i": ["map", [[2, true]]]},
 460       {"i": ["map", [[2, true], [0, true]]]},
 461       {"i": ["map", [[2, true], [1, false]]]},
 462       {"i": ["map", [[2, true], [1, false], [0, true]]]}]']],
 463   [dnl
 464 condition  0: T---- ---
 465 condition  1: -T--- ---
 466 condition  2: --T-- ---
 467 condition  3: ---T- ---
 468 condition  4: ----T ---
 469 condition  5: ----- T--
 470 condition  6: ----- -T-
 471 condition  7: ----- --T
 472 condition  8: -TTTT TTT
 473 condition  9: T-TTT TTT
 474 condition 10: TT-TT TTT
 475 condition 11: TTT-T TTT
 476 condition 12: TTTT- TTT
 477 condition 13: TTTTT -TT
 478 condition 14: TTTTT T-T
 479 condition 15: TTTTT TT-
 480 condition 16: TTTTT TTT
 481 condition 17: -T-T- T-T
 482 condition 18: --TT- -TT
 483 condition 19: ---T- --T
 484 condition 20: ----T TTT
 485 condition 21: ----- T-T
 486 condition 22: ----- -TT
 487 condition 23: ----- --T
 488 condition 24: TTTTT TTT
 489 condition 25: T-T-T -T-
 490 condition 26: TT--T T--
 491 condition 27: T---T ---
 492 condition 28: TTTT- ---
 493 condition 29: T-T-- ---
 494 condition 30: TT--- ---
 495 condition 31: T---- ---
 496 condition 32: ---T- --T], [condition])
 497
 498 # This is the same as the "set" test except that it adds values,
 499 # and those values don't always match.
 500 OVSDB_CHECK_POSITIVE([evaluating conditions on maps (2)],
 501   [[evaluate-conditions \
 502     '{"columns": {"i": {"type": {"key": "integer",
 503                                  "value": "boolean",
 504                                  "min": 0,
 505                                  "max": "unlimited"}}}}' \
 506     '[[["i", "==", ["map", []]]],
 507       [["i", "==", ["map", [[0, true]]]]],
 508       [["i", "==", ["map", [[1, false]]]]],
 509       [["i", "==", ["map", [[0, true], [1, false]]]]],
 510       [["i", "==", ["map", [[2, true]]]]],
 511       [["i", "==", ["map", [[2, true], [0, true]]]]],
 512       [["i", "==", ["map", [[2, true], [1, false]]]]],
 513       [["i", "==", ["map", [[2, true], [1, false], [0, true]]]]],
 514       [["i", "!=", ["map", []]]],
 515       [["i", "!=", ["map", [[0, true]]]]],
 516       [["i", "!=", ["map", [[1, false]]]]],
 517       [["i", "!=", ["map", [[0, true], [1, false]]]]],
 518       [["i", "!=", ["map", [[2, true]]]]],
 519       [["i", "!=", ["map", [[2, true], [0, true]]]]],
 520       [["i", "!=", ["map", [[2, true], [1, false]]]]],
 521       [["i", "!=", ["map", [[2, true], [1, false], [0, true]]]]],
 522       [["i", "includes", ["map", []]]],
 523       [["i", "includes", ["map", [[0, true]]]]],
 524       [["i", "includes", ["map", [[1, false]]]]],
 525       [["i", "includes", ["map", [[0, true], [1, false]]]]],
 526       [["i", "includes", ["map", [[2, true]]]]],
 527       [["i", "includes", ["map", [[2, true], [0, true]]]]],
 528       [["i", "includes", ["map", [[2, true], [1, false]]]]],
 529       [["i", "includes", ["map", [[2, true], [1, false], [0, true]]]]],
 530       [["i", "excludes", ["map", []]]],
 531       [["i", "excludes", ["map", [[0, true]]]]],
 532       [["i", "excludes", ["map", [[1, false]]]]],
 533       [["i", "excludes", ["map", [[0, true], [1, false]]]]],
 534       [["i", "excludes", ["map", [[2, true]]]]],
 535       [["i", "excludes", ["map", [[2, true], [0, true]]]]],
 536       [["i", "excludes", ["map", [[2, true], [1, false]]]]],
 537       [["i", "excludes", ["map", [[2, true], [1, false], [0, true]]]]],
 538       [["i", "includes", ["map", [[0, true]]]],
 539        ["i", "includes", ["map", [[1, false]]]]]]' \
 540     '[{"i": ["map", []]},
 541       {"i": ["map", [[0, true]]]},
 542       {"i": ["map", [[0, false]]]},
 543       {"i": ["map", [[1, false]]]},
 544       {"i": ["map", [[1, true]]]},
 545
 546       {"i": ["map", [[0, true], [1, false]]]},
 547       {"i": ["map", [[0, true], [1, true]]]},
 548       {"i": ["map", [[2, true]]]},
 549       {"i": ["map", [[2, false]]]},
 550       {"i": ["map", [[2, true], [0, true]]]},
 551
 552       {"i": ["map", [[2, false], [0, true]]]},
 553       {"i": ["map", [[2, true], [1, false]]]},
 554       {"i": ["map", [[2, true], [1, true]]]},
 555       {"i": ["map", [[2, true], [1, false], [0, true]]]},
 556       {"i": ["map", [[2, true], [1, false], [0, false]]]}]']],
 557   [dnl
 558 condition  0: T---- ----- -----
 559 condition  1: -T--- ----- -----
 560 condition  2: ---T- ----- -----
 561 condition  3: ----- T---- -----
 562 condition  4: ----- --T-- -----
 563 condition  5: ----- ----T -----
 564 condition  6: ----- ----- -T---
 565 condition  7: ----- ----- ---T-
 566 condition  8: -TTTT TTTTT TTTTT
 567 condition  9: T-TTT TTTTT TTTTT
 568 condition 10: TTT-T TTTTT TTTTT
 569 condition 11: TTTTT -TTTT TTTTT
 570 condition 12: TTTTT TT-TT TTTTT
 571 condition 13: TTTTT TTTT- TTTTT
 572 condition 14: TTTTT TTTTT T-TTT
 573 condition 15: TTTTT TTTTT TTT-T
 574 condition 16: TTTTT TTTTT TTTTT
 575 condition 17: -T--- TT--T T--T-
 576 condition 18: ---T- T---- -T-TT
 577 condition 19: ----- T---- ---T-
 578 condition 20: ----- --T-T -TTTT
 579 condition 21: ----- ----T ---T-
 580 condition 22: ----- ----- -T-TT
 581 condition 23: ----- ----- ---T-
 582 condition 24: TTTTT TTTTT TTTTT
 583 condition 25: T-TTT --TT- -TT-T
 584 condition 26: TTT-T -TTTT T-T--
 585 condition 27: T-T-T --TT- --T--
 586 condition 28: TTTTT TT-T- T----
 587 condition 29: T-TTT ---T- -----
 588 condition 30: TTT-T -T-T- T----
 589 condition 31: T-T-T ---T- -----
 590 condition 32: ----- T---- ---T-], [condition])
 591
 592 OVSDB_CHECK_POSITIVE([evaluating conditions on optional integers],
 593   [[evaluate-conditions \
 594     '{"columns": {"i": {"type": {"key": "integer", "min": 0, "max": 1}}}}' \
 595     '[[["i", "<", 1]],
 596       [["i", "<=", 1]],
 597       [["i", "==", 1]],
 598       [["i", "!=", 1]],
 599       [["i", ">=", 1]],
 600       [["i", ">", 1]],
 601       [["i", "includes", 1]],
 602       [["i", "excludes", 1]],
 603       [["i", ">", 0], ["i", "<", 2]]]' \
 604     '[{"i": ["set", []]},
 605       {"i": ["set", [0]]},
 606       {"i": ["set", [1]]},
 607       {"i": ["set", [2]]}]']],
 608   [dnl
 609 condition  0: -T--
 610 condition  1: -TT-
 611 condition  2: --T-
 612 condition  3: TT-T
 613 condition  4: --TT
 614 condition  5: ---T
 615 condition  6: --T-
 616 condition  7: TT-T
 617 condition  8: --T-], [condition])
 618
 619 OVSDB_CHECK_POSITIVE([evaluating conditions on optional strings],
 620   [[evaluate-conditions \
 621     '{"columns": {"s": {"type": {"key": "string", "min": 0, "max": 1}}}}' \
 622     '[[["s", "==", ""]],
 623       [["s", "!=", ""]],
 624       [["s", "includes", ""]],
 625       [["s", "excludes", ""]],
 626       [["s", "==", "foo"]],
 627       [["s", "!=", "foo"]],
 628       [["s", "includes", "foo"]],
 629       [["s", "excludes", "foo"]],
 630       [["s", "!=", "foo"], ["s", "!=", ""]]]' \
 631     '[{"s": ["set", [""]]},
 632       {"s": ["set", ["foo"]]},
 633       {"s": ["set", ["xxx"]]},
 634       {"s": ["set", []]}]']],
 635   [dnl
 636 condition  0: T---
 637 condition  1: -TTT
 638 condition  2: T---
 639 condition  3: -TTT
 640 condition  4: -T--
 641 condition  5: T-TT
 642 condition  6: -T--
 643 condition  7: T-TT
 644 condition  8: --TT], [condition])
 645
 646 OVSDB_CHECK_POSITIVE([evaluating conditions on optional reals],
 647   [[evaluate-conditions \
 648     '{"columns": {"r": {"type": {"key": "real", "min": 0, "max": 1}}}}' \
 649     '[[["r", "<", 5.0]],
 650       [["r", "<=", 5.0]],
 651       [["r", "==", 5.0]],
 652       [["r", "!=", 5.0]],
 653       [["r", ">=", 5.0]],
 654       [["r", ">", 5.0]],
 655       [["r", "includes", 5.0]],
 656       [["r", "excludes", 5.0]],
 657       [["r", "!=", 0], ["r", "!=", 5.1]]]' \
 658     '[{"r": ["set", [0]]},
 659       {"r": ["set", [5.0]]},
 660       {"r": ["set", [5.1]]},
 661       {"r": ["set", []]}]']],
 662   [dnl
 663 condition  0: T---
 664 condition  1: TT--
 665 condition  2: -T--
 666 condition  3: T-TT
 667 condition  4: -TT-
 668 condition  5: --T-
 669 condition  6: -T--
 670 condition  7: T-TT
 671 condition  8: -T-T], [condition])
 672
 673 OVSDB_CHECK_POSITIVE([evaluating false boolean condition],
 674   [[evaluate-conditions-any \
 675     '{"columns": {"i": {"type": "integer"}}}' \
 676     '[[false,["i","==",1]]]' \
 677     '[{"i": 0},
 678       {"i": 1},
 679       {"i": 2}']]],
 680   [condition  0: -T-])
 681
 682 OVSDB_CHECK_POSITIVE([evaluating true boolean condition],
 683   [[evaluate-conditions-any \
 684     '{"columns": {"i": {"type": "integer"}}}' \
 685     '[[true,["i","==",1]]]' \
 686     '[{"i": 0},
 687       {"i": 1},
 688       {"i": 2}']]],
 689   [condition  0: TTT])
 690
 691 OVSDB_CHECK_POSITIVE([compare condition],
 692   [[compare-conditions \
 693     '{"columns": {"i": {"type": "integer"}}}' \
 694     '[[true,["i","==",1],["i","==",2],["i","==",3]],
 695       [["i","==",1],["i","==",3],["i","==",2],true],
 696       [["i","==",1]],
 697       [["i",">=",1]]']]],
 698   [condition 0-1: 0
 699 condition 1-2: 1
 700 condition 2-3: -1])