src/daemon/common_test.c

   1 /**
   2  * collectd - src/tests/test_common.c
   3  * Copyright (C) 2013       Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at collectd.org>
  25  */
  26
  27 #include "common.h"
  28 #include "testing.h"
  29
  30 #if HAVE_LIBKSTAT
  31 kstat_ctl_t *kc;
  32 #endif /* HAVE_LIBKSTAT */
  33
  34 DEF_TEST(sstrncpy) {
  35   char buffer[16] = "";
  36   char *ptr = &buffer[4];
  37   char *ret;
  38
  39   buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
  40   buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
  41
  42   ret = sstrncpy(ptr, "foobar", 8);
  43   OK(ret == ptr);
  44   EXPECT_EQ_STR("foobar", ptr);
  45   OK(buffer[3] == buffer[12]);
  46
  47   ret = sstrncpy(ptr, "abc", 8);
  48   OK(ret == ptr);
  49   EXPECT_EQ_STR("abc", ptr);
  50   OK(buffer[3] == buffer[12]);
  51
  52   ret = sstrncpy(ptr, "collectd", 8);
  53   OK(ret == ptr);
  54   OK(ptr[7] == 0);
  55   EXPECT_EQ_STR("collect", ptr);
  56   OK(buffer[3] == buffer[12]);
  57
  58   return (0);
  59 }
  60
  61 DEF_TEST(ssnprintf) {
  62   char buffer[16] = "";
  63   char *ptr = &buffer[4];
  64   int status;
  65
  66   buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
  67   buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
  68
  69   status = ssnprintf(ptr, 8, "%i", 1337);
  70   OK(status == 4);
  71   EXPECT_EQ_STR("1337", ptr);
  72
  73   status = ssnprintf(ptr, 8, "%s", "collectd");
  74   OK(status == 8);
  75   OK(ptr[7] == 0);
  76   EXPECT_EQ_STR("collect", ptr);
  77   OK(buffer[3] == buffer[12]);
  78
  79   return (0);
  80 }
  81
  82 DEF_TEST(sstrdup) {
  83   char *ptr;
  84
  85   ptr = sstrdup("collectd");
  86   OK(ptr != NULL);
  87   EXPECT_EQ_STR("collectd", ptr);
  88
  89   sfree(ptr);
  90
  91   ptr = sstrdup(NULL);
  92   OK(ptr == NULL);
  93
  94   return (0);
  95 }
  96
  97 DEF_TEST(strsplit) {
  98   char buffer[32];
  99   char *fields[8];
 100   int status;
 101
 102   strncpy(buffer, "foo bar", sizeof(buffer));
 103   status = strsplit(buffer, fields, 8);
 104   OK(status == 2);
 105   EXPECT_EQ_STR("foo", fields[0]);
 106   EXPECT_EQ_STR("bar", fields[1]);
 107
 108   strncpy(buffer, "foo \t bar", sizeof(buffer));
 109   status = strsplit(buffer, fields, 8);
 110   OK(status == 2);
 111   EXPECT_EQ_STR("foo", fields[0]);
 112   EXPECT_EQ_STR("bar", fields[1]);
 113
 114   strncpy(buffer, "one two\tthree\rfour\nfive", sizeof(buffer));
 115   status = strsplit(buffer, fields, 8);
 116   OK(status == 5);
 117   EXPECT_EQ_STR("one", fields[0]);
 118   EXPECT_EQ_STR("two", fields[1]);
 119   EXPECT_EQ_STR("three", fields[2]);
 120   EXPECT_EQ_STR("four", fields[3]);
 121   EXPECT_EQ_STR("five", fields[4]);
 122
 123   strncpy(buffer, "\twith trailing\n", sizeof(buffer));
 124   status = strsplit(buffer, fields, 8);
 125   OK(status == 2);
 126   EXPECT_EQ_STR("with", fields[0]);
 127   EXPECT_EQ_STR("trailing", fields[1]);
 128
 129   strncpy(buffer, "1 2 3 4 5 6 7 8 9 10 11 12 13", sizeof(buffer));
 130   status = strsplit(buffer, fields, 8);
 131   OK(status == 8);
 132   EXPECT_EQ_STR("7", fields[6]);
 133   EXPECT_EQ_STR("8", fields[7]);
 134
 135   strncpy(buffer, "single", sizeof(buffer));
 136   status = strsplit(buffer, fields, 8);
 137   OK(status == 1);
 138   EXPECT_EQ_STR("single", fields[0]);
 139
 140   strncpy(buffer, "", sizeof(buffer));
 141   status = strsplit(buffer, fields, 8);
 142   OK(status == 0);
 143
 144   return (0);
 145 }
 146
 147 DEF_TEST(strjoin) {
 148   struct {
 149     char **fields;
 150     size_t fields_num;
 151     char *separator;
 152
 153     int want_return;
 154     char *want_buffer;
 155   } cases[] = {
 156       /* Normal case. */
 157       {(char *[]){"foo", "bar"}, 2, "!", 7, "foo!bar"},
 158       /* One field only. */
 159       {(char *[]){"foo"}, 1, "!", 3, "foo"},
 160       /* No fields at all. */
 161       {NULL, 0, "!", 0, ""},
 162       /* Longer separator. */
 163       {(char *[]){"foo", "bar"}, 2, "rcht", 10, "foorchtbar"},
 164       /* Empty separator. */
 165       {(char *[]){"foo", "bar"}, 2, "", 6, "foobar"},
 166       /* NULL separator. */
 167       {(char *[]){"foo", "bar"}, 2, NULL, 6, "foobar"},
 168       /* buffer not large enough -> string is truncated. */
 169       {(char *[]){"aaaaaa", "bbbbbb", "c!"}, 3, "-", 16, "aaaaaa-bbbbbb-c"},
 170       /* buffer not large enough -> last field fills buffer completely. */
 171       {(char *[]){"aaaaaaa", "bbbbbbb", "!"}, 3, "-", 17, "aaaaaaa-bbbbbbb"},
 172       /* buffer not large enough -> string does *not* end in separator. */
 173       {(char *[]){"aaaa", "bbbb", "cccc", "!"}, 4, "-", 16, "aaaa-bbbb-cccc"},
 174       /* buffer not large enough -> string does not end with partial
 175          separator. */
 176       {(char *[]){"aaaaaa", "bbbbbb", "!"}, 3, "+-", 17, "aaaaaa+-bbbbbb"},
 177   };
 178
 179   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 180     char buffer[16];
 181     int status;
 182
 183     memset(buffer, 0xFF, sizeof(buffer));
 184     status = strjoin(buffer, sizeof(buffer), cases[i].fields,
 185                      cases[i].fields_num, cases[i].separator);
 186     EXPECT_EQ_INT(cases[i].want_return, status);
 187     EXPECT_EQ_STR(cases[i].want_buffer, buffer);
 188
 189     /* use (NULL, 0) to determine required buffer size. */
 190     EXPECT_EQ_INT(cases[i].want_return,
 191                   strjoin(NULL, 0, cases[i].fields, cases[i].fields_num,
 192                           cases[i].separator));
 193   }
 194
 195   return (0);
 196 }
 197
 198 DEF_TEST(escape_slashes) {
 199   struct {
 200     char *str;
 201     char *want;
 202   } cases[] = {
 203       {"foo/bar/baz", "foo_bar_baz"},
 204       {"/like/a/path", "like_a_path"},
 205       {"trailing/slash/", "trailing_slash_"},
 206       {"foo//bar", "foo__bar"},
 207   };
 208
 209   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 210     char buffer[32];
 211
 212     strncpy(buffer, cases[i].str, sizeof(buffer));
 213     OK(escape_slashes(buffer, sizeof(buffer)) == 0);
 214     EXPECT_EQ_STR(cases[i].want, buffer);
 215   }
 216
 217   return 0;
 218 }
 219
 220 DEF_TEST(escape_string) {
 221   struct {
 222     char *str;
 223     char *want;
 224   } cases[] = {
 225       {"foobar", "foobar"},
 226       {"f00bar", "f00bar"},
 227       {"foo bar", "\"foo bar\""},
 228       {"foo \"bar\"", "\"foo \\\"bar\\\"\""},
 229       {"012345678901234", "012345678901234"},
 230       {"012345 78901234", "\"012345 789012\""},
 231       {"012345 78901\"34", "\"012345 78901\""},
 232   };
 233
 234   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 235     char buffer[16];
 236
 237     strncpy(buffer, cases[i].str, sizeof(buffer));
 238     OK(escape_string(buffer, sizeof(buffer)) == 0);
 239     EXPECT_EQ_STR(cases[i].want, buffer);
 240   }
 241
 242   return 0;
 243 }
 244
 245 DEF_TEST(strunescape) {
 246   char buffer[16];
 247   int status;
 248
 249   strncpy(buffer, "foo\\tbar", sizeof(buffer));
 250   status = strunescape(buffer, sizeof(buffer));
 251   OK(status == 0);
 252   EXPECT_EQ_STR("foo\tbar", buffer);
 253
 254   strncpy(buffer, "\\tfoo\\r\\n", sizeof(buffer));
 255   status = strunescape(buffer, sizeof(buffer));
 256   OK(status == 0);
 257   EXPECT_EQ_STR("\tfoo\r\n", buffer);
 258
 259   strncpy(buffer, "With \\\"quotes\\\"", sizeof(buffer));
 260   status = strunescape(buffer, sizeof(buffer));
 261   OK(status == 0);
 262   EXPECT_EQ_STR("With \"quotes\"", buffer);
 263
 264   /* Backslash before null byte */
 265   strncpy(buffer, "\\tbackslash end\\", sizeof(buffer));
 266   status = strunescape(buffer, sizeof(buffer));
 267   OK(status != 0);
 268   EXPECT_EQ_STR("\tbackslash end", buffer);
 269   return (0);
 270
 271   /* Backslash at buffer end */
 272   strncpy(buffer, "\\t3\\56", sizeof(buffer));
 273   status = strunescape(buffer, 4);
 274   OK(status != 0);
 275   OK(buffer[0] == '\t');
 276   OK(buffer[1] == '3');
 277   OK(buffer[2] == 0);
 278   OK(buffer[3] == 0);
 279   OK(buffer[4] == '5');
 280   OK(buffer[5] == '6');
 281   OK(buffer[6] == '7');
 282
 283   return (0);
 284 }
 285
 286 DEF_TEST(parse_values) {
 287   struct {
 288     char buffer[64];
 289     int status;
 290     gauge_t value;
 291   } cases[] = {
 292       {"1435044576:42", 0, 42.0}, {"1435044576:42:23", -1, NAN},
 293       {"1435044576:U", 0, NAN},   {"N:12.3", 0, 12.3},
 294       {"N:42.0:23", -1, NAN},     {"N:U", 0, NAN},
 295       {"T:42.0", -1, NAN},
 296   };
 297
 298   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 299     data_source_t dsrc = {
 300         .name = "value", .type = DS_TYPE_GAUGE, .min = 0.0, .max = NAN,
 301     };
 302     data_set_t ds = {
 303         .type = "example", .ds_num = 1, .ds = &dsrc,
 304     };
 305
 306     value_t v = {
 307         .gauge = NAN,
 308     };
 309     value_list_t vl = {
 310         .values = &v,
 311         .values_len = 1,
 312         .time = 0,
 313         .interval = 0,
 314         .host = "example.com",
 315         .plugin = "common_test",
 316         .type = "example",
 317         .meta = NULL,
 318     };
 319
 320     int status = parse_values(cases[i].buffer, &vl, &ds);
 321     EXPECT_EQ_INT(cases[i].status, status);
 322     if (status != 0)
 323       continue;
 324
 325     EXPECT_EQ_DOUBLE(cases[i].value, vl.values[0].gauge);
 326   }
 327
 328   return (0);
 329 }
 330
 331 DEF_TEST(value_to_rate) {
 332   struct {
 333     time_t t0;
 334     time_t t1;
 335     int ds_type;
 336     value_t v0;
 337     value_t v1;
 338     gauge_t want;
 339   } cases[] = {
 340       {0, 10, DS_TYPE_DERIVE, {.derive = 0}, {.derive = 1000}, NAN},
 341       {10, 20, DS_TYPE_DERIVE, {.derive = 1000}, {.derive = 2000}, 100.0},
 342       {20, 30, DS_TYPE_DERIVE, {.derive = 2000}, {.derive = 1800}, -20.0},
 343       {0, 10, DS_TYPE_COUNTER, {.counter = 0}, {.counter = 1000}, NAN},
 344       {10, 20, DS_TYPE_COUNTER, {.counter = 1000}, {.counter = 5000}, 400.0},
 345       /* 32bit wrap-around. */
 346       {20,
 347        30,
 348        DS_TYPE_COUNTER,
 349        {.counter = 4294967238ULL},
 350        {.counter = 42},
 351        10.0},
 352       /* 64bit wrap-around. */
 353       {30,
 354        40,
 355        DS_TYPE_COUNTER,
 356        {.counter = 18446744073709551558ULL},
 357        {.counter = 42},
 358        10.0},
 359   };
 360
 361   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 362     cdtime_t t0 = TIME_T_TO_CDTIME_T(cases[i].t0);
 363     value_to_rate_state_t state = {
 364         .last_value = cases[i].v0, .last_time = t0,
 365     };
 366     gauge_t got;
 367
 368     if (cases[i].t0 == 0) {
 369       EXPECT_EQ_INT(EAGAIN,
 370                     value_to_rate(&got, cases[i].v1, cases[i].ds_type,
 371                                   TIME_T_TO_CDTIME_T(cases[i].t1), &state));
 372       continue;
 373     }
 374
 375     EXPECT_EQ_INT(0, value_to_rate(&got, cases[i].v1, cases[i].ds_type,
 376                                    TIME_T_TO_CDTIME_T(cases[i].t1), &state));
 377     EXPECT_EQ_DOUBLE(cases[i].want, got);
 378   }
 379
 380   return 0;
 381 }
 382
 383 int main(void) {
 384   RUN_TEST(sstrncpy);
 385   RUN_TEST(ssnprintf);
 386   RUN_TEST(sstrdup);
 387   RUN_TEST(strsplit);
 388   RUN_TEST(strjoin);
 389   RUN_TEST(escape_slashes);
 390   RUN_TEST(escape_string);
 391   RUN_TEST(strunescape);
 392   RUN_TEST(parse_values);
 393   RUN_TEST(value_to_rate);
 394
 395   END_TEST;
 396 }
 397
 398 /* vim: set sw=2 sts=2 et : */