← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gconf/quantal

« back to all changes in this revision

Viewing changes to tests/testschemas.c

  • Committer: Bazaar Package Importer
  • Author(s): Josselin Mouette
  • Date: 2007-11-01 18:47:26 UTC
  • mto: (7.1.1 lenny) (1.2.1) (76.1.1 oneiric-proposed)
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: james.westby@ubuntu.com-20071101184726-e3e4cxfcp41tz6ui
Tags: upstream-2.20.1
ImportĀ upstreamĀ versionĀ 2.20.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/testschemas.c
17
17
 * Boston, MA 02111-1307, USA.
18
18
 */
19
19
 
 
20
 
 
21
 
 
22
 
 
23
 
 
24
 
 
25
 
 
26
 
 
27
 
 
28
 
 
29
 
 
30
/*
 
31
 *
 
32
 *
 
33
 * DO NOT USE THESE CRAPPY TESTS AS EXAMPLE CODE. USE THE DOCS AND examples
 
34
 *
 
35
 *
 
36
 *
 
37
 */
 
38
 
 
39
 
 
40
 
 
41
 
 
42
 
 
43
 
 
44
 
 
45
 
20
46
#include <gconf/gconf.h>
21
47
#include <stdio.h>
 
48
#include <string.h>
 
49
#include <stdlib.h>
22
50
#include <unistd.h>
23
51
#include <math.h>
 
52
#include <locale.h>
24
53
#include <gconf/gconf-internals.h>
25
54
 
26
55
/* glibc printf() functions accept NULL for a %s format, but to be
92
121
 
93
122
  while (*keyp)
94
123
    {
95
 
      gconf_engine_unset(conf, *keyp, &err);
 
124
      g_assert (err == NULL);
 
125
      
 
126
      gconf_engine_unset (conf, *keyp, &err);
96
127
 
97
128
      if (err != NULL)
98
129
        {
99
 
          fprintf(stderr, "unset of `%s' failed: %s\n", *keyp, err->message);
100
 
          g_error_free(err);
 
130
          fprintf (stderr, "unset of `%s' failed: %s\n", *keyp, err->message);
 
131
          g_error_free (err);
101
132
          err = NULL;
 
133
          exit (1);
102
134
        }
103
135
      else
104
136
        {
105
137
          GConfValue* val;
106
138
          gchar* valstr;
107
139
          
108
 
          val = gconf_engine_get (conf, *keyp, &err);
109
 
 
110
 
 
 
140
          val = gconf_engine_get_without_default (conf, *keyp, &err);
 
141
 
 
142
          if (err != NULL)
 
143
            {
 
144
              fprintf (stderr, "gconf_engine_get_without_default on key %s failed: %s\n", *keyp, err->message);
 
145
              g_error_free (err);
 
146
              err = NULL;
 
147
              exit (1);
 
148
            }
 
149
          
111
150
          if (val)
112
 
            valstr = gconf_value_to_string(val);
 
151
            valstr = gconf_value_to_string (val);
113
152
          else
114
 
            valstr = g_strdup("(none)");
 
153
            valstr = g_strdup ("(none)");
115
154
          
116
 
          check(val == NULL, "unsetting a previously-set value `%s' the value `%s' existed", *keyp, valstr);
 
155
          check (val == NULL, "unsetting a previously-set value `%s' the value `%s' existed", *keyp, valstr);
117
156
 
118
 
          g_free(valstr);
 
157
          g_free (valstr);
119
158
        }
120
159
      
121
160
      ++keyp;
244
283
{
245
284
  GError* err = NULL;
246
285
  
247
 
  if (!gconf_engine_set_schema(conf, *keyp, schema, &err))
 
286
  if (!gconf_engine_set_schema (conf, *keyp, schema, &err))
248
287
    {
249
 
      fprintf(stderr, "Failed to set key `%s' to schema: %s\n",
 
288
      fprintf (stderr, "Failed to set key `%s' to schema: %s\n",
250
289
              *keyp, err->message);
251
 
      g_error_free(err);
 
290
      g_error_free (err);
252
291
      err = NULL;
253
292
    }
254
293
  else
255
294
    {
256
295
      GConfSchema* gotten;
 
296
      GConfValue *val;
257
297
      
258
 
      gotten = gconf_engine_get_schema(conf, *keyp, &err);
 
298
      val = gconf_engine_get_with_locale (conf, *keyp, gconf_schema_get_locale (schema), &err);
259
299
 
260
300
      if (err != NULL)
261
301
        {
262
 
          check(gotten == NULL, "NULL not returned though there was an error");
 
302
          check (val == NULL, "NULL not returned though there was an error");
263
303
 
264
 
          fprintf(stderr, "Failed to get key `%s': %s\n",
265
 
                  *keyp, err->message);
 
304
          fprintf (stderr, "Failed to get key `%s': %s\n",
 
305
                   *keyp, err->message);
266
306
          g_error_free(err);
267
307
          err = NULL;
268
308
        }
269
309
      else
270
310
        {
271
 
          check (gconf_schema_get_type(schema) == gconf_schema_get_type(gotten),
 
311
          check (val != NULL, "Did not get a schema back after setting it");
 
312
 
 
313
          check (val->type == GCONF_VALUE_SCHEMA, "Got type %s back instead of schema",
 
314
                 gconf_value_type_to_string (val->type));
 
315
 
 
316
          gotten = gconf_value_get_schema (val);
 
317
          
 
318
          check (gconf_schema_get_type (schema) == gconf_schema_get_type (gotten),
272
319
                 "schema set/get pair: type `%s' set, `%s' got",
273
 
                 gconf_value_type_to_string(gconf_schema_get_type(schema)),
274
 
                 gconf_value_type_to_string(gconf_schema_get_type(gotten)));
275
 
 
 
320
                 gconf_value_type_to_string (gconf_schema_get_type (schema)),
 
321
                 gconf_value_type_to_string (gconf_schema_get_type (gotten)));
276
322
 
277
323
          /* If we set the schema for the current locale be sure we get it back */
278
 
          if (null_safe_strcmp(gconf_current_locale(), gconf_schema_get_locale(schema)) == 0)
 
324
          if (null_safe_strcmp (gconf_current_locale (), gconf_schema_get_locale (schema)) == 0)
279
325
            {
280
326
              check (null_safe_strcmp(gconf_current_locale(), gconf_schema_get_locale(gotten)) == 0,
281
327
                     "schema set/get pair: locale `%s' set, `%s' got",
282
328
                     gconf_current_locale(),
283
 
                     NULL_SAFE(gconf_schema_get_locale(gotten)));
 
329
                     NULL_SAFE (gconf_schema_get_locale (gotten)));
284
330
            }
285
331
              
286
 
          check (null_safe_strcmp(gconf_schema_get_short_desc(schema), gconf_schema_get_short_desc(gotten)) == 0,
 
332
          check (null_safe_strcmp (gconf_schema_get_short_desc (schema), gconf_schema_get_short_desc (gotten)) == 0,
287
333
                 "schema set/get pair: short_desc `%s' set, `%s' got",
288
 
                 NULL_SAFE(gconf_schema_get_short_desc(schema)),
289
 
                 NULL_SAFE(gconf_schema_get_short_desc(gotten)));
 
334
                 NULL_SAFE (gconf_schema_get_short_desc (schema)),
 
335
                 NULL_SAFE (gconf_schema_get_short_desc (gotten)));
290
336
 
291
 
          check (null_safe_strcmp(gconf_schema_get_long_desc(schema), gconf_schema_get_long_desc(gotten)) == 0,
 
337
          check (null_safe_strcmp (gconf_schema_get_long_desc (schema), gconf_schema_get_long_desc (gotten)) == 0,
292
338
                 "schema set/get pair: long_desc `%s' set, `%s' got",
293
 
                 NULL_SAFE(gconf_schema_get_long_desc(schema)),
294
 
                 NULL_SAFE(gconf_schema_get_long_desc(gotten)));
 
339
                 NULL_SAFE (gconf_schema_get_long_desc (schema)),
 
340
                 NULL_SAFE (gconf_schema_get_long_desc (gotten)));
295
341
 
296
 
          check (null_safe_strcmp(gconf_schema_get_owner(schema), gconf_schema_get_owner(gotten)) == 0,
 
342
          check (null_safe_strcmp (gconf_schema_get_owner(schema), gconf_schema_get_owner(gotten)) == 0,
297
343
                 "schema set/get pair: owner `%s' set, `%s' got",
298
 
                 NULL_SAFE(gconf_schema_get_owner(schema)),
299
 
                 NULL_SAFE(gconf_schema_get_owner(gotten)));
 
344
                 NULL_SAFE (gconf_schema_get_owner (schema)),
 
345
                 NULL_SAFE (gconf_schema_get_owner (gotten)));
300
346
 
301
347
          {
302
348
            GConfValue* set_default;
303
349
            GConfValue* got_default;
304
350
 
305
 
            set_default = gconf_schema_get_default_value(schema);
306
 
            got_default = gconf_schema_get_default_value(gotten);
 
351
            set_default = gconf_schema_get_default_value (schema);
 
352
            got_default = gconf_schema_get_default_value (gotten);
307
353
 
308
354
            if (set_default && got_default)
309
355
              {
310
 
                check(set_default->type == GCONF_VALUE_INT,
 
356
                check (set_default->type == GCONF_VALUE_INT,
311
357
                      "set default type is INT");
312
358
                
313
 
                check(set_default->type == got_default->type,
314
 
                      "schema set/get pair: default value type `%s' set, `%s' got",
315
 
                      gconf_value_type_to_string(set_default->type),
316
 
                      gconf_value_type_to_string(got_default->type));
317
 
                
318
 
                check(set_default->type == got_default->type,
319
 
                      "schema set/get pair: default value type `%s' set, `%s' got",
320
 
                      gconf_value_type_to_string(set_default->type),
321
 
                      gconf_value_type_to_string(got_default->type));
322
 
                
323
 
                check(gconf_value_get_int(set_default) == gconf_value_get_int(got_default),
324
 
                      "schema set/get pair: default value (int) `%d' set, `%d' got",
325
 
                      gconf_value_get_int(set_default), gconf_value_get_int(got_default));
 
359
                check (set_default->type == got_default->type,
 
360
                       "schema set/get pair: default value type `%s' set, `%s' got",
 
361
                       gconf_value_type_to_string(set_default->type),
 
362
                       gconf_value_type_to_string(got_default->type));
 
363
                
 
364
                check (set_default->type == got_default->type,
 
365
                       "schema set/get pair: default value type `%s' set, `%s' got",
 
366
                       gconf_value_type_to_string(set_default->type),
 
367
                       gconf_value_type_to_string(got_default->type));
 
368
                
 
369
                check (gconf_value_get_int(set_default) == gconf_value_get_int(got_default),
 
370
                       "schema set/get pair: default value (int) `%d' set, `%d' got",
 
371
                       gconf_value_get_int(set_default), gconf_value_get_int(got_default));
326
372
              }
327
373
            else
328
374
              {
334
380
              }
335
381
          }
336
382
          
337
 
          gconf_schema_free(gotten);
 
383
          gconf_value_free (val);
338
384
        }
339
385
    }
340
386
}
341
387
      
342
388
void
343
 
check_schema_storage(GConfEngine* conf)
 
389
check_schema_storage (GConfEngine* conf)
344
390
{
345
391
  const gchar** keyp = NULL;
346
392
  guint i; 
365
411
          if (*localep == NULL)
366
412
            localep = locales;
367
413
          
368
 
          schema = gconf_schema_new();
369
 
 
370
 
          gconf_schema_set_type(schema, GCONF_VALUE_INT);
371
 
          gconf_schema_set_locale(schema, *localep);
372
 
          short_desc = g_strdup_printf("Schema for key `%s' storing value %d",
373
 
                                       *keyp, ints[i]);
374
 
          gconf_schema_set_short_desc(schema, short_desc);
375
 
 
376
 
          long_desc = g_strdup_printf("Long description for schema with short description `%s' is really really long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long "
 
414
          schema = gconf_schema_new ();
 
415
 
 
416
          gconf_schema_set_type (schema, GCONF_VALUE_INT);
 
417
          gconf_schema_set_locale (schema, *localep);
 
418
          short_desc = g_strdup_printf ("Schema for key `%s' storing value %d",
 
419
                                        *keyp, ints[i]);
 
420
          gconf_schema_set_short_desc (schema, short_desc);
 
421
 
 
422
          long_desc = g_strdup_printf ("Long description for schema with short description `%s' is really really long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long "
377
423
                                      "UTF-8: German (Deutsch SĆ¼d) GrĆ¼ĆŸ Gott Greek (Ī•Ī»Ī»Ī·Ī½Ī¹ĪŗĪ¬) Ī“ĪµĪ¹Ī¬ ĻƒĪ±Ļ‚ Hebrew(שלום) Hebrew punctuation(\xd6\xbfש\xd6\xbb\xd6\xbc\xd6\xbb\xd6\xbfל\xd6\xbcו\xd6\xbc\xd6\xbb\xd6\xbb\xd6\xbfם\xd6\xbc\xd6\xbb\xd6\xbf) Japanese (ę—„ęœ¬čŖž) Thai (ąøŖąø§ąø±ąøŖąø”ąøµąø„ąø£ąø±ąøš) Thai wrong spelling (ąø„ąø³ąø•ą¹ˆąø­ą¹„ąø›ąø™ąø·ą¹ˆąøŖąø°ąøąø”ąøœąø“ąø” ąøžąø±ąø±ą¹‰ąø±ąø±ą¹ˆąø‡ą¹‚ąøąø°)\n", short_desc);
378
424
          
379
 
          gconf_schema_set_long_desc(schema, long_desc);
380
 
 
381
 
          gconf_schema_set_owner(schema, "testschemas");
382
 
 
383
 
          default_value = gconf_value_new(GCONF_VALUE_INT);
384
 
          gconf_value_set_int(default_value, default_value_int);
385
 
          
386
 
          gconf_schema_set_default_value_nocopy(schema, default_value);
387
 
 
388
 
          check(gconf_value_get_int(gconf_schema_get_default_value(schema)) == default_value_int,
389
 
                "Properly stored default int value in the schema");
390
 
          
391
 
          check_one_schema(conf, keyp, schema);
392
 
 
 
425
          gconf_schema_set_long_desc (schema, long_desc);
 
426
 
 
427
          gconf_schema_set_owner (schema, "testschemas");
 
428
 
 
429
          default_value = gconf_value_new (GCONF_VALUE_INT);
 
430
          gconf_value_set_int (default_value, default_value_int);
 
431
          
 
432
          gconf_schema_set_default_value_nocopy (schema, default_value);
 
433
 
 
434
          check (gconf_value_get_int (gconf_schema_get_default_value (schema)) == default_value_int,
 
435
                 "Properly stored default int value in the schema");
 
436
 
 
437
          check_one_schema (conf, keyp, schema);
 
438
          
393
439
          gconf_schema_free(schema);
394
440
          g_free(long_desc);
395
441
          g_free(short_desc);
432
478
  check_unset(conf);
433
479
}
434
480
 
 
481
 
 
482
enum
 
483
{
 
484
  SCHEMA_INFO_SHORT_DOCS,
 
485
  SCHEMA_INFO_LONG_DOCS,
 
486
  SCHEMA_INFO_SCHEMA_NAME
 
487
};
 
488
 
 
489
static char*
 
490
get_schema_info (GConfEngine *conf, const gchar *key, int info)
 
491
{
 
492
  GError* err = NULL;
 
493
  GConfEntry* entry;
 
494
  char *retval;
 
495
 
 
496
  retval = NULL;
 
497
  
 
498
  err = NULL;
 
499
  entry = gconf_engine_get_entry (conf, key, NULL, TRUE, &err);
 
500
 
 
501
  if (entry != NULL)
 
502
    {
 
503
      const char *s;
 
504
          
 
505
      s = gconf_entry_get_schema_name (entry);
 
506
 
 
507
      if (s == NULL)
 
508
        {
 
509
          retval = NULL;
 
510
        }
 
511
      else if (info == SCHEMA_INFO_SCHEMA_NAME)
 
512
        {
 
513
          retval = g_strdup (s);
 
514
        }
 
515
      else
 
516
        {
 
517
          GConfValue *val;
 
518
 
 
519
          err = NULL;
 
520
              
 
521
          val = gconf_engine_get (conf, s, &err);
 
522
 
 
523
          if (val != NULL && val->type == GCONF_VALUE_SCHEMA)
 
524
            {
 
525
              GConfSchema *schema;
 
526
 
 
527
              schema = gconf_value_get_schema (val);
 
528
 
 
529
              if (schema)
 
530
                {
 
531
                  if (info == SCHEMA_INFO_SHORT_DOCS)
 
532
                    retval = g_strdup (gconf_schema_get_short_desc (schema));
 
533
                  else if (info == SCHEMA_INFO_LONG_DOCS)
 
534
                    retval = g_strdup (gconf_schema_get_long_desc (schema));
 
535
                }
 
536
            }
 
537
          else if (err != NULL)
 
538
            {
 
539
              fprintf (stderr, "Error getting schema at '%s': %s\n",
 
540
                       s, err->message);
 
541
              g_error_free (err);
 
542
              exit (1);
 
543
            }
 
544
          else
 
545
            {
 
546
              if (val == NULL)
 
547
                fprintf (stderr, "No schema stored at '%s'\n",
 
548
                         s);
 
549
              else
 
550
                fprintf (stderr, "Value at '%s' is not a schema\n",
 
551
                         s);
 
552
 
 
553
              exit (1);
 
554
            }
 
555
 
 
556
          if (val)
 
557
            gconf_value_free (val);
 
558
        }
 
559
          
 
560
      gconf_entry_free (entry);
 
561
    }
 
562
  else
 
563
    {
 
564
      if (err == NULL)
 
565
        {
 
566
          fprintf(stderr, "No value set for `%s'\n", key);
 
567
        }
 
568
      else
 
569
        {
 
570
          fprintf(stderr, "Failed to get value for `%s': %s\n",
 
571
                  key, err->message);
 
572
          g_error_free(err);
 
573
          err = NULL;
 
574
        }
 
575
    }
 
576
 
 
577
  return retval;
 
578
}
 
579
 
435
580
void 
436
581
check_schema_use(GConfEngine * conf)
437
582
{
443
588
  char           *s;
444
589
  char           *schema_value = "string value from schema";
445
590
  char           *non_schema_value = "a string value *not* from schema";
446
 
 
 
591
  
447
592
  gconf_schema_set_type(schema, GCONF_VALUE_STRING);
448
593
  gconf_schema_set_locale(schema, "C");
449
594
  gconf_schema_set_short_desc(schema, "short desc");
452
597
  gconf_value_set_string(value, schema_value);
453
598
  gconf_schema_set_default_value(schema, value);
454
599
 
455
 
  if (gconf_engine_set_schema(conf, schema_key, schema, &err))
 
600
  if (!gconf_engine_set_schema(conf, schema_key, schema, &err))
456
601
    {
457
 
      if (err)
458
 
        {
459
 
          fprintf(stderr, "gconf_engine_set_schema -> %s\n", err->message);
460
 
          g_error_free (err);
461
 
        }
462
 
      
 
602
      fprintf(stderr, "gconf_engine_set_schema -> %s\n", err->message);
 
603
      g_error_free (err);      
463
604
      err = NULL;
 
605
      exit (1);
464
606
    }
465
607
  keyp = keys;
466
608
  while (*keyp)
467
609
    {
468
 
      if (gconf_engine_associate_schema(conf, *keyp, schema_key, &err))
 
610
      if (!gconf_engine_associate_schema(conf, *keyp, schema_key, &err))
469
611
        {
470
 
          if (err)
471
 
            {
472
 
              fprintf(stderr, "gconf_engine_associate_schema -> %s\n", err->message);
473
 
              g_error_free (err);
474
 
            }
475
 
          
 
612
          fprintf(stderr, "gconf_engine_associate_schema -> %s\n", err->message);
 
613
          g_error_free (err);          
476
614
          err = NULL;
477
 
 
478
 
        }
 
615
          exit (1);
 
616
        }
 
617
 
 
618
      /* Make sure we can get schema name */
 
619
      s = get_schema_info (conf, *keyp, SCHEMA_INFO_SCHEMA_NAME);
 
620
      if (s == NULL)
 
621
        {
 
622
          fprintf (stderr, "ERROR: Failed to get initial schema name\n");
 
623
          exit (1);
 
624
        }
 
625
      else if (strcmp (s, schema_key) != 0)
 
626
        {
 
627
          fprintf (stderr, "ERROR: got wrong schema name '%s'\n", schema_key);
 
628
          exit (1);
 
629
        }
 
630
 
 
631
      g_free (s);
 
632
 
 
633
      
479
634
      ++keyp;
480
635
    }
481
636
 
484
639
  keyp = keys;
485
640
  while (*keyp)
486
641
    {
487
 
      gconf_engine_unset(conf, *keyp, &err);
 
642
      g_assert (err == NULL);
 
643
      gconf_engine_unset (conf, *keyp, &err);
 
644
 
 
645
      if (err)
 
646
        {
 
647
          fprintf(stderr, "gconf_engine_unset -> %s\n", err->message);
 
648
          g_error_free (err);
 
649
          err = NULL;
 
650
          exit (1);
 
651
        }
 
652
      
488
653
      s = gconf_engine_get_string(conf, *keyp, &err);
 
654
 
 
655
      if (err)
 
656
        {
 
657
          fprintf(stderr, "gconf_engine_get_string -> %s\n", err->message);
 
658
          g_error_free (err);
 
659
          err = NULL;
 
660
          exit (1);
 
661
        }
 
662
      
489
663
      if (s)
490
664
        {
491
665
          if (strcmp(s, schema_value) != 0)
492
666
            {
493
667
              fprintf(stderr, "ERROR: Failed to get schema value (got '%s', not '%s')\n", s, schema_value);
 
668
              exit (1);
494
669
            }
495
670
          else
496
671
            {
497
672
              printf(".");
498
673
            }
 
674
 
 
675
          g_free (s);
499
676
        }
500
677
      else
501
678
        {
502
679
          fprintf(stderr, "ERROR: Failed to get a value when expecting schema value\n");
 
680
          exit (1);
503
681
        }
504
682
 
505
683
      /* associate_schema should accept NULL to unset schemas */
506
 
      gconf_engine_associate_schema(conf, *keyp, "/bogus-nonschema", &err);
 
684
      if (!gconf_engine_associate_schema (conf, *keyp, "/bogus-nonschema", &err))
 
685
        {
 
686
          fprintf(stderr, "gconf_engine_associate_schema -> %s\n", err->message);
 
687
          g_error_free (err);          
 
688
          err = NULL;
 
689
          exit (1);
 
690
        }
 
691
 
 
692
      /* Make sure we can get schema name */
 
693
      s = get_schema_info (conf, *keyp, SCHEMA_INFO_SCHEMA_NAME);
 
694
      if (s == NULL)
 
695
        {
 
696
          fprintf (stderr, "ERROR: Failed to get bogus schema name\n");
 
697
          exit (1);
 
698
        }
 
699
      else if (strcmp (s, "/bogus-nonschema") != 0)
 
700
        {
 
701
          fprintf (stderr, "ERROR: got wrong schema name '%s'\n", schema_key);
 
702
          exit (1);
 
703
        }
 
704
 
 
705
      g_free (s);
 
706
      
507
707
      s = gconf_engine_get_string(conf, *keyp, &err);
 
708
 
 
709
      if (err)
 
710
        {
 
711
          fprintf(stderr, "gconf_engine_get_string -> %s\n", err->message);
 
712
          g_error_free (err);
 
713
          err = NULL;
 
714
          exit (1);
 
715
        }
 
716
      
508
717
      if (s != NULL)
509
718
        {
510
719
          fprintf(stderr, "Failed to disassociate schema, found '%s'\n", s);
 
720
          g_free (s);
 
721
          exit (1);
511
722
        }
512
 
 
 
723
      
513
724
      gconf_engine_set_string(conf, *keyp, non_schema_value, &err);
 
725
      if (err != NULL)
 
726
        {
 
727
          fprintf(stderr, "gconf_engine_set_string -> %s\n", err->message);
 
728
          g_error_free (err);          
 
729
          err = NULL;
 
730
          exit (1);
 
731
        }
 
732
      
514
733
      s = gconf_engine_get_string(conf, *keyp, &err);
 
734
      
515
735
      if (s)
516
736
        {
517
737
          if (strcmp(s, non_schema_value) != 0)
518
738
            {
519
739
              fprintf(stderr, "ERROR: Failed to get non-schema value (got '%s', not '%s')\n", s, non_schema_value);
 
740
              exit (1);
520
741
            }
521
742
          else
522
743
            {
523
744
              printf(".");
524
745
            }
 
746
 
 
747
          g_free (s);
525
748
        }
526
749
      else
527
750
        {
528
751
          fprintf(stderr, "ERROR: Failed to get a value when expecting non-schema value\n");
529
 
        }
 
752
 
 
753
          if (err != NULL)
 
754
            {
 
755
              fprintf(stderr, "gconf_engine_get_string -> %s\n", err->message);
 
756
              g_error_free (err);          
 
757
              err = NULL;
 
758
            }
 
759
 
 
760
          exit (1);
 
761
        }
 
762
 
 
763
      /* Make sure we can still get schema name when we have a value set */
 
764
      s = get_schema_info (conf, *keyp, SCHEMA_INFO_SCHEMA_NAME);
 
765
      if (s == NULL)
 
766
        {
 
767
          fprintf (stderr, "ERROR: Failed to get schema name when a value was set in the database\n");
 
768
          exit (1);
 
769
        }
 
770
      else if (strcmp (s, "/bogus-nonschema") != 0)
 
771
        {
 
772
          fprintf (stderr, "ERROR: got wrong schema name '%s'\n", schema_key);
 
773
          exit (1);
 
774
        }
 
775
 
 
776
      g_free (s);
530
777
      
531
778
      fflush(stdout);
532
779
      ++keyp;
538
785
{
539
786
  GConfEngine* conf;
540
787
  GError* err = NULL;
 
788
 
 
789
  setlocale (LC_ALL, "");
541
790
  
542
791
  if (!gconf_init(argc, argv, &err))
543
792
    {