t/unit/core/data_test.c

   1 /*
   2  * SysDB - t/unit/core/data_test.c
   3  * Copyright (C) 2014 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 #include "core/data.h"
  29 #include "libsysdb_test.h"
  30
  31 #include <assert.h>
  32 #include <check.h>
  33
  34 static regex_t empty_re;
  35
  36 START_TEST(test_data)
  37 {
  38         sdb_data_t d1, d2;
  39         int check;
  40
  41         int64_t int_values[] = { 47, 11, 23 };
  42         char *string_values[] = { "foo", "bar", "qux" "baz" };
  43         size_t i;
  44
  45         d2.type = SDB_TYPE_INTEGER;
  46         d2.data.integer = 4711;
  47         memset(&d1, 0, sizeof(d1));
  48         check = sdb_data_copy(&d1, &d2);
  49         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
  50         fail_unless(d1.type == d2.type,
  51                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
  52                         d1.type, d2.type);
  53         fail_unless(d1.data.integer == d2.data.integer,
  54                         "sdb_data_copy() didn't copy integer data: got: %d; expected: %d",
  55                         d1.data.integer, d2.data.integer);
  56
  57         d2.type = SDB_TYPE_DECIMAL;
  58         d2.data.decimal = 47.11;
  59         check = sdb_data_copy(&d1, &d2);
  60         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
  61         fail_unless(d1.type == d2.type,
  62                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
  63                         d1.type, d2.type);
  64         fail_unless(d1.data.decimal == d2.data.decimal,
  65                         "sdb_data_copy() didn't copy decimal data: got: %f; expected: %f",
  66                         d1.data.decimal, d2.data.decimal);
  67
  68         d2.type = SDB_TYPE_STRING;
  69         d2.data.string = "some string";
  70         check = sdb_data_copy(&d1, &d2);
  71         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
  72         fail_unless(d1.type == d2.type,
  73                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
  74                         d1.type, d2.type);
  75         fail_unless(!strcmp(d1.data.string, d2.data.string),
  76                         "sdb_data_copy() didn't copy string data: got: %s; expected: %s",
  77                         d1.data.string, d2.data.string);
  78
  79         sdb_data_free_datum(&d1);
  80         fail_unless(d1.data.string == NULL,
  81                         "sdb_data_free_datum() didn't free string data");
  82
  83         d1.type = 0;
  84         d2.type = SDB_TYPE_STRING;
  85         d2.data.string = NULL;
  86         check = sdb_data_copy(&d1, &d2);
  87         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
  88         fail_unless(d1.type == d2.type,
  89                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
  90                         d1.type, d2.type);
  91         fail_unless(d1.data.string == d2.data.string,
  92                         "sdb_data_copy() didn't copy string data: got: %s; expected: %s",
  93                         d1.data.string, d2.data.string);
  94
  95         sdb_data_free_datum(&d1);
  96         fail_unless(d1.data.string == NULL,
  97                         "sdb_data_free_datum() didn't free string data");
  98
  99         d2.type = SDB_TYPE_DATETIME;
 100         d2.data.datetime = 4711;
 101         check = sdb_data_copy(&d1, &d2);
 102         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 103         fail_unless(d1.type == d2.type,
 104                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 105                         d1.type, d2.type);
 106         fail_unless(d1.data.datetime == d2.data.datetime,
 107                         "sdb_data_copy() didn't copy datetime data: got: %d; expected: %d",
 108                         d1.data.datetime, d2.data.datetime);
 109
 110         d2.type = SDB_TYPE_BINARY;
 111         d2.data.binary.datum = (unsigned char *)"some string";
 112         d2.data.binary.length = strlen((const char *)d2.data.binary.datum);
 113         check = sdb_data_copy(&d1, &d2);
 114         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 115         fail_unless(d1.type == d2.type,
 116                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 117                         d1.type, d2.type);
 118         fail_unless(d1.data.binary.length == d2.data.binary.length,
 119                         "sdb_data_copy() didn't copy length; got: %d; expected: 5d",
 120                         d1.data.binary.length, d2.data.binary.length);
 121         fail_unless(!memcmp(d1.data.binary.datum, d2.data.binary.datum,
 122                                 d2.data.binary.length),
 123                         "sdb_data_copy() didn't copy binary data: got: %s; expected: %s",
 124                         d1.data.binary.datum, d2.data.binary.datum);
 125
 126         sdb_data_free_datum(&d1);
 127         fail_unless(d1.data.binary.length == 0,
 128                         "sdb_data_free_datum() didn't reset binary datum length");
 129         fail_unless(d1.data.binary.datum == NULL,
 130                         "sdb_data_free_datum() didn't free binary datum");
 131
 132         d1.type = 0;
 133         d2.type = SDB_TYPE_BINARY;
 134         d2.data.binary.datum = NULL;
 135         d2.data.binary.length = 0;
 136         check = sdb_data_copy(&d1, &d2);
 137         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 138         fail_unless(d1.type == d2.type,
 139                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 140                         d1.type, d2.type);
 141         fail_unless(d1.data.binary.length == d2.data.binary.length,
 142                         "sdb_data_copy() didn't copy length; got: %d; expected: 5d",
 143                         d1.data.binary.length, d2.data.binary.length);
 144         fail_unless(d1.data.binary.datum == d2.data.binary.datum,
 145                         "sdb_data_copy() didn't copy binary data: got: %s; expected: %s",
 146                         d1.data.binary.datum, d2.data.binary.datum);
 147
 148         sdb_data_free_datum(&d1);
 149         fail_unless(d1.data.binary.length == 0,
 150                         "sdb_data_free_datum() didn't reset binary datum length");
 151         fail_unless(d1.data.binary.datum == NULL,
 152                         "sdb_data_free_datum() didn't free binary datum");
 153
 154         check = sdb_data_parse(".", SDB_TYPE_REGEX, &d2);
 155         fail_unless(check == 0,
 156                         "INTERNAL ERROR: Failed to parse regex '.'");
 157         assert(d2.type == SDB_TYPE_REGEX);
 158         check = sdb_data_copy(&d1, &d2);
 159         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 160         fail_unless(d1.type == d2.type,
 161                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 162                         d1.type, d2.type);
 163         fail_unless(d1.data.re.raw != d2.data.re.raw,
 164                         "sdb_data_copy() copy string pointer");
 165         fail_unless(!strcmp(d1.data.re.raw, d2.data.re.raw),
 166                         "sdb_data_copy() didn't copy raw regex: got: %s; expected: %s",
 167                         d1.data.re.raw, d2.data.re.raw);
 168         sdb_data_free_datum(&d2);
 169
 170         sdb_data_free_datum(&d1);
 171         fail_unless(d1.data.re.raw == NULL,
 172                         "sdb_data_free_datum() didn't reset raw regex");
 173
 174         d2.type = SDB_TYPE_REGEX;
 175         d2.data.re.raw = NULL;
 176         check = sdb_data_copy(&d1, &d2);
 177         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 178         fail_unless(d1.type == d2.type,
 179                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 180                         d1.type, d2.type);
 181
 182         d2.type = SDB_TYPE_ARRAY | SDB_TYPE_INTEGER;
 183         d2.data.array.length = SDB_STATIC_ARRAY_LEN(int_values);
 184         d2.data.array.values = int_values;
 185         check = sdb_data_copy(&d1, &d2);
 186         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 187         fail_unless(d1.type == d2.type,
 188                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 189                         d1.type, d2.type);
 190         fail_unless(d1.data.array.values != d2.data.array.values,
 191                         "sdb_data_copy() didn't copy values: got: %p; expected: %p",
 192                         d1.data.array.values, d2.data.array.values);
 193         for (i = 0; i < SDB_STATIC_ARRAY_LEN(int_values); ++i) {
 194                 int *i1 = d1.data.array.values;
 195                 int *i2 = d2.data.array.values;
 196                 fail_unless(i1[i] == i2[i],
 197                                 "sdb_data_copy() modified integer value %d: "
 198                                 "got: %d; expected: %d", i, i1[i], i2[i]);
 199         }
 200         sdb_data_free_datum(&d1);
 201
 202         d2.type = SDB_TYPE_ARRAY | SDB_TYPE_STRING;
 203         d2.data.array.length = SDB_STATIC_ARRAY_LEN(string_values);
 204         d2.data.array.values = string_values;
 205         check = sdb_data_copy(&d1, &d2);
 206         fail_unless(!check, "sdb_data_copy() = %i; expected: 0", check);
 207         fail_unless(d1.type == d2.type,
 208                         "sdb_data_copy() didn't copy type; got: %i; expected: %i",
 209                         d1.type, d2.type);
 210         fail_unless(d1.data.array.values != d2.data.array.values,
 211                         "sdb_data_copy() didn't copy values: got: %p; expected: %p",
 212                         d1.data.array.values, d2.data.array.values);
 213         for (i = 0; i < SDB_STATIC_ARRAY_LEN(string_values); ++i) {
 214                 char **s1 = d1.data.array.values;
 215                 char **s2 = d2.data.array.values;
 216                 fail_unless(s1[i] != s2[i],
 217                                 "sdb_data_copy() didn't copy string value %d", i);
 218                 fail_unless(!strcmp(s1[i], s2[i]),
 219                                 "sdb_data_copy() modified string value %d: "
 220                                 "got: %s; expected: %s", i, s1[i], s2[i]);
 221         }
 222         sdb_data_free_datum(&d1);
 223 }
 224 END_TEST
 225
 226 START_TEST(test_cmp)
 227 {
 228         int64_t int_values1[] = { 1, 2, 3 };
 229         int64_t int_values2[] = { 1, 3, 2 };
 230         char *string_values1[] = { "a", "b", "c" };
 231         char *string_values2[] = { "a", "c", "b" };
 232
 233         struct {
 234                 sdb_data_t d1;
 235                 sdb_data_t d2;
 236                 int expected;
 237         } golden_data[] = {
 238                 {
 239                         { SDB_TYPE_INTEGER, { .integer = 47 } },
 240                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 241                         -1,
 242                 },
 243                 {
 244                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 245                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 246                         0,
 247                 },
 248                 {
 249                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 250                         { SDB_TYPE_INTEGER, { .integer = 47 } },
 251                         1,
 252                 },
 253                 {
 254                         { SDB_TYPE_DECIMAL, { .decimal = 65535.9 } },
 255                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 256                         -1,
 257                 },
 258                 {
 259                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 260                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 261                         0,
 262                 },
 263                 {
 264                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 265                         { SDB_TYPE_DECIMAL, { .decimal = 65535.9 } },
 266                         1,
 267                 },
 268                 {
 269                         { SDB_TYPE_STRING, { .string = NULL } },
 270                         { SDB_TYPE_STRING, { .string = "" } },
 271                         -1,
 272                 },
 273                 {
 274                         { SDB_TYPE_STRING, { .string = NULL } },
 275                         { SDB_TYPE_STRING, { .string = NULL } },
 276                         0,
 277                 },
 278                 {
 279                         { SDB_TYPE_STRING, { .string = "" } },
 280                         { SDB_TYPE_STRING, { .string = NULL } },
 281                         1,
 282                 },
 283                 {
 284                         { SDB_TYPE_STRING, { .string = "a" } },
 285                         { SDB_TYPE_STRING, { .string = "b" } },
 286                         -1,
 287                 },
 288                 {
 289                         { SDB_TYPE_STRING, { .string = "a" } },
 290                         { SDB_TYPE_STRING, { .string = "ab" } },
 291                         -1,
 292                 },
 293                 {
 294                         { SDB_TYPE_STRING, { .string = "a" } },
 295                         { SDB_TYPE_STRING, { .string = "a" } },
 296                         0,
 297                 },
 298                 {
 299                         { SDB_TYPE_STRING, { .string = "b" } },
 300                         { SDB_TYPE_STRING, { .string = "a" } },
 301                         1,
 302                 },
 303                 {
 304                         { SDB_TYPE_STRING, { .string = "ab" } },
 305                         { SDB_TYPE_STRING, { .string = "a" } },
 306                         1,
 307                 },
 308                 {
 309                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471000 } },
 310                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 311                         -1,
 312                 },
 313                 {
 314                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 315                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 316                         0,
 317                 },
 318                 {
 319                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 320                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471000 } },
 321                         1,
 322                 },
 323                 {
 324                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 325                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
 326                         -1,
 327                 },
 328                 {
 329                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 330                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 331                         0,
 332                 },
 333                 {
 334                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
 335                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 336                         1,
 337                 },
 338                 {
 339                         {
 340                                 SDB_TYPE_BINARY,
 341                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 342                         },
 343                         {
 344                                 SDB_TYPE_BINARY,
 345                                 { .binary = { 3, (unsigned char *)"a\0b" } },
 346                         },
 347                         -1,
 348                 },
 349                 {
 350                         {
 351                                 SDB_TYPE_BINARY,
 352                                 { .binary = { 1, (unsigned char *)"a" } },
 353                         },
 354                         {
 355                                 SDB_TYPE_BINARY,
 356                                 { .binary = { 3, (unsigned char *)"a\0\0" } },
 357                         },
 358                         -1,
 359                 },
 360                 {
 361                         {
 362                                 SDB_TYPE_BINARY,
 363                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 364                         },
 365                         {
 366                                 SDB_TYPE_BINARY,
 367                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 368                         },
 369                         0,
 370                 },
 371                 {
 372                         {
 373                                 SDB_TYPE_BINARY,
 374                                 { .binary = { 3, (unsigned char *)"a\0b" } },
 375                         },
 376                         {
 377                                 SDB_TYPE_BINARY,
 378                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 379                         },
 380                         1,
 381                 },
 382                 {
 383                         {
 384                                 SDB_TYPE_BINARY,
 385                                 { .binary = { 3, (unsigned char *)"a\0\0" } },
 386                         },
 387                         {
 388                                 SDB_TYPE_BINARY,
 389                                 { .binary = { 1, (unsigned char *)"a" } },
 390                         },
 391                         1,
 392                 },
 393                 {
 394                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 395                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 396                         0,
 397                 },
 398                 {
 399                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 400                         { SDB_TYPE_REGEX, { .re = { "b", empty_re } } },
 401                         -1,
 402                 },
 403                 {
 404                         { SDB_TYPE_REGEX, { .re = { "b", empty_re } } },
 405                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 406                         1,
 407                 },
 408                 {
 409                         {
 410                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 411                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values1), int_values1 } },
 412                         },
 413                         {
 414                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 415                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values1), int_values1 } },
 416                         },
 417                         0,
 418                 },
 419                 {
 420                         {
 421                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 422                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values1), int_values1 } },
 423                         },
 424                         {
 425                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 426                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values2), int_values2 } },
 427                         },
 428                         -1,
 429                 },
 430                 {
 431                         {
 432                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 433                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values2), int_values2 } },
 434                         },
 435                         {
 436                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 437                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values1), int_values1 } },
 438                         },
 439                         1,
 440                 },
 441                 {
 442                         {
 443                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 444                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values1), string_values1 } },
 445                         },
 446                         {
 447                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 448                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values1), string_values1 } },
 449                         },
 450                         0,
 451                 },
 452                 {
 453                         {
 454                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 455                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values1), string_values1 } },
 456                         },
 457                         {
 458                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 459                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values2), string_values2 } },
 460                         },
 461                         -1,
 462                 },
 463                 {
 464                         {
 465                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 466                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values2), string_values2 } },
 467                         },
 468                         {
 469                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 470                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values1), string_values1 } },
 471                         },
 472                         1,
 473                 },
 474         };
 475
 476         size_t i;
 477
 478         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 479                 int check = sdb_data_cmp(&golden_data[i].d1, &golden_data[i].d2);
 480                 check = check < 0 ? -1 : check > 0 ? 1 : 0;
 481                 if (check != golden_data[i].expected) {
 482                         char d1_str[64] = "", d2_str[64] = "";
 483                         sdb_data_format(&golden_data[i].d1, d1_str, sizeof(d1_str),
 484                                         SDB_DOUBLE_QUOTED);
 485                         sdb_data_format(&golden_data[i].d2, d2_str, sizeof(d2_str),
 486                                         SDB_DOUBLE_QUOTED);
 487                         fail("sdb_data_cmp(%s, %s) = %d; expected: %d",
 488                                         d1_str, d2_str, check, golden_data[i].expected);
 489                 }
 490         }
 491 }
 492 END_TEST
 493
 494 START_TEST(test_strcmp)
 495 {
 496         struct {
 497                 sdb_data_t d1;
 498                 sdb_data_t d2;
 499                 int expected;
 500         } golden_data[] = {
 501                 /* same data as for the sdb_data_cmp test; in case the types match,
 502                  * both functions should behave the same (except for some loss in
 503                  * precision, e.g. when formatting datetime values) */
 504                 {
 505                         { SDB_TYPE_INTEGER, { .integer = 47 } },
 506                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 507                         -1,
 508                 },
 509                 {
 510                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 511                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 512                         0,
 513                 },
 514                 {
 515                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 516                         { SDB_TYPE_INTEGER, { .integer = 47 } },
 517                         1,
 518                 },
 519                 {
 520                         { SDB_TYPE_DECIMAL, { .decimal = 65535.9 } },
 521                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 522                         -1,
 523                 },
 524                 {
 525                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 526                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 527                         0,
 528                 },
 529                 {
 530                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
 531                         { SDB_TYPE_DECIMAL, { .decimal = 65535.9 } },
 532                         1,
 533                 },
 534                 {
 535                         { SDB_TYPE_STRING, { .string = NULL } },
 536                         { SDB_TYPE_STRING, { .string = "" } },
 537                         -1,
 538                 },
 539                 {
 540                         { SDB_TYPE_STRING, { .string = NULL } },
 541                         { SDB_TYPE_STRING, { .string = NULL } },
 542                         0,
 543                 },
 544                 {
 545                         { SDB_TYPE_STRING, { .string = "" } },
 546                         { SDB_TYPE_STRING, { .string = NULL } },
 547                         1,
 548                 },
 549                 {
 550                         { SDB_TYPE_STRING, { .string = "a" } },
 551                         { SDB_TYPE_STRING, { .string = "b" } },
 552                         -1,
 553                 },
 554                 {
 555                         { SDB_TYPE_STRING, { .string = "a" } },
 556                         { SDB_TYPE_STRING, { .string = "ab" } },
 557                         -1,
 558                 },
 559                 {
 560                         { SDB_TYPE_STRING, { .string = "a" } },
 561                         { SDB_TYPE_STRING, { .string = "a" } },
 562                         0,
 563                 },
 564                 {
 565                         { SDB_TYPE_STRING, { .string = "b" } },
 566                         { SDB_TYPE_STRING, { .string = "a" } },
 567                         1,
 568                 },
 569                 {
 570                         { SDB_TYPE_STRING, { .string = "ab" } },
 571                         { SDB_TYPE_STRING, { .string = "a" } },
 572                         1,
 573                 },
 574                 {
 575                         { SDB_TYPE_DATETIME, { .datetime = 471047114711471100 } },
 576                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 577                         -1,
 578                 },
 579                 {
 580                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 581                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 582                         0,
 583                 },
 584                 {
 585                         { SDB_TYPE_DATETIME, { .datetime = 471147114711471100 } },
 586                         { SDB_TYPE_DATETIME, { .datetime = 471047114711471100 } },
 587                         1,
 588                 },
 589                 {
 590                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 591                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
 592                         -1,
 593                 },
 594                 {
 595                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 596                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 597                         0,
 598                 },
 599                 {
 600                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
 601                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 602                         1,
 603                 },
 604                 {
 605                         {
 606                                 SDB_TYPE_BINARY,
 607                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 608                         },
 609                         {
 610                                 SDB_TYPE_BINARY,
 611                                 { .binary = { 3, (unsigned char *)"a\0b" } },
 612                         },
 613                         -1,
 614                 },
 615                 {
 616                         {
 617                                 SDB_TYPE_BINARY,
 618                                 { .binary = { 1, (unsigned char *)"a" } },
 619                         },
 620                         {
 621                                 SDB_TYPE_BINARY,
 622                                 { .binary = { 3, (unsigned char *)"a\0\0" } },
 623                         },
 624                         -1,
 625                 },
 626                 {
 627                         {
 628                                 SDB_TYPE_BINARY,
 629                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 630                         },
 631                         {
 632                                 SDB_TYPE_BINARY,
 633                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 634                         },
 635                         0,
 636                 },
 637                 {
 638                         {
 639                                 SDB_TYPE_BINARY,
 640                                 { .binary = { 3, (unsigned char *)"a\0b" } },
 641                         },
 642                         {
 643                                 SDB_TYPE_BINARY,
 644                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 645                         },
 646                         1,
 647                 },
 648                 {
 649                         {
 650                                 SDB_TYPE_BINARY,
 651                                 { .binary = { 3, (unsigned char *)"a\0\0" } },
 652                         },
 653                         {
 654                                 SDB_TYPE_BINARY,
 655                                 { .binary = { 1, (unsigned char *)"a" } },
 656                         },
 657                         1,
 658                 },
 659                 {
 660                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 661                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 662                         0,
 663                 },
 664                 {
 665                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 666                         { SDB_TYPE_REGEX, { .re = { "b", empty_re } } },
 667                         -1,
 668                 },
 669                 {
 670                         { SDB_TYPE_REGEX, { .re = { "b", empty_re } } },
 671                         { SDB_TYPE_REGEX, { .re = { "a", empty_re } } },
 672                         1,
 673                 },
 674                 /* type mismatches */
 675                 {
 676                         { SDB_TYPE_INTEGER, { .integer = 123 } },
 677                         { SDB_TYPE_STRING, { .string = "123" } },
 678                         0,
 679                 },
 680                 {
 681                         { SDB_TYPE_INTEGER, { .integer = 120 } },
 682                         { SDB_TYPE_STRING, { .string = "123" } },
 683                         -1,
 684                 },
 685                 {
 686                         { SDB_TYPE_STRING, { .string = "123" } },
 687                         { SDB_TYPE_INTEGER, { .integer = 120 } },
 688                         1,
 689                 },
 690                 {
 691                         { SDB_TYPE_STRING, { .string = "12.3" } },
 692                         { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
 693                         0,
 694                 },
 695                 {
 696                         { SDB_TYPE_STRING, { .string = "12.0" } },
 697                         { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
 698                         -1,
 699                 },
 700                 {
 701                         { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
 702                         { SDB_TYPE_STRING, { .string = "12.0" } },
 703                         1,
 704                 },
 705                 {
 706                         { SDB_TYPE_REGEX, { .re = { "regex", empty_re } } },
 707                         { SDB_TYPE_STRING, { .string = "/regex/" } },
 708                         0,
 709                 },
 710         };
 711
 712         size_t i;
 713
 714         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 715                 int check = sdb_data_strcmp(&golden_data[i].d1, &golden_data[i].d2);
 716                 check = check < 0 ? -1 : check > 0 ? 1 : 0;
 717                 if (check != golden_data[i].expected) {
 718                         char d1_str[64] = "", d2_str[64] = "";
 719                         sdb_data_format(&golden_data[i].d1, d1_str, sizeof(d1_str),
 720                                         SDB_DOUBLE_QUOTED);
 721                         sdb_data_format(&golden_data[i].d2, d2_str, sizeof(d2_str),
 722                                         SDB_DOUBLE_QUOTED);
 723                         fail("sdb_data_strcmp(%s, %s) = %d; expected: %d",
 724                                         d1_str, d2_str, check, golden_data[i].expected);
 725                 }
 726         }
 727 }
 728 END_TEST
 729
 730 START_TEST(test_parse_op)
 731 {
 732         struct {
 733                 const char *op;
 734                 int id;
 735         } golden_data[] = {
 736                 { "+",  SDB_DATA_ADD },
 737                 { "-",  SDB_DATA_SUB },
 738                 { "*",  SDB_DATA_MUL },
 739                 { "/",  SDB_DATA_DIV },
 740                 { "%",  SDB_DATA_MOD },
 741                 { "||", SDB_DATA_CONCAT },
 742                 { "&&", -1 },
 743         };
 744
 745         size_t i;
 746
 747         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 748                 const char *op;
 749                 int id;
 750
 751                 id = sdb_data_parse_op(golden_data[i].op);
 752                 fail_unless(id == golden_data[i].id,
 753                                 "sdb_data_parse_op(%s) = %d; expected: %d",
 754                                 golden_data[i].op, id, golden_data[i].id);
 755
 756                 if (id <= 0)
 757                         continue;
 758
 759                 op = SDB_DATA_OP_TO_STRING(id);
 760                 fail_unless(!strcmp(op, golden_data[i].op),
 761                                 "SDB_DATA_OP_TO_STRING(%d) = '%s'; expected: '%s'",
 762                                 id, op, golden_data[i].op);
 763         }
 764 }
 765 END_TEST
 766
 767 START_TEST(test_expr_eval)
 768 {
 769         sdb_data_t err = { -1, { .integer = 0 } };
 770
 771         int64_t int_values[] = { 47, 11, 23 };
 772         int64_t expected_int_concat[] = { 47, 11, 23, 47, 11, 23 };
 773         char *string_values[] = { "foo", "bar", "qux" "baz" };
 774         char *expected_string_concat[] =
 775                 { "foo", "bar", "qux" "baz", "foo", "bar", "qux" "baz" };
 776
 777         struct {
 778                 sdb_data_t d1;
 779                 sdb_data_t d2;
 780                 sdb_data_t expected_add;
 781                 sdb_data_t expected_sub;
 782                 sdb_data_t expected_mul;
 783                 sdb_data_t expected_div;
 784                 sdb_data_t expected_mod;
 785                 sdb_data_t expected_concat;
 786         } golden_data[] = {
 787                 {
 788                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
 789                         { SDB_TYPE_INTEGER, { .integer = 47 } },
 790                         { SDB_TYPE_INTEGER, { .integer = 4758 } },
 791                         { SDB_TYPE_INTEGER, { .integer = 4664 } },
 792                         { SDB_TYPE_INTEGER, { .integer = 221417 } },
 793                         { SDB_TYPE_INTEGER, { .integer = 100 } },
 794                         { SDB_TYPE_INTEGER, { .integer = 11 } },
 795                         err,
 796                 },
 797                 {
 798                         { SDB_TYPE_DECIMAL, { .decimal = 35.0 } },
 799                         { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
 800                         { SDB_TYPE_DECIMAL, { .decimal = 52.5 } },
 801                         { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
 802                         { SDB_TYPE_DECIMAL, { .decimal = 612.5 } },
 803                         { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
 804                         { SDB_TYPE_DECIMAL, { .decimal = 0.0 } },
 805                         err,
 806                 },
 807                 {
 808                         { SDB_TYPE_STRING, { .string = NULL } },
 809                         { SDB_TYPE_STRING, { .string = "" } },
 810                         SDB_DATA_NULL,
 811                         SDB_DATA_NULL,
 812                         SDB_DATA_NULL,
 813                         SDB_DATA_NULL,
 814                         SDB_DATA_NULL,
 815                         SDB_DATA_NULL,
 816                 },
 817                 {
 818                         { SDB_TYPE_STRING, { .string = NULL } },
 819                         { SDB_TYPE_STRING, { .string = NULL } },
 820                         SDB_DATA_NULL,
 821                         SDB_DATA_NULL,
 822                         SDB_DATA_NULL,
 823                         SDB_DATA_NULL,
 824                         SDB_DATA_NULL,
 825                         SDB_DATA_NULL,
 826                 },
 827                 {
 828                         { SDB_TYPE_STRING, { .string = "" } },
 829                         { SDB_TYPE_STRING, { .string = NULL } },
 830                         SDB_DATA_NULL,
 831                         SDB_DATA_NULL,
 832                         SDB_DATA_NULL,
 833                         SDB_DATA_NULL,
 834                         SDB_DATA_NULL,
 835                         SDB_DATA_NULL,
 836                 },
 837                 {
 838                         { SDB_TYPE_STRING, { .string = "a" } },
 839                         { SDB_TYPE_STRING, { .string = "b" } },
 840                         err,
 841                         err,
 842                         err,
 843                         err,
 844                         err,
 845                         { SDB_TYPE_STRING, { .string = "ab" } },
 846                 },
 847                 {
 848                         { SDB_TYPE_DATETIME, { .datetime = 47114711 } },
 849                         { SDB_TYPE_DATETIME, { .datetime = 4711 } },
 850                         { SDB_TYPE_DATETIME, { .datetime = 47119422 } },
 851                         { SDB_TYPE_DATETIME, { .datetime = 47110000 } },
 852                         { SDB_TYPE_DATETIME, { .datetime = 221957403521 } },
 853                         { SDB_TYPE_DATETIME, { .datetime = 10001 } },
 854                         { SDB_TYPE_DATETIME, { .datetime = 0 } },
 855                         err,
 856                 },
 857                 {
 858                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 859                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
 860                         SDB_DATA_NULL,
 861                         SDB_DATA_NULL,
 862                         SDB_DATA_NULL,
 863                         SDB_DATA_NULL,
 864                         SDB_DATA_NULL,
 865                         SDB_DATA_NULL,
 866                 },
 867                 {
 868                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 869                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 870                         SDB_DATA_NULL,
 871                         SDB_DATA_NULL,
 872                         SDB_DATA_NULL,
 873                         SDB_DATA_NULL,
 874                         SDB_DATA_NULL,
 875                         SDB_DATA_NULL,
 876                 },
 877                 {
 878                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
 879                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
 880                         SDB_DATA_NULL,
 881                         SDB_DATA_NULL,
 882                         SDB_DATA_NULL,
 883                         SDB_DATA_NULL,
 884                         SDB_DATA_NULL,
 885                         SDB_DATA_NULL,
 886                 },
 887                 {
 888                         {
 889                                 SDB_TYPE_BINARY,
 890                                 { .binary = { 3, (unsigned char *)"a\0a" } },
 891                         },
 892                         {
 893                                 SDB_TYPE_BINARY,
 894                                 { .binary = { 3, (unsigned char *)"b\0b" } },
 895                         },
 896                         err,
 897                         err,
 898                         err,
 899                         err,
 900                         err,
 901                         {
 902                                 SDB_TYPE_BINARY,
 903                                 { .binary = { 6, (unsigned char *)"a\0ab\0b" } },
 904                         },
 905                 },
 906                 {
 907                         { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
 908                         { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
 909                         err,
 910                         err,
 911                         err,
 912                         err,
 913                         err,
 914                         err,
 915                 },
 916                 {
 917                         {
 918                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 919                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
 920                         },
 921                         {
 922                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 923                                 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
 924                         },
 925                         err,
 926                         err,
 927                         err,
 928                         err,
 929                         err,
 930                         {
 931                                 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
 932                                 { .array = {
 933                                                 SDB_STATIC_ARRAY_LEN(expected_int_concat),
 934                                                 expected_int_concat
 935                                 } },
 936                         },
 937                 },
 938                 {
 939                         {
 940                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 941                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
 942                         },
 943                         {
 944                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 945                                 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
 946                         },
 947                         err,
 948                         err,
 949                         err,
 950                         err,
 951                         err,
 952                         {
 953                                 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
 954                                 { .array = {
 955                                                 SDB_STATIC_ARRAY_LEN(expected_string_concat),
 956                                                 expected_string_concat
 957                                 } },
 958                         },
 959                 },
 960                 {
 961                         { SDB_TYPE_NULL, { .integer = 0 } },
 962                         { SDB_TYPE_NULL, { .integer = 0 } },
 963                         SDB_DATA_NULL,
 964                         SDB_DATA_NULL,
 965                         SDB_DATA_NULL,
 966                         SDB_DATA_NULL,
 967                         SDB_DATA_NULL,
 968                         SDB_DATA_NULL,
 969                 },
 970                 {
 971                         { SDB_TYPE_NULL, { .integer = 0 } },
 972                         { SDB_TYPE_INTEGER, { .integer = 42 } },
 973                         SDB_DATA_NULL,
 974                         SDB_DATA_NULL,
 975                         SDB_DATA_NULL,
 976                         SDB_DATA_NULL,
 977                         SDB_DATA_NULL,
 978                         SDB_DATA_NULL,
 979                 },
 980                 {
 981                         { SDB_TYPE_INTEGER, { .integer = 42 } },
 982                         { SDB_TYPE_NULL, { .integer = 0 } },
 983                         SDB_DATA_NULL,
 984                         SDB_DATA_NULL,
 985                         SDB_DATA_NULL,
 986                         SDB_DATA_NULL,
 987                         SDB_DATA_NULL,
 988                         SDB_DATA_NULL,
 989                 },
 990                 {
 991                         { SDB_TYPE_NULL, { .integer = 0 } },
 992                         { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
 993                         SDB_DATA_NULL,
 994                         SDB_DATA_NULL,
 995                         SDB_DATA_NULL,
 996                         SDB_DATA_NULL,
 997                         SDB_DATA_NULL,
 998                         SDB_DATA_NULL,
 999                 },
1000                 {
1001                         { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1002                         { SDB_TYPE_NULL, { .integer = 0 } },
1003                         SDB_DATA_NULL,
1004                         SDB_DATA_NULL,
1005                         SDB_DATA_NULL,
1006                         SDB_DATA_NULL,
1007                         SDB_DATA_NULL,
1008                         SDB_DATA_NULL,
1009                 },
1010                 {
1011                         { SDB_TYPE_NULL, { .integer = 0 } },
1012                         { SDB_TYPE_STRING, { .string = "47.11" } },
1013                         SDB_DATA_NULL,
1014                         SDB_DATA_NULL,
1015                         SDB_DATA_NULL,
1016                         SDB_DATA_NULL,
1017                         SDB_DATA_NULL,
1018                         SDB_DATA_NULL,
1019                 },
1020                 {
1021                         { SDB_TYPE_STRING, { .string = "47.11" } },
1022                         { SDB_TYPE_NULL, { .integer = 0 } },
1023                         SDB_DATA_NULL,
1024                         SDB_DATA_NULL,
1025                         SDB_DATA_NULL,
1026                         SDB_DATA_NULL,
1027                         SDB_DATA_NULL,
1028                         SDB_DATA_NULL,
1029                 },
1030                 {
1031                         { SDB_TYPE_NULL, { .integer = 0 } },
1032                         { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1033                         SDB_DATA_NULL,
1034                         SDB_DATA_NULL,
1035                         SDB_DATA_NULL,
1036                         SDB_DATA_NULL,
1037                         SDB_DATA_NULL,
1038                         SDB_DATA_NULL,
1039                 },
1040                 {
1041                         { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1042                         { SDB_TYPE_NULL, { .integer = 0 } },
1043                         SDB_DATA_NULL,
1044                         SDB_DATA_NULL,
1045                         SDB_DATA_NULL,
1046                         SDB_DATA_NULL,
1047                         SDB_DATA_NULL,
1048                         SDB_DATA_NULL,
1049                 },
1050                 {
1051                         { SDB_TYPE_NULL, { .integer = 0 } },
1052                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1053                         SDB_DATA_NULL,
1054                         SDB_DATA_NULL,
1055                         SDB_DATA_NULL,
1056                         SDB_DATA_NULL,
1057                         SDB_DATA_NULL,
1058                         SDB_DATA_NULL,
1059                 },
1060                 {
1061                         { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1062                         { SDB_TYPE_NULL, { .integer = 0 } },
1063                         SDB_DATA_NULL,
1064                         SDB_DATA_NULL,
1065                         SDB_DATA_NULL,
1066                         SDB_DATA_NULL,
1067                         SDB_DATA_NULL,
1068                         SDB_DATA_NULL,
1069                 },
1070                 {
1071                         { SDB_TYPE_NULL, { .integer = 0 } },
1072                         { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1073                         SDB_DATA_NULL,
1074                         SDB_DATA_NULL,
1075                         SDB_DATA_NULL,
1076                         SDB_DATA_NULL,
1077                         SDB_DATA_NULL,
1078                         SDB_DATA_NULL,
1079                 },
1080                 {
1081                         { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1082                         { SDB_TYPE_NULL, { .integer = 0 } },
1083                         SDB_DATA_NULL,
1084                         SDB_DATA_NULL,
1085                         SDB_DATA_NULL,
1086                         SDB_DATA_NULL,
1087                         SDB_DATA_NULL,
1088                         SDB_DATA_NULL,
1089                 },
1090                 /* supported type-mismatches */
1091                 {
1092                         /* int * datetime */
1093                         { SDB_TYPE_INTEGER,  { .integer  = 20 } },
1094                         { SDB_TYPE_DATETIME, { .datetime = 2 } },
1095                         err,
1096                         err,
1097                         { SDB_TYPE_DATETIME, { .datetime = 40 } },
1098                         err,
1099                         err,
1100                         err,
1101                 },
1102                 {
1103                         /* datetime * int, datetime / int, datetime % int */
1104                         { SDB_TYPE_DATETIME, { .datetime = 20 } },
1105                         { SDB_TYPE_INTEGER,  { .integer  = 2 } },
1106                         err,
1107                         err,
1108                         { SDB_TYPE_DATETIME, { .datetime = 40 } },
1109                         { SDB_TYPE_DATETIME, { .datetime = 10 } },
1110                         { SDB_TYPE_DATETIME, { .datetime = 0 } },
1111                         err,
1112                 },
1113                 {
1114                         /* float * datetime */
1115                         { SDB_TYPE_DECIMAL,  { .decimal  = 20.0 } },
1116                         { SDB_TYPE_DATETIME, { .datetime = 2 } },
1117                         err,
1118                         err,
1119                         { SDB_TYPE_DATETIME, { .datetime = 40 } },
1120                         err,
1121                         err,
1122                         err,
1123                 },
1124                 {
1125                         /* datetime * float, datetime / float, datetime % float */
1126                         { SDB_TYPE_DATETIME, { .datetime = 20 } },
1127                         { SDB_TYPE_DECIMAL,  { .decimal  = 2.0 } },
1128                         err,
1129                         err,
1130                         { SDB_TYPE_DATETIME, { .datetime = 40 } },
1131                         { SDB_TYPE_DATETIME, { .datetime = 10 } },
1132                         { SDB_TYPE_DATETIME, { .datetime = 0 } },
1133                         err,
1134                 },
1135         };
1136
1137         size_t i;
1138
1139         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1140                 struct {
1141                         int op;
1142                         sdb_data_t expected;
1143                 } tests[] = {
1144                         { SDB_DATA_ADD, golden_data[i].expected_add },
1145                         { SDB_DATA_SUB, golden_data[i].expected_sub },
1146                         { SDB_DATA_MUL, golden_data[i].expected_mul },
1147                         { SDB_DATA_DIV, golden_data[i].expected_div },
1148                         { SDB_DATA_MOD, golden_data[i].expected_mod },
1149                         { SDB_DATA_CONCAT, golden_data[i].expected_concat },
1150                 };
1151
1152                 size_t j;
1153                 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
1154                         sdb_data_t res;
1155                         int check;
1156
1157                         char d1_str[64] = "", d2_str[64] = "";
1158                         sdb_data_format(&golden_data[i].d1, d1_str, sizeof(d1_str),
1159                                         SDB_DOUBLE_QUOTED);
1160                         sdb_data_format(&golden_data[i].d2, d2_str, sizeof(d2_str),
1161                                         SDB_DOUBLE_QUOTED);
1162
1163                         check = sdb_data_expr_eval(tests[j].op,
1164                                         &golden_data[i].d1, &golden_data[i].d2, &res);
1165                         fail_unless((check == 0) == (tests[j].expected.type != -1),
1166                                         "sdb_data_expr_eval(%s, %s, %s) = %d; expected: %d",
1167                                         SDB_DATA_OP_TO_STRING(tests[j].op), d1_str, d2_str, check,
1168                                         tests[j].expected.type == -1 ? -1 : 0);
1169                         if (tests[j].expected.type == -1)
1170                                 continue;
1171
1172                         if (tests[j].expected.type == SDB_TYPE_NULL) {
1173                                 fail_unless(res.type == SDB_TYPE_NULL,
1174                                                 "sdb_data_expr_eval(%s, %s, %s) evaluated to "
1175                                                 "type %d; expected: SDB_TYPE_NULL",
1176                                                 SDB_DATA_OP_TO_STRING(tests[j].op),
1177                                                 d1_str, d2_str, res.type);
1178                                 continue;
1179                         }
1180
1181                         check = sdb_data_cmp(&res, &tests[j].expected);
1182                         if (check != 0) {
1183                                 char res_str[64] = "", expected_str[64] = "";
1184                                 sdb_data_format(&res, res_str, sizeof(res_str),
1185                                                 SDB_DOUBLE_QUOTED);
1186                                 sdb_data_format(&tests[j].expected, expected_str,
1187                                                 sizeof(expected_str), SDB_DOUBLE_QUOTED);
1188                                 fail("sdb_data_expr_eval(%s, %s, %s) evaluated to %s "
1189                                                 "(type %d); expected: %s (type %d)",
1190                                                 SDB_DATA_OP_TO_STRING(tests[j].op),
1191                                                 d1_str, d2_str, res_str, res.type,
1192                                                 expected_str, tests[j].expected.type);
1193                         }
1194
1195                         sdb_data_free_datum(&res);
1196                 }
1197         }
1198 }
1199 END_TEST
1200
1201 START_TEST(test_format)
1202 {
1203         struct {
1204                 sdb_data_t datum;
1205                 const char *expected;
1206         } golden_data[] = {
1207                 {
1208                         { SDB_TYPE_INTEGER, { .integer = 4711 } },
1209                         "4711",
1210                 },
1211                 {
1212                         { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
1213                         "65536",
1214                 },
1215                 {
1216                         { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
1217                         "12.3",
1218                 },
1219                 {
1220                         { SDB_TYPE_STRING, { .string = NULL } },
1221                         "\"<NULL>\"",
1222                 },
1223                 {
1224                         { SDB_TYPE_STRING, { .string = "this is a test" } },
1225                         "\"this is a test\"",
1226                 },
1227                 {
1228                         { SDB_TYPE_STRING, { .string = "special \\ \" characters" } },
1229                         "\"special \\\\ \\\" characters\"",
1230                 },
1231                 {
1232                         { SDB_TYPE_DATETIME, { .datetime= 471147114711471100 } },
1233                         "\"1984-12-06 02:11:54 +0000\"",
1234                 },
1235                 {
1236                         { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1237                         "\"<NULL>\"",
1238                 },
1239                 {
1240                         {
1241                                 SDB_TYPE_BINARY,
1242                                 { .binary = { 12, (unsigned char *)"binary\0crap\x42" } },
1243                         },
1244                         "\"\\x62\\x69\\x6e\\x61\\x72\\x79\\x0\\x63\\x72\\x61\\x70\\x42\"",
1245                 },
1246                 {
1247                         { SDB_TYPE_REGEX, { .re = { "some regex", empty_re } } },
1248                         "\"/some regex/\"",
1249                 },
1250         };
1251
1252         size_t i;
1253
1254         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1255                 sdb_data_t *datum = &golden_data[i].datum;
1256                 char buf[sdb_data_strlen(datum) + 2];
1257                 int check;
1258
1259                 memset(buf, (int)'A', sizeof(buf));
1260
1261                 check = sdb_data_format(datum, buf, sizeof(buf) - 1,
1262                                 SDB_DOUBLE_QUOTED);
1263                 fail_unless(check > 0,
1264                                 "sdb_data_format(type=%s) = %d; expected: >0",
1265                                 SDB_TYPE_TO_STRING(datum->type), check);
1266                 fail_unless(! strcmp(buf, golden_data[i].expected),
1267                                 "sdb_data_format(type=%s) used wrong format: %s; expected: %s",
1268                                 SDB_TYPE_TO_STRING(datum->type), buf, golden_data[i].expected);
1269
1270                 fail_unless((size_t)check <= sizeof(buf) - 2,
1271                                 "sdb_data_format(type=%s) wrote %d bytes; "
1272                                 "expected <= %zu based on sdb_data_strlen()",
1273                                 SDB_TYPE_TO_STRING(datum->type), check, sizeof(buf) - 2);
1274
1275                 fail_unless(buf[sizeof(buf) - 2] == '\0',
1276                                 "sdb_data_format(type=%s) did not nul-terminate the buffer",
1277                                 SDB_TYPE_TO_STRING(datum->type));
1278                 fail_unless(buf[sizeof(buf) - 1] == 'A',
1279                                 "sdb_data_format(type=%s) wrote past the end of the buffer",
1280                                 SDB_TYPE_TO_STRING(datum->type));
1281         }
1282 }
1283 END_TEST
1284
1285 START_TEST(test_parse)
1286 {
1287         struct {
1288                 char *input;
1289                 sdb_data_t result;
1290                 int expected;
1291         } golden_data[] = {
1292                 { "4711",    { SDB_TYPE_INTEGER,  { .integer  = 4711 } },          0 },
1293                 { "0x10",    { SDB_TYPE_INTEGER,  { .integer  = 16 } },            0 },
1294                 { "010",     { SDB_TYPE_INTEGER,  { .integer  = 8 } },             0 },
1295                 { "abc",     { SDB_TYPE_INTEGER,  { .integer  = 0 } },            -1 },
1296                 { "1.2",     { SDB_TYPE_DECIMAL,  { .decimal  = 1.2 } },           0 },
1297                 { "0x1p+16", { SDB_TYPE_DECIMAL,  { .decimal  = 65536.0 } },       0 },
1298                 { "abc",     { SDB_TYPE_DECIMAL,  { .decimal  = 0.0 } },          -1 },
1299                 { "abc",     { SDB_TYPE_STRING,   { .string   = "abc" } },         0 },
1300                 { ".4",      { SDB_TYPE_DATETIME, { .datetime = 400000000 } },     0 },
1301                 { "abc",     { SDB_TYPE_DATETIME, { .datetime = 0 } },            -1 },
1302                 { "abc",     { SDB_TYPE_BINARY,
1303                                          { .binary = { 3, (unsigned char *)"abc" } } }, 0 },
1304                 { "abc",     { SDB_TYPE_REGEX,    { .re = { "abc", empty_re } } }, 0 },
1305                 { "(|",      { SDB_TYPE_REGEX,    { .re = { "", empty_re } } },   -1 },
1306         };
1307
1308         size_t i;
1309
1310         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1311                 sdb_data_t result;
1312                 int type, check;
1313
1314                 memset(&result, 0, sizeof(result));
1315                 type = golden_data[i].result.type;
1316                 check = sdb_data_parse(golden_data[i].input, type, &result);
1317                 fail_unless(check == golden_data[i].expected,
1318                                 "sdb_data_parse(%s, %d, <d>) = %d; expected: %d",
1319                                 golden_data[i].input, type, check, golden_data[i].expected);
1320
1321                 if (check)
1322                         continue;
1323
1324                 fail_unless(sdb_data_cmp(&result, &golden_data[i].result) == 0,
1325                                 "sdb_data_parse(%s, %d, <d>) did not create expected result",
1326                                 golden_data[i].input, type);
1327
1328                 if (type == SDB_TYPE_STRING)
1329                         fail_unless(golden_data[i].input == result.data.string,
1330                                         "sdb_data_parse(%s, %d, <d>) modified input string",
1331                                         golden_data[i].input, type);
1332                 if (type == SDB_TYPE_BINARY)
1333                         fail_unless(golden_data[i].input == (char *)result.data.binary.datum,
1334                                         "sdb_data_parse(%s, %d, <d>) modified input string",
1335                                         golden_data[i].input, type);
1336                 if (type == SDB_TYPE_REGEX) {
1337                         fail_unless(golden_data[i].input != result.data.re.raw,
1338                                         "sdb_data_parse(%s, %d, <d>) copied input string",
1339                                         golden_data[i].input, type);
1340                         sdb_data_free_datum(&result);
1341                 }
1342         }
1343 }
1344 END_TEST
1345
1346 Suite *
1347 core_data_suite(void)
1348 {
1349         Suite *s = suite_create("core::data");
1350         TCase *tc;
1351
1352         tc = tcase_create("core");
1353         tcase_add_test(tc, test_data);
1354         tcase_add_test(tc, test_cmp);
1355         tcase_add_test(tc, test_strcmp);
1356         tcase_add_test(tc, test_parse_op);
1357         tcase_add_test(tc, test_expr_eval);
1358         tcase_add_test(tc, test_format);
1359         tcase_add_test(tc, test_parse);
1360         suite_add_tcase(s, tc);
1361
1362         return s;
1363 } /* core_data_suite */
1364
1365 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1366