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 <stdio.h>
  34 #include <string.h>
  35
  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"
  44
  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"
  52
  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         };
  71
  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         };
 141
 142         size_t i;
 143
 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)];
 149
 150                 sdb_data_t datum = SDB_DATA_INIT;
 151                 ssize_t check;
 152
 153                 if (sdb_data_format(&golden_data[i].datum, v1, sizeof(v1), 0) < 0)
 154                         snprintf(v1, sizeof(v1), "<ERR>");
 155
 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);
 159
 160                 if (len < 0)
 161                         continue;
 162
 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                 }
 177
 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>");
 181
 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);
 191
 192                 sdb_data_free_datum(&datum);
 193         }
 194 }
 195 END_TEST
 196
 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"
 203
 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         };
 221
 222         size_t i;
 223
 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];
 227
 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);
 231
 232                 if (len < 0)
 233                         continue;
 234
 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
 253
 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         };
 273
 274         size_t i;
 275
 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];
 279
 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);
 283
 284                 if (len < 0)
 285                         continue;
 286
 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
 305
 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         };
 337
 338         size_t i;
 339
 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];
 343
 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);
 347
 348                 if (len < 0)
 349                         continue;
 350
 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
 369
 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         };
 398
 399         size_t i;
 400
 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];
 404
 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);
 408
 409                 if (len < 0)
 410                         continue;
 411
 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
 430
 431 Suite *
 432 util_proto_suite(void)
 433 {
 434         Suite *s = suite_create("utils::proto");
 435         TCase *tc;
 436
 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);
 444
 445         return s;
 446 } /* util_proto_suite */
 447
 448 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 449