t/unit/parser/parser_test.c

   1 /*
   2  * SysDB - t/unit/parser/parser_test.c
   3  * Copyright (C) 2013-2015 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif
  31
  32 #include "parser/parser.h"
  33 #include "core/object.h"
  34 #include "core/store.h"
  35 #include "testutils.h"
  36
  37 #include <check.h>
  38 #include <limits.h>
  39
  40 /*
  41  * tests
  42  */
  43
  44 struct {
  45         const char *query;
  46         int len;
  47         int expected;
  48         int expected_type;
  49         int expected_extra; /* type-specific extra information */
  50 } parse_data[] = {
  51         /* empty commands */
  52         { NULL,                  -1, -1, 0, 0 },
  53         { "",                    -1,  0, 0, 0 },
  54         { ";",                   -1,  0, 0, 0 },
  55         { ";;",                  -1,  0, 0, 0 },
  56
  57         /* FETCH commands */
  58         { "FETCH host 'host'",   -1,  1, SDB_AST_TYPE_FETCH, SDB_HOST },
  59         { "FETCH host 'host' FILTER "
  60           "age > 60s",           -1,  1, SDB_AST_TYPE_FETCH, SDB_HOST },
  61         { "FETCH service "
  62           "'host'.'service'",    -1,  1, SDB_AST_TYPE_FETCH, SDB_SERVICE },
  63         { "FETCH metric "
  64           "'host'.'metric'",     -1,  1, SDB_AST_TYPE_FETCH, SDB_METRIC },
  65
  66         /* LIST commands */
  67         { "LIST hosts",            -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  68         { "LIST hosts -- foo",     -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  69         { "LIST hosts;",           -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  70         { "LIST hosts; INVALID",   11,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  71         { "LIST hosts FILTER "
  72           "age > 60s",             -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  73         { "LIST services",         -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  74         { "LIST services FILTER "
  75           "age > 60s",             -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  76         { "LIST metrics",          -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
  77         { "LIST metrics FILTER "
  78           "age > 60s",             -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
  79         /* field access */
  80         { "LIST hosts FILTER "
  81           "name = 'a'",            -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  82         { "LIST hosts FILTER "
  83           "last_update > 1s",      -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  84         { "LIST hosts FILTER "
  85           "age > 120s",            -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  86         { "LIST hosts FILTER "
  87           "interval > 10s",        -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  88         { "LIST hosts FILTER "
  89           "backend = ['b']",       -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  90         { "LIST hosts FILTER ANY "
  91           "attribute.value = 'a'", -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  92         { "LIST services FILTER "
  93           "name = 'a'",            -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  94         { "LIST services FILTER "
  95           "last_update > 1s",      -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  96         { "LIST services FILTER "
  97           "age > 120s",            -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  98         { "LIST services FILTER "
  99           "interval > 10s",        -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
 100         { "LIST services FILTER "
 101           "backend = ['b']",       -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
 102         { "LIST services FILTER ANY "
 103           "attribute.value = 'a'", -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
 104         { "LIST metrics FILTER "
 105           "name = 'a'",            -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 106         { "LIST metrics FILTER "
 107           "last_update > 1s",      -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 108         { "LIST metrics FILTER "
 109           "age > 120s",            -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 110         { "LIST metrics FILTER "
 111           "interval > 10s",        -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 112         { "LIST metrics FILTER "
 113           "backend = ['b']",       -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 114         { "LIST metrics FILTER ANY "
 115           "attribute.value = 'a'", -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 116
 117         /* LOOKUP commands */
 118         { "LOOKUP hosts",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 119         { "LOOKUP hosts MATCHING "
 120           "name = 'host'",       -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 121         { "LOOKUP hosts MATCHING NOT "
 122           "name = 'host'",       -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 123         { "LOOKUP hosts MATCHING "
 124           "name =~ 'p' AND "
 125           "ANY service.name =~ 'p'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 126         { "LOOKUP hosts MATCHING NOT "
 127           "name =~ 'p' AND "
 128           "ANY service.name =~ 'p'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 129         { "LOOKUP hosts MATCHING "
 130           "name =~ 'p' AND "
 131           "ANY service.name =~ 'p' OR "
 132           "ANY service.name =~ 'r'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 133         { "LOOKUP hosts MATCHING NOT "
 134           "name =~ 'p' AND "
 135           "ANY service.name =~ 'p' OR "
 136           "ANY service.name =~ 'r'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 137         { "LOOKUP hosts MATCHING "
 138           "name =~ 'p' "
 139           "FILTER age > 1D",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 140         { "LOOKUP hosts MATCHING "
 141           "name =~ 'p' "
 142           "FILTER age > 1D AND "
 143           "interval < 240s" ,        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 144         { "LOOKUP hosts MATCHING "
 145           "name =~ 'p' "
 146           "FILTER NOT age>1D",       -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 147         { "LOOKUP hosts MATCHING "
 148           "name =~ 'p' "
 149           "FILTER age>"
 150           "interval",                -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 151         { "LOOKUP hosts MATCHING "
 152           "host.name =~ 'p'",        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 153         { "LOOKUP services",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 154         { "LOOKUP services MATCHING ANY "
 155           "attribute.name =~ 'a'",   -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 156         { "LOOKUP services MATCHING "
 157           "host.name = 'p'",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 158         { "LOOKUP services MATCHING "
 159           "service.name = 'p'",      -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 160         { "LOOKUP services MATCHING ANY "
 161           "host.backend =~ 'b'",     -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 162         { "LOOKUP metrics",          -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 163         { "LOOKUP metrics MATCHING ANY "
 164           "attribute.name =~ 'a'",   -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 165         { "LOOKUP metrics MATCHING "
 166           "host.name = 'p'",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 167         { "LOOKUP metrics MATCHING "
 168           "metric.name = 'p'",       -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 169         { "LOOKUP metrics MATCHING ANY "
 170           "host.service.name = 'p'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 171
 172         /* TIMESERIES commands */
 173         { "TIMESERIES 'host'.'metric' "
 174           "START 2014-01-01 "
 175           "END 2014-12-31 "
 176           "23:59:59",            -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 177         { "TIMESERIES 'host'.'metric' "
 178           "START 2014-02-02 "
 179           "14:02",               -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 180         /* the end time has to be greater than the start time;
 181          * we'll be safe for about 200 years ;-) */
 182         { "TIMESERIES 'host'.'metric' "
 183           "END 2214-02-02",      -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 184         { "TIMESERIES "
 185           "'host'.'metric'",     -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 186
 187         /* STORE commands */
 188         { "STORE host 'host'",   -1,  1, SDB_AST_TYPE_STORE, SDB_HOST },
 189         { "STORE host 'host' "
 190           "LAST UPDATE "
 191           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_HOST },
 192         { "STORE host attribute "
 193           "'host'.'key' 123",    -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 194         { "STORE host attribute "
 195           "'host'.'key' 123 "
 196           "LAST UPDATE "
 197           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 198         { "STORE service "
 199           "'host'.'svc'",        -1,  1, SDB_AST_TYPE_STORE, SDB_SERVICE },
 200         { "STORE service "
 201           "'host'.'svc' "
 202           "LAST UPDATE "
 203           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_SERVICE },
 204         { "STORE service attribute "
 205           "'host'.'svc'.'key' "
 206           "123",                 -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 207         { "STORE service attribute "
 208           "'host'.'svc'.'key' "
 209           "123 "
 210           "LAST UPDATE "
 211           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 212         { "STORE metric "
 213           "'host'.'metric'",     -1,  1, SDB_AST_TYPE_STORE, SDB_METRIC },
 214         { "STORE metric "
 215           "'host'.'metric' "
 216           "LAST UPDATE "
 217           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_METRIC },
 218         { "STORE metric "
 219           "'host'.'metric' "
 220           "STORE 'typ' 'id' "
 221           "LAST UPDATE "
 222           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_METRIC },
 223         { "STORE metric attribute "
 224           "'host'.'metric'.'key' "
 225           "123",                 -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 226         { "STORE metric attribute "
 227           "'host'.'metric'.'key' "
 228           "123 "
 229           "LAST UPDATE "
 230           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 231
 232         /* string constants */
 233         { "LOOKUP hosts MATCHING "
 234           "name = ''''",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 235         { "LOOKUP hosts MATCHING "
 236           "name = '''foo'",      -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 237         { "LOOKUP hosts MATCHING "
 238           "name = 'f''oo'",      -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 239         { "LOOKUP hosts MATCHING "
 240           "name = 'foo'''",      -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 241         { "LOOKUP hosts MATCHING "
 242           "name = '''",          -1, -1, 0, SDB_HOST },
 243
 244         /* numeric constants */
 245         { "LOOKUP hosts MATCHING "
 246           "attribute['foo'] = "
 247           "1234",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 248         { "LOOKUP hosts MATCHING "
 249           "attribute['foo'] != "
 250           "+234",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 251         { "LOOKUP hosts MATCHING "
 252           "attribute['foo'] < "
 253           "-234",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 254         { "LOOKUP hosts MATCHING "
 255           "attribute['foo'] > "
 256           "12.4",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 257         { "LOOKUP hosts MATCHING "
 258           "attribute['foo'] <= "
 259           "12. + .3",            -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 260         { "LOOKUP hosts MATCHING "
 261           "attribute['foo'] <= "
 262           "'f' || 'oo'",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 263         { "LOOKUP hosts MATCHING "
 264           "attribute['foo'] >= "
 265           ".4",                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 266         { "LOOKUP hosts MATCHING "
 267           "attribute['foo'] = "
 268           "+12e3",               -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 269         { "LOOKUP hosts MATCHING "
 270           "attribute['foo'] = "
 271           "+12e-3",              -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 272         { "LOOKUP hosts MATCHING "
 273           "attribute['foo'] = "
 274           "-12e+3",              -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 275
 276         /* date, time, interval constants */
 277         { "LOOKUP hosts MATCHING "
 278           "attribute['foo'] = "
 279           "1 Y 42D",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 280         { "LOOKUP hosts MATCHING "
 281           "attribute['foo'] = "
 282           "1s 42D",              -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 283         /*
 284          * TODO: Something like 1Y42D should work as well but it doesn't since
 285          * the scanner will tokenize it into {digit}{identifier} :-/
 286          *
 287         { "LOOKUP hosts MATCHING "
 288           "attribute['foo'] = "
 289           "1Y42D",               -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 290          */
 291
 292         /* array constants */
 293         { "LOOKUP hosts MATCHING "
 294           "backend = ['foo']",   -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 295         { "LOOKUP hosts MATCHING "
 296           "backend = ['a','b']", -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 297
 298         /* array iteration */
 299         { "LOOKUP hosts MATCHING "
 300           "'foo' IN backend",   -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 301         { "LOOKUP hosts MATCHING 'foo' "
 302           "NOT IN backend",     -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 303         { "LOOKUP hosts MATCHING "
 304           "['foo','bar'] "
 305           "IN backend ",        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 306         /* attribute type is unknown */
 307         { "LOOKUP hosts MATCHING "
 308           "attribute['backend'] "
 309           "IN backend ",        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 310         { "LOOKUP hosts MATCHING "
 311           "ANY backend < 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 312         { "LOOKUP hosts MATCHING "
 313           "ANY backend <= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 314         { "LOOKUP hosts MATCHING "
 315           "ANY backend = 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 316         { "LOOKUP hosts MATCHING "
 317           "ANY backend != 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 318         { "LOOKUP hosts MATCHING "
 319           "ANY backend >= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 320         { "LOOKUP hosts MATCHING "
 321           "ANY backend > 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 322         { "LOOKUP hosts MATCHING "
 323           "ANY backend =~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 324         { "LOOKUP hosts MATCHING "
 325           "ANY backend !~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 326         { "LOOKUP hosts MATCHING "
 327           "ALL backend < 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 328         { "LOOKUP hosts MATCHING "
 329           "ALL backend <= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 330         { "LOOKUP hosts MATCHING "
 331           "ALL backend = 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 332         { "LOOKUP hosts MATCHING "
 333           "ALL backend != 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 334         { "LOOKUP hosts MATCHING "
 335           "ALL backend >= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 336         { "LOOKUP hosts MATCHING "
 337           "ALL backend > 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 338         { "LOOKUP hosts MATCHING "
 339           "ALL backend =~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 340         { "LOOKUP hosts MATCHING "
 341           "ALL backend !~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 342         { "LOOKUP hosts MATCHING "
 343           "ANY backend || 'a' = 'b'",
 344                                 -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 345         /* attribute type is unknown */
 346         { "LOOKUP hosts MATCHING "
 347           "ANY backend = attribute['backend']",
 348                                 -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 349
 350         /* valid operand types */
 351         { "LOOKUP hosts MATCHING "
 352           "age * 1 > 0s",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 353         { "LOOKUP hosts MATCHING "
 354           "age / 1 > 0s",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 355         { "LOOKUP hosts MATCHING "
 356           "name > ''",           -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 357         { "LOOKUP hosts MATCHING "
 358           "name >= ''",          -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 359         { "LOOKUP hosts MATCHING "
 360           "name != ''",          -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 361         { "LOOKUP hosts MATCHING "
 362           "name = ''",           -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 363         { "LOOKUP hosts MATCHING "
 364           "name <= ''",          -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 365         { "LOOKUP hosts MATCHING "
 366           "name < ''",           -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 367
 368         /* typed expressions */
 369         { "LOOKUP services MATCHING "
 370           "host.attribute['a'] = 'a'",
 371                                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 372         /* TODO: this should work but the analyzer currently sees ATTRIBUTE
 373          * (instead of SERVICE-ATTRIBUTE) as the child type
 374         { "LOOKUP services MATCHING "
 375           "ANY attribute.service.name = 's'",
 376                                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 377          */
 378         { "LOOKUP hosts MATCHING "
 379           "ANY service.service.name = 's'",
 380                                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 381
 382         /* NULL / TRUE / FALSE */
 383         { "LOOKUP hosts MATCHING "
 384           "attribute['foo'] "
 385           "IS NULL",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 386         { "LOOKUP hosts MATCHING "
 387           "attribute['foo'] "
 388           "IS NOT NULL",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 389         { "LOOKUP hosts MATCHING "
 390           "NOT attribute['foo'] "
 391           "IS NULL",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 392         { "LOOKUP hosts MATCHING "
 393           "ANY service.name IS NULL", -1, -1, 0, 0 },
 394         { "LOOKUP hosts MATCHING "
 395           "attribute['foo'] "
 396           "IS TRUE",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 397         { "LOOKUP hosts MATCHING "
 398           "attribute['foo'] "
 399           "IS NOT TRUE",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 400         { "LOOKUP hosts MATCHING "
 401           "NOT attribute['foo'] "
 402           "IS TRUE",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 403         { "LOOKUP hosts MATCHING "
 404           "attribute['foo'] "
 405           "IS FALSE",            -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 406         { "LOOKUP hosts MATCHING "
 407           "attribute['foo'] "
 408           "IS NOT FALSE",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 409         { "LOOKUP hosts MATCHING "
 410           "NOT attribute['foo'] "
 411           "IS FALSE",            -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 412         { "LOOKUP metrics MATCHING "
 413           "timeseries IS TRUE",  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 414
 415         /* invalid numeric constants */
 416         { "LOOKUP hosts MATCHING "
 417           "attribute['foo'] = "
 418           "+-12e+3",             -1, -1, 0, 0 },
 419         { "LOOKUP hosts MATCHING "
 420           "attribute['foo'] = "
 421           "-12e-+3",             -1, -1, 0, 0 },
 422         { "LOOKUP hosts MATCHING "
 423           "attribute['foo'] = "
 424           "e+3",                 -1, -1, 0, 0 },
 425         { "LOOKUP hosts MATCHING "
 426           "attribute['foo'] = "
 427           "3e",                  -1, -1, 0, 0 },
 428         /* following SQL standard, we don't support hex numbers */
 429         { "LOOKUP hosts MATCHING "
 430           "attribute['foo'] = "
 431           "0x12",                -1, -1, 0, 0 },
 432
 433         /* invalid expressions */
 434         { "LOOKUP hosts MATCHING "
 435           "attr['foo'] = 1.23",  -1, -1, 0, 0 },
 436         { "LOOKUP hosts MATCHING "
 437           "attr['foo'] IS NULL", -1, -1, 0, 0 },
 438
 439         /* comments */
 440         { "/* some comment */",  -1,  0, 0, 0 },
 441         { "-- another comment",  -1,  0, 0, 0 },
 442
 443         /* syntax errors */
 444         { "INVALID",             -1, -1, 0, 0 },
 445         { "FETCH host",          -1, -1, 0, 0 },
 446         { "FETCH 'host'",        -1, -1, 0, 0 },
 447         { "LIST hosts; INVALID", -1, -1, 0, 0 },
 448         { "/* some incomplete",  -1, -1, 0, 0 },
 449
 450         /*
 451          * syntactically correct but semantically invalid commands
 452          */
 453
 454         /* invalid fields */
 455         { "LIST hosts FILTER "
 456           "field = 'a'",           -1, -1, 0, 0 },
 457         { "LIST services FILTER "
 458           "field = 'a'",           -1, -1, 0, 0 },
 459         { "LIST metrics FILTER "
 460           "field = 'a'",           -1, -1, 0, 0 },
 461         { "LIST hosts FILTER "
 462           "value = 'a'",           -1, -1, 0, 0 },
 463         { "LIST services FILTER "
 464           "value = 'a'",           -1, -1, 0, 0 },
 465         { "LIST metrics FILTER "
 466           "value = 'a'",           -1, -1, 0, 0 },
 467         { "LIST metrics FILTER "
 468           "name.1 = 'a'",          -1, -1, 0, 0 },
 469         { "LIST hosts FILTER "
 470           "timeseries IS TRUE",    -1, -1, 0, 0 },
 471         { "LIST services FILTER "
 472           "timeseries IS TRUE",    -1, -1, 0, 0 },
 473
 474         /* type mismatches */
 475         { "LOOKUP hosts MATCHING "
 476           "attribute['foo'] = "
 477           "1.23 + 'foo'",       -1,  -1, 0, 0 },
 478         { "LOOKUP hosts MATCHING "
 479           "1 IN backend ",      -1,  -1, 0, 0 },
 480         { "LOOKUP hosts MATCHING "
 481           "1 NOT IN backend ",  -1,  -1, 0, 0 },
 482         { "LOOKUP hosts MATCHING "
 483           "age > 0",             -1, -1, 0, 0 },
 484         { "LOOKUP hosts MATCHING "
 485           "NOT age > 0",         -1, -1, 0, 0 },
 486         { "LOOKUP hosts MATCHING "
 487           "age >= 0",            -1, -1, 0, 0 },
 488         { "LOOKUP hosts MATCHING "
 489           "age = 0",             -1, -1, 0, 0 },
 490         { "LOOKUP hosts MATCHING "
 491           "age != 0",            -1, -1, 0, 0 },
 492         { "LOOKUP hosts MATCHING "
 493           "age <= 0",            -1, -1, 0, 0 },
 494         { "LOOKUP hosts MATCHING "
 495           "age < 0",             -1, -1, 0, 0 },
 496         { "LOOKUP hosts MATCHING "
 497           "age + 1 > 0s",        -1, -1, 0, 0 },
 498         { "LOOKUP hosts MATCHING "
 499           "age - 1 > 0s",        -1, -1, 0, 0 },
 500
 501         /* datetime <mul/div> integer is allowed */
 502         { "LOOKUP hosts MATCHING "
 503           "age || 1 > 0s",       -1, -1, 0, 0 },
 504         { "LOOKUP hosts MATCHING "
 505           "name + 1 = ''",       -1, -1, 0, 0 },
 506         { "LOOKUP hosts MATCHING "
 507           "name - 1 = ''",       -1, -1, 0, 0 },
 508         { "LOOKUP hosts MATCHING "
 509           "name * 1 = ''",       -1, -1, 0, 0 },
 510         { "LOOKUP hosts MATCHING "
 511           "name / 1 = ''",       -1, -1, 0, 0 },
 512         { "LOOKUP hosts MATCHING "
 513           "name % 1 = ''",       -1, -1, 0, 0 },
 514         { "LOOKUP hosts MATCHING "
 515           "(name % 1) + 1 = ''", -1, -1, 0, 0 },
 516         { "LOOKUP hosts MATCHING "
 517           "1 + (name % 1) = ''", -1, -1, 0, 0 },
 518         { "LOOKUP hosts MATCHING "
 519           "'' = 1 + (name % 1)", -1, -1, 0, 0 },
 520         { "LOOKUP hosts MATCHING "
 521           "age > 0 AND "
 522           "age = 0s",            -1, -1, 0, 0 },
 523         { "LOOKUP hosts MATCHING "
 524           "age = 0s AND "
 525           "age > 0",             -1, -1, 0, 0 },
 526         { "LOOKUP services MATCHING "
 527           "host.name > 0",       -1, -1, 0, 0 },
 528         { "LOOKUP services MATCHING "
 529           "backend > 'b'",       -1, -1, 0, 0 },
 530         { "LOOKUP services MATCHING "
 531           "'b' > backend",       -1, -1, 0, 0 },
 532         { "LOOKUP services MATCHING "
 533           "attribute['a'] > backend",
 534                                  -1, -1, 0, 0 },
 535         { "LOOKUP services MATCHING "
 536           "backend > attribute['a']",
 537                                  -1, -1, 0, 0 },
 538         { "LOOKUP services MATCHING "
 539           "host.name + 1 = ''",  -1, -1, 0, 0 },
 540         { "LOOKUP hosts MATCHING "
 541           "'a' + 1 IN 'b'",      -1, -1, 0, 0 },
 542         { "LOOKUP hosts MATCHING "
 543           "'a' IN 'b' - 1",      -1, -1, 0, 0 },
 544         { "LOOKUP hosts MATCHING "
 545           "name + 1 IN 'b'",     -1, -1, 0, 0 },
 546         { "LOOKUP hosts MATCHING "
 547           "'a' IN name - 1",     -1, -1, 0, 0 },
 548         { "LOOKUP hosts MATCHING "
 549           "'b' IN 'abc'",        -1, -1, 0, 0 },
 550         { "LOOKUP hosts MATCHING "
 551           "1 IN age",            -1, -1, 0, 0 },
 552         { "LOOKUP hosts MATCHING "
 553           "name =~ 'a' + 1",     -1, -1, 0, 0 },
 554         { "LOOKUP hosts MATCHING "
 555           "name =~ name + 1",    -1, -1, 0, 0 },
 556         { "LOOKUP hosts MATCHING "
 557           "name + 1 =~ 'a'",     -1, -1, 0, 0 },
 558         { "LOOKUP hosts MATCHING "
 559           "name =~ 1",           -1, -1, 0, 0 },
 560         { "LOOKUP hosts MATCHING "
 561           "name + 1 IS NULL",    -1, -1, 0, 0 },
 562         { "LOOKUP hosts FILTER "
 563           "name + 1 IS NULL",    -1, -1, 0, 0 },
 564         { "LOOKUP hosts MATCHING "
 565           "name + 1 IS TRUE",    -1, -1, 0, 0 },
 566         { "LOOKUP hosts FILTER "
 567           "name + 1 IS TRUE",    -1, -1, 0, 0 },
 568         { "LOOKUP hosts MATCHING "
 569           "name + 1 IS FALSE",   -1, -1, 0, 0 },
 570         { "LOOKUP hosts FILTER "
 571           "name + 1 IS FALSE",   -1, -1, 0, 0 },
 572
 573         /* invalid iterators */
 574         { "LOOKUP hosts MATCHING "
 575           "ANY backend !~ backend",
 576                                 -1,  -1, 0, 0 },
 577         { "LOOKUP hosts MATCHING "
 578           "ANY backend = 1",    -1,  -1, 0, 0 },
 579         { "LOOKUP hosts MATCHING "
 580           "ANY 'patt' =~ 'p'",  -1,  -1, 0, 0 },
 581         { "LOOKUP hosts MATCHING "
 582           "ALL 1 || '2' < '3'", -1,  -1, 0, 0 },
 583         { "LOOKUP hosts MATCHING "
 584           "ALL name =~ 'a'",    -1,  -1, 0, 0 },
 585         { "LOOKUP hosts MATCHING ANY "
 586           "host.name = 'h'",    -1, -1, 0, 0 },
 587         { "LOOKUP services MATCHING ANY "
 588           "host.name = 'h'",    -1, -1, 0, 0 },
 589         { "LOOKUP metrics MATCHING ANY "
 590           "host.name = 'h'",    -1, -1, 0, 0 },
 591         { "LOOKUP hosts MATCHING ANY "
 592           "name || 'a' = 'b'",  -1, -1, 0, 0 },
 593
 594         /* invalid LIST commands */
 595         { "LIST",                -1, -1, 0, 0 },
 596         { "LIST foo",            -1, -1, 0, 0 },
 597         { "LIST hosts MATCHING "
 598           "name = 'host'",       -1, -1, 0, 0 },
 599         { "LIST foo FILTER "
 600           "age > 60s",           -1, -1, 0, 0 },
 601
 602         /* invalid FETCH commands */
 603         { "FETCH host 'host' MATCHING "
 604           "name = 'host'",       -1, -1, 0, 0 },
 605         { "FETCH service 'host'",-1, -1, 0, 0 },
 606         { "FETCH metric 'host'", -1, -1, 0, 0 },
 607         { "FETCH host "
 608           "'host'.'localhost'",  -1, -1, 0, 0 },
 609         { "FETCH foo 'host'",    -1, -1, 0, 0 },
 610         { "FETCH foo 'host' FILTER "
 611           "age > 60s",           -1, -1, 0, 0 },
 612
 613         /* invalid LOOKUP commands */
 614         { "LOOKUP foo",          -1, -1, 0, 0 },
 615         { "LOOKUP foo MATCHING "
 616           "name = 'host'",       -1, -1, 0, 0 },
 617         { "LOOKUP foo FILTER "
 618           "age > 60s",           -1, -1, 0, 0 },
 619         { "LOOKUP foo MATCHING "
 620           "name = 'host' FILTER "
 621           "age > 60s",           -1, -1, 0, 0 },
 622         { "LOOKUP hosts MATCHING "
 623           "attribute['foo'] <= "
 624           "f || 'oo'",           -1, -1, 0, 0 },
 625         { "LOOKUP hosts MATCHING "
 626           "attribute['foo'] <= "
 627           "'f' || oo",           -1, -1, 0, 0 },
 628         { "LOOKUP hosts MATCHING "
 629           "ANY host.name = 'host'",   -1, -1, 0, 0 },
 630         { "LOOKUP hosts MATCHING "
 631           "ANY service.name > 1",     -1, -1, 0, 0 },
 632         { "LOOKUP hosts MATCHING "
 633           "service.name = 's'",       -1, -1, 0, 0 },
 634         { "LOOKUP services MATCHING "
 635           "ANY host.name = 'host'",   -1, -1, 0, 0 },
 636         { "LOOKUP services MATCHING "
 637           "ANY service.name = 'svc'", -1, -1, 0, 0 },
 638         { "LOOKUP services MATCHING "
 639           "ANY metric.name = 'm'",    -1, -1, 0, 0 },
 640         { "LOOKUP services MATCHING "
 641           "metric.name = 'm'",        -1, -1, 0, 0 },
 642         { "LOOKUP metrics MATCHING "
 643           "ANY host.name = 'host'",   -1, -1, 0, 0 },
 644         { "LOOKUP metrics MATCHING "
 645           "ANY service.name = 'svc'", -1, -1, 0, 0 },
 646         { "LOOKUP metrics MATCHING "
 647           "ANY metric.name = 'm'",    -1, -1, 0, 0 },
 648         { "LOOKUP metrics MATCHING "
 649           "service.name = 'm'",       -1, -1, 0, 0 },
 650
 651         /* invalid STORE commands */
 652         { "STORE host "
 653           "'obj'.'host'",        -1, -1, 0, 0 },
 654         { "STORE host attribute "
 655           ".'key' 123",          -1, -1, 0, 0 },
 656         { "STORE host attribute "
 657           "'o'.'h'.'key' 123",   -1, -1, 0, 0 },
 658         { "STORE service 'svc'", -1, -1, 0, 0 },
 659         { "STORE service "
 660           "'host'.'svc' "
 661           "STORE 'typ' 'id' "
 662           "LAST UPDATE "
 663           "2015-02-01",          -1, -1, 0, 0 },
 664         { "STORE service attribute "
 665           "'svc'.'key' 123",     -1, -1, 0, 0 },
 666         { "STORE metric 'm'",    -1, -1, 0, 0 },
 667         { "STORE metric "
 668           "'host'.'metric' "
 669           "STORE 'typ'.'id' "
 670           "LAST UPDATE "
 671           "2015-02-01",          -1, -1, 0, 0 },
 672         { "STORE metric attribute "
 673           "'metric'.'key' 123",  -1, -1, 0, 0 },
 674 };
 675
 676 START_TEST(test_parse)
 677 {
 678         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 679         sdb_llist_t *check;
 680         sdb_ast_node_t *node;
 681         sdb_store_query_t *q;
 682         _Bool ok;
 683
 684         check = sdb_parser_parse(parse_data[_i].query,
 685                         parse_data[_i].len, errbuf);
 686         if (parse_data[_i].expected < 0)
 687                 ok = check == 0;
 688         else
 689                 ok = sdb_llist_len(check) == (size_t)parse_data[_i].expected;
 690
 691         fail_unless(ok, "sdb_parser_parse(%s) = %p (len: %zu); expected: %d "
 692                         "(parse error: %s)", parse_data[_i].query, check,
 693                         sdb_llist_len(check), parse_data[_i].expected,
 694                         sdb_strbuf_string(errbuf));
 695
 696         if (! check) {
 697                 sdb_strbuf_destroy(errbuf);
 698                 return;
 699         }
 700
 701         if ((! parse_data[_i].expected_type)
 702                         || (parse_data[_i].expected <= 0)) {
 703                 sdb_llist_destroy(check);
 704                 sdb_strbuf_destroy(errbuf);
 705                 return;
 706         }
 707
 708         node = SDB_AST_NODE(sdb_llist_get(check, 0));
 709         fail_unless(node->type == parse_data[_i].expected_type,
 710                         "sdb_parser_parse(%s)->type = %i; expected: %d",
 711                         parse_data[_i].query, node->type,
 712                         parse_data[_i].expected_type);
 713
 714         if (node->type == SDB_AST_TYPE_FETCH) {
 715                 sdb_ast_fetch_t *f = SDB_AST_FETCH(node);
 716                 fail_unless(f->obj_type == parse_data[_i].expected_extra,
 717                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 718                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(f->obj_type),
 719                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 720         }
 721         else if (node->type == SDB_AST_TYPE_LIST) {
 722                 sdb_ast_list_t *l = SDB_AST_LIST(node);
 723                 fail_unless(l->obj_type == parse_data[_i].expected_extra,
 724                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 725                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(l->obj_type),
 726                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 727         }
 728         else if (node->type == SDB_AST_TYPE_LOOKUP) {
 729                 sdb_ast_lookup_t *l = SDB_AST_LOOKUP(node);
 730                 fail_unless(l->obj_type == parse_data[_i].expected_extra,
 731                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 732                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(l->obj_type),
 733                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 734         }
 735         else if (node->type == SDB_AST_TYPE_STORE) {
 736                 sdb_ast_store_t *s = SDB_AST_STORE(node);
 737                 fail_unless(s->obj_type == parse_data[_i].expected_extra,
 738                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 739                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(s->obj_type),
 740                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 741         }
 742
 743         /* TODO: this should move into front-end specific tests */
 744         q = sdb_store_query_prepare(node);
 745         fail_unless(q != NULL,
 746                         "sdb_store_query_prepare(AST<%s>) = NULL; expected: <query>",
 747                         parse_data[_i].query);
 748
 749         sdb_object_deref(SDB_OBJ(node));
 750         sdb_object_deref(SDB_OBJ(q));
 751         sdb_llist_destroy(check);
 752         sdb_strbuf_destroy(errbuf);
 753 }
 754 END_TEST
 755
 756 struct {
 757         int context;
 758         const char *expr;
 759         int len;
 760         int expected;
 761 } parse_conditional_data[] = {
 762         /* empty expressions */
 763         { SDB_HOST, NULL,                           -1, -1 },
 764         { SDB_HOST, "",                             -1, -1 },
 765
 766         /* match hosts by name */
 767         { SDB_HOST, "name < 'localhost'",           -1,  SDB_AST_LT },
 768         { SDB_HOST, "name <= 'localhost'",          -1,  SDB_AST_LE },
 769         { SDB_HOST, "name = 'localhost'",           -1,  SDB_AST_EQ },
 770         { SDB_HOST, "name != 'localhost'",          -1,  SDB_AST_NE },
 771         { SDB_HOST, "name >= 'localhost'",          -1,  SDB_AST_GE },
 772         { SDB_HOST, "name > 'localhost'",           -1,  SDB_AST_GT },
 773         { SDB_HOST, "name =~ 'host'",               -1,  SDB_AST_REGEX },
 774         { SDB_HOST, "name !~ 'host'",               -1,  SDB_AST_NREGEX },
 775         { SDB_HOST, "name = 'localhost' -- foo",    -1,  SDB_AST_EQ },
 776         { SDB_HOST, "name = 'host' <garbage>",      13,  SDB_AST_EQ },
 777         { SDB_HOST, "name &^ 'localhost'",          -1,  -1 },
 778         /* match by backend */
 779         { SDB_HOST, "ANY backend < 'be'",           -1,  SDB_AST_ANY },
 780         { SDB_HOST, "ANY backend <= 'be'",          -1,  SDB_AST_ANY },
 781         { SDB_HOST, "ANY backend = 'be'",           -1,  SDB_AST_ANY },
 782         { SDB_HOST, "ANY backend != 'be'",          -1,  SDB_AST_ANY },
 783         { SDB_HOST, "ANY backend >= 'be'",          -1,  SDB_AST_ANY },
 784         { SDB_HOST, "ANY backend > 'be'",           -1,  SDB_AST_ANY },
 785         { SDB_HOST, "ALL backend < 'be'",           -1,  SDB_AST_ALL },
 786         { SDB_HOST, "ALL backend <= 'be'",          -1,  SDB_AST_ALL },
 787         { SDB_HOST, "ALL backend = 'be'",           -1,  SDB_AST_ALL },
 788         { SDB_HOST, "ALL backend != 'be'",          -1,  SDB_AST_ALL },
 789         { SDB_HOST, "ALL backend >= 'be'",          -1,  SDB_AST_ALL },
 790         { SDB_HOST, "ALL backend > 'be'",           -1,  SDB_AST_ALL },
 791         { SDB_HOST, "ANY backend &^ 'be'",          -1,  -1 },
 792         /* match hosts by service */
 793         { SDB_HOST, "ANY service.name < 'name'",         -1,  SDB_AST_ANY },
 794         { SDB_HOST, "ANY service.name <= 'name'",        -1,  SDB_AST_ANY },
 795         { SDB_HOST, "ANY service.name = 'name'",         -1,  SDB_AST_ANY },
 796         { SDB_HOST, "ANY service.name != 'name'",        -1,  SDB_AST_ANY },
 797         { SDB_HOST, "ANY service.name >= 'name'",        -1,  SDB_AST_ANY },
 798         { SDB_HOST, "ANY service.name > 'name'",         -1,  SDB_AST_ANY },
 799         { SDB_HOST, "ANY service.name =~ 'pattern'",     -1,  SDB_AST_ANY },
 800         { SDB_HOST, "ANY service.name !~ 'pattern'",     -1,  SDB_AST_ANY },
 801         { SDB_HOST, "ANY service.name &^ 'name'",        -1,  -1 },
 802         { SDB_HOST, "ALL service.name < 'name'",         -1,  SDB_AST_ALL },
 803         { SDB_HOST, "ALL service.name <= 'name'",        -1,  SDB_AST_ALL },
 804         { SDB_HOST, "ALL service.name = 'name'",         -1,  SDB_AST_ALL },
 805         { SDB_HOST, "ALL service.name != 'name'",        -1,  SDB_AST_ALL },
 806         { SDB_HOST, "ALL service.name >= 'name'",        -1,  SDB_AST_ALL },
 807         { SDB_HOST, "ALL service.name > 'name'",         -1,  SDB_AST_ALL },
 808         { SDB_HOST, "ALL service.name =~ 'pattern'",     -1,  SDB_AST_ALL },
 809         { SDB_HOST, "ALL service.name !~ 'pattern'",     -1,  SDB_AST_ALL },
 810         { SDB_HOST, "ALL service.name &^ 'name'",        -1,  -1 },
 811         { SDB_HOST, "ANY service < 'name'",              -1,  -1 },
 812         /* match hosts by metric */
 813         { SDB_HOST, "ANY metric.name < 'name'",          -1,  SDB_AST_ANY },
 814         { SDB_HOST, "ANY metric.name <= 'name'",         -1,  SDB_AST_ANY },
 815         { SDB_HOST, "ANY metric.name = 'name'",          -1,  SDB_AST_ANY },
 816         { SDB_HOST, "ANY metric.name != 'name'",         -1,  SDB_AST_ANY },
 817         { SDB_HOST, "ANY metric.name >= 'name'",         -1,  SDB_AST_ANY },
 818         { SDB_HOST, "ANY metric.name > 'name'",          -1,  SDB_AST_ANY },
 819         { SDB_HOST, "ANY metric.name =~ 'pattern'",      -1,  SDB_AST_ANY },
 820         { SDB_HOST, "ANY metric.name !~ 'pattern'",      -1,  SDB_AST_ANY },
 821         { SDB_HOST, "ANY metric.name &^ 'pattern'",      -1,  -1 },
 822         { SDB_HOST, "ALL metric.name < 'name'",          -1,  SDB_AST_ALL },
 823         { SDB_HOST, "ALL metric.name <= 'name'",         -1,  SDB_AST_ALL },
 824         { SDB_HOST, "ALL metric.name = 'name'",          -1,  SDB_AST_ALL },
 825         { SDB_HOST, "ALL metric.name != 'name'",         -1,  SDB_AST_ALL },
 826         { SDB_HOST, "ALL metric.name >= 'name'",         -1,  SDB_AST_ALL },
 827         { SDB_HOST, "ALL metric.name > 'name'",          -1,  SDB_AST_ALL },
 828         { SDB_HOST, "ALL metric.name =~ 'pattern'",      -1,  SDB_AST_ALL },
 829         { SDB_HOST, "ALL metric.name !~ 'pattern'",      -1,  SDB_AST_ALL },
 830         { SDB_HOST, "ALL metric.name &^ 'pattern'",      -1,  -1 },
 831         { SDB_HOST, "ANY metric <= 'name'",              -1,  -1 },
 832         /* match hosts by attribute */
 833         { SDB_HOST, "ANY attribute.name < 'name'",       -1,  SDB_AST_ANY },
 834         { SDB_HOST, "ANY attribute.name <= 'name'",      -1,  SDB_AST_ANY },
 835         { SDB_HOST, "ANY attribute.name = 'name'",       -1,  SDB_AST_ANY },
 836         { SDB_HOST, "ANY attribute.name != 'name'",      -1,  SDB_AST_ANY },
 837         { SDB_HOST, "ANY attribute.name >= 'name'",      -1,  SDB_AST_ANY },
 838         { SDB_HOST, "ANY attribute.name > 'name'",       -1,  SDB_AST_ANY },
 839         { SDB_HOST, "ANY attribute.name =~ 'pattern'",   -1,  SDB_AST_ANY },
 840         { SDB_HOST, "ANY attribute.name !~ 'pattern'",   -1,  SDB_AST_ANY },
 841         { SDB_HOST, "ANY attribute.name &^ 'pattern'",   -1,  -1 },
 842         { SDB_HOST, "ALL attribute.name < 'name'",       -1,  SDB_AST_ALL },
 843         { SDB_HOST, "ALL attribute.name <= 'name'",      -1,  SDB_AST_ALL },
 844         { SDB_HOST, "ALL attribute.name = 'name'",       -1,  SDB_AST_ALL },
 845         { SDB_HOST, "ALL attribute.name != 'name'",      -1,  SDB_AST_ALL },
 846         { SDB_HOST, "ALL attribute.name >= 'name'",      -1,  SDB_AST_ALL },
 847         { SDB_HOST, "ALL attribute.name > 'name'",       -1,  SDB_AST_ALL },
 848         { SDB_HOST, "ALL attribute.name =~ 'pattern'",   -1,  SDB_AST_ALL },
 849         { SDB_HOST, "ALL attribute.name !~ 'pattern'",   -1,  SDB_AST_ALL },
 850         { SDB_HOST, "ALL attribute.name &^ 'pattern'",   -1,  -1 },
 851         { SDB_HOST, "ANY attribute !~ 'pattern'",        -1,  -1 },
 852
 853         /* composite expressions */
 854         { SDB_HOST, "name =~ 'pattern' AND "
 855           "ANY service.name =~ 'pattern'",  -1,  SDB_AST_AND },
 856         { SDB_HOST, "name =~ 'pattern' OR "
 857           "ANY service.name =~ 'pattern'",  -1,  SDB_AST_OR },
 858         { SDB_HOST, "NOT name = 'host'",              -1,  SDB_AST_NOT },
 859         /* numeric expressions */
 860         { SDB_HOST, "attribute['foo'] < 123",         -1,  SDB_AST_LT },
 861         { SDB_HOST, "attribute['foo'] <= 123",        -1,  SDB_AST_LE },
 862         { SDB_HOST, "attribute['foo'] = 123",         -1,  SDB_AST_EQ },
 863         { SDB_HOST, "attribute['foo'] >= 123",        -1,  SDB_AST_GE },
 864         { SDB_HOST, "attribute['foo'] > 123",         -1,  SDB_AST_GT },
 865         /* datetime expressions */
 866         { SDB_HOST, "attribute['foo'] = "
 867           "2014-08-16",                     -1,  SDB_AST_EQ },
 868         { SDB_HOST, "attribute['foo'] = "
 869           "17:23",                          -1,  SDB_AST_EQ },
 870         { SDB_HOST, "attribute['foo'] = "
 871           "17:23:53",                       -1,  SDB_AST_EQ },
 872         { SDB_HOST, "attribute['foo'] = "
 873           "17:23:53.123",                   -1,  SDB_AST_EQ },
 874         { SDB_HOST, "attribute['foo'] = "
 875           "17:23:53.123456789",             -1,  SDB_AST_EQ },
 876         { SDB_HOST, "attribute['foo'] = "
 877           "2014-08-16 17:23",               -1,  SDB_AST_EQ },
 878         { SDB_HOST, "attribute['foo'] = "
 879           "2014-08-16 17:23:53",            -1,  SDB_AST_EQ },
 880         /* NULL / TRUE / FALSE */
 881         { SDB_HOST, "attribute['foo'] IS NULL",       -1,  SDB_AST_ISNULL },
 882         { SDB_HOST, "attribute['foo'] IS NOT NULL",   -1,  SDB_AST_NOT },
 883         { SDB_HOST, "attribute['foo'] IS TRUE",       -1,  SDB_AST_ISTRUE },
 884         { SDB_HOST, "attribute['foo'] IS NOT TRUE",   -1,  SDB_AST_NOT },
 885         { SDB_HOST, "attribute['foo'] IS FALSE",      -1,  SDB_AST_ISFALSE },
 886         { SDB_HOST, "attribute['foo'] IS NOT FALSE",  -1,  SDB_AST_NOT },
 887         /* array expressions */
 888         { SDB_HOST, "backend < ['a']",                -1,  SDB_AST_LT },
 889         { SDB_HOST, "backend <= ['a']",               -1,  SDB_AST_LE },
 890         { SDB_HOST, "backend = ['a']",                -1,  SDB_AST_EQ },
 891         { SDB_HOST, "backend != ['a']",               -1,  SDB_AST_NE },
 892         { SDB_HOST, "backend >= ['a']",               -1,  SDB_AST_GE },
 893         { SDB_HOST, "backend > ['a']",                -1,  SDB_AST_GT },
 894         { SDB_HOST, "backend &^ ['a']",               -1,  -1 },
 895
 896         /* object field comparison */
 897         { SDB_HOST, "name < 'a'",                     -1,  SDB_AST_LT },
 898         { SDB_HOST, "name <= 'a'",                    -1,  SDB_AST_LE },
 899         { SDB_HOST, "name = 'a'",                     -1,  SDB_AST_EQ },
 900         { SDB_HOST, "name != 'a'",                    -1,  SDB_AST_NE },
 901         { SDB_HOST, "name >= 'a'",                    -1,  SDB_AST_GE },
 902         { SDB_HOST, "name > 'a'",                     -1,  SDB_AST_GT },
 903         { SDB_HOST, "last_update < 2014-10-01",       -1,  SDB_AST_LT },
 904         { SDB_HOST, "last_update <= 2014-10-01",      -1,  SDB_AST_LE },
 905         { SDB_HOST, "last_update = 2014-10-01",       -1,  SDB_AST_EQ },
 906         { SDB_HOST, "last_update != 2014-10-01",      -1,  SDB_AST_NE },
 907         { SDB_HOST, "last_update >= 2014-10-01",      -1,  SDB_AST_GE },
 908         { SDB_HOST, "last_update > 2014-10-01",       -1,  SDB_AST_GT },
 909         { SDB_HOST, "Last_Update >= 24D",             -1,  SDB_AST_GE },
 910         { SDB_HOST, "age < 20s",                      -1,  SDB_AST_LT },
 911         { SDB_HOST, "age <= 20s",                     -1,  SDB_AST_LE },
 912         { SDB_HOST, "age = 20s",                      -1,  SDB_AST_EQ },
 913         { SDB_HOST, "age != 20s",                     -1,  SDB_AST_NE },
 914         { SDB_HOST, "age >= 20s",                     -1,  SDB_AST_GE },
 915         { SDB_HOST, "age > 20s",                      -1,  SDB_AST_GT },
 916         { SDB_HOST, "AGE <= 1m",                      -1,  SDB_AST_LE },
 917         { SDB_HOST, "age > 1M",                       -1,  SDB_AST_GT },
 918         { SDB_HOST, "age != 20Y",                     -1,  SDB_AST_NE },
 919         { SDB_HOST, "age <= 2 * interval",            -1,  SDB_AST_LE },
 920         { SDB_HOST, "interval < 20s",                 -1,  SDB_AST_LT },
 921         { SDB_HOST, "interval <= 20s",                -1,  SDB_AST_LE },
 922         { SDB_HOST, "interval = 20s",                 -1,  SDB_AST_EQ },
 923         { SDB_HOST, "interval != 20s",                -1,  SDB_AST_NE },
 924         { SDB_HOST, "interval >= 20s",                -1,  SDB_AST_GE },
 925         { SDB_HOST, "interval > 20s",                 -1,  SDB_AST_GT },
 926         { SDB_HOST, "'be' IN backend",                -1,  SDB_AST_IN },
 927         { SDB_HOST, "'be' NOT IN backend",            -1,  SDB_AST_NOT },
 928         { SDB_HOST, "['a','b'] IN backend",           -1,  SDB_AST_IN },
 929         { SDB_HOST, "['a','b'] NOT IN backend",       -1,  SDB_AST_NOT },
 930         { SDB_METRIC, "timeseries IS TRUE",           -1,  SDB_AST_ISTRUE },
 931         { SDB_METRIC, "timeseries IS FALSE",          -1,  SDB_AST_ISFALSE },
 932         { SDB_METRIC, "timeseries IS NOT TRUE",       -1,  SDB_AST_NOT },
 933         { SDB_METRIC, "timeseries IS NOT FALSE",      -1,  SDB_AST_NOT },
 934         { SDB_METRIC, "timeseries > 0",               -1,  -1 },
 935         { SDB_METRIC, "timeseries = TRUE",            -1,  -1 },
 936         { SDB_METRIC, "timeseries != FALSE",          -1,  -1 },
 937
 938         /* check operator precedence */
 939         { SDB_HOST, "name = 'name' OR "
 940           "ANY service.name = 'name' AND "
 941           "ANY attribute.name = 'name' OR "
 942           "attribute['foo'] = 'bar'",       -1,  SDB_AST_OR },
 943         { SDB_HOST, "name = 'name' AND "
 944           "ANY service.name = 'name' AND "
 945           "ANY attribute.name = 'name' OR "
 946           "attribute['foo'] = 'bar'",       -1,  SDB_AST_OR },
 947         { SDB_HOST, "name = 'name' AND "
 948           "ANY service.name = 'name' OR "
 949           "ANY attribute.name = 'name' AND "
 950           "attribute['foo'] = 'bar'",       -1,  SDB_AST_OR },
 951         { SDB_HOST, "(name = 'name' OR "
 952           "ANY service.name = 'name') AND "
 953           "(ANY attribute.name = 'name' OR "
 954           "attribute['foo'] = 'bar')",      -1,  SDB_AST_AND },
 955         { SDB_HOST, "NOT name = 'name' OR "
 956           "ANY service.name = 'name'",      -1,  SDB_AST_OR },
 957         { SDB_HOST, "NOT name = 'name' OR "
 958           "NOT ANY service.name = 'name'",  -1,  SDB_AST_OR },
 959         { SDB_HOST, "NOT (name = 'name' OR "
 960           "NOT ANY service.name = 'name')", -1,  SDB_AST_NOT },
 961
 962         /* syntax errors */
 963         { SDB_HOST, "LIST hosts",                     -1, -1 },
 964         { SDB_HOST, "foo &^ bar",                     -1, -1 },
 965         { SDB_HOST, "invalid",                        -1, -1 },
 966 };
 967
 968 START_TEST(test_parse_conditional)
 969 {
 970         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 971         sdb_ast_node_t *node;
 972
 973         node = sdb_parser_parse_conditional(parse_conditional_data[_i].context,
 974                         parse_conditional_data[_i].expr, parse_conditional_data[_i].len, errbuf);
 975
 976         if (parse_conditional_data[_i].expected < 0) {
 977                 fail_unless(node == NULL,
 978                                 "sdb_parser_parse_conditional(%s, %s) = %p; expected: NULL",
 979                                 SDB_STORE_TYPE_TO_NAME(parse_conditional_data[_i].context),
 980                                 parse_conditional_data[_i].expr, node);
 981                 sdb_object_deref(SDB_OBJ(node));
 982                 sdb_strbuf_destroy(errbuf);
 983                 return;
 984         }
 985
 986         fail_unless(node != NULL, "sdb_parser_parse_conditional(%s, %s) = NULL; "
 987                         "expected: <cond> (parse error: %s)",
 988                         SDB_STORE_TYPE_TO_NAME(parse_conditional_data[_i].context),
 989                         parse_conditional_data[_i].expr, sdb_strbuf_string(errbuf));
 990         if (node->type == SDB_AST_TYPE_OPERATOR)
 991                 fail_unless(SDB_AST_OP(node)->kind == parse_conditional_data[_i].expected,
 992                                 "sdb_parser_parse_conditional(%s, %s) returned conditional of type %d; "
 993                                 "expected: %d",
 994                                 SDB_STORE_TYPE_TO_NAME(parse_conditional_data[_i].context),
 995                                 parse_conditional_data[_i].expr,
 996                                 SDB_AST_OP(node)->kind, parse_conditional_data[_i].expected);
 997         else if (node->type == SDB_AST_TYPE_ITERATOR)
 998                 fail_unless(SDB_AST_ITER(node)->kind == parse_conditional_data[_i].expected,
 999                                 "sdb_parser_parse_conditional(%s, %s) returned conditional of type %d; "
1000                                 "expected: %d",
1001                                 SDB_STORE_TYPE_TO_NAME(parse_conditional_data[_i].context),
1002                                 parse_conditional_data[_i].expr,
1003                                 SDB_AST_ITER(node)->kind, parse_conditional_data[_i].expected);
1004
1005         fail_unless(node->data_type == -1,
1006                         "sdb_parser_parse_conditional(%s, %s) returned conditional "
1007                         "of data-type %s; expected: %s",
1008                         SDB_STORE_TYPE_TO_NAME(parse_conditional_data[_i].context),
1009                         parse_conditional_data[_i].expr,
1010                         SDB_TYPE_TO_STRING(node->data_type), SDB_TYPE_TO_STRING(-1));
1011
1012         sdb_object_deref(SDB_OBJ(node));
1013         sdb_strbuf_destroy(errbuf);
1014 }
1015 END_TEST
1016
1017 struct {
1018         int context;
1019         const char *expr;
1020         int len;
1021         int expected;
1022         int data_type;
1023 } parse_arith_data[] = {
1024         /* empty expressions */
1025         { SDB_HOST, NULL,                   -1, -1, -1 },
1026         { SDB_HOST, "",                     -1, -1, -1 },
1027
1028         /* constant expressions */
1029         { SDB_HOST, "'localhost'",          -1, SDB_AST_TYPE_CONST, SDB_TYPE_STRING },
1030         { SDB_HOST, "123",                  -1, SDB_AST_TYPE_CONST, SDB_TYPE_INTEGER },
1031         { SDB_HOST, "42.3",                 -1, SDB_AST_TYPE_CONST, SDB_TYPE_DECIMAL },
1032         { SDB_HOST, "2014-08-16",           -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1033         { SDB_HOST, "17:23",                -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1034         { SDB_HOST, "17:23:53",             -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1035         { SDB_HOST, "17:23:53.123",         -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1036         { SDB_HOST, "17:23:53.123456789",   -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1037         { SDB_HOST, "2014-08-16 17:23",     -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1038         { SDB_HOST, "2014-08-16 17:23:53",  -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1039         { SDB_HOST, "10s",                  -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1040         { SDB_HOST, "60m",                  -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1041         { SDB_HOST, "10Y 24D 1h",           -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
1042
1043         /* TODO: the analyzer and/or optimizer should turn these into constants */
1044         { SDB_HOST, "123 + 456",            -1, SDB_AST_ADD, SDB_TYPE_INTEGER },
1045         { SDB_HOST, "'foo' || 'bar'",       -1, SDB_AST_CONCAT, SDB_TYPE_STRING },
1046         { SDB_HOST, "456 - 123",            -1, SDB_AST_SUB, SDB_TYPE_INTEGER },
1047         { SDB_HOST, "1.2 * 3.4",            -1, SDB_AST_MUL, SDB_TYPE_DECIMAL },
1048         { SDB_HOST, "1.2 / 3.4",            -1, SDB_AST_DIV, SDB_TYPE_DECIMAL },
1049         { SDB_HOST, "5 % 2",                -1, SDB_AST_MOD, SDB_TYPE_INTEGER },
1050
1051         /* queryable fields */
1052         { SDB_HOST, "last_update",          -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
1053         { SDB_HOST, "AGE",                  -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
1054         { SDB_HOST, "interval",             -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
1055         { SDB_HOST, "Last_Update",          -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
1056         { SDB_HOST, "backend",              -1, SDB_AST_TYPE_VALUE, SDB_TYPE_ARRAY | SDB_TYPE_STRING },
1057
1058         /* attributes */
1059         { SDB_HOST, "attribute['foo']",     -1, SDB_AST_TYPE_VALUE, -1 },
1060
1061         /* arithmetic expressions */
1062         { SDB_HOST, "age + age",            -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1063         { SDB_HOST, "age - age",            -1, SDB_AST_SUB, SDB_TYPE_DATETIME },
1064         { SDB_HOST, "age * age",            -1, SDB_AST_MUL, SDB_TYPE_DATETIME },
1065         { SDB_HOST, "age / age",            -1, SDB_AST_DIV, SDB_TYPE_DATETIME },
1066         { SDB_HOST, "age \% age",           -1, SDB_AST_MOD, SDB_TYPE_DATETIME },
1067
1068         /* operator precedence */
1069         { SDB_HOST, "age + age * age",      -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1070         { SDB_HOST, "age * age + age",      -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1071         { SDB_HOST, "age + age - age",      -1, SDB_AST_SUB, SDB_TYPE_DATETIME },
1072         { SDB_HOST, "age - age + age",      -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1073         { SDB_HOST, "(age + age) * age",    -1, SDB_AST_MUL, SDB_TYPE_DATETIME },
1074         { SDB_HOST, "age + (age * age)",    -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1075
1076         /* boolean expressions */
1077         { SDB_METRIC, "timeseries + 1",               -1, -1, -1 },
1078         { SDB_METRIC, "timeseries - 1",               -1, -1, -1 },
1079         { SDB_METRIC, "timeseries * 1",               -1, -1, -1 },
1080         { SDB_METRIC, "timeseries / 1",               -1, -1, -1 },
1081         { SDB_METRIC, "timeseries \% 1",              -1, -1, -1 },
1082         { SDB_METRIC, "timeseries CONCAT 1",          -1, -1, -1 },
1083         { SDB_METRIC, "timeseries + timeseries",      -1, -1, -1 },
1084         { SDB_METRIC, "timeseries - timeseries",      -1, -1, -1 },
1085         { SDB_METRIC, "timeseries * timeseries",      -1, -1, -1 },
1086         { SDB_METRIC, "timeseries / timeseries",      -1, -1, -1 },
1087         { SDB_METRIC, "timeseries \% timeseries",     -1, -1, -1 },
1088         { SDB_METRIC, "timeseries CONCAT timeseries", -1, -1, -1 },
1089
1090         /* syntax errors */
1091         { SDB_HOST, "LIST",                 -1, -1, -1 },
1092         { SDB_HOST, "foo &^ bar",           -1, -1, -1 },
1093         { SDB_HOST, "invalid",              -1, -1, -1 },
1094 };
1095
1096 START_TEST(test_parse_arith)
1097 {
1098         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
1099         sdb_ast_node_t *node;
1100
1101         node = sdb_parser_parse_arith(parse_arith_data[_i].context,
1102                         parse_arith_data[_i].expr, parse_arith_data[_i].len, errbuf);
1103
1104         if (parse_arith_data[_i].expected < 0) {
1105                 fail_unless(node == NULL,
1106                                 "sdb_parser_parse_arith(%s, %s) = %p; expected: NULL",
1107                                 SDB_STORE_TYPE_TO_NAME(parse_arith_data[_i].context),
1108                                 parse_arith_data[_i].expr, node);
1109                 sdb_object_deref(SDB_OBJ(node));
1110                 sdb_strbuf_destroy(errbuf);
1111                 return;
1112         }
1113
1114         fail_unless(node != NULL, "sdb_parser_parse_arith(%s, %s) = NULL; "
1115                         "expected: <expr> (parse error: %s)",
1116                         SDB_STORE_TYPE_TO_NAME(parse_arith_data[_i].context),
1117                         parse_arith_data[_i].expr, sdb_strbuf_string(errbuf));
1118         if (node->type == SDB_AST_TYPE_OPERATOR)
1119                 fail_unless(SDB_AST_OP(node)->kind == parse_arith_data[_i].expected,
1120                                 "sdb_parser_parse_arith(%s, %s) returned expression of type %d; "
1121                                 "expected: %d", SDB_STORE_TYPE_TO_NAME(parse_arith_data[_i].context),
1122                                 parse_arith_data[_i].expr, SDB_AST_OP(node)->kind,
1123                                 parse_arith_data[_i].expected);
1124         else
1125                 fail_unless(node->type == parse_arith_data[_i].expected,
1126                                 "sdb_parser_parse_arith(%s, %s) returned expression of type %d; "
1127                                 "expected: %d", SDB_STORE_TYPE_TO_NAME(parse_arith_data[_i].context),
1128                                 parse_arith_data[_i].expr, node->type,
1129                                 parse_arith_data[_i].expected);
1130
1131         fail_unless(node->data_type == parse_arith_data[_i].data_type,
1132                         "sdb_parser_parse_arith(%s, %s) returned expression of data-type %s; "
1133                         "expected: %s", SDB_STORE_TYPE_TO_NAME(parse_arith_data[_i].context),
1134                         parse_arith_data[_i].expr, SDB_TYPE_TO_STRING(node->data_type),
1135                         SDB_TYPE_TO_STRING(parse_arith_data[_i].data_type));
1136
1137         sdb_object_deref(SDB_OBJ(node));
1138         sdb_strbuf_destroy(errbuf);
1139 }
1140 END_TEST
1141
1142 TEST_MAIN("parser::parser")
1143 {
1144         TCase *tc = tcase_create("core");
1145         TC_ADD_LOOP_TEST(tc, parse);
1146         TC_ADD_LOOP_TEST(tc, parse_conditional);
1147         TC_ADD_LOOP_TEST(tc, parse_arith);
1148         ADD_TCASE(tc);
1149 }
1150 TEST_MAIN_END
1151
1152 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1153