![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
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 */
28 #include "core/data.h"
29 #include "libsysdb_test.h"
31 #include <assert.h>
32 #include <check.h>
34 static regex_t empty_re;
36 START_TEST(test_data)
37 {
38 sdb_data_t d1, d2;
39 int check;
41 int64_t int_values[] = { 47, 11, 23 };
42 char *string_values[] = { "foo", "bar", "qux" "baz" };
43 size_t i;
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);
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);
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);
79 sdb_data_free_datum(&d1);
80 fail_unless(d1.data.string == NULL,
81 "sdb_data_free_datum() didn't free string data");
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);
95 sdb_data_free_datum(&d1);
96 fail_unless(d1.data.string == NULL,
97 "sdb_data_free_datum() didn't free string data");
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);
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);
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");
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);
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");
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);
170 sdb_data_free_datum(&d1);
171 fail_unless(d1.data.re.raw == NULL,
172 "sdb_data_free_datum() didn't reset raw regex");
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);
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);
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
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" };
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 };
476 size_t i;
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
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 };
712 size_t i;
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
730 START_TEST(test_inarray)
731 {
732 int64_t int_values[] = { 47, 11, 64 };
733 double dec_values[] = { 12.3, 47.11, 64.0 };
734 char *string_values[] = { "foo", "bar", "qux", "baz" };
736 sdb_data_t int_array = {
737 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
738 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } }
739 };
740 sdb_data_t dec_array = {
741 SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL,
742 { .array = { SDB_STATIC_ARRAY_LEN(dec_values), dec_values } }
743 };
744 sdb_data_t string_array = {
745 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
746 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } }
747 };
749 struct {
750 sdb_data_t value;
751 sdb_data_t array;
752 _Bool expected;
753 } golden_data[] = {
754 { { SDB_TYPE_INTEGER, { .integer = 47 } }, int_array, 1 },
755 { { SDB_TYPE_INTEGER, { .integer = 11 } }, int_array, 1 },
756 { { SDB_TYPE_INTEGER, { .integer = 64 } }, int_array, 1 },
757 { { SDB_TYPE_INTEGER, { .integer = 65 } }, int_array, 0 },
758 { { SDB_TYPE_NULL, { .integer = 0 } }, int_array, 0 },
759 { int_array, { SDB_TYPE_INTEGER, { .integer = 47 } }, 0 },
760 { int_array, int_array, 0 },
761 { { SDB_TYPE_DECIMAL, { .decimal = 12.3 } }, dec_array, 1 },
762 { { SDB_TYPE_DECIMAL, { .decimal = 47.11 } }, dec_array, 1 },
763 { { SDB_TYPE_DECIMAL, { .decimal = 64.0 } }, dec_array, 1 },
764 { { SDB_TYPE_DECIMAL, { .decimal = 60.0 } }, dec_array, 0 },
765 { { SDB_TYPE_INTEGER, { .integer = 64 } }, dec_array, 0 },
766 { { SDB_TYPE_NULL, { .integer = 0 } }, dec_array, 0 },
767 { { SDB_TYPE_STRING, { .string = "Foo" } }, string_array, 1 },
768 { { SDB_TYPE_STRING, { .string = "FOO" } }, string_array, 1 },
769 { { SDB_TYPE_STRING, { .string = "foo" } }, string_array, 1 },
770 { { SDB_TYPE_STRING, { .string = "bar" } }, string_array, 1 },
771 { { SDB_TYPE_STRING, { .string = "qux" } }, string_array, 1 },
772 { { SDB_TYPE_STRING, { .string = "baz" } }, string_array, 1 },
773 { { SDB_TYPE_STRING, { .string = "ba" } }, string_array, 0 },
774 { { SDB_TYPE_STRING, { .string = "abc" } }, string_array, 0 },
775 { { SDB_TYPE_NULL, { .integer = 0 } }, string_array, 0 },
776 };
778 size_t i;
780 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
781 char v_str[1024] = "", a_str[1024] = "";
782 _Bool check;
784 sdb_data_format(&golden_data[i].value,
785 v_str, sizeof(v_str), SDB_UNQUOTED);
786 sdb_data_format(&golden_data[i].array,
787 a_str, sizeof(a_str), SDB_UNQUOTED);
789 check = sdb_data_inarray(&golden_data[i].value, &golden_data[i].array);
790 fail_unless(check == golden_data[i].expected,
791 "sdb_data_inarray(%s, %s) = %d; expected: %d",
792 v_str, a_str, check, golden_data[i].expected);
793 }
794 }
795 END_TEST
797 START_TEST(test_array_get)
798 {
799 int64_t int_values[] = { 47, 11, 64 };
800 double dec_values[] = { 12.3, 47.11, 64.0 };
801 char *string_values[] = { "foo", "bar", "qux", "baz" };
803 sdb_data_t int_array = {
804 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
805 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } }
806 };
807 sdb_data_t dec_array = {
808 SDB_TYPE_ARRAY | SDB_TYPE_DECIMAL,
809 { .array = { SDB_STATIC_ARRAY_LEN(dec_values), dec_values } }
810 };
811 sdb_data_t string_array = {
812 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
813 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } }
814 };
816 struct {
817 sdb_data_t array;
818 size_t i;
819 sdb_data_t expected;
820 } golden_data[] = {
821 { int_array, 0, { SDB_TYPE_INTEGER, { .integer = 47 } } },
822 { int_array, 1, { SDB_TYPE_INTEGER, { .integer = 11 } } },
823 { int_array, 2, { SDB_TYPE_INTEGER, { .integer = 64 } } },
824 { int_array, 3, { -1, { .integer = 0 } } },
825 { dec_array, 0, { SDB_TYPE_DECIMAL, { .decimal = 12.3 } } },
826 { dec_array, 1, { SDB_TYPE_DECIMAL, { .decimal = 47.11 } } },
827 { dec_array, 2, { SDB_TYPE_DECIMAL, { .decimal = 64.0 } } },
828 { dec_array, 3, { -1, { .integer = 0 } } },
829 { string_array, 0, { SDB_TYPE_STRING, { .string = "foo" } } },
830 { string_array, 1, { SDB_TYPE_STRING, { .string = "bar" } } },
831 { string_array, 2, { SDB_TYPE_STRING, { .string = "qux" } } },
832 { string_array, 3, { SDB_TYPE_STRING, { .string = "baz" } } },
833 { string_array, 4, { -1, { .integer = 0 } } },
834 { { SDB_TYPE_INTEGER, { .integer = 666 } }, 0, { -1, { .integer = 0 } } },
835 { { SDB_TYPE_INTEGER, { .integer = 666 } }, 1, { -1, { .integer = 0 } } },
836 };
838 size_t i;
840 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
841 char a_str[1024] = "", v_str[1024] = "", exp_str[1024] = "";
842 sdb_data_t value = SDB_DATA_INIT;
843 int check;
845 sdb_data_format(&golden_data[i].array,
846 a_str, sizeof(a_str), SDB_UNQUOTED);
847 sdb_data_format(&golden_data[i].expected,
848 exp_str, sizeof(exp_str), SDB_UNQUOTED);
850 check = sdb_data_array_get(&golden_data[i].array,
851 golden_data[i].i, &value);
853 sdb_data_format(&value, v_str, sizeof(v_str), SDB_UNQUOTED);
855 if (golden_data[i].expected.type < 0) {
856 fail_unless(check < 0,
857 "sdb_data_array_get(%s, %zu) = %d (%s); expected: <0",
858 a_str, golden_data[i].i, check, v_str);
859 continue;
860 }
862 fail_unless(check == 0,
863 "sdb_data_array_get(%s, %zu) = %d; expected: 0",
864 a_str, golden_data[i].i, check);
865 fail_unless(! sdb_data_cmp(&value, &golden_data[i].expected),
866 "sdb_data_array_get(%s, %zu) -> '%s'; expected: '%s'",
867 a_str, golden_data[i].i, v_str, exp_str);
868 }
869 }
870 END_TEST
872 START_TEST(test_parse_op)
873 {
874 struct {
875 const char *op;
876 int id;
877 } golden_data[] = {
878 { "+", SDB_DATA_ADD },
879 { "-", SDB_DATA_SUB },
880 { "*", SDB_DATA_MUL },
881 { "/", SDB_DATA_DIV },
882 { "%", SDB_DATA_MOD },
883 { "||", SDB_DATA_CONCAT },
884 { "&&", -1 },
885 };
887 size_t i;
889 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
890 const char *op;
891 int id;
893 id = sdb_data_parse_op(golden_data[i].op);
894 fail_unless(id == golden_data[i].id,
895 "sdb_data_parse_op(%s) = %d; expected: %d",
896 golden_data[i].op, id, golden_data[i].id);
898 if (id <= 0)
899 continue;
901 op = SDB_DATA_OP_TO_STRING(id);
902 fail_unless(!strcmp(op, golden_data[i].op),
903 "SDB_DATA_OP_TO_STRING(%d) = '%s'; expected: '%s'",
904 id, op, golden_data[i].op);
905 }
906 }
907 END_TEST
909 START_TEST(test_expr_eval)
910 {
911 sdb_data_t err = { -1, { .integer = 0 } };
913 int64_t int_values[] = { 47, 11, 23 };
914 int64_t expected_int_append[] = { 47, 11, 23, 42 };
915 int64_t expected_int_prepend[] = { 42, 47, 11, 23 };
916 int64_t expected_int_concat[] = { 47, 11, 23, 47, 11, 23 };
917 char *string_values[] = { "foo", "bar", "qux" "baz" };
918 char *expected_string_append[] = { "foo", "bar", "qux" "baz", "bay" };
919 char *expected_string_prepend[] = { "bay", "foo", "bar", "qux" "baz" };
920 char *expected_string_concat[] =
921 { "foo", "bar", "qux" "baz", "foo", "bar", "qux" "baz" };
923 struct {
924 sdb_data_t d1;
925 sdb_data_t d2;
926 sdb_data_t expected_add;
927 sdb_data_t expected_sub;
928 sdb_data_t expected_mul;
929 sdb_data_t expected_div;
930 sdb_data_t expected_mod;
931 sdb_data_t expected_concat;
932 } golden_data[] = {
933 {
934 { SDB_TYPE_INTEGER, { .integer = 4711 } },
935 { SDB_TYPE_INTEGER, { .integer = 47 } },
936 { SDB_TYPE_INTEGER, { .integer = 4758 } },
937 { SDB_TYPE_INTEGER, { .integer = 4664 } },
938 { SDB_TYPE_INTEGER, { .integer = 221417 } },
939 { SDB_TYPE_INTEGER, { .integer = 100 } },
940 { SDB_TYPE_INTEGER, { .integer = 11 } },
941 err,
942 },
943 {
944 { SDB_TYPE_DECIMAL, { .decimal = 35.0 } },
945 { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
946 { SDB_TYPE_DECIMAL, { .decimal = 52.5 } },
947 { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
948 { SDB_TYPE_DECIMAL, { .decimal = 612.5 } },
949 { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
950 { SDB_TYPE_DECIMAL, { .decimal = 0.0 } },
951 err,
952 },
953 {
954 { SDB_TYPE_STRING, { .string = NULL } },
955 { SDB_TYPE_STRING, { .string = "" } },
956 SDB_DATA_NULL,
957 SDB_DATA_NULL,
958 SDB_DATA_NULL,
959 SDB_DATA_NULL,
960 SDB_DATA_NULL,
961 SDB_DATA_NULL,
962 },
963 {
964 { SDB_TYPE_STRING, { .string = NULL } },
965 { SDB_TYPE_STRING, { .string = NULL } },
966 SDB_DATA_NULL,
967 SDB_DATA_NULL,
968 SDB_DATA_NULL,
969 SDB_DATA_NULL,
970 SDB_DATA_NULL,
971 SDB_DATA_NULL,
972 },
973 {
974 { SDB_TYPE_STRING, { .string = "" } },
975 { SDB_TYPE_STRING, { .string = NULL } },
976 SDB_DATA_NULL,
977 SDB_DATA_NULL,
978 SDB_DATA_NULL,
979 SDB_DATA_NULL,
980 SDB_DATA_NULL,
981 SDB_DATA_NULL,
982 },
983 {
984 { SDB_TYPE_STRING, { .string = "a" } },
985 { SDB_TYPE_STRING, { .string = "b" } },
986 err,
987 err,
988 err,
989 err,
990 err,
991 { SDB_TYPE_STRING, { .string = "ab" } },
992 },
993 {
994 { SDB_TYPE_DATETIME, { .datetime = 47114711 } },
995 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
996 { SDB_TYPE_DATETIME, { .datetime = 47119422 } },
997 { SDB_TYPE_DATETIME, { .datetime = 47110000 } },
998 { SDB_TYPE_DATETIME, { .datetime = 221957403521 } },
999 { SDB_TYPE_DATETIME, { .datetime = 10001 } },
1000 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1001 err,
1002 },
1003 {
1004 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1005 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1006 SDB_DATA_NULL,
1007 SDB_DATA_NULL,
1008 SDB_DATA_NULL,
1009 SDB_DATA_NULL,
1010 SDB_DATA_NULL,
1011 SDB_DATA_NULL,
1012 },
1013 {
1014 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1015 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1016 SDB_DATA_NULL,
1017 SDB_DATA_NULL,
1018 SDB_DATA_NULL,
1019 SDB_DATA_NULL,
1020 SDB_DATA_NULL,
1021 SDB_DATA_NULL,
1022 },
1023 {
1024 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1025 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1026 SDB_DATA_NULL,
1027 SDB_DATA_NULL,
1028 SDB_DATA_NULL,
1029 SDB_DATA_NULL,
1030 SDB_DATA_NULL,
1031 SDB_DATA_NULL,
1032 },
1033 {
1034 {
1035 SDB_TYPE_BINARY,
1036 { .binary = { 3, (unsigned char *)"a\0a" } },
1037 },
1038 {
1039 SDB_TYPE_BINARY,
1040 { .binary = { 3, (unsigned char *)"b\0b" } },
1041 },
1042 err,
1043 err,
1044 err,
1045 err,
1046 err,
1047 {
1048 SDB_TYPE_BINARY,
1049 { .binary = { 6, (unsigned char *)"a\0ab\0b" } },
1050 },
1051 },
1052 {
1053 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1054 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1055 err,
1056 err,
1057 err,
1058 err,
1059 err,
1060 err,
1061 },
1062 {
1063 {
1064 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1065 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1066 },
1067 {
1068 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1069 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1070 },
1071 err,
1072 err,
1073 err,
1074 err,
1075 err,
1076 {
1077 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1078 { .array = {
1079 SDB_STATIC_ARRAY_LEN(expected_int_concat),
1080 expected_int_concat
1081 } },
1082 },
1083 },
1084 {
1085 {
1086 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1087 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1088 },
1089 { SDB_TYPE_INTEGER, { .integer = 42 }, },
1090 err,
1091 err,
1092 err,
1093 err,
1094 err,
1095 {
1096 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1097 { .array = {
1098 SDB_STATIC_ARRAY_LEN(expected_int_append),
1099 expected_int_append
1100 } },
1101 },
1102 },
1103 {
1104 { SDB_TYPE_INTEGER, { .integer = 42 }, },
1105 {
1106 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1107 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1108 },
1109 err,
1110 err,
1111 err,
1112 err,
1113 err,
1114 {
1115 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1116 { .array = {
1117 SDB_STATIC_ARRAY_LEN(expected_int_prepend),
1118 expected_int_prepend
1119 } },
1120 },
1121 },
1122 {
1123 {
1124 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1125 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1126 },
1127 {
1128 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1129 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1130 },
1131 err,
1132 err,
1133 err,
1134 err,
1135 err,
1136 {
1137 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1138 { .array = {
1139 SDB_STATIC_ARRAY_LEN(expected_string_concat),
1140 expected_string_concat
1141 } },
1142 },
1143 },
1144 {
1145 {
1146 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1147 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1148 },
1149 { SDB_TYPE_STRING, { .string = "bay" } },
1150 err,
1151 err,
1152 err,
1153 err,
1154 err,
1155 {
1156 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1157 { .array = {
1158 SDB_STATIC_ARRAY_LEN(expected_string_append),
1159 expected_string_append
1160 } },
1161 },
1162 },
1163 {
1164 { SDB_TYPE_STRING, { .string = "bay" } },
1165 {
1166 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1167 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1168 },
1169 err,
1170 err,
1171 err,
1172 err,
1173 err,
1174 {
1175 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1176 { .array = {
1177 SDB_STATIC_ARRAY_LEN(expected_string_prepend),
1178 expected_string_prepend
1179 } },
1180 },
1181 },
1182 {
1183 { SDB_TYPE_NULL, { .integer = 0 } },
1184 { SDB_TYPE_NULL, { .integer = 0 } },
1185 SDB_DATA_NULL,
1186 SDB_DATA_NULL,
1187 SDB_DATA_NULL,
1188 SDB_DATA_NULL,
1189 SDB_DATA_NULL,
1190 SDB_DATA_NULL,
1191 },
1192 {
1193 { SDB_TYPE_NULL, { .integer = 0 } },
1194 { SDB_TYPE_INTEGER, { .integer = 42 } },
1195 SDB_DATA_NULL,
1196 SDB_DATA_NULL,
1197 SDB_DATA_NULL,
1198 SDB_DATA_NULL,
1199 SDB_DATA_NULL,
1200 SDB_DATA_NULL,
1201 },
1202 {
1203 { SDB_TYPE_INTEGER, { .integer = 42 } },
1204 { SDB_TYPE_NULL, { .integer = 0 } },
1205 SDB_DATA_NULL,
1206 SDB_DATA_NULL,
1207 SDB_DATA_NULL,
1208 SDB_DATA_NULL,
1209 SDB_DATA_NULL,
1210 SDB_DATA_NULL,
1211 },
1212 {
1213 { SDB_TYPE_NULL, { .integer = 0 } },
1214 { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1215 SDB_DATA_NULL,
1216 SDB_DATA_NULL,
1217 SDB_DATA_NULL,
1218 SDB_DATA_NULL,
1219 SDB_DATA_NULL,
1220 SDB_DATA_NULL,
1221 },
1222 {
1223 { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1224 { SDB_TYPE_NULL, { .integer = 0 } },
1225 SDB_DATA_NULL,
1226 SDB_DATA_NULL,
1227 SDB_DATA_NULL,
1228 SDB_DATA_NULL,
1229 SDB_DATA_NULL,
1230 SDB_DATA_NULL,
1231 },
1232 {
1233 { SDB_TYPE_NULL, { .integer = 0 } },
1234 { SDB_TYPE_STRING, { .string = "47.11" } },
1235 SDB_DATA_NULL,
1236 SDB_DATA_NULL,
1237 SDB_DATA_NULL,
1238 SDB_DATA_NULL,
1239 SDB_DATA_NULL,
1240 SDB_DATA_NULL,
1241 },
1242 {
1243 { SDB_TYPE_STRING, { .string = "47.11" } },
1244 { SDB_TYPE_NULL, { .integer = 0 } },
1245 SDB_DATA_NULL,
1246 SDB_DATA_NULL,
1247 SDB_DATA_NULL,
1248 SDB_DATA_NULL,
1249 SDB_DATA_NULL,
1250 SDB_DATA_NULL,
1251 },
1252 {
1253 { SDB_TYPE_NULL, { .integer = 0 } },
1254 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1255 SDB_DATA_NULL,
1256 SDB_DATA_NULL,
1257 SDB_DATA_NULL,
1258 SDB_DATA_NULL,
1259 SDB_DATA_NULL,
1260 SDB_DATA_NULL,
1261 },
1262 {
1263 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1264 { SDB_TYPE_NULL, { .integer = 0 } },
1265 SDB_DATA_NULL,
1266 SDB_DATA_NULL,
1267 SDB_DATA_NULL,
1268 SDB_DATA_NULL,
1269 SDB_DATA_NULL,
1270 SDB_DATA_NULL,
1271 },
1272 {
1273 { SDB_TYPE_NULL, { .integer = 0 } },
1274 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1275 SDB_DATA_NULL,
1276 SDB_DATA_NULL,
1277 SDB_DATA_NULL,
1278 SDB_DATA_NULL,
1279 SDB_DATA_NULL,
1280 SDB_DATA_NULL,
1281 },
1282 {
1283 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1284 { SDB_TYPE_NULL, { .integer = 0 } },
1285 SDB_DATA_NULL,
1286 SDB_DATA_NULL,
1287 SDB_DATA_NULL,
1288 SDB_DATA_NULL,
1289 SDB_DATA_NULL,
1290 SDB_DATA_NULL,
1291 },
1292 {
1293 { SDB_TYPE_NULL, { .integer = 0 } },
1294 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1295 SDB_DATA_NULL,
1296 SDB_DATA_NULL,
1297 SDB_DATA_NULL,
1298 SDB_DATA_NULL,
1299 SDB_DATA_NULL,
1300 SDB_DATA_NULL,
1301 },
1302 {
1303 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1304 { SDB_TYPE_NULL, { .integer = 0 } },
1305 SDB_DATA_NULL,
1306 SDB_DATA_NULL,
1307 SDB_DATA_NULL,
1308 SDB_DATA_NULL,
1309 SDB_DATA_NULL,
1310 SDB_DATA_NULL,
1311 },
1312 /* supported type-mismatches */
1313 {
1314 /* int * datetime */
1315 { SDB_TYPE_INTEGER, { .integer = 20 } },
1316 { SDB_TYPE_DATETIME, { .datetime = 2 } },
1317 err,
1318 err,
1319 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1320 err,
1321 err,
1322 err,
1323 },
1324 {
1325 /* datetime * int, datetime / int, datetime % int */
1326 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1327 { SDB_TYPE_INTEGER, { .integer = 2 } },
1328 err,
1329 err,
1330 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1331 { SDB_TYPE_DATETIME, { .datetime = 10 } },
1332 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1333 err,
1334 },
1335 {
1336 /* float * datetime */
1337 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1338 { SDB_TYPE_DATETIME, { .datetime = 2 } },
1339 err,
1340 err,
1341 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1342 err,
1343 err,
1344 err,
1345 },
1346 {
1347 /* datetime * float, datetime / float, datetime % float */
1348 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1349 { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
1350 err,
1351 err,
1352 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1353 { SDB_TYPE_DATETIME, { .datetime = 10 } },
1354 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1355 err,
1356 },
1357 /* unsupported type-mismatches */
1358 {
1359 { SDB_TYPE_INTEGER, { .integer = 20 } },
1360 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1361 err, err, err, err, err, err,
1362 },
1363 {
1364 { SDB_TYPE_INTEGER, { .integer = 20 } },
1365 { SDB_TYPE_STRING, { .string = "20" } },
1366 err, err, err, err, err, err,
1367 },
1368 {
1369 { SDB_TYPE_INTEGER, { .integer = 20 } },
1370 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1371 err, err, err, err, err, err,
1372 },
1373 {
1374 { SDB_TYPE_INTEGER, { .integer = 20 } },
1375 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1376 err, err, err, err, err, err,
1377 },
1378 {
1379 { SDB_TYPE_INTEGER, { .integer = 20 } },
1380 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1381 err, err, err, err, err, err,
1382 },
1383 {
1384 { SDB_TYPE_INTEGER, { .integer = 20 } },
1385 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1386 err, err, err, err, err, err,
1387 },
1388 {
1389 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1390 { SDB_TYPE_INTEGER, { .integer = 20 } },
1391 err, err, err, err, err, err,
1392 },
1393 {
1394 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1395 { SDB_TYPE_STRING, { .string = "20.0" } },
1396 err, err, err, err, err, err,
1397 },
1398 {
1399 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1400 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1401 err, err, err, err, err, err,
1402 },
1403 {
1404 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1405 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1406 err, err, err, err, err, err,
1407 },
1408 {
1409 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1410 { SDB_TYPE_BINARY, { .binary = { 4, (unsigned char *)"20.0" } } },
1411 err, err, err, err, err, err,
1412 },
1413 {
1414 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1415 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1416 err, err, err, err, err, err,
1417 },
1418 {
1419 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1420 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1421 err, err, err, err, err, err,
1422 },
1423 {
1424 { SDB_TYPE_STRING, { .string = "20" } },
1425 { SDB_TYPE_INTEGER, { .integer = 20 } },
1426 err, err, err, err, err, err,
1427 },
1428 {
1429 { SDB_TYPE_STRING, { .string = "20" } },
1430 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1431 err, err, err, err, err, err,
1432 },
1433 {
1434 { SDB_TYPE_STRING, { .string = "20" } },
1435 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1436 err, err, err, err, err, err,
1437 },
1438 {
1439 { SDB_TYPE_STRING, { .string = "20" } },
1440 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1441 err, err, err, err, err, err,
1442 },
1443 {
1444 { SDB_TYPE_STRING, { .string = "20" } },
1445 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1446 err, err, err, err, err, err,
1447 },
1448 {
1449 { SDB_TYPE_STRING, { .string = "20" } },
1450 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1451 err, err, err, err, err, err,
1452 },
1453 {
1454 { SDB_TYPE_STRING, { .string = "20" } },
1455 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1456 err, err, err, err, err, err,
1457 },
1458 {
1459 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1460 { SDB_TYPE_STRING, { .string = "20" } },
1461 err, err, err, err, err, err,
1462 },
1463 {
1464 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1465 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1466 err, err, err, err, err, err,
1467 },
1468 {
1469 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1470 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1471 err, err, err, err, err, err,
1472 },
1473 {
1474 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1475 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1476 err, err, err, err, err, err,
1477 },
1478 {
1479 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1480 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1481 err, err, err, err, err, err,
1482 },
1483 {
1484 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1485 { SDB_TYPE_INTEGER, { .integer = 20 } },
1486 err, err, err, err, err, err,
1487 },
1488 {
1489 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1490 { SDB_TYPE_INTEGER, { .integer = 20 } },
1491 err, err, err, err, err, err,
1492 },
1493 {
1494 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1495 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1496 err, err, err, err, err, err,
1497 },
1498 {
1499 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1500 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1501 err, err, err, err, err, err,
1502 },
1503 {
1504 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1505 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1506 err, err, err, err, err, err,
1507 },
1508 {
1509 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1510 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1511 err, err, err, err, err, err,
1512 },
1513 {
1514 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1515 { SDB_TYPE_STRING, { .string = "20" } },
1516 err, err, err, err, err, err,
1517 },
1518 {
1519 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1520 { SDB_TYPE_STRING, { .string = "20" } },
1521 err, err, err, err, err, err,
1522 },
1523 {
1524 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1525 { SDB_TYPE_STRING, { .string = "20" } },
1526 err, err, err, err, err, err,
1527 },
1528 {
1529 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1530 { SDB_TYPE_STRING, { .string = "20" } },
1531 err, err, err, err, err, err,
1532 },
1533 {
1534 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1535 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1536 err, err, err, err, err, err,
1537 },
1538 {
1539 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1540 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1541 err, err, err, err, err, err,
1542 },
1543 {
1544 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1545 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1546 err, err, err, err, err, err,
1547 },
1548 {
1549 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1550 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1551 err, err, err, err, err, err,
1552 },
1553 {
1554 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1555 { SDB_TYPE_INTEGER, { .integer = 20 } },
1556 err, err, err, err, err, err,
1557 },
1558 {
1559 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1560 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1561 err, err, err, err, err, err,
1562 },
1563 {
1564 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1565 { SDB_TYPE_STRING, { .string = "20" } },
1566 err, err, err, err, err, err,
1567 },
1568 {
1569 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1570 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1571 err, err, err, err, err, err,
1572 },
1573 {
1574 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1575 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1576 err, err, err, err, err, err,
1577 },
1578 {
1579 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1580 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1581 err, err, err, err, err, err,
1582 },
1583 {
1584 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1585 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1586 err, err, err, err, err, err,
1587 },
1588 };
1590 size_t i;
1592 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1593 struct {
1594 int op;
1595 sdb_data_t expected;
1596 } tests[] = {
1597 { SDB_DATA_ADD, golden_data[i].expected_add },
1598 { SDB_DATA_SUB, golden_data[i].expected_sub },
1599 { SDB_DATA_MUL, golden_data[i].expected_mul },
1600 { SDB_DATA_DIV, golden_data[i].expected_div },
1601 { SDB_DATA_MOD, golden_data[i].expected_mod },
1602 { SDB_DATA_CONCAT, golden_data[i].expected_concat },
1603 };
1605 size_t j;
1606 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
1607 sdb_data_t res;
1608 int check;
1609 int type1, type2, type;
1611 char d1_str[64] = "", d2_str[64] = "";
1612 sdb_data_format(&golden_data[i].d1, d1_str, sizeof(d1_str),
1613 SDB_DOUBLE_QUOTED);
1614 sdb_data_format(&golden_data[i].d2, d2_str, sizeof(d2_str),
1615 SDB_DOUBLE_QUOTED);
1617 type1 = golden_data[i].d1.type;
1618 type2 = golden_data[i].d2.type;
1619 if (sdb_data_isnull(&golden_data[i].d1))
1620 type1 = SDB_TYPE_NULL;
1621 if (sdb_data_isnull(&golden_data[i].d2))
1622 type2 = SDB_TYPE_NULL;
1623 type = sdb_data_expr_type(tests[j].op, type1, type2);
1625 check = sdb_data_expr_eval(tests[j].op,
1626 &golden_data[i].d1, &golden_data[i].d2, &res);
1627 fail_unless((check == 0) == (tests[j].expected.type != -1),
1628 "sdb_data_expr_eval(%s, %s, %s) = %d; expected: %d",
1629 SDB_DATA_OP_TO_STRING(tests[j].op), d1_str, d2_str, check,
1630 tests[j].expected.type == -1 ? -1 : 0);
1632 fail_unless(tests[j].expected.type == type,
1633 "sdb_data_expr_eval(%s, %s, %s) expected to evaluate "
1634 "to type %d while sdb_data_expr_type(%d, %d, %d) "
1635 "predicted type %d", SDB_DATA_OP_TO_STRING(tests[j].op),
1636 d1_str, d2_str, tests[j].expected.type,
1637 tests[j].op, golden_data[i].d1.type,
1638 golden_data[i].d2.type, type);
1640 if (tests[j].expected.type == -1)
1641 continue;
1643 if (tests[j].expected.type == SDB_TYPE_NULL) {
1644 fail_unless(res.type == SDB_TYPE_NULL,
1645 "sdb_data_expr_eval(%s, %s, %s) evaluated to "
1646 "type %d; expected: SDB_TYPE_NULL",
1647 SDB_DATA_OP_TO_STRING(tests[j].op),
1648 d1_str, d2_str, res.type);
1649 continue;
1650 }
1652 check = sdb_data_cmp(&res, &tests[j].expected);
1653 if (check != 0) {
1654 char res_str[64] = "", expected_str[64] = "";
1655 sdb_data_format(&res, res_str, sizeof(res_str),
1656 SDB_DOUBLE_QUOTED);
1657 sdb_data_format(&tests[j].expected, expected_str,
1658 sizeof(expected_str), SDB_DOUBLE_QUOTED);
1659 fail("sdb_data_expr_eval(%s, %s, %s) evaluated to %s "
1660 "(type %d); expected: %s (type %d)",
1661 SDB_DATA_OP_TO_STRING(tests[j].op),
1662 d1_str, d2_str, res_str, res.type,
1663 expected_str, tests[j].expected.type);
1664 }
1666 sdb_data_free_datum(&res);
1667 }
1668 }
1669 }
1670 END_TEST
1672 START_TEST(test_format)
1673 {
1674 int64_t int_values[] = { 47, 11, 23 };
1675 char *string_values[] = { "foo", "bar", "qux", "baz" };
1677 struct {
1678 sdb_data_t datum;
1679 const char *expected;
1680 } golden_data[] = {
1681 {
1682 { SDB_TYPE_INTEGER, { .integer = 4711 } },
1683 "4711",
1684 },
1685 {
1686 { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
1687 "65536",
1688 },
1689 {
1690 { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
1691 "12.3",
1692 },
1693 {
1694 { SDB_TYPE_STRING, { .string = NULL } },
1695 "NULL",
1696 },
1697 {
1698 { SDB_TYPE_STRING, { .string = "this is a test" } },
1699 "\"this is a test\"",
1700 },
1701 {
1702 { SDB_TYPE_STRING, { .string = "special \\ \" characters" } },
1703 "\"special \\\\ \\\" characters\"",
1704 },
1705 {
1706 { SDB_TYPE_DATETIME, { .datetime= 471147114711471100 } },
1707 "\"1984-12-06 02:11:54 +0000\"",
1708 },
1709 {
1710 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1711 "NULL",
1712 },
1713 {
1714 {
1715 SDB_TYPE_BINARY,
1716 { .binary = { 12, (unsigned char *)"binary\0crap\x42" } },
1717 },
1718 "\"\\x62\\x69\\x6e\\x61\\x72\\x79\\x0\\x63\\x72\\x61\\x70\\x42\"",
1719 },
1720 {
1721 { SDB_TYPE_REGEX, { .re = { "some regex", empty_re } } },
1722 "\"/some regex/\"",
1723 },
1724 {
1725 {
1726 SDB_TYPE_INTEGER | SDB_TYPE_ARRAY,
1727 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1728 },
1729 "[47, 11, 23]",
1730 },
1731 {
1732 {
1733 SDB_TYPE_STRING | SDB_TYPE_ARRAY,
1734 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1735 },
1736 "[\"foo\", \"bar\", \"qux\", \"baz\"]",
1737 },
1738 };
1740 size_t i;
1742 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1743 sdb_data_t *datum = &golden_data[i].datum;
1744 char buf[sdb_data_strlen(datum) + 2];
1745 int check;
1747 memset(buf, (int)'A', sizeof(buf));
1749 check = sdb_data_format(datum, buf, sizeof(buf) - 1,
1750 SDB_DOUBLE_QUOTED);
1751 fail_unless(check > 0,
1752 "sdb_data_format(type=%s) = %d; expected: >0",
1753 SDB_TYPE_TO_STRING(datum->type), check);
1754 fail_unless(! strcmp(buf, golden_data[i].expected),
1755 "sdb_data_format(type=%s) used wrong format: %s; expected: %s",
1756 SDB_TYPE_TO_STRING(datum->type), buf, golden_data[i].expected);
1758 fail_unless((size_t)check <= sizeof(buf) - 2,
1759 "sdb_data_format(type=%s) wrote %d bytes; "
1760 "expected <= %zu based on sdb_data_strlen()",
1761 SDB_TYPE_TO_STRING(datum->type), check, sizeof(buf) - 2);
1763 fail_unless(buf[sizeof(buf) - 2] == '\0',
1764 "sdb_data_format(type=%s) did not nul-terminate the buffer",
1765 SDB_TYPE_TO_STRING(datum->type));
1766 fail_unless(buf[sizeof(buf) - 1] == 'A',
1767 "sdb_data_format(type=%s) wrote past the end of the buffer",
1768 SDB_TYPE_TO_STRING(datum->type));
1769 }
1770 }
1771 END_TEST
1773 START_TEST(test_parse)
1774 {
1775 struct {
1776 char *input;
1777 sdb_data_t result;
1778 int expected;
1779 } golden_data[] = {
1780 { "4711", { SDB_TYPE_INTEGER, { .integer = 4711 } }, 0 },
1781 { "0x10", { SDB_TYPE_INTEGER, { .integer = 16 } }, 0 },
1782 { "010", { SDB_TYPE_INTEGER, { .integer = 8 } }, 0 },
1783 { "abc", { SDB_TYPE_INTEGER, { .integer = 0 } }, -1 },
1784 { "1.2", { SDB_TYPE_DECIMAL, { .decimal = 1.2 } }, 0 },
1785 { "0x1p+16", { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } }, 0 },
1786 { "abc", { SDB_TYPE_DECIMAL, { .decimal = 0.0 } }, -1 },
1787 { "abc", { SDB_TYPE_STRING, { .string = "abc" } }, 0 },
1788 { ".4", { SDB_TYPE_DATETIME, { .datetime = 400000000 } }, 0 },
1789 { "abc", { SDB_TYPE_DATETIME, { .datetime = 0 } }, -1 },
1790 { "abc", { SDB_TYPE_BINARY,
1791 { .binary = { 3, (unsigned char *)"abc" } } }, 0 },
1792 { "abc", { SDB_TYPE_REGEX, { .re = { "abc", empty_re } } }, 0 },
1793 { "(|", { SDB_TYPE_REGEX, { .re = { "", empty_re } } }, -1 },
1794 };
1796 size_t i;
1798 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1799 sdb_data_t result;
1800 int type, check;
1802 memset(&result, 0, sizeof(result));
1803 type = golden_data[i].result.type;
1804 check = sdb_data_parse(golden_data[i].input, type, &result);
1805 fail_unless(check == golden_data[i].expected,
1806 "sdb_data_parse(%s, %d, <d>) = %d; expected: %d",
1807 golden_data[i].input, type, check, golden_data[i].expected);
1809 if (check)
1810 continue;
1812 fail_unless(sdb_data_cmp(&result, &golden_data[i].result) == 0,
1813 "sdb_data_parse(%s, %d, <d>) did not create expected result",
1814 golden_data[i].input, type);
1816 if (type == SDB_TYPE_STRING)
1817 fail_unless(golden_data[i].input == result.data.string,
1818 "sdb_data_parse(%s, %d, <d>) modified input string",
1819 golden_data[i].input, type);
1820 if (type == SDB_TYPE_BINARY)
1821 fail_unless(golden_data[i].input == (char *)result.data.binary.datum,
1822 "sdb_data_parse(%s, %d, <d>) modified input string",
1823 golden_data[i].input, type);
1824 if (type == SDB_TYPE_REGEX) {
1825 fail_unless(golden_data[i].input != result.data.re.raw,
1826 "sdb_data_parse(%s, %d, <d>) copied input string",
1827 golden_data[i].input, type);
1828 sdb_data_free_datum(&result);
1829 }
1830 }
1831 }
1832 END_TEST
1834 Suite *
1835 core_data_suite(void)
1836 {
1837 Suite *s = suite_create("core::data");
1838 TCase *tc;
1840 tc = tcase_create("core");
1841 tcase_add_test(tc, test_data);
1842 tcase_add_test(tc, test_cmp);
1843 tcase_add_test(tc, test_strcmp);
1844 tcase_add_test(tc, test_inarray);
1845 tcase_add_test(tc, test_array_get);
1846 tcase_add_test(tc, test_parse_op);
1847 tcase_add_test(tc, test_expr_eval);
1848 tcase_add_test(tc, test_format);
1849 tcase_add_test(tc, test_parse);
1850 suite_add_tcase(s, tc);
1852 return s;
1853 } /* core_data_suite */
1855 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */