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
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.

235 satır
7.4 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 <alloca.h>
  24. #include <stdbool.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <xml.h>
  28. /**
  29. * Will halt the program iff assertion fails
  30. */
  31. static void _assert_that(_Bool condition, char const* message, char const* func, char const* file, int line) {
  32. if (!condition) {
  33. fprintf(stderr, "Assertion failed: %s, in %s (%s:%i)\n", message, func, file, line);
  34. exit(EXIT_FAILURE);
  35. }
  36. }
  37. #define assert_that(condition, message) \
  38. _assert_that(condition, message, __func__, __FILE__, __LINE__)
  39. /**
  40. * @return true iff xml string equals the c string
  41. */
  42. static _Bool string_equals(struct xml_string* a, char const* b) {
  43. size_t a_length = xml_string_length(a);
  44. size_t b_length = strlen(b);
  45. uint8_t* a_buffer = alloca((a_length + 1) * sizeof(uint8_t));
  46. xml_string_copy(a, a_buffer, a_length);
  47. a_buffer[a_length] = 0;
  48. if (a_length != b_length) {
  49. fprintf(stderr, "string_equals: %s#%i <> %s#%i\n", a_buffer, (int)a_length, b, (int)b_length);
  50. return false;
  51. }
  52. size_t i = 0; for (; i < a_length; ++i) {
  53. if (a_buffer[i] != b[i]) {
  54. fprintf(stderr, "string_equals: %s <> %s\n", a_buffer, b);
  55. return false;
  56. }
  57. }
  58. return true;
  59. }
  60. /**
  61. * Converts a static character array to an uint8_t data source
  62. */
  63. #define SOURCE(source, content) \
  64. uint8_t* source = calloc(strlen(content) + 1, sizeof(uint8_t)); \
  65. { char const* content_string = content; \
  66. memcpy(source, content_string, strlen(content) + 1); \
  67. }
  68. /**
  69. * Tries to parse a simple document containing only one tag
  70. */
  71. static void test_xml_parse_document_0() {
  72. SOURCE(source, "<Hello>World</Hello>");
  73. // uint8_t* source = malloc((1 + strlen("<Hello>World</Hello>")) * sizeof(uint8_t));
  74. // { char const* content_string = "<Hello>World</Hello>";
  75. // memcpy(source, content_string, strlen("<Hello>World</Hello>") + 1);
  76. // }
  77. struct xml_document* document = xml_parse_document(source, strlen(source));
  78. assert_that(document, "Could not parse document");
  79. struct xml_node* root = xml_document_root(document);
  80. assert_that(string_equals(xml_node_name(root), "Hello"), "root node name must be `Hello'");
  81. assert_that(string_equals(xml_node_content(root), "World"), "root node content must be `World'");
  82. xml_document_free(document, true);
  83. }
  84. /**
  85. * Tries to parse a document containing multiple tags
  86. */
  87. static void test_xml_parse_document_1() {
  88. SOURCE(source, ""
  89. "<Parent>\n"
  90. "\t<Child>\n"
  91. "\t\tFirst content\n"
  92. "\t</Child>\n"
  93. "\t<Child>\n"
  94. "\t\tSecond content\n"
  95. "\t</Child>\n"
  96. "</Parent>\n"
  97. );
  98. struct xml_document* document = xml_parse_document(source, strlen(source));
  99. assert_that(document, "Could not parse document");
  100. struct xml_node* root = xml_document_root(document);
  101. assert_that(string_equals(xml_node_name(root), "Parent"), "root node name must be `Parent'");
  102. assert_that(2 == xml_node_children(root), "root must have two children");
  103. struct xml_node* first_child = xml_node_child(root, 0);
  104. struct xml_node* second_child = xml_node_child(root, 1);
  105. assert_that(first_child && second_child, "Failed retrieving the children of root");
  106. struct xml_node* third_child = xml_node_child(root, 2);
  107. assert_that(!third_child, "root has a third child where non should be");
  108. assert_that(string_equals(xml_node_name(first_child), "Child"), "first_child node name must be `Child'");
  109. assert_that(string_equals(xml_node_content(first_child), "First content"), "first_child node content must be `First content'");
  110. assert_that(string_equals(xml_node_name(second_child), "Child"), "second_child node name must be `Child'");
  111. assert_that(string_equals(xml_node_content(second_child), "Second content"), "second_child node content must be `tSecond content'");
  112. xml_document_free(document, true);
  113. }
  114. /**
  115. * Tests the eas functionality
  116. */
  117. static void test_xml_parse_document_2() {
  118. SOURCE(source, ""
  119. "<Parent>\n"
  120. "\t<Child>\n"
  121. "\t\tFirst content\n"
  122. "\t</Child>\n"
  123. "\t<This><Is>\n"
  124. "<A><Test>Content A</Test></A>\n"
  125. "<B><Test>Content B</Test></B>\n"
  126. "\t</Is></This>\n"
  127. "\t<Child>\n"
  128. "\t\tSecond content\n"
  129. "\t</Child>\n"
  130. "</Parent>\n"
  131. );
  132. struct xml_document* document = xml_parse_document(source, strlen(source));
  133. assert_that(document, "Could not parse document");
  134. struct xml_node* root = xml_document_root(document);
  135. assert_that(string_equals(xml_node_name(root), "Parent"), "root node name must be `Parent'");
  136. assert_that(3 == xml_node_children(root), "root must have two children");
  137. struct xml_node* test_a = xml_easy_child(root, "This", "Is", "A", "Test", 0);
  138. assert_that(test_a, "Cannot find Parent/This/Is/A/Test");
  139. assert_that(string_equals(xml_node_content(test_a), "Content A"), "Content of Parent/This/Is/A/Test must be `Content A'");
  140. struct xml_node* test_b = xml_easy_child(root, "This", "Is", "B", "Test", 0);
  141. assert_that(test_b, "Cannot find Parent/This/Is/B/Test");
  142. assert_that(string_equals(xml_node_content(test_b), "Content B"), "Content of Parent/This/Is/B/Test must be `Content B'");
  143. struct xml_node* test_c = xml_easy_child(root, "This", "Is", "C", "Test", 0);
  144. assert_that(!test_c, "Must not find Parent/This/Is/C/Test because no such path exists");
  145. struct xml_node* must_be_null = xml_easy_child(root, "Child");
  146. assert_that(!must_be_null, "Parent/Child cannot be a valid expression, because there are two children named `Child' in `Parent'");
  147. uint8_t* name_is = xml_easy_name(xml_easy_child(root, "This", "Is", 0));
  148. assert_that(!strcmp(name_is, "Is"), "Name of Parent/This/Is must be `Is'");
  149. free(name_is);
  150. uint8_t* content_a = xml_easy_content(test_a);
  151. assert_that(!strcmp(content_a, "Content A"), "Content of Parent/This/Is/A/Test must be `Content A'");
  152. free(content_a);
  153. xml_document_free(document, true);
  154. }
  155. /**
  156. * Tests the xml_open_document functionality
  157. */
  158. static void test_xml_parse_document_3() {
  159. #define FILE_NAME "test.xml"
  160. FILE* handle = fopen(FILE_NAME, "rb");
  161. assert_that(handle, "Cannot open " FILE_NAME);
  162. struct xml_document* document = xml_open_document(handle);
  163. assert_that(document, "Cannot parse " FILE_NAME);
  164. struct xml_node* element = xml_easy_child(
  165. xml_document_root(document), "Element", "With", 0
  166. );
  167. assert_that(element, "Cannot find Document/Element/With");
  168. assert_that(string_equals(xml_node_content(element), "Child"), "Content of Document/Element/With must be `Child'");
  169. xml_document_free(document, true);
  170. #undef FILE_NAME
  171. }
  172. /**
  173. * Console interface
  174. */
  175. int main(int argc, char** argv) {
  176. test_xml_parse_document_0();
  177. test_xml_parse_document_1();
  178. test_xml_parse_document_2();
  179. test_xml_parse_document_3();
  180. fprintf(stdout, "All tests passed :-)\n");
  181. exit(EXIT_SUCCESS);
  182. }