← Back to branch summary

~ubuntu-branches/debian/squeeze/glib2.0/squeeze

« back to all changes in this revision

Viewing changes to glib/tests/keyfile.c

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo Noronha Silva
  • Date: 2009-02-15 13:00:43 UTC
  • mfrom: (1.3.1 upstream) (69.1.10 intrepid)
  • Revision ID: james.westby@ubuntu.com-20090215130043-q47fbt3owmt42m2f
Tags: 2.18.4-2
* Release to unstable
* debian/rules:
- bump SHVER, since we are already forcing a 2.18.0 dependecy on the
  symbols introduced in the development versions
* debian/control.in:
- added Homepage and Vcs-* control fields

Show diffs side-by-side

added added

removed removed

Lines of Context:
glib/tests/keyfile.c
 
1
#include <glib.h>
 
2
#include <locale.h>
 
3
#include <string.h>
 
4
#include <stdlib.h>
 
5
 
 
6
static GKeyFile *
 
7
load_data (const gchar   *data, 
 
8
           GKeyFileFlags  flags)
 
9
{
 
10
  GKeyFile *keyfile;
 
11
  GError *error = NULL;
 
12
 
 
13
  keyfile = g_key_file_new ();
 
14
  g_key_file_load_from_data (keyfile, data, -1, flags, &error);
 
15
  g_assert (error == NULL);
 
16
  return keyfile;
 
17
}
 
18
 
 
19
static void
 
20
check_error (GError **error,
 
21
             GQuark   domain,
 
22
             gint     code)
 
23
{
 
24
  g_assert (*error != NULL);
 
25
  g_assert ((*error)->domain == domain);
 
26
  g_assert ((*error)->code == code);
 
27
  g_error_free (*error);
 
28
  *error = NULL;
 
29
}
 
30
 
 
31
static void 
 
32
check_no_error (GError **error)
 
33
{
 
34
  g_assert (*error == NULL);
 
35
}
 
36
 
 
37
static void
 
38
check_string_value (GKeyFile    *keyfile,
 
39
                    const gchar *group,
 
40
                    const gchar *key,
 
41
                    const gchar *expected) 
 
42
{
 
43
  GError *error = NULL;
 
44
  gchar *value;
 
45
 
 
46
  value = g_key_file_get_string (keyfile, group, key, &error);
 
47
  check_no_error (&error);
 
48
  g_assert (value != NULL);
 
49
  g_assert_cmpstr (value, ==, expected);
 
50
  g_free (value);
 
51
}
 
52
 
 
53
static void
 
54
check_locale_string_value (GKeyFile    *keyfile,
 
55
                           const gchar *group,
 
56
                           const gchar *key,
 
57
                           const gchar *locale,
 
58
                           const gchar *expected) 
 
59
{
 
60
  GError *error = NULL;
 
61
  gchar *value;
 
62
 
 
63
  value = g_key_file_get_locale_string (keyfile, group, key, locale, &error);
 
64
  check_no_error (&error);
 
65
  g_assert (value != NULL);
 
66
  g_assert_cmpstr (value, ==, expected);
 
67
  g_free (value);
 
68
}
 
69
 
 
70
static void
 
71
check_string_list_value (GKeyFile    *keyfile,
 
72
                         const gchar *group,
 
73
                         const gchar *key,
 
74
                         ...)
 
75
{
 
76
  gint i;
 
77
  gchar *v, **value;
 
78
  va_list args;
 
79
  gsize len;
 
80
  GError *error = NULL;
 
81
 
 
82
  value = g_key_file_get_string_list (keyfile, group, key, &len, &error);
 
83
  check_no_error (&error);
 
84
  g_assert (value != NULL);
 
85
  
 
86
  va_start (args, key);
 
87
  i = 0;
 
88
  v = va_arg (args, gchar*);
 
89
  while (v)
 
90
    {
 
91
      g_assert (value[i] != NULL);
 
92
      g_assert_cmpstr (v, ==, value[i]);
 
93
      i++;
 
94
      v = va_arg (args, gchar*);
 
95
    }
 
96
 
 
97
  va_end (args);
 
98
  
 
99
  g_strfreev (value);
 
100
}
 
101
 
 
102
static void
 
103
check_locale_string_list_value (GKeyFile    *keyfile,
 
104
                                const gchar *group,
 
105
                                const gchar *key,
 
106
                                const gchar *locale,
 
107
                                ...)
 
108
{
 
109
  gint i;
 
110
  gchar *v, **value;
 
111
  va_list args;
 
112
  gsize len;
 
113
  GError *error = NULL;
 
114
 
 
115
  value = g_key_file_get_locale_string_list (keyfile, group, key, locale, &len, &error);
 
116
  check_no_error (&error);
 
117
  g_assert (value != NULL);
 
118
  
 
119
  va_start (args, locale);
 
120
  i = 0;
 
121
  v = va_arg (args, gchar*);
 
122
  while (v)
 
123
    {
 
124
      g_assert (value[i] != NULL);
 
125
      g_assert_cmpstr (v, ==, value[i]);
 
126
      i++;
 
127
      v = va_arg (args, gchar*);
 
128
    }
 
129
 
 
130
  va_end (args);
 
131
  
 
132
  g_strfreev (value);
 
133
}
 
134
 
 
135
static void
 
136
check_integer_list_value (GKeyFile    *keyfile,
 
137
                          const gchar *group,
 
138
                          const gchar *key,
 
139
                          ...)
 
140
{
 
141
  gint i;
 
142
  gint v, *value;
 
143
  va_list args;
 
144
  gsize len;
 
145
  GError *error = NULL;
 
146
 
 
147
  value = g_key_file_get_integer_list (keyfile, group, key, &len, &error);
 
148
  check_no_error (&error);
 
149
  g_assert (value != NULL);
 
150
  
 
151
  va_start (args, key);
 
152
  i = 0;
 
153
  v = va_arg (args, gint);
 
154
  while (v != -100)
 
155
    {
 
156
      g_assert_cmpint (i, <, len);
 
157
      g_assert_cmpint (value[i], ==, v);
 
158
      i++;
 
159
      v = va_arg (args, gint);
 
160
    }
 
161
 
 
162
  va_end (args);
 
163
  
 
164
  g_free (value);
 
165
}
 
166
 
 
167
static void
 
168
check_double_list_value (GKeyFile    *keyfile,
 
169
                          const gchar *group,
 
170
                          const gchar *key,
 
171
                          ...)
 
172
{
 
173
  gint i;
 
174
  gdouble v, *value;
 
175
  va_list args;
 
176
  gsize len;
 
177
  GError *error = NULL;
 
178
 
 
179
  value = g_key_file_get_double_list (keyfile, group, key, &len, &error);
 
180
  check_no_error (&error);
 
181
  g_assert (value != NULL);
 
182
  
 
183
  va_start (args, key);
 
184
  i = 0;
 
185
  v = va_arg (args, gdouble);
 
186
  while (v != -100)
 
187
    {
 
188
      g_assert_cmpint (i, <, len);
 
189
      g_assert_cmpfloat (value[i], ==, v);
 
190
      i++;
 
191
      v = va_arg (args, gdouble);
 
192
    }
 
193
 
 
194
  va_end (args);
 
195
  
 
196
  g_free (value);
 
197
}
 
198
 
 
199
static void
 
200
check_boolean_list_value (GKeyFile    *keyfile,
 
201
                          const gchar *group,
 
202
                          const gchar *key,
 
203
                          ...)
 
204
{
 
205
  gint i;
 
206
  gboolean v, *value;
 
207
  va_list args;
 
208
  gsize len;
 
209
  GError *error = NULL;
 
210
 
 
211
  value = g_key_file_get_boolean_list (keyfile, group, key, &len, &error);
 
212
  check_no_error (&error);
 
213
  g_assert (value != NULL);
 
214
  
 
215
  va_start (args, key);
 
216
  i = 0;
 
217
  v = va_arg (args, gboolean);
 
218
  while (v != -100)
 
219
    {
 
220
      g_assert_cmpint (i, <, len);
 
221
      g_assert_cmpint (value[i], ==, v);
 
222
      i++;
 
223
      v = va_arg (args, gboolean);
 
224
    }
 
225
 
 
226
  va_end (args);
 
227
  
 
228
  g_free (value);
 
229
}
 
230
 
 
231
static void
 
232
check_boolean_value (GKeyFile    *keyfile,
 
233
                     const gchar *group,
 
234
                     const gchar *key,
 
235
                     gboolean     expected) 
 
236
{
 
237
  GError *error = NULL;
 
238
  gboolean value;
 
239
 
 
240
  value = g_key_file_get_boolean (keyfile, group, key, &error);
 
241
  check_no_error (&error);
 
242
  g_assert_cmpint (value, ==, expected);
 
243
}
 
244
 
 
245
static void
 
246
check_integer_value (GKeyFile    *keyfile,
 
247
                     const gchar *group,
 
248
                     const gchar *key,
 
249
                     gint         expected) 
 
250
{
 
251
  GError *error = NULL;
 
252
  gint value;
 
253
 
 
254
  value = g_key_file_get_integer (keyfile, group, key, &error);
 
255
  check_no_error (&error);
 
256
  g_assert_cmpint (value, ==, expected);
 
257
}
 
258
 
 
259
static void
 
260
check_double_value (GKeyFile    *keyfile,
 
261
                     const gchar *group,
 
262
                     const gchar *key,
 
263
                     gdouble      expected) 
 
264
{
 
265
  GError *error = NULL;
 
266
  gdouble value;
 
267
 
 
268
  value = g_key_file_get_double (keyfile, group, key, &error);
 
269
  check_no_error (&error);
 
270
  g_assert_cmpfloat (value, ==, expected);
 
271
}
 
272
 
 
273
static void
 
274
check_name (const gchar *what,
 
275
            const gchar *value,
 
276
            const gchar *expected,
 
277
            gint         position)
 
278
{
 
279
  g_assert_cmpstr (value, ==, expected);
 
280
}
 
281
 
 
282
static void
 
283
check_length (const gchar *what,
 
284
              gint         n_items,
 
285
              gint         length,
 
286
              gint         expected)
 
287
{
 
288
  g_assert_cmpint (n_items, ==, length);
 
289
  g_assert_cmpint (n_items, ==, expected);
 
290
}
 
291
 
 
292
 
 
293
/* check that both \n and \r\n are accepted as line ends,
 
294
 * and that stray \r are passed through
 
295
 */
 
296
static void
 
297
test_line_ends (void)
 
298
{
 
299
  GKeyFile *keyfile;
 
300
 
 
301
  const gchar *data = 
 
302
    "[group1]\n"
 
303
    "key1=value1\n"
 
304
    "key2=value2\r\n"
 
305
    "[group2]\r\n"
 
306
    "key3=value3\r\r\n"
 
307
    "key4=value4\n";
 
308
 
 
309
  keyfile = load_data (data, 0);
 
310
 
 
311
  check_string_value (keyfile, "group1", "key1", "value1");
 
312
  check_string_value (keyfile, "group1", "key2", "value2");
 
313
  check_string_value (keyfile, "group2", "key3", "value3\r");
 
314
  check_string_value (keyfile, "group2", "key4", "value4");
 
315
 
 
316
  g_key_file_free (keyfile);
 
317
}
 
318
 
 
319
/* check handling of whitespace 
 
320
 */
 
321
static void
 
322
test_whitespace (void)
 
323
{
 
324
  GKeyFile *keyfile;
 
325
 
 
326
  const gchar *data = 
 
327
    "[group1]\n"
 
328
    "key1 = value1\n"
 
329
    "key2\t=\tvalue2\n"
 
330
    " [ group2 ] \n"
 
331
    "key3  =  value3  \n"
 
332
    "key4  =  value \t4\n"
 
333
    "  key5  =  value5\n";
 
334
  
 
335
  keyfile = load_data (data, 0);
 
336
 
 
337
  check_string_value (keyfile, "group1", "key1", "value1");
 
338
  check_string_value (keyfile, "group1", "key2", "value2");
 
339
  check_string_value (keyfile, " group2 ", "key3", "value3  ");
 
340
  check_string_value (keyfile, " group2 ", "key4", "value \t4");
 
341
  check_string_value (keyfile, " group2 ", "key5", "value5");
 
342
 
 
343
  g_key_file_free (keyfile);
 
344
}
 
345
 
 
346
/* check handling of comments
 
347
 */
 
348
static void
 
349
test_comments (void)
 
350
{
 
351
  GKeyFile *keyfile;
 
352
  gchar **names;
 
353
  gsize len;
 
354
  GError *error = NULL;
 
355
  gchar *comment;
 
356
 
 
357
  const gchar *data = 
 
358
    "# top comment\n"
 
359
    "# top comment, continued\n"
 
360
    "[group1]\n"
 
361
    "key1 = value1\n"
 
362
    "# key comment\n"
 
363
    "# key comment, continued\n"
 
364
    "key2 = value2\n"
 
365
    "# line end check\r\n"
 
366
    "key3 = value3\n"
 
367
    "key4 = value4\n"
 
368
    "# group comment\n"
 
369
    "# group comment, continued\n"
 
370
    "[group2]\n";
 
371
 
 
372
  const gchar *top_comment= " top comment\n top comment, continued\n";
 
373
  const gchar *group_comment= " group comment\n group comment, continued\n";
 
374
  const gchar *key_comment= " key comment\n key comment, continued\n";
 
375
  
 
376
  keyfile = load_data (data, 0);
 
377
 
 
378
  check_string_value (keyfile, "group1", "key1", "value1");
 
379
  check_string_value (keyfile, "group1", "key2", "value2");
 
380
  check_string_value (keyfile, "group1", "key3", "value3");
 
381
  check_string_value (keyfile, "group1", "key4", "value4");
 
382
 
 
383
  names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 
384
  check_no_error (&error);
 
385
 
 
386
  check_length ("keys", g_strv_length (names), len, 4);
 
387
  check_name ("key", names[0], "key1", 0);
 
388
  check_name ("key", names[1], "key2", 1);
 
389
  check_name ("key", names[2], "key3", 2);
 
390
  check_name ("key", names[3], "key4", 3);
 
391
 
 
392
  g_strfreev (names);
 
393
 
 
394
  g_key_file_free (keyfile);
 
395
 
 
396
  keyfile = load_data (data, G_KEY_FILE_KEEP_COMMENTS);
 
397
 
 
398
  names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 
399
  check_no_error (&error);
 
400
 
 
401
  check_length ("keys", g_strv_length (names), len, 4);
 
402
  check_name ("key", names[0], "key1", 0);
 
403
  check_name ("key", names[1], "key2", 1);
 
404
  check_name ("key", names[2], "key3", 2);
 
405
  check_name ("key", names[3], "key4", 3);
 
406
 
 
407
  g_strfreev (names);
 
408
 
 
409
  comment = g_key_file_get_comment (keyfile, NULL, NULL, &error);
 
410
  check_no_error (&error);
 
411
  check_name ("top comment", comment, top_comment, 0);
 
412
  g_free (comment);
 
413
 
 
414
  comment = g_key_file_get_comment (keyfile, "group1", "key2", &error);
 
415
  check_no_error (&error);
 
416
  check_name ("key comment", comment, key_comment, 0);
 
417
  g_free (comment);
 
418
 
 
419
  comment = g_key_file_get_comment (keyfile, "group2", NULL, &error);
 
420
  check_no_error (&error);
 
421
  check_name ("group comment", comment, group_comment, 0);
 
422
  g_free (comment);
 
423
 
 
424
  comment = g_key_file_get_comment (keyfile, "group3", NULL, &error);
 
425
  check_error (&error, 
 
426
               G_KEY_FILE_ERROR,
 
427
               G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 
428
  g_assert (comment == NULL);
 
429
 
 
430
  g_key_file_free (keyfile);
 
431
}
 
432
 
 
433
 
 
434
/* check key and group listing */
 
435
static void
 
436
test_listing (void)
 
437
{
 
438
  GKeyFile *keyfile;
 
439
  gchar **names;
 
440
  gsize len;
 
441
  gchar *start;
 
442
  GError *error = NULL;
 
443
 
 
444
  const gchar *data = 
 
445
    "[group1]\n"
 
446
    "key1=value1\n"
 
447
    "key2=value2\n"
 
448
    "[group2]\n"
 
449
    "key3=value3\n"
 
450
    "key4=value4\n";
 
451
  
 
452
  keyfile = load_data (data, 0);
 
453
 
 
454
  names = g_key_file_get_groups (keyfile, &len);
 
455
  g_assert (names != NULL);
 
456
 
 
457
  check_length ("groups", g_strv_length (names), len, 2);
 
458
  check_name ("group name", names[0], "group1", 0);
 
459
  check_name ("group name", names[1], "group2", 1);
 
460
  
 
461
  g_strfreev (names);
 
462
  
 
463
  names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 
464
  check_no_error (&error);
 
465
 
 
466
  check_length ("keys", g_strv_length (names), len, 2);
 
467
  check_name ("key", names[0], "key1", 0);
 
468
  check_name ("key", names[1], "key2", 1);
 
469
 
 
470
  g_strfreev (names);
 
471
 
 
472
  names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);
 
473
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 
474
 
 
475
  g_strfreev (names);
 
476
 
 
477
  g_assert (g_key_file_has_group (keyfile, "group1"));
 
478
  g_assert (g_key_file_has_group (keyfile, "group2"));
 
479
  g_assert (!g_key_file_has_group (keyfile, "group10"));
 
480
  g_assert (!g_key_file_has_group (keyfile, "group20"));
 
481
 
 
482
  start = g_key_file_get_start_group (keyfile);
 
483
  g_assert_cmpstr (start, ==, "group1");
 
484
  g_free (start);
 
485
 
 
486
  g_assert (g_key_file_has_key (keyfile, "group1", "key1", &error));
 
487
  check_no_error (&error);
 
488
  g_assert (g_key_file_has_key (keyfile, "group2", "key3", &error)); 
 
489
  check_no_error (&error);
 
490
  g_assert (!g_key_file_has_key (keyfile, "group2", "no-such-key", NULL)); 
 
491
  
 
492
  g_key_file_has_key (keyfile, "no-such-group", "key", &error);
 
493
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 
494
 
 
495
  g_key_file_free (keyfile);
 
496
}
 
497
 
 
498
/* check parsing of string values */
 
499
static void
 
500
test_string (void)
 
501
{
 
502
  GKeyFile *keyfile;
 
503
  GError *error = NULL;
 
504
  gchar *value;
 
505
 
 
506
  const gchar *data = 
 
507
    "[valid]\n"
 
508
    "key1=\\s\\n\\t\\r\\\\\n"
 
509
    "key2=\"quoted\"\n"
 
510
    "key3='quoted'\n"
 
511
    "key4=\xe2\x89\xa0\xe2\x89\xa0\n"
 
512
    "[invalid]\n"
 
513
    "key1=\\a\\b\\0800xff\n"
 
514
    "key2=blabla\\\n";
 
515
  
 
516
  keyfile = load_data (data, 0);
 
517
 
 
518
  check_string_value (keyfile, "valid", "key1", " \n\t\r\\");
 
519
  check_string_value (keyfile, "valid", "key2", "\"quoted\"");
 
520
  check_string_value (keyfile, "valid", "key3", "'quoted'");  
 
521
  check_string_value (keyfile, "valid", "key4", "\xe2\x89\xa0\xe2\x89\xa0");  
 
522
  
 
523
  value = g_key_file_get_string (keyfile, "invalid", "key1", &error);
 
524
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
525
  g_free (value);
 
526
 
 
527
  value = g_key_file_get_string (keyfile, "invalid", "key2", &error);
 
528
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
529
  g_free (value);
 
530
  
 
531
  g_key_file_free (keyfile);
 
532
}
 
533
 
 
534
/* check parsing of boolean values */
 
535
static void
 
536
test_boolean (void)
 
537
{
 
538
  GKeyFile *keyfile;
 
539
  GError *error = NULL;
 
540
 
 
541
  const gchar *data = 
 
542
    "[valid]\n"
 
543
    "key1=true\n"
 
544
    "key2=false\n"
 
545
    "key3=1\n"
 
546
    "key4=0\n"
 
547
    "[invalid]\n"
 
548
    "key1=t\n"
 
549
    "key2=f\n"
 
550
    "key3=yes\n"
 
551
    "key4=no\n";
 
552
  
 
553
  keyfile = load_data (data, 0);
 
554
 
 
555
  check_boolean_value (keyfile, "valid", "key1", TRUE);
 
556
  check_boolean_value (keyfile, "valid", "key2", FALSE);
 
557
  check_boolean_value (keyfile, "valid", "key3", TRUE);
 
558
  check_boolean_value (keyfile, "valid", "key4", FALSE);
 
559
 
 
560
  g_key_file_get_boolean (keyfile, "invalid", "key1", &error);
 
561
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
562
 
 
563
  g_key_file_get_boolean (keyfile, "invalid", "key2", &error);
 
564
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
565
 
 
566
  g_key_file_get_boolean (keyfile, "invalid", "key3", &error);
 
567
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
568
 
 
569
  g_key_file_get_boolean (keyfile, "invalid", "key4", &error);
 
570
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
571
 
 
572
  g_key_file_free (keyfile);
 
573
}
 
574
 
 
575
/* check parsing of integer and double values */
 
576
static void
 
577
test_number (void)
 
578
{
 
579
  GKeyFile *keyfile;
 
580
  GError *error = NULL;
 
581
 
 
582
  const gchar *data = 
 
583
    "[valid]\n"
 
584
    "key1=0\n"
 
585
    "key2=1\n"
 
586
    "key3=-1\n"
 
587
    "key4=2324431\n"
 
588
    "key5=-2324431\n"
 
589
    "key6=000111\n"
 
590
    "dkey1=000111\n"
 
591
    "dkey2=145.45\n"
 
592
    "dkey3=-3453.7\n"
 
593
    "[invalid]\n"
 
594
    "key1=0xffff\n"
 
595
    "key2=0.5\n"
 
596
    "key3=1e37\n"
 
597
    "key4=ten\n"
 
598
    "key5=\n"
 
599
    "key6=1.0.0\n"
 
600
    "key7=2x2\n"
 
601
    "key8=abc\n";
 
602
  
 
603
  keyfile = load_data (data, 0);
 
604
 
 
605
  check_integer_value (keyfile, "valid", "key1", 0);
 
606
  check_integer_value (keyfile, "valid", "key2", 1);
 
607
  check_integer_value (keyfile, "valid", "key3", -1);
 
608
  check_integer_value (keyfile, "valid", "key4", 2324431);
 
609
  check_integer_value (keyfile, "valid", "key5", -2324431);
 
610
  check_integer_value (keyfile, "valid", "key6", 111);
 
611
  check_double_value (keyfile, "valid", "dkey1", 111.0);
 
612
  check_double_value (keyfile, "valid", "dkey2", 145.45);
 
613
  check_double_value (keyfile, "valid", "dkey3", -3453.7);
 
614
 
 
615
  g_key_file_get_integer (keyfile, "invalid", "key1", &error);
 
616
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
617
 
 
618
  g_key_file_get_integer (keyfile, "invalid", "key2", &error);
 
619
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
620
 
 
621
  g_key_file_get_integer (keyfile, "invalid", "key3", &error);
 
622
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
623
 
 
624
  g_key_file_get_integer (keyfile, "invalid", "key4", &error);
 
625
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
626
 
 
627
  g_key_file_get_double (keyfile, "invalid", "key5", &error);
 
628
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
629
 
 
630
  g_key_file_get_double (keyfile, "invalid", "key6", &error);
 
631
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
632
 
 
633
  g_key_file_get_double (keyfile, "invalid", "key7", &error);
 
634
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
635
 
 
636
  g_key_file_get_double (keyfile, "invalid", "key8", &error);
 
637
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 
638
 
 
639
  g_key_file_free (keyfile);
 
640
}
 
641
 
 
642
/* check handling of translated strings */
 
643
static void
 
644
test_locale_string (void)
 
645
{
 
646
  GKeyFile *keyfile;
 
647
 
 
648
  const gchar *data = 
 
649
    "[valid]\n"
 
650
    "key1=v1\n"
 
651
    "key1[de]=v1-de\n"
 
652
    "key1[de_DE]=v1-de_DE\n"
 
653
    "key1[de_DE.UTF8]=v1-de_DE.UTF8\n"
 
654
    "key1[fr]=v1-fr\n"
 
655
    "key1[en] =v1-en\n"
 
656
    "key1[sr@Latn]=v1-sr\n";
 
657
  
 
658
  keyfile = load_data (data, G_KEY_FILE_KEEP_TRANSLATIONS);
 
659
 
 
660
  check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
 
661
  check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
 
662
  check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de_DE");
 
663
  check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de_DE.UTF8");
 
664
  check_locale_string_value (keyfile, "valid", "key1", "fr", "v1-fr");
 
665
  check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1-fr");
 
666
  check_locale_string_value (keyfile, "valid", "key1", "en", "v1-en");
 
667
  check_locale_string_value (keyfile, "valid", "key1", "sr@Latn", "v1-sr");
 
668
  
 
669
  g_key_file_free (keyfile);
 
670
 
 
671
  /* now test that translations are thrown away */
 
672
 
 
673
  g_setenv ("LANGUAGE", "de", TRUE);
 
674
  setlocale (LC_ALL, "");
 
675
 
 
676
  keyfile = load_data (data, 0);
 
677
 
 
678
  check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
 
679
  check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
 
680
  check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de");
 
681
  check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de");
 
682
  check_locale_string_value (keyfile, "valid", "key1", "fr", "v1");
 
683
  check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1");
 
684
  check_locale_string_value (keyfile, "valid", "key1", "en", "v1");
 
685
 
 
686
  g_key_file_free (keyfile);  
 
687
}
 
688
 
 
689
static void
 
690
test_lists (void)
 
691
{
 
692
  GKeyFile *keyfile;
 
693
 
 
694
  const gchar *data = 
 
695
    "[valid]\n"
 
696
    "key1=v1;v2\n"
 
697
    "key2=v1;v2;\n"
 
698
    "key3=v1,v2\n"
 
699
    "key4=v1\\;v2\n"
 
700
    "key5=true;false\n"
 
701
    "key6=1;0;-1\n"
 
702
    "key7= 1 ; 0 ; -1 \n"
 
703
    "key8=v1\\,v2\n"
 
704
    "key9=0;1.3456;-76532.456\n";
 
705
  
 
706
  keyfile = load_data (data, 0);
 
707
 
 
708
  check_string_list_value (keyfile, "valid", "key1", "v1", "v2", NULL);
 
709
  check_string_list_value (keyfile, "valid", "key2", "v1", "v2", NULL);
 
710
  check_string_list_value (keyfile, "valid", "key3", "v1,v2", NULL);
 
711
  check_string_list_value (keyfile, "valid", "key4", "v1;v2", NULL);
 
712
  check_boolean_list_value (keyfile, "valid", "key5", TRUE, FALSE, -100);
 
713
  check_integer_list_value (keyfile, "valid", "key6", 1, 0, -1, -100);
 
714
  check_double_list_value (keyfile, "valid", "key9", 0.0, 1.3456, -76532.456, -100.0);
 
715
  /* maybe these should be valid */
 
716
  /* check_integer_list_value (keyfile, "valid", "key7", 1, 0, -1, -100);*/
 
717
  /* check_string_list_value (keyfile, "valid", "key8", "v1\\,v2", NULL);*/
 
718
 
 
719
  g_key_file_free (keyfile);  
 
720
 
 
721
  /* Now check an alternate separator */
 
722
 
 
723
  keyfile = load_data (data, 0);
 
724
  g_key_file_set_list_separator (keyfile, ',');
 
725
 
 
726
  check_string_list_value (keyfile, "valid", "key1", "v1;v2", NULL);
 
727
  check_string_list_value (keyfile, "valid", "key2", "v1;v2;", NULL);
 
728
  check_string_list_value (keyfile, "valid", "key3", "v1", "v2", NULL);
 
729
 
 
730
  g_key_file_free (keyfile);  
 
731
}
 
732
 
 
733
static void
 
734
test_lists_set_get (void)
 
735
{
 
736
  GKeyFile *keyfile;
 
737
  static const char * const strings[] = { "v1", "v2" };
 
738
  static const char * const locale_strings[] = { "v1-l", "v2-l" };
 
739
  static int integers[] = { 1, -1, 2 };
 
740
  static gdouble doubles[] = { 3.14, 2.71 };
 
741
  
 
742
  keyfile = g_key_file_new ();
 
743
  g_key_file_set_string_list (keyfile, "group0", "key1", strings, G_N_ELEMENTS (strings));
 
744
  g_key_file_set_locale_string_list (keyfile, "group0", "key1", "de", locale_strings, G_N_ELEMENTS (locale_strings));
 
745
  g_key_file_set_integer_list (keyfile, "group0", "key2", integers, G_N_ELEMENTS (integers));
 
746
  g_key_file_set_double_list (keyfile, "group0", "key3", doubles, G_N_ELEMENTS (doubles));
 
747
 
 
748
  check_string_list_value (keyfile, "group0", "key1", strings[0], strings[1], NULL);
 
749
  check_locale_string_list_value (keyfile, "group0", "key1", "de", locale_strings[0], locale_strings[1], NULL);
 
750
  check_integer_list_value (keyfile, "group0", "key2", integers[0], integers[1], -100);
 
751
  check_double_list_value (keyfile, "group0", "key3", doubles[0], doubles[1], -100.0);
 
752
  g_key_file_free (keyfile);
 
753
 
 
754
  /* and again with a different list separator */
 
755
  keyfile = g_key_file_new ();
 
756
  g_key_file_set_list_separator (keyfile, ',');
 
757
  g_key_file_set_string_list (keyfile, "group0", "key1", strings, G_N_ELEMENTS (strings));
 
758
  g_key_file_set_locale_string_list (keyfile, "group0", "key1", "de", locale_strings, G_N_ELEMENTS (locale_strings));
 
759
  g_key_file_set_integer_list (keyfile, "group0", "key2", integers, G_N_ELEMENTS (integers));
 
760
  g_key_file_set_double_list (keyfile, "group0", "key3", doubles, G_N_ELEMENTS (doubles));
 
761
 
 
762
  check_string_list_value (keyfile, "group0", "key1", strings[0], strings[1], NULL);
 
763
  check_locale_string_list_value (keyfile, "group0", "key1", "de", locale_strings[0], locale_strings[1], NULL);
 
764
  check_integer_list_value (keyfile, "group0", "key2", integers[0], integers[1], -100);
 
765
  check_double_list_value (keyfile, "group0", "key3", doubles[0], doubles[1], -100.0);
 
766
  g_key_file_free (keyfile);
 
767
}
 
768
 
 
769
static void
 
770
test_group_remove (void)
 
771
{
 
772
  GKeyFile *keyfile;
 
773
  gchar **names;
 
774
  gsize len;
 
775
  GError *error = NULL;
 
776
 
 
777
  const gchar *data = 
 
778
    "[group1]\n"
 
779
    "[group2]\n"
 
780
    "key1=bla\n"
 
781
    "key2=bla\n"
 
782
    "[group3]\n"
 
783
    "key1=bla\n"
 
784
    "key2=bla\n";
 
785
  
 
786
  g_test_bug ("165887");
 
787
 
 
788
  keyfile = load_data (data, 0);
 
789
  
 
790
  names = g_key_file_get_groups (keyfile, &len);
 
791
  g_assert (names != NULL);
 
792
 
 
793
  check_length ("groups", g_strv_length (names), len, 3);
 
794
  check_name ("group name", names[0], "group1", 0);
 
795
  check_name ("group name", names[1], "group2", 1);
 
796
  check_name ("group name", names[2], "group3", 2);
 
797
 
 
798
  g_key_file_remove_group (keyfile, "group1", &error);
 
799
  check_no_error (&error);
 
800
  
 
801
  g_strfreev (names);
 
802
 
 
803
  names = g_key_file_get_groups (keyfile, &len);
 
804
  g_assert (names != NULL);
 
805
 
 
806
  check_length ("groups", g_strv_length (names), len, 2);
 
807
  check_name ("group name", names[0], "group2", 0);
 
808
  check_name ("group name", names[1], "group3", 1);
 
809
 
 
810
  g_key_file_remove_group (keyfile, "group2", &error);
 
811
  check_no_error (&error);
 
812
  
 
813
  g_strfreev (names);
 
814
 
 
815
  names = g_key_file_get_groups (keyfile, &len);
 
816
  g_assert (names != NULL);
 
817
 
 
818
  check_length ("groups", g_strv_length (names), len, 1);
 
819
  check_name ("group name", names[0], "group3", 0);
 
820
 
 
821
  g_key_file_remove_group (keyfile, "no such group", &error);
 
822
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 
823
 
 
824
  g_strfreev (names);
 
825
 
 
826
  g_key_file_free (keyfile);
 
827
}
 
828
 
 
829
static void 
 
830
test_key_remove (void)
 
831
{
 
832
  GKeyFile *keyfile;
 
833
  gchar *value;
 
834
  GError *error = NULL;
 
835
 
 
836
  const gchar *data = 
 
837
    "[group1]\n"
 
838
    "key1=bla\n"
 
839
    "key2=bla\n";
 
840
  
 
841
  g_test_bug ("165980");
 
842
  
 
843
  keyfile = load_data (data, 0);
 
844
  
 
845
  check_string_value (keyfile, "group1", "key1", "bla");
 
846
 
 
847
  g_key_file_remove_key (keyfile, "group1", "key1", &error);
 
848
  check_no_error (&error);
 
849
 
 
850
  value = g_key_file_get_string (keyfile, "group1", "key1", &error);
 
851
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
 
852
  g_free (value);
 
853
  
 
854
  g_key_file_remove_key (keyfile, "group1", "key1", &error);
 
855
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
 
856
 
 
857
  g_key_file_remove_key (keyfile, "no such group", "key1", &error);
 
858
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 
859
 
 
860
  g_key_file_free (keyfile);
 
861
}
 
862
 
 
863
 
 
864
static void
 
865
test_groups (void)
 
866
{
 
867
  GKeyFile *keyfile;
 
868
 
 
869
  const gchar *data = 
 
870
    "[1]\n"
 
871
    "key1=123\n"
 
872
    "[2]\n"
 
873
    "key2=123\n";
 
874
  
 
875
  g_test_bug ("316309");
 
876
 
 
877
  keyfile = load_data (data, 0);
 
878
 
 
879
  check_string_value (keyfile, "1", "key1", "123");
 
880
  check_string_value (keyfile, "2", "key2", "123");
 
881
 
 
882
  g_key_file_free (keyfile);  
 
883
}
 
884
 
 
885
static void
 
886
test_group_names (void)
 
887
{
 
888
  GKeyFile *keyfile;
 
889
  GError *error = NULL;
 
890
  const gchar *data;
 
891
  gchar *value;
 
892
 
 
893
  /* [ in group name */
 
894
  data = "[a[b]\n"
 
895
         "key1=123\n";
 
896
  keyfile = g_key_file_new ();
 
897
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
898
  g_key_file_free (keyfile);  
 
899
  check_error (&error, 
 
900
               G_KEY_FILE_ERROR,
 
901
               G_KEY_FILE_ERROR_PARSE);
 
902
 
 
903
  /* ] in group name */
 
904
  data = "[a]b]\n"
 
905
         "key1=123\n";
 
906
  keyfile = g_key_file_new ();
 
907
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
908
  g_key_file_free (keyfile);  
 
909
  check_error (&error, 
 
910
               G_KEY_FILE_ERROR,
 
911
               G_KEY_FILE_ERROR_PARSE);
 
912
 
 
913
  /* control char in group name */
 
914
  data = "[a\tb]\n"
 
915
         "key1=123\n";
 
916
  keyfile = g_key_file_new ();
 
917
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
918
  g_key_file_free (keyfile);  
 
919
  check_error (&error, 
 
920
               G_KEY_FILE_ERROR,
 
921
               G_KEY_FILE_ERROR_PARSE);
 
922
 
 
923
  /* empty group name */
 
924
  data = "[]\n"
 
925
         "key1=123\n";
 
926
  keyfile = g_key_file_new ();
 
927
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
928
  g_key_file_free (keyfile);  
 
929
  check_error (&error, 
 
930
               G_KEY_FILE_ERROR,
 
931
               G_KEY_FILE_ERROR_PARSE);
 
932
 
 
933
  /* Unicode in group name */
 
934
  data = "[\xc2\xbd]\n"
 
935
         "key1=123\n";
 
936
  keyfile = g_key_file_new ();
 
937
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
938
  g_key_file_free (keyfile);  
 
939
  check_no_error (&error);
 
940
 
 
941
  keyfile = g_key_file_new ();
 
942
  /*g_key_file_set_string (keyfile, "a[b", "key1", "123");*/
 
943
  value = g_key_file_get_string (keyfile, "a[b", "key1", &error);
 
944
  check_error (&error, 
 
945
               G_KEY_FILE_ERROR,
 
946
               G_KEY_FILE_ERROR_GROUP_NOT_FOUND);  
 
947
  g_key_file_free (keyfile);  
 
948
 
 
949
  keyfile = g_key_file_new ();
 
950
  /*g_key_file_set_string (keyfile, "a]b", "key1", "123");*/
 
951
  value = g_key_file_get_string (keyfile, "a]b", "key1", &error);
 
952
  check_error (&error, 
 
953
               G_KEY_FILE_ERROR,
 
954
               G_KEY_FILE_ERROR_GROUP_NOT_FOUND);  
 
955
  g_key_file_free (keyfile);  
 
956
 
 
957
  keyfile = g_key_file_new ();
 
958
  /*g_key_file_set_string (keyfile, "a\tb", "key1", "123");*/
 
959
  value = g_key_file_get_string (keyfile, "a\tb", "key1", &error);
 
960
  check_error (&error, 
 
961
               G_KEY_FILE_ERROR,
 
962
               G_KEY_FILE_ERROR_GROUP_NOT_FOUND);  
 
963
  g_key_file_free (keyfile);  
 
964
 
 
965
  keyfile = g_key_file_new ();
 
966
  g_key_file_set_string (keyfile, "\xc2\xbd", "key1", "123");
 
967
  check_string_value (keyfile, "\xc2\xbd", "key1", "123");
 
968
  g_key_file_free (keyfile);  
 
969
}
 
970
 
 
971
static void
 
972
test_key_names (void)
 
973
{
 
974
  GKeyFile *keyfile;
 
975
  GError *error = NULL;
 
976
  const gchar *data;
 
977
  gchar *value;
 
978
 
 
979
  /* [ in key name */
 
980
  data = "[a]\n"
 
981
         "key[=123\n";
 
982
  keyfile = g_key_file_new ();
 
983
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
984
  g_key_file_free (keyfile);  
 
985
  check_error (&error, 
 
986
               G_KEY_FILE_ERROR,
 
987
               G_KEY_FILE_ERROR_PARSE);
 
988
 
 
989
  /* empty key name */
 
990
  data = "[a]\n"
 
991
         " =123\n";
 
992
  keyfile = g_key_file_new ();
 
993
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
994
  g_key_file_free (keyfile);  
 
995
  check_error (&error, 
 
996
               G_KEY_FILE_ERROR,
 
997
               G_KEY_FILE_ERROR_PARSE);
 
998
 
 
999
  /* empty key name */
 
1000
  data = "[a]\n"
 
1001
         " [de] =123\n";
 
1002
  keyfile = g_key_file_new ();
 
1003
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1004
  g_key_file_free (keyfile);  
 
1005
  check_error (&error, 
 
1006
               G_KEY_FILE_ERROR,
 
1007
               G_KEY_FILE_ERROR_PARSE);
 
1008
 
 
1009
  /* bad locale suffix */
 
1010
  data = "[a]\n"
 
1011
         "foo[@#!&%]=123\n";
 
1012
  keyfile = g_key_file_new ();
 
1013
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1014
  g_key_file_free (keyfile);  
 
1015
  check_error (&error, 
 
1016
               G_KEY_FILE_ERROR,
 
1017
               G_KEY_FILE_ERROR_PARSE);
 
1018
 
 
1019
  /* initial space */
 
1020
  data = "[a]\n"
 
1021
         " foo=123\n";
 
1022
  keyfile = g_key_file_new ();
 
1023
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1024
  check_no_error (&error);
 
1025
  check_string_value (keyfile, "a", "foo", "123");
 
1026
  g_key_file_free (keyfile);  
 
1027
 
 
1028
  /* final space */
 
1029
  data = "[a]\n"
 
1030
         "foo =123\n";
 
1031
  keyfile = g_key_file_new ();
 
1032
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1033
  check_no_error (&error);
 
1034
  check_string_value (keyfile, "a", "foo", "123");
 
1035
  g_key_file_free (keyfile);  
 
1036
 
 
1037
  /* inner space */
 
1038
  data = "[a]\n"
 
1039
         "foo bar=123\n";
 
1040
  keyfile = g_key_file_new ();
 
1041
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1042
  check_no_error (&error);
 
1043
  check_string_value (keyfile, "a", "foo bar", "123");
 
1044
  g_key_file_free (keyfile);  
 
1045
 
 
1046
  /* inner space */
 
1047
  data = "[a]\n"
 
1048
         "foo [de] =123\n";
 
1049
  keyfile = g_key_file_new ();
 
1050
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1051
  check_error (&error, 
 
1052
               G_KEY_FILE_ERROR,
 
1053
               G_KEY_FILE_ERROR_PARSE);
 
1054
  g_key_file_free (keyfile);  
 
1055
 
 
1056
  /* control char in key name */
 
1057
  data = "[a]\n"
 
1058
         "key\tfoo=123\n";
 
1059
  keyfile = g_key_file_new ();
 
1060
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1061
  g_key_file_free (keyfile);  
 
1062
  check_no_error (&error);
 
1063
 
 
1064
  /* Unicode in key name */
 
1065
  data = "[a]\n"
 
1066
         "\xc2\xbd=123\n";
 
1067
  keyfile = g_key_file_new ();
 
1068
  g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 
1069
  g_key_file_free (keyfile);  
 
1070
  check_no_error (&error); 
 
1071
 
 
1072
  keyfile = g_key_file_new ();
 
1073
  g_key_file_set_string (keyfile, "a", "x", "123");
 
1074
  /*g_key_file_set_string (keyfile, "a", "key=", "123");*/
 
1075
  value = g_key_file_get_string (keyfile, "a", "key=", &error);
 
1076
  check_error (&error, 
 
1077
               G_KEY_FILE_ERROR,
 
1078
               G_KEY_FILE_ERROR_KEY_NOT_FOUND);  
 
1079
  g_key_file_free (keyfile);  
 
1080
 
 
1081
  keyfile = g_key_file_new ();
 
1082
  g_key_file_set_string (keyfile, "a", "x", "123");
 
1083
  /*g_key_file_set_string (keyfile, "a", "key[", "123");*/
 
1084
  value = g_key_file_get_string (keyfile, "a", "key[", &error);
 
1085
  check_error (&error, 
 
1086
               G_KEY_FILE_ERROR,
 
1087
               G_KEY_FILE_ERROR_KEY_NOT_FOUND);  
 
1088
  g_key_file_free (keyfile);  
 
1089
 
 
1090
  keyfile = g_key_file_new ();
 
1091
  g_key_file_set_string (keyfile, "a", "x", "123");
 
1092
  g_key_file_set_string (keyfile, "a", "key\tfoo", "123");
 
1093
  value = g_key_file_get_string (keyfile, "a", "key\tfoo", &error);
 
1094
  check_no_error (&error);
 
1095
  g_key_file_free (keyfile);  
 
1096
 
 
1097
  keyfile = g_key_file_new ();
 
1098
  g_key_file_set_string (keyfile, "a", "x", "123");
 
1099
  /*g_key_file_set_string (keyfile, "a", " key", "123");*/
 
1100
  value = g_key_file_get_string (keyfile, "a", " key", &error);
 
1101
  check_error (&error, 
 
1102
               G_KEY_FILE_ERROR,
 
1103
               G_KEY_FILE_ERROR_KEY_NOT_FOUND);  
 
1104
  g_key_file_free (keyfile);  
 
1105
 
 
1106
  keyfile = g_key_file_new ();
 
1107
  g_key_file_set_string (keyfile, "a", "x", "123");
 
1108
 
 
1109
  /* Unicode key */
 
1110
  g_key_file_set_string (keyfile, "a", "\xc2\xbd", "123");
 
1111
  check_string_value (keyfile, "a", "\xc2\xbd", "123");
 
1112
 
 
1113
  /* Keys with / + . (as used by the gnome-vfs mime cache) */
 
1114
  g_key_file_set_string (keyfile, "a", "foo/bar", "/");
 
1115
  check_string_value (keyfile, "a", "foo/bar", "/");
 
1116
  g_key_file_set_string (keyfile, "a", "foo+bar", "+");
 
1117
  check_string_value (keyfile, "a", "foo+bar", "+");
 
1118
  g_key_file_set_string (keyfile, "a", "foo.bar", ".");
 
1119
  check_string_value (keyfile, "a", "foo.bar", ".");
 
1120
 
 
1121
  g_key_file_free (keyfile);  
 
1122
}
 
1123
 
 
1124
static void
 
1125
test_duplicate_keys (void)
 
1126
{
 
1127
  GKeyFile *keyfile;
 
1128
  const gchar *data = 
 
1129
    "[1]\n"
 
1130
    "key1=123\n"
 
1131
    "key1=345\n";
 
1132
 
 
1133
  keyfile = load_data (data, 0);
 
1134
  check_string_value (keyfile, "1", "key1", "345");
 
1135
 
 
1136
  g_key_file_free (keyfile);  
 
1137
}
 
1138
 
 
1139
static void
 
1140
test_duplicate_groups (void)
 
1141
{
 
1142
  GKeyFile *keyfile;
 
1143
  const gchar *data = 
 
1144
    "[Desktop Entry]\n"
 
1145
    "key1=123\n"
 
1146
    "[Desktop Entry]\n"
 
1147
    "key2=123\n";
 
1148
  
 
1149
  g_test_bug ("157877");
 
1150
 
 
1151
  keyfile = load_data (data, 0);
 
1152
  check_string_value (keyfile, "Desktop Entry", "key1", "123");
 
1153
  check_string_value (keyfile, "Desktop Entry", "key2", "123");
 
1154
 
 
1155
  g_key_file_free (keyfile);  
 
1156
}
 
1157
 
 
1158
static void
 
1159
test_duplicate_groups2 (void)
 
1160
{
 
1161
  GKeyFile *keyfile;
 
1162
  const gchar *data = 
 
1163
    "[A]\n"
 
1164
    "foo=bar\n"
 
1165
    "[B]\n"
 
1166
    "foo=baz\n"
 
1167
    "[A]\n"
 
1168
    "foo=bang\n";
 
1169
  
 
1170
  g_test_bug ("385910");
 
1171
 
 
1172
  keyfile = load_data (data, 0);
 
1173
  check_string_value (keyfile, "A", "foo", "bang");
 
1174
  check_string_value (keyfile, "B", "foo", "baz");
 
1175
 
 
1176
  g_key_file_free (keyfile);  
 
1177
}
 
1178
 
 
1179
static void
 
1180
test_reload_idempotency (void)
 
1181
{
 
1182
  static const gchar *original_data=""
 
1183
    "# Top comment\n"
 
1184
    "\n"
 
1185
    "# First comment\n"
 
1186
    "[first]\n"
 
1187
    "key=value\n"
 
1188
    "# A random comment in the first group\n"
 
1189
    "anotherkey=anothervalue\n"
 
1190
    "# Second comment - one line\n"
 
1191
    "[second]\n"
 
1192
    "# Third comment - two lines\n"
 
1193
    "# Third comment - two lines\n"
 
1194
    "[third]\n"
 
1195
    "blank_line=1\n"
 
1196
    "\n"
 
1197
    "blank_lines=2\n"
 
1198
    "\n\n"
 
1199
    "[fourth]\n"
 
1200
    "[fifth]\n";
 
1201
  GKeyFile *keyfile;
 
1202
  GError *error = NULL;
 
1203
  gchar *data1, *data2;
 
1204
  gsize len1, len2;
 
1205
 
 
1206
  g_test_bug ("420686");
 
1207
 
 
1208
  /* check that we only insert a single new line between groups */
 
1209
  keyfile = g_key_file_new ();
 
1210
  g_key_file_load_from_data (keyfile,
 
1211
                             original_data, strlen(original_data),
 
1212
                             G_KEY_FILE_KEEP_COMMENTS,
 
1213
                             &error);
 
1214
  check_no_error (&error);
 
1215
 
 
1216
  data1 = g_key_file_to_data (keyfile, &len1, &error);
 
1217
  g_assert (data1 != NULL);
 
1218
  g_key_file_free (keyfile);
 
1219
 
 
1220
  keyfile = g_key_file_new ();
 
1221
  g_key_file_load_from_data (keyfile,
 
1222
                             data1, len1,
 
1223
                             G_KEY_FILE_KEEP_COMMENTS,
 
1224
                             &error);
 
1225
  check_no_error (&error);
 
1226
 
 
1227
  data2 = g_key_file_to_data (keyfile, &len2, &error);
 
1228
  g_assert (data2 != NULL);
 
1229
  g_key_file_free (keyfile);
 
1230
 
 
1231
  g_assert_cmpstr (data1, ==, data2);
 
1232
 
 
1233
  g_free (data2);
 
1234
  g_free (data1);
 
1235
}
 
1236
 
 
1237
int
 
1238
main (int argc, char *argv[])
 
1239
{
 
1240
  g_test_init (&argc, &argv, NULL);
 
1241
  g_test_bug_base ("http://bugzilla.gnome.org/");
 
1242
 
 
1243
  g_test_add_func ("/keyfile/line-ends", test_line_ends);
 
1244
  g_test_add_func ("/keyfile/whitespace", test_whitespace);
 
1245
  g_test_add_func ("/keyfile/comments", test_comments);
 
1246
  g_test_add_func ("/keyfile/listing", test_listing);
 
1247
  g_test_add_func ("/keyfile/string", test_string);
 
1248
  g_test_add_func ("/keyfile/boolean", test_boolean);
 
1249
  g_test_add_func ("/keyfile/number", test_number);
 
1250
  g_test_add_func ("/keyfile/locale-string", test_locale_string);
 
1251
  g_test_add_func ("/keyfile/lists", test_lists);
 
1252
  g_test_add_func ("/keyfile/lists-set-get", test_lists_set_get);
 
1253
  g_test_add_func ("/keyfile/group-remove", test_group_remove);
 
1254
  g_test_add_func ("/keyfile/key-remove", test_key_remove);
 
1255
  g_test_add_func ("/keyfile/groups", test_groups);
 
1256
  g_test_add_func ("/keyfile/duplicate-keys", test_duplicate_keys);
 
1257
  g_test_add_func ("/keyfile/duplicate-groups", test_duplicate_groups);
 
1258
  g_test_add_func ("/keyfile/duplicate-groups2", test_duplicate_groups2);
 
1259
  g_test_add_func ("/keyfile/group-names", test_group_names);
 
1260
  g_test_add_func ("/keyfile/key-names", test_key_names);
 
1261
  g_test_add_func ("/keyfile/reload", test_reload_idempotency);
 
1262
  
 
1263
  return g_test_run ();
 
1264
}