Branch data Line data Source code
1 : : /* GLib testing framework examples and tests
2 : : *
3 : : * Copyright (C) 2011 Red Hat, Inc.
4 : : *
5 : : * SPDX-License-Identifier: LGPL-2.1-or-later
6 : : *
7 : : * This library is free software; you can redistribute it and/or
8 : : * modify it under the terms of the GNU Lesser General Public
9 : : * License as published by the Free Software Foundation; either
10 : : * version 2.1 of the License, or (at your option) any later version.
11 : : *
12 : : * This library is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : * Lesser General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU Lesser General
18 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 : : */
20 : :
21 : : #include <string.h>
22 : : #include <gio/gio.h>
23 : : #include <glibconfig.h>
24 : : #include "gconstructor.h"
25 : : #include "test_resources2.h"
26 : : #include "digit_test_resources.h"
27 : :
28 : : #ifdef _MSC_VER
29 : : # define MODULE_FILENAME_PREFIX ""
30 : : #else
31 : : # define MODULE_FILENAME_PREFIX "lib"
32 : : #endif
33 : :
34 : : static void
35 : 3 : test_resource (GResource *resource)
36 : : {
37 : 3 : GError *error = NULL;
38 : : gboolean found, success;
39 : : gsize size;
40 : : guint32 flags;
41 : : GBytes *data;
42 : : char **children;
43 : : GInputStream *in;
44 : : char buffer[128];
45 : 3 : const gchar *not_found_paths[] =
46 : : {
47 : : "/not/there",
48 : : "/",
49 : : "",
50 : : };
51 : : gsize i;
52 : :
53 : 12 : for (i = 0; i < G_N_ELEMENTS (not_found_paths); i++)
54 : : {
55 : 9 : found = g_resource_get_info (resource,
56 : 9 : not_found_paths[i],
57 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
58 : : &size, &flags, &error);
59 : 9 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
60 : 9 : g_clear_error (&error);
61 : 9 : g_assert_false (found);
62 : : }
63 : :
64 : 3 : found = g_resource_get_info (resource,
65 : : "/test1.txt",
66 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
67 : : &size, &flags, &error);
68 : 3 : g_assert_true (found);
69 : 3 : g_assert_no_error (error);
70 : 3 : g_assert_cmpint (size, ==, 6);
71 : 3 : g_assert_cmpuint (flags, ==, G_RESOURCE_FLAGS_COMPRESSED);
72 : :
73 : 3 : found = g_resource_get_info (resource,
74 : : "/empty.txt",
75 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
76 : : &size, &flags, &error);
77 : 3 : g_assert_true (found);
78 : 3 : g_assert_no_error (error);
79 : 3 : g_assert_cmpint (size, ==, 0);
80 : 3 : g_assert_cmpuint (flags, ==, G_RESOURCE_FLAGS_COMPRESSED);
81 : :
82 : 3 : found = g_resource_get_info (resource,
83 : : "/a_prefix/test2.txt",
84 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
85 : : &size, &flags, &error);
86 : 3 : g_assert_true (found);
87 : 3 : g_assert_no_error (error);
88 : 3 : g_assert_cmpint (size, ==, 6);
89 : 3 : g_assert_cmpuint (flags, ==, 0);
90 : :
91 : 3 : found = g_resource_get_info (resource,
92 : : "/a_prefix/test2-alias.txt",
93 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
94 : : &size, &flags, &error);
95 : 3 : g_assert_true (found);
96 : 3 : g_assert_no_error (error);
97 : 3 : g_assert_cmpint (size, ==, 6);
98 : 3 : g_assert_cmpuint (flags, ==, 0);
99 : :
100 : 12 : for (i = 0; i < G_N_ELEMENTS (not_found_paths); i++)
101 : : {
102 : 9 : data = g_resource_lookup_data (resource,
103 : 9 : not_found_paths[i],
104 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
105 : : &error);
106 : 9 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
107 : 9 : g_clear_error (&error);
108 : 9 : g_assert_null (data);
109 : : }
110 : :
111 : 3 : data = g_resource_lookup_data (resource,
112 : : "/test1.txt",
113 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
114 : : &error);
115 : 3 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
116 : 3 : g_assert_no_error (error);
117 : 3 : g_bytes_unref (data);
118 : :
119 : 3 : data = g_resource_lookup_data (resource,
120 : : "/empty.txt",
121 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
122 : : &error);
123 : 3 : g_assert_cmpuint (g_bytes_get_size (data), ==, 0);
124 : 3 : g_assert_no_error (error);
125 : 3 : g_bytes_unref (data);
126 : :
127 : 12 : for (i = 0; i < G_N_ELEMENTS (not_found_paths); i++)
128 : : {
129 : 18 : in = g_resource_open_stream (resource,
130 : 9 : not_found_paths[i],
131 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
132 : : &error);
133 : 9 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
134 : 9 : g_clear_error (&error);
135 : 9 : g_assert_null (in);
136 : : }
137 : :
138 : 3 : in = g_resource_open_stream (resource,
139 : : "/test1.txt",
140 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
141 : : &error);
142 : 3 : g_assert_nonnull (in);
143 : 3 : g_assert_no_error (error);
144 : :
145 : 3 : success = g_input_stream_read_all (in, buffer, sizeof (buffer) - 1,
146 : : &size,
147 : : NULL, &error);
148 : 3 : g_assert_true (success);
149 : 3 : g_assert_no_error (error);
150 : 3 : g_assert_cmpint (size, ==, 6);
151 : 3 : buffer[size] = 0;
152 : 3 : g_assert_cmpstr (buffer, ==, "test1\n");
153 : :
154 : 3 : g_input_stream_close (in, NULL, &error);
155 : 3 : g_assert_no_error (error);
156 : 3 : g_clear_object (&in);
157 : :
158 : 3 : in = g_resource_open_stream (resource,
159 : : "/empty.txt",
160 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
161 : : &error);
162 : 3 : g_assert_no_error (error);
163 : 3 : g_assert_nonnull (in);
164 : :
165 : 3 : success = g_input_stream_read_all (in, buffer, sizeof (buffer) - 1,
166 : : &size,
167 : : NULL, &error);
168 : 3 : g_assert_no_error (error);
169 : 3 : g_assert_true (success);
170 : 3 : g_assert_cmpint (size, ==, 0);
171 : :
172 : 3 : g_input_stream_close (in, NULL, &error);
173 : 3 : g_assert_no_error (error);
174 : 3 : g_clear_object (&in);
175 : :
176 : 3 : data = g_resource_lookup_data (resource,
177 : : "/a_prefix/test2.txt",
178 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
179 : : &error);
180 : 3 : g_assert_nonnull (data);
181 : 3 : g_assert_no_error (error);
182 : 3 : size = g_bytes_get_size (data);
183 : 3 : g_assert_cmpint (size, ==, 6);
184 : 3 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test2\n");
185 : 3 : g_bytes_unref (data);
186 : :
187 : 3 : data = g_resource_lookup_data (resource,
188 : : "/a_prefix/test2-alias.txt",
189 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
190 : : &error);
191 : 3 : g_assert_nonnull (data);
192 : 3 : g_assert_no_error (error);
193 : 3 : size = g_bytes_get_size (data);
194 : 3 : g_assert_cmpint (size, ==, 6);
195 : 3 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test2\n");
196 : 3 : g_bytes_unref (data);
197 : :
198 : 12 : for (i = 0; i < G_N_ELEMENTS (not_found_paths); i++)
199 : : {
200 : 9 : if (g_str_equal (not_found_paths[i], "/"))
201 : 3 : continue;
202 : :
203 : 6 : children = g_resource_enumerate_children (resource,
204 : 6 : not_found_paths[i],
205 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
206 : : &error);
207 : 6 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
208 : 6 : g_clear_error (&error);
209 : 6 : g_assert_null (children);
210 : : }
211 : :
212 : 3 : children = g_resource_enumerate_children (resource,
213 : : "/a_prefix",
214 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
215 : : &error);
216 : 3 : g_assert_nonnull (children);
217 : 3 : g_assert_no_error (error);
218 : 3 : g_assert_cmpint (g_strv_length (children), ==, 2);
219 : 3 : g_strfreev (children);
220 : :
221 : : /* Test the preferred lookup where we have a trailing slash. */
222 : 3 : children = g_resource_enumerate_children (resource,
223 : : "/a_prefix/",
224 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
225 : : &error);
226 : 3 : g_assert_nonnull (children);
227 : 3 : g_assert_no_error (error);
228 : 3 : g_assert_cmpint (g_strv_length (children), ==, 2);
229 : 3 : g_strfreev (children);
230 : :
231 : : /* test with a path > 256 and no trailing slash to test the
232 : : * slow path of resources where we allocate a modified path.
233 : : */
234 : 3 : children = g_resource_enumerate_children (resource,
235 : : "/not/here/not/here/not/here/not/here/not/here/not/here/not/here"
236 : : "/not/here/not/here/not/here/not/here/not/here/not/here/not/here"
237 : : "/not/here/not/here/not/here/not/here/not/here/not/here/not/here"
238 : : "/not/here/not/here/not/here/not/here/not/here/not/here/not/here"
239 : : "/not/here/not/here/not/here/not/here/not/here/not/here/not/here"
240 : : "/with/no/trailing/slash",
241 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
242 : : &error);
243 : 3 : g_assert_null (children);
244 : 3 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
245 : 3 : g_clear_error (&error);
246 : 3 : }
247 : :
248 : : static void
249 : 1 : test_resource_file (void)
250 : : {
251 : : GResource *resource;
252 : 1 : GError *error = NULL;
253 : :
254 : 1 : resource = g_resource_load ("not-there", &error);
255 : 1 : g_assert_null (resource);
256 : 1 : g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
257 : 1 : g_clear_error (&error);
258 : :
259 : 1 : resource = g_resource_load (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL), &error);
260 : 1 : g_assert_nonnull (resource);
261 : 1 : g_assert_no_error (error);
262 : :
263 : 1 : test_resource (resource);
264 : 1 : g_resource_unref (resource);
265 : 1 : }
266 : :
267 : : static void
268 : 1 : test_resource_file_path (void)
269 : : {
270 : : static const struct {
271 : : const gchar *input;
272 : : const gchar *expected;
273 : : } test_uris[] = {
274 : : { "resource://", "resource:///" },
275 : : { "resource:///", "resource:///" },
276 : : { "resource://////", "resource:///" },
277 : : { "resource:///../../../", "resource:///" },
278 : : { "resource:///../../..", "resource:///" },
279 : : { "resource://abc", "resource:///abc" },
280 : : { "resource:///abc/", "resource:///abc" },
281 : : { "resource:/a/b/../c/", "resource:///a/c" },
282 : : { "resource://../a/b/../c/../", "resource:///a" },
283 : : { "resource://a/b/cc//bb//a///", "resource:///a/b/cc/bb/a" },
284 : : { "resource://././././", "resource:///" },
285 : : { "resource://././././../", "resource:///" },
286 : : { "resource://a/b/c/d.png", "resource:///a/b/c/d.png" },
287 : : { "resource://a/b/c/..png", "resource:///a/b/c/..png" },
288 : : { "resource://a/b/c/./png", "resource:///a/b/c/png" },
289 : : };
290 : : guint i;
291 : :
292 : 16 : for (i = 0; i < G_N_ELEMENTS (test_uris); i++)
293 : : {
294 : : GFile *file;
295 : : gchar *uri;
296 : :
297 : 15 : file = g_file_new_for_uri (test_uris[i].input);
298 : 15 : g_assert_nonnull (file);
299 : :
300 : 15 : uri = g_file_get_uri (file);
301 : 15 : g_assert_nonnull (uri);
302 : :
303 : 15 : g_assert_cmpstr (uri, ==, test_uris[i].expected);
304 : :
305 : 15 : g_object_unref (file);
306 : 15 : g_free (uri);
307 : : }
308 : 1 : }
309 : :
310 : : static void
311 : 1 : test_resource_data (void)
312 : : {
313 : : GResource *resource;
314 : 1 : GError *error = NULL;
315 : : gboolean loaded_file;
316 : : char *content;
317 : : gsize content_size;
318 : : GBytes *data;
319 : :
320 : 1 : loaded_file = g_file_get_contents (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL),
321 : : &content, &content_size, NULL);
322 : 1 : g_assert_true (loaded_file);
323 : :
324 : 1 : data = g_bytes_new_take (content, content_size);
325 : 1 : resource = g_resource_new_from_data (data, &error);
326 : 1 : g_bytes_unref (data);
327 : 1 : g_assert_nonnull (resource);
328 : 1 : g_assert_no_error (error);
329 : :
330 : 1 : test_resource (resource);
331 : :
332 : 1 : g_resource_unref (resource);
333 : 1 : }
334 : :
335 : : static void
336 : 1 : test_resource_data_unaligned (void)
337 : : {
338 : : GResource *resource;
339 : 1 : GError *error = NULL;
340 : : gboolean loaded_file;
341 : : char *content, *content_copy;
342 : : gsize content_size;
343 : : GBytes *data;
344 : :
345 : 1 : loaded_file = g_file_get_contents (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL),
346 : : &content, &content_size, NULL);
347 : 1 : g_assert_true (loaded_file);
348 : :
349 : 1 : content_copy = g_new (char, content_size + 1);
350 : 1 : memcpy (content_copy + 1, content, content_size);
351 : :
352 : 1 : data = g_bytes_new_with_free_func (content_copy + 1, content_size,
353 : : (GDestroyNotify) g_free, content_copy);
354 : 1 : g_free (content);
355 : 1 : resource = g_resource_new_from_data (data, &error);
356 : 1 : g_bytes_unref (data);
357 : 1 : g_assert_nonnull (resource);
358 : 1 : g_assert_no_error (error);
359 : :
360 : 1 : test_resource (resource);
361 : :
362 : 1 : g_resource_unref (resource);
363 : 1 : }
364 : :
365 : : /* Test error handling for corrupt GResource files (specifically, a corrupt
366 : : * GVDB header). */
367 : : static void
368 : 1 : test_resource_data_corrupt (void)
369 : : {
370 : : /* A GVDB header is 6 guint32s, and requires a magic number in the first two
371 : : * guint32s. A set of zero bytes of a greater length is considered corrupt. */
372 : : static const guint8 data[sizeof (guint32) * 7] = { 0, };
373 : 1 : GBytes *bytes = NULL;
374 : 1 : GResource *resource = NULL;
375 : 1 : GError *local_error = NULL;
376 : :
377 : 1 : bytes = g_bytes_new_static (data, sizeof (data));
378 : 1 : resource = g_resource_new_from_data (bytes, &local_error);
379 : 1 : g_bytes_unref (bytes);
380 : 1 : g_assert_error (local_error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_INTERNAL);
381 : 1 : g_assert_null (resource);
382 : :
383 : 1 : g_clear_error (&local_error);
384 : 1 : }
385 : :
386 : : /* Test handling for empty GResource files. They should also be treated as
387 : : * corrupt. */
388 : : static void
389 : 1 : test_resource_data_empty (void)
390 : : {
391 : 1 : GBytes *bytes = NULL;
392 : 1 : GResource *resource = NULL;
393 : 1 : GError *local_error = NULL;
394 : :
395 : 1 : bytes = g_bytes_new_static (NULL, 0);
396 : 1 : resource = g_resource_new_from_data (bytes, &local_error);
397 : 1 : g_bytes_unref (bytes);
398 : 1 : g_assert_error (local_error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_INTERNAL);
399 : 1 : g_assert_null (resource);
400 : :
401 : 1 : g_clear_error (&local_error);
402 : 1 : }
403 : :
404 : : static void
405 : 1 : test_resource_data_corrupt_compression (void)
406 : : {
407 : 1 : GFile *resource_file = NULL;
408 : 1 : GBytes *resource_bytes = NULL, *corrupt_bytes = NULL, *data_bytes = NULL;
409 : 1 : guint8 *corrupt_data = NULL;
410 : 1 : GResource *resource = NULL;
411 : 1 : GError *local_error = NULL;
412 : :
413 : 1 : g_test_summary ("Test error handling for corrupt GResource files (specifically, corrupt zlib compression).");
414 : :
415 : 1 : resource_file = g_file_new_for_path (g_test_get_filename (G_TEST_BUILT, "test6.gresource", NULL));
416 : 1 : resource_bytes = g_file_load_bytes (resource_file, NULL, NULL, &local_error);
417 : 1 : g_assert_no_error (local_error);
418 : 1 : g_clear_object (&resource_file);
419 : :
420 : : /* Test loading the resource normally, to check it works. */
421 : 1 : resource = g_resource_new_from_data (resource_bytes, &local_error);
422 : 1 : g_assert_no_error (local_error);
423 : :
424 : 1 : data_bytes = g_resource_lookup_data (resource, "/test-corrupt-compression.txt",
425 : : G_RESOURCE_LOOKUP_FLAGS_NONE, &local_error);
426 : 1 : g_assert_no_error (local_error);
427 : 1 : g_assert_nonnull (data_bytes);
428 : 1 : g_clear_pointer (&data_bytes, g_bytes_unref);
429 : :
430 : 1 : g_clear_pointer (&resource, g_resource_unref);
431 : :
432 : : /* Modify the data to zero out bytes 0x90 to 0x100. These are comfortably
433 : : * within the compressed file data, so should break that while not breaking
434 : : * the GVDB header. */
435 : 1 : corrupt_data = g_memdup2 (g_bytes_get_data (resource_bytes, NULL), g_bytes_get_size (resource_bytes));
436 : 1 : memset (corrupt_data + 0x90, 0, 0x10);
437 : 1 : corrupt_bytes = g_bytes_new_take (g_steal_pointer (&corrupt_data), g_bytes_get_size (resource_bytes));
438 : :
439 : 1 : resource = g_resource_new_from_data (corrupt_bytes, &local_error);
440 : 1 : g_assert_no_error (local_error);
441 : 1 : g_bytes_unref (corrupt_bytes);
442 : :
443 : 1 : data_bytes = g_resource_lookup_data (resource, "/test-corrupt-compression.txt",
444 : : G_RESOURCE_LOOKUP_FLAGS_NONE, &local_error);
445 : 1 : g_assert_error (local_error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_INTERNAL);
446 : 1 : g_assert_null (data_bytes);
447 : 1 : g_clear_error (&local_error);
448 : :
449 : 1 : g_clear_pointer (&resource_bytes, g_bytes_unref);
450 : 1 : g_clear_pointer (&resource, g_resource_unref);
451 : 1 : }
452 : :
453 : : static void
454 : 1 : test_resource_registered (void)
455 : : {
456 : : GResource *resource;
457 : 1 : GError *error = NULL;
458 : : gboolean found, success;
459 : : gsize size;
460 : : guint32 flags;
461 : : GBytes *data;
462 : : char **children;
463 : : GInputStream *in;
464 : : char buffer[128];
465 : :
466 : 1 : resource = g_resource_load (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL), &error);
467 : 1 : g_assert_nonnull (resource);
468 : 1 : g_assert_no_error (error);
469 : :
470 : 1 : found = g_resources_get_info ("/test1.txt",
471 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
472 : : &size, &flags, &error);
473 : 1 : g_assert_false (found);
474 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
475 : 1 : g_clear_error (&error);
476 : :
477 : 1 : g_resources_register (resource);
478 : :
479 : 1 : found = g_resources_get_info ("/test1.txt",
480 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
481 : : &size, &flags, &error);
482 : 1 : g_assert_true (found);
483 : 1 : g_assert_no_error (error);
484 : 1 : g_assert_cmpint (size, ==, 6);
485 : 1 : g_assert_cmpint (flags, ==, G_RESOURCE_FLAGS_COMPRESSED);
486 : :
487 : 1 : found = g_resources_get_info ("/empty.txt",
488 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
489 : : &size, &flags, &error);
490 : 1 : g_assert_no_error (error);
491 : 1 : g_assert_true (found);
492 : 1 : g_assert_cmpint (size, ==, 0);
493 : 1 : g_assert_cmpint (flags, ==, G_RESOURCE_FLAGS_COMPRESSED);
494 : :
495 : 1 : found = g_resources_get_info ("/a_prefix/test2.txt",
496 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
497 : : &size, &flags, &error);
498 : 1 : g_assert_true (found);
499 : 1 : g_assert_no_error (error);
500 : 1 : g_assert_cmpint (size, ==, 6);
501 : 1 : g_assert_cmpint (flags, ==, 0);
502 : :
503 : 1 : found = g_resources_get_info ("/a_prefix/test2-alias.txt",
504 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
505 : : &size, &flags, &error);
506 : 1 : g_assert_true (found);
507 : 1 : g_assert_no_error (error);
508 : 1 : g_assert_cmpint (size, ==, 6);
509 : 1 : g_assert_cmpuint (flags, ==, 0);
510 : :
511 : 1 : data = g_resources_lookup_data ("/test1.txt",
512 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
513 : : &error);
514 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
515 : 1 : g_assert_no_error (error);
516 : 1 : g_bytes_unref (data);
517 : :
518 : 1 : in = g_resources_open_stream ("/test1.txt",
519 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
520 : : &error);
521 : 1 : g_assert_nonnull (in);
522 : 1 : g_assert_no_error (error);
523 : :
524 : 1 : success = g_input_stream_read_all (in, buffer, sizeof (buffer) - 1,
525 : : &size,
526 : : NULL, &error);
527 : 1 : g_assert_true (success);
528 : 1 : g_assert_no_error (error);
529 : 1 : g_assert_cmpint (size, ==, 6);
530 : 1 : buffer[size] = 0;
531 : 1 : g_assert_cmpstr (buffer, ==, "test1\n");
532 : :
533 : 1 : g_input_stream_close (in, NULL, &error);
534 : 1 : g_assert_no_error (error);
535 : 1 : g_clear_object (&in);
536 : :
537 : 1 : data = g_resources_lookup_data ("/empty.txt",
538 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
539 : : &error);
540 : 1 : g_assert_no_error (error);
541 : 1 : g_assert_cmpuint (g_bytes_get_size (data), ==, 0);
542 : 1 : g_bytes_unref (data);
543 : :
544 : 1 : in = g_resources_open_stream ("/empty.txt",
545 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
546 : : &error);
547 : 1 : g_assert_no_error (error);
548 : 1 : g_assert_nonnull (in);
549 : :
550 : 1 : success = g_input_stream_read_all (in, buffer, sizeof (buffer) - 1,
551 : : &size,
552 : : NULL, &error);
553 : 1 : g_assert_no_error (error);
554 : 1 : g_assert_true (success);
555 : 1 : g_assert_cmpint (size, ==, 0);
556 : :
557 : 1 : g_input_stream_close (in, NULL, &error);
558 : 1 : g_assert_no_error (error);
559 : 1 : g_clear_object (&in);
560 : :
561 : 1 : data = g_resources_lookup_data ("/a_prefix/test2.txt",
562 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
563 : : &error);
564 : 1 : g_assert_nonnull (data);
565 : 1 : g_assert_no_error (error);
566 : 1 : size = g_bytes_get_size (data);
567 : 1 : g_assert_cmpint (size, ==, 6);
568 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test2\n");
569 : 1 : g_bytes_unref (data);
570 : :
571 : 1 : data = g_resources_lookup_data ("/a_prefix/test2-alias.txt",
572 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
573 : : &error);
574 : 1 : g_assert_nonnull (data);
575 : 1 : g_assert_no_error (error);
576 : 1 : size = g_bytes_get_size (data);
577 : 1 : g_assert_cmpint (size, ==, 6);
578 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test2\n");
579 : 1 : g_bytes_unref (data);
580 : :
581 : 1 : children = g_resources_enumerate_children ("/not/here",
582 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
583 : : &error);
584 : 1 : g_assert_null (children);
585 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
586 : 1 : g_clear_error (&error);
587 : :
588 : 1 : children = g_resources_enumerate_children ("/a_prefix",
589 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
590 : : &error);
591 : 1 : g_assert_nonnull (children);
592 : 1 : g_assert_no_error (error);
593 : 1 : g_assert_cmpint (g_strv_length (children), ==, 2);
594 : 1 : g_strfreev (children);
595 : :
596 : 1 : g_resources_unregister (resource);
597 : 1 : g_resource_unref (resource);
598 : :
599 : 1 : found = g_resources_get_info ("/test1.txt",
600 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
601 : : &size, &flags, &error);
602 : 1 : g_assert_false (found);
603 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
604 : 1 : g_clear_error (&error);
605 : :
606 : 1 : data = g_resources_lookup_data ("/test1.txt",
607 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
608 : : &error);
609 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
610 : 1 : g_assert_null (data);
611 : 1 : g_clear_error (&error);
612 : :
613 : 1 : in = g_resources_open_stream ("/test1.txt",
614 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
615 : : &error);
616 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
617 : 1 : g_assert_null (in);
618 : 1 : g_clear_error (&error);
619 : 1 : }
620 : :
621 : : static void
622 : 1 : test_resource_automatic (void)
623 : : {
624 : 1 : GError *error = NULL;
625 : : gboolean found;
626 : : gsize size;
627 : : guint32 flags;
628 : : GBytes *data;
629 : :
630 : 1 : found = g_resources_get_info ("/auto_loaded/test1.txt",
631 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
632 : : &size, &flags, &error);
633 : 1 : g_assert_true (found);
634 : 1 : g_assert_no_error (error);
635 : 1 : g_assert_cmpint (size, ==, 6);
636 : 1 : g_assert_cmpint (flags, ==, 0);
637 : :
638 : 1 : data = g_resources_lookup_data ("/auto_loaded/test1.txt",
639 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
640 : : &error);
641 : 1 : g_assert_nonnull (data);
642 : 1 : g_assert_no_error (error);
643 : 1 : size = g_bytes_get_size (data);
644 : 1 : g_assert_cmpint (size, ==, 6);
645 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
646 : 1 : g_bytes_unref (data);
647 : 1 : }
648 : :
649 : : static void
650 : 1 : test_resource_manual (void)
651 : : {
652 : 1 : GError *error = NULL;
653 : : gboolean found;
654 : : gsize size;
655 : : guint32 flags;
656 : : GBytes *data;
657 : :
658 : 1 : found = g_resources_get_info ("/manual_loaded/test1.txt",
659 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
660 : : &size, &flags, &error);
661 : 1 : g_assert_true (found);
662 : 1 : g_assert_no_error (error);
663 : 1 : g_assert_cmpint (size, ==, 6);
664 : 1 : g_assert_cmpuint (flags, ==, 0);
665 : :
666 : 1 : data = g_resources_lookup_data ("/manual_loaded/test1.txt",
667 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
668 : : &error);
669 : 1 : g_assert_nonnull (data);
670 : 1 : g_assert_no_error (error);
671 : 1 : size = g_bytes_get_size (data);
672 : 1 : g_assert_cmpint (size, ==, 6);
673 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
674 : 1 : g_bytes_unref (data);
675 : 1 : }
676 : :
677 : : static void
678 : 1 : test_resource_manual2 (void)
679 : : {
680 : : GResource *resource;
681 : : GBytes *data;
682 : : gsize size;
683 : 1 : GError *error = NULL;
684 : :
685 : 1 : resource = _g_test2_get_resource ();
686 : :
687 : 1 : data = g_resource_lookup_data (resource,
688 : : "/manual_loaded/test1.txt",
689 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
690 : : &error);
691 : 1 : g_assert_nonnull (data);
692 : 1 : g_assert_no_error (error);
693 : 1 : size = g_bytes_get_size (data);
694 : 1 : g_assert_cmpint (size, ==, 6);
695 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
696 : 1 : g_bytes_unref (data);
697 : :
698 : 1 : g_resource_unref (resource);
699 : 1 : }
700 : :
701 : : /* Test building resources with external data option,
702 : : * where data is linked in as binary instead of compiled in.
703 : : * Checks if resources are automatically registered and
704 : : * data can be found and read. */
705 : : static void
706 : 1 : test_resource_binary_linked (void)
707 : : {
708 : : #ifdef NO_EXTERNAL_DATA
709 : : g_test_skip ("--external-data cannot be tested: " NO_EXTERNAL_DATA);
710 : : return;
711 : : #else /* !NO_EXTERNAL_DATA */
712 : 1 : GError *error = NULL;
713 : : gboolean found;
714 : : gsize size;
715 : : guint32 flags;
716 : : GBytes *data;
717 : :
718 : 1 : found = g_resources_get_info ("/binary_linked/test1.txt",
719 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
720 : : &size, &flags, &error);
721 : 1 : g_assert_true (found);
722 : 1 : g_assert_no_error (error);
723 : 1 : g_assert_cmpint (size, ==, 6);
724 : 1 : g_assert_cmpuint (flags, ==, 0);
725 : :
726 : 1 : data = g_resources_lookup_data ("/binary_linked/test1.txt",
727 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
728 : : &error);
729 : 1 : g_assert_nonnull (data);
730 : 1 : g_assert_no_error (error);
731 : 1 : size = g_bytes_get_size (data);
732 : 1 : g_assert_cmpint (size, ==, 6);
733 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
734 : 1 : g_bytes_unref (data);
735 : : #endif /* !NO_EXTERNAL_DATA */
736 : 1 : }
737 : :
738 : : /* Test resource whose xml file starts with more than one digit
739 : : * and where no explicit c-name is given
740 : : * Checks if resources are successfully registered and
741 : : * data can be found and read. */
742 : : static void
743 : 1 : test_resource_digits (void)
744 : : {
745 : 1 : GError *error = NULL;
746 : : gboolean found;
747 : : gsize size;
748 : : guint32 flags;
749 : : GBytes *data;
750 : :
751 : 1 : found = g_resources_get_info ("/digit_test/test1.txt",
752 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
753 : : &size, &flags, &error);
754 : 1 : g_assert_true (found);
755 : 1 : g_assert_no_error (error);
756 : 1 : g_assert_cmpint (size, ==, 6);
757 : 1 : g_assert_cmpuint (flags, ==, 0);
758 : :
759 : 1 : data = g_resources_lookup_data ("/digit_test/test1.txt",
760 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
761 : : &error);
762 : 1 : g_assert_nonnull (data);
763 : 1 : g_assert_no_error (error);
764 : 1 : size = g_bytes_get_size (data);
765 : 1 : g_assert_cmpint (size, ==, 6);
766 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
767 : 1 : g_bytes_unref (data);
768 : 1 : }
769 : :
770 : : static void
771 : 1 : test_resource_module (void)
772 : : {
773 : : GIOModule *module;
774 : : gboolean found;
775 : : gsize size;
776 : : guint32 flags;
777 : : GBytes *data;
778 : : GError *error;
779 : :
780 : : #ifdef GLIB_STATIC_COMPILATION
781 : : /* The resource module is statically linked with a separate copy
782 : : * of a GLib so g_static_resource_init won't work as expected. */
783 : : g_test_skip ("Resource modules aren't supported in static builds.");
784 : : return;
785 : : #endif
786 : :
787 : 1 : if (g_module_supported ())
788 : : {
789 : 1 : module = g_io_module_new (g_test_get_filename (G_TEST_BUILT,
790 : : MODULE_FILENAME_PREFIX "resourceplugin",
791 : : NULL));
792 : :
793 : 1 : error = NULL;
794 : :
795 : 1 : found = g_resources_get_info ("/resourceplugin/test1.txt",
796 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
797 : : &size, &flags, &error);
798 : 1 : g_assert_false (found);
799 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
800 : 1 : g_clear_error (&error);
801 : :
802 : 1 : g_type_module_use (G_TYPE_MODULE (module));
803 : :
804 : 1 : found = g_resources_get_info ("/resourceplugin/test1.txt",
805 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
806 : : &size, &flags, &error);
807 : 1 : g_assert_true (found);
808 : 1 : g_assert_no_error (error);
809 : 1 : g_assert_cmpint (size, ==, 6);
810 : 1 : g_assert_cmpuint (flags, ==, 0);
811 : :
812 : 1 : data = g_resources_lookup_data ("/resourceplugin/test1.txt",
813 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
814 : : &error);
815 : 1 : g_assert_nonnull (data);
816 : 1 : g_assert_no_error (error);
817 : 1 : size = g_bytes_get_size (data);
818 : 1 : g_assert_cmpint (size, ==, 6);
819 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, "test1\n");
820 : 1 : g_bytes_unref (data);
821 : :
822 : 1 : g_type_module_unuse (G_TYPE_MODULE (module));
823 : :
824 : 1 : found = g_resources_get_info ("/resourceplugin/test1.txt",
825 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
826 : : &size, &flags, &error);
827 : 1 : g_assert_false (found);
828 : 1 : g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
829 : 1 : g_clear_error (&error);
830 : :
831 : 1 : g_clear_object (&module);
832 : : }
833 : 1 : }
834 : :
835 : : static void
836 : 1 : test_uri_query_info (void)
837 : : {
838 : : GResource *resource;
839 : 1 : GError *error = NULL;
840 : : gboolean loaded_file;
841 : : char *content;
842 : : gsize content_size;
843 : : GBytes *data;
844 : : GFile *file;
845 : : GFileInfo *info;
846 : : const char *content_type;
847 : 1 : gchar *mime_type = NULL;
848 : : const char *fs_type;
849 : : gboolean readonly;
850 : :
851 : 1 : loaded_file = g_file_get_contents (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL),
852 : : &content, &content_size, NULL);
853 : 1 : g_assert_true (loaded_file);
854 : :
855 : 1 : data = g_bytes_new_take (content, content_size);
856 : 1 : resource = g_resource_new_from_data (data, &error);
857 : 1 : g_bytes_unref (data);
858 : 1 : g_assert_nonnull (resource);
859 : 1 : g_assert_no_error (error);
860 : :
861 : 1 : g_resources_register (resource);
862 : :
863 : 1 : file = g_file_new_for_uri ("resource://" "/a_prefix/test2-alias.txt");
864 : 1 : info = g_file_query_info (file, "*", 0, NULL, &error);
865 : 1 : g_assert_no_error (error);
866 : :
867 : 1 : content_type = g_file_info_get_content_type (info);
868 : 1 : g_assert_nonnull (content_type);
869 : 1 : mime_type = g_content_type_get_mime_type (content_type);
870 : 1 : g_assert_nonnull (mime_type);
871 : : #ifdef __APPLE__
872 : : g_assert_cmpstr (mime_type, ==, "text/*");
873 : : #else
874 : 1 : g_assert_cmpstr (mime_type, ==, "text/plain");
875 : : #endif
876 : 1 : g_free (mime_type);
877 : :
878 : 1 : g_object_unref (info);
879 : :
880 : 1 : info = g_file_query_filesystem_info (file, "*", NULL, &error);
881 : 1 : g_assert_no_error (error);
882 : :
883 : 1 : fs_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
884 : 1 : g_assert_cmpstr (fs_type, ==, "resource");
885 : 1 : readonly = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
886 : 1 : g_assert_true (readonly);
887 : :
888 : 1 : g_object_unref (info);
889 : :
890 : 1 : g_assert_cmpuint (g_file_hash (file), !=, 0);
891 : :
892 : 1 : g_object_unref (file);
893 : :
894 : 1 : g_resources_unregister (resource);
895 : 1 : g_resource_unref (resource);
896 : 1 : }
897 : :
898 : : static void
899 : 1 : test_uri_file (void)
900 : : {
901 : : GResource *resource;
902 : 1 : GError *error = NULL;
903 : : gboolean loaded_file;
904 : : char *content;
905 : : gsize content_size;
906 : : GBytes *data;
907 : : GFile *file;
908 : : GFileInfo *info;
909 : : gchar *name;
910 : : GFile *file2, *parent;
911 : : GFileEnumerator *enumerator;
912 : : gchar *scheme;
913 : : GFileAttributeInfoList *attrs;
914 : : GInputStream *stream;
915 : : gchar buf[1024];
916 : : gboolean ret;
917 : : gssize skipped;
918 : :
919 : 1 : loaded_file = g_file_get_contents (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL),
920 : : &content, &content_size, NULL);
921 : 1 : g_assert_true (loaded_file);
922 : :
923 : 1 : data = g_bytes_new_take (content, content_size);
924 : 1 : resource = g_resource_new_from_data (data, &error);
925 : 1 : g_bytes_unref (data);
926 : 1 : g_assert_nonnull (resource);
927 : 1 : g_assert_no_error (error);
928 : :
929 : 1 : g_resources_register (resource);
930 : :
931 : 1 : file = g_file_new_for_uri ("resource://" "/a_prefix/test2-alias.txt");
932 : :
933 : 1 : g_assert_null (g_file_get_path (file));
934 : :
935 : 1 : name = g_file_get_parse_name (file);
936 : 1 : g_assert_cmpstr (name, ==, "resource:///a_prefix/test2-alias.txt");
937 : 1 : g_free (name);
938 : :
939 : 1 : name = g_file_get_uri (file);
940 : 1 : g_assert_cmpstr (name, ==, "resource:///a_prefix/test2-alias.txt");
941 : 1 : g_free (name);
942 : :
943 : 1 : g_assert_false (g_file_is_native (file));
944 : 1 : g_assert_false (g_file_has_uri_scheme (file, "http"));
945 : 1 : g_assert_true (g_file_has_uri_scheme (file, "resource"));
946 : 1 : scheme = g_file_get_uri_scheme (file);
947 : 1 : g_assert_cmpstr (scheme, ==, "resource");
948 : 1 : g_free (scheme);
949 : :
950 : 1 : file2 = g_file_dup (file);
951 : 1 : g_assert_true (g_file_equal (file, file2));
952 : 1 : g_object_unref (file2);
953 : :
954 : 1 : parent = g_file_get_parent (file);
955 : 1 : enumerator = g_file_enumerate_children (parent, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
956 : 1 : g_assert_no_error (error);
957 : :
958 : 1 : file2 = g_file_get_child_for_display_name (parent, "test2-alias.txt", &error);
959 : 1 : g_assert_no_error (error);
960 : 1 : g_assert_true (g_file_equal (file, file2));
961 : 1 : g_object_unref (file2);
962 : :
963 : 1 : info = g_file_enumerator_next_file (enumerator, NULL, &error);
964 : 1 : g_assert_no_error (error);
965 : 1 : g_assert_nonnull (info);
966 : 1 : g_object_unref (info);
967 : :
968 : 1 : info = g_file_enumerator_next_file (enumerator, NULL, &error);
969 : 1 : g_assert_no_error (error);
970 : 1 : g_assert_nonnull (info);
971 : 1 : g_object_unref (info);
972 : :
973 : 1 : info = g_file_enumerator_next_file (enumerator, NULL, &error);
974 : 1 : g_assert_no_error (error);
975 : 1 : g_assert_null (info);
976 : :
977 : 1 : g_file_enumerator_close (enumerator, NULL, &error);
978 : 1 : g_assert_no_error (error);
979 : 1 : g_object_unref (enumerator);
980 : :
981 : 1 : file2 = g_file_new_for_uri ("resource://" "a_prefix/../a_prefix//test2-alias.txt");
982 : 1 : g_assert_true (g_file_equal (file, file2));
983 : :
984 : 1 : g_assert_true (g_file_has_prefix (file, parent));
985 : :
986 : 1 : name = g_file_get_relative_path (parent, file);
987 : 1 : g_assert_cmpstr (name, ==, "test2-alias.txt");
988 : 1 : g_free (name);
989 : :
990 : 1 : g_object_unref (parent);
991 : :
992 : 1 : attrs = g_file_query_settable_attributes (file, NULL, &error);
993 : 1 : g_assert_no_error (error);
994 : 1 : g_file_attribute_info_list_unref (attrs);
995 : :
996 : 1 : attrs = g_file_query_writable_namespaces (file, NULL, &error);
997 : 1 : g_assert_no_error (error);
998 : 1 : g_file_attribute_info_list_unref (attrs);
999 : :
1000 : 1 : stream = G_INPUT_STREAM (g_file_read (file, NULL, &error));
1001 : 1 : g_assert_no_error (error);
1002 : 1 : g_assert_cmpint (g_seekable_tell (G_SEEKABLE (stream)), ==, 0);
1003 : 1 : g_assert_true (g_seekable_can_seek (G_SEEKABLE (G_SEEKABLE (stream))));
1004 : 1 : ret = g_seekable_seek (G_SEEKABLE (stream), 1, G_SEEK_SET, NULL, &error);
1005 : 1 : g_assert_true (ret);
1006 : 1 : g_assert_no_error (error);
1007 : 1 : skipped = g_input_stream_skip (stream, 1, NULL, &error);
1008 : 1 : g_assert_cmpint (skipped, ==, 1);
1009 : 1 : g_assert_no_error (error);
1010 : :
1011 : 1 : memset (buf, 0, 1024);
1012 : 1 : ret = g_input_stream_read_all (stream, &buf, 1024, NULL, NULL, &error);
1013 : 1 : g_assert_true (ret);
1014 : 1 : g_assert_no_error (error);
1015 : 1 : g_assert_cmpstr (buf, ==, "st2\n");
1016 : 1 : info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM (stream),
1017 : : G_FILE_ATTRIBUTE_STANDARD_SIZE,
1018 : : NULL,
1019 : : &error);
1020 : 1 : g_assert_no_error (error);
1021 : 1 : g_assert_nonnull (info);
1022 : 1 : g_assert_cmpint (g_file_info_get_size (info), ==, 6);
1023 : 1 : g_object_unref (info);
1024 : :
1025 : 1 : ret = g_input_stream_close (stream, NULL, &error);
1026 : 1 : g_assert_true (ret);
1027 : 1 : g_assert_no_error (error);
1028 : 1 : g_object_unref (stream);
1029 : :
1030 : 1 : g_object_unref (file);
1031 : 1 : g_object_unref (file2);
1032 : :
1033 : 1 : g_resources_unregister (resource);
1034 : 1 : g_resource_unref (resource);
1035 : 1 : }
1036 : :
1037 : : static void
1038 : 1 : test_resource_64k (void)
1039 : : {
1040 : 1 : GError *error = NULL;
1041 : : gboolean found;
1042 : : gsize size;
1043 : : guint32 flags;
1044 : : GBytes *data;
1045 : : gchar **tokens;
1046 : :
1047 : 1 : found = g_resources_get_info ("/big_prefix/gresource-big-test.txt",
1048 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
1049 : : &size, &flags, &error);
1050 : 1 : g_assert_true (found);
1051 : 1 : g_assert_no_error (error);
1052 : :
1053 : : /* Check size: 100 of all lower case letters + newline char +
1054 : : * 100 all upper case letters + newline char +
1055 : : * 100 of all numbers between 0 to 9 + newline char
1056 : : * (for 12 iterations)
1057 : : */
1058 : :
1059 : 1 : g_assert_cmpint (size, ==, (26 + 26 + 10) * (100 + 1) * 12);
1060 : 1 : g_assert_cmpuint (flags, ==, 0);
1061 : 1 : data = g_resources_lookup_data ("/big_prefix/gresource-big-test.txt",
1062 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
1063 : : &error);
1064 : 1 : g_assert_nonnull (data);
1065 : 1 : g_assert_no_error (error);
1066 : 1 : size = g_bytes_get_size (data);
1067 : :
1068 : 1 : g_assert_cmpint (size, ==, (26 + 26 + 10) * (100 + 1) * 12);
1069 : 1 : tokens = g_strsplit ((const gchar *) g_bytes_get_data (data, NULL), "\n", -1);
1070 : :
1071 : : /* check tokens[x] == entry at gresource-big-test.txt's line, where x = line - 1 */
1072 : 1 : g_assert_cmpstr (tokens[0], ==, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
1073 : 1 : g_assert_cmpstr (tokens[27], ==, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
1074 : 1 : g_assert_cmpstr (tokens[183], ==, "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777");
1075 : 1 : g_assert_cmpstr (tokens[600], ==, "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ");
1076 : 1 : g_assert_cmpstr (tokens[742], ==, "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888");
1077 : 1 : g_strfreev (tokens);
1078 : 1 : g_bytes_unref (data);
1079 : 1 : }
1080 : :
1081 : : /* Check that g_resources_get_info() respects G_RESOURCE_OVERLAYS */
1082 : : static void
1083 : 2 : test_overlay (void)
1084 : : {
1085 : 2 : if (g_test_subprocess ())
1086 : : {
1087 : 1 : GError *error = NULL;
1088 : : gboolean res;
1089 : : gsize size;
1090 : : char *overlay;
1091 : : char *path;
1092 : 1 : GInputStream *in = NULL;
1093 : : char buffer[128];
1094 : 1 : GBytes *data = NULL;
1095 : 1 : char *expected_overlay_data = NULL;
1096 : 1 : size_t expected_overlay_size = 0;
1097 : :
1098 : 1 : path = g_test_build_filename (G_TEST_DIST, "test1.overlay", NULL);
1099 : 1 : res = g_file_get_contents (path, &expected_overlay_data, &expected_overlay_size, NULL);
1100 : 1 : g_assert (res);
1101 : :
1102 : 1 : overlay = g_strconcat ("/auto_loaded/test1.txt=", path, NULL);
1103 : 1 : g_setenv ("G_RESOURCE_OVERLAYS", overlay, TRUE);
1104 : :
1105 : : /* Test getting its info. */
1106 : 1 : res = g_resources_get_info ("/auto_loaded/test1.txt", 0, &size, NULL, &error);
1107 : 1 : g_assert_true (res);
1108 : 1 : g_assert_no_error (error);
1109 : : /* test1.txt is 6 bytes, test1.overlay is 23 */
1110 : 1 : g_assert_cmpuint (size, ==, expected_overlay_size);
1111 : :
1112 : : /* Test it as a stream too. */
1113 : 1 : in = g_resources_open_stream ("/auto_loaded/test1.txt",
1114 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
1115 : : &error);
1116 : 1 : g_assert_no_error (error);
1117 : 1 : g_assert_nonnull (in);
1118 : :
1119 : 1 : res = g_input_stream_read_all (in, buffer, sizeof (buffer) - 1,
1120 : : &size,
1121 : : NULL, &error);
1122 : 1 : g_assert_no_error (error);
1123 : 1 : g_assert_true (res);
1124 : 1 : g_assert_cmpuint (size, ==, expected_overlay_size);
1125 : :
1126 : 1 : g_input_stream_close (in, NULL, &error);
1127 : 1 : g_assert_no_error (error);
1128 : 1 : g_clear_object (&in);
1129 : :
1130 : : /* Test data lookup. */
1131 : 1 : data = g_resources_lookup_data ("/auto_loaded/test1.txt",
1132 : : G_RESOURCE_LOOKUP_FLAGS_NONE,
1133 : : &error);
1134 : 1 : g_assert_nonnull (data);
1135 : 1 : g_assert_no_error (error);
1136 : 1 : size = g_bytes_get_size (data);
1137 : 1 : g_assert_cmpuint (size, ==, expected_overlay_size);
1138 : 1 : g_assert_cmpstr (g_bytes_get_data (data, NULL), ==, expected_overlay_data);
1139 : 1 : g_bytes_unref (data);
1140 : :
1141 : 1 : g_free (overlay);
1142 : 1 : g_free (path);
1143 : 1 : g_free (expected_overlay_data);
1144 : :
1145 : 1 : return;
1146 : : }
1147 : 1 : g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_INHERIT_STDERR);
1148 : 1 : g_test_trap_assert_passed ();
1149 : : }
1150 : :
1151 : : static void
1152 : 1 : test_resource_has_children (void)
1153 : : {
1154 : : GResource *resource;
1155 : 1 : GError *error = NULL;
1156 : :
1157 : 1 : g_assert_true (g_resources_has_children ("/auto_loaded"));
1158 : 1 : g_assert_true (g_resources_has_children ("/auto_loaded/"));
1159 : 1 : g_assert_false (g_resources_has_children ("/auto_loaded/test1.txt"));
1160 : 1 : g_assert_false (g_resources_has_children ("/no/such/prefix"));
1161 : 1 : g_assert_false (g_resources_has_children (""));
1162 : :
1163 : 1 : resource = g_resource_load (g_test_get_filename (G_TEST_BUILT, "test.gresource", NULL), &error);
1164 : 1 : g_assert_nonnull (resource);
1165 : 1 : g_assert_no_error (error);
1166 : :
1167 : 1 : g_assert_true (g_resource_has_children (resource, "/a_prefix"));
1168 : 1 : g_assert_true (g_resource_has_children (resource, "/a_prefix/"));
1169 : 1 : g_assert_false (g_resource_has_children (resource, "/a_prefix/test2.txt"));
1170 : 1 : g_assert_false (g_resource_has_children (resource, "/no/such/prefix"));
1171 : 1 : g_assert_false (g_resource_has_children (resource, ""));
1172 : :
1173 : 1 : g_resource_unref (resource);
1174 : 1 : }
1175 : :
1176 : : int
1177 : 2 : main (int argc,
1178 : : char *argv[])
1179 : : {
1180 : 2 : g_test_init (&argc, &argv, NULL);
1181 : :
1182 : 2 : _g_test2_register_resource ();
1183 : 2 : _digit_test_register_resource ();
1184 : :
1185 : 2 : g_test_add_func ("/resource/file", test_resource_file);
1186 : 2 : g_test_add_func ("/resource/file-path", test_resource_file_path);
1187 : 2 : g_test_add_func ("/resource/data", test_resource_data);
1188 : 2 : g_test_add_func ("/resource/data_unaligned", test_resource_data_unaligned);
1189 : 2 : g_test_add_func ("/resource/data-corrupt", test_resource_data_corrupt);
1190 : 2 : g_test_add_func ("/resource/data-corrupt-compression", test_resource_data_corrupt_compression);
1191 : 2 : g_test_add_func ("/resource/data-empty", test_resource_data_empty);
1192 : 2 : g_test_add_func ("/resource/registered", test_resource_registered);
1193 : 2 : g_test_add_func ("/resource/manual", test_resource_manual);
1194 : 2 : g_test_add_func ("/resource/manual2", test_resource_manual2);
1195 : : #ifdef G_HAS_CONSTRUCTORS
1196 : 2 : g_test_add_func ("/resource/automatic", test_resource_automatic);
1197 : : /* This only uses automatic resources too, so it tests the constructors and destructors */
1198 : 2 : g_test_add_func ("/resource/module", test_resource_module);
1199 : 2 : g_test_add_func ("/resource/binary-linked", test_resource_binary_linked);
1200 : : #endif
1201 : 2 : g_test_add_func ("/resource/uri/query-info", test_uri_query_info);
1202 : 2 : g_test_add_func ("/resource/uri/file", test_uri_file);
1203 : 2 : g_test_add_func ("/resource/64k", test_resource_64k);
1204 : 2 : g_test_add_func ("/resource/overlay", test_overlay);
1205 : 2 : g_test_add_func ("/resource/digits", test_resource_digits);
1206 : 2 : g_test_add_func ("/resource/has-children", test_resource_has_children);
1207 : :
1208 : 2 : return g_test_run();
1209 : : }
|
