t/unit/frontend/parser_test.c

   1 /*
   2  * SysDB - t/unit/frontend/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 "frontend/connection.h"
  33 #include "frontend/parser.h"
  34 #include "core/store-private.h"
  35 #include "core/object.h"
  36 #include "testutils.h"
  37
  38 #include <check.h>
  39 #include <limits.h>
  40
  41 /*
  42  * tests
  43  */
  44
  45 struct {
  46         const char *query;
  47         int len;
  48         int expected;
  49         sdb_conn_state_t expected_cmd;
  50 } parse_data[] = {
  51         /* empty commands */
  52         { NULL,                  -1, -1, 0 },
  53         { "",                    -1,  0, 0 },
  54         { ";",                   -1,  0, 0 },
  55         { ";;",                  -1,  0, 0 },
  56
  57         /* FETCH commands */
  58         { "FETCH host 'host'",   -1,  1, SDB_CONNECTION_FETCH  },
  59         { "FETCH host 'host' FILTER "
  60           "age > 60s",           -1,  1, SDB_CONNECTION_FETCH  },
  61         { "FETCH service "
  62           "'host'.'service'",    -1,  1, SDB_CONNECTION_FETCH  },
  63         { "FETCH metric "
  64           "'host'.'metric'",     -1,  1, SDB_CONNECTION_FETCH  },
  65
  66         /* LIST commands */
  67         { "LIST hosts",          -1,  1, SDB_CONNECTION_LIST   },
  68         { "LIST hosts -- foo",   -1,  1, SDB_CONNECTION_LIST   },
  69         { "LIST hosts;",         -1,  1, SDB_CONNECTION_LIST   },
  70         { "LIST hosts; INVALID", 11,  1, SDB_CONNECTION_LIST   },
  71         { "LIST hosts FILTER "
  72           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  73         { "LIST services",       -1,  1, SDB_CONNECTION_LIST   },
  74         { "LIST services FILTER "
  75           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  76         { "LIST metrics",        -1,  1, SDB_CONNECTION_LIST   },
  77         { "LIST metrics FILTER "
  78           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  79
  80         /* LOOKUP commands */
  81         { "LOOKUP hosts",        -1,  1, SDB_CONNECTION_LOOKUP },
  82         { "LOOKUP hosts MATCHING "
  83           "name = 'host'",       -1,  1, SDB_CONNECTION_LOOKUP },
  84         { "LOOKUP hosts MATCHING NOT "
  85           "name = 'host'",       -1,  1, SDB_CONNECTION_LOOKUP },
  86         { "LOOKUP hosts MATCHING "
  87           "name =~ 'p' AND "
  88           "ANY service.name =~ 'p'", -1,   1, SDB_CONNECTION_LOOKUP },
  89         { "LOOKUP hosts MATCHING NOT "
  90           "name =~ 'p' AND "
  91           "ANY service.name =~ 'p'", -1,   1, SDB_CONNECTION_LOOKUP },
  92         { "LOOKUP hosts MATCHING "
  93           "name =~ 'p' AND "
  94           "ANY service.name =~ 'p' OR "
  95           "ANY service.name =~ 'r'", -1,   1, SDB_CONNECTION_LOOKUP },
  96         { "LOOKUP hosts MATCHING NOT "
  97           "name =~ 'p' AND "
  98           "ANY service.name =~ 'p' OR "
  99           "ANY service.name =~ 'r'", -1,   1, SDB_CONNECTION_LOOKUP },
 100         { "LOOKUP hosts MATCHING "
 101           "name =~ 'p' "
 102           "FILTER age > 1D",         -1,   1, SDB_CONNECTION_LOOKUP },
 103         { "LOOKUP hosts MATCHING "
 104           "name =~ 'p' "
 105           "FILTER age > 1D AND "
 106           "interval < 240s" ,        -1,   1, SDB_CONNECTION_LOOKUP },
 107         { "LOOKUP hosts MATCHING "
 108           "name =~ 'p' "
 109           "FILTER NOT age>1D",       -1,   1, SDB_CONNECTION_LOOKUP },
 110         { "LOOKUP hosts MATCHING "
 111           "name =~ 'p' "
 112           "FILTER age>"
 113           "interval",                -1,   1, SDB_CONNECTION_LOOKUP },
 114         { "LOOKUP hosts MATCHING "
 115           "host.name =~ 'p'",        -1,   1, SDB_CONNECTION_LOOKUP },
 116         { "LOOKUP services",         -1,   1, SDB_CONNECTION_LOOKUP },
 117         { "LOOKUP services MATCHING ANY "
 118           "attribute.name =~ 'a'",   -1,   1, SDB_CONNECTION_LOOKUP },
 119         { "LOOKUP services MATCHING "
 120           "host.name = 'p'",         -1,   1, SDB_CONNECTION_LOOKUP },
 121         { "LOOKUP services MATCHING "
 122           "service.name = 'p'",      -1,   1, SDB_CONNECTION_LOOKUP },
 123         { "LOOKUP metrics",          -1,   1, SDB_CONNECTION_LOOKUP },
 124         { "LOOKUP metrics MATCHING ANY "
 125           "attribute.name =~ 'a'",   -1,   1, SDB_CONNECTION_LOOKUP },
 126         { "LOOKUP metrics MATCHING "
 127           "host.name = 'p'",         -1,   1, SDB_CONNECTION_LOOKUP },
 128         { "LOOKUP metrics MATCHING "
 129           "metric.name = 'p'",       -1,   1, SDB_CONNECTION_LOOKUP },
 130
 131         /* TIMESERIES commands */
 132         { "TIMESERIES 'host'.'metric' "
 133           "START 2014-01-01 "
 134           "END 2014-12-31 "
 135           "23:59:59",            -1,  1, SDB_CONNECTION_TIMESERIES },
 136         { "TIMESERIES 'host'.'metric' "
 137           "START 2014-02-02 "
 138           "14:02",               -1,  1, SDB_CONNECTION_TIMESERIES },
 139         { "TIMESERIES 'host'.'metric' "
 140           "END 2014-02-02",      -1,  1, SDB_CONNECTION_TIMESERIES },
 141         { "TIMESERIES "
 142           "'host'.'metric'",     -1,  1, SDB_CONNECTION_TIMESERIES },
 143
 144         /* STORE commands */
 145         { "STORE host 'host'",   -1,  1, SDB_CONNECTION_STORE_HOST },
 146         { "STORE host 'host' "
 147           "LAST UPDATE "
 148           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_HOST },
 149         { "STORE host attribute "
 150           "'host'.'key' 123",    -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 151         { "STORE host attribute "
 152           "'host'.'key' 123 "
 153           "LAST UPDATE "
 154           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 155         { "STORE service "
 156           "'host'.'svc'",        -1,  1, SDB_CONNECTION_STORE_SERVICE },
 157         { "STORE service "
 158           "'host'.'svc' "
 159           "LAST UPDATE "
 160           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_SERVICE },
 161         { "STORE service attribute "
 162           "'host'.'svc'.'key' "
 163           "123",                 -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 164         { "STORE service attribute "
 165           "'host'.'svc'.'key' "
 166           "123 "
 167           "LAST UPDATE "
 168           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 169         { "STORE metric "
 170           "'host'.'metric'",     -1,  1, SDB_CONNECTION_STORE_METRIC },
 171         { "STORE metric "
 172           "'host'.'metric' "
 173           "LAST UPDATE "
 174           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_METRIC },
 175         { "STORE metric "
 176           "'host'.'metric' "
 177           "STORE 'typ' 'id' "
 178           "LAST UPDATE "
 179           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_METRIC },
 180         { "STORE metric attribute "
 181           "'host'.'metric'.'key' "
 182           "123",                 -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 183         { "STORE metric attribute "
 184           "'host'.'metric'.'key' "
 185           "123 "
 186           "LAST UPDATE "
 187           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 188
 189         /* string constants */
 190         { "LOOKUP hosts MATCHING "
 191           "name = ''''",         -1,  1, SDB_CONNECTION_LOOKUP },
 192         { "LOOKUP hosts MATCHING "
 193           "name = '''foo'",      -1,  1, SDB_CONNECTION_LOOKUP },
 194         { "LOOKUP hosts MATCHING "
 195           "name = 'f''oo'",      -1,  1, SDB_CONNECTION_LOOKUP },
 196         { "LOOKUP hosts MATCHING "
 197           "name = 'foo'''",      -1,  1, SDB_CONNECTION_LOOKUP },
 198         { "LOOKUP hosts MATCHING "
 199           "name = '''",          -1, -1, 0 },
 200
 201         /* numeric constants */
 202         { "LOOKUP hosts MATCHING "
 203           "attribute['foo'] = "
 204           "1234",                -1,  1, SDB_CONNECTION_LOOKUP },
 205         { "LOOKUP hosts MATCHING "
 206           "attribute['foo'] != "
 207           "+234",                -1,  1, SDB_CONNECTION_LOOKUP },
 208         { "LOOKUP hosts MATCHING "
 209           "attribute['foo'] < "
 210           "-234",                -1,  1, SDB_CONNECTION_LOOKUP },
 211         { "LOOKUP hosts MATCHING "
 212           "attribute['foo'] > "
 213           "12.4",                -1,  1, SDB_CONNECTION_LOOKUP },
 214         { "LOOKUP hosts MATCHING "
 215           "attribute['foo'] <= "
 216           "12. + .3",            -1,  1, SDB_CONNECTION_LOOKUP },
 217         { "LOOKUP hosts MATCHING "
 218           "attribute['foo'] <= "
 219           "'f' || 'oo'",         -1,  1, SDB_CONNECTION_LOOKUP },
 220         { "LOOKUP hosts MATCHING "
 221           "attribute['foo'] >= "
 222           ".4",                  -1,  1, SDB_CONNECTION_LOOKUP },
 223         { "LOOKUP hosts MATCHING "
 224           "attribute['foo'] = "
 225           "+12e3",               -1,  1, SDB_CONNECTION_LOOKUP },
 226         { "LOOKUP hosts MATCHING "
 227           "attribute['foo'] = "
 228           "+12e-3",              -1,  1, SDB_CONNECTION_LOOKUP },
 229         { "LOOKUP hosts MATCHING "
 230           "attribute['foo'] = "
 231           "-12e+3",              -1,  1, SDB_CONNECTION_LOOKUP },
 232
 233         /* date, time, interval constants */
 234         { "LOOKUP hosts MATCHING "
 235           "attribute['foo'] = "
 236           "1 Y 42D",             -1,  1, SDB_CONNECTION_LOOKUP },
 237         { "LOOKUP hosts MATCHING "
 238           "attribute['foo'] = "
 239           "1s 42D",              -1,  1, SDB_CONNECTION_LOOKUP },
 240         /*
 241          * TODO: Something like 1Y42D should work as well but it doesn't since
 242          * the scanner will tokenize it into {digit}{identifier} :-/
 243          *
 244         { "LOOKUP hosts MATCHING "
 245           "attribute['foo'] = "
 246           "1Y42D",               -1,  1, SDB_CONNECTION_LOOKUP },
 247          */
 248
 249         /* array constants */
 250         { "LOOKUP hosts MATCHING "
 251           "backend = ['foo']",   -1,  1, SDB_CONNECTION_LOOKUP },
 252         { "LOOKUP hosts MATCHING "
 253           "backend = ['a','b']", -1,  1, SDB_CONNECTION_LOOKUP },
 254
 255         /* array iteration */
 256         { "LOOKUP hosts MATCHING "
 257           "'foo' IN backend",   -1,   1, SDB_CONNECTION_LOOKUP },
 258         { "LOOKUP hosts MATCHING 'foo' "
 259           "NOT IN backend",   -1,   1, SDB_CONNECTION_LOOKUP },
 260         { "LOOKUP hosts MATCHING "
 261           "['foo','bar'] "
 262           "IN backend ",        -1,   1, SDB_CONNECTION_LOOKUP },
 263         /* attribute type is unknown */
 264         { "LOOKUP hosts MATCHING "
 265           "attribute['backend'] "
 266           "IN backend ",        -1,   1, SDB_CONNECTION_LOOKUP },
 267         /* type mismatch */
 268         { "LOOKUP hosts MATCHING "
 269           "1 IN backend ",      -1,  -1, 0 },
 270         { "LOOKUP hosts MATCHING "
 271           "1 NOT IN backend ",  -1,  -1, 0 },
 272         { "LOOKUP hosts MATCHING "
 273           "ANY backend < 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 274         { "LOOKUP hosts MATCHING "
 275           "ANY backend <= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 276         { "LOOKUP hosts MATCHING "
 277           "ANY backend = 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 278         { "LOOKUP hosts MATCHING "
 279           "ANY backend != 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 280         { "LOOKUP hosts MATCHING "
 281           "ANY backend >= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 282         { "LOOKUP hosts MATCHING "
 283           "ANY backend > 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 284         { "LOOKUP hosts MATCHING "
 285           "ANY backend =~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 286         { "LOOKUP hosts MATCHING "
 287           "ANY backend !~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 288         /* right operand is an array */
 289         { "LOOKUP hosts MATCHING "
 290           "ANY backend !~ backend",
 291                                 -1,  -1, 0 },
 292         { "LOOKUP hosts MATCHING "
 293           "ALL backend < 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 294         { "LOOKUP hosts MATCHING "
 295           "ALL backend <= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 296         { "LOOKUP hosts MATCHING "
 297           "ALL backend = 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 298         { "LOOKUP hosts MATCHING "
 299           "ALL backend != 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 300         { "LOOKUP hosts MATCHING "
 301           "ALL backend >= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 302         { "LOOKUP hosts MATCHING "
 303           "ALL backend > 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 304         { "LOOKUP hosts MATCHING "
 305           "ALL backend =~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 306         { "LOOKUP hosts MATCHING "
 307           "ALL backend !~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 308         /* attribute type is unknown */
 309         { "LOOKUP hosts MATCHING "
 310           "ANY backend = attribute['backend']",
 311                                 -1,   1, SDB_CONNECTION_LOOKUP },
 312         /* type mismatch */
 313         { "LOOKUP hosts MATCHING "
 314           "ANY backend = 1",    -1,  -1, 0 },
 315
 316         /* valid operand types */
 317         { "LOOKUP hosts MATCHING "
 318           "age * 1 > 0s",        -1,  1, SDB_CONNECTION_LOOKUP },
 319         { "LOOKUP hosts MATCHING "
 320           "age / 1 > 0s",        -1,  1, SDB_CONNECTION_LOOKUP },
 321         { "LOOKUP hosts MATCHING "
 322           "name > ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 323         { "LOOKUP hosts MATCHING "
 324           "name >= ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 325         { "LOOKUP hosts MATCHING "
 326           "name != ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 327         { "LOOKUP hosts MATCHING "
 328           "name = ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 329         { "LOOKUP hosts MATCHING "
 330           "name <= ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 331         { "LOOKUP hosts MATCHING "
 332           "name < ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 333
 334         /* NULL */
 335         { "LOOKUP hosts MATCHING "
 336           "attribute['foo'] "
 337           "IS NULL",             -1,  1, SDB_CONNECTION_LOOKUP },
 338         { "LOOKUP hosts MATCHING "
 339           "attribute['foo'] "
 340           "IS NOT NULL",         -1,  1, SDB_CONNECTION_LOOKUP },
 341         { "LOOKUP hosts MATCHING "
 342           "NOT attribute['foo'] "
 343           "IS NULL",             -1,  1, SDB_CONNECTION_LOOKUP },
 344         { "LOOKUP hosts MATCHING "
 345           "ANY service.name IS NULL", -1, -1, 0 },
 346
 347         /* invalid numeric constants */
 348         { "LOOKUP hosts MATCHING "
 349           "attribute['foo'] = "
 350           "+-12e+3",             -1, -1, 0 },
 351         { "LOOKUP hosts MATCHING "
 352           "attribute['foo'] = "
 353           "-12e-+3",             -1, -1, 0 },
 354         { "LOOKUP hosts MATCHING "
 355           "attribute['foo'] = "
 356           "e+3",                 -1, -1, 0 },
 357         { "LOOKUP hosts MATCHING "
 358           "attribute['foo'] = "
 359           "3e",                  -1, -1, 0 },
 360         /* following SQL standard, we don't support hex numbers */
 361         { "LOOKUP hosts MATCHING "
 362           "attribute['foo'] = "
 363           "0x12",                -1, -1, 0 },
 364
 365         /* invalid expressions */
 366         { "LOOKUP hosts MATCHING "
 367           "attribute['foo'] = "
 368           "1.23 + 'foo'",        -1, -1, 0 },
 369         { "LOOKUP hosts MATCHING "
 370           "attr['foo'] = 1.23",  -1, -1, 0 },
 371         { "LOOKUP hosts MATCHING "
 372           "attr['foo'] IS NULL", -1, -1, 0 },
 373
 374         /* type mismatches */
 375         { "LOOKUP hosts MATCHING "
 376           "age > 0",             -1, -1, 0 },
 377         { "LOOKUP hosts MATCHING "
 378           "NOT age > 0",         -1, -1, 0 },
 379         { "LOOKUP hosts MATCHING "
 380           "age >= 0",            -1, -1, 0 },
 381         { "LOOKUP hosts MATCHING "
 382           "age = 0",             -1, -1, 0 },
 383         { "LOOKUP hosts MATCHING "
 384           "age != 0",            -1, -1, 0 },
 385         { "LOOKUP hosts MATCHING "
 386           "age <= 0",            -1, -1, 0 },
 387         { "LOOKUP hosts MATCHING "
 388           "age < 0",             -1, -1, 0 },
 389         { "LOOKUP hosts MATCHING "
 390           "age + 1 > 0s",        -1, -1, 0 },
 391         { "LOOKUP hosts MATCHING "
 392           "age - 1 > 0s",        -1, -1, 0 },
 393         /* datetime <mul/div> integer is allowed */
 394         { "LOOKUP hosts MATCHING "
 395           "age || 1 > 0s",       -1, -1, 0 },
 396         { "LOOKUP hosts MATCHING "
 397           "name + 1 = ''",       -1, -1, 0 },
 398         { "LOOKUP hosts MATCHING "
 399           "name - 1 = ''",       -1, -1, 0 },
 400         { "LOOKUP hosts MATCHING "
 401           "name * 1 = ''",       -1, -1, 0 },
 402         { "LOOKUP hosts MATCHING "
 403           "name / 1 = ''",       -1, -1, 0 },
 404         { "LOOKUP hosts MATCHING "
 405           "name % 1 = ''",       -1, -1, 0 },
 406         { "LOOKUP hosts MATCHING "
 407           "(name % 1) + 1 = ''", -1, -1, 0 },
 408         { "LOOKUP hosts MATCHING "
 409           "1 + (name % 1) = ''", -1, -1, 0 },
 410         { "LOOKUP hosts MATCHING "
 411           "'' = 1 + (name % 1)", -1, -1, 0 },
 412         { "LOOKUP hosts MATCHING "
 413           "age > 0 AND "
 414           "age = 0s",            -1, -1, 0 },
 415         { "LOOKUP hosts MATCHING "
 416           "age = 0s AND "
 417           "age > 0",             -1, -1, 0 },
 418         { "LOOKUP services MATCHING "
 419           "host.name > 0",       -1, -1, 0 },
 420         { "LOOKUP services MATCHING "
 421           "backend > 'b'",       -1, -1, 0 },
 422         { "LOOKUP services MATCHING "
 423           "'b' > backend",       -1, -1, 0 },
 424         { "LOOKUP services MATCHING "
 425           "attribute['a'] > backend",
 426                                  -1, -1, 0 },
 427         { "LOOKUP services MATCHING "
 428           "backend > attribute['a']",
 429                                  -1, -1, 0 },
 430         { "LOOKUP services MATCHING "
 431           "host.name + 1 = ''",  -1, -1, 0 },
 432         { "LOOKUP hosts MATCHING "
 433           "'a' + 1 IN 'b'",      -1, -1, 0 },
 434         { "LOOKUP hosts MATCHING "
 435           "'a' IN 'b' - 1",      -1, -1, 0 },
 436         { "LOOKUP hosts MATCHING "
 437           "name + 1 IN 'b'",     -1, -1, 0 },
 438         { "LOOKUP hosts MATCHING "
 439           "'a' IN name - 1",     -1, -1, 0 },
 440         { "LOOKUP hosts MATCHING "
 441           "'b' IN 'abc'",        -1, -1, 0 },
 442         { "LOOKUP hosts MATCHING "
 443           "1 IN age",            -1, -1, 0 },
 444         { "LOOKUP hosts MATCHING "
 445           "name =~ 'a' + 1",     -1, -1, 0 },
 446         { "LOOKUP hosts MATCHING "
 447           "name =~ name + 1",    -1, -1, 0 },
 448         { "LOOKUP hosts MATCHING "
 449           "name + 1 =~ 'a'",     -1, -1, 0 },
 450         { "LOOKUP hosts MATCHING "
 451           "name =~ 1",           -1, -1, 0 },
 452         { "LOOKUP hosts MATCHING "
 453           "name + 1 IS NULL",    -1, -1, 0 },
 454         { "LOOKUP hosts FILTER "
 455           "name + 1 IS NULL",    -1, -1, 0 },
 456         { "LOOKUP hosts MATCHING "
 457           "ANY 'patt' =~ 'p'",  -1,  -1, 0 },
 458
 459         /* comments */
 460         { "/* some comment */",  -1,  0, 0 },
 461         { "-- another comment",  -1,  0, 0 },
 462
 463         /* syntax errors */
 464         { "INVALID",             -1, -1, 0 },
 465         { "FETCH host",          -1, -1, 0 },
 466         { "FETCH 'host'",        -1, -1, 0 },
 467         { "LIST hosts; INVALID", -1, -1, 0 },
 468         { "/* some incomplete",  -1, -1, 0 },
 469
 470         /* invalid LIST commands */
 471         { "LIST",                -1, -1, 0 },
 472         { "LIST foo",            -1, -1, 0 },
 473         { "LIST hosts MATCHING "
 474           "name = 'host'",       -1, -1, 0 },
 475         { "LIST foo FILTER "
 476           "age > 60s",           -1, -1, 0 },
 477
 478         /* invalid FETCH commands */
 479         { "FETCH host 'host' MATCHING "
 480           "name = 'host'",       -1, -1, 0 },
 481         { "FETCH service 'host'",-1, -1, 0 },
 482         { "FETCH metric 'host'", -1, -1, 0 },
 483         { "FETCH host "
 484           "'host'.'localhost'",  -1, -1, 0 },
 485         { "FETCH foo 'host'",    -1, -1, 0 },
 486         { "FETCH foo 'host' FILTER "
 487           "age > 60s",           -1, -1, 0 },
 488
 489         /* invalid LOOKUP commands */
 490         { "LOOKUP foo",          -1, -1, 0 },
 491         { "LOOKUP foo MATCHING "
 492           "name = 'host'",       -1, -1, 0 },
 493         { "LOOKUP foo FILTER "
 494           "age > 60s",           -1, -1, 0 },
 495         { "LOOKUP foo MATCHING "
 496           "name = 'host' FILTER "
 497           "age > 60s",           -1, -1, 0 },
 498         { "LOOKUP hosts MATCHING "
 499           "attribute['foo'] <= "
 500           "f || 'oo'",           -1, -1, 0 },
 501         { "LOOKUP hosts MATCHING "
 502           "attribute['foo'] <= "
 503           "'f' || oo",           -1, -1, 0 },
 504         { "LOOKUP hosts MATCHING "
 505           "ANY host.name = 'host'",   -1, -1, 0 },
 506         { "LOOKUP hosts MATCHING "
 507           "ANY service.name > 1",     -1, -1, 0 },
 508         { "LOOKUP hosts MATCHING "
 509           "service.name = 's'",       -1, -1, 0 },
 510         { "LOOKUP services MATCHING "
 511           "ANY host.name = 'host'",   -1, -1, 0 },
 512         { "LOOKUP services MATCHING "
 513           "ANY service.name = 'svc'", -1, -1, 0 },
 514         { "LOOKUP services MATCHING "
 515           "ANY metric.name = 'm'",    -1, -1, 0 },
 516         { "LOOKUP services MATCHING "
 517           "metric.name = 'm'",        -1, -1, 0 },
 518         { "LOOKUP metrics MATCHING "
 519           "ANY host.name = 'host'",   -1, -1, 0 },
 520         { "LOOKUP metrics MATCHING "
 521           "ANY service.name = 'svc'", -1, -1, 0 },
 522         { "LOOKUP metrics MATCHING "
 523           "ANY metric.name = 'm'",    -1, -1, 0 },
 524         { "LOOKUP metrics MATCHING "
 525           "service.name = 'm'",       -1, -1, 0 },
 526
 527         /* invalid STORE commands */
 528         { "STORE host "
 529           "'obj'.'host'",        -1, -1, 0 },
 530         { "STORE host attribute "
 531           ".'key' 123",          -1, -1, 0 },
 532         { "STORE host attribute "
 533           "'o'.'h'.'key' 123",   -1, -1, 0 },
 534         { "STORE service 'svc'", -1, -1, 0 },
 535         { "STORE service "
 536           "'host'.'svc' "
 537           "STORE 'typ' 'id' "
 538           "LAST UPDATE "
 539           "2015-02-01",          -1, -1, 0 },
 540         { "STORE service attribute "
 541           "'svc'.'key' 123",     -1, -1, 0 },
 542         { "STORE metric 'm'",    -1, -1, 0 },
 543         { "STORE metric "
 544           "'host'.'metric' "
 545           "STORE 'typ'.'id' "
 546           "LAST UPDATE "
 547           "2015-02-01",          -1, -1, 0 },
 548         { "STORE metric attribute "
 549           "'metric'.'key' 123",  -1, -1, 0 },
 550 };
 551
 552 START_TEST(test_parse)
 553 {
 554         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 555         sdb_llist_t *check;
 556         sdb_object_t *obj;
 557         _Bool ok;
 558
 559         check = sdb_fe_parse(parse_data[_i].query,
 560                         parse_data[_i].len, errbuf);
 561         if (parse_data[_i].expected < 0)
 562                 ok = check == 0;
 563         else
 564                 ok = sdb_llist_len(check) == (size_t)parse_data[_i].expected;
 565
 566         fail_unless(ok, "sdb_fe_parse(%s) = %p (len: %zu); expected: %d "
 567                         "(parser error: %s)", parse_data[_i].query, check,
 568                         sdb_llist_len(check), parse_data[_i].expected,
 569                         sdb_strbuf_string(errbuf));
 570
 571         if (! check) {
 572                 sdb_strbuf_destroy(errbuf);
 573                 return;
 574         }
 575
 576         if ((! parse_data[_i].expected_cmd)
 577                         || (parse_data[_i].expected <= 0)) {
 578                 sdb_llist_destroy(check);
 579                 sdb_strbuf_destroy(errbuf);
 580                 return;
 581         }
 582
 583         obj = sdb_llist_get(check, 0);
 584         fail_unless(SDB_CONN_NODE(obj)->cmd == parse_data[_i].expected_cmd,
 585                         "sdb_fe_parse(%s)->cmd = %i; expected: %d",
 586                         parse_data[_i].query, SDB_CONN_NODE(obj)->cmd,
 587                         parse_data[_i].expected_cmd);
 588
 589         sdb_object_deref(obj);
 590         sdb_llist_destroy(check);
 591         sdb_strbuf_destroy(errbuf);
 592 }
 593 END_TEST
 594
 595 struct {
 596         const char *expr;
 597         int len;
 598         int expected;
 599 } parse_matcher_data[] = {
 600         /* empty expressions */
 601         { NULL,                           -1, -1 },
 602         { "",                             -1, -1 },
 603
 604         /* match hosts by name */
 605         { "name < 'localhost'",           -1,  MATCHER_LT },
 606         { "name <= 'localhost'",          -1,  MATCHER_LE },
 607         { "name = 'localhost'",           -1,  MATCHER_EQ },
 608         { "name != 'localhost'",          -1,  MATCHER_NE },
 609         { "name >= 'localhost'",          -1,  MATCHER_GE },
 610         { "name > 'localhost'",           -1,  MATCHER_GT },
 611         { "name =~ 'host'",               -1,  MATCHER_REGEX },
 612         { "name !~ 'host'",               -1,  MATCHER_NREGEX },
 613         { "name = 'localhost' -- foo",    -1,  MATCHER_EQ },
 614         { "name = 'host' <garbage>",      13,  MATCHER_EQ },
 615         { "name &^ 'localhost'",          -1,  -1 },
 616         /* match by backend */
 617         { "ANY backend < 'be'",           -1,  MATCHER_ANY },
 618         { "ANY backend <= 'be'",          -1,  MATCHER_ANY },
 619         { "ANY backend = 'be'",           -1,  MATCHER_ANY },
 620         { "ANY backend != 'be'",          -1,  MATCHER_ANY },
 621         { "ANY backend >= 'be'",          -1,  MATCHER_ANY },
 622         { "ANY backend > 'be'",           -1,  MATCHER_ANY },
 623         { "ALL backend < 'be'",           -1,  MATCHER_ALL },
 624         { "ALL backend <= 'be'",          -1,  MATCHER_ALL },
 625         { "ALL backend = 'be'",           -1,  MATCHER_ALL },
 626         { "ALL backend != 'be'",          -1,  MATCHER_ALL },
 627         { "ALL backend >= 'be'",          -1,  MATCHER_ALL },
 628         { "ALL backend > 'be'",           -1,  MATCHER_ALL },
 629         { "ANY backend &^ 'be'",          -1,  -1 },
 630         /* match hosts by service */
 631         { "ANY service.name < 'name'",         -1,  MATCHER_ANY },
 632         { "ANY service.name <= 'name'",        -1,  MATCHER_ANY },
 633         { "ANY service.name = 'name'",         -1,  MATCHER_ANY },
 634         { "ANY service.name != 'name'",        -1,  MATCHER_ANY },
 635         { "ANY service.name >= 'name'",        -1,  MATCHER_ANY },
 636         { "ANY service.name > 'name'",         -1,  MATCHER_ANY },
 637         { "ANY service.name =~ 'pattern'",     -1,  MATCHER_ANY },
 638         { "ANY service.name !~ 'pattern'",     -1,  MATCHER_ANY },
 639         { "ANY service.name &^ 'name'",        -1,  -1 },
 640         { "ALL service.name < 'name'",         -1,  MATCHER_ALL },
 641         { "ALL service.name <= 'name'",        -1,  MATCHER_ALL },
 642         { "ALL service.name = 'name'",         -1,  MATCHER_ALL },
 643         { "ALL service.name != 'name'",        -1,  MATCHER_ALL },
 644         { "ALL service.name >= 'name'",        -1,  MATCHER_ALL },
 645         { "ALL service.name > 'name'",         -1,  MATCHER_ALL },
 646         { "ALL service.name =~ 'pattern'",     -1,  MATCHER_ALL },
 647         { "ALL service.name !~ 'pattern'",     -1,  MATCHER_ALL },
 648         { "ALL service.name &^ 'name'",        -1,  -1 },
 649         { "ANY service < 'name'",              -1,  -1 },
 650         /* match hosts by metric */
 651         { "ANY metric.name < 'name'",          -1,  MATCHER_ANY },
 652         { "ANY metric.name <= 'name'",         -1,  MATCHER_ANY },
 653         { "ANY metric.name = 'name'",          -1,  MATCHER_ANY },
 654         { "ANY metric.name != 'name'",         -1,  MATCHER_ANY },
 655         { "ANY metric.name >= 'name'",         -1,  MATCHER_ANY },
 656         { "ANY metric.name > 'name'",          -1,  MATCHER_ANY },
 657         { "ANY metric.name =~ 'pattern'",      -1,  MATCHER_ANY },
 658         { "ANY metric.name !~ 'pattern'",      -1,  MATCHER_ANY },
 659         { "ANY metric.name &^ 'pattern'",      -1,  -1 },
 660         { "ALL metric.name < 'name'",          -1,  MATCHER_ALL },
 661         { "ALL metric.name <= 'name'",         -1,  MATCHER_ALL },
 662         { "ALL metric.name = 'name'",          -1,  MATCHER_ALL },
 663         { "ALL metric.name != 'name'",         -1,  MATCHER_ALL },
 664         { "ALL metric.name >= 'name'",         -1,  MATCHER_ALL },
 665         { "ALL metric.name > 'name'",          -1,  MATCHER_ALL },
 666         { "ALL metric.name =~ 'pattern'",      -1,  MATCHER_ALL },
 667         { "ALL metric.name !~ 'pattern'",      -1,  MATCHER_ALL },
 668         { "ALL metric.name &^ 'pattern'",      -1,  -1 },
 669         { "ANY metric <= 'name'",              -1,  -1 },
 670         /* match hosts by attribute */
 671         { "ANY attribute.name < 'name'",       -1,  MATCHER_ANY },
 672         { "ANY attribute.name <= 'name'",      -1,  MATCHER_ANY },
 673         { "ANY attribute.name = 'name'",       -1,  MATCHER_ANY },
 674         { "ANY attribute.name != 'name'",      -1,  MATCHER_ANY },
 675         { "ANY attribute.name >= 'name'",      -1,  MATCHER_ANY },
 676         { "ANY attribute.name > 'name'",       -1,  MATCHER_ANY },
 677         { "ANY attribute.name =~ 'pattern'",   -1,  MATCHER_ANY },
 678         { "ANY attribute.name !~ 'pattern'",   -1,  MATCHER_ANY },
 679         { "ANY attribute.name &^ 'pattern'",   -1,  -1 },
 680         { "ALL attribute.name < 'name'",       -1,  MATCHER_ALL },
 681         { "ALL attribute.name <= 'name'",      -1,  MATCHER_ALL },
 682         { "ALL attribute.name = 'name'",       -1,  MATCHER_ALL },
 683         { "ALL attribute.name != 'name'",      -1,  MATCHER_ALL },
 684         { "ALL attribute.name >= 'name'",      -1,  MATCHER_ALL },
 685         { "ALL attribute.name > 'name'",       -1,  MATCHER_ALL },
 686         { "ALL attribute.name =~ 'pattern'",   -1,  MATCHER_ALL },
 687         { "ALL attribute.name !~ 'pattern'",   -1,  MATCHER_ALL },
 688         { "ALL attribute.name &^ 'pattern'",   -1,  -1 },
 689         { "ANY attribute !~ 'pattern'",        -1,  -1 },
 690         /* composite expressions */
 691         { "name =~ 'pattern' AND "
 692           "ANY service.name =~ 'pattern'",     -1,  MATCHER_AND },
 693         { "name =~ 'pattern' OR "
 694           "ANY service.name =~ 'pattern'",     -1,  MATCHER_OR },
 695         { "NOT name = 'host'",                 -1,  MATCHER_NOT },
 696         /* numeric expressions */
 697         { "attribute['foo'] < 123",         -1,  MATCHER_LT },
 698         { "attribute['foo'] <= 123",        -1,  MATCHER_LE },
 699         { "attribute['foo'] = 123",         -1,  MATCHER_EQ },
 700         { "attribute['foo'] >= 123",        -1,  MATCHER_GE },
 701         { "attribute['foo'] > 123",         -1,  MATCHER_GT },
 702         /* datetime expressions */
 703         { "attribute['foo'] = "
 704           "2014-08-16",                     -1,  MATCHER_EQ },
 705         { "attribute['foo'] = "
 706           "17:23",                          -1,  MATCHER_EQ },
 707         { "attribute['foo'] = "
 708           "17:23:53",                       -1,  MATCHER_EQ },
 709         { "attribute['foo'] = "
 710           "17:23:53.123",                   -1,  MATCHER_EQ },
 711         { "attribute['foo'] = "
 712           "17:23:53.123456789",             -1,  MATCHER_EQ },
 713         { "attribute['foo'] = "
 714           "2014-08-16 17:23",               -1,  MATCHER_EQ },
 715         { "attribute['foo'] = "
 716           "2014-08-16 17:23:53",            -1,  MATCHER_EQ },
 717         /* NULL; while this is an implementation detail,
 718          * IS NULL currently maps to an equality matcher */
 719         { "attribute['foo'] IS NULL",       -1,  MATCHER_ISNULL },
 720         { "attribute['foo'] IS NOT NULL",   -1,  MATCHER_ISNNULL },
 721         /* array expressions */
 722         { "backend < ['a']",                -1,  MATCHER_LT },
 723         { "backend <= ['a']",               -1,  MATCHER_LE },
 724         { "backend = ['a']",                -1,  MATCHER_EQ },
 725         { "backend != ['a']",               -1,  MATCHER_NE },
 726         { "backend >= ['a']",               -1,  MATCHER_GE },
 727         { "backend > ['a']",                -1,  MATCHER_GT },
 728         { "backend &^ ['a']",               -1,  -1 },
 729
 730         /* object field matchers */
 731         { "name < 'a'",                     -1,  MATCHER_LT },
 732         { "name <= 'a'",                    -1,  MATCHER_LE },
 733         { "name = 'a'",                     -1,  MATCHER_EQ },
 734         { "name != 'a'",                    -1,  MATCHER_NE },
 735         { "name >= 'a'",                    -1,  MATCHER_GE },
 736         { "name > 'a'",                     -1,  MATCHER_GT },
 737         { "last_update < 2014-10-01",       -1,  MATCHER_LT },
 738         { "last_update <= 2014-10-01",      -1,  MATCHER_LE },
 739         { "last_update = 2014-10-01",       -1,  MATCHER_EQ },
 740         { "last_update != 2014-10-01",      -1,  MATCHER_NE },
 741         { "last_update >= 2014-10-01",      -1,  MATCHER_GE },
 742         { "last_update > 2014-10-01",       -1,  MATCHER_GT },
 743         { "Last_Update >= 24D",             -1,  MATCHER_GE },
 744         { "age < 20s",                      -1,  MATCHER_LT },
 745         { "age <= 20s",                     -1,  MATCHER_LE },
 746         { "age = 20s",                      -1,  MATCHER_EQ },
 747         { "age != 20s",                     -1,  MATCHER_NE },
 748         { "age >= 20s",                     -1,  MATCHER_GE },
 749         { "age > 20s",                      -1,  MATCHER_GT },
 750         { "AGE <= 1m",                      -1,  MATCHER_LE },
 751         { "age > 1M",                       -1,  MATCHER_GT },
 752         { "age != 20Y",                     -1,  MATCHER_NE },
 753         { "age <= 2 * interval",            -1,  MATCHER_LE },
 754         { "interval < 20s",                 -1,  MATCHER_LT },
 755         { "interval <= 20s",                -1,  MATCHER_LE },
 756         { "interval = 20s",                 -1,  MATCHER_EQ },
 757         { "interval != 20s",                -1,  MATCHER_NE },
 758         { "interval >= 20s",                -1,  MATCHER_GE },
 759         { "interval > 20s",                 -1,  MATCHER_GT },
 760         { "'be' IN backend",                -1,  MATCHER_IN },
 761         { "'be' NOT IN backend",            -1,  MATCHER_NIN },
 762         { "['a','b'] IN backend",           -1,  MATCHER_IN },
 763         { "['a','b'] NOT IN backend",       -1,  MATCHER_NIN },
 764
 765         /* check operator precedence */
 766         { "name = 'name' OR "
 767           "ANY service.name = 'name' AND "
 768           "ANY attribute.name = 'name' OR "
 769           "attribute['foo'] = 'bar'",       -1,  MATCHER_OR },
 770         { "name = 'name' AND "
 771           "ANY service.name = 'name' AND "
 772           "ANY attribute.name = 'name' OR "
 773           "attribute['foo'] = 'bar'",       -1,  MATCHER_OR },
 774         { "name = 'name' AND "
 775           "ANY service.name = 'name' OR "
 776           "ANY attribute.name = 'name' AND "
 777           "attribute['foo'] = 'bar'",       -1,  MATCHER_OR },
 778         { "(name = 'name' OR "
 779           "ANY service.name = 'name') AND "
 780           "(ANY attribute.name = 'name' OR "
 781           "attribute['foo'] = 'bar')",      -1,  MATCHER_AND },
 782         { "NOT name = 'name' OR "
 783           "ANY service.name = 'name'",      -1,  MATCHER_OR },
 784         { "NOT name = 'name' OR "
 785           "NOT ANY service.name = 'name'",  -1,  MATCHER_OR },
 786         { "NOT (name = 'name' OR "
 787           "NOT ANY service.name = 'name')", -1,  MATCHER_NOT },
 788
 789         /* syntax errors */
 790         { "LIST",                           -1, -1 },
 791         { "foo &^ bar",                     -1, -1 },
 792         { "invalid",                        -1, -1 },
 793 };
 794
 795 START_TEST(test_parse_matcher)
 796 {
 797         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 798         sdb_store_matcher_t *m;
 799
 800         m = sdb_fe_parse_matcher(parse_matcher_data[_i].expr,
 801                         parse_matcher_data[_i].len, errbuf);
 802
 803         if (parse_matcher_data[_i].expected < 0) {
 804                 fail_unless(m == NULL,
 805                                 "sdb_fe_parse_matcher(%s) = %p; expected: NULL",
 806                                 parse_matcher_data[_i].expr, m);
 807                 sdb_object_deref(SDB_OBJ(m));
 808                 sdb_strbuf_destroy(errbuf);
 809                 return;
 810         }
 811
 812         fail_unless(m != NULL, "sdb_fe_parse_matcher(%s) = NULL; "
 813                         "expected: <matcher> (parser error: %s)",
 814                         parse_matcher_data[_i].expr, sdb_strbuf_string(errbuf));
 815         fail_unless(M(m)->type == parse_matcher_data[_i].expected,
 816                         "sdb_fe_parse_matcher(%s) returned matcher of type %d; "
 817                         "expected: %d", parse_matcher_data[_i].expr, M(m)->type,
 818                         parse_matcher_data[_i].expected);
 819
 820         sdb_object_deref(SDB_OBJ(m));
 821         sdb_strbuf_destroy(errbuf);
 822 }
 823 END_TEST
 824
 825 struct {
 826         const char *expr;
 827         int len;
 828         int expected;
 829 } parse_expr_data[] = {
 830         /* empty expressions */
 831         { NULL,                   -1, INT_MAX },
 832         { "",                     -1, INT_MAX },
 833
 834         /* constant expressions */
 835         { "'localhost'",          -1, 0 },
 836         { "123",                  -1, 0 },
 837         { "2014-08-16",           -1, 0 },
 838         { "17:23",                -1, 0 },
 839         { "17:23:53",             -1, 0 },
 840         { "17:23:53.123",         -1, 0 },
 841         { "17:23:53.123456789",   -1, 0 },
 842         { "2014-08-16 17:23",     -1, 0 },
 843         { "2014-08-16 17:23:53",  -1, 0 },
 844         { "10s",                  -1, 0 },
 845         { "60m",                  -1, 0 },
 846         { "10Y 24D 1h",           -1, 0 },
 847
 848         { "123 + 456",            -1, 0 },
 849         { "'foo' || 'bar'",       -1, 0 },
 850         { "456 - 123",            -1, 0 },
 851         { "1.2 * 3.4",            -1, 0 },
 852         { "1.2 / 3.4",            -1, 0 },
 853         { "5 % 2",                -1, 0 },
 854
 855         /* queryable fields */
 856         { "last_update",          -1, FIELD_VALUE },
 857         { "AGE",                  -1, FIELD_VALUE },
 858         { "interval",             -1, FIELD_VALUE },
 859         { "Last_Update",          -1, FIELD_VALUE },
 860         { "backend",              -1, FIELD_VALUE },
 861
 862         /* attributes */
 863         { "attribute['foo']",     -1, ATTR_VALUE },
 864
 865         /* arithmetic expressions */
 866         { "age + age",            -1, SDB_DATA_ADD },
 867         { "age - age",            -1, SDB_DATA_SUB },
 868         { "age * age",            -1, SDB_DATA_MUL },
 869         { "age / age",            -1, SDB_DATA_DIV },
 870         { "age % age",            -1, SDB_DATA_MOD },
 871         { "age || age",           -1, SDB_DATA_CONCAT },
 872
 873         /* operator precedence */
 874         { "age + age * age",      -1, SDB_DATA_ADD },
 875         { "age * age + age",      -1, SDB_DATA_ADD },
 876         { "age + age - age",      -1, SDB_DATA_SUB },
 877         { "age - age + age",      -1, SDB_DATA_ADD },
 878         { "(age + age) * age",    -1, SDB_DATA_MUL },
 879         { "age + (age * age)",    -1, SDB_DATA_ADD },
 880
 881         /* syntax errors */
 882         { "LIST",                 -1, INT_MAX },
 883         { "foo &^ bar",           -1, INT_MAX },
 884         { "invalid",              -1, INT_MAX },
 885 };
 886
 887 START_TEST(test_parse_expr)
 888 {
 889         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 890         sdb_store_expr_t *e;
 891
 892         e = sdb_fe_parse_expr(parse_expr_data[_i].expr,
 893                         parse_expr_data[_i].len, errbuf);
 894
 895         if (parse_expr_data[_i].expected == INT_MAX) {
 896                 fail_unless(e == NULL,
 897                                 "sdb_fe_parse_expr(%s) = %p; expected: NULL",
 898                                 parse_expr_data[_i].expr, e);
 899                 sdb_object_deref(SDB_OBJ(e));
 900                 sdb_strbuf_destroy(errbuf);
 901                 return;
 902         }
 903
 904         fail_unless(e != NULL, "sdb_fe_parse_expr(%s) = NULL; "
 905                         "expected: <expr> (parser error: %s)",
 906                         parse_expr_data[_i].expr, sdb_strbuf_string(errbuf));
 907         fail_unless(e->type == parse_expr_data[_i].expected,
 908                         "sdb_fe_parse_expr(%s) returned expression of type %d; "
 909                         "expected: %d", parse_expr_data[_i].expr, e->type,
 910                         parse_expr_data[_i].expected);
 911
 912         sdb_object_deref(SDB_OBJ(e));
 913         sdb_strbuf_destroy(errbuf);
 914 }
 915 END_TEST
 916
 917 TEST_MAIN("frontend::parser")
 918 {
 919         TCase *tc = tcase_create("core");
 920         TC_ADD_LOOP_TEST(tc, parse);
 921         TC_ADD_LOOP_TEST(tc, parse_matcher);
 922         TC_ADD_LOOP_TEST(tc, parse_expr);
 923         ADD_TCASE(tc);
 924 }
 925 TEST_MAIN_END
 926
 927 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 928