gio/tests/file.c

   1 #include <string.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <gio/gio.h>
   5 #include <gio/gfiledescriptorbased.h>
   6 #ifdef G_OS_UNIX
   7 #include <sys/stat.h>
   8 #endif
   9
  10 static void
  11 test_basic_for_file (GFile       *file,
  12                      const gchar *suffix)
  13 {
  14   gchar *s;
  15
  16   s = g_file_get_basename (file);
  17   g_assert_cmpstr (s, ==, "testfile");
  18   g_free (s);
  19
  20   s = g_file_get_uri (file);
  21   g_assert_true (g_str_has_prefix (s, "file://"));
  22   g_assert_true (g_str_has_suffix (s, suffix));
  23   g_free (s);
  24
  25   g_assert_true (g_file_has_uri_scheme (file, "file"));
  26   s = g_file_get_uri_scheme (file);
  27   g_assert_cmpstr (s, ==, "file");
  28   g_free (s);
  29 }
  30
  31 static void
  32 test_basic (void)
  33 {
  34   GFile *file;
  35
  36   file = g_file_new_for_path ("./some/directory/testfile");
  37   test_basic_for_file (file, "/some/directory/testfile");
  38   g_object_unref (file);
  39 }
  40
  41 static void
  42 test_build_filename (void)
  43 {
  44   GFile *file;
  45
  46   file = g_file_new_build_filename (".", "some", "directory", "testfile", NULL);
  47   test_basic_for_file (file, "/some/directory/testfile");
  48   g_object_unref (file);
  49
  50   file = g_file_new_build_filename ("testfile", NULL);
  51   test_basic_for_file (file, "/testfile");
  52   g_object_unref (file);
  53 }
  54
  55 static void
  56 test_parent (void)
  57 {
  58   GFile *file;
  59   GFile *file2;
  60   GFile *parent;
  61   GFile *root;
  62
  63   file = g_file_new_for_path ("./some/directory/testfile");
  64   file2 = g_file_new_for_path ("./some/directory");
  65   root = g_file_new_for_path ("/");
  66
  67   g_assert_true (g_file_has_parent (file, file2));
  68
  69   parent = g_file_get_parent (file);
  70   g_assert_true (g_file_equal (parent, file2));
  71   g_object_unref (parent);
  72
  73   g_assert_null (g_file_get_parent (root));
  74
  75   g_object_unref (file);
  76   g_object_unref (file2);
  77   g_object_unref (root);
  78 }
  79
  80 static void
  81 test_child (void)
  82 {
  83   GFile *file;
  84   GFile *child;
  85   GFile *child2;
  86
  87   file = g_file_new_for_path ("./some/directory");
  88   child = g_file_get_child (file, "child");
  89   g_assert_true (g_file_has_parent (child, file));
  90
  91   child2 = g_file_get_child_for_display_name (file, "child2", NULL);
  92   g_assert_true (g_file_has_parent (child2, file));
  93
  94   g_object_unref (child);
  95   g_object_unref (child2);
  96   g_object_unref (file);
  97 }
  98
  99 static void
 100 test_empty_path (void)
 101 {
 102   GFile *file = NULL;
 103
 104   g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2328");
 105   g_test_summary ("Check that creating a file with an empty path results in errors");
 106
 107   /* Creating the file must always succeed. */
 108   file = g_file_new_for_path ("");
 109   g_assert_nonnull (file);
 110
 111   /* But then querying its path should indicate it’s invalid. */
 112   g_assert_null (g_file_get_path (file));
 113   g_assert_null (g_file_get_basename (file));
 114   g_assert_null (g_file_get_parent (file));
 115
 116   g_object_unref (file);
 117 }
 118
 119 static void
 120 test_type (void)
 121 {
 122   GFile *datapath_f;
 123   GFile *file;
 124   GFileType type;
 125   GError *error = NULL;
 126
 127   datapath_f = g_file_new_for_path (g_test_get_dir (G_TEST_DIST));
 128
 129   file = g_file_get_child (datapath_f, "g-icon.c");
 130   type = g_file_query_file_type (file, 0, NULL);
 131   g_assert_cmpint (type, ==, G_FILE_TYPE_REGULAR);
 132   g_object_unref (file);
 133
 134   file = g_file_get_child (datapath_f, "cert-tests");
 135   type = g_file_query_file_type (file, 0, NULL);
 136   g_assert_cmpint (type, ==, G_FILE_TYPE_DIRECTORY);
 137
 138   g_file_read (file, NULL, &error);
 139   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
 140   g_error_free (error);
 141   g_object_unref (file);
 142
 143   g_object_unref (datapath_f);
 144 }
 145
 146 static void
 147 test_parse_name (void)
 148 {
 149   GFile *file;
 150   gchar *name;
 151
 152   file = g_file_new_for_uri ("file://somewhere");
 153   name = g_file_get_parse_name (file);
 154   g_assert_cmpstr (name, ==, "file://somewhere");
 155   g_object_unref (file);
 156   g_free (name);
 157
 158   file = g_file_parse_name ("~foo");
 159   name = g_file_get_parse_name (file);
 160   g_assert_nonnull (name);
 161   g_object_unref (file);
 162   g_free (name);
 163 }
 164
 165 typedef struct
 166 {
 167   GMainContext *context;
 168   GFile *file;
 169   GFileMonitor *monitor;
 170   GOutputStream *ostream;
 171   GInputStream *istream;
 172   gint buffersize;
 173   gint monitor_created;
 174   gint monitor_deleted;
 175   gint monitor_changed;
 176   gchar *monitor_path;
 177   gint pos;
 178   const gchar *data;
 179   gchar *buffer;
 180   guint timeout;
 181   gboolean file_deleted;
 182   gboolean timed_out;
 183 } CreateDeleteData;
 184
 185 static void
 186 monitor_changed (GFileMonitor      *monitor,
 187                  GFile             *file,
 188                  GFile             *other_file,
 189                  GFileMonitorEvent  event_type,
 190                  gpointer           user_data)
 191 {
 192   CreateDeleteData *data = user_data;
 193   gchar *path;
 194   const gchar *peeked_path;
 195
 196   path = g_file_get_path (file);
 197   peeked_path = g_file_peek_path (file);
 198   g_assert_cmpstr (data->monitor_path, ==, path);
 199   g_assert_cmpstr (path, ==, peeked_path);
 200   g_free (path);
 201
 202   if (event_type == G_FILE_MONITOR_EVENT_CREATED)
 203     data->monitor_created++;
 204   if (event_type == G_FILE_MONITOR_EVENT_DELETED)
 205     data->monitor_deleted++;
 206   if (event_type == G_FILE_MONITOR_EVENT_CHANGED)
 207     data->monitor_changed++;
 208
 209   g_main_context_wakeup (data->context);
 210 }
 211
 212 static void
 213 iclosed_cb (GObject      *source,
 214             GAsyncResult *res,
 215             gpointer      user_data)
 216 {
 217   CreateDeleteData *data = user_data;
 218   GError *error;
 219   gboolean ret;
 220
 221   error = NULL;
 222   ret = g_input_stream_close_finish (data->istream, res, &error);
 223   g_assert_no_error (error);
 224   g_assert_true (ret);
 225
 226   g_assert_true (g_input_stream_is_closed (data->istream));
 227
 228   ret = g_file_delete (data->file, NULL, &error);
 229   g_assert_true (ret);
 230   g_assert_no_error (error);
 231
 232   data->file_deleted = TRUE;
 233   g_main_context_wakeup (data->context);
 234 }
 235
 236 static void
 237 read_cb (GObject      *source,
 238          GAsyncResult *res,
 239          gpointer      user_data)
 240 {
 241   CreateDeleteData *data = user_data;
 242   GError *error;
 243   gssize size;
 244
 245   error = NULL;
 246   size = g_input_stream_read_finish (data->istream, res, &error);
 247   g_assert_no_error (error);
 248
 249   data->pos += size;
 250   if (data->pos < strlen (data->data))
 251     {
 252       g_input_stream_read_async (data->istream,
 253                                  data->buffer + data->pos,
 254                                  strlen (data->data) - data->pos,
 255                                  0,
 256                                  NULL,
 257                                  read_cb,
 258                                  data);
 259     }
 260   else
 261     {
 262       g_assert_cmpstr (data->buffer, ==, data->data);
 263       g_assert_false (g_input_stream_is_closed (data->istream));
 264       g_input_stream_close_async (data->istream, 0, NULL, iclosed_cb, data);
 265     }
 266 }
 267
 268 static void
 269 ipending_cb (GObject      *source,
 270              GAsyncResult *res,
 271              gpointer      user_data)
 272 {
 273   CreateDeleteData *data = user_data;
 274   GError *error;
 275
 276   error = NULL;
 277   g_input_stream_read_finish (data->istream, res, &error);
 278   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 279   g_error_free (error);
 280 }
 281
 282 static void
 283 skipped_cb (GObject      *source,
 284             GAsyncResult *res,
 285             gpointer      user_data)
 286 {
 287   CreateDeleteData *data = user_data;
 288   GError *error;
 289   gssize size;
 290
 291   error = NULL;
 292   size = g_input_stream_skip_finish (data->istream, res, &error);
 293   g_assert_no_error (error);
 294   g_assert_cmpint (size, ==, data->pos);
 295
 296   g_input_stream_read_async (data->istream,
 297                              data->buffer + data->pos,
 298                              strlen (data->data) - data->pos,
 299                              0,
 300                              NULL,
 301                              read_cb,
 302                              data);
 303   /* check that we get a pending error */
 304   g_input_stream_read_async (data->istream,
 305                              data->buffer + data->pos,
 306                              strlen (data->data) - data->pos,
 307                              0,
 308                              NULL,
 309                              ipending_cb,
 310                              data);
 311 }
 312
 313 static void
 314 opened_cb (GObject      *source,
 315            GAsyncResult *res,
 316            gpointer      user_data)
 317 {
 318   GFileInputStream *base;
 319   CreateDeleteData *data = user_data;
 320   GError *error;
 321
 322   error = NULL;
 323   base = g_file_read_finish (data->file, res, &error);
 324   g_assert_no_error (error);
 325
 326   if (data->buffersize == 0)
 327     data->istream = G_INPUT_STREAM (g_object_ref (base));
 328   else
 329     data->istream = g_buffered_input_stream_new_sized (G_INPUT_STREAM (base), data->buffersize);
 330   g_object_unref (base);
 331
 332   data->buffer = g_new0 (gchar, strlen (data->data) + 1);
 333
 334   /* copy initial segment directly, then skip */
 335   memcpy (data->buffer, data->data, 10);
 336   data->pos = 10;
 337
 338   g_input_stream_skip_async (data->istream,
 339                              10,
 340                              0,
 341                              NULL,
 342                              skipped_cb,
 343                              data);
 344 }
 345
 346 static void
 347 oclosed_cb (GObject      *source,
 348             GAsyncResult *res,
 349             gpointer      user_data)
 350 {
 351   CreateDeleteData *data = user_data;
 352   GError *error;
 353   gboolean ret;
 354
 355   error = NULL;
 356   ret = g_output_stream_close_finish (data->ostream, res, &error);
 357   g_assert_no_error (error);
 358   g_assert_true (ret);
 359   g_assert_true (g_output_stream_is_closed (data->ostream));
 360
 361   g_file_read_async (data->file, 0, NULL, opened_cb, data);
 362 }
 363
 364 static void
 365 written_cb (GObject      *source,
 366             GAsyncResult *res,
 367             gpointer      user_data)
 368 {
 369   CreateDeleteData *data = user_data;
 370   gssize size;
 371   GError *error;
 372
 373   error = NULL;
 374   size = g_output_stream_write_finish (data->ostream, res, &error);
 375   g_assert_no_error (error);
 376
 377   data->pos += size;
 378   if (data->pos < strlen (data->data))
 379     {
 380       g_output_stream_write_async (data->ostream,
 381                                    data->data + data->pos,
 382                                    strlen (data->data) - data->pos,
 383                                    0,
 384                                    NULL,
 385                                    written_cb,
 386                                    data);
 387     }
 388   else
 389     {
 390       g_assert_false (g_output_stream_is_closed (data->ostream));
 391       g_output_stream_close_async (data->ostream, 0, NULL, oclosed_cb, data);
 392     }
 393 }
 394
 395 static void
 396 opending_cb (GObject      *source,
 397              GAsyncResult *res,
 398              gpointer      user_data)
 399 {
 400   CreateDeleteData *data = user_data;
 401   GError *error;
 402
 403   error = NULL;
 404   g_output_stream_write_finish (data->ostream, res, &error);
 405   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 406   g_error_free (error);
 407 }
 408
 409 static void
 410 created_cb (GObject      *source,
 411             GAsyncResult *res,
 412             gpointer      user_data)
 413 {
 414   GFileOutputStream *base;
 415   CreateDeleteData *data = user_data;
 416   GError *error;
 417
 418   error = NULL;
 419   base = g_file_create_finish (G_FILE (source), res, &error);
 420   g_assert_no_error (error);
 421   g_assert_true (g_file_query_exists (data->file, NULL));
 422
 423   if (data->buffersize == 0)
 424     data->ostream = G_OUTPUT_STREAM (g_object_ref (base));
 425   else
 426     data->ostream = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM (base), data->buffersize);
 427   g_object_unref (base);
 428
 429   g_output_stream_write_async (data->ostream,
 430                                data->data,
 431                                strlen (data->data),
 432                                0,
 433                                NULL,
 434                                written_cb,
 435                                data);
 436   /* check that we get a pending error */
 437   g_output_stream_write_async (data->ostream,
 438                                data->data,
 439                                strlen (data->data),
 440                                0,
 441                                NULL,
 442                                opending_cb,
 443                                data);
 444 }
 445
 446 static gboolean
 447 stop_timeout (gpointer user_data)
 448 {
 449   CreateDeleteData *data = user_data;
 450
 451   data->timed_out = TRUE;
 452   g_main_context_wakeup (data->context);
 453
 454   return G_SOURCE_REMOVE;
 455 }
 456
 457 /*
 458  * This test does a fully async create-write-read-delete.
 459  * Callbackistan.
 460  */
 461 static void
 462 test_create_delete (gconstpointer d)
 463 {
 464   GError *error;
 465   CreateDeleteData *data;
 466   GFileIOStream *iostream;
 467
 468   data = g_new0 (CreateDeleteData, 1);
 469
 470   data->buffersize = GPOINTER_TO_INT (d);
 471   data->data = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ0123456789";
 472   data->pos = 0;
 473
 474   data->file = g_file_new_tmp ("g_file_create_delete_XXXXXX",
 475                                &iostream, NULL);
 476   g_assert_nonnull (data->file);
 477   g_object_unref (iostream);
 478
 479   data->monitor_path = g_file_get_path (data->file);
 480   remove (data->monitor_path);
 481
 482   g_assert_false (g_file_query_exists (data->file, NULL));
 483
 484   error = NULL;
 485   data->monitor = g_file_monitor_file (data->file, 0, NULL, &error);
 486   g_assert_no_error (error);
 487
 488   /* This test doesn't work with GPollFileMonitor, because it assumes
 489    * that the monitor will notice a create immediately followed by a
 490    * delete, rather than coalescing them into nothing.
 491    */
 492   /* This test also doesn't work with GKqueueFileMonitor because of
 493    * the same reason. Kqueue is able to return a kevent when a file is
 494    * created or deleted in a directory. However, the kernel doesn't tell
 495    * the program file names, so GKqueueFileMonitor has to calculate the
 496    * difference itself. This is usually too slow for rapid file creation
 497    * and deletion tests.
 498    */
 499   if (strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GPollFileMonitor") == 0 ||
 500       strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GKqueueFileMonitor") == 0)
 501     {
 502       g_test_skip ("skipping test for this GFileMonitor implementation");
 503       goto skip;
 504     }
 505
 506   g_file_monitor_set_rate_limit (data->monitor, 100);
 507
 508   g_signal_connect (data->monitor, "changed", G_CALLBACK (monitor_changed), data);
 509
 510   /* Use the global default main context */
 511   data->context = NULL;
 512   data->timeout = g_timeout_add_seconds (10, stop_timeout, data);
 513
 514   g_file_create_async (data->file, 0, 0, NULL, created_cb, data);
 515
 516   while (!data->timed_out &&
 517          (data->monitor_created == 0 ||
 518           data->monitor_deleted == 0 ||
 519           data->monitor_changed == 0 ||
 520           !data->file_deleted))
 521     g_main_context_iteration (data->context, TRUE);
 522
 523   g_source_remove (data->timeout);
 524
 525   g_assert_false (data->timed_out);
 526   g_assert_true (data->file_deleted);
 527   g_assert_cmpint (data->monitor_created, ==, 1);
 528   g_assert_cmpint (data->monitor_deleted, ==, 1);
 529   g_assert_cmpint (data->monitor_changed, >, 0);
 530
 531   g_assert_false (g_file_monitor_is_cancelled (data->monitor));
 532   g_file_monitor_cancel (data->monitor);
 533   g_assert_true (g_file_monitor_is_cancelled (data->monitor));
 534
 535   g_clear_pointer (&data->context, g_main_context_unref);
 536   g_object_unref (data->ostream);
 537   g_object_unref (data->istream);
 538
 539  skip:
 540   g_object_unref (data->monitor);
 541   g_object_unref (data->file);
 542   g_free (data->monitor_path);
 543   g_free (data->buffer);
 544   g_free (data);
 545 }
 546
 547 static const gchar *original_data =
 548     "/**\n"
 549     " * g_file_replace_contents_async:\n"
 550     "**/\n";
 551
 552 static const gchar *replace_data =
 553     "/**\n"
 554     " * g_file_replace_contents_async:\n"
 555     " * @file: input #GFile.\n"
 556     " * @contents: string of contents to replace the file with.\n"
 557     " * @length: the length of @contents in bytes.\n"
 558     " * @etag: (nullable): a new <link linkend=\"gfile-etag\">entity tag</link> for the @file, or %NULL\n"
 559     " * @make_backup: %TRUE if a backup should be created.\n"
 560     " * @flags: a set of #GFileCreateFlags.\n"
 561     " * @cancellable: optional #GCancellable object, %NULL to ignore.\n"
 562     " * @callback: a #GAsyncReadyCallback to call when the request is satisfied\n"
 563     " * @user_data: the data to pass to callback function\n"
 564     " * \n"
 565     " * Starts an asynchronous replacement of @file with the given \n"
 566     " * @contents of @length bytes. @etag will replace the document's\n"
 567     " * current entity tag.\n"
 568     " * \n"
 569     " * When this operation has completed, @callback will be called with\n"
 570     " * @user_user data, and the operation can be finalized with \n"
 571     " * g_file_replace_contents_finish().\n"
 572     " * \n"
 573     " * If @cancellable is not %NULL, then the operation can be cancelled by\n"
 574     " * triggering the cancellable object from another thread. If the operation\n"
 575     " * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. \n"
 576     " * \n"
 577     " * If @make_backup is %TRUE, this function will attempt to \n"
 578     " * make a backup of @file.\n"
 579     " **/\n";
 580
 581 typedef struct
 582 {
 583   GFile *file;
 584   const gchar *data;
 585   GMainLoop *loop;
 586   gboolean again;
 587 } ReplaceLoadData;
 588
 589 static void replaced_cb (GObject      *source,
 590                          GAsyncResult *res,
 591                          gpointer      user_data);
 592
 593 static void
 594 loaded_cb (GObject      *source,
 595            GAsyncResult *res,
 596            gpointer      user_data)
 597 {
 598   ReplaceLoadData *data = user_data;
 599   gboolean ret;
 600   GError *error;
 601   gchar *contents;
 602   gsize length;
 603
 604   error = NULL;
 605   ret = g_file_load_contents_finish (data->file, res, &contents, &length, NULL, &error);
 606   g_assert_true (ret);
 607   g_assert_no_error (error);
 608   g_assert_cmpint (length, ==, strlen (data->data));
 609   g_assert_cmpstr (contents, ==, data->data);
 610
 611   g_free (contents);
 612
 613   if (data->again)
 614     {
 615       data->again = FALSE;
 616       data->data = "pi pa po";
 617
 618       g_file_replace_contents_async (data->file,
 619                                      data->data,
 620                                      strlen (data->data),
 621                                      NULL,
 622                                      FALSE,
 623                                      0,
 624                                      NULL,
 625                                      replaced_cb,
 626                                      data);
 627     }
 628   else
 629     {
 630        error = NULL;
 631        ret = g_file_delete (data->file, NULL, &error);
 632        g_assert_no_error (error);
 633        g_assert_true (ret);
 634        g_assert_false (g_file_query_exists (data->file, NULL));
 635
 636        g_main_loop_quit (data->loop);
 637     }
 638 }
 639
 640 static void
 641 replaced_cb (GObject      *source,
 642              GAsyncResult *res,
 643              gpointer      user_data)
 644 {
 645   ReplaceLoadData *data = user_data;
 646   GError *error;
 647
 648   error = NULL;
 649   g_file_replace_contents_finish (data->file, res, NULL, &error);
 650   g_assert_no_error (error);
 651
 652   g_file_load_contents_async (data->file, NULL, loaded_cb, data);
 653 }
 654
 655 static void
 656 test_replace_load (void)
 657 {
 658   ReplaceLoadData *data;
 659   const gchar *path;
 660   GFileIOStream *iostream;
 661
 662   data = g_new0 (ReplaceLoadData, 1);
 663   data->again = TRUE;
 664   data->data = replace_data;
 665
 666   data->file = g_file_new_tmp ("g_file_replace_load_XXXXXX",
 667                                &iostream, NULL);
 668   g_assert_nonnull (data->file);
 669   g_object_unref (iostream);
 670
 671   path = g_file_peek_path (data->file);
 672   remove (path);
 673
 674   g_assert_false (g_file_query_exists (data->file, NULL));
 675
 676   data->loop = g_main_loop_new (NULL, FALSE);
 677
 678   g_file_replace_contents_async (data->file,
 679                                  data->data,
 680                                  strlen (data->data),
 681                                  NULL,
 682                                  FALSE,
 683                                  0,
 684                                  NULL,
 685                                  replaced_cb,
 686                                  data);
 687
 688   g_main_loop_run (data->loop);
 689
 690   g_main_loop_unref (data->loop);
 691   g_object_unref (data->file);
 692   g_free (data);
 693 }
 694
 695 static void
 696 test_replace_cancel (void)
 697 {
 698   GFile *tmpdir, *file;
 699   GFileOutputStream *ostream;
 700   GFileEnumerator *fenum;
 701   GFileInfo *info;
 702   GCancellable *cancellable;
 703   gchar *path;
 704   gchar *contents;
 705   gsize nwrote, length;
 706   guint count;
 707   GError *error = NULL;
 708
 709   g_test_bug ("https://bugzilla.gnome.org/629301");
 710
 711   path = g_dir_make_tmp ("g_file_replace_cancel_XXXXXX", &error);
 712   g_assert_no_error (error);
 713   tmpdir = g_file_new_for_path (path);
 714   g_free (path);
 715
 716   file = g_file_get_child (tmpdir, "file");
 717   g_file_replace_contents (file,
 718                            original_data,
 719                            strlen (original_data),
 720                            NULL, FALSE, 0, NULL,
 721                            NULL, &error);
 722   g_assert_no_error (error);
 723
 724   ostream = g_file_replace (file, NULL, TRUE, 0, NULL, &error);
 725   g_assert_no_error (error);
 726
 727   g_output_stream_write_all (G_OUTPUT_STREAM (ostream),
 728                              replace_data, strlen (replace_data),
 729                              &nwrote, NULL, &error);
 730   g_assert_no_error (error);
 731   g_assert_cmpint (nwrote, ==, strlen (replace_data));
 732
 733   /* At this point there should be two files; the original and the
 734    * temporary.
 735    */
 736   fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
 737   g_assert_no_error (error);
 738
 739   info = g_file_enumerator_next_file (fenum, NULL, &error);
 740   g_assert_no_error (error);
 741   g_assert_nonnull (info);
 742   g_object_unref (info);
 743   info = g_file_enumerator_next_file (fenum, NULL, &error);
 744   g_assert_no_error (error);
 745   g_assert_nonnull (info);
 746   g_object_unref (info);
 747
 748   g_file_enumerator_close (fenum, NULL, &error);
 749   g_assert_no_error (error);
 750   g_object_unref (fenum);
 751
 752   /* Also test the g_file_enumerator_iterate() API */
 753   fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
 754   g_assert_no_error (error);
 755   count = 0;
 756
 757   while (TRUE)
 758     {
 759       gboolean ret = g_file_enumerator_iterate (fenum, &info, NULL, NULL, &error);
 760       g_assert_true (ret);
 761       g_assert_no_error (error);
 762       if (!info)
 763         break;
 764       count++;
 765     }
 766   g_assert_cmpint (count, ==, 2);
 767
 768   g_file_enumerator_close (fenum, NULL, &error);
 769   g_assert_no_error (error);
 770   g_object_unref (fenum);
 771
 772   /* Now test just getting child from the g_file_enumerator_iterate() API */
 773   fenum = g_file_enumerate_children (tmpdir, "standard::name", 0, NULL, &error);
 774   g_assert_no_error (error);
 775   count = 0;
 776
 777   while (TRUE)
 778     {
 779       GFile *child;
 780       gboolean ret = g_file_enumerator_iterate (fenum, NULL, &child, NULL, &error);
 781
 782       g_assert_true (ret);
 783       g_assert_no_error (error);
 784
 785       if (!child)
 786         break;
 787
 788       g_assert_true (G_IS_FILE (child));
 789       count++;
 790     }
 791   g_assert_cmpint (count, ==, 2);
 792
 793   g_file_enumerator_close (fenum, NULL, &error);
 794   g_assert_no_error (error);
 795   g_object_unref (fenum);
 796
 797   /* Make sure the temporary gets deleted even if we cancel. */
 798   cancellable = g_cancellable_new ();
 799   g_cancellable_cancel (cancellable);
 800   g_output_stream_close (G_OUTPUT_STREAM (ostream), cancellable, &error);
 801   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
 802   g_clear_error (&error);
 803
 804   g_object_unref (cancellable);
 805   g_object_unref (ostream);
 806
 807   /* Make sure that file contents wasn't actually replaced. */
 808   g_file_load_contents (file,
 809                         NULL,
 810                         &contents,
 811                         &length,
 812                         NULL,
 813                         &error);
 814   g_assert_no_error (error);
 815   g_assert_cmpstr (contents, ==, original_data);
 816   g_free (contents);
 817
 818   g_file_delete (file, NULL, &error);
 819   g_assert_no_error (error);
 820   g_object_unref (file);
 821
 822   /* This will only succeed if the temp file was deleted. */
 823   g_file_delete (tmpdir, NULL, &error);
 824   g_assert_no_error (error);
 825   g_object_unref (tmpdir);
 826 }
 827
 828 static void
 829 test_replace_symlink (void)
 830 {
 831 #ifdef G_OS_UNIX
 832   gchar *tmpdir_path = NULL;
 833   GFile *tmpdir = NULL, *source_file = NULL, *target_file = NULL;
 834   GFileOutputStream *stream = NULL;
 835   const gchar *new_contents = "this is a test message which should be written to source and not target";
 836   gsize n_written;
 837   GFileEnumerator *enumerator = NULL;
 838   GFileInfo *info = NULL;
 839   gchar *contents = NULL;
 840   gsize length = 0;
 841   GError *local_error = NULL;
 842
 843   g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2325");
 844   g_test_summary ("Test that G_FILE_CREATE_REPLACE_DESTINATION doesn’t follow symlinks");
 845
 846   /* Create a fresh, empty working directory. */
 847   tmpdir_path = g_dir_make_tmp ("g_file_replace_symlink_XXXXXX", &local_error);
 848   g_assert_no_error (local_error);
 849   tmpdir = g_file_new_for_path (tmpdir_path);
 850
 851   g_test_message ("Using temporary directory %s", tmpdir_path);
 852   g_free (tmpdir_path);
 853
 854   /* Create symlink `source` which points to `target`. */
 855   source_file = g_file_get_child (tmpdir, "source");
 856   target_file = g_file_get_child (tmpdir, "target");
 857   g_file_make_symbolic_link (source_file, "target", NULL, &local_error);
 858   g_assert_no_error (local_error);
 859
 860   /* Ensure that `target` doesn’t exist */
 861   g_assert_false (g_file_query_exists (target_file, NULL));
 862
 863   /* Replace the `source` symlink with a regular file using
 864    * %G_FILE_CREATE_REPLACE_DESTINATION, which should replace it *without*
 865    * following the symlink */
 866   stream = g_file_replace (source_file, NULL, FALSE  /* no backup */,
 867                            G_FILE_CREATE_REPLACE_DESTINATION, NULL, &local_error);
 868   g_assert_no_error (local_error);
 869
 870   g_output_stream_write_all (G_OUTPUT_STREAM (stream), new_contents, strlen (new_contents),
 871                              &n_written, NULL, &local_error);
 872   g_assert_no_error (local_error);
 873   g_assert_cmpint (n_written, ==, strlen (new_contents));
 874
 875   g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, &local_error);
 876   g_assert_no_error (local_error);
 877
 878   g_clear_object (&stream);
 879
 880   /* At this point, there should still only be one file: `source`. It should
 881    * now be a regular file. `target` should not exist. */
 882   enumerator = g_file_enumerate_children (tmpdir,
 883                                           G_FILE_ATTRIBUTE_STANDARD_NAME ","
 884                                           G_FILE_ATTRIBUTE_STANDARD_TYPE,
 885                                           G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &local_error);
 886   g_assert_no_error (local_error);
 887
 888   info = g_file_enumerator_next_file (enumerator, NULL, &local_error);
 889   g_assert_no_error (local_error);
 890   g_assert_nonnull (info);
 891
 892   g_assert_cmpstr (g_file_info_get_name (info), ==, "source");
 893   g_assert_cmpint (g_file_info_get_file_type (info), ==, G_FILE_TYPE_REGULAR);
 894
 895   g_clear_object (&info);
 896
 897   info = g_file_enumerator_next_file (enumerator, NULL, &local_error);
 898   g_assert_no_error (local_error);
 899   g_assert_null (info);
 900
 901   g_file_enumerator_close (enumerator, NULL, &local_error);
 902   g_assert_no_error (local_error);
 903   g_clear_object (&enumerator);
 904
 905   /* Double-check that `target` doesn’t exist */
 906   g_assert_false (g_file_query_exists (target_file, NULL));
 907
 908   /* Check the content of `source`. */
 909   g_file_load_contents (source_file,
 910                         NULL,
 911                         &contents,
 912                         &length,
 913                         NULL,
 914                         &local_error);
 915   g_assert_no_error (local_error);
 916   g_assert_cmpstr (contents, ==, new_contents);
 917   g_assert_cmpuint (length, ==, strlen (new_contents));
 918   g_free (contents);
 919
 920   /* Tidy up. */
 921   g_file_delete (source_file, NULL, &local_error);
 922   g_assert_no_error (local_error);
 923
 924   g_file_delete (tmpdir, NULL, &local_error);
 925   g_assert_no_error (local_error);
 926
 927   g_clear_object (&target_file);
 928   g_clear_object (&source_file);
 929   g_clear_object (&tmpdir);
 930 #else  /* if !G_OS_UNIX */
 931   g_test_skip ("Symlink replacement tests can only be run on Unix")
 932 #endif
 933 }
 934
 935 static void
 936 test_replace_symlink_using_etag (void)
 937 {
 938 #ifdef G_OS_UNIX
 939   gchar *tmpdir_path = NULL;
 940   GFile *tmpdir = NULL, *source_file = NULL, *target_file = NULL;
 941   GFileOutputStream *stream = NULL;
 942   const gchar *old_contents = "this is a test message which should be written to target and then overwritten";
 943   gchar *old_etag = NULL;
 944   const gchar *new_contents = "this is an updated message";
 945   gsize n_written;
 946   gchar *contents = NULL;
 947   gsize length = 0;
 948   GFileInfo *info = NULL;
 949   GError *local_error = NULL;
 950
 951   g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2417");
 952   g_test_summary ("Test that ETag checks work when replacing a file through a symlink");
 953
 954   /* Create a fresh, empty working directory. */
 955   tmpdir_path = g_dir_make_tmp ("g_file_replace_symlink_using_etag_XXXXXX", &local_error);
 956   g_assert_no_error (local_error);
 957   tmpdir = g_file_new_for_path (tmpdir_path);
 958
 959   g_test_message ("Using temporary directory %s", tmpdir_path);
 960   g_free (tmpdir_path);
 961
 962   /* Create symlink `source` which points to `target`. */
 963   source_file = g_file_get_child (tmpdir, "source");
 964   target_file = g_file_get_child (tmpdir, "target");
 965   g_file_make_symbolic_link (source_file, "target", NULL, &local_error);
 966   g_assert_no_error (local_error);
 967
 968   /* Sleep for at least 1s to ensure the mtimes of `source` and `target` differ,
 969    * as that’s what _g_local_file_info_create_etag() uses to create the ETag,
 970    * and one failure mode we’re testing for is that the ETags of `source` and
 971    * `target` are conflated. */
 972   sleep (1);
 973
 974   /* Create `target` with some arbitrary content. */
 975   stream = g_file_create (target_file, G_FILE_CREATE_NONE, NULL, &local_error);
 976   g_assert_no_error (local_error);
 977   g_output_stream_write_all (G_OUTPUT_STREAM (stream), old_contents, strlen (old_contents),
 978                              &n_written, NULL, &local_error);
 979   g_assert_no_error (local_error);
 980   g_assert_cmpint (n_written, ==, strlen (old_contents));
 981
 982   g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, &local_error);
 983   g_assert_no_error (local_error);
 984
 985   old_etag = g_file_output_stream_get_etag (stream);
 986   g_assert_nonnull (old_etag);
 987   g_assert_cmpstr (old_etag, !=, "");
 988
 989   g_clear_object (&stream);
 990
 991   /* Sleep again to ensure the ETag changes again. */
 992   sleep (1);
 993
 994   /* Write out a new copy of the `target`, checking its ETag first. This should
 995    * replace `target` by following the symlink. */
 996   stream = g_file_replace (source_file, old_etag, FALSE  /* no backup */,
 997                            G_FILE_CREATE_NONE, NULL, &local_error);
 998   g_assert_no_error (local_error);
 999
1000   g_output_stream_write_all (G_OUTPUT_STREAM (stream), new_contents, strlen (new_contents),
1001                              &n_written, NULL, &local_error);
1002   g_assert_no_error (local_error);
1003   g_assert_cmpint (n_written, ==, strlen (new_contents));
1004
1005   g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, &local_error);
1006   g_assert_no_error (local_error);
1007
1008   g_clear_object (&stream);
1009
1010   /* At this point, there should be a regular file, `target`, containing
1011    * @new_contents; and a symlink `source` which points to `target`. */
1012   g_assert_cmpint (g_file_query_file_type (source_file, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL), ==, G_FILE_TYPE_SYMBOLIC_LINK);
1013   g_assert_cmpint (g_file_query_file_type (target_file, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL), ==, G_FILE_TYPE_REGULAR);
1014
1015   /* Check the content of `target`. */
1016   g_file_load_contents (target_file,
1017                         NULL,
1018                         &contents,
1019                         &length,
1020                         NULL,
1021                         &local_error);
1022   g_assert_no_error (local_error);
1023   g_assert_cmpstr (contents, ==, new_contents);
1024   g_assert_cmpuint (length, ==, strlen (new_contents));
1025   g_free (contents);
1026
1027   /* And check its ETag value has changed. */
1028   info = g_file_query_info (target_file, G_FILE_ATTRIBUTE_ETAG_VALUE,
1029                             G_FILE_QUERY_INFO_NONE, NULL, &local_error);
1030   g_assert_no_error (local_error);
1031   g_assert_cmpstr (g_file_info_get_etag (info), !=, old_etag);
1032
1033   g_clear_object (&info);
1034   g_free (old_etag);
1035
1036   /* Tidy up. */
1037   g_file_delete (target_file, NULL, &local_error);
1038   g_assert_no_error (local_error);
1039
1040   g_file_delete (source_file, NULL, &local_error);
1041   g_assert_no_error (local_error);
1042
1043   g_file_delete (tmpdir, NULL, &local_error);
1044   g_assert_no_error (local_error);
1045
1046   g_clear_object (&target_file);
1047   g_clear_object (&source_file);
1048   g_clear_object (&tmpdir);
1049 #else  /* if !G_OS_UNIX */
1050   g_test_skip ("Symlink replacement tests can only be run on Unix")
1051 #endif
1052 }
1053
1054 /* FIXME: These tests have only been checked on Linux. Most of them are probably
1055  * applicable on Windows, too, but that has not been tested yet.
1056  * See https://gitlab.gnome.org/GNOME/glib/-/issues/2325 */
1057 #ifdef __linux__
1058
1059 /* Different kinds of file which create_test_file() can create. */
1060 typedef enum
1061 {
1062   FILE_TEST_SETUP_TYPE_NONEXISTENT,
1063   FILE_TEST_SETUP_TYPE_REGULAR_EMPTY,
1064   FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY,
1065   FILE_TEST_SETUP_TYPE_DIRECTORY,
1066   FILE_TEST_SETUP_TYPE_SOCKET,
1067   FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING,
1068   FILE_TEST_SETUP_TYPE_SYMLINK_VALID,
1069 } FileTestSetupType;
1070
1071 /* Create file `tmpdir/basename`, of type @setup_type, and chmod it to
1072  * @setup_mode. Return the #GFile representing it. Abort on any errors. */
1073 static GFile *
1074 create_test_file (GFile             *tmpdir,
1075                   const gchar       *basename,
1076                   FileTestSetupType  setup_type,
1077                   guint              setup_mode)
1078 {
1079   GFile *test_file = g_file_get_child (tmpdir, basename);
1080   gchar *target_basename = g_strdup_printf ("%s-target", basename);  /* for symlinks */
1081   GFile *target_file = g_file_get_child (tmpdir, target_basename);
1082   GError *local_error = NULL;
1083
1084   switch (setup_type)
1085     {
1086     case FILE_TEST_SETUP_TYPE_NONEXISTENT:
1087       /* Nothing to do here. */
1088       g_assert (setup_mode == 0);
1089       break;
1090     case FILE_TEST_SETUP_TYPE_REGULAR_EMPTY:
1091     case FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY:
1092         {
1093           gchar *contents = NULL;
1094
1095           if (setup_type == FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY)
1096             contents = g_strdup_printf ("this is some test content in %s", basename);
1097           else
1098             contents = g_strdup ("");
1099
1100           g_file_set_contents (g_file_peek_path (test_file), contents, -1, &local_error);
1101           g_assert_no_error (local_error);
1102
1103           g_file_set_attribute_uint32 (test_file, G_FILE_ATTRIBUTE_UNIX_MODE,
1104                                        setup_mode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
1105                                        NULL, &local_error);
1106           g_assert_no_error (local_error);
1107
1108           g_free (contents);
1109           break;
1110         }
1111     case FILE_TEST_SETUP_TYPE_DIRECTORY:
1112       g_assert (setup_mode == 0);
1113
1114       g_file_make_directory (test_file, NULL, &local_error);
1115       g_assert_no_error (local_error);
1116       break;
1117     case FILE_TEST_SETUP_TYPE_SOCKET:
1118       g_assert_no_errno (mknod (g_file_peek_path (test_file), S_IFSOCK | setup_mode, 0));
1119       break;
1120     case FILE_TEST_SETUP_TYPE_SYMLINK_VALID:
1121       g_file_set_contents (g_file_peek_path (target_file), "target file", -1, &local_error);
1122       g_assert_no_error (local_error);
1123       G_GNUC_FALLTHROUGH;
1124     case FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING:
1125       /* Permissions on a symlink are not used by the kernel, so are only
1126        * applicable if the symlink is valid (and are applied to the target) */
1127       g_assert (setup_type != FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING || setup_mode == 0);
1128
1129       g_file_make_symbolic_link (test_file, target_basename, NULL, &local_error);
1130       g_assert_no_error (local_error);
1131
1132       if (setup_type == FILE_TEST_SETUP_TYPE_SYMLINK_VALID)
1133         {
1134           g_file_set_attribute_uint32 (test_file, G_FILE_ATTRIBUTE_UNIX_MODE,
1135                                        setup_mode, G_FILE_QUERY_INFO_NONE,
1136                                        NULL, &local_error);
1137           g_assert_no_error (local_error);
1138         }
1139
1140       if (setup_type == FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING)
1141         {
1142           /* Ensure that the target doesn’t exist */
1143           g_assert_false (g_file_query_exists (target_file, NULL));
1144         }
1145       break;
1146     default:
1147       g_assert_not_reached ();
1148     }
1149
1150   g_clear_object (&target_file);
1151   g_free (target_basename);
1152
1153   return g_steal_pointer (&test_file);
1154 }
1155
1156 /* Check that @test_file is of the @expected_type, has the @expected_mode, and
1157  * (if it’s a regular file) has the @expected_contents or (if it’s a symlink)
1158  * has the symlink target given by @expected_contents.
1159  *
1160  * @test_file must point to the file `tmpdir/basename`.
1161  *
1162  * Aborts on any errors or mismatches against the expectations.
1163  */
1164 static void
1165 check_test_file (GFile             *test_file,
1166                  GFile             *tmpdir,
1167                  const gchar       *basename,
1168                  FileTestSetupType  expected_type,
1169                  guint              expected_mode,
1170                  const gchar       *expected_contents)
1171 {
1172   gchar *target_basename = g_strdup_printf ("%s-target", basename);  /* for symlinks */
1173   GFile *target_file = g_file_get_child (tmpdir, target_basename);
1174   GFileType test_file_type = g_file_query_file_type (test_file, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL);
1175   GFileInfo *info = NULL;
1176   GError *local_error = NULL;
1177
1178   switch (expected_type)
1179     {
1180     case FILE_TEST_SETUP_TYPE_NONEXISTENT:
1181       g_assert (expected_mode == 0);
1182       g_assert (expected_contents == NULL);
1183
1184       g_assert_false (g_file_query_exists (test_file, NULL));
1185       g_assert_cmpint (test_file_type, ==, G_FILE_TYPE_UNKNOWN);
1186       break;
1187     case FILE_TEST_SETUP_TYPE_REGULAR_EMPTY:
1188     case FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY:
1189       g_assert (expected_type != FILE_TEST_SETUP_TYPE_REGULAR_EMPTY || expected_contents == NULL);
1190       g_assert (expected_type != FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY || expected_contents != NULL);
1191
1192       g_assert_cmpint (test_file_type, ==, G_FILE_TYPE_REGULAR);
1193
1194       info = g_file_query_info (test_file,
1195                                 G_FILE_ATTRIBUTE_STANDARD_SIZE ","
1196                                 G_FILE_ATTRIBUTE_UNIX_MODE,
1197                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &local_error);
1198       g_assert_no_error (local_error);
1199
1200       if (expected_type == FILE_TEST_SETUP_TYPE_REGULAR_EMPTY)
1201         g_assert_cmpint (g_file_info_get_size (info), ==, 0);
1202       else
1203         g_assert_cmpint (g_file_info_get_size (info), >, 0);
1204
1205       if (expected_contents != NULL)
1206         {
1207           gchar *contents = NULL;
1208           gsize length = 0;
1209
1210           g_file_get_contents (g_file_peek_path (test_file), &contents, &length, &local_error);
1211           g_assert_no_error (local_error);
1212
1213           g_assert_cmpstr (contents, ==, expected_contents);
1214           g_free (contents);
1215         }
1216
1217       g_assert_cmpuint (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE) & 0777, ==, expected_mode);
1218
1219       break;
1220     case FILE_TEST_SETUP_TYPE_DIRECTORY:
1221       g_assert (expected_mode == 0);
1222       g_assert (expected_contents == NULL);
1223
1224       g_assert_cmpint (test_file_type, ==, G_FILE_TYPE_DIRECTORY);
1225       break;
1226     case FILE_TEST_SETUP_TYPE_SOCKET:
1227       g_assert (expected_contents == NULL);
1228
1229       g_assert_cmpint (test_file_type, ==, G_FILE_TYPE_SPECIAL);
1230
1231       info = g_file_query_info (test_file,
1232                                 G_FILE_ATTRIBUTE_UNIX_MODE,
1233                                 G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &local_error);
1234       g_assert_no_error (local_error);
1235
1236       g_assert_cmpuint (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE) & 0777, ==, expected_mode);
1237       break;
1238     case FILE_TEST_SETUP_TYPE_SYMLINK_VALID:
1239     case FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING:
1240         {
1241           GFile *symlink_target_file = NULL;
1242
1243           /* Permissions on a symlink are not used by the kernel, so are only
1244            * applicable if the symlink is valid (and are applied to the target) */
1245           g_assert (expected_type != FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING || expected_mode == 0);
1246           g_assert (expected_contents != NULL);
1247
1248           g_assert_cmpint (test_file_type, ==, G_FILE_TYPE_SYMBOLIC_LINK);
1249
1250           info = g_file_query_info (test_file,
1251                                     G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,
1252                                     G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &local_error);
1253           g_assert_no_error (local_error);
1254
1255           g_assert_cmpstr (g_file_info_get_symlink_target (info), ==, expected_contents);
1256
1257           symlink_target_file = g_file_get_child (tmpdir, g_file_info_get_symlink_target (info));
1258           if (expected_type == FILE_TEST_SETUP_TYPE_SYMLINK_VALID)
1259             g_assert_true (g_file_query_exists (symlink_target_file, NULL));
1260           else
1261             g_assert_false (g_file_query_exists (symlink_target_file, NULL));
1262
1263           if (expected_type == FILE_TEST_SETUP_TYPE_SYMLINK_VALID)
1264             {
1265               GFileInfo *target_info = NULL;
1266
1267               /* Need to re-query the info so we follow symlinks */
1268               target_info = g_file_query_info (test_file,
1269                                                G_FILE_ATTRIBUTE_UNIX_MODE,
1270                                                G_FILE_QUERY_INFO_NONE, NULL, &local_error);
1271               g_assert_no_error (local_error);
1272
1273               g_assert_cmpuint (g_file_info_get_attribute_uint32 (target_info, G_FILE_ATTRIBUTE_UNIX_MODE) & 0777, ==, expected_mode);
1274
1275               g_clear_object (&target_info);
1276             }
1277
1278           g_clear_object (&symlink_target_file);
1279           break;
1280         }
1281     default:
1282       g_assert_not_reached ();
1283     }
1284
1285   g_clear_object (&info);
1286   g_clear_object (&target_file);
1287   g_free (target_basename);
1288 }
1289
1290 #endif  /* __linux__ */
1291
1292 /* A big test for g_file_replace() and g_file_replace_readwrite(). The
1293  * @test_data is a boolean: %TRUE to test g_file_replace_readwrite(), %FALSE to
1294  * test g_file_replace(). The test setup and checks are identical for both
1295  * functions; in the case of testing g_file_replace_readwrite(), only the output
1296  * stream side of the returned #GIOStream is tested. i.e. We test the write
1297  * behaviour of both functions is identical.
1298  *
1299  * This is intended to test all static behaviour of the function: for each test
1300  * scenario, a temporary directory is set up with a source file (and maybe some
1301  * other files) in a set configuration, g_file_replace{,_readwrite}() is called,
1302  * and the final state of the directory is checked.
1303  *
1304  * This test does not check dynamic behaviour or race conditions. For example,
1305  * it does not test what happens if the source file is deleted from another
1306  * process half-way through a call to g_file_replace().
1307  */
1308 static void
1309 test_replace (gconstpointer test_data)
1310 {
1311 #ifdef __linux__
1312   gboolean read_write = GPOINTER_TO_UINT (test_data);
1313   const gchar *new_contents = "this is a new test message which should be written to source";
1314   const gchar *original_source_contents = "this is some test content in source";
1315   const gchar *original_backup_contents = "this is some test content in source~";
1316   mode_t current_umask = umask (0);
1317   guint32 default_public_mode = 0666 & ~current_umask;
1318   guint32 default_private_mode = 0600;
1319
1320   const struct
1321     {
1322       /* Arguments to pass to g_file_replace(). */
1323       gboolean replace_make_backup;
1324       GFileCreateFlags replace_flags;
1325       const gchar *replace_etag;  /* (nullable) */
1326
1327       /* File system setup. */
1328       FileTestSetupType setup_source_type;
1329       guint setup_source_mode;
1330       FileTestSetupType setup_backup_type;
1331       guint setup_backup_mode;
1332
1333       /* Expected results. */
1334       gboolean expected_success;
1335       GQuark expected_error_domain;
1336       gint expected_error_code;
1337
1338       /* Expected final file system state. */
1339       guint expected_n_files;
1340       FileTestSetupType expected_source_type;
1341       guint expected_source_mode;
1342       const gchar *expected_source_contents;  /* content for a regular file, or target for a symlink; NULL otherwise */
1343       FileTestSetupType expected_backup_type;
1344       guint expected_backup_mode;
1345       const gchar *expected_backup_contents;  /* content for a regular file, or target for a symlink; NULL otherwise */
1346     }
1347   tests[] =
1348     {
1349       /* replace_make_backup == FALSE, replace_flags == NONE, replace_etag == NULL,
1350        * all the different values of setup_source_type, mostly with a backup
1351        * file created to check it’s not modified */
1352       {
1353         FALSE, G_FILE_CREATE_NONE, NULL,
1354         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1355         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1356         TRUE, 0, 0,
1357         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1358         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1359       },
1360       {
1361         FALSE, G_FILE_CREATE_NONE, NULL,
1362         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode,
1363         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1364         TRUE, 0, 0,
1365         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1366         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1367       },
1368       {
1369         FALSE, G_FILE_CREATE_NONE, NULL,
1370         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1371         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1372         TRUE, 0, 0,
1373         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1374         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1375       },
1376       {
1377         FALSE, G_FILE_CREATE_NONE, NULL,
1378         FILE_TEST_SETUP_TYPE_DIRECTORY, 0,
1379         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1380         FALSE, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
1381         2, FILE_TEST_SETUP_TYPE_DIRECTORY, 0, NULL,
1382         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1383       },
1384       {
1385         FALSE, G_FILE_CREATE_NONE, NULL,
1386         FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode,
1387         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1388         FALSE, G_IO_ERROR, G_IO_ERROR_NOT_REGULAR_FILE,
1389         2, FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode, NULL,
1390         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1391       },
1392       {
1393         FALSE, G_FILE_CREATE_NONE, NULL,
1394         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0,
1395         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1396         TRUE, 0, 0,
1397         3, FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode, "source-target",
1398         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1399       },
1400       {
1401         FALSE, G_FILE_CREATE_NONE, NULL,
1402         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode,
1403         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1404         TRUE, 0, 0,
1405         3, FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode, "source-target",
1406         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1407       },
1408
1409       /* replace_etag set to an invalid value, with setup_source_type as a
1410        * regular non-empty file; replacement should fail */
1411       {
1412         FALSE, G_FILE_CREATE_NONE, "incorrect etag",
1413         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1414         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1415         FALSE, G_IO_ERROR, G_IO_ERROR_WRONG_ETAG,
1416         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1417         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1418       },
1419
1420       /* replace_make_backup == TRUE, replace_flags == NONE, replace_etag == NULL,
1421        * all the different values of setup_source_type, with a backup
1422        * file created to check it’s either replaced or the operation fails */
1423       {
1424         TRUE, G_FILE_CREATE_NONE, NULL,
1425         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1426         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1427         TRUE, 0, 0,
1428         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1429         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1430       },
1431       {
1432         TRUE, G_FILE_CREATE_NONE, NULL,
1433         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode,
1434         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1435         TRUE, 0, 0,
1436         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1437         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode, NULL,
1438       },
1439       {
1440         TRUE, G_FILE_CREATE_NONE, NULL,
1441         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1442         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1443         TRUE, 0, 0,
1444         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1445         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1446       },
1447       {
1448         TRUE, G_FILE_CREATE_NONE, NULL,
1449         FILE_TEST_SETUP_TYPE_DIRECTORY, 0,
1450         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1451         FALSE, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
1452         2, FILE_TEST_SETUP_TYPE_DIRECTORY, 0, NULL,
1453         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1454       },
1455       {
1456         TRUE, G_FILE_CREATE_NONE, NULL,
1457         FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode,
1458         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1459         FALSE, G_IO_ERROR, G_IO_ERROR_NOT_REGULAR_FILE,
1460         2, FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode, NULL,
1461         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1462       },
1463       {
1464         TRUE, G_FILE_CREATE_NONE, NULL,
1465         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0,
1466         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1467         TRUE, 0, 0,
1468         /* The final situation here is a bit odd; the backup file is a bit
1469          * pointless as the original source file was a dangling symlink.
1470          * Theoretically the backup file should be that symlink, pointing to
1471          * `source-target`, and hence no longer dangling, as that file has now
1472          * been created as the new source content, since REPLACE_DESTINATION was
1473          * not specified. However, the code instead creates an empty regular
1474          * file as the backup. FIXME: This seems acceptable for now, but not
1475          * entirely ideal and would be good to fix at some point. */
1476         3, FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode, "source-target",
1477         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, 0777 & ~current_umask, NULL,
1478       },
1479       {
1480         TRUE, G_FILE_CREATE_NONE, NULL,
1481         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode,
1482         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1483         TRUE, 0, 0,
1484         /* FIXME: The permissions for the backup file are just the default umask,
1485          * but should probably be the same as the permissions for the source
1486          * file (`default_public_mode`). This probably arises from the fact that
1487          * symlinks don’t have permissions. */
1488         3, FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode, "source-target",
1489         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, 0777 & ~current_umask, "target file",
1490       },
1491
1492       /* replace_make_backup == TRUE, replace_flags == NONE, replace_etag == NULL,
1493        * setup_source_type is a regular file, with a backup file of every type
1494        * created to check it’s either replaced or the operation fails */
1495       {
1496         TRUE, G_FILE_CREATE_NONE, NULL,
1497         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1498         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1499         TRUE, 0, 0,
1500         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1501         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1502       },
1503       {
1504         TRUE, G_FILE_CREATE_NONE, NULL,
1505         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1506         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode,
1507         TRUE, 0, 0,
1508         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1509         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1510       },
1511       {
1512         TRUE, G_FILE_CREATE_NONE, NULL,
1513         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1514         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1515         TRUE, 0, 0,
1516         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1517         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1518       },
1519       {
1520         TRUE, G_FILE_CREATE_NONE, NULL,
1521         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1522         FILE_TEST_SETUP_TYPE_DIRECTORY, 0,
1523         FALSE, G_IO_ERROR, G_IO_ERROR_CANT_CREATE_BACKUP,
1524         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1525         FILE_TEST_SETUP_TYPE_DIRECTORY, 0, NULL,
1526       },
1527       {
1528         TRUE, G_FILE_CREATE_NONE, NULL,
1529         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1530         FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode,
1531         TRUE, 0, 0,
1532         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1533         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1534       },
1535       {
1536         TRUE, G_FILE_CREATE_NONE, NULL,
1537         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1538         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0,
1539         TRUE, 0, 0,
1540         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1541         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1542       },
1543       {
1544         TRUE, G_FILE_CREATE_NONE, NULL,
1545         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1546         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode,
1547         TRUE, 0, 0,
1548         /* the third file is `source~-target`, the original target of the old
1549          * backup symlink */
1550         3, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1551         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1552       },
1553
1554       /* replace_make_backup == FALSE, replace_flags == REPLACE_DESTINATION,
1555        * replace_etag == NULL, all the different values of setup_source_type,
1556        * mostly with a backup file created to check it’s not modified */
1557       {
1558         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1559         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1560         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1561         TRUE, 0, 0,
1562         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1563         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1564       },
1565       {
1566         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1567         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode,
1568         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1569         TRUE, 0, 0,
1570         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1571         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1572       },
1573       {
1574         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1575         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1576         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1577         TRUE, 0, 0,
1578         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1579         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1580       },
1581       {
1582         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1583         FILE_TEST_SETUP_TYPE_DIRECTORY, 0,
1584         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1585         FALSE, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
1586         2, FILE_TEST_SETUP_TYPE_DIRECTORY, 0, NULL,
1587         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1588       },
1589       {
1590         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1591         FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode,
1592         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1593         FALSE, G_IO_ERROR, G_IO_ERROR_NOT_REGULAR_FILE,
1594         2, FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode, NULL,
1595         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1596       },
1597       {
1598         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1599         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0,
1600         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1601         TRUE, 0, 0,
1602         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1603         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1604       },
1605       {
1606         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1607         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode,
1608         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1609         TRUE, 0, 0,
1610         /* the third file is `source-target`, the original target of the old
1611          * source file */
1612         3, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1613         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1614       },
1615
1616       /* replace_flags == REPLACE_DESTINATION, replace_etag set to an invalid
1617        * value, with setup_source_type as a regular non-empty file; replacement
1618        * should fail */
1619       {
1620         FALSE, G_FILE_CREATE_REPLACE_DESTINATION, "incorrect etag",
1621         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1622         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1623         FALSE, G_IO_ERROR, G_IO_ERROR_WRONG_ETAG,
1624         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1625         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1626       },
1627
1628       /* replace_make_backup == TRUE, replace_flags == REPLACE_DESTINATION,
1629        * replace_etag == NULL, all the different values of setup_source_type,
1630        * with a backup file created to check it’s either replaced or the
1631        * operation fails */
1632       {
1633         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1634         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1635         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1636         TRUE, 0, 0,
1637         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1638         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1639       },
1640       {
1641         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1642         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode,
1643         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1644         TRUE, 0, 0,
1645         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1646         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode, NULL,
1647       },
1648       {
1649         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1650         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1651         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1652         TRUE, 0, 0,
1653         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1654         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1655       },
1656       {
1657         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1658         FILE_TEST_SETUP_TYPE_DIRECTORY, 0,
1659         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1660         FALSE, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
1661         2, FILE_TEST_SETUP_TYPE_DIRECTORY, 0, NULL,
1662         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1663       },
1664       {
1665         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1666         FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode,
1667         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1668         FALSE, G_IO_ERROR, G_IO_ERROR_NOT_REGULAR_FILE,
1669         2, FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode, NULL,
1670         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_backup_contents,
1671       },
1672       {
1673         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1674         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0,
1675         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1676         TRUE, 0, 0,
1677         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1678         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0, "source-target",
1679       },
1680       {
1681         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1682         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode,
1683         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1684         TRUE, 0, 0,
1685         /* the third file is `source-target`, the original target of the old
1686          * source file */
1687         3, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1688         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode, "source-target",
1689       },
1690
1691       /* replace_make_backup == TRUE, replace_flags == REPLACE_DESTINATION,
1692        * replace_etag == NULL, setup_source_type is a regular file, with a
1693        * backup file of every type created to check it’s either replaced or the
1694        * operation fails */
1695       {
1696         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1697         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1698         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1699         TRUE, 0, 0,
1700         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1701         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1702       },
1703       {
1704         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1705         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1706         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, default_public_mode,
1707         TRUE, 0, 0,
1708         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1709         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1710       },
1711       {
1712         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1713         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1714         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1715         TRUE, 0, 0,
1716         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1717         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1718       },
1719       {
1720         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1721         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1722         FILE_TEST_SETUP_TYPE_DIRECTORY, 0,
1723         FALSE, G_IO_ERROR, G_IO_ERROR_CANT_CREATE_BACKUP,
1724         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1725         FILE_TEST_SETUP_TYPE_DIRECTORY, 0, NULL,
1726       },
1727       {
1728         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1729         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1730         FILE_TEST_SETUP_TYPE_SOCKET, default_public_mode,
1731         TRUE, 0, 0,
1732         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1733         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1734       },
1735       {
1736         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1737         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1738         FILE_TEST_SETUP_TYPE_SYMLINK_DANGLING, 0,
1739         TRUE, 0, 0,
1740         2, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1741         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1742       },
1743       {
1744         TRUE, G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1745         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1746         FILE_TEST_SETUP_TYPE_SYMLINK_VALID, default_public_mode,
1747         TRUE, 0, 0,
1748         /* the third file is `source~-target`, the original target of the old
1749          * backup symlink */
1750         3, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1751         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, original_source_contents,
1752       },
1753
1754       /* several different setups with replace_flags == PRIVATE */
1755       {
1756         FALSE, G_FILE_CREATE_PRIVATE, NULL,
1757         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1758         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1759         TRUE, 0, 0,
1760         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_private_mode, new_contents,
1761         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1762       },
1763       {
1764         FALSE, G_FILE_CREATE_PRIVATE, NULL,
1765         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1766         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1767         TRUE, 0, 0,
1768         /* the file isn’t being replaced, so it should keep its existing permissions */
1769         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode, new_contents,
1770         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1771       },
1772       {
1773         FALSE, G_FILE_CREATE_PRIVATE | G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1774         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1775         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1776         TRUE, 0, 0,
1777         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_private_mode, new_contents,
1778         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1779       },
1780       {
1781         FALSE, G_FILE_CREATE_PRIVATE | G_FILE_CREATE_REPLACE_DESTINATION, NULL,
1782         FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_public_mode,
1783         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1784         TRUE, 0, 0,
1785         1, FILE_TEST_SETUP_TYPE_REGULAR_NONEMPTY, default_private_mode, new_contents,
1786         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1787       },
1788
1789       /* make the initial source file unreadable, so the replace operation
1790        * should fail */
1791       {
1792         FALSE, G_FILE_CREATE_NONE, NULL,
1793         FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, 0  /* most restrictive permissions */,
1794         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0,
1795         FALSE, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
1796         1, FILE_TEST_SETUP_TYPE_REGULAR_EMPTY, 0, NULL,
1797         FILE_TEST_SETUP_TYPE_NONEXISTENT, 0, NULL,
1798       },
1799     };
1800   gsize i;
1801
1802   g_test_summary ("Test various situations for g_file_replace()");
1803
1804   /* Reset the umask after querying it above. There’s no way to query it without
1805    * changing it. */
1806   umask (current_umask);
1807   g_test_message ("Current umask: %u", current_umask);
1808
1809   for (i = 0; i < G_N_ELEMENTS (tests); i++)
1810     {
1811       gchar *tmpdir_path = NULL;
1812       GFile *tmpdir = NULL, *source_file = NULL, *backup_file = NULL;
1813       GFileOutputStream *output_stream = NULL;
1814       GFileIOStream *io_stream = NULL;
1815       GFileEnumerator *enumerator = NULL;
1816       GFileInfo *info = NULL;
1817       guint n_files;
1818       GError *local_error = NULL;
1819
1820       /* Create a fresh, empty working directory. */
1821       tmpdir_path = g_dir_make_tmp ("g_file_replace_XXXXXX", &local_error);
1822       g_assert_no_error (local_error);
1823       tmpdir = g_file_new_for_path (tmpdir_path);
1824
1825       g_test_message ("Test %" G_GSIZE_FORMAT ", using temporary directory %s", i, tmpdir_path);
1826       g_free (tmpdir_path);
1827
1828       /* Set up the test directory. */
1829       source_file = create_test_file (tmpdir, "source", tests[i].setup_source_type, tests[i].setup_source_mode);
1830       backup_file = create_test_file (tmpdir, "source~", tests[i].setup_backup_type, tests[i].setup_backup_mode);
1831
1832       /* Replace the source file. Check the error state only after finishing
1833        * writing, as the replace operation is split across g_file_replace() and
1834        * g_output_stream_close(). */
1835       if (read_write)
1836         io_stream = g_file_replace_readwrite (source_file,
1837                                               tests[i].replace_etag,
1838                                               tests[i].replace_make_backup,
1839                                               tests[i].replace_flags,
1840                                               NULL,
1841                                               &local_error);
1842       else
1843         output_stream = g_file_replace (source_file,
1844                                         tests[i].replace_etag,
1845                                         tests[i].replace_make_backup,
1846                                         tests[i].replace_flags,
1847                                         NULL,
1848                                         &local_error);
1849
1850       if (tests[i].expected_success)
1851         {
1852           g_assert_no_error (local_error);
1853           if (read_write)
1854             g_assert_nonnull (io_stream);
1855           else
1856             g_assert_nonnull (output_stream);
1857         }
1858
1859       /* Write new content to it. */
1860       if (io_stream != NULL)
1861         {
1862           GOutputStream *io_output_stream = g_io_stream_get_output_stream (G_IO_STREAM (io_stream));
1863           gsize n_written;
1864
1865           g_output_stream_write_all (G_OUTPUT_STREAM (io_output_stream), new_contents, strlen (new_contents),
1866                                      &n_written, NULL, &local_error);
1867
1868           if (tests[i].expected_success)
1869             {
1870               g_assert_no_error (local_error);
1871               g_assert_cmpint (n_written, ==, strlen (new_contents));
1872             }
1873
1874           g_io_stream_close (G_IO_STREAM (io_stream), NULL, (local_error == NULL) ? &local_error : NULL);
1875
1876           if (tests[i].expected_success)
1877             g_assert_no_error (local_error);
1878         }
1879       else if (output_stream != NULL)
1880         {
1881           gsize n_written;
1882
1883           g_output_stream_write_all (G_OUTPUT_STREAM (output_stream), new_contents, strlen (new_contents),
1884                                      &n_written, NULL, &local_error);
1885
1886           if (tests[i].expected_success)
1887             {
1888               g_assert_no_error (local_error);
1889               g_assert_cmpint (n_written, ==, strlen (new_contents));
1890             }
1891
1892           g_output_stream_close (G_OUTPUT_STREAM (output_stream), NULL, (local_error == NULL) ? &local_error : NULL);
1893
1894           if (tests[i].expected_success)
1895             g_assert_no_error (local_error);
1896         }
1897
1898       if (tests[i].expected_success)
1899         g_assert_no_error (local_error);
1900       else
1901         g_assert_error (local_error, tests[i].expected_error_domain, tests[i].expected_error_code);
1902
1903       g_clear_error (&local_error);
1904       g_clear_object (&io_stream);
1905       g_clear_object (&output_stream);
1906
1907       /* Verify the final state of the directory. */
1908       enumerator = g_file_enumerate_children (tmpdir,
1909                                               G_FILE_ATTRIBUTE_STANDARD_NAME,
1910                                               G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &local_error);
1911       g_assert_no_error (local_error);
1912
1913       n_files = 0;
1914       do
1915         {
1916           g_file_enumerator_iterate (enumerator, &info, NULL, NULL, &local_error);
1917           g_assert_no_error (local_error);
1918
1919           if (info != NULL)
1920             n_files++;
1921         }
1922       while (info != NULL);
1923
1924       g_clear_object (&enumerator);
1925
1926       g_assert_cmpuint (n_files, ==, tests[i].expected_n_files);
1927
1928       check_test_file (source_file, tmpdir, "source", tests[i].expected_source_type, tests[i].expected_source_mode, tests[i].expected_source_contents);
1929       check_test_file (backup_file, tmpdir, "source~", tests[i].expected_backup_type, tests[i].expected_backup_mode, tests[i].expected_backup_contents);
1930
1931       /* Tidy up. Ignore failure apart from when deleting the directory, which
1932        * should be empty. */
1933       g_file_delete (source_file, NULL, NULL);
1934       g_file_delete (backup_file, NULL, NULL);
1935
1936       /* Other files which are occasionally generated by the tests. */
1937         {
1938           GFile *backup_target_file = g_file_get_child (tmpdir, "source~-target");
1939           g_file_delete (backup_target_file, NULL, NULL);
1940           g_clear_object (&backup_target_file);
1941         }
1942         {
1943           GFile *backup_target_file = g_file_get_child (tmpdir, "source-target");
1944           g_file_delete (backup_target_file, NULL, NULL);
1945           g_clear_object (&backup_target_file);
1946         }
1947
1948       g_file_delete (tmpdir, NULL, &local_error);
1949       g_assert_no_error (local_error);
1950
1951       g_clear_object (&backup_file);
1952       g_clear_object (&source_file);
1953       g_clear_object (&tmpdir);
1954     }
1955 #else  /* if !__linux__ */
1956   g_test_skip ("File replacement tests can only be run on Linux");
1957 #endif
1958 }
1959
1960 static void
1961 on_file_deleted (GObject      *object,
1962                  GAsyncResult *result,
1963                  gpointer      user_data)
1964 {
1965   GError *local_error = NULL;
1966   GMainLoop *loop = user_data;
1967
1968   (void) g_file_delete_finish ((GFile*)object, result, &local_error);
1969   g_assert_no_error (local_error);
1970
1971   g_main_loop_quit (loop);
1972 }
1973
1974 static void
1975 test_async_delete (void)
1976 {
1977   GFile *file;
1978   GFileIOStream *iostream;
1979   GError *local_error = NULL;
1980   GError **error = &local_error;
1981   GMainLoop *loop;
1982
1983   file = g_file_new_tmp ("g_file_delete_XXXXXX",
1984                          &iostream, error);
1985   g_assert_no_error (local_error);
1986   g_object_unref (iostream);
1987
1988   g_assert_true (g_file_query_exists (file, NULL));
1989
1990   loop = g_main_loop_new (NULL, TRUE);
1991
1992   g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, on_file_deleted, loop);
1993
1994   g_main_loop_run (loop);
1995
1996   g_assert_false (g_file_query_exists (file, NULL));
1997
1998   g_main_loop_unref (loop);
1999   g_object_unref (file);
2000 }
2001
2002 static void
2003 test_copy_preserve_mode (void)
2004 {
2005 #ifdef G_OS_UNIX
2006   mode_t current_umask = umask (0);
2007   const struct
2008     {
2009       guint32 source_mode;
2010       guint32 expected_destination_mode;
2011       gboolean create_destination_before_copy;
2012       GFileCopyFlags copy_flags;
2013     }
2014   vectors[] =
2015     {
2016       /* Overwriting the destination file should copy the permissions from the
2017        * source file, even if %G_FILE_COPY_ALL_METADATA is set: */
2018       { 0600, 0600, TRUE, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
2019       { 0600, 0600, TRUE, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS },
2020       /* The same behaviour should hold if the destination file is not being
2021        * overwritten because it doesn’t already exist: */
2022       { 0600, 0600, FALSE, G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
2023       { 0600, 0600, FALSE, G_FILE_COPY_NOFOLLOW_SYMLINKS },
2024       /* Anything with %G_FILE_COPY_TARGET_DEFAULT_PERMS should use the current
2025        * umask for the destination file: */
2026       { 0600, 0666 & ~current_umask, TRUE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
2027       { 0600, 0666 & ~current_umask, TRUE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS },
2028       { 0600, 0666 & ~current_umask, FALSE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
2029       { 0600, 0666 & ~current_umask, FALSE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_NOFOLLOW_SYMLINKS },
2030     };
2031   gsize i;
2032
2033   /* Reset the umask after querying it above. There’s no way to query it without
2034    * changing it. */
2035   umask (current_umask);
2036   g_test_message ("Current umask: %u", current_umask);
2037
2038   for (i = 0; i < G_N_ELEMENTS (vectors); i++)
2039     {
2040       GFile *tmpfile;
2041       GFile *dest_tmpfile;
2042       GFileInfo *dest_info;
2043       GFileIOStream *iostream;
2044       GError *local_error = NULL;
2045       guint32 romode = vectors[i].source_mode;
2046       guint32 dest_mode;
2047
2048       g_test_message ("Vector %" G_GSIZE_FORMAT, i);
2049
2050       tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
2051                                 &iostream, &local_error);
2052       g_assert_no_error (local_error);
2053       g_io_stream_close ((GIOStream*)iostream, NULL, &local_error);
2054       g_assert_no_error (local_error);
2055       g_clear_object (&iostream);
2056
2057       g_file_set_attribute (tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_ATTRIBUTE_TYPE_UINT32,
2058                             &romode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2059                             NULL, &local_error);
2060       g_assert_no_error (local_error);
2061
2062       dest_tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
2063                                      &iostream, &local_error);
2064       g_assert_no_error (local_error);
2065       g_io_stream_close ((GIOStream*)iostream, NULL, &local_error);
2066       g_assert_no_error (local_error);
2067       g_clear_object (&iostream);
2068
2069       if (!vectors[i].create_destination_before_copy)
2070         {
2071           g_file_delete (dest_tmpfile, NULL, &local_error);
2072           g_assert_no_error (local_error);
2073         }
2074
2075       g_file_copy (tmpfile, dest_tmpfile, vectors[i].copy_flags,
2076                    NULL, NULL, NULL, &local_error);
2077       g_assert_no_error (local_error);
2078
2079       dest_info = g_file_query_info (dest_tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2080                                      NULL, &local_error);
2081       g_assert_no_error (local_error);
2082
2083       dest_mode = g_file_info_get_attribute_uint32 (dest_info, G_FILE_ATTRIBUTE_UNIX_MODE);
2084
2085       g_assert_cmpint (dest_mode & ~S_IFMT, ==, vectors[i].expected_destination_mode);
2086       g_assert_cmpint (dest_mode & S_IFMT, ==, S_IFREG);
2087
2088       (void) g_file_delete (tmpfile, NULL, NULL);
2089       (void) g_file_delete (dest_tmpfile, NULL, NULL);
2090
2091       g_clear_object (&tmpfile);
2092       g_clear_object (&dest_tmpfile);
2093       g_clear_object (&dest_info);
2094     }
2095 #else  /* if !G_OS_UNIX */
2096   g_test_skip ("File permissions tests can only be run on Unix")
2097 #endif
2098 }
2099
2100 static gchar *
2101 splice_to_string (GInputStream   *stream,
2102                   GError        **error)
2103 {
2104   GMemoryOutputStream *buffer = NULL;
2105   char *ret = NULL;
2106
2107   buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
2108   if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
2109     goto out;
2110
2111   if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
2112     goto out;
2113
2114   if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
2115     goto out;
2116
2117   ret = g_memory_output_stream_steal_data (buffer);
2118  out:
2119   g_clear_object (&buffer);
2120   return ret;
2121 }
2122
2123 static gboolean
2124 get_size_from_du (const gchar *path, guint64 *size)
2125 {
2126   GSubprocess *du;
2127   gboolean ok;
2128   gchar *result;
2129   gchar *endptr;
2130   GError *error = NULL;
2131   gchar *du_path = NULL;
2132
2133   /* If we can’t find du, don’t try and run the test. */
2134   du_path = g_find_program_in_path ("du");
2135   if (du_path == NULL)
2136     return FALSE;
2137   g_free (du_path);
2138
2139   du = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE,
2140                          &error,
2141                          "du", "--bytes", "-s", path, NULL);
2142   g_assert_no_error (error);
2143
2144   result = splice_to_string (g_subprocess_get_stdout_pipe (du), &error);
2145   g_assert_no_error (error);
2146
2147   *size = g_ascii_strtoll (result, &endptr, 10);
2148
2149   g_subprocess_wait (du, NULL, &error);
2150   g_assert_no_error (error);
2151
2152   ok = g_subprocess_get_successful (du);
2153
2154   g_object_unref (du);
2155   g_free (result);
2156
2157   return ok;
2158 }
2159
2160 static void
2161 test_measure (void)
2162 {
2163   GFile *file;
2164   guint64 size;
2165   guint64 num_bytes;
2166   guint64 num_dirs;
2167   guint64 num_files;
2168   GError *error = NULL;
2169   gboolean ok;
2170   gchar *path;
2171
2172   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
2173   file = g_file_new_for_path (path);
2174
2175   if (!get_size_from_du (path, &size))
2176     {
2177       g_test_message ("du not found or fail to run, skipping byte measurement");
2178       size = 0;
2179     }
2180
2181   ok = g_file_measure_disk_usage (file,
2182                                   G_FILE_MEASURE_APPARENT_SIZE,
2183                                   NULL,
2184                                   NULL,
2185                                   NULL,
2186                                   &num_bytes,
2187                                   &num_dirs,
2188                                   &num_files,
2189                                   &error);
2190   g_assert_true (ok);
2191   g_assert_no_error (error);
2192
2193   if (size > 0)
2194     g_assert_cmpuint (num_bytes, ==, size);
2195   g_assert_cmpuint (num_dirs, ==, 6);
2196   g_assert_cmpuint (num_files, ==, 32);
2197
2198   g_object_unref (file);
2199   g_free (path);
2200 }
2201
2202 typedef struct {
2203   guint64 expected_bytes;
2204   guint64 expected_dirs;
2205   guint64 expected_files;
2206   gint progress_count;
2207   guint64 progress_bytes;
2208   guint64 progress_dirs;
2209   guint64 progress_files;
2210 } MeasureData;
2211
2212 static void
2213 measure_progress (gboolean reporting,
2214                   guint64  current_size,
2215                   guint64  num_dirs,
2216                   guint64  num_files,
2217                   gpointer user_data)
2218 {
2219   MeasureData *data = user_data;
2220
2221   data->progress_count += 1;
2222
2223   g_assert_cmpuint (current_size, >=, data->progress_bytes);
2224   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
2225   g_assert_cmpuint (num_files, >=, data->progress_files);
2226
2227   data->progress_bytes = current_size;
2228   data->progress_dirs = num_dirs;
2229   data->progress_files = num_files;
2230 }
2231
2232 static void
2233 measure_done (GObject      *source,
2234               GAsyncResult *res,
2235               gpointer      user_data)
2236 {
2237   MeasureData *data = user_data;
2238   guint64 num_bytes, num_dirs, num_files;
2239   GError *error = NULL;
2240   gboolean ok;
2241
2242   ok = g_file_measure_disk_usage_finish (G_FILE (source), res, &num_bytes, &num_dirs, &num_files, &error);
2243   g_assert_true (ok);
2244   g_assert_no_error (error);
2245
2246   if (data->expected_bytes > 0)
2247     g_assert_cmpuint (data->expected_bytes, ==, num_bytes);
2248   g_assert_cmpuint (data->expected_dirs, ==, num_dirs);
2249   g_assert_cmpuint (data->expected_files, ==, num_files);
2250
2251   g_assert_cmpuint (data->progress_count, >, 0);
2252   g_assert_cmpuint (num_bytes, >=, data->progress_bytes);
2253   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
2254   g_assert_cmpuint (num_files, >=, data->progress_files);
2255
2256   g_free (data);
2257   g_object_unref (source);
2258 }
2259
2260 static void
2261 test_measure_async (void)
2262 {
2263   gchar *path;
2264   GFile *file;
2265   MeasureData *data;
2266
2267   data = g_new (MeasureData, 1);
2268
2269   data->progress_count = 0;
2270   data->progress_bytes = 0;
2271   data->progress_files = 0;
2272   data->progress_dirs = 0;
2273
2274   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
2275   file = g_file_new_for_path (path);
2276
2277   if (!get_size_from_du (path, &data->expected_bytes))
2278     {
2279       g_test_message ("du not found or fail to run, skipping byte measurement");
2280       data->expected_bytes = 0;
2281     }
2282
2283   g_free (path);
2284
2285   data->expected_dirs = 6;
2286   data->expected_files = 32;
2287
2288   g_file_measure_disk_usage_async (file,
2289                                    G_FILE_MEASURE_APPARENT_SIZE,
2290                                    0, NULL,
2291                                    measure_progress, data,
2292                                    measure_done, data);
2293 }
2294
2295 static void
2296 test_load_bytes (void)
2297 {
2298   gchar filename[] = "g_file_load_bytes_XXXXXX";
2299   GError *error = NULL;
2300   GBytes *bytes;
2301   GFile *file;
2302   int len;
2303   int fd;
2304   int ret;
2305
2306   fd = g_mkstemp (filename);
2307   g_assert_cmpint (fd, !=, -1);
2308   len = strlen ("test_load_bytes");
2309   ret = write (fd, "test_load_bytes", len);
2310   g_assert_cmpint (ret, ==, len);
2311   close (fd);
2312
2313   file = g_file_new_for_path (filename);
2314   bytes = g_file_load_bytes (file, NULL, NULL, &error);
2315   g_assert_no_error (error);
2316   g_assert_nonnull (bytes);
2317   g_assert_cmpint (len, ==, g_bytes_get_size (bytes));
2318   g_assert_cmpstr ("test_load_bytes", ==, (gchar *)g_bytes_get_data (bytes, NULL));
2319
2320   g_file_delete (file, NULL, NULL);
2321
2322   g_bytes_unref (bytes);
2323   g_object_unref (file);
2324 }
2325
2326 typedef struct
2327 {
2328   GMainLoop *main_loop;
2329   GFile *file;
2330   GBytes *bytes;
2331 } LoadBytesAsyncData;
2332
2333 static void
2334 test_load_bytes_cb (GObject      *object,
2335                     GAsyncResult *result,
2336                     gpointer      user_data)
2337 {
2338   GFile *file = G_FILE (object);
2339   LoadBytesAsyncData *data = user_data;
2340   GError *error = NULL;
2341
2342   data->bytes = g_file_load_bytes_finish (file, result, NULL, &error);
2343   g_assert_no_error (error);
2344   g_assert_nonnull (data->bytes);
2345
2346   g_main_loop_quit (data->main_loop);
2347 }
2348
2349 static void
2350 test_load_bytes_async (void)
2351 {
2352   LoadBytesAsyncData data = { 0 };
2353   gchar filename[] = "g_file_load_bytes_XXXXXX";
2354   int len;
2355   int fd;
2356   int ret;
2357
2358   fd = g_mkstemp (filename);
2359   g_assert_cmpint (fd, !=, -1);
2360   len = strlen ("test_load_bytes_async");
2361   ret = write (fd, "test_load_bytes_async", len);
2362   g_assert_cmpint (ret, ==, len);
2363   close (fd);
2364
2365   data.main_loop = g_main_loop_new (NULL, FALSE);
2366   data.file = g_file_new_for_path (filename);
2367
2368   g_file_load_bytes_async (data.file, NULL, test_load_bytes_cb, &data);
2369   g_main_loop_run (data.main_loop);
2370
2371   g_assert_cmpint (len, ==, g_bytes_get_size (data.bytes));
2372   g_assert_cmpstr ("test_load_bytes_async", ==, (gchar *)g_bytes_get_data (data.bytes, NULL));
2373
2374   g_file_delete (data.file, NULL, NULL);
2375   g_object_unref (data.file);
2376   g_bytes_unref (data.bytes);
2377   g_main_loop_unref (data.main_loop);
2378 }
2379
2380 static void
2381 test_writev_helper (GOutputVector *vectors,
2382                     gsize          n_vectors,
2383                     gboolean       use_bytes_written,
2384                     const guint8  *expected_contents,
2385                     gsize          expected_length)
2386 {
2387   GFile *file;
2388   GFileIOStream *iostream = NULL;
2389   GOutputStream *ostream;
2390   GError *error = NULL;
2391   gsize bytes_written = 0;
2392   gboolean res;
2393   guint8 *contents;
2394   gsize length;
2395
2396   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2397                          &iostream, NULL);
2398   g_assert_nonnull (file);
2399   g_assert_nonnull (iostream);
2400
2401   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2402
2403   res = g_output_stream_writev_all (ostream, vectors, n_vectors, use_bytes_written ? &bytes_written : NULL, NULL, &error);
2404   g_assert_no_error (error);
2405   g_assert_true (res);
2406   if (use_bytes_written)
2407     g_assert_cmpuint (bytes_written, ==, expected_length);
2408
2409   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2410   g_assert_no_error (error);
2411   g_assert_true (res);
2412   g_object_unref (iostream);
2413
2414   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2415   g_assert_no_error (error);
2416   g_assert_true (res);
2417
2418   g_assert_cmpmem (contents, length, expected_contents, expected_length);
2419
2420   g_free (contents);
2421
2422   g_file_delete (file, NULL, NULL);
2423   g_object_unref (file);
2424 }
2425
2426 /* Test that writev() on local file output streams works on a non-empty vector */
2427 static void
2428 test_writev (void)
2429 {
2430   GOutputVector vectors[3];
2431   const guint8 buffer[] = {1, 2, 3, 4, 5,
2432                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
2433                            1, 2, 3};
2434
2435   vectors[0].buffer = buffer;
2436   vectors[0].size = 5;
2437
2438   vectors[1].buffer = buffer + 5;
2439   vectors[1].size = 12;
2440
2441   vectors[2].buffer = buffer + 5 + 12;
2442   vectors[2].size = 3;
2443
2444   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, buffer, sizeof buffer);
2445 }
2446
2447 /* Test that writev() on local file output streams works on a non-empty vector without returning bytes_written */
2448 static void
2449 test_writev_no_bytes_written (void)
2450 {
2451   GOutputVector vectors[3];
2452   const guint8 buffer[] = {1, 2, 3, 4, 5,
2453                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
2454                            1, 2, 3};
2455
2456   vectors[0].buffer = buffer;
2457   vectors[0].size = 5;
2458
2459   vectors[1].buffer = buffer + 5;
2460   vectors[1].size = 12;
2461
2462   vectors[2].buffer = buffer + 5 + 12;
2463   vectors[2].size = 3;
2464
2465   test_writev_helper (vectors, G_N_ELEMENTS (vectors), FALSE, buffer, sizeof buffer);
2466 }
2467
2468 /* Test that writev() on local file output streams works on 0 vectors */
2469 static void
2470 test_writev_no_vectors (void)
2471 {
2472   test_writev_helper (NULL, 0, TRUE, NULL, 0);
2473 }
2474
2475 /* Test that writev() on local file output streams works on empty vectors */
2476 static void
2477 test_writev_empty_vectors (void)
2478 {
2479   GOutputVector vectors[3];
2480
2481   vectors[0].buffer = NULL;
2482   vectors[0].size = 0;
2483   vectors[1].buffer = NULL;
2484   vectors[1].size = 0;
2485   vectors[2].buffer = NULL;
2486   vectors[2].size = 0;
2487
2488   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, NULL, 0);
2489 }
2490
2491 /* Test that writev() fails if the sum of sizes in the vector is too big */
2492 static void
2493 test_writev_too_big_vectors (void)
2494 {
2495   GFile *file;
2496   GFileIOStream *iostream = NULL;
2497   GOutputStream *ostream;
2498   GError *error = NULL;
2499   gsize bytes_written = 0;
2500   gboolean res;
2501   guint8 *contents;
2502   gsize length;
2503   GOutputVector vectors[3];
2504
2505   vectors[0].buffer = (void*) 1;
2506   vectors[0].size = G_MAXSIZE / 2;
2507
2508   vectors[1].buffer = (void*) 1;
2509   vectors[1].size = G_MAXSIZE / 2;
2510
2511   vectors[2].buffer = (void*) 1;
2512   vectors[2].size = G_MAXSIZE / 2;
2513
2514   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2515                          &iostream, NULL);
2516   g_assert_nonnull (file);
2517   g_assert_nonnull (iostream);
2518
2519   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2520
2521   res = g_output_stream_writev_all (ostream, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
2522   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
2523   g_assert_cmpuint (bytes_written, ==, 0);
2524   g_assert_false (res);
2525   g_clear_error (&error);
2526
2527   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2528   g_assert_no_error (error);
2529   g_assert_true (res);
2530   g_object_unref (iostream);
2531
2532   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2533   g_assert_no_error (error);
2534   g_assert_true (res);
2535
2536   g_assert_cmpmem (contents, length, NULL, 0);
2537
2538   g_free (contents);
2539
2540   g_file_delete (file, NULL, NULL);
2541   g_object_unref (file);
2542 }
2543
2544 typedef struct
2545 {
2546   gsize bytes_written;
2547   GOutputVector *vectors;
2548   gsize n_vectors;
2549   GError *error;
2550   gboolean done;
2551 } WritevAsyncData;
2552
2553 static void
2554 test_writev_async_cb (GObject      *object,
2555                       GAsyncResult *result,
2556                       gpointer      user_data)
2557 {
2558   GOutputStream *ostream = G_OUTPUT_STREAM (object);
2559   WritevAsyncData *data = user_data;
2560   GError *error = NULL;
2561   gsize bytes_written;
2562   gboolean res;
2563
2564   res = g_output_stream_writev_finish (ostream, result, &bytes_written, &error);
2565   g_assert_true (res);
2566   g_assert_no_error (error);
2567   data->bytes_written += bytes_written;
2568
2569   /* skip vectors that have been written in full */
2570   while (data->n_vectors > 0 && bytes_written >= data->vectors[0].size)
2571     {
2572       bytes_written -= data->vectors[0].size;
2573       ++data->vectors;
2574       --data->n_vectors;
2575     }
2576   /* skip partially written vector data */
2577   if (bytes_written > 0 && data->n_vectors > 0)
2578     {
2579       data->vectors[0].size -= bytes_written;
2580       data->vectors[0].buffer = ((guint8 *) data->vectors[0].buffer) + bytes_written;
2581     }
2582
2583   if (data->n_vectors > 0)
2584     g_output_stream_writev_async (ostream, data->vectors, data->n_vectors, 0, NULL, test_writev_async_cb, &data);
2585 }
2586
2587 /* Test that writev_async() on local file output streams works on a non-empty vector */
2588 static void
2589 test_writev_async (void)
2590 {
2591   WritevAsyncData data = { 0 };
2592   GFile *file;
2593   GFileIOStream *iostream = NULL;
2594   GOutputVector vectors[3];
2595   const guint8 buffer[] = {1, 2, 3, 4, 5,
2596                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
2597                            1, 2, 3};
2598   GOutputStream *ostream;
2599   GError *error = NULL;
2600   gboolean res;
2601   guint8 *contents;
2602   gsize length;
2603
2604   vectors[0].buffer = buffer;
2605   vectors[0].size = 5;
2606
2607   vectors[1].buffer = buffer + 5;
2608   vectors[1].size = 12;
2609
2610   vectors[2].buffer = buffer + 5  + 12;
2611   vectors[2].size = 3;
2612
2613   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2614                          &iostream, NULL);
2615   g_assert_nonnull (file);
2616   g_assert_nonnull (iostream);
2617
2618   data.vectors = vectors;
2619   data.n_vectors = G_N_ELEMENTS (vectors);
2620
2621   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2622
2623   g_output_stream_writev_async (ostream, data.vectors, data.n_vectors, 0, NULL, test_writev_async_cb, &data);
2624
2625   while (data.n_vectors > 0)
2626     g_main_context_iteration (NULL, TRUE);
2627
2628   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
2629
2630   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2631   g_assert_no_error (error);
2632   g_assert_true (res);
2633   g_object_unref (iostream);
2634
2635   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2636   g_assert_no_error (error);
2637   g_assert_true (res);
2638
2639   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
2640
2641   g_free (contents);
2642
2643   g_file_delete (file, NULL, NULL);
2644   g_object_unref (file);
2645 }
2646
2647 static void
2648 test_writev_all_cb (GObject      *object,
2649                     GAsyncResult *result,
2650                     gpointer      user_data)
2651 {
2652   GOutputStream *ostream = G_OUTPUT_STREAM (object);
2653   WritevAsyncData *data = user_data;
2654
2655   g_output_stream_writev_all_finish (ostream, result, &data->bytes_written, &data->error);
2656   data->done = TRUE;
2657 }
2658
2659 /* Test that writev_async_all() on local file output streams works on a non-empty vector */
2660 static void
2661 test_writev_async_all (void)
2662 {
2663   WritevAsyncData data = { 0 };
2664   GFile *file;
2665   GFileIOStream *iostream = NULL;
2666   GOutputStream *ostream;
2667   GOutputVector vectors[3];
2668   const guint8 buffer[] = {1, 2, 3, 4, 5,
2669                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
2670                            1, 2, 3};
2671   GError *error = NULL;
2672   gboolean res;
2673   guint8 *contents;
2674   gsize length;
2675
2676   vectors[0].buffer = buffer;
2677   vectors[0].size = 5;
2678
2679   vectors[1].buffer = buffer + 5;
2680   vectors[1].size = 12;
2681
2682   vectors[2].buffer = buffer + 5  + 12;
2683   vectors[2].size = 3;
2684
2685   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2686                          &iostream, NULL);
2687   g_assert_nonnull (file);
2688   g_assert_nonnull (iostream);
2689
2690   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2691
2692   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
2693
2694   while (!data.done)
2695     g_main_context_iteration (NULL, TRUE);
2696
2697   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
2698   g_assert_no_error (data.error);
2699
2700   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2701   g_assert_no_error (error);
2702   g_assert_true (res);
2703   g_object_unref (iostream);
2704
2705   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2706   g_assert_no_error (error);
2707   g_assert_true (res);
2708
2709   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
2710
2711   g_free (contents);
2712
2713   g_file_delete (file, NULL, NULL);
2714   g_object_unref (file);
2715 }
2716
2717 /* Test that writev_async_all() on local file output streams handles cancellation correctly */
2718 static void
2719 test_writev_async_all_cancellation (void)
2720 {
2721   WritevAsyncData data = { 0 };
2722   GFile *file;
2723   GFileIOStream *iostream = NULL;
2724   GOutputVector vectors[3];
2725   const guint8 buffer[] = {1, 2, 3, 4, 5,
2726                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
2727                            1, 2, 3};
2728   GOutputStream *ostream;
2729   GError *error = NULL;
2730   gboolean res;
2731   guint8 *contents;
2732   gsize length;
2733   GCancellable *cancellable;
2734
2735   vectors[0].buffer = buffer;
2736   vectors[0].size = 5;
2737
2738   vectors[1].buffer = buffer + 5;
2739   vectors[1].size = 12;
2740
2741   vectors[2].buffer = buffer + 5  + 12;
2742   vectors[2].size = 3;
2743
2744   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2745                          &iostream, NULL);
2746   g_assert_nonnull (file);
2747   g_assert_nonnull (iostream);
2748
2749   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2750
2751   cancellable = g_cancellable_new ();
2752   g_cancellable_cancel (cancellable);
2753
2754   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, cancellable, test_writev_all_cb, &data);
2755
2756   while (!data.done)
2757     g_main_context_iteration (NULL, TRUE);
2758
2759   g_assert_cmpuint (data.bytes_written, ==, 0);
2760   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
2761   g_clear_error (&data.error);
2762
2763   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2764   g_assert_no_error (error);
2765   g_assert_true (res);
2766   g_object_unref (iostream);
2767
2768   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2769   g_assert_no_error (error);
2770   g_assert_true (res);
2771   g_assert_cmpuint (length, ==, 0);
2772
2773   g_free (contents);
2774
2775   g_file_delete (file, NULL, NULL);
2776   g_object_unref (file);
2777   g_object_unref (cancellable);
2778 }
2779
2780 /* Test that writev_async_all() with empty vectors is handled correctly */
2781 static void
2782 test_writev_async_all_empty_vectors (void)
2783 {
2784   WritevAsyncData data = { 0 };
2785   GFile *file;
2786   GFileIOStream *iostream = NULL;
2787   GOutputVector vectors[3];
2788   GOutputStream *ostream;
2789   GError *error = NULL;
2790   gboolean res;
2791   guint8 *contents;
2792   gsize length;
2793
2794   vectors[0].buffer = NULL;
2795   vectors[0].size = 0;
2796
2797   vectors[1].buffer = NULL;
2798   vectors[1].size = 0;
2799
2800   vectors[2].buffer = NULL;
2801   vectors[2].size = 0;
2802
2803   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2804                          &iostream, NULL);
2805   g_assert_nonnull (file);
2806   g_assert_nonnull (iostream);
2807
2808   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2809
2810   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
2811
2812   while (!data.done)
2813     g_main_context_iteration (NULL, TRUE);
2814
2815   g_assert_cmpuint (data.bytes_written, ==, 0);
2816   g_assert_no_error (data.error);
2817   g_clear_error (&data.error);
2818
2819   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2820   g_assert_no_error (error);
2821   g_assert_true (res);
2822   g_object_unref (iostream);
2823
2824   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2825   g_assert_no_error (error);
2826   g_assert_true (res);
2827   g_assert_cmpuint (length, ==, 0);
2828
2829   g_free (contents);
2830
2831   g_file_delete (file, NULL, NULL);
2832   g_object_unref (file);
2833 }
2834
2835 /* Test that writev_async_all() with no vectors is handled correctly */
2836 static void
2837 test_writev_async_all_no_vectors (void)
2838 {
2839   WritevAsyncData data = { 0 };
2840   GFile *file;
2841   GFileIOStream *iostream = NULL;
2842   GOutputStream *ostream;
2843   GError *error = NULL;
2844   gboolean res;
2845   guint8 *contents;
2846   gsize length;
2847
2848   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2849                          &iostream, NULL);
2850   g_assert_nonnull (file);
2851   g_assert_nonnull (iostream);
2852
2853   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2854
2855   g_output_stream_writev_all_async (ostream, NULL, 0, 0, NULL, test_writev_all_cb, &data);
2856
2857   while (!data.done)
2858     g_main_context_iteration (NULL, TRUE);
2859
2860   g_assert_cmpuint (data.bytes_written, ==, 0);
2861   g_assert_no_error (data.error);
2862   g_clear_error (&data.error);
2863
2864   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2865   g_assert_no_error (error);
2866   g_assert_true (res);
2867   g_object_unref (iostream);
2868
2869   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2870   g_assert_no_error (error);
2871   g_assert_true (res);
2872   g_assert_cmpuint (length, ==, 0);
2873
2874   g_free (contents);
2875
2876   g_file_delete (file, NULL, NULL);
2877   g_object_unref (file);
2878 }
2879
2880 /* Test that writev_async_all() with too big vectors is handled correctly */
2881 static void
2882 test_writev_async_all_too_big_vectors (void)
2883 {
2884   WritevAsyncData data = { 0 };
2885   GFile *file;
2886   GFileIOStream *iostream = NULL;
2887   GOutputVector vectors[3];
2888   GOutputStream *ostream;
2889   GError *error = NULL;
2890   gboolean res;
2891   guint8 *contents;
2892   gsize length;
2893
2894   vectors[0].buffer = (void*) 1;
2895   vectors[0].size = G_MAXSIZE / 2;
2896
2897   vectors[1].buffer = (void*) 1;
2898   vectors[1].size = G_MAXSIZE / 2;
2899
2900   vectors[2].buffer = (void*) 1;
2901   vectors[2].size = G_MAXSIZE / 2;
2902
2903   file = g_file_new_tmp ("g_file_writev_XXXXXX",
2904                          &iostream, NULL);
2905   g_assert_nonnull (file);
2906   g_assert_nonnull (iostream);
2907
2908   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
2909
2910   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
2911
2912   while (!data.done)
2913     g_main_context_iteration (NULL, TRUE);
2914
2915   g_assert_cmpuint (data.bytes_written, ==, 0);
2916   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
2917   g_clear_error (&data.error);
2918
2919   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
2920   g_assert_no_error (error);
2921   g_assert_true (res);
2922   g_object_unref (iostream);
2923
2924   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
2925   g_assert_no_error (error);
2926   g_assert_true (res);
2927   g_assert_cmpuint (length, ==, 0);
2928
2929   g_free (contents);
2930
2931   g_file_delete (file, NULL, NULL);
2932   g_object_unref (file);
2933 }
2934
2935 static void
2936 test_build_attribute_list_for_copy (void)
2937 {
2938   GFile *tmpfile;
2939   GFileIOStream *iostream;
2940   GError *error = NULL;
2941   const GFileCopyFlags test_flags[] =
2942     {
2943       G_FILE_COPY_NONE,
2944       G_FILE_COPY_TARGET_DEFAULT_PERMS,
2945       G_FILE_COPY_ALL_METADATA,
2946       G_FILE_COPY_ALL_METADATA | G_FILE_COPY_TARGET_DEFAULT_PERMS,
2947     };
2948   gsize i;
2949   char *attrs;
2950   gchar *attrs_with_commas;
2951
2952   tmpfile = g_file_new_tmp ("tmp-build-attribute-list-for-copyXXXXXX",
2953                             &iostream, &error);
2954   g_assert_no_error (error);
2955   g_io_stream_close ((GIOStream*)iostream, NULL, &error);
2956   g_assert_no_error (error);
2957   g_clear_object (&iostream);
2958
2959   for (i = 0; i < G_N_ELEMENTS (test_flags); i++)
2960     {
2961       GFileCopyFlags flags = test_flags[i];
2962
2963       attrs = g_file_build_attribute_list_for_copy (tmpfile, flags, NULL, &error);
2964       g_test_message ("Attributes for copy: %s", attrs);
2965       g_assert_no_error (error);
2966       g_assert_nonnull (attrs);
2967       attrs_with_commas = g_strconcat (",", attrs, ",", NULL);
2968       g_free (attrs);
2969
2970       /* See g_local_file_class_init for reference. */
2971       if (flags & G_FILE_COPY_TARGET_DEFAULT_PERMS)
2972         g_assert_null (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_UNIX_MODE ","));
2973       else
2974         g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_UNIX_MODE ","));
2975 #ifdef G_OS_UNIX
2976       if (flags & G_FILE_COPY_ALL_METADATA)
2977         {
2978           g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_UNIX_UID ","));
2979           g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_UNIX_GID ","));
2980         }
2981       else
2982         {
2983           g_assert_null (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_UNIX_UID ","));
2984           g_assert_null (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_UNIX_GID ","));
2985         }
2986 #endif
2987 #ifdef HAVE_UTIMES
2988       g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_TIME_MODIFIED ","));
2989       g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC ","));
2990       if (flags & G_FILE_COPY_ALL_METADATA)
2991         {
2992           g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_TIME_ACCESS ","));
2993           g_assert_nonnull (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_TIME_ACCESS_USEC ","));
2994         }
2995       else
2996         {
2997           g_assert_null (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_TIME_ACCESS ","));
2998           g_assert_null (g_strstr_len (attrs_with_commas, -1, "," G_FILE_ATTRIBUTE_TIME_ACCESS_USEC ","));
2999         }
3000 #endif
3001       g_free (attrs_with_commas);
3002     }
3003
3004   (void) g_file_delete (tmpfile, NULL, NULL);
3005   g_clear_object (&tmpfile);
3006 }
3007
3008 int
3009 main (int argc, char *argv[])
3010 {
3011   g_test_init (&argc, &argv, NULL);
3012
3013   g_test_add_func ("/file/basic", test_basic);
3014   g_test_add_func ("/file/build-filename", test_build_filename);
3015   g_test_add_func ("/file/parent", test_parent);
3016   g_test_add_func ("/file/child", test_child);
3017   g_test_add_func ("/file/empty-path", test_empty_path);
3018   g_test_add_func ("/file/type", test_type);
3019   g_test_add_func ("/file/parse-name", test_parse_name);
3020   g_test_add_data_func ("/file/async-create-delete/0", GINT_TO_POINTER (0), test_create_delete);
3021   g_test_add_data_func ("/file/async-create-delete/1", GINT_TO_POINTER (1), test_create_delete);
3022   g_test_add_data_func ("/file/async-create-delete/10", GINT_TO_POINTER (10), test_create_delete);
3023   g_test_add_data_func ("/file/async-create-delete/25", GINT_TO_POINTER (25), test_create_delete);
3024   g_test_add_data_func ("/file/async-create-delete/4096", GINT_TO_POINTER (4096), test_create_delete);
3025   g_test_add_func ("/file/replace-load", test_replace_load);
3026   g_test_add_func ("/file/replace-cancel", test_replace_cancel);
3027   g_test_add_func ("/file/replace-symlink", test_replace_symlink);
3028   g_test_add_func ("/file/replace-symlink/using-etag", test_replace_symlink_using_etag);
3029   g_test_add_data_func ("/file/replace/write-only", GUINT_TO_POINTER (FALSE), test_replace);
3030   g_test_add_data_func ("/file/replace/read-write", GUINT_TO_POINTER (TRUE), test_replace);
3031   g_test_add_func ("/file/async-delete", test_async_delete);
3032   g_test_add_func ("/file/copy-preserve-mode", test_copy_preserve_mode);
3033   g_test_add_func ("/file/measure", test_measure);
3034   g_test_add_func ("/file/measure-async", test_measure_async);
3035   g_test_add_func ("/file/load-bytes", test_load_bytes);
3036   g_test_add_func ("/file/load-bytes-async", test_load_bytes_async);
3037   g_test_add_func ("/file/writev", test_writev);
3038   g_test_add_func ("/file/writev/no-bytes-written", test_writev_no_bytes_written);
3039   g_test_add_func ("/file/writev/no-vectors", test_writev_no_vectors);
3040   g_test_add_func ("/file/writev/empty-vectors", test_writev_empty_vectors);
3041   g_test_add_func ("/file/writev/too-big-vectors", test_writev_too_big_vectors);
3042   g_test_add_func ("/file/writev/async", test_writev_async);
3043   g_test_add_func ("/file/writev/async_all", test_writev_async_all);
3044   g_test_add_func ("/file/writev/async_all-empty-vectors", test_writev_async_all_empty_vectors);
3045   g_test_add_func ("/file/writev/async_all-no-vectors", test_writev_async_all_no_vectors);
3046   g_test_add_func ("/file/writev/async_all-to-big-vectors", test_writev_async_all_too_big_vectors);
3047   g_test_add_func ("/file/writev/async_all-cancellation", test_writev_async_all_cancellation);
3048   g_test_add_func ("/file/build-attribute-list-for-copy", test_build_attribute_list_for_copy);
3049
3050   return g_test_run ();
3051 }