?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add some more cases to the app-id unit tests
[glib.git] / gio / tests / file.c
blob7791837911dccde6e2ffb8bc15495fbaa02a6729
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 (void)
12 {
13 GFile *file;
14 gchar *s;
15
16 file = g_file_new_for_path ("./some/directory/testfile");
17
18 s = g_file_get_basename (file);
19 g_assert_cmpstr (s, ==, "testfile");
20 g_free (s);
21
22 s = g_file_get_uri (file);
23 g_assert (g_str_has_prefix (s, "file://"));
24 g_assert (g_str_has_suffix (s, "/some/directory/testfile"));
25 g_free (s);
26
27 g_assert (g_file_has_uri_scheme (file, "file"));
28 s = g_file_get_uri_scheme (file);
29 g_assert_cmpstr (s, ==, "file");
30 g_free (s);
31
32 g_object_unref (file);
33 }
34
35 static void
36 test_parent (void)
37 {
38 GFile *file;
39 GFile *file2;
40 GFile *parent;
41 GFile *root;
42
43 file = g_file_new_for_path ("./some/directory/testfile");
44 file2 = g_file_new_for_path ("./some/directory");
45 root = g_file_new_for_path ("/");
46
47 g_assert (g_file_has_parent (file, file2));
48
49 parent = g_file_get_parent (file);
50 g_assert (g_file_equal (parent, file2));
51 g_object_unref (parent);
52
53 g_assert (g_file_get_parent (root) == NULL);
54
55 g_object_unref (file);
56 g_object_unref (file2);
57 g_object_unref (root);
58 }
59
60 static void
61 test_child (void)
62 {
63 GFile *file;
64 GFile *child;
65 GFile *child2;
66
67 file = g_file_new_for_path ("./some/directory");
68 child = g_file_get_child (file, "child");
69 g_assert (g_file_has_parent (child, file));
70
71 child2 = g_file_get_child_for_display_name (file, "child2", NULL);
72 g_assert (g_file_has_parent (child2, file));
73
74 g_object_unref (child);
75 g_object_unref (child2);
76 g_object_unref (file);
77 }
78
79 static void
80 test_type (void)
81 {
82 GFile *datapath_f;
83 GFile *file;
84 GFileType type;
85 GError *error = NULL;
86
87 datapath_f = g_file_new_for_path (g_test_get_dir (G_TEST_DIST));
88
89 file = g_file_get_child (datapath_f, "g-icon.c");
90 type = g_file_query_file_type (file, 0, NULL);
91 g_assert_cmpint (type, ==, G_FILE_TYPE_REGULAR);
92 g_object_unref (file);
93
94 file = g_file_get_child (datapath_f, "cert-tests");
95 type = g_file_query_file_type (file, 0, NULL);
96 g_assert_cmpint (type, ==, G_FILE_TYPE_DIRECTORY);
97
98 g_file_read (file, NULL, &error);
99 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY);
100 g_error_free (error);
101 g_object_unref (file);
102
103 g_object_unref (datapath_f);
104 }
105
106 static void
107 test_parse_name (void)
108 {
109 GFile *file;
110 gchar *name;
111
112 file = g_file_new_for_uri ("file://somewhere");
113 name = g_file_get_parse_name (file);
114 g_assert_cmpstr (name, ==, "file://somewhere");
115 g_object_unref (file);
116 g_free (name);
117
118 file = g_file_parse_name ("~foo");
119 name = g_file_get_parse_name (file);
120 g_assert (name != NULL);
121 g_object_unref (file);
122 g_free (name);
123 }
124
125 typedef struct
126 {
127 GFile *file;
128 GFileMonitor *monitor;
129 GOutputStream *ostream;
130 GInputStream *istream;
131 GMainLoop *loop;
132 gint buffersize;
133 gint monitor_created;
134 gint monitor_deleted;
135 gint monitor_changed;
136 gchar *monitor_path;
137 gint pos;
138 gchar *data;
139 gchar *buffer;
140 guint timeout;
141 } CreateDeleteData;
142
143 static void
144 monitor_changed (GFileMonitor *monitor,
145 GFile *file,
146 GFile *other_file,
147 GFileMonitorEvent event_type,
148 gpointer user_data)
149 {
150 CreateDeleteData *data = user_data;
151 gchar *path;
152
153 path = g_file_get_path (file);
154 g_assert_cmpstr (data->monitor_path, ==, path);
155 g_free (path);
156
157 if (event_type == G_FILE_MONITOR_EVENT_CREATED)
158 data->monitor_created++;
159 if (event_type == G_FILE_MONITOR_EVENT_DELETED)
160 data->monitor_deleted++;
161 if (event_type == G_FILE_MONITOR_EVENT_CHANGED)
162 data->monitor_changed++;
163 }
164
165
166 static gboolean
167 quit_idle (gpointer user_data)
168 {
169 CreateDeleteData *data = user_data;
170
171 g_source_remove (data->timeout);
172 g_main_loop_quit (data->loop);
173
174 return FALSE;
175 }
176
177 static void
178 iclosed_cb (GObject *source,
179 GAsyncResult *res,
180 gpointer user_data)
181 {
182 CreateDeleteData *data = user_data;
183 GError *error;
184 gboolean ret;
185
186 error = NULL;
187 ret = g_input_stream_close_finish (data->istream, res, &error);
188 g_assert_no_error (error);
189 g_assert (ret);
190
191 g_assert (g_input_stream_is_closed (data->istream));
192
193 ret = g_file_delete (data->file, NULL, &error);
194 g_assert (ret);
195 g_assert_no_error (error);
196
197 /* work around file monitor bug:
198 * inotify events are only processed every 1000 ms, regardless
199 * of the rate limit set on the file monitor
200 */
201 g_timeout_add (2000, quit_idle, data);
202 }
203
204 static void
205 read_cb (GObject *source,
206 GAsyncResult *res,
207 gpointer user_data)
208 {
209 CreateDeleteData *data = user_data;
210 GError *error;
211 gssize size;
212
213 error = NULL;
214 size = g_input_stream_read_finish (data->istream, res, &error);
215 g_assert_no_error (error);
216
217 data->pos += size;
218 if (data->pos < strlen (data->data))
219 {
220 g_input_stream_read_async (data->istream,
221 data->buffer + data->pos,
222 strlen (data->data) - data->pos,
223 0,
224 NULL,
225 read_cb,
226 data);
227 }
228 else
229 {
230 g_assert_cmpstr (data->buffer, ==, data->data);
231 g_assert (!g_input_stream_is_closed (data->istream));
232 g_input_stream_close_async (data->istream, 0, NULL, iclosed_cb, data);
233 }
234 }
235
236 static void
237 ipending_cb (GObject *source,
238 GAsyncResult *res,
239 gpointer user_data)
240 {
241 CreateDeleteData *data = user_data;
242 GError *error;
243
244 error = NULL;
245 g_input_stream_read_finish (data->istream, res, &error);
246 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
247 g_error_free (error);
248 }
249
250 static void
251 skipped_cb (GObject *source,
252 GAsyncResult *res,
253 gpointer user_data)
254 {
255 CreateDeleteData *data = user_data;
256 GError *error;
257 gssize size;
258
259 error = NULL;
260 size = g_input_stream_skip_finish (data->istream, res, &error);
261 g_assert_no_error (error);
262 g_assert_cmpint (size, ==, data->pos);
263
264 g_input_stream_read_async (data->istream,
265 data->buffer + data->pos,
266 strlen (data->data) - data->pos,
267 0,
268 NULL,
269 read_cb,
270 data);
271 /* check that we get a pending error */
272 g_input_stream_read_async (data->istream,
273 data->buffer + data->pos,
274 strlen (data->data) - data->pos,
275 0,
276 NULL,
277 ipending_cb,
278 data);
279 }
280
281 static void
282 opened_cb (GObject *source,
283 GAsyncResult *res,
284 gpointer user_data)
285 {
286 GFileInputStream *base;
287 CreateDeleteData *data = user_data;
288 GError *error;
289
290 error = NULL;
291 base = g_file_read_finish (data->file, res, &error);
292 g_assert_no_error (error);
293
294 if (data->buffersize == 0)
295 data->istream = G_INPUT_STREAM (g_object_ref (base));
296 else
297 data->istream = g_buffered_input_stream_new_sized (G_INPUT_STREAM (base), data->buffersize);
298 g_object_unref (base);
299
300 data->buffer = g_new0 (gchar, strlen (data->data) + 1);
301
302 /* copy initial segment directly, then skip */
303 memcpy (data->buffer, data->data, 10);
304 data->pos = 10;
305
306 g_input_stream_skip_async (data->istream,
307 10,
308 0,
309 NULL,
310 skipped_cb,
311 data);
312 }
313
314 static void
315 oclosed_cb (GObject *source,
316 GAsyncResult *res,
317 gpointer user_data)
318 {
319 CreateDeleteData *data = user_data;
320 GError *error;
321 gboolean ret;
322
323 error = NULL;
324 ret = g_output_stream_close_finish (data->ostream, res, &error);
325 g_assert_no_error (error);
326 g_assert (ret);
327 g_assert (g_output_stream_is_closed (data->ostream));
328
329 g_file_read_async (data->file, 0, NULL, opened_cb, data);
330 }
331
332 static void
333 written_cb (GObject *source,
334 GAsyncResult *res,
335 gpointer user_data)
336 {
337 CreateDeleteData *data = user_data;
338 gssize size;
339 GError *error;
340
341 error = NULL;
342 size = g_output_stream_write_finish (data->ostream, res, &error);
343 g_assert_no_error (error);
344
345 data->pos += size;
346 if (data->pos < strlen (data->data))
347 {
348 g_output_stream_write_async (data->ostream,
349 data->data + data->pos,
350 strlen (data->data) - data->pos,
351 0,
352 NULL,
353 written_cb,
354 data);
355 }
356 else
357 {
358 g_assert (!g_output_stream_is_closed (data->ostream));
359 g_output_stream_close_async (data->ostream, 0, NULL, oclosed_cb, data);
360 }
361 }
362
363 static void
364 opending_cb (GObject *source,
365 GAsyncResult *res,
366 gpointer user_data)
367 {
368 CreateDeleteData *data = user_data;
369 GError *error;
370
371 error = NULL;
372 g_output_stream_write_finish (data->ostream, res, &error);
373 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
374 g_error_free (error);
375 }
376
377 static void
378 created_cb (GObject *source,
379 GAsyncResult *res,
380 gpointer user_data)
381 {
382 GFileOutputStream *base;
383 CreateDeleteData *data = user_data;
384 GError *error;
385
386 error = NULL;
387 base = g_file_create_finish (G_FILE (source), res, &error);
388 g_assert_no_error (error);
389 g_assert (g_file_query_exists (data->file, NULL));
390
391 if (data->buffersize == 0)
392 data->ostream = G_OUTPUT_STREAM (g_object_ref (base));
393 else
394 data->ostream = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM (base), data->buffersize);
395 g_object_unref (base);
396
397 g_output_stream_write_async (data->ostream,
398 data->data,
399 strlen (data->data),
400 0,
401 NULL,
402 written_cb,
403 data);
404 /* check that we get a pending error */
405 g_output_stream_write_async (data->ostream,
406 data->data,
407 strlen (data->data),
408 0,
409 NULL,
410 opending_cb,
411 data);
412 }
413
414 static gboolean
415 stop_timeout (gpointer data)
416 {
417 g_assert_not_reached ();
418
419 return FALSE;
420 }
421
422 /*
423 * This test does a fully async create-write-read-delete.
424 * Callbackistan.
425 */
426 static void
427 test_create_delete (gconstpointer d)
428 {
429 GError *error;
430 CreateDeleteData *data;
431 GFileIOStream *iostream;
432
433 data = g_new0 (CreateDeleteData, 1);
434
435 data->buffersize = GPOINTER_TO_INT (d);
436 data->data = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ0123456789";
437 data->pos = 0;
438
439 data->file = g_file_new_tmp ("g_file_create_delete_XXXXXX",
440 &iostream, NULL);
441 g_assert (data->file != NULL);
442 g_object_unref (iostream);
443
444 data->monitor_path = g_file_get_path (data->file);
445 remove (data->monitor_path);
446
447 g_assert (!g_file_query_exists (data->file, NULL));
448
449 error = NULL;
450 data->monitor = g_file_monitor_file (data->file, 0, NULL, &error);
451 g_assert_no_error (error);
452
453 /* This test doesn't work with GPollFileMonitor, because it assumes
454 * that the monitor will notice a create immediately followed by a
455 * delete, rather than coalescing them into nothing.
456 */
457 if (!strcmp (G_OBJECT_TYPE_NAME (data->monitor), "GPollFileMonitor"))
458 {
459 g_test_skip ("skipping test for this GFileMonitor implementation");
460 goto skip;
461 }
462
463 g_file_monitor_set_rate_limit (data->monitor, 100);
464
465 g_signal_connect (data->monitor, "changed", G_CALLBACK (monitor_changed), data);
466
467 data->loop = g_main_loop_new (NULL, FALSE);
468
469 data->timeout = g_timeout_add (5000, stop_timeout, NULL);
470
471 g_file_create_async (data->file, 0, 0, NULL, created_cb, data);
472
473 g_main_loop_run (data->loop);
474
475 g_assert_cmpint (data->monitor_created, ==, 1);
476 g_assert_cmpint (data->monitor_deleted, ==, 1);
477 g_assert_cmpint (data->monitor_changed, >, 0);
478
479 g_assert (!g_file_monitor_is_cancelled (data->monitor));
480 g_file_monitor_cancel (data->monitor);
481 g_assert (g_file_monitor_is_cancelled (data->monitor));
482
483 g_main_loop_unref (data->loop);
484 g_object_unref (data->ostream);
485 g_object_unref (data->istream);
486
487 skip:
488 g_object_unref (data->monitor);
489 g_object_unref (data->file);
490 free (data->monitor_path);
491 g_free (data->buffer);
492 g_free (data);
493 }
494
495 static const gchar *replace_data =
496 "/**\n"
497 " * g_file_replace_contents_async:\n"
498 " * @file: input #GFile.\n"
499 " * @contents: string of contents to replace the file with.\n"
500 " * @length: the length of @contents in bytes.\n"
501 " * @etag: (nullable): a new <link linkend=\"gfile-etag\">entity tag</link> for the @file, or %NULL\n"
502 " * @make_backup: %TRUE if a backup should be created.\n"
503 " * @flags: a set of #GFileCreateFlags.\n"
504 " * @cancellable: optional #GCancellable object, %NULL to ignore.\n"
505 " * @callback: a #GAsyncReadyCallback to call when the request is satisfied\n"
506 " * @user_data: the data to pass to callback function\n"
507 " * \n"
508 " * Starts an asynchronous replacement of @file with the given \n"
509 " * @contents of @length bytes. @etag will replace the document's\n"
510 " * current entity tag.\n"
511 " * \n"
512 " * When this operation has completed, @callback will be called with\n"
513 " * @user_user data, and the operation can be finalized with \n"
514 " * g_file_replace_contents_finish().\n"
515 " * \n"
516 " * If @cancellable is not %NULL, then the operation can be cancelled by\n"
517 " * triggering the cancellable object from another thread. If the operation\n"
518 " * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. \n"
519 " * \n"
520 " * If @make_backup is %TRUE, this function will attempt to \n"
521 " * make a backup of @file.\n"
522 " **/\n";
523
524 typedef struct
525 {
526 GFile *file;
527 const gchar *data;
528 GMainLoop *loop;
529 gboolean again;
530 } ReplaceLoadData;
531
532 static void replaced_cb (GObject *source,
533 GAsyncResult *res,
534 gpointer user_data);
535
536 static void
537 loaded_cb (GObject *source,
538 GAsyncResult *res,
539 gpointer user_data)
540 {
541 ReplaceLoadData *data = user_data;
542 gboolean ret;
543 GError *error;
544 gchar *contents;
545 gsize length;
546
547 error = NULL;
548 ret = g_file_load_contents_finish (data->file, res, &contents, &length, NULL, &error);
549 g_assert (ret);
550 g_assert_no_error (error);
551 g_assert_cmpint (length, ==, strlen (data->data));
552 g_assert_cmpstr (contents, ==, data->data);
553
554 g_free (contents);
555
556 if (data->again)
557 {
558 data->again = FALSE;
559 data->data = "pi pa po";
560
561 g_file_replace_contents_async (data->file,
562 data->data,
563 strlen (data->data),
564 NULL,
565 FALSE,
566 0,
567 NULL,
568 replaced_cb,
569 data);
570 }
571 else
572 {
573 error = NULL;
574 ret = g_file_delete (data->file, NULL, &error);
575 g_assert_no_error (error);
576 g_assert (ret);
577 g_assert (!g_file_query_exists (data->file, NULL));
578
579 g_main_loop_quit (data->loop);
580 }
581 }
582
583 static void
584 replaced_cb (GObject *source,
585 GAsyncResult *res,
586 gpointer user_data)
587 {
588 ReplaceLoadData *data = user_data;
589 GError *error;
590
591 error = NULL;
592 g_file_replace_contents_finish (data->file, res, NULL, &error);
593 g_assert_no_error (error);
594
595 g_file_load_contents_async (data->file, NULL, loaded_cb, data);
596 }
597
598 static void
599 test_replace_load (void)
600 {
601 ReplaceLoadData *data;
602 gchar *path;
603 GFileIOStream *iostream;
604
605 data = g_new0 (ReplaceLoadData, 1);
606 data->again = TRUE;
607 data->data = replace_data;
608
609 data->file = g_file_new_tmp ("g_file_replace_load_XXXXXX",
610 &iostream, NULL);
611 g_assert (data->file != NULL);
612 g_object_unref (iostream);
613
614 path = g_file_get_path (data->file);
615 remove (path);
616
617 g_assert (!g_file_query_exists (data->file, NULL));
618
619 data->loop = g_main_loop_new (NULL, FALSE);
620
621 g_file_replace_contents_async (data->file,
622 data->data,
623 strlen (data->data),
624 NULL,
625 FALSE,
626 0,
627 NULL,
628 replaced_cb,
629 data);
630
631 g_main_loop_run (data->loop);
632
633 g_main_loop_unref (data->loop);
634 g_object_unref (data->file);
635 g_free (data);
636 free (path);
637 }
638
639 static void
640 test_replace_cancel (void)
641 {
642 GFile *tmpdir, *file;
643 GFileOutputStream *ostream;
644 GFileEnumerator *fenum;
645 GFileInfo *info;
646 GCancellable *cancellable;
647 gchar *path;
648 gsize nwrote;
649 guint count;
650 GError *error = NULL;
651
652 g_test_bug ("629301");
653
654 path = g_dir_make_tmp ("g_file_replace_cancel_XXXXXX", &error);
655 g_assert_no_error (error);
656 tmpdir = g_file_new_for_path (path);
657 g_free (path);
658
659 file = g_file_get_child (tmpdir, "file");
660 g_file_replace_contents (file,
661 replace_data,
662 strlen (replace_data),
663 NULL, FALSE, 0, NULL,
664 NULL, &error);
665 g_assert_no_error (error);
666
667 ostream = g_file_replace (file, NULL, TRUE, 0, NULL, &error);
668 g_assert_no_error (error);
669
670 g_output_stream_write_all (G_OUTPUT_STREAM (ostream),
671 replace_data, strlen (replace_data),
672 &nwrote, NULL, &error);
673 g_assert_no_error (error);
674 g_assert_cmpint (nwrote, ==, strlen (replace_data));
675
676 /* At this point there should be two files; the original and the
677 * temporary.
678 */
679 fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
680 g_assert_no_error (error);
681
682 info = g_file_enumerator_next_file (fenum, NULL, &error);
683 g_assert_no_error (error);
684 g_assert (info != NULL);
685 g_object_unref (info);
686 info = g_file_enumerator_next_file (fenum, NULL, &error);
687 g_assert_no_error (error);
688 g_assert (info != NULL);
689 g_object_unref (info);
690
691 g_file_enumerator_close (fenum, NULL, &error);
692 g_assert_no_error (error);
693 g_object_unref (fenum);
694
695 /* Also test the g_file_enumerator_iterate() API */
696 fenum = g_file_enumerate_children (tmpdir, NULL, 0, NULL, &error);
697 g_assert_no_error (error);
698 count = 0;
699
700 while (TRUE)
701 {
702 gboolean ret = g_file_enumerator_iterate (fenum, &info, NULL, NULL, &error);
703 g_assert (ret);
704 g_assert_no_error (error);
705 if (!info)
706 break;
707 count++;
708 }
709 g_assert_cmpint (count, ==, 2);
710
711 g_file_enumerator_close (fenum, NULL, &error);
712 g_assert_no_error (error);
713 g_object_unref (fenum);
714
715 /* Now test just getting child from the g_file_enumerator_iterate() API */
716 fenum = g_file_enumerate_children (tmpdir, "standard::name", 0, NULL, &error);
717 g_assert_no_error (error);
718 count = 0;
719
720 while (TRUE)
721 {
722 GFile *child;
723 gboolean ret = g_file_enumerator_iterate (fenum, NULL, &child, NULL, &error);
724
725 g_assert (ret);
726 g_assert_no_error (error);
727
728 if (!child)
729 break;
730
731 g_assert (G_IS_FILE (child));
732 count++;
733 }
734 g_assert_cmpint (count, ==, 2);
735
736 g_file_enumerator_close (fenum, NULL, &error);
737 g_assert_no_error (error);
738 g_object_unref (fenum);
739
740 /* Make sure the temporary gets deleted even if we cancel. */
741 cancellable = g_cancellable_new ();
742 g_cancellable_cancel (cancellable);
743 g_output_stream_close (G_OUTPUT_STREAM (ostream), cancellable, &error);
744 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
745 g_clear_error (&error);
746
747 g_object_unref (cancellable);
748 g_object_unref (ostream);
749
750 g_file_delete (file, NULL, &error);
751 g_assert_no_error (error);
752 g_object_unref (file);
753
754 /* This will only succeed if the temp file was deleted. */
755 g_file_delete (tmpdir, NULL, &error);
756 g_assert_no_error (error);
757 g_object_unref (tmpdir);
758 }
759
760 static void
761 on_file_deleted (GObject *object,
762 GAsyncResult *result,
763 gpointer user_data)
764 {
765 GError *local_error = NULL;
766 GMainLoop *loop = user_data;
767
768 (void) g_file_delete_finish ((GFile*)object, result, &local_error);
769 g_assert_no_error (local_error);
770
771 g_main_loop_quit (loop);
772 }
773
774 static void
775 test_async_delete (void)
776 {
777 GFile *file;
778 GFileIOStream *iostream;
779 GError *local_error = NULL;
780 GError **error = &local_error;
781 GMainLoop *loop;
782
783 file = g_file_new_tmp ("g_file_delete_XXXXXX",
784 &iostream, error);
785 g_assert_no_error (local_error);
786 g_object_unref (iostream);
787
788 g_assert (g_file_query_exists (file, NULL));
789
790 loop = g_main_loop_new (NULL, TRUE);
791
792 g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, on_file_deleted, loop);
793
794 g_main_loop_run (loop);
795
796 g_assert (!g_file_query_exists (file, NULL));
797
798 g_main_loop_unref (loop);
799 g_object_unref (file);
800 }
801
802 #ifdef G_OS_UNIX
803 static void
804 test_copy_preserve_mode (void)
805 {
806 GFile *tmpfile;
807 GFile *dest_tmpfile;
808 GFileInfo *dest_info;
809 GFileIOStream *iostream;
810 GError *local_error = NULL;
811 GError **error = &local_error;
812 guint32 romode = S_IFREG | 0600;
813 guint32 dest_mode;
814
815 tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
816 &iostream, error);
817 g_assert_no_error (local_error);
818 g_io_stream_close ((GIOStream*)iostream, NULL, error);
819 g_assert_no_error (local_error);
820 g_clear_object (&iostream);
821
822 g_file_set_attribute (tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_ATTRIBUTE_TYPE_UINT32,
823 &romode, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
824 NULL, error);
825 g_assert_no_error (local_error);
826
827 dest_tmpfile = g_file_new_tmp ("tmp-copy-preserve-modeXXXXXX",
828 &iostream, error);
829 g_assert_no_error (local_error);
830 g_io_stream_close ((GIOStream*)iostream, NULL, error);
831 g_assert_no_error (local_error);
832 g_clear_object (&iostream);
833
834 g_file_copy (tmpfile, dest_tmpfile, G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA,
835 NULL, NULL, NULL, error);
836 g_assert_no_error (local_error);
837
838 dest_info = g_file_query_info (dest_tmpfile, G_FILE_ATTRIBUTE_UNIX_MODE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
839 NULL, error);
840 g_assert_no_error (local_error);
841
842 dest_mode = g_file_info_get_attribute_uint32 (dest_info, G_FILE_ATTRIBUTE_UNIX_MODE);
843
844 g_assert_cmpint (dest_mode, ==, romode);
845
846 (void) g_file_delete (tmpfile, NULL, NULL);
847 (void) g_file_delete (dest_tmpfile, NULL, NULL);
848
849 g_clear_object (&tmpfile);
850 g_clear_object (&dest_tmpfile);
851 g_clear_object (&dest_info);
852 }
853 #endif
854
855 static gchar *
856 splice_to_string (GInputStream *stream,
857 GError **error)
858 {
859 GMemoryOutputStream *buffer = NULL;
860 char *ret = NULL;
861
862 buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
863 if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
864 goto out;
865
866 if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
867 goto out;
868
869 if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
870 goto out;
871
872 ret = g_memory_output_stream_steal_data (buffer);
873 out:
874 g_clear_object (&buffer);
875 return ret;
876 }
877
878 static guint64
879 get_size_from_du (const gchar *path)
880 {
881 GSubprocess *du;
882 gchar *result;
883 gchar *endptr;
884 guint64 size;
885 GError *error = NULL;
886
887 du = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE,
888 &error,
889 "du", "--bytes", "-s", path, NULL);
890 g_assert_no_error (error);
891
892 result = splice_to_string (g_subprocess_get_stdout_pipe (du), &error);
893 g_assert_no_error (error);
894
895 size = g_ascii_strtoll (result, &endptr, 10);
896
897 g_object_unref (du);
898 g_free (result);
899
900 return size;
901 }
902
903 static void
904 test_measure (void)
905 {
906 GFile *file;
907 guint64 size;
908 guint64 num_bytes;
909 guint64 num_dirs;
910 guint64 num_files;
911 GError *error = NULL;
912 gboolean ok;
913 gchar *path;
914
915 path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
916 file = g_file_new_for_path (path);
917
918 if (g_find_program_in_path ("du"))
919 {
920 size = get_size_from_du (path);
921 }
922 else
923 {
924 g_test_message ("du not found, skipping byte measurement");
925 size = 0;
926 }
927
928 ok = g_file_measure_disk_usage (file,
929 G_FILE_MEASURE_APPARENT_SIZE,
930 NULL,
931 NULL,
932 NULL,
933 &num_bytes,
934 &num_dirs,
935 &num_files,
936 &error);
937 g_assert (ok);
938 g_assert_no_error (error);
939
940 if (size > 0)
941 g_assert_cmpuint (num_bytes, ==, size);
942 g_assert_cmpuint (num_dirs, ==, 6);
943 g_assert_cmpuint (num_files, ==, 30);
944
945 g_object_unref (file);
946 g_free (path);
947 }
948
949 typedef struct {
950 guint64 expected_bytes;
951 guint64 expected_dirs;
952 guint64 expected_files;
953 gint progress_count;
954 guint64 progress_bytes;
955 guint64 progress_dirs;
956 guint64 progress_files;
957 } MeasureData;
958
959 static void
960 measure_progress (gboolean reporting,
961 guint64 current_size,
962 guint64 num_dirs,
963 guint64 num_files,
964 gpointer user_data)
965 {
966 MeasureData *data = user_data;
967
968 data->progress_count += 1;
969
970 g_assert_cmpuint (current_size, >=, data->progress_bytes);
971 g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
972 g_assert_cmpuint (num_files, >=, data->progress_files);
973
974 data->progress_bytes = current_size;
975 data->progress_dirs = num_dirs;
976 data->progress_files = num_files;
977 }
978
979 static void
980 measure_done (GObject *source,
981 GAsyncResult *res,
982 gpointer user_data)
983 {
984 MeasureData *data = user_data;
985 guint64 num_bytes, num_dirs, num_files;
986 GError *error = NULL;
987 gboolean ok;
988
989 ok = g_file_measure_disk_usage_finish (G_FILE (source), res, &num_bytes, &num_dirs, &num_files, &error);
990 g_assert (ok);
991 g_assert_no_error (error);
992
993 if (data->expected_bytes > 0)
994 g_assert_cmpuint (data->expected_bytes, ==, num_bytes);
995 g_assert_cmpuint (data->expected_dirs, ==, num_dirs);
996 g_assert_cmpuint (data->expected_files, ==, num_files);
997
998 g_assert_cmpuint (data->progress_count, >, 0);
999 g_assert_cmpuint (num_bytes, >=, data->progress_bytes);
1000 g_assert_cmpuint (num_dirs, >=, data->progress_dirs);
1001 g_assert_cmpuint (num_files, >=, data->progress_files);
1002
1003 g_free (data);
1004 g_object_unref (source);
1005 }
1006
1007 static void
1008 test_measure_async (void)
1009 {
1010 gchar *path;
1011 GFile *file;
1012 MeasureData *data;
1013
1014 data = g_new (MeasureData, 1);
1015
1016 data->progress_count = 0;
1017 data->progress_bytes = 0;
1018 data->progress_files = 0;
1019 data->progress_dirs = 0;
1020
1021 path = g_test_build_filename (G_TEST_DIST, "desktop-files", NULL);
1022 file = g_file_new_for_path (path);
1023
1024 if (g_find_program_in_path ("du"))
1025 {
1026 data->expected_bytes = get_size_from_du (path);
1027 }
1028 else
1029 {
1030 g_test_message ("du not found, skipping byte measurement");
1031 data->expected_bytes = 0;
1032 }
1033
1034 g_free (path);
1035
1036 data->expected_dirs = 6;
1037 data->expected_files = 30;
1038
1039 g_file_measure_disk_usage_async (file,
1040 G_FILE_MEASURE_APPARENT_SIZE,
1041 0, NULL,
1042 measure_progress, data,
1043 measure_done, data);
1044 }
1045
1046 int
1047 main (int argc, char *argv[])
1048 {
1049 g_test_init (&argc, &argv, NULL);
1050
1051 g_test_bug_base ("http://bugzilla.gnome.org/");
1052
1053 g_test_add_func ("/file/basic", test_basic);
1054 g_test_add_func ("/file/parent", test_parent);
1055 g_test_add_func ("/file/child", test_child);
1056 g_test_add_func ("/file/type", test_type);
1057 g_test_add_func ("/file/parse-name", test_parse_name);
1058 g_test_add_data_func ("/file/async-create-delete/0", GINT_TO_POINTER (0), test_create_delete);
1059 g_test_add_data_func ("/file/async-create-delete/1", GINT_TO_POINTER (1), test_create_delete);
1060 g_test_add_data_func ("/file/async-create-delete/10", GINT_TO_POINTER (10), test_create_delete);
1061 g_test_add_data_func ("/file/async-create-delete/25", GINT_TO_POINTER (25), test_create_delete);
1062 g_test_add_data_func ("/file/async-create-delete/4096", GINT_TO_POINTER (4096), test_create_delete);
1063 g_test_add_func ("/file/replace-load", test_replace_load);
1064 g_test_add_func ("/file/replace-cancel", test_replace_cancel);
1065 g_test_add_func ("/file/async-delete", test_async_delete);
1066 #ifdef G_OS_UNIX
1067 g_test_add_func ("/file/copy-preserve-mode", test_copy_preserve_mode);
1068 #endif
1069 g_test_add_func ("/file/measure", test_measure);
1070 g_test_add_func ("/file/measure-async", test_measure_async);
1071
1072 return g_test_run ();
1073 }
glib mirror