1 #undef G_DISABLE_ASSERT
2 #undef G_LOG_DOMAIN
3
4 #include <locale.h>
5 #include <string.h>
6 #include <stdio.h>
7 #include <glib.h>
8
9 static int depth = 0;
10 static GString *string;
11
12 static void
13 indent (int extra)
14 {
15 int i = 0;
16 while (i < depth)
17 {
18 g_string_append (string, " ");
19 ++i;
20 }
21 }
22
23 static void
24 start_element_handler (GMarkupParseContext *context,
25 const gchar *element_name,
26 const gchar **attribute_names,
27 const gchar **attribute_values,
28 gpointer user_data,
29 GError **error)
30 {
31 int i;
32
33 indent (0);
34 g_string_append_printf (string, "ELEMENT '%s'\n", element_name);
35
36 i = 0;
37 while (attribute_names[i] != NULL)
38 {
39 indent (1);
40
41 g_string_append_printf (string, "%s=\"%s\"\n",
42 attribute_names[i],
43 attribute_values[i]);
44
45 ++i;
46 }
47
48 ++depth;
49 }
50
51 static void
52 end_element_handler (GMarkupParseContext *context,
53 const gchar *element_name,
54 gpointer user_data,
55 GError **error)
56 {
57 --depth;
58 indent (0);
59 g_string_append_printf (string, "END '%s'\n", element_name);
60 }
61
62 static void
63 text_handler (GMarkupParseContext *context,
64 const gchar *text,
65 gsize text_len,
66 gpointer user_data,
67 GError **error)
68 {
69 indent (0);
70 g_string_append_printf (string, "TEXT '%.*s'\n", (int)text_len, text);
71 }
72
73
74 static void
75 passthrough_handler (GMarkupParseContext *context,
76 const gchar *passthrough_text,
77 gsize text_len,
78 gpointer user_data,
79 GError **error)
80 {
81 indent (0);
82
83 g_string_append_printf (string, "PASS '%.*s'\n", (int)text_len, passthrough_text);
84 }
85
86 static void
87 error_handler (GMarkupParseContext *context,
88 GError *error,
89 gpointer user_data)
90 {
91 g_string_append_printf (string, "ERROR %s\n", error->message);
92 }
93
94 static const GMarkupParser parser = {
95 start_element_handler,
96 end_element_handler,
97 text_handler,
98 passthrough_handler,
99 error_handler
100 };
101
102 static const GMarkupParser silent_parser = {
103 NULL,
104 NULL,
105 NULL,
106 NULL,
107 error_handler
108 };
109
110 static int
111 test_in_chunks (const gchar *contents,
112 gint length,
113 gint chunk_size,
114 GMarkupParseFlags flags)
115 {
116 GMarkupParseContext *context;
117 int i = 0;
118
119 context = g_markup_parse_context_new (&silent_parser, flags, NULL, NULL);
120
121 while (i < length)
122 {
123 int this_chunk = MIN (length - i, chunk_size);
124
125 if (!g_markup_parse_context_parse (context,
126 contents + i,
127 this_chunk,
128 NULL))
129 {
130 g_markup_parse_context_free (context);
131 return 1;
132 }
133
134 i += this_chunk;
135 }
136
137 if (!g_markup_parse_context_end_parse (context, NULL))
138 {
139 g_markup_parse_context_free (context);
140 return 1;
141 }
142
143 g_markup_parse_context_free (context);
144
145 return 0;
146 }
147
148 /* Load the given @filename and parse it multiple times with different chunking
149 * and length handling. All results should be equal. %TRUE is returned if the
150 * file was parsed successfully on every attempt; %FALSE if it failed to parse
151 * on every attempt. The test aborts if some attempts succeed and some fail. */
152 static gboolean
153 test_file (const gchar *filename,
154 GMarkupParseFlags flags)
155 {
156 gchar *contents = NULL, *contents_unterminated = NULL;
157 gsize length_bytes;
158 GError *local_error = NULL;
159 GMarkupParseContext *context;
160 gint line, col;
161 guint n_failures = 0;
162 guint n_tests = 0;
163 const gsize chunk_sizes_bytes[] = { 1, 2, 5, 12, 1024 };
164 gsize i;
165 GString *first_string = NULL;
166
167 g_file_get_contents (filename, &contents, &length_bytes, &local_error);
168 g_assert_no_error (local_error);
169
170 /* Make a copy of the contents with no trailing nul. */
171 contents_unterminated = g_malloc (length_bytes);
172 if (contents_unterminated != NULL)
173 memcpy (contents_unterminated, contents, length_bytes);
174
175 /* Test with nul termination. */
176 context = g_markup_parse_context_new (&parser, flags, NULL, NULL);
177 g_assert (g_markup_parse_context_get_user_data (context) == NULL);
178 g_markup_parse_context_get_position (context, &line, &col);
179 g_assert_cmpint (line, ==, 1);
180 g_assert_cmpint (col, ==, 1);
181
182 if (!g_markup_parse_context_parse (context, contents, -1, NULL) ||
183 !g_markup_parse_context_end_parse (context, NULL))
184 n_failures++;
185 n_tests++;
186
187 g_markup_parse_context_free (context);
188
189 /* FIXME: Swap out the error string so we only return one copy of it, not
190 * @n_tests copies. This should be fixed properly by eliminating the global
191 * state in this file. */
192 first_string = g_steal_pointer (&string);
193 string = g_string_new ("");
194
195 /* With the length specified explicitly and a nul terminator present (since
196 * g_file_get_contents() always adds one). */
197 if (test_in_chunks (contents, length_bytes, length_bytes, flags) != 0)
198 n_failures++;
199 n_tests++;
200
201 /* With the length specified explicitly and no nul terminator present. */
202 if (test_in_chunks (contents_unterminated, length_bytes, length_bytes, flags) != 0)
203 n_failures++;
204 n_tests++;
205
206 /* In various sized chunks. */
207 for (i = 0; i < G_N_ELEMENTS (chunk_sizes_bytes); i++)
208 {
209 if (test_in_chunks (contents, length_bytes, chunk_sizes_bytes[i], flags) != 0)
210 n_failures++;
211 n_tests++;
212 }
213
214 g_free (contents);
215 g_free (contents_unterminated);
216
217 /* FIXME: Restore the error string. */
218 g_string_free (string, TRUE);
219 string = g_steal_pointer (&first_string);
220
221 /* We expect the file to either always be parsed successfully, or never be
222 * parsed successfully. There’s a bug in GMarkup if it sometimes parses
223 * successfully depending on how you chunk or terminate the input. */
224 if (n_failures > 0)
225 g_assert_cmpint (n_failures, ==, n_tests);
226
227 return (n_failures == 0);
228 }
229
230 static gchar *
231 get_expected_filename (const gchar *filename,
232 GMarkupParseFlags flags)
233 {
234 gchar *f, *p, *expected;
235
236 f = g_strdup (filename);
237 p = strstr (f, ".gmarkup");
238 if (p)
239 *p = 0;
240 if (flags == 0)
241 expected = g_strconcat (f, ".expected", NULL);
242 else if (flags == G_MARKUP_TREAT_CDATA_AS_TEXT)
243 expected = g_strconcat (f, ".cdata-as-text", NULL);
244 else
245 g_assert_not_reached ();
246
247 g_free (f);
248
249 return expected;
250 }
251
252 static void
253 test_parse (gconstpointer d)
254 {
255 const gchar *filename = d;
256 gchar *expected_file;
257 gchar *expected;
258 gboolean valid_input;
259 GError *error = NULL;
260 gboolean res;
261
262 valid_input = strstr (filename, "valid") != NULL;
263 expected_file = get_expected_filename (filename, 0);
264
265 depth = 0;
266 string = g_string_sized_new (0);
267
268 res = test_file (filename, 0);
269 g_assert_cmpint (res, ==, valid_input);
270
271 g_file_get_contents (expected_file, &expected, NULL, &error);
272 g_assert_no_error (error);
273 g_assert_cmpstr (string->str, ==, expected);
274 g_free (expected);
275
276 g_string_free (string, TRUE);
277
278 g_free (expected_file);
279
280 expected_file = get_expected_filename (filename, G_MARKUP_TREAT_CDATA_AS_TEXT);
281 if (g_file_test (expected_file, G_FILE_TEST_EXISTS))
282 {
283 depth = 0;
284 string = g_string_sized_new (0);
285
286 res = test_file (filename, G_MARKUP_TREAT_CDATA_AS_TEXT);
287 g_assert_cmpint (res, ==, valid_input);
288
289 g_file_get_contents (expected_file, &expected, NULL, &error);
290 g_assert_no_error (error);
291 g_assert_cmpstr (string->str, ==, expected);
292 g_free (expected);
293
294 g_string_free (string, TRUE);
295 }
296
297 g_free (expected_file);
298 }
299
300 int
301 main (int argc, char *argv[])
302 {
303 GDir *dir;
304 GError *error;
305 const gchar *name;
306 gchar *path;
307
308 g_setenv ("LC_ALL", "C", TRUE);
309 setlocale (LC_ALL, "");
310
311 g_test_init (&argc, &argv, NULL);
312
313 /* allow to easily generate expected output for new test cases */
314 if (argc > 1)
315 {
316 gint arg = 1;
317 GMarkupParseFlags flags = G_MARKUP_DEFAULT_FLAGS;
318
319 if (strcmp (argv[1], "--cdata-as-text") == 0)
320 {
321 flags = G_MARKUP_TREAT_CDATA_AS_TEXT;
322 arg = 2;
323 }
324 string = g_string_sized_new (0);
325 test_file (argv[arg], flags);
326 g_print ("%s", string->str);
327 return 0;
328 }
329
330 error = NULL;
331 path = g_test_build_filename (G_TEST_DIST, "markups", NULL);
332 dir = g_dir_open (path, 0, &error);
333 g_free (path);
334 g_assert_no_error (error);
335 while ((name = g_dir_read_name (dir)) != NULL)
336 {
337 if (!strstr (name, "gmarkup"))
338 continue;
339
340 path = g_strdup_printf ("/markup/parse/%s", name);
341 g_test_add_data_func_full (path, g_test_build_filename (G_TEST_DIST, "markups", name, NULL),
342 test_parse, g_free);
343 g_free (path);
344 }
345 g_dir_close (dir);
346
347 return g_test_run ();
348 }