/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- */

/* test-file-saver.c

 * This file is part of GtkSourceView

 *

 * Copyright (C) 2010 - Jesse van den Kieboom

 * Copyright (C) 2014 - Sébastien Wilmet

 *

 * GtkSourceView is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * GtkSourceView is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <gio/gio.h>

#include <gtk/gtk.h>

#include <string.h>

#include <sys/stat.h>

#include <glib/gprintf.h>

#include <gtksourceview/gtksource.h>

#define ENABLE_REMOTE_TESTS	FALSE

/* linux/bsd has it. others such as Solaris, do not */

#ifndef ACCESSPERMS

#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)

#endif

#define DEFAULT_REMOTE_URI_DIR "sftp://localhost/tmp/"

#define DEFAULT_TEST_TEXT_FILE "gtksourceview-file-saver-test.txt"

#define DEFAULT_TEST_UNOWNED_TEXT_FILE "gtksourceview-file-saver-unowned-group.txt"

#define DEFAULT_UNOWNED_DIR "gtksourceview-file-saver-unowned"

#define DEFAULT_REMOTE_URI DEFAULT_REMOTE_URI_DIR DEFAULT_TEST_TEXT_FILE

#define DEFAULT_CONTENT "hello world!"

#define DEFAULT_CONTENT_RESULT "hello world!\n"

#define UNOWNED_REMOTE_DIRECTORY DEFAULT_REMOTE_URI_DIR DEFAULT_UNOWNED_DIR

typedef struct _SaverTestData SaverTestData;

typedef void (*SavedCallback) (SaverTestData *data);

struct _SaverTestData

{

	GtkSourceFileSaver *saver;

	GFile *location;

	const gchar *expected_file_contents;

	SavedCallback saved_callback;

	gpointer userdata;

	guint file_existed : 1;

};

static const gchar *

read_file (GFile *location)

{

	/* TODO use g_file_load_contents() */

	GError *error = NULL;

	static gchar buffer[4096];

	gsize read;

	GInputStream *stream = G_INPUT_STREAM (g_file_read (location, NULL, &error));

	g_assert_no_error (error);

	g_input_stream_read_all (stream, buffer, sizeof (buffer) - 1, &read, NULL, &error);

	g_assert_no_error (error);

	buffer[read] = '\0';

	g_input_stream_close (stream, NULL, NULL);

	g_object_unref (stream);

	return buffer;

}

static void

save_file_cb (GtkSourceFileSaver *saver,

	      GAsyncResult       *result,

	      SaverTestData      *data)

{

	GError *error = NULL;

	gtk_source_file_saver_save_finish (saver, result, &error);

	g_assert_no_error (error);

	g_assert_cmpstr (data->expected_file_contents, ==, read_file (data->location));

	if (data->saved_callback != NULL)

	{

		data->saved_callback (data);

	}

	if (!data->file_existed)

	{

		g_file_delete (data->location, NULL, NULL);

	}

	/* finished */

	gtk_main_quit ();

}

static void

save_file (SaverTestData *data)

{

	data->file_existed = g_file_query_exists (data->location, NULL);

	gtk_source_file_saver_save_async (data->saver,

					  G_PRIORITY_DEFAULT,

					  NULL, NULL, NULL, NULL,

					  (GAsyncReadyCallback) save_file_cb,

					  data);

}

static void

mount_cb (GFile         *location,

	  GAsyncResult  *result,

	  SaverTestData *data)

{

	GError *error = NULL;

	g_file_mount_enclosing_volume_finish (location, result, &error);

	if (error != NULL && error->code == G_IO_ERROR_ALREADY_MOUNTED)

	{

		g_error_free (error);

	}

	else

	{

		g_assert_no_error (error);

	}

	save_file (data);

}

static void

check_mounted (SaverTestData *data)

{

	GMountOperation *mount_operation;

	if (g_file_is_native (data->location))

	{

		save_file (data);

		return;

	}

	mount_operation = gtk_mount_operation_new (NULL);

	g_file_mount_enclosing_volume (data->location,

	                               G_MOUNT_MOUNT_NONE,

	                               mount_operation,

	                               NULL,

	                               (GAsyncReadyCallback) mount_cb,

	                               data);

	g_object_unref (mount_operation);

}

static void

test_saver (const gchar            *filename_or_uri,

	    const gchar            *buffer_contents,

	    const gchar            *expected_file_contents,

	    GtkSourceNewlineType    newline_type,

	    SavedCallback           saved_callback,

	    gpointer                userdata)

{

	GFile *location;

	GtkSourceBuffer *buffer;

	GtkSourceFile *file;

	GtkSourceFileSaver *saver;

	SaverTestData *data;

	location = g_file_new_for_commandline_arg (filename_or_uri);

	buffer = gtk_source_buffer_new (NULL);

	gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), buffer_contents, -1);

	file = gtk_source_file_new ();

	saver = gtk_source_file_saver_new_with_target (buffer, file, location);

	gtk_source_file_saver_set_newline_type (saver, newline_type);

	gtk_source_file_saver_set_encoding (saver, gtk_source_encoding_get_utf8 ());

	data = g_slice_new (SaverTestData);

	data->saver = saver;

	data->location = location;

	data->expected_file_contents = expected_file_contents;

	data->saved_callback = saved_callback;

	data->userdata = userdata;

	check_mounted (data);

	gtk_main ();

	g_object_unref (location);

	g_object_unref (buffer);

	g_object_unref (file);

	g_object_unref (saver);

	g_slice_free (SaverTestData, data);

}

typedef struct

{

	GtkSourceNewlineType type;

	const gchar *text;

	const gchar *result;

} NewLineTestData;

static NewLineTestData newline_test_data[] = {

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\nhello\nworld", "\nhello\nworld\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\nhello\nworld\n", "\nhello\nworld\n\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\nhello\nworld\n\n", "\nhello\nworld\n\n\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\r\nhello\r\nworld", "\nhello\nworld\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\r\nhello\r\nworld\r\n", "\nhello\nworld\n\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\rhello\rworld", "\nhello\nworld\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\rhello\rworld\r", "\nhello\nworld\n\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\nhello\r\nworld", "\nhello\nworld\n"},

	{GTK_SOURCE_NEWLINE_TYPE_LF, "\nhello\r\nworld\r", "\nhello\nworld\n\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\nhello\nworld", "\r\nhello\r\nworld\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\nhello\nworld\n", "\r\nhello\r\nworld\r\n\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\nhello\nworld\n\n", "\r\nhello\r\nworld\r\n\r\n\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\r\nhello\r\nworld", "\r\nhello\r\nworld\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\r\nhello\r\nworld\r\n", "\r\nhello\r\nworld\r\n\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\rhello\rworld", "\r\nhello\r\nworld\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\rhello\rworld\r", "\r\nhello\r\nworld\r\n\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\nhello\r\nworld", "\r\nhello\r\nworld\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR_LF, "\nhello\r\nworld\r", "\r\nhello\r\nworld\r\n\r\n"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\nhello\nworld", "\rhello\rworld\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\nhello\nworld\n", "\rhello\rworld\r\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\nhello\nworld\n\n", "\rhello\rworld\r\r\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\r\nhello\r\nworld", "\rhello\rworld\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\r\nhello\r\nworld\r\n", "\rhello\rworld\r\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\rhello\rworld", "\rhello\rworld\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\rhello\rworld\r", "\rhello\rworld\r\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\nhello\r\nworld", "\rhello\rworld\r"},

	{GTK_SOURCE_NEWLINE_TYPE_CR, "\nhello\r\nworld\r", "\rhello\rworld\r\r"}

};

static void

test_new_line (const gchar *filename)

{

	gint i;

	gint num = sizeof (newline_test_data) / sizeof (NewLineTestData);

	for (i = 0; i < num; ++i)

	{

		NewLineTestData *nt = &(newline_test_data[i]);

		test_saver (filename,

		            nt->text,

			    nt->result,

		            nt->type,

			    NULL,

			    NULL);

	}

}

static void

test_local_newline (void)

{

	gchar *default_local_uri;

	default_local_uri = g_build_filename (g_get_tmp_dir (),

	                                      DEFAULT_TEST_TEXT_FILE,

	                                      NULL);

	test_new_line (default_local_uri);

	g_free (default_local_uri);

}

static void

test_local (void)

{

	gchar *default_local_uri;

	default_local_uri = g_build_filename (g_get_tmp_dir (),

	                                      DEFAULT_TEST_TEXT_FILE,

	                                      NULL);

	test_saver (default_local_uri,

	            "hello world",

		    "hello world\n",

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	test_saver (default_local_uri,

	            "hello world\r\n",

		    "hello world\n\n",

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	test_saver (default_local_uri,

	            "hello world\n",

		    "hello world\n\n",

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	g_free (default_local_uri);

}

static void

test_remote_newline (void)

{

	test_new_line (DEFAULT_REMOTE_URI);

}

static void

test_remote (void)

{

	test_saver (DEFAULT_REMOTE_URI,

	            "hello world",

		    "hello world\n",

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	test_saver (DEFAULT_REMOTE_URI,

	            "hello world\r\n",

		    "hello world\n\n",

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	test_saver (DEFAULT_REMOTE_URI,

	            "hello world\n",

		    "hello world\n\n",

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

}

#ifndef G_OS_WIN32

static void

check_permissions (GFile *location,

                   guint  permissions)

{

	GError *error = NULL;

	GFileInfo *info;

	info = g_file_query_info (location,

	                          G_FILE_ATTRIBUTE_UNIX_MODE,

	                          G_FILE_QUERY_INFO_NONE,

	                          NULL,

	                          &error);

	g_assert_no_error (error);

	g_assert_cmpint (permissions,

	                 ==,

	                 g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE) & ACCESSPERMS);

	g_object_unref (info);

}

static void

check_permissions_saved (SaverTestData *data)

{

	guint permissions = (guint)GPOINTER_TO_INT (data->userdata);

	check_permissions (data->location, permissions);

}

static void

test_permissions (const gchar *uri,

                  guint        permissions)

{

	GError *error = NULL;

	GFile *location = g_file_new_for_commandline_arg (uri);

	GFileOutputStream *stream;

	GFileInfo *info;

	guint mode;

	g_file_delete (location, NULL, NULL);

	stream = g_file_create (location, 0, NULL, &error);

	g_assert_no_error (error);

	g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, NULL);

	g_object_unref (stream);

	info = g_file_query_info (location,

	                          G_FILE_ATTRIBUTE_UNIX_MODE,

	                          G_FILE_QUERY_INFO_NONE,

	                          NULL,

	                          &error);

	g_assert_no_error (error);

	mode = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);

	g_object_unref (info);

	g_file_set_attribute_uint32 (location,

	                             G_FILE_ATTRIBUTE_UNIX_MODE,

	                             (mode & ~ACCESSPERMS) | permissions,

	                             G_FILE_QUERY_INFO_NONE,

	                             NULL,

	                             &error);

	g_assert_no_error (error);

	check_permissions (location, permissions);

	test_saver (uri,

	            DEFAULT_CONTENT,

		    DEFAULT_CONTENT_RESULT,

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    check_permissions_saved,

		    GINT_TO_POINTER ((gint)permissions));

	g_file_delete (location, NULL, NULL);

	g_object_unref (location);

}

static void

test_local_permissions (void)

{

	gchar *default_local_uri;

	default_local_uri = g_build_filename (g_get_tmp_dir (),

	                                      DEFAULT_TEST_TEXT_FILE,

	                                      NULL);

	test_permissions (default_local_uri, 0600);

	test_permissions (default_local_uri, 0660);

	test_permissions (default_local_uri, 0666);

	test_permissions (default_local_uri, 0760);

	g_free (default_local_uri);

}

#endif

static void

test_local_unowned_directory (void)

{

	gchar *unowned_local_uri;

	unowned_local_uri = g_build_filename (g_get_tmp_dir (),

	                                             DEFAULT_UNOWNED_DIR,

	                                             DEFAULT_TEST_TEXT_FILE,

                                                 NULL);

	test_saver (unowned_local_uri,

	            DEFAULT_CONTENT,

		    DEFAULT_CONTENT_RESULT,

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	g_free (unowned_local_uri);

}

static void

test_remote_unowned_directory (void)

{

	gchar *unowned_remote_uri;

	unowned_remote_uri = g_strconcat (UNOWNED_REMOTE_DIRECTORY,

	                                  DEFAULT_TEST_TEXT_FILE,

	                                  NULL);

	test_saver (unowned_remote_uri,

	            DEFAULT_CONTENT,

		    DEFAULT_CONTENT_RESULT,

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    NULL,

		    NULL);

	g_free (unowned_remote_uri);

}

#ifndef G_OS_WIN32

static void

test_remote_permissions (void)

{

	test_permissions (DEFAULT_REMOTE_URI, 0600);

	test_permissions (DEFAULT_REMOTE_URI, 0660);

	test_permissions (DEFAULT_REMOTE_URI, 0666);

	test_permissions (DEFAULT_REMOTE_URI, 0760);

}

static void

test_unowned_group_permissions (SaverTestData *data)

{

	GError *error = NULL;

	const gchar *group;

	guint32 mode;

	GFileInfo *info = g_file_query_info (data->location,

	                                     G_FILE_ATTRIBUTE_OWNER_GROUP ","

	                                     G_FILE_ATTRIBUTE_UNIX_MODE,

	                                     G_FILE_QUERY_INFO_NONE,

	                                     NULL,

	                                     &error);

	g_assert_no_error (error);

	group = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP);

	g_assert_cmpstr (group, ==, "root");

	mode = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);

	g_assert_cmpint (mode & ACCESSPERMS, ==, 0660);

	g_object_unref (info);

}

static void

test_unowned_group (const gchar *uri)

{

	test_saver (uri,

	            DEFAULT_CONTENT,

		    DEFAULT_CONTENT_RESULT,

	            GTK_SOURCE_NEWLINE_TYPE_LF,

		    test_unowned_group_permissions,

		    NULL);

}

static void

test_local_unowned_group (void)

{

	gchar *unowned_group_local_uri;

	unowned_group_local_uri = g_build_filename (g_get_tmp_dir (),

	                                            DEFAULT_TEST_UNOWNED_TEXT_FILE,

	                                            NULL);

	test_unowned_group (unowned_group_local_uri);

	g_free (unowned_group_local_uri);

}

#if 0

static void

test_remote_unowned_group (void)

{

	g_char *unowned_group_remote_uri;

	unowned_group_remote_uri = g_strconcat (DEFAULT_REMOTE_URI_DIR,

	                                        DEFAULT_TEST_UNOWNED_TEXT_FILE,

	                                        NULL);

	test_unowned_group ();

	g_free (unowned_group_remote_uri);

}

#endif

#endif

static gboolean

check_unowned_directory (void)

{

	gchar *unowned_local_directory, *unowned_local_uri;

	GFile *unowned, *unowned_file;

	GFileInfo *info;

	GError *error = NULL;

	unowned_local_directory = g_build_filename (g_get_tmp_dir (),

	                                            DEFAULT_UNOWNED_DIR,

	                                            NULL);

	unowned = g_file_new_for_path (unowned_local_directory);

	g_free (unowned_local_directory);

	g_printf ("*** Checking for unowned directory test... ");

	info = g_file_query_info (unowned,

	                          G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,

	                          G_FILE_QUERY_INFO_NONE,

	                          NULL,

	                          &error);

	if (error)

	{

		g_object_unref (unowned);

		g_printf ("NO: directory does not exist\n");

		g_error_free (error);

		return FALSE;

	}

	if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))

	{

		g_object_unref (unowned);

		g_printf ("NO: directory is writable\n");

		g_object_unref (info);

		return FALSE;

	}

	g_object_unref (info);

	g_object_unref (unowned);

	unowned_local_uri = g_build_filename (g_get_tmp_dir (),

	                                      DEFAULT_UNOWNED_DIR,

	                                      DEFAULT_TEST_TEXT_FILE,

	                                      NULL);

	unowned_file = g_file_new_for_commandline_arg (unowned_local_uri);

	info = g_file_query_info (unowned_file,

	                          G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,

	                          G_FILE_QUERY_INFO_NONE,

	                          NULL,

	                          &error);

	g_free (unowned_local_uri);

	if (error)

	{

		g_object_unref (unowned_file);

		g_error_free (error);

		g_printf ("NO: file does not exist\n");

		return FALSE;

	}

	if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))

	{

		g_object_unref (unowned_file);

		g_printf ("NO: file is not writable\n");

		g_object_unref (info);

		return FALSE;

	}

	g_object_unref (info);

	g_object_unref (unowned_file);

	g_printf ("YES\n");

	return TRUE;

}

static gboolean

check_unowned_group (void)

{

	gchar *unowned_group_local_uri;

	GFile *unowned;

	GFileInfo *info;

	GError *error = NULL;

	unowned_group_local_uri = g_build_filename (g_get_tmp_dir (),

	                                            DEFAULT_TEST_UNOWNED_TEXT_FILE,

	                                            NULL);

	unowned = g_file_new_for_path (unowned_group_local_uri);

	g_printf ("*** Checking for unowned group test... ");

	info = g_file_query_info (unowned,

	                          G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE ","

	                          G_FILE_ATTRIBUTE_OWNER_GROUP ","

	                          G_FILE_ATTRIBUTE_UNIX_MODE,

	                          G_FILE_QUERY_INFO_NONE,

	                          NULL,

	                          &error);

	g_free (unowned_group_local_uri);

	if (error)

	{

		g_object_unref (unowned);

		g_printf ("NO: file does not exist\n");

		g_error_free (error);

		return FALSE;

	}

	if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))

	{

		g_object_unref (unowned);

		g_printf ("NO: file is not writable\n");

		g_object_unref (info);

		return FALSE;

	}

	if (g_strcmp0 (g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP),

	               "root") != 0)

	{

		g_object_unref (unowned);

		g_printf ("NO: group is not root (%s)\n", g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP));

		g_object_unref (info);

		return FALSE;

	}

#ifndef G_OS_WIN32

	if ((g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE) & ACCESSPERMS) != 0660)

	{

		g_object_unref (unowned);

		g_printf ("NO: file has wrong permissions\n");

		g_object_unref (info);

		return FALSE;

	}

#endif

	g_object_unref (info);

	g_object_unref (unowned);

	g_printf ("YES\n");

	return TRUE;

}

static void

all_tests (void)

{

	gboolean have_unowned;

#ifndef G_OS_WIN32

	gboolean have_unowned_group;

#endif

	g_printf ("\n***\n");

	have_unowned = check_unowned_directory ();

#ifndef G_OS_WIN32

	have_unowned_group = check_unowned_group ();

#endif

	g_printf ("***\n\n");

	g_test_trap_subprocess ("/file-saver/subprocess/local",

				0,

				G_TEST_SUBPROCESS_INHERIT_STDERR);

	g_test_trap_assert_passed ();

	g_test_trap_subprocess ("/file-saver/subprocess/local-new-line",

				0,

				G_TEST_SUBPROCESS_INHERIT_STDERR);

	g_test_trap_assert_passed ();

	if (have_unowned)

	{

		g_test_trap_subprocess ("/file-saver/subprocess/local-unowned-directory",

					0,

					G_TEST_SUBPROCESS_INHERIT_STDERR);

		g_test_trap_assert_passed ();

	}

	if (ENABLE_REMOTE_TESTS)

	{

		g_test_trap_subprocess ("/file-saver/subprocess/remote",

					0,

					G_TEST_SUBPROCESS_INHERIT_STDERR);

		g_test_trap_assert_passed ();

		g_test_trap_subprocess ("/file-saver/subprocess/remote-new-line",

					0,

					G_TEST_SUBPROCESS_INHERIT_STDERR);

		g_test_trap_assert_passed ();

		if (have_unowned)

		{

			g_test_trap_subprocess ("/file-saver/subprocess/remote-unowned-directory",

						0,

						G_TEST_SUBPROCESS_INHERIT_STDERR);

			g_test_trap_assert_passed ();

		}

		/*

		if (have_unowned_group)

		{

			g_test_trap_subprocess ("/file-saver/subprocess/remote-unowned-group",

						0,

						G_TEST_SUBPROCESS_INHERIT_STDERR);

			g_test_trap_assert_passed ();

		}

		*/

	}

#ifndef G_OS_WIN32

	g_test_trap_subprocess ("/file-saver/subprocess/local-permissions",

				0,

				G_TEST_SUBPROCESS_INHERIT_STDERR);

	g_test_trap_assert_passed ();

	if (have_unowned_group)

	{

		g_test_trap_subprocess ("/file-saver/subprocess/local-unowned-group",

					0,

					G_TEST_SUBPROCESS_INHERIT_STDERR);

		g_test_trap_assert_passed ();

	}

	if (ENABLE_REMOTE_TESTS)

	{

		g_test_trap_subprocess ("/file-saver/subprocess/remote-permissions",

					0,

					G_TEST_SUBPROCESS_INHERIT_STDERR);

		g_test_trap_assert_passed ();

	}

#endif

}

gint

main (gint   argc,

      gchar *argv[])

{

	gtk_test_init (&argc, &argv);

	g_test_add_func ("/file-saver", all_tests);

	g_test_add_func ("/file-saver/subprocess/local", test_local);

	g_test_add_func ("/file-saver/subprocess/local-new-line", test_local_newline);

	g_test_add_func ("/file-saver/subprocess/local-unowned-directory", test_local_unowned_directory);

	if (ENABLE_REMOTE_TESTS)

	{

		g_test_add_func ("/file-saver/subprocess/remote", test_remote);

		g_test_add_func ("/file-saver/subprocess/remote-new-line", test_remote_newline);

		g_test_add_func ("/file-saver/subprocess/remote-unowned-directory", test_remote_unowned_directory);

		/* FIXME: there is a bug in gvfs sftp which doesn't pass this test */

		/* g_test_add_func ("/file-saver/subprocess/remote-unowned-group", test_remote_unowned_group); */

	}

#ifndef G_OS_WIN32

	g_test_add_func ("/file-saver/subprocess/local-permissions", test_local_permissions);

	g_test_add_func ("/file-saver/subprocess/local-unowned-group", test_local_unowned_group);

	if (ENABLE_REMOTE_TESTS)

	{

		g_test_add_func ("/file-saver/subprocess/remote-permissions", test_remote_permissions);

	}

#endif

	return g_test_run ();

}