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 *replace_data =
 527     "/**\n"
 528     " * g_file_replace_contents_async:\n"
 529     " * @file: input #GFile.\n"
 530     " * @contents: string of contents to replace the file with.\n"
 531     " * @length: the length of @contents in bytes.\n"
 532     " * @etag: (nullable): a new <link linkend=\"gfile-etag\">entity tag</link> for the @file, or %NULL\n"
 533     " * @make_backup: %TRUE if a backup should be created.\n"
 534     " * @flags: a set of #GFileCreateFlags.\n"
 535     " * @cancellable: optional #GCancellable object, %NULL to ignore.\n"
 536     " * @callback: a #GAsyncReadyCallback to call when the request is satisfied\n"
 537     " * @user_data: the data to pass to callback function\n"
 538     " * \n"
 539     " * Starts an asynchronous replacement of @file with the given \n"
 540     " * @contents of @length bytes. @etag will replace the document's\n"
 541     " * current entity tag.\n"
 542     " * \n"
 543     " * When this operation has completed, @callback will be called with\n"
 544     " * @user_user data, and the operation can be finalized with \n"
 545     " * g_file_replace_contents_finish().\n"
 546     " * \n"
 547     " * If @cancellable is not %NULL, then the operation can be cancelled by\n"
 548     " * triggering the cancellable object from another thread. If the operation\n"
 549     " * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. \n"
 550     " * \n"
 551     " * If @make_backup is %TRUE, this function will attempt to \n"
 552     " * make a backup of @file.\n"
 553     " **/\n";
 554
 555 typedef struct
 556 {
 557   GFile *file;
 558   const gchar *data;
 559   GMainLoop *loop;
 560   gboolean again;
 561 } ReplaceLoadData;
 562
 563 static void replaced_cb (GObject      *source,
 564                          GAsyncResult *res,
 565                          gpointer      user_data);
 566
 567 static void
 568 loaded_cb (GObject      *source,
 569            GAsyncResult *res,
 570            gpointer      user_data)
 571 {
 572   ReplaceLoadData *data = user_data;
 573   gboolean ret;
 574   GError *error;
 575   gchar *contents;
 576   gsize length;
 577
 578   error = NULL;
 579   ret = g_file_load_contents_finish (data->file, res, &contents, &length, NULL, &error);
 580   g_assert (ret);
 581   g_assert_no_error (error);
 582   g_assert_cmpint (length, ==, strlen (data->data));
 583   g_assert_cmpstr (contents, ==, data->data);
 584
 585   g_free (contents);
 586
 587   if (data->again)
 588     {
 589       data->again = FALSE;
 590       data->data = "pi pa po";
 591
 592       g_file_replace_contents_async (data->file,
 593                                      data->data,
 594                                      strlen (data->data),
 595                                      NULL,
 596                                      FALSE,
 597                                      0,
 598                                      NULL,
 599                                      replaced_cb,
 600                                      data);
 601     }
 602   else
 603     {
 604        error = NULL;
 605        ret = g_file_delete (data->file, NULL, &error);
 606        g_assert_no_error (error);
 607        g_assert (ret);
 608        g_assert (!g_file_query_exists (data->file, NULL));
 609
 610        g_main_loop_quit (data->loop);
 611     }
 612 }
 613
 614 static void
 615 replaced_cb (GObject      *source,
 616              GAsyncResult *res,
 617              gpointer      user_data)
 618 {
 619   ReplaceLoadData *data = user_data;
 620   GError *error;
 621
 622   error = NULL;
 623   g_file_replace_contents_finish (data->file, res, NULL, &error);
 624   g_assert_no_error (error);
 625
 626   g_file_load_contents_async (data->file, NULL, loaded_cb, data);
 627 }
 628
 629 static void
 630 test_replace_load (void)
 631 {
 632   ReplaceLoadData *data;
 633   const gchar *path;
 634   GFileIOStream *iostream;
 635
 636   data = g_new0 (ReplaceLoadData, 1);
 637   data->again = TRUE;
 638   data->data = replace_data;
 639
 640   data->file = g_file_new_tmp ("g_file_replace_load_XXXXXX",
 641                                &iostream, NULL);
 642   g_assert (data->file != NULL);
 643   g_object_unref (iostream);
 644
 645   path = g_file_peek_path (data->file);
 646   remove (path);
 647
 648   g_assert (!g_file_query_exists (data->file, NULL));
 649
 650   data->loop = g_main_loop_new (NULL, FALSE);
 651
 652   g_file_replace_contents_async (data->file,
 653                                  data->data,
 654                                  strlen (data->data),
 655                                  NULL,
 656                                  FALSE,
 657                                  0,
 658                                  NULL,
 659                                  replaced_cb,
 660                                  data);
 661
 662   g_main_loop_run (data->loop);
 663
 664   g_main_loop_unref (data->loop);
 665   g_object_unref (data->file);
 666   g_free (data);
 667 }
 668
 669 static void
 670 test_replace_cancel (void)
 671 {
 672   GFile *tmpdir, *file;
 673   GFileOutputStream *ostream;
 674   GFileEnumerator *fenum;
 675   GFileInfo *info;
 676   GCancellable *cancellable;
 677   gchar *path;
 678   gsize nwrote;
 679   guint count;
 680   GError *error = NULL;
 681
 682   g_test_bug ("629301");
 683
 684   path = g_dir_make_tmp ("g_file_replace_cancel_XXXXXX", &error);
 685   g_assert_no_error (error);
 686   tmpdir = g_file_new_for_path (path);
 687   g_free (path);
 688
 689   file = g_file_get_child (tmpdir, "file");
 690   g_file_replace_contents (file,
 691                            replace_data,
 692                            strlen (replace_data),
 693                            NULL, FALSE, 0, NULL,
 694                            NULL, &error);
 695   g_assert_no_error (error);
 696
 697   ostream = g_file_replace (file, NULL, TRUE, 0, NULL, &error);
 698   g_assert_no_error (error);
 699
 700   g_output_stream_write_all (G_OUTPUT_STREAM (ostream),
 701                              replace_data, strlen (replace_data),
 702                              &nwrote, NULL, &error);
 703   g_assert_no_error (error);
 704   g_assert_cmpint (nwrote, ==, strlen (replace_data));
 705
 706   /* At this point there should be two files; the original and the
 707    * temporary.
 708    */
 709   fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
 710   g_assert_no_error (error);
 711
 712   info = g_file_enumerator_next_file (fenum, NULL, &error);
 713   g_assert_no_error (error);
 714   g_assert (info != NULL);
 715   g_object_unref (info);
 716   info = g_file_enumerator_next_file (fenum, NULL, &error);
 717   g_assert_no_error (error);
 718   g_assert (info != NULL);
 719   g_object_unref (info);
 720
 721   g_file_enumerator_close (fenum, NULL, &error);
 722   g_assert_no_error (error);
 723   g_object_unref (fenum);
 724
 725   /* Also test the g_file_enumerator_iterate() API */
 726   fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
 727   g_assert_no_error (error);
 728   count = 0;
 729
 730   while (TRUE)
 731     {
 732       gboolean ret = g_file_enumerator_iterate (fenum, &info, NULL, NULL, &error);
 733       g_assert (ret);
 734       g_assert_no_error (error);
 735       if (!info)
 736         break;
 737       count++;
 738     }
 739   g_assert_cmpint (count, ==, 2);
 740
 741   g_file_enumerator_close (fenum, NULL, &error);
 742   g_assert_no_error (error);
 743   g_object_unref (fenum);
 744
 745   /* Now test just getting child from the g_file_enumerator_iterate() API */
 746   fenum = g_file_enumerate_children (tmpdir, "standard::name", 0, NULL, &error);
 747   g_assert_no_error (error);
 748   count = 0;
 749
 750   while (TRUE)
 751     {
 752       GFile *child;
 753       gboolean ret = g_file_enumerator_iterate (fenum, NULL, &child, NULL, &error);
 754
 755       g_assert (ret);
 756       g_assert_no_error (error);
 757
 758       if (!child)
 759         break;
 760
 761       g_assert (G_IS_FILE (child));
 762       count++;
 763     }
 764   g_assert_cmpint (count, ==, 2);
 765
 766   g_file_enumerator_close (fenum, NULL, &error);
 767   g_assert_no_error (error);
 768   g_object_unref (fenum);
 769
 770   /* Make sure the temporary gets deleted even if we cancel. */
 771   cancellable = g_cancellable_new ();
 772   g_cancellable_cancel (cancellable);
 773   g_output_stream_close (G_OUTPUT_STREAM (ostream), cancellable, &error);
 774   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
 775   g_clear_error (&error);
 776
 777   g_object_unref (cancellable);
 778   g_object_unref (ostream);
 779
 780   g_file_delete (file, NULL, &error);
 781   g_assert_no_error (error);
 782   g_object_unref (file);
 783
 784   /* This will only succeed if the temp file was deleted. */
 785   g_file_delete (tmpdir, NULL, &error);
 786   g_assert_no_error (error);
 787   g_object_unref (tmpdir);
 788 }
 789
 790 static void
 791 on_file_deleted (GObject      *object,
 792                  GAsyncResult *result,
 793                  gpointer      user_data)
 794 {
 795   GError *local_error = NULL;
 796   GMainLoop *loop = user_data;
 797
 798   (void) g_file_delete_finish ((GFile*)object, result, &local_error);
 799   g_assert_no_error (local_error);
 800
 801   g_main_loop_quit (loop);
 802 }
 803
 804 static void
 805 test_async_delete (void)
 806 {
 807   GFile *file;
 808   GFileIOStream *iostream;
 809   GError *local_error = NULL;
 810   GError **error = &local_error;
 811   GMainLoop *loop;
 812
 813   file = g_file_new_tmp ("g_file_delete_XXXXXX",
 814                          &iostream, error);
 815   g_assert_no_error (local_error);
 816   g_object_unref (iostream);
 817
 818   g_assert (g_file_query_exists (file, NULL));
 819
 820   loop = g_main_loop_new (NULL, TRUE);
 821
 822   g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, on_file_deleted, loop);
 823
 824   g_main_loop_run (loop);
 825
 826   g_assert (!g_file_query_exists (file, NULL));
 827
 828   g_main_loop_unref (loop);
 829   g_object_unref (file);
 830 }
 831
 832 #ifdef G_OS_UNIX
 833 static void
 834 test_copy_preserve_mode (void)
 835 {
 836   GFile *tmpfile;
 837   GFile *dest_tmpfile;
 838   GFileInfo *dest_info;
 839   GFileIOStream *iostream;
 840   GError *local_error = NULL;
 841   GError **error = &local_error;
 842   guint32 romode = S_IFREG | 0600;
 843   guint32 dest_mode;
 844
 845   tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
 846                             &iostream, error);
 847   g_assert_no_error (local_error);
 848   g_io_stream_close ((GIOStream*)iostream, NULL, error);
 849   g_assert_no_error (local_error);
 850   g_clear_object (&iostream);
 851
 852   g_file_set_attribute (tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_ATTRIBUTE_TYPE_UINT32,
 853                         &romode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 854                         NULL, error);
 855   g_assert_no_error (local_error);
 856
 857   dest_tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
 858                                  &iostream, error);
 859   g_assert_no_error (local_error);
 860   g_io_stream_close ((GIOStream*)iostream, NULL, error);
 861   g_assert_no_error (local_error);
 862   g_clear_object (&iostream);
 863
 864   g_file_copy (tmpfile, dest_tmpfile, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA,
 865                NULL, NULL, NULL, error);
 866   g_assert_no_error (local_error);
 867
 868   dest_info = g_file_query_info (dest_tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 869                                  NULL, error);
 870   g_assert_no_error (local_error);
 871
 872   dest_mode = g_file_info_get_attribute_uint32 (dest_info, G_FILE_ATTRIBUTE_UNIX_MODE);
 873
 874   g_assert_cmpint (dest_mode, ==, romode);
 875
 876   (void) g_file_delete (tmpfile, NULL, NULL);
 877   (void) g_file_delete (dest_tmpfile, NULL, NULL);
 878
 879   g_clear_object (&tmpfile);
 880   g_clear_object (&dest_tmpfile);
 881   g_clear_object (&dest_info);
 882 }
 883 #endif
 884
 885 static gchar *
 886 splice_to_string (GInputStream   *stream,
 887                   GError        **error)
 888 {
 889   GMemoryOutputStream *buffer = NULL;
 890   char *ret = NULL;
 891
 892   buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 893   if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
 894     goto out;
 895
 896   if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
 897     goto out;
 898
 899   if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
 900     goto out;
 901
 902   ret = g_memory_output_stream_steal_data (buffer);
 903  out:
 904   g_clear_object (&buffer);
 905   return ret;
 906 }
 907
 908 static gboolean
 909 get_size_from_du (const gchar *path, guint64 *size)
 910 {
 911   GSubprocess *du;
 912   gboolean ok;
 913   gchar *result;
 914   gchar *endptr;
 915   GError *error = NULL;
 916   gchar *du_path = NULL;
 917
 918   /* If we can’t find du, don’t try and run the test. */
 919   du_path = g_find_program_in_path ("du");
 920   if (du_path == NULL)
 921     return FALSE;
 922   g_free (du_path);
 923
 924   du = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE,
 925                          &error,
 926                          "du", "--bytes", "-s", path, NULL);
 927   g_assert_no_error (error);
 928
 929   result = splice_to_string (g_subprocess_get_stdout_pipe (du), &error);
 930   g_assert_no_error (error);
 931
 932   *size = g_ascii_strtoll (result, &endptr, 10);
 933
 934   g_subprocess_wait (du, NULL, &error);
 935   g_assert_no_error (error);
 936
 937   ok = g_subprocess_get_successful (du);
 938
 939   g_object_unref (du);
 940   g_free (result);
 941
 942   return ok;
 943 }
 944
 945 static void
 946 test_measure (void)
 947 {
 948   GFile *file;
 949   guint64 size;
 950   guint64 num_bytes;
 951   guint64 num_dirs;
 952   guint64 num_files;
 953   GError *error = NULL;
 954   gboolean ok;
 955   gchar *path;
 956
 957   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
 958   file = g_file_new_for_path (path);
 959
 960   if (!get_size_from_du (path, &size))
 961     {
 962       g_test_message ("du not found or fail to run, skipping byte measurement");
 963       size = 0;
 964     }
 965
 966   ok = g_file_measure_disk_usage (file,
 967                                   G_FILE_MEASURE_APPARENT_SIZE,
 968                                   NULL,
 969                                   NULL,
 970                                   NULL,
 971                                   &num_bytes,
 972                                   &num_dirs,
 973                                   &num_files,
 974                                   &error);
 975   g_assert (ok);
 976   g_assert_no_error (error);
 977
 978   if (size > 0)
 979     g_assert_cmpuint (num_bytes, ==, size);
 980   g_assert_cmpuint (num_dirs, ==, 6);
 981   g_assert_cmpuint (num_files, ==, 31);
 982
 983   g_object_unref (file);
 984   g_free (path);
 985 }
 986
 987 typedef struct {
 988   guint64 expected_bytes;
 989   guint64 expected_dirs;
 990   guint64 expected_files;
 991   gint progress_count;
 992   guint64 progress_bytes;
 993   guint64 progress_dirs;
 994   guint64 progress_files;
 995 } MeasureData;
 996
 997 static void
 998 measure_progress (gboolean reporting,
 999                   guint64  current_size,
1000                   guint64  num_dirs,
1001                   guint64  num_files,
1002                   gpointer user_data)
1003 {
1004   MeasureData *data = user_data;
1005
1006   data->progress_count += 1;
1007
1008   g_assert_cmpuint (current_size, >=, data->progress_bytes);
1009   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1010   g_assert_cmpuint (num_files, >=, data->progress_files);
1011
1012   data->progress_bytes = current_size;
1013   data->progress_dirs = num_dirs;
1014   data->progress_files = num_files;
1015 }
1016
1017 static void
1018 measure_done (GObject      *source,
1019               GAsyncResult *res,
1020               gpointer      user_data)
1021 {
1022   MeasureData *data = user_data;
1023   guint64 num_bytes, num_dirs, num_files;
1024   GError *error = NULL;
1025   gboolean ok;
1026
1027   ok = g_file_measure_disk_usage_finish (G_FILE (source), res, &num_bytes, &num_dirs, &num_files, &error);
1028   g_assert (ok);
1029   g_assert_no_error (error);
1030
1031   if (data->expected_bytes > 0)
1032     g_assert_cmpuint (data->expected_bytes, ==, num_bytes);
1033   g_assert_cmpuint (data->expected_dirs, ==, num_dirs);
1034   g_assert_cmpuint (data->expected_files, ==, num_files);
1035
1036   g_assert_cmpuint (data->progress_count, >, 0);
1037   g_assert_cmpuint (num_bytes, >=, data->progress_bytes);
1038   g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1039   g_assert_cmpuint (num_files, >=, data->progress_files);
1040
1041   g_free (data);
1042   g_object_unref (source);
1043 }
1044
1045 static void
1046 test_measure_async (void)
1047 {
1048   gchar *path;
1049   GFile *file;
1050   MeasureData *data;
1051
1052   data = g_new (MeasureData, 1);
1053
1054   data->progress_count = 0;
1055   data->progress_bytes = 0;
1056   data->progress_files = 0;
1057   data->progress_dirs = 0;
1058
1059   path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1060   file = g_file_new_for_path (path);
1061
1062   if (!get_size_from_du (path, &data->expected_bytes))
1063     {
1064       g_test_message ("du not found or fail to run, skipping byte measurement");
1065       data->expected_bytes = 0;
1066     }
1067
1068   g_free (path);
1069
1070   data->expected_dirs = 6;
1071   data->expected_files = 31;
1072
1073   g_file_measure_disk_usage_async (file,
1074                                    G_FILE_MEASURE_APPARENT_SIZE,
1075                                    0, NULL,
1076                                    measure_progress, data,
1077                                    measure_done, data);
1078 }
1079
1080 static void
1081 test_load_bytes (void)
1082 {
1083   gchar filename[] = "g_file_load_bytes_XXXXXX";
1084   GError *error = NULL;
1085   GBytes *bytes;
1086   GFile *file;
1087   int len;
1088   int fd;
1089   int ret;
1090
1091   fd = g_mkstemp (filename);
1092   g_assert_cmpint (fd, !=, -1);
1093   len = strlen ("test_load_bytes");
1094   ret = write (fd, "test_load_bytes", len);
1095   g_assert_cmpint (ret, ==, len);
1096   close (fd);
1097
1098   file = g_file_new_for_path (filename);
1099   bytes = g_file_load_bytes (file, NULL, NULL, &error);
1100   g_assert_no_error (error);
1101   g_assert (bytes != NULL);
1102   g_assert_cmpint (len, ==, g_bytes_get_size (bytes));
1103   g_assert_cmpstr ("test_load_bytes", ==, (gchar *)g_bytes_get_data (bytes, NULL));
1104
1105   g_file_delete (file, NULL, NULL);
1106
1107   g_bytes_unref (bytes);
1108   g_object_unref (file);
1109 }
1110
1111 typedef struct
1112 {
1113   GMainLoop *main_loop;
1114   GFile *file;
1115   GBytes *bytes;
1116 } LoadBytesAsyncData;
1117
1118 static void
1119 test_load_bytes_cb (GObject      *object,
1120                     GAsyncResult *result,
1121                     gpointer      user_data)
1122 {
1123   GFile *file = G_FILE (object);
1124   LoadBytesAsyncData *data = user_data;
1125   GError *error = NULL;
1126
1127   data->bytes = g_file_load_bytes_finish (file, result, NULL, &error);
1128   g_assert_no_error (error);
1129   g_assert (data->bytes != NULL);
1130
1131   g_main_loop_quit (data->main_loop);
1132 }
1133
1134 static void
1135 test_load_bytes_async (void)
1136 {
1137   LoadBytesAsyncData data = { 0 };
1138   gchar filename[] = "g_file_load_bytes_XXXXXX";
1139   int len;
1140   int fd;
1141   int ret;
1142
1143   fd = g_mkstemp (filename);
1144   g_assert_cmpint (fd, !=, -1);
1145   len = strlen ("test_load_bytes_async");
1146   ret = write (fd, "test_load_bytes_async", len);
1147   g_assert_cmpint (ret, ==, len);
1148   close (fd);
1149
1150   data.main_loop = g_main_loop_new (NULL, FALSE);
1151   data.file = g_file_new_for_path (filename);
1152
1153   g_file_load_bytes_async (data.file, NULL, test_load_bytes_cb, &data);
1154   g_main_loop_run (data.main_loop);
1155
1156   g_assert_cmpint (len, ==, g_bytes_get_size (data.bytes));
1157   g_assert_cmpstr ("test_load_bytes_async", ==, (gchar *)g_bytes_get_data (data.bytes, NULL));
1158
1159   g_file_delete (data.file, NULL, NULL);
1160   g_object_unref (data.file);
1161   g_bytes_unref (data.bytes);
1162   g_main_loop_unref (data.main_loop);
1163 }
1164
1165 static void
1166 test_writev_helper (GOutputVector *vectors,
1167                     gsize          n_vectors,
1168                     gboolean       use_bytes_written,
1169                     const guint8  *expected_contents,
1170                     gsize          expected_length)
1171 {
1172   GFile *file;
1173   GFileIOStream *iostream = NULL;
1174   GOutputStream *ostream;
1175   GError *error = NULL;
1176   gsize bytes_written = 0;
1177   gboolean res;
1178   guint8 *contents;
1179   gsize length;
1180
1181   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1182                          &iostream, NULL);
1183   g_assert_nonnull (file);
1184   g_assert_nonnull (iostream);
1185
1186   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1187
1188   res = g_output_stream_writev_all (ostream, vectors, n_vectors, use_bytes_written ? &bytes_written : NULL, NULL, &error);
1189   g_assert_no_error (error);
1190   g_assert_true (res);
1191   if (use_bytes_written)
1192     g_assert_cmpuint (bytes_written, ==, expected_length);
1193
1194   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1195   g_assert_no_error (error);
1196   g_assert_true (res);
1197   g_object_unref (iostream);
1198
1199   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1200   g_assert_no_error (error);
1201   g_assert_true (res);
1202
1203   g_assert_cmpmem (contents, length, expected_contents, expected_length);
1204
1205   g_free (contents);
1206
1207   g_file_delete (file, NULL, NULL);
1208   g_object_unref (file);
1209 }
1210
1211 /* Test that writev() on local file output streams works on a non-empty vector */
1212 static void
1213 test_writev (void)
1214 {
1215   GOutputVector vectors[3];
1216   const guint8 buffer[] = {1, 2, 3, 4, 5,
1217                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1218                            1, 2, 3};
1219
1220   vectors[0].buffer = buffer;
1221   vectors[0].size = 5;
1222
1223   vectors[1].buffer = buffer + 5;
1224   vectors[1].size = 12;
1225
1226   vectors[2].buffer = buffer + 5 + 12;
1227   vectors[2].size = 3;
1228
1229   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, buffer, sizeof buffer);
1230 }
1231
1232 /* Test that writev() on local file output streams works on a non-empty vector without returning bytes_written */
1233 static void
1234 test_writev_no_bytes_written (void)
1235 {
1236   GOutputVector vectors[3];
1237   const guint8 buffer[] = {1, 2, 3, 4, 5,
1238                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1239                            1, 2, 3};
1240
1241   vectors[0].buffer = buffer;
1242   vectors[0].size = 5;
1243
1244   vectors[1].buffer = buffer + 5;
1245   vectors[1].size = 12;
1246
1247   vectors[2].buffer = buffer + 5 + 12;
1248   vectors[2].size = 3;
1249
1250   test_writev_helper (vectors, G_N_ELEMENTS (vectors), FALSE, buffer, sizeof buffer);
1251 }
1252
1253 /* Test that writev() on local file output streams works on 0 vectors */
1254 static void
1255 test_writev_no_vectors (void)
1256 {
1257   test_writev_helper (NULL, 0, TRUE, NULL, 0);
1258 }
1259
1260 /* Test that writev() on local file output streams works on empty vectors */
1261 static void
1262 test_writev_empty_vectors (void)
1263 {
1264   GOutputVector vectors[3];
1265
1266   vectors[0].buffer = NULL;
1267   vectors[0].size = 0;
1268   vectors[1].buffer = NULL;
1269   vectors[1].size = 0;
1270   vectors[2].buffer = NULL;
1271   vectors[2].size = 0;
1272
1273   test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, NULL, 0);
1274 }
1275
1276 /* Test that writev() fails if the sum of sizes in the vector is too big */
1277 static void
1278 test_writev_too_big_vectors (void)
1279 {
1280   GFile *file;
1281   GFileIOStream *iostream = NULL;
1282   GOutputStream *ostream;
1283   GError *error = NULL;
1284   gsize bytes_written = 0;
1285   gboolean res;
1286   guint8 *contents;
1287   gsize length;
1288   GOutputVector vectors[3];
1289
1290   vectors[0].buffer = (void*) 1;
1291   vectors[0].size = G_MAXSIZE / 2;
1292
1293   vectors[1].buffer = (void*) 1;
1294   vectors[1].size = G_MAXSIZE / 2;
1295
1296   vectors[2].buffer = (void*) 1;
1297   vectors[2].size = G_MAXSIZE / 2;
1298
1299   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1300                          &iostream, NULL);
1301   g_assert_nonnull (file);
1302   g_assert_nonnull (iostream);
1303
1304   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1305
1306   res = g_output_stream_writev_all (ostream, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1307   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1308   g_assert_cmpuint (bytes_written, ==, 0);
1309   g_assert_false (res);
1310   g_clear_error (&error);
1311
1312   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1313   g_assert_no_error (error);
1314   g_assert_true (res);
1315   g_object_unref (iostream);
1316
1317   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1318   g_assert_no_error (error);
1319   g_assert_true (res);
1320
1321   g_assert_cmpmem (contents, length, NULL, 0);
1322
1323   g_free (contents);
1324
1325   g_file_delete (file, NULL, NULL);
1326   g_object_unref (file);
1327 }
1328
1329 typedef struct
1330 {
1331   gsize bytes_written;
1332   GOutputVector *vectors;
1333   gsize n_vectors;
1334   GError *error;
1335   gboolean done;
1336 } WritevAsyncData;
1337
1338 static void
1339 test_writev_async_cb (GObject      *object,
1340                       GAsyncResult *result,
1341                       gpointer      user_data)
1342 {
1343   GOutputStream *ostream = G_OUTPUT_STREAM (object);
1344   WritevAsyncData *data = user_data;
1345   GError *error = NULL;
1346   gsize bytes_written;
1347   gboolean res;
1348
1349   res = g_output_stream_writev_finish (ostream, result, &bytes_written, &error);
1350   g_assert_true (res);
1351   g_assert_no_error (error);
1352   data->bytes_written += bytes_written;
1353
1354   /* skip vectors that have been written in full */
1355   while (data->n_vectors > 0 && bytes_written >= data->vectors[0].size)
1356     {
1357       bytes_written -= data->vectors[0].size;
1358       ++data->vectors;
1359       --data->n_vectors;
1360     }
1361   /* skip partially written vector data */
1362   if (bytes_written > 0 && data->n_vectors > 0)
1363     {
1364       data->vectors[0].size -= bytes_written;
1365       data->vectors[0].buffer = ((guint8 *) data->vectors[0].buffer) + bytes_written;
1366     }
1367
1368   if (data->n_vectors > 0)
1369     g_output_stream_writev_async (ostream, data->vectors, data->n_vectors, 0, NULL, test_writev_async_cb, &data);
1370 }
1371
1372 /* Test that writev_async() on local file output streams works on a non-empty vector */
1373 static void
1374 test_writev_async (void)
1375 {
1376   WritevAsyncData data = { 0 };
1377   GFile *file;
1378   GFileIOStream *iostream = NULL;
1379   GOutputVector vectors[3];
1380   const guint8 buffer[] = {1, 2, 3, 4, 5,
1381                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1382                            1, 2, 3};
1383   GOutputStream *ostream;
1384   GError *error = NULL;
1385   gboolean res;
1386   guint8 *contents;
1387   gsize length;
1388
1389   vectors[0].buffer = buffer;
1390   vectors[0].size = 5;
1391
1392   vectors[1].buffer = buffer + 5;
1393   vectors[1].size = 12;
1394
1395   vectors[2].buffer = buffer + 5  + 12;
1396   vectors[2].size = 3;
1397
1398   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1399                          &iostream, NULL);
1400   g_assert_nonnull (file);
1401   g_assert_nonnull (iostream);
1402
1403   data.vectors = vectors;
1404   data.n_vectors = G_N_ELEMENTS (vectors);
1405
1406   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1407
1408   g_output_stream_writev_async (ostream, data.vectors, data.n_vectors, 0, NULL, test_writev_async_cb, &data);
1409
1410   while (data.n_vectors > 0)
1411     g_main_context_iteration (NULL, TRUE);
1412
1413   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1414
1415   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1416   g_assert_no_error (error);
1417   g_assert_true (res);
1418   g_object_unref (iostream);
1419
1420   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1421   g_assert_no_error (error);
1422   g_assert_true (res);
1423
1424   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1425
1426   g_free (contents);
1427
1428   g_file_delete (file, NULL, NULL);
1429   g_object_unref (file);
1430 }
1431
1432 static void
1433 test_writev_all_cb (GObject      *object,
1434                     GAsyncResult *result,
1435                     gpointer      user_data)
1436 {
1437   GOutputStream *ostream = G_OUTPUT_STREAM (object);
1438   WritevAsyncData *data = user_data;
1439
1440   g_output_stream_writev_all_finish (ostream, result, &data->bytes_written, &data->error);
1441   data->done = TRUE;
1442 }
1443
1444 /* Test that writev_async_all() on local file output streams works on a non-empty vector */
1445 static void
1446 test_writev_async_all (void)
1447 {
1448   WritevAsyncData data = { 0 };
1449   GFile *file;
1450   GFileIOStream *iostream = NULL;
1451   GOutputStream *ostream;
1452   GOutputVector vectors[3];
1453   const guint8 buffer[] = {1, 2, 3, 4, 5,
1454                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1455                            1, 2, 3};
1456   GError *error = NULL;
1457   gboolean res;
1458   guint8 *contents;
1459   gsize length;
1460
1461   vectors[0].buffer = buffer;
1462   vectors[0].size = 5;
1463
1464   vectors[1].buffer = buffer + 5;
1465   vectors[1].size = 12;
1466
1467   vectors[2].buffer = buffer + 5  + 12;
1468   vectors[2].size = 3;
1469
1470   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1471                          &iostream, NULL);
1472   g_assert_nonnull (file);
1473   g_assert_nonnull (iostream);
1474
1475   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1476
1477   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1478
1479   while (!data.done)
1480     g_main_context_iteration (NULL, TRUE);
1481
1482   g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1483   g_assert_no_error (data.error);
1484
1485   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1486   g_assert_no_error (error);
1487   g_assert_true (res);
1488   g_object_unref (iostream);
1489
1490   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1491   g_assert_no_error (error);
1492   g_assert_true (res);
1493
1494   g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1495
1496   g_free (contents);
1497
1498   g_file_delete (file, NULL, NULL);
1499   g_object_unref (file);
1500 }
1501
1502 /* Test that writev_async_all() on local file output streams handles cancellation correctly */
1503 static void
1504 test_writev_async_all_cancellation (void)
1505 {
1506   WritevAsyncData data = { 0 };
1507   GFile *file;
1508   GFileIOStream *iostream = NULL;
1509   GOutputVector vectors[3];
1510   const guint8 buffer[] = {1, 2, 3, 4, 5,
1511                            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1512                            1, 2, 3};
1513   GOutputStream *ostream;
1514   GError *error = NULL;
1515   gboolean res;
1516   guint8 *contents;
1517   gsize length;
1518   GCancellable *cancellable;
1519
1520   vectors[0].buffer = buffer;
1521   vectors[0].size = 5;
1522
1523   vectors[1].buffer = buffer + 5;
1524   vectors[1].size = 12;
1525
1526   vectors[2].buffer = buffer + 5  + 12;
1527   vectors[2].size = 3;
1528
1529   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1530                          &iostream, NULL);
1531   g_assert_nonnull (file);
1532   g_assert_nonnull (iostream);
1533
1534   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1535
1536   cancellable = g_cancellable_new ();
1537   g_cancellable_cancel (cancellable);
1538
1539   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, cancellable, 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, ==, 0);
1545   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1546   g_clear_error (&data.error);
1547
1548   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1549   g_assert_no_error (error);
1550   g_assert_true (res);
1551   g_object_unref (iostream);
1552
1553   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1554   g_assert_no_error (error);
1555   g_assert_true (res);
1556   g_assert_cmpuint (length, ==, 0);
1557
1558   g_free (contents);
1559
1560   g_file_delete (file, NULL, NULL);
1561   g_object_unref (file);
1562   g_object_unref (cancellable);
1563 }
1564
1565 /* Test that writev_async_all() with empty vectors is handled correctly */
1566 static void
1567 test_writev_async_all_empty_vectors (void)
1568 {
1569   WritevAsyncData data = { 0 };
1570   GFile *file;
1571   GFileIOStream *iostream = NULL;
1572   GOutputVector vectors[3];
1573   GOutputStream *ostream;
1574   GError *error = NULL;
1575   gboolean res;
1576   guint8 *contents;
1577   gsize length;
1578
1579   vectors[0].buffer = NULL;
1580   vectors[0].size = 0;
1581
1582   vectors[1].buffer = NULL;
1583   vectors[1].size = 0;
1584
1585   vectors[2].buffer = NULL;
1586   vectors[2].size = 0;
1587
1588   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1589                          &iostream, NULL);
1590   g_assert_nonnull (file);
1591   g_assert_nonnull (iostream);
1592
1593   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1594
1595   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1596
1597   while (!data.done)
1598     g_main_context_iteration (NULL, TRUE);
1599
1600   g_assert_cmpuint (data.bytes_written, ==, 0);
1601   g_assert_no_error (data.error);
1602   g_clear_error (&data.error);
1603
1604   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1605   g_assert_no_error (error);
1606   g_assert_true (res);
1607   g_object_unref (iostream);
1608
1609   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1610   g_assert_no_error (error);
1611   g_assert_true (res);
1612   g_assert_cmpuint (length, ==, 0);
1613
1614   g_free (contents);
1615
1616   g_file_delete (file, NULL, NULL);
1617   g_object_unref (file);
1618 }
1619
1620 /* Test that writev_async_all() with no vectors is handled correctly */
1621 static void
1622 test_writev_async_all_no_vectors (void)
1623 {
1624   WritevAsyncData data = { 0 };
1625   GFile *file;
1626   GFileIOStream *iostream = NULL;
1627   GOutputStream *ostream;
1628   GError *error = NULL;
1629   gboolean res;
1630   guint8 *contents;
1631   gsize length;
1632
1633   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1634                          &iostream, NULL);
1635   g_assert_nonnull (file);
1636   g_assert_nonnull (iostream);
1637
1638   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1639
1640   g_output_stream_writev_all_async (ostream, NULL, 0, 0, NULL, test_writev_all_cb, &data);
1641
1642   while (!data.done)
1643     g_main_context_iteration (NULL, TRUE);
1644
1645   g_assert_cmpuint (data.bytes_written, ==, 0);
1646   g_assert_no_error (data.error);
1647   g_clear_error (&data.error);
1648
1649   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1650   g_assert_no_error (error);
1651   g_assert_true (res);
1652   g_object_unref (iostream);
1653
1654   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1655   g_assert_no_error (error);
1656   g_assert_true (res);
1657   g_assert_cmpuint (length, ==, 0);
1658
1659   g_free (contents);
1660
1661   g_file_delete (file, NULL, NULL);
1662   g_object_unref (file);
1663 }
1664
1665 /* Test that writev_async_all() with too big vectors is handled correctly */
1666 static void
1667 test_writev_async_all_too_big_vectors (void)
1668 {
1669   WritevAsyncData data = { 0 };
1670   GFile *file;
1671   GFileIOStream *iostream = NULL;
1672   GOutputVector vectors[3];
1673   GOutputStream *ostream;
1674   GError *error = NULL;
1675   gboolean res;
1676   guint8 *contents;
1677   gsize length;
1678
1679   vectors[0].buffer = (void*) 1;
1680   vectors[0].size = G_MAXSIZE / 2;
1681
1682   vectors[1].buffer = (void*) 1;
1683   vectors[1].size = G_MAXSIZE / 2;
1684
1685   vectors[2].buffer = (void*) 1;
1686   vectors[2].size = G_MAXSIZE / 2;
1687
1688   file = g_file_new_tmp ("g_file_writev_XXXXXX",
1689                          &iostream, NULL);
1690   g_assert_nonnull (file);
1691   g_assert_nonnull (iostream);
1692
1693   ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1694
1695   g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1696
1697   while (!data.done)
1698     g_main_context_iteration (NULL, TRUE);
1699
1700   g_assert_cmpuint (data.bytes_written, ==, 0);
1701   g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1702   g_clear_error (&data.error);
1703
1704   res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1705   g_assert_no_error (error);
1706   g_assert_true (res);
1707   g_object_unref (iostream);
1708
1709   res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1710   g_assert_no_error (error);
1711   g_assert_true (res);
1712   g_assert_cmpuint (length, ==, 0);
1713
1714   g_free (contents);
1715
1716   g_file_delete (file, NULL, NULL);
1717   g_object_unref (file);
1718 }
1719
1720 int
1721 main (int argc, char *argv[])
1722 {
1723   g_test_init (&argc, &argv, NULL);
1724
1725   g_test_bug_base ("http://bugzilla.gnome.org/");
1726
1727   g_test_add_func ("/file/basic", test_basic);
1728   g_test_add_func ("/file/build-filename", test_build_filename);
1729   g_test_add_func ("/file/parent", test_parent);
1730   g_test_add_func ("/file/child", test_child);
1731   g_test_add_func ("/file/type", test_type);
1732   g_test_add_func ("/file/parse-name", test_parse_name);
1733   g_test_add_data_func ("/file/async-create-delete/0", GINT_TO_POINTER (0), test_create_delete);
1734   g_test_add_data_func ("/file/async-create-delete/1", GINT_TO_POINTER (1), test_create_delete);
1735   g_test_add_data_func ("/file/async-create-delete/10", GINT_TO_POINTER (10), test_create_delete);
1736   g_test_add_data_func ("/file/async-create-delete/25", GINT_TO_POINTER (25), test_create_delete);
1737   g_test_add_data_func ("/file/async-create-delete/4096", GINT_TO_POINTER (4096), test_create_delete);
1738   g_test_add_func ("/file/replace-load", test_replace_load);
1739   g_test_add_func ("/file/replace-cancel", test_replace_cancel);
1740   g_test_add_func ("/file/async-delete", test_async_delete);
1741 #ifdef G_OS_UNIX
1742   g_test_add_func ("/file/copy-preserve-mode", test_copy_preserve_mode);
1743 #endif
1744   g_test_add_func ("/file/measure", test_measure);
1745   g_test_add_func ("/file/measure-async", test_measure_async);
1746   g_test_add_func ("/file/load-bytes", test_load_bytes);
1747   g_test_add_func ("/file/load-bytes-async", test_load_bytes_async);
1748   g_test_add_func ("/file/writev", test_writev);
1749   g_test_add_func ("/file/writev/no-bytes-written", test_writev_no_bytes_written);
1750   g_test_add_func ("/file/writev/no-vectors", test_writev_no_vectors);
1751   g_test_add_func ("/file/writev/empty-vectors", test_writev_empty_vectors);
1752   g_test_add_func ("/file/writev/too-big-vectors", test_writev_too_big_vectors);
1753   g_test_add_func ("/file/writev/async", test_writev_async);
1754   g_test_add_func ("/file/writev/async_all", test_writev_async_all);
1755   g_test_add_func ("/file/writev/async_all-empty-vectors", test_writev_async_all_empty_vectors);
1756   g_test_add_func ("/file/writev/async_all-no-vectors", test_writev_async_all_no_vectors);
1757   g_test_add_func ("/file/writev/async_all-to-big-vectors", test_writev_async_all_too_big_vectors);
1758   g_test_add_func ("/file/writev/async_all-cancellation", test_writev_async_all_cancellation);
1759
1760   return g_test_run ();
1761 }