gtk2/tests/autotestfilesystem.c

/* GTK - The GIMP Toolkit
 * autotestfilesystem.c: Automated tests for GtkFileSystem implementations
 * Copyright (C) 2005, Novell, Inc.
 *
 * Authors:
 *   Federico Mena-Quintero <federico@novell.com>
 *
 * This library 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 of the License, or (at your option) any later version.
 *
 * This library 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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED

#include <config.h>
#include <string.h>
#include <unistd.h>
#include <glib/gprintf.h>
#include <gtk/gtk.h>
#include <gtk/gtkfilesystem.h>

#define CALLBACK_TIMEOUT_MS 3000	/* Period after which the callback must have been called */
#define CANCEL_TIMEOUT_MS 100		/* We'll sleep for this much time before cancelling */

#define GET_FOLDER_FILENAME "/etc"
#define GET_INFO_FILENAME "/etc/passwd"
#define CREATE_FOLDER_FILENAME "/tmp/autotestfilesystem-tmp"
#define VOLUME_MOUNT_FILENAME "/"

/* This is stolen from gtkfilechooserdefault.c:set_file_system_backend() */
static GtkFileSystem *
get_file_system (void)
{
  GtkFileSystem *file_system = NULL;

#if 1
  file_system = gtk_file_system_create ("gnome-vfs");
#else
  GtkSettings *settings = gtk_settings_get_default ();
  gchar *default_backend = NULL;

  g_object_get (settings, "gtk-file-chooser-backend", &default_backend, NULL);
  if (default_backend)
    {
      file_system = gtk_file_system_create (default_backend);
      g_free (default_backend);
    }

  if (!file_system)
    {
#if defined (G_OS_UNIX)
      file_system = gtk_file_system_unix_new ();
#elif defined (G_OS_WIN32)
      file_system = gtk_file_system_win32_new ();
#else
#error "No default filesystem implementation on the platform"
#endif
    }

#endif

  return file_system;
}



/***** Testing infrastructure *****/

typedef struct {
  gboolean callback_was_called;
  gboolean timeout_was_called;
} TestCallbackClosure;

static void
notify_callback_called (TestCallbackClosure *closure)
{
  closure->callback_was_called = TRUE;
  gtk_main_quit ();
}

static gboolean
timeout_cb (gpointer data)
{
  TestCallbackClosure *closure;

  closure = data;

  closure->timeout_was_called = TRUE;
  gtk_main_quit ();

  return FALSE;
}

static void
wait_for_callback (TestCallbackClosure *closure)
{
  gdk_threads_add_timeout (CALLBACK_TIMEOUT_MS, timeout_cb, closure);
  gtk_main ();
}

typedef struct {
  const char *test_name;
  gboolean callback_must_be_called;
  gpointer (* setup_fn) (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			 TestCallbackClosure *callback_closure);
  void (* cleanup_fn) (gpointer data, gboolean *success, char **failure_reason);
} TestSpec;

static gboolean
run_test (TestSpec *test_spec)
{
  GtkFileSystem *file_system;
  TestCallbackClosure closure;
  gboolean success_setup, success_cleanup;
  gpointer test_data;
  gboolean callback_success;
  gboolean passed;
  char *setup_failure_reason;
  char *cleanup_failure_reason;

  file_system = get_file_system ();
  if (!file_system)
    {
      printf ("FAIL: test \"%s\"\n", test_spec->test_name);
      printf ("      could not create file system!\n");
      return FALSE;
    }

  closure.callback_was_called = FALSE;
  closure.timeout_was_called = FALSE;

  success_setup = success_cleanup = callback_success = FALSE;
  setup_failure_reason = cleanup_failure_reason = NULL;

  test_data = test_spec->setup_fn (file_system, &success_setup, &setup_failure_reason, &closure);
  if (success_setup)
    {
      wait_for_callback (&closure);

      test_spec->cleanup_fn (test_data, &success_cleanup, &cleanup_failure_reason);

      callback_success = (test_spec->callback_must_be_called == closure.callback_was_called);
    }

  g_object_unref (file_system);

  passed = (success_setup && success_cleanup && callback_success);

  printf ("%s: test \"%s\"\n", passed ? "PASS" : "FAIL", test_spec->test_name);

  if (!passed)
    {
      if (!success_setup)
	printf ("      failure during setup: %s\n",
		setup_failure_reason ? setup_failure_reason : "unknown failure");
      else
	{
	  if (!success_cleanup)
	    printf ("      failure during cleanup: %s\n",
		    cleanup_failure_reason ? cleanup_failure_reason : "unknown failure");

	  if (!callback_success)
	    printf ("      callback %s called but it %s called\n",
		    test_spec->callback_must_be_called ? "MUST BE" : "MUST NOT BE",
		    closure.callback_was_called ? "WAS" : "WAS NOT");
	}
    }

  g_free (setup_failure_reason);
  g_free (cleanup_failure_reason);

  return passed;
}

static gboolean
run_tests (TestSpec *test_specs, int num_tests)
{
  int i;
  int num_passed;

  num_passed = 0;

  for (i = 0; i < num_tests; i++)
    if (run_test (test_specs + i))
      num_passed++;

  if (num_passed == num_tests)
    printf ("ALL TESTS PASSED\n");
  else
    printf ("%d of %d tests FAILED\n", (num_tests - num_passed), num_tests);

  return (num_passed == num_tests);
}



/***** Test functions *****/

static void
sleep_and_cancel_handle (GtkFileSystemHandle *handle)
{
  g_usleep (CANCEL_TIMEOUT_MS * 1000);
  gtk_file_system_cancel_operation (handle);
}

/* get_folder */

struct get_folder_data {
  TestCallbackClosure *callback_closure;
  GtkFileSystemHandle *handle;
  GtkFileFolder *folder;
};

static void
get_folder_cb (GtkFileSystemHandle *handle,
	       GtkFileFolder       *folder,
	       const GError        *error,
	       gpointer             data)
{
  struct get_folder_data *get_folder_data;

  get_folder_data = data;
  get_folder_data->folder = folder;
  notify_callback_called (get_folder_data->callback_closure);
}

static gpointer
get_folder_generic_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			  TestCallbackClosure *callback_closure)
{
  struct get_folder_data *get_folder_data;
  GtkFilePath *path;

  path = gtk_file_system_filename_to_path (file_system, GET_FOLDER_FILENAME);
  if (!path)
    {
      *success = FALSE;
      *failure_reason = g_strdup_printf ("could not turn \"%s\" into a GtkFilePath", GET_FOLDER_FILENAME);
      return NULL;
    }

  get_folder_data = g_new (struct get_folder_data, 1);

  get_folder_data->callback_closure = callback_closure;
  get_folder_data->folder = NULL;

  get_folder_data->handle = gtk_file_system_get_folder (file_system,
							path,
							GTK_FILE_INFO_ALL,
							get_folder_cb,
							get_folder_data);
  gtk_file_path_free (path);

  if (!get_folder_data->handle)
    {
      g_free (get_folder_data);
      *success = FALSE;
      *failure_reason = g_strdup ("gtk_file_system_get_folder() returned a NULL handle");
      return NULL;
    }

  *success = TRUE;

  return get_folder_data;
}

static gpointer
get_folder_no_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			    TestCallbackClosure *callback_closure)
{
  return get_folder_generic_setup (file_system, success, failure_reason, callback_closure);
}

static void
get_folder_cleanup (gpointer data, gboolean *success, char **failure_reason)
{
  struct get_folder_data *get_folder_data;

  get_folder_data = data;

  if (get_folder_data->folder)
    g_object_unref (get_folder_data->folder);

  g_free (get_folder_data);

  *success = TRUE;
}

static gpointer
get_folder_with_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			      TestCallbackClosure *callback_closure)
{
  struct get_folder_data *get_folder_data;

  get_folder_data = get_folder_generic_setup (file_system, success, failure_reason, callback_closure);

  if (*success)
    sleep_and_cancel_handle (get_folder_data->handle);

  return get_folder_data;
}

/* get_info */

struct get_info_data {
  TestCallbackClosure *callback_closure;
  GtkFileSystemHandle *handle;
};

static void
get_info_cb (GtkFileSystemHandle *handle,
	     const GtkFileInfo   *file_info,
	     const GError        *error,
	     gpointer             data)
{
  struct get_info_data *get_info_data;

  get_info_data = data;
  notify_callback_called (get_info_data->callback_closure);
}

static gpointer
get_info_generic_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			TestCallbackClosure *callback_closure)
{
  GtkFilePath *path;
  struct get_info_data *get_info_data;

  path = gtk_file_system_filename_to_path (file_system, GET_INFO_FILENAME);
  if (!path)
    {
      *success = FALSE;
      *failure_reason = g_strdup_printf ("could not turn \"%s\" into a GtkFilePath", GET_INFO_FILENAME);
      return NULL;
    }

  get_info_data = g_new (struct get_info_data, 1);

  get_info_data->callback_closure = callback_closure;
  get_info_data->handle = gtk_file_system_get_info (file_system,
						    path,
						    GTK_FILE_INFO_ALL,
						    get_info_cb,
						    get_info_data);
  gtk_file_path_free (path);

  if (!get_info_data->handle)
    {
      g_free (get_info_data);
      *success = FALSE;
      *failure_reason = g_strdup ("gtk_file_system_get_info() returned a NULL handle");
      return NULL;
    }

  *success = TRUE;
  return get_info_data;
}

static gpointer
get_info_no_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			  TestCallbackClosure *callback_closure)
{
  return get_info_generic_setup (file_system, success, failure_reason, callback_closure);
}

static void
get_info_cleanup (gpointer data, gboolean *success, char **failure_reason)
{
  struct get_info_data *get_info_data;

  get_info_data = data;
  g_free (get_info_data);

  *success = TRUE;
}

static gpointer
get_info_with_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			    TestCallbackClosure *callback_closure)
{
  struct get_info_data *get_info_data;

  get_info_data = get_info_generic_setup (file_system, success, failure_reason, callback_closure);

  if (*success)
    sleep_and_cancel_handle (get_info_data->handle);

  return get_info_data;
}

/* create_folder */

struct create_folder_data {
  TestCallbackClosure *callback_closure;
  GtkFileSystemHandle *handle;
};

static void
create_folder_cb (GtkFileSystemHandle *handle,
		  const GtkFilePath   *path,
		  const GError        *error,
		  gpointer             data)
{
  struct get_folder_data *get_folder_data;

  get_folder_data = data;
  notify_callback_called (get_folder_data->callback_closure);
}

static gpointer
create_folder_generic_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			     TestCallbackClosure *callback_closure)
{
  GtkFilePath *path;
  struct create_folder_data *create_folder_data;

  path = gtk_file_system_filename_to_path (file_system, CREATE_FOLDER_FILENAME);
  if (!path)
    {
      *success = FALSE;
      *failure_reason = g_strdup_printf ("could not turn \"%s\" into a GtkFilePath", CREATE_FOLDER_FILENAME);
      return NULL;
    }

  create_folder_data = g_new (struct create_folder_data, 1);

  create_folder_data->callback_closure = callback_closure;
  create_folder_data->handle = gtk_file_system_create_folder (file_system,
							      path,
							      create_folder_cb,
							      create_folder_data);
  gtk_file_path_free (path);

  if (!create_folder_data->handle)
    {
      g_free (create_folder_data);
      *success = FALSE;
      *failure_reason = g_strdup ("gtk_file_system_create_folder() returned a NULL handle");
      return NULL;
    }

  *success = TRUE;
  return create_folder_data;
}

static gpointer
create_folder_no_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			       TestCallbackClosure *callback_closure)
{
  return create_folder_generic_setup (file_system, success, failure_reason, callback_closure);
}

static void
create_folder_cleanup (gpointer data, gboolean *success, char **failure_reason)
{
  struct create_folder_data *create_folder_data;

  create_folder_data = data;

  rmdir (CREATE_FOLDER_FILENAME);

  g_free (create_folder_data);

  *success = TRUE;
}

static gpointer
create_folder_with_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
				 TestCallbackClosure *callback_closure)
{
  struct create_folder_data *create_folder_data;

  create_folder_data = create_folder_generic_setup (file_system, success, failure_reason, callback_closure);

  if (*success)
    sleep_and_cancel_handle (create_folder_data->handle);

  return create_folder_data;
}

/* volume_mount */

struct volume_mount_data {
  TestCallbackClosure *callback_closure;
  GtkFileSystemVolume *volume;
  GtkFileSystemHandle *handle;
};

static void
volume_mount_cb (GtkFileSystemHandle *handle,
		 GtkFileSystemVolume *volume,
		 const GError        *error,
		 gpointer             data)
{
  struct volume_mount_data *volume_mount_data;

  volume_mount_data = data;
  notify_callback_called (volume_mount_data->callback_closure);
}

static gpointer
volume_mount_generic_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			    TestCallbackClosure *callback_closure)
{
  GtkFilePath *path;
  struct volume_mount_data *volume_mount_data;

  path = gtk_file_system_filename_to_path (file_system, VOLUME_MOUNT_FILENAME);
  if (!path)
    {
      *success = FALSE;
      *failure_reason = g_strdup_printf ("could not turn \"%s\" into a GtkFilePath", VOLUME_MOUNT_FILENAME);
      return NULL;
    }

  volume_mount_data = g_new (struct volume_mount_data, 1);

  volume_mount_data->callback_closure = callback_closure;
  volume_mount_data->volume = gtk_file_system_get_volume_for_path (file_system, path);
  gtk_file_path_free (path);

  if (!volume_mount_data->volume)
    {
      g_free (volume_mount_data);
      *success = FALSE;
      *failure_reason = g_strdup ("gtk_file_system_get_volume_for_path() returned a NULL volume");
      return NULL;
    }

  volume_mount_data->handle = gtk_file_system_volume_mount (file_system,
							    volume_mount_data->volume,
							    volume_mount_cb,
							    volume_mount_data);
  if (!volume_mount_data->handle)
    {
      g_object_unref (volume_mount_data->volume);
      g_free (volume_mount_data);
      *success = FALSE;
      *failure_reason = g_strdup ("gtk_file_system_volume_mount() returned a NULL handle");
      return NULL;
    }

  *success = TRUE;
  return volume_mount_data;
}

static gpointer
volume_mount_no_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
			      TestCallbackClosure *callback_closure)
{
  return volume_mount_generic_setup (file_system, success, failure_reason, callback_closure);
}

static void
volume_mount_cleanup (gpointer data, gboolean *success, char **failure_reason)
{
  struct volume_mount_data *volume_mount_data;

  volume_mount_data = data;

  g_object_unref (volume_mount_data->volume);
  g_free (volume_mount_data);

  *success = TRUE;
}

static gpointer
volume_mount_with_cancel_setup (GtkFileSystem *file_system, gboolean *success, char **failure_reason,
				TestCallbackClosure *callback_closure)
{
  struct volume_mount_data *volume_mount_data;

  volume_mount_data = volume_mount_generic_setup (file_system, success, failure_reason, callback_closure);

  if (*success)
    sleep_and_cancel_handle (volume_mount_data->handle);

  return volume_mount_data;
}

/* tests */

static TestSpec tests[] = {
  {
    "get_folder no cancel",
    TRUE,
    get_folder_no_cancel_setup,
    get_folder_cleanup
  },
  {
    "get_folder with cancel",
    FALSE,
    get_folder_with_cancel_setup,
    get_folder_cleanup
  },
  {
    "get_info no cancel",
    TRUE,
    get_info_no_cancel_setup,
    get_info_cleanup
  },
  {
    "get_info with cancel",
    FALSE,
    get_info_with_cancel_setup,
    get_info_cleanup
  },
  {
    "create_folder no cancel",
    TRUE,
    create_folder_no_cancel_setup,
    create_folder_cleanup
  },
  {
    "create_folder with cancel",
    FALSE,
    create_folder_with_cancel_setup,
    create_folder_cleanup
  },
  {
    "volume_mount no cancel",
    TRUE,
    volume_mount_no_cancel_setup,
    volume_mount_cleanup
  },
  {
    "volume_mount with cancel",
    FALSE,
    volume_mount_with_cancel_setup,
    volume_mount_cleanup
  }
};



/***** main *****/

static GLogFunc default_log_handler;
static int num_warnings;
static int num_errors;
static int num_critical_errors;

static void
log_override_cb (const gchar   *log_domain,
		 GLogLevelFlags log_level,
		 const gchar   *message,
		 gpointer       user_data)
{
  if (log_level & G_LOG_LEVEL_WARNING)
    num_warnings++;

  if (log_level & G_LOG_LEVEL_ERROR)
    num_errors++;

  if (log_level & G_LOG_LEVEL_CRITICAL)
    num_critical_errors++;

  (* default_log_handler) (log_domain, log_level, message, user_data);
}

static void
log_test (gboolean passed, const char *test_name, ...)
{
  va_list args;
  char *str;

  va_start (args, test_name);
  str = g_strdup_vprintf (test_name, args);
  va_end (args);

  g_printf ("%s: %s\n", passed ? "PASSED" : "FAILED", str);
  g_free (str);
}

int
main (int argc, char **argv)
{
  gboolean passed;
  gboolean zero_warnings;
  gboolean zero_errors;
  gboolean zero_critical_errors;

  default_log_handler = g_log_set_default_handler (log_override_cb, NULL);

  gtk_init (&argc, &argv);

  /* Start tests */

  passed = run_tests (tests, G_N_ELEMENTS (tests));

  /* Warnings and errors */

  zero_warnings = num_warnings == 0;
  zero_errors = num_errors == 0;
  zero_critical_errors = num_critical_errors == 0;

  log_test (zero_warnings, "main(): zero warnings (actual number %d)", num_warnings);
  log_test (zero_errors, "main(): zero errors (actual number %d)", num_errors);
  log_test (zero_critical_errors, "main(): zero critical errors (actual number %d)", num_critical_errors);

  /* Done */

  passed = passed && zero_warnings && zero_errors && zero_critical_errors;

  log_test (passed, "main(): ALL TESTS");

  return 0;
}