Simple XML subset parser comparable to glib's Markup parser, but without any dependencies in one self contained file. Forked from https://github.com/ooxi/xml.c
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

223 lines
7.8 KiB

  1. /**
  2. * Copyright (c) 2012 ooxi/xml.c
  3. * https://github.com/ooxi/xml.c
  4. *
  5. * This software is provided 'as-is', without any express or implied warranty.
  6. * In no event will the authors be held liable for any damages arising from the
  7. * use of this software.
  8. *
  9. * Permission is granted to anyone to use this software for any purpose,
  10. * including commercial applications, and to alter it and redistribute it
  11. * freely, subject to the following restrictions:
  12. *
  13. * 1. The origin of this software must not be misrepresented; you must not
  14. * claim that you wrote the original software. If you use this software in a
  15. * product, an acknowledgment in the product documentation would be
  16. * appreciated but is not required.
  17. *
  18. * 2. Altered source versions must be plainly marked as such, and must not be
  19. * misrepresented as being the original software.
  20. *
  21. * 3. This notice may not be removed or altered from any source distribution.
  22. */
  23. #include <iostream>
  24. #include <cstdlib>
  25. #include <cstdio>
  26. #include <xml.h>
  27. /**
  28. * Will halt the program iff assertion fails
  29. */
  30. static void _assert_that(bool condition, const char* message,
  31. const char* func, const char* file, int line) {
  32. if (!condition) {
  33. std::cerr << "Assertion failed: " << message << ", in " << func << " ("
  34. << file << ":" << line << ")\n";
  35. exit(EXIT_FAILURE);
  36. }
  37. }
  38. #define assert_that(condition, message) \
  39. _assert_that(condition, message, __func__, __FILE__, __LINE__)
  40. /**
  41. * @return true iff xml string equals the c string
  42. */
  43. static bool string_equals(struct xml_string* a, const char* b) {
  44. size_t a_length = xml_string_length(a);
  45. size_t b_length = strlen(b);
  46. uint8_t* a_buffer = new uint8_t[((a_length + 1) * sizeof(uint8_t))];
  47. xml_string_copy(a, a_buffer, a_length);
  48. a_buffer[a_length] = 0;
  49. if (a_length != b_length) {
  50. std::cerr << "string_equals: " << a_buffer << "#" << a_length << " <> "
  51. << b << "#" << b_length << "\n";
  52. delete[] a_buffer;
  53. return false;
  54. }
  55. size_t i = 0; for (; i < a_length; ++i) {
  56. if (a_buffer[i] != b[i]) {
  57. std::cerr << "string_equals: " << a_buffer << " <> " << b << "\n";
  58. delete[] a_buffer;
  59. return false;
  60. }
  61. }
  62. delete[] a_buffer;
  63. return true;
  64. }
  65. /**
  66. * Converts a static character array to an uint8_t data source which can be
  67. * freed
  68. */
  69. #define SOURCE(source, content) \
  70. uint8_t* source = (uint8_t*)calloc(strlen(content) + 1, sizeof(uint8_t)); \
  71. memcpy(source, (content), strlen(content) + 1); \
  72. /**
  73. * Tries to parse a simple document containing only one tag
  74. */
  75. static void test_xml_parse_document_0() {
  76. SOURCE(source, "<Hello>World</Hello>");
  77. // uint8_t* source = malloc((1 + strlen("<Hello>World</Hello>")) *
  78. // sizeof(uint8_t));
  79. // {
  80. // const char* content_string = "<Hello>World</Hello>";
  81. // memcpy(source, content_string, strlen("<Hello>World</Hello>") + 1);
  82. // }
  83. struct xml_document* document = xml_parse_document(source,
  84. strlen((const char *)source));
  85. assert_that(document, "Could not parse document");
  86. struct xml_node* root = xml_document_root(document);
  87. assert_that(string_equals(xml_node_name(root), "Hello"),
  88. "root node name must be `Hello'");
  89. assert_that(string_equals(xml_node_content(root), "World"),
  90. "root node content must be `World'");
  91. xml_document_free(document, true);
  92. }
  93. /**
  94. * Tries to parse a document containing multiple tags
  95. */
  96. static void test_xml_parse_document_1() {
  97. SOURCE(source, ""
  98. "<Parent>\n"
  99. "\t<Child>\n"
  100. "\t\tFirst content\n"
  101. "\t</Child>\n"
  102. "\t<Child>\n"
  103. "\t\tSecond content\n"
  104. "\t</Child>\n"
  105. "</Parent>\n"
  106. );
  107. struct xml_document* document = xml_parse_document(source,
  108. strlen((const char *)source));
  109. assert_that(document, "Could not parse document");
  110. struct xml_node* root = xml_document_root(document);
  111. assert_that(string_equals(xml_node_name(root), "Parent"),
  112. "root node name must be `Parent'");
  113. assert_that(2 == xml_node_children(root), "root must have two children");
  114. struct xml_node* first_child = xml_node_child(root, 0);
  115. struct xml_node* second_child = xml_node_child(root, 1);
  116. assert_that(first_child && second_child,
  117. "Failed retrieving the children of root");
  118. struct xml_node* third_child = xml_node_child(root, 2);
  119. assert_that(!third_child, "root has a third child where non should be");
  120. assert_that(string_equals(xml_node_name(first_child), "Child"),
  121. "first_child node name must be `Child'");
  122. assert_that(string_equals(xml_node_content(first_child), "First content"),
  123. "first_child node content must be `First content'");
  124. assert_that(string_equals(xml_node_name(second_child), "Child"),
  125. "second_child node name must be `Child'");
  126. assert_that(string_equals(xml_node_content(second_child), "Second content"),
  127. "second_child node content must be `tSecond content'");
  128. xml_document_free(document, true);
  129. }
  130. /**
  131. * Tests the eas functionality
  132. */
  133. static void test_xml_parse_document_2() {
  134. SOURCE(source, ""
  135. "<Parent>\n"
  136. "\t<Child>\n"
  137. "\t\tFirst content\n"
  138. "\t</Child>\n"
  139. "\t<This><Is>\n"
  140. "<A><Test>Content A</Test></A>\n"
  141. "<B><Test>Content B</Test></B>\n"
  142. "\t</Is></This>\n"
  143. "\t<Child>\n"
  144. "\t\tSecond content\n"
  145. "\t</Child>\n"
  146. "</Parent>\n"
  147. );
  148. struct xml_document* document = xml_parse_document(source,
  149. strlen((const char *)source));
  150. assert_that(document, "Could not parse document");
  151. struct xml_node* root = xml_document_root(document);
  152. assert_that(string_equals(xml_node_name(root), "Parent"),
  153. "root node name must be `Parent'");
  154. assert_that(3 == xml_node_children(root),
  155. "root must have two children");
  156. struct xml_node* test_a = xml_easy_child(root, (uint8_t *)"This",
  157. (uint8_t *)"Is", (uint8_t *)"A", (uint8_t *)"Test", 0);
  158. assert_that(test_a, "Cannot find Parent/This/Is/A/Test");
  159. assert_that(string_equals(xml_node_content(test_a), "Content A"),
  160. "Content of Parent/This/Is/A/Test must be `Content A'");
  161. struct xml_node* test_b = xml_easy_child(root, (uint8_t *)"This",
  162. (uint8_t *)"Is", (uint8_t *)"B", (uint8_t *)"Test", 0);
  163. assert_that(test_b, "Cannot find Parent/This/Is/B/Test");
  164. assert_that(string_equals(xml_node_content(test_b), "Content B"),
  165. "Content of Parent/This/Is/B/Test must be `Content B'");
  166. struct xml_node* test_c = xml_easy_child(root, (uint8_t *)"This",
  167. (uint8_t *)"Is", (uint8_t *)"C", (uint8_t *)"Test", 0);
  168. assert_that(!test_c,
  169. "Must not find Parent/This/Is/C/Test because no such path exists");
  170. struct xml_node* must_be_null = xml_easy_child(root, (uint8_t *)"Child");
  171. assert_that(!must_be_null,
  172. "Parent/Child cannot be a valid expression, because there are two children "
  173. "named `Child' in `Parent'");
  174. uint8_t* name_is = xml_easy_name(xml_easy_child(root, (uint8_t *)"This",
  175. (uint8_t *)"Is", 0));
  176. assert_that(!strcmp((const char*)name_is, "Is"),
  177. "Name of Parent/This/Is must be `Is'");
  178. free(name_is);
  179. uint8_t* content_a = xml_easy_content(test_a);
  180. assert_that(!strcmp((const char*)content_a, "Content A"),
  181. "Content of Parent/This/Is/A/Test must be `Content A'");
  182. free(content_a);
  183. xml_document_free(document, true);
  184. }
  185. /**
  186. * Tests the xml_open_document functionality
  187. */
  188. static void test_xml_parse_document_3() {
  189. #define FILE_NAME "test.xml"
  190. FILE* handle = fopen(FILE_NAME, "rb");
  191. assert_that(handle, "Cannot open " FILE_NAME);
  192. struct xml_document* document = xml_open_document(handle);
  193. assert_that(document, "Cannot parse " FILE_NAME);
  194. struct xml_node* element = xml_easy_child(xml_document_root(document),
  195. (uint8_t *)"Element", (uint8_t *)"With", 0);
  196. assert_that(element, "Cannot find Document/Element/With");
  197. assert_that(string_equals(xml_node_content(element), "Child"),
  198. "Content of Document/Element/With must be `Child'");
  199. xml_document_free(document, true);
  200. #undef FILE_NAME
  201. }
  202. int main(int argc, char **argv) {
  203. test_xml_parse_document_0();
  204. test_xml_parse_document_1();
  205. test_xml_parse_document_2();
  206. test_xml_parse_document_3();
  207. std::cout << "All tests passed :-)\n";
  208. exit(EXIT_SUCCESS);
  209. }