gio/tests/live-g-file.c

   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 }