← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/dbus-glib/oneiric-updates

« back to all changes in this revision

Viewing changes to test/core/test-gvariant.c

  • Committer: Bazaar Package Importer
  • Author(s): Simon McVittie
  • Date: 2010-08-16 19:52:19 UTC
  • mfrom: (2.2.1 experimental) (2.1.9 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100816195219-ig40gau6zeskqey2
Tags: 0.88-2
Re-upload to unstable, with release team acknowledgement for squeeze

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/core/test-gvariant.c
 
1
#include <dbus/dbus-glib.h>
 
2
#include <gio/gio.h>
 
3
 
 
4
/**
 
5
 * test_g_variant_equivalent:
 
6
 *
 
7
 * The function g_variant_equal() cannot be used for dictionaries because it
 
8
 * cares about the ordering of dictionaries, which breaks our tests.
 
9
 */
 
10
static gboolean
 
11
test_g_variant_equivalent (GVariant *one,
 
12
    GVariant *two)
 
13
{
 
14
  if (!g_variant_type_equal (
 
15
        g_variant_get_type (one),
 
16
        g_variant_get_type (two)))
 
17
    {
 
18
      return FALSE;
 
19
    }
 
20
  else if (g_variant_is_of_type (one, G_VARIANT_TYPE_DICTIONARY) &&
 
21
           g_variant_is_of_type (two, G_VARIANT_TYPE_DICTIONARY))
 
22
    {
 
23
      GHashTable *hash;
 
24
      GVariantIter iter;
 
25
      GVariant *child;
 
26
      gboolean equal = TRUE;
 
27
 
 
28
      if (g_variant_n_children (one) != g_variant_n_children (two))
 
29
        return FALSE;
 
30
 
 
31
      /* pack @one into a hash table */
 
32
      hash = g_hash_table_new_full (g_variant_hash, g_variant_equal,
 
33
          (GDestroyNotify) g_variant_unref, (GDestroyNotify) g_variant_unref);
 
34
 
 
35
      g_variant_iter_init (&iter, one);
 
36
      while ((child = g_variant_iter_next_value (&iter)))
 
37
        {
 
38
          g_hash_table_insert (hash,
 
39
              g_variant_get_child_value (child, 0),
 
40
              g_variant_get_child_value (child, 1));
 
41
          g_variant_unref (child);
 
42
        }
 
43
 
 
44
      /* now iterate @two to check for the keys in @hash */
 
45
      g_variant_iter_init (&iter, two);
 
46
      while (equal && (child = g_variant_iter_next_value (&iter)))
 
47
        {
 
48
          GVariant *k, *v1, *v2;
 
49
 
 
50
          k = g_variant_get_child_value (child, 0);
 
51
          v1 = g_variant_get_child_value (child, 1);
 
52
 
 
53
          v2 = g_hash_table_lookup (hash, k);
 
54
 
 
55
          if (v2 == NULL || !test_g_variant_equivalent (v1, v2))
 
56
            equal = FALSE;
 
57
          else
 
58
            g_hash_table_remove (hash, k);
 
59
 
 
60
          g_variant_unref (k);
 
61
          g_variant_unref (v1);
 
62
          g_variant_unref (child);
 
63
        }
 
64
 
 
65
      if (g_hash_table_size (hash) > 0)
 
66
        equal = FALSE;
 
67
 
 
68
      g_hash_table_destroy (hash);
 
69
 
 
70
      return equal;
 
71
    }
 
72
  else if (g_variant_is_container (one) &&
 
73
           g_variant_is_container (two))
 
74
    {
 
75
      guint i, size;
 
76
      gboolean equal = TRUE;
 
77
 
 
78
      if (g_variant_n_children (one) != g_variant_n_children (two))
 
79
        return FALSE;
 
80
 
 
81
      size = g_variant_n_children (one);
 
82
      for (i = 0; equal && i < size; i++)
 
83
        {
 
84
          GVariant *child1, *child2;
 
85
 
 
86
          child1 = g_variant_get_child_value (one, i);
 
87
          child2 = g_variant_get_child_value (two, i);
 
88
 
 
89
          equal = test_g_variant_equivalent (child1, child2);
 
90
 
 
91
          g_variant_unref (child1);
 
92
          g_variant_unref (child2);
 
93
        }
 
94
 
 
95
      return equal;
 
96
    }
 
97
  else
 
98
    {
 
99
      return g_variant_equal (one, two);
 
100
    }
 
101
}
 
102
 
 
103
/* test_g_variant_equivalent tests */
 
104
static void
 
105
test_simple_equiv (void)
 
106
{
 
107
  GVariant *v1, *v2;
 
108
 
 
109
  v1 = g_variant_new_int32 (1984);
 
110
  v2 = g_variant_new_int32 (1984);
 
111
 
 
112
  g_assert (test_g_variant_equivalent (v1, v2));
 
113
 
 
114
  g_variant_unref (v1);
 
115
  g_variant_unref (v2);
 
116
}
 
117
 
 
118
static void
 
119
test_simple_not_equiv (void)
 
120
{
 
121
  GVariant *v1, *v2;
 
122
 
 
123
  v1 = g_variant_new_int32 (1982);
 
124
  v2 = g_variant_new_int32 (1984);
 
125
 
 
126
  g_assert (!test_g_variant_equivalent (v1, v2));
 
127
 
 
128
  g_variant_unref (v1);
 
129
  g_variant_unref (v2);
 
130
}
 
131
 
 
132
static void
 
133
test_array_not_equiv (void)
 
134
{
 
135
  GVariantBuilder b;
 
136
  GVariant *v1, *v2;
 
137
 
 
138
  g_variant_builder_init (&b, G_VARIANT_TYPE ("av"));
 
139
  g_variant_builder_add (&b, "v", g_variant_new_int32 (1984));
 
140
  g_variant_builder_add (&b, "v", g_variant_new_string ("Orwell"));
 
141
  g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher"));
 
142
  v1 = g_variant_builder_end (&b);
 
143
 
 
144
  g_variant_builder_init (&b, G_VARIANT_TYPE ("av"));
 
145
  /* note the order has changed */
 
146
  g_variant_builder_add (&b, "v", g_variant_new_string ("Orwell"));
 
147
  g_variant_builder_add (&b, "v", g_variant_new_int32 (1984));
 
148
  g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher"));
 
149
  v2 = g_variant_builder_end (&b);
 
150
 
 
151
  g_assert (!test_g_variant_equivalent (v1, v2));
 
152
 
 
153
  g_variant_unref (v1);
 
154
  g_variant_unref (v2);
 
155
}
 
156
 
 
157
static void
 
158
test_map_equiv (void)
 
159
{
 
160
  GVariantBuilder b;
 
161
  GVariant *v1, *v2;
 
162
 
 
163
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
164
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
165
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
166
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith");
 
167
  v1 = g_variant_builder_end (&b);
 
168
 
 
169
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
170
  /* note the order has changed */
 
171
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
172
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
173
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith");
 
174
  v2 = g_variant_builder_end (&b);
 
175
 
 
176
  g_assert (test_g_variant_equivalent (v1, v2));
 
177
 
 
178
  g_variant_unref (v1);
 
179
  g_variant_unref (v2);
 
180
}
 
181
 
 
182
static void
 
183
test_map_not_equiv1 (void)
 
184
{
 
185
  GVariantBuilder b;
 
186
  GVariant *v1, *v2;
 
187
 
 
188
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
189
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
190
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
191
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith");
 
192
  v1 = g_variant_builder_end (&b);
 
193
 
 
194
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
195
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
196
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
197
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith");
 
198
  g_variant_builder_add (&b, "{os}", "/cats/rory", "Rory Cat");
 
199
  v2 = g_variant_builder_end (&b);
 
200
 
 
201
  g_assert (!test_g_variant_equivalent (v1, v2));
 
202
 
 
203
  g_variant_unref (v1);
 
204
  g_variant_unref (v2);
 
205
}
 
206
 
 
207
static void
 
208
test_map_not_equiv2 (void)
 
209
{
 
210
  GVariantBuilder b;
 
211
  GVariant *v1, *v2;
 
212
 
 
213
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
214
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
215
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
216
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith");
 
217
  v1 = g_variant_builder_end (&b);
 
218
 
 
219
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
220
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
221
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
222
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Cat");
 
223
  v2 = g_variant_builder_end (&b);
 
224
 
 
225
  g_assert (!test_g_variant_equivalent (v1, v2));
 
226
 
 
227
  g_variant_unref (v1);
 
228
  g_variant_unref (v2);
 
229
}
 
230
 
 
231
/* dbus_g_value_build_g_variant tests */
 
232
static void
 
233
test_i (void)
 
234
{
 
235
  GValue v = { 0, };
 
236
  GVariant *var, *varc;
 
237
 
 
238
  g_value_init (&v, G_TYPE_INT);
 
239
  g_value_set_int (&v, 1984);
 
240
 
 
241
  var = dbus_g_value_build_g_variant (&v);
 
242
  g_value_unset (&v);
 
243
 
 
244
  varc = g_variant_new_int32 (1984);
 
245
 
 
246
  g_assert (test_g_variant_equivalent (var, varc));
 
247
 
 
248
  g_variant_unref (var);
 
249
  g_variant_unref (varc);
 
250
}
 
251
 
 
252
static void
 
253
test_s (void)
 
254
{
 
255
  GValue v = { 0, };
 
256
  GVariant *var, *varc;
 
257
 
 
258
  g_value_init (&v, G_TYPE_STRING);
 
259
  g_value_set_static_string (&v, "Orwell");
 
260
 
 
261
  var = dbus_g_value_build_g_variant (&v);
 
262
  g_value_unset (&v);
 
263
 
 
264
  varc = g_variant_new_string ("Orwell");
 
265
 
 
266
  g_assert (test_g_variant_equivalent (var, varc));
 
267
 
 
268
  g_variant_unref (var);
 
269
  g_variant_unref (varc);
 
270
}
 
271
 
 
272
static void
 
273
test_o (void)
 
274
{
 
275
  GValue v = { 0, };
 
276
  GVariant *var, *varc;
 
277
 
 
278
  g_value_init (&v, DBUS_TYPE_G_OBJECT_PATH);
 
279
  g_value_set_boxed (&v, "/cats/escher");
 
280
 
 
281
  var = dbus_g_value_build_g_variant (&v);
 
282
  g_value_unset (&v);
 
283
 
 
284
  varc = g_variant_new_object_path ("/cats/escher");
 
285
 
 
286
  g_assert (test_g_variant_equivalent (var, varc));
 
287
 
 
288
  g_variant_unref (var);
 
289
  g_variant_unref (varc);
 
290
}
 
291
 
 
292
static void
 
293
test_us (void)
 
294
{
 
295
  GValue v = { 0, };
 
296
  GVariant *var, *varc;
 
297
  GType us = dbus_g_type_get_struct ("GValueArray",
 
298
      G_TYPE_UINT,
 
299
      G_TYPE_STRING,
 
300
      G_TYPE_INVALID);
 
301
 
 
302
  g_value_init (&v, us);
 
303
  g_value_take_boxed (&v, dbus_g_type_specialized_construct (us));
 
304
  dbus_g_type_struct_set (&v,
 
305
      0, 1984,
 
306
      1, "Orwell",
 
307
      G_MAXUINT);
 
308
 
 
309
  var = dbus_g_value_build_g_variant (&v);
 
310
  g_value_unset (&v);
 
311
 
 
312
  varc = g_variant_new ("(us)", 1984, "Orwell");
 
313
 
 
314
  g_assert (test_g_variant_equivalent (var, varc));
 
315
 
 
316
  g_variant_unref (var);
 
317
  g_variant_unref (varc);
 
318
}
 
319
 
 
320
static void
 
321
test_a_os (void)
 
322
{
 
323
  GValue v = { 0, };
 
324
  GHashTable *map;
 
325
  GVariantBuilder b;
 
326
  GVariant *var, *varc;
 
327
  GType a_os = dbus_g_type_get_map ("GHashTable",
 
328
      DBUS_TYPE_G_OBJECT_PATH,
 
329
      G_TYPE_STRING);
 
330
 
 
331
  g_value_init (&v, a_os);
 
332
  map = dbus_g_type_specialized_construct (a_os);
 
333
 
 
334
  g_hash_table_insert (map,
 
335
      g_strdup ("/cats/escher"), g_strdup ("Escher Moonbeam"));
 
336
  g_hash_table_insert (map,
 
337
      g_strdup ("/cats/harvey"), g_strdup ("Harvey Nomcat"));
 
338
  g_hash_table_insert (map,
 
339
      g_strdup ("/cats/josh"), g_strdup ("Josh Smith"));
 
340
  g_value_take_boxed (&v, map);
 
341
 
 
342
  var = dbus_g_value_build_g_variant (&v);
 
343
  g_value_unset (&v);
 
344
 
 
345
  g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}"));
 
346
  g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam");
 
347
  g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat");
 
348
  g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith");
 
349
  varc = g_variant_builder_end (&b);
 
350
 
 
351
  g_assert (test_g_variant_equivalent (var, varc));
 
352
 
 
353
  g_variant_unref (var);
 
354
  g_variant_unref (varc);
 
355
}
 
356
 
 
357
static void
 
358
test_av (void)
 
359
{
 
360
  GValue v = { 0, }, *v2;
 
361
  GVariantBuilder b;
 
362
  GVariant *var, *varc;
 
363
  GType av = dbus_g_type_get_collection ("GPtrArray", G_TYPE_VALUE);
 
364
  GPtrArray *array;
 
365
 
 
366
  g_value_init (&v, av);
 
367
  array = dbus_g_type_specialized_construct (av);
 
368
 
 
369
  v2 = g_new0 (GValue, 1);
 
370
  g_value_init (v2, G_TYPE_INT);
 
371
  g_value_set_int (v2, 1984);
 
372
  g_ptr_array_add (array, v2);
 
373
 
 
374
  v2 = g_new0 (GValue, 1);
 
375
  g_value_init (v2, G_TYPE_STRING);
 
376
  g_value_set_static_string (v2, "Orwell");
 
377
  g_ptr_array_add (array, v2);
 
378
 
 
379
  v2 = g_new0 (GValue, 1);
 
380
  g_value_init (v2, DBUS_TYPE_G_OBJECT_PATH);
 
381
  g_value_set_boxed (v2, "/cats/escher");
 
382
  g_ptr_array_add (array, v2);
 
383
 
 
384
  g_value_take_boxed (&v, array);
 
385
 
 
386
  var = dbus_g_value_build_g_variant (&v);
 
387
  g_value_unset (&v);
 
388
 
 
389
  g_variant_builder_init (&b, G_VARIANT_TYPE ("av"));
 
390
  g_variant_builder_add (&b, "v", g_variant_new_int32 (1984));
 
391
  g_variant_builder_add (&b, "v", g_variant_new_string ("Orwell"));
 
392
  g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher"));
 
393
  varc = g_variant_builder_end (&b);
 
394
 
 
395
  g_assert (test_g_variant_equivalent (var, varc));
 
396
 
 
397
  g_variant_unref (var);
 
398
  g_variant_unref (varc);
 
399
}
 
400
 
 
401
static void
 
402
test_g (void)
 
403
{
 
404
  GValue v = { 0, };
 
405
  GVariant *var, *varc;
 
406
 
 
407
  g_value_init (&v, DBUS_TYPE_G_SIGNATURE);
 
408
  g_value_set_boxed (&v, "a{u(ua{sa{sv}})}");
 
409
 
 
410
  var = dbus_g_value_build_g_variant (&v);
 
411
  g_value_unset (&v);
 
412
 
 
413
  varc = g_variant_new_signature ("a{u(ua{sa{sv}})}");
 
414
 
 
415
  g_assert (test_g_variant_equivalent (var, varc));
 
416
 
 
417
  g_variant_unref (var);
 
418
  g_variant_unref (varc);
 
419
}
 
420
 
 
421
int
 
422
main (int argc,
 
423
    char **argv)
 
424
{
 
425
  g_type_init ();
 
426
  dbus_g_type_specialized_init ();
 
427
 
 
428
  g_test_init (&argc, &argv, NULL);
 
429
 
 
430
  /* test_g_variant_equivalent tests */
 
431
  g_test_add_func ("/test_g_variant_equivalent/test_simple_equiv",
 
432
      test_simple_equiv);
 
433
  g_test_add_func ("/test_g_variant_equivalent/test_simple_not_equiv",
 
434
      test_simple_not_equiv);
 
435
  g_test_add_func ("/test_g_variant_equivalent/test_array_not_equiv",
 
436
      test_array_not_equiv);
 
437
  g_test_add_func ("/test_g_variant_equivalent/test_map_equiv",
 
438
      test_map_equiv);
 
439
  g_test_add_func ("/test_g_variant_equivalent/test_map_not_equiv1",
 
440
      test_map_not_equiv1);
 
441
  g_test_add_func ("/test_g_variant_equivalent/test_map_not_equiv2",
 
442
      test_map_not_equiv2);
 
443
 
 
444
  /* dbus_g_value_build_g_variant tests */
 
445
  g_test_add_func ("/gvalue-to-gvariant/i", test_i);
 
446
  g_test_add_func ("/gvalue-to-gvariant/s", test_s);
 
447
  g_test_add_func ("/gvalue-to-gvariant/o", test_o);
 
448
  g_test_add_func ("/gvalue-to-gvariant/us", test_us);
 
449
  g_test_add_func ("/gvalue-to-gvariant/a{os}", test_a_os);
 
450
  g_test_add_func ("/gvalue-to-gvariant/av", test_av);
 
451
  g_test_add_func ("/gvalue-to-gvariant/g", test_g);
 
452
 
 
453
  return g_test_run ();
 
454
}