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