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