← Back to branch summary

~ubuntu-branches/ubuntu/maverick/telepathy-glib/maverick

« back to all changes in this revision

Viewing changes to tests/gnio-util.c

  • Committer: Bazaar Package Importer
  • Author(s): Simon McVittie
  • Date: 2010-05-10 17:59:54 UTC
  • mfrom: (1.6.1 upstream) (27.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20100510175954-bxvqq3xx0sy4itmp
Tags: 0.11.5-1
New upstream version with new API/ABI

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/gnio-util.c
 
1
/* tests of the GNIO utility functions */
 
2
 
 
3
#include <config.h>
 
4
 
 
5
#include <string.h>
 
6
 
 
7
#include <glib.h>
 
8
#include <dbus/dbus-glib.h>
 
9
#include <gio/gio.h>
 
10
 
 
11
#ifdef HAVE_GIO_UNIX
 
12
#include <gio/gunixsocketaddress.h>
 
13
#endif /* HAVE_GIO_UNIX */
 
14
 
 
15
#include <telepathy-glib/gnio-util.h>
 
16
#include <telepathy-glib/util.h>
 
17
#include <telepathy-glib/gtypes.h>
 
18
 
 
19
#define IPV4_ADDR "127.0.1.1"
 
20
#define IPV6_ADDR "::1"
 
21
#define UNIX_ADDR "/tmp/socket/test/123456"
 
22
#define ABST_ADDR "\000" "123456" "NOT_COPIED"
 
23
#define ABST_ADDR_LEN 7
 
24
#define PORT 41414
 
25
 
 
26
static void
 
27
test_variant_to_sockaddr_ipv4 (void)
 
28
{
 
29
  GValueArray *array;
 
30
  GValue value = { 0, };
 
31
  GSocketAddress *sockaddr;
 
32
  GInetSocketAddress *inetaddr;
 
33
  GInetAddress *hostaddr;
 
34
  char *host;
 
35
  guint16 port;
 
36
  GError *error = NULL;
 
37
 
 
38
  /* set up an address variant */
 
39
  array = tp_value_array_build (2,
 
40
      G_TYPE_STRING, IPV4_ADDR,
 
41
      G_TYPE_UINT, PORT,
 
42
      G_TYPE_INVALID);
 
43
 
 
44
  g_value_init (&value, TP_STRUCT_TYPE_SOCKET_ADDRESS_IPV4);
 
45
  g_value_take_boxed (&value, array);
 
46
 
 
47
  /* convert to a GSocketAddress */
 
48
  sockaddr = tp_g_socket_address_from_variant (TP_SOCKET_ADDRESS_TYPE_IPV4,
 
49
                                               &value, &error);
 
50
  g_value_unset (&value);
 
51
 
 
52
  /* check the socket address */
 
53
  g_assert_no_error (error);
 
54
  g_assert (sockaddr != NULL);
 
55
  g_assert (G_IS_INET_SOCKET_ADDRESS (sockaddr));
 
56
 
 
57
  inetaddr = G_INET_SOCKET_ADDRESS (sockaddr);
 
58
  hostaddr = g_inet_socket_address_get_address (inetaddr);
 
59
 
 
60
  host = g_inet_address_to_string (hostaddr);
 
61
  port = g_inet_socket_address_get_port (inetaddr);
 
62
 
 
63
  g_assert_cmpstr (host, ==, IPV4_ADDR);
 
64
  g_assert_cmpuint (port, ==, PORT);
 
65
 
 
66
  g_free (host);
 
67
  g_object_unref (sockaddr);
 
68
}
 
69
 
 
70
static void
 
71
test_variant_to_sockaddr_ipv6 (void)
 
72
{
 
73
  GValueArray *array;
 
74
  GValue value = { 0, };
 
75
  GSocketAddress *sockaddr;
 
76
  GInetSocketAddress *inetaddr;
 
77
  GInetAddress *hostaddr;
 
78
  char *host;
 
79
  guint16 port;
 
80
  GError *error = NULL;
 
81
 
 
82
  /* set up an address variant */
 
83
  array = tp_value_array_build (2,
 
84
      G_TYPE_STRING, IPV6_ADDR,
 
85
      G_TYPE_UINT, PORT,
 
86
      G_TYPE_INVALID);
 
87
 
 
88
  g_value_init (&value, TP_STRUCT_TYPE_SOCKET_ADDRESS_IPV6);
 
89
  g_value_take_boxed (&value, array);
 
90
 
 
91
  /* convert to a GSocketAddress */
 
92
  sockaddr = tp_g_socket_address_from_variant (TP_SOCKET_ADDRESS_TYPE_IPV6,
 
93
                                               &value, &error);
 
94
  g_value_unset (&value);
 
95
 
 
96
  /* check the socket address */
 
97
  g_assert_no_error (error);
 
98
  g_assert (sockaddr != NULL);
 
99
  g_assert (G_IS_INET_SOCKET_ADDRESS (sockaddr));
 
100
 
 
101
  inetaddr = G_INET_SOCKET_ADDRESS (sockaddr);
 
102
  hostaddr = g_inet_socket_address_get_address (inetaddr);
 
103
 
 
104
  host = g_inet_address_to_string (hostaddr);
 
105
  port = g_inet_socket_address_get_port (inetaddr);
 
106
 
 
107
  g_assert_cmpstr (host, ==, IPV6_ADDR);
 
108
  g_assert_cmpuint (port, ==, PORT);
 
109
 
 
110
  g_free (host);
 
111
  g_object_unref (sockaddr);
 
112
}
 
113
 
 
114
static void
 
115
test_sockaddr_to_variant_ipv4 (void)
 
116
{
 
117
  GInetAddress *hostaddr = g_inet_address_new_from_string (IPV4_ADDR);
 
118
  GSocketAddress *sockaddr = g_inet_socket_address_new (hostaddr, PORT);
 
119
  GValue *variant, *value;
 
120
  GValueArray *array;
 
121
  TpSocketAddressType type;
 
122
  GError *error = NULL;
 
123
 
 
124
  g_object_unref (hostaddr);
 
125
 
 
126
  variant = tp_address_variant_from_g_socket_address (sockaddr, &type, &error);
 
127
  g_object_unref (sockaddr);
 
128
 
 
129
  g_assert_no_error (error);
 
130
  g_assert_cmpuint (type, ==, TP_SOCKET_ADDRESS_TYPE_IPV4);
 
131
  g_assert (G_VALUE_HOLDS (variant, TP_STRUCT_TYPE_SOCKET_ADDRESS_IPV4));
 
132
 
 
133
  array = g_value_get_boxed (variant);
 
134
  value = g_value_array_get_nth (array, 0);
 
135
 
 
136
  g_assert (G_VALUE_HOLDS_STRING (value));
 
137
  g_assert_cmpstr (g_value_get_string (value), ==, IPV4_ADDR);
 
138
 
 
139
  value = g_value_array_get_nth (array, 1);
 
140
 
 
141
  g_assert (G_VALUE_HOLDS_UINT (value));
 
142
  g_assert_cmpuint (g_value_get_uint (value), ==, PORT);
 
143
 
 
144
  tp_g_value_slice_free (variant);
 
145
}
 
146
 
 
147
static void
 
148
test_sockaddr_to_variant_ipv6 (void)
 
149
{
 
150
  GInetAddress *hostaddr = g_inet_address_new_from_string (IPV6_ADDR);
 
151
  GSocketAddress *sockaddr = g_inet_socket_address_new (hostaddr, PORT);
 
152
  GValue *variant, *value;
 
153
  GValueArray *array;
 
154
  TpSocketAddressType type;
 
155
  GError *error = NULL;
 
156
 
 
157
  g_object_unref (hostaddr);
 
158
 
 
159
  variant = tp_address_variant_from_g_socket_address (sockaddr, &type, &error);
 
160
  g_object_unref (sockaddr);
 
161
 
 
162
  g_assert_no_error (error);
 
163
  g_assert_cmpuint (type, ==, TP_SOCKET_ADDRESS_TYPE_IPV6);
 
164
  g_assert (G_VALUE_HOLDS (variant, TP_STRUCT_TYPE_SOCKET_ADDRESS_IPV6));
 
165
 
 
166
  array = g_value_get_boxed (variant);
 
167
  value = g_value_array_get_nth (array, 0);
 
168
 
 
169
  g_assert (G_VALUE_HOLDS_STRING (value));
 
170
  g_assert_cmpstr (g_value_get_string (value), ==, IPV6_ADDR);
 
171
 
 
172
  value = g_value_array_get_nth (array, 1);
 
173
 
 
174
  g_assert (G_VALUE_HOLDS_UINT (value));
 
175
  g_assert_cmpuint (g_value_get_uint (value), ==, PORT);
 
176
 
 
177
  tp_g_value_slice_free (variant);
 
178
}
 
179
 
 
180
#ifdef HAVE_GIO_UNIX
 
181
static void
 
182
test_variant_to_sockaddr_unix (void)
 
183
{
 
184
  GArray *array;
 
185
  GValue value = { 0, };
 
186
  GSocketAddress *sockaddr;
 
187
  GUnixSocketAddress *unixaddr;
 
188
  guint pathlen = strlen (UNIX_ADDR);
 
189
  GError *error = NULL;
 
190
 
 
191
  array = g_array_sized_new (TRUE, FALSE, sizeof (char), pathlen);
 
192
  g_array_append_vals (array, UNIX_ADDR, pathlen);
 
193
 
 
194
  g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY);
 
195
  g_value_take_boxed (&value, array);
 
196
 
 
197
  sockaddr = tp_g_socket_address_from_variant (TP_SOCKET_ADDRESS_TYPE_UNIX,
 
198
      &value, &error);
 
199
  g_value_unset (&value);
 
200
 
 
201
  g_assert_no_error (error);
 
202
  g_assert (G_IS_UNIX_SOCKET_ADDRESS (sockaddr));
 
203
 
 
204
  unixaddr = G_UNIX_SOCKET_ADDRESS (sockaddr);
 
205
 
 
206
  g_assert (g_unix_socket_address_get_is_abstract (unixaddr) == FALSE);
 
207
  g_assert_cmpuint (g_unix_socket_address_get_path_len (unixaddr), ==, pathlen);
 
208
  g_assert_cmpstr (g_unix_socket_address_get_path (unixaddr), ==, UNIX_ADDR);
 
209
 
 
210
  g_object_unref (sockaddr);
 
211
}
 
212
 
 
213
static void
 
214
test_variant_to_sockaddr_abstract_unix (void)
 
215
{
 
216
  GArray *array;
 
217
  GValue value = { 0, };
 
218
  GSocketAddress *sockaddr;
 
219
  GUnixSocketAddress *unixaddr;
 
220
  GError *error = NULL;
 
221
 
 
222
  array = g_array_sized_new (TRUE, FALSE, sizeof (char), ABST_ADDR_LEN);
 
223
  g_array_append_vals (array, ABST_ADDR, ABST_ADDR_LEN);
 
224
 
 
225
  g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY);
 
226
  g_value_take_boxed (&value, array);
 
227
 
 
228
  sockaddr = tp_g_socket_address_from_variant (
 
229
      TP_SOCKET_ADDRESS_TYPE_ABSTRACT_UNIX,
 
230
      &value, &error);
 
231
  g_value_unset (&value);
 
232
 
 
233
  g_assert_no_error (error);
 
234
  g_assert (G_IS_UNIX_SOCKET_ADDRESS (sockaddr));
 
235
 
 
236
  unixaddr = G_UNIX_SOCKET_ADDRESS (sockaddr);
 
237
 
 
238
  g_assert (g_unix_socket_address_get_is_abstract (unixaddr) == TRUE);
 
239
  g_assert_cmpuint (g_unix_socket_address_get_path_len (unixaddr), ==,
 
240
      ABST_ADDR_LEN);
 
241
  g_assert (memcmp (g_unix_socket_address_get_path (unixaddr), ABST_ADDR,
 
242
        ABST_ADDR_LEN) == 0);
 
243
 
 
244
  g_object_unref (sockaddr);
 
245
}
 
246
 
 
247
static void
 
248
test_sockaddr_to_variant_unix (void)
 
249
{
 
250
  GSocketAddress *sockaddr = g_unix_socket_address_new (UNIX_ADDR);
 
251
  GValue *variant;
 
252
  GArray *array;
 
253
  TpSocketAddressType type;
 
254
  GError *error = NULL;
 
255
 
 
256
  variant = tp_address_variant_from_g_socket_address (sockaddr, &type, &error);
 
257
  g_object_unref (sockaddr);
 
258
 
 
259
  g_assert_no_error (error);
 
260
  g_assert_cmpuint (type, ==, TP_SOCKET_ADDRESS_TYPE_UNIX);
 
261
  g_assert (G_VALUE_HOLDS (variant, DBUS_TYPE_G_UCHAR_ARRAY));
 
262
 
 
263
  array = g_value_get_boxed (variant);
 
264
 
 
265
  g_assert_cmpuint (array->len, ==, strlen (UNIX_ADDR));
 
266
  g_assert_cmpstr (array->data, ==, UNIX_ADDR);
 
267
 
 
268
  tp_g_value_slice_free (variant);
 
269
}
 
270
 
 
271
static void
 
272
test_sockaddr_to_variant_abstract_unix (void)
 
273
{
 
274
  GSocketAddress *sockaddr = g_unix_socket_address_new_abstract (
 
275
      ABST_ADDR, ABST_ADDR_LEN);
 
276
  GValue *variant;
 
277
  GArray *array;
 
278
  TpSocketAddressType type;
 
279
  GError *error = NULL;
 
280
 
 
281
  variant = tp_address_variant_from_g_socket_address (sockaddr, &type, &error);
 
282
  g_object_unref (sockaddr);
 
283
 
 
284
  g_assert_no_error (error);
 
285
  g_assert_cmpuint (type, ==, TP_SOCKET_ADDRESS_TYPE_ABSTRACT_UNIX);
 
286
  g_assert (G_VALUE_HOLDS (variant, DBUS_TYPE_G_UCHAR_ARRAY));
 
287
 
 
288
  array = g_value_get_boxed (variant);
 
289
 
 
290
  g_assert_cmpuint (array->len, ==, ABST_ADDR_LEN);
 
291
  g_assert (memcmp (array->data, ABST_ADDR, ABST_ADDR_LEN) == 0);
 
292
 
 
293
  tp_g_value_slice_free (variant);
 
294
}
 
295
#endif /* HAVE_GIO_UNIX */
 
296
 
 
297
int
 
298
main (int argc, char **argv)
 
299
{
 
300
  g_type_init ();
 
301
  dbus_g_type_specialized_init ();
 
302
 
 
303
  test_variant_to_sockaddr_ipv4 ();
 
304
  test_variant_to_sockaddr_ipv6 ();
 
305
  test_sockaddr_to_variant_ipv4 ();
 
306
  test_sockaddr_to_variant_ipv6 ();
 
307
#ifdef HAVE_GIO_UNIX
 
308
  test_variant_to_sockaddr_unix ();
 
309
  test_variant_to_sockaddr_abstract_unix ();
 
310
  test_sockaddr_to_variant_unix ();
 
311
  test_sockaddr_to_variant_abstract_unix ();
 
312
#endif /* HAVE_GIO_UNIX */
 
313
 
 
314
  return 0;
 
315
}