|
31
|
1 |
/* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. */
|
|
|
2 |
#include <glib.h>
|
|
|
3 |
#include <locale.h>
|
|
|
4 |
#include <string.h>
|
|
|
5 |
#include <stdlib.h>
|
|
|
6 |
#include <stdio.h>
|
|
|
7 |
|
|
|
8 |
#ifdef SYMBIAN
|
|
|
9 |
#include "mrt2_glib2_test.h"
|
|
|
10 |
#endif /*SYMBIAN*/
|
|
|
11 |
|
|
|
12 |
|
|
|
13 |
static GKeyFile *
|
|
|
14 |
load_data (const gchar *data,
|
|
|
15 |
GKeyFileFlags flags)
|
|
|
16 |
{
|
|
|
17 |
GKeyFile *keyfile;
|
|
|
18 |
GError *error = NULL;
|
|
|
19 |
|
|
|
20 |
keyfile = g_key_file_new ();
|
|
|
21 |
g_key_file_load_from_data (keyfile, data, -1, flags, &error);
|
|
|
22 |
if (error)
|
|
|
23 |
{
|
|
|
24 |
g_print ("Could not load data: %s\n", error->message);
|
|
|
25 |
|
|
|
26 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
27 |
|
|
|
28 |
#ifdef SYMBIAN
|
|
|
29 |
testResultXml("keyfile-test");
|
|
|
30 |
#endif /* EMULATOR */
|
|
|
31 |
|
|
|
32 |
exit (1);
|
|
|
33 |
}
|
|
|
34 |
|
|
|
35 |
return keyfile;
|
|
|
36 |
}
|
|
|
37 |
|
|
|
38 |
static void
|
|
|
39 |
check_error (GError **error,
|
|
|
40 |
GQuark domain,
|
|
|
41 |
gint code)
|
|
|
42 |
{
|
|
|
43 |
if (*error == NULL)
|
|
|
44 |
{
|
|
|
45 |
g_print ("Missing an error\n");
|
|
|
46 |
|
|
|
47 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
48 |
|
|
|
49 |
#ifdef SYMBIAN
|
|
|
50 |
testResultXml("keyfile-test");
|
|
|
51 |
#endif /* EMULATOR */
|
|
|
52 |
|
|
|
53 |
exit (1);
|
|
|
54 |
}
|
|
|
55 |
|
|
|
56 |
if ((*error)->domain != domain)
|
|
|
57 |
{
|
|
|
58 |
g_print ("Wrong error domain: got %s, expected %s\n",
|
|
|
59 |
g_quark_to_string ((*error)->domain),
|
|
|
60 |
g_quark_to_string (domain));
|
|
|
61 |
|
|
|
62 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
63 |
|
|
|
64 |
#ifdef SYMBIAN
|
|
|
65 |
testResultXml("keyfile-test");
|
|
|
66 |
#endif /* EMULATOR */
|
|
|
67 |
|
|
|
68 |
exit (1);
|
|
|
69 |
}
|
|
|
70 |
|
|
|
71 |
if ((*error)->code != code)
|
|
|
72 |
{
|
|
|
73 |
g_print ("Wrong error code: got %d, expected %d\n",
|
|
|
74 |
(*error)->code, code);
|
|
|
75 |
|
|
|
76 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
77 |
|
|
|
78 |
#ifdef SYMBIAN
|
|
|
79 |
testResultXml("keyfile-test");
|
|
|
80 |
#endif /* EMULATOR */
|
|
|
81 |
|
|
|
82 |
exit (1);
|
|
|
83 |
}
|
|
|
84 |
|
|
|
85 |
g_error_free (*error);
|
|
|
86 |
*error = NULL;
|
|
|
87 |
}
|
|
|
88 |
|
|
|
89 |
static void
|
|
|
90 |
check_no_error (GError **error)
|
|
|
91 |
{
|
|
|
92 |
if (*error != NULL)
|
|
|
93 |
{
|
|
|
94 |
g_print ("Unexpected error: (%s, %d) %s\n",
|
|
|
95 |
g_quark_to_string ((*error)->domain),
|
|
|
96 |
(*error)->code, (*error)->message);
|
|
|
97 |
|
|
|
98 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
99 |
|
|
|
100 |
#ifdef SYMBIAN
|
|
|
101 |
testResultXml("keyfile-test");
|
|
|
102 |
#endif /* EMULATOR */
|
|
|
103 |
|
|
|
104 |
exit (1);
|
|
|
105 |
}
|
|
|
106 |
}
|
|
|
107 |
|
|
|
108 |
static void
|
|
|
109 |
check_string_value (GKeyFile *keyfile,
|
|
|
110 |
const gchar *group,
|
|
|
111 |
const gchar *key,
|
|
|
112 |
const gchar *expected)
|
|
|
113 |
{
|
|
|
114 |
GError *error = NULL;
|
|
|
115 |
gchar *value;
|
|
|
116 |
|
|
|
117 |
value = g_key_file_get_string (keyfile, group, key, &error);
|
|
|
118 |
check_no_error (&error);
|
|
|
119 |
g_assert (value != NULL);
|
|
|
120 |
|
|
|
121 |
if (strcmp (value, expected) != 0)
|
|
|
122 |
{
|
|
|
123 |
g_print ("Group %s key %s: "
|
|
|
124 |
"expected string value '%s', actual value '%s'\n",
|
|
|
125 |
group, key, expected, value);
|
|
|
126 |
|
|
|
127 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
128 |
|
|
|
129 |
#ifdef SYMBIAN
|
|
|
130 |
testResultXml("keyfile-test");
|
|
|
131 |
#endif /* EMULATOR */
|
|
|
132 |
|
|
|
133 |
exit (1);
|
|
|
134 |
}
|
|
|
135 |
|
|
|
136 |
g_free (value);
|
|
|
137 |
}
|
|
|
138 |
|
|
|
139 |
static void
|
|
|
140 |
check_locale_string_value (GKeyFile *keyfile,
|
|
|
141 |
const gchar *group,
|
|
|
142 |
const gchar *key,
|
|
|
143 |
const gchar *locale,
|
|
|
144 |
const gchar *expected)
|
|
|
145 |
{
|
|
|
146 |
GError *error = NULL;
|
|
|
147 |
gchar *value;
|
|
|
148 |
|
|
|
149 |
value = g_key_file_get_locale_string (keyfile, group, key, locale, &error);
|
|
|
150 |
check_no_error (&error);
|
|
|
151 |
g_assert (value != NULL);
|
|
|
152 |
|
|
|
153 |
if (strcmp (value, expected) != 0)
|
|
|
154 |
{
|
|
|
155 |
g_print ("Group %s key %s locale %s: "
|
|
|
156 |
"expected string value '%s', actual value '%s'\n",
|
|
|
157 |
group, key, locale, expected, value);
|
|
|
158 |
|
|
|
159 |
|
|
|
160 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
161 |
|
|
|
162 |
#ifdef SYMBIAN
|
|
|
163 |
testResultXml("keyfile-test");
|
|
|
164 |
#endif /* EMULATOR */
|
|
|
165 |
|
|
|
166 |
exit (1);
|
|
|
167 |
}
|
|
|
168 |
|
|
|
169 |
g_free (value);
|
|
|
170 |
}
|
|
|
171 |
|
|
|
172 |
static void
|
|
|
173 |
check_string_list_value (GKeyFile *keyfile,
|
|
|
174 |
const gchar *group,
|
|
|
175 |
const gchar *key,
|
|
|
176 |
...)
|
|
|
177 |
{
|
|
|
178 |
gint i;
|
|
|
179 |
gchar *v, **value;
|
|
|
180 |
va_list args;
|
|
|
181 |
gsize len;
|
|
|
182 |
GError *error = NULL;
|
|
|
183 |
|
|
|
184 |
value = g_key_file_get_string_list (keyfile, group, key, &len, &error);
|
|
|
185 |
check_no_error (&error);
|
|
|
186 |
g_assert (value != NULL);
|
|
|
187 |
|
|
|
188 |
va_start (args, key);
|
|
|
189 |
i = 0;
|
|
|
190 |
v = va_arg (args, gchar*);
|
|
|
191 |
while (v)
|
|
|
192 |
{
|
|
|
193 |
if (value[i] == NULL)
|
|
|
194 |
{
|
|
|
195 |
g_print ("Group %s key %s: list too short (%d)\n",
|
|
|
196 |
group, key, i);
|
|
|
197 |
|
|
|
198 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
199 |
|
|
|
200 |
#ifdef SYMBIAN
|
|
|
201 |
testResultXml("keyfile-test");
|
|
|
202 |
#endif /* EMULATOR */
|
|
|
203 |
|
|
|
204 |
exit (1);
|
|
|
205 |
}
|
|
|
206 |
if (strcmp (v, value[i]) != 0)
|
|
|
207 |
{
|
|
|
208 |
g_print ("Group %s key %s: mismatch at %d, expected %s, got %s\n",
|
|
|
209 |
group, key, i, v, value[i]);
|
|
|
210 |
|
|
|
211 |
|
|
|
212 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
213 |
|
|
|
214 |
#ifdef SYMBIAN
|
|
|
215 |
testResultXml("keyfile-test");
|
|
|
216 |
#endif /* EMULATOR */
|
|
|
217 |
|
|
|
218 |
exit (1);
|
|
|
219 |
}
|
|
|
220 |
|
|
|
221 |
i++;
|
|
|
222 |
v = va_arg (args, gchar*);
|
|
|
223 |
}
|
|
|
224 |
|
|
|
225 |
va_end (args);
|
|
|
226 |
|
|
|
227 |
g_strfreev (value);
|
|
|
228 |
}
|
|
|
229 |
|
|
|
230 |
static void
|
|
|
231 |
check_integer_list_value (GKeyFile *keyfile,
|
|
|
232 |
const gchar *group,
|
|
|
233 |
const gchar *key,
|
|
|
234 |
...)
|
|
|
235 |
{
|
|
|
236 |
gint i;
|
|
|
237 |
gint v, *value;
|
|
|
238 |
va_list args;
|
|
|
239 |
gsize len;
|
|
|
240 |
GError *error = NULL;
|
|
|
241 |
|
|
|
242 |
value = g_key_file_get_integer_list (keyfile, group, key, &len, &error);
|
|
|
243 |
check_no_error (&error);
|
|
|
244 |
g_assert (value != NULL);
|
|
|
245 |
|
|
|
246 |
va_start (args, key);
|
|
|
247 |
i = 0;
|
|
|
248 |
v = va_arg (args, gint);
|
|
|
249 |
while (v != -100)
|
|
|
250 |
{
|
|
|
251 |
if (i == len)
|
|
|
252 |
{
|
|
|
253 |
g_print ("Group %s key %s: list too short (%d)\n",
|
|
|
254 |
group, key, i);
|
|
|
255 |
|
|
|
256 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
257 |
|
|
|
258 |
#ifdef SYMBIAN
|
|
|
259 |
testResultXml("keyfile-test");
|
|
|
260 |
#endif /* EMULATOR */
|
|
|
261 |
|
|
|
262 |
exit (1);
|
|
|
263 |
}
|
|
|
264 |
if (value[i] != v)
|
|
|
265 |
{
|
|
|
266 |
g_print ("Group %s key %s: mismatch at %d, expected %d, got %d\n",
|
|
|
267 |
group, key, i, v, value[i]);
|
|
|
268 |
|
|
|
269 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
270 |
|
|
|
271 |
#ifdef SYMBIAN
|
|
|
272 |
testResultXml("keyfile-test");
|
|
|
273 |
#endif /* EMULATOR */
|
|
|
274 |
|
|
|
275 |
exit (1);
|
|
|
276 |
}
|
|
|
277 |
|
|
|
278 |
i++;
|
|
|
279 |
v = va_arg (args, gint);
|
|
|
280 |
}
|
|
|
281 |
|
|
|
282 |
va_end (args);
|
|
|
283 |
|
|
|
284 |
g_free (value);
|
|
|
285 |
}
|
|
|
286 |
|
|
|
287 |
static void
|
|
|
288 |
check_boolean_list_value (GKeyFile *keyfile,
|
|
|
289 |
const gchar *group,
|
|
|
290 |
const gchar *key,
|
|
|
291 |
...)
|
|
|
292 |
{
|
|
|
293 |
gint i;
|
|
|
294 |
gboolean v, *value;
|
|
|
295 |
va_list args;
|
|
|
296 |
gsize len;
|
|
|
297 |
GError *error = NULL;
|
|
|
298 |
|
|
|
299 |
value = g_key_file_get_boolean_list (keyfile, group, key, &len, &error);
|
|
|
300 |
check_no_error (&error);
|
|
|
301 |
g_assert (value != NULL);
|
|
|
302 |
|
|
|
303 |
va_start (args, key);
|
|
|
304 |
i = 0;
|
|
|
305 |
v = va_arg (args, gboolean);
|
|
|
306 |
while (v != -100)
|
|
|
307 |
{
|
|
|
308 |
if (i == len)
|
|
|
309 |
{
|
|
|
310 |
g_print ("Group %s key %s: list too short (%d)\n",
|
|
|
311 |
group, key, i);
|
|
|
312 |
|
|
|
313 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
314 |
|
|
|
315 |
#ifdef SYMBIAN
|
|
|
316 |
testResultXml("keyfile-test");
|
|
|
317 |
#endif /* EMULATOR */
|
|
|
318 |
|
|
|
319 |
exit (1);
|
|
|
320 |
}
|
|
|
321 |
if (value[i] != v)
|
|
|
322 |
{
|
|
|
323 |
g_print ("Group %s key %s: mismatch at %d, expected %d, got %d\n",
|
|
|
324 |
group, key, i, v, value[i]);
|
|
|
325 |
|
|
|
326 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
327 |
|
|
|
328 |
#ifdef SYMBIAN
|
|
|
329 |
testResultXml("keyfile-test");
|
|
|
330 |
#endif /* EMULATOR */
|
|
|
331 |
|
|
|
332 |
exit (1);
|
|
|
333 |
}
|
|
|
334 |
|
|
|
335 |
i++;
|
|
|
336 |
v = va_arg (args, gboolean);
|
|
|
337 |
}
|
|
|
338 |
|
|
|
339 |
va_end (args);
|
|
|
340 |
|
|
|
341 |
g_free (value);
|
|
|
342 |
}
|
|
|
343 |
|
|
|
344 |
static void
|
|
|
345 |
check_boolean_value (GKeyFile *keyfile,
|
|
|
346 |
const gchar *group,
|
|
|
347 |
const gchar *key,
|
|
|
348 |
gboolean expected)
|
|
|
349 |
{
|
|
|
350 |
GError *error = NULL;
|
|
|
351 |
gboolean value;
|
|
|
352 |
|
|
|
353 |
value = g_key_file_get_boolean (keyfile, group, key, &error);
|
|
|
354 |
check_no_error (&error);
|
|
|
355 |
|
|
|
356 |
if (value != expected)
|
|
|
357 |
{
|
|
|
358 |
g_print ("Group %s key %s: "
|
|
|
359 |
"expected boolean value '%s', actual value '%s'\n",
|
|
|
360 |
group, key,
|
|
|
361 |
expected ? "true" : "false",
|
|
|
362 |
value ? "true" : "false");
|
|
|
363 |
|
|
|
364 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
365 |
|
|
|
366 |
#ifdef SYMBIAN
|
|
|
367 |
testResultXml("keyfile-test");
|
|
|
368 |
#endif /* EMULATOR */
|
|
|
369 |
|
|
|
370 |
exit (1);
|
|
|
371 |
}
|
|
|
372 |
}
|
|
|
373 |
|
|
|
374 |
static void
|
|
|
375 |
check_integer_value (GKeyFile *keyfile,
|
|
|
376 |
const gchar *group,
|
|
|
377 |
const gchar *key,
|
|
|
378 |
gint expected)
|
|
|
379 |
{
|
|
|
380 |
GError *error = NULL;
|
|
|
381 |
gint value;
|
|
|
382 |
|
|
|
383 |
value = g_key_file_get_integer (keyfile, group, key, &error);
|
|
|
384 |
check_no_error (&error);
|
|
|
385 |
|
|
|
386 |
if (value != expected)
|
|
|
387 |
{
|
|
|
388 |
g_print ("Group %s key %s: "
|
|
|
389 |
"expected integer value %d, actual value %d\n",
|
|
|
390 |
group, key, expected, value);
|
|
|
391 |
|
|
|
392 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
393 |
|
|
|
394 |
#ifdef SYMBIAN
|
|
|
395 |
testResultXml("keyfile-test");
|
|
|
396 |
#endif /* EMULATOR */
|
|
|
397 |
|
|
|
398 |
exit (1);
|
|
|
399 |
}
|
|
|
400 |
}
|
|
|
401 |
|
|
|
402 |
static void
|
|
|
403 |
check_name (const gchar *what,
|
|
|
404 |
const gchar *value,
|
|
|
405 |
const gchar *expected,
|
|
|
406 |
gint position)
|
|
|
407 |
{
|
|
|
408 |
if (!value || strcmp (expected, value) != 0)
|
|
|
409 |
{
|
|
|
410 |
g_print ("Wrong %s returned: got '%s' at %d, expected '%s'\n",
|
|
|
411 |
what, value, position, expected);
|
|
|
412 |
|
|
|
413 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
414 |
|
|
|
415 |
#ifdef SYMBIAN
|
|
|
416 |
testResultXml("keyfile-test");
|
|
|
417 |
#endif /* EMULATOR */
|
|
|
418 |
|
|
|
419 |
exit (1);
|
|
|
420 |
}
|
|
|
421 |
}
|
|
|
422 |
|
|
|
423 |
static void
|
|
|
424 |
check_length (const gchar *what,
|
|
|
425 |
gint n_items,
|
|
|
426 |
gint length,
|
|
|
427 |
gint expected)
|
|
|
428 |
{
|
|
|
429 |
if (n_items != length || length != expected)
|
|
|
430 |
{
|
|
|
431 |
g_print ("Wrong number of %s returned: got %d items, length %d, expected %d\n",
|
|
|
432 |
what, n_items, length, expected);
|
|
|
433 |
|
|
|
434 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
435 |
|
|
|
436 |
#ifdef SYMBIAN
|
|
|
437 |
testResultXml("keyfile-test");
|
|
|
438 |
#endif /* EMULATOR */
|
|
|
439 |
|
|
|
440 |
exit (1);
|
|
|
441 |
}
|
|
|
442 |
}
|
|
|
443 |
|
|
|
444 |
|
|
|
445 |
/* check that both \n and \r\n are accepted as line ends,
|
|
|
446 |
* and that stray \r are passed through
|
|
|
447 |
*/
|
|
|
448 |
static void
|
|
|
449 |
test_line_ends (void)
|
|
|
450 |
{
|
|
|
451 |
GKeyFile *keyfile;
|
|
|
452 |
|
|
|
453 |
const gchar *data =
|
|
|
454 |
"[group1]\n"
|
|
|
455 |
"key1=value1\n"
|
|
|
456 |
"key2=value2\r\n"
|
|
|
457 |
"[group2]\r\n"
|
|
|
458 |
"key3=value3\r\r\n"
|
|
|
459 |
"key4=value4\n";
|
|
|
460 |
|
|
|
461 |
keyfile = load_data (data, 0);
|
|
|
462 |
|
|
|
463 |
check_string_value (keyfile, "group1", "key1", "value1");
|
|
|
464 |
check_string_value (keyfile, "group1", "key2", "value2");
|
|
|
465 |
check_string_value (keyfile, "group2", "key3", "value3\r");
|
|
|
466 |
check_string_value (keyfile, "group2", "key4", "value4");
|
|
|
467 |
|
|
|
468 |
g_key_file_free (keyfile);
|
|
|
469 |
}
|
|
|
470 |
|
|
|
471 |
/* check handling of whitespace
|
|
|
472 |
*/
|
|
|
473 |
static void
|
|
|
474 |
test_whitespace (void)
|
|
|
475 |
{
|
|
|
476 |
GKeyFile *keyfile;
|
|
|
477 |
|
|
|
478 |
const gchar *data =
|
|
|
479 |
"[group1]\n"
|
|
|
480 |
"key1 = value1\n"
|
|
|
481 |
"key2\t=\tvalue2\n"
|
|
|
482 |
" [ group2 ] \n"
|
|
|
483 |
"key3 = value3 \n"
|
|
|
484 |
"key4 = value \t4\n"
|
|
|
485 |
" key5 = value5\n";
|
|
|
486 |
|
|
|
487 |
keyfile = load_data (data, 0);
|
|
|
488 |
|
|
|
489 |
check_string_value (keyfile, "group1", "key1", "value1");
|
|
|
490 |
check_string_value (keyfile, "group1", "key2", "value2");
|
|
|
491 |
check_string_value (keyfile, " group2 ", "key3", "value3 ");
|
|
|
492 |
check_string_value (keyfile, " group2 ", "key4", "value \t4");
|
|
|
493 |
check_string_value (keyfile, " group2 ", "key5", "value5");
|
|
|
494 |
|
|
|
495 |
g_key_file_free (keyfile);
|
|
|
496 |
}
|
|
|
497 |
|
|
|
498 |
/* check handling of comments
|
|
|
499 |
*/
|
|
|
500 |
static void
|
|
|
501 |
test_comments (void)
|
|
|
502 |
{
|
|
|
503 |
GKeyFile *keyfile;
|
|
|
504 |
gchar **names;
|
|
|
505 |
gsize len;
|
|
|
506 |
GError *error = NULL;
|
|
|
507 |
gchar *comment;
|
|
|
508 |
|
|
|
509 |
const gchar *data =
|
|
|
510 |
"# top comment\n"
|
|
|
511 |
"# top comment, continued\n"
|
|
|
512 |
"[group1]\n"
|
|
|
513 |
"key1 = value1\n"
|
|
|
514 |
"# key comment\n"
|
|
|
515 |
"# key comment, continued\n"
|
|
|
516 |
"key2 = value2\n"
|
|
|
517 |
"# line end check\r\n"
|
|
|
518 |
"key3 = value3\n"
|
|
|
519 |
"key4 = value4\n"
|
|
|
520 |
"# group comment\n"
|
|
|
521 |
"# group comment, continued\n"
|
|
|
522 |
"[group2]\n";
|
|
|
523 |
|
|
|
524 |
const gchar *top_comment= " top comment\n top comment, continued\n";
|
|
|
525 |
const gchar *group_comment= " group comment\n group comment, continued\n";
|
|
|
526 |
const gchar *key_comment= " key comment\n key comment, continued\n";
|
|
|
527 |
|
|
|
528 |
keyfile = load_data (data, 0);
|
|
|
529 |
|
|
|
530 |
check_string_value (keyfile, "group1", "key1", "value1");
|
|
|
531 |
check_string_value (keyfile, "group1", "key2", "value2");
|
|
|
532 |
check_string_value (keyfile, "group1", "key3", "value3");
|
|
|
533 |
check_string_value (keyfile, "group1", "key4", "value4");
|
|
|
534 |
|
|
|
535 |
names = g_key_file_get_keys (keyfile, "group1", &len, &error);
|
|
|
536 |
check_no_error (&error);
|
|
|
537 |
|
|
|
538 |
check_length ("keys", g_strv_length (names), len, 4);
|
|
|
539 |
check_name ("key", names[0], "key1", 0);
|
|
|
540 |
check_name ("key", names[1], "key2", 1);
|
|
|
541 |
check_name ("key", names[2], "key3", 2);
|
|
|
542 |
check_name ("key", names[3], "key4", 3);
|
|
|
543 |
|
|
|
544 |
g_strfreev (names);
|
|
|
545 |
|
|
|
546 |
g_key_file_free (keyfile);
|
|
|
547 |
|
|
|
548 |
keyfile = load_data (data, G_KEY_FILE_KEEP_COMMENTS);
|
|
|
549 |
|
|
|
550 |
names = g_key_file_get_keys (keyfile, "group1", &len, &error);
|
|
|
551 |
check_no_error (&error);
|
|
|
552 |
|
|
|
553 |
check_length ("keys", g_strv_length (names), len, 4);
|
|
|
554 |
check_name ("key", names[0], "key1", 0);
|
|
|
555 |
check_name ("key", names[1], "key2", 1);
|
|
|
556 |
check_name ("key", names[2], "key3", 2);
|
|
|
557 |
check_name ("key", names[3], "key4", 3);
|
|
|
558 |
|
|
|
559 |
g_strfreev (names);
|
|
|
560 |
|
|
|
561 |
comment = g_key_file_get_comment (keyfile, NULL, NULL, &error);
|
|
|
562 |
check_no_error (&error);
|
|
|
563 |
check_name ("top comment", comment, top_comment, 0);
|
|
|
564 |
g_free (comment);
|
|
|
565 |
|
|
|
566 |
comment = g_key_file_get_comment (keyfile, "group1", "key2", &error);
|
|
|
567 |
check_no_error (&error);
|
|
|
568 |
check_name ("key comment", comment, key_comment, 0);
|
|
|
569 |
g_free (comment);
|
|
|
570 |
|
|
|
571 |
comment = g_key_file_get_comment (keyfile, "group2", NULL, &error);
|
|
|
572 |
check_no_error (&error);
|
|
|
573 |
check_name ("group comment", comment, group_comment, 0);
|
|
|
574 |
g_free (comment);
|
|
|
575 |
|
|
|
576 |
g_key_file_free (keyfile);
|
|
|
577 |
}
|
|
|
578 |
|
|
|
579 |
|
|
|
580 |
/* check key and group listing */
|
|
|
581 |
static void
|
|
|
582 |
test_listing (void)
|
|
|
583 |
{
|
|
|
584 |
GKeyFile *keyfile;
|
|
|
585 |
gchar **names;
|
|
|
586 |
gsize len;
|
|
|
587 |
gchar *start;
|
|
|
588 |
GError *error = NULL;
|
|
|
589 |
|
|
|
590 |
const gchar *data =
|
|
|
591 |
"[group1]\n"
|
|
|
592 |
"key1=value1\n"
|
|
|
593 |
"key2=value2\n"
|
|
|
594 |
"[group2]\n"
|
|
|
595 |
"key3=value3\n"
|
|
|
596 |
"key4=value4\n";
|
|
|
597 |
|
|
|
598 |
keyfile = load_data (data, 0);
|
|
|
599 |
|
|
|
600 |
names = g_key_file_get_groups (keyfile, &len);
|
|
|
601 |
if (names == NULL)
|
|
|
602 |
{
|
|
|
603 |
g_print ("Error listing groups\n");
|
|
|
604 |
|
|
|
605 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
606 |
|
|
|
607 |
#ifdef SYMBIAN
|
|
|
608 |
testResultXml("keyfile-test");
|
|
|
609 |
#endif /* EMULATOR */
|
|
|
610 |
|
|
|
611 |
exit (1);
|
|
|
612 |
}
|
|
|
613 |
|
|
|
614 |
check_length ("groups", g_strv_length (names), len, 2);
|
|
|
615 |
check_name ("group name", names[0], "group1", 0);
|
|
|
616 |
check_name ("group name", names[1], "group2", 1);
|
|
|
617 |
|
|
|
618 |
g_strfreev (names);
|
|
|
619 |
|
|
|
620 |
names = g_key_file_get_keys (keyfile, "group1", &len, &error);
|
|
|
621 |
check_no_error (&error);
|
|
|
622 |
|
|
|
623 |
check_length ("keys", g_strv_length (names), len, 2);
|
|
|
624 |
check_name ("key", names[0], "key1", 0);
|
|
|
625 |
check_name ("key", names[1], "key2", 1);
|
|
|
626 |
|
|
|
627 |
g_strfreev (names);
|
|
|
628 |
|
|
|
629 |
names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);
|
|
|
630 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
|
|
|
631 |
|
|
|
632 |
g_strfreev (names);
|
|
|
633 |
|
|
|
634 |
if (!g_key_file_has_group (keyfile, "group1") ||
|
|
|
635 |
!g_key_file_has_group (keyfile, "group2") ||
|
|
|
636 |
g_key_file_has_group (keyfile, "group10") ||
|
|
|
637 |
g_key_file_has_group (keyfile, "group2 "))
|
|
|
638 |
{
|
|
|
639 |
g_print ("Group finding trouble\n");
|
|
|
640 |
|
|
|
641 |
|
|
|
642 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
643 |
|
|
|
644 |
#ifdef SYMBIAN
|
|
|
645 |
testResultXml("keyfile-test");
|
|
|
646 |
#endif /* EMULATOR */
|
|
|
647 |
|
|
|
648 |
exit (1);
|
|
|
649 |
}
|
|
|
650 |
|
|
|
651 |
start = g_key_file_get_start_group (keyfile);
|
|
|
652 |
if (!start || strcmp (start, "group1") != 0)
|
|
|
653 |
{
|
|
|
654 |
g_print ("Start group finding trouble\n");
|
|
|
655 |
|
|
|
656 |
|
|
|
657 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
658 |
|
|
|
659 |
#ifdef SYMBIAN
|
|
|
660 |
testResultXml("keyfile-test");
|
|
|
661 |
#endif /* EMULATOR */
|
|
|
662 |
|
|
|
663 |
exit (1);
|
|
|
664 |
}
|
|
|
665 |
g_free (start);
|
|
|
666 |
|
|
|
667 |
if (!g_key_file_has_key (keyfile, "group1", "key1", &error) ||
|
|
|
668 |
!g_key_file_has_key (keyfile, "group2", "key3", &error) ||
|
|
|
669 |
g_key_file_has_key (keyfile, "group2", "no-such-key", &error))
|
|
|
670 |
{
|
|
|
671 |
g_print ("Key finding trouble\n");
|
|
|
672 |
|
|
|
673 |
|
|
|
674 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
675 |
|
|
|
676 |
#ifdef SYMBIAN
|
|
|
677 |
testResultXml("keyfile-test");
|
|
|
678 |
#endif /* EMULATOR */
|
|
|
679 |
|
|
|
680 |
|
|
|
681 |
exit (1);
|
|
|
682 |
}
|
|
|
683 |
check_no_error (&error);
|
|
|
684 |
|
|
|
685 |
g_key_file_has_key (keyfile, "no-such-group", "key", &error);
|
|
|
686 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
|
|
|
687 |
|
|
|
688 |
g_key_file_free (keyfile);
|
|
|
689 |
}
|
|
|
690 |
|
|
|
691 |
/* check parsing of string values */
|
|
|
692 |
static void
|
|
|
693 |
test_string (void)
|
|
|
694 |
{
|
|
|
695 |
GKeyFile *keyfile;
|
|
|
696 |
GError *error = NULL;
|
|
|
697 |
gchar *value;
|
|
|
698 |
|
|
|
699 |
const gchar *data =
|
|
|
700 |
"[valid]\n"
|
|
|
701 |
"key1=\\s\\n\\t\\r\\\\\n"
|
|
|
702 |
"key2=\"quoted\"\n"
|
|
|
703 |
"key3='quoted'\n"
|
|
|
704 |
"key4=\xe2\x89\xa0\xe2\x89\xa0\n"
|
|
|
705 |
"[invalid]\n"
|
|
|
706 |
"key1=\\a\\b\\0800xff\n"
|
|
|
707 |
"key2=blabla\\\n";
|
|
|
708 |
|
|
|
709 |
keyfile = load_data (data, 0);
|
|
|
710 |
|
|
|
711 |
check_string_value (keyfile, "valid", "key1", " \n\t\r\\");
|
|
|
712 |
check_string_value (keyfile, "valid", "key2", "\"quoted\"");
|
|
|
713 |
check_string_value (keyfile, "valid", "key3", "'quoted'");
|
|
|
714 |
check_string_value (keyfile, "valid", "key4", "\xe2\x89\xa0\xe2\x89\xa0");
|
|
|
715 |
|
|
|
716 |
value = g_key_file_get_string (keyfile, "invalid", "key1", &error);
|
|
|
717 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
718 |
g_free (value);
|
|
|
719 |
|
|
|
720 |
value = g_key_file_get_string (keyfile, "invalid", "key2", &error);
|
|
|
721 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
722 |
g_free (value);
|
|
|
723 |
|
|
|
724 |
g_key_file_free (keyfile);
|
|
|
725 |
}
|
|
|
726 |
|
|
|
727 |
/* check parsing of boolean values */
|
|
|
728 |
static void
|
|
|
729 |
test_boolean (void)
|
|
|
730 |
{
|
|
|
731 |
GKeyFile *keyfile;
|
|
|
732 |
GError *error = NULL;
|
|
|
733 |
|
|
|
734 |
const gchar *data =
|
|
|
735 |
"[valid]\n"
|
|
|
736 |
"key1=true\n"
|
|
|
737 |
"key2=false\n"
|
|
|
738 |
"key3=1\n"
|
|
|
739 |
"key4=0\n"
|
|
|
740 |
"[invalid]\n"
|
|
|
741 |
"key1=t\n"
|
|
|
742 |
"key2=f\n"
|
|
|
743 |
"key3=yes\n"
|
|
|
744 |
"key4=no\n";
|
|
|
745 |
|
|
|
746 |
keyfile = load_data (data, 0);
|
|
|
747 |
|
|
|
748 |
check_boolean_value (keyfile, "valid", "key1", TRUE);
|
|
|
749 |
check_boolean_value (keyfile, "valid", "key2", FALSE);
|
|
|
750 |
check_boolean_value (keyfile, "valid", "key3", TRUE);
|
|
|
751 |
check_boolean_value (keyfile, "valid", "key4", FALSE);
|
|
|
752 |
|
|
|
753 |
g_key_file_get_boolean (keyfile, "invalid", "key1", &error);
|
|
|
754 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
755 |
|
|
|
756 |
g_key_file_get_boolean (keyfile, "invalid", "key2", &error);
|
|
|
757 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
758 |
|
|
|
759 |
g_key_file_get_boolean (keyfile, "invalid", "key3", &error);
|
|
|
760 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
761 |
|
|
|
762 |
g_key_file_get_boolean (keyfile, "invalid", "key4", &error);
|
|
|
763 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
764 |
|
|
|
765 |
g_key_file_free (keyfile);
|
|
|
766 |
}
|
|
|
767 |
|
|
|
768 |
/* check parsing of integer values */
|
|
|
769 |
static void
|
|
|
770 |
test_integer (void)
|
|
|
771 |
{
|
|
|
772 |
GKeyFile *keyfile;
|
|
|
773 |
GError *error = NULL;
|
|
|
774 |
|
|
|
775 |
const gchar *data =
|
|
|
776 |
"[valid]\n"
|
|
|
777 |
"key1=0\n"
|
|
|
778 |
"key2=1\n"
|
|
|
779 |
"key3=-1\n"
|
|
|
780 |
"key4=2324431\n"
|
|
|
781 |
"key5=-2324431\n"
|
|
|
782 |
"key6=000111\n"
|
|
|
783 |
"[invalid]\n"
|
|
|
784 |
"key1=0xffff\n"
|
|
|
785 |
"key2=0.5\n"
|
|
|
786 |
"key3=1e37\n"
|
|
|
787 |
"key4=ten\n";
|
|
|
788 |
|
|
|
789 |
keyfile = load_data (data, 0);
|
|
|
790 |
|
|
|
791 |
check_integer_value (keyfile, "valid", "key1", 0);
|
|
|
792 |
check_integer_value (keyfile, "valid", "key2", 1);
|
|
|
793 |
check_integer_value (keyfile, "valid", "key3", -1);
|
|
|
794 |
check_integer_value (keyfile, "valid", "key4", 2324431);
|
|
|
795 |
check_integer_value (keyfile, "valid", "key5", -2324431);
|
|
|
796 |
check_integer_value (keyfile, "valid", "key6", 111);
|
|
|
797 |
|
|
|
798 |
g_key_file_get_integer (keyfile, "invalid", "key1", &error);
|
|
|
799 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
800 |
|
|
|
801 |
g_key_file_get_integer (keyfile, "invalid", "key2", &error);
|
|
|
802 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
803 |
|
|
|
804 |
g_key_file_get_integer (keyfile, "invalid", "key3", &error);
|
|
|
805 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
806 |
|
|
|
807 |
g_key_file_get_integer (keyfile, "invalid", "key4", &error);
|
|
|
808 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
|
|
|
809 |
|
|
|
810 |
g_key_file_free (keyfile);
|
|
|
811 |
}
|
|
|
812 |
|
|
|
813 |
/* check handling of translated strings */
|
|
|
814 |
static void
|
|
|
815 |
test_locale_string (void)
|
|
|
816 |
{
|
|
|
817 |
GKeyFile *keyfile;
|
|
|
818 |
GError *error = NULL;
|
|
|
819 |
gchar *value;
|
|
|
820 |
|
|
|
821 |
const gchar *data =
|
|
|
822 |
"[valid]\n"
|
|
|
823 |
"key1=v1\n"
|
|
|
824 |
"key1[de]=v1-de\n"
|
|
|
825 |
"key1[de_DE]=v1-de_DE\n"
|
|
|
826 |
"key1[de_DE.UTF8]=v1-de_DE.UTF8\n"
|
|
|
827 |
"key1[fr]=v1-fr\n"
|
|
|
828 |
"key1[en] =v1-en\n"
|
|
|
829 |
"key1[sr@Latn]=v1-sr\n";
|
|
|
830 |
|
|
|
831 |
keyfile = load_data (data, G_KEY_FILE_KEEP_TRANSLATIONS);
|
|
|
832 |
|
|
|
833 |
check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
|
|
|
834 |
check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
|
|
|
835 |
check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de_DE");
|
|
|
836 |
check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de_DE.UTF8");
|
|
|
837 |
check_locale_string_value (keyfile, "valid", "key1", "fr", "v1-fr");
|
|
|
838 |
check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1-fr");
|
|
|
839 |
check_locale_string_value (keyfile, "valid", "key1", "en", "v1-en");
|
|
|
840 |
check_locale_string_value (keyfile, "valid", "key1", "sr@Latn", "v1-sr");
|
|
|
841 |
|
|
|
842 |
g_key_file_free (keyfile);
|
|
|
843 |
|
|
|
844 |
/* now test that translations are thrown away */
|
|
|
845 |
|
|
|
846 |
g_setenv ("LANGUAGE", "de", TRUE);
|
|
|
847 |
setlocale (LC_ALL, "");
|
|
|
848 |
|
|
|
849 |
keyfile = load_data (data, 0);
|
|
|
850 |
|
|
|
851 |
check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
|
|
|
852 |
check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
|
|
|
853 |
check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de");
|
|
|
854 |
check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de");
|
|
|
855 |
check_locale_string_value (keyfile, "valid", "key1", "fr", "v1");
|
|
|
856 |
check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1");
|
|
|
857 |
check_locale_string_value (keyfile, "valid", "key1", "en", "v1");
|
|
|
858 |
|
|
|
859 |
g_key_file_free (keyfile);
|
|
|
860 |
}
|
|
|
861 |
|
|
|
862 |
static void
|
|
|
863 |
test_lists (void)
|
|
|
864 |
{
|
|
|
865 |
GKeyFile *keyfile;
|
|
|
866 |
|
|
|
867 |
const gchar *data =
|
|
|
868 |
"[valid]\n"
|
|
|
869 |
"key1=v1;v2\n"
|
|
|
870 |
"key2=v1;v2;\n"
|
|
|
871 |
"key3=v1,v2\n"
|
|
|
872 |
"key4=v1\\;v2\n"
|
|
|
873 |
"key5=true;false\n"
|
|
|
874 |
"key6=1;0;-1\n"
|
|
|
875 |
"key7= 1 ; 0 ; -1 \n"
|
|
|
876 |
"key8=v1\\,v2\n";
|
|
|
877 |
|
|
|
878 |
keyfile = load_data (data, 0);
|
|
|
879 |
|
|
|
880 |
check_string_list_value (keyfile, "valid", "key1", "v1", "v2", NULL);
|
|
|
881 |
check_string_list_value (keyfile, "valid", "key2", "v1", "v2", NULL);
|
|
|
882 |
check_string_list_value (keyfile, "valid", "key3", "v1,v2", NULL);
|
|
|
883 |
check_string_list_value (keyfile, "valid", "key4", "v1;v2", NULL);
|
|
|
884 |
check_boolean_list_value (keyfile, "valid", "key5", TRUE, FALSE, -100);
|
|
|
885 |
check_integer_list_value (keyfile, "valid", "key6", 1, 0, -1, -100);
|
|
|
886 |
/* maybe these should be valid */
|
|
|
887 |
/* check_integer_list_value (keyfile, "valid", "key7", 1, 0, -1, -100);*/
|
|
|
888 |
/* check_string_list_value (keyfile, "valid", "key8", "v1\\,v2", NULL);*/
|
|
|
889 |
|
|
|
890 |
g_key_file_free (keyfile);
|
|
|
891 |
|
|
|
892 |
/* Now check an alternate separator */
|
|
|
893 |
|
|
|
894 |
keyfile = load_data (data, 0);
|
|
|
895 |
g_key_file_set_list_separator (keyfile, ',');
|
|
|
896 |
|
|
|
897 |
check_string_list_value (keyfile, "valid", "key1", "v1;v2", NULL);
|
|
|
898 |
check_string_list_value (keyfile, "valid", "key2", "v1;v2;", NULL);
|
|
|
899 |
check_string_list_value (keyfile, "valid", "key3", "v1", "v2", NULL);
|
|
|
900 |
|
|
|
901 |
g_key_file_free (keyfile);
|
|
|
902 |
}
|
|
|
903 |
|
|
|
904 |
/* http://bugzilla.gnome.org/show_bug.cgi?id=165887 */
|
|
|
905 |
static void
|
|
|
906 |
test_group_remove (void)
|
|
|
907 |
{
|
|
|
908 |
GKeyFile *keyfile;
|
|
|
909 |
gchar **names;
|
|
|
910 |
gsize len;
|
|
|
911 |
GError *error = NULL;
|
|
|
912 |
|
|
|
913 |
const gchar *data =
|
|
|
914 |
"[group1]\n"
|
|
|
915 |
"[group2]\n"
|
|
|
916 |
"key1=bla\n"
|
|
|
917 |
"key2=bla\n"
|
|
|
918 |
"[group3]\n"
|
|
|
919 |
"key1=bla\n"
|
|
|
920 |
"key2=bla\n";
|
|
|
921 |
|
|
|
922 |
keyfile = load_data (data, 0);
|
|
|
923 |
|
|
|
924 |
names = g_key_file_get_groups (keyfile, &len);
|
|
|
925 |
if (names == NULL)
|
|
|
926 |
{
|
|
|
927 |
g_print ("Error listing groups\n");
|
|
|
928 |
|
|
|
929 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
930 |
|
|
|
931 |
#ifdef SYMBIAN
|
|
|
932 |
testResultXml("keyfile-test");
|
|
|
933 |
#endif /* EMULATOR */
|
|
|
934 |
|
|
|
935 |
exit (1);
|
|
|
936 |
}
|
|
|
937 |
|
|
|
938 |
check_length ("groups", g_strv_length (names), len, 3);
|
|
|
939 |
check_name ("group name", names[0], "group1", 0);
|
|
|
940 |
check_name ("group name", names[1], "group2", 1);
|
|
|
941 |
check_name ("group name", names[2], "group3", 2);
|
|
|
942 |
|
|
|
943 |
g_key_file_remove_group (keyfile, "group1", &error);
|
|
|
944 |
check_no_error (&error);
|
|
|
945 |
|
|
|
946 |
g_strfreev (names);
|
|
|
947 |
|
|
|
948 |
names = g_key_file_get_groups (keyfile, &len);
|
|
|
949 |
if (names == NULL)
|
|
|
950 |
{
|
|
|
951 |
g_print ("Error listing groups\n");
|
|
|
952 |
|
|
|
953 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
954 |
|
|
|
955 |
#ifdef SYMBIAN
|
|
|
956 |
testResultXml("keyfile-test");
|
|
|
957 |
#endif /* EMULATOR */
|
|
|
958 |
|
|
|
959 |
exit (1);
|
|
|
960 |
}
|
|
|
961 |
|
|
|
962 |
check_length ("groups", g_strv_length (names), len, 2);
|
|
|
963 |
check_name ("group name", names[0], "group2", 0);
|
|
|
964 |
check_name ("group name", names[1], "group3", 1);
|
|
|
965 |
|
|
|
966 |
g_key_file_remove_group (keyfile, "group2", &error);
|
|
|
967 |
check_no_error (&error);
|
|
|
968 |
|
|
|
969 |
g_strfreev (names);
|
|
|
970 |
|
|
|
971 |
names = g_key_file_get_groups (keyfile, &len);
|
|
|
972 |
if (names == NULL)
|
|
|
973 |
{
|
|
|
974 |
g_print ("Error listing groups\n");
|
|
|
975 |
|
|
|
976 |
g_assert(FALSE && "keyfile-test failed");
|
|
|
977 |
|
|
|
978 |
#ifdef SYMBIAN
|
|
|
979 |
testResultXml("keyfile-test");
|
|
|
980 |
#endif /* EMULATOR */
|
|
|
981 |
|
|
|
982 |
exit (1);
|
|
|
983 |
}
|
|
|
984 |
|
|
|
985 |
check_length ("groups", g_strv_length (names), len, 1);
|
|
|
986 |
check_name ("group name", names[0], "group3", 0);
|
|
|
987 |
|
|
|
988 |
g_key_file_remove_group (keyfile, "no such group", &error);
|
|
|
989 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
|
|
|
990 |
|
|
|
991 |
g_strfreev (names);
|
|
|
992 |
|
|
|
993 |
g_key_file_free (keyfile);
|
|
|
994 |
}
|
|
|
995 |
|
|
|
996 |
/* http://bugzilla.gnome.org/show_bug.cgi?id=165980 */
|
|
|
997 |
static void
|
|
|
998 |
test_key_remove (void)
|
|
|
999 |
{
|
|
|
1000 |
GKeyFile *keyfile;
|
|
|
1001 |
gchar *value;
|
|
|
1002 |
GError *error = NULL;
|
|
|
1003 |
|
|
|
1004 |
const gchar *data =
|
|
|
1005 |
"[group1]\n"
|
|
|
1006 |
"key1=bla\n"
|
|
|
1007 |
"key2=bla\n";
|
|
|
1008 |
|
|
|
1009 |
keyfile = load_data (data, 0);
|
|
|
1010 |
|
|
|
1011 |
check_string_value (keyfile, "group1", "key1", "bla");
|
|
|
1012 |
|
|
|
1013 |
g_key_file_remove_key (keyfile, "group1", "key1", &error);
|
|
|
1014 |
check_no_error (&error);
|
|
|
1015 |
|
|
|
1016 |
value = g_key_file_get_string (keyfile, "group1", "key1", &error);
|
|
|
1017 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
|
|
|
1018 |
g_free (value);
|
|
|
1019 |
|
|
|
1020 |
g_key_file_remove_key (keyfile, "group1", "key1", &error);
|
|
|
1021 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
|
|
|
1022 |
|
|
|
1023 |
g_key_file_remove_key (keyfile, "no such group", "key1", &error);
|
|
|
1024 |
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
|
|
|
1025 |
|
|
|
1026 |
g_key_file_free (keyfile);
|
|
|
1027 |
}
|
|
|
1028 |
|
|
|
1029 |
/* http://bugzilla.gnome.org/show_bug.cgi?id=316309 */
|
|
|
1030 |
static void
|
|
|
1031 |
test_groups (void)
|
|
|
1032 |
{
|
|
|
1033 |
GKeyFile *keyfile;
|
|
|
1034 |
|
|
|
1035 |
const gchar *data =
|
|
|
1036 |
"[1]\n"
|
|
|
1037 |
"key1=123\n"
|
|
|
1038 |
"[2]\n"
|
|
|
1039 |
"key2=123\n";
|
|
|
1040 |
|
|
|
1041 |
keyfile = load_data (data, 0);
|
|
|
1042 |
|
|
|
1043 |
check_string_value (keyfile, "1", "key1", "123");
|
|
|
1044 |
check_string_value (keyfile, "2", "key2", "123");
|
|
|
1045 |
|
|
|
1046 |
g_key_file_free (keyfile);
|
|
|
1047 |
}
|
|
|
1048 |
|
|
|
1049 |
|
|
|
1050 |
int
|
|
|
1051 |
main (int argc, char *argv[])
|
|
|
1052 |
{
|
|
|
1053 |
#ifdef SYMBIAN
|
|
|
1054 |
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
|
|
|
1055 |
g_set_print_handler(mrtPrintHandler);
|
|
|
1056 |
#endif /*SYMBIAN*/
|
|
|
1057 |
|
|
|
1058 |
|
|
|
1059 |
test_line_ends ();
|
|
|
1060 |
test_whitespace ();
|
|
|
1061 |
test_comments ();
|
|
|
1062 |
test_listing ();
|
|
|
1063 |
test_string ();
|
|
|
1064 |
test_boolean ();
|
|
|
1065 |
test_integer ();
|
|
|
1066 |
test_locale_string ();
|
|
|
1067 |
test_lists ();
|
|
|
1068 |
test_group_remove ();
|
|
|
1069 |
test_key_remove ();
|
|
|
1070 |
test_groups ();
|
|
|
1071 |
|
|
|
1072 |
#ifdef SYMBIAN
|
|
|
1073 |
testResultXml("keyfile-test");
|
|
|
1074 |
#endif /* EMULATOR */
|
|
|
1075 |
|
|
|
1076 |
return 0;
|
|
|
1077 |
}
|