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 */
27 #include "testing.h"
28 #include "common.h"
30 DEF_TEST(sstrncpy)
31 {
32 char buffer[16] = "";
33 char *ptr = &buffer[4];
34 char *ret;
36 buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
37 buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
39 ret = sstrncpy (ptr, "foobar", 8);
40 OK(ret == ptr);
41 EXPECT_EQ_STR ("foobar", ptr);
42 OK(buffer[3] == buffer[12]);
44 ret = sstrncpy (ptr, "abc", 8);
45 OK(ret == ptr);
46 EXPECT_EQ_STR ("abc", ptr);
47 OK(buffer[3] == buffer[12]);
49 ret = sstrncpy (ptr, "collectd", 8);
50 OK(ret == ptr);
51 OK(ptr[7] == 0);
52 EXPECT_EQ_STR ("collect", ptr);
53 OK(buffer[3] == buffer[12]);
55 return (0);
56 }
58 DEF_TEST(ssnprintf)
59 {
60 char buffer[16] = "";
61 char *ptr = &buffer[4];
62 int status;
64 buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
65 buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
67 status = ssnprintf (ptr, 8, "%i", 1337);
68 OK(status == 4);
69 EXPECT_EQ_STR ("1337", ptr);
71 status = ssnprintf (ptr, 8, "%s", "collectd");
72 OK(status == 8);
73 OK(ptr[7] == 0);
74 EXPECT_EQ_STR ("collect", ptr);
75 OK(buffer[3] == buffer[12]);
77 return (0);
78 }
80 DEF_TEST(sstrdup)
81 {
82 char *ptr;
84 ptr = sstrdup ("collectd");
85 OK(ptr != NULL);
86 EXPECT_EQ_STR ("collectd", ptr);
88 sfree(ptr);
89 OK(ptr == NULL);
91 ptr = sstrdup (NULL);
92 OK(ptr == NULL);
94 return (0);
95 }
97 DEF_TEST(strsplit)
98 {
99 char buffer[32];
100 char *fields[8];
101 int status;
103 strncpy (buffer, "foo bar", sizeof (buffer));
104 status = strsplit (buffer, fields, 8);
105 OK(status == 2);
106 EXPECT_EQ_STR ("foo", fields[0]);
107 EXPECT_EQ_STR ("bar", fields[1]);
109 strncpy (buffer, "foo \t bar", sizeof (buffer));
110 status = strsplit (buffer, fields, 8);
111 OK(status == 2);
112 EXPECT_EQ_STR ("foo", fields[0]);
113 EXPECT_EQ_STR ("bar", fields[1]);
115 strncpy (buffer, "one two\tthree\rfour\nfive", sizeof (buffer));
116 status = strsplit (buffer, fields, 8);
117 OK(status == 5);
118 EXPECT_EQ_STR ("one", fields[0]);
119 EXPECT_EQ_STR ("two", fields[1]);
120 EXPECT_EQ_STR ("three", fields[2]);
121 EXPECT_EQ_STR ("four", fields[3]);
122 EXPECT_EQ_STR ("five", fields[4]);
124 strncpy (buffer, "\twith trailing\n", sizeof (buffer));
125 status = strsplit (buffer, fields, 8);
126 OK(status == 2);
127 EXPECT_EQ_STR ("with", fields[0]);
128 EXPECT_EQ_STR ("trailing", fields[1]);
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 EXPECT_EQ_STR ("7", fields[6]);
134 EXPECT_EQ_STR ("8", fields[7]);
136 strncpy (buffer, "single", sizeof (buffer));
137 status = strsplit (buffer, fields, 8);
138 OK(status == 1);
139 EXPECT_EQ_STR ("single", fields[0]);
141 strncpy (buffer, "", sizeof (buffer));
142 status = strsplit (buffer, fields, 8);
143 OK(status == 0);
145 return (0);
146 }
148 DEF_TEST(strjoin)
149 {
150 char buffer[16];
151 char *fields[4];
152 int status;
154 fields[0] = "foo";
155 fields[1] = "bar";
156 fields[2] = "baz";
157 fields[3] = "qux";
159 status = strjoin (buffer, sizeof (buffer), fields, 2, "!");
160 OK(status == 7);
161 EXPECT_EQ_STR ("foo!bar", buffer);
163 status = strjoin (buffer, sizeof (buffer), fields, 1, "!");
164 OK(status == 3);
165 EXPECT_EQ_STR ("foo", buffer);
167 status = strjoin (buffer, sizeof (buffer), fields, 0, "!");
168 OK(status < 0);
170 status = strjoin (buffer, sizeof (buffer), fields, 2, "rcht");
171 OK(status == 10);
172 EXPECT_EQ_STR ("foorchtbar", buffer);
174 status = strjoin (buffer, sizeof (buffer), fields, 4, "");
175 OK(status == 12);
176 EXPECT_EQ_STR ("foobarbazqux", buffer);
178 status = strjoin (buffer, sizeof (buffer), fields, 4, "!");
179 OK(status == 15);
180 EXPECT_EQ_STR ("foo!bar!baz!qux", buffer);
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);
189 return (0);
190 }
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;
205 for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
206 char buffer[32];
208 strncpy (buffer, cases[i].str, sizeof (buffer));
209 OK(escape_slashes (buffer, sizeof (buffer)) == 0);
210 EXPECT_EQ_STR(cases[i].want, buffer);
211 }
213 return 0;
214 }
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;
232 for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
233 char buffer[16];
235 strncpy (buffer, cases[i].str, sizeof (buffer));
236 OK(escape_string (buffer, sizeof (buffer)) == 0);
237 EXPECT_EQ_STR(cases[i].want, buffer);
238 }
240 return 0;
241 }
243 DEF_TEST(strunescape)
244 {
245 char buffer[16];
246 int status;
248 strncpy (buffer, "foo\\tbar", sizeof (buffer));
249 status = strunescape (buffer, sizeof (buffer));
250 OK(status == 0);
251 EXPECT_EQ_STR ("foo\tbar", buffer);
253 strncpy (buffer, "\\tfoo\\r\\n", sizeof (buffer));
254 status = strunescape (buffer, sizeof (buffer));
255 OK(status == 0);
256 EXPECT_EQ_STR ("\tfoo\r\n", buffer);
258 strncpy (buffer, "With \\\"quotes\\\"", sizeof (buffer));
259 status = strunescape (buffer, sizeof (buffer));
260 OK(status == 0);
261 EXPECT_EQ_STR ("With \"quotes\"", buffer);
263 /* Backslash before null byte */
264 strncpy (buffer, "\\tbackslash end\\", sizeof (buffer));
265 status = strunescape (buffer, sizeof (buffer));
266 OK(status != 0);
267 EXPECT_EQ_STR ("\tbackslash end", buffer);
268 return (0);
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');
282 return (0);
283 }
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 };
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 };
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 };
330 int status = parse_values (cases[i].buffer, &vl, &ds);
331 EXPECT_EQ_INT (cases[i].status, status);
332 if (status != 0)
333 continue;
335 EXPECT_EQ_DOUBLE (cases[i].value, vl.values[0].gauge);
336 }
338 return (0);
339 }
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;
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 gauge_t got;
367 if (cases[i].t0 == 0) {
368 OK(value_to_rate (&got, cases[i].v1, cases[i].ds_type, TIME_T_TO_CDTIME_T(cases[i].t1), &state) == EAGAIN);
369 continue;
370 }
372 OK(value_to_rate (&got, cases[i].v1, cases[i].ds_type, TIME_T_TO_CDTIME_T(cases[i].t1), &state) == 0);
373 EXPECT_EQ_DOUBLE(cases[i].want, got);
374 }
376 return 0;
377 }
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);
392 END_TEST;
393 }
395 /* vim: set sw=2 sts=2 et : */