2 * collectd - src/tests/test_common.c
3 * Copyright (C) 2013 Florian octo Forster
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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.
24 * Florian octo Forster <octo at collectd.org>
32 #endif /* HAVE_LIBKSTAT */
36 char *ptr = &buffer[4];
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);
44 EXPECT_EQ_STR("foobar", ptr);
45 OK(buffer[3] == buffer[12]);
47 ret = sstrncpy(ptr, "abc", 8);
49 EXPECT_EQ_STR("abc", ptr);
50 OK(buffer[3] == buffer[12]);
52 ret = sstrncpy(ptr, "collectd", 8);
55 EXPECT_EQ_STR("collect", ptr);
56 OK(buffer[3] == buffer[12]);
63 char *ptr = &buffer[4];
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);
71 EXPECT_EQ_STR("1337", ptr);
73 status = ssnprintf(ptr, 8, "%s", "collectd");
76 EXPECT_EQ_STR("collect", ptr);
77 OK(buffer[3] == buffer[12]);
85 ptr = sstrdup("collectd");
87 EXPECT_EQ_STR("collectd", ptr);
102 strncpy(buffer, "foo bar", sizeof(buffer));
103 status = strsplit(buffer, fields, 8);
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);
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);
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);
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);
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);
138 EXPECT_EQ_STR("single", fields[0]);
140 strncpy(buffer, "", sizeof(buffer));
141 status = strsplit(buffer, fields, 8);
157 {(char *[]){"foo", "bar"}, 2, "!", 7, "foo!bar"},
158 /* One field only. */
159 {(char *[]){"foo"}, 1, "!", 3, "foo"},
160 /* No fields at all. */
161 {NULL, 0, "!", 0, ""},
162 /* Longer separator. */
163 {(char *[]){"foo", "bar"}, 2, "rcht", 10, "foorchtbar"},
164 /* Empty separator. */
165 {(char *[]){"foo", "bar"}, 2, "", 6, "foobar"},
166 /* NULL separator. */
167 {(char *[]){"foo", "bar"}, 2, NULL, 6, "foobar"},
168 /* buffer not large enough -> string is truncated. */
169 {(char *[]){"aaaaaa", "bbbbbb", "c!"}, 3, "-", 16, "aaaaaa-bbbbbb-c"},
170 /* buffer not large enough -> last field fills buffer completely. */
171 {(char *[]){"aaaaaaa", "bbbbbbb", "!"}, 3, "-", 17, "aaaaaaa-bbbbbbb"},
172 /* buffer not large enough -> string does *not* end in separator. */
173 {(char *[]){"aaaa", "bbbb", "cccc", "!"}, 4, "-", 16, "aaaa-bbbb-cccc"},
174 /* buffer not large enough -> string does not end with partial
176 {(char *[]){"aaaaaa", "bbbbbb", "!"}, 3, "+-", 17, "aaaaaa+-bbbbbb"},
179 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
183 memset(buffer, 0xFF, sizeof(buffer));
184 status = strjoin(buffer, sizeof(buffer), cases[i].fields,
185 cases[i].fields_num, cases[i].separator);
186 EXPECT_EQ_INT(cases[i].want_return, status);
187 EXPECT_EQ_STR(cases[i].want_buffer, buffer);
189 /* use (NULL, 0) to determine required buffer size. */
190 EXPECT_EQ_INT(cases[i].want_return,
191 strjoin(NULL, 0, cases[i].fields, cases[i].fields_num,
192 cases[i].separator));
198 DEF_TEST(escape_slashes) {
203 {"foo/bar/baz", "foo_bar_baz"},
204 {"/like/a/path", "like_a_path"},
205 {"trailing/slash/", "trailing_slash_"},
206 {"foo//bar", "foo__bar"},
209 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
212 strncpy(buffer, cases[i].str, sizeof(buffer));
213 OK(escape_slashes(buffer, sizeof(buffer)) == 0);
214 EXPECT_EQ_STR(cases[i].want, buffer);
220 DEF_TEST(escape_string) {
225 {"foobar", "foobar"},
226 {"f00bar", "f00bar"},
227 {"foo bar", "\"foo bar\""},
228 {"foo \"bar\"", "\"foo \\\"bar\\\"\""},
229 {"012345678901234", "012345678901234"},
230 {"012345 78901234", "\"012345 789012\""},
231 {"012345 78901\"34", "\"012345 78901\""},
234 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
237 strncpy(buffer, cases[i].str, sizeof(buffer));
238 OK(escape_string(buffer, sizeof(buffer)) == 0);
239 EXPECT_EQ_STR(cases[i].want, buffer);
245 DEF_TEST(strunescape) {
249 strncpy(buffer, "foo\\tbar", sizeof(buffer));
250 status = strunescape(buffer, sizeof(buffer));
252 EXPECT_EQ_STR("foo\tbar", buffer);
254 strncpy(buffer, "\\tfoo\\r\\n", sizeof(buffer));
255 status = strunescape(buffer, sizeof(buffer));
257 EXPECT_EQ_STR("\tfoo\r\n", buffer);
259 strncpy(buffer, "With \\\"quotes\\\"", sizeof(buffer));
260 status = strunescape(buffer, sizeof(buffer));
262 EXPECT_EQ_STR("With \"quotes\"", buffer);
264 /* Backslash before null byte */
265 strncpy(buffer, "\\tbackslash end\\", sizeof(buffer));
266 status = strunescape(buffer, sizeof(buffer));
268 EXPECT_EQ_STR("\tbackslash end", buffer);
271 /* Backslash at buffer end */
272 strncpy(buffer, "\\t3\\56", sizeof(buffer));
273 status = strunescape(buffer, 4);
275 OK(buffer[0] == '\t');
276 OK(buffer[1] == '3');
279 OK(buffer[4] == '5');
280 OK(buffer[5] == '6');
281 OK(buffer[6] == '7');
286 DEF_TEST(parse_values) {
292 {"1435044576:42", 0, 42.0}, {"1435044576:42:23", -1, NAN},
293 {"1435044576:U", 0, NAN}, {"N:12.3", 0, 12.3},
294 {"N:42.0:23", -1, NAN}, {"N:U", 0, NAN},
298 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
299 data_source_t dsrc = {
300 .name = "value", .type = DS_TYPE_GAUGE, .min = 0.0, .max = NAN,
303 .type = "example", .ds_num = 1, .ds = &dsrc,
314 .host = "example.com",
315 .plugin = "common_test",
320 int status = parse_values(cases[i].buffer, &vl, &ds);
321 EXPECT_EQ_INT(cases[i].status, status);
325 EXPECT_EQ_DOUBLE(cases[i].value, vl.values[0].gauge);
331 DEF_TEST(value_to_rate) {
340 {0, 10, DS_TYPE_DERIVE, {.derive = 0}, {.derive = 1000}, NAN},
341 {10, 20, DS_TYPE_DERIVE, {.derive = 1000}, {.derive = 2000}, 100.0},
342 {20, 30, DS_TYPE_DERIVE, {.derive = 2000}, {.derive = 1800}, -20.0},
343 {0, 10, DS_TYPE_COUNTER, {.counter = 0}, {.counter = 1000}, NAN},
344 {10, 20, DS_TYPE_COUNTER, {.counter = 1000}, {.counter = 5000}, 400.0},
345 /* 32bit wrap-around. */
349 {.counter = 4294967238ULL},
352 /* 64bit wrap-around. */
356 {.counter = 18446744073709551558ULL},
361 for (size_t i = 0; i < STATIC_ARRAY_SIZE(cases); i++) {
362 cdtime_t t0 = TIME_T_TO_CDTIME_T(cases[i].t0);
363 value_to_rate_state_t state = {
364 .last_value = cases[i].v0, .last_time = t0,
368 if (cases[i].t0 == 0) {
369 EXPECT_EQ_INT(EAGAIN,
370 value_to_rate(&got, cases[i].v1, cases[i].ds_type,
371 TIME_T_TO_CDTIME_T(cases[i].t1), &state));
375 EXPECT_EQ_INT(0, value_to_rate(&got, cases[i].v1, cases[i].ds_type,
376 TIME_T_TO_CDTIME_T(cases[i].t1), &state));
377 EXPECT_EQ_DOUBLE(cases[i].want, got);
389 RUN_TEST(escape_slashes);
390 RUN_TEST(escape_string);
391 RUN_TEST(strunescape);
392 RUN_TEST(parse_values);
393 RUN_TEST(value_to_rate);
398 /* vim: set sw=2 sts=2 et : */