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  * This work is provided "as is"; redistribution and modification
   6  * in whole or in part, in any medium, physical or electronic is
   7  * permitted without restriction.
   8  *
   9  * This work is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12  *
  13  * In no event shall the authors or contributors be liable for any
  14  * direct, indirect, incidental, special, exemplary, or consequential
  15  * damages (including, but not limited to, procurement of substitute
  16  * goods or services; loss of use, data, or profits; or business
  17  * interruption) however caused and on any theory of liability, whether
  18  * in contract, strict liability, or tort (including negligence or
  19  * otherwise) arising in any way out of the use of this software, even
  20  * if advised of the possibility of such damage.
  21  */
  22
  23 #include <glib/glib.h>
  24 #include <gio/gio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/stat.h>
  28
  29 #define DEFAULT_TEST_DIR                "testdir_live-g-file"
  30
  31 #define PATTERN_FILE_SIZE       0x10000
  32 #define TEST_HANDLE_SPECIAL     TRUE
  33
  34 enum StructureExtraFlags
  35 {
  36   TEST_DELETE_NORMAL = 1 << 0,
  37   TEST_DELETE_TRASH = 1 << 1,
  38   TEST_DELETE_NON_EMPTY = 1 << 2,
  39   TEST_DELETE_FAILURE = 1 << 3,
  40   TEST_NOT_EXISTS = 1 << 4,
  41   TEST_ENUMERATE_FILE = 1 << 5,
  42   TEST_NO_ACCESS = 1 << 6,
  43   TEST_COPY = 1 << 7,
  44   TEST_MOVE = 1 << 8,
  45   TEST_COPY_ERROR_RECURSE = 1 << 9,
  46   TEST_ALREADY_EXISTS = 1 << 10,
  47   TEST_TARGET_IS_FILE = 1 << 11,
  48   TEST_CREATE = 1 << 12,
  49   TEST_REPLACE = 1 << 13,
  50   TEST_APPEND = 1 << 14,
  51   TEST_OPEN = 1 << 15,
  52   TEST_OVERWRITE = 1 << 16,
  53   TEST_INVALID_SYMLINK = 1 << 17,
  54 };
  55
  56 struct StructureItem
  57 {
  58   const char *filename;
  59   const char *link_to;
  60   GFileType file_type;
  61   GFileCreateFlags create_flags;
  62   guint32 mode;
  63   gboolean handle_special;
  64   enum StructureExtraFlags extra_flags;
  65 };
  66
  67 #define TEST_DIR_NO_ACCESS              "dir_no-access"
  68 #define TEST_DIR_NO_WRITE               "dir_no-write"
  69 #define TEST_DIR_TARGET                 "dir-target"
  70 #define TEST_NAME_NOT_EXISTS    "not_exists"
  71 #define TEST_TARGET_FILE                "target-file"
  72
  73
  74 static const struct StructureItem sample_struct[] = {
  75 /*       filename                               link    file_type                               create_flags            mode | handle_special | extra_flags              */
  76     {"dir1",                            NULL,   G_FILE_TYPE_DIRECTORY,  G_FILE_CREATE_NONE, 0, 0, TEST_DELETE_NORMAL | TEST_DELETE_NON_EMPTY | TEST_REPLACE | TEST_OPEN},
  77     {"dir1/subdir",                     NULL,   G_FILE_TYPE_DIRECTORY,  G_FILE_CREATE_NONE, 0, 0, TEST_COPY     | TEST_COPY_ERROR_RECURSE | TEST_APPEND},
  78     {"dir2",                            NULL,   G_FILE_TYPE_DIRECTORY,  G_FILE_CREATE_NONE, 0, 0, TEST_DELETE_NORMAL | TEST_MOVE | TEST_CREATE},
  79     {TEST_DIR_TARGET,           NULL,   G_FILE_TYPE_DIRECTORY,  G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_COPY_ERROR_RECURSE},
  80     {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},
  81     {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},
  82     {TEST_TARGET_FILE,          NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_OPEN},
  83         {"normal_file",                 NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, 0, TEST_ENUMERATE_FILE | TEST_CREATE | TEST_OVERWRITE},
  84         {"normal_file-symlink", "normal_file",  G_FILE_TYPE_SYMBOLIC_LINK, G_FILE_CREATE_NONE, 0, 0, TEST_ENUMERATE_FILE | TEST_COPY | TEST_OPEN},
  85     {"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},
  86     {"private_file",            NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_PRIVATE, 0, 0, TEST_COPY | TEST_OPEN | TEST_OVERWRITE | TEST_APPEND},
  87     {"normal_file2",            NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_OVERWRITE | TEST_REPLACE},
  88     {"readonly_file",           NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, S_IRUSR + S_IRGRP + S_IROTH, 0, TEST_DELETE_NORMAL | TEST_OPEN},
  89     {"UTF_pr\xcc\x8ci\xcc\x81lis\xcc\x8c z",
  90                                                 NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_CREATE | TEST_OPEN | TEST_OVERWRITE},
  91     {"dir_pr\xcc\x8ci\xcc\x81lis\xcc\x8c z",
  92                                                 NULL,   G_FILE_TYPE_DIRECTORY,  G_FILE_CREATE_NONE, 0, 0, TEST_DELETE_NORMAL | TEST_CREATE},
  93     {"pattern_file",            NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_COPY | TEST_OPEN | TEST_APPEND},
  94     {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},
  95     {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},
  96     {"not_exists2",                     NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_NOT_EXISTS | TEST_CREATE},
  97     {"not_exists3",                     NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_NOT_EXISTS | TEST_REPLACE},
  98     {"not_exists4",                     NULL,   G_FILE_TYPE_REGULAR,    G_FILE_CREATE_NONE, 0, TEST_HANDLE_SPECIAL, TEST_NOT_EXISTS | TEST_APPEND},
  99     {"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},
 100         {"lost_symlink",                "nowhere",      G_FILE_TYPE_SYMBOLIC_LINK, G_FILE_CREATE_NONE, 0, 0, TEST_COPY | TEST_DELETE_NORMAL | TEST_OPEN | TEST_INVALID_SYMLINK},
 101   };
 102
 103 static gboolean write_test;
 104 static gboolean verbose;
 105 static gboolean posix_compat;
 106
 107 #ifdef G_HAVE_ISO_VARARGS
 108 #define log(...) if (verbose)  g_print (__VA_ARGS__)
 109 #elif defined(G_HAVE_GNUC_VARARGS)
 110 #define log(msg...) if (verbose)  g_print (msg)
 111 #else  /* no varargs macros */
 112 static void log (const g_char *format, ...)
 113 {
 114   va_list args;
 115   va_start (args, format);
 116   if (verbose) g_print (format, args);
 117   va_end (args);
 118 }
 119 #endif
 120
 121 static GFile *
 122 create_empty_file (GFile * parent, const char *filename,
 123                    GFileCreateFlags create_flags)
 124 {
 125   GFile *child;
 126   gboolean res;
 127   GError *error;
 128   GFileOutputStream *outs;
 129
 130   child = g_file_get_child (parent, filename);
 131   g_assert (child != NULL);
 132
 133   error = NULL;
 134   outs = g_file_replace (child, NULL, FALSE, create_flags, NULL, &error);
 135   g_assert_no_error (error);
 136   g_assert (outs != NULL);
 137   error = NULL;
 138   res = g_output_stream_close (G_OUTPUT_STREAM (outs), NULL, &error);
 139   g_object_unref (outs);
 140   return child;
 141 }
 142
 143 static GFile *
 144 create_empty_dir (GFile * parent, const char *filename)
 145 {
 146   GFile *child;
 147   gboolean res;
 148   GError *error;
 149
 150   child = g_file_get_child (parent, filename);
 151   g_assert (child != NULL);
 152   error = NULL;
 153   res = g_file_make_directory (child, NULL, &error);
 154   g_assert_cmpint (res, ==, TRUE);
 155   g_assert_no_error (error);
 156   return child;
 157 }
 158
 159 static GFile *
 160 create_symlink (GFile * parent, const char *filename, const char *points_to)
 161 {
 162   GFile *child;
 163   gboolean res;
 164   GError *error;
 165
 166   child = g_file_get_child (parent, filename);
 167   g_assert (child != NULL);
 168   error = NULL;
 169   res = g_file_make_symbolic_link (child, points_to, NULL, &error);
 170   g_assert_cmpint (res, ==, TRUE);
 171   g_assert_no_error (error);
 172   return child;
 173 }
 174
 175 static void
 176 test_create_structure (gconstpointer test_data)
 177 {
 178   GFile *root;
 179   GFile *child;
 180   gboolean res;
 181   GError *error;
 182   GFileOutputStream *outs;
 183   GDataOutputStream *outds;
 184   int i;
 185   struct StructureItem item;
 186
 187   g_assert (test_data != NULL);
 188   log ("\n  Going to create testing structure in '%s'...\n",
 189        (char *) test_data);
 190
 191   root = g_file_new_for_commandline_arg ((char *) test_data);
 192   g_assert (root != NULL);
 193
 194   /*  create root directory  */
 195   res = g_file_make_directory (root, NULL, NULL);
 196   /*  don't care about errors here  */
 197
 198   /*  create any other items  */
 199   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 200     {
 201       item = sample_struct[i];
 202       if ((item.handle_special)
 203           || ((!posix_compat)
 204               && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK)))
 205         continue;
 206
 207       child = NULL;
 208       switch (item.file_type)
 209         {
 210         case G_FILE_TYPE_REGULAR:
 211           log ("    Creating file '%s'...\n", item.filename);
 212           child = create_empty_file (root, item.filename, item.create_flags);
 213           break;
 214         case G_FILE_TYPE_DIRECTORY:
 215           log ("    Creating directory '%s'...\n", item.filename);
 216           child = create_empty_dir (root, item.filename);
 217           break;
 218         case G_FILE_TYPE_SYMBOLIC_LINK:
 219           log ("    Creating symlink '%s' --> '%s'...\n", item.filename,
 220                item.link_to);
 221           child = create_symlink (root, item.filename, item.link_to);
 222           break;
 223         default:
 224           break;
 225         }
 226       g_assert (child != NULL);
 227
 228       if ((item.mode > 0) && (posix_compat))
 229         {
 230           error = NULL;
 231           res =
 232             g_file_set_attribute_uint32 (child, G_FILE_ATTRIBUTE_UNIX_MODE,
 233                                          item.mode,
 234                                          G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 235                                          NULL, &error);
 236           g_assert_cmpint (res, ==, TRUE);
 237           g_assert_no_error (error);
 238         }
 239
 240       g_object_unref (child);
 241     }
 242
 243   /*  create a pattern file  */
 244   log ("    Creating pattern file...");
 245   child = g_file_get_child (root, "pattern_file");
 246   g_assert (child != NULL);
 247
 248   error = NULL;
 249   outs =
 250     g_file_replace (child, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error);
 251   g_assert_no_error (error);
 252
 253   g_assert (outs != NULL);
 254   outds = g_data_output_stream_new (G_OUTPUT_STREAM (outs));
 255   g_assert (outds != NULL);
 256   for (i = 0; i < PATTERN_FILE_SIZE; i++)
 257     {
 258       error = NULL;
 259       res = g_data_output_stream_put_byte (outds, i % 256, NULL, &error);
 260       g_assert_no_error (error);
 261     }
 262   error = NULL;
 263   res = g_output_stream_close (G_OUTPUT_STREAM (outs), NULL, &error);
 264   g_assert_no_error (error);
 265   g_object_unref (outds);
 266   g_object_unref (outs);
 267   g_object_unref (child);
 268   log (" done.\n");
 269
 270   g_object_unref (root);
 271 }
 272
 273 static GFile *
 274 file_exists (GFile * parent, const char *filename, gboolean * result)
 275 {
 276   GFile *child;
 277   gboolean res;
 278
 279   if (result)
 280     *result = FALSE;
 281
 282   child = g_file_get_child (parent, filename);
 283   g_assert (child != NULL);
 284   res = g_file_query_exists (child, NULL);
 285   if (result)
 286     *result = res;
 287
 288   return child;
 289 }
 290
 291 static void
 292 test_attributes (struct StructureItem item, GFileInfo * info)
 293 {
 294   GFileType ftype;
 295   guint32 mode;
 296   const char *name, *display_name, *edit_name, *copy_name, *symlink_target;
 297   gboolean utf8_valid;
 298   gboolean has_attr;
 299   gboolean is_symlink;
 300   gboolean can_read, can_write;
 301
 302   /*  standard::type  */
 303   has_attr = g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
 304   g_assert_cmpint (has_attr, ==, TRUE);
 305   ftype = g_file_info_get_file_type (info);
 306   g_assert_cmpint (ftype, !=, G_FILE_TYPE_UNKNOWN);
 307   g_assert_cmpint (ftype, ==, item.file_type);
 308
 309   /*  unix::mode  */
 310   if ((item.mode > 0) && (posix_compat))
 311     {
 312       mode =
 313         g_file_info_get_attribute_uint32 (info,
 314                                           G_FILE_ATTRIBUTE_UNIX_MODE) & 0xFFF;
 315       g_assert_cmpint (mode, ==, item.mode);
 316     }
 317
 318   /*  access::can-read  */
 319   if (item.file_type != G_FILE_TYPE_SYMBOLIC_LINK)
 320     {
 321       can_read =
 322         g_file_info_get_attribute_boolean (info,
 323                                            G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
 324       g_assert_cmpint (can_read, ==, TRUE);
 325     }
 326
 327   /*  access::can-write  */
 328   if ((write_test) && ((item.extra_flags & TEST_OVERWRITE) == TEST_OVERWRITE))
 329     {
 330       can_write =
 331         g_file_info_get_attribute_boolean (info,
 332                                            G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
 333       g_assert_cmpint (can_write, ==, TRUE);
 334     }
 335
 336   /*  standard::name  */
 337   name = g_file_info_get_name (info);
 338   g_assert (name != NULL);
 339
 340   /*  standard::display-name  */
 341   display_name = g_file_info_get_display_name (info);
 342   g_assert (display_name != NULL);
 343   utf8_valid = g_utf8_validate (display_name, -1, NULL);
 344   g_assert_cmpint (utf8_valid, ==, TRUE);
 345
 346   /*  standard::edit-name  */
 347   edit_name = g_file_info_get_edit_name (info);
 348   if (edit_name)
 349     {
 350       utf8_valid = g_utf8_validate (edit_name, -1, NULL);
 351       g_assert_cmpint (utf8_valid, ==, TRUE);
 352     }
 353
 354   /*  standard::copy-name  */
 355   copy_name =
 356     g_file_info_get_attribute_string (info,
 357                                       G_FILE_ATTRIBUTE_STANDARD_COPY_NAME);
 358   if (copy_name)
 359     {
 360       utf8_valid = g_utf8_validate (copy_name, -1, NULL);
 361       g_assert_cmpint (utf8_valid, ==, TRUE);
 362     }
 363
 364   /*  standard::is-symlink  */
 365   if (posix_compat)
 366     {
 367       is_symlink = g_file_info_get_is_symlink (info);
 368       g_assert_cmpint (is_symlink, ==,
 369                        item.file_type == G_FILE_TYPE_SYMBOLIC_LINK);
 370     }
 371
 372   /*  standard::symlink-target  */
 373   if ((item.file_type == G_FILE_TYPE_SYMBOLIC_LINK) && (posix_compat))
 374     {
 375       symlink_target = g_file_info_get_symlink_target (info);
 376       g_assert_cmpstr (symlink_target, ==, item.link_to);
 377     }
 378 }
 379
 380 static void
 381 test_initial_structure (gconstpointer test_data)
 382 {
 383   GFile *root;
 384   GFile *child;
 385   gboolean res;
 386   GError *error;
 387   GFileInputStream *ins;
 388   int i;
 389   GFileInfo *info;
 390   guint32 size;
 391   guchar *buffer;
 392   gssize read, total_read;
 393   struct StructureItem item;
 394
 395
 396   g_assert (test_data != NULL);
 397   log ("\n  Testing sample structure in '%s'...\n", (char *) test_data);
 398
 399   root = g_file_new_for_commandline_arg ((char *) test_data);
 400   g_assert (root != NULL);
 401   res = g_file_query_exists (root, NULL);
 402   g_assert_cmpint (res, ==, TRUE);
 403
 404   /*  test the structure  */
 405   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 406     {
 407       item = sample_struct[i];
 408       if (((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
 409           || (item.handle_special))
 410         continue;
 411
 412       log ("    Testing file '%s'...\n", item.filename);
 413
 414       child = file_exists (root, item.filename, &res);
 415       g_assert (child != NULL);
 416       g_assert_cmpint (res, ==, TRUE);
 417
 418       error = NULL;
 419       info =
 420         g_file_query_info (child, "*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 421                            NULL, &error);
 422       g_assert_no_error (error);
 423       g_assert (info != NULL);
 424
 425       test_attributes (item, info);
 426
 427       g_object_unref (child);
 428     }
 429
 430   /*  read and test the pattern file  */
 431   log ("    Testing pattern file...\n");
 432   child = file_exists (root, "pattern_file", &res);
 433   g_assert (child != NULL);
 434   g_assert_cmpint (res, ==, TRUE);
 435
 436   error = NULL;
 437   info =
 438     g_file_query_info (child, "*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL,
 439                        &error);
 440   g_assert_no_error (error);
 441   g_assert (info != NULL);
 442   size = g_file_info_get_size (info);
 443   g_assert_cmpint (size, ==, PATTERN_FILE_SIZE);
 444
 445   error = NULL;
 446   ins = g_file_read (child, NULL, &error);
 447   g_assert (ins != NULL);
 448   g_assert_no_error (error);
 449
 450   buffer = g_malloc (PATTERN_FILE_SIZE);
 451   total_read = 0;
 452
 453   while (total_read < PATTERN_FILE_SIZE)
 454     {
 455       error = NULL;
 456       read =
 457         g_input_stream_read (G_INPUT_STREAM (ins), buffer + total_read,
 458                              PATTERN_FILE_SIZE, NULL, &error);
 459       g_assert_no_error (error);
 460       total_read += read;
 461       log ("      read %d bytes, total = %d of %d.\n", read, total_read,
 462            PATTERN_FILE_SIZE);
 463     }
 464   g_assert_cmpint (total_read, ==, PATTERN_FILE_SIZE);
 465
 466   error = NULL;
 467   res = g_input_stream_close (G_INPUT_STREAM (ins), NULL, &error);
 468   g_assert_no_error (error);
 469   g_assert_cmpint (res, ==, TRUE);
 470
 471   for (i = 0; i < PATTERN_FILE_SIZE; i++)
 472     g_assert_cmpint (*(buffer + i), ==, i % 256);
 473
 474   g_object_unref (ins);
 475   g_object_unref (child);
 476   g_free (buffer);
 477   g_object_unref (root);
 478 }
 479
 480 static void
 481 traverse_recurse_dirs (GFile * parent, GFile * root)
 482 {
 483   gboolean res;
 484   GError *error;
 485   GFileEnumerator *enumerator;
 486   GFileInfo *info;
 487   GFile *descend;
 488   char *relative_path;
 489   int i;
 490   gboolean found;
 491
 492   g_assert (root != NULL);
 493
 494   error = NULL;
 495   enumerator =
 496     g_file_enumerate_children (parent, "*",
 497                                G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL,
 498                                &error);
 499   g_assert (enumerator != NULL);
 500   g_assert_no_error (error);
 501
 502   error = NULL;
 503   info = g_file_enumerator_next_file (enumerator, NULL, &error);
 504   while ((info) && (!error))
 505     {
 506       descend = g_file_get_child (parent, g_file_info_get_name (info));
 507       g_assert (descend != NULL);
 508       relative_path = g_file_get_relative_path (root, descend);
 509       g_assert (relative_path != NULL);
 510
 511       found = FALSE;
 512       for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 513         {
 514           if (strcmp (sample_struct[i].filename, relative_path) == 0)
 515             {
 516               /*  test the attributes again  */
 517               test_attributes (sample_struct[i], info);
 518
 519               found = TRUE;
 520               break;
 521             }
 522         }
 523       g_assert_cmpint (found, ==, TRUE);
 524
 525       log ("  Found file %s, relative to root: %s\n",
 526            g_file_info_get_display_name (info), relative_path);
 527
 528       if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
 529         traverse_recurse_dirs (descend, root);
 530
 531       g_object_unref (descend);
 532       error = NULL;
 533       info = g_file_enumerator_next_file (enumerator, NULL, &error);
 534     }
 535   g_assert_no_error (error);
 536
 537   error = NULL;
 538   res = g_file_enumerator_close (enumerator, NULL, &error);
 539   g_assert_cmpint (res, ==, TRUE);
 540   g_assert_no_error (error);
 541 }
 542
 543 static void
 544 test_traverse_structure (gconstpointer test_data)
 545 {
 546   GFile *root;
 547   gboolean res;
 548
 549   g_assert (test_data != NULL);
 550   log ("\n  Traversing through the sample structure in '%s'...\n",
 551        (char *) test_data);
 552
 553   root = g_file_new_for_commandline_arg ((char *) test_data);
 554   g_assert (root != NULL);
 555   res = g_file_query_exists (root, NULL);
 556   g_assert_cmpint (res, ==, TRUE);
 557
 558   traverse_recurse_dirs (root, root);
 559
 560   g_object_unref (root);
 561 }
 562
 563
 564
 565
 566 static void
 567 test_enumerate (gconstpointer test_data)
 568 {
 569   GFile *root, *child;
 570   gboolean res;
 571   GError *error;
 572   GFileEnumerator *enumerator;
 573   GFileInfo *info;
 574   int i;
 575   struct StructureItem item;
 576
 577
 578   g_assert (test_data != NULL);
 579   log ("\n  Test enumerate '%s'...\n", (char *) test_data);
 580
 581   root = g_file_new_for_commandline_arg ((char *) test_data);
 582   g_assert (root != NULL);
 583   res = g_file_query_exists (root, NULL);
 584   g_assert_cmpint (res, ==, TRUE);
 585
 586
 587   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 588     {
 589       item = sample_struct[i];
 590       if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
 591         continue;
 592
 593       if (((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS) ||
 594           (((item.extra_flags & TEST_NO_ACCESS) == TEST_NO_ACCESS)
 595            && posix_compat)
 596           || ((item.extra_flags & TEST_ENUMERATE_FILE) ==
 597               TEST_ENUMERATE_FILE))
 598         {
 599           log ("    Testing file '%s'\n", item.filename);
 600           child = g_file_get_child (root, item.filename);
 601           g_assert (child != NULL);
 602           error = NULL;
 603           enumerator =
 604             g_file_enumerate_children (child, "*",
 605                                        G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 606                                        NULL, &error);
 607
 608           if ((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS)
 609             {
 610               g_assert (enumerator == NULL);
 611               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
 612             }
 613           if ((item.extra_flags & TEST_ENUMERATE_FILE) == TEST_ENUMERATE_FILE)
 614             {
 615               g_assert (enumerator == NULL);
 616               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY);
 617             }
 618           if ((item.extra_flags & TEST_NO_ACCESS) == TEST_NO_ACCESS)
 619             {
 620               g_assert (enumerator != NULL);
 621
 622               error = NULL;
 623               info = g_file_enumerator_next_file (enumerator, NULL, &error);
 624               g_assert (info == NULL);
 625               g_assert_no_error (error);
 626               /*  no items should be found, no error should be logged  */
 627             }
 628
 629           if (error)
 630             g_error_free (error);
 631
 632           if (enumerator)
 633             {
 634               error = NULL;
 635               res = g_file_enumerator_close (enumerator, NULL, &error);
 636               g_assert_cmpint (res, ==, TRUE);
 637               g_assert_no_error (error);
 638             }
 639           g_object_unref (child);
 640         }
 641     }
 642   g_object_unref (root);
 643 }
 644
 645 static void
 646 do_copy_move (GFile * root, struct StructureItem item, const char *target_dir,
 647               enum StructureExtraFlags extra_flags)
 648 {
 649   GFile *dst_dir, *src_file, *dst_file;
 650   gboolean res;
 651   GError *error;
 652
 653   log ("    do_copy_move: '%s' --> '%s'\n", item.filename, target_dir);
 654
 655   dst_dir = g_file_get_child (root, target_dir);
 656   g_assert (dst_dir != NULL);
 657   src_file = g_file_get_child (root, item.filename);
 658   g_assert (src_file != NULL);
 659   dst_file = g_file_get_child (dst_dir, item.filename);
 660   g_assert (dst_file != NULL);
 661
 662   error = NULL;
 663   if ((item.extra_flags & TEST_COPY) == TEST_COPY)
 664     res =
 665       g_file_copy (src_file, dst_file,
 666                    G_FILE_COPY_NOFOLLOW_SYMLINKS |
 667                    ((extra_flags ==
 668                      TEST_OVERWRITE) ? G_FILE_COPY_OVERWRITE :
 669                     G_FILE_COPY_NONE), NULL, NULL, NULL, &error);
 670   else
 671     res =
 672       g_file_move (src_file, dst_file, G_FILE_COPY_NOFOLLOW_SYMLINKS, NULL,
 673                    NULL, NULL, &error);
 674
 675   if (error)
 676     log ("       res = %d, error code %d = %s\n", res, error->code,
 677          error->message);
 678
 679   /*  copying file/directory to itself (".")  */
 680   if (((item.extra_flags & TEST_NOT_EXISTS) != TEST_NOT_EXISTS) &&
 681       (extra_flags == TEST_ALREADY_EXISTS))
 682     {
 683       g_assert_cmpint (res, ==, FALSE);
 684       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
 685     }
 686   /*  target file is a file, overwrite is not set  */
 687   else if (((item.extra_flags & TEST_NOT_EXISTS) != TEST_NOT_EXISTS) &&
 688            (extra_flags == TEST_TARGET_IS_FILE))
 689     {
 690       g_assert_cmpint (res, ==, FALSE);
 691       if (item.file_type == G_FILE_TYPE_DIRECTORY)
 692         g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE);
 693       else
 694         g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY);
 695     }
 696   /*  source file is directory  */
 697   else if ((item.extra_flags & TEST_COPY_ERROR_RECURSE) ==
 698            TEST_COPY_ERROR_RECURSE)
 699     {
 700       g_assert_cmpint (res, ==, FALSE);
 701       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_RECURSE);
 702     }
 703   /*  source or target path doesn't exist  */
 704   else if (((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS) ||
 705            (extra_flags == TEST_NOT_EXISTS))
 706     {
 707       g_assert_cmpint (res, ==, FALSE);
 708       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
 709     }
 710   /*  source or target path permission denied  */
 711   else if (((item.extra_flags & TEST_NO_ACCESS) == TEST_NO_ACCESS) ||
 712            (extra_flags == TEST_NO_ACCESS))
 713     {
 714       g_assert_cmpint (res, ==, FALSE);
 715       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED);
 716     }
 717   /*  no error should be found, all exceptions defined above  */
 718   else
 719     {
 720       g_assert_cmpint (res, ==, TRUE);
 721       g_assert_no_error (error);
 722     }
 723
 724   if (error)
 725     g_error_free (error);
 726
 727
 728   g_object_unref (dst_dir);
 729   g_object_unref (src_file);
 730   g_object_unref (dst_file);
 731 }
 732
 733 static void
 734 test_copy_move (gconstpointer test_data)
 735 {
 736   GFile *root;
 737   gboolean res;
 738   int i;
 739   struct StructureItem item;
 740
 741   log ("\n");
 742
 743   g_assert (test_data != NULL);
 744   root = g_file_new_for_commandline_arg ((char *) test_data);
 745   g_assert (root != NULL);
 746   res = g_file_query_exists (root, NULL);
 747   g_assert_cmpint (res, ==, TRUE);
 748
 749
 750   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 751     {
 752       item = sample_struct[i];
 753
 754       if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
 755         continue;
 756
 757       if (((item.extra_flags & TEST_COPY) == TEST_COPY) ||
 758           ((item.extra_flags & TEST_MOVE) == TEST_MOVE))
 759         {
 760           /*  test copy/move to a directory, expecting no errors if source files exist  */
 761           do_copy_move (root, item, TEST_DIR_TARGET, 0);
 762
 763           /*  some files have been already moved so we can't count with them in the tests  */
 764           if ((item.extra_flags & TEST_COPY) == TEST_COPY)
 765             {
 766               /*  test overwrite for flagged files  */
 767               if ((item.extra_flags & TEST_OVERWRITE) == TEST_OVERWRITE)
 768                 {
 769                   do_copy_move (root, item, TEST_DIR_TARGET, TEST_OVERWRITE);
 770                 }
 771               /*  source = target, should return G_IO_ERROR_EXISTS  */
 772               do_copy_move (root, item, ".", TEST_ALREADY_EXISTS);
 773               /*  target is file  */
 774               do_copy_move (root, item, TEST_TARGET_FILE,
 775                             TEST_TARGET_IS_FILE);
 776               /*  target path is invalid  */
 777               do_copy_move (root, item, TEST_NAME_NOT_EXISTS,
 778                             TEST_NOT_EXISTS);
 779
 780               /*  tests on POSIX-compatible filesystems  */
 781               if (posix_compat)
 782                 {
 783                   /*  target directory is not accessible (no execute flag)  */
 784                   do_copy_move (root, item, TEST_DIR_NO_ACCESS,
 785                                 TEST_NO_ACCESS);
 786                   /*  target directory is readonly  */
 787                   do_copy_move (root, item, TEST_DIR_NO_WRITE,
 788                                 TEST_NO_ACCESS);
 789                 }
 790             }
 791         }
 792     }
 793   g_object_unref (root);
 794 }
 795
 796 static void
 797 test_create (gconstpointer test_data)
 798 {
 799   GFile *root, *child;
 800   gboolean res;
 801   GError *error;
 802   int i;
 803   struct StructureItem item;
 804   GFileOutputStream *os;
 805
 806   g_assert (test_data != NULL);
 807   log ("\n");
 808
 809   root = g_file_new_for_commandline_arg ((char *) test_data);
 810   g_assert (root != NULL);
 811   res = g_file_query_exists (root, NULL);
 812   g_assert_cmpint (res, ==, TRUE);
 813
 814   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 815     {
 816       item = sample_struct[i];
 817
 818       if (((item.extra_flags & TEST_CREATE) == TEST_CREATE) ||
 819           ((item.extra_flags & TEST_REPLACE) == TEST_REPLACE) ||
 820           ((item.extra_flags & TEST_APPEND) == TEST_APPEND))
 821         {
 822           log ("  test_create: '%s'\n", item.filename);
 823
 824           child = g_file_get_child (root, item.filename);
 825           g_assert (child != NULL);
 826           error = NULL;
 827           os = NULL;
 828
 829           if ((item.extra_flags & TEST_CREATE) == TEST_CREATE)
 830             os = g_file_create (child, item.create_flags, NULL, &error);
 831           else if ((item.extra_flags & TEST_REPLACE) == TEST_REPLACE)
 832             os =
 833               g_file_replace (child, NULL, TRUE, item.create_flags, NULL,
 834                               &error);
 835           else if ((item.extra_flags & TEST_APPEND) == TEST_APPEND)
 836             os = g_file_append_to (child, item.create_flags, NULL, &error);
 837
 838
 839           if (error)
 840             log ("       error code %d = %s\n", error->code, error->message);
 841
 842           if (((item.extra_flags & TEST_NOT_EXISTS) == 0) &&
 843               ((item.extra_flags & TEST_CREATE) == TEST_CREATE))
 844             {
 845               g_assert (os == NULL);
 846               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
 847             }
 848           else if (item.file_type == G_FILE_TYPE_DIRECTORY)
 849             {
 850               g_assert (os == NULL);
 851               if ((item.extra_flags & TEST_CREATE) == TEST_CREATE)
 852                 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
 853               else
 854                 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
 855             }
 856           else
 857             {
 858               g_assert (os != NULL);
 859               g_assert_no_error (error);
 860             }
 861
 862           if (error)
 863             g_error_free (error);
 864
 865           if (os)
 866             {
 867               error = NULL;
 868               res =
 869                 g_output_stream_close (G_OUTPUT_STREAM (os), NULL, &error);
 870               if (error)
 871                 log ("         g_output_stream_close: error %d = %s\n",
 872                      error->code, error->message);
 873               g_assert_cmpint (res, ==, TRUE);
 874               g_assert_no_error (error);
 875             }
 876           g_object_unref (child);
 877         }
 878     }
 879   g_object_unref (root);
 880 }
 881
 882 static void
 883 test_open (gconstpointer test_data)
 884 {
 885   GFile *root, *child;
 886   gboolean res;
 887   GError *error;
 888   int i;
 889   struct StructureItem item;
 890   GFileInputStream *input_stream;
 891
 892   g_assert (test_data != NULL);
 893   log ("\n");
 894
 895   root = g_file_new_for_commandline_arg ((char *) test_data);
 896   g_assert (root != NULL);
 897   res = g_file_query_exists (root, NULL);
 898   g_assert_cmpint (res, ==, TRUE);
 899
 900   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 901     {
 902       item = sample_struct[i];
 903
 904       if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
 905         continue;
 906
 907       if ((item.extra_flags & TEST_OPEN) == TEST_OPEN)
 908         {
 909           log ("  test_open: '%s'\n", item.filename);
 910
 911           child = g_file_get_child (root, item.filename);
 912           g_assert (child != NULL);
 913           error = NULL;
 914           input_stream = g_file_read (child, NULL, &error);
 915
 916           if (((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS) ||
 917               ((item.extra_flags & TEST_INVALID_SYMLINK) ==
 918                TEST_INVALID_SYMLINK))
 919             {
 920               g_assert (input_stream == NULL);
 921               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
 922             }
 923           else if (item.file_type == G_FILE_TYPE_DIRECTORY)
 924             {
 925               g_assert (input_stream == NULL);
 926               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
 927             }
 928           else
 929             {
 930               g_assert (input_stream != NULL);
 931               g_assert_no_error (error);
 932             }
 933
 934           if (error)
 935             g_error_free (error);
 936
 937           if (input_stream)
 938             {
 939               error = NULL;
 940               res =
 941                 g_input_stream_close (G_INPUT_STREAM (input_stream), NULL,
 942                                       &error);
 943               g_assert_cmpint (res, ==, TRUE);
 944               g_assert_no_error (error);
 945             }
 946           g_object_unref (child);
 947         }
 948     }
 949   g_object_unref (root);
 950 }
 951
 952 static void
 953 test_delete (gconstpointer test_data)
 954 {
 955   GFile *root;
 956   GFile *child;
 957   gboolean res;
 958   GError *error;
 959   int i;
 960   struct StructureItem item;
 961
 962   g_assert (test_data != NULL);
 963   log ("\n");
 964
 965   root = g_file_new_for_commandline_arg ((char *) test_data);
 966   g_assert (root != NULL);
 967   res = g_file_query_exists (root, NULL);
 968   g_assert_cmpint (res, ==, TRUE);
 969
 970   for (i = 0; i < G_N_ELEMENTS (sample_struct); i++)
 971     {
 972       item = sample_struct[i];
 973
 974       if ((!posix_compat) && (item.file_type == G_FILE_TYPE_SYMBOLIC_LINK))
 975         continue;
 976
 977       if (((item.extra_flags & TEST_DELETE_NORMAL) == TEST_DELETE_NORMAL) ||
 978           ((item.extra_flags & TEST_DELETE_TRASH) == TEST_DELETE_TRASH))
 979         {
 980           child = file_exists (root, item.filename, &res);
 981           g_assert (child != NULL);
 982           /*  we don't care about result here  */
 983
 984           log ("  Deleting %s, path = %s\n", item.filename,
 985                g_file_get_path (child));
 986           error = NULL;
 987           if ((item.extra_flags & TEST_DELETE_NORMAL) == TEST_DELETE_NORMAL)
 988             res = g_file_delete (child, NULL, &error);
 989           else
 990             res = g_file_trash (child, NULL, &error);
 991
 992           if ((item.extra_flags & TEST_DELETE_NON_EMPTY) ==
 993               TEST_DELETE_NON_EMPTY)
 994             {
 995               g_assert_cmpint (res, ==, FALSE);
 996               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_EMPTY);
 997             }
 998           if ((item.extra_flags & TEST_DELETE_FAILURE) == TEST_DELETE_FAILURE)
 999             {
1000               g_assert_cmpint (res, ==, FALSE);
1001               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
1002             }
1003           if ((item.extra_flags & TEST_NOT_EXISTS) == TEST_NOT_EXISTS)
1004             {
1005               g_assert_cmpint (res, ==, FALSE);
1006               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND);
1007             }
1008
1009           if (error)
1010             {
1011               log ("      result = %d, error = %s\n", res, error->message);
1012               g_error_free (error);
1013             }
1014
1015           g_object_unref (child);
1016         }
1017     }
1018   g_object_unref (root);
1019 }
1020
1021
1022 static void
1023 cleanup_dir_recurse (GFile *parent, GFile *root)
1024 {
1025   gboolean res;
1026   GError *error;
1027   GFileEnumerator *enumerator;
1028   GFileInfo *info;
1029   GFile *descend;
1030   char *relative_path;
1031
1032   g_assert (root != NULL);
1033
1034   error = NULL;
1035   enumerator =
1036     g_file_enumerate_children (parent, "*",
1037                                G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL,
1038                                &error);
1039   if (! enumerator)
1040           return;
1041
1042   error = NULL;
1043   info = g_file_enumerator_next_file (enumerator, NULL, &error);
1044   while ((info) && (!error))
1045     {
1046       descend = g_file_get_child (parent, g_file_info_get_name (info));
1047       g_assert (descend != NULL);
1048       relative_path = g_file_get_relative_path (root, descend);
1049       g_assert (relative_path != NULL);
1050
1051       log ("    deleting '%s'\n", g_file_info_get_display_name (info));
1052
1053       if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
1054           cleanup_dir_recurse (descend, root);
1055
1056       error = NULL;
1057       res = g_file_delete (descend, NULL, &error);
1058       g_assert_cmpint (res, ==, TRUE);
1059
1060       g_object_unref (descend);
1061       error = NULL;
1062       info = g_file_enumerator_next_file (enumerator, NULL, &error);
1063     }
1064   g_assert_no_error (error);
1065
1066   error = NULL;
1067   res = g_file_enumerator_close (enumerator, NULL, &error);
1068   g_assert_cmpint (res, ==, TRUE);
1069   g_assert_no_error (error);
1070 }
1071
1072 static void
1073 prep_clean_structure (gconstpointer test_data)
1074 {
1075   GFile *root;
1076
1077   g_assert (test_data != NULL);
1078   log ("\n  Cleaning target testing structure in '%s'...\n",
1079        (char *) test_data);
1080
1081   root = g_file_new_for_commandline_arg ((char *) test_data);
1082   g_assert (root != NULL);
1083
1084   cleanup_dir_recurse (root, root);
1085
1086   g_file_delete (root, NULL, NULL);
1087
1088   g_object_unref (root);
1089 }
1090
1091 int
1092 main (int argc, char *argv[])
1093 {
1094   static gboolean only_create_struct;
1095   static char *target_path;
1096   GError *error;
1097   GOptionContext *context;
1098
1099   static GOptionEntry cmd_entries[] = {
1100     {"read-write", 'w', 0, G_OPTION_ARG_NONE, &write_test,
1101      "Perform write tests (incl. structure creation)", NULL},
1102     {"create-struct", 'c', 0, G_OPTION_ARG_NONE, &only_create_struct,
1103      "Only create testing structure (no tests)", NULL},
1104     {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Be verbose", NULL},
1105     {"posix", 'x', 0, G_OPTION_ARG_NONE, &posix_compat,
1106      "Test POSIX-specific features (unix permissions, symlinks)", NULL},
1107     {NULL}
1108   };
1109
1110   verbose = FALSE;
1111   write_test = FALSE;
1112   only_create_struct = FALSE;
1113   target_path = NULL;
1114   posix_compat = FALSE;
1115
1116   /*  strip all gtester-specific args  */
1117   g_type_init ();
1118   g_test_init (&argc, &argv, NULL);
1119
1120   /*  no extra parameters specified, assume we're executed from glib test suite  */
1121   if (argc < 2)
1122     {
1123           verbose = TRUE;
1124           write_test = TRUE;
1125           only_create_struct = FALSE;
1126           target_path = DEFAULT_TEST_DIR;
1127 #ifdef G_PLATFORM_WIN32
1128           posix_compat = FALSE;
1129 #else
1130           posix_compat = TRUE;
1131 #endif
1132     }
1133
1134   /*  add trailing args  */
1135   error = NULL;
1136   context = g_option_context_new ("target_path");
1137   g_option_context_add_main_entries (context, cmd_entries, NULL);
1138   if (!g_option_context_parse (context, &argc, &argv, &error))
1139     {
1140       g_print ("option parsing failed: %s\n", error->message);
1141       return g_test_run ();
1142     }
1143
1144   /*  remaining arg should is the target path; we don't care of the extra args here  */
1145   if (argc >= 2)
1146     target_path = strdup (argv[1]);
1147
1148   if (! target_path)
1149     {
1150       g_print ("error: target path was not specified\n");
1151       g_print ("%s", g_option_context_get_help (context, TRUE, NULL));
1152       return g_test_run ();
1153     }
1154
1155
1156   /*  Write test - clean target directory first  */
1157   /*    this can be also considered as a test - enumerate + delete  */
1158   if (write_test || only_create_struct)
1159     g_test_add_data_func ("/live-g-file/prep_clean_structure", target_path,
1160                   prep_clean_structure);
1161
1162   /*  Write test - create new testing structure  */
1163   if (write_test || only_create_struct)
1164     g_test_add_data_func ("/live-g-file/create_structure", target_path,
1165                           test_create_structure);
1166
1167   /*  Read test - test the sample structure - expect defined attributes to be there  */
1168   if (!only_create_struct)
1169     g_test_add_data_func ("/live-g-file/test_initial_structure", target_path,
1170                           test_initial_structure);
1171
1172   /*  Read test - test traverse the structure - no special file should appear  */
1173   if (!only_create_struct)
1174     g_test_add_data_func ("/live-g-file/test_traverse_structure", target_path,
1175                           test_traverse_structure);
1176
1177   /*  Read test - enumerate  */
1178   if (!only_create_struct)
1179     g_test_add_data_func ("/live-g-file/test_enumerate", target_path,
1180                           test_enumerate);
1181
1182   /*  Read test - open (g_file_read())  */
1183   if (!only_create_struct)
1184     g_test_add_data_func ("/live-g-file/test_open", target_path, test_open);
1185
1186   /*  Write test - create  */
1187   if (write_test && (!only_create_struct))
1188     g_test_add_data_func ("/live-g-file/test_create", target_path,
1189                           test_create);
1190
1191   /*  Write test - copy, move  */
1192   if (write_test && (!only_create_struct))
1193     g_test_add_data_func ("/live-g-file/test_copy_move", target_path,
1194                           test_copy_move);
1195
1196   /*  Write test - delete, trash  */
1197   if (write_test && (!only_create_struct))
1198     g_test_add_data_func ("/live-g-file/test_delete", target_path,
1199                           test_delete);
1200
1201   if (write_test || only_create_struct)
1202     g_test_add_data_func ("/live-g-file/final_clean", target_path,
1203                   prep_clean_structure);
1204
1205   return g_test_run ();
1206
1207 }