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