![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
704ebdd48b43ae58cf38b62c8d18fb4c0e1b781c
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_concat[] = { 47, 11, 23, 47, 11, 23 };
915 char *string_values[] = { "foo", "bar", "qux" "baz" };
916 char *expected_string_concat[] =
917 { "foo", "bar", "qux" "baz", "foo", "bar", "qux" "baz" };
919 struct {
920 sdb_data_t d1;
921 sdb_data_t d2;
922 sdb_data_t expected_add;
923 sdb_data_t expected_sub;
924 sdb_data_t expected_mul;
925 sdb_data_t expected_div;
926 sdb_data_t expected_mod;
927 sdb_data_t expected_concat;
928 } golden_data[] = {
929 {
930 { SDB_TYPE_INTEGER, { .integer = 4711 } },
931 { SDB_TYPE_INTEGER, { .integer = 47 } },
932 { SDB_TYPE_INTEGER, { .integer = 4758 } },
933 { SDB_TYPE_INTEGER, { .integer = 4664 } },
934 { SDB_TYPE_INTEGER, { .integer = 221417 } },
935 { SDB_TYPE_INTEGER, { .integer = 100 } },
936 { SDB_TYPE_INTEGER, { .integer = 11 } },
937 err,
938 },
939 {
940 { SDB_TYPE_DECIMAL, { .decimal = 35.0 } },
941 { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
942 { SDB_TYPE_DECIMAL, { .decimal = 52.5 } },
943 { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
944 { SDB_TYPE_DECIMAL, { .decimal = 612.5 } },
945 { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
946 { SDB_TYPE_DECIMAL, { .decimal = 0.0 } },
947 err,
948 },
949 {
950 { SDB_TYPE_STRING, { .string = NULL } },
951 { SDB_TYPE_STRING, { .string = "" } },
952 SDB_DATA_NULL,
953 SDB_DATA_NULL,
954 SDB_DATA_NULL,
955 SDB_DATA_NULL,
956 SDB_DATA_NULL,
957 SDB_DATA_NULL,
958 },
959 {
960 { SDB_TYPE_STRING, { .string = NULL } },
961 { SDB_TYPE_STRING, { .string = NULL } },
962 SDB_DATA_NULL,
963 SDB_DATA_NULL,
964 SDB_DATA_NULL,
965 SDB_DATA_NULL,
966 SDB_DATA_NULL,
967 SDB_DATA_NULL,
968 },
969 {
970 { SDB_TYPE_STRING, { .string = "" } },
971 { SDB_TYPE_STRING, { .string = NULL } },
972 SDB_DATA_NULL,
973 SDB_DATA_NULL,
974 SDB_DATA_NULL,
975 SDB_DATA_NULL,
976 SDB_DATA_NULL,
977 SDB_DATA_NULL,
978 },
979 {
980 { SDB_TYPE_STRING, { .string = "a" } },
981 { SDB_TYPE_STRING, { .string = "b" } },
982 err,
983 err,
984 err,
985 err,
986 err,
987 { SDB_TYPE_STRING, { .string = "ab" } },
988 },
989 {
990 { SDB_TYPE_DATETIME, { .datetime = 47114711 } },
991 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
992 { SDB_TYPE_DATETIME, { .datetime = 47119422 } },
993 { SDB_TYPE_DATETIME, { .datetime = 47110000 } },
994 { SDB_TYPE_DATETIME, { .datetime = 221957403521 } },
995 { SDB_TYPE_DATETIME, { .datetime = 10001 } },
996 { SDB_TYPE_DATETIME, { .datetime = 0 } },
997 err,
998 },
999 {
1000 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1001 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1002 SDB_DATA_NULL,
1003 SDB_DATA_NULL,
1004 SDB_DATA_NULL,
1005 SDB_DATA_NULL,
1006 SDB_DATA_NULL,
1007 SDB_DATA_NULL,
1008 },
1009 {
1010 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1011 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1012 SDB_DATA_NULL,
1013 SDB_DATA_NULL,
1014 SDB_DATA_NULL,
1015 SDB_DATA_NULL,
1016 SDB_DATA_NULL,
1017 SDB_DATA_NULL,
1018 },
1019 {
1020 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1021 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1022 SDB_DATA_NULL,
1023 SDB_DATA_NULL,
1024 SDB_DATA_NULL,
1025 SDB_DATA_NULL,
1026 SDB_DATA_NULL,
1027 SDB_DATA_NULL,
1028 },
1029 {
1030 {
1031 SDB_TYPE_BINARY,
1032 { .binary = { 3, (unsigned char *)"a\0a" } },
1033 },
1034 {
1035 SDB_TYPE_BINARY,
1036 { .binary = { 3, (unsigned char *)"b\0b" } },
1037 },
1038 err,
1039 err,
1040 err,
1041 err,
1042 err,
1043 {
1044 SDB_TYPE_BINARY,
1045 { .binary = { 6, (unsigned char *)"a\0ab\0b" } },
1046 },
1047 },
1048 {
1049 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1050 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1051 err,
1052 err,
1053 err,
1054 err,
1055 err,
1056 err,
1057 },
1058 {
1059 {
1060 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1061 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1062 },
1063 {
1064 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1065 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
1066 },
1067 err,
1068 err,
1069 err,
1070 err,
1071 err,
1072 {
1073 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
1074 { .array = {
1075 SDB_STATIC_ARRAY_LEN(expected_int_concat),
1076 expected_int_concat
1077 } },
1078 },
1079 },
1080 {
1081 {
1082 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1083 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1084 },
1085 {
1086 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1087 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1088 },
1089 err,
1090 err,
1091 err,
1092 err,
1093 err,
1094 {
1095 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1096 { .array = {
1097 SDB_STATIC_ARRAY_LEN(expected_string_concat),
1098 expected_string_concat
1099 } },
1100 },
1101 },
1102 {
1103 { SDB_TYPE_NULL, { .integer = 0 } },
1104 { SDB_TYPE_NULL, { .integer = 0 } },
1105 SDB_DATA_NULL,
1106 SDB_DATA_NULL,
1107 SDB_DATA_NULL,
1108 SDB_DATA_NULL,
1109 SDB_DATA_NULL,
1110 SDB_DATA_NULL,
1111 },
1112 {
1113 { SDB_TYPE_NULL, { .integer = 0 } },
1114 { SDB_TYPE_INTEGER, { .integer = 42 } },
1115 SDB_DATA_NULL,
1116 SDB_DATA_NULL,
1117 SDB_DATA_NULL,
1118 SDB_DATA_NULL,
1119 SDB_DATA_NULL,
1120 SDB_DATA_NULL,
1121 },
1122 {
1123 { SDB_TYPE_INTEGER, { .integer = 42 } },
1124 { SDB_TYPE_NULL, { .integer = 0 } },
1125 SDB_DATA_NULL,
1126 SDB_DATA_NULL,
1127 SDB_DATA_NULL,
1128 SDB_DATA_NULL,
1129 SDB_DATA_NULL,
1130 SDB_DATA_NULL,
1131 },
1132 {
1133 { SDB_TYPE_NULL, { .integer = 0 } },
1134 { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1135 SDB_DATA_NULL,
1136 SDB_DATA_NULL,
1137 SDB_DATA_NULL,
1138 SDB_DATA_NULL,
1139 SDB_DATA_NULL,
1140 SDB_DATA_NULL,
1141 },
1142 {
1143 { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1144 { SDB_TYPE_NULL, { .integer = 0 } },
1145 SDB_DATA_NULL,
1146 SDB_DATA_NULL,
1147 SDB_DATA_NULL,
1148 SDB_DATA_NULL,
1149 SDB_DATA_NULL,
1150 SDB_DATA_NULL,
1151 },
1152 {
1153 { SDB_TYPE_NULL, { .integer = 0 } },
1154 { SDB_TYPE_STRING, { .string = "47.11" } },
1155 SDB_DATA_NULL,
1156 SDB_DATA_NULL,
1157 SDB_DATA_NULL,
1158 SDB_DATA_NULL,
1159 SDB_DATA_NULL,
1160 SDB_DATA_NULL,
1161 },
1162 {
1163 { SDB_TYPE_STRING, { .string = "47.11" } },
1164 { SDB_TYPE_NULL, { .integer = 0 } },
1165 SDB_DATA_NULL,
1166 SDB_DATA_NULL,
1167 SDB_DATA_NULL,
1168 SDB_DATA_NULL,
1169 SDB_DATA_NULL,
1170 SDB_DATA_NULL,
1171 },
1172 {
1173 { SDB_TYPE_NULL, { .integer = 0 } },
1174 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1175 SDB_DATA_NULL,
1176 SDB_DATA_NULL,
1177 SDB_DATA_NULL,
1178 SDB_DATA_NULL,
1179 SDB_DATA_NULL,
1180 SDB_DATA_NULL,
1181 },
1182 {
1183 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
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_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
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_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
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_REGEX, { .re = { ".", empty_re } } },
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_REGEX, { .re = { ".", empty_re } } },
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 /* supported type-mismatches */
1233 {
1234 /* int * datetime */
1235 { SDB_TYPE_INTEGER, { .integer = 20 } },
1236 { SDB_TYPE_DATETIME, { .datetime = 2 } },
1237 err,
1238 err,
1239 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1240 err,
1241 err,
1242 err,
1243 },
1244 {
1245 /* datetime * int, datetime / int, datetime % int */
1246 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1247 { SDB_TYPE_INTEGER, { .integer = 2 } },
1248 err,
1249 err,
1250 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1251 { SDB_TYPE_DATETIME, { .datetime = 10 } },
1252 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1253 err,
1254 },
1255 {
1256 /* float * datetime */
1257 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1258 { SDB_TYPE_DATETIME, { .datetime = 2 } },
1259 err,
1260 err,
1261 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1262 err,
1263 err,
1264 err,
1265 },
1266 {
1267 /* datetime * float, datetime / float, datetime % float */
1268 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1269 { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
1270 err,
1271 err,
1272 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1273 { SDB_TYPE_DATETIME, { .datetime = 10 } },
1274 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1275 err,
1276 },
1277 /* unsupported type-mismatches */
1278 {
1279 { SDB_TYPE_INTEGER, { .integer = 20 } },
1280 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1281 err, err, err, err, err, err,
1282 },
1283 {
1284 { SDB_TYPE_INTEGER, { .integer = 20 } },
1285 { SDB_TYPE_STRING, { .string = "20" } },
1286 err, err, err, err, err, err,
1287 },
1288 {
1289 { SDB_TYPE_INTEGER, { .integer = 20 } },
1290 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1291 err, err, err, err, err, err,
1292 },
1293 {
1294 { SDB_TYPE_INTEGER, { .integer = 20 } },
1295 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1296 err, err, err, err, err, err,
1297 },
1298 {
1299 { SDB_TYPE_INTEGER, { .integer = 20 } },
1300 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1301 err, err, err, err, err, err,
1302 },
1303 {
1304 { SDB_TYPE_INTEGER, { .integer = 20 } },
1305 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1306 err, err, err, err, err, err,
1307 },
1308 {
1309 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1310 { SDB_TYPE_INTEGER, { .integer = 20 } },
1311 err, err, err, err, err, err,
1312 },
1313 {
1314 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1315 { SDB_TYPE_STRING, { .string = "20.0" } },
1316 err, err, err, err, err, err,
1317 },
1318 {
1319 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1320 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1321 err, err, err, err, err, err,
1322 },
1323 {
1324 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1325 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1326 err, err, err, err, err, err,
1327 },
1328 {
1329 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1330 { SDB_TYPE_BINARY, { .binary = { 4, (unsigned char *)"20.0" } } },
1331 err, err, err, err, err, err,
1332 },
1333 {
1334 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1335 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1336 err, err, err, err, err, err,
1337 },
1338 {
1339 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1340 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1341 err, err, err, err, err, err,
1342 },
1343 {
1344 { SDB_TYPE_STRING, { .string = "20" } },
1345 { SDB_TYPE_INTEGER, { .integer = 20 } },
1346 err, err, err, err, err, err,
1347 },
1348 {
1349 { SDB_TYPE_STRING, { .string = "20" } },
1350 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1351 err, err, err, err, err, err,
1352 },
1353 {
1354 { SDB_TYPE_STRING, { .string = "20" } },
1355 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1356 err, err, err, err, err, err,
1357 },
1358 {
1359 { SDB_TYPE_STRING, { .string = "20" } },
1360 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1361 err, err, err, err, err, err,
1362 },
1363 {
1364 { SDB_TYPE_STRING, { .string = "20" } },
1365 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1366 err, err, err, err, err, err,
1367 },
1368 {
1369 { SDB_TYPE_STRING, { .string = "20" } },
1370 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1371 err, err, err, err, err, err,
1372 },
1373 {
1374 { SDB_TYPE_STRING, { .string = "20" } },
1375 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1376 err, err, err, err, err, err,
1377 },
1378 {
1379 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1380 { SDB_TYPE_STRING, { .string = "20" } },
1381 err, err, err, err, err, err,
1382 },
1383 {
1384 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1385 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1386 err, err, err, err, err, err,
1387 },
1388 {
1389 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1390 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1391 err, err, err, err, err, err,
1392 },
1393 {
1394 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1395 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1396 err, err, err, err, err, err,
1397 },
1398 {
1399 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1400 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1401 err, err, err, err, err, err,
1402 },
1403 {
1404 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1405 { SDB_TYPE_INTEGER, { .integer = 20 } },
1406 err, err, err, err, err, err,
1407 },
1408 {
1409 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1410 { SDB_TYPE_INTEGER, { .integer = 20 } },
1411 err, err, err, err, err, err,
1412 },
1413 {
1414 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1415 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1416 err, err, err, err, err, err,
1417 },
1418 {
1419 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1420 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1421 err, err, err, err, err, err,
1422 },
1423 {
1424 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1425 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1426 err, err, err, err, err, err,
1427 },
1428 {
1429 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1430 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1431 err, err, err, err, err, err,
1432 },
1433 {
1434 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1435 { SDB_TYPE_STRING, { .string = "20" } },
1436 err, err, err, err, err, err,
1437 },
1438 {
1439 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1440 { SDB_TYPE_STRING, { .string = "20" } },
1441 err, err, err, err, err, err,
1442 },
1443 {
1444 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1445 { SDB_TYPE_STRING, { .string = "20" } },
1446 err, err, err, err, err, err,
1447 },
1448 {
1449 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1450 { SDB_TYPE_STRING, { .string = "20" } },
1451 err, err, err, err, err, err,
1452 },
1453 {
1454 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1455 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1456 err, err, err, err, err, err,
1457 },
1458 {
1459 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1460 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1461 err, err, err, err, err, err,
1462 },
1463 {
1464 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1465 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1466 err, err, err, err, err, err,
1467 },
1468 {
1469 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1470 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1471 err, err, err, err, err, err,
1472 },
1473 {
1474 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1475 { SDB_TYPE_INTEGER, { .integer = 20 } },
1476 err, err, err, err, err, err,
1477 },
1478 {
1479 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1480 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1481 err, err, err, err, err, err,
1482 },
1483 {
1484 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1485 { SDB_TYPE_STRING, { .string = "20" } },
1486 err, err, err, err, err, err,
1487 },
1488 {
1489 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1490 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1491 err, err, err, err, err, err,
1492 },
1493 {
1494 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1495 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1496 err, err, err, err, err, err,
1497 },
1498 {
1499 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1500 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1501 err, err, err, err, err, err,
1502 },
1503 {
1504 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1505 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1506 err, err, err, err, err, err,
1507 },
1508 };
1510 size_t i;
1512 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1513 struct {
1514 int op;
1515 sdb_data_t expected;
1516 } tests[] = {
1517 { SDB_DATA_ADD, golden_data[i].expected_add },
1518 { SDB_DATA_SUB, golden_data[i].expected_sub },
1519 { SDB_DATA_MUL, golden_data[i].expected_mul },
1520 { SDB_DATA_DIV, golden_data[i].expected_div },
1521 { SDB_DATA_MOD, golden_data[i].expected_mod },
1522 { SDB_DATA_CONCAT, golden_data[i].expected_concat },
1523 };
1525 size_t j;
1526 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
1527 sdb_data_t res;
1528 int check;
1529 int type1, type2, type;
1531 char d1_str[64] = "", d2_str[64] = "";
1532 sdb_data_format(&golden_data[i].d1, d1_str, sizeof(d1_str),
1533 SDB_DOUBLE_QUOTED);
1534 sdb_data_format(&golden_data[i].d2, d2_str, sizeof(d2_str),
1535 SDB_DOUBLE_QUOTED);
1537 type1 = golden_data[i].d1.type;
1538 type2 = golden_data[i].d2.type;
1539 if (sdb_data_isnull(&golden_data[i].d1))
1540 type1 = SDB_TYPE_NULL;
1541 if (sdb_data_isnull(&golden_data[i].d2))
1542 type2 = SDB_TYPE_NULL;
1543 type = sdb_data_expr_type(tests[j].op, type1, type2);
1545 check = sdb_data_expr_eval(tests[j].op,
1546 &golden_data[i].d1, &golden_data[i].d2, &res);
1547 fail_unless((check == 0) == (tests[j].expected.type != -1),
1548 "sdb_data_expr_eval(%s, %s, %s) = %d; expected: %d",
1549 SDB_DATA_OP_TO_STRING(tests[j].op), d1_str, d2_str, check,
1550 tests[j].expected.type == -1 ? -1 : 0);
1552 fail_unless(tests[j].expected.type == type,
1553 "sdb_data_expr_eval(%s, %s, %s) expected to evaluate "
1554 "to type %d while sdb_data_expr_type(%d, %d, %d) "
1555 "predicted type %d", SDB_DATA_OP_TO_STRING(tests[j].op),
1556 d1_str, d2_str, tests[j].expected.type,
1557 tests[j].op, golden_data[i].d1.type,
1558 golden_data[i].d2.type, type);
1560 if (tests[j].expected.type == -1)
1561 continue;
1563 if (tests[j].expected.type == SDB_TYPE_NULL) {
1564 fail_unless(res.type == SDB_TYPE_NULL,
1565 "sdb_data_expr_eval(%s, %s, %s) evaluated to "
1566 "type %d; expected: SDB_TYPE_NULL",
1567 SDB_DATA_OP_TO_STRING(tests[j].op),
1568 d1_str, d2_str, res.type);
1569 continue;
1570 }
1572 check = sdb_data_cmp(&res, &tests[j].expected);
1573 if (check != 0) {
1574 char res_str[64] = "", expected_str[64] = "";
1575 sdb_data_format(&res, res_str, sizeof(res_str),
1576 SDB_DOUBLE_QUOTED);
1577 sdb_data_format(&tests[j].expected, expected_str,
1578 sizeof(expected_str), SDB_DOUBLE_QUOTED);
1579 fail("sdb_data_expr_eval(%s, %s, %s) evaluated to %s "
1580 "(type %d); expected: %s (type %d)",
1581 SDB_DATA_OP_TO_STRING(tests[j].op),
1582 d1_str, d2_str, res_str, res.type,
1583 expected_str, tests[j].expected.type);
1584 }
1586 sdb_data_free_datum(&res);
1587 }
1588 }
1589 }
1590 END_TEST
1592 START_TEST(test_format)
1593 {
1594 struct {
1595 sdb_data_t datum;
1596 const char *expected;
1597 } golden_data[] = {
1598 {
1599 { SDB_TYPE_INTEGER, { .integer = 4711 } },
1600 "4711",
1601 },
1602 {
1603 { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
1604 "65536",
1605 },
1606 {
1607 { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
1608 "12.3",
1609 },
1610 {
1611 { SDB_TYPE_STRING, { .string = NULL } },
1612 "NULL",
1613 },
1614 {
1615 { SDB_TYPE_STRING, { .string = "this is a test" } },
1616 "\"this is a test\"",
1617 },
1618 {
1619 { SDB_TYPE_STRING, { .string = "special \\ \" characters" } },
1620 "\"special \\\\ \\\" characters\"",
1621 },
1622 {
1623 { SDB_TYPE_DATETIME, { .datetime= 471147114711471100 } },
1624 "\"1984-12-06 02:11:54 +0000\"",
1625 },
1626 {
1627 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1628 "NULL",
1629 },
1630 {
1631 {
1632 SDB_TYPE_BINARY,
1633 { .binary = { 12, (unsigned char *)"binary\0crap\x42" } },
1634 },
1635 "\"\\x62\\x69\\x6e\\x61\\x72\\x79\\x0\\x63\\x72\\x61\\x70\\x42\"",
1636 },
1637 {
1638 { SDB_TYPE_REGEX, { .re = { "some regex", empty_re } } },
1639 "\"/some regex/\"",
1640 },
1641 };
1643 size_t i;
1645 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1646 sdb_data_t *datum = &golden_data[i].datum;
1647 char buf[sdb_data_strlen(datum) + 2];
1648 int check;
1650 memset(buf, (int)'A', sizeof(buf));
1652 check = sdb_data_format(datum, buf, sizeof(buf) - 1,
1653 SDB_DOUBLE_QUOTED);
1654 fail_unless(check > 0,
1655 "sdb_data_format(type=%s) = %d; expected: >0",
1656 SDB_TYPE_TO_STRING(datum->type), check);
1657 fail_unless(! strcmp(buf, golden_data[i].expected),
1658 "sdb_data_format(type=%s) used wrong format: %s; expected: %s",
1659 SDB_TYPE_TO_STRING(datum->type), buf, golden_data[i].expected);
1661 fail_unless((size_t)check <= sizeof(buf) - 2,
1662 "sdb_data_format(type=%s) wrote %d bytes; "
1663 "expected <= %zu based on sdb_data_strlen()",
1664 SDB_TYPE_TO_STRING(datum->type), check, sizeof(buf) - 2);
1666 fail_unless(buf[sizeof(buf) - 2] == '\0',
1667 "sdb_data_format(type=%s) did not nul-terminate the buffer",
1668 SDB_TYPE_TO_STRING(datum->type));
1669 fail_unless(buf[sizeof(buf) - 1] == 'A',
1670 "sdb_data_format(type=%s) wrote past the end of the buffer",
1671 SDB_TYPE_TO_STRING(datum->type));
1672 }
1673 }
1674 END_TEST
1676 START_TEST(test_parse)
1677 {
1678 struct {
1679 char *input;
1680 sdb_data_t result;
1681 int expected;
1682 } golden_data[] = {
1683 { "4711", { SDB_TYPE_INTEGER, { .integer = 4711 } }, 0 },
1684 { "0x10", { SDB_TYPE_INTEGER, { .integer = 16 } }, 0 },
1685 { "010", { SDB_TYPE_INTEGER, { .integer = 8 } }, 0 },
1686 { "abc", { SDB_TYPE_INTEGER, { .integer = 0 } }, -1 },
1687 { "1.2", { SDB_TYPE_DECIMAL, { .decimal = 1.2 } }, 0 },
1688 { "0x1p+16", { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } }, 0 },
1689 { "abc", { SDB_TYPE_DECIMAL, { .decimal = 0.0 } }, -1 },
1690 { "abc", { SDB_TYPE_STRING, { .string = "abc" } }, 0 },
1691 { ".4", { SDB_TYPE_DATETIME, { .datetime = 400000000 } }, 0 },
1692 { "abc", { SDB_TYPE_DATETIME, { .datetime = 0 } }, -1 },
1693 { "abc", { SDB_TYPE_BINARY,
1694 { .binary = { 3, (unsigned char *)"abc" } } }, 0 },
1695 { "abc", { SDB_TYPE_REGEX, { .re = { "abc", empty_re } } }, 0 },
1696 { "(|", { SDB_TYPE_REGEX, { .re = { "", empty_re } } }, -1 },
1697 };
1699 size_t i;
1701 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1702 sdb_data_t result;
1703 int type, check;
1705 memset(&result, 0, sizeof(result));
1706 type = golden_data[i].result.type;
1707 check = sdb_data_parse(golden_data[i].input, type, &result);
1708 fail_unless(check == golden_data[i].expected,
1709 "sdb_data_parse(%s, %d, <d>) = %d; expected: %d",
1710 golden_data[i].input, type, check, golden_data[i].expected);
1712 if (check)
1713 continue;
1715 fail_unless(sdb_data_cmp(&result, &golden_data[i].result) == 0,
1716 "sdb_data_parse(%s, %d, <d>) did not create expected result",
1717 golden_data[i].input, type);
1719 if (type == SDB_TYPE_STRING)
1720 fail_unless(golden_data[i].input == result.data.string,
1721 "sdb_data_parse(%s, %d, <d>) modified input string",
1722 golden_data[i].input, type);
1723 if (type == SDB_TYPE_BINARY)
1724 fail_unless(golden_data[i].input == (char *)result.data.binary.datum,
1725 "sdb_data_parse(%s, %d, <d>) modified input string",
1726 golden_data[i].input, type);
1727 if (type == SDB_TYPE_REGEX) {
1728 fail_unless(golden_data[i].input != result.data.re.raw,
1729 "sdb_data_parse(%s, %d, <d>) copied input string",
1730 golden_data[i].input, type);
1731 sdb_data_free_datum(&result);
1732 }
1733 }
1734 }
1735 END_TEST
1737 Suite *
1738 core_data_suite(void)
1739 {
1740 Suite *s = suite_create("core::data");
1741 TCase *tc;
1743 tc = tcase_create("core");
1744 tcase_add_test(tc, test_data);
1745 tcase_add_test(tc, test_cmp);
1746 tcase_add_test(tc, test_strcmp);
1747 tcase_add_test(tc, test_inarray);
1748 tcase_add_test(tc, test_array_get);
1749 tcase_add_test(tc, test_parse_op);
1750 tcase_add_test(tc, test_expr_eval);
1751 tcase_add_test(tc, test_format);
1752 tcase_add_test(tc, test_parse);
1753 suite_add_tcase(s, tc);
1755 return s;
1756 } /* core_data_suite */
1758 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */