1 /* Copyright (C) 2014 Trend Micro Inc.
4 * This program is a free software; you can redistribute it
5 * and/or modify it under the terms of the GNU General Public
6 * License (version 2) as published by the FSF - Free Software
15 #include "../os_xml/os_xml.h"
16 #include "../os_xml/os_xml_internal.h"
18 Suite *test_suite(void);
20 static void create_xml_file(const char *str, char file_name[], size_t length)
22 strncpy(file_name, "/tmp/tmp_file-XXXXXX", length);
23 int fd = mkstemp(file_name);
25 write(fd, str, strlen(str));
29 static void nodecat(XML_NODE node, OS_XML *xml, char *buffer) {
34 strncat(buffer, "<", 1);
35 ck_assert_ptr_ne(node[i]->element, NULL);
36 strncat(buffer, node[i]->element, strlen(node[i]->element));
37 /* write attributes */
38 if(node[i]->attributes)
40 ck_assert_ptr_ne(node[i]->values, NULL);
42 while(node[i]->attributes[j])
44 strncat(buffer, " ", 1);
45 ck_assert_ptr_ne(node[i]->values[j], NULL);
46 strncat(buffer, node[i]->attributes[j], strlen(node[i]->attributes[j]));
47 strncat(buffer, "=", 1);
48 strncat(buffer, "\"", 1);
49 strncat(buffer, node[i]->values[j], strlen(node[i]->values[j]));
50 strncat(buffer, "\"", 1);
53 ck_assert_ptr_eq(node[i]->values[j], NULL);
57 ck_assert_ptr_eq(node[i]->values, NULL);
59 strncat(buffer, ">", 1);
60 ck_assert_ptr_ne(node[i]->content, NULL);
61 strncat(buffer, node[i]->content, strlen(node[i]->content));
64 XML_NODE child = OS_GetElementsbyNode(xml, node[i]);
67 nodecat(child, xml, buffer);
72 strncat(buffer, "</", 2);
73 strncat(buffer, node[i]->element, strlen(node[i]->element));
74 strncat(buffer, ">", 1);
79 static void assert_os_xml_eq_str(OS_XML *xml, const char *xml_str)
81 XML_NODE node = OS_GetElementsbyNode(xml, NULL);
84 ck_assert_str_eq(xml_str, "");
88 char *buffer = (char *) malloc(6144 * sizeof(char));
90 nodecat(node, xml, buffer);
93 ck_assert_str_eq(buffer, xml_str);
98 #define assert_os_xml_eq(PARSE_STR, XML_STR) do { \
99 char _ck_xml_file_name[256]; \
100 create_xml_file(PARSE_STR, _ck_xml_file_name, 256); \
102 ck_assert_int_eq(OS_ReadXML(_ck_xml_file_name, &_ck_xml), 0); \
103 ck_assert_int_eq(OS_ApplyVariables(&_ck_xml), 0); \
104 assert_os_xml_eq_str(&_ck_xml, XML_STR); \
105 OS_ClearXML(&_ck_xml); \
106 unlink(_ck_xml_file_name); \
109 START_TEST(test_simplenodes)
111 assert_os_xml_eq("", "");
112 assert_os_xml_eq("<root></root>", "<root></root>");
113 assert_os_xml_eq("<root/>", "<root></root>");
114 assert_os_xml_eq("<root />", "<root></root>");
119 START_TEST(test_multiplenodes)
131 START_TEST(test_children)
141 "<child3.1></child3.1>"
152 "<child3.1></child3.1>"
159 START_TEST(test_multiplecontent)
166 "<root><child></child></root>");
173 "<root>value2<child></child></root>");
178 START_TEST(test_attributes)
181 "<root attr1=\"test\" attr2=\"1\"></root>",
182 "<root attr1=\"test\" attr2=\"1\"></root>");
185 "<root attr1=\"test\"\nattr2=\"test\"\tattr3=\"test\"></root>",
186 "<root attr1=\"test\" attr2=\"test\" attr3=\"test\"></root>");
189 "<root attr1=\"test/test\"></root>",
190 "<root attr1=\"test/test\"></root>");
193 "<root attr1=\"test1\"></root><root attr1=\"test2\"></root>",
194 "<root attr1=\"test1\"></root><root attr1=\"test2\"></root>");
197 "<root attr1=\"test\"\n\t \t\n \n\t \nattr2=\"test\"></root>",
198 "<root attr1=\"test\" attr2=\"test\"></root>");
201 "<root\n\t \t\n \n\t \nattr1=\"test\"></root>",
202 "<root attr1=\"test\"></root>");
205 "<root attr1=\n\t \t\n \n\t \n\"test\"></root>",
206 "<root attr1=\"test\"></root>");
209 "<root attr=\"test\" />",
210 "<root attr=\"test\"></root>");
213 "<root attr=\"test\"/>",
214 "<root attr=\"test\"></root>");
218 START_TEST(test_variables)
221 "<var name=\"var1\">value1</var>"
222 "<var name=\"var2\">value2</var>"
223 "<root attr1=\"$var1\" attr2=\"1\">$var2</root>"
224 "<root attr1=\"blah$var1\" attr2=\"1\">blah$var2</root>"
225 "<root attr1=\"blah$var1$var2 blah\" attr2=\"1\">blah$var2$var1 blah</root>",
226 "<root attr1=\"value1\" attr2=\"1\">value2</root>"
227 "<root attr1=\"blahvalue1\" attr2=\"1\">blahvalue2</root>"
228 "<root attr1=\"blahvalue1value2 blah\" attr2=\"1\">blahvalue2value1 blah</root>");
232 START_TEST(test_comments)
235 "<root1/><!comment!><root2/>",
236 "<root1></root1><root2></root2>");
238 "<root1/><!--comment--><root2/>",
239 "<root1></root1><root2></root2>");
242 "<root1/><! comment with ! !><root2/>",
243 "<root1></root1><root2></root2>");
246 "<root1/><! comment with - --><root2/>",
247 "<root1></root1><root2></root2>");
251 START_TEST(test_specialchars)
254 "<var name=\"var1\">value1</var>"
255 "<root1>\\</root1\\></root1>",
256 "<root1>\\</root1\\></root1>");
260 START_TEST(test_linecounter)
262 char xml_file_name[256];
263 create_xml_file("<root1/>\n<root2/>\n<root3/>" , xml_file_name, 256);
266 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
267 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
268 ck_assert_ptr_ne(node = OS_GetElementsbyNode(&xml, NULL), NULL);
269 ck_assert_int_eq(xml.ln[0], 1);
270 ck_assert_int_eq(xml.ln[1], 2);
271 ck_assert_int_eq(xml.ln[2], 3);
275 unlink(xml_file_name);
279 START_TEST(test_invalidfile)
282 ck_assert_int_ne(OS_ReadXML("invalid_file.inv", &xml), 0);
283 ck_assert_str_eq(xml.err, "XMLERR: File 'invalid_file.inv' not found.");
284 ck_assert_int_eq(xml.err_line, 0);
290 START_TEST(test_unclosednode)
292 char xml_file_name[256];
293 create_xml_file("<root>", xml_file_name, 256);
295 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
296 ck_assert_str_eq(xml.err, "XMLERR: End of file and some elements were not closed.");
297 ck_assert_int_eq(xml.err_line, 1);
300 unlink(xml_file_name);
304 START_TEST(test_unclosednode2)
306 char xml_file_name[256];
307 create_xml_file("<root></root2>", xml_file_name, 256);
309 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
310 ck_assert_str_eq(xml.err, "XMLERR: Element 'root' not closed.");
311 ck_assert_int_eq(xml.err_line, 1);
314 unlink(xml_file_name);
318 START_TEST(test_unclosedcomment)
320 char xml_file_name[256];
321 create_xml_file("<!-- comment", xml_file_name, 256);
323 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
324 ck_assert_str_eq(xml.err, "XMLERR: Comment not closed.");
325 ck_assert_int_eq(xml.err_line, 1);
328 unlink(xml_file_name);
332 START_TEST(test_nodenotopened)
334 char xml_file_name[256];
335 create_xml_file("</root>", xml_file_name, 256);
337 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
338 ck_assert_str_eq(xml.err, "XMLERR: Element not opened.");
339 ck_assert_int_eq(xml.err_line, 1);
342 unlink(xml_file_name);
346 START_TEST(test_unclosedattribute)
348 char xml_file_name[256];
349 create_xml_file("<root attr=\"attribute></root>", xml_file_name, 256);
351 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
352 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' not closed.");
353 ck_assert_int_eq(xml.err_line, 1);
356 unlink(xml_file_name);
360 START_TEST(test_unquotedattribute)
362 char xml_file_name[256];
363 create_xml_file("<root attr=attribute></root>", xml_file_name, 256);
365 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
366 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' not followed by a \" or '.");
367 ck_assert_int_eq(xml.err_line, 1);
370 unlink(xml_file_name);
374 START_TEST(test_infiniteattribute)
376 char xml_file_name[256];
377 create_xml_file("<root attr", xml_file_name, 256);
379 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
380 ck_assert_str_eq(xml.err, "XMLERR: End of file while reading an attribute.");
381 ck_assert_int_eq(xml.err_line, 1);
384 unlink(xml_file_name);
388 START_TEST(test_invalidvariablename)
390 char xml_file_name[256];
391 create_xml_file("<var test=\"test\"></var>", xml_file_name, 256);
393 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
394 ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
395 ck_assert_str_eq(xml.err, "XMLERR: Only \"name\" is allowed as an attribute for a variable.");
396 ck_assert_int_eq(xml.err_line, 1);
399 unlink(xml_file_name);
403 START_TEST(test_invalidvariable)
405 char xml_file_name[256];
406 char overflow_string[XML_VARIABLE_MAXSIZE + 10];
407 memset(overflow_string, 'c', XML_VARIABLE_MAXSIZE + 9);
408 overflow_string[XML_VARIABLE_MAXSIZE + 9] = '\0';
410 char xml_string[2 * XML_VARIABLE_MAXSIZE];
411 snprintf(xml_string, 2 * XML_VARIABLE_MAXSIZE - 1, "<var name=\"%s\">test</var><root/>", overflow_string);
412 create_xml_file(xml_string, xml_file_name, 256);
414 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
415 ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
416 ck_assert_str_eq(xml.err, "XMLERR: Invalid variable name size.");
417 ck_assert_int_eq(xml.err_line, 1);
420 unlink(xml_file_name);
424 START_TEST(test_invalidvariable2)
426 char xml_file_name[256];
427 char overflow_string[XML_VARIABLE_MAXSIZE + 10];
428 memset(overflow_string, 'c', XML_VARIABLE_MAXSIZE + 9);
429 overflow_string[XML_VARIABLE_MAXSIZE + 9] = '\0';
431 char xml_string[3 * XML_VARIABLE_MAXSIZE];
432 snprintf(xml_string, 3 * XML_VARIABLE_MAXSIZE - 1, "<var name=\"%s\">test</var><test>$%s</test>", overflow_string, overflow_string);
433 create_xml_file(xml_string, xml_file_name, 256);
435 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
436 ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
437 ck_assert_str_eq(xml.err, "XMLERR: Invalid variable name size.");
438 ck_assert_int_eq(xml.err_line, 1);
441 unlink(xml_file_name);
445 START_TEST(test_unknownvariable)
447 char xml_file_name[256];
448 create_xml_file("<var name=\"test\">content</var><root>$var</root>", xml_file_name, 256);
450 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
451 ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
452 ck_assert_str_eq(xml.err, "XMLERR: Unknown variable: 'var'.");
453 ck_assert_int_eq(xml.err_line, 1);
456 unlink(xml_file_name);
460 START_TEST(test_infiniteattribute2)
462 char xml_file_name[256];
463 create_xml_file("<root attr=", xml_file_name, 256);
465 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
466 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' not followed by a \" or '.");
467 ck_assert_int_eq(xml.err_line, 1);
470 unlink(xml_file_name);
474 START_TEST(test_invalidattributestart)
476 char xml_file_name[256];
477 create_xml_file("<root attr= test\"test\"/>", xml_file_name, 256);
479 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
480 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' not followed by a \" or '.");
481 ck_assert_int_eq(xml.err_line, 1);
484 unlink(xml_file_name);
488 START_TEST(test_invalidattributeclosing)
490 char xml_file_name[256];
491 create_xml_file("<root attr=''", xml_file_name, 256);
493 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
494 ck_assert_str_eq(xml.err, "XMLERR: Bad attribute closing for 'attr'=''.");
495 ck_assert_int_eq(xml.err_line, 1);
498 unlink(xml_file_name);
502 START_TEST(test_invalidattributeclosing2)
504 char xml_file_name[256];
505 create_xml_file("<root attr='test'test/>", xml_file_name, 256);
507 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
508 ck_assert_str_eq(xml.err, "XMLERR: Bad attribute closing for 'attr'='test'.");
509 ck_assert_int_eq(xml.err_line, 1);
512 unlink(xml_file_name);
516 START_TEST(test_infiniteattribute3)
518 char xml_file_name[256];
519 create_xml_file("<root attr='", xml_file_name, 256);
521 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
522 ck_assert_str_eq(xml.err, "XMLERR: End of file while reading an attribute.");
523 ck_assert_int_eq(xml.err_line, 1);
526 unlink(xml_file_name);
530 START_TEST(test_duplicateattribute)
532 char xml_file_name[256];
533 create_xml_file("<root attr='test' attr2='test' attr='test123'></root>", xml_file_name, 256);
535 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
536 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' already defined.");
537 ck_assert_int_eq(xml.err_line, 1);
540 unlink(xml_file_name);
544 START_TEST(test_noattributevalue)
546 char xml_file_name[256];
547 create_xml_file("<root attr></root>", xml_file_name, 256);
549 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
550 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' has no value.");
551 ck_assert_int_eq(xml.err_line, 1);
554 unlink(xml_file_name);
558 START_TEST(test_noattributevalue2)
560 char xml_file_name[256];
561 create_xml_file("<root attr attr2='test'></root>", xml_file_name, 256);
563 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
564 ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' has no value.");
565 ck_assert_int_eq(xml.err_line, 1);
568 unlink(xml_file_name);
573 /*START_TEST(test_unknownvariable)
575 char xml_file_name[256];
576 create_xml_file("<root>$var</root>", xml_file_name, 256);
578 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
579 ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
580 ck_assert_str_eq(xml.err, "XML_ERR: Unknown variable: var");
581 ck_assert_int_eq(xml.err_line, 0);
584 unlink(xml_file_name);
588 START_TEST(test_oselementsexists)
590 char xml_file_name[256];
591 create_xml_file("<root></root><root1/><root/>", xml_file_name, 256);
593 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
594 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
595 ck_assert_int_eq(OS_RootElementExist(&xml, "root"), 2);
596 ck_assert_int_eq(OS_RootElementExist(&xml, "root1"), 1);
597 ck_assert_int_eq(OS_RootElementExist(&xml, "root2"), 0);
600 unlink(xml_file_name);
604 START_TEST(test_osgetonecontentforelement)
606 char xml_file_name[256];
607 create_xml_file("<root><child>test</child><child>test2</child><child2>test</child2></root>", xml_file_name, 256);
609 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
610 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
611 const char *xml_path1[] = { "root", "child", NULL };
612 const char *xml_path2[] = { "root", "child2", NULL };
613 const char *xml_path3[] = { "root", "child3", NULL };
614 char *content1, *content2;
615 ck_assert_str_eq(content1 = OS_GetOneContentforElement(&xml, xml_path1), "test");
616 ck_assert_str_eq(content2 = OS_GetOneContentforElement(&xml, xml_path2), "test");
617 ck_assert_ptr_eq(OS_GetOneContentforElement(&xml, xml_path3), NULL);
622 unlink(xml_file_name);
626 static void assert_ox_xml_write_eq(const char *xml_str_old, const char *xml_str_new,const char **xml_path, const char *oldval, const char *newval)
628 char xml_in_file_name[256];
629 create_xml_file(xml_str_old, xml_in_file_name, 256);
630 char xml_out_file_name[256];
631 create_xml_file("", xml_out_file_name, 256);
633 ck_assert_int_eq(OS_WriteXML(xml_in_file_name, xml_out_file_name, xml_path, oldval, newval), 0);
636 ck_assert_int_eq(OS_ReadXML(xml_out_file_name, &xml), 0);
637 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
638 assert_os_xml_eq_str(&xml, xml_str_new);
641 unlink(xml_in_file_name);
642 unlink(xml_out_file_name);
645 START_TEST(test_oswritexml_success)
647 const char *xml_path[] = { "root", "child", NULL };
648 assert_ox_xml_write_eq(
649 "<root><child>test</child></root>",
650 "<root><child>test_new</child></root>",
651 xml_path, "test", "test_new");
653 assert_ox_xml_write_eq(
654 "<root><child>test</child></root>",
655 "<root><child>test</child></root>",
656 xml_path, "test", "test");
658 assert_ox_xml_write_eq(
659 "<root><child></child></root>",
660 "<root><child>test</child></root>",
661 xml_path, "test", "test");
663 assert_ox_xml_write_eq(
664 "<root2><child></child></root2>",
665 "<root2><child></child></root2><root>\n <child>test</child></root>",
666 xml_path, NULL, "test");
670 START_TEST(test_oswritexml_failures)
672 char xml_in_file_name[256];
673 create_xml_file("<root><child>test</child></root>", xml_in_file_name, 256);
674 char xml_out_file_name[256];
675 create_xml_file("", xml_out_file_name, 256);
676 const char *xml_path[] = { "root", "child", NULL };
678 ck_assert_int_eq(OS_WriteXML("invalid", xml_out_file_name, xml_path, "test", "test_new"), XMLW_NOIN);
679 ck_assert_int_eq(OS_WriteXML(xml_in_file_name, "??invalid<<!!\"\"//\\\\", xml_path, "test", "test_new"), XMLW_NOOUT);
681 unlink(xml_in_file_name);
682 unlink(xml_out_file_name);
686 START_TEST(test_osgetattributecontent)
688 char xml_file_name[256];
689 create_xml_file("<root attr=\"value\" attr2=\"value1\"></root>", xml_file_name, 256);
691 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
692 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
693 const char *xml_path1[] = { "root", NULL };
694 const char *xml_path2[] = { NULL };
695 char *content1, *content2, *content3, *content4;
696 ck_assert_str_eq(content1 = OS_GetAttributeContent(&xml, xml_path1, "attr"), "value");
697 ck_assert_str_eq(content2 = OS_GetAttributeContent(&xml, xml_path1, "attr2"), "value1");
698 ck_assert_str_eq(content3 = OS_GetAttributeContent(&xml, xml_path1, "attr3"), "");
699 ck_assert_str_eq(content4 = OS_GetAttributeContent(&xml, xml_path1, NULL), "");
700 ck_assert_ptr_eq(OS_GetAttributeContent(&xml, xml_path2, NULL), NULL);
708 unlink(xml_file_name);
712 START_TEST(test_osgetcontents)
714 char xml_file_name[256];
715 create_xml_file("<root>value</root><root>value2</root><root2>value</root2>", xml_file_name, 256);
717 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
718 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
719 const char *xml_path1[] = { "root", NULL };
720 const char *xml_path2[] = { "root2", NULL };
721 char **content1, **content2;
722 ck_assert_ptr_ne(content1 = OS_GetContents(&xml, xml_path1), NULL);
723 ck_assert_str_eq(content1[0], "value");
724 ck_assert_str_eq(content1[1], "value2");
725 ck_assert_ptr_eq(content1[2], NULL);
727 ck_assert_ptr_ne(content2 = OS_GetContents(&xml, xml_path2), NULL);
728 ck_assert_str_eq(content2[0], "value");
729 ck_assert_ptr_eq(content2[1], NULL);
731 ck_assert_ptr_eq(OS_GetContents(&xml, NULL), NULL);
743 unlink(xml_file_name);
747 START_TEST(test_osgetelementcontent)
749 char xml_file_name[256];
750 create_xml_file("<root>value</root>", xml_file_name, 256);
752 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
753 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
754 const char *xml_path[] = { "root", NULL };
756 ck_assert_ptr_ne(content = OS_GetElementContent(&xml, xml_path), NULL);
757 ck_assert_str_eq(content[0], "value");
758 ck_assert_ptr_eq(content[1], NULL);
765 unlink(xml_file_name);
769 START_TEST(test_osgetelements)
771 char xml_file_name[256];
772 create_xml_file("<root><child1/><child2/></root>", xml_file_name, 256);
774 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
775 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
776 const char *xml_path[] = { "root", NULL };
777 char **content1, **content2;
778 ck_assert_ptr_ne(content1 = OS_GetElements(&xml, xml_path), NULL);
779 ck_assert_str_eq(content1[0], "child1");
780 ck_assert_str_eq(content1[1], "child2");
781 ck_assert_ptr_eq(content1[2], NULL);
782 ck_assert_ptr_ne(content2 = OS_GetElements(&xml, NULL), NULL);
783 ck_assert_str_eq(content2[0], "root");
784 ck_assert_ptr_eq(content2[1], NULL);
785 const char *xml_path2[] = { NULL };
786 ck_assert_ptr_eq(OS_GetElements(&xml, xml_path2), NULL);
797 unlink(xml_file_name);
801 START_TEST(test_osgetattributes)
803 char xml_file_name[256];
804 create_xml_file("<root attr1=\"1\" attr2=\"2\"></root>", xml_file_name, 256);
806 ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
807 ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
808 const char *xml_path[] = { "root", NULL };
810 ck_assert_ptr_ne(content = OS_GetAttributes(&xml, xml_path), NULL);
811 ck_assert_str_eq(content[0], "attr1");
812 ck_assert_str_eq(content[1], "attr2");
813 ck_assert_ptr_eq(content[2], NULL);
820 unlink(xml_file_name);
824 START_TEST(test_osclearnode)
830 START_TEST(test_stringoverflow)
832 char xml_file_name[256];
833 char overflow_string[XML_MAXSIZE + 10];
834 memset(overflow_string, 'c', XML_MAXSIZE + 9);
835 overflow_string[XML_MAXSIZE + 9] = '\0';
837 char xml_string[2 * XML_MAXSIZE];
838 snprintf(xml_string, 2 * XML_MAXSIZE - 1, "<%s/>", overflow_string);
839 create_xml_file(xml_string, xml_file_name, 256);
841 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
842 ck_assert_str_eq(xml.err, "XMLERR: String overflow.");
843 ck_assert_int_eq(xml.err_line, 1);
846 unlink(xml_file_name);
850 START_TEST(test_stringoverflow2)
852 char xml_file_name[256];
853 char overflow_string[XML_MAXSIZE + 10];
854 memset(overflow_string, 'c', XML_MAXSIZE + 9);
855 overflow_string[XML_MAXSIZE + 9] = '\0';
857 char xml_string[2 * XML_MAXSIZE];
858 snprintf(xml_string, 2 * XML_MAXSIZE - 1, "<test>%s</test>", overflow_string);
859 create_xml_file(xml_string, xml_file_name, 256);
861 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
862 ck_assert_str_eq(xml.err, "XMLERR: String overflow.");
863 ck_assert_int_eq(xml.err_line, 1);
866 unlink(xml_file_name);
870 START_TEST(test_stringoverflow3)
872 char xml_file_name[256];
873 char overflow_string[XML_MAXSIZE + 10];
874 memset(overflow_string, 'c', XML_MAXSIZE + 9);
875 overflow_string[XML_MAXSIZE + 9] = '\0';
877 char xml_string[2 * XML_MAXSIZE];
878 snprintf(xml_string, 2 * XML_MAXSIZE - 1, "<test %s=\"test\">test</test>", overflow_string);
879 create_xml_file(xml_string, xml_file_name, 256);
881 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
882 ck_assert_str_eq(xml.err, "XMLERR: Overflow attempt at attribute 'cccccccccccccccccccc'.");
883 ck_assert_int_eq(xml.err_line, 1);
886 unlink(xml_file_name);
890 START_TEST(test_stringoverflow4)
892 char xml_file_name[256];
893 char overflow_string[XML_MAXSIZE + 10];
894 memset(overflow_string, 'c', XML_MAXSIZE + 9);
895 overflow_string[XML_MAXSIZE + 9] = '\0';
897 char xml_string[2 * XML_MAXSIZE];
898 snprintf(xml_string, 2 * XML_MAXSIZE - 1, "<test test=\"%s\">test</test>", overflow_string);
899 create_xml_file(xml_string, xml_file_name, 256);
901 ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
902 ck_assert_str_eq(xml.err, "XMLERR: Overflow attempt at attribute 'test'.");
903 ck_assert_int_eq(xml.err_line, 1);
906 unlink(xml_file_name);
910 Suite *test_suite(void)
912 Suite *s = suite_create("os_xml");
915 TCase *tc_core = tcase_create("Core");
916 tcase_add_test(tc_core, test_simplenodes);
917 tcase_add_test(tc_core, test_multiplenodes);
918 tcase_add_test(tc_core, test_multiplecontent);
919 tcase_add_test(tc_core, test_children);
920 tcase_add_test(tc_core, test_attributes);
921 tcase_add_test(tc_core, test_variables);
922 tcase_add_test(tc_core, test_comments);
923 tcase_add_test(tc_core, test_specialchars);
924 tcase_add_test(tc_core, test_linecounter);
925 tcase_add_test(tc_core, test_invalidfile);
926 tcase_add_test(tc_core, test_unclosednode);
927 tcase_add_test(tc_core, test_unclosednode2);
928 tcase_add_test(tc_core, test_unclosedcomment);
929 tcase_add_test(tc_core, test_nodenotopened);
930 tcase_add_test(tc_core, test_unclosedattribute);
931 tcase_add_test(tc_core, test_infiniteattribute);
932 tcase_add_test(tc_core, test_unquotedattribute);
933 tcase_add_test(tc_core, test_invalidvariablename);
934 tcase_add_test(tc_core, test_invalidvariable);
935 tcase_add_test(tc_core, test_invalidvariable2);
936 tcase_add_test(tc_core, test_unknownvariable);
937 tcase_add_test(tc_core, test_infiniteattribute2);
938 tcase_add_test(tc_core, test_invalidattributestart);
939 tcase_add_test(tc_core, test_invalidattributeclosing);
940 tcase_add_test(tc_core, test_invalidattributeclosing2);
941 tcase_add_test(tc_core, test_infiniteattribute3);
942 tcase_add_test(tc_core, test_duplicateattribute);
943 tcase_add_test(tc_core, test_noattributevalue);
944 tcase_add_test(tc_core, test_noattributevalue2);
945 tcase_add_test(tc_core, test_oselementsexists);
946 tcase_add_test(tc_core, test_osgetonecontentforelement);
947 tcase_add_test(tc_core, test_oswritexml_success);
948 tcase_add_test(tc_core, test_oswritexml_failures);
949 tcase_add_test(tc_core, test_osgetattributecontent);
950 tcase_add_test(tc_core, test_osgetcontents);
951 tcase_add_test(tc_core, test_osgetelementcontent);
952 tcase_add_test(tc_core, test_osgetelements);
953 tcase_add_test(tc_core, test_osgetattributes);
954 tcase_add_test(tc_core, test_osclearnode);
955 tcase_add_test(tc_core, test_stringoverflow);
956 tcase_add_test(tc_core, test_stringoverflow2);
957 tcase_add_test(tc_core, test_stringoverflow3);
958 tcase_add_test(tc_core, test_stringoverflow4);
959 suite_add_tcase(s, tc_core);
966 Suite *s = test_suite();
967 SRunner *sr = srunner_create(s);
968 srunner_run_all(sr, CK_NORMAL);
969 int number_failed = srunner_ntests_failed(sr);
972 return ((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE);