t/unit/utils/proto_test.c

   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  */
  27
  28 #include "core/store.h"
  29 #include "utils/proto.h"
  30 #include "libsysdb_test.h"
  31
  32 #include <check.h>
  33 #include <stdbool.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36
  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 */
  44
  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"
  53
  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"
  61
  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         };
  80
  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         };
 150
 151         size_t i;
 152
 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)];
 158
 159                 sdb_data_t datum = SDB_DATA_INIT;
 160                 ssize_t check;
 161
 162                 if (sdb_data_format(&golden_data[i].datum, v1, sizeof(v1), 0) < 0)
 163                         snprintf(v1, sizeof(v1), "<ERR>");
 164
 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);
 168
 169                 if (len < 0)
 170                         continue;
 171
 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                 }
 186
 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>");
 190
 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);
 200
 201                 sdb_data_free_datum(&datum);
 202         }
 203 }
 204 END_TEST
 205
 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"
 212
 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         };
 230
 231         size_t i;
 232
 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];
 236
 237                 sdb_proto_host_t host;
 238                 ssize_t check;
 239
 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);
 243
 244                 if (len < 0)
 245                         continue;
 246
 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                 }
 262
 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
 276
 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         };
 296
 297         size_t i;
 298
 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];
 302
 303                 sdb_proto_service_t svc;
 304                 ssize_t check;
 305
 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);
 309
 310                 if (len < 0)
 311                         continue;
 312
 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                 }
 328
 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
 343
 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         };
 375
 376         size_t i;
 377
 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];
 381
 382                 sdb_proto_metric_t metric;
 383                 ssize_t check;
 384
 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);
 388
 389                 if (len < 0)
 390                         continue;
 391
 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                 }
 407
 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                 }
 414
 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
 435
 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         };
 463
 464         size_t i;
 465
 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];
 469
 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];
 474
 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);
 478
 479                 if (len < 0)
 480                         continue;
 481
 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                 }
 497
 498                 if (sdb_data_format(&golden_data[i].attr.value, v1, sizeof(v1), 0) < 0)
 499                         snprintf(v1, sizeof(v1), "<ERR>");
 500
 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);
 505
 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
 526
 527 Suite *
 528 util_proto_suite(void)
 529 {
 530         Suite *s = suite_create("utils::proto");
 531         TCase *tc;
 532
 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);
 540
 541         return s;
 542 } /* util_proto_suite */
 543
 544 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 545