Merge branch 'collectd-5.5'
[collectd.git] / 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 : */