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.1 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, see <http://www.gnu.org/licenses/>.
17 *
18 * Author: David Zeuthen <davidz@redhat.com>
19 */
20
21 #include <gio/gio.h>
22 #include <unistd.h>
23 #include <string.h>
24
25 /* ---------------------------------------------------------------------------------------------------- */
26 /* Test that registered errors are properly mapped */
27 /* ---------------------------------------------------------------------------------------------------- */
28
29 static void
check_registered_error(const gchar * given_dbus_error_name,GQuark error_domain,gint error_code)30 check_registered_error (const gchar *given_dbus_error_name,
31 GQuark error_domain,
32 gint error_code)
33 {
34 GError *error;
35 gchar *dbus_error_name;
36
37 error = g_dbus_error_new_for_dbus_error (given_dbus_error_name, "test message");
38 g_assert_error (error, error_domain, error_code);
39 g_assert (g_dbus_error_is_remote_error (error));
40 g_assert (g_dbus_error_strip_remote_error (error));
41 g_assert_cmpstr (error->message, ==, "test message");
42 dbus_error_name = g_dbus_error_get_remote_error (error);
43 g_assert_cmpstr (dbus_error_name, ==, given_dbus_error_name);
44 g_free (dbus_error_name);
45 g_error_free (error);
46 }
47
48 static void
test_registered_errors(void)49 test_registered_errors (void)
50 {
51 /* Here we check that we are able to map to GError and back for registered
52 * errors.
53 *
54 * For example, if "org.freedesktop.DBus.Error.AddressInUse" is
55 * associated with (G_DBUS_ERROR, G_DBUS_ERROR_DBUS_FAILED), check
56 * that
57 *
58 * - Creating a GError for e.g. "org.freedesktop.DBus.Error.AddressInUse"
59 * has (error_domain, code) == (G_DBUS_ERROR, G_DBUS_ERROR_DBUS_FAILED)
60 *
61 * - That it is possible to recover e.g. "org.freedesktop.DBus.Error.AddressInUse"
62 * as the D-Bus error name when dealing with an error with (error_domain, code) ==
63 * (G_DBUS_ERROR, G_DBUS_ERROR_DBUS_FAILED)
64 *
65 * We just check a couple of well-known errors.
66 */
67 check_registered_error ("org.freedesktop.DBus.Error.Failed",
68 G_DBUS_ERROR,
69 G_DBUS_ERROR_FAILED);
70 check_registered_error ("org.freedesktop.DBus.Error.AddressInUse",
71 G_DBUS_ERROR,
72 G_DBUS_ERROR_ADDRESS_IN_USE);
73 check_registered_error ("org.freedesktop.DBus.Error.UnknownMethod",
74 G_DBUS_ERROR,
75 G_DBUS_ERROR_UNKNOWN_METHOD);
76 check_registered_error ("org.freedesktop.DBus.Error.UnknownObject",
77 G_DBUS_ERROR,
78 G_DBUS_ERROR_UNKNOWN_OBJECT);
79 }
80
81 /* ---------------------------------------------------------------------------------------------------- */
82
83 static void
check_unregistered_error(const gchar * given_dbus_error_name)84 check_unregistered_error (const gchar *given_dbus_error_name)
85 {
86 GError *error;
87 gchar *dbus_error_name;
88
89 error = g_dbus_error_new_for_dbus_error (given_dbus_error_name, "test message");
90 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_DBUS_ERROR);
91 g_assert (g_dbus_error_is_remote_error (error));
92 dbus_error_name = g_dbus_error_get_remote_error (error);
93 g_assert_cmpstr (dbus_error_name, ==, given_dbus_error_name);
94 g_free (dbus_error_name);
95
96 /* strip the message */
97 g_assert (g_dbus_error_strip_remote_error (error));
98 g_assert_cmpstr (error->message, ==, "test message");
99
100 /* check that we can no longer recover the D-Bus error name */
101 g_assert (g_dbus_error_get_remote_error (error) == NULL);
102
103 g_error_free (error);
104
105 }
106
107 static void
test_unregistered_errors(void)108 test_unregistered_errors (void)
109 {
110 /* Here we check that we are able to map to GError and back for unregistered
111 * errors.
112 *
113 * For example, if "com.example.Error.Failed" is not registered, then check
114 *
115 * - Creating a GError for e.g. "com.example.Error.Failed" has (error_domain, code) ==
116 * (G_IO_ERROR, G_IO_ERROR_DBUS_ERROR)
117 *
118 * - That it is possible to recover e.g. "com.example.Error.Failed" from that
119 * GError.
120 *
121 * We just check a couple of random errors.
122 */
123
124 check_unregistered_error ("com.example.Error.Failed");
125 check_unregistered_error ("foobar.buh");
126 }
127
128 /* ---------------------------------------------------------------------------------------------------- */
129
130 static void
check_transparent_gerror(GQuark error_domain,gint error_code)131 check_transparent_gerror (GQuark error_domain,
132 gint error_code)
133 {
134 GError *error;
135 gchar *given_dbus_error_name;
136 gchar *dbus_error_name;
137
138 error = g_error_new (error_domain, error_code, "test message");
139 given_dbus_error_name = g_dbus_error_encode_gerror (error);
140 g_assert (g_str_has_prefix (given_dbus_error_name, "org.gtk.GDBus.UnmappedGError.Quark"));
141 g_error_free (error);
142
143 error = g_dbus_error_new_for_dbus_error (given_dbus_error_name, "test message");
144 g_assert_error (error, error_domain, error_code);
145 g_assert (g_dbus_error_is_remote_error (error));
146 dbus_error_name = g_dbus_error_get_remote_error (error);
147 g_assert_cmpstr (dbus_error_name, ==, given_dbus_error_name);
148 g_free (dbus_error_name);
149 g_free (given_dbus_error_name);
150
151 /* strip the message */
152 g_assert (g_dbus_error_strip_remote_error (error));
153 g_assert_cmpstr (error->message, ==, "test message");
154
155 /* check that we can no longer recover the D-Bus error name */
156 g_assert (g_dbus_error_get_remote_error (error) == NULL);
157
158 g_error_free (error);
159 }
160
161 static void
test_transparent_gerror(void)162 test_transparent_gerror (void)
163 {
164 /* Here we check that we are able to transparent pass unregistered GError's
165 * over the wire.
166 *
167 * For example, if G_IO_ERROR_FAILED is not registered, then check
168 *
169 * - g_dbus_error_encode_gerror() returns something of the form
170 * org.gtk.GDBus.UnmappedGError.Quark_HEXENCODED_QUARK_NAME_.Code_ERROR_CODE
171 *
172 * - mapping back the D-Bus error name gives us G_IO_ERROR_FAILED
173 *
174 * - That it is possible to recover the D-Bus error name from the
175 * GError.
176 *
177 * We just check a couple of random errors.
178 */
179
180 check_transparent_gerror (G_IO_ERROR, G_IO_ERROR_FAILED);
181 check_transparent_gerror (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE);
182 }
183
184 typedef enum
185 {
186 TEST_ERROR_FAILED,
187 TEST_ERROR_BLA
188 } TestError;
189
190 GDBusErrorEntry test_error_entries[] =
191 {
192 { TEST_ERROR_FAILED, "org.gtk.test.Error.Failed" },
193 { TEST_ERROR_BLA, "org.gtk.test.Error.Bla" }
194 };
195
196 static void
test_register_error(void)197 test_register_error (void)
198 {
199 gsize test_error_quark = 0;
200 gboolean res;
201 gchar *msg;
202 GError *error;
203
204 g_dbus_error_register_error_domain ("test-error-quark",
205 &test_error_quark,
206 test_error_entries,
207 G_N_ELEMENTS (test_error_entries));
208 g_assert_cmpint (test_error_quark, !=, 0);
209
210 error = g_dbus_error_new_for_dbus_error ("org.gtk.test.Error.Failed", "Failed");
211 g_assert_error (error, test_error_quark, TEST_ERROR_FAILED);
212 res = g_dbus_error_is_remote_error (error);
213 msg = g_dbus_error_get_remote_error (error);
214 g_assert (res);
215 g_assert_cmpstr (msg, ==, "org.gtk.test.Error.Failed");
216 res = g_dbus_error_strip_remote_error (error);
217 g_assert (res);
218 g_assert_cmpstr (error->message, ==, "Failed");
219 g_clear_error (&error);
220 g_free (msg);
221
222 g_dbus_error_set_dbus_error (&error, "org.gtk.test.Error.Failed", "Failed again", "Prefix %d", 1);
223 res = g_dbus_error_is_remote_error (error);
224 msg = g_dbus_error_get_remote_error (error);
225 g_assert (res);
226 g_assert_cmpstr (msg, ==, "org.gtk.test.Error.Failed");
227 res = g_dbus_error_strip_remote_error (error);
228 g_assert (res);
229 g_assert_cmpstr (error->message, ==, "Prefix 1: Failed again");
230 g_clear_error (&error);
231 g_free (msg);
232
233 error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_NOT_EMPTY, "Not Empty");
234 res = g_dbus_error_is_remote_error (error);
235 msg = g_dbus_error_get_remote_error (error);
236 g_assert (!res);
237 g_assert_cmpstr (msg, ==, NULL);
238 res = g_dbus_error_strip_remote_error (error);
239 g_assert (!res);
240 g_assert_cmpstr (error->message, ==, "Not Empty");
241 g_clear_error (&error);
242
243 error = g_error_new_literal (test_error_quark, TEST_ERROR_BLA, "Bla");
244 msg = g_dbus_error_encode_gerror (error);
245 g_assert_cmpstr (msg, ==, "org.gtk.test.Error.Bla");
246 g_free (msg);
247 g_clear_error (&error);
248
249 res = g_dbus_error_unregister_error (test_error_quark,
250 TEST_ERROR_BLA, "org.gtk.test.Error.Bla");
251 g_assert (res);
252 }
253
254
255 /* ---------------------------------------------------------------------------------------------------- */
256
257 int
main(int argc,char * argv[])258 main (int argc,
259 char *argv[])
260 {
261 g_test_init (&argc, &argv, NULL);
262
263 g_test_add_func ("/gdbus/registered-errors", test_registered_errors);
264 g_test_add_func ("/gdbus/unregistered-errors", test_unregistered_errors);
265 g_test_add_func ("/gdbus/transparent-gerror", test_transparent_gerror);
266 g_test_add_func ("/gdbus/register-error", test_register_error);
267
268 return g_test_run();
269 }
270