← Back to branch summary

~canonical-dx-team/ubuntu/maverick/gtk+2.0/menuproxy

« back to all changes in this revision

Viewing changes to tests/autotestfilechooser.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-05-04 12:24:25 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20070504122425-0m8midgzrp40y8w2
Tags: 2.10.12-1ubuntu1
* Sync with Debian
* New upstream version:
  Fixed bugs:
  - 379414 file chooser warnings when changing path in the entry
  - 418585 GtkFileChooserDefault sizing code is not DPI independent
  - 419568 Crash in search if start with special letter
  - 435062 build dies with icon cache validation
  - 379399 Segfault to call gtk_print_operation_run twice.
  - 387889 cups backend has problems when there are too many printers
  - 418531 invalid read to gtkicontheme.c gtk_icon_theme_lookup_icon...
  - 423916 crash in color scheme code
  - 424042 Segmentation fault while quickly pressing Alt+arrows
  - 415260 Protect against negative indices when setting values in G...
  - 419171 XGetVisualInfo() may not set nxvisuals
  - 128852 Gdk cursors don't look good on win32
  - 344657 Ctrl-H doesn't toggle "Show Hidden Files" setting
  - 345345 PrintOperation::paginate is not emitted for class handler
  - 347567 GtkPrintOperation::end-print is not emitted if it's cance...
  - 369112 gtk_ui_manager_add_ui should accept unnamed separator
  - 392015 Selected menu item invisible on Windows Vista
  - 399253 MS-Windows Theme Bottom Tab placement rendering glitches
  - 399425 gtk_input_dialog_fill_axes() adds child to gtkscrolledwin...
  - 403251 [patch] little memory leak in GtkPrintJob
  - 403267 [patch] memory leak in GtkPageSetupUnixDialog
  - 403470 MS-Windows Theme tab placement other than on top leaks a ...
  - 404506 Windows system fonts that have multi-byte font names cann...
  - 405089 Incorrect window placement for GtkEventBox private window
  - 405515 Minor leak in gtkfilesystemmodel.c
  - 405539 gdk_pixbuf_save() for PNG saver can return FALSE without ...
  - 415681 gdk_window_clear_area includes an extra line and column o...
  - 418219 GtkRecentChooser should apply filter before sorting and c...
  - 418403 Scroll to printer after selecting it from settings
  - 421985 _gtk_print_operation_platform_backend_launch_preview
  - 421990 gtk_print_job_get_surface
  - 421993 gtk_print_operation_init
  - 423064 Conditional jump or move depends on uninitialised value(s...
  - 423722 Fix printing header in gtk-demo
  - 424168 gtk_print_operation_run on async preview
  - 425655 Don't install gtk+-unix-print-2.0.pc on non-UNIX platforms
  - 425786 GDK segfaults if XineramaQueryScreens fails
  - 428665 Lpr Backend gets stuck in infinite loop during gtk_enumer...
  - 429902 GtkPrintOperation leaks cairo contextes
  - 431997 First delay of GdkPixbufAnimationIter is wrong
  - 433242 Inconsistent scroll arrow position calculations
  - 433972 Placing gtk.Expander inside a gtk.TextView() changes gtk....
  - 434261 _gtk_toolbar_elide_underscores incorrectly handles some s...
  - 383354 ctrl-L should make 'Location' entry disappear
  - 418673 gtk_recent_manager_add_item
  - 429732 gtk_accel_group_finalize accesses invalid memory
  - 435028 WM_CLIENT_LEADER is wrong on the leader_window
  - 431067 Background of the header window is not updated
  - 338843 add recent files support inside the ui manager
  - 148535 add drop shadow to menus, tooltips, etc. under Windows XP
* debian/control.in:
  - Conflicts on ubuntulooks (<= 0.9.11-1)
* debian/patches/15_default-fallback-icon-theme.patch:
  - patch from Debian, fallback on gnome icon theme

Show diffs side-by-side

added added

removed removed

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