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 "testing.h"
  28 #include "common.h"
  29
  30 DEF_TEST(sstrncpy)
  31 {
  32   char buffer[16] = "";
  33   char *ptr = &buffer[4];
  34   char *ret;
  35
  36   buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
  37   buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
  38
  39   ret = sstrncpy (ptr, "foobar", 8);
  40   OK(ret == ptr);
  41   STREQ ("foobar", ptr);
  42   OK(buffer[3] == buffer[12]);
  43
  44   ret = sstrncpy (ptr, "abc", 8);
  45   OK(ret == ptr);
  46   STREQ ("abc", ptr);
  47   OK(buffer[3] == buffer[12]);
  48
  49   ret = sstrncpy (ptr, "collectd", 8);
  50   OK(ret == ptr);
  51   OK(ptr[7] == 0);
  52   STREQ ("collect", ptr);
  53   OK(buffer[3] == buffer[12]);
  54
  55   return (0);
  56 }
  57
  58 DEF_TEST(ssnprintf)
  59 {
  60   char buffer[16] = "";
  61   char *ptr = &buffer[4];
  62   int status;
  63
  64   buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
  65   buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
  66
  67   status = ssnprintf (ptr, 8, "%i", 1337);
  68   OK(status == 4);
  69   STREQ ("1337", ptr);
  70
  71   status = ssnprintf (ptr, 8, "%s", "collectd");
  72   OK(status == 8);
  73   OK(ptr[7] == 0);
  74   STREQ ("collect", ptr);
  75   OK(buffer[3] == buffer[12]);
  76
  77   return (0);
  78 }
  79
  80 DEF_TEST(sstrdup)
  81 {
  82   char *ptr;
  83
  84   ptr = sstrdup ("collectd");
  85   OK(ptr != NULL);
  86   STREQ ("collectd", ptr);
  87
  88   sfree(ptr);
  89   OK(ptr == NULL);
  90
  91   ptr = sstrdup (NULL);
  92   OK(ptr == NULL);
  93
  94   return (0);
  95 }
  96
  97 DEF_TEST(strsplit)
  98 {
  99   char buffer[32];
 100   char *fields[8];
 101   int status;
 102
 103   strncpy (buffer, "foo bar", sizeof (buffer));
 104   status = strsplit (buffer, fields, 8);
 105   OK(status == 2);
 106   STREQ ("foo", fields[0]);
 107   STREQ ("bar", fields[1]);
 108
 109   strncpy (buffer, "foo \t bar", sizeof (buffer));
 110   status = strsplit (buffer, fields, 8);
 111   OK(status == 2);
 112   STREQ ("foo", fields[0]);
 113   STREQ ("bar", fields[1]);
 114
 115   strncpy (buffer, "one two\tthree\rfour\nfive", sizeof (buffer));
 116   status = strsplit (buffer, fields, 8);
 117   OK(status == 5);
 118   STREQ ("one", fields[0]);
 119   STREQ ("two", fields[1]);
 120   STREQ ("three", fields[2]);
 121   STREQ ("four", fields[3]);
 122   STREQ ("five", fields[4]);
 123
 124   strncpy (buffer, "\twith trailing\n", sizeof (buffer));
 125   status = strsplit (buffer, fields, 8);
 126   OK(status == 2);
 127   STREQ ("with", fields[0]);
 128   STREQ ("trailing", fields[1]);
 129
 130   strncpy (buffer, "1 2 3 4 5 6 7 8 9 10 11 12 13", sizeof (buffer));
 131   status = strsplit (buffer, fields, 8);
 132   OK(status == 8);
 133   STREQ ("7", fields[6]);
 134   STREQ ("8", fields[7]);
 135
 136   strncpy (buffer, "single", sizeof (buffer));
 137   status = strsplit (buffer, fields, 8);
 138   OK(status == 1);
 139   STREQ ("single", fields[0]);
 140
 141   strncpy (buffer, "", sizeof (buffer));
 142   status = strsplit (buffer, fields, 8);
 143   OK(status == 0);
 144
 145   return (0);
 146 }
 147
 148 DEF_TEST(strjoin)
 149 {
 150   char buffer[16];
 151   char *fields[4];
 152   int status;
 153
 154   fields[0] = "foo";
 155   fields[1] = "bar";
 156   fields[2] = "baz";
 157   fields[3] = "qux";
 158
 159   status = strjoin (buffer, sizeof (buffer), fields, 2, "!");
 160   OK(status == 7);
 161   STREQ ("foo!bar", buffer);
 162
 163   status = strjoin (buffer, sizeof (buffer), fields, 1, "!");
 164   OK(status == 3);
 165   STREQ ("foo", buffer);
 166
 167   status = strjoin (buffer, sizeof (buffer), fields, 0, "!");
 168   OK(status < 0);
 169
 170   status = strjoin (buffer, sizeof (buffer), fields, 2, "rcht");
 171   OK(status == 10);
 172   STREQ ("foorchtbar", buffer);
 173
 174   status = strjoin (buffer, sizeof (buffer), fields, 4, "");
 175   OK(status == 12);
 176   STREQ ("foobarbazqux", buffer);
 177
 178   status = strjoin (buffer, sizeof (buffer), fields, 4, "!");
 179   OK(status == 15);
 180   STREQ ("foo!bar!baz!qux", buffer);
 181
 182   fields[0] = "0123";
 183   fields[1] = "4567";
 184   fields[2] = "8901";
 185   fields[3] = "2345";
 186   status = strjoin (buffer, sizeof (buffer), fields, 4, "-");
 187   OK(status < 0);
 188
 189   return (0);
 190 }
 191
 192 DEF_TEST(escape_slashes)
 193 {
 194   struct {
 195     char *str;
 196     char *want;
 197   } cases[] = {
 198     {"foo/bar/baz", "foo_bar_baz"},
 199     {"/like/a/path", "like_a_path"},
 200     {"trailing/slash/", "trailing_slash_"},
 201     {"foo//bar", "foo__bar"},
 202   };
 203   size_t i;
 204
 205   for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
 206     char buffer[32];
 207
 208     strncpy (buffer, cases[i].str, sizeof (buffer));
 209     OK(escape_slashes (buffer, sizeof (buffer)) == 0);
 210     STREQ(cases[i].want, buffer);
 211   }
 212
 213   return 0;
 214 }
 215
 216 DEF_TEST(strunescape)
 217 {
 218   char buffer[16];
 219   int status;
 220
 221   strncpy (buffer, "foo\\tbar", sizeof (buffer));
 222   status = strunescape (buffer, sizeof (buffer));
 223   OK(status == 0);
 224   STREQ ("foo\tbar", buffer);
 225
 226   strncpy (buffer, "\\tfoo\\r\\n", sizeof (buffer));
 227   status = strunescape (buffer, sizeof (buffer));
 228   OK(status == 0);
 229   STREQ ("\tfoo\r\n", buffer);
 230
 231   strncpy (buffer, "With \\\"quotes\\\"", sizeof (buffer));
 232   status = strunescape (buffer, sizeof (buffer));
 233   OK(status == 0);
 234   STREQ ("With \"quotes\"", buffer);
 235
 236   /* Backslash before null byte */
 237   strncpy (buffer, "\\tbackslash end\\", sizeof (buffer));
 238   status = strunescape (buffer, sizeof (buffer));
 239   OK(status != 0);
 240   STREQ ("\tbackslash end", buffer);
 241   return (0);
 242
 243   /* Backslash at buffer end */
 244   strncpy (buffer, "\\t3\\56", sizeof (buffer));
 245   status = strunescape (buffer, 4);
 246   OK(status != 0);
 247   OK(buffer[0] == '\t');
 248   OK(buffer[1] == '3');
 249   OK(buffer[2] == 0);
 250   OK(buffer[3] == 0);
 251   OK(buffer[4] == '5');
 252   OK(buffer[5] == '6');
 253   OK(buffer[6] == '7');
 254
 255   return (0);
 256 }
 257
 258 DEF_TEST(parse_values)
 259 {
 260   struct {
 261     char buffer[64];
 262     int status;
 263     gauge_t value;
 264   } cases[] = {
 265     {"1435044576:42",     0, 42.0},
 266     {"1435044576:42:23", -1,  NAN},
 267     {"1435044576:U",      0,  NAN},
 268     {"N:12.3",            0, 12.3},
 269     {"N:42.0:23",        -1,  NAN},
 270     {"N:U",               0,  NAN},
 271     {"T:42.0",           -1,  NAN},
 272   };
 273
 274   size_t i;
 275   for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
 276   {
 277     data_source_t dsrc = {
 278       .name = "value",
 279       .type = DS_TYPE_GAUGE,
 280       .min = 0.0,
 281       .max = NAN,
 282     };
 283     data_set_t ds = {
 284       .type = "example",
 285       .ds_num = 1,
 286       .ds = &dsrc,
 287     };
 288
 289     value_t v = {
 290       .gauge = NAN,
 291     };
 292     value_list_t vl = {
 293       .values = &v,
 294       .values_len = 1,
 295       .time = 0,
 296       .interval = 0,
 297       .host = "example.com",
 298       .plugin = "common_test",
 299       .type = "example",
 300       .meta = NULL,
 301     };
 302
 303     int status = parse_values (cases[i].buffer, &vl, &ds);
 304     OK(status == cases[i].status);
 305     if (status != 0)
 306       continue;
 307
 308     OK(cases[i].value == vl.values[0].gauge);
 309   }
 310
 311   return (0);
 312 }
 313
 314 int main (void)
 315 {
 316   RUN_TEST(sstrncpy);
 317   RUN_TEST(ssnprintf);
 318   RUN_TEST(sstrdup);
 319   RUN_TEST(strsplit);
 320   RUN_TEST(strjoin);
 321   RUN_TEST(escape_slashes);
 322   RUN_TEST(strunescape);
 323   RUN_TEST(parse_values);
 324
 325   END_TEST;
 326 }
 327
 328 /* vim: set sw=2 sts=2 et : */