![[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_parse_op)
798 {
799 struct {
800 const char *op;
801 int id;
802 } golden_data[] = {
803 { "+", SDB_DATA_ADD },
804 { "-", SDB_DATA_SUB },
805 { "*", SDB_DATA_MUL },
806 { "/", SDB_DATA_DIV },
807 { "%", SDB_DATA_MOD },
808 { "||", SDB_DATA_CONCAT },
809 { "&&", -1 },
810 };
812 size_t i;
814 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
815 const char *op;
816 int id;
818 id = sdb_data_parse_op(golden_data[i].op);
819 fail_unless(id == golden_data[i].id,
820 "sdb_data_parse_op(%s) = %d; expected: %d",
821 golden_data[i].op, id, golden_data[i].id);
823 if (id <= 0)
824 continue;
826 op = SDB_DATA_OP_TO_STRING(id);
827 fail_unless(!strcmp(op, golden_data[i].op),
828 "SDB_DATA_OP_TO_STRING(%d) = '%s'; expected: '%s'",
829 id, op, golden_data[i].op);
830 }
831 }
832 END_TEST
834 START_TEST(test_expr_eval)
835 {
836 sdb_data_t err = { -1, { .integer = 0 } };
838 int64_t int_values[] = { 47, 11, 23 };
839 int64_t expected_int_concat[] = { 47, 11, 23, 47, 11, 23 };
840 char *string_values[] = { "foo", "bar", "qux" "baz" };
841 char *expected_string_concat[] =
842 { "foo", "bar", "qux" "baz", "foo", "bar", "qux" "baz" };
844 struct {
845 sdb_data_t d1;
846 sdb_data_t d2;
847 sdb_data_t expected_add;
848 sdb_data_t expected_sub;
849 sdb_data_t expected_mul;
850 sdb_data_t expected_div;
851 sdb_data_t expected_mod;
852 sdb_data_t expected_concat;
853 } golden_data[] = {
854 {
855 { SDB_TYPE_INTEGER, { .integer = 4711 } },
856 { SDB_TYPE_INTEGER, { .integer = 47 } },
857 { SDB_TYPE_INTEGER, { .integer = 4758 } },
858 { SDB_TYPE_INTEGER, { .integer = 4664 } },
859 { SDB_TYPE_INTEGER, { .integer = 221417 } },
860 { SDB_TYPE_INTEGER, { .integer = 100 } },
861 { SDB_TYPE_INTEGER, { .integer = 11 } },
862 err,
863 },
864 {
865 { SDB_TYPE_DECIMAL, { .decimal = 35.0 } },
866 { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
867 { SDB_TYPE_DECIMAL, { .decimal = 52.5 } },
868 { SDB_TYPE_DECIMAL, { .decimal = 17.5 } },
869 { SDB_TYPE_DECIMAL, { .decimal = 612.5 } },
870 { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
871 { SDB_TYPE_DECIMAL, { .decimal = 0.0 } },
872 err,
873 },
874 {
875 { SDB_TYPE_STRING, { .string = NULL } },
876 { SDB_TYPE_STRING, { .string = "" } },
877 SDB_DATA_NULL,
878 SDB_DATA_NULL,
879 SDB_DATA_NULL,
880 SDB_DATA_NULL,
881 SDB_DATA_NULL,
882 SDB_DATA_NULL,
883 },
884 {
885 { SDB_TYPE_STRING, { .string = NULL } },
886 { SDB_TYPE_STRING, { .string = NULL } },
887 SDB_DATA_NULL,
888 SDB_DATA_NULL,
889 SDB_DATA_NULL,
890 SDB_DATA_NULL,
891 SDB_DATA_NULL,
892 SDB_DATA_NULL,
893 },
894 {
895 { SDB_TYPE_STRING, { .string = "" } },
896 { SDB_TYPE_STRING, { .string = NULL } },
897 SDB_DATA_NULL,
898 SDB_DATA_NULL,
899 SDB_DATA_NULL,
900 SDB_DATA_NULL,
901 SDB_DATA_NULL,
902 SDB_DATA_NULL,
903 },
904 {
905 { SDB_TYPE_STRING, { .string = "a" } },
906 { SDB_TYPE_STRING, { .string = "b" } },
907 err,
908 err,
909 err,
910 err,
911 err,
912 { SDB_TYPE_STRING, { .string = "ab" } },
913 },
914 {
915 { SDB_TYPE_DATETIME, { .datetime = 47114711 } },
916 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
917 { SDB_TYPE_DATETIME, { .datetime = 47119422 } },
918 { SDB_TYPE_DATETIME, { .datetime = 47110000 } },
919 { SDB_TYPE_DATETIME, { .datetime = 221957403521 } },
920 { SDB_TYPE_DATETIME, { .datetime = 10001 } },
921 { SDB_TYPE_DATETIME, { .datetime = 0 } },
922 err,
923 },
924 {
925 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
926 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
927 SDB_DATA_NULL,
928 SDB_DATA_NULL,
929 SDB_DATA_NULL,
930 SDB_DATA_NULL,
931 SDB_DATA_NULL,
932 SDB_DATA_NULL,
933 },
934 {
935 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
936 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
937 SDB_DATA_NULL,
938 SDB_DATA_NULL,
939 SDB_DATA_NULL,
940 SDB_DATA_NULL,
941 SDB_DATA_NULL,
942 SDB_DATA_NULL,
943 },
944 {
945 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
946 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
947 SDB_DATA_NULL,
948 SDB_DATA_NULL,
949 SDB_DATA_NULL,
950 SDB_DATA_NULL,
951 SDB_DATA_NULL,
952 SDB_DATA_NULL,
953 },
954 {
955 {
956 SDB_TYPE_BINARY,
957 { .binary = { 3, (unsigned char *)"a\0a" } },
958 },
959 {
960 SDB_TYPE_BINARY,
961 { .binary = { 3, (unsigned char *)"b\0b" } },
962 },
963 err,
964 err,
965 err,
966 err,
967 err,
968 {
969 SDB_TYPE_BINARY,
970 { .binary = { 6, (unsigned char *)"a\0ab\0b" } },
971 },
972 },
973 {
974 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
975 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
976 err,
977 err,
978 err,
979 err,
980 err,
981 err,
982 },
983 {
984 {
985 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
986 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
987 },
988 {
989 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
990 { .array = { SDB_STATIC_ARRAY_LEN(int_values), int_values } },
991 },
992 err,
993 err,
994 err,
995 err,
996 err,
997 {
998 SDB_TYPE_ARRAY | SDB_TYPE_INTEGER,
999 { .array = {
1000 SDB_STATIC_ARRAY_LEN(expected_int_concat),
1001 expected_int_concat
1002 } },
1003 },
1004 },
1005 {
1006 {
1007 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1008 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1009 },
1010 {
1011 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1012 { .array = { SDB_STATIC_ARRAY_LEN(string_values), string_values } },
1013 },
1014 err,
1015 err,
1016 err,
1017 err,
1018 err,
1019 {
1020 SDB_TYPE_ARRAY | SDB_TYPE_STRING,
1021 { .array = {
1022 SDB_STATIC_ARRAY_LEN(expected_string_concat),
1023 expected_string_concat
1024 } },
1025 },
1026 },
1027 {
1028 { SDB_TYPE_NULL, { .integer = 0 } },
1029 { SDB_TYPE_NULL, { .integer = 0 } },
1030 SDB_DATA_NULL,
1031 SDB_DATA_NULL,
1032 SDB_DATA_NULL,
1033 SDB_DATA_NULL,
1034 SDB_DATA_NULL,
1035 SDB_DATA_NULL,
1036 },
1037 {
1038 { SDB_TYPE_NULL, { .integer = 0 } },
1039 { SDB_TYPE_INTEGER, { .integer = 42 } },
1040 SDB_DATA_NULL,
1041 SDB_DATA_NULL,
1042 SDB_DATA_NULL,
1043 SDB_DATA_NULL,
1044 SDB_DATA_NULL,
1045 SDB_DATA_NULL,
1046 },
1047 {
1048 { SDB_TYPE_INTEGER, { .integer = 42 } },
1049 { SDB_TYPE_NULL, { .integer = 0 } },
1050 SDB_DATA_NULL,
1051 SDB_DATA_NULL,
1052 SDB_DATA_NULL,
1053 SDB_DATA_NULL,
1054 SDB_DATA_NULL,
1055 SDB_DATA_NULL,
1056 },
1057 {
1058 { SDB_TYPE_NULL, { .integer = 0 } },
1059 { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1060 SDB_DATA_NULL,
1061 SDB_DATA_NULL,
1062 SDB_DATA_NULL,
1063 SDB_DATA_NULL,
1064 SDB_DATA_NULL,
1065 SDB_DATA_NULL,
1066 },
1067 {
1068 { SDB_TYPE_DECIMAL, { .decimal = 47.11 } },
1069 { SDB_TYPE_NULL, { .integer = 0 } },
1070 SDB_DATA_NULL,
1071 SDB_DATA_NULL,
1072 SDB_DATA_NULL,
1073 SDB_DATA_NULL,
1074 SDB_DATA_NULL,
1075 SDB_DATA_NULL,
1076 },
1077 {
1078 { SDB_TYPE_NULL, { .integer = 0 } },
1079 { SDB_TYPE_STRING, { .string = "47.11" } },
1080 SDB_DATA_NULL,
1081 SDB_DATA_NULL,
1082 SDB_DATA_NULL,
1083 SDB_DATA_NULL,
1084 SDB_DATA_NULL,
1085 SDB_DATA_NULL,
1086 },
1087 {
1088 { SDB_TYPE_STRING, { .string = "47.11" } },
1089 { SDB_TYPE_NULL, { .integer = 0 } },
1090 SDB_DATA_NULL,
1091 SDB_DATA_NULL,
1092 SDB_DATA_NULL,
1093 SDB_DATA_NULL,
1094 SDB_DATA_NULL,
1095 SDB_DATA_NULL,
1096 },
1097 {
1098 { SDB_TYPE_NULL, { .integer = 0 } },
1099 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1100 SDB_DATA_NULL,
1101 SDB_DATA_NULL,
1102 SDB_DATA_NULL,
1103 SDB_DATA_NULL,
1104 SDB_DATA_NULL,
1105 SDB_DATA_NULL,
1106 },
1107 {
1108 { SDB_TYPE_DATETIME, { .datetime = 4711 } },
1109 { SDB_TYPE_NULL, { .integer = 0 } },
1110 SDB_DATA_NULL,
1111 SDB_DATA_NULL,
1112 SDB_DATA_NULL,
1113 SDB_DATA_NULL,
1114 SDB_DATA_NULL,
1115 SDB_DATA_NULL,
1116 },
1117 {
1118 { SDB_TYPE_NULL, { .integer = 0 } },
1119 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1120 SDB_DATA_NULL,
1121 SDB_DATA_NULL,
1122 SDB_DATA_NULL,
1123 SDB_DATA_NULL,
1124 SDB_DATA_NULL,
1125 SDB_DATA_NULL,
1126 },
1127 {
1128 { SDB_TYPE_BINARY, { .binary = { 1, (unsigned char *)"a" } } },
1129 { SDB_TYPE_NULL, { .integer = 0 } },
1130 SDB_DATA_NULL,
1131 SDB_DATA_NULL,
1132 SDB_DATA_NULL,
1133 SDB_DATA_NULL,
1134 SDB_DATA_NULL,
1135 SDB_DATA_NULL,
1136 },
1137 {
1138 { SDB_TYPE_NULL, { .integer = 0 } },
1139 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1140 SDB_DATA_NULL,
1141 SDB_DATA_NULL,
1142 SDB_DATA_NULL,
1143 SDB_DATA_NULL,
1144 SDB_DATA_NULL,
1145 SDB_DATA_NULL,
1146 },
1147 {
1148 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1149 { SDB_TYPE_NULL, { .integer = 0 } },
1150 SDB_DATA_NULL,
1151 SDB_DATA_NULL,
1152 SDB_DATA_NULL,
1153 SDB_DATA_NULL,
1154 SDB_DATA_NULL,
1155 SDB_DATA_NULL,
1156 },
1157 /* supported type-mismatches */
1158 {
1159 /* int * datetime */
1160 { SDB_TYPE_INTEGER, { .integer = 20 } },
1161 { SDB_TYPE_DATETIME, { .datetime = 2 } },
1162 err,
1163 err,
1164 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1165 err,
1166 err,
1167 err,
1168 },
1169 {
1170 /* datetime * int, datetime / int, datetime % int */
1171 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1172 { SDB_TYPE_INTEGER, { .integer = 2 } },
1173 err,
1174 err,
1175 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1176 { SDB_TYPE_DATETIME, { .datetime = 10 } },
1177 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1178 err,
1179 },
1180 {
1181 /* float * datetime */
1182 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1183 { SDB_TYPE_DATETIME, { .datetime = 2 } },
1184 err,
1185 err,
1186 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1187 err,
1188 err,
1189 err,
1190 },
1191 {
1192 /* datetime * float, datetime / float, datetime % float */
1193 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1194 { SDB_TYPE_DECIMAL, { .decimal = 2.0 } },
1195 err,
1196 err,
1197 { SDB_TYPE_DATETIME, { .datetime = 40 } },
1198 { SDB_TYPE_DATETIME, { .datetime = 10 } },
1199 { SDB_TYPE_DATETIME, { .datetime = 0 } },
1200 err,
1201 },
1202 /* unsupported type-mismatches */
1203 {
1204 { SDB_TYPE_INTEGER, { .integer = 20 } },
1205 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1206 err, err, err, err, err, err,
1207 },
1208 {
1209 { SDB_TYPE_INTEGER, { .integer = 20 } },
1210 { SDB_TYPE_STRING, { .string = "20" } },
1211 err, err, err, err, err, err,
1212 },
1213 {
1214 { SDB_TYPE_INTEGER, { .integer = 20 } },
1215 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1216 err, err, err, err, err, err,
1217 },
1218 {
1219 { SDB_TYPE_INTEGER, { .integer = 20 } },
1220 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1221 err, err, err, err, err, err,
1222 },
1223 {
1224 { SDB_TYPE_INTEGER, { .integer = 20 } },
1225 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1226 err, err, err, err, err, err,
1227 },
1228 {
1229 { SDB_TYPE_INTEGER, { .integer = 20 } },
1230 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1231 err, err, err, err, err, err,
1232 },
1233 {
1234 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1235 { SDB_TYPE_INTEGER, { .integer = 20 } },
1236 err, err, err, err, err, err,
1237 },
1238 {
1239 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1240 { SDB_TYPE_STRING, { .string = "20.0" } },
1241 err, err, err, err, err, err,
1242 },
1243 {
1244 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1245 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1246 err, err, err, err, err, err,
1247 },
1248 {
1249 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1250 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1251 err, err, err, err, err, err,
1252 },
1253 {
1254 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1255 { SDB_TYPE_BINARY, { .binary = { 4, (unsigned char *)"20.0" } } },
1256 err, err, err, err, err, err,
1257 },
1258 {
1259 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1260 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1261 err, err, err, err, err, err,
1262 },
1263 {
1264 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1265 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1266 err, err, err, err, err, err,
1267 },
1268 {
1269 { SDB_TYPE_STRING, { .string = "20" } },
1270 { SDB_TYPE_INTEGER, { .integer = 20 } },
1271 err, err, err, err, err, err,
1272 },
1273 {
1274 { SDB_TYPE_STRING, { .string = "20" } },
1275 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1276 err, err, err, err, err, err,
1277 },
1278 {
1279 { SDB_TYPE_STRING, { .string = "20" } },
1280 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1281 err, err, err, err, err, err,
1282 },
1283 {
1284 { SDB_TYPE_STRING, { .string = "20" } },
1285 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1286 err, err, err, err, err, err,
1287 },
1288 {
1289 { SDB_TYPE_STRING, { .string = "20" } },
1290 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1291 err, err, err, err, err, err,
1292 },
1293 {
1294 { SDB_TYPE_STRING, { .string = "20" } },
1295 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1296 err, err, err, err, err, err,
1297 },
1298 {
1299 { SDB_TYPE_STRING, { .string = "20" } },
1300 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1301 err, err, err, err, err, err,
1302 },
1303 {
1304 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1305 { SDB_TYPE_STRING, { .string = "20" } },
1306 err, err, err, err, err, err,
1307 },
1308 {
1309 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1310 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1311 err, err, err, err, err, err,
1312 },
1313 {
1314 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1315 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1316 err, err, err, err, err, err,
1317 },
1318 {
1319 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1320 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1321 err, err, err, err, err, err,
1322 },
1323 {
1324 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1325 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1326 err, err, err, err, err, err,
1327 },
1328 {
1329 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1330 { SDB_TYPE_INTEGER, { .integer = 20 } },
1331 err, err, err, err, err, err,
1332 },
1333 {
1334 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1335 { SDB_TYPE_INTEGER, { .integer = 20 } },
1336 err, err, err, err, err, err,
1337 },
1338 {
1339 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1340 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1341 err, err, err, err, err, err,
1342 },
1343 {
1344 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1345 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1346 err, err, err, err, err, err,
1347 },
1348 {
1349 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1350 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1351 err, err, err, err, err, err,
1352 },
1353 {
1354 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1355 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1356 err, err, err, err, err, err,
1357 },
1358 {
1359 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1360 { SDB_TYPE_STRING, { .string = "20" } },
1361 err, err, err, err, err, err,
1362 },
1363 {
1364 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1365 { SDB_TYPE_STRING, { .string = "20" } },
1366 err, err, err, err, err, err,
1367 },
1368 {
1369 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1370 { SDB_TYPE_STRING, { .string = "20" } },
1371 err, err, err, err, err, err,
1372 },
1373 {
1374 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1375 { SDB_TYPE_STRING, { .string = "20" } },
1376 err, err, err, err, err, err,
1377 },
1378 {
1379 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1380 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1381 err, err, err, err, err, err,
1382 },
1383 {
1384 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1385 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1386 err, err, err, err, err, err,
1387 },
1388 {
1389 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1390 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1391 err, err, err, err, err, err,
1392 },
1393 {
1394 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1395 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1396 err, err, err, err, err, err,
1397 },
1398 {
1399 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1400 { SDB_TYPE_INTEGER, { .integer = 20 } },
1401 err, err, err, err, err, err,
1402 },
1403 {
1404 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1405 { SDB_TYPE_DECIMAL, { .decimal = 20.0 } },
1406 err, err, err, err, err, err,
1407 },
1408 {
1409 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1410 { SDB_TYPE_STRING, { .string = "20" } },
1411 err, err, err, err, err, err,
1412 },
1413 {
1414 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1415 { SDB_TYPE_DATETIME, { .datetime = 20 } },
1416 err, err, err, err, err, err,
1417 },
1418 {
1419 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1420 { SDB_TYPE_BINARY, { .binary = { 2, (unsigned char *)"20" } } },
1421 err, err, err, err, err, err,
1422 },
1423 {
1424 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1425 { SDB_TYPE_BINARY, { .binary = { 3, (unsigned char *)"20" } } },
1426 err, err, err, err, err, err,
1427 },
1428 {
1429 { SDB_TYPE_REGEX, { .re = { ".", empty_re } } },
1430 { SDB_TYPE_REGEX + 1, { .integer = 0 } },
1431 err, err, err, err, err, err,
1432 },
1433 };
1435 size_t i;
1437 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1438 struct {
1439 int op;
1440 sdb_data_t expected;
1441 } tests[] = {
1442 { SDB_DATA_ADD, golden_data[i].expected_add },
1443 { SDB_DATA_SUB, golden_data[i].expected_sub },
1444 { SDB_DATA_MUL, golden_data[i].expected_mul },
1445 { SDB_DATA_DIV, golden_data[i].expected_div },
1446 { SDB_DATA_MOD, golden_data[i].expected_mod },
1447 { SDB_DATA_CONCAT, golden_data[i].expected_concat },
1448 };
1450 size_t j;
1451 for (j = 0; j < SDB_STATIC_ARRAY_LEN(tests); ++j) {
1452 sdb_data_t res;
1453 int check;
1454 int type1, type2, type;
1456 char d1_str[64] = "", d2_str[64] = "";
1457 sdb_data_format(&golden_data[i].d1, d1_str, sizeof(d1_str),
1458 SDB_DOUBLE_QUOTED);
1459 sdb_data_format(&golden_data[i].d2, d2_str, sizeof(d2_str),
1460 SDB_DOUBLE_QUOTED);
1462 type1 = golden_data[i].d1.type;
1463 type2 = golden_data[i].d2.type;
1464 if (sdb_data_isnull(&golden_data[i].d1))
1465 type1 = SDB_TYPE_NULL;
1466 if (sdb_data_isnull(&golden_data[i].d2))
1467 type2 = SDB_TYPE_NULL;
1468 type = sdb_data_expr_type(tests[j].op, type1, type2);
1470 check = sdb_data_expr_eval(tests[j].op,
1471 &golden_data[i].d1, &golden_data[i].d2, &res);
1472 fail_unless((check == 0) == (tests[j].expected.type != -1),
1473 "sdb_data_expr_eval(%s, %s, %s) = %d; expected: %d",
1474 SDB_DATA_OP_TO_STRING(tests[j].op), d1_str, d2_str, check,
1475 tests[j].expected.type == -1 ? -1 : 0);
1477 fail_unless(tests[j].expected.type == type,
1478 "sdb_data_expr_eval(%s, %s, %s) expected to evaluate "
1479 "to type %d while sdb_data_expr_type(%d, %d, %d) "
1480 "predicted type %d", SDB_DATA_OP_TO_STRING(tests[j].op),
1481 d1_str, d2_str, tests[j].expected.type,
1482 tests[j].op, golden_data[i].d1.type,
1483 golden_data[i].d2.type, type);
1485 if (tests[j].expected.type == -1)
1486 continue;
1488 if (tests[j].expected.type == SDB_TYPE_NULL) {
1489 fail_unless(res.type == SDB_TYPE_NULL,
1490 "sdb_data_expr_eval(%s, %s, %s) evaluated to "
1491 "type %d; expected: SDB_TYPE_NULL",
1492 SDB_DATA_OP_TO_STRING(tests[j].op),
1493 d1_str, d2_str, res.type);
1494 continue;
1495 }
1497 check = sdb_data_cmp(&res, &tests[j].expected);
1498 if (check != 0) {
1499 char res_str[64] = "", expected_str[64] = "";
1500 sdb_data_format(&res, res_str, sizeof(res_str),
1501 SDB_DOUBLE_QUOTED);
1502 sdb_data_format(&tests[j].expected, expected_str,
1503 sizeof(expected_str), SDB_DOUBLE_QUOTED);
1504 fail("sdb_data_expr_eval(%s, %s, %s) evaluated to %s "
1505 "(type %d); expected: %s (type %d)",
1506 SDB_DATA_OP_TO_STRING(tests[j].op),
1507 d1_str, d2_str, res_str, res.type,
1508 expected_str, tests[j].expected.type);
1509 }
1511 sdb_data_free_datum(&res);
1512 }
1513 }
1514 }
1515 END_TEST
1517 START_TEST(test_format)
1518 {
1519 struct {
1520 sdb_data_t datum;
1521 const char *expected;
1522 } golden_data[] = {
1523 {
1524 { SDB_TYPE_INTEGER, { .integer = 4711 } },
1525 "4711",
1526 },
1527 {
1528 { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } },
1529 "65536",
1530 },
1531 {
1532 { SDB_TYPE_DECIMAL, { .decimal = 12.3 } },
1533 "12.3",
1534 },
1535 {
1536 { SDB_TYPE_STRING, { .string = NULL } },
1537 "NULL",
1538 },
1539 {
1540 { SDB_TYPE_STRING, { .string = "this is a test" } },
1541 "\"this is a test\"",
1542 },
1543 {
1544 { SDB_TYPE_STRING, { .string = "special \\ \" characters" } },
1545 "\"special \\\\ \\\" characters\"",
1546 },
1547 {
1548 { SDB_TYPE_DATETIME, { .datetime= 471147114711471100 } },
1549 "\"1984-12-06 02:11:54 +0000\"",
1550 },
1551 {
1552 { SDB_TYPE_BINARY, { .binary = { 0, NULL } } },
1553 "NULL",
1554 },
1555 {
1556 {
1557 SDB_TYPE_BINARY,
1558 { .binary = { 12, (unsigned char *)"binary\0crap\x42" } },
1559 },
1560 "\"\\x62\\x69\\x6e\\x61\\x72\\x79\\x0\\x63\\x72\\x61\\x70\\x42\"",
1561 },
1562 {
1563 { SDB_TYPE_REGEX, { .re = { "some regex", empty_re } } },
1564 "\"/some regex/\"",
1565 },
1566 };
1568 size_t i;
1570 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1571 sdb_data_t *datum = &golden_data[i].datum;
1572 char buf[sdb_data_strlen(datum) + 2];
1573 int check;
1575 memset(buf, (int)'A', sizeof(buf));
1577 check = sdb_data_format(datum, buf, sizeof(buf) - 1,
1578 SDB_DOUBLE_QUOTED);
1579 fail_unless(check > 0,
1580 "sdb_data_format(type=%s) = %d; expected: >0",
1581 SDB_TYPE_TO_STRING(datum->type), check);
1582 fail_unless(! strcmp(buf, golden_data[i].expected),
1583 "sdb_data_format(type=%s) used wrong format: %s; expected: %s",
1584 SDB_TYPE_TO_STRING(datum->type), buf, golden_data[i].expected);
1586 fail_unless((size_t)check <= sizeof(buf) - 2,
1587 "sdb_data_format(type=%s) wrote %d bytes; "
1588 "expected <= %zu based on sdb_data_strlen()",
1589 SDB_TYPE_TO_STRING(datum->type), check, sizeof(buf) - 2);
1591 fail_unless(buf[sizeof(buf) - 2] == '\0',
1592 "sdb_data_format(type=%s) did not nul-terminate the buffer",
1593 SDB_TYPE_TO_STRING(datum->type));
1594 fail_unless(buf[sizeof(buf) - 1] == 'A',
1595 "sdb_data_format(type=%s) wrote past the end of the buffer",
1596 SDB_TYPE_TO_STRING(datum->type));
1597 }
1598 }
1599 END_TEST
1601 START_TEST(test_parse)
1602 {
1603 struct {
1604 char *input;
1605 sdb_data_t result;
1606 int expected;
1607 } golden_data[] = {
1608 { "4711", { SDB_TYPE_INTEGER, { .integer = 4711 } }, 0 },
1609 { "0x10", { SDB_TYPE_INTEGER, { .integer = 16 } }, 0 },
1610 { "010", { SDB_TYPE_INTEGER, { .integer = 8 } }, 0 },
1611 { "abc", { SDB_TYPE_INTEGER, { .integer = 0 } }, -1 },
1612 { "1.2", { SDB_TYPE_DECIMAL, { .decimal = 1.2 } }, 0 },
1613 { "0x1p+16", { SDB_TYPE_DECIMAL, { .decimal = 65536.0 } }, 0 },
1614 { "abc", { SDB_TYPE_DECIMAL, { .decimal = 0.0 } }, -1 },
1615 { "abc", { SDB_TYPE_STRING, { .string = "abc" } }, 0 },
1616 { ".4", { SDB_TYPE_DATETIME, { .datetime = 400000000 } }, 0 },
1617 { "abc", { SDB_TYPE_DATETIME, { .datetime = 0 } }, -1 },
1618 { "abc", { SDB_TYPE_BINARY,
1619 { .binary = { 3, (unsigned char *)"abc" } } }, 0 },
1620 { "abc", { SDB_TYPE_REGEX, { .re = { "abc", empty_re } } }, 0 },
1621 { "(|", { SDB_TYPE_REGEX, { .re = { "", empty_re } } }, -1 },
1622 };
1624 size_t i;
1626 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
1627 sdb_data_t result;
1628 int type, check;
1630 memset(&result, 0, sizeof(result));
1631 type = golden_data[i].result.type;
1632 check = sdb_data_parse(golden_data[i].input, type, &result);
1633 fail_unless(check == golden_data[i].expected,
1634 "sdb_data_parse(%s, %d, <d>) = %d; expected: %d",
1635 golden_data[i].input, type, check, golden_data[i].expected);
1637 if (check)
1638 continue;
1640 fail_unless(sdb_data_cmp(&result, &golden_data[i].result) == 0,
1641 "sdb_data_parse(%s, %d, <d>) did not create expected result",
1642 golden_data[i].input, type);
1644 if (type == SDB_TYPE_STRING)
1645 fail_unless(golden_data[i].input == result.data.string,
1646 "sdb_data_parse(%s, %d, <d>) modified input string",
1647 golden_data[i].input, type);
1648 if (type == SDB_TYPE_BINARY)
1649 fail_unless(golden_data[i].input == (char *)result.data.binary.datum,
1650 "sdb_data_parse(%s, %d, <d>) modified input string",
1651 golden_data[i].input, type);
1652 if (type == SDB_TYPE_REGEX) {
1653 fail_unless(golden_data[i].input != result.data.re.raw,
1654 "sdb_data_parse(%s, %d, <d>) copied input string",
1655 golden_data[i].input, type);
1656 sdb_data_free_datum(&result);
1657 }
1658 }
1659 }
1660 END_TEST
1662 Suite *
1663 core_data_suite(void)
1664 {
1665 Suite *s = suite_create("core::data");
1666 TCase *tc;
1668 tc = tcase_create("core");
1669 tcase_add_test(tc, test_data);
1670 tcase_add_test(tc, test_cmp);
1671 tcase_add_test(tc, test_strcmp);
1672 tcase_add_test(tc, test_inarray);
1673 tcase_add_test(tc, test_parse_op);
1674 tcase_add_test(tc, test_expr_eval);
1675 tcase_add_test(tc, test_format);
1676 tcase_add_test(tc, test_parse);
1677 suite_add_tcase(s, tc);
1679 return s;
1680 } /* core_data_suite */
1682 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */