5 #include <gio/gfiledescriptorbased.h>
11 test_basic_for_file (GFile *file,
16 s = g_file_get_basename (file);
17 g_assert_cmpstr (s, ==, "testfile");
20 s = g_file_get_uri (file);
21 g_assert_true (g_str_has_prefix (s, "file://"));
22 g_assert_true (g_str_has_suffix (s, suffix));
25 g_assert_true (g_file_has_uri_scheme (file, "file"));
26 s = g_file_get_uri_scheme (file);
27 g_assert_cmpstr (s, ==, "file");
36 file = g_file_new_for_path ("./some/directory/testfile");
37 test_basic_for_file (file, "/some/directory/testfile");
38 g_object_unref (file);
42 test_build_filename (void)
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);
50 file = g_file_new_build_filename ("testfile", NULL);
51 test_basic_for_file (file, "/testfile");
52 g_object_unref (file);
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 ("/");
67 g_assert_true (g_file_has_parent (file, file2));
69 parent = g_file_get_parent (file);
70 g_assert_true (g_file_equal (parent, file2));
71 g_object_unref (parent);
73 g_assert_null (g_file_get_parent (root));
75 g_object_unref (file);
76 g_object_unref (file2);
77 g_object_unref (root);
87 file = g_file_new_for_path ("./some/directory");
88 child = g_file_get_child (file, "child");
89 g_assert_true (g_file_has_parent (child, file));
91 child2 = g_file_get_child_for_display_name (file, "child2", NULL);
92 g_assert_true (g_file_has_parent (child2, file));
94 g_object_unref (child);
95 g_object_unref (child2);
96 g_object_unref (file);
105 GError *error = NULL;
107 datapath_f = g_file_new_for_path (g_test_get_dir (G_TEST_DIST));
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);
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);
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);
123 g_object_unref (datapath_f);
127 test_parse_name (void)
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);
138 file = g_file_parse_name ("~foo");
139 name = g_file_get_parse_name (file);
140 g_assert_nonnull (name);
141 g_object_unref (file);
147 GMainContext *context;
149 GFileMonitor *monitor;
150 GOutputStream *ostream;
151 GInputStream *istream;
153 gint monitor_created;
154 gint monitor_deleted;
155 gint monitor_changed;
161 gboolean file_deleted;
166 monitor_changed (GFileMonitor *monitor,
169 GFileMonitorEvent event_type,
172 CreateDeleteData *data = user_data;
174 const gchar *peeked_path;
176 path = g_file_get_path (file);
177 peeked_path = g_file_peek_path (file);
178 g_assert_cmpstr (data->monitor_path, ==, path);
179 g_assert_cmpstr (path, ==, peeked_path);
182 if (event_type == G_FILE_MONITOR_EVENT_CREATED)
183 data->monitor_created++;
184 if (event_type == G_FILE_MONITOR_EVENT_DELETED)
185 data->monitor_deleted++;
186 if (event_type == G_FILE_MONITOR_EVENT_CHANGED)
187 data->monitor_changed++;
189 g_main_context_wakeup (data->context);
193 iclosed_cb (GObject *source,
197 CreateDeleteData *data = user_data;
202 ret = g_input_stream_close_finish (data->istream, res, &error);
203 g_assert_no_error (error);
206 g_assert_true (g_input_stream_is_closed (data->istream));
208 ret = g_file_delete (data->file, NULL, &error);
210 g_assert_no_error (error);
212 data->file_deleted = TRUE;
213 g_main_context_wakeup (data->context);
217 read_cb (GObject *source,
221 CreateDeleteData *data = user_data;
226 size = g_input_stream_read_finish (data->istream, res, &error);
227 g_assert_no_error (error);
230 if (data->pos < strlen (data->data))
232 g_input_stream_read_async (data->istream,
233 data->buffer + data->pos,
234 strlen (data->data) - data->pos,
242 g_assert_cmpstr (data->buffer, ==, data->data);
243 g_assert_false (g_input_stream_is_closed (data->istream));
244 g_input_stream_close_async (data->istream, 0, NULL, iclosed_cb, data);
249 ipending_cb (GObject *source,
253 CreateDeleteData *data = user_data;
257 g_input_stream_read_finish (data->istream, res, &error);
258 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
259 g_error_free (error);
263 skipped_cb (GObject *source,
267 CreateDeleteData *data = user_data;
272 size = g_input_stream_skip_finish (data->istream, res, &error);
273 g_assert_no_error (error);
274 g_assert_cmpint (size, ==, data->pos);
276 g_input_stream_read_async (data->istream,
277 data->buffer + data->pos,
278 strlen (data->data) - data->pos,
283 /* check that we get a pending error */
284 g_input_stream_read_async (data->istream,
285 data->buffer + data->pos,
286 strlen (data->data) - data->pos,
294 opened_cb (GObject *source,
298 GFileInputStream *base;
299 CreateDeleteData *data = user_data;
303 base = g_file_read_finish (data->file, res, &error);
304 g_assert_no_error (error);
306 if (data->buffersize == 0)
307 data->istream = G_INPUT_STREAM (g_object_ref (base));
309 data->istream = g_buffered_input_stream_new_sized (G_INPUT_STREAM (base), data->buffersize);
310 g_object_unref (base);
312 data->buffer = g_new0 (gchar, strlen (data->data) + 1);
314 /* copy initial segment directly, then skip */
315 memcpy (data->buffer, data->data, 10);
318 g_input_stream_skip_async (data->istream,
327 oclosed_cb (GObject *source,
331 CreateDeleteData *data = user_data;
336 ret = g_output_stream_close_finish (data->ostream, res, &error);
337 g_assert_no_error (error);
339 g_assert_true (g_output_stream_is_closed (data->ostream));
341 g_file_read_async (data->file, 0, NULL, opened_cb, data);
345 written_cb (GObject *source,
349 CreateDeleteData *data = user_data;
354 size = g_output_stream_write_finish (data->ostream, res, &error);
355 g_assert_no_error (error);
358 if (data->pos < strlen (data->data))
360 g_output_stream_write_async (data->ostream,
361 data->data + data->pos,
362 strlen (data->data) - data->pos,
370 g_assert_false (g_output_stream_is_closed (data->ostream));
371 g_output_stream_close_async (data->ostream, 0, NULL, oclosed_cb, data);
376 opending_cb (GObject *source,
380 CreateDeleteData *data = user_data;
384 g_output_stream_write_finish (data->ostream, res, &error);
385 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
386 g_error_free (error);
390 created_cb (GObject *source,
394 GFileOutputStream *base;
395 CreateDeleteData *data = user_data;
399 base = g_file_create_finish (G_FILE (source), res, &error);
400 g_assert_no_error (error);
401 g_assert_true (g_file_query_exists (data->file, NULL));
403 if (data->buffersize == 0)
404 data->ostream = G_OUTPUT_STREAM (g_object_ref (base));
406 data->ostream = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM (base), data->buffersize);
407 g_object_unref (base);
409 g_output_stream_write_async (data->ostream,
416 /* check that we get a pending error */
417 g_output_stream_write_async (data->ostream,
427 stop_timeout (gpointer user_data)
429 CreateDeleteData *data = user_data;
431 data->timed_out = TRUE;
432 g_main_context_wakeup (data->context);
434 return G_SOURCE_REMOVE;
438 * This test does a fully async create-write-read-delete.
442 test_create_delete (gconstpointer d)
445 CreateDeleteData *data;
446 GFileIOStream *iostream;
448 data = g_new0 (CreateDeleteData, 1);
450 data->buffersize = GPOINTER_TO_INT (d);
451 data->data = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ0123456789";
454 data->file = g_file_new_tmp ("g_file_create_delete_XXXXXX",
456 g_assert_nonnull (data->file);
457 g_object_unref (iostream);
459 data->monitor_path = g_file_get_path (data->file);
460 remove (data->monitor_path);
462 g_assert_false (g_file_query_exists (data->file, NULL));
465 data->monitor = g_file_monitor_file (data->file, 0, NULL, &error);
466 g_assert_no_error (error);
468 /* This test doesn't work with GPollFileMonitor, because it assumes
469 * that the monitor will notice a create immediately followed by a
470 * delete, rather than coalescing them into nothing.
472 /* This test also doesn't work with GKqueueFileMonitor because of
473 * the same reason. Kqueue is able to return a kevent when a file is
474 * created or deleted in a directory. However, the kernel doesn't tell
475 * the program file names, so GKqueueFileMonitor has to calculate the
476 * difference itself. This is usually too slow for rapid file creation
477 * and deletion tests.
479 if (strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GPollFileMonitor") == 0 ||
480 strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GKqueueFileMonitor") == 0)
482 g_test_skip ("skipping test for this GFileMonitor implementation");
486 g_file_monitor_set_rate_limit (data->monitor, 100);
488 g_signal_connect (data->monitor, "changed", G_CALLBACK (monitor_changed), data);
490 /* Use the global default main context */
491 data->context = NULL;
492 data->timeout = g_timeout_add_seconds (10, stop_timeout, data);
494 g_file_create_async (data->file, 0, 0, NULL, created_cb, data);
496 while (!data->timed_out &&
497 (data->monitor_created == 0 ||
498 data->monitor_deleted == 0 ||
499 data->monitor_changed == 0 ||
500 !data->file_deleted))
501 g_main_context_iteration (data->context, TRUE);
503 g_source_remove (data->timeout);
505 g_assert_false (data->timed_out);
506 g_assert_true (data->file_deleted);
507 g_assert_cmpint (data->monitor_created, ==, 1);
508 g_assert_cmpint (data->monitor_deleted, ==, 1);
509 g_assert_cmpint (data->monitor_changed, >, 0);
511 g_assert_false (g_file_monitor_is_cancelled (data->monitor));
512 g_file_monitor_cancel (data->monitor);
513 g_assert_true (g_file_monitor_is_cancelled (data->monitor));
515 g_clear_pointer (&data->context, g_main_context_unref);
516 g_object_unref (data->ostream);
517 g_object_unref (data->istream);
520 g_object_unref (data->monitor);
521 g_object_unref (data->file);
522 g_free (data->monitor_path);
523 g_free (data->buffer);
527 static const gchar *original_data =
529 " * g_file_replace_contents_async:\n"
532 static const gchar *replace_data =
534 " * g_file_replace_contents_async:\n"
535 " * @file: input #GFile.\n"
536 " * @contents: string of contents to replace the file with.\n"
537 " * @length: the length of @contents in bytes.\n"
538 " * @etag: (nullable): a new <link linkend=\"gfile-etag\">entity tag</link> for the @file, or %NULL\n"
539 " * @make_backup: %TRUE if a backup should be created.\n"
540 " * @flags: a set of #GFileCreateFlags.\n"
541 " * @cancellable: optional #GCancellable object, %NULL to ignore.\n"
542 " * @callback: a #GAsyncReadyCallback to call when the request is satisfied\n"
543 " * @user_data: the data to pass to callback function\n"
545 " * Starts an asynchronous replacement of @file with the given \n"
546 " * @contents of @length bytes. @etag will replace the document's\n"
547 " * current entity tag.\n"
549 " * When this operation has completed, @callback will be called with\n"
550 " * @user_user data, and the operation can be finalized with \n"
551 " * g_file_replace_contents_finish().\n"
553 " * If @cancellable is not %NULL, then the operation can be cancelled by\n"
554 " * triggering the cancellable object from another thread. If the operation\n"
555 " * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. \n"
557 " * If @make_backup is %TRUE, this function will attempt to \n"
558 " * make a backup of @file.\n"
569 static void replaced_cb (GObject *source,
574 loaded_cb (GObject *source,
578 ReplaceLoadData *data = user_data;
585 ret = g_file_load_contents_finish (data->file, res, &contents, &length, NULL, &error);
587 g_assert_no_error (error);
588 g_assert_cmpint (length, ==, strlen (data->data));
589 g_assert_cmpstr (contents, ==, data->data);
596 data->data = "pi pa po";
598 g_file_replace_contents_async (data->file,
611 ret = g_file_delete (data->file, NULL, &error);
612 g_assert_no_error (error);
614 g_assert_false (g_file_query_exists (data->file, NULL));
616 g_main_loop_quit (data->loop);
621 replaced_cb (GObject *source,
625 ReplaceLoadData *data = user_data;
629 g_file_replace_contents_finish (data->file, res, NULL, &error);
630 g_assert_no_error (error);
632 g_file_load_contents_async (data->file, NULL, loaded_cb, data);
636 test_replace_load (void)
638 ReplaceLoadData *data;
640 GFileIOStream *iostream;
642 data = g_new0 (ReplaceLoadData, 1);
644 data->data = replace_data;
646 data->file = g_file_new_tmp ("g_file_replace_load_XXXXXX",
648 g_assert_nonnull (data->file);
649 g_object_unref (iostream);
651 path = g_file_peek_path (data->file);
654 g_assert_false (g_file_query_exists (data->file, NULL));
656 data->loop = g_main_loop_new (NULL, FALSE);
658 g_file_replace_contents_async (data->file,
668 g_main_loop_run (data->loop);
670 g_main_loop_unref (data->loop);
671 g_object_unref (data->file);
676 test_replace_cancel (void)
678 GFile *tmpdir, *file;
679 GFileOutputStream *ostream;
680 GFileEnumerator *fenum;
682 GCancellable *cancellable;
685 gsize nwrote, length;
687 GError *error = NULL;
689 g_test_bug ("629301");
691 path = g_dir_make_tmp ("g_file_replace_cancel_XXXXXX", &error);
692 g_assert_no_error (error);
693 tmpdir = g_file_new_for_path (path);
696 file = g_file_get_child (tmpdir, "file");
697 g_file_replace_contents (file,
699 strlen (original_data),
700 NULL, FALSE, 0, NULL,
702 g_assert_no_error (error);
704 ostream = g_file_replace (file, NULL, TRUE, 0, NULL, &error);
705 g_assert_no_error (error);
707 g_output_stream_write_all (G_OUTPUT_STREAM (ostream),
708 replace_data, strlen (replace_data),
709 &nwrote, NULL, &error);
710 g_assert_no_error (error);
711 g_assert_cmpint (nwrote, ==, strlen (replace_data));
713 /* At this point there should be two files; the original and the
716 fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
717 g_assert_no_error (error);
719 info = g_file_enumerator_next_file (fenum, NULL, &error);
720 g_assert_no_error (error);
721 g_assert_nonnull (info);
722 g_object_unref (info);
723 info = g_file_enumerator_next_file (fenum, NULL, &error);
724 g_assert_no_error (error);
725 g_assert_nonnull (info);
726 g_object_unref (info);
728 g_file_enumerator_close (fenum, NULL, &error);
729 g_assert_no_error (error);
730 g_object_unref (fenum);
732 /* Also test the g_file_enumerator_iterate() API */
733 fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
734 g_assert_no_error (error);
739 gboolean ret = g_file_enumerator_iterate (fenum, &info, NULL, NULL, &error);
741 g_assert_no_error (error);
746 g_assert_cmpint (count, ==, 2);
748 g_file_enumerator_close (fenum, NULL, &error);
749 g_assert_no_error (error);
750 g_object_unref (fenum);
752 /* Now test just getting child from the g_file_enumerator_iterate() API */
753 fenum = g_file_enumerate_children (tmpdir, "standard::name", 0, NULL, &error);
754 g_assert_no_error (error);
760 gboolean ret = g_file_enumerator_iterate (fenum, NULL, &child, NULL, &error);
763 g_assert_no_error (error);
768 g_assert_true (G_IS_FILE (child));
771 g_assert_cmpint (count, ==, 2);
773 g_file_enumerator_close (fenum, NULL, &error);
774 g_assert_no_error (error);
775 g_object_unref (fenum);
777 /* Make sure the temporary gets deleted even if we cancel. */
778 cancellable = g_cancellable_new ();
779 g_cancellable_cancel (cancellable);
780 g_output_stream_close (G_OUTPUT_STREAM (ostream), cancellable, &error);
781 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
782 g_clear_error (&error);
784 g_object_unref (cancellable);
785 g_object_unref (ostream);
787 /* Make sure that file contents wasn't actually replaced. */
788 g_file_load_contents (file,
794 g_assert_no_error (error);
795 g_assert_cmpstr (contents, ==, original_data);
798 g_file_delete (file, NULL, &error);
799 g_assert_no_error (error);
800 g_object_unref (file);
802 /* This will only succeed if the temp file was deleted. */
803 g_file_delete (tmpdir, NULL, &error);
804 g_assert_no_error (error);
805 g_object_unref (tmpdir);
809 on_file_deleted (GObject *object,
810 GAsyncResult *result,
813 GError *local_error = NULL;
814 GMainLoop *loop = user_data;
816 (void) g_file_delete_finish ((GFile*)object, result, &local_error);
817 g_assert_no_error (local_error);
819 g_main_loop_quit (loop);
823 test_async_delete (void)
826 GFileIOStream *iostream;
827 GError *local_error = NULL;
828 GError **error = &local_error;
831 file = g_file_new_tmp ("g_file_delete_XXXXXX",
833 g_assert_no_error (local_error);
834 g_object_unref (iostream);
836 g_assert_true (g_file_query_exists (file, NULL));
838 loop = g_main_loop_new (NULL, TRUE);
840 g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, on_file_deleted, loop);
842 g_main_loop_run (loop);
844 g_assert_false (g_file_query_exists (file, NULL));
846 g_main_loop_unref (loop);
847 g_object_unref (file);
851 test_copy_preserve_mode (void)
854 mode_t current_umask = umask (0);
858 guint32 expected_destination_mode;
859 gboolean create_destination_before_copy;
860 GFileCopyFlags copy_flags;
864 /* Overwriting the destination file should copy the permissions from the
865 * source file, even if %G_FILE_COPY_ALL_METADATA is set: */
866 { 0600, 0600, TRUE, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
867 { 0600, 0600, TRUE, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS },
868 /* The same behaviour should hold if the destination file is not being
869 * overwritten because it doesn’t already exist: */
870 { 0600, 0600, FALSE, G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
871 { 0600, 0600, FALSE, G_FILE_COPY_NOFOLLOW_SYMLINKS },
872 /* Anything with %G_FILE_COPY_TARGET_DEFAULT_PERMS should use the current
873 * umask for the destination file: */
874 { 0600, 0666 & ~current_umask, TRUE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
875 { 0600, 0666 & ~current_umask, TRUE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS },
876 { 0600, 0666 & ~current_umask, FALSE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA },
877 { 0600, 0666 & ~current_umask, FALSE, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_NOFOLLOW_SYMLINKS },
881 /* Reset the umask after querying it above. There’s no way to query it without
883 umask (current_umask);
884 g_test_message ("Current umask: %u", current_umask);
886 for (i = 0; i < G_N_ELEMENTS (vectors); i++)
890 GFileInfo *dest_info;
891 GFileIOStream *iostream;
892 GError *local_error = NULL;
893 guint32 romode = vectors[i].source_mode;
896 g_test_message ("Vector %" G_GSIZE_FORMAT, i);
898 tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
899 &iostream, &local_error);
900 g_assert_no_error (local_error);
901 g_io_stream_close ((GIOStream*)iostream, NULL, &local_error);
902 g_assert_no_error (local_error);
903 g_clear_object (&iostream);
905 g_file_set_attribute (tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_ATTRIBUTE_TYPE_UINT32,
906 &romode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
908 g_assert_no_error (local_error);
910 dest_tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
911 &iostream, &local_error);
912 g_assert_no_error (local_error);
913 g_io_stream_close ((GIOStream*)iostream, NULL, &local_error);
914 g_assert_no_error (local_error);
915 g_clear_object (&iostream);
917 if (!vectors[i].create_destination_before_copy)
919 g_file_delete (dest_tmpfile, NULL, &local_error);
920 g_assert_no_error (local_error);
923 g_file_copy (tmpfile, dest_tmpfile, vectors[i].copy_flags,
924 NULL, NULL, NULL, &local_error);
925 g_assert_no_error (local_error);
927 dest_info = g_file_query_info (dest_tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
929 g_assert_no_error (local_error);
931 dest_mode = g_file_info_get_attribute_uint32 (dest_info, G_FILE_ATTRIBUTE_UNIX_MODE);
933 g_assert_cmpint (dest_mode & ~S_IFMT, ==, vectors[i].expected_destination_mode);
934 g_assert_cmpint (dest_mode & S_IFMT, ==, S_IFREG);
936 (void) g_file_delete (tmpfile, NULL, NULL);
937 (void) g_file_delete (dest_tmpfile, NULL, NULL);
939 g_clear_object (&tmpfile);
940 g_clear_object (&dest_tmpfile);
941 g_clear_object (&dest_info);
943 #else /* if !G_OS_UNIX */
944 g_test_skip ("File permissions tests can only be run on Unix")
949 splice_to_string (GInputStream *stream,
952 GMemoryOutputStream *buffer = NULL;
955 buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
956 if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
959 if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
962 if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
965 ret = g_memory_output_stream_steal_data (buffer);
967 g_clear_object (&buffer);
972 get_size_from_du (const gchar *path, guint64 *size)
978 GError *error = NULL;
979 gchar *du_path = NULL;
981 /* If we can’t find du, don’t try and run the test. */
982 du_path = g_find_program_in_path ("du");
987 du = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE,
989 "du", "--bytes", "-s", path, NULL);
990 g_assert_no_error (error);
992 result = splice_to_string (g_subprocess_get_stdout_pipe (du), &error);
993 g_assert_no_error (error);
995 *size = g_ascii_strtoll (result, &endptr, 10);
997 g_subprocess_wait (du, NULL, &error);
998 g_assert_no_error (error);
1000 ok = g_subprocess_get_successful (du);
1002 g_object_unref (du);
1016 GError *error = NULL;
1020 path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1021 file = g_file_new_for_path (path);
1023 if (!get_size_from_du (path, &size))
1025 g_test_message ("du not found or fail to run, skipping byte measurement");
1029 ok = g_file_measure_disk_usage (file,
1030 G_FILE_MEASURE_APPARENT_SIZE,
1039 g_assert_no_error (error);
1042 g_assert_cmpuint (num_bytes, ==, size);
1043 g_assert_cmpuint (num_dirs, ==, 6);
1044 g_assert_cmpuint (num_files, ==, 32);
1046 g_object_unref (file);
1051 guint64 expected_bytes;
1052 guint64 expected_dirs;
1053 guint64 expected_files;
1054 gint progress_count;
1055 guint64 progress_bytes;
1056 guint64 progress_dirs;
1057 guint64 progress_files;
1061 measure_progress (gboolean reporting,
1062 guint64 current_size,
1067 MeasureData *data = user_data;
1069 data->progress_count += 1;
1071 g_assert_cmpuint (current_size, >=, data->progress_bytes);
1072 g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1073 g_assert_cmpuint (num_files, >=, data->progress_files);
1075 data->progress_bytes = current_size;
1076 data->progress_dirs = num_dirs;
1077 data->progress_files = num_files;
1081 measure_done (GObject *source,
1085 MeasureData *data = user_data;
1086 guint64 num_bytes, num_dirs, num_files;
1087 GError *error = NULL;
1090 ok = g_file_measure_disk_usage_finish (G_FILE (source), res, &num_bytes, &num_dirs, &num_files, &error);
1092 g_assert_no_error (error);
1094 if (data->expected_bytes > 0)
1095 g_assert_cmpuint (data->expected_bytes, ==, num_bytes);
1096 g_assert_cmpuint (data->expected_dirs, ==, num_dirs);
1097 g_assert_cmpuint (data->expected_files, ==, num_files);
1099 g_assert_cmpuint (data->progress_count, >, 0);
1100 g_assert_cmpuint (num_bytes, >=, data->progress_bytes);
1101 g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1102 g_assert_cmpuint (num_files, >=, data->progress_files);
1105 g_object_unref (source);
1109 test_measure_async (void)
1115 data = g_new (MeasureData, 1);
1117 data->progress_count = 0;
1118 data->progress_bytes = 0;
1119 data->progress_files = 0;
1120 data->progress_dirs = 0;
1122 path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1123 file = g_file_new_for_path (path);
1125 if (!get_size_from_du (path, &data->expected_bytes))
1127 g_test_message ("du not found or fail to run, skipping byte measurement");
1128 data->expected_bytes = 0;
1133 data->expected_dirs = 6;
1134 data->expected_files = 32;
1136 g_file_measure_disk_usage_async (file,
1137 G_FILE_MEASURE_APPARENT_SIZE,
1139 measure_progress, data,
1140 measure_done, data);
1144 test_load_bytes (void)
1146 gchar filename[] = "g_file_load_bytes_XXXXXX";
1147 GError *error = NULL;
1154 fd = g_mkstemp (filename);
1155 g_assert_cmpint (fd, !=, -1);
1156 len = strlen ("test_load_bytes");
1157 ret = write (fd, "test_load_bytes", len);
1158 g_assert_cmpint (ret, ==, len);
1161 file = g_file_new_for_path (filename);
1162 bytes = g_file_load_bytes (file, NULL, NULL, &error);
1163 g_assert_no_error (error);
1164 g_assert_nonnull (bytes);
1165 g_assert_cmpint (len, ==, g_bytes_get_size (bytes));
1166 g_assert_cmpstr ("test_load_bytes", ==, (gchar *)g_bytes_get_data (bytes, NULL));
1168 g_file_delete (file, NULL, NULL);
1170 g_bytes_unref (bytes);
1171 g_object_unref (file);
1176 GMainLoop *main_loop;
1179 } LoadBytesAsyncData;
1182 test_load_bytes_cb (GObject *object,
1183 GAsyncResult *result,
1186 GFile *file = G_FILE (object);
1187 LoadBytesAsyncData *data = user_data;
1188 GError *error = NULL;
1190 data->bytes = g_file_load_bytes_finish (file, result, NULL, &error);
1191 g_assert_no_error (error);
1192 g_assert_nonnull (data->bytes);
1194 g_main_loop_quit (data->main_loop);
1198 test_load_bytes_async (void)
1200 LoadBytesAsyncData data = { 0 };
1201 gchar filename[] = "g_file_load_bytes_XXXXXX";
1206 fd = g_mkstemp (filename);
1207 g_assert_cmpint (fd, !=, -1);
1208 len = strlen ("test_load_bytes_async");
1209 ret = write (fd, "test_load_bytes_async", len);
1210 g_assert_cmpint (ret, ==, len);
1213 data.main_loop = g_main_loop_new (NULL, FALSE);
1214 data.file = g_file_new_for_path (filename);
1216 g_file_load_bytes_async (data.file, NULL, test_load_bytes_cb, &data);
1217 g_main_loop_run (data.main_loop);
1219 g_assert_cmpint (len, ==, g_bytes_get_size (data.bytes));
1220 g_assert_cmpstr ("test_load_bytes_async", ==, (gchar *)g_bytes_get_data (data.bytes, NULL));
1222 g_file_delete (data.file, NULL, NULL);
1223 g_object_unref (data.file);
1224 g_bytes_unref (data.bytes);
1225 g_main_loop_unref (data.main_loop);
1229 test_writev_helper (GOutputVector *vectors,
1231 gboolean use_bytes_written,
1232 const guint8 *expected_contents,
1233 gsize expected_length)
1236 GFileIOStream *iostream = NULL;
1237 GOutputStream *ostream;
1238 GError *error = NULL;
1239 gsize bytes_written = 0;
1244 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1246 g_assert_nonnull (file);
1247 g_assert_nonnull (iostream);
1249 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1251 res = g_output_stream_writev_all (ostream, vectors, n_vectors, use_bytes_written ? &bytes_written : NULL, NULL, &error);
1252 g_assert_no_error (error);
1253 g_assert_true (res);
1254 if (use_bytes_written)
1255 g_assert_cmpuint (bytes_written, ==, expected_length);
1257 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1258 g_assert_no_error (error);
1259 g_assert_true (res);
1260 g_object_unref (iostream);
1262 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1263 g_assert_no_error (error);
1264 g_assert_true (res);
1266 g_assert_cmpmem (contents, length, expected_contents, expected_length);
1270 g_file_delete (file, NULL, NULL);
1271 g_object_unref (file);
1274 /* Test that writev() on local file output streams works on a non-empty vector */
1278 GOutputVector vectors[3];
1279 const guint8 buffer[] = {1, 2, 3, 4, 5,
1280 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1283 vectors[0].buffer = buffer;
1284 vectors[0].size = 5;
1286 vectors[1].buffer = buffer + 5;
1287 vectors[1].size = 12;
1289 vectors[2].buffer = buffer + 5 + 12;
1290 vectors[2].size = 3;
1292 test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, buffer, sizeof buffer);
1295 /* Test that writev() on local file output streams works on a non-empty vector without returning bytes_written */
1297 test_writev_no_bytes_written (void)
1299 GOutputVector vectors[3];
1300 const guint8 buffer[] = {1, 2, 3, 4, 5,
1301 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1304 vectors[0].buffer = buffer;
1305 vectors[0].size = 5;
1307 vectors[1].buffer = buffer + 5;
1308 vectors[1].size = 12;
1310 vectors[2].buffer = buffer + 5 + 12;
1311 vectors[2].size = 3;
1313 test_writev_helper (vectors, G_N_ELEMENTS (vectors), FALSE, buffer, sizeof buffer);
1316 /* Test that writev() on local file output streams works on 0 vectors */
1318 test_writev_no_vectors (void)
1320 test_writev_helper (NULL, 0, TRUE, NULL, 0);
1323 /* Test that writev() on local file output streams works on empty vectors */
1325 test_writev_empty_vectors (void)
1327 GOutputVector vectors[3];
1329 vectors[0].buffer = NULL;
1330 vectors[0].size = 0;
1331 vectors[1].buffer = NULL;
1332 vectors[1].size = 0;
1333 vectors[2].buffer = NULL;
1334 vectors[2].size = 0;
1336 test_writev_helper (vectors, G_N_ELEMENTS (vectors), TRUE, NULL, 0);
1339 /* Test that writev() fails if the sum of sizes in the vector is too big */
1341 test_writev_too_big_vectors (void)
1344 GFileIOStream *iostream = NULL;
1345 GOutputStream *ostream;
1346 GError *error = NULL;
1347 gsize bytes_written = 0;
1351 GOutputVector vectors[3];
1353 vectors[0].buffer = (void*) 1;
1354 vectors[0].size = G_MAXSIZE / 2;
1356 vectors[1].buffer = (void*) 1;
1357 vectors[1].size = G_MAXSIZE / 2;
1359 vectors[2].buffer = (void*) 1;
1360 vectors[2].size = G_MAXSIZE / 2;
1362 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1364 g_assert_nonnull (file);
1365 g_assert_nonnull (iostream);
1367 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1369 res = g_output_stream_writev_all (ostream, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1370 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1371 g_assert_cmpuint (bytes_written, ==, 0);
1372 g_assert_false (res);
1373 g_clear_error (&error);
1375 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1376 g_assert_no_error (error);
1377 g_assert_true (res);
1378 g_object_unref (iostream);
1380 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1381 g_assert_no_error (error);
1382 g_assert_true (res);
1384 g_assert_cmpmem (contents, length, NULL, 0);
1388 g_file_delete (file, NULL, NULL);
1389 g_object_unref (file);
1394 gsize bytes_written;
1395 GOutputVector *vectors;
1402 test_writev_async_cb (GObject *object,
1403 GAsyncResult *result,
1406 GOutputStream *ostream = G_OUTPUT_STREAM (object);
1407 WritevAsyncData *data = user_data;
1408 GError *error = NULL;
1409 gsize bytes_written;
1412 res = g_output_stream_writev_finish (ostream, result, &bytes_written, &error);
1413 g_assert_true (res);
1414 g_assert_no_error (error);
1415 data->bytes_written += bytes_written;
1417 /* skip vectors that have been written in full */
1418 while (data->n_vectors > 0 && bytes_written >= data->vectors[0].size)
1420 bytes_written -= data->vectors[0].size;
1424 /* skip partially written vector data */
1425 if (bytes_written > 0 && data->n_vectors > 0)
1427 data->vectors[0].size -= bytes_written;
1428 data->vectors[0].buffer = ((guint8 *) data->vectors[0].buffer) + bytes_written;
1431 if (data->n_vectors > 0)
1432 g_output_stream_writev_async (ostream, data->vectors, data->n_vectors, 0, NULL, test_writev_async_cb, &data);
1435 /* Test that writev_async() on local file output streams works on a non-empty vector */
1437 test_writev_async (void)
1439 WritevAsyncData data = { 0 };
1441 GFileIOStream *iostream = NULL;
1442 GOutputVector vectors[3];
1443 const guint8 buffer[] = {1, 2, 3, 4, 5,
1444 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1446 GOutputStream *ostream;
1447 GError *error = NULL;
1452 vectors[0].buffer = buffer;
1453 vectors[0].size = 5;
1455 vectors[1].buffer = buffer + 5;
1456 vectors[1].size = 12;
1458 vectors[2].buffer = buffer + 5 + 12;
1459 vectors[2].size = 3;
1461 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1463 g_assert_nonnull (file);
1464 g_assert_nonnull (iostream);
1466 data.vectors = vectors;
1467 data.n_vectors = G_N_ELEMENTS (vectors);
1469 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1471 g_output_stream_writev_async (ostream, data.vectors, data.n_vectors, 0, NULL, test_writev_async_cb, &data);
1473 while (data.n_vectors > 0)
1474 g_main_context_iteration (NULL, TRUE);
1476 g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1478 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1479 g_assert_no_error (error);
1480 g_assert_true (res);
1481 g_object_unref (iostream);
1483 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1484 g_assert_no_error (error);
1485 g_assert_true (res);
1487 g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1491 g_file_delete (file, NULL, NULL);
1492 g_object_unref (file);
1496 test_writev_all_cb (GObject *object,
1497 GAsyncResult *result,
1500 GOutputStream *ostream = G_OUTPUT_STREAM (object);
1501 WritevAsyncData *data = user_data;
1503 g_output_stream_writev_all_finish (ostream, result, &data->bytes_written, &data->error);
1507 /* Test that writev_async_all() on local file output streams works on a non-empty vector */
1509 test_writev_async_all (void)
1511 WritevAsyncData data = { 0 };
1513 GFileIOStream *iostream = NULL;
1514 GOutputStream *ostream;
1515 GOutputVector vectors[3];
1516 const guint8 buffer[] = {1, 2, 3, 4, 5,
1517 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1519 GError *error = NULL;
1524 vectors[0].buffer = buffer;
1525 vectors[0].size = 5;
1527 vectors[1].buffer = buffer + 5;
1528 vectors[1].size = 12;
1530 vectors[2].buffer = buffer + 5 + 12;
1531 vectors[2].size = 3;
1533 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1535 g_assert_nonnull (file);
1536 g_assert_nonnull (iostream);
1538 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1540 g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1543 g_main_context_iteration (NULL, TRUE);
1545 g_assert_cmpuint (data.bytes_written, ==, sizeof buffer);
1546 g_assert_no_error (data.error);
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);
1553 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1554 g_assert_no_error (error);
1555 g_assert_true (res);
1557 g_assert_cmpmem (contents, length, buffer, sizeof buffer);
1561 g_file_delete (file, NULL, NULL);
1562 g_object_unref (file);
1565 /* Test that writev_async_all() on local file output streams handles cancellation correctly */
1567 test_writev_async_all_cancellation (void)
1569 WritevAsyncData data = { 0 };
1571 GFileIOStream *iostream = NULL;
1572 GOutputVector vectors[3];
1573 const guint8 buffer[] = {1, 2, 3, 4, 5,
1574 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1576 GOutputStream *ostream;
1577 GError *error = NULL;
1581 GCancellable *cancellable;
1583 vectors[0].buffer = buffer;
1584 vectors[0].size = 5;
1586 vectors[1].buffer = buffer + 5;
1587 vectors[1].size = 12;
1589 vectors[2].buffer = buffer + 5 + 12;
1590 vectors[2].size = 3;
1592 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1594 g_assert_nonnull (file);
1595 g_assert_nonnull (iostream);
1597 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1599 cancellable = g_cancellable_new ();
1600 g_cancellable_cancel (cancellable);
1602 g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, cancellable, test_writev_all_cb, &data);
1605 g_main_context_iteration (NULL, TRUE);
1607 g_assert_cmpuint (data.bytes_written, ==, 0);
1608 g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1609 g_clear_error (&data.error);
1611 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1612 g_assert_no_error (error);
1613 g_assert_true (res);
1614 g_object_unref (iostream);
1616 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1617 g_assert_no_error (error);
1618 g_assert_true (res);
1619 g_assert_cmpuint (length, ==, 0);
1623 g_file_delete (file, NULL, NULL);
1624 g_object_unref (file);
1625 g_object_unref (cancellable);
1628 /* Test that writev_async_all() with empty vectors is handled correctly */
1630 test_writev_async_all_empty_vectors (void)
1632 WritevAsyncData data = { 0 };
1634 GFileIOStream *iostream = NULL;
1635 GOutputVector vectors[3];
1636 GOutputStream *ostream;
1637 GError *error = NULL;
1642 vectors[0].buffer = NULL;
1643 vectors[0].size = 0;
1645 vectors[1].buffer = NULL;
1646 vectors[1].size = 0;
1648 vectors[2].buffer = NULL;
1649 vectors[2].size = 0;
1651 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1653 g_assert_nonnull (file);
1654 g_assert_nonnull (iostream);
1656 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1658 g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1661 g_main_context_iteration (NULL, TRUE);
1663 g_assert_cmpuint (data.bytes_written, ==, 0);
1664 g_assert_no_error (data.error);
1665 g_clear_error (&data.error);
1667 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1668 g_assert_no_error (error);
1669 g_assert_true (res);
1670 g_object_unref (iostream);
1672 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1673 g_assert_no_error (error);
1674 g_assert_true (res);
1675 g_assert_cmpuint (length, ==, 0);
1679 g_file_delete (file, NULL, NULL);
1680 g_object_unref (file);
1683 /* Test that writev_async_all() with no vectors is handled correctly */
1685 test_writev_async_all_no_vectors (void)
1687 WritevAsyncData data = { 0 };
1689 GFileIOStream *iostream = NULL;
1690 GOutputStream *ostream;
1691 GError *error = NULL;
1696 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1698 g_assert_nonnull (file);
1699 g_assert_nonnull (iostream);
1701 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1703 g_output_stream_writev_all_async (ostream, NULL, 0, 0, NULL, test_writev_all_cb, &data);
1706 g_main_context_iteration (NULL, TRUE);
1708 g_assert_cmpuint (data.bytes_written, ==, 0);
1709 g_assert_no_error (data.error);
1710 g_clear_error (&data.error);
1712 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1713 g_assert_no_error (error);
1714 g_assert_true (res);
1715 g_object_unref (iostream);
1717 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1718 g_assert_no_error (error);
1719 g_assert_true (res);
1720 g_assert_cmpuint (length, ==, 0);
1724 g_file_delete (file, NULL, NULL);
1725 g_object_unref (file);
1728 /* Test that writev_async_all() with too big vectors is handled correctly */
1730 test_writev_async_all_too_big_vectors (void)
1732 WritevAsyncData data = { 0 };
1734 GFileIOStream *iostream = NULL;
1735 GOutputVector vectors[3];
1736 GOutputStream *ostream;
1737 GError *error = NULL;
1742 vectors[0].buffer = (void*) 1;
1743 vectors[0].size = G_MAXSIZE / 2;
1745 vectors[1].buffer = (void*) 1;
1746 vectors[1].size = G_MAXSIZE / 2;
1748 vectors[2].buffer = (void*) 1;
1749 vectors[2].size = G_MAXSIZE / 2;
1751 file = g_file_new_tmp ("g_file_writev_XXXXXX",
1753 g_assert_nonnull (file);
1754 g_assert_nonnull (iostream);
1756 ostream = g_io_stream_get_output_stream (G_IO_STREAM (iostream));
1758 g_output_stream_writev_all_async (ostream, vectors, G_N_ELEMENTS (vectors), 0, NULL, test_writev_all_cb, &data);
1761 g_main_context_iteration (NULL, TRUE);
1763 g_assert_cmpuint (data.bytes_written, ==, 0);
1764 g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1765 g_clear_error (&data.error);
1767 res = g_io_stream_close (G_IO_STREAM (iostream), NULL, &error);
1768 g_assert_no_error (error);
1769 g_assert_true (res);
1770 g_object_unref (iostream);
1772 res = g_file_load_contents (file, NULL, (gchar **) &contents, &length, NULL, &error);
1773 g_assert_no_error (error);
1774 g_assert_true (res);
1775 g_assert_cmpuint (length, ==, 0);
1779 g_file_delete (file, NULL, NULL);
1780 g_object_unref (file);
1784 main (int argc, char *argv[])
1786 g_test_init (&argc, &argv, NULL);
1788 g_test_bug_base ("http://bugzilla.gnome.org/");
1790 g_test_add_func ("/file/basic", test_basic);
1791 g_test_add_func ("/file/build-filename", test_build_filename);
1792 g_test_add_func ("/file/parent", test_parent);
1793 g_test_add_func ("/file/child", test_child);
1794 g_test_add_func ("/file/type", test_type);
1795 g_test_add_func ("/file/parse-name", test_parse_name);
1796 g_test_add_data_func ("/file/async-create-delete/0", GINT_TO_POINTER (0), test_create_delete);
1797 g_test_add_data_func ("/file/async-create-delete/1", GINT_TO_POINTER (1), test_create_delete);
1798 g_test_add_data_func ("/file/async-create-delete/10", GINT_TO_POINTER (10), test_create_delete);
1799 g_test_add_data_func ("/file/async-create-delete/25", GINT_TO_POINTER (25), test_create_delete);
1800 g_test_add_data_func ("/file/async-create-delete/4096", GINT_TO_POINTER (4096), test_create_delete);
1801 g_test_add_func ("/file/replace-load", test_replace_load);
1802 g_test_add_func ("/file/replace-cancel", test_replace_cancel);
1803 g_test_add_func ("/file/async-delete", test_async_delete);
1804 g_test_add_func ("/file/copy-preserve-mode", test_copy_preserve_mode);
1805 g_test_add_func ("/file/measure", test_measure);
1806 g_test_add_func ("/file/measure-async", test_measure_async);
1807 g_test_add_func ("/file/load-bytes", test_load_bytes);
1808 g_test_add_func ("/file/load-bytes-async", test_load_bytes_async);
1809 g_test_add_func ("/file/writev", test_writev);
1810 g_test_add_func ("/file/writev/no-bytes-written", test_writev_no_bytes_written);
1811 g_test_add_func ("/file/writev/no-vectors", test_writev_no_vectors);
1812 g_test_add_func ("/file/writev/empty-vectors", test_writev_empty_vectors);
1813 g_test_add_func ("/file/writev/too-big-vectors", test_writev_too_big_vectors);
1814 g_test_add_func ("/file/writev/async", test_writev_async);
1815 g_test_add_func ("/file/writev/async_all", test_writev_async_all);
1816 g_test_add_func ("/file/writev/async_all-empty-vectors", test_writev_async_all_empty_vectors);
1817 g_test_add_func ("/file/writev/async_all-no-vectors", test_writev_async_all_no_vectors);
1818 g_test_add_func ("/file/writev/async_all-to-big-vectors", test_writev_async_all_too_big_vectors);
1819 g_test_add_func ("/file/writev/async_all-cancellation", test_writev_async_all_cancellation);
1821 return g_test_run ();