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