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 <locale.h>
24 #include <gio/gio.h>
25
26 /* ---------------------------------------------------------------------------------------------------- */
27
28 static void
29 on_notify_locked (GObject *object,
30 GParamSpec *pspec,
31 gpointer user_data)
32 {
33 gint *count = user_data;
34 *count += 1;
35 }
36
37 static void
38 message_lock (void)
39 {
40 GDBusMessage *m;
41 gint count;
42
43 count = 0;
44 m = g_dbus_message_new ();
45 g_signal_connect (m,
46 "notify::locked",
47 G_CALLBACK (on_notify_locked),
48 &count);
49 g_assert (!g_dbus_message_get_locked (m));
50 g_dbus_message_lock (m);
51 g_assert (g_dbus_message_get_locked (m));
52 g_assert_cmpint (count, ==, 1);
53 g_dbus_message_lock (m);
54 g_assert (g_dbus_message_get_locked (m));
55 g_assert_cmpint (count, ==, 1);
56
57 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
58 "*Attempted to modify a locked message*");
59 g_dbus_message_set_serial (m, 42);
60 g_test_assert_expected_messages ();
61
62 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
63 "*Attempted to modify a locked message*");
64 g_dbus_message_set_byte_order (m, G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN);
65 g_test_assert_expected_messages ();
66
67 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
68 "*Attempted to modify a locked message*");
69 g_dbus_message_set_message_type (m, G_DBUS_MESSAGE_TYPE_METHOD_CALL);
70 g_test_assert_expected_messages ();
71
72 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
73 "*Attempted to modify a locked message*");
74 g_dbus_message_set_flags (m, G_DBUS_MESSAGE_FLAGS_NONE);
75 g_test_assert_expected_messages ();
76
77 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
78 "*Attempted to modify a locked message*");
79 g_dbus_message_set_body (m, NULL);
80 g_test_assert_expected_messages ();
81
82 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
83 "*Attempted to modify a locked message*");
84 g_dbus_message_set_header (m, 0, NULL);
85 g_test_assert_expected_messages ();
86
87 g_object_unref (m);
88 }
89
90 /* ---------------------------------------------------------------------------------------------------- */
91
92 static void
93 message_copy (void)
94 {
95 GDBusMessage *m;
96 GDBusMessage *copy;
97 GError *error;
98 guchar *m_headers;
99 guchar *copy_headers;
100 guint n;
101
102 m = g_dbus_message_new_method_call ("org.example.Name",
103 "/org/example/Object",
104 "org.example.Interface",
105 "Method");
106 g_dbus_message_set_serial (m, 42);
107 g_dbus_message_set_byte_order (m, G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN);
108
109 error = NULL;
110 copy = g_dbus_message_copy (m, &error);
111 g_assert_no_error (error);
112 g_assert (G_IS_DBUS_MESSAGE (copy));
113 g_assert (m != copy);
114 g_assert_cmpint (G_OBJECT (m)->ref_count, ==, 1);
115 g_assert_cmpint (G_OBJECT (copy)->ref_count, ==, 1);
116
117 g_assert_cmpint (g_dbus_message_get_serial (copy), ==, g_dbus_message_get_serial (m));
118 g_assert_cmpint (g_dbus_message_get_byte_order (copy), ==, g_dbus_message_get_byte_order (m));
119 g_assert_cmpint (g_dbus_message_get_flags (copy), ==, g_dbus_message_get_flags (m));
120 g_assert_cmpint (g_dbus_message_get_message_type (copy), ==, g_dbus_message_get_message_type (m));
121 m_headers = g_dbus_message_get_header_fields (m);
122 copy_headers = g_dbus_message_get_header_fields (copy);
123 g_assert (m_headers != NULL);
124 g_assert (copy_headers != NULL);
125 for (n = 0; m_headers[n] != 0; n++)
126 {
127 GVariant *m_val;
128 GVariant *copy_val;
129 m_val = g_dbus_message_get_header (m, m_headers[n]);
130 copy_val = g_dbus_message_get_header (m, m_headers[n]);
131 g_assert (m_val != NULL);
132 g_assert (copy_val != NULL);
133 g_assert_cmpvariant (m_val, copy_val);
134 }
135 g_assert_cmpint (n, >, 0); /* make sure we actually compared headers etc. */
136 g_assert_cmpint (copy_headers[n], ==, 0);
137 g_free (m_headers);
138 g_free (copy_headers);
139
140 g_object_unref (copy);
141 g_object_unref (m);
142 }
143
144 /* ---------------------------------------------------------------------------------------------------- */
145
146 /* Test g_dbus_message_bytes_needed() returns correct results for a variety of
147 * arbitrary binary inputs.*/
148 static void
149 message_bytes_needed (void)
150 {
151 const struct
152 {
153 const guint8 blob[16];
154 gssize expected_bytes_needed;
155 }
156 vectors[] =
157 {
158 /* Little endian with header rounding */
159 { { 'l', 0, 0, 1, /* endianness, message type, flags, protocol version */
160 50, 0, 0, 0, /* body length */
161 1, 0, 0, 0, /* message serial */
162 7, 0, 0, 0 /* header length */}, 74 },
163 /* Little endian without header rounding */
164 { { 'l', 0, 0, 1, /* endianness, message type, flags, protocol version */
165 50, 0, 0, 0, /* body length */
166 1, 0, 0, 0, /* message serial */
167 8, 0, 0, 0 /* header length */}, 74 },
168 /* Big endian with header rounding */
169 { { 'B', 0, 0, 1, /* endianness, message type, flags, protocol version */
170 0, 0, 0, 50, /* body length */
171 0, 0, 0, 1, /* message serial */
172 0, 0, 0, 7 /* header length */}, 74 },
173 /* Big endian without header rounding */
174 { { 'B', 0, 0, 1, /* endianness, message type, flags, protocol version */
175 0, 0, 0, 50, /* body length */
176 0, 0, 0, 1, /* message serial */
177 0, 0, 0, 8 /* header length */}, 74 },
178 /* Invalid endianness */
179 { { '!', 0, 0, 1, /* endianness, message type, flags, protocol version */
180 0, 0, 0, 50, /* body length */
181 0, 0, 0, 1, /* message serial */
182 0, 0, 0, 8 /* header length */}, -1 },
183 /* Oversized */
184 { { 'l', 0, 0, 1, /* endianness, message type, flags, protocol version */
185 0, 0, 0, 0x08, /* body length (128MiB) */
186 1, 0, 0, 0, /* message serial */
187 7, 0, 0, 0 /* header length */}, -1 },
188 };
189 gsize i;
190
191 for (i = 0; i < G_N_ELEMENTS (vectors); i++)
192 {
193 gssize bytes_needed;
194 GError *local_error = NULL;
195
196 g_test_message ("Vector: %" G_GSIZE_FORMAT, i);
197
198 bytes_needed = g_dbus_message_bytes_needed ((guchar *) vectors[i].blob,
199 G_N_ELEMENTS (vectors[i].blob),
200 &local_error);
201
202 if (vectors[i].expected_bytes_needed < 0)
203 g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
204 else
205 g_assert_no_error (local_error);
206 g_assert_cmpint (bytes_needed, ==, vectors[i].expected_bytes_needed);
207
208 g_clear_error (&local_error);
209 }
210 }
211
212 /* ---------------------------------------------------------------------------------------------------- */
213
214 int
215 main (int argc,
216 char *argv[])
217 {
218 setlocale (LC_ALL, "C");
219
220 g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
221
222 g_test_add_func ("/gdbus/message/lock", message_lock);
223 g_test_add_func ("/gdbus/message/copy", message_copy);
224 g_test_add_func ("/gdbus/message/bytes-needed", message_bytes_needed);
225
226 return g_test_run ();
227 }