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_KSTAT_H
  31 #include <kstat.h>
  32 #endif
  33
  34 #if HAVE_LIBKSTAT
  35 kstat_ctl_t *kc;
  36 #endif /* HAVE_LIBKSTAT */
  37
  38 DEF_TEST(sstrncpy) {
  39   char buffer[16] = "";
  40   char *ptr = &buffer[4];
  41   char *ret;
  42
  43   buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
  44   buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
  45
  46   ret = sstrncpy(ptr, "foobar", 8);
  47   OK(ret == ptr);
  48   EXPECT_EQ_STR("foobar", ptr);
  49   OK(buffer[3] == buffer[12]);
  50
  51   ret = sstrncpy(ptr, "abc", 8);
  52   OK(ret == ptr);
  53   EXPECT_EQ_STR("abc", ptr);
  54   OK(buffer[3] == buffer[12]);
  55
  56   ret = sstrncpy(ptr, "collectd", 8);
  57   OK(ret == ptr);
  58   OK(ptr[7] == 0);
  59   EXPECT_EQ_STR("collect", ptr);
  60   OK(buffer[3] == buffer[12]);
  61
  62   return 0;
  63 }
  64
  65 DEF_TEST(sstrdup) {
  66   char *ptr;
  67
  68   ptr = sstrdup("collectd");
  69   OK(ptr != NULL);
  70   EXPECT_EQ_STR("collectd", ptr);
  71
  72   sfree(ptr);
  73
  74   ptr = sstrdup(NULL);
  75   OK(ptr == NULL);
  76
  77   return 0;
  78 }
  79
  80 DEF_TEST(strsplit) {
  81   char buffer[32];
  82   char *fields[8];
  83   int status;
  84
  85   strncpy(buffer, "foo bar", sizeof(buffer));
  86   status = strsplit(buffer, fields, 8);
  87   OK(status == 2);
  88   EXPECT_EQ_STR("foo", fields[0]);
  89   EXPECT_EQ_STR("bar", fields[1]);
  90
  91   strncpy(buffer, "foo \t bar", sizeof(buffer));
  92   status = strsplit(buffer, fields, 8);
  93   OK(status == 2);
  94   EXPECT_EQ_STR("foo", fields[0]);
  95   EXPECT_EQ_STR("bar", fields[1]);
  96
  97   strncpy(buffer, "one two\tthree\rfour\nfive", sizeof(buffer));
  98   status = strsplit(buffer, fields, 8);
  99   OK(status == 5);
 100   EXPECT_EQ_STR("one", fields[0]);
 101   EXPECT_EQ_STR("two", fields[1]);
 102   EXPECT_EQ_STR("three", fields[2]);
 103   EXPECT_EQ_STR("four", fields[3]);
 104   EXPECT_EQ_STR("five", fields[4]);
 105
 106   strncpy(buffer, "\twith trailing\n", sizeof(buffer));
 107   status = strsplit(buffer, fields, 8);
 108   OK(status == 2);
 109   EXPECT_EQ_STR("with", fields[0]);
 110   EXPECT_EQ_STR("trailing", fields[1]);
 111
 112   strncpy(buffer, "1 2 3 4 5 6 7 8 9 10 11 12 13", sizeof(buffer));
 113   status = strsplit(buffer, fields, 8);
 114   OK(status == 8);
 115   EXPECT_EQ_STR("7", fields[6]);
 116   EXPECT_EQ_STR("8", fields[7]);
 117
 118   strncpy(buffer, "single", sizeof(buffer));
 119   status = strsplit(buffer, fields, 8);
 120   OK(status == 1);
 121   EXPECT_EQ_STR("single", fields[0]);
 122
 123   strncpy(buffer, "", sizeof(buffer));
 124   status = strsplit(buffer, fields, 8);
 125   OK(status == 0);
 126
 127   return 0;
 128 }
 129
 130 DEF_TEST(strjoin) {
 131   struct {
 132     char **fields;
 133     size_t fields_num;
 134     char *separator;
 135
 136     int want_return;
 137     char *want_buffer;
 138   } cases[] = {
 139       /* Normal case. */
 140       {(char *[]){"foo", "bar"}, 2, "!", 7, "foo!bar"},
 141       /* One field only. */
 142       {(char *[]){"foo"}, 1, "!", 3, "foo"},
 143       /* No fields at all. */
 144       {NULL, 0, "!", 0, ""},
 145       /* Longer separator. */
 146       {(char *[]){"foo", "bar"}, 2, "rcht", 10, "foorchtbar"},
 147       /* Empty separator. */
 148       {(char *[]){"foo", "bar"}, 2, "", 6, "foobar"},
 149       /* NULL separator. */
 150       {(char *[]){"foo", "bar"}, 2, NULL, 6, "foobar"},
 151       /* buffer not large enough -> string is truncated. */
 152       {(char *[]){"aaaaaa", "bbbbbb", "c!"}, 3, "-", 16, "aaaaaa-bbbbbb-c"},
 153       /* buffer not large enough -> last field fills buffer completely. */
 154       {(char *[]){"aaaaaaa", "bbbbbbb", "!"}, 3, "-", 17, "aaaaaaa-bbbbbbb"},
 155       /* buffer not large enough -> string does *not* end in separator. */
 156       {(char *[]){"aaaa", "bbbb", "cccc", "!"}, 4, "-", 16, "aaaa-bbbb-cccc"},
 157       /* buffer not large enough -> string does not end with partial
 158          separator. */
 159       {(char *[]){"aaaaaa", "bbbbbb", "!"}, 3, "+-", 17, "aaaaaa+-bbbbbb"},
 160   };
 161
 162   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 163     char buffer[16];
 164     int status;
 165
 166     memset(buffer, 0xFF, sizeof(buffer));
 167     status = strjoin(buffer, sizeof(buffer), cases[i].fields,
 168                      cases[i].fields_num, cases[i].separator);
 169     EXPECT_EQ_INT(cases[i].want_return, status);
 170     EXPECT_EQ_STR(cases[i].want_buffer, buffer);
 171   }
 172
 173   /* use (NULL, 0) to determine required buffer size. */
 174   EXPECT_EQ_INT(3, strjoin(NULL, 0, (char *[]){"a", "b"}, 2, "-"));
 175
 176   return 0;
 177 }
 178
 179 DEF_TEST(escape_slashes) {
 180   struct {
 181     char *str;
 182     char *want;
 183   } cases[] = {
 184       {"foo/bar/baz", "foo_bar_baz"},
 185       {"/like/a/path", "like_a_path"},
 186       {"trailing/slash/", "trailing_slash_"},
 187       {"foo//bar", "foo__bar"},
 188   };
 189
 190   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 191     char buffer[32];
 192
 193     strncpy(buffer, cases[i].str, sizeof(buffer));
 194     OK(escape_slashes(buffer, sizeof(buffer)) == 0);
 195     EXPECT_EQ_STR(cases[i].want, buffer);
 196   }
 197
 198   return 0;
 199 }
 200
 201 DEF_TEST(escape_string) {
 202   struct {
 203     char *str;
 204     char *want;
 205   } cases[] = {
 206       {"foobar", "foobar"},
 207       {"f00bar", "f00bar"},
 208       {"foo bar", "\"foo bar\""},
 209       {"foo \"bar\"", "\"foo \\\"bar\\\"\""},
 210       {"012345678901234", "012345678901234"},
 211       {"012345 78901234", "\"012345 789012\""},
 212       {"012345 78901\"34", "\"012345 78901\""},
 213   };
 214
 215   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 216     char buffer[16];
 217
 218     strncpy(buffer, cases[i].str, sizeof(buffer));
 219     OK(escape_string(buffer, sizeof(buffer)) == 0);
 220     EXPECT_EQ_STR(cases[i].want, buffer);
 221   }
 222
 223   return 0;
 224 }
 225
 226 DEF_TEST(strunescape) {
 227   char buffer[16];
 228   int status;
 229
 230   strncpy(buffer, "foo\\tbar", sizeof(buffer));
 231   status = strunescape(buffer, sizeof(buffer));
 232   OK(status == 0);
 233   EXPECT_EQ_STR("foo\tbar", buffer);
 234
 235   strncpy(buffer, "\\tfoo\\r\\n", sizeof(buffer));
 236   status = strunescape(buffer, sizeof(buffer));
 237   OK(status == 0);
 238   EXPECT_EQ_STR("\tfoo\r\n", buffer);
 239
 240   strncpy(buffer, "With \\\"quotes\\\"", sizeof(buffer));
 241   status = strunescape(buffer, sizeof(buffer));
 242   OK(status == 0);
 243   EXPECT_EQ_STR("With \"quotes\"", buffer);
 244
 245   /* Backslash before null byte */
 246   strncpy(buffer, "\\tbackslash end\\", sizeof(buffer));
 247   status = strunescape(buffer, sizeof(buffer));
 248   OK(status != 0);
 249   EXPECT_EQ_STR("\tbackslash end", buffer);
 250   return 0;
 251
 252   /* Backslash at buffer end */
 253   strncpy(buffer, "\\t3\\56", sizeof(buffer));
 254   status = strunescape(buffer, 4);
 255   OK(status != 0);
 256   OK(buffer[0] == '\t');
 257   OK(buffer[1] == '3');
 258   OK(buffer[2] == 0);
 259   OK(buffer[3] == 0);
 260   OK(buffer[4] == '5');
 261   OK(buffer[5] == '6');
 262   OK(buffer[6] == '7');
 263
 264   return 0;
 265 }
 266
 267 DEF_TEST(parse_values) {
 268   struct {
 269     char buffer[64];
 270     int status;
 271     gauge_t value;
 272   } cases[] = {
 273       {"1435044576:42", 0, 42.0}, {"1435044576:42:23", -1, NAN},
 274       {"1435044576:U", 0, NAN},   {"N:12.3", 0, 12.3},
 275       {"N:42.0:23", -1, NAN},     {"N:U", 0, NAN},
 276       {"T:42.0", -1, NAN},
 277   };
 278
 279   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 280     data_source_t dsrc = {
 281         .name = "value", .type = DS_TYPE_GAUGE, .min = 0.0, .max = NAN,
 282     };
 283     data_set_t ds = {
 284         .type = "example", .ds_num = 1, .ds = &dsrc,
 285     };
 286
 287     value_t v = {
 288         .gauge = NAN,
 289     };
 290     value_list_t vl = {
 291         .values = &v,
 292         .values_len = 1,
 293         .time = 0,
 294         .interval = 0,
 295         .host = "example.com",
 296         .plugin = "common_test",
 297         .type = "example",
 298         .meta = NULL,
 299     };
 300
 301     int status = parse_values(cases[i].buffer, &vl, &ds);
 302     EXPECT_EQ_INT(cases[i].status, status);
 303     if (status != 0)
 304       continue;
 305
 306     EXPECT_EQ_DOUBLE(cases[i].value, vl.values[0].gauge);
 307   }
 308
 309   return 0;
 310 }
 311
 312 DEF_TEST(value_to_rate) {
 313   struct {
 314     time_t t0;
 315     time_t t1;
 316     int ds_type;
 317     value_t v0;
 318     value_t v1;
 319     gauge_t want;
 320   } cases[] = {
 321       {0, 10, DS_TYPE_DERIVE, {.derive = 0}, {.derive = 1000}, NAN},
 322       {10, 20, DS_TYPE_DERIVE, {.derive = 1000}, {.derive = 2000}, 100.0},
 323       {20, 30, DS_TYPE_DERIVE, {.derive = 2000}, {.derive = 1800}, -20.0},
 324       {0, 10, DS_TYPE_COUNTER, {.counter = 0}, {.counter = 1000}, NAN},
 325       {10, 20, DS_TYPE_COUNTER, {.counter = 1000}, {.counter = 5000}, 400.0},
 326       /* 32bit wrap-around. */
 327       {20,
 328        30,
 329        DS_TYPE_COUNTER,
 330        {.counter = 4294967238ULL},
 331        {.counter = 42},
 332        10.0},
 333       /* 64bit wrap-around. */
 334       {30,
 335        40,
 336        DS_TYPE_COUNTER,
 337        {.counter = 18446744073709551558ULL},
 338        {.counter = 42},
 339        10.0},
 340   };
 341
 342   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 343     cdtime_t t0 = TIME_T_TO_CDTIME_T(cases[i].t0);
 344     value_to_rate_state_t state = {
 345         .last_value = cases[i].v0, .last_time = t0,
 346     };
 347     gauge_t got;
 348
 349     if (cases[i].t0 == 0) {
 350       EXPECT_EQ_INT(EAGAIN,
 351                     value_to_rate(&got, cases[i].v1, cases[i].ds_type,
 352                                   TIME_T_TO_CDTIME_T(cases[i].t1), &state));
 353       continue;
 354     }
 355
 356     EXPECT_EQ_INT(0, value_to_rate(&got, cases[i].v1, cases[i].ds_type,
 357                                    TIME_T_TO_CDTIME_T(cases[i].t1), &state));
 358     EXPECT_EQ_DOUBLE(cases[i].want, got);
 359   }
 360
 361   return 0;
 362 }
 363
 364 int main(void) {
 365   RUN_TEST(sstrncpy);
 366   RUN_TEST(sstrdup);
 367   RUN_TEST(strsplit);
 368   RUN_TEST(strjoin);
 369   RUN_TEST(escape_slashes);
 370   RUN_TEST(escape_string);
 371   RUN_TEST(strunescape);
 372   RUN_TEST(parse_values);
 373   RUN_TEST(value_to_rate);
 374
 375   END_TEST;
 376 }