Debian Codegraph @

src/utils/message_parser/message_parser_test.c

raw
1 /**
2 * collectd - src/utils/message_parser/message_parser_test.c
3 *
4 * Copyright(c) 2018 Intel Corporation. All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 *
24 * Authors:
25 * Marcin Mozejko <[email protected]>
26 **/
27
28 #include "testing.h"
29 #include "utils/message_parser/message_parser.c"
30
31 #define TEST_PATTERN_NAME "test_pattern_name"
32 #define TEST_REGEX "test_regex"
33 #define TEST_EX_REGEX "test_ex_regex"
34 #define TEST_MSG_ITEM_NAME "test_msg_item_name"
35 #define TEST_MSG_ITEM_VAL "test_msg_item_value"
36 #define TEST_FILENAME "test_filename"
37 #define TEST_PATTERNS_LEN 4
38
39 static int start_message_assembly_mock_error(parser_job_data_t *self) {
40 return -1;
41 }
42
43 static int start_message_assembly_mock_success(parser_job_data_t *self) {
44 return 0;
45 }
46
47 static void message_item_assembly_mock(parser_job_data_t *self,
48 checked_match_t *cm,
49 char *const *matches) {
50 return;
51 }
52
53 static void end_message_assembly_mock(parser_job_data_t *self) { return; }
54
55 DEF_TEST(msg_item_assembly) {
56 parser_job_data_t *job = calloc(1, sizeof(*job));
57 checked_match_t *cm = calloc(1, sizeof(*cm));
58 char *const matches[] = {"test_match0", "test_match1"};
59
60 job->messages_storage = calloc(1, sizeof(*job->messages_storage));
61 job->message_idx = 0;
62
63 cm->parser_job = job;
64 cm->msg_pattern.name = TEST_PATTERN_NAME;
65 cm->msg_pattern.regex = TEST_REGEX;
66 cm->msg_pattern.submatch_idx = 1;
67 cm->msg_pattern.excluderegex = TEST_EX_REGEX;
68 cm->msg_pattern.is_mandatory = false;
69 cm->msg_pattern_idx = 0;
70
71 message_item_t *msg_it = &(job->messages_storage[job->message_idx]
72 .message_items[job->message_item_idx]);
73
74 message_item_assembly(job, cm, matches);
75
76 EXPECT_EQ_STR(msg_it->name, TEST_PATTERN_NAME);
77 EXPECT_EQ_STR(msg_it->value, "test_match1");
78
79 sfree(cm);
80 sfree(job->messages_storage);
81 sfree(job);
82
83 return 0;
84 }
85
86 DEF_TEST(start_msg_item_assembly_1) {
87 parser_job_data_t *job = calloc(1, sizeof(*job));
88
89 job->messages_max_len = MSG_STOR_INIT_LEN;
90 job->message_idx = 0;
91 job->message_item_idx = 1;
92 job->messages_storage =
93 calloc(job->messages_max_len, sizeof(*job->messages_storage));
94 job->messages_storage[0].started = true;
95 job->messages_storage[0].completed = false;
96
97 sstrncpy(job->messages_storage[0].message_items[0].name, TEST_MSG_ITEM_NAME,
98 sizeof(TEST_MSG_ITEM_NAME));
99 sstrncpy(job->messages_storage[0].message_items[0].value, TEST_MSG_ITEM_VAL,
100 sizeof(TEST_MSG_ITEM_VAL));
101
102 int ret = start_message_assembly(job);
103
104 EXPECT_EQ_STR("", job->messages_storage[0].message_items[0].name);
105 EXPECT_EQ_STR("", job->messages_storage[0].message_items[0].value);
106 EXPECT_EQ_INT(0, job->message_item_idx);
107 EXPECT_EQ_INT(0, ret);
108 sfree(job->messages_storage);
109 sfree(job);
110
111 return 0;
112 }
113
114 DEF_TEST(start_msg_item_assembly_2) {
115 parser_job_data_t *job = calloc(1, sizeof(*job));
116
117 job->messages_max_len = MSG_STOR_INIT_LEN;
118 job->message_idx = 0;
119 job->message_item_idx = 1;
120 job->messages_storage =
121 calloc(job->messages_max_len, sizeof(*job->messages_storage));
122 job->messages_storage[0].started = true;
123 job->messages_storage[0].completed = true;
124
125 sstrncpy(job->messages_storage[0].message_items[0].name, TEST_MSG_ITEM_NAME,
126 sizeof(TEST_MSG_ITEM_NAME));
127 sstrncpy(job->messages_storage[0].message_items[0].value, TEST_MSG_ITEM_VAL,
128 sizeof(TEST_MSG_ITEM_VAL));
129
130 int ret = start_message_assembly(job);
131
132 EXPECT_EQ_STR("", job->messages_storage[1].message_items[0].name);
133 EXPECT_EQ_STR("", job->messages_storage[1].message_items[0].value);
134 EXPECT_EQ_STR(TEST_MSG_ITEM_NAME,
135 job->messages_storage[0].message_items[0].name);
136 EXPECT_EQ_STR(TEST_MSG_ITEM_VAL,
137 job->messages_storage[0].message_items[0].value);
138
139 EXPECT_EQ_INT(0, job->message_item_idx);
140 EXPECT_EQ_INT(1, job->message_idx);
141 EXPECT_EQ_INT(0, ret);
142 sfree(job->messages_storage);
143 sfree(job);
144
145 return 0;
146 }
147
148 DEF_TEST(start_msg_item_assembly_3) {
149 parser_job_data_t *job = calloc(1, sizeof(*job));
150
151 job->messages_max_len = 1;
152 job->message_idx = 0;
153 job->message_item_idx = 1;
154 job->messages_storage =
155 calloc(job->messages_max_len, sizeof(*job->messages_storage));
156 job->messages_storage[0].started = true;
157 job->messages_storage[0].completed = true;
158 job->resize_message_buffer = resize_message_buffer;
159
160 sstrncpy(job->messages_storage[0].message_items[0].name, TEST_MSG_ITEM_NAME,
161 sizeof(TEST_MSG_ITEM_NAME));
162 sstrncpy(job->messages_storage[0].message_items[0].value, TEST_MSG_ITEM_VAL,
163 sizeof(TEST_MSG_ITEM_VAL));
164
165 int ret = start_message_assembly(job);
166
167 EXPECT_EQ_STR(TEST_MSG_ITEM_NAME,
168 job->messages_storage[0].message_items[0].name);
169 EXPECT_EQ_STR(TEST_MSG_ITEM_VAL,
170 job->messages_storage[0].message_items[0].value);
171 EXPECT_EQ_INT(0, job->message_item_idx);
172 EXPECT_EQ_INT(1 + MSG_STOR_INC_STEP, job->messages_max_len);
173 EXPECT_EQ_INT(0, ret);
174 sfree(job->messages_storage);
175 sfree(job);
176
177 return 0;
178 }
179
180 DEF_TEST(resize_msg_buffer) {
181 const u_int new_size = 5;
182 parser_job_data_t *job = calloc(1, sizeof(*job));
183 job->messages_storage = calloc(1, sizeof(*job->messages_storage));
184 job->messages_max_len = 1;
185 int ret = resize_message_buffer(job, new_size);
186 EXPECT_EQ_INT(0, ret);
187 EXPECT_EQ_INT(new_size, job->messages_max_len);
188 sfree(job->messages_storage);
189 sfree(job);
190
191 return 0;
192 }
193
194 DEF_TEST(end_msg_assembly_1) {
195 parser_job_data_t *job = calloc(1, sizeof(*job));
196
197 job->message_idx = 0;
198 job->messages_storage = calloc(1, sizeof(*job->messages_storage));
199 job->messages_max_len = 1;
200
201 end_message_assembly(job);
202
203 EXPECT_EQ_INT(1, job->messages_storage[job->message_idx].completed);
204 EXPECT_EQ_INT(1, job->messages_completed);
205 EXPECT_EQ_INT(0, job->message_item_idx);
206
207 sfree(job->messages_storage);
208 sfree(job);
209
210 return 0;
211 }
212
213 DEF_TEST(end_msg_assembly_2) {
214 parser_job_data_t *job = calloc(1, sizeof(*job));
215
216 job->message_idx = 1;
217 job->message_item_idx = 1;
218 job->messages_storage = calloc(2, sizeof(*job->messages_storage));
219 job->messages_max_len = 1;
220 job->message_patterns_len = 1;
221 job->message_patterns = calloc(1, sizeof(*job->message_patterns));
222 job->message_patterns[0].is_mandatory = true;
223 job->message_patterns[0].regex = TEST_REGEX;
224
225 end_message_assembly(job);
226
227 EXPECT_EQ_INT(0, job->messages_storage[job->message_idx].completed);
228 EXPECT_EQ_INT(0, job->messages_completed);
229 EXPECT_EQ_INT(0, job->message_item_idx);
230 EXPECT_EQ_INT(0, job->message_idx);
231
232 sfree(job->messages_storage);
233 sfree(job->message_patterns);
234 sfree(job);
235
236 return 0;
237 }
238
239 DEF_TEST(msg_assembler_1) {
240 int ret = message_assembler(NULL, NULL, 0, NULL);
241
242 EXPECT_EQ_INT(-1, ret);
243
244 return 0;
245 }
246
247 DEF_TEST(msg_assembler_2) {
248
249 checked_match_t *cm = calloc(1, sizeof(*cm));
250 cm->msg_pattern.submatch_idx = 1;
251
252 int ret = message_assembler(NULL, NULL, 1, cm);
253
254 EXPECT_EQ_INT(-1, ret);
255
256 sfree(cm);
257
258 return 0;
259 }
260
261 DEF_TEST(msg_assembler_3) {
262 parser_job_data_t *job = calloc(1, sizeof(*job));
263 checked_match_t *cm = calloc(1, sizeof(*cm));
264
265 job->messages_storage = calloc(1, sizeof(*job->messages_storage));
266 job->message_patterns = calloc(1, sizeof(*job->message_patterns));
267 job->message_patterns_len = 1;
268 job->message_item_idx = 32;
269 job->message_idx = 0;
270 job->end_message_assembly = end_message_assembly;
271 cm->msg_pattern.submatch_idx = 1;
272 cm->parser_job = job;
273
274 int ret = message_assembler(NULL, NULL, 3, cm);
275
276 EXPECT_EQ_INT(-1, ret);
277
278 sfree(cm);
279 sfree(job->messages_storage);
280 sfree(job->message_patterns);
281 sfree(job);
282
283 return 0;
284 }
285
286 DEF_TEST(msg_assembler_4) {
287 parser_job_data_t *job = calloc(1, sizeof(*job));
288 checked_match_t *cm = calloc(1, sizeof(*cm));
289
290 cm->parser_job = job;
291 cm->msg_pattern_idx = 0;
292 cm->msg_pattern.submatch_idx = 0;
293 cm->msg_pattern.regex = TEST_REGEX;
294 job->messages_storage = calloc(1, sizeof(*job->messages_storage));
295 job->message_patterns = calloc(1, sizeof(*job->message_patterns));
296 job->message_patterns_len = 1;
297 job->message_patterns[0].regex = cm->msg_pattern.regex;
298 job->message_item_idx = 0;
299 job->message_idx = 0;
300 job->start_message_assembly = start_message_assembly_mock_error;
301
302 int ret = message_assembler(NULL, NULL, 3, cm);
303 EXPECT_EQ_INT(-1, ret);
304
305 job->start_message_assembly = start_message_assembly_mock_success;
306 job->message_idx = -1;
307 job->messages_storage[0].started = true;
308 job->messages_storage[0].completed = false;
309 ret = message_assembler(NULL, NULL, 3, cm);
310 EXPECT_EQ_INT(0, ret);
311
312 job->message_idx = 0;
313 job->messages_storage[0].started = false;
314 job->messages_storage[0].completed = false;
315 ret = message_assembler(NULL, NULL, 3, cm);
316 EXPECT_EQ_INT(0, ret);
317
318 job->message_idx = 0;
319 job->messages_storage[0].started = true;
320 job->messages_storage[0].completed = true;
321 ret = message_assembler(NULL, NULL, 3, cm);
322 EXPECT_EQ_INT(0, ret);
323
324 job->messages_storage[0].completed = false;
325 job->message_item_assembly = message_item_assembly_mock;
326 job->end_message_assembly = end_message_assembly_mock;
327 ret = message_assembler(NULL, NULL, 3, cm);
328
329 EXPECT_EQ_INT(1, job->messages_storage[0].matched_patterns_check[0]);
330 EXPECT_EQ_INT(0, ret);
331
332 sfree(cm);
333 sfree(job->messages_storage);
334 sfree(job->message_patterns);
335 sfree(job);
336
337 return 0;
338 }
339
340 DEF_TEST(msg_parser_init) {
341 message_pattern_t patterns[TEST_PATTERNS_LEN] = {
342 {"pattern_1", "test_regex_1", 0, "", 1},
343 {"pattern_2", "test_regex_2", 0, "", 0},
344 {"pattern_3", "test_regex_3", 0, "", 0},
345 {"pattern_4", "test_regex_4", 0, "", 1}
346
347 };
348 unsigned int start_idx = 0;
349 unsigned int stop_idx = 1;
350 const char *filename = TEST_FILENAME;
351 parser_job_data_t *job = NULL;
352
353 job = message_parser_init(filename, start_idx, stop_idx, patterns,
354 TEST_PATTERNS_LEN);
355
356 OK(job != NULL);
357 OK(job->resize_message_buffer == resize_message_buffer);
358 OK(job->start_message_assembly == start_message_assembly);
359 OK(job->end_message_assembly == end_message_assembly);
360 OK(job->message_item_assembly == message_item_assembly);
361 OK(job->messages_max_len == MSG_STOR_INIT_LEN);
362 OK(job->filename == filename);
363 OK(job->start_idx == start_idx);
364 OK(job->stop_idx == stop_idx);
365 OK(job->message_idx == -1);
366 OK(job->messages_completed == 0);
367 OK(memcmp(patterns, job->message_patterns,
368 sizeof(message_pattern_t) * TEST_PATTERNS_LEN) == 0);
369 OK(job->message_patterns_len == TEST_PATTERNS_LEN);
370
371 sfree(job->messages_storage);
372 sfree(job->message_patterns);
373 tail_match_destroy(job->tm);
374 sfree(job);
375
376 return 0;
377 }
378
379 DEF_TEST(msg_parser_read_1) {
380 parser_job_data_t *job = NULL;
381 int ret = message_parser_read(job, NULL, 0);
382
383 EXPECT_EQ_INT(-1, ret);
384
385 return 0;
386 }
387
388 DEF_TEST(msg_parser_read_2) {
389
390 message_pattern_t patterns[TEST_PATTERNS_LEN] = {
391 {"pattern_1", "test_regex_1", 0, "", 1},
392 {"pattern_2", "test_regex_2", 0, "", 0},
393 {"pattern_3", "test_regex_3", 0, "", 0},
394 {"pattern_4", "test_regex_4", 0, "", 1}
395
396 };
397
398 unsigned int start_idx = 0;
399 unsigned int stop_idx = 1;
400 const char *filename = TEST_FILENAME;
401 parser_job_data_t *job = calloc(1, sizeof(*job));
402
403 job->resize_message_buffer = resize_message_buffer;
404 job->start_message_assembly = start_message_assembly;
405 job->end_message_assembly = end_message_assembly;
406 job->message_item_assembly = message_item_assembly;
407 job->messages_max_len = MSG_STOR_INIT_LEN;
408 job->filename = filename;
409 job->start_idx = start_idx;
410 job->stop_idx = stop_idx;
411 job->message_idx = -1;
412 job->messages_completed = 0;
413 job->message_patterns = patterns;
414 job->message_patterns_len = TEST_PATTERNS_LEN;
415 job->tm = tail_match_create(job->filename);
416
417 int ret = message_parser_read(job, NULL, 0);
418
419 EXPECT_EQ_INT(-1, ret);
420
421 tail_match_destroy(job->tm);
422 sfree(job);
423
424 return 0;
425 }
426
427 int main(void) {
428 /* message_item_assembly */
429 RUN_TEST(msg_item_assembly);
430 /* start_message_item_assembly */
431 RUN_TEST(start_msg_item_assembly_1);
432 RUN_TEST(start_msg_item_assembly_2);
433 RUN_TEST(start_msg_item_assembly_3);
434 /* resize_message_buffer */
435 RUN_TEST(resize_msg_buffer);
436 /* end_message assembly */
437 RUN_TEST(end_msg_assembly_1);
438 RUN_TEST(end_msg_assembly_2);
439 /* message_assembler */
440 RUN_TEST(msg_assembler_1);
441 RUN_TEST(msg_assembler_2);
442 RUN_TEST(msg_assembler_3);
443 RUN_TEST(msg_assembler_4);
444 /* message_parser_init */
445 RUN_TEST(msg_parser_init);
446 /* message_parser_read */
447 RUN_TEST(msg_parser_read_1);
448 RUN_TEST(msg_parser_read_2);
449
450 END_TEST;
451 }