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