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 <stdbool.h>
34 #include <stdio.h>
35 #include <string.h>
37 static bool
38 streq(const char *s1, const char *s2)
39 {
40 if ((! s1) || (! s2))
41 return (s1 == NULL) == (s2 == NULL);
42 return strcmp(s1, s2) == 0;
43 } /* streq */
45 START_TEST(test_marshal_data)
46 {
47 #define INT_TYPE "\0\0\0\1"
48 #define DECIMAL_TYPE "\0\0\0\2"
49 #define STRING_TYPE "\0\0\0\3"
50 #define DATETIME_TYPE "\0\0\0\4"
51 #define BINARY_TYPE "\0\0\0\5"
52 #define REGEX_TYPE "\0\0\0\6"
54 #define NULL_ARRAY "\0\0\1\0"
55 #define INT_ARRAY "\0\0\1\1"
56 #define DECIMAL_ARRAY "\0\0\1\2"
57 #define STRING_ARRAY "\0\0\1\3"
58 #define DATETIME_ARRAY "\0\0\1\4"
59 #define BINARY_ARRAY "\0\0\1\5"
60 #define REGEX_ARRAY "\0\0\1\6"
62 regex_t dummy_re;
63 int64_t int_values[] = { 47, 11, 23 };
64 double dec_values[] = { 47.11, .5 };
65 char *string_values[] = { "foo", "abcd" };
66 sdb_time_t datetime_values[] = { 4711, 1234567890123456789L };
67 struct {
68 size_t length;
69 unsigned char *datum;
70 } binary_values[] = {
71 { 3, (unsigned char *)"\x1\x2\x3" },
72 { 4, (unsigned char *)"\x42\x0\xa\x1b" },
73 };
74 struct {
75 char *raw;
76 regex_t regex;
77 } regex_values[] = {
78 { "dummy regex", dummy_re },
79 };
81 struct {
82 sdb_data_t datum;
83 ssize_t expected_len;
84 char *expected;
85 } golden_data[] = {
86 {
87 { SDB_TYPE_NULL, { .integer = 0 } },
88 4, "\0\0\0\0",
89 },
90 {
91 { SDB_TYPE_INTEGER, { .integer = 4711 } },
92 12, INT_TYPE "\0\0\0\0\0\0\x12\x67",
93 },
94 {
95 { SDB_TYPE_DECIMAL, { .decimal = 3.141592653e130 } },
96 12, DECIMAL_TYPE "\x5b\x6\xa9\x40\x66\x1e\x10\x4",
97 },
98 {
99 { SDB_TYPE_STRING, { .string = "some string" } },
100 16, STRING_TYPE "some string\0",
101 },
102 {
103 { SDB_TYPE_DATETIME, { .datetime = 1418923804000000 } },
104 12, DATETIME_TYPE "\x0\x5\xa\x80\xf1\x4c\xff\x0",
105 },
106 {
107 { SDB_TYPE_BINARY, { .binary = {
108 4, (unsigned char *)"\x42\x0\xa\x1b" } } },
109 12, BINARY_TYPE "\0\0\0\x4" "\x42\x0\xa\x1b",
110 },
111 {
112 { SDB_TYPE_REGEX, { .re = { "dummy", dummy_re } } },
113 10, REGEX_TYPE "dummy\0",
114 },
115 {
116 { SDB_TYPE_INTEGER | SDB_TYPE_ARRAY, { .array = {
117 3, int_values } } },
118 32, INT_ARRAY "\0\0\0\x3" "\0\0\0\0\0\0\0\x2f"
119 "\0\0\0\0\0\0\0\xb" "\0\0\0\0\0\0\0\x17"
120 },
121 {
122 { SDB_TYPE_DECIMAL | SDB_TYPE_ARRAY, { .array = {
123 2, dec_values } } },
124 24, DECIMAL_ARRAY "\0\0\0\x2" "\x40\x47\x8e\x14\x7a\xe1\x47\xae"
125 "\x3f\xe0\0\0\0\0\0\0"
126 },
127 {
128 { SDB_TYPE_STRING | SDB_TYPE_ARRAY, { .array = {
129 2, string_values } } },
130 17, STRING_ARRAY "\0\0\0\x2" "foo\0" "abcd\0"
131 },
132 {
133 { SDB_TYPE_DATETIME | SDB_TYPE_ARRAY, { .array = {
134 2, datetime_values } } },
135 24, DATETIME_ARRAY "\0\0\0\x2" "\0\0\0\0\0\0\x12\x67"
136 "\x11\x22\x10\xf4\x7d\xe9\x81\x15"
137 },
138 {
139 { SDB_TYPE_BINARY | SDB_TYPE_ARRAY, { .array = {
140 2, binary_values } } },
141 23, BINARY_ARRAY "\0\0\0\x2" "\0\0\0\x3" "\x1\x2\x3"
142 "\0\0\0\4" "\x42\x0\xa\x1b"
143 },
144 {
145 { SDB_TYPE_REGEX | SDB_TYPE_ARRAY, { .array = {
146 1, regex_values } } },
147 20, REGEX_ARRAY "\0\0\0\1" "dummy regex\0"
148 },
149 };
151 size_t i;
153 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
154 ssize_t len = sdb_proto_marshal_data(NULL, 0, &golden_data[i].datum);
155 char buf[len > 0 ? len : 1];
156 char v1[sdb_data_strlen(&golden_data[i].datum)];
157 char v2[sdb_data_strlen(&golden_data[i].datum)];
159 sdb_data_t datum = SDB_DATA_INIT;
160 ssize_t check;
162 if (sdb_data_format(&golden_data[i].datum, v1, sizeof(v1), 0) < 0)
163 snprintf(v1, sizeof(v1), "<ERR>");
165 fail_unless(len == golden_data[i].expected_len,
166 "<%zu> sdb_proto_marshal_data(NULL, 0, %s) = %zi; expected: %zi",
167 i, v1, len, golden_data[i].expected_len);
169 if (len < 0)
170 continue;
172 len = sdb_proto_marshal_data(buf, sizeof(buf), &golden_data[i].datum);
173 fail_unless(len == golden_data[i].expected_len,
174 "<%zu> sdb_proto_marshal_data(<buf>, %zu, %s) = %zi; expected: %zi",
175 i, sizeof(buf), v1, len, golden_data[i].expected_len);
176 if (memcmp(buf, golden_data[i].expected, len) != 0) {
177 size_t pos;
178 for (pos = 0; pos < (size_t)len; ++pos)
179 if (buf[pos] != golden_data[i].expected[pos])
180 break;
181 fail("<%zu> sdb_proto_marshal_data(%s) -> \"%s\"; expected: \"%s\" "
182 "(bytes %zu differ: '%x' != '%x')",
183 i, v1, buf, golden_data[i].expected,
184 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
185 }
187 check = sdb_proto_unmarshal_data(buf, len, &datum);
188 if (sdb_data_format(&datum, v2, sizeof(v2), 0) < 0)
189 snprintf(v2, sizeof(v2), "<ERR>");
191 if (sdb_data_isnull(&golden_data[i].datum))
192 fail_unless(sdb_data_isnull(&datum),
193 "<%zu> sdb_proto_unmarshal_data(buf<%s>) -> \"%s\"", i, v1, v2);
194 else
195 fail_unless(sdb_data_cmp(&golden_data[i].datum, &datum) == 0,
196 "<%zu> sdb_proto_unmarshal_data(buf<%s>) -> \"%s\"", i, v1, v2);
197 fail_unless(check == len,
198 "<%zu> sdb_proto_unmarshal_data(buf<%s>) = %zi; expected: %zi",
199 i, v1, check, len);
201 sdb_data_free_datum(&datum);
202 }
203 }
204 END_TEST
206 #define HOST_TYPE "\0\0\0\1"
207 #define SVC_TYPE "\0\0\0\2"
208 #define METRIC_TYPE "\0\0\0\3"
209 #define HOST_ATTR_TYPE "\0\0\0\x11"
210 #define SVC_ATTR_TYPE "\0\0\0\x12"
211 #define METRIC_ATTR_TYPE "\0\0\0\x13"
213 START_TEST(test_marshal_host)
214 {
215 struct {
216 sdb_proto_host_t host;
217 ssize_t expected_len;
218 char *expected;
219 } golden_data[] = {
220 {
221 { 4711, "hostA" },
222 18, HOST_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0"
223 },
224 {
225 { 0, "hostA" },
226 18, HOST_TYPE "\0\0\0\0\0\0\0\0" "hostA\0"
227 },
228 { { 4711, NULL }, -1, NULL },
229 };
231 size_t i;
233 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
234 ssize_t len = sdb_proto_marshal_host(NULL, 0, &golden_data[i].host);
235 char buf[len > 0 ? len : 1];
237 sdb_proto_host_t host;
238 ssize_t check;
240 fail_unless(len == golden_data[i].expected_len,
241 "<%zu> sdb_proto_marshal_host(NULL, 0, %s) = %zi; expected: %zi",
242 i, golden_data[i].host.name, len, golden_data[i].expected_len);
244 if (len < 0)
245 continue;
247 len = sdb_proto_marshal_host(buf, sizeof(buf), &golden_data[i].host);
248 fail_unless(len == golden_data[i].expected_len,
249 "<%zu> sdb_proto_marshal_host(<buf>, %zu, %s) = %zi; expected: %zi",
250 i, sizeof(buf), golden_data[i].host.name,
251 len, golden_data[i].expected_len);
252 if (memcmp(buf, golden_data[i].expected, len) != 0) {
253 size_t pos;
254 for (pos = 0; pos < (size_t)len; ++pos)
255 if (buf[pos] != golden_data[i].expected[pos])
256 break;
257 fail("<%zu> sdb_proto_marshal_host(%s) -> \"%s\"; expected: \"%s\" "
258 "(bytes %zu differ: '%x' != '%x')",
259 i, golden_data[i].host.name, buf, golden_data[i].expected,
260 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
261 }
263 check = sdb_proto_unmarshal_host(buf, len, &host);
264 fail_unless(check == len,
265 "<%zu> sdb_proto_unmarshal_host(buf<%s>) = %zi; expected: %zi",
266 i, golden_data[i].host.name, check, len);
267 fail_unless((host.last_update == golden_data[i].host.last_update)
268 && streq(host.name, golden_data[i].host.name),
269 "<%zu> sdb_proto_unmarshal_host(buf<%s>) = { %"PRIsdbTIME", %s }; "
270 "expected: { %"PRIsdbTIME", %s }", i, golden_data[i].host.name,
271 host.last_update, host.name, golden_data[i].host.last_update,
272 golden_data[i].host.name);
273 }
274 }
275 END_TEST
277 START_TEST(test_marshal_service)
278 {
279 struct {
280 sdb_proto_service_t svc;
281 ssize_t expected_len;
282 char *expected;
283 } golden_data[] = {
284 {
285 { 4711, "hostA", "serviceX" },
286 27, SVC_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0serviceX\0"
287 },
288 {
289 { 0, "hostA", "serviceX" },
290 27, SVC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0serviceX\0"
291 },
292 { { 4711, "hostA", NULL }, -1, NULL },
293 { { 4711, NULL, "serviceX" }, -1, NULL },
294 { { 4711, NULL, NULL }, -1, NULL },
295 };
297 size_t i;
299 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
300 ssize_t len = sdb_proto_marshal_service(NULL, 0, &golden_data[i].svc);
301 char buf[len > 0 ? len : 1];
303 sdb_proto_service_t svc;
304 ssize_t check;
306 fail_unless(len == golden_data[i].expected_len,
307 "<%zu> sdb_proto_marshal_service(NULL, 0, %s) = %zi; expected: %zi",
308 i, golden_data[i].svc.name, len, golden_data[i].expected_len);
310 if (len < 0)
311 continue;
313 len = sdb_proto_marshal_service(buf, sizeof(buf), &golden_data[i].svc);
314 fail_unless(len == golden_data[i].expected_len,
315 "<%zu> sdb_proto_marshal_service(<buf>, %zu, %s) = %zi; expected: %zi",
316 i, sizeof(buf), golden_data[i].svc.name,
317 len, golden_data[i].expected_len);
318 if (memcmp(buf, golden_data[i].expected, len) != 0) {
319 size_t pos;
320 for (pos = 0; pos < (size_t)len; ++pos)
321 if (buf[pos] != golden_data[i].expected[pos])
322 break;
323 fail("<%zu> sdb_proto_marshal_service(%s) -> \"%s\"; expected: \"%s\" "
324 "(bytes %zu differ: '%x' != '%x')",
325 i, golden_data[i].svc.name, buf, golden_data[i].expected,
326 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
327 }
329 check = sdb_proto_unmarshal_service(buf, len, &svc);
330 fail_unless(check == len,
331 "<%zu> sdb_proto_unmarshal_service(buf<%s>) = %zi; expected: %zi",
332 i, golden_data[i].svc.name, check, len);
333 fail_unless((svc.last_update == golden_data[i].svc.last_update)
334 && streq(svc.hostname, golden_data[i].svc.hostname)
335 && streq(svc.name, golden_data[i].svc.name),
336 "<%zu> sdb_proto_unmarshal_service(buf<%s>) = { %"PRIsdbTIME", %s, %s }; "
337 "expected: { %"PRIsdbTIME", %s, %s }", i, golden_data[i].svc.name,
338 svc.last_update, svc.hostname, svc.name, golden_data[i].svc.last_update,
339 golden_data[i].svc.hostname, golden_data[i].svc.name);
340 }
341 }
342 END_TEST
344 START_TEST(test_marshal_metric)
345 {
346 struct {
347 sdb_proto_metric_t metric;
348 ssize_t expected_len;
349 char *expected;
350 } golden_data[] = {
351 {
352 { 4711, "hostA", "metricX", NULL, NULL },
353 26, METRIC_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0metricX\0"
354 },
355 {
356 { 0, "hostA", "metricX", NULL, NULL },
357 26, METRIC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0metricX\0"
358 },
359 {
360 { 0, "hostA", "metricX", "type", NULL },
361 26, METRIC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0metricX\0"
362 },
363 {
364 { 0, "hostA", "metricX", NULL, "id" },
365 26, METRIC_TYPE "\0\0\0\0\0\0\0\0" "hostA\0metricX\0"
366 },
367 {
368 { 4711, "hostA", "metricX", "type", "id" },
369 34, METRIC_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0metricX\0type\0id\0"
370 },
371 { { 4711, "hostA", NULL, NULL, NULL }, -1, NULL },
372 { { 4711, NULL, "metricX", NULL, NULL }, -1, NULL },
373 { { 4711, NULL, NULL, NULL, NULL }, -1, NULL },
374 };
376 size_t i;
378 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
379 ssize_t len = sdb_proto_marshal_metric(NULL, 0, &golden_data[i].metric);
380 char buf[len > 0 ? len : 1];
382 sdb_proto_metric_t metric;
383 ssize_t check;
385 fail_unless(len == golden_data[i].expected_len,
386 "<%zu> sdb_proto_marshal_metric(NULL, 0, %s) = %zi; expected: %zi",
387 i, golden_data[i].metric.name, len, golden_data[i].expected_len);
389 if (len < 0)
390 continue;
392 len = sdb_proto_marshal_metric(buf, sizeof(buf), &golden_data[i].metric);
393 fail_unless(len == golden_data[i].expected_len,
394 "<%zu> sdb_proto_marshal_metric(<buf>, %zu, %s) = %zi; expected: %zi",
395 i, sizeof(buf), golden_data[i].metric.name,
396 len, golden_data[i].expected_len);
397 if (memcmp(buf, golden_data[i].expected, len) != 0) {
398 size_t pos;
399 for (pos = 0; pos < (size_t)len; ++pos)
400 if (buf[pos] != golden_data[i].expected[pos])
401 break;
402 fail("<%zu> sdb_proto_marshal_metric(%s) -> \"%s\"; expected: \"%s\" "
403 "(bytes %zu differ: '%x' != '%x')",
404 i, golden_data[i].metric.name, buf, golden_data[i].expected,
405 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
406 }
408 if ((! golden_data[i].metric.store_type)
409 || (! golden_data[i].metric.store_id)) {
410 /* if any of these is NULL, we expect both to be NULL */
411 golden_data[i].metric.store_type = NULL;
412 golden_data[i].metric.store_id = NULL;
413 }
415 check = sdb_proto_unmarshal_metric(buf, len, &metric);
416 fail_unless(check == len,
417 "<%zu> sdb_proto_unmarshal_metric(buf<%s>) = %zi; expected: %zi",
418 i, golden_data[i].metric.name, check, len);
419 fail_unless((metric.last_update == golden_data[i].metric.last_update)
420 && streq(metric.hostname, golden_data[i].metric.hostname)
421 && streq(metric.name, golden_data[i].metric.name)
422 && streq(metric.store_type, golden_data[i].metric.store_type)
423 && streq(metric.store_id, golden_data[i].metric.store_id),
424 "<%zu> sdb_proto_unmarshal_metric(buf<%s>) = "
425 "{ %"PRIsdbTIME", %s, %s, %s, %s }; expected: "
426 "{ %"PRIsdbTIME", %s, %s, %s, %s }", i, golden_data[i].metric.name,
427 metric.last_update, metric.hostname, metric.name,
428 metric.store_type, metric.store_id,
429 golden_data[i].metric.last_update,
430 golden_data[i].metric.hostname, golden_data[i].metric.name,
431 golden_data[i].metric.store_type, golden_data[i].metric.store_id);
432 }
433 }
434 END_TEST
436 START_TEST(test_marshal_attribute)
437 {
438 sdb_data_t v = { SDB_TYPE_INTEGER, { .integer = 4711 } };
439 #define VAL "\0\0\0\1" "\0\0\0\0\0\0\x12\x67"
440 struct {
441 sdb_proto_attribute_t attr;
442 ssize_t expected_len;
443 char *expected;
444 } golden_data[] = {
445 {
446 { 4711, SDB_HOST, NULL, "hostA", "k1", v },
447 33, HOST_ATTR_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0" "k1\0" VAL
448 },
449 {
450 { 4711, SDB_SERVICE, "hostA", "svc1", "k1", v },
451 38, SVC_ATTR_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0" "svc1\0" "k1\0" VAL
452 },
453 {
454 { 4711, SDB_METRIC, "hostA", "m1", "k1", v },
455 36, METRIC_ATTR_TYPE "\0\0\0\0\0\0\x12\x67" "hostA\0" "m1\0" "k1\0" VAL
456 },
457 { { 4711, SDB_HOST, NULL, NULL, "k1", v }, -1, NULL },
458 { { 4711, SDB_HOST, NULL, "hostA", NULL, v }, -1, NULL },
459 { { 4711, SDB_SERVICE, NULL, "svc1", "k1", v }, -1, NULL },
460 { { 4711, SDB_METRIC, NULL, "m1", "k1", v }, -1, NULL },
461 { { 4711, 0, "hostA", "svc1", "k1", v }, -1, NULL },
462 };
464 size_t i;
466 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
467 ssize_t len = sdb_proto_marshal_attribute(NULL, 0, &golden_data[i].attr);
468 char buf[len > 0 ? len : 1];
470 sdb_proto_attribute_t attr;
471 ssize_t check;
472 char v1[sdb_data_strlen(&golden_data[i].attr.value) + 1];
473 char v2[sdb_data_strlen(&golden_data[i].attr.value) + 1];
475 fail_unless(len == golden_data[i].expected_len,
476 "<%zu> sdb_proto_marshal_attribute(NULL, 0, %s) = %zi; expected: %zi",
477 i, golden_data[i].attr.key, len, golden_data[i].expected_len);
479 if (len < 0)
480 continue;
482 len = sdb_proto_marshal_attribute(buf, sizeof(buf), &golden_data[i].attr);
483 fail_unless(len == golden_data[i].expected_len,
484 "<%zu> sdb_proto_marshal_attribute(<buf>, %zu, %s) = %zi; expected: %zi",
485 i, sizeof(buf), golden_data[i].attr.key,
486 len, golden_data[i].expected_len);
487 if (memcmp(buf, golden_data[i].expected, len) != 0) {
488 size_t pos;
489 for (pos = 0; pos < (size_t)len; ++pos)
490 if (buf[pos] != golden_data[i].expected[pos])
491 break;
492 fail("<%zu> sdb_proto_marshal_attribute(%s) -> \"%s\"; expected: \"%s\" "
493 "(bytes %zu differ: '%x' != '%x')",
494 i, golden_data[i].attr.key, buf, golden_data[i].expected,
495 pos, (int)buf[pos], (int)golden_data[i].expected[pos]);
496 }
498 if (sdb_data_format(&golden_data[i].attr.value, v1, sizeof(v1), 0) < 0)
499 snprintf(v1, sizeof(v1), "<ERR>");
501 check = sdb_proto_unmarshal_attribute(buf, len, &attr);
502 fail_unless(check == len,
503 "<%zu> sdb_proto_unmarshal_attribute(buf<%s>) = %zi; expected: %zi",
504 i, golden_data[i].attr.key, check, len);
506 if (sdb_data_format(&attr.value, v2, sizeof(v2), 0) < 0)
507 snprintf(v2, sizeof(v2), "<ERR>");
508 fail_unless((attr.last_update == golden_data[i].attr.last_update)
509 && (attr.parent_type == golden_data[i].attr.parent_type)
510 && streq(attr.hostname, golden_data[i].attr.hostname)
511 && streq(attr.parent, golden_data[i].attr.parent)
512 && streq(attr.key, golden_data[i].attr.key)
513 && (sdb_data_cmp(&attr.value, &golden_data[i].attr.value) == 0),
514 "<%zu> sdb_proto_unmarshal_attribute(buf<%s>) = "
515 "{ %"PRIsdbTIME", %s, %s, %s, %s, %s }; expected: "
516 "{ %"PRIsdbTIME", %s, %s, %s, %s, %s }", i, golden_data[i].attr.key,
517 attr.last_update, SDB_STORE_TYPE_TO_NAME(attr.parent_type),
518 attr.hostname, attr.parent, attr.key, v1,
519 golden_data[i].attr.last_update,
520 SDB_STORE_TYPE_TO_NAME(golden_data[i].attr.parent_type),
521 golden_data[i].attr.hostname, golden_data[i].attr.parent,
522 golden_data[i].attr.key, v2);
523 }
524 }
525 END_TEST
527 Suite *
528 util_proto_suite(void)
529 {
530 Suite *s = suite_create("utils::proto");
531 TCase *tc;
533 tc = tcase_create("core");
534 tcase_add_test(tc, test_marshal_data);
535 tcase_add_test(tc, test_marshal_host);
536 tcase_add_test(tc, test_marshal_service);
537 tcase_add_test(tc, test_marshal_metric);
538 tcase_add_test(tc, test_marshal_attribute);
539 suite_add_tcase(s, tc);
541 return s;
542 } /* util_proto_suite */
544 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */