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 (g_str_has_prefix (s, "file://"));
  22   g_assert (g_str_has_suffix (s, suffix));
  23   g_free (s);
  24
  25   g_assert (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 (g_file_has_parent (file, file2));
  68
  69   parent = g_file_get_parent (file);
  70   g_assert (g_file_equal (parent, file2));
  71   g_object_unref (parent);
  72
  73   g_assert (g_file_get_parent (root) == NULL);
  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 (g_file_has_parent (child, file));
  90
  91   child2 = g_file_get_child_for_display_name (file, "child2", NULL);
  92   g_assert (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_type (void)
 101 {
 102   GFile *datapath_f;
 103   GFile *file;
 104   GFileType type;
 105   GError *error = NULL;
 106
 107   datapath_f = g_file_new_for_path (g_test_get_dir (G_TEST_DIST));
 108
 109   file = g_file_get_child (datapath_f, "g-icon.c");
 110   type = g_file_query_file_type (file, 0, NULL);
 111   g_assert_cmpint (type, ==, G_FILE_TYPE_REGULAR);
 112   g_object_unref (file);
 113
 114   file = g_file_get_child (datapath_f, "cert-tests");
 115   type = g_file_query_file_type (file, 0, NULL);
 116   g_assert_cmpint (type, ==, G_FILE_TYPE_DIRECTORY);
 117
 118   g_file_read (file, NULL, &error);
 119   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
 120   g_error_free (error);
 121   g_object_unref (file);
 122
 123   g_object_unref (datapath_f);
 124 }
 125
 126 static void
 127 test_parse_name (void)
 128 {
 129   GFile *file;
 130   gchar *name;
 131
 132   file = g_file_new_for_uri ("file://somewhere");
 133   name = g_file_get_parse_name (file);
 134   g_assert_cmpstr (name, ==, "file://somewhere");
 135   g_object_unref (file);
 136   g_free (name);
 137
 138   file = g_file_parse_name ("~foo");
 139   name = g_file_get_parse_name (file);
 140   g_assert (name != NULL);
 141   g_object_unref (file);
 142   g_free (name);
 143 }
 144
 145 typedef struct
 146 {
 147   GFile *file;
 148   GFileMonitor *monitor;
 149   GOutputStream *ostream;
 150   GInputStream *istream;
 151   GMainLoop *loop;
 152   gint buffersize;
 153   gint monitor_created;
 154   gint monitor_deleted;
 155   gint monitor_changed;
 156   gchar *monitor_path;
 157   gint pos;
 158   const gchar *data;
 159   gchar *buffer;
 160   guint timeout;
 161 } CreateDeleteData;
 162
 163 static void
 164 monitor_changed (GFileMonitor      *monitor,
 165                  GFile             *file,
 166                  GFile             *other_file,
 167                  GFileMonitorEvent  event_type,
 168                  gpointer           user_data)
 169 {
 170   CreateDeleteData *data = user_data;
 171   gchar *path;
 172   const gchar *peeked_path;
 173
 174   path = g_file_get_path (file);
 175   peeked_path = g_file_peek_path (file);
 176   g_assert_cmpstr (data->monitor_path, ==, path);
 177   g_assert_cmpstr (path, ==, peeked_path);
 178   g_free (path);
 179
 180   if (event_type == G_FILE_MONITOR_EVENT_CREATED)
 181     data->monitor_created++;
 182   if (event_type == G_FILE_MONITOR_EVENT_DELETED)
 183     data->monitor_deleted++;
 184   if (event_type == G_FILE_MONITOR_EVENT_CHANGED)
 185     data->monitor_changed++;
 186 }
 187
 188
 189 static gboolean
 190 quit_idle (gpointer user_data)
 191 {
 192   CreateDeleteData *data = user_data;
 193
 194   g_source_remove (data->timeout);
 195   g_main_loop_quit (data->loop);
 196
 197   return FALSE;
 198 }
 199
 200 static void
 201 iclosed_cb (GObject      *source,
 202             GAsyncResult *res,
 203             gpointer      user_data)
 204 {
 205   CreateDeleteData *data = user_data;
 206   GError *error;
 207   gboolean ret;
 208
 209   error = NULL;
 210   ret = g_input_stream_close_finish (data->istream, res, &error);
 211   g_assert_no_error (error);
 212   g_assert (ret);
 213
 214   g_assert (g_input_stream_is_closed (data->istream));
 215
 216   ret = g_file_delete (data->file, NULL, &error);
 217   g_assert (ret);
 218   g_assert_no_error (error);
 219
 220   /* work around file monitor bug:
 221    * inotify events are only processed every 1000 ms, regardless
 222    * of the rate limit set on the file monitor
 223    */
 224   g_timeout_add (2000, quit_idle, data);
 225 }
 226
 227 static void
 228 read_cb (GObject      *source,
 229          GAsyncResult *res,
 230          gpointer      user_data)
 231 {
 232   CreateDeleteData *data = user_data;
 233   GError *error;
 234   gssize size;
 235
 236   error = NULL;
 237   size = g_input_stream_read_finish (data->istream, res, &error);
 238   g_assert_no_error (error);
 239
 240   data->pos += size;
 241   if (data->pos < strlen (data->data))
 242     {
 243       g_input_stream_read_async (data->istream,
 244                                  data->buffer + data->pos,
 245                                  strlen (data->data) - data->pos,
 246                                  0,
 247                                  NULL,
 248                                  read_cb,
 249                                  data);
 250     }
 251   else
 252     {
 253       g_assert_cmpstr (data->buffer, ==, data->data);
 254       g_assert (!g_input_stream_is_closed (data->istream));
 255       g_input_stream_close_async (data->istream, 0, NULL, iclosed_cb, data);
 256     }
 257 }
 258
 259 static void
 260 ipending_cb (GObject      *source,
 261              GAsyncResult *res,
 262              gpointer      user_data)
 263 {
 264   CreateDeleteData *data = user_data;
 265   GError *error;
 266
 267   error = NULL;
 268   g_input_stream_read_finish (data->istream, res, &error);
 269   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 270   g_error_free (error);
 271 }
 272
 273 static void
 274 skipped_cb (GObject      *source,
 275             GAsyncResult *res,
 276             gpointer      user_data)
 277 {
 278   CreateDeleteData *data = user_data;
 279   GError *error;
 280   gssize size;
 281
 282   error = NULL;
 283   size = g_input_stream_skip_finish (data->istream, res, &error);
 284   g_assert_no_error (error);
 285   g_assert_cmpint (size, ==, data->pos);
 286
 287   g_input_stream_read_async (data->istream,
 288                              data->buffer + data->pos,
 289                              strlen (data->data) - data->pos,
 290                              0,
 291                              NULL,
 292                              read_cb,
 293                              data);
 294   /* check that we get a pending error */
 295   g_input_stream_read_async (data->istream,
 296                              data->buffer + data->pos,
 297                              strlen (data->data) - data->pos,
 298                              0,
 299                              NULL,
 300                              ipending_cb,
 301                              data);
 302 }
 303
 304 static void
 305 opened_cb (GObject      *source,
 306            GAsyncResult *res,
 307            gpointer      user_data)
 308 {
 309   GFileInputStream *base;
 310   CreateDeleteData *data = user_data;
 311   GError *error;
 312
 313   error = NULL;
 314   base = g_file_read_finish (data->file, res, &error);
 315   g_assert_no_error (error);
 316
 317   if (data->buffersize == 0)
 318     data->istream = G_INPUT_STREAM (g_object_ref (base));
 319   else
 320     data->istream = g_buffered_input_stream_new_sized (G_INPUT_STREAM (base), data->buffersize);
 321   g_object_unref (base);
 322
 323   data->buffer = g_new0 (gchar, strlen (data->data) + 1);
 324
 325   /* copy initial segment directly, then skip */
 326   memcpy (data->buffer, data->data, 10);
 327   data->pos = 10;
 328
 329   g_input_stream_skip_async (data->istream,
 330                              10,
 331                              0,
 332                              NULL,
 333                              skipped_cb,
 334                              data);
 335 }
 336
 337 static void
 338 oclosed_cb (GObject      *source,
 339             GAsyncResult *res,
 340             gpointer      user_data)
 341 {
 342   CreateDeleteData *data = user_data;
 343   GError *error;
 344   gboolean ret;
 345
 346   error = NULL;
 347   ret = g_output_stream_close_finish (data->ostream, res, &error);
 348   g_assert_no_error (error);
 349   g_assert (ret);
 350   g_assert (g_output_stream_is_closed (data->ostream));
 351
 352   g_file_read_async (data->file, 0, NULL, opened_cb, data);
 353 }
 354
 355 static void
 356 written_cb (GObject      *source,
 357             GAsyncResult *res,
 358             gpointer      user_data)
 359 {
 360   CreateDeleteData *data = user_data;
 361   gssize size;
 362   GError *error;
 363
 364   error = NULL;
 365   size = g_output_stream_write_finish (data->ostream, res, &error);
 366   g_assert_no_error (error);
 367
 368   data->pos += size;
 369   if (data->pos < strlen (data->data))
 370     {
 371       g_output_stream_write_async (data->ostream,
 372                                    data->data + data->pos,
 373                                    strlen (data->data) - data->pos,
 374                                    0,
 375                                    NULL,
 376                                    written_cb,
 377                                    data);
 378     }
 379   else
 380     {
 381       g_assert (!g_output_stream_is_closed (data->ostream));
 382       g_output_stream_close_async (data->ostream, 0, NULL, oclosed_cb, data);
 383     }
 384 }
 385
 386 static void
 387 opending_cb (GObject      *source,
 388              GAsyncResult *res,
 389              gpointer      user_data)
 390 {
 391   CreateDeleteData *data = user_data;
 392   GError *error;
 393
 394   error = NULL;
 395   g_output_stream_write_finish (data->ostream, res, &error);
 396   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 397   g_error_free (error);
 398 }
 399
 400 static void
 401 created_cb (GObject      *source,
 402             GAsyncResult *res,
 403             gpointer      user_data)
 404 {
 405   GFileOutputStream *base;
 406   CreateDeleteData *data = user_data;
 407   GError *error;
 408
 409   error = NULL;
 410   base = g_file_create_finish (G_FILE (source), res, &error);
 411   g_assert_no_error (error);
 412   g_assert (g_file_query_exists  (data->file, NULL));
 413
 414   if (data->buffersize == 0)
 415     data->ostream = G_OUTPUT_STREAM (g_object_ref (base));
 416   else
 417     data->ostream = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM (base), data->buffersize);
 418   g_object_unref (base);
 419
 420   g_output_stream_write_async (data->ostream,
 421                                data->data,
 422                                strlen (data->data),
 423                                0,
 424                                NULL,
 425                                written_cb,
 426                                data);
 427   /* check that we get a pending error */
 428   g_output_stream_write_async (data->ostream,
 429                                data->data,
 430                                strlen (data->data),
 431                                0,
 432                                NULL,
 433                                opending_cb,
 434                                data);
 435 }
 436
 437 static gboolean
 438 stop_timeout (gpointer data)
 439 {
 440   g_assert_not_reached ();
 441
 442   return FALSE;
 443 }
 444
 445 /*
 446  * This test does a fully async create-write-read-delete.
 447  * Callbackistan.
 448  */
 449 static void
 450 test_create_delete (gconstpointer d)
 451 {
 452   GError *error;
 453   CreateDeleteData *data;
 454   GFileIOStream *iostream;
 455
 456   data = g_new0 (CreateDeleteData, 1);
 457
 458   data->buffersize = GPOINTER_TO_INT (d);
 459   data->data = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ0123456789";
 460   data->pos = 0;
 461
 462   data->file = g_file_new_tmp ("g_file_create_delete_XXXXXX",
 463                                &iostream, NULL);
 464   g_assert (data->file != NULL);
 465   g_object_unref (iostream);
 466
 467   data->monitor_path = g_file_get_path (data->file);
 468   remove (data->monitor_path);
 469
 470   g_assert (!g_file_query_exists  (data->file, NULL));
 471
 472   error = NULL;
 473   data->monitor = g_file_monitor_file (data->file, 0, NULL, &error);
 474   g_assert_no_error (error);
 475
 476   /* This test doesn't work with GPollFileMonitor, because it assumes
 477    * that the monitor will notice a create immediately followed by a
 478    * delete, rather than coalescing them into nothing.
 479    */
 480   /* This test also doesn't work with GKqueueFileMonitor because of
 481    * the same reason. Kqueue is able to return a kevent when a file is
 482    * created or deleted in a directory. However, the kernel doesn't tell
 483    * the program file names, so GKqueueFileMonitor has to calculate the
 484    * difference itself. This is usually too slow for rapid file creation
 485    * and deletion tests.
 486    */
 487   if (strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GPollFileMonitor") == 0 ||
 488       strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GKqueueFileMonitor") == 0)
 489     {
 490       g_test_skip ("skipping test for this GFileMonitor implementation");
 491       goto skip;
 492     }
 493
 494   g_file_monitor_set_rate_limit (data->monitor, 100);
 495
 496   g_signal_connect (data->monitor, "changed", G_CALLBACK (monitor_changed), data);
 497
 498   data->loop = g_main_loop_new (NULL, FALSE);
 499
 500   data->timeout = g_timeout_add (10000, stop_timeout, NULL);
 501
 502   g_file_create_async (data->file, 0, 0, NULL, created_cb, data);
 503
 504   g_main_loop_run (data->loop);
 505
 506   g_assert_cmpint (data->monitor_created, ==, 1);
 507   g_assert_cmpint (data->monitor_deleted, ==, 1);
 508   g_assert_cmpint (data->monitor_changed, >, 0);
 509
 510   g_assert (!g_file_monitor_is_cancelled (data->monitor));
 511   g_file_monitor_cancel (data->monitor);
 512   g_assert (g_file_monitor_is_cancelled (data->monitor));
 513
 514   g_main_loop_unref (data->loop);
 515   g_object_unref (data->ostream);
 516   g_object_unref (data->istream);
 517
 518  skip:
 519   g_object_unref (data->monitor);
 520   g_object_unref (data->file);
 521   g_free (data->monitor_path);
 522   g_free (data->buffer);
 523   g_free (data);
 524 }
 525
 526 static const gchar *original_data =
 527     "/**\n"
 528     " * g_file_replace_contents_async:\n"
 529     "**/\n";
 530
 531 static const gchar *replace_data =
 532     "/**\n"
 533     " * g_file_replace_contents_async:\n"
 534     " * @file: input #GFile.\n"
 535     " * @contents: string of contents to replace the file with.\n"
 536     " * @length: the length of @contents in bytes.\n"
 537     " * @etag: (nullable): a new <link linkend=\"gfile-etag\">entity tag</link> for the @file, or %NULL\n"
 538     " * @make_backup: %TRUE if a backup should be created.\n"
 539     " * @flags: a set of #GFileCreateFlags.\n"
 540     " * @cancellable: optional #GCancellable object, %NULL to ignore.\n"
 541     " * @callback: a #GAsyncReadyCallback to call when the request is satisfied\n"
 542     " * @user_data: the data to pass to callback function\n"
 543     " * \n"
 544     " * Starts an asynchronous replacement of @file with the given \n"
 545     " * @contents of @length bytes. @etag will replace the document's\n"
 546     " * current entity tag.\n"
 547     " * \n"
 548     " * When this operation has completed, @callback will be called with\n"
 549     " * @user_user data, and the operation can be finalized with \n"
 550     " * g_file_replace_contents_finish().\n"
 551     " * \n"
 552     " * If @cancellable is not %NULL, then the operation can be cancelled by\n"
 553     " * triggering the cancellable object from another thread. If the operation\n"
 554     " * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. \n"
 555     " * \n"
 556     " * If @make_backup is %TRUE, this function will attempt to \n"
 557     " * make a backup of @file.\n"
 558     " **/\n";
 559
 560 typedef struct
 561 {
 562   GFile *file;
 563   const gchar *data;
 564   GMainLoop *loop;
 565   gboolean again;
 566 } ReplaceLoadData;
 567
 568 static void replaced_cb (GObject      *source,
 569                          GAsyncResult *res,
 570                          gpointer      user_data);
 571
 572 static void
 573 loaded_cb (GObject      *source,
 574            GAsyncResult *res,
 575            gpointer      user_data)
 576 {
 577   ReplaceLoadData *data = user_data;
 578   gboolean ret;
 579   GError *error;
 580   gchar *contents;
 581   gsize length;
 582
 583   error = NULL;
 584   ret = g_file_load_contents_finish (data->file, res, &contents, &length, NULL, &error);
 585   g_assert (ret);
 586   g_assert_no_error (error);
 587   g_assert_cmpint (length, ==, strlen (data->data));
 588   g_assert_cmpstr (contents, ==, data->data);
 589
 590   g_free (contents);
 591
 592   if (data->again)
 593     {
 594       data->again = FALSE;
 595       data->data = "pi pa po";
 596
 597       g_file_replace_contents_async (data->file,
 598                                      data->data,
 599                                      strlen (data->data),
 600                                      NULL,
 601                                      FALSE,
 602                                      0,
 603                                      NULL,
 604                                      replaced_cb,
 605                                      data);
 606     }
 607   else
 608     {
 609        error = NULL;
 610        ret = g_file_delete (data->file, NULL, &error);
 611        g_assert_no_error (error);
 612        g_assert (ret);
 613        g_assert (!g_file_query_exists (data->file, NULL));
 614
 615        g_main_loop_quit (data->loop);
 616     }
 617 }
 618
 619 static void
 620 replaced_cb (GObject      *source,
 621              GAsyncResult *res,
 622              gpointer      user_data)
 623 {
 624   ReplaceLoadData *data = user_data;
 625   GError *error;
 626
 627   error = NULL;
 628   g_file_replace_contents_finish (data->file, res, NULL, &error);
 629   g_assert_no_error (error);
 630
 631   g_file_load_contents_async (data->file, NULL, loaded_cb, data);
 632 }
 633
 634 static void
 635 test_replace_load (void)
 636 {
 637   ReplaceLoadData *data;
 638   const gchar *path;
 639   GFileIOStream *iostream;
 640
 641   data = g_new0 (ReplaceLoadData, 1);
 642   data->again = TRUE;
 643   data->data = replace_data;
 644
 645   data->file = g_file_new_tmp ("g_file_replace_load_XXXXXX",
 646                                &iostream, NULL);
 647   g_assert (data->file != NULL);
 648   g_object_unref (iostream);
 649
 650   path = g_file_peek_path (data->file);
 651   remove (path);
 652
 653   g_assert (!g_file_query_exists (data->file, NULL));
 654
 655   data->loop = g_main_loop_new (NULL, FALSE);
 656
 657   g_file_replace_contents_async (data->file,
 658                                  data->data,
 659                                  strlen (data->data),
 660                                  NULL,
 661                                  FALSE,
 662                                  0,
 663                                  NULL,
 664                                  replaced_cb,
 665                                  data);
 666
 667   g_main_loop_run (data->loop);
 668
 669   g_main_loop_unref (data->loop);
 670   g_object_unref (data->file);
 671   g_free (data);
 672 }
 673
 674 static void
 675 test_replace_cancel (void)
 676 {
 677   GFile *tmpdir, *file;
 678   GFileOutputStream *ostream;
 679   GFileEnumerator *fenum;
 680   GFileInfo *info;
 681   GCancellable *cancellable;
 682   gchar *path;
 683   gchar *contents;
 684   gsize nwrote, length;
 685   guint count;
 686   GError *error = NULL;
 687
 688   g_test_bug ("629301");
 689
 690   path = g_dir_make_tmp ("g_file_replace_cancel_XXXXXX", &error);
 691   g_assert_no_error (error);
 692   tmpdir = g_file_new_for_path (path);
 693   g_free (path);
 694
 695   file = g_file_get_child (tmpdir, "file");
 696   g_file_replace_contents (file,
 697                            original_data,
 698                            strlen (original_data),
 699                            NULL, FALSE, 0, NULL,
 700                            NULL, &error);
 701   g_assert_no_error (error);
 702
 703   ostream = g_file_replace (file, NULL, TRUE, 0, NULL, &error);
 704   g_assert_no_error (error);
 705
 706   g_output_stream_write_all (G_OUTPUT_STREAM (ostream),
 707                              replace_data, strlen (replace_data),
 708                              &nwrote, NULL, &error);
 709   g_assert_no_error (error);
 710   g_assert_cmpint (nwrote, ==, strlen (replace_data));
 711
 712   /* At this point there should be two files; the original and the
 713    * temporary.
 714    */
 715   fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
 716   g_assert_no_error (error);
 717
 718   info = g_file_enumerator_next_file (fenum, NULL, &error);
 719   g_assert_no_error (error);
 720   g_assert (info != NULL);
 721   g_object_unref (info);
 722   info = g_file_enumerator_next_file (fenum, NULL, &error);
 723   g_assert_no_error (error);
 724   g_assert (info != NULL);
 725   g_object_unref (info);
 726
 727   g_file_enumerator_close (fenum, NULL, &error);
 728   g_assert_no_error (error);
 729   g_object_unref (fenum);
 730
 731   /* Also test the g_file_enumerator_iterate() API */
 732   fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
 733   g_assert_no_error (error);
 734   count = 0;
 735
 736   while (TRUE)
 737     {
 738       gboolean ret = g_file_enumerator_iterate (fenum, &info, NULL, NULL, &error);
 739       g_assert (ret);
 740       g_assert_no_error (error);
 741       if (!info)
 742         break;
 743       count++;
 744     }
 745   g_assert_cmpint (count, ==, 2);
 746
 747   g_file_enumerator_close (fenum, NULL, &error);
 748   g_assert_no_error (error);
 749   g_object_unref (fenum);
 750
 751   /* Now test just getting child from the g_file_enumerator_iterate() API */
 752   fenum = g_file_enumerate_children (tmpdir, "standard::name", 0, NULL, &error);
 753   g_assert_no_error (error);
 754   count = 0;
 755
 756   while (TRUE)
 757     {
 758       GFile *child;
 759       gboolean ret = g_file_enumerator_iterate (fenum, NULL, &child, NULL, &error);
 760
 761       g_assert (ret);
 762       g_assert_no_error (error);
 763
 764       if (!child)
 765         break;
 766
 767       g_assert (G_IS_FILE (child));
 768       count++;
 769     }
 770   g_assert_cmpint (count, ==, 2);
 771
 772   g_file_enumerator_close (fenum, NULL, &error);
 773   g_assert_no_error (error);
 774   g_object_unref (fenum);
 775
 776   /* Make sure the temporary gets deleted even if we cancel. */
 777   cancellable = g_cancellable_new ();
 778   g_cancellable_cancel (cancellable);
 779   g_output_stream_close (G_OUTPUT_STREAM (ostream), cancellable, &error);
 780   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
 781   g_clear_error (&error);
 782
 783   g_object_unref (cancellable);
 784   g_object_unref (ostream);
 785
 786   /* Make sure that file contents wasn't actually replaced. */
 787   g_file_load_contents (file,
 788                         NULL,
 789                         &contents,
 790                         &length,
 791                         NULL,
 792                         &error);
 793   g_assert_no_error (error);
 794   g_assert_cmpstr (contents, ==, original_data);
 795   g_free (contents);
 796
 797   g_file_delete (file, NULL, &error);
 798   g_assert_no_error (error);
 799   g_object_unref (file);
 800
 801   /* This will only succeed if the temp file was deleted. */
 802   g_file_delete (tmpdir, NULL, &error);
 803   g_assert_no_error (error);
 804   g_object_unref (tmpdir);
 805 }
 806
 807 static void
 808 on_file_deleted (GObject      *object,
 809                  GAsyncResult *result,
 810                  gpointer      user_data)
 811 {
 812   GError *local_error = NULL;
 813   GMainLoop *loop = user_data;
 814
 815   (void) g_file_delete_finish ((GFile*)object, result, &local_error);
 816   g_assert_no_error (local_error);
 817
 818   g_main_loop_quit (loop);
 819 }
 820
 821 static void
 822 test_async_delete (void)
 823 {
 824   GFile *file;
 825   GFileIOStream *iostream;
 826   GError *local_error = NULL;
 827   GError **error = &local_error;
 828   GMainLoop *loop;
 829
 830   file = g_file_new_tmp ("g_file_delete_XXXXXX",
 831                          &iostream, error);
 832   g_assert_no_error (local_error);
 833   g_object_unref (iostream);
 834
 835   g_assert (g_file_query_exists (file, NULL));
 836
 837   loop = g_main_loop_new (NULL, TRUE);
 838
 839   g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, on_file_deleted, loop);
 840
 841   g_main_loop_run (loop);
 842
 843   g_assert (!g_file_query_exists (file, NULL));
 844
 845   g_main_loop_unref (loop);
 846   g_object_unref (file);
 847 }
 848
 849 static void
 850 test_copy_preserve_mode (void)
 851 {
 852 #ifdef G_OS_UNIX
 853   mode_t current_umask = umask (0);
 854   const struct
 855     {
 856       guint32 source_mode;
 857       guint32 expected_destination_mode;
 858       gboolean create_destination_before_copy;
 859       GFileCopyFlags copy_flags;
 860     }
 861   vectors[] =
 862     {
 863       /* Overwriting the destination file should copy the permissions from the
 864        * source file, even if %G_FILE_COPY_ALL_METADATA is set: */
 865       { 0600, 0600, TRUE, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
 866       { 0600, 0600, TRUE, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS },
 867       /* The same behaviour should hold if the destination file is not being
 868        * overwritten because it doesn’t already exist: */
 869       { 0600, 0600, FALSE, G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
 870       { 0600, 0600, FALSE, G_FILE_COPY_NOFOLLOW_SYMLINKS },
 871       /* Anything with %G_FILE_COPY_TARGET_DEFAULT_PERMS should use the current
 872        * umask for the destination file: */
 873       { 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 },
 874       { 0600, 0666 & ~current_umask, TRUE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS },
 875       { 0600, 0666 & ~current_umask, FALSE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
 876       { 0600, 0666 & ~current_umask, FALSE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_NOFOLLOW_SYMLINKS },
 877     };
 878   gsize i;
 879
 880   /* Reset the umask after querying it above. There’s no way to query it without
 881    * changing it. */
 882   umask (current_umask);
 883   g_test_message ("Current umask: %u", current_umask);
 884
 885   for (i = 0; i < G_N_ELEMENTS (vectors); i++)
 886     {
 887       GFile *tmpfile;
 888       GFile *dest_tmpfile;
 889       GFileInfo *dest_info;
 890       GFileIOStream *iostream;
 891       GError *local_error = NULL;
 892       guint32 romode = vectors[i].source_mode;
 893       guint32 dest_mode;
 894
 895       g_test_message ("Vector %" G_GSIZE_FORMAT, i);
 896
 897       tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
 898                                 &iostream, &local_error);
 899       g_assert_no_error (local_error);
 900       g_io_stream_close ((GIOStream*)iostream, NULL, &local_error);
 901       g_assert_no_error (local_error);
 902       g_clear_object (&iostream);
 903
 904       g_file_set_attribute (tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_ATTRIBUTE_TYPE_UINT32,
 905                             &romode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 906                             NULL, &local_error);
 907       g_assert_no_error (local_error);
 908
 909       dest_tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
 910                                      &iostream, &local_error);
 911       g_assert_no_error (local_error);
 912       g_io_stream_close ((GIOStream*)iostream, NULL, &local_error);
 913       g_assert_no_error (local_error);
 914       g_clear_object (&iostream);
 915
 916       if (!vectors[i].create_destination_before_copy)
 917         {
 918           g_file_delete (dest_tmpfile, NULL, &local_error);
 919           g_assert_no_error (local_error);
 920         }
 921
 922       g_file_copy (tmpfile, dest_tmpfile, vectors[i].copy_flags,
 923                    NULL, NULL, NULL, &local_error);
 924       g_assert_no_error (local_error);
 925
 926       dest_info = g_file_query_info (dest_tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 927                                      NULL, &local_error);
 928       g_assert_no_error (local_error);
 929
 930       dest_mode = g_file_info_get_attribute_uint32 (dest_info, G_FILE_ATTRIBUTE_UNIX_MODE);
 931
 932       g_assert_cmpint (dest_mode & ~S_IFMT, ==, vectors[i].expected_destination_mode);
 933       g_assert_cmpint (dest_mode & S_IFMT, ==, S_IFREG);
 934
 935       (void) g_file_delete (tmpfile, NULL, NULL);
 936       (void) g_file_delete (dest_tmpfile, NULL, NULL);
 937
 938       g_clear_object (&tmpfile);
 939       g_clear_object (&dest_tmpfile);
 940       g_clear_object (&dest_info);
 941     }
 942 #else  /* if !G_OS_UNIX */
 943   g_test_skip ("File permissions tests can only be run on Unix")
 944 #endif
 945 }
 946
 947 static gchar *
 948 splice_to_string (GInputStream   *stream,
 949                   GError        **error)
 950 {
 951   GMemoryOutputStream *buffer = NULL;
 952   char *ret = NULL;
 953
 954   buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 955   if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
 956     goto out;
 957
 958   if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
 959     goto out;
 960
 961   if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
 962     goto out;
 963
 964   ret = g_memory_output_stream_steal_data (buffer);
 965  out:
 966   g_clear_object (&buffer);
 967   return ret;
 968 }
 969
 970 static gboolean
 971 get_size_from_du (const gchar *path, guint64 *size)
 972 {
 973   GSubprocess *du;
 974   gboolean ok;
 975   gchar *result;
 976   gchar *endptr;
 977   GError *error = NULL;
 978   gchar *du_path = NULL;
 979
 980   /* If we can’t find du, don’t try and run the test. */
 981   du_path = g_find_program_in_path ("du");
 982   if (du_path == NULL)
 983     return FALSE;
 984   g_free (du_path);
 985
 986   du = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE,
 987                          &error,
 988                          "du", "--bytes", "-s", path, NULL);
 989   g_assert_no_error (error);
 990
 991   result = splice_to_string (g_subprocess_get_stdout_pipe (du), &error);
 992   g_assert_no_error (error);
 993
 994   *size = g_ascii_strtoll (result, &endptr, 10);
 995
 996   g_subprocess_wait (du, NULL, &error);
 997   g_assert_no_error (error);
 998
 999   ok = g_subprocess_get_successful (du);
1000
1001   g_object_unref (du);
1002   g_free (result);
1003
1004   return ok;
1005 }
1006
1007 static void
1008 test_measure (void)
1009 {
1010   GFile *file;
1011   guint64 size;
1012   guint64 num_bytes;
1013   guint64 num_dirs;
1014   guint64 num_files;
1015   GError *error = NULL;
1016   gboolean ok;
1017   gchar *path;
1018
1019   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1020   file = g_file_new_for_path (path);
1021
1022   if (!get_size_from_du (path, &size))
1023     {
1024       g_test_message ("du not found or fail to run, skipping byte measurement");
1025       size = 0;
1026     }
1027
1028   ok = g_file_measure_disk_usage (file,
1029                                   G_FILE_MEASURE_APPARENT_SIZE,
1030                                   NULL,
1031                                   NULL,
1032                                   NULL,
1033                                   &num_bytes,
1034                                   &num_dirs,
1035                                   &num_files,
1036                                   &error);
1037   g_assert (ok);
1038   g_assert_no_error (error);
1039
1040   if (size > 0)
1041     g_assert_cmpuint (num_bytes, ==, size);
1042   g_assert_cmpuint (num_dirs, ==, 6);
1043   g_assert_cmpuint (num_files, ==, 31);
1044
1045   g_object_unref (file);
1046   g_free (path);
1047 }
1048
1049 typedef struct {
1050   guint64 expected_bytes;
1051   guint64 expected_dirs;
1052   guint64 expected_files;
1053   gint progress_count;
1054   guint64 progress_bytes;
1055   guint64 progress_dirs;
1056   guint64 progress_files;
1057 } MeasureData;
1058
1059 static void
1060 measure_progress (gboolean reporting,
1061                   guint64  current_size,
1062                   guint64  num_dirs,
1063                   guint64  num_files,
1064                   gpointer user_data)
1065 {
1066   MeasureData *data = user_data;
1067
1068   data->progress_count += 1;
1069
1070   g_assert_cmpuint (current_size, >=, data->progress_bytes);
1071   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1072   g_assert_cmpuint (num_files, >=, data->progress_files);
1073
1074   data->progress_bytes = current_size;
1075   data->progress_dirs = num_dirs;
1076   data->progress_files = num_files;
1077 }
1078
1079 static void
1080 measure_done (GObject      *source,
1081               GAsyncResult *res,
1082               gpointer      user_data)
1083 {
1084   MeasureData *data = user_data;
1085   guint64 num_bytes, num_dirs, num_files;
1086   GError *error = NULL;
1087   gboolean ok;
1088
1089   ok = g_file_measure_disk_usage_finish (G_FILE (source), res, &num_bytes, &num_dirs, &num_files, &error);
1090   g_assert (ok);
1091   g_assert_no_error (error);
1092
1093   if (data->expected_bytes > 0)
1094     g_assert_cmpuint (data->expected_bytes, ==, num_bytes);
1095   g_assert_cmpuint (data->expected_dirs, ==, num_dirs);
1096   g_assert_cmpuint (data->expected_files, ==, num_files);
1097
1098   g_assert_cmpuint (data->progress_count, >, 0);
1099   g_assert_cmpuint (num_bytes, >=, data->progress_bytes);
1100   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1101   g_assert_cmpuint (num_files, >=, data->progress_files);
1102
1103   g_free (data);
1104   g_object_unref (source);
1105 }
1106
1107 static void
1108 test_measure_async (void)
1109 {
1110   gchar *path;
1111   GFile *file;
1112   MeasureData *data;
1113
1114   data = g_new (MeasureData, 1);
1115
1116   data->progress_count = 0;
1117   data->progress_bytes = 0;
1118   data->progress_files = 0;
1119   data->progress_dirs = 0;
1120
1121   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1122   file = g_file_new_for_path (path);
1123
1124   if (!get_size_from_du (path, &data->expected_bytes))
1125     {
1126       g_test_message ("du not found or fail to run, skipping byte measurement");
1127       data->expected_bytes = 0;
1128     }
1129
1130   g_free (path);
1131
1132   data->expected_dirs = 6;
1133   data->expected_files = 31;
1134
1135   g_file_measure_disk_usage_async (file,
1136                                    G_FILE_MEASURE_APPARENT_SIZE,
1137                                    0, NULL,
1138                                    measure_progress, data,
1139                                    measure_done, data);
1140 }
1141
1142 static void
1143 test_load_bytes (void)
1144 {
1145   gchar filename[] = "g_file_load_bytes_XXXXXX";
1146   GError *error = NULL;
1147   GBytes *bytes;
1148   GFile *file;
1149   int len;
1150   int fd;
1151   int ret;
1152
1153   fd = g_mkstemp (filename);
1154   g_assert_cmpint (fd, !=, -1);
1155   len = strlen ("test_load_bytes");
1156   ret = write (fd, "test_load_bytes", len);
1157   g_assert_cmpint (ret, ==, len);
1158   close (fd);
1159
1160   file = g_file_new_for_path (filename);
1161   bytes = g_file_load_bytes (file, NULL, NULL, &error);
1162   g_assert_no_error (error);
1163   g_assert (bytes != NULL);
1164   g_assert_cmpint (len, ==, g_bytes_get_size (bytes));
1165   g_assert_cmpstr ("test_load_bytes", ==, (gchar *)g_bytes_get_data (bytes, NULL));
1166
1167   g_file_delete (file, NULL, NULL);
1168
1169   g_bytes_unref (bytes);
1170   g_object_unref (file);
1171 }
1172
1173 typedef struct
1174 {
1175   GMainLoop *main_loop;
1176   GFile *file;
1177   GBytes *bytes;
1178 } LoadBytesAsyncData;
1179
1180 static void
1181 test_load_bytes_cb (GObject      *object,
1182                     GAsyncResult *result,
1183                     gpointer      user_data)
1184 {
1185   GFile *file = G_FILE (object);
1186   LoadBytesAsyncData *data = user_data;
1187   GError *error = NULL;
1188
1189   data->bytes = g_file_load_bytes_finish (file, result, NULL, &error);
1190   g_assert_no_error (error);
1191   g_assert (data->bytes != NULL);
1192
1193   g_main_loop_quit (data->main_loop);
1194 }
1195
1196 static void
1197 test_load_bytes_async (void)
1198 {
1199   LoadBytesAsyncData data = { 0 };
1200   gchar filename[] = "g_file_load_bytes_XXXXXX";
1201   int len;
1202   int fd;
1203   int ret;
1204
1205   fd = g_mkstemp (filename);
1206   g_assert_cmpint (fd, !=, -1);
1207   len = strlen ("test_load_bytes_async");
1208   ret = write (fd, "test_load_bytes_async", len);
1209   g_assert_cmpint (ret, ==, len);
1210   close (fd);
1211
1212   data.main_loop = g_main_loop_new (NULL, FALSE);
1213   data.file = g_file_new_for_path (filename);
1214
1215   g_file_load_bytes_async (data.file, NULL, test_load_bytes_cb, &data);
1216   g_main_loop_run (data.main_loop);
1217
1218   g_assert_cmpint (len, ==, g_bytes_get_size (data.bytes));
1219   g_assert_cmpstr ("test_load_bytes_async", ==, (gchar *)g_bytes_get_data (data.bytes, NULL));
1220
1221   g_file_delete (data.file, NULL, NULL);
1222   g_object_unref (data.file);
1223   g_bytes_unref (data.bytes);
1224   g_main_loop_unref (data.main_loop);
1225 }
1226
1227 static void
1228 test_writev_helper (GOutputVector *vectors,
1229                     gsize          n_vectors,
1230                     gboolean       use_bytes_written,
1231                     const guint8  *expected_contents,
1232                     gsize          expected_length)
1233 {
1234   GFile *file;
1235   GFileIOStream *iostream = NULL;
1236   GOutputStream *ostream;
1237   GError *error = NULL;
1238   gsize bytes_written = 0;
1239   gboolean res;
1240   guint8 *contents;
1241   gsize length;
1242
1243   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1244                          &iostream, NULL);
1245   g_assert_nonnull (file);
1246   g_assert_nonnull (iostream);
1247
1248   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1249
1250   res = g_output_stream_writev_all (ostream, vectors, n_vectors, use_bytes_written ? &bytes_written : NULL, NULL, &error);
1251   g_assert_no_error (error);
1252   g_assert_true (res);
1253   if (use_bytes_written)
1254     g_assert_cmpuint (bytes_written, ==, expected_length);
1255
1256   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1257   g_assert_no_error (error);
1258   g_assert_true (res);
1259   g_object_unref (iostream);
1260
1261   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1262   g_assert_no_error (error);
1263   g_assert_true (res);
1264
1265   g_assert_cmpmem (contents, length, expected_contents, expected_length);
1266
1267   g_free (contents);
1268
1269   g_file_delete (file, NULL, NULL);
1270   g_object_unref (file);
1271 }
1272
1273 /* Test that writev() on local file output streams works on a non-empty vector */
1274 static void
1275 test_writev (void)
1276 {
1277   GOutputVector vectors[3];
1278   const guint8 buffer[] = {1, 2, 3, 4, 5,
1279                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1280                            1, 2, 3};
1281
1282   vectors[0].buffer = buffer;
1283   vectors[0].size = 5;
1284
1285   vectors[1].buffer = buffer + 5;
1286   vectors[1].size = 12;
1287
1288   vectors[2].buffer = buffer + 5 + 12;
1289   vectors[2].size = 3;
1290
1291   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, buffer, sizeof buffer);
1292 }
1293
1294 /* Test that writev() on local file output streams works on a non-empty vector without returning bytes_written */
1295 static void
1296 test_writev_no_bytes_written (void)
1297 {
1298   GOutputVector vectors[3];
1299   const guint8 buffer[] = {1, 2, 3, 4, 5,
1300                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1301                            1, 2, 3};
1302
1303   vectors[0].buffer = buffer;
1304   vectors[0].size = 5;
1305
1306   vectors[1].buffer = buffer + 5;
1307   vectors[1].size = 12;
1308
1309   vectors[2].buffer = buffer + 5 + 12;
1310   vectors[2].size = 3;
1311
1312   test_writev_helper (vectors, G_N_ELEMENTS (vectors), FALSE, buffer, sizeof buffer);
1313 }
1314
1315 /* Test that writev() on local file output streams works on 0 vectors */
1316 static void
1317 test_writev_no_vectors (void)
1318 {
1319   test_writev_helper (NULL, 0, TRUE, NULL, 0);
1320 }
1321
1322 /* Test that writev() on local file output streams works on empty vectors */
1323 static void
1324 test_writev_empty_vectors (void)
1325 {
1326   GOutputVector vectors[3];
1327
1328   vectors[0].buffer = NULL;
1329   vectors[0].size = 0;
1330   vectors[1].buffer = NULL;
1331   vectors[1].size = 0;
1332   vectors[2].buffer = NULL;
1333   vectors[2].size = 0;
1334
1335   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, NULL, 0);
1336 }
1337
1338 /* Test that writev() fails if the sum of sizes in the vector is too big */
1339 static void
1340 test_writev_too_big_vectors (void)
1341 {
1342   GFile *file;
1343   GFileIOStream *iostream = NULL;
1344   GOutputStream *ostream;
1345   GError *error = NULL;
1346   gsize bytes_written = 0;
1347   gboolean res;
1348   guint8 *contents;
1349   gsize length;
1350   GOutputVector vectors[3];
1351
1352   vectors[0].buffer = (void*) 1;
1353   vectors[0].size = G_MAXSIZE / 2;
1354
1355   vectors[1].buffer = (void*) 1;
1356   vectors[1].size = G_MAXSIZE / 2;
1357
1358   vectors[2].buffer = (void*) 1;
1359   vectors[2].size = G_MAXSIZE / 2;
1360
1361   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1362                          &iostream, NULL);
1363   g_assert_nonnull (file);
1364   g_assert_nonnull (iostream);
1365
1366   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1367
1368   res = g_output_stream_writev_all (ostream, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1369   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1370   g_assert_cmpuint (bytes_written, ==, 0);
1371   g_assert_false (res);
1372   g_clear_error (&error);
1373
1374   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1375   g_assert_no_error (error);
1376   g_assert_true (res);
1377   g_object_unref (iostream);
1378
1379   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1380   g_assert_no_error (error);
1381   g_assert_true (res);
1382
1383   g_assert_cmpmem (contents, length, NULL, 0);
1384
1385   g_free (contents);
1386
1387   g_file_delete (file, NULL, NULL);
1388   g_object_unref (file);
1389 }
1390
1391 typedef struct
1392 {
1393   gsize bytes_written;
1394   GOutputVector *vectors;
1395   gsize n_vectors;
1396   GError *error;
1397   gboolean done;
1398 } WritevAsyncData;
1399
1400 static void
1401 test_writev_async_cb (GObject      *object,
1402                       GAsyncResult *result,
1403                       gpointer      user_data)
1404 {
1405   GOutputStream *ostream = G_OUTPUT_STREAM (object);
1406   WritevAsyncData *data = user_data;
1407   GError *error = NULL;
1408   gsize bytes_written;
1409   gboolean res;
1410
1411   res = g_output_stream_writev_finish (ostream, result, &bytes_written, &error);
1412   g_assert_true (res);
1413   g_assert_no_error (error);
1414   data->bytes_written += bytes_written;
1415
1416   /* skip vectors that have been written in full */
1417   while (data->n_vectors > 0 && bytes_written >= data->vectors[0].size)
1418     {
1419       bytes_written -= data->vectors[0].size;
1420       ++data->vectors;
1421       --data->n_vectors;
1422     }
1423   /* skip partially written vector data */
1424   if (bytes_written > 0 && data->n_vectors > 0)
1425     {
1426       data->vectors[0].size -= bytes_written;
1427       data->vectors[0].buffer = ((guint8 *) data->vectors[0].buffer) + bytes_written;
1428     }
1429
1430   if (data->n_vectors > 0)
1431     g_output_stream_writev_async (ostream, data->vectors, data->n_vectors, 0, NULL, test_writev_async_cb, &data);
1432 }
1433
1434 /* Test that writev_async() on local file output streams works on a non-empty vector */
1435 static void
1436 test_writev_async (void)
1437 {
1438   WritevAsyncData data = { 0 };
1439   GFile *file;
1440   GFileIOStream *iostream = NULL;
1441   GOutputVector vectors[3];
1442   const guint8 buffer[] = {1, 2, 3, 4, 5,
1443                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1444                            1, 2, 3};
1445   GOutputStream *ostream;
1446   GError *error = NULL;
1447   gboolean res;
1448   guint8 *contents;
1449   gsize length;
1450
1451   vectors[0].buffer = buffer;
1452   vectors[0].size = 5;
1453
1454   vectors[1].buffer = buffer + 5;
1455   vectors[1].size = 12;
1456
1457   vectors[2].buffer = buffer + 5  + 12;
1458   vectors[2].size = 3;
1459
1460   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1461                          &iostream, NULL);
1462   g_assert_nonnull (file);
1463   g_assert_nonnull (iostream);
1464
1465   data.vectors = vectors;
1466   data.n_vectors = G_N_ELEMENTS (vectors);
1467
1468   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1469
1470   g_output_stream_writev_async (ostream, data.vectors, data.n_vectors, 0, NULL, test_writev_async_cb, &data);
1471
1472   while (data.n_vectors > 0)
1473     g_main_context_iteration (NULL, TRUE);
1474
1475   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1476
1477   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1478   g_assert_no_error (error);
1479   g_assert_true (res);
1480   g_object_unref (iostream);
1481
1482   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1483   g_assert_no_error (error);
1484   g_assert_true (res);
1485
1486   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1487
1488   g_free (contents);
1489
1490   g_file_delete (file, NULL, NULL);
1491   g_object_unref (file);
1492 }
1493
1494 static void
1495 test_writev_all_cb (GObject      *object,
1496                     GAsyncResult *result,
1497                     gpointer      user_data)
1498 {
1499   GOutputStream *ostream = G_OUTPUT_STREAM (object);
1500   WritevAsyncData *data = user_data;
1501
1502   g_output_stream_writev_all_finish (ostream, result, &data->bytes_written, &data->error);
1503   data->done = TRUE;
1504 }
1505
1506 /* Test that writev_async_all() on local file output streams works on a non-empty vector */
1507 static void
1508 test_writev_async_all (void)
1509 {
1510   WritevAsyncData data = { 0 };
1511   GFile *file;
1512   GFileIOStream *iostream = NULL;
1513   GOutputStream *ostream;
1514   GOutputVector vectors[3];
1515   const guint8 buffer[] = {1, 2, 3, 4, 5,
1516                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1517                            1, 2, 3};
1518   GError *error = NULL;
1519   gboolean res;
1520   guint8 *contents;
1521   gsize length;
1522
1523   vectors[0].buffer = buffer;
1524   vectors[0].size = 5;
1525
1526   vectors[1].buffer = buffer + 5;
1527   vectors[1].size = 12;
1528
1529   vectors[2].buffer = buffer + 5  + 12;
1530   vectors[2].size = 3;
1531
1532   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1533                          &iostream, NULL);
1534   g_assert_nonnull (file);
1535   g_assert_nonnull (iostream);
1536
1537   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1538
1539   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1540
1541   while (!data.done)
1542     g_main_context_iteration (NULL, TRUE);
1543
1544   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1545   g_assert_no_error (data.error);
1546
1547   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1548   g_assert_no_error (error);
1549   g_assert_true (res);
1550   g_object_unref (iostream);
1551
1552   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1553   g_assert_no_error (error);
1554   g_assert_true (res);
1555
1556   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1557
1558   g_free (contents);
1559
1560   g_file_delete (file, NULL, NULL);
1561   g_object_unref (file);
1562 }
1563
1564 /* Test that writev_async_all() on local file output streams handles cancellation correctly */
1565 static void
1566 test_writev_async_all_cancellation (void)
1567 {
1568   WritevAsyncData data = { 0 };
1569   GFile *file;
1570   GFileIOStream *iostream = NULL;
1571   GOutputVector vectors[3];
1572   const guint8 buffer[] = {1, 2, 3, 4, 5,
1573                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1574                            1, 2, 3};
1575   GOutputStream *ostream;
1576   GError *error = NULL;
1577   gboolean res;
1578   guint8 *contents;
1579   gsize length;
1580   GCancellable *cancellable;
1581
1582   vectors[0].buffer = buffer;
1583   vectors[0].size = 5;
1584
1585   vectors[1].buffer = buffer + 5;
1586   vectors[1].size = 12;
1587
1588   vectors[2].buffer = buffer + 5  + 12;
1589   vectors[2].size = 3;
1590
1591   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1592                          &iostream, NULL);
1593   g_assert_nonnull (file);
1594   g_assert_nonnull (iostream);
1595
1596   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1597
1598   cancellable = g_cancellable_new ();
1599   g_cancellable_cancel (cancellable);
1600
1601   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, cancellable, test_writev_all_cb, &data);
1602
1603   while (!data.done)
1604     g_main_context_iteration (NULL, TRUE);
1605
1606   g_assert_cmpuint (data.bytes_written, ==, 0);
1607   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1608   g_clear_error (&data.error);
1609
1610   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1611   g_assert_no_error (error);
1612   g_assert_true (res);
1613   g_object_unref (iostream);
1614
1615   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1616   g_assert_no_error (error);
1617   g_assert_true (res);
1618   g_assert_cmpuint (length, ==, 0);
1619
1620   g_free (contents);
1621
1622   g_file_delete (file, NULL, NULL);
1623   g_object_unref (file);
1624   g_object_unref (cancellable);
1625 }
1626
1627 /* Test that writev_async_all() with empty vectors is handled correctly */
1628 static void
1629 test_writev_async_all_empty_vectors (void)
1630 {
1631   WritevAsyncData data = { 0 };
1632   GFile *file;
1633   GFileIOStream *iostream = NULL;
1634   GOutputVector vectors[3];
1635   GOutputStream *ostream;
1636   GError *error = NULL;
1637   gboolean res;
1638   guint8 *contents;
1639   gsize length;
1640
1641   vectors[0].buffer = NULL;
1642   vectors[0].size = 0;
1643
1644   vectors[1].buffer = NULL;
1645   vectors[1].size = 0;
1646
1647   vectors[2].buffer = NULL;
1648   vectors[2].size = 0;
1649
1650   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1651                          &iostream, NULL);
1652   g_assert_nonnull (file);
1653   g_assert_nonnull (iostream);
1654
1655   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1656
1657   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1658
1659   while (!data.done)
1660     g_main_context_iteration (NULL, TRUE);
1661
1662   g_assert_cmpuint (data.bytes_written, ==, 0);
1663   g_assert_no_error (data.error);
1664   g_clear_error (&data.error);
1665
1666   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1667   g_assert_no_error (error);
1668   g_assert_true (res);
1669   g_object_unref (iostream);
1670
1671   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1672   g_assert_no_error (error);
1673   g_assert_true (res);
1674   g_assert_cmpuint (length, ==, 0);
1675
1676   g_free (contents);
1677
1678   g_file_delete (file, NULL, NULL);
1679   g_object_unref (file);
1680 }
1681
1682 /* Test that writev_async_all() with no vectors is handled correctly */
1683 static void
1684 test_writev_async_all_no_vectors (void)
1685 {
1686   WritevAsyncData data = { 0 };
1687   GFile *file;
1688   GFileIOStream *iostream = NULL;
1689   GOutputStream *ostream;
1690   GError *error = NULL;
1691   gboolean res;
1692   guint8 *contents;
1693   gsize length;
1694
1695   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1696                          &iostream, NULL);
1697   g_assert_nonnull (file);
1698   g_assert_nonnull (iostream);
1699
1700   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1701
1702   g_output_stream_writev_all_async (ostream, NULL, 0, 0, NULL, test_writev_all_cb, &data);
1703
1704   while (!data.done)
1705     g_main_context_iteration (NULL, TRUE);
1706
1707   g_assert_cmpuint (data.bytes_written, ==, 0);
1708   g_assert_no_error (data.error);
1709   g_clear_error (&data.error);
1710
1711   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1712   g_assert_no_error (error);
1713   g_assert_true (res);
1714   g_object_unref (iostream);
1715
1716   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1717   g_assert_no_error (error);
1718   g_assert_true (res);
1719   g_assert_cmpuint (length, ==, 0);
1720
1721   g_free (contents);
1722
1723   g_file_delete (file, NULL, NULL);
1724   g_object_unref (file);
1725 }
1726
1727 /* Test that writev_async_all() with too big vectors is handled correctly */
1728 static void
1729 test_writev_async_all_too_big_vectors (void)
1730 {
1731   WritevAsyncData data = { 0 };
1732   GFile *file;
1733   GFileIOStream *iostream = NULL;
1734   GOutputVector vectors[3];
1735   GOutputStream *ostream;
1736   GError *error = NULL;
1737   gboolean res;
1738   guint8 *contents;
1739   gsize length;
1740
1741   vectors[0].buffer = (void*) 1;
1742   vectors[0].size = G_MAXSIZE / 2;
1743
1744   vectors[1].buffer = (void*) 1;
1745   vectors[1].size = G_MAXSIZE / 2;
1746
1747   vectors[2].buffer = (void*) 1;
1748   vectors[2].size = G_MAXSIZE / 2;
1749
1750   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1751                          &iostream, NULL);
1752   g_assert_nonnull (file);
1753   g_assert_nonnull (iostream);
1754
1755   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1756
1757   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1758
1759   while (!data.done)
1760     g_main_context_iteration (NULL, TRUE);
1761
1762   g_assert_cmpuint (data.bytes_written, ==, 0);
1763   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1764   g_clear_error (&data.error);
1765
1766   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1767   g_assert_no_error (error);
1768   g_assert_true (res);
1769   g_object_unref (iostream);
1770
1771   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1772   g_assert_no_error (error);
1773   g_assert_true (res);
1774   g_assert_cmpuint (length, ==, 0);
1775
1776   g_free (contents);
1777
1778   g_file_delete (file, NULL, NULL);
1779   g_object_unref (file);
1780 }
1781
1782 int
1783 main (int argc, char *argv[])
1784 {
1785   g_test_init (&argc, &argv, NULL);
1786
1787   g_test_bug_base ("http://bugzilla.gnome.org/");
1788
1789   g_test_add_func ("/file/basic", test_basic);
1790   g_test_add_func ("/file/build-filename", test_build_filename);
1791   g_test_add_func ("/file/parent", test_parent);
1792   g_test_add_func ("/file/child", test_child);
1793   g_test_add_func ("/file/type", test_type);
1794   g_test_add_func ("/file/parse-name", test_parse_name);
1795   g_test_add_data_func ("/file/async-create-delete/0", GINT_TO_POINTER (0), test_create_delete);
1796   g_test_add_data_func ("/file/async-create-delete/1", GINT_TO_POINTER (1), test_create_delete);
1797   g_test_add_data_func ("/file/async-create-delete/10", GINT_TO_POINTER (10), test_create_delete);
1798   g_test_add_data_func ("/file/async-create-delete/25", GINT_TO_POINTER (25), test_create_delete);
1799   g_test_add_data_func ("/file/async-create-delete/4096", GINT_TO_POINTER (4096), test_create_delete);
1800   g_test_add_func ("/file/replace-load", test_replace_load);
1801   g_test_add_func ("/file/replace-cancel", test_replace_cancel);
1802   g_test_add_func ("/file/async-delete", test_async_delete);
1803   g_test_add_func ("/file/copy-preserve-mode", test_copy_preserve_mode);
1804   g_test_add_func ("/file/measure", test_measure);
1805   g_test_add_func ("/file/measure-async", test_measure_async);
1806   g_test_add_func ("/file/load-bytes", test_load_bytes);
1807   g_test_add_func ("/file/load-bytes-async", test_load_bytes_async);
1808   g_test_add_func ("/file/writev", test_writev);
1809   g_test_add_func ("/file/writev/no-bytes-written", test_writev_no_bytes_written);
1810   g_test_add_func ("/file/writev/no-vectors", test_writev_no_vectors);
1811   g_test_add_func ("/file/writev/empty-vectors", test_writev_empty_vectors);
1812   g_test_add_func ("/file/writev/too-big-vectors", test_writev_too_big_vectors);
1813   g_test_add_func ("/file/writev/async", test_writev_async);
1814   g_test_add_func ("/file/writev/async_all", test_writev_async_all);
1815   g_test_add_func ("/file/writev/async_all-empty-vectors", test_writev_async_all_empty_vectors);
1816   g_test_add_func ("/file/writev/async_all-no-vectors", test_writev_async_all_no_vectors);
1817   g_test_add_func ("/file/writev/async_all-to-big-vectors", test_writev_async_all_too_big_vectors);
1818   g_test_add_func ("/file/writev/async_all-cancellation", test_writev_async_all_cancellation);
1819
1820   return g_test_run ();
1821 }