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
 190   /* use (NULL, 0) to determine required buffer size. */
 191   EXPECT_EQ_INT(3, strjoin(NULL, 0, (char *[]){"a", "b"}, 2, "-"));
 192
 193   return (0);
 194 }
 195
 196 DEF_TEST(escape_slashes) {
 197   struct {
 198     char *str;
 199     char *want;
 200   } cases[] = {
 201       {"foo/bar/baz", "foo_bar_baz"},
 202       {"/like/a/path", "like_a_path"},
 203       {"trailing/slash/", "trailing_slash_"},
 204       {"foo//bar", "foo__bar"},
 205   };
 206
 207   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 208     char buffer[32];
 209
 210     strncpy(buffer, cases[i].str, sizeof(buffer));
 211     OK(escape_slashes(buffer, sizeof(buffer)) == 0);
 212     EXPECT_EQ_STR(cases[i].want, buffer);
 213   }
 214
 215   return 0;
 216 }
 217
 218 DEF_TEST(escape_string) {
 219   struct {
 220     char *str;
 221     char *want;
 222   } cases[] = {
 223       {"foobar", "foobar"},
 224       {"f00bar", "f00bar"},
 225       {"foo bar", "\"foo bar\""},
 226       {"foo \"bar\"", "\"foo \\\"bar\\\"\""},
 227       {"012345678901234", "012345678901234"},
 228       {"012345 78901234", "\"012345 789012\""},
 229       {"012345 78901\"34", "\"012345 78901\""},
 230   };
 231
 232   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 233     char buffer[16];
 234
 235     strncpy(buffer, cases[i].str, sizeof(buffer));
 236     OK(escape_string(buffer, sizeof(buffer)) == 0);
 237     EXPECT_EQ_STR(cases[i].want, buffer);
 238   }
 239
 240   return 0;
 241 }
 242
 243 DEF_TEST(strunescape) {
 244   char buffer[16];
 245   int status;
 246
 247   strncpy(buffer, "foo\\tbar", sizeof(buffer));
 248   status = strunescape(buffer, sizeof(buffer));
 249   OK(status == 0);
 250   EXPECT_EQ_STR("foo\tbar", buffer);
 251
 252   strncpy(buffer, "\\tfoo\\r\\n", sizeof(buffer));
 253   status = strunescape(buffer, sizeof(buffer));
 254   OK(status == 0);
 255   EXPECT_EQ_STR("\tfoo\r\n", buffer);
 256
 257   strncpy(buffer, "With \\\"quotes\\\"", sizeof(buffer));
 258   status = strunescape(buffer, sizeof(buffer));
 259   OK(status == 0);
 260   EXPECT_EQ_STR("With \"quotes\"", buffer);
 261
 262   /* Backslash before null byte */
 263   strncpy(buffer, "\\tbackslash end\\", sizeof(buffer));
 264   status = strunescape(buffer, sizeof(buffer));
 265   OK(status != 0);
 266   EXPECT_EQ_STR("\tbackslash end", buffer);
 267   return (0);
 268
 269   /* Backslash at buffer end */
 270   strncpy(buffer, "\\t3\\56", sizeof(buffer));
 271   status = strunescape(buffer, 4);
 272   OK(status != 0);
 273   OK(buffer[0] == '\t');
 274   OK(buffer[1] == '3');
 275   OK(buffer[2] == 0);
 276   OK(buffer[3] == 0);
 277   OK(buffer[4] == '5');
 278   OK(buffer[5] == '6');
 279   OK(buffer[6] == '7');
 280
 281   return (0);
 282 }
 283
 284 DEF_TEST(parse_values) {
 285   struct {
 286     char buffer[64];
 287     int status;
 288     gauge_t value;
 289   } cases[] = {
 290       {"1435044576:42", 0, 42.0}, {"1435044576:42:23", -1, NAN},
 291       {"1435044576:U", 0, NAN},   {"N:12.3", 0, 12.3},
 292       {"N:42.0:23", -1, NAN},     {"N:U", 0, NAN},
 293       {"T:42.0", -1, NAN},
 294   };
 295
 296   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 297     data_source_t dsrc = {
 298         .name = "value", .type = DS_TYPE_GAUGE, .min = 0.0, .max = NAN,
 299     };
 300     data_set_t ds = {
 301         .type = "example", .ds_num = 1, .ds = &dsrc,
 302     };
 303
 304     value_t v = {
 305         .gauge = NAN,
 306     };
 307     value_list_t vl = {
 308         .values = &v,
 309         .values_len = 1,
 310         .time = 0,
 311         .interval = 0,
 312         .host = "example.com",
 313         .plugin = "common_test",
 314         .type = "example",
 315         .meta = NULL,
 316     };
 317
 318     int status = parse_values(cases[i].buffer, &vl, &ds);
 319     EXPECT_EQ_INT(cases[i].status, status);
 320     if (status != 0)
 321       continue;
 322
 323     EXPECT_EQ_DOUBLE(cases[i].value, vl.values[0].gauge);
 324   }
 325
 326   return (0);
 327 }
 328
 329 DEF_TEST(value_to_rate) {
 330   struct {
 331     time_t t0;
 332     time_t t1;
 333     int ds_type;
 334     value_t v0;
 335     value_t v1;
 336     gauge_t want;
 337   } cases[] = {
 338       {0, 10, DS_TYPE_DERIVE, {.derive = 0}, {.derive = 1000}, NAN},
 339       {10, 20, DS_TYPE_DERIVE, {.derive = 1000}, {.derive = 2000}, 100.0},
 340       {20, 30, DS_TYPE_DERIVE, {.derive = 2000}, {.derive = 1800}, -20.0},
 341       {0, 10, DS_TYPE_COUNTER, {.counter = 0}, {.counter = 1000}, NAN},
 342       {10, 20, DS_TYPE_COUNTER, {.counter = 1000}, {.counter = 5000}, 400.0},
 343       /* 32bit wrap-around. */
 344       {20,
 345        30,
 346        DS_TYPE_COUNTER,
 347        {.counter = 4294967238ULL},
 348        {.counter = 42},
 349        10.0},
 350       /* 64bit wrap-around. */
 351       {30,
 352        40,
 353        DS_TYPE_COUNTER,
 354        {.counter = 18446744073709551558ULL},
 355        {.counter = 42},
 356        10.0},
 357   };
 358
 359   for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
 360     cdtime_t t0 = TIME_T_TO_CDTIME_T(cases[i].t0);
 361     value_to_rate_state_t state = {
 362         .last_value = cases[i].v0, .last_time = t0,
 363     };
 364     gauge_t got;
 365
 366     if (cases[i].t0 == 0) {
 367       EXPECT_EQ_INT(EAGAIN,
 368                     value_to_rate(&got, cases[i].v1, cases[i].ds_type,
 369                                   TIME_T_TO_CDTIME_T(cases[i].t1), &state));
 370       continue;
 371     }
 372
 373     EXPECT_EQ_INT(0, value_to_rate(&got, cases[i].v1, cases[i].ds_type,
 374                                    TIME_T_TO_CDTIME_T(cases[i].t1), &state));
 375     EXPECT_EQ_DOUBLE(cases[i].want, got);
 376   }
 377
 378   return 0;
 379 }
 380
 381 int main(void) {
 382   RUN_TEST(sstrncpy);
 383   RUN_TEST(ssnprintf);
 384   RUN_TEST(sstrdup);
 385   RUN_TEST(strsplit);
 386   RUN_TEST(strjoin);
 387   RUN_TEST(escape_slashes);
 388   RUN_TEST(escape_string);
 389   RUN_TEST(strunescape);
 390   RUN_TEST(parse_values);
 391   RUN_TEST(value_to_rate);
 392
 393   END_TEST;
 394 }