2002-08-12 Michael Meeks <michael@ximian.com>
[platform/core/uifw/at-spi2-atk.git] / test / test-simple.c
1 /*
2  * test-simple.c: A set of simple regression tests
3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
4  *
5  * Copyright 2001 Ximian, Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
22
23 /*
24  * ******** Do not copy this code as an example *********
25  */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <gtk/gtk.h>
31 #include <cspi/spi.h>
32 #include <libbonobo.h>
33
34
35 /* Known bugs */
36 #define WHOLE_STRING -1
37
38 static void validate_accessible (Accessible *accessible,
39                                  gboolean    has_parent,
40                                  gboolean    recurse_down);
41
42 #define WINDOW_MAGIC 0x123456a
43 #define TEST_STRING_A "A test string"
44 #define TEST_STRING_B "Another test string"
45
46 static int      print_tree_depth = 0;
47 static gboolean print_tree = FALSE;
48 static gboolean do_poke = FALSE;
49 static gboolean key_press_received = FALSE;
50 static gboolean key_release_received = FALSE;
51
52 typedef struct {
53         gulong     magic;
54         GtkWidget *window;
55 } TestWindow;
56
57 static gboolean
58 focus_me (GtkWidget *widget)
59 {
60         AtkObject *aobject = atk_implementor_ref_accessible (
61                 ATK_IMPLEMENTOR (widget));
62         
63         /* Force a focus event - even if the WM focused
64          * us before our at-bridge's idle handler registered
65          * our interest */
66         if (!GTK_WIDGET_HAS_FOCUS (widget))
67                 gtk_widget_grab_focus (widget);
68 /*      else: FIXME - gtk_widget_grab_focus should send a notify */
69                 atk_focus_tracker_notify (aobject);
70         
71         g_object_unref (G_OBJECT (aobject));
72
73         return FALSE;
74 }
75
76 static void
77 test_window_add_and_show (GtkContainer *container, GtkWidget *widget)
78 {
79         gtk_container_add (container, widget);
80         gtk_widget_show (widget);
81 }
82
83 static GtkWidget *
84 create_tree (void)
85 {
86         GtkWidget         *widget;
87         GtkTreeIter        iter;
88         GtkListStore      *store;
89         GtkTreeViewColumn *column;
90
91         store = gtk_list_store_new (1, G_TYPE_STRING);
92         gtk_list_store_append (store, &iter);
93         gtk_list_store_set (store, &iter, 0, TEST_STRING_A, -1); 
94         column = gtk_tree_view_column_new_with_attributes ("String",
95                 gtk_cell_renderer_text_new (), "text", 0, NULL);
96         widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); 
97         g_object_unref (G_OBJECT (store));
98         gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
99
100         return widget;
101 }
102
103 static TestWindow *
104 create_test_window (void)
105 {
106         TestWindow *win = g_new0 (TestWindow, 1);
107         GtkWidget  *widget, *vbox;
108
109         win->magic  = WINDOW_MAGIC;
110         win->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
111  
112         gtk_widget_show (win->window);
113
114         vbox = gtk_vbox_new (0, 0);
115         gtk_container_add (GTK_CONTAINER (win->window), vbox);
116         gtk_widget_show (vbox);
117
118         widget = gtk_entry_new ();
119         gtk_entry_set_text (GTK_ENTRY (widget), TEST_STRING_A);
120         test_window_add_and_show (GTK_CONTAINER (vbox), widget);
121
122         widget = gtk_button_new_with_label ("_Foobar");
123         test_window_add_and_show (GTK_CONTAINER (vbox), widget);
124
125         widget = gtk_hseparator_new ();
126         test_window_add_and_show (GTK_CONTAINER (vbox), widget);
127
128         widget = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION,
129                                            GTK_ICON_SIZE_LARGE_TOOLBAR);
130         test_window_add_and_show (GTK_CONTAINER (vbox), widget);
131
132         widget = g_object_new (GTK_TYPE_RANGE, NULL);
133         gtk_range_set_range (GTK_RANGE (widget), 0.0, 100.0);
134         test_window_add_and_show (GTK_CONTAINER (vbox), widget);
135
136         widget = create_tree ();
137         test_window_add_and_show (GTK_CONTAINER (vbox), widget);
138
139         g_idle_add ((GSourceFunc) focus_me, win->window);
140
141         return win;
142 }
143
144 static void
145 test_window_destroy (TestWindow *win)
146 {
147         gtk_widget_destroy (win->window);
148         g_free (win);
149 }
150
151 static void
152 test_roles (void)
153 {
154         int i;
155
156         fprintf (stderr, "Testing roles...\n");
157         for (i = -1; i < 1000; i++)
158                 g_assert (AccessibleRole_getName (i) != NULL);
159
160         g_assert (!strcmp (AccessibleRole_getName (SPI_ROLE_FILE_CHOOSER), "file chooser"));
161         g_assert (!strcmp (AccessibleRole_getName (SPI_ROLE_RADIO_BUTTON), "radiobutton"));
162         g_assert (!strcmp (AccessibleRole_getName (SPI_ROLE_TABLE), "table"));
163         g_assert (!strcmp (AccessibleRole_getName (SPI_ROLE_WINDOW), "window"));
164 }
165
166 static void
167 test_action (AccessibleAction *action)
168 {
169         gint n_actions, i;
170         gchar *s, *sd;
171         g_assert ((n_actions = AccessibleAction_getNActions (action)) >= 0);
172
173         fprintf (stderr, "Testing actions...");
174         for (i = 0; i < n_actions; ++i)
175         {
176                 s = AccessibleAction_getName (action, i);
177                 g_assert (s);
178                 sd = AccessibleAction_getDescription (action, i);
179                 g_assert (sd);
180                 fprintf (stderr, "%d: %s (%s);  ", i, s, sd);
181                 SPI_freeString (s);
182                 SPI_freeString (sd);
183                 g_assert (AccessibleAction_doAction (action, i));
184         }
185         fprintf (stderr, "\n");
186 }
187
188 static void
189 test_desktop (void)
190 {
191         Accessible  *desktop;
192         Accessible  *application;
193         int          length;
194         Accessible **list;
195
196         fprintf (stderr, "Testing desktop...\n");
197
198         g_assert (SPI_getDesktop (-1) == NULL);
199         desktop = SPI_getDesktop (0);
200         g_assert (desktop != NULL);
201
202         g_assert ((length = SPI_getDesktopList (&list)) > 0);
203         g_assert (list[0] == desktop);
204         SPI_freeDesktopList (list);
205
206         validate_accessible (desktop, FALSE, FALSE);
207
208         application = Accessible_getChildAtIndex (desktop, 0);
209         g_assert (application != NULL);
210         AccessibleApplication_unref (application);
211
212         Accessible_unref (desktop);
213 }
214
215 static void
216 test_application (Accessible *application)
217 {
218         char *str;
219
220         fprintf (stderr, "Testing application ...\n");
221         g_assert (Accessible_isApplication (application));
222         g_assert (Accessible_getApplication (application) ==
223                   application);
224         AccessibleApplication_unref (application);
225
226         str = AccessibleApplication_getToolkitName (application);
227         g_assert (str != NULL);
228         g_assert (!strcmp (str, "GAIL"));
229         SPI_freeString (str);
230
231         str = AccessibleApplication_getVersion (application);
232         g_assert (str != NULL);
233         SPI_freeString (str);
234
235         AccessibleApplication_getID (application);
236 }
237
238 static void
239 test_editable_text (AccessibleEditableText *etext)
240 {
241         char *str;
242         AccessibleText *text;
243
244         fprintf (stderr, "Testing editable text ...\n");
245         
246         g_assert (Accessible_isText (etext));
247         text = Accessible_getText (etext);
248
249         AccessibleEditableText_setTextContents (
250                 etext, TEST_STRING_B);
251
252         str = AccessibleText_getText (text, 0, WHOLE_STRING);
253         g_assert (!strcmp (str, TEST_STRING_B));
254
255         SPI_freeString (str);
256
257         /* FIXME: lots more editing here */
258
259         AccessibleEditableText_setTextContents (
260                 etext, TEST_STRING_A);
261
262         AccessibleText_unref (text);
263 }
264
265 static void
266 test_table (AccessibleTable *table)
267 {
268         Accessible *header;
269         gint index;
270         gint rows, columns;
271
272         fprintf (stderr, "Testing table ...\n");
273
274         rows = AccessibleTable_getNRows (table);
275         g_assert (rows > 0);
276
277         columns = AccessibleTable_getNColumns (table);
278         g_assert (columns > 0);
279
280         index = AccessibleTable_getIndexAt (table, rows - 1, columns - 1);
281
282         g_assert (AccessibleTable_getRowAtIndex (table, index) == rows - 1);
283
284         g_assert (AccessibleTable_getColumnAtIndex (table, index) == columns - 1);
285
286         g_assert ((header = AccessibleTable_getColumnHeader (table, 0)));
287         Accessible_unref (header);
288
289         AccessibleTable_isSelected (table, 0, 0);
290         
291         /* FIXME: lots more tests */
292 }
293
294 static void
295 test_text (AccessibleText *text)
296 {
297         char *str;
298
299         fprintf (stderr, "Testing text ...\n");
300
301         g_assert (AccessibleText_getCharacterCount (text) ==
302                   strlen (TEST_STRING_A));
303
304         str = AccessibleText_getText (text, 0, WHOLE_STRING);
305         g_assert (!strcmp (str, TEST_STRING_A));
306         SPI_freeString (str);
307
308         str = AccessibleText_getText (text, 0, 5);
309         g_assert (!strncmp (str, TEST_STRING_A, 5));
310         SPI_freeString (str);
311
312         AccessibleText_setCaretOffset (text, 7);
313         g_assert (AccessibleText_getCaretOffset (text) == 7);
314
315         /* FIXME: lots more tests - selections etc. etc. */
316 }
317
318 static void
319 test_value (AccessibleValue *value)
320 {
321         float original_value;
322         
323         fprintf (stderr, "Testing value ...\n");
324
325         original_value = AccessibleValue_getCurrentValue (value);
326         
327         g_assert (AccessibleValue_getCurrentValue (value) <=
328                   AccessibleValue_getMaximumValue (value));
329
330         g_assert (AccessibleValue_getCurrentValue (value) >=
331                   AccessibleValue_getMinimumValue (value));
332
333         AccessibleValue_setCurrentValue (value, 
334                   AccessibleValue_getMinimumValue (value));
335         
336         g_assert (AccessibleValue_getCurrentValue (value) ==
337                   AccessibleValue_getMinimumValue (value));
338
339         AccessibleValue_setCurrentValue (value, 
340                   AccessibleValue_getMaximumValue (value));
341         
342         g_assert (AccessibleValue_getCurrentValue (value) ==
343                   AccessibleValue_getMaximumValue (value));
344
345         AccessibleValue_setCurrentValue (value, original_value);
346         
347         g_assert (AccessibleValue_getCurrentValue (value) == original_value);
348 }
349
350 static void
351 test_component (AccessibleComponent *component)
352 {
353         long x, y, width, height;
354
355         fprintf (stderr, "Testing component...\n");
356
357         AccessibleComponent_getExtents (
358                 component, &x, &y, &width, &height, SPI_COORD_TYPE_SCREEN);
359
360         AccessibleComponent_getPosition (
361                 component, &x, &y, SPI_COORD_TYPE_SCREEN);
362
363         AccessibleComponent_getSize (component, &width, &height);
364
365         if (width > 0 && height > 0) {
366 #ifdef FIXME
367                 Accessible *accessible, *componentb;
368 #endif
369
370                 g_assert (AccessibleComponent_contains (
371                         component, x, y, SPI_COORD_TYPE_SCREEN));
372
373                 g_assert (AccessibleComponent_contains (
374                         component, x + width - 1, y, SPI_COORD_TYPE_SCREEN));
375
376                 g_assert (AccessibleComponent_contains (
377                         component, x + width - 1, y + height - 1,
378                         SPI_COORD_TYPE_SCREEN));
379
380 #ifdef FIXME
381                 accessible = AccessibleComponent_getAccessibleAtPoint (
382                         component, x, y, SPI_COORD_TYPE_SCREEN);
383
384                 g_assert (Accessible_isComponent (accessible));
385                 componentb = Accessible_getComponent (accessible);
386                 g_assert (componentb == component);
387
388                 AccessibleComponent_unref (componentb);
389                 Accessible_unref (accessible);
390 #endif
391         }
392
393         AccessibleComponent_getLayer (component);
394         AccessibleComponent_getMDIZOrder (component);
395 /*      AccessibleComponent_grabFocus (component); */
396 }
397
398 static void
399 test_image (AccessibleImage *image)
400 {
401         char *desc;
402         long int x = -1, y = -1, width = -1, height = -1;
403
404         desc = AccessibleImage_getImageDescription (image);
405         g_assert (desc != NULL);
406         SPI_freeString (desc);
407
408         AccessibleImage_getImagePosition (image, &x, &y,
409                                           SPI_COORD_TYPE_SCREEN);
410         AccessibleImage_getImageSize     (image, &width, &height);
411         AccessibleImage_getImageExtents  (image, &x, &y, &width, &height,
412                                           SPI_COORD_TYPE_WINDOW);
413 }
414
415 static void
416 validate_tree (Accessible *accessible,
417                gboolean    has_parent,
418                gboolean    recurse_down)
419 {
420         Accessible  *parent;
421         long         len, i;
422
423         parent = Accessible_getParent (accessible);
424         if (has_parent) {
425                 long        index;
426                 Accessible *child_at_index;
427
428                 g_assert (parent != NULL);
429
430                 index = Accessible_getIndexInParent (accessible);
431                 g_assert (index >= 0); 
432
433                 child_at_index = Accessible_getChildAtIndex (parent, index);
434
435                 g_assert (child_at_index == accessible);
436
437                 Accessible_unref (child_at_index);
438                 Accessible_unref (parent);
439         }
440
441         len = Accessible_getChildCount (accessible);
442         print_tree_depth++;
443         for (i = 0; i < len; i++) {
444                 Accessible *child;
445
446                 child = Accessible_getChildAtIndex (accessible, i);
447 #ifdef ROPEY
448                 if (!child)
449                         fprintf (stderr, "Unusual - ChildGone at %ld\n", i);
450
451                 g_assert (Accessible_getIndexInParent (child) == i);
452                 g_assert (Accessible_getParent (child) == accessible);
453 #endif
454
455                 if (recurse_down && child)
456                         validate_accessible (child, has_parent, recurse_down);
457
458                 Accessible_unref (child);
459         }
460         print_tree_depth--;
461 }
462
463 static void
464 validate_accessible (Accessible *accessible,
465                      gboolean    has_parent,
466                      gboolean    recurse_down)
467 {
468         Accessible          *tmp;
469         char                *name, *descr;
470         AccessibleRole       role;
471         AccessibleRelation **relations;
472         char                *role_name;
473         GString             *item_str = g_string_new ("");
474         int                  i;
475
476         name = Accessible_getName (accessible);
477         g_assert (name != NULL);
478         
479         descr = Accessible_getDescription (accessible);
480         g_assert (descr != NULL);
481
482         role = Accessible_getRole (accessible);
483         g_assert (role != SPI_ROLE_INVALID);
484         role_name = Accessible_getRoleName (accessible);
485         g_assert (role_name != NULL);
486
487         relations = Accessible_getRelationSet (accessible);
488         g_assert (relations != NULL);
489
490         for (i = 0; relations [i]; i++) {
491                 AccessibleRelationType type;
492                 int                    targets;
493
494                 fprintf (stderr, "relation %d\n", i);
495
496                 type = AccessibleRelation_getRelationType (relations [i]);
497                 g_assert (type != SPI_RELATION_NULL);
498
499                 targets = AccessibleRelation_getNTargets (relations [i]);
500                 g_assert (targets != -1);
501
502                 AccessibleRelation_unref (relations [i]);
503                 relations [i] = NULL;
504         }
505         free (relations);
506
507         if (print_tree) {
508                 int i;
509
510                 for (i = 0; i < print_tree_depth; i++)
511                         fputc (' ', stderr);
512                 fputs ("|-> [ ", stderr);
513         }
514
515         if (Accessible_isAction (accessible)) {
516                 tmp = Accessible_getAction (accessible);
517                 g_assert (tmp != NULL);
518                 if (print_tree)
519                         fprintf (stderr, "At");
520                 else
521                         test_action (tmp);
522                 AccessibleAction_unref (tmp);
523         }
524
525         if (Accessible_isApplication (accessible)) {
526                 tmp = Accessible_getApplication (accessible);
527                 if (print_tree)
528                         fprintf (stderr, "Ap");
529                 else
530                         test_application (tmp);
531                 AccessibleApplication_unref (tmp);
532         }
533
534         if (Accessible_isComponent (accessible)) {
535                 tmp = Accessible_getComponent (accessible);
536                 g_assert (tmp != NULL);
537                 if (print_tree)
538                         fprintf (stderr, "Co");
539                 else
540                         test_component (tmp);
541                 AccessibleComponent_unref (tmp);
542         }
543
544         if (Accessible_isEditableText (accessible)) {
545                 tmp = Accessible_getEditableText (accessible);
546                 g_assert (tmp != NULL);
547                 if (print_tree)
548                         fprintf (stderr, "Et");
549                 else
550                         test_editable_text (tmp);
551                 AccessibleEditableText_unref (tmp);
552         }
553
554         if (Accessible_isHypertext (accessible)) {
555                 tmp = Accessible_getHypertext (accessible);
556                 g_assert (tmp != NULL);
557                 if (print_tree)
558                         fprintf (stderr, "Ht");
559                 AccessibleHypertext_unref (tmp);
560         }
561
562         if (Accessible_isImage (accessible)) {
563                 tmp = Accessible_getImage (accessible);
564                 g_assert (tmp != NULL);
565                 if (print_tree) {
566                         char *desc;
567
568                         fprintf (stderr, "Im");
569
570                         desc = AccessibleImage_getImageDescription (tmp);
571                         g_string_append_printf (
572                                 item_str, " image descr: '%s'", desc);
573                         SPI_freeString (desc);
574                 } else
575                         test_image (tmp);
576
577                 AccessibleImage_unref (tmp);
578         }
579
580         if (Accessible_isSelection (accessible)) {
581                 tmp = Accessible_getSelection (accessible);
582                 g_assert (tmp != NULL);
583                 if (print_tree)
584                         fprintf (stderr, "Se");
585                 AccessibleSelection_unref (tmp);
586         }
587
588         if (Accessible_isTable (accessible)) {
589                 tmp = Accessible_getTable (accessible);
590                 g_assert (tmp != NULL);
591                 if (print_tree)
592                         fprintf (stderr, "Ta");
593                 else
594                         test_table (tmp);
595                 AccessibleTable_unref (tmp);
596         }
597
598         if (Accessible_isText (accessible)) {
599                 tmp = Accessible_getText (accessible);
600                 g_assert (tmp != NULL);
601                 if (print_tree)
602                         fprintf (stderr, "Te");
603                 else
604                         test_text (tmp);
605                 AccessibleText_unref (tmp);
606         }
607
608         if (Accessible_isValue (accessible)) {
609                 tmp = Accessible_getValue (accessible);
610                 g_assert (tmp != NULL);
611                 if (print_tree)
612                         fprintf (stderr, "Va");
613                 else
614                         test_value (tmp); 
615                 AccessibleValue_unref (tmp);
616         }
617
618         if (print_tree)
619                 fprintf (stderr, " ] '%s' (%s) - %s: %s\n",
620                          name, descr, role_name, item_str->str);
621
622         SPI_freeString (name);
623         SPI_freeString (descr);
624         SPI_freeString (role_name);
625         g_string_free (item_str, TRUE);
626
627         validate_tree (accessible, has_parent, recurse_down);
628 }
629
630 static void
631 test_misc (void)
632 {
633         fprintf (stderr, "Testing misc bits ...\n");
634
635         g_assert (!Accessible_isComponent (NULL));
636         g_assert (Accessible_getComponent (NULL) == NULL);
637         SPI_freeString (NULL);
638 }
639
640 static void
641 global_listener_cb (const AccessibleEvent *event,
642                     void                  *user_data)
643 {
644         TestWindow *win = user_data;
645         Accessible *desktop;
646         AccessibleApplication *application;
647
648         g_assert (win->magic == WINDOW_MAGIC);
649         g_assert (!strcmp (event->type, "focus:"));
650
651         fprintf (stderr, "Fielded focus event ...\n");
652
653         if (!do_poke) {
654                 desktop = SPI_getDesktop (0);
655                 application = Accessible_getChildAtIndex (desktop, 0);
656                 g_assert (application != NULL);
657                 Accessible_unref (desktop);
658                 
659                 test_application (application);
660                 
661                 AccessibleApplication_unref (application);
662                 
663                 print_tree = FALSE;
664
665                 validate_accessible (event->source, TRUE, TRUE);
666
667                 fprintf (stderr, "quitting mainloop.\n");
668                 gtk_main_quit ();
669         }
670
671         print_tree = TRUE;
672         validate_accessible (event->source, TRUE, TRUE);
673 }
674
675 static SPIBoolean
676 key_listener_cb (const AccessibleKeystroke *stroke,
677                  void                      *user_data)
678 {
679         AccessibleKeystroke *s = user_data;
680         
681         *s = *stroke;
682         
683         if (s->type == SPI_KEY_PRESSED)
684                 key_press_received = TRUE;
685         else if (s->type == SPI_KEY_RELEASED)
686                 key_release_received = TRUE;
687         
688         return TRUE;
689 }
690
691
692 static void
693 test_keylisteners (void)
694 {
695 #ifdef BILL_MAKES_THIS_WORK_RELIABLY
696         int i;
697         AccessibleKeystroke stroke;
698         AccessibleKeystrokeListener *key_listener;
699         AccessibleKeySet *test_keyset;
700
701         fprintf (stderr, "Testing keyboard listeners ...\n");
702
703         key_listener = SPI_createAccessibleKeystrokeListener (
704                 key_listener_cb, &stroke);
705
706         test_keyset = SPI_createAccessibleKeySet (1, "=", NULL, NULL);
707         
708         g_assert (SPI_registerAccessibleKeystrokeListener (
709                 key_listener,
710                 test_keyset,
711                 0,
712                 SPI_KEY_PRESSED | SPI_KEY_RELEASED,
713                 SPI_KEYLISTENER_CANCONSUME | SPI_KEYLISTENER_ALL_WINDOWS));
714
715         for (i = 0; i < 3; i++) {
716                 memset (&stroke, 0, sizeof (AccessibleKeystroke));
717                 g_assert (SPI_generateKeyboardEvent ('=', NULL, SPI_KEY_SYM));
718                 while (!(key_press_received))
719                         g_main_context_iteration (NULL, TRUE);
720                 fprintf (stderr, "p");
721                 g_assert (!strcmp (stroke.keystring, "="));
722                 while (!(key_release_received))
723                         g_main_context_iteration (NULL, TRUE);
724                 fprintf (stderr, "r ");
725                 key_press_received = FALSE;
726                 key_release_received = FALSE;
727         }
728         g_assert (SPI_deregisterAccessibleKeystrokeListener (key_listener, 0));
729         SPI_freeAccessibleKeySet (test_keyset);
730
731         fprintf (stderr, "\n");
732
733         AccessibleKeystrokeListener_unref (key_listener);
734
735         g_assert (SPI_generateMouseEvent (100, 100, "rel"));
736         g_assert (SPI_generateMouseEvent (-50, -50, "rel"));              
737         g_assert (SPI_generateMouseEvent (-50, -50, "rel"));              
738         g_assert (SPI_generateMouseEvent (-1, -1, "b1c")); 
739 #endif
740 }
741
742 int
743 main (int argc, char **argv)
744 {
745         int leaked, i;
746         TestWindow *win;
747         const char *modules;
748         AccessibleEventListener *global_listener;
749
750         modules = g_getenv ("GTK_MODULES");
751         if (!modules || modules [0] == '\0')
752                 putenv ("GTK_MODULES=gail:atk-bridge");
753         modules = NULL;
754
755         for (i = 1; i < argc; i++) {
756                 if (!g_strcasecmp (argv [i], "--poke"))
757                         do_poke = TRUE;
758         }
759
760         gtk_init (&argc, &argv);
761
762         g_assert (!SPI_init ());
763         g_assert (SPI_init ());
764         g_assert (SPI_getDesktopCount () == 1);
765
766         test_roles ();
767         test_misc ();
768         test_desktop ();
769         test_keylisteners (); 
770
771         win = create_test_window ();
772
773         global_listener = SPI_createAccessibleEventListener (global_listener_cb, win);
774         g_assert (SPI_registerGlobalEventListener (global_listener, "focus:"));
775
776         fprintf (stderr, "Waiting for focus event ...\n");
777         gtk_main ();
778
779         g_assert (SPI_deregisterGlobalEventListenerAll (global_listener));
780         AccessibleEventListener_unref (global_listener);
781
782         test_window_destroy (win);
783
784         /* Wait for any pending events from the registry */
785         g_usleep (500*1000);
786         for (i = 0; i < 100; i++)
787                 linc_main_iteration (FALSE);
788
789         if ((leaked = SPI_exit ()))
790                 g_error ("Leaked %d SPI handles", leaked);
791
792         g_assert (!SPI_exit ());
793
794         fprintf (stderr, "All tests passed\n");
795
796         if (g_getenv ("_MEMPROF_SOCKET")) {
797                 fprintf (stderr, "Waiting for memprof\n");
798                 gtk_main ();
799         }
800
801         putenv ("AT_BRIDGE_SHUTDOWN=1");
802
803         return 0;
804 }