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