Use the C gdbus-testserver in tests
[platform/upstream/glib.git] / gio / tests / gdbus-proxy.c
1 /* GLib testing framework examples and tests
2  *
3  * Copyright (C) 2008-2010 Red Hat, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General
16  * Public License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  * Author: David Zeuthen <davidz@redhat.com>
21  */
22
23 #include <gio/gio.h>
24 #include <unistd.h>
25 #include <string.h>
26
27 #include "gdbus-tests.h"
28
29 /* all tests rely on a shared mainloop */
30 static GMainLoop *loop = NULL;
31
32 /* ---------------------------------------------------------------------------------------------------- */
33 /* Test that the method aspects of GDBusProxy works */
34 /* ---------------------------------------------------------------------------------------------------- */
35
36 static void
37 test_methods (GDBusProxy *proxy)
38 {
39   GVariant *result;
40   GError *error;
41   const gchar *str;
42   gchar *dbus_error_name;
43
44   /* check that we can invoke a method */
45   error = NULL;
46   result = g_dbus_proxy_call_sync (proxy,
47                                    "HelloWorld",
48                                    g_variant_new ("(s)", "Hey"),
49                                    G_DBUS_CALL_FLAGS_NONE,
50                                    -1,
51                                    NULL,
52                                    &error);
53   g_assert_no_error (error);
54   g_assert (result != NULL);
55   g_assert_cmpstr (g_variant_get_type_string (result), ==, "(s)");
56   g_variant_get (result, "(&s)", &str);
57   g_assert_cmpstr (str, ==, "You greeted me with 'Hey'. Thanks!");
58   g_variant_unref (result);
59
60   /* Check that we can completely recover the returned error */
61   result = g_dbus_proxy_call_sync (proxy,
62                                    "HelloWorld",
63                                    g_variant_new ("(s)", "Yo"),
64                                    G_DBUS_CALL_FLAGS_NONE,
65                                    -1,
66                                    NULL,
67                                    &error);
68   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_DBUS_ERROR);
69   g_assert (g_dbus_error_is_remote_error (error));
70   g_assert (g_dbus_error_is_remote_error (error));
71   g_assert (result == NULL);
72   dbus_error_name = g_dbus_error_get_remote_error (error);
73   g_assert_cmpstr (dbus_error_name, ==, "com.example.TestException");
74   g_free (dbus_error_name);
75   g_assert (g_dbus_error_strip_remote_error (error));
76   g_assert_cmpstr (error->message, ==, "Yo is not a proper greeting");
77   g_clear_error (&error);
78
79   /* Check that we get a timeout if the method handling is taking longer than timeout */
80   error = NULL;
81   result = g_dbus_proxy_call_sync (proxy,
82                                    "Sleep",
83                                    g_variant_new ("(i)", 500 /* msec */),
84                                    G_DBUS_CALL_FLAGS_NONE,
85                                    100 /* msec */,
86                                    NULL,
87                                    &error);
88   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
89   g_assert (!g_dbus_error_is_remote_error (error));
90   g_assert (result == NULL);
91   g_clear_error (&error);
92
93   /* Check that proxy-default timeouts work. */
94   g_assert_cmpint (g_dbus_proxy_get_default_timeout (proxy), ==, -1);
95
96   /* the default timeout is 25000 msec so this should work */
97   result = g_dbus_proxy_call_sync (proxy,
98                                    "Sleep",
99                                    g_variant_new ("(i)", 500 /* msec */),
100                                    G_DBUS_CALL_FLAGS_NONE,
101                                    -1, /* use proxy default (e.g. -1 -> e.g. 25000 msec) */
102                                    NULL,
103                                    &error);
104   g_assert_no_error (error);
105   g_assert (result != NULL);
106   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
107   g_variant_unref (result);
108
109   /* now set the proxy-default timeout to 250 msec and try the 500 msec call - this should FAIL */
110   g_dbus_proxy_set_default_timeout (proxy, 250);
111   g_assert_cmpint (g_dbus_proxy_get_default_timeout (proxy), ==, 250);
112   result = g_dbus_proxy_call_sync (proxy,
113                                    "Sleep",
114                                    g_variant_new ("(i)", 500 /* msec */),
115                                    G_DBUS_CALL_FLAGS_NONE,
116                                    -1, /* use proxy default (e.g. 250 msec) */
117                                    NULL,
118                                    &error);
119   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
120   g_assert (!g_dbus_error_is_remote_error (error));
121   g_assert (result == NULL);
122   g_clear_error (&error);
123
124   /* clean up after ourselves */
125   g_dbus_proxy_set_default_timeout (proxy, -1);
126 }
127
128 static gboolean
129 strv_equal (gchar **strv, ...)
130 {
131   gint count;
132   va_list list;
133   const gchar *str;
134   gboolean res;
135
136   res = TRUE;
137   count = 0;
138   va_start (list, strv);
139   while (1)
140     {
141       str = va_arg (list, const gchar *);
142       if (str == NULL)
143         break;
144       if (g_strcmp0 (str, strv[count]) != 0)
145         {
146           res = FALSE;
147           break;
148         }
149       count++;
150     }
151   va_end (list);
152
153   if (res)
154     res = g_strv_length (strv) == count;
155
156   return res;
157 }
158
159 /* ---------------------------------------------------------------------------------------------------- */
160 /* Test that the property aspects of GDBusProxy works */
161 /* ---------------------------------------------------------------------------------------------------- */
162
163 static void
164 test_properties (GDBusProxy *proxy)
165 {
166   GError *error;
167   GVariant *variant;
168   GVariant *variant2;
169   GVariant *result;
170   gchar **names;
171   gchar *name_owner;
172   GDBusProxy *proxy2;
173
174   error = NULL;
175
176   if (g_dbus_proxy_get_flags (proxy) & G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES)
177     {
178        g_assert (g_dbus_proxy_get_cached_property_names (proxy) == NULL);
179        return;
180     }
181
182   /*
183    * Check that we can list all cached properties.
184    */
185   names = g_dbus_proxy_get_cached_property_names (proxy);
186
187   g_assert (strv_equal (names,
188                         "PropertyThatWillBeInvalidated",
189                         "ab",
190                         "ad",
191                         "ai",
192                         "an",
193                         "ao",
194                         "aq",
195                         "as",
196                         "at",
197                         "au",
198                         "ax",
199                         "ay",
200                         "b",
201                         "d",
202                         "foo",
203                         "i",
204                         "n",
205                         "o",
206                         "q",
207                         "s",
208                         "t",
209                         "u",
210                         "x",
211                         "y",
212                         NULL));
213
214   g_strfreev (names);
215
216   /*
217    * Check that we can read cached properties.
218    *
219    * No need to test all properties - GVariant has already been tested
220    */
221   variant = g_dbus_proxy_get_cached_property (proxy, "y");
222   g_assert (variant != NULL);
223   g_assert_cmpint (g_variant_get_byte (variant), ==, 1);
224   g_variant_unref (variant);
225   variant = g_dbus_proxy_get_cached_property (proxy, "o");
226   g_assert (variant != NULL);
227   g_assert_cmpstr (g_variant_get_string (variant, NULL), ==, "/some/path");
228   g_variant_unref (variant);
229
230   /*
231    * Now ask the service to change a property and check that #GDBusProxy::g-property-changed
232    * is received. Also check that the cache is updated.
233    */
234   variant2 = g_variant_new_byte (42);
235   result = g_dbus_proxy_call_sync (proxy,
236                                    "FrobSetProperty",
237                                    g_variant_new ("(sv)",
238                                                   "y",
239                                                   variant2),
240                                    G_DBUS_CALL_FLAGS_NONE,
241                                    -1,
242                                    NULL,
243                                    &error);
244   g_assert_no_error (error);
245   g_assert (result != NULL);
246   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
247   g_variant_unref (result);
248   _g_assert_signal_received (proxy, "g-properties-changed");
249   variant = g_dbus_proxy_get_cached_property (proxy, "y");
250   g_assert (variant != NULL);
251   g_assert_cmpint (g_variant_get_byte (variant), ==, 42);
252   g_variant_unref (variant);
253
254   g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_byte (142));
255   variant = g_dbus_proxy_get_cached_property (proxy, "y");
256   g_assert (variant != NULL);
257   g_assert_cmpint (g_variant_get_byte (variant), ==, 142);
258   g_variant_unref (variant);
259
260   g_dbus_proxy_set_cached_property (proxy, "y", NULL);
261   variant = g_dbus_proxy_get_cached_property (proxy, "y");
262   g_assert (variant == NULL);
263
264   /* Check that the invalidation feature of the PropertiesChanged()
265    * signal works... First, check that we have a cached value of the
266    * property (from the initial GetAll() call)
267    */
268   variant = g_dbus_proxy_get_cached_property (proxy, "PropertyThatWillBeInvalidated");
269   g_assert (variant != NULL);
270   g_assert_cmpstr (g_variant_get_string (variant, NULL), ==, "InitialValue");
271   g_variant_unref (variant);
272   /* now ask to invalidate the property - this causes a
273    *
274    *   PropertiesChanaged("com.example.Frob",
275    *                      {},
276    *                      ["PropertyThatWillBeInvalidated")
277    *
278    * signal to be emitted. This is received before the method reply
279    * for FrobInvalidateProperty *but* since the proxy was created in
280    * the same thread as we're doing this synchronous call, we'll get
281    * the method reply before...
282    */
283   result = g_dbus_proxy_call_sync (proxy,
284                                    "FrobInvalidateProperty",
285                                    g_variant_new ("(s)", "OMGInvalidated"),
286                                    G_DBUS_CALL_FLAGS_NONE,
287                                    -1,
288                                    NULL,
289                                    &error);
290   g_assert_no_error (error);
291   g_assert (result != NULL);
292   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
293   g_variant_unref (result);
294   /* ... hence we wait for the g-properties-changed signal to be delivered */
295   _g_assert_signal_received (proxy, "g-properties-changed");
296   /* ... and now we finally, check that the cached value has been invalidated */
297   variant = g_dbus_proxy_get_cached_property (proxy, "PropertyThatWillBeInvalidated");
298   g_assert (variant == NULL);
299
300   /* Now test that G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES works - we need a new proxy for that */
301   error = NULL;
302   proxy2 = g_dbus_proxy_new_sync (g_dbus_proxy_get_connection (proxy),
303                                   G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
304                                   NULL,                      /* GDBusInterfaceInfo */
305                                   "com.example.TestService", /* name */
306                                   "/com/example/TestObject", /* object path */
307                                   "com.example.Frob",        /* interface */
308                                   NULL, /* GCancellable */
309                                   &error);
310   g_assert_no_error (error);
311
312   name_owner = g_dbus_proxy_get_name_owner (proxy2);
313   g_assert (name_owner != NULL);
314   g_free (name_owner);
315
316   variant = g_dbus_proxy_get_cached_property (proxy2, "PropertyThatWillBeInvalidated");
317   g_assert (variant != NULL);
318   g_assert_cmpstr (g_variant_get_string (variant, NULL), ==, "OMGInvalidated"); /* from previous test */
319   g_variant_unref (variant);
320
321   result = g_dbus_proxy_call_sync (proxy2,
322                                    "FrobInvalidateProperty",
323                                    g_variant_new ("(s)", "OMGInvalidated2"),
324                                    G_DBUS_CALL_FLAGS_NONE,
325                                    -1,
326                                    NULL,
327                                    &error);
328   g_assert_no_error (error);
329   g_assert (result != NULL);
330   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
331   g_variant_unref (result);
332
333   /* this time we should get the ::g-properties-changed _with_ the value */
334   _g_assert_signal_received (proxy2, "g-properties-changed");
335
336   variant = g_dbus_proxy_get_cached_property (proxy2, "PropertyThatWillBeInvalidated");
337   g_assert (variant != NULL);
338   g_assert_cmpstr (g_variant_get_string (variant, NULL), ==, "OMGInvalidated2");
339   g_variant_unref (variant);
340
341   g_object_unref (proxy2);
342 }
343
344 /* ---------------------------------------------------------------------------------------------------- */
345 /* Test that the signal aspects of GDBusProxy works */
346 /* ---------------------------------------------------------------------------------------------------- */
347
348 static void
349 test_proxy_signals_on_signal (GDBusProxy  *proxy,
350                               const gchar *sender_name,
351                               const gchar *signal_name,
352                               GVariant    *parameters,
353                               gpointer     user_data)
354 {
355   GString *s = user_data;
356
357   g_assert_cmpstr (signal_name, ==, "TestSignal");
358   g_assert_cmpstr (g_variant_get_type_string (parameters), ==, "(sov)");
359
360   g_variant_print_string (parameters, s, TRUE);
361 }
362
363 typedef struct
364 {
365   GMainLoop *internal_loop;
366   GString *s;
367 } TestSignalData;
368
369 static void
370 test_proxy_signals_on_emit_signal_cb (GDBusProxy   *proxy,
371                                       GAsyncResult *res,
372                                       gpointer      user_data)
373 {
374   TestSignalData *data = user_data;
375   GError *error;
376   GVariant *result;
377
378   error = NULL;
379   result = g_dbus_proxy_call_finish (proxy,
380                                      res,
381                                      &error);
382   g_assert_no_error (error);
383   g_assert (result != NULL);
384   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
385   g_variant_unref (result);
386
387   /* check that the signal was recieved before we got the method result */
388   g_assert (strlen (data->s->str) > 0);
389
390   /* break out of the loop */
391   g_main_loop_quit (data->internal_loop);
392 }
393
394 static void
395 test_signals (GDBusProxy *proxy)
396 {
397   GError *error;
398   GString *s;
399   gulong signal_handler_id;
400   TestSignalData data;
401   GVariant *result;
402
403   error = NULL;
404
405   /*
406    * Ask the service to emit a signal and check that we receive it.
407    *
408    * Note that blocking calls don't block in the mainloop so wait for the signal (which
409    * is dispatched before the method reply)
410    */
411   s = g_string_new (NULL);
412   signal_handler_id = g_signal_connect (proxy,
413                                         "g-signal",
414                                         G_CALLBACK (test_proxy_signals_on_signal),
415                                         s);
416
417   result = g_dbus_proxy_call_sync (proxy,
418                                    "EmitSignal",
419                                    g_variant_new ("(so)",
420                                                   "Accept the next proposition you hear",
421                                                   "/some/path"),
422                                    G_DBUS_CALL_FLAGS_NONE,
423                                    -1,
424                                    NULL,
425                                    &error);
426   g_assert_no_error (error);
427   g_assert (result != NULL);
428   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
429   g_variant_unref (result);
430   /* check that we haven't received the signal just yet */
431   g_assert (strlen (s->str) == 0);
432   /* and now wait for the signal */
433   _g_assert_signal_received (proxy, "g-signal");
434   g_assert_cmpstr (s->str,
435                    ==,
436                    "('Accept the next proposition you hear .. in bed!', objectpath '/some/path/in/bed', <'a variant'>)");
437   g_signal_handler_disconnect (proxy, signal_handler_id);
438   g_string_free (s, TRUE);
439
440   /*
441    * Now do this async to check the signal is received before the method returns.
442    */
443   s = g_string_new (NULL);
444   data.internal_loop = g_main_loop_new (NULL, FALSE);
445   data.s = s;
446   signal_handler_id = g_signal_connect (proxy,
447                                         "g-signal",
448                                         G_CALLBACK (test_proxy_signals_on_signal),
449                                         s);
450   g_dbus_proxy_call (proxy,
451                      "EmitSignal",
452                      g_variant_new ("(so)",
453                                     "You will make a great programmer",
454                                     "/some/other/path"),
455                      G_DBUS_CALL_FLAGS_NONE,
456                      -1,
457                      NULL,
458                      (GAsyncReadyCallback) test_proxy_signals_on_emit_signal_cb,
459                      &data);
460   g_main_loop_run (data.internal_loop);
461   g_main_loop_unref (data.internal_loop);
462   g_assert_cmpstr (s->str,
463                    ==,
464                    "('You will make a great programmer .. in bed!', objectpath '/some/other/path/in/bed', <'a variant'>)");
465   g_signal_handler_disconnect (proxy, signal_handler_id);
466   g_string_free (s, TRUE);
467 }
468
469 /* ---------------------------------------------------------------------------------------------------- */
470
471 static void
472 test_bogus_method_return (GDBusProxy *proxy)
473 {
474   GError *error = NULL;
475   GVariant *result;
476
477   result = g_dbus_proxy_call_sync (proxy,
478                                    "PairReturn",
479                                    NULL,
480                                    G_DBUS_CALL_FLAGS_NONE,
481                                    -1,
482                                    NULL,
483                                    &error);
484   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
485   g_error_free (error);
486   g_assert (result == NULL);
487 }
488
489 #if 0 /* Disabled: see https://bugzilla.gnome.org/show_bug.cgi?id=658999 */
490 static void
491 test_bogus_signal (GDBusProxy *proxy)
492 {
493   GError *error = NULL;
494   GVariant *result;
495   GDBusInterfaceInfo *old_iface_info;
496
497   result = g_dbus_proxy_call_sync (proxy,
498                                    "EmitSignal2",
499                                    NULL,
500                                    G_DBUS_CALL_FLAGS_NONE,
501                                    -1,
502                                    NULL,
503                                    &error);
504   g_assert_no_error (error);
505   g_assert (result != NULL);
506   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
507   g_variant_unref (result);
508
509   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
510     {
511       /* and now wait for the signal that will never arrive */
512       _g_assert_signal_received (proxy, "g-signal");
513     }
514   g_test_trap_assert_stderr ("*Dropping signal TestSignal2 of type (i) since the type from the expected interface is (u)*");
515   g_test_trap_assert_failed();
516
517   /* Our main branch will also do g_warning() when running the mainloop so
518    * temporarily remove the expected interface
519    */
520   old_iface_info = g_dbus_proxy_get_interface_info (proxy);
521   g_dbus_proxy_set_interface_info (proxy, NULL);
522   _g_assert_signal_received (proxy, "g-signal");
523   g_dbus_proxy_set_interface_info (proxy, old_iface_info);
524 }
525
526 static void
527 test_bogus_property (GDBusProxy *proxy)
528 {
529   GError *error = NULL;
530   GVariant *result;
531   GDBusInterfaceInfo *old_iface_info;
532
533   /* Make the service emit a PropertiesChanged signal for property 'i' of type 'i' - since
534    * our introspection data has this as type 'u' we should get a warning on stderr.
535    */
536   result = g_dbus_proxy_call_sync (proxy,
537                                    "FrobSetProperty",
538                                    g_variant_new ("(sv)",
539                                                   "i", g_variant_new_int32 (42)),
540                                    G_DBUS_CALL_FLAGS_NONE,
541                                    -1,
542                                    NULL,
543                                    &error);
544   g_assert_no_error (error);
545   g_assert (result != NULL);
546   g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
547   g_variant_unref (result);
548
549   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
550     {
551       /* and now wait for the signal that will never arrive */
552       _g_assert_signal_received (proxy, "g-properties-changed");
553     }
554   g_test_trap_assert_stderr ("*Received property i with type i does not match expected type u in the expected interface*");
555   g_test_trap_assert_failed();
556
557   /* Our main branch will also do g_warning() when running the mainloop so
558    * temporarily remove the expected interface
559    */
560   old_iface_info = g_dbus_proxy_get_interface_info (proxy);
561   g_dbus_proxy_set_interface_info (proxy, NULL);
562   _g_assert_signal_received (proxy, "g-properties-changed");
563   g_dbus_proxy_set_interface_info (proxy, old_iface_info);
564 }
565 #endif /* Disabled: see https://bugzilla.gnome.org/show_bug.cgi?id=658999 */
566
567 /* ---------------------------------------------------------------------------------------------------- */
568
569 static const gchar *frob_dbus_interface_xml =
570   "<node>"
571   "  <interface name='com.example.Frob'>"
572   /* PairReturn() is deliberately different from gdbus-testserver.py's definition */
573   "    <method name='PairReturn'>"
574   "      <arg type='u' name='somenumber' direction='in'/>"
575   "      <arg type='s' name='somestring' direction='out'/>"
576   "    </method>"
577   "    <method name='HelloWorld'>"
578   "      <arg type='s' name='somestring' direction='in'/>"
579   "      <arg type='s' name='somestring' direction='out'/>"
580   "    </method>"
581   "    <method name='Sleep'>"
582   "      <arg type='i' name='timeout' direction='in'/>"
583   "    </method>"
584   /* We deliberately only mention a single property here */
585   "    <property name='y' type='y' access='readwrite'/>"
586   /* The 'i' property is deliberately different from gdbus-testserver.py's definition */
587   "    <property name='i' type='u' access='readwrite'/>"
588   /* ::TestSignal2 is deliberately different from gdbus-testserver.py's definition */
589   "    <signal name='TestSignal2'>"
590   "      <arg type='u' name='somenumber'/>"
591   "    </signal>"
592   "  </interface>"
593   "</node>";
594 static GDBusInterfaceInfo *frob_dbus_interface_info;
595
596 static void
597 test_expected_interface (GDBusProxy *proxy)
598 {
599   GVariant *value;
600   GError *error;
601
602   /* This is obviously wrong but expected interface is not set so we don't fail... */
603   g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_string ("error_me_out!"));
604   g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_byte (42));
605   g_dbus_proxy_set_cached_property (proxy, "does-not-exist", g_variant_new_string ("something"));
606   g_dbus_proxy_set_cached_property (proxy, "does-not-exist", NULL);
607
608   /* Now repeat the method tests, with an expected interface set */
609   g_dbus_proxy_set_interface_info (proxy, frob_dbus_interface_info);
610   test_methods (proxy);
611   test_signals (proxy);
612
613   /* And also where we deliberately set the expected interface definition incorrectly */
614   test_bogus_method_return (proxy);
615   /* Disabled: see https://bugzilla.gnome.org/show_bug.cgi?id=658999
616   test_bogus_signal (proxy);
617   test_bogus_property (proxy);
618   */
619
620   if (g_test_undefined ())
621     {
622       /* Also check that we complain if setting a cached property of the wrong type */
623       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
624         {
625           g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_string ("error_me_out!"));
626         }
627       g_test_trap_assert_stderr ("*Trying to set property y of type s but according to the expected interface the type is y*");
628       g_test_trap_assert_failed();
629     }
630
631   /* this should work, however (since the type is correct) */
632   g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_byte (42));
633
634   if (g_test_undefined ())
635     {
636       /* Try to get the value of a property where the type we expect is different from
637        * what we have in our cache (e.g. what the service returned)
638        */
639       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
640         {
641           value = g_dbus_proxy_get_cached_property (proxy, "i");
642         }
643       g_test_trap_assert_stderr ("*Trying to get property i with type i but according to the expected interface the type is u*");
644       g_test_trap_assert_failed();
645     }
646
647   /* Even if a property does not exist in expected_interface, looking it
648    * up, or setting it, should never fail. Because it could be that the
649    * property has been added to the service but the GDBusInterfaceInfo*
650    * passed to g_dbus_proxy_set_interface_info() just haven't been updated.
651    *
652    * See https://bugzilla.gnome.org/show_bug.cgi?id=660886
653    */
654   value = g_dbus_proxy_get_cached_property (proxy, "d");
655   g_assert (value != NULL);
656   g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE));
657   g_assert_cmpfloat (g_variant_get_double (value), ==, 7.5);
658   g_variant_unref (value);
659   /* update it via the cached property... */
660   g_dbus_proxy_set_cached_property (proxy, "d", g_variant_new_double (75.0));
661   /* ... and finally check that it has changed */
662   value = g_dbus_proxy_get_cached_property (proxy, "d");
663   g_assert (value != NULL);
664   g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE));
665   g_assert_cmpfloat (g_variant_get_double (value), ==, 75.0);
666   g_variant_unref (value);
667   /* now update it via the D-Bus interface... */
668   error = NULL;
669   value = g_dbus_proxy_call_sync (proxy, "FrobSetProperty",
670                                   g_variant_new ("(sv)", "d", g_variant_new_double (85.0)),
671                                   G_DBUS_CALL_FLAGS_NONE,
672                                   -1, NULL, &error);
673   g_assert_no_error (error);
674   g_assert (value != NULL);
675   g_assert_cmpstr (g_variant_get_type_string (value), ==, "()");
676   g_variant_unref (value);
677   /* ...ensure we receive the ::PropertiesChanged signal... */
678   _g_assert_signal_received (proxy, "g-properties-changed");
679   /* ... and finally check that it has changed */
680   value = g_dbus_proxy_get_cached_property (proxy, "d");
681   g_assert (value != NULL);
682   g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE));
683   g_assert_cmpfloat (g_variant_get_double (value), ==, 85.0);
684   g_variant_unref (value);
685 }
686
687 static void
688 test_basic (GDBusProxy *proxy)
689 {
690   GDBusConnection *connection;
691   GDBusConnection *conn;
692   GDBusProxyFlags flags;
693   GDBusInterfaceInfo *info;
694   gchar *name;
695   gchar *path;
696   gchar *interface;
697   gint timeout;
698
699   connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
700
701   g_assert (g_dbus_proxy_get_connection (proxy) == connection);
702   g_assert (g_dbus_proxy_get_flags (proxy) == G_DBUS_PROXY_FLAGS_NONE);
703   g_assert (g_dbus_proxy_get_interface_info (proxy) == NULL);
704   g_assert_cmpstr (g_dbus_proxy_get_name (proxy), ==, "com.example.TestService");
705   g_assert_cmpstr (g_dbus_proxy_get_object_path (proxy), ==, "/com/example/TestObject");
706   g_assert_cmpstr (g_dbus_proxy_get_interface_name (proxy), ==, "com.example.Frob");
707   g_assert_cmpint (g_dbus_proxy_get_default_timeout (proxy), ==, -1);
708
709   g_object_get (proxy,
710                 "g-connection", &conn,
711                 "g-interface-info", &info,
712                 "g-flags", &flags,
713                 "g-name", &name,
714                 "g-object-path", &path,
715                 "g-interface-name", &interface,
716                 "g-default-timeout", &timeout,
717                 NULL);
718
719   g_assert (conn == connection);
720   g_assert (info == NULL);
721   g_assert_cmpint (flags, ==, G_DBUS_PROXY_FLAGS_NONE);
722   g_assert_cmpstr (name, ==, "com.example.TestService");
723   g_assert_cmpstr (path, ==, "/com/example/TestObject");
724   g_assert_cmpstr (interface, ==, "com.example.Frob");
725   g_assert_cmpint (timeout, ==, -1);
726
727   g_object_unref (conn);
728   g_free (name);
729   g_free (path);
730   g_free (interface);
731
732   g_object_unref (connection);
733 }
734
735 static void
736 kill_test_service (GDBusConnection *connection)
737 {
738 #ifdef G_OS_UNIX
739   guint pid;
740   GVariant *ret;
741   GError *error = NULL;
742   const gchar *name = "com.example.TestService";
743
744   ret = g_dbus_connection_call_sync (connection,
745                                      "org.freedesktop.DBus",
746                                      "/org/freedesktop/DBus",
747                                      "org.freedesktop.DBus",
748                                      "GetConnectionUnixProcessID",
749                                      g_variant_new ("(s)", name),
750                                      NULL,
751                                      G_DBUS_CALL_FLAGS_NONE,
752                                      -1,
753                                      NULL,
754                                      &error);
755   g_variant_get (ret, "(u)", &pid);
756   g_variant_unref (ret);
757   kill (pid, SIGTERM);
758 #else
759   g_warning ("Can't kill com.example.TestService");
760 #endif
761 }
762
763 static void
764 test_proxy (void)
765 {
766   GDBusProxy *proxy;
767   GDBusConnection *connection;
768   GError *error;
769
770   error = NULL;
771   connection = g_bus_get_sync (G_BUS_TYPE_SESSION,
772                                NULL,
773                                &error);
774   g_assert_no_error (error);
775   error = NULL;
776   proxy = g_dbus_proxy_new_sync (connection,
777                                  G_DBUS_PROXY_FLAGS_NONE,
778                                  NULL,                      /* GDBusInterfaceInfo */
779                                  "com.example.TestService", /* name */
780                                  "/com/example/TestObject", /* object path */
781                                  "com.example.Frob",        /* interface */
782                                  NULL, /* GCancellable */
783                                  &error);
784   g_assert_no_error (error);
785
786   /* this is safe; testserver will exit once the bus goes away */
787   g_assert (g_spawn_command_line_async (SRCDIR "/gdbus-testserver", NULL));
788
789   _g_assert_property_notify (proxy, "g-name-owner");
790
791   test_basic (proxy);
792   test_methods (proxy);
793   test_properties (proxy);
794   test_signals (proxy);
795   test_expected_interface (proxy);
796
797   g_object_unref (proxy);
798   kill_test_service (connection);
799   g_object_unref (connection);
800 }
801
802 /* ---------------------------------------------------------------------------------------------------- */
803
804 static void
805 proxy_ready (GObject      *source,
806              GAsyncResult *result,
807              gpointer      user_data)
808 {
809   GDBusProxy *proxy;
810   GError *error;
811
812   error = NULL;
813   proxy = g_dbus_proxy_new_for_bus_finish (result, &error);
814   g_assert_no_error (error);
815
816   _g_assert_property_notify (proxy, "g-name-owner");
817
818   test_basic (proxy);
819   test_methods (proxy);
820   test_properties (proxy);
821   test_signals (proxy);
822   test_expected_interface (proxy);
823
824   kill_test_service (g_dbus_proxy_get_connection (proxy));
825   g_object_unref (proxy);
826   g_main_loop_quit (loop);
827 }
828
829 static gboolean
830 fail_test (gpointer user_data)
831 {
832   g_assert_not_reached ();
833 }
834
835 static void
836 test_async (void)
837 {
838   g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
839                             G_DBUS_PROXY_FLAGS_NONE,
840                             NULL,                      /* GDBusInterfaceInfo */
841                             "com.example.TestService", /* name */
842                             "/com/example/TestObject", /* object path */
843                             "com.example.Frob",        /* interface */
844                             NULL, /* GCancellable */
845                             proxy_ready,
846                             NULL);
847
848   /* this is safe; testserver will exit once the bus goes away */
849   g_assert (g_spawn_command_line_async (SRCDIR "/gdbus-testserver.py", NULL));
850
851   g_timeout_add (10000, fail_test, NULL);
852   g_main_loop_run (loop);
853 }
854
855 static void
856 test_no_properties (void)
857 {
858   GDBusProxy *proxy;
859   GError *error;
860
861   error = NULL;
862   proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
863                                          G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
864                                          NULL,                      /* GDBusInterfaceInfo */
865                                          "com.example.TestService", /* name */
866                                          "/com/example/TestObject", /* object path */
867                                          "com.example.Frob",        /* interface */
868                                          NULL, /* GCancellable */
869                                          &error);
870   g_assert_no_error (error);
871
872   test_properties (proxy);
873
874   g_object_unref (proxy);
875 }
876
877 static void
878 check_error (GObject      *source,
879              GAsyncResult *result,
880              gpointer      user_data)
881 {
882   GError *error = NULL;
883   GVariant *reply;
884
885   reply = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), result, &error);
886   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
887   g_assert (reply == NULL);
888   g_error_free (error);
889
890   g_main_loop_quit (loop);
891 }
892
893 static void
894 test_wellknown_noauto (void)
895 {
896   GError *error = NULL;
897   GDBusProxy *proxy;
898
899   proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
900                                          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
901                                          NULL, "some.name.that.does.not.exist",
902                                          "/", "some.interface", NULL, &error);
903   g_assert_no_error (error);
904   g_assert (proxy != NULL);
905
906   g_dbus_proxy_call (proxy, "method", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, check_error, NULL);
907   g_timeout_add (10000, fail_test, NULL);
908   g_main_loop_run (loop);
909   g_object_unref (proxy);
910 }
911
912 int
913 main (int   argc,
914       char *argv[])
915 {
916   gint ret;
917   GDBusNodeInfo *introspection_data = NULL;
918
919   g_test_init (&argc, &argv, NULL);
920
921   introspection_data = g_dbus_node_info_new_for_xml (frob_dbus_interface_xml, NULL);
922   g_assert (introspection_data != NULL);
923   frob_dbus_interface_info = introspection_data->interfaces[0];
924
925   /* all the tests rely on a shared main loop */
926   loop = g_main_loop_new (NULL, FALSE);
927
928   session_bus_up ();
929
930   g_test_add_func ("/gdbus/proxy", test_proxy);
931   g_test_add_func ("/gdbus/proxy/no-properties", test_no_properties);
932   g_test_add_func ("/gdbus/proxy/wellknown-noauto", test_wellknown_noauto);
933   g_test_add_func ("/gdbus/proxy/async", test_async);
934
935   ret = g_test_run();
936
937   g_dbus_node_info_unref (introspection_data);
938
939   session_bus_down ();
940   return ret;
941 }