2412034a4ea50a9ddd7f68e21a91e9dbc8cf1c5d
1 /*
2 * SysDB - t/unit/utils/proto_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/store.h"
29 #include "utils/proto.h"
30 #include "libsysdb_test.h"
32 #include <check.h>
33 #include <stdio.h>
34 #include <string.h>
36 START_TEST(test_marshal_data)
37 {
38 #define INT_TYPE "\0\0\0\1"
39 #define DECIMAL_TYPE "\0\0\0\2"
40 #define STRING_TYPE "\0\0\0\3"
41 #define DATETIME_TYPE "\0\0\0\4"
42 #define BINARY_TYPE "\0\0\0\5"
43 #define REGEX_TYPE "\0\0\0\6"
45 #define NULL_ARRAY "\0\0\1\0"
46 #define INT_ARRAY "\0\0\1\1"
47 #define DECIMAL_ARRAY "\0\0\1\2"
48 #define STRING_ARRAY "\0\0\1\3"
49 #define DATETIME_ARRAY "\0\0\1\4"
50 #define BINARY_ARRAY "\0\0\1\5"
51 #define REGEX_ARRAY "\0\0\1\6"
53 regex_t dummy_re;
54 int64_t int_values[] = { 47, 11, 23 };
55 double dec_values[] = { 47.11, .5 };
56 char *string_values[] = { "foo", "abcd" };
57 sdb_time_t datetime_values[] = { 4711, 1234567890123456789L };
58 struct {
59 size_t length;
60 unsigned char *datum;
61 } binary_values[] = {
62 { 3, (unsigned char *)"\x1\x2\x3" },
63 { 4, (unsigned char *)"\x42\x0\xa\x1b" },
64 };
65 struct {
66 char *raw;
67 regex_t regex;
68 } regex_values[] = {
69 { "dummy regex", dummy_re },
70 };
72 struct {
73 sdb_data_t datum;
74 ssize_t expected_len;
75 char *expected;
76 } golden_data[] = {
77 {
78 { SDB_TYPE_NULL, { .integer = 0 } },
79 4, "\0\0\0\0",
80 },
81 {
82 { SDB_TYPE_INTEGER, { .integer = 4711 } },
83 12, INT_TYPE "\0\0\0\0\0\0\x12\x67",
84 },
85 {
86 { SDB_TYPE_DECIMAL, { .decimal = 3.141592653e130 } },
87 12, DECIMAL_TYPE "\x5b\x6\xa9\x40\x66\x1e\x10\x4",
88 },
89 {
90 { SDB_TYPE_STRING, { .string = "some string" } },
91 16, STRING_TYPE "some string\0",
92 },
93 {
94 { SDB_TYPE_DATETIME, { .datetime = 1418923804000000 } },
95 12, DATETIME_TYPE "\x0\x5\xa\x80\xf1\x4c\xff\x0",
96 },
97 {
98 { SDB_TYPE_BINARY, { .binary = {
99 4, (unsigned char *)"\x42\x0\xa\x1b" } } },
100 12, BINARY_TYPE "\0\0\0\x4" "\x42\x0\xa\x1b",
101 },
102 {
103 { SDB_TYPE_REGEX, { .re = { "dummy", dummy_re } } },
104 10, REGEX_TYPE "dummy\0",
105 },
106 {
107 { SDB_TYPE_INTEGER | SDB_TYPE_ARRAY, { .array = {
108 3, int_values } } },
109 32, INT_ARRAY "\0\0\0\x3" "\0\0\0\0\0\0\0\x2f"
110 "\0\0\0\0\0\0\0\xb" "\0\0\0\0\0\0\0\x17"
111 },
112 {
113 { SDB_TYPE_DECIMAL | SDB_TYPE_ARRAY, { .array = {
114 2, dec_values } } },
115 24, DECIMAL_ARRAY "\0\0\0\x2" "\x40\x47\x8e\x14\x7a\xe1\x47\xae"
116 "\x3f\xe0\0\0\0\0\0\0"
117 },
118 {
119 { SDB_TYPE_STRING | SDB_TYPE_ARRAY, { .array = {
120 2, string_values } } },
121 17, STRING_ARRAY "\0\0\0\x2" "foo\0" "abcd\0"
122 },
123 {
124 { SDB_TYPE_DATETIME | SDB_TYPE_ARRAY, { .array = {
125 2, datetime_values } } },
126 24, DATETIME_ARRAY "\0\0\0\x2" "\0\0\0\0\0\0\x12\x67"
127 "\x11\x22\x10\xf4\x7d\xe9\x81\x15"
128 },
129 {
130 { SDB_TYPE_BINARY | SDB_TYPE_ARRAY, { .array = {
131 2, binary_values } } },
132 23, BINARY_ARRAY "\0\0\0\x2" "\0\0\0\x3" "\x1\x2\x3"
133 "\0\0\0\4" "\x42\x0\xa\x1b"
134 },
135 {
136 { SDB_TYPE_REGEX | SDB_TYPE_ARRAY, { .array = {
137 1, regex_values } } },
138 20, REGEX_ARRAY "\0\0\0\1" "dummy regex\0"
139 },
140 };
142 size_t i;
144 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
145 ssize_t len = sdb_proto_marshal_data(NULL, 0, &golden_data[i].datum);
146 char buf[len > 0 ? len : 1];
147 char v1[sdb_data_strlen(&golden_data[i].datum)];
148 char v2[sdb_data_strlen(&golden_data[i].datum)];
150 sdb_data_t datum = SDB_DATA_INIT;
151 ssize_t check;
153 if (sdb_data_format(&golden_data[i].datum, v1, sizeof(v1), 0) < 0)
154 snprintf(v1, sizeof(v1), "<ERR>");
156 fail_unless(len == golden_data[i].expected_len,
157 "<%zu> sdb_proto_marshal_data(NULL, 0, %s) = %zi; expected: %zi",
158 i, v1, len, golden_data[i].expected_len);
160 if (len < 0)
161 continue;
163 len = sdb_proto_marshal_data(buf, sizeof(buf), &golden_data[i].datum);
164 fail_unless(len == golden_data[i].expected_len,
165 "<%zu> sdb_proto_marshal_data(<buf>, %zu, %s) = %zi; expected: %zi",
166 i, sizeof(buf), v1, len, golden_data[i].expected_len);
167 if (memcmp(buf, golden_data[i].expected, len) != 0) {
168 size_t pos;
169 for (pos = 0; pos < (size_t)len; ++pos)
170 if (buf[pos] != golden_data[i].expected[pos])
171 break;
172 fail("<%zu> sdb_proto_marshal_data(%s) -> \"%s\"; expected: \"%s\" "
173 "(bytes %zu differ: '%x' != '%x')",
174 i, v1, buf, golden_data[i].expected,
175 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
176 }
178 check = sdb_proto_unmarshal_data(buf, len, &datum);
179 if (sdb_data_format(&datum, v2, sizeof(v2), 0) < 0)
180 snprintf(v2, sizeof(v2), "<ERR>");
182 if (sdb_data_isnull(&golden_data[i].datum))
183 fail_unless(sdb_data_isnull(&datum),
184 "<%zu> sdb_proto_unmarshal_data(buf<%s>) -> \"%s\"", i, v1, v2);
185 else
186 fail_unless(sdb_data_cmp(&golden_data[i].datum, &datum) == 0,
187 "<%zu> sdb_proto_unmarshal_data(buf<%s>) -> \"%s\"", i, v1, v2);
188 fail_unless(check == len,
189 "<%zu> sdb_proto_unmarshal_data(buf<%s>) = %zi; expected: %zi",
190 i, v1, check, len);
192 sdb_data_free_datum(&datum);
193 }
194 }
195 END_TEST
197 #define HOST_TYPE "\0\0\0\1"
198 #define SVC_TYPE "\0\0\0\2"
199 #define METRIC_TYPE "\0\0\0\3"
200 #define HOST_ATTR_TYPE "\0\0\0\x11"
201 #define SVC_ATTR_TYPE "\0\0\0\x12"
202 #define METRIC_ATTR_TYPE "\0\0\0\x13"
204 START_TEST(test_marshal_host)
205 {
206 struct {
207 sdb_proto_host_t host;
208 ssize_t expected_len;
209 char *expected;
210 } golden_data[] = {
211 {
212 { 4711, "hostA" },
213 18, HOST_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0"
214 },
215 {
216 { 0, "hostA" },
217 18, HOST_TYPE "\0\0\0\0\0\0\0\0" "hostA\0"
218 },
219 { { 4711, NULL }, -1, NULL },
220 };
222 size_t i;
224 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
225 ssize_t len = sdb_proto_marshal_host(NULL, 0, &golden_data[i].host);
226 char buf[len > 0 ? len : 1];
228 fail_unless(len == golden_data[i].expected_len,
229 "<%zu> sdb_proto_marshal_host(NULL, 0, %s) = %zi; expected: %zi",
230 i, golden_data[i].host.name, len, golden_data[i].expected_len);
232 if (len < 0)
233 continue;
235 len = sdb_proto_marshal_host(buf, sizeof(buf), &golden_data[i].host);
236 fail_unless(len == golden_data[i].expected_len,
237 "<%zu> sdb_proto_marshal_host(<buf>, %zu, %s) = %zi; expected: %zi",
238 i, sizeof(buf), golden_data[i].host.name,
239 len, golden_data[i].expected_len);
240 if (memcmp(buf, golden_data[i].expected, len) != 0) {
241 size_t pos;
242 for (pos = 0; pos < (size_t)len; ++pos)
243 if (buf[pos] != golden_data[i].expected[pos])
244 break;
245 fail("<%zu> sdb_proto_marshal_host(%s) -> \"%s\"; expected: \"%s\" "
246 "(bytes %zu differ: '%x' != '%x')",
247 i, golden_data[i].host.name, buf, golden_data[i].expected,
248 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
249 }
250 }
251 }
252 END_TEST
254 START_TEST(test_marshal_service)
255 {
256 struct {
257 sdb_proto_service_t svc;
258 ssize_t expected_len;
259 char *expected;
260 } golden_data[] = {
261 {
262 { 4711, "hostA", "serviceX" },
263 27, SVC_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0serviceX\0"
264 },
265 {
266 { 0, "hostA", "serviceX" },
267 27, SVC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0serviceX\0"
268 },
269 { { 4711, "hostA", NULL }, -1, NULL },
270 { { 4711, NULL, "serviceX" }, -1, NULL },
271 { { 4711, NULL, NULL }, -1, NULL },
272 };
274 size_t i;
276 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
277 ssize_t len = sdb_proto_marshal_service(NULL, 0, &golden_data[i].svc);
278 char buf[len > 0 ? len : 1];
280 fail_unless(len == golden_data[i].expected_len,
281 "<%zu> sdb_proto_marshal_service(NULL, 0, %s) = %zi; expected: %zi",
282 i, golden_data[i].svc.name, len, golden_data[i].expected_len);
284 if (len < 0)
285 continue;
287 len = sdb_proto_marshal_service(buf, sizeof(buf), &golden_data[i].svc);
288 fail_unless(len == golden_data[i].expected_len,
289 "<%zu> sdb_proto_marshal_service(<buf>, %zu, %s) = %zi; expected: %zi",
290 i, sizeof(buf), golden_data[i].svc.name,
291 len, golden_data[i].expected_len);
292 if (memcmp(buf, golden_data[i].expected, len) != 0) {
293 size_t pos;
294 for (pos = 0; pos < (size_t)len; ++pos)
295 if (buf[pos] != golden_data[i].expected[pos])
296 break;
297 fail("<%zu> sdb_proto_marshal_service(%s) -> \"%s\"; expected: \"%s\" "
298 "(bytes %zu differ: '%x' != '%x')",
299 i, golden_data[i].svc.name, buf, golden_data[i].expected,
300 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
301 }
302 }
303 }
304 END_TEST
306 START_TEST(test_marshal_metric)
307 {
308 struct {
309 sdb_proto_metric_t metric;
310 ssize_t expected_len;
311 char *expected;
312 } golden_data[] = {
313 {
314 { 4711, "hostA", "metricX", NULL, NULL },
315 26, METRIC_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0metricX\0"
316 },
317 {
318 { 0, "hostA", "metricX", NULL, NULL },
319 26, METRIC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0metricX\0"
320 },
321 {
322 { 0, "hostA", "metricX", "type", NULL },
323 26, METRIC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0metricX\0"
324 },
325 {
326 { 0, "hostA", "metricX", NULL, "id" },
327 26, METRIC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0metricX\0"
328 },
329 {
330 { 4711, "hostA", "metricX", "type", "id" },
331 34, METRIC_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0metricX\0type\0id\0"
332 },
333 { { 4711, "hostA", NULL, NULL, NULL }, -1, NULL },
334 { { 4711, NULL, "metricX", NULL, NULL }, -1, NULL },
335 { { 4711, NULL, NULL, NULL, NULL }, -1, NULL },
336 };
338 size_t i;
340 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
341 ssize_t len = sdb_proto_marshal_metric(NULL, 0, &golden_data[i].metric);
342 char buf[len > 0 ? len : 1];
344 fail_unless(len == golden_data[i].expected_len,
345 "<%zu> sdb_proto_marshal_metric(NULL, 0, %s) = %zi; expected: %zi",
346 i, golden_data[i].metric.name, len, golden_data[i].expected_len);
348 if (len < 0)
349 continue;
351 len = sdb_proto_marshal_metric(buf, sizeof(buf), &golden_data[i].metric);
352 fail_unless(len == golden_data[i].expected_len,
353 "<%zu> sdb_proto_marshal_metric(<buf>, %zu, %s) = %zi; expected: %zi",
354 i, sizeof(buf), golden_data[i].metric.name,
355 len, golden_data[i].expected_len);
356 if (memcmp(buf, golden_data[i].expected, len) != 0) {
357 size_t pos;
358 for (pos = 0; pos < (size_t)len; ++pos)
359 if (buf[pos] != golden_data[i].expected[pos])
360 break;
361 fail("<%zu> sdb_proto_marshal_metric(%s) -> \"%s\"; expected: \"%s\" "
362 "(bytes %zu differ: '%x' != '%x')",
363 i, golden_data[i].metric.name, buf, golden_data[i].expected,
364 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
365 }
366 }
367 }
368 END_TEST
370 START_TEST(test_marshal_attribute)
371 {
372 sdb_data_t v = { SDB_TYPE_NULL, { .integer = 0 } };
373 #define VAL "\0\0\0\0"
374 struct {
375 sdb_proto_attribute_t attr;
376 ssize_t expected_len;
377 char *expected;
378 } golden_data[] = {
379 {
380 { 4711, SDB_HOST, NULL, "hostA", "k1", &v },
381 25, HOST_ATTR_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0" "k1\0" VAL
382 },
383 {
384 { 4711, SDB_SERVICE, "hostA", "svc1", "k1", &v },
385 30, SVC_ATTR_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0" "svc1\0" "k1\0" VAL
386 },
387 {
388 { 4711, SDB_METRIC, "hostA", "m1", "k1", &v },
389 28, METRIC_ATTR_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0" "m1\0" "k1\0" VAL
390 },
391 { { 4711, SDB_HOST, NULL, NULL, "k1", &v }, -1, NULL },
392 { { 4711, SDB_HOST, NULL, "hostA", NULL, &v }, -1, NULL },
393 { { 4711, SDB_HOST, NULL, "hostA", "k1", NULL }, -1, NULL },
394 { { 4711, SDB_SERVICE, NULL, "svc1", "k1", &v }, -1, NULL },
395 { { 4711, SDB_METRIC, NULL, "m1", "k1", &v }, -1, NULL },
396 { { 4711, 0, "hostA", "svc1", "k1", &v }, -1, NULL },
397 };
399 size_t i;
401 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
402 ssize_t len = sdb_proto_marshal_attribute(NULL, 0, &golden_data[i].attr);
403 char buf[len > 0 ? len : 1];
405 fail_unless(len == golden_data[i].expected_len,
406 "<%zu> sdb_proto_marshal_attribute(NULL, 0, %s) = %zi; expected: %zi",
407 i, golden_data[i].attr.key, len, golden_data[i].expected_len);
409 if (len < 0)
410 continue;
412 len = sdb_proto_marshal_attribute(buf, sizeof(buf), &golden_data[i].attr);
413 fail_unless(len == golden_data[i].expected_len,
414 "<%zu> sdb_proto_marshal_attribute(<buf>, %zu, %s) = %zi; expected: %zi",
415 i, sizeof(buf), golden_data[i].attr.key,
416 len, golden_data[i].expected_len);
417 if (memcmp(buf, golden_data[i].expected, len) != 0) {
418 size_t pos;
419 for (pos = 0; pos < (size_t)len; ++pos)
420 if (buf[pos] != golden_data[i].expected[pos])
421 break;
422 fail("<%zu> sdb_proto_marshal_attribute(%s) -> \"%s\"; expected: \"%s\" "
423 "(bytes %zu differ: '%x' != '%x')",
424 i, golden_data[i].attr.key, buf, golden_data[i].expected,
425 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
426 }
427 }
428 }
429 END_TEST
431 Suite *
432 util_proto_suite(void)
433 {
434 Suite *s = suite_create("utils::proto");
435 TCase *tc;
437 tc = tcase_create("core");
438 tcase_add_test(tc, test_marshal_data);
439 tcase_add_test(tc, test_marshal_host);
440 tcase_add_test(tc, test_marshal_service);
441 tcase_add_test(tc, test_marshal_metric);
442 tcase_add_test(tc, test_marshal_attribute);
443 suite_add_tcase(s, tc);
445 return s;
446 } /* util_proto_suite */
448 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */