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 char buffer[16] = "";
36 char *ptr = &buffer[4];
37 char *ret;
39 buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
40 buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
42 ret = sstrncpy(ptr, "foobar", 8);
43 OK(ret == ptr);
44 EXPECT_EQ_STR("foobar", ptr);
45 OK(buffer[3] == buffer[12]);
47 ret = sstrncpy(ptr, "abc", 8);
48 OK(ret == ptr);
49 EXPECT_EQ_STR("abc", ptr);
50 OK(buffer[3] == buffer[12]);
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]);
58 return (0);
59 }
61 DEF_TEST(ssnprintf) {
62 char buffer[16] = "";
63 char *ptr = &buffer[4];
64 int status;
66 buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
67 buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
69 status = ssnprintf(ptr, 8, "%i", 1337);
70 OK(status == 4);
71 EXPECT_EQ_STR("1337", ptr);
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]);
79 return (0);
80 }
82 DEF_TEST(sstrdup) {
83 char *ptr;
85 ptr = sstrdup("collectd");
86 OK(ptr != NULL);
87 EXPECT_EQ_STR("collectd", ptr);
89 sfree(ptr);
91 ptr = sstrdup(NULL);
92 OK(ptr == NULL);
94 return (0);
95 }
97 DEF_TEST(strsplit) {
98 char buffer[32];
99 char *fields[8];
100 int status;
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]);
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]);
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]);
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]);
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]);
135 strncpy(buffer, "single", sizeof(buffer));
136 status = strsplit(buffer, fields, 8);
137 OK(status == 1);
138 EXPECT_EQ_STR("single", fields[0]);
140 strncpy(buffer, "", sizeof(buffer));
141 status = strsplit(buffer, fields, 8);
142 OK(status == 0);
144 return (0);
145 }
147 DEF_TEST(strjoin) {
148 char buffer[16];
149 char *fields[4];
150 int status;
152 fields[0] = "foo";
153 fields[1] = "bar";
154 fields[2] = "baz";
155 fields[3] = "qux";
157 status = strjoin(buffer, sizeof(buffer), fields, 2, "!");
158 OK(status == 7);
159 EXPECT_EQ_STR("foo!bar", buffer);
161 status = strjoin(buffer, sizeof(buffer), fields, 1, "!");
162 OK(status == 3);
163 EXPECT_EQ_STR("foo", buffer);
165 status = strjoin(buffer, sizeof(buffer), fields, 0, "!");
166 OK(status < 0);
168 status = strjoin(buffer, sizeof(buffer), fields, 2, "rcht");
169 OK(status == 10);
170 EXPECT_EQ_STR("foorchtbar", buffer);
172 status = strjoin(buffer, sizeof(buffer), fields, 4, "");
173 OK(status == 12);
174 EXPECT_EQ_STR("foobarbazqux", buffer);
176 status = strjoin(buffer, sizeof(buffer), fields, 4, "!");
177 OK(status == 15);
178 EXPECT_EQ_STR("foo!bar!baz!qux", buffer);
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);
187 return (0);
188 }
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 };
201 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
202 char buffer[32];
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 }
209 return 0;
210 }
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 };
226 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
227 char buffer[16];
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 }
234 return 0;
235 }
237 DEF_TEST(strunescape) {
238 char buffer[16];
239 int status;
241 strncpy(buffer, "foo\\tbar", sizeof(buffer));
242 status = strunescape(buffer, sizeof(buffer));
243 OK(status == 0);
244 EXPECT_EQ_STR("foo\tbar", buffer);
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);
251 strncpy(buffer, "With \\\"quotes\\\"", sizeof(buffer));
252 status = strunescape(buffer, sizeof(buffer));
253 OK(status == 0);
254 EXPECT_EQ_STR("With \"quotes\"", buffer);
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);
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');
275 return (0);
276 }
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 };
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 };
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 };
312 int status = parse_values(cases[i].buffer, &vl, &ds);
313 EXPECT_EQ_INT(cases[i].status, status);
314 if (status != 0)
315 continue;
317 EXPECT_EQ_DOUBLE(cases[i].value, vl.values[0].gauge);
318 }
320 return (0);
321 }
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 };
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;
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 }
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 }
369 return 0;
370 }
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);
384 END_TEST;
385 }
387 /* vim: set sw=2 sts=2 et : */