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