src/daemon/common_test.c: Fix "decimal constant is unsigned only in ISO C90" warning.
[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 "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(escape_string)
217 {
218   struct {
219     char *str;
220     char *want;
221   } cases[] = {
222     {"foobar", "foobar"},
223     {"f00bar", "f00bar"},
224     {"foo bar", "\"foo bar\""},
225     {"foo \"bar\"", "\"foo \\\"bar\\\"\""},
226     {"012345678901234", "012345678901234"},
227     {"012345 78901234", "\"012345 789012\""},
228     {"012345 78901\"34", "\"012345 78901\""},
229   };
230   size_t i;
231
232   for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
233     char buffer[16];
234
235     strncpy (buffer, cases[i].str, sizeof (buffer));
236     OK(escape_string (buffer, sizeof (buffer)) == 0);
237     STREQ(cases[i].want, buffer);
238   }
239
240   return 0;
241 }
242
243 DEF_TEST(strunescape)
244 {
245   char buffer[16];
246   int status;
247
248   strncpy (buffer, "foo\\tbar", sizeof (buffer));
249   status = strunescape (buffer, sizeof (buffer));
250   OK(status == 0);
251   STREQ ("foo\tbar", buffer);
252
253   strncpy (buffer, "\\tfoo\\r\\n", sizeof (buffer));
254   status = strunescape (buffer, sizeof (buffer));
255   OK(status == 0);
256   STREQ ("\tfoo\r\n", buffer);
257
258   strncpy (buffer, "With \\\"quotes\\\"", sizeof (buffer));
259   status = strunescape (buffer, sizeof (buffer));
260   OK(status == 0);
261   STREQ ("With \"quotes\"", buffer);
262
263   /* Backslash before null byte */
264   strncpy (buffer, "\\tbackslash end\\", sizeof (buffer));
265   status = strunescape (buffer, sizeof (buffer));
266   OK(status != 0);
267   STREQ ("\tbackslash end", buffer);
268   return (0);
269
270   /* Backslash at buffer end */
271   strncpy (buffer, "\\t3\\56", sizeof (buffer));
272   status = strunescape (buffer, 4);
273   OK(status != 0);
274   OK(buffer[0] == '\t');
275   OK(buffer[1] == '3');
276   OK(buffer[2] == 0);
277   OK(buffer[3] == 0);
278   OK(buffer[4] == '5');
279   OK(buffer[5] == '6');
280   OK(buffer[6] == '7');
281
282   return (0);
283 }
284
285 DEF_TEST(parse_values)
286 {
287   struct {
288     char buffer[64];
289     int status;
290     gauge_t value;
291   } cases[] = {
292     {"1435044576:42",     0, 42.0},
293     {"1435044576:42:23", -1,  NAN},
294     {"1435044576:U",      0,  NAN},
295     {"N:12.3",            0, 12.3},
296     {"N:42.0:23",        -1,  NAN},
297     {"N:U",               0,  NAN},
298     {"T:42.0",           -1,  NAN},
299   };
300
301   size_t i;
302   for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
303   {
304     data_source_t dsrc = {
305       .name = "value",
306       .type = DS_TYPE_GAUGE,
307       .min = 0.0,
308       .max = NAN,
309     };
310     data_set_t ds = {
311       .type = "example",
312       .ds_num = 1,
313       .ds = &dsrc,
314     };
315
316     value_t v = {
317       .gauge = NAN,
318     };
319     value_list_t vl = {
320       .values = &v,
321       .values_len = 1,
322       .time = 0,
323       .interval = 0,
324       .host = "example.com",
325       .plugin = "common_test",
326       .type = "example",
327       .meta = NULL,
328     };
329
330     int status = parse_values (cases[i].buffer, &vl, &ds);
331     OK(status == cases[i].status);
332     if (status != 0)
333       continue;
334
335     OK(cases[i].value == vl.values[0].gauge);
336   }
337
338   return (0);
339 }
340
341 DEF_TEST(value_to_rate)
342 {
343   struct {
344     time_t t0;
345     time_t t1;
346     int ds_type;
347     value_t v0;
348     value_t v1;
349     gauge_t want;
350   } cases[] = {
351     { 0, 10, DS_TYPE_DERIVE,  {.derive  =    0}, {.derive = 1000},   NAN},
352     {10, 20, DS_TYPE_DERIVE,  {.derive  = 1000}, {.derive = 2000}, 100.0},
353     {20, 30, DS_TYPE_DERIVE,  {.derive  = 2000}, {.derive = 1800}, -20.0},
354     { 0, 10, DS_TYPE_COUNTER, {.counter =    0}, {.counter = 1000},   NAN},
355     {10, 20, DS_TYPE_COUNTER, {.counter = 1000}, {.counter = 5000}, 400.0},
356     /* 32bit wrap-around. */
357     {20, 30, DS_TYPE_COUNTER, {.counter = 4294967238ULL}, {.counter =   42}, 10.0},
358     /* 64bit wrap-around. */
359     {30, 40, DS_TYPE_COUNTER, {.counter = 18446744073709551558ULL}, {.counter =   42}, 10.0},
360   };
361   size_t i;
362
363   for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
364     value_to_rate_state_t state = { cases[i].v0, TIME_T_TO_CDTIME_T (cases[i].t0) };
365     value_t got;
366
367     if (cases[i].t0 == 0) {
368       OK(value_to_rate (&got, cases[i].v1.derive, &state, cases[i].ds_type, TIME_T_TO_CDTIME_T (cases[i].t1)) == EAGAIN);
369       continue;
370     }
371
372     OK(value_to_rate (&got, cases[i].v1.derive, &state, cases[i].ds_type, TIME_T_TO_CDTIME_T (cases[i].t1)) == 0);
373     DBLEQ(cases[i].want, got.gauge);
374   }
375
376   return 0;
377 }
378
379 int main (void)
380 {
381   RUN_TEST(sstrncpy);
382   RUN_TEST(ssnprintf);
383   RUN_TEST(sstrdup);
384   RUN_TEST(strsplit);
385   RUN_TEST(strjoin);
386   RUN_TEST(escape_slashes);
387   RUN_TEST(escape_string);
388   RUN_TEST(strunescape);
389   RUN_TEST(parse_values);
390   RUN_TEST(value_to_rate);
391
392   END_TEST;
393 }
394
395 /* vim: set sw=2 sts=2 et : */