Pileus Git - ~andy/gtk/blob - gtk/tests/filechooser.c

   1 /* GTK - The GIMP Toolkit
   2  * autotestfilechooser.c: Automated unit tests for the GtkFileChooser widget
   3  * Copyright (C) 2005, Novell, Inc.
   4  *
   5  * Authors:
   6  *   Federico Mena-Quintero <federico@novell.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /* TODO:
  25  *
  26  * - In test_reload_sequence(), test that the selection is preserved properly
  27  *   between unmap/map.
  28  *
  29  * - More tests!
  30  */
  31
  32 #define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED
  33 #undef GTK_DISABLE_DEPRECATED
  34 #define SLEEP_DURATION  100
  35
  36 #include "config.h"
  37 #include <string.h>
  38 #include <glib/gprintf.h>
  39 #include <gtk/gtk.h>
  40 #include "gtk/gtkfilechooserprivate.h"
  41 #include "gtk/gtkfilechooserdefault.h"
  42 #include "gtk/gtkfilechooserentry.h"
  43
  44 static void
  45 log_test (gboolean passed, const char *test_name, ...)
  46 {
  47   va_list args;
  48   char *str;
  49
  50   va_start (args, test_name);
  51   str = g_strdup_vprintf (test_name, args);
  52   va_end (args);
  53
  54   if (g_test_verbose())
  55     g_printf ("%s: %s\n", passed ? "PASSED" : "FAILED", str);
  56   g_free (str);
  57 }
  58
  59 typedef void (* SetFilenameFn) (GtkFileChooser *chooser, gpointer data);
  60 typedef gboolean (* CompareFilenameFn) (GtkFileChooser *chooser, gpointer data);
  61
  62 struct test_set_filename_closure {
  63   GtkWidget *chooser;
  64   GtkWidget *accept_button;
  65   gboolean focus_button;
  66 };
  67
  68 static gboolean
  69 set_filename_timeout_cb (gpointer data)
  70 {
  71   struct test_set_filename_closure *closure;
  72
  73   closure = data;
  74
  75   if (closure->focus_button)
  76     gtk_widget_grab_focus (closure->accept_button);
  77
  78   gtk_button_clicked (GTK_BUTTON (closure->accept_button));
  79
  80   return FALSE;
  81 }
  82
  83
  84 static guint wait_for_idle_id = 0;
  85
  86 static gboolean
  87 wait_for_idle_idle (gpointer data)
  88 {
  89   wait_for_idle_id = 0;
  90
  91   return FALSE;
  92 }
  93
  94 static void
  95 wait_for_idle (void)
  96 {
  97   wait_for_idle_id = g_idle_add_full (G_PRIORITY_LOW + 100,
  98                                       wait_for_idle_idle,
  99                                       NULL, NULL);
 100
 101   while (wait_for_idle_id)
 102     gtk_main_iteration ();
 103 }
 104
 105 static gboolean
 106 test_set_filename (GtkFileChooserAction action,
 107                    gboolean focus_button,
 108                    SetFilenameFn set_filename_fn,const
 109                    CompareFilenameFn compare_filename_fn,
 110                    gpointer data)
 111 {
 112   GtkWidget *chooser;
 113   struct test_set_filename_closure closure;
 114   gboolean retval;
 115
 116   chooser = gtk_file_chooser_dialog_new ("hello", NULL, action,
 117                                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 118                                          NULL);
 119
 120   closure.chooser = chooser;
 121   closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (chooser), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
 122   closure.focus_button = focus_button;
 123
 124   gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT);
 125
 126   (* set_filename_fn) (GTK_FILE_CHOOSER (chooser), data);
 127
 128   gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, set_filename_timeout_cb, &closure, NULL);
 129   gtk_dialog_run (GTK_DIALOG (chooser));
 130
 131   retval = (* compare_filename_fn) (GTK_FILE_CHOOSER (chooser), data);
 132
 133   gtk_widget_destroy (chooser);
 134
 135   return retval;
 136 }
 137
 138 static void
 139 set_filename_cb (GtkFileChooser *chooser, gpointer data)
 140 {
 141   const char *filename;
 142
 143   filename = data;
 144   gtk_file_chooser_set_filename (chooser, filename);
 145 }
 146
 147 static gboolean
 148 compare_filename_cb (GtkFileChooser *chooser, gpointer data)
 149 {
 150   const char *filename;
 151   char *out_filename;
 152   gboolean retval;
 153
 154   filename = data;
 155   out_filename = gtk_file_chooser_get_filename (chooser);
 156
 157   if (out_filename)
 158     {
 159       retval = (strcmp (out_filename, filename) == 0);
 160       g_free (out_filename);
 161     } else
 162       retval = FALSE;
 163
 164   return retval;
 165 }
 166
 167 static gboolean
 168 test_black_box_set_filename (GtkFileChooserAction action, const char *filename, gboolean focus_button)
 169 {
 170   gboolean passed;
 171
 172   passed = test_set_filename (action, focus_button, set_filename_cb, compare_filename_cb, (char *) filename);
 173
 174   log_test (passed, "set_filename: action %d, focus_button=%s",
 175             (int) action,
 176             focus_button ? "TRUE" : "FALSE");
 177
 178   return passed;
 179
 180 }
 181
 182 struct current_name_closure {
 183         const char *path;
 184         const char *current_name;
 185 };
 186
 187 static void
 188 set_current_name_cb (GtkFileChooser *chooser, gpointer data)
 189 {
 190   struct current_name_closure *closure;
 191
 192   closure = data;
 193
 194   gtk_file_chooser_set_current_folder (chooser, closure->path);
 195   gtk_file_chooser_set_current_name (chooser, closure->current_name);
 196 }
 197
 198 static gboolean
 199 compare_current_name_cb (GtkFileChooser *chooser, gpointer data)
 200 {
 201   struct current_name_closure *closure;
 202   char *out_filename;
 203   gboolean retval;
 204
 205   closure = data;
 206
 207   out_filename = gtk_file_chooser_get_filename (chooser);
 208
 209   if (out_filename)
 210     {
 211       char *filename;
 212
 213       filename = g_build_filename (closure->path, closure->current_name, NULL);
 214       retval = (strcmp (filename, out_filename) == 0);
 215       g_free (filename);
 216       g_free (out_filename);
 217     } else
 218       retval = FALSE;
 219
 220   return retval;
 221 }
 222
 223 static gboolean
 224 test_black_box_set_current_name (GtkFileChooserAction action, const char *path, const char *current_name, gboolean focus_button)
 225 {
 226   struct current_name_closure closure;
 227   gboolean passed;
 228
 229   closure.path = path;
 230   closure.current_name = current_name;
 231
 232   passed = test_set_filename (action, focus_button,
 233                               set_current_name_cb, compare_current_name_cb, &closure);
 234
 235   log_test (passed, "set_current_name, focus_button=%s", focus_button ? "TRUE" : "FALSE");
 236
 237   return passed;
 238 }
 239
 240 /* FIXME: fails in CREATE_FOLDER mode when FOLDER_NAME == "/" */
 241
 242 #if 0
 243 #define FILE_NAME "/nonexistent"
 244 #define FOLDER_NAME "/etc"
 245 #else
 246 #define FILE_NAME "/etc/passwd"
 247 #define FOLDER_NAME "/etc"
 248 #endif
 249
 250 #define CURRENT_NAME "parangaricutirimicuaro.txt"
 251 #define CURRENT_NAME_FOLDER "parangaricutirimicuaro"
 252
 253 /* https://bugzilla.novell.com/show_bug.cgi?id=184875
 254  * http://bugzilla.gnome.org/show_bug.cgi?id=347066
 255  * http://bugzilla.gnome.org/show_bug.cgi?id=346058
 256  */
 257 static void
 258 test_black_box (void)
 259 {
 260   gboolean passed;
 261   char *cwd;
 262
 263   passed = TRUE;
 264
 265   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_OPEN, FILE_NAME, FALSE);
 266   g_assert (passed);
 267   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_OPEN, FILE_NAME, TRUE);
 268   g_assert (passed);
 269   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SAVE, FILE_NAME, FALSE);
 270   g_assert (passed);
 271   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SAVE, FILE_NAME, TRUE);
 272   g_assert (passed);
 273   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, FOLDER_NAME, FALSE);
 274   g_assert (passed);
 275   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, FOLDER_NAME, TRUE);
 276   g_assert (passed);
 277   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, FOLDER_NAME, FALSE);
 278   g_assert (passed);
 279   passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, FOLDER_NAME, TRUE);
 280   g_assert (passed);
 281
 282   cwd = g_get_current_dir ();
 283
 284   passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_SAVE, cwd, CURRENT_NAME, FALSE);
 285   g_assert (passed);
 286   passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_SAVE, cwd, CURRENT_NAME, TRUE);
 287   g_assert (passed);
 288   passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, cwd, CURRENT_NAME_FOLDER, FALSE);
 289   g_assert (passed);
 290   passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, cwd, CURRENT_NAME_FOLDER, TRUE);
 291   g_assert (passed);
 292
 293   g_free (cwd);
 294
 295   log_test (passed, "Black box tests");
 296 }
 297
 298 struct confirm_overwrite_closure {
 299   GtkWidget *chooser;
 300   GtkWidget *accept_button;
 301   gint confirm_overwrite_signal_emitted;
 302   gchar *extension;
 303 };
 304
 305 static GtkFileChooserConfirmation
 306 confirm_overwrite_cb (GtkFileChooser *chooser, gpointer data)
 307 {
 308   struct confirm_overwrite_closure *closure = data;
 309
 310   if (g_test_verbose())
 311     printf ("bling!\n");
 312   closure->confirm_overwrite_signal_emitted += 1;
 313
 314   return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME;
 315 }
 316
 317 static void
 318 overwrite_response_cb (GtkFileChooser *chooser, gint response, gpointer data)
 319 {
 320   struct confirm_overwrite_closure *closure = data;
 321   char *filename;
 322
 323   if (g_test_verbose())
 324     printf ("plong!\n");
 325
 326   if (response != GTK_RESPONSE_ACCEPT)
 327     return;
 328
 329   filename = gtk_file_chooser_get_filename (chooser);
 330
 331   if (!g_str_has_suffix (filename, closure->extension))
 332     {
 333       char *basename;
 334
 335       basename = g_path_get_basename (filename);
 336       g_free (filename);
 337
 338       filename = g_strconcat (basename, closure->extension, NULL);
 339       gtk_file_chooser_set_current_name (chooser, filename);
 340
 341       g_signal_stop_emission_by_name (chooser, "response");
 342       gtk_dialog_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT);
 343     }
 344 }
 345
 346 static gboolean
 347 confirm_overwrite_timeout_cb (gpointer data)
 348 {
 349   struct confirm_overwrite_closure *closure;
 350
 351   closure = data;
 352   gtk_button_clicked (GTK_BUTTON (closure->accept_button));
 353
 354   return FALSE;
 355 }
 356
 357 /* http://bugzilla.gnome.org/show_bug.cgi?id=347883 */
 358 static gboolean
 359 test_confirm_overwrite_for_path (const char *path, gboolean append_extension)
 360 {
 361   gboolean passed;
 362   struct confirm_overwrite_closure closure;
 363   char *filename;
 364
 365   passed = TRUE;
 366
 367   closure.extension = NULL;
 368   closure.confirm_overwrite_signal_emitted = 0;
 369   closure.chooser = gtk_file_chooser_dialog_new ("hello", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
 370                                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 371                                                  NULL);
 372   closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (closure.chooser),
 373                                                  GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT);
 374   gtk_dialog_set_default_response (GTK_DIALOG (closure.chooser), GTK_RESPONSE_ACCEPT);
 375
 376   gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (closure.chooser), TRUE);
 377
 378   g_signal_connect (closure.chooser, "confirm-overwrite",
 379                     G_CALLBACK (confirm_overwrite_cb), &closure);
 380
 381   if (append_extension)
 382     {
 383       char *extension;
 384
 385       filename = g_path_get_dirname (path);
 386       gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (closure.chooser), filename);
 387       g_free (filename);
 388
 389       filename = g_path_get_basename (path);
 390       extension = strchr (filename, '.');
 391
 392       if (extension)
 393         {
 394           closure.extension = g_strdup (extension);
 395           *extension = '\0';
 396         }
 397
 398       gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (closure.chooser), filename);
 399       g_free (filename);
 400
 401       g_signal_connect (closure.chooser, "response",
 402                         G_CALLBACK (overwrite_response_cb), &closure);
 403     }
 404   else
 405     {
 406       gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (closure.chooser), path);
 407     }
 408
 409   gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, confirm_overwrite_timeout_cb, &closure, NULL);
 410   gtk_dialog_run (GTK_DIALOG (closure.chooser));
 411
 412   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (closure.chooser));
 413   passed = passed && filename && (strcmp (filename, path) == 0);
 414   g_free (filename);
 415
 416   gtk_widget_destroy (closure.chooser);
 417
 418   passed = passed && (1 == closure.confirm_overwrite_signal_emitted);
 419
 420   log_test (passed, "Confirm overwrite for %s", path);
 421
 422   return passed;
 423 }
 424
 425 static void
 426 test_confirm_overwrite (void)
 427 {
 428   gboolean passed = TRUE;
 429
 430   /* first test for a file we know will always exist */
 431   passed = passed && test_confirm_overwrite_for_path ("/etc/passwd", FALSE);
 432   g_assert (passed);
 433   passed = passed && test_confirm_overwrite_for_path ("/etc/resolv.conf", TRUE);
 434   g_assert (passed);
 435 }
 436
 437 static const GtkFileChooserAction open_actions[] = {
 438   GTK_FILE_CHOOSER_ACTION_OPEN,
 439   GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
 440 };
 441
 442 static const GtkFileChooserAction save_actions[] = {
 443   GTK_FILE_CHOOSER_ACTION_SAVE,
 444   GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
 445 };
 446
 447
 448 static gboolean
 449 has_action (const GtkFileChooserAction *actions,
 450             int n_actions,
 451             GtkFileChooserAction sought_action)
 452 {
 453   int i;
 454
 455   for (i = 0; i < n_actions; i++)
 456     if (actions[i] == sought_action)
 457       return TRUE;
 458
 459   return FALSE;
 460 }
 461
 462 static const char *
 463 get_action_name (GtkFileChooserAction action)
 464 {
 465   GEnumClass *enum_class;
 466   GEnumValue *enum_value;
 467
 468   enum_class = g_type_class_peek (GTK_TYPE_FILE_CHOOSER_ACTION);
 469   if (!enum_class)
 470     g_error ("BUG: get_action_name(): no GEnumClass for GTK_TYPE_FILE_CHOOSER_ACTION");
 471
 472   enum_value = g_enum_get_value (enum_class, (int) action);
 473   if (!enum_value)
 474     g_error ("BUG: get_action_name(): no GEnumValue for GtkFileChooserAction %d", (int) action);
 475
 476   return enum_value->value_name;
 477 }
 478
 479 static GtkFileChooserDefault *
 480 get_impl_from_dialog (GtkWidget *dialog)
 481 {
 482   GtkFileChooserDialog *d;
 483   GtkFileChooserDialogPrivate *dialog_priv;
 484   GtkFileChooserWidget *chooser_widget;
 485   GtkFileChooserWidgetPrivate *widget_priv;
 486   GtkFileChooserDefault *impl;
 487
 488   d = GTK_FILE_CHOOSER_DIALOG (dialog);
 489   dialog_priv = d->priv;
 490   chooser_widget = GTK_FILE_CHOOSER_WIDGET (dialog_priv->widget);
 491   if (!chooser_widget)
 492     g_error ("BUG: dialog_priv->widget is not a GtkFileChooserWidget");
 493
 494   widget_priv = chooser_widget->priv;
 495   impl = (GtkFileChooserDefault *) (widget_priv->impl);
 496   if (!impl)
 497     g_error ("BUG: widget_priv->impl is not a GtkFileChooserDefault");
 498
 499   return impl;
 500 }
 501
 502 static gboolean
 503 test_widgets_for_current_action (GtkFileChooserDialog *dialog,
 504                                  GtkFileChooserAction  expected_action)
 505 {
 506   GtkFileChooserDefault *impl;
 507   gboolean passed;
 508
 509   if (gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog)) != expected_action)
 510     return FALSE;
 511
 512   impl = get_impl_from_dialog (GTK_WIDGET (dialog));
 513
 514   g_assert (impl->action == expected_action);
 515
 516   passed = TRUE;
 517
 518   /* OPEN implies that the "new folder" button is hidden; otherwise it is shown */
 519   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
 520     passed = passed && !gtk_widget_get_visible (impl->browse_new_folder_button);
 521   else
 522     passed = passed && gtk_widget_get_visible (impl->browse_new_folder_button);
 523
 524   /* Check that the widgets are present/visible or not */
 525   if (has_action (open_actions, G_N_ELEMENTS (open_actions), impl->action))
 526     {
 527       passed = passed && (impl->save_widgets == NULL
 528                           && (impl->location_mode == LOCATION_MODE_PATH_BAR
 529                               ? impl->location_entry == NULL
 530                               : impl->location_entry != NULL)
 531                           && impl->save_folder_label == NULL
 532                           && impl->save_folder_combo == NULL
 533                           && impl->save_expander == NULL
 534                           && GTK_IS_CONTAINER (impl->browse_widgets) && gtk_widget_is_drawable (impl->browse_widgets));
 535     }
 536   else if (has_action (save_actions, G_N_ELEMENTS (save_actions), impl->action))
 537     {
 538       /* FIXME: we can't use GTK_IS_FILE_CHOOSER_ENTRY() because it uses
 539        * _gtk_file_chooser_entry_get_type(), which is a non-exported symbol.
 540        * So, we just test impl->location_entry for being non-NULL
 541        */
 542       passed = passed && (GTK_IS_CONTAINER (impl->save_widgets) && gtk_widget_is_drawable (impl->save_widgets)
 543                           && impl->location_entry != NULL && gtk_widget_is_drawable (impl->location_entry)
 544                           && GTK_IS_LABEL (impl->save_folder_label) && gtk_widget_is_drawable (impl->save_folder_label)
 545                           && GTK_IS_COMBO_BOX (impl->save_folder_combo) && gtk_widget_is_drawable (impl->save_folder_combo)
 546                           && GTK_IS_EXPANDER (impl->save_expander) && gtk_widget_is_drawable (impl->save_expander)
 547                           && GTK_IS_CONTAINER (impl->browse_widgets));
 548
 549       /* FIXME: we are in a SAVE mode; test the visibility and sensitivity of
 550        * the children that change depending on the state of the expander.
 551        */
 552     }
 553   else
 554     {
 555       g_error ("BAD TEST: test_widgets_for_current_action() doesn't know about %s", get_action_name (impl->action));
 556       passed = FALSE;
 557     }
 558
 559   return passed;
 560 }
 561
 562 typedef gboolean (* ForeachActionCallback) (GtkFileChooserDialog *dialog,
 563                                             GtkFileChooserAction  action,
 564                                             gpointer              user_data);
 565
 566 static gboolean
 567 foreach_action (GtkFileChooserDialog *dialog,
 568                 ForeachActionCallback callback,
 569                 gpointer              user_data)
 570 {
 571   GEnumClass *enum_class;
 572   int i;
 573
 574   enum_class = g_type_class_peek (GTK_TYPE_FILE_CHOOSER_ACTION);
 575   if (!enum_class)
 576     g_error ("BUG: get_action_name(): no GEnumClass for GTK_TYPE_FILE_CHOOSER_ACTION");
 577
 578   for (i = 0; i < enum_class->n_values; i++)
 579     {
 580       GEnumValue *enum_value;
 581       GtkFileChooserAction action;
 582       gboolean passed;
 583
 584       enum_value = enum_class->values + i;
 585       action = enum_value->value;
 586
 587       passed = (* callback) (dialog, action, user_data);
 588       if (!passed)
 589         return FALSE;
 590     }
 591
 592   return TRUE;
 593 }
 594
 595 struct action_closure {
 596   GtkFileChooserAction from_action;
 597 };
 598
 599 static gboolean
 600 switch_from_to_action_cb (GtkFileChooserDialog *dialog,
 601                           GtkFileChooserAction  action,
 602                           gpointer              user_data)
 603 {
 604   struct action_closure *closure;
 605   gboolean passed;
 606
 607   closure = user_data;
 608
 609   gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), closure->from_action);
 610
 611   passed = test_widgets_for_current_action (dialog, closure->from_action);
 612   log_test (passed, "switch_from_to_action_cb(): reset to action %s", get_action_name (closure->from_action));
 613   if (!passed)
 614     return FALSE;
 615
 616   gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), action);
 617
 618   passed = test_widgets_for_current_action (dialog, action);
 619   log_test (passed, "switch_from_to_action_cb(): transition from %s to %s",
 620             get_action_name (closure->from_action),
 621             get_action_name (action));
 622   return passed;
 623 }
 624
 625 static gboolean
 626 switch_from_action_cb (GtkFileChooserDialog *dialog,
 627                        GtkFileChooserAction  action,
 628                        gpointer              user_data)
 629 {
 630   struct action_closure closure;
 631
 632   closure.from_action = action;
 633
 634   return foreach_action (dialog, switch_from_to_action_cb, &closure);
 635 }
 636
 637 static void
 638 test_action_widgets (void)
 639 {
 640   GtkWidget *dialog;
 641   GtkFileChooserAction action;
 642   gboolean passed;
 643
 644   dialog = gtk_file_chooser_dialog_new ("Test file chooser",
 645                                         NULL,
 646                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 647                                         GTK_STOCK_CANCEL,
 648                                         GTK_RESPONSE_CANCEL,
 649                                         GTK_STOCK_OK,
 650                                         GTK_RESPONSE_ACCEPT,
 651                                         NULL);
 652   gtk_widget_show_now (dialog);
 653
 654   action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog));
 655
 656   passed = test_widgets_for_current_action (GTK_FILE_CHOOSER_DIALOG (dialog), action);
 657   log_test (passed, "test_action_widgets(): widgets for initial action %s", get_action_name (action));
 658   g_assert (passed);
 659
 660   passed = foreach_action (GTK_FILE_CHOOSER_DIALOG (dialog), switch_from_action_cb, NULL);
 661   log_test (passed, "test_action_widgets(): all transitions through property change");
 662   g_assert (passed);
 663
 664   gtk_widget_destroy (dialog);
 665 }
 666
 667 static gboolean
 668 test_reload_sequence (gboolean set_folder_before_map)
 669 {
 670   GtkWidget *dialog;
 671   GtkFileChooserDefault *impl;
 672   gboolean passed;
 673   char *folder;
 674   char *current_working_dir;
 675
 676   passed = TRUE;
 677
 678   current_working_dir = g_get_current_dir ();
 679
 680   dialog = gtk_file_chooser_dialog_new ("Test file chooser",
 681                                         NULL,
 682                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 683                                         GTK_STOCK_CANCEL,
 684                                         GTK_RESPONSE_CANCEL,
 685                                         GTK_STOCK_OK,
 686                                         GTK_RESPONSE_ACCEPT,
 687                                         NULL);
 688   impl = get_impl_from_dialog (dialog);
 689
 690   if (set_folder_before_map)
 691     {
 692       gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
 693
 694       wait_for_idle ();
 695
 696       passed = passed && (impl->current_folder != NULL
 697                           && impl->browse_files_model != NULL
 698                           && (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 699                           && impl->reload_state == RELOAD_HAS_FOLDER
 700                           && (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
 701                           && ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 702                               ? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
 703                               : TRUE));
 704
 705       wait_for_idle ();
 706
 707       folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
 708       passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 709       g_free (folder);
 710     }
 711   else
 712     {
 713       /* Initially, no folder is not loaded or pending */
 714       passed = passed && (impl->current_folder == NULL
 715                           && impl->sort_model == NULL
 716                           && impl->browse_files_model == NULL
 717                           && impl->load_state == LOAD_EMPTY
 718                           && impl->reload_state == RELOAD_EMPTY
 719                           && impl->load_timeout_id == 0);
 720
 721       wait_for_idle ();
 722
 723       folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
 724       passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 725     }
 726
 727   log_test (passed, "test_reload_sequence(): initial status");
 728
 729   /* After mapping, it is loading some folder, either the one that was explicitly set or the default one */
 730
 731   gtk_widget_show_now (dialog);
 732
 733   wait_for_idle ();
 734
 735   passed = passed && (impl->current_folder != NULL
 736                       && impl->browse_files_model != NULL
 737                       && (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 738                       && impl->reload_state == RELOAD_HAS_FOLDER
 739                       && (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
 740                       && ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 741                           ? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
 742                           : TRUE));
 743
 744   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
 745   if (set_folder_before_map)
 746     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 747   else
 748     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 749
 750   g_free (folder);
 751
 752   log_test (passed, "test_reload_sequence(): status after map");
 753
 754   /* Unmap it; we should still have a folder */
 755
 756   gtk_widget_hide (dialog);
 757
 758   wait_for_idle ();
 759
 760   passed = passed && (impl->current_folder != NULL
 761                       && impl->browse_files_model != NULL
 762                       && (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 763                       && impl->reload_state == RELOAD_WAS_UNMAPPED
 764                       && (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
 765                       && ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 766                           ? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
 767                           : TRUE));
 768
 769   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
 770   if (set_folder_before_map)
 771     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 772   else
 773     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 774
 775   g_free (folder);
 776
 777   log_test (passed, "test_reload_sequence(): status after unmap");
 778
 779   /* Map it again! */
 780
 781   gtk_widget_show_now (dialog);
 782
 783   wait_for_idle ();
 784
 785   passed = passed && (impl->current_folder != NULL
 786                       && impl->browse_files_model != NULL
 787                       && (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 788                       && impl->reload_state == RELOAD_HAS_FOLDER
 789                       && (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
 790                       && ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
 791                           ? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
 792                           : TRUE));
 793
 794   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
 795   if (set_folder_before_map)
 796     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 797   else
 798     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 799
 800   g_free (folder);
 801
 802   log_test (passed, "test_reload_sequence(): status after re-map");
 803
 804   gtk_widget_destroy (dialog);
 805   g_free (current_working_dir);
 806
 807   return passed;
 808 }
 809
 810 static void
 811 test_reload (void)
 812 {
 813   gboolean passed;
 814
 815   passed = test_reload_sequence (FALSE);
 816   log_test (passed, "test_reload(): create and use the default folder");
 817   g_assert (passed);
 818
 819   passed = test_reload_sequence (TRUE);
 820   log_test (passed, "test_reload(): set a folder explicitly before mapping");
 821   g_assert (passed);
 822 }
 823
 824 static gboolean
 825 test_button_folder_states_for_action (GtkFileChooserAction action, gboolean use_dialog, gboolean set_folder_on_dialog)
 826 {
 827   gboolean passed;
 828   GtkWidget *window;
 829   GtkWidget *button;
 830   char *folder;
 831   GtkWidget *dialog;
 832   char *current_working_dir;
 833   gboolean must_have_cwd;
 834
 835   passed = TRUE;
 836
 837   current_working_dir = g_get_current_dir ();
 838   must_have_cwd = !(use_dialog && set_folder_on_dialog);
 839
 840   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 841
 842   if (use_dialog)
 843     {
 844       dialog = gtk_file_chooser_dialog_new ("Test", NULL, action,
 845                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 846                                             GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 847                                             NULL);
 848       button = gtk_file_chooser_button_new_with_dialog (dialog);
 849
 850       if (set_folder_on_dialog)
 851         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
 852     }
 853   else
 854     {
 855       button = gtk_file_chooser_button_new ("Test", action);
 856       dialog = NULL; /* keep gcc happy */
 857     }
 858
 859   gtk_container_add (GTK_CONTAINER (window), button);
 860
 861   /* Pre-map; no folder is set */
 862   wait_for_idle ();
 863
 864   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
 865   if (must_have_cwd)
 866     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 867   else
 868     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 869
 870   log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, pre-map, %s",
 871             get_action_name (action),
 872             use_dialog,
 873             set_folder_on_dialog,
 874             must_have_cwd ? "must have $cwd" : "must have explicit folder");
 875
 876   /* Map; folder should be set */
 877
 878   gtk_widget_show_all (window);
 879   gtk_widget_show_now (window);
 880
 881   wait_for_idle ();
 882
 883   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
 884
 885   if (must_have_cwd)
 886     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 887   else
 888     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 889
 890   log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, mapped, %s",
 891             get_action_name (action),
 892             use_dialog,
 893             set_folder_on_dialog,
 894             must_have_cwd ? "must have $cwd" : "must have explicit folder");
 895   g_free (folder);
 896
 897   /* Unmap; folder should be set */
 898
 899   gtk_widget_hide (window);
 900   wait_for_idle ();
 901   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
 902
 903   if (must_have_cwd)
 904     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 905   else
 906     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 907
 908   log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, unmapped, %s",
 909             get_action_name (action),
 910             use_dialog,
 911             set_folder_on_dialog,
 912             must_have_cwd ? "must have $cwd" : "must have explicit folder");
 913   g_free (folder);
 914
 915   /* Re-map; folder should be set */
 916
 917   gtk_widget_show_now (window);
 918   folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
 919
 920   if (must_have_cwd)
 921     passed = passed && (folder != NULL && strcmp (folder, current_working_dir) == 0);
 922   else
 923     passed = passed && (folder != NULL && strcmp (folder, g_get_home_dir()) == 0);
 924   wait_for_idle ();
 925   log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, re-mapped, %s",
 926             get_action_name (action),
 927             use_dialog,
 928             set_folder_on_dialog,
 929             must_have_cwd ? "must have $cwd" : "must have explicit folder");
 930   g_free (folder);
 931
 932   g_free (current_working_dir);
 933
 934   gtk_widget_destroy (window);
 935
 936   return passed;
 937 }
 938
 939 static void
 940 test_button_folder_states (void)
 941 {
 942   /* GtkFileChooserButton only supports OPEN and SELECT_FOLDER */
 943   static const GtkFileChooserAction actions_to_test[] = {
 944     GTK_FILE_CHOOSER_ACTION_OPEN,
 945     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
 946   };
 947   gboolean passed;
 948   int i;
 949
 950   passed = TRUE;
 951
 952   for (i = 0; i < G_N_ELEMENTS (actions_to_test); i++)
 953     {
 954       passed = passed && test_button_folder_states_for_action (actions_to_test[i], FALSE, FALSE);
 955       g_assert (passed);
 956       passed = passed && test_button_folder_states_for_action (actions_to_test[i], TRUE, FALSE);
 957       g_assert (passed);
 958       passed = passed && test_button_folder_states_for_action (actions_to_test[i], TRUE, TRUE);
 959       g_assert (passed);
 960       log_test (passed, "test_button_folder_states(): action %s", get_action_name (actions_to_test[i]));
 961     }
 962
 963   log_test (passed, "test_button_folder_states(): all supported actions");
 964 }
 965
 966 static gboolean
 967 sleep_timeout_cb (gpointer data)
 968 {
 969   gtk_main_quit ();
 970   return FALSE;
 971 }
 972
 973 static void
 974 sleep_in_main_loop (double fraction)
 975 {
 976   /* process all pending idles and events */
 977   while (g_main_context_pending (NULL))
 978     g_main_context_iteration (NULL, FALSE);
 979   /* sleeping probably isn't strictly necessary here */
 980   gdk_threads_add_timeout_full (G_MAXINT, fraction * SLEEP_DURATION, sleep_timeout_cb, NULL, NULL);
 981   gtk_main ();
 982   /* process any pending idles or events that arrived during sleep */
 983   while (g_main_context_pending (NULL))
 984     g_main_context_iteration (NULL, FALSE);
 985 }
 986
 987 static void
 988 test_folder_switch_and_filters (void)
 989 {
 990   gboolean passed;
 991   char *cwd;
 992   char *base_dir;
 993   GtkFilePath *cwd_path;
 994   GtkFilePath *base_dir_path;
 995   GtkWidget *dialog;
 996   GtkFileFilter *all_filter;
 997   GtkFileFilter *txt_filter;
 998   GtkFileChooserDefault *impl;
 999
1000   passed = TRUE;
1001
1002   cwd = g_get_current_dir ();
1003   base_dir = g_build_filename (cwd, "file-chooser-test-dir", NULL);
1004
1005   dialog = gtk_file_chooser_dialog_new ("Test", NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
1006                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1007                                         GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1008                                         NULL);
1009   impl = get_impl_from_dialog (dialog);
1010
1011   cwd_path = gtk_file_system_filename_to_path (impl->file_system, cwd);
1012   base_dir_path = gtk_file_system_filename_to_path (impl->file_system, base_dir);
1013
1014   passed = passed && gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), base_dir);
1015   g_assert (passed);
1016
1017   /* All files filter */
1018
1019   all_filter = gtk_file_filter_new ();
1020   gtk_file_filter_set_name (all_filter, "All files");
1021   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), all_filter);
1022
1023   /* *.txt filter */
1024
1025   txt_filter = gtk_file_filter_new ();
1026   gtk_file_filter_set_name (all_filter, "*.txt");
1027   gtk_file_filter_add_pattern (txt_filter, "*.txt");
1028   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), txt_filter);
1029
1030   /* Test filter set */
1031
1032   gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), all_filter);
1033   passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == all_filter);
1034   g_assert (passed);
1035
1036   gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), txt_filter);
1037   passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter);
1038   log_test (passed, "test_folder_switch_and_filters(): set and get filter");
1039   g_assert (passed);
1040
1041   gtk_widget_show (dialog);
1042
1043   /* Test that filter is unchanged when we switch folders */
1044
1045   gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), cwd);
1046   sleep_in_main_loop (0.5);
1047   passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter);
1048   g_assert (passed);
1049
1050   gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), base_dir);
1051   sleep_in_main_loop (0.25);
1052
1053   g_signal_emit_by_name (impl->browse_path_bar, "path-clicked",
1054                          (GtkFilePath *) cwd_path,
1055                          (GtkFilePath *) base_dir_path,
1056                          FALSE);
1057   sleep_in_main_loop (0.25);
1058   passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter);
1059   log_test (passed, "test_folder_switch_and_filters(): filter after changing folder");
1060   g_assert (passed);
1061
1062   /* cleanups */
1063   g_free (cwd);
1064   g_free (base_dir);
1065   gtk_file_path_free (cwd_path);
1066   gtk_file_path_free (base_dir_path);
1067
1068   gtk_widget_destroy (dialog);
1069
1070   log_test (passed, "test_folder_switch_and_filters(): all filter tests");
1071 }
1072
1073 extern void pixbuf_init (void);
1074
1075 int
1076 main (int    argc,
1077       char **argv)
1078 {
1079   pixbuf_init ();
1080   /* initialize test program */
1081   gtk_test_init (&argc, &argv);
1082
1083   /* register tests */
1084   g_test_add_func ("/GtkFileChooser/black_box", test_black_box);
1085   g_test_add_func ("/GtkFileChooser/confirm_overwrite", test_confirm_overwrite);
1086   g_test_add_func ("/GtkFileChooser/action_widgets", test_action_widgets);
1087   g_test_add_func ("/GtkFileChooser/reload", test_reload);
1088   g_test_add_func ("/GtkFileChooser/button_folder_states", test_button_folder_states);
1089   g_test_add_func ("/GtkFileChooser/folder_switch_and_filters", test_folder_switch_and_filters);
1090
1091   /* run and check selected tests */
1092   return g_test_run();
1093 }