1 /* GLib testing framework examples and tests
2 * Copyright (C) 2008 Red Hat, Inc.
3 * Authors: Tomas Bzatek <tbzatek@redhat.com>
4 *
5 * SPDX-License-Identifier: LicenseRef-old-glib-tests
6 *
7 * This work is provided "as is"; redistribution and modification
8 * in whole or in part, in any medium, physical or electronic is
9 * permitted without restriction.
10 *
11 * This work is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 *
15 * In no event shall the authors or contributors be liable for any
16 * direct, indirect, incidental, special, exemplary, or consequential
17 * damages (including, but not limited to, procurement of substitute
18 * goods or services; loss of use, data, or profits; or business
19 * interruption) however caused and on any theory of liability, whether
20 * in contract, strict liability, or tort (including negligence or
21 * otherwise) arising in any way out of the use of this software, even
22 * if advised of the possibility of such damage.
23 */
24
25 #include <glib/glib.h>
26 #include <gio/gio.h>
27 #include <errno.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <unistd.h>
31 #include <sys/types.h>
32 #include <string.h>
33 #include <sys/stat.h>
34
35 #define DEFAULT_TEST_DIR "testdir_live-g-file"
36
37 #define PATTERN_FILE_SIZE 0x10000
38 #define TEST_HANDLE_SPECIAL TRUE
39
40 enum StructureExtraFlags
41 {
42 TEST_DELETE_NORMAL = 1 << 0,
43 TEST_DELETE_TRASH = 1 << 1,
44 TEST_DELETE_NON_EMPTY = 1 << 2,
45 TEST_DELETE_FAILURE = 1 << 3,
46 TEST_NOT_EXISTS = 1 << 4,
47 TEST_ENUMERATE_FILE = 1 << 5,
48 TEST_NO_ACCESS = 1 << 6,
49 TEST_COPY = 1 << 7,
50 TEST_MOVE = 1 << 8,
51 TEST_COPY_ERROR_RECURSE = 1 << 9,
52 TEST_ALREADY_EXISTS = 1 << 10,
53 TEST_TARGET_IS_FILE = 1 << 11,
54 TEST_CREATE = 1 << 12,
55 TEST_REPLACE = 1 << 13,
56 TEST_APPEND = 1 << 14,
57 TEST_OPEN = 1 << 15,
58 TEST_OVERWRITE = 1 << 16,
59 TEST_INVALID_SYMLINK = 1 << 17,
60 TEST_HIDDEN = 1 << 18,
61 TEST_DOT_HIDDEN = 1 << 19,
62 };
63
64 struct StructureItem
65 {
66 const char *filename;
67 const char *link_to;
68 GFileType file_type;
69 GFileCreateFlags create_flags;
70 guint32 mode;
71 gboolean handle_special;
72 enum StructureExtraFlags extra_flags;
73 };
74
75 #define TEST_DIR_NO_ACCESS "dir_no-access"
76 #define TEST_DIR_NO_WRITE "dir_no-write"
77 #define TEST_DIR_TARGET "dir-target"
78 #define TEST_NAME_NOT_EXISTS "not_exists"
79 #define TEST_TARGET_FILE "target-file"
80
81
82 static const struct StructureItem sample_struct[] = {
83 /* filename link file_type create_flags mode | handle_special | extra_flags */
84 {"dir1", NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_NONE, 0, 0, TEST_DELETE_NORMAL | TEST_DELETE_NON_EMPTY | TEST_REPLACE | TEST_OPEN},
85 {"dir1/subdir", NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_COPY_ERROR_RECURSE | TEST_APPEND},
86 {"dir2", NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_NONE, 0, 0, TEST_DELETE_NORMAL | TEST_MOVE | TEST_CREATE},
87 {TEST_DIR_TARGET, NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_COPY_ERROR_RECURSE},
88 {TEST_DIR_NO_ACCESS, NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_PRIVATE, S_IRUSR + S_IWUSR + S_IRGRP + S_IWGRP + S_IROTH + S_IWOTH, 0, TEST_NO_ACCESS | TEST_OPEN},
89 {TEST_DIR_NO_WRITE, NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_PRIVATE, S_IRUSR + S_IXUSR + S_IRGRP + S_IXGRP + S_IROTH + S_IXOTH, 0, 0},
90 {TEST_TARGET_FILE, NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_OPEN},
91 {"normal_file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_ENUMERATE_FILE | TEST_CREATE | TEST_OVERWRITE},
92 {"normal_file-symlink", "normal_file", G_FILE_TYPE_SYMBOLIC_LINK, G_FILE_CREATE_NONE, 0, 0, TEST_ENUMERATE_FILE | TEST_COPY | TEST_OPEN},
93 {"executable_file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, S_IRWXU + S_IRWXG + S_IRWXO, 0, TEST_DELETE_TRASH | TEST_COPY | TEST_OPEN | TEST_OVERWRITE | TEST_REPLACE},
94 {"private_file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_PRIVATE, 0, 0, TEST_COPY | TEST_OPEN | TEST_OVERWRITE | TEST_APPEND},
95 {"normal_file2", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_OVERWRITE | TEST_REPLACE},
96 {"readonly_file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, S_IRUSR + S_IRGRP + S_IROTH, 0, TEST_DELETE_NORMAL | TEST_OPEN},
97 {"UTF_pr\xcc\x8ci\xcc\x81lis\xcc\x8c z",
98 NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_CREATE | TEST_OPEN | TEST_OVERWRITE},
99 {"dir_pr\xcc\x8ci\xcc\x81lis\xcc\x8c z",
100 NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_NONE, 0, 0, TEST_DELETE_NORMAL | TEST_CREATE},
101 {"pattern_file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_COPY | TEST_OPEN | TEST_APPEND},
102 {TEST_NAME_NOT_EXISTS, NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_DELETE_NORMAL | TEST_NOT_EXISTS | TEST_COPY | TEST_OPEN},
103 {TEST_NAME_NOT_EXISTS, NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_DELETE_TRASH | TEST_NOT_EXISTS | TEST_MOVE},
104 {"not_exists2", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_NOT_EXISTS | TEST_CREATE},
105 {"not_exists3", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_NOT_EXISTS | TEST_REPLACE},
106 {"not_exists4", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_NOT_EXISTS | TEST_APPEND},
107 {"dir_no-execute/file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_DELETE_NORMAL | TEST_DELETE_FAILURE | TEST_NOT_EXISTS | TEST_OPEN},
108 {"lost_symlink", "nowhere", G_FILE_TYPE_SYMBOLIC_LINK, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_DELETE_NORMAL | TEST_OPEN | TEST_INVALID_SYMLINK},
109 {"dir_hidden", NULL, G_FILE_TYPE_DIRECTORY, G_FILE_CREATE_NONE, 0, 0, 0},
110 {"dir_hidden/.hidden", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, 0},
111 {"dir_hidden/.a-hidden-file", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_HIDDEN},
112 {"dir_hidden/file-in-.hidden1", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_HIDDEN | TEST_DOT_HIDDEN},
113 {"dir_hidden/file-in-.hidden2", NULL, G_FILE_TYPE_REGULAR, G_FILE_CREATE_NONE, 0, 0, TEST_HIDDEN | TEST_DOT_HIDDEN},
114 };
115
116 static gboolean test_suite;
117 static gboolean write_test;
118 static gboolean verbose;
119 static gboolean posix_compat;
120
121 #ifdef G_OS_UNIX
122 /*
123 * check_cap_dac_override:
124 * @tmpdir: A temporary directory in which we can create and delete files
125 *
126 * Check whether the current process can bypass DAC permissions.
127 *
128 * Traditionally, "privileged" processes (those with effective uid 0)
129 * could do this (and bypass many other checks), and "unprivileged"
130 * processes could not.
131 *
132 * In Linux, the special powers of euid 0 are divided into many
133 * capabilities: see `capabilities(7)`. The one we are interested in
134 * here is `CAP_DAC_OVERRIDE`.
135 *
136 * We do this generically instead of actually looking at the capability
137 * bits, so that the right thing will happen on non-Linux Unix
138 * implementations, in particular if they have something equivalent to
139 * but not identical to Linux permissions.
140 *
141 * Returns: %TRUE if we have Linux `CAP_DAC_OVERRIDE` or equivalent
142 * privileges
143 */
144 static gboolean
145 check_cap_dac_override (const char *tmpdir)
146 {
147 gchar *dac_denies_write;
148 gchar *inside;
149 gboolean have_cap;
150
151 dac_denies_write = g_build_filename (tmpdir, "dac-denies-write", NULL);
152 inside = g_build_filename (dac_denies_write, "inside", NULL);
153
154 g_assert_no_errno (mkdir (dac_denies_write, S_IRWXU));
155 g_assert_no_errno (chmod (dac_denies_write, 0));
156
157 if (mkdir (inside, S_IRWXU) == 0)
158 {
159 g_test_message ("Looks like we have CAP_DAC_OVERRIDE or equivalent");
160 g_assert_no_errno (rmdir (inside));
161 have_cap = TRUE;
162 }
163 else
164 {
165 int saved_errno = errno;
166
167 g_test_message ("We do not have CAP_DAC_OVERRIDE or equivalent");
168 g_assert_cmpint (saved_errno, ==, EACCES);
169 have_cap = FALSE;
170 }
171
172 g_assert_no_errno (chmod (dac_denies_write, S_IRWXU));
173 g_assert_no_errno (rmdir (dac_denies_write));
174 g_free (dac_denies_write);
175 g_free (inside);
176 return have_cap;
177 }
178 #endif
179
180 static GFile *
181 create_empty_file (GFile * parent, const char *filename,
182 GFileCreateFlags create_flags)
183 {
184 GFile *child;
185 GError *error;
186 GFileOutputStream *outs;
187
188 child = g_file_get_child (parent, filename);
189 g_assert_nonnull (child);
190
191 error = NULL;
192 outs = g_file_replace (child, NULL, FALSE, create_flags, NULL, &error);
193 g_assert_no_error (error);
194 g_assert_nonnull (outs);
195 error = NULL;
196 g_output_stream_close (G_OUTPUT_STREAM (outs), NULL, &error);
197 g_object_unref (outs);
198 return child;
199 }
200
201 static GFile *
202 create_empty_dir (GFile * parent, const char *filename)
203 {
204 GFile *child;
205 gboolean res;
206 GError *error;
207
208 child = g_file_get_child (parent, filename);
209 g_assert_nonnull (child);
210 error = NULL;
211 res = g_file_make_directory (child, NULL, &error);
212 g_assert_true (res);
213 g_assert_no_error (error);
214 return child;
215 }
216
217 static GFile *
218 create_symlink (GFile * parent, const char *filename, const char *points_to)
219 {
220 GFile *child;
221 gboolean res;
222 GError *error;
223
224 child = g_file_get_child (parent, filename);
225 g_assert_nonnull (child);
226 error = NULL;
227 res = g_file_make_symbolic_link (child, points_to, NULL, &error);
228 g_assert_true (res);
229 g_assert_no_error (error);
230 return child;
231 }
232
233 static void
234 test_create_structure (gconstpointer test_data)
235 {
236 GFile *root;
237 GFile *child;
238 gboolean res;
239 GError *error = NULL;
240 GFileOutputStream *outs;
241 GDataOutputStream *outds;
242 guint i;
243 struct StructureItem item;
244
245 g_assert_nonnull (test_data);
246 g_test_message ("\n Going to create testing structure in '%s'...",
247 (char *) test_data);
248
249 root = g_file_new_for_commandline_arg ((char *) test_data);
250 g_assert_nonnull (root);
251
252 /* create root directory */
253 g_file_make_directory (root, NULL, &error);
254 g_assert_no_error (error);
255
256 /* create any other items */
257 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
258 {
259 item = sample_struct[i];
260 if ((item.handle_special)
261 || ((!posix_compat)
262 && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK)))
263 continue;
264
265 child = NULL;
266 switch (item.file_type)
267 {
268 case G_FILE_TYPE_REGULAR:
269 g_test_message (" Creating file '%s'...", item.filename);
270 child = create_empty_file (root, item.filename, item.create_flags);
271 break;
272 case G_FILE_TYPE_DIRECTORY:
273 g_test_message (" Creating directory '%s'...", item.filename);
274 child = create_empty_dir (root, item.filename);
275 break;
276 case G_FILE_TYPE_SYMBOLIC_LINK:
277 g_test_message (" Creating symlink '%s' --> '%s'...", item.filename,
278 item.link_to);
279 child = create_symlink (root, item.filename, item.link_to);
280 break;
281 case G_FILE_TYPE_UNKNOWN:
282 case G_FILE_TYPE_SPECIAL:
283 case G_FILE_TYPE_SHORTCUT:
284 case G_FILE_TYPE_MOUNTABLE:
285 default:
286 break;
287 }
288 g_assert_nonnull (child);
289
290 if ((item.mode > 0) && (posix_compat))
291 {
292 res =
293 g_file_set_attribute_uint32 (child, G_FILE_ATTRIBUTE_UNIX_MODE,
294 item.mode,
295 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
296 NULL, &error);
297 g_assert_true (res);
298 g_assert_no_error (error);
299 }
300
301 if ((item.extra_flags & TEST_DOT_HIDDEN) == TEST_DOT_HIDDEN)
302 {
303 gchar *dir, *path, *basename;
304 FILE *f;
305
306 dir = g_path_get_dirname (item.filename);
307 basename = g_path_get_basename (item.filename);
308 path = g_build_filename (test_data, dir, ".hidden", NULL);
309
310 f = fopen (path, "a");
311 fprintf (f, "%s\n", basename);
312 fclose (f);
313
314 g_free (dir);
315 g_free (path);
316 g_free (basename);
317 }
318
319 g_object_unref (child);
320 }
321
322 /* create a pattern file */
323 g_test_message (" Creating pattern file...");
324 child = g_file_get_child (root, "pattern_file");
325 g_assert_nonnull (child);
326
327 outs =
328 g_file_replace (child, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error);
329 g_assert_no_error (error);
330
331 g_assert_nonnull (outs);
332 outds = g_data_output_stream_new (G_OUTPUT_STREAM (outs));
333 g_assert_nonnull (outds);
334 for (i = 0; i < PATTERN_FILE_SIZE; i++)
335 {
336 g_data_output_stream_put_byte (outds, i % 256, NULL, &error);
337 g_assert_no_error (error);
338 }
339
340 g_output_stream_close (G_OUTPUT_STREAM (outs), NULL, &error);
341 g_assert_no_error (error);
342 g_object_unref (outds);
343 g_object_unref (outs);
344 g_object_unref (child);
345 g_test_message (" done.");
346
347 g_object_unref (root);
348 }
349
350 static GFile *
351 file_exists (GFile * parent, const char *filename, gboolean * result)
352 {
353 GFile *child;
354 gboolean res;
355
356 if (result)
357 *result = FALSE;
358
359 child = g_file_get_child (parent, filename);
360 g_assert_nonnull (child);
361 res = g_file_query_exists (child, NULL);
362 if (result)
363 *result = res;
364
365 return child;
366 }
367
368 static void
369 test_attributes (struct StructureItem item, GFileInfo * info)
370 {
371 GFileType ftype;
372 guint32 mode;
373 const char *name, *display_name, *edit_name, *copy_name, *symlink_target;
374 gboolean utf8_valid;
375 gboolean has_attr;
376 gboolean is_symlink;
377 gboolean is_hidden;
378 gboolean can_read, can_write;
379
380 /* standard::type */
381 has_attr = g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
382 g_assert_true (has_attr);
383 ftype = g_file_info_get_file_type (info);
384 g_assert_cmpint (ftype, !=, G_FILE_TYPE_UNKNOWN);
385 g_assert_cmpint (ftype, ==, item.file_type);
386
387 /* unix::mode */
388 if ((item.mode > 0) && (posix_compat))
389 {
390 mode =
391 g_file_info_get_attribute_uint32 (info,
392 G_FILE_ATTRIBUTE_UNIX_MODE) & 0xFFF;
393 g_assert_cmpint (mode, ==, item.mode);
394 }
395
396 /* access::can-read */
397 if (item.file_type != G_FILE_TYPE_SYMBOLIC_LINK)
398 {
399 can_read =
400 g_file_info_get_attribute_boolean (info,
401 G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
402 g_assert_true (can_read);
403 }
404
405 /* access::can-write */
406 if ((write_test) && ((item.extra_flags & TEST_OVERWRITE) == TEST_OVERWRITE))
407 {
408 can_write =
409 g_file_info_get_attribute_boolean (info,
410 G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
411 g_assert_true (can_write);
412 }
413
414 /* standard::name */
415 name = g_file_info_get_name (info);
416 g_assert_nonnull (name);
417
418 /* standard::display-name */
419 display_name = g_file_info_get_display_name (info);
420 g_assert_nonnull (display_name);
421 utf8_valid = g_utf8_validate (display_name, -1, NULL);
422 g_assert_true (utf8_valid);
423
424 /* standard::edit-name */
425 edit_name = g_file_info_get_edit_name (info);
426 if (edit_name)
427 {
428 utf8_valid = g_utf8_validate (edit_name, -1, NULL);
429 g_assert_true (utf8_valid);
430 }
431
432 /* standard::copy-name */
433 copy_name =
434 g_file_info_get_attribute_string (info,
435 G_FILE_ATTRIBUTE_STANDARD_COPY_NAME);
436 if (copy_name)
437 {
438 utf8_valid = g_utf8_validate (copy_name, -1, NULL);
439 g_assert_true (utf8_valid);
440 }
441
442 /* standard::is-symlink */
443 if (posix_compat)
444 {
445 is_symlink = g_file_info_get_is_symlink (info);
446 g_assert_cmpint (is_symlink, ==,
447 item.file_type == G_FILE_TYPE_SYMBOLIC_LINK);
448 }
449
450 /* standard::symlink-target */
451 if ((item.file_type == G_FILE_TYPE_SYMBOLIC_LINK) && (posix_compat))
452 {
453 symlink_target = g_file_info_get_symlink_target (info);
454 g_assert_cmpstr (symlink_target, ==, item.link_to);
455 }
456
457 /* standard::is-hidden */
458 if ((item.extra_flags & TEST_HIDDEN) == TEST_HIDDEN)
459 {
460 is_hidden =
461 g_file_info_get_attribute_boolean (info,
462 G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN);
463 g_assert_true (is_hidden);
464 }
465
466 /* unix::is-mountpoint */
467 if (posix_compat)
468 {
469 gboolean is_mountpoint =
470 g_file_info_get_attribute_boolean (info,
471 G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT);
472 g_assert_false (is_mountpoint);
473 }
474 }
475
476 static void
477 test_initial_structure (gconstpointer test_data)
478 {
479 GFile *root;
480 GFile *child;
481 gboolean res;
482 GError *error;
483 GFileInputStream *ins;
484 guint i;
485 GFileInfo *info;
486 guint32 size;
487 guchar *buffer;
488 gssize read, total_read;
489 struct StructureItem item;
490
491 g_assert_nonnull (test_data);
492 g_test_message (" Testing sample structure in '%s'...", (char *) test_data);
493
494 root = g_file_new_for_commandline_arg ((char *) test_data);
495 g_assert_nonnull (root);
496 res = g_file_query_exists (root, NULL);
497 g_assert_true (res);
498
499 /* test the structure */
500 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
501 {
502 item = sample_struct[i];
503 if (((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
504 || (item.handle_special))
505 continue;
506
507 g_test_message (" Testing file '%s'...", item.filename);
508
509 child = file_exists (root, item.filename, &res);
510 g_assert_nonnull (child);
511 g_assert_true (res);
512
513 error = NULL;
514 info =
515 g_file_query_info (child, "*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
516 NULL, &error);
517 g_assert_no_error (error);
518 g_assert_nonnull (info);
519
520 test_attributes (item, info);
521
522 g_object_unref (child);
523 g_object_unref (info);
524 }
525
526 /* read and test the pattern file */
527 g_test_message (" Testing pattern file...");
528 child = file_exists (root, "pattern_file", &res);
529 g_assert_nonnull (child);
530 g_assert_true (res);
531
532 error = NULL;
533 info =
534 g_file_query_info (child, "*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL,
535 &error);
536 g_assert_no_error (error);
537 g_assert_nonnull (info);
538 size = g_file_info_get_size (info);
539 g_assert_cmpint (size, ==, PATTERN_FILE_SIZE);
540 g_object_unref (info);
541
542 error = NULL;
543 ins = g_file_read (child, NULL, &error);
544 g_assert_nonnull (ins);
545 g_assert_no_error (error);
546
547 buffer = g_malloc (PATTERN_FILE_SIZE);
548 total_read = 0;
549
550 while (total_read < PATTERN_FILE_SIZE)
551 {
552 error = NULL;
553 read =
554 g_input_stream_read (G_INPUT_STREAM (ins), buffer + total_read,
555 PATTERN_FILE_SIZE, NULL, &error);
556 g_assert_no_error (error);
557 total_read += read;
558 g_test_message (" read %"G_GSSIZE_FORMAT" bytes, total = %"G_GSSIZE_FORMAT" of %d.",
559 read, total_read, PATTERN_FILE_SIZE);
560 }
561 g_assert_cmpint (total_read, ==, PATTERN_FILE_SIZE);
562
563 error = NULL;
564 res = g_input_stream_close (G_INPUT_STREAM (ins), NULL, &error);
565 g_assert_no_error (error);
566 g_assert_true (res);
567
568 for (i = 0; i < PATTERN_FILE_SIZE; i++)
569 g_assert_cmpint (*(buffer + i), ==, i % 256);
570
571 g_object_unref (ins);
572 g_object_unref (child);
573 g_free (buffer);
574 g_object_unref (root);
575 }
576
577 static void
578 traverse_recurse_dirs (GFile * parent, GFile * root)
579 {
580 gboolean res;
581 GError *error;
582 GFileEnumerator *enumerator;
583 GFileInfo *info;
584 GFile *descend;
585 char *relative_path;
586 guint i;
587 gboolean found;
588
589 g_assert_nonnull (root);
590
591 error = NULL;
592 enumerator =
593 g_file_enumerate_children (parent, "*",
594 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL,
595 &error);
596 g_assert_nonnull (enumerator);
597 g_assert_no_error (error);
598
599 g_assert_true (g_file_enumerator_get_container (enumerator) == parent);
600
601 error = NULL;
602 info = g_file_enumerator_next_file (enumerator, NULL, &error);
603 while ((info) && (!error))
604 {
605 descend = g_file_enumerator_get_child (enumerator, info);
606 g_assert_nonnull (descend);
607 relative_path = g_file_get_relative_path (root, descend);
608 g_assert_nonnull (relative_path);
609
610 found = FALSE;
611 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
612 {
613 if (strcmp (sample_struct[i].filename, relative_path) == 0)
614 {
615 /* test the attributes again */
616 test_attributes (sample_struct[i], info);
617
618 found = TRUE;
619 break;
620 }
621 }
622 g_assert_true (found);
623
624 g_test_message (" Found file %s, relative to root: %s",
625 g_file_info_get_display_name (info), relative_path);
626
627 if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
628 traverse_recurse_dirs (descend, root);
629
630 g_object_unref (descend);
631 error = NULL;
632 g_object_unref (info);
633 g_free (relative_path);
634
635 info = g_file_enumerator_next_file (enumerator, NULL, &error);
636 }
637 g_assert_no_error (error);
638
639 error = NULL;
640 res = g_file_enumerator_close (enumerator, NULL, &error);
641 g_assert_true (res);
642 g_assert_no_error (error);
643 g_assert_true (g_file_enumerator_is_closed (enumerator));
644
645 g_object_unref (enumerator);
646 }
647
648 static void
649 test_traverse_structure (gconstpointer test_data)
650 {
651 GFile *root;
652 gboolean res;
653
654 g_assert_nonnull (test_data);
655 g_test_message (" Traversing through the sample structure in '%s'...",
656 (char *) test_data);
657
658 root = g_file_new_for_commandline_arg ((char *) test_data);
659 g_assert_nonnull (root);
660 res = g_file_query_exists (root, NULL);
661 g_assert_true (res);
662
663 traverse_recurse_dirs (root, root);
664
665 g_object_unref (root);
666 }
667
668
669
670
671 static void
672 test_enumerate (gconstpointer test_data)
673 {
674 GFile *root, *child;
675 gboolean res;
676 GError *error;
677 GFileEnumerator *enumerator;
678 GFileInfo *info;
679 guint i;
680 struct StructureItem item;
681
682
683 g_assert_nonnull (test_data);
684 g_test_message (" Test enumerate '%s'...", (char *) test_data);
685
686 root = g_file_new_for_commandline_arg ((char *) test_data);
687 g_assert_nonnull (root);
688 res = g_file_query_exists (root, NULL);
689 g_assert_true (res);
690
691
692 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
693 {
694 item = sample_struct[i];
695 if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
696 continue;
697
698 if (((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS) ||
699 (((item.extra_flags & TEST_NO_ACCESS) == TEST_NO_ACCESS)
700 && posix_compat)
701 || ((item.extra_flags & TEST_ENUMERATE_FILE) ==
702 TEST_ENUMERATE_FILE))
703 {
704 g_test_message (" Testing file '%s'", item.filename);
705 child = g_file_get_child (root, item.filename);
706 g_assert_nonnull (child);
707 error = NULL;
708 enumerator =
709 g_file_enumerate_children (child, "*",
710 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
711 NULL, &error);
712
713 if ((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS)
714 {
715 g_assert_null (enumerator);
716 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
717 }
718 if ((item.extra_flags & TEST_ENUMERATE_FILE) == TEST_ENUMERATE_FILE)
719 {
720 g_assert_null (enumerator);
721 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY);
722 }
723 if ((item.extra_flags & TEST_NO_ACCESS) == TEST_NO_ACCESS)
724 {
725 g_assert_nonnull (enumerator);
726
727 error = NULL;
728 info = g_file_enumerator_next_file (enumerator, NULL, &error);
729 g_assert_null (info);
730 g_assert_no_error (error);
731 /* no items should be found, no error should be logged */
732 }
733
734 if (error)
735 g_error_free (error);
736
737 if (enumerator)
738 {
739 error = NULL;
740 res = g_file_enumerator_close (enumerator, NULL, &error);
741 g_assert_true (res);
742 g_assert_no_error (error);
743
744 g_object_unref (enumerator);
745 }
746 g_object_unref (child);
747 }
748 }
749 g_object_unref (root);
750 }
751
752 static void
753 do_copy_move (GFile * root, struct StructureItem item, const char *target_dir,
754 enum StructureExtraFlags extra_flags)
755 {
756 GFile *dst_dir, *src_file, *dst_file;
757 gboolean res;
758 GError *error;
759 #ifdef G_OS_UNIX
760 gboolean have_cap_dac_override = check_cap_dac_override (g_file_peek_path (root));
761 #endif
762
763 g_test_message (" do_copy_move: '%s' --> '%s'", item.filename, target_dir);
764
765 dst_dir = g_file_get_child (root, target_dir);
766 g_assert_nonnull (dst_dir);
767 src_file = g_file_get_child (root, item.filename);
768 g_assert_nonnull (src_file);
769 dst_file = g_file_get_child (dst_dir, item.filename);
770 g_assert_nonnull (dst_file);
771
772 error = NULL;
773 if ((item.extra_flags & TEST_COPY) == TEST_COPY)
774 res =
775 g_file_copy (src_file, dst_file,
776 G_FILE_COPY_NOFOLLOW_SYMLINKS |
777 ((extra_flags ==
778 TEST_OVERWRITE) ? G_FILE_COPY_OVERWRITE :
779 G_FILE_COPY_NONE), NULL, NULL, NULL, &error);
780 else
781 res =
782 g_file_move (src_file, dst_file, G_FILE_COPY_NOFOLLOW_SYMLINKS, NULL,
783 NULL, NULL, &error);
784
785 if (error)
786 g_test_message (" res = %d, error code %d = %s", res, error->code,
787 error->message);
788
789 /* copying file/directory to itself (".") */
790 if (((item.extra_flags & TEST_NOT_EXISTS) != TEST_NOT_EXISTS) &&
791 (extra_flags == TEST_ALREADY_EXISTS))
792 {
793 g_assert_false (res);
794 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
795 }
796 /* target file is a file, overwrite is not set */
797 else if (((item.extra_flags & TEST_NOT_EXISTS) != TEST_NOT_EXISTS) &&
798 (extra_flags == TEST_TARGET_IS_FILE))
799 {
800 g_assert_false (res);
801 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY);
802 }
803 /* source file is directory */
804 else if ((item.extra_flags & TEST_COPY_ERROR_RECURSE) ==
805 TEST_COPY_ERROR_RECURSE)
806 {
807 g_assert_false (res);
808 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE);
809 }
810 /* source or target path doesn't exist */
811 else if (((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS) ||
812 (extra_flags == TEST_NOT_EXISTS))
813 {
814 g_assert_false (res);
815 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
816 }
817 /* source or target path permission denied */
818 else if (((item.extra_flags & TEST_NO_ACCESS) == TEST_NO_ACCESS) ||
819 (extra_flags == TEST_NO_ACCESS))
820 {
821 /* This works for root, see bug #552912 */
822 #ifdef G_OS_UNIX
823 if (have_cap_dac_override)
824 {
825 g_test_message ("Unable to exercise g_file_copy() or g_file_move() "
826 "failing with EACCES: we probably have "
827 "CAP_DAC_OVERRIDE");
828 g_assert_true (res);
829 g_assert_no_error (error);
830 }
831 else
832 #endif
833 {
834 g_assert_false (res);
835 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED);
836 }
837 }
838 /* no error should be found, all exceptions defined above */
839 else
840 {
841 g_assert_true (res);
842 g_assert_no_error (error);
843 }
844
845 if (error)
846 g_error_free (error);
847
848
849 g_object_unref (dst_dir);
850 g_object_unref (src_file);
851 g_object_unref (dst_file);
852 }
853
854 static void
855 test_copy_move (gconstpointer test_data)
856 {
857 GFile *root;
858 gboolean res;
859 guint i;
860 struct StructureItem item;
861
862 g_assert_nonnull (test_data);
863 root = g_file_new_for_commandline_arg ((char *) test_data);
864 g_assert_nonnull (root);
865 res = g_file_query_exists (root, NULL);
866 g_assert_true (res);
867
868
869 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
870 {
871 item = sample_struct[i];
872
873 if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
874 continue;
875
876 if (((item.extra_flags & TEST_COPY) == TEST_COPY) ||
877 ((item.extra_flags & TEST_MOVE) == TEST_MOVE))
878 {
879 /* test copy/move to a directory, expecting no errors if source files exist */
880 do_copy_move (root, item, TEST_DIR_TARGET, 0);
881
882 /* some files have been already moved so we can't count with them in the tests */
883 if ((item.extra_flags & TEST_COPY) == TEST_COPY)
884 {
885 /* test overwrite for flagged files */
886 if ((item.extra_flags & TEST_OVERWRITE) == TEST_OVERWRITE)
887 {
888 do_copy_move (root, item, TEST_DIR_TARGET, TEST_OVERWRITE);
889 }
890 /* source = target, should return G_IO_ERROR_EXISTS */
891 do_copy_move (root, item, ".", TEST_ALREADY_EXISTS);
892 /* target is file */
893 do_copy_move (root, item, TEST_TARGET_FILE,
894 TEST_TARGET_IS_FILE);
895 /* target path is invalid */
896 do_copy_move (root, item, TEST_NAME_NOT_EXISTS,
897 TEST_NOT_EXISTS);
898
899 /* tests on POSIX-compatible filesystems */
900 if (posix_compat)
901 {
902 /* target directory is not accessible (no execute flag) */
903 do_copy_move (root, item, TEST_DIR_NO_ACCESS,
904 TEST_NO_ACCESS);
905 /* target directory is readonly */
906 do_copy_move (root, item, TEST_DIR_NO_WRITE,
907 TEST_NO_ACCESS);
908 }
909 }
910 }
911 }
912 g_object_unref (root);
913 }
914
915 /* Test that G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT is TRUE for / and for another
916 * known mountpoint. The FALSE case is tested for many directories and files by
917 * test_initial_structure(), via test_attributes().
918 */
919 static void
920 test_unix_is_mountpoint (gconstpointer data)
921 {
922 const gchar *path = data;
923 GFile *file = g_file_new_for_path (path);
924 GFileInfo *info;
925 gboolean is_mountpoint;
926 GError *error = NULL;
927
928 info = g_file_query_info (file, G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT,
929 G_FILE_QUERY_INFO_NONE, NULL, &error);
930 g_assert_no_error (error);
931 g_assert_nonnull (info);
932
933 is_mountpoint =
934 g_file_info_get_attribute_boolean (info,
935 G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT);
936 g_assert_true (is_mountpoint);
937
938 g_clear_object (&info);
939 g_clear_object (&file);
940 }
941
942 static void
943 test_create (gconstpointer test_data)
944 {
945 GFile *root, *child;
946 gboolean res;
947 GError *error;
948 guint i;
949 struct StructureItem item;
950 GFileOutputStream *os;
951
952 g_assert_nonnull (test_data);
953
954 root = g_file_new_for_commandline_arg ((char *) test_data);
955 g_assert_nonnull (root);
956 res = g_file_query_exists (root, NULL);
957 g_assert_true (res);
958
959 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
960 {
961 item = sample_struct[i];
962
963 if (((item.extra_flags & TEST_CREATE) == TEST_CREATE) ||
964 ((item.extra_flags & TEST_REPLACE) == TEST_REPLACE) ||
965 ((item.extra_flags & TEST_APPEND) == TEST_APPEND))
966 {
967 g_test_message (" test_create: '%s'", item.filename);
968
969 child = g_file_get_child (root, item.filename);
970 g_assert_nonnull (child);
971 error = NULL;
972 os = NULL;
973
974 if ((item.extra_flags & TEST_CREATE) == TEST_CREATE)
975 os = g_file_create (child, item.create_flags, NULL, &error);
976 else if ((item.extra_flags & TEST_REPLACE) == TEST_REPLACE)
977 os =
978 g_file_replace (child, NULL, TRUE, item.create_flags, NULL,
979 &error);
980 else if ((item.extra_flags & TEST_APPEND) == TEST_APPEND)
981 os = g_file_append_to (child, item.create_flags, NULL, &error);
982
983
984 if (error)
985 g_test_message (" error code %d = %s", error->code, error->message);
986
987 if (((item.extra_flags & TEST_NOT_EXISTS) == 0) &&
988 ((item.extra_flags & TEST_CREATE) == TEST_CREATE))
989 {
990 g_assert_null (os);
991 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
992 }
993 else if (item.file_type == G_FILE_TYPE_DIRECTORY)
994 {
995 g_assert_null (os);
996 if ((item.extra_flags & TEST_CREATE) == TEST_CREATE)
997 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
998 else
999 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
1000 }
1001 else
1002 {
1003 g_assert_nonnull (os);
1004 g_assert_no_error (error);
1005 }
1006
1007 if (error)
1008 g_error_free (error);
1009
1010 if (os)
1011 {
1012 error = NULL;
1013 res =
1014 g_output_stream_close (G_OUTPUT_STREAM (os), NULL, &error);
1015 if (error)
1016 g_test_message (" g_output_stream_close: error %d = %s",
1017 error->code, error->message);
1018 g_assert_true (res);
1019 g_assert_no_error (error);
1020 g_object_unref (os);
1021 }
1022 g_object_unref (child);
1023 }
1024 }
1025 g_object_unref (root);
1026 }
1027
1028 static void
1029 test_open (gconstpointer test_data)
1030 {
1031 GFile *root, *child;
1032 gboolean res;
1033 GError *error;
1034 guint i;
1035 struct StructureItem item;
1036 GFileInputStream *input_stream;
1037
1038 g_assert_nonnull (test_data);
1039
1040 root = g_file_new_for_commandline_arg ((char *) test_data);
1041 g_assert_nonnull (root);
1042 res = g_file_query_exists (root, NULL);
1043 g_assert_true (res);
1044
1045 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
1046 {
1047 item = sample_struct[i];
1048
1049 if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
1050 continue;
1051
1052 if ((item.extra_flags & TEST_OPEN) == TEST_OPEN)
1053 {
1054 g_test_message (" test_open: '%s'", item.filename);
1055
1056 child = g_file_get_child (root, item.filename);
1057 g_assert_nonnull (child);
1058 error = NULL;
1059 input_stream = g_file_read (child, NULL, &error);
1060
1061 if (((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS) ||
1062 ((item.extra_flags & TEST_INVALID_SYMLINK) ==
1063 TEST_INVALID_SYMLINK))
1064 {
1065 g_assert_null (input_stream);
1066 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
1067 }
1068 else if (item.file_type == G_FILE_TYPE_DIRECTORY)
1069 {
1070 g_assert_null (input_stream);
1071 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
1072 }
1073 else
1074 {
1075 g_assert_nonnull (input_stream);
1076 g_assert_no_error (error);
1077 }
1078
1079 if (error)
1080 g_error_free (error);
1081
1082 if (input_stream)
1083 {
1084 error = NULL;
1085 res =
1086 g_input_stream_close (G_INPUT_STREAM (input_stream), NULL,
1087 &error);
1088 g_assert_true (res);
1089 g_assert_no_error (error);
1090 g_object_unref (input_stream);
1091 }
1092 g_object_unref (child);
1093 }
1094 }
1095 g_object_unref (root);
1096 }
1097
1098 static void
1099 test_delete (gconstpointer test_data)
1100 {
1101 GFile *root;
1102 GFile *child;
1103 gboolean res;
1104 GError *error;
1105 guint i;
1106 struct StructureItem item;
1107 gchar *path;
1108
1109 g_assert_nonnull (test_data);
1110
1111 root = g_file_new_for_commandline_arg ((char *) test_data);
1112 g_assert_nonnull (root);
1113 res = g_file_query_exists (root, NULL);
1114 g_assert_true (res);
1115
1116 for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
1117 {
1118 item = sample_struct[i];
1119
1120 if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
1121 continue;
1122
1123 if (((item.extra_flags & TEST_DELETE_NORMAL) == TEST_DELETE_NORMAL) ||
1124 ((item.extra_flags & TEST_DELETE_TRASH) == TEST_DELETE_TRASH))
1125 {
1126 child = file_exists (root, item.filename, &res);
1127 g_assert_nonnull (child);
1128 /* we don't care about result here */
1129
1130 path = g_file_get_path (child);
1131 g_test_message (" Deleting %s, path = %s", item.filename, path);
1132 g_free (path);
1133
1134 error = NULL;
1135 if ((item.extra_flags & TEST_DELETE_NORMAL) == TEST_DELETE_NORMAL)
1136 res = g_file_delete (child, NULL, &error);
1137 else
1138 res = g_file_trash (child, NULL, &error);
1139
1140 if ((item.extra_flags & TEST_DELETE_NON_EMPTY) ==
1141 TEST_DELETE_NON_EMPTY)
1142 {
1143 g_assert_false (res);
1144 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_EMPTY);
1145 }
1146 if ((item.extra_flags & TEST_DELETE_FAILURE) == TEST_DELETE_FAILURE)
1147 {
1148 g_assert_false (res);
1149 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
1150 }
1151 if ((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS)
1152 {
1153 g_assert_false (res);
1154 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
1155 }
1156
1157 if (error)
1158 {
1159 g_test_message (" result = %d, error = %s", res, error->message);
1160 g_error_free (error);
1161 }
1162
1163 g_object_unref (child);
1164 }
1165 }
1166 g_object_unref (root);
1167 }
1168
1169 static void
1170 test_make_directory_with_parents (gconstpointer test_data)
1171 {
1172 GFile *root, *child, *grandchild, *greatgrandchild;
1173 gboolean res;
1174 GError *error = NULL;
1175 #ifdef G_OS_UNIX
1176 gboolean have_cap_dac_override = check_cap_dac_override (test_data);
1177 #endif
1178
1179 g_assert_nonnull (test_data);
1180
1181 root = g_file_new_for_commandline_arg ((char *) test_data);
1182 g_assert_nonnull (root);
1183 res = g_file_query_exists (root, NULL);
1184 g_assert_true (res);
1185
1186 child = g_file_get_child (root, "a");
1187 grandchild = g_file_get_child (child, "b");
1188 greatgrandchild = g_file_get_child (grandchild, "c");
1189
1190 /* Check that we can successfully make directory hierarchies of
1191 * depth 1, 2, or 3
1192 */
1193 res = g_file_make_directory_with_parents (child, NULL, &error);
1194 g_assert_true (res);
1195 g_assert_no_error (error);
1196 res = g_file_query_exists (child, NULL);
1197 g_assert_true (res);
1198
1199 g_file_delete (child, NULL, NULL);
1200
1201 res = g_file_make_directory_with_parents (grandchild, NULL, &error);
1202 g_assert_true (res);
1203 g_assert_no_error (error);
1204 res = g_file_query_exists (grandchild, NULL);
1205 g_assert_true (res);
1206
1207 g_file_delete (grandchild, NULL, NULL);
1208 g_file_delete (child, NULL, NULL);
1209
1210 res = g_file_make_directory_with_parents (greatgrandchild, NULL, &error);
1211 g_assert_true (res);
1212 g_assert_no_error (error);
1213 res = g_file_query_exists (greatgrandchild, NULL);
1214 g_assert_true (res);
1215
1216 g_file_delete (greatgrandchild, NULL, NULL);
1217 g_file_delete (grandchild, NULL, NULL);
1218 g_file_delete (child, NULL, NULL);
1219
1220 /* Now test failure by trying to create a directory hierarchy
1221 * where a ancestor exists but is read-only
1222 */
1223
1224 /* No obvious way to do this on Windows */
1225 if (!posix_compat)
1226 goto out;
1227
1228 #ifdef G_OS_UNIX
1229 /* Permissions are ignored if we have CAP_DAC_OVERRIDE or equivalent,
1230 * and in particular if we're root */
1231 if (have_cap_dac_override)
1232 {
1233 g_test_skip ("Unable to exercise g_file_make_directory_with_parents "
1234 "failing with EACCES: we probably have "
1235 "CAP_DAC_OVERRIDE");
1236 goto out;
1237 }
1238 #endif
1239
1240 g_file_make_directory (child, NULL, NULL);
1241 g_assert_true (res);
1242
1243 res = g_file_set_attribute_uint32 (child,
1244 G_FILE_ATTRIBUTE_UNIX_MODE,
1245 S_IRUSR + S_IXUSR, /* -r-x------ */
1246 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
1247 NULL, NULL);
1248 g_assert_true (res);
1249
1250 res = g_file_make_directory_with_parents (grandchild, NULL, &error);
1251 g_assert_false (res);
1252 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED);
1253 g_clear_error (&error);
1254
1255 res = g_file_make_directory_with_parents (greatgrandchild, NULL, &error);
1256 g_assert_false (res);
1257 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED);
1258 g_clear_error (&error);
1259
1260 out:
1261 g_object_unref (greatgrandchild);
1262 g_object_unref (grandchild);
1263 g_object_unref (child);
1264 g_object_unref (root);
1265 }
1266
1267
1268 static void
1269 cleanup_dir_recurse (GFile *parent, GFile *root)
1270 {
1271 gboolean res;
1272 GError *error;
1273 GFileEnumerator *enumerator;
1274 GFileInfo *info;
1275 GFile *descend;
1276 char *relative_path;
1277
1278 g_assert_nonnull (root);
1279
1280 enumerator =
1281 g_file_enumerate_children (parent, "*",
1282 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL,
1283 NULL);
1284 if (! enumerator)
1285 return;
1286
1287 error = NULL;
1288 info = g_file_enumerator_next_file (enumerator, NULL, &error);
1289 while ((info) && (!error))
1290 {
1291 descend = g_file_enumerator_get_child (enumerator, info);
1292 g_assert_nonnull (descend);
1293 relative_path = g_file_get_relative_path (root, descend);
1294 g_assert_nonnull (relative_path);
1295 g_free (relative_path);
1296
1297 g_test_message (" deleting '%s'", g_file_info_get_display_name (info));
1298
1299 if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
1300 cleanup_dir_recurse (descend, root);
1301
1302 error = NULL;
1303 res = g_file_delete (descend, NULL, &error);
1304 g_assert_true (res);
1305
1306 g_object_unref (descend);
1307 error = NULL;
1308 g_object_unref (info);
1309
1310 info = g_file_enumerator_next_file (enumerator, NULL, &error);
1311 }
1312 g_assert_no_error (error);
1313
1314 error = NULL;
1315 res = g_file_enumerator_close (enumerator, NULL, &error);
1316 g_assert_true (res);
1317 g_assert_no_error (error);
1318
1319 g_object_unref (enumerator);
1320 }
1321
1322 static void
1323 prep_clean_structure (gconstpointer test_data)
1324 {
1325 GFile *root;
1326
1327 g_assert_nonnull (test_data);
1328 g_test_message (" Cleaning target testing structure in '%s'...",
1329 (char *) test_data);
1330
1331 root = g_file_new_for_commandline_arg ((char *) test_data);
1332 g_assert_nonnull (root);
1333
1334 cleanup_dir_recurse (root, root);
1335
1336 g_file_delete (root, NULL, NULL);
1337
1338 g_object_unref (root);
1339 }
1340
1341 int
1342 main (int argc, char *argv[])
1343 {
1344 static gboolean only_create_struct;
1345 const char *target_path;
1346 GError *error;
1347 GOptionContext *context;
1348
1349 static GOptionEntry cmd_entries[] = {
1350 {"read-write", 'w', 0, G_OPTION_ARG_NONE, &write_test,
1351 "Perform write tests (incl. structure creation)", NULL},
1352 {"create-struct", 'c', 0, G_OPTION_ARG_NONE, &only_create_struct,
1353 "Only create testing structure (no tests)", NULL},
1354 {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Be verbose", NULL},
1355 {"posix", 'x', 0, G_OPTION_ARG_NONE, &posix_compat,
1356 "Test POSIX-specific features (unix permissions, symlinks)", NULL},
1357 G_OPTION_ENTRY_NULL
1358 };
1359
1360 test_suite = FALSE;
1361 verbose = FALSE;
1362 write_test = FALSE;
1363 only_create_struct = FALSE;
1364 target_path = NULL;
1365 posix_compat = FALSE;
1366
1367 /* strip all gtester-specific args */
1368 g_test_init (&argc, &argv, NULL);
1369
1370 /* no extra parameters specified, assume we're executed from glib test suite */
1371 if (argc < 2)
1372 {
1373 test_suite = TRUE;
1374 verbose = TRUE;
1375 write_test = TRUE;
1376 only_create_struct = FALSE;
1377 target_path = DEFAULT_TEST_DIR;
1378 #ifdef G_PLATFORM_WIN32
1379 posix_compat = FALSE;
1380 #else
1381 posix_compat = TRUE;
1382 #endif
1383 }
1384
1385 /* add trailing args */
1386 error = NULL;
1387 context = g_option_context_new ("target_path");
1388 g_option_context_add_main_entries (context, cmd_entries, NULL);
1389 if (!g_option_context_parse (context, &argc, &argv, &error))
1390 {
1391 g_printerr ("option parsing failed: %s\n", error->message);
1392 return g_test_run ();
1393 }
1394
1395 /* remaining arg should is the target path; we don't care of the extra args here */
1396 if (argc >= 2)
1397 target_path = strdup (argv[1]);
1398
1399 if (! target_path)
1400 {
1401 g_printerr ("error: target path was not specified\n");
1402 g_printerr ("%s", g_option_context_get_help (context, TRUE, NULL));
1403 return g_test_run ();
1404 }
1405
1406 g_option_context_free (context);
1407
1408 /* Write test - clean target directory first */
1409 /* this can be also considered as a test - enumerate + delete */
1410 if (write_test || only_create_struct)
1411 g_test_add_data_func ("/live-g-file/prep_clean_structure", target_path,
1412 prep_clean_structure);
1413
1414 /* Write test - create new testing structure */
1415 if (write_test || only_create_struct)
1416 g_test_add_data_func ("/live-g-file/create_structure", target_path,
1417 test_create_structure);
1418
1419 /* Read test - test the sample structure - expect defined attributes to be there */
1420 if (!only_create_struct)
1421 g_test_add_data_func ("/live-g-file/test_initial_structure", target_path,
1422 test_initial_structure);
1423
1424 /* Read test - test traverse the structure - no special file should appear */
1425 if (!only_create_struct)
1426 g_test_add_data_func ("/live-g-file/test_traverse_structure", target_path,
1427 test_traverse_structure);
1428
1429 /* Read test - enumerate */
1430 if (!only_create_struct)
1431 g_test_add_data_func ("/live-g-file/test_enumerate", target_path,
1432 test_enumerate);
1433
1434 /* Read test - open (g_file_read()) */
1435 if (!only_create_struct)
1436 g_test_add_data_func ("/live-g-file/test_open", target_path, test_open);
1437
1438 if (posix_compat)
1439 {
1440 g_test_add_data_func ("/live-g-file/test_unix_is_mountpoint/sysroot",
1441 "/",
1442 test_unix_is_mountpoint);
1443 #ifdef __linux__
1444 g_test_add_data_func ("/live-g-file/test_unix_is_mountpoint/proc",
1445 "/proc",
1446 test_unix_is_mountpoint);
1447 #endif
1448 }
1449
1450 /* Write test - create */
1451 if (write_test && (!only_create_struct))
1452 g_test_add_data_func ("/live-g-file/test_create", target_path,
1453 test_create);
1454
1455 /* Write test - copy, move */
1456 if (write_test && (!only_create_struct))
1457 g_test_add_data_func ("/live-g-file/test_copy_move", target_path,
1458 test_copy_move);
1459
1460 /* Write test - delete, trash */
1461 if (write_test && (!only_create_struct))
1462 g_test_add_data_func ("/live-g-file/test_delete", target_path,
1463 test_delete);
1464
1465 /* Write test - make_directory_with_parents */
1466 if (write_test && (!only_create_struct))
1467 g_test_add_data_func ("/live-g-file/test_make_directory_with_parents", target_path,
1468 test_make_directory_with_parents);
1469
1470 if (write_test || only_create_struct)
1471 g_test_add_data_func ("/live-g-file/final_clean", target_path,
1472 prep_clean_structure);
1473
1474 return g_test_run ();
1475
1476 }