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 "common.h"
28 #include "testing.h"
30 #if HAVE_LIBKSTAT
31 kstat_ctl_t *kc;
32 #endif /* HAVE_LIBKSTAT */
34 DEF_TEST(sstrncpy)
35 {
36 char buffer[16] = "";
37 char *ptr = &buffer[4];
38 char *ret;
40 buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
41 buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
43 ret = sstrncpy (ptr, "foobar", 8);
44 OK(ret == ptr);
45 EXPECT_EQ_STR ("foobar", ptr);
46 OK(buffer[3] == buffer[12]);
48 ret = sstrncpy (ptr, "abc", 8);
49 OK(ret == ptr);
50 EXPECT_EQ_STR ("abc", ptr);
51 OK(buffer[3] == buffer[12]);
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]);
59 return (0);
60 }
62 DEF_TEST(ssnprintf)
63 {
64 char buffer[16] = "";
65 char *ptr = &buffer[4];
66 int status;
68 buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
69 buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
71 status = ssnprintf (ptr, 8, "%i", 1337);
72 OK(status == 4);
73 EXPECT_EQ_STR ("1337", ptr);
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]);
81 return (0);
82 }
84 DEF_TEST(sstrdup)
85 {
86 char *ptr;
88 ptr = sstrdup ("collectd");
89 OK(ptr != NULL);
90 EXPECT_EQ_STR ("collectd", ptr);
92 sfree(ptr);
94 ptr = sstrdup (NULL);
95 OK(ptr == NULL);
97 return (0);
98 }
100 DEF_TEST(strsplit)
101 {
102 char buffer[32];
103 char *fields[8];
104 int status;
106 strncpy (buffer, "foo bar", sizeof (buffer));
107 status = strsplit (buffer, fields, 8);
108 OK(status == 2);
109 EXPECT_EQ_STR ("foo", fields[0]);
110 EXPECT_EQ_STR ("bar", fields[1]);
112 strncpy (buffer, "foo \t bar", sizeof (buffer));
113 status = strsplit (buffer, fields, 8);
114 OK(status == 2);
115 EXPECT_EQ_STR ("foo", fields[0]);
116 EXPECT_EQ_STR ("bar", fields[1]);
118 strncpy (buffer, "one two\tthree\rfour\nfive", sizeof (buffer));
119 status = strsplit (buffer, fields, 8);
120 OK(status == 5);
121 EXPECT_EQ_STR ("one", fields[0]);
122 EXPECT_EQ_STR ("two", fields[1]);
123 EXPECT_EQ_STR ("three", fields[2]);
124 EXPECT_EQ_STR ("four", fields[3]);
125 EXPECT_EQ_STR ("five", fields[4]);
127 strncpy (buffer, "\twith trailing\n", sizeof (buffer));
128 status = strsplit (buffer, fields, 8);
129 OK(status == 2);
130 EXPECT_EQ_STR ("with", fields[0]);
131 EXPECT_EQ_STR ("trailing", fields[1]);
133 strncpy (buffer, "1 2 3 4 5 6 7 8 9 10 11 12 13", sizeof (buffer));
134 status = strsplit (buffer, fields, 8);
135 OK(status == 8);
136 EXPECT_EQ_STR ("7", fields[6]);
137 EXPECT_EQ_STR ("8", fields[7]);
139 strncpy (buffer, "single", sizeof (buffer));
140 status = strsplit (buffer, fields, 8);
141 OK(status == 1);
142 EXPECT_EQ_STR ("single", fields[0]);
144 strncpy (buffer, "", sizeof (buffer));
145 status = strsplit (buffer, fields, 8);
146 OK(status == 0);
148 return (0);
149 }
151 DEF_TEST(strjoin) {
152 struct {
153 char **fields;
154 size_t fields_num;
155 char *separator;
157 int want_return;
158 char *want_buffer;
159 } cases
160 [] = {
161 /* Normal case. */
162 {(char *[]){"foo", "bar"}, 2, "!", 7, "foo!bar"},
163 /* One field only. */
164 {(char *[]){"foo"}, 1, "!", 3, "foo"},
165 /* No fields at all. */
166 {NULL, 0, "!", 0, ""},
167 /* Longer separator. */
168 {(char *[]){"foo", "bar"}, 2, "rcht", 10, "foorchtbar"},
169 /* Empty separator. */
170 {(char *[]){"foo", "bar"}, 2, "", 6, "foobar"},
171 /* NULL separator. */
172 {(char *[]){"foo", "bar"}, 2, NULL, 6, "foobar"},
173 /* buffer not large enough -> string is truncated. */
174 {(char *[]){"aaaaaa", "bbbbbb", "c!"}, 3, "-", 16, "aaaaaa-bbbbbb-c"},
175 /* buffer not large enough -> last field fills buffer completely. */
176 {(char *[]){"aaaaaaa", "bbbbbbb", "!"}, 3, "-", 17,
177 "aaaaaaa-bbbbbbb"},
178 /* buffer not large enough -> string does *not* end in separator. */
179 {(char *[]){"aaaa", "bbbb", "cccc", "!"}, 4, "-", 16,
180 "aaaa-bbbb-cccc"},
181 /* buffer not large enough -> string does not end with partial
182 separator. */
183 {(char *[]){"aaaaaa", "bbbbbb", "!"}, 3, "+-", 17, "aaaaaa+-bbbbbb"},
184 };
186 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
187 char buffer[16];
188 int status;
190 memset(buffer, 0xFF, sizeof(buffer));
191 status = strjoin(buffer, sizeof(buffer), cases[i].fields,
192 cases[i].fields_num, cases[i].separator);
193 EXPECT_EQ_INT(cases[i].want_return, status);
194 EXPECT_EQ_STR(cases[i].want_buffer, buffer);
195 }
197 /* use (NULL, 0) to determine required buffer size. */
198 EXPECT_EQ_INT(3, strjoin(NULL, 0, (char *[]){"a", "b"}, 2, "-"));
200 return (0);
201 }
203 DEF_TEST(escape_slashes)
204 {
205 struct {
206 char *str;
207 char *want;
208 } cases[] = {
209 {"foo/bar/baz", "foo_bar_baz"},
210 {"/like/a/path", "like_a_path"},
211 {"trailing/slash/", "trailing_slash_"},
212 {"foo//bar", "foo__bar"},
213 };
215 for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
216 char buffer[32];
218 strncpy (buffer, cases[i].str, sizeof (buffer));
219 OK(escape_slashes (buffer, sizeof (buffer)) == 0);
220 EXPECT_EQ_STR(cases[i].want, buffer);
221 }
223 return 0;
224 }
226 DEF_TEST(escape_string)
227 {
228 struct {
229 char *str;
230 char *want;
231 } cases[] = {
232 {"foobar", "foobar"},
233 {"f00bar", "f00bar"},
234 {"foo bar", "\"foo bar\""},
235 {"foo \"bar\"", "\"foo \\\"bar\\\"\""},
236 {"012345678901234", "012345678901234"},
237 {"012345 78901234", "\"012345 789012\""},
238 {"012345 78901\"34", "\"012345 78901\""},
239 };
241 for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
242 char buffer[16];
244 strncpy (buffer, cases[i].str, sizeof (buffer));
245 OK(escape_string (buffer, sizeof (buffer)) == 0);
246 EXPECT_EQ_STR(cases[i].want, buffer);
247 }
249 return 0;
250 }
252 DEF_TEST(strunescape)
253 {
254 char buffer[16];
255 int status;
257 strncpy (buffer, "foo\\tbar", sizeof (buffer));
258 status = strunescape (buffer, sizeof (buffer));
259 OK(status == 0);
260 EXPECT_EQ_STR ("foo\tbar", buffer);
262 strncpy (buffer, "\\tfoo\\r\\n", sizeof (buffer));
263 status = strunescape (buffer, sizeof (buffer));
264 OK(status == 0);
265 EXPECT_EQ_STR ("\tfoo\r\n", buffer);
267 strncpy (buffer, "With \\\"quotes\\\"", sizeof (buffer));
268 status = strunescape (buffer, sizeof (buffer));
269 OK(status == 0);
270 EXPECT_EQ_STR ("With \"quotes\"", buffer);
272 /* Backslash before null byte */
273 strncpy (buffer, "\\tbackslash end\\", sizeof (buffer));
274 status = strunescape (buffer, sizeof (buffer));
275 OK(status != 0);
276 EXPECT_EQ_STR ("\tbackslash end", buffer);
277 return (0);
279 /* Backslash at buffer end */
280 strncpy (buffer, "\\t3\\56", sizeof (buffer));
281 status = strunescape (buffer, 4);
282 OK(status != 0);
283 OK(buffer[0] == '\t');
284 OK(buffer[1] == '3');
285 OK(buffer[2] == 0);
286 OK(buffer[3] == 0);
287 OK(buffer[4] == '5');
288 OK(buffer[5] == '6');
289 OK(buffer[6] == '7');
291 return (0);
292 }
294 DEF_TEST(parse_values)
295 {
296 struct {
297 char buffer[64];
298 int status;
299 gauge_t value;
300 } cases[] = {
301 {"1435044576:42", 0, 42.0},
302 {"1435044576:42:23", -1, NAN},
303 {"1435044576:U", 0, NAN},
304 {"N:12.3", 0, 12.3},
305 {"N:42.0:23", -1, NAN},
306 {"N:U", 0, NAN},
307 {"T:42.0", -1, NAN},
308 };
310 for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
311 {
312 data_source_t dsrc = {
313 .name = "value",
314 .type = DS_TYPE_GAUGE,
315 .min = 0.0,
316 .max = NAN,
317 };
318 data_set_t ds = {
319 .type = "example",
320 .ds_num = 1,
321 .ds = &dsrc,
322 };
324 value_t v = {
325 .gauge = NAN,
326 };
327 value_list_t vl = {
328 .values = &v,
329 .values_len = 1,
330 .time = 0,
331 .interval = 0,
332 .host = "example.com",
333 .plugin = "common_test",
334 .type = "example",
335 .meta = NULL,
336 };
338 int status = parse_values (cases[i].buffer, &vl, &ds);
339 EXPECT_EQ_INT (cases[i].status, status);
340 if (status != 0)
341 continue;
343 EXPECT_EQ_DOUBLE (cases[i].value, vl.values[0].gauge);
344 }
346 return (0);
347 }
349 DEF_TEST(value_to_rate)
350 {
351 struct {
352 time_t t0;
353 time_t t1;
354 int ds_type;
355 value_t v0;
356 value_t v1;
357 gauge_t want;
358 } cases[] = {
359 { 0, 10, DS_TYPE_DERIVE, {.derive = 0}, {.derive = 1000}, NAN},
360 {10, 20, DS_TYPE_DERIVE, {.derive = 1000}, {.derive = 2000}, 100.0},
361 {20, 30, DS_TYPE_DERIVE, {.derive = 2000}, {.derive = 1800}, -20.0},
362 { 0, 10, DS_TYPE_COUNTER, {.counter = 0}, {.counter = 1000}, NAN},
363 {10, 20, DS_TYPE_COUNTER, {.counter = 1000}, {.counter = 5000}, 400.0},
364 /* 32bit wrap-around. */
365 {20, 30, DS_TYPE_COUNTER, {.counter = 4294967238ULL}, {.counter = 42}, 10.0},
366 /* 64bit wrap-around. */
367 {30, 40, DS_TYPE_COUNTER, {.counter = 18446744073709551558ULL}, {.counter = 42}, 10.0},
368 };
370 for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
371 value_to_rate_state_t state = { cases[i].v0, TIME_T_TO_CDTIME_T (cases[i].t0) };
372 gauge_t got;
374 if (cases[i].t0 == 0) {
375 OK(value_to_rate (&got, cases[i].v1, cases[i].ds_type, TIME_T_TO_CDTIME_T(cases[i].t1), &state) == EAGAIN);
376 continue;
377 }
379 OK(value_to_rate (&got, cases[i].v1, cases[i].ds_type, TIME_T_TO_CDTIME_T(cases[i].t1), &state) == 0);
380 EXPECT_EQ_DOUBLE(cases[i].want, got);
381 }
383 return 0;
384 }
386 int main (void)
387 {
388 RUN_TEST(sstrncpy);
389 RUN_TEST(ssnprintf);
390 RUN_TEST(sstrdup);
391 RUN_TEST(strsplit);
392 RUN_TEST(strjoin);
393 RUN_TEST(escape_slashes);
394 RUN_TEST(escape_string);
395 RUN_TEST(strunescape);
396 RUN_TEST(parse_values);
397 RUN_TEST(value_to_rate);
399 END_TEST;
400 }
402 /* vim: set sw=2 sts=2 et : */