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 #ifdef G_OS_UNIX
 850 static void
 851 test_copy_preserve_mode (void)
 852 {
 853   GFile *tmpfile;
 854   GFile *dest_tmpfile;
 855   GFileInfo *dest_info;
 856   GFileIOStream *iostream;
 857   GError *local_error = NULL;
 858   GError **error = &local_error;
 859   guint32 romode = S_IFREG | 0600;
 860   guint32 dest_mode;
 861
 862   tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
 863                             &iostream, error);
 864   g_assert_no_error (local_error);
 865   g_io_stream_close ((GIOStream*)iostream, NULL, error);
 866   g_assert_no_error (local_error);
 867   g_clear_object (&iostream);
 868
 869   g_file_set_attribute (tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_ATTRIBUTE_TYPE_UINT32,
 870                         &romode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 871                         NULL, error);
 872   g_assert_no_error (local_error);
 873
 874   dest_tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
 875                                  &iostream, error);
 876   g_assert_no_error (local_error);
 877   g_io_stream_close ((GIOStream*)iostream, NULL, error);
 878   g_assert_no_error (local_error);
 879   g_clear_object (&iostream);
 880
 881   g_file_copy (tmpfile, dest_tmpfile, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA,
 882                NULL, NULL, NULL, error);
 883   g_assert_no_error (local_error);
 884
 885   dest_info = g_file_query_info (dest_tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 886                                  NULL, error);
 887   g_assert_no_error (local_error);
 888
 889   dest_mode = g_file_info_get_attribute_uint32 (dest_info, G_FILE_ATTRIBUTE_UNIX_MODE);
 890
 891   g_assert_cmpint (dest_mode, ==, romode);
 892
 893   (void) g_file_delete (tmpfile, NULL, NULL);
 894   (void) g_file_delete (dest_tmpfile, NULL, NULL);
 895
 896   g_clear_object (&tmpfile);
 897   g_clear_object (&dest_tmpfile);
 898   g_clear_object (&dest_info);
 899 }
 900 #endif
 901
 902 static gchar *
 903 splice_to_string (GInputStream   *stream,
 904                   GError        **error)
 905 {
 906   GMemoryOutputStream *buffer = NULL;
 907   char *ret = NULL;
 908
 909   buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 910   if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
 911     goto out;
 912
 913   if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
 914     goto out;
 915
 916   if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
 917     goto out;
 918
 919   ret = g_memory_output_stream_steal_data (buffer);
 920  out:
 921   g_clear_object (&buffer);
 922   return ret;
 923 }
 924
 925 static gboolean
 926 get_size_from_du (const gchar *path, guint64 *size)
 927 {
 928   GSubprocess *du;
 929   gboolean ok;
 930   gchar *result;
 931   gchar *endptr;
 932   GError *error = NULL;
 933   gchar *du_path = NULL;
 934
 935   /* If we can’t find du, don’t try and run the test. */
 936   du_path = g_find_program_in_path ("du");
 937   if (du_path == NULL)
 938     return FALSE;
 939   g_free (du_path);
 940
 941   du = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE,
 942                          &error,
 943                          "du", "--bytes", "-s", path, NULL);
 944   g_assert_no_error (error);
 945
 946   result = splice_to_string (g_subprocess_get_stdout_pipe (du), &error);
 947   g_assert_no_error (error);
 948
 949   *size = g_ascii_strtoll (result, &endptr, 10);
 950
 951   g_subprocess_wait (du, NULL, &error);
 952   g_assert_no_error (error);
 953
 954   ok = g_subprocess_get_successful (du);
 955
 956   g_object_unref (du);
 957   g_free (result);
 958
 959   return ok;
 960 }
 961
 962 static void
 963 test_measure (void)
 964 {
 965   GFile *file;
 966   guint64 size;
 967   guint64 num_bytes;
 968   guint64 num_dirs;
 969   guint64 num_files;
 970   GError *error = NULL;
 971   gboolean ok;
 972   gchar *path;
 973
 974   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
 975   file = g_file_new_for_path (path);
 976
 977   if (!get_size_from_du (path, &size))
 978     {
 979       g_test_message ("du not found or fail to run, skipping byte measurement");
 980       size = 0;
 981     }
 982
 983   ok = g_file_measure_disk_usage (file,
 984                                   G_FILE_MEASURE_APPARENT_SIZE,
 985                                   NULL,
 986                                   NULL,
 987                                   NULL,
 988                                   &num_bytes,
 989                                   &num_dirs,
 990                                   &num_files,
 991                                   &error);
 992   g_assert (ok);
 993   g_assert_no_error (error);
 994
 995   if (size > 0)
 996     g_assert_cmpuint (num_bytes, ==, size);
 997   g_assert_cmpuint (num_dirs, ==, 6);
 998   g_assert_cmpuint (num_files, ==, 31);
 999
1000   g_object_unref (file);
1001   g_free (path);
1002 }
1003
1004 typedef struct {
1005   guint64 expected_bytes;
1006   guint64 expected_dirs;
1007   guint64 expected_files;
1008   gint progress_count;
1009   guint64 progress_bytes;
1010   guint64 progress_dirs;
1011   guint64 progress_files;
1012 } MeasureData;
1013
1014 static void
1015 measure_progress (gboolean reporting,
1016                   guint64  current_size,
1017                   guint64  num_dirs,
1018                   guint64  num_files,
1019                   gpointer user_data)
1020 {
1021   MeasureData *data = user_data;
1022
1023   data->progress_count += 1;
1024
1025   g_assert_cmpuint (current_size, >=, data->progress_bytes);
1026   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1027   g_assert_cmpuint (num_files, >=, data->progress_files);
1028
1029   data->progress_bytes = current_size;
1030   data->progress_dirs = num_dirs;
1031   data->progress_files = num_files;
1032 }
1033
1034 static void
1035 measure_done (GObject      *source,
1036               GAsyncResult *res,
1037               gpointer      user_data)
1038 {
1039   MeasureData *data = user_data;
1040   guint64 num_bytes, num_dirs, num_files;
1041   GError *error = NULL;
1042   gboolean ok;
1043
1044   ok = g_file_measure_disk_usage_finish (G_FILE (source), res, &num_bytes, &num_dirs, &num_files, &error);
1045   g_assert (ok);
1046   g_assert_no_error (error);
1047
1048   if (data->expected_bytes > 0)
1049     g_assert_cmpuint (data->expected_bytes, ==, num_bytes);
1050   g_assert_cmpuint (data->expected_dirs, ==, num_dirs);
1051   g_assert_cmpuint (data->expected_files, ==, num_files);
1052
1053   g_assert_cmpuint (data->progress_count, >, 0);
1054   g_assert_cmpuint (num_bytes, >=, data->progress_bytes);
1055   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1056   g_assert_cmpuint (num_files, >=, data->progress_files);
1057
1058   g_free (data);
1059   g_object_unref (source);
1060 }
1061
1062 static void
1063 test_measure_async (void)
1064 {
1065   gchar *path;
1066   GFile *file;
1067   MeasureData *data;
1068
1069   data = g_new (MeasureData, 1);
1070
1071   data->progress_count = 0;
1072   data->progress_bytes = 0;
1073   data->progress_files = 0;
1074   data->progress_dirs = 0;
1075
1076   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1077   file = g_file_new_for_path (path);
1078
1079   if (!get_size_from_du (path, &data->expected_bytes))
1080     {
1081       g_test_message ("du not found or fail to run, skipping byte measurement");
1082       data->expected_bytes = 0;
1083     }
1084
1085   g_free (path);
1086
1087   data->expected_dirs = 6;
1088   data->expected_files = 31;
1089
1090   g_file_measure_disk_usage_async (file,
1091                                    G_FILE_MEASURE_APPARENT_SIZE,
1092                                    0, NULL,
1093                                    measure_progress, data,
1094                                    measure_done, data);
1095 }
1096
1097 static void
1098 test_load_bytes (void)
1099 {
1100   gchar filename[] = "g_file_load_bytes_XXXXXX";
1101   GError *error = NULL;
1102   GBytes *bytes;
1103   GFile *file;
1104   int len;
1105   int fd;
1106   int ret;
1107
1108   fd = g_mkstemp (filename);
1109   g_assert_cmpint (fd, !=, -1);
1110   len = strlen ("test_load_bytes");
1111   ret = write (fd, "test_load_bytes", len);
1112   g_assert_cmpint (ret, ==, len);
1113   close (fd);
1114
1115   file = g_file_new_for_path (filename);
1116   bytes = g_file_load_bytes (file, NULL, NULL, &error);
1117   g_assert_no_error (error);
1118   g_assert (bytes != NULL);
1119   g_assert_cmpint (len, ==, g_bytes_get_size (bytes));
1120   g_assert_cmpstr ("test_load_bytes", ==, (gchar *)g_bytes_get_data (bytes, NULL));
1121
1122   g_file_delete (file, NULL, NULL);
1123
1124   g_bytes_unref (bytes);
1125   g_object_unref (file);
1126 }
1127
1128 typedef struct
1129 {
1130   GMainLoop *main_loop;
1131   GFile *file;
1132   GBytes *bytes;
1133 } LoadBytesAsyncData;
1134
1135 static void
1136 test_load_bytes_cb (GObject      *object,
1137                     GAsyncResult *result,
1138                     gpointer      user_data)
1139 {
1140   GFile *file = G_FILE (object);
1141   LoadBytesAsyncData *data = user_data;
1142   GError *error = NULL;
1143
1144   data->bytes = g_file_load_bytes_finish (file, result, NULL, &error);
1145   g_assert_no_error (error);
1146   g_assert (data->bytes != NULL);
1147
1148   g_main_loop_quit (data->main_loop);
1149 }
1150
1151 static void
1152 test_load_bytes_async (void)
1153 {
1154   LoadBytesAsyncData data = { 0 };
1155   gchar filename[] = "g_file_load_bytes_XXXXXX";
1156   int len;
1157   int fd;
1158   int ret;
1159
1160   fd = g_mkstemp (filename);
1161   g_assert_cmpint (fd, !=, -1);
1162   len = strlen ("test_load_bytes_async");
1163   ret = write (fd, "test_load_bytes_async", len);
1164   g_assert_cmpint (ret, ==, len);
1165   close (fd);
1166
1167   data.main_loop = g_main_loop_new (NULL, FALSE);
1168   data.file = g_file_new_for_path (filename);
1169
1170   g_file_load_bytes_async (data.file, NULL, test_load_bytes_cb, &data);
1171   g_main_loop_run (data.main_loop);
1172
1173   g_assert_cmpint (len, ==, g_bytes_get_size (data.bytes));
1174   g_assert_cmpstr ("test_load_bytes_async", ==, (gchar *)g_bytes_get_data (data.bytes, NULL));
1175
1176   g_file_delete (data.file, NULL, NULL);
1177   g_object_unref (data.file);
1178   g_bytes_unref (data.bytes);
1179   g_main_loop_unref (data.main_loop);
1180 }
1181
1182 static void
1183 test_writev_helper (GOutputVector *vectors,
1184                     gsize          n_vectors,
1185                     gboolean       use_bytes_written,
1186                     const guint8  *expected_contents,
1187                     gsize          expected_length)
1188 {
1189   GFile *file;
1190   GFileIOStream *iostream = NULL;
1191   GOutputStream *ostream;
1192   GError *error = NULL;
1193   gsize bytes_written = 0;
1194   gboolean res;
1195   guint8 *contents;
1196   gsize length;
1197
1198   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1199                          &iostream, NULL);
1200   g_assert_nonnull (file);
1201   g_assert_nonnull (iostream);
1202
1203   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1204
1205   res = g_output_stream_writev_all (ostream, vectors, n_vectors, use_bytes_written ? &bytes_written : NULL, NULL, &error);
1206   g_assert_no_error (error);
1207   g_assert_true (res);
1208   if (use_bytes_written)
1209     g_assert_cmpuint (bytes_written, ==, expected_length);
1210
1211   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1212   g_assert_no_error (error);
1213   g_assert_true (res);
1214   g_object_unref (iostream);
1215
1216   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1217   g_assert_no_error (error);
1218   g_assert_true (res);
1219
1220   g_assert_cmpmem (contents, length, expected_contents, expected_length);
1221
1222   g_free (contents);
1223
1224   g_file_delete (file, NULL, NULL);
1225   g_object_unref (file);
1226 }
1227
1228 /* Test that writev() on local file output streams works on a non-empty vector */
1229 static void
1230 test_writev (void)
1231 {
1232   GOutputVector vectors[3];
1233   const guint8 buffer[] = {1, 2, 3, 4, 5,
1234                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1235                            1, 2, 3};
1236
1237   vectors[0].buffer = buffer;
1238   vectors[0].size = 5;
1239
1240   vectors[1].buffer = buffer + 5;
1241   vectors[1].size = 12;
1242
1243   vectors[2].buffer = buffer + 5 + 12;
1244   vectors[2].size = 3;
1245
1246   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, buffer, sizeof buffer);
1247 }
1248
1249 /* Test that writev() on local file output streams works on a non-empty vector without returning bytes_written */
1250 static void
1251 test_writev_no_bytes_written (void)
1252 {
1253   GOutputVector vectors[3];
1254   const guint8 buffer[] = {1, 2, 3, 4, 5,
1255                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1256                            1, 2, 3};
1257
1258   vectors[0].buffer = buffer;
1259   vectors[0].size = 5;
1260
1261   vectors[1].buffer = buffer + 5;
1262   vectors[1].size = 12;
1263
1264   vectors[2].buffer = buffer + 5 + 12;
1265   vectors[2].size = 3;
1266
1267   test_writev_helper (vectors, G_N_ELEMENTS (vectors), FALSE, buffer, sizeof buffer);
1268 }
1269
1270 /* Test that writev() on local file output streams works on 0 vectors */
1271 static void
1272 test_writev_no_vectors (void)
1273 {
1274   test_writev_helper (NULL, 0, TRUE, NULL, 0);
1275 }
1276
1277 /* Test that writev() on local file output streams works on empty vectors */
1278 static void
1279 test_writev_empty_vectors (void)
1280 {
1281   GOutputVector vectors[3];
1282
1283   vectors[0].buffer = NULL;
1284   vectors[0].size = 0;
1285   vectors[1].buffer = NULL;
1286   vectors[1].size = 0;
1287   vectors[2].buffer = NULL;
1288   vectors[2].size = 0;
1289
1290   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, NULL, 0);
1291 }
1292
1293 /* Test that writev() fails if the sum of sizes in the vector is too big */
1294 static void
1295 test_writev_too_big_vectors (void)
1296 {
1297   GFile *file;
1298   GFileIOStream *iostream = NULL;
1299   GOutputStream *ostream;
1300   GError *error = NULL;
1301   gsize bytes_written = 0;
1302   gboolean res;
1303   guint8 *contents;
1304   gsize length;
1305   GOutputVector vectors[3];
1306
1307   vectors[0].buffer = (void*) 1;
1308   vectors[0].size = G_MAXSIZE / 2;
1309
1310   vectors[1].buffer = (void*) 1;
1311   vectors[1].size = G_MAXSIZE / 2;
1312
1313   vectors[2].buffer = (void*) 1;
1314   vectors[2].size = G_MAXSIZE / 2;
1315
1316   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1317                          &iostream, NULL);
1318   g_assert_nonnull (file);
1319   g_assert_nonnull (iostream);
1320
1321   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1322
1323   res = g_output_stream_writev_all (ostream, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1324   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1325   g_assert_cmpuint (bytes_written, ==, 0);
1326   g_assert_false (res);
1327   g_clear_error (&error);
1328
1329   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1330   g_assert_no_error (error);
1331   g_assert_true (res);
1332   g_object_unref (iostream);
1333
1334   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1335   g_assert_no_error (error);
1336   g_assert_true (res);
1337
1338   g_assert_cmpmem (contents, length, NULL, 0);
1339
1340   g_free (contents);
1341
1342   g_file_delete (file, NULL, NULL);
1343   g_object_unref (file);
1344 }
1345
1346 typedef struct
1347 {
1348   gsize bytes_written;
1349   GOutputVector *vectors;
1350   gsize n_vectors;
1351   GError *error;
1352   gboolean done;
1353 } WritevAsyncData;
1354
1355 static void
1356 test_writev_async_cb (GObject      *object,
1357                       GAsyncResult *result,
1358                       gpointer      user_data)
1359 {
1360   GOutputStream *ostream = G_OUTPUT_STREAM (object);
1361   WritevAsyncData *data = user_data;
1362   GError *error = NULL;
1363   gsize bytes_written;
1364   gboolean res;
1365
1366   res = g_output_stream_writev_finish (ostream, result, &bytes_written, &error);
1367   g_assert_true (res);
1368   g_assert_no_error (error);
1369   data->bytes_written += bytes_written;
1370
1371   /* skip vectors that have been written in full */
1372   while (data->n_vectors > 0 && bytes_written >= data->vectors[0].size)
1373     {
1374       bytes_written -= data->vectors[0].size;
1375       ++data->vectors;
1376       --data->n_vectors;
1377     }
1378   /* skip partially written vector data */
1379   if (bytes_written > 0 && data->n_vectors > 0)
1380     {
1381       data->vectors[0].size -= bytes_written;
1382       data->vectors[0].buffer = ((guint8 *) data->vectors[0].buffer) + bytes_written;
1383     }
1384
1385   if (data->n_vectors > 0)
1386     g_output_stream_writev_async (ostream, data->vectors, data->n_vectors, 0, NULL, test_writev_async_cb, &data);
1387 }
1388
1389 /* Test that writev_async() on local file output streams works on a non-empty vector */
1390 static void
1391 test_writev_async (void)
1392 {
1393   WritevAsyncData data = { 0 };
1394   GFile *file;
1395   GFileIOStream *iostream = NULL;
1396   GOutputVector vectors[3];
1397   const guint8 buffer[] = {1, 2, 3, 4, 5,
1398                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1399                            1, 2, 3};
1400   GOutputStream *ostream;
1401   GError *error = NULL;
1402   gboolean res;
1403   guint8 *contents;
1404   gsize length;
1405
1406   vectors[0].buffer = buffer;
1407   vectors[0].size = 5;
1408
1409   vectors[1].buffer = buffer + 5;
1410   vectors[1].size = 12;
1411
1412   vectors[2].buffer = buffer + 5  + 12;
1413   vectors[2].size = 3;
1414
1415   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1416                          &iostream, NULL);
1417   g_assert_nonnull (file);
1418   g_assert_nonnull (iostream);
1419
1420   data.vectors = vectors;
1421   data.n_vectors = G_N_ELEMENTS (vectors);
1422
1423   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1424
1425   g_output_stream_writev_async (ostream, data.vectors, data.n_vectors, 0, NULL, test_writev_async_cb, &data);
1426
1427   while (data.n_vectors > 0)
1428     g_main_context_iteration (NULL, TRUE);
1429
1430   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1431
1432   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1433   g_assert_no_error (error);
1434   g_assert_true (res);
1435   g_object_unref (iostream);
1436
1437   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1438   g_assert_no_error (error);
1439   g_assert_true (res);
1440
1441   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1442
1443   g_free (contents);
1444
1445   g_file_delete (file, NULL, NULL);
1446   g_object_unref (file);
1447 }
1448
1449 static void
1450 test_writev_all_cb (GObject      *object,
1451                     GAsyncResult *result,
1452                     gpointer      user_data)
1453 {
1454   GOutputStream *ostream = G_OUTPUT_STREAM (object);
1455   WritevAsyncData *data = user_data;
1456
1457   g_output_stream_writev_all_finish (ostream, result, &data->bytes_written, &data->error);
1458   data->done = TRUE;
1459 }
1460
1461 /* Test that writev_async_all() on local file output streams works on a non-empty vector */
1462 static void
1463 test_writev_async_all (void)
1464 {
1465   WritevAsyncData data = { 0 };
1466   GFile *file;
1467   GFileIOStream *iostream = NULL;
1468   GOutputStream *ostream;
1469   GOutputVector vectors[3];
1470   const guint8 buffer[] = {1, 2, 3, 4, 5,
1471                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1472                            1, 2, 3};
1473   GError *error = NULL;
1474   gboolean res;
1475   guint8 *contents;
1476   gsize length;
1477
1478   vectors[0].buffer = buffer;
1479   vectors[0].size = 5;
1480
1481   vectors[1].buffer = buffer + 5;
1482   vectors[1].size = 12;
1483
1484   vectors[2].buffer = buffer + 5  + 12;
1485   vectors[2].size = 3;
1486
1487   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1488                          &iostream, NULL);
1489   g_assert_nonnull (file);
1490   g_assert_nonnull (iostream);
1491
1492   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1493
1494   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1495
1496   while (!data.done)
1497     g_main_context_iteration (NULL, TRUE);
1498
1499   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1500   g_assert_no_error (data.error);
1501
1502   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1503   g_assert_no_error (error);
1504   g_assert_true (res);
1505   g_object_unref (iostream);
1506
1507   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1508   g_assert_no_error (error);
1509   g_assert_true (res);
1510
1511   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1512
1513   g_free (contents);
1514
1515   g_file_delete (file, NULL, NULL);
1516   g_object_unref (file);
1517 }
1518
1519 /* Test that writev_async_all() on local file output streams handles cancellation correctly */
1520 static void
1521 test_writev_async_all_cancellation (void)
1522 {
1523   WritevAsyncData data = { 0 };
1524   GFile *file;
1525   GFileIOStream *iostream = NULL;
1526   GOutputVector vectors[3];
1527   const guint8 buffer[] = {1, 2, 3, 4, 5,
1528                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1529                            1, 2, 3};
1530   GOutputStream *ostream;
1531   GError *error = NULL;
1532   gboolean res;
1533   guint8 *contents;
1534   gsize length;
1535   GCancellable *cancellable;
1536
1537   vectors[0].buffer = buffer;
1538   vectors[0].size = 5;
1539
1540   vectors[1].buffer = buffer + 5;
1541   vectors[1].size = 12;
1542
1543   vectors[2].buffer = buffer + 5  + 12;
1544   vectors[2].size = 3;
1545
1546   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1547                          &iostream, NULL);
1548   g_assert_nonnull (file);
1549   g_assert_nonnull (iostream);
1550
1551   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1552
1553   cancellable = g_cancellable_new ();
1554   g_cancellable_cancel (cancellable);
1555
1556   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, cancellable, test_writev_all_cb, &data);
1557
1558   while (!data.done)
1559     g_main_context_iteration (NULL, TRUE);
1560
1561   g_assert_cmpuint (data.bytes_written, ==, 0);
1562   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1563   g_clear_error (&data.error);
1564
1565   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1566   g_assert_no_error (error);
1567   g_assert_true (res);
1568   g_object_unref (iostream);
1569
1570   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1571   g_assert_no_error (error);
1572   g_assert_true (res);
1573   g_assert_cmpuint (length, ==, 0);
1574
1575   g_free (contents);
1576
1577   g_file_delete (file, NULL, NULL);
1578   g_object_unref (file);
1579   g_object_unref (cancellable);
1580 }
1581
1582 /* Test that writev_async_all() with empty vectors is handled correctly */
1583 static void
1584 test_writev_async_all_empty_vectors (void)
1585 {
1586   WritevAsyncData data = { 0 };
1587   GFile *file;
1588   GFileIOStream *iostream = NULL;
1589   GOutputVector vectors[3];
1590   GOutputStream *ostream;
1591   GError *error = NULL;
1592   gboolean res;
1593   guint8 *contents;
1594   gsize length;
1595
1596   vectors[0].buffer = NULL;
1597   vectors[0].size = 0;
1598
1599   vectors[1].buffer = NULL;
1600   vectors[1].size = 0;
1601
1602   vectors[2].buffer = NULL;
1603   vectors[2].size = 0;
1604
1605   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1606                          &iostream, NULL);
1607   g_assert_nonnull (file);
1608   g_assert_nonnull (iostream);
1609
1610   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1611
1612   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1613
1614   while (!data.done)
1615     g_main_context_iteration (NULL, TRUE);
1616
1617   g_assert_cmpuint (data.bytes_written, ==, 0);
1618   g_assert_no_error (data.error);
1619   g_clear_error (&data.error);
1620
1621   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1622   g_assert_no_error (error);
1623   g_assert_true (res);
1624   g_object_unref (iostream);
1625
1626   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1627   g_assert_no_error (error);
1628   g_assert_true (res);
1629   g_assert_cmpuint (length, ==, 0);
1630
1631   g_free (contents);
1632
1633   g_file_delete (file, NULL, NULL);
1634   g_object_unref (file);
1635 }
1636
1637 /* Test that writev_async_all() with no vectors is handled correctly */
1638 static void
1639 test_writev_async_all_no_vectors (void)
1640 {
1641   WritevAsyncData data = { 0 };
1642   GFile *file;
1643   GFileIOStream *iostream = NULL;
1644   GOutputStream *ostream;
1645   GError *error = NULL;
1646   gboolean res;
1647   guint8 *contents;
1648   gsize length;
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, NULL, 0, 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 too big vectors is handled correctly */
1683 static void
1684 test_writev_async_all_too_big_vectors (void)
1685 {
1686   WritevAsyncData data = { 0 };
1687   GFile *file;
1688   GFileIOStream *iostream = NULL;
1689   GOutputVector vectors[3];
1690   GOutputStream *ostream;
1691   GError *error = NULL;
1692   gboolean res;
1693   guint8 *contents;
1694   gsize length;
1695
1696   vectors[0].buffer = (void*) 1;
1697   vectors[0].size = G_MAXSIZE / 2;
1698
1699   vectors[1].buffer = (void*) 1;
1700   vectors[1].size = G_MAXSIZE / 2;
1701
1702   vectors[2].buffer = (void*) 1;
1703   vectors[2].size = G_MAXSIZE / 2;
1704
1705   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1706                          &iostream, NULL);
1707   g_assert_nonnull (file);
1708   g_assert_nonnull (iostream);
1709
1710   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1711
1712   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1713
1714   while (!data.done)
1715     g_main_context_iteration (NULL, TRUE);
1716
1717   g_assert_cmpuint (data.bytes_written, ==, 0);
1718   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1719   g_clear_error (&data.error);
1720
1721   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1722   g_assert_no_error (error);
1723   g_assert_true (res);
1724   g_object_unref (iostream);
1725
1726   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1727   g_assert_no_error (error);
1728   g_assert_true (res);
1729   g_assert_cmpuint (length, ==, 0);
1730
1731   g_free (contents);
1732
1733   g_file_delete (file, NULL, NULL);
1734   g_object_unref (file);
1735 }
1736
1737 int
1738 main (int argc, char *argv[])
1739 {
1740   g_test_init (&argc, &argv, NULL);
1741
1742   g_test_bug_base ("http://bugzilla.gnome.org/");
1743
1744   g_test_add_func ("/file/basic", test_basic);
1745   g_test_add_func ("/file/build-filename", test_build_filename);
1746   g_test_add_func ("/file/parent", test_parent);
1747   g_test_add_func ("/file/child", test_child);
1748   g_test_add_func ("/file/type", test_type);
1749   g_test_add_func ("/file/parse-name", test_parse_name);
1750   g_test_add_data_func ("/file/async-create-delete/0", GINT_TO_POINTER (0), test_create_delete);
1751   g_test_add_data_func ("/file/async-create-delete/1", GINT_TO_POINTER (1), test_create_delete);
1752   g_test_add_data_func ("/file/async-create-delete/10", GINT_TO_POINTER (10), test_create_delete);
1753   g_test_add_data_func ("/file/async-create-delete/25", GINT_TO_POINTER (25), test_create_delete);
1754   g_test_add_data_func ("/file/async-create-delete/4096", GINT_TO_POINTER (4096), test_create_delete);
1755   g_test_add_func ("/file/replace-load", test_replace_load);
1756   g_test_add_func ("/file/replace-cancel", test_replace_cancel);
1757   g_test_add_func ("/file/async-delete", test_async_delete);
1758 #ifdef G_OS_UNIX
1759   g_test_add_func ("/file/copy-preserve-mode", test_copy_preserve_mode);
1760 #endif
1761   g_test_add_func ("/file/measure", test_measure);
1762   g_test_add_func ("/file/measure-async", test_measure_async);
1763   g_test_add_func ("/file/load-bytes", test_load_bytes);
1764   g_test_add_func ("/file/load-bytes-async", test_load_bytes_async);
1765   g_test_add_func ("/file/writev", test_writev);
1766   g_test_add_func ("/file/writev/no-bytes-written", test_writev_no_bytes_written);
1767   g_test_add_func ("/file/writev/no-vectors", test_writev_no_vectors);
1768   g_test_add_func ("/file/writev/empty-vectors", test_writev_empty_vectors);
1769   g_test_add_func ("/file/writev/too-big-vectors", test_writev_too_big_vectors);
1770   g_test_add_func ("/file/writev/async", test_writev_async);
1771   g_test_add_func ("/file/writev/async_all", test_writev_async_all);
1772   g_test_add_func ("/file/writev/async_all-empty-vectors", test_writev_async_all_empty_vectors);
1773   g_test_add_func ("/file/writev/async_all-no-vectors", test_writev_async_all_no_vectors);
1774   g_test_add_func ("/file/writev/async_all-to-big-vectors", test_writev_async_all_too_big_vectors);
1775   g_test_add_func ("/file/writev/async_all-cancellation", test_writev_async_all_cancellation);
1776
1777   return g_test_run ();
1778 }