← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/option-test.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:
tests/option-test.c
1
 
#include <stdio.h>
2
 
#include <string.h>
3
 
#include <locale.h>
4
 
#include <glib.h>
5
 
 
6
 
int error_test1_int;
7
 
char *error_test2_string;
8
 
gboolean error_test3_boolean;
9
 
 
10
 
int arg_test1_int;
11
 
gchar *arg_test2_string;
12
 
gchar *arg_test3_filename;
13
 
gdouble arg_test4_double;
14
 
gdouble arg_test5_double;
15
 
gint64 arg_test6_int64;
16
 
gint64 arg_test6_int64_2;
17
 
 
18
 
gchar *callback_test1_string;
19
 
int callback_test2_int;
20
 
 
21
 
gchar *callback_test_optional_string;
22
 
gboolean callback_test_optional_boolean;
23
 
 
24
 
gchar **array_test1_array;
25
 
 
26
 
gboolean ignore_test1_boolean;
27
 
gboolean ignore_test2_boolean;
28
 
gchar *ignore_test3_string;
29
 
 
30
 
gchar **
31
 
split_string (const char *str, int *argc)
32
 
{
33
 
  gchar **argv;
34
 
  int len;
35
 
  
36
 
  argv = g_strsplit (str, " ", 0);
37
 
 
38
 
  for (len = 0; argv[len] != NULL; len++);
39
 
 
40
 
  if (argc)
41
 
    *argc = len;
42
 
    
43
 
  return argv;
44
 
}
45
 
 
46
 
gchar *
47
 
join_stringv (int argc, char **argv)
48
 
{
49
 
  int i;
50
 
  GString *str;
51
 
 
52
 
  str = g_string_new (NULL);
53
 
 
54
 
  for (i = 0; i < argc; i++)
55
 
    {
56
 
      g_string_append (str, argv[i]);
57
 
 
58
 
      if (i < argc - 1)
59
 
        g_string_append_c (str, ' ');
60
 
    }
61
 
 
62
 
  return g_string_free (str, FALSE);
63
 
}
64
 
 
65
 
/* Performs a shallow copy */
66
 
char **
67
 
copy_stringv (char **argv, int argc)
68
 
{
69
 
  return g_memdup (argv, sizeof (char *) * (argc + 1));
70
 
}
71
 
 
72
 
 
73
 
static gboolean
74
 
error_test1_pre_parse (GOptionContext *context,
75
 
                       GOptionGroup   *group,
76
 
                       gpointer        data,
77
 
                       GError        **error)
78
 
{
79
 
  g_assert (error_test1_int == 0x12345678);
80
 
 
81
 
  return TRUE;
82
 
}
83
 
 
84
 
static gboolean
85
 
error_test1_post_parse (GOptionContext *context,
86
 
                        GOptionGroup   *group,
87
 
                        gpointer          data,
88
 
                        GError        **error)
89
 
{
90
 
  g_assert (error_test1_int == 20);
91
 
 
92
 
  /* Set an error in the post hook */
93
 
  g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "");
94
 
 
95
 
  return FALSE;
96
 
}
97
 
 
98
 
void
99
 
error_test1 (void)
100
 
{
101
 
  GOptionContext *context;
102
 
  gboolean retval;
103
 
  GError *error = NULL;
104
 
  gchar **argv;
105
 
  int argc;
106
 
  GOptionGroup *main_group;
107
 
  GOptionEntry entries [] =
108
 
    { { "test", 0, 0, G_OPTION_ARG_INT, &error_test1_int, NULL, NULL },
109
 
      { NULL } };
110
 
  
111
 
  context = g_option_context_new (NULL);
112
 
  g_option_context_add_main_entries (context, entries, NULL);
113
 
 
114
 
  /* Set pre and post parse hooks */
115
 
  main_group = g_option_context_get_main_group (context);
116
 
  g_option_group_set_parse_hooks (main_group,
117
 
                                  error_test1_pre_parse, error_test1_post_parse);
118
 
  
119
 
  /* Now try parsing */
120
 
  argv = split_string ("program --test 20", &argc);
121
 
 
122
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
123
 
  g_assert (retval == FALSE);
124
 
 
125
 
  /* On failure, values should be reset */
126
 
  g_assert (error_test1_int == 0x12345678);
127
 
  
128
 
  g_strfreev (argv);
129
 
  g_option_context_free (context);
130
 
  
131
 
}
132
 
 
133
 
static gboolean
134
 
error_test2_pre_parse (GOptionContext *context,
135
 
                       GOptionGroup   *group,
136
 
                       gpointer   data,
137
 
                       GError        **error)
138
 
{
139
 
  g_assert (strcmp (error_test2_string, "foo") == 0);
140
 
 
141
 
  return TRUE;
142
 
}
143
 
 
144
 
static gboolean
145
 
error_test2_post_parse (GOptionContext *context,
146
 
                        GOptionGroup   *group,
147
 
                        gpointer          data,
148
 
                        GError        **error)
149
 
{
150
 
  g_assert (strcmp (error_test2_string, "bar") == 0);
151
 
 
152
 
  /* Set an error in the post hook */
153
 
  g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "");
154
 
 
155
 
  return FALSE;
156
 
}
157
 
 
158
 
void
159
 
error_test2 (void)
160
 
{
161
 
  GOptionContext *context;
162
 
  gboolean retval;
163
 
  GError *error = NULL;
164
 
  gchar **argv;
165
 
  int argc;
166
 
  GOptionGroup *main_group;
167
 
  GOptionEntry entries [] =
168
 
    { { "test", 0, 0, G_OPTION_ARG_STRING, &error_test2_string, NULL, NULL },
169
 
      { NULL } };
170
 
 
171
 
  context = g_option_context_new (NULL);
172
 
  g_option_context_add_main_entries (context, entries, NULL);
173
 
 
174
 
  /* Set pre and post parse hooks */
175
 
  main_group = g_option_context_get_main_group (context);
176
 
  g_option_group_set_parse_hooks (main_group,
177
 
                                  error_test2_pre_parse, error_test2_post_parse);
178
 
  
179
 
  /* Now try parsing */
180
 
  argv = split_string ("program --test bar", &argc);
181
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
182
 
 
183
 
  g_error_free (error);
184
 
  g_assert (retval == FALSE);
185
 
 
186
 
  g_assert (strcmp (error_test2_string, "foo") == 0);
187
 
  
188
 
  g_strfreev (argv);
189
 
  g_option_context_free (context);
190
 
}
191
 
 
192
 
static gboolean
193
 
error_test3_pre_parse (GOptionContext *context,
194
 
                       GOptionGroup   *group,
195
 
                       gpointer   data,
196
 
                       GError        **error)
197
 
{
198
 
  g_assert (!error_test3_boolean);
199
 
 
200
 
  return TRUE;
201
 
}
202
 
 
203
 
static gboolean
204
 
error_test3_post_parse (GOptionContext *context,
205
 
                        GOptionGroup   *group,
206
 
                        gpointer          data,
207
 
                        GError        **error)
208
 
{
209
 
  g_assert (error_test3_boolean);
210
 
 
211
 
  /* Set an error in the post hook */
212
 
  g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "");
213
 
 
214
 
  return FALSE;
215
 
}
216
 
 
217
 
void
218
 
error_test3 (void)
219
 
{
220
 
  GOptionContext *context;
221
 
  gboolean retval;
222
 
  GError *error = NULL;
223
 
  gchar **argv;
224
 
  int argc;
225
 
  GOptionGroup *main_group;
226
 
  GOptionEntry entries [] =
227
 
    { { "test", 0, 0, G_OPTION_ARG_NONE, &error_test3_boolean, NULL, NULL },
228
 
      { NULL } };
229
 
 
230
 
  context = g_option_context_new (NULL);
231
 
  g_option_context_add_main_entries (context, entries, NULL);
232
 
 
233
 
  /* Set pre and post parse hooks */
234
 
  main_group = g_option_context_get_main_group (context);
235
 
  g_option_group_set_parse_hooks (main_group,
236
 
                                  error_test3_pre_parse, error_test3_post_parse);
237
 
  
238
 
  /* Now try parsing */
239
 
  argv = split_string ("program --test", &argc);
240
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
241
 
 
242
 
  g_error_free (error);
243
 
  g_assert (retval == FALSE);
244
 
 
245
 
  g_assert (!error_test3_boolean);
246
 
  
247
 
  g_strfreev (argv);
248
 
  g_option_context_free (context);
249
 
}
250
 
 
251
 
void
252
 
arg_test1 (void)
253
 
{
254
 
  GOptionContext *context;
255
 
  gboolean retval;
256
 
  GError *error = NULL;
257
 
  gchar **argv;
258
 
  int argc;
259
 
  GOptionEntry entries [] =
260
 
    { { "test", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, NULL, NULL },
261
 
      { NULL } };
262
 
 
263
 
  context = g_option_context_new (NULL);
264
 
  g_option_context_add_main_entries (context, entries, NULL);
265
 
 
266
 
  /* Now try parsing */
267
 
  argv = split_string ("program --test 20 --test 30", &argc);
268
 
 
269
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
270
 
  g_assert (retval);
271
 
 
272
 
  /* Last arg specified is the one that should be stored */
273
 
  g_assert (arg_test1_int == 30);
274
 
 
275
 
  g_strfreev (argv);
276
 
  g_option_context_free (context);
277
 
}
278
 
 
279
 
void
280
 
arg_test2 (void)
281
 
{
282
 
  GOptionContext *context;
283
 
  gboolean retval;
284
 
  GError *error = NULL;
285
 
  gchar **argv;
286
 
  int argc;
287
 
  GOptionEntry entries [] =
288
 
    { { "test", 0, 0, G_OPTION_ARG_STRING, &arg_test2_string, NULL, NULL },
289
 
      { NULL } };
290
 
  
291
 
  context = g_option_context_new (NULL);
292
 
  g_option_context_add_main_entries (context, entries, NULL);
293
 
 
294
 
  /* Now try parsing */
295
 
  argv = split_string ("program --test foo --test bar", &argc);
296
 
  
297
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
298
 
  g_assert (retval);
299
 
 
300
 
  /* Last arg specified is the one that should be stored */
301
 
  g_assert (strcmp (arg_test2_string, "bar") == 0);
302
 
 
303
 
  g_free (arg_test2_string);
304
 
  
305
 
  g_strfreev (argv);
306
 
  g_option_context_free (context);
307
 
}
308
 
 
309
 
void
310
 
arg_test3 (void)
311
 
{
312
 
  GOptionContext *context;
313
 
  gboolean retval;
314
 
  GError *error = NULL;
315
 
  gchar **argv;
316
 
  int argc;
317
 
  GOptionEntry entries [] =
318
 
    { { "test", 0, 0, G_OPTION_ARG_FILENAME, &arg_test3_filename, NULL, NULL },
319
 
      { NULL } };
320
 
  
321
 
  context = g_option_context_new (NULL);
322
 
  g_option_context_add_main_entries (context, entries, NULL);
323
 
 
324
 
  /* Now try parsing */
325
 
  argv = split_string ("program --test foo.txt", &argc);
326
 
  
327
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
328
 
  g_assert (retval);
329
 
 
330
 
  /* Last arg specified is the one that should be stored */
331
 
  g_assert (strcmp (arg_test3_filename, "foo.txt") == 0);
332
 
 
333
 
  g_free (arg_test3_filename);
334
 
  
335
 
  g_strfreev (argv);
336
 
  g_option_context_free (context);
337
 
}
338
 
 
339
 
 
340
 
void
341
 
arg_test4 (void)
342
 
{
343
 
  GOptionContext *context;
344
 
  gboolean retval;
345
 
  GError *error = NULL;
346
 
  gchar **argv;
347
 
  int argc;
348
 
  GOptionEntry entries [] =
349
 
    { { "test", 0, 0, G_OPTION_ARG_DOUBLE, &arg_test4_double, NULL, NULL },
350
 
      { NULL } };
351
 
 
352
 
  context = g_option_context_new (NULL);
353
 
  g_option_context_add_main_entries (context, entries, NULL);
354
 
 
355
 
  /* Now try parsing */
356
 
  argv = split_string ("program --test 20.0 --test 30.03", &argc);
357
 
 
358
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
359
 
  g_assert (retval);
360
 
 
361
 
  /* Last arg specified is the one that should be stored */
362
 
  g_assert (arg_test4_double == 30.03);
363
 
 
364
 
  g_strfreev (argv);
365
 
  g_option_context_free (context);
366
 
}
367
 
 
368
 
void
369
 
arg_test5 (void)
370
 
{
371
 
  GOptionContext *context;
372
 
  gboolean retval;
373
 
  GError *error = NULL;
374
 
  gchar **argv;
375
 
  int argc;
376
 
  char *old_locale, *current_locale;
377
 
  const char *locale = "de_DE";
378
 
  GOptionEntry entries [] =
379
 
    { { "test", 0, 0, G_OPTION_ARG_DOUBLE, &arg_test5_double, NULL, NULL },
380
 
      { NULL } };
381
 
 
382
 
  context = g_option_context_new (NULL);
383
 
  g_option_context_add_main_entries (context, entries, NULL);
384
 
 
385
 
  /* Now try parsing */
386
 
  argv = split_string ("program --test 20,0 --test 30,03", &argc);
387
 
 
388
 
  /* set it to some locale that uses commas instead of decimal points */
389
 
  
390
 
  old_locale = g_strdup (setlocale (LC_NUMERIC, locale));
391
 
  current_locale = setlocale (LC_NUMERIC, NULL);
392
 
  if (strcmp (current_locale, locale) != 0)
393
 
    {
394
 
      fprintf (stderr, "Cannot set locale to %s, skipping\n", locale);
395
 
      goto cleanup; 
396
 
    }
397
 
 
398
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
399
 
  g_assert (retval);
400
 
 
401
 
  /* Last arg specified is the one that should be stored */
402
 
  g_assert (arg_test5_double == 30.03);
403
 
 
404
 
 cleanup:
405
 
  setlocale (LC_NUMERIC, old_locale);
406
 
  g_free (old_locale);
407
 
 
408
 
  g_strfreev (argv);
409
 
  g_option_context_free (context);
410
 
}
411
 
 
412
 
void
413
 
arg_test6 (void)
414
 
{
415
 
  GOptionContext *context;
416
 
  gboolean retval;
417
 
  GError *error = NULL;
418
 
  gchar **argv;
419
 
  int argc;
420
 
  GOptionEntry entries [] =
421
 
    { { "test", 0, 0, G_OPTION_ARG_INT64, &arg_test6_int64, NULL, NULL },
422
 
      { "test2", 0, 0, G_OPTION_ARG_INT64, &arg_test6_int64_2, NULL, NULL },
423
 
      { NULL } };
424
 
 
425
 
  context = g_option_context_new (NULL);
426
 
  g_option_context_add_main_entries (context, entries, NULL);
427
 
 
428
 
  /* Now try parsing */
429
 
  argv = split_string ("program --test 4294967297 --test 4294967296 --test2 0xfffffffff", &argc);
430
 
 
431
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
432
 
  g_assert (retval);
433
 
 
434
 
  /* Last arg specified is the one that should be stored */
435
 
  g_assert (arg_test6_int64 == G_GINT64_CONSTANT(4294967296));
436
 
  g_assert (arg_test6_int64_2 == G_GINT64_CONSTANT(0xfffffffff));
437
 
 
438
 
  g_strfreev (argv);
439
 
  g_option_context_free (context);
440
 
}
441
 
 
442
 
static gboolean
443
 
callback_parse1 (const gchar *option_name, const gchar *value,
444
 
                 gpointer data, GError **error)
445
 
{
446
 
        callback_test1_string = g_strdup (value);
447
 
        return TRUE;
448
 
}
449
 
 
450
 
void
451
 
callback_test1 (void)
452
 
{
453
 
  GOptionContext *context;
454
 
  gboolean retval;
455
 
  GError *error = NULL;
456
 
  gchar **argv;
457
 
  int argc;
458
 
  GOptionEntry entries [] =
459
 
    { { "test", 0, 0, G_OPTION_ARG_CALLBACK, callback_parse1, NULL, NULL },
460
 
      { NULL } };
461
 
  
462
 
  context = g_option_context_new (NULL);
463
 
  g_option_context_add_main_entries (context, entries, NULL);
464
 
 
465
 
  /* Now try parsing */
466
 
  argv = split_string ("program --test foo.txt", &argc);
467
 
  
468
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
469
 
  g_assert (retval);
470
 
 
471
 
  g_assert (strcmp (callback_test1_string, "foo.txt") == 0);
472
 
 
473
 
  g_free (callback_test1_string);
474
 
  
475
 
  g_strfreev (argv);
476
 
  g_option_context_free (context);
477
 
}
478
 
 
479
 
static gboolean
480
 
callback_parse2 (const gchar *option_name, const gchar *value,
481
 
                 gpointer data, GError **error)
482
 
{
483
 
        callback_test2_int++;
484
 
        return TRUE;
485
 
}
486
 
 
487
 
void
488
 
callback_test2 (void)
489
 
{
490
 
  GOptionContext *context;
491
 
  gboolean retval;
492
 
  GError *error = NULL;
493
 
  gchar **argv;
494
 
  int argc;
495
 
  GOptionEntry entries [] =
496
 
    { { "test", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, callback_parse2, NULL, NULL },
497
 
      { NULL } };
498
 
  
499
 
  context = g_option_context_new (NULL);
500
 
  g_option_context_add_main_entries (context, entries, NULL);
501
 
 
502
 
  /* Now try parsing */
503
 
  argv = split_string ("program --test --test", &argc);
504
 
  
505
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
506
 
  g_assert (retval);
507
 
 
508
 
  g_assert (callback_test2_int == 2);
509
 
  
510
 
  g_strfreev (argv);
511
 
  g_option_context_free (context);
512
 
}
513
 
 
514
 
static gboolean
515
 
callback_parse_optional (const gchar *option_name, const gchar *value,
516
 
                 gpointer data, GError **error)
517
 
{
518
 
        callback_test_optional_boolean = TRUE;
519
 
        if (value)
520
 
                callback_test_optional_string = g_strdup (value);
521
 
        else
522
 
                callback_test_optional_string = NULL;
523
 
        return TRUE;
524
 
}
525
 
 
526
 
void
527
 
callback_test_optional_1 (void)
528
 
{
529
 
  GOptionContext *context;
530
 
  gboolean retval;
531
 
  GError *error = NULL;
532
 
  gchar **argv;
533
 
  int argc;
534
 
  GOptionEntry entries [] =
535
 
    { { "test", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
536
 
        callback_parse_optional, NULL, NULL },
537
 
      { NULL } };
538
 
  
539
 
  context = g_option_context_new (NULL);
540
 
  g_option_context_add_main_entries (context, entries, NULL);
541
 
 
542
 
  /* Now try parsing */
543
 
  argv = split_string ("program --test foo.txt", &argc);
544
 
  
545
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
546
 
  g_assert (retval);
547
 
 
548
 
  g_assert (strcmp (callback_test_optional_string, "foo.txt") == 0);
549
 
  
550
 
  g_assert (callback_test_optional_boolean);
551
 
 
552
 
  g_free (callback_test_optional_string);
553
 
  
554
 
  g_strfreev (argv);
555
 
  g_option_context_free (context);
556
 
}
557
 
 
558
 
void
559
 
callback_test_optional_2 (void)
560
 
{
561
 
  GOptionContext *context;
562
 
  gboolean retval;
563
 
  GError *error = NULL;
564
 
  gchar **argv;
565
 
  int argc;
566
 
  GOptionEntry entries [] =
567
 
    { { "test", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
568
 
        callback_parse_optional, NULL, NULL },
569
 
      { NULL } };
570
 
  
571
 
  context = g_option_context_new (NULL);
572
 
  g_option_context_add_main_entries (context, entries, NULL);
573
 
 
574
 
  /* Now try parsing */
575
 
  argv = split_string ("program --test", &argc);
576
 
  
577
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
578
 
  g_assert (retval);
579
 
 
580
 
  g_assert (callback_test_optional_string == NULL);
581
 
  
582
 
  g_assert (callback_test_optional_boolean);
583
 
 
584
 
  g_free (callback_test_optional_string);
585
 
  
586
 
  g_strfreev (argv);
587
 
  g_option_context_free (context);
588
 
}
589
 
 
590
 
void
591
 
callback_test_optional_3 (void)
592
 
{
593
 
  GOptionContext *context;
594
 
  gboolean retval;
595
 
  GError *error = NULL;
596
 
  gchar **argv;
597
 
  int argc;
598
 
  GOptionEntry entries [] =
599
 
    { { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
600
 
        callback_parse_optional, NULL, NULL },
601
 
      { NULL } };
602
 
  
603
 
  context = g_option_context_new (NULL);
604
 
  g_option_context_add_main_entries (context, entries, NULL);
605
 
 
606
 
  /* Now try parsing */
607
 
  argv = split_string ("program -t foo.txt", &argc);
608
 
  
609
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
610
 
  g_assert (retval);
611
 
 
612
 
  g_assert (strcmp (callback_test_optional_string, "foo.txt") == 0);
613
 
  
614
 
  g_assert (callback_test_optional_boolean);
615
 
 
616
 
  g_free (callback_test_optional_string);
617
 
  
618
 
  g_strfreev (argv);
619
 
  g_option_context_free (context);
620
 
}
621
 
 
622
 
 
623
 
void
624
 
callback_test_optional_4 (void)
625
 
{
626
 
  GOptionContext *context;
627
 
  gboolean retval;
628
 
  GError *error = NULL;
629
 
  gchar **argv;
630
 
  int argc;
631
 
  GOptionEntry entries [] =
632
 
    { { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
633
 
        callback_parse_optional, NULL, NULL },
634
 
      { NULL } };
635
 
  
636
 
  context = g_option_context_new (NULL);
637
 
  g_option_context_add_main_entries (context, entries, NULL);
638
 
 
639
 
  /* Now try parsing */
640
 
  argv = split_string ("program -t", &argc);
641
 
  
642
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
643
 
  g_assert (retval);
644
 
 
645
 
  g_assert (callback_test_optional_string == NULL);
646
 
  
647
 
  g_assert (callback_test_optional_boolean);
648
 
 
649
 
  g_free (callback_test_optional_string);
650
 
  
651
 
  g_strfreev (argv);
652
 
  g_option_context_free (context);
653
 
}
654
 
 
655
 
void
656
 
callback_test_optional_5 (void)
657
 
{
658
 
  GOptionContext *context;
659
 
  gboolean dummy;
660
 
  gboolean retval;
661
 
  GError *error = NULL;
662
 
  gchar **argv;
663
 
  int argc;
664
 
  GOptionEntry entries [] =
665
 
    { { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
666
 
      { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
667
 
        callback_parse_optional, NULL, NULL },
668
 
      { NULL } };
669
 
  
670
 
  context = g_option_context_new (NULL);
671
 
  g_option_context_add_main_entries (context, entries, NULL);
672
 
 
673
 
  /* Now try parsing */
674
 
  argv = split_string ("program --test --dummy", &argc);
675
 
  
676
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
677
 
  g_assert (retval);
678
 
 
679
 
  g_assert (callback_test_optional_string == NULL);
680
 
  
681
 
  g_assert (callback_test_optional_boolean);
682
 
 
683
 
  g_free (callback_test_optional_string);
684
 
  
685
 
  g_strfreev (argv);
686
 
  g_option_context_free (context);
687
 
}
688
 
 
689
 
void
690
 
callback_test_optional_6 (void)
691
 
{
692
 
  GOptionContext *context;
693
 
  gboolean dummy;
694
 
  gboolean retval;
695
 
  GError *error = NULL;
696
 
  gchar **argv;
697
 
  int argc;
698
 
  GOptionEntry entries [] =
699
 
    { { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
700
 
      { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
701
 
        callback_parse_optional, NULL, NULL },
702
 
      { NULL } };
703
 
  
704
 
  context = g_option_context_new (NULL);
705
 
  g_option_context_add_main_entries (context, entries, NULL);
706
 
 
707
 
  /* Now try parsing */
708
 
  argv = split_string ("program -t -d", &argc);
709
 
  
710
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
711
 
  g_assert (retval);
712
 
 
713
 
  g_assert (callback_test_optional_string == NULL);
714
 
  
715
 
  g_assert (callback_test_optional_boolean);
716
 
 
717
 
  g_free (callback_test_optional_string);
718
 
  
719
 
  g_strfreev (argv);
720
 
  g_option_context_free (context);
721
 
}
722
 
 
723
 
void
724
 
callback_test_optional_7 (void)
725
 
{
726
 
  GOptionContext *context;
727
 
  gboolean dummy;
728
 
  gboolean retval;
729
 
  GError *error = NULL;
730
 
  gchar **argv;
731
 
  int argc;
732
 
  GOptionEntry entries [] =
733
 
    { { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
734
 
      { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
735
 
        callback_parse_optional, NULL, NULL },
736
 
      { NULL } };
737
 
  
738
 
  context = g_option_context_new (NULL);
739
 
  g_option_context_add_main_entries (context, entries, NULL);
740
 
 
741
 
  /* Now try parsing */
742
 
  argv = split_string ("program -td", &argc);
743
 
  
744
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
745
 
  g_assert (retval);
746
 
 
747
 
  g_assert (callback_test_optional_string == NULL);
748
 
  
749
 
  g_assert (callback_test_optional_boolean);
750
 
 
751
 
  g_free (callback_test_optional_string);
752
 
  
753
 
  g_strfreev (argv);
754
 
  g_option_context_free (context);
755
 
}
756
 
 
757
 
void
758
 
callback_test_optional_8 (void)
759
 
{
760
 
  GOptionContext *context;
761
 
  gboolean dummy;
762
 
  gboolean retval;
763
 
  GError *error = NULL;
764
 
  gchar **argv;
765
 
  int argc;
766
 
  GOptionEntry entries [] =
767
 
    { { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
768
 
      { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 
769
 
        callback_parse_optional, NULL, NULL },
770
 
      { NULL } };
771
 
  
772
 
  context = g_option_context_new (NULL);
773
 
  g_option_context_add_main_entries (context, entries, NULL);
774
 
 
775
 
  /* Now try parsing */
776
 
  argv = split_string ("program -dt foo.txt", &argc);
777
 
  
778
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
779
 
  g_assert (retval);
780
 
 
781
 
  g_assert (callback_test_optional_string);
782
 
  
783
 
  g_assert (callback_test_optional_boolean);
784
 
 
785
 
  g_free (callback_test_optional_string);
786
 
  
787
 
  g_strfreev (argv);
788
 
  g_option_context_free (context);
789
 
}
790
 
 
791
 
static GPtrArray *callback_remaining_args;
792
 
static gboolean
793
 
callback_remaining_test1_callback (const gchar *option_name, const gchar *value,
794
 
                         gpointer data, GError **error)
795
 
{
796
 
        g_ptr_array_add (callback_remaining_args, g_strdup (value));
797
 
        return TRUE;
798
 
}
799
 
 
800
 
void
801
 
callback_remaining_test1 (void)
802
 
{
803
 
  GOptionContext *context;
804
 
  gboolean retval;
805
 
  GError *error = NULL;
806
 
  gchar **argv;
807
 
  int argc;
808
 
  GOptionEntry entries [] =
809
 
    { { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_CALLBACK, callback_remaining_test1_callback, NULL, NULL },
810
 
      { NULL } };
811
 
  
812
 
  callback_remaining_args = g_ptr_array_new ();
813
 
  context = g_option_context_new (NULL);
814
 
  g_option_context_add_main_entries (context, entries, NULL);
815
 
 
816
 
  /* Now try parsing */
817
 
  argv = split_string ("program foo.txt blah.txt", &argc);
818
 
  
819
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
820
 
  g_assert (retval);
821
 
 
822
 
  g_assert (callback_remaining_args->len == 2);
823
 
  g_assert (strcmp (callback_remaining_args->pdata[0], "foo.txt") == 0);
824
 
  g_assert (strcmp (callback_remaining_args->pdata[1], "blah.txt") == 0);
825
 
 
826
 
  g_ptr_array_foreach (callback_remaining_args, (GFunc) g_free, NULL);
827
 
  g_ptr_array_free (callback_remaining_args, TRUE);
828
 
  
829
 
  g_strfreev (argv);
830
 
  g_option_context_free (context);
831
 
}
832
 
 
833
 
void
834
 
ignore_test1 (void)
835
 
{
836
 
  GOptionContext *context;
837
 
  gboolean retval;
838
 
  GError *error = NULL;
839
 
  gchar **argv, **argv_copy;
840
 
  int argc;
841
 
  gchar *arg;
842
 
  GOptionEntry entries [] =
843
 
    { { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
844
 
      { NULL } };
845
 
 
846
 
  context = g_option_context_new (NULL);
847
 
  g_option_context_set_ignore_unknown_options (context, TRUE);
848
 
  g_option_context_add_main_entries (context, entries, NULL);
849
 
 
850
 
  /* Now try parsing */
851
 
  argv = split_string ("program --test --hello", &argc);
852
 
  argv_copy = copy_stringv (argv, argc);
853
 
  
854
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
855
 
  g_assert (retval);
856
 
 
857
 
  /* Check array */
858
 
  arg = join_stringv (argc, argv);
859
 
  g_assert (strcmp (arg, "program --hello") == 0);
860
 
 
861
 
  g_free (arg);
862
 
  g_strfreev (argv_copy);
863
 
  g_free (argv);
864
 
  g_option_context_free (context);
865
 
}
866
 
 
867
 
void
868
 
ignore_test2 (void)
869
 
{
870
 
  GOptionContext *context;
871
 
  gboolean retval;
872
 
  GError *error = NULL;
873
 
  gchar **argv;
874
 
  int argc;
875
 
  gchar *arg;
876
 
  GOptionEntry entries [] =
877
 
    { { "test", 't', 0, G_OPTION_ARG_NONE, &ignore_test2_boolean, NULL, NULL },
878
 
      { NULL } };
879
 
 
880
 
  context = g_option_context_new (NULL);
881
 
  g_option_context_set_ignore_unknown_options (context, TRUE);
882
 
  g_option_context_add_main_entries (context, entries, NULL);
883
 
 
884
 
  /* Now try parsing */
885
 
  argv = split_string ("program -test", &argc);
886
 
  
887
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
888
 
  g_assert (retval);
889
 
 
890
 
  /* Check array */
891
 
  arg = join_stringv (argc, argv);
892
 
  g_assert (strcmp (arg, "program -es") == 0);
893
 
 
894
 
  g_free (arg);
895
 
  g_strfreev (argv);
896
 
  g_option_context_free (context);
897
 
}
898
 
 
899
 
void
900
 
ignore_test3 (void)
901
 
{
902
 
  GOptionContext *context;
903
 
  gboolean retval;
904
 
  GError *error = NULL;
905
 
  gchar **argv, **argv_copy;
906
 
  int argc;
907
 
  gchar *arg;
908
 
  GOptionEntry entries [] =
909
 
    { { "test", 0, 0, G_OPTION_ARG_STRING, &ignore_test3_string, NULL, NULL },
910
 
      { NULL } };
911
 
 
912
 
  context = g_option_context_new (NULL);
913
 
  g_option_context_set_ignore_unknown_options (context, TRUE);
914
 
  g_option_context_add_main_entries (context, entries, NULL);
915
 
 
916
 
  /* Now try parsing */
917
 
  argv = split_string ("program --test foo --hello", &argc);
918
 
  argv_copy = copy_stringv (argv, argc);
919
 
  
920
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
921
 
  g_assert (retval);
922
 
 
923
 
  /* Check array */
924
 
  arg = join_stringv (argc, argv);
925
 
  g_assert (strcmp (arg, "program --hello") == 0);
926
 
 
927
 
  g_assert (strcmp (ignore_test3_string, "foo") == 0);
928
 
  g_free (ignore_test3_string);
929
 
 
930
 
  g_free (arg);
931
 
  g_strfreev (argv_copy);
932
 
  g_free (argv);
933
 
  g_option_context_free (context);
934
 
}
935
 
 
936
 
void
937
 
array_test1 (void)
938
 
{
939
 
  GOptionContext *context;
940
 
  gboolean retval;
941
 
  GError *error = NULL;
942
 
  gchar **argv;
943
 
  int argc;
944
 
  GOptionEntry entries [] =
945
 
    { { "test", 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },
946
 
      { NULL } };
947
 
        
948
 
  context = g_option_context_new (NULL);
949
 
  g_option_context_add_main_entries (context, entries, NULL);
950
 
 
951
 
  /* Now try parsing */
952
 
  argv = split_string ("program --test foo --test bar", &argc);
953
 
  
954
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
955
 
  g_assert (retval);
956
 
 
957
 
  /* Check array */
958
 
  g_assert (strcmp (array_test1_array[0], "foo") == 0);
959
 
  g_assert (strcmp (array_test1_array[1], "bar") == 0);
960
 
  g_assert (array_test1_array[2] == NULL);
961
 
 
962
 
  g_strfreev (array_test1_array);
963
 
  
964
 
  g_strfreev (argv);
965
 
  g_option_context_free (context);
966
 
}
967
 
 
968
 
void
969
 
add_test1 (void)
970
 
{
971
 
  GOptionContext *context;
972
 
 
973
 
  GOptionEntry entries1 [] =
974
 
    { { "test1", 0, 0, G_OPTION_ARG_STRING_ARRAY, NULL, NULL, NULL },
975
 
      { NULL } };
976
 
  GOptionEntry entries2 [] =
977
 
    { { "test2", 0, 0, G_OPTION_ARG_STRING_ARRAY, NULL, NULL, NULL },
978
 
      { NULL } };
979
 
 
980
 
  context = g_option_context_new (NULL);
981
 
  g_option_context_add_main_entries (context, entries1, NULL);
982
 
  g_option_context_add_main_entries (context, entries2, NULL);
983
 
 
984
 
  g_option_context_free (context);
985
 
}
986
 
 
987
 
void
988
 
empty_test1 (void)
989
 
{
990
 
  GOptionContext *context;
991
 
  GOptionEntry entries [] =
992
 
    { { NULL } };
993
 
  char *prgname;
994
 
 
995
 
  g_set_prgname (NULL);
996
 
  context = g_option_context_new (NULL);
997
 
 
998
 
  g_option_context_add_main_entries (context, entries, NULL);
999
 
  
1000
 
  g_option_context_parse (context, NULL, NULL, NULL);
1001
 
 
1002
 
  prgname = g_get_prgname ();
1003
 
  g_assert (prgname && strcmp (prgname, "<unknown>") == 0);
1004
 
  
1005
 
  g_option_context_free (context);
1006
 
}
1007
 
 
1008
 
void
1009
 
empty_test2 (void)
1010
 
{
1011
 
  GOptionContext *context;
1012
 
 
1013
 
  context = g_option_context_new (NULL);
1014
 
  g_option_context_parse (context, NULL, NULL, NULL);
1015
 
  
1016
 
  g_option_context_free (context);
1017
 
}
1018
 
 
1019
 
void
1020
 
empty_test3 (void)
1021
 
{
1022
 
  GOptionContext *context;
1023
 
  gint argc;
1024
 
  gchar **argv;
1025
 
 
1026
 
  argc = 0;
1027
 
  argv = NULL;
1028
 
 
1029
 
  context = g_option_context_new (NULL);
1030
 
  g_option_context_parse (context, &argc, &argv, NULL);
1031
 
  
1032
 
  g_option_context_free (context);
1033
 
}
1034
 
 
1035
 
/* check that non-option arguments are left in argv by default */
1036
 
void
1037
 
rest_test1 (void)
1038
 
{
1039
 
  GOptionContext *context;
1040
 
  gboolean retval;
1041
 
  GError *error = NULL;
1042
 
  gchar **argv;
1043
 
  int argc;
1044
 
  GOptionEntry entries [] = { 
1045
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1046
 
      { NULL } 
1047
 
  };
1048
 
        
1049
 
  context = g_option_context_new (NULL);
1050
 
  g_option_context_add_main_entries (context, entries, NULL);
1051
 
 
1052
 
  /* Now try parsing */
1053
 
  argv = split_string ("program foo --test bar", &argc);
1054
 
  
1055
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1056
 
  g_assert (retval);
1057
 
 
1058
 
  /* Check array */
1059
 
  g_assert (ignore_test1_boolean);
1060
 
  g_assert (strcmp (argv[0], "program") == 0);
1061
 
  g_assert (strcmp (argv[1], "foo") == 0);
1062
 
  g_assert (strcmp (argv[2], "bar") == 0);
1063
 
  g_assert (argv[3] == NULL);
1064
 
 
1065
 
  g_strfreev (argv);
1066
 
  g_option_context_free (context);
1067
 
}
1068
 
 
1069
 
/* check that -- works */
1070
 
void
1071
 
rest_test2 (void)
1072
 
{
1073
 
  GOptionContext *context;
1074
 
  gboolean retval;
1075
 
  GError *error = NULL;
1076
 
  gchar **argv;
1077
 
  int argc;
1078
 
  GOptionEntry entries [] = { 
1079
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1080
 
      { NULL } 
1081
 
  };
1082
 
        
1083
 
  context = g_option_context_new (NULL);
1084
 
  g_option_context_add_main_entries (context, entries, NULL);
1085
 
 
1086
 
  /* Now try parsing */
1087
 
  argv = split_string ("program foo --test -- -bar", &argc);
1088
 
  
1089
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1090
 
  g_assert (retval);
1091
 
 
1092
 
  /* Check array */
1093
 
  g_assert (ignore_test1_boolean);
1094
 
  g_assert (strcmp (argv[0], "program") == 0);
1095
 
  g_assert (strcmp (argv[1], "foo") == 0);
1096
 
  g_assert (strcmp (argv[2], "--") == 0);
1097
 
  g_assert (strcmp (argv[3], "-bar") == 0);
1098
 
  g_assert (argv[4] == NULL);
1099
 
 
1100
 
  g_strfreev (argv);
1101
 
  g_option_context_free (context);
1102
 
}
1103
 
 
1104
 
/* check that -- stripping works */
1105
 
void
1106
 
rest_test2a (void)
1107
 
{
1108
 
  GOptionContext *context;
1109
 
  gboolean retval;
1110
 
  GError *error = NULL;
1111
 
  gchar **argv;
1112
 
  int argc;
1113
 
  GOptionEntry entries [] = { 
1114
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1115
 
      { NULL } 
1116
 
  };
1117
 
        
1118
 
  context = g_option_context_new (NULL);
1119
 
  g_option_context_add_main_entries (context, entries, NULL);
1120
 
 
1121
 
  /* Now try parsing */
1122
 
  argv = split_string ("program foo --test -- bar", &argc);
1123
 
  
1124
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1125
 
  g_assert (retval);
1126
 
 
1127
 
  /* Check array */
1128
 
  g_assert (ignore_test1_boolean);
1129
 
  g_assert (strcmp (argv[0], "program") == 0);
1130
 
  g_assert (strcmp (argv[1], "foo") == 0);
1131
 
  g_assert (strcmp (argv[2], "bar") == 0);
1132
 
  g_assert (argv[3] == NULL);
1133
 
 
1134
 
  g_strfreev (argv);
1135
 
  g_option_context_free (context);
1136
 
}
1137
 
 
1138
 
void
1139
 
rest_test2b (void)
1140
 
{
1141
 
  GOptionContext *context;
1142
 
  gboolean retval;
1143
 
  GError *error = NULL;
1144
 
  gchar **argv;
1145
 
  int argc;
1146
 
  GOptionEntry entries [] = { 
1147
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1148
 
      { NULL } 
1149
 
  };
1150
 
        
1151
 
  context = g_option_context_new (NULL);
1152
 
  g_option_context_set_ignore_unknown_options (context, TRUE);
1153
 
  g_option_context_add_main_entries (context, entries, NULL);
1154
 
 
1155
 
  /* Now try parsing */
1156
 
  argv = split_string ("program foo --test -bar --", &argc);
1157
 
  
1158
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1159
 
  g_assert (retval);
1160
 
 
1161
 
  /* Check array */
1162
 
  g_assert (ignore_test1_boolean);
1163
 
  g_assert (strcmp (argv[0], "program") == 0);
1164
 
  g_assert (strcmp (argv[1], "foo") == 0);
1165
 
  g_assert (strcmp (argv[2], "-bar") == 0);
1166
 
  g_assert (argv[3] == NULL);
1167
 
 
1168
 
  g_strfreev (argv);
1169
 
  g_option_context_free (context);
1170
 
}
1171
 
 
1172
 
void
1173
 
rest_test2c (void)
1174
 
{
1175
 
  GOptionContext *context;
1176
 
  gboolean retval;
1177
 
  GError *error = NULL;
1178
 
  gchar **argv;
1179
 
  int argc;
1180
 
  GOptionEntry entries [] = { 
1181
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1182
 
      { NULL } 
1183
 
  };
1184
 
        
1185
 
  context = g_option_context_new (NULL);
1186
 
  g_option_context_add_main_entries (context, entries, NULL);
1187
 
 
1188
 
  /* Now try parsing */
1189
 
  argv = split_string ("program --test foo -- bar", &argc);
1190
 
  
1191
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1192
 
  g_assert (retval);
1193
 
 
1194
 
  /* Check array */
1195
 
  g_assert (ignore_test1_boolean);
1196
 
  g_assert (strcmp (argv[0], "program") == 0);
1197
 
  g_assert (strcmp (argv[1], "foo") == 0);
1198
 
  g_assert (strcmp (argv[2], "bar") == 0);
1199
 
  g_assert (argv[3] == NULL);
1200
 
 
1201
 
  g_strfreev (argv);
1202
 
  g_option_context_free (context);
1203
 
}
1204
 
 
1205
 
void
1206
 
rest_test2d (void)
1207
 
{
1208
 
  GOptionContext *context;
1209
 
  gboolean retval;
1210
 
  GError *error = NULL;
1211
 
  gchar **argv;
1212
 
  int argc;
1213
 
  GOptionEntry entries [] = { 
1214
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1215
 
      { NULL } 
1216
 
  };
1217
 
        
1218
 
  context = g_option_context_new (NULL);
1219
 
  g_option_context_add_main_entries (context, entries, NULL);
1220
 
 
1221
 
  /* Now try parsing */
1222
 
  argv = split_string ("program --test -- -bar", &argc);
1223
 
  
1224
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1225
 
  g_assert (retval);
1226
 
 
1227
 
  /* Check array */
1228
 
  g_assert (ignore_test1_boolean);
1229
 
  g_assert (strcmp (argv[0], "program") == 0);
1230
 
  g_assert (strcmp (argv[1], "--") == 0);
1231
 
  g_assert (strcmp (argv[2], "-bar") == 0);
1232
 
  g_assert (argv[3] == NULL);
1233
 
 
1234
 
  g_strfreev (argv);
1235
 
  g_option_context_free (context);
1236
 
}
1237
 
 
1238
 
 
1239
 
/* check that G_OPTION_REMAINING collects non-option arguments */
1240
 
void
1241
 
rest_test3 (void)
1242
 
{
1243
 
  GOptionContext *context;
1244
 
  gboolean retval;
1245
 
  GError *error = NULL;
1246
 
  gchar **argv;
1247
 
  int argc;
1248
 
  GOptionEntry entries [] = { 
1249
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1250
 
      { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },
1251
 
      { NULL } 
1252
 
  };
1253
 
        
1254
 
  context = g_option_context_new (NULL);
1255
 
  g_option_context_add_main_entries (context, entries, NULL);
1256
 
 
1257
 
  /* Now try parsing */
1258
 
  argv = split_string ("program foo --test bar", &argc);
1259
 
  
1260
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1261
 
  g_assert (retval);
1262
 
 
1263
 
  /* Check array */
1264
 
  g_assert (ignore_test1_boolean);
1265
 
  g_assert (strcmp (array_test1_array[0], "foo") == 0);
1266
 
  g_assert (strcmp (array_test1_array[1], "bar") == 0);
1267
 
  g_assert (array_test1_array[2] == NULL);
1268
 
 
1269
 
  g_strfreev (array_test1_array);
1270
 
  
1271
 
  g_strfreev (argv);
1272
 
  g_option_context_free (context);
1273
 
}
1274
 
 
1275
 
 
1276
 
/* check that G_OPTION_REMAINING and -- work together */
1277
 
void
1278
 
rest_test4 (void)
1279
 
{
1280
 
  GOptionContext *context;
1281
 
  gboolean retval;
1282
 
  GError *error = NULL;
1283
 
  gchar **argv;
1284
 
  int argc;
1285
 
  GOptionEntry entries [] = { 
1286
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1287
 
      { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },
1288
 
      { NULL } 
1289
 
  };
1290
 
        
1291
 
  context = g_option_context_new (NULL);
1292
 
  g_option_context_add_main_entries (context, entries, NULL);
1293
 
 
1294
 
  /* Now try parsing */
1295
 
  argv = split_string ("program foo --test -- -bar", &argc);
1296
 
  
1297
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1298
 
  g_assert (retval);
1299
 
 
1300
 
  /* Check array */
1301
 
  g_assert (ignore_test1_boolean);
1302
 
  g_assert (strcmp (array_test1_array[0], "foo") == 0);
1303
 
  g_assert (strcmp (array_test1_array[1], "-bar") == 0);
1304
 
  g_assert (array_test1_array[2] == NULL);
1305
 
 
1306
 
  g_strfreev (array_test1_array);
1307
 
  
1308
 
  g_strfreev (argv);
1309
 
  g_option_context_free (context);
1310
 
}
1311
 
 
1312
 
/* test that G_OPTION_REMAINING works with G_OPTION_ARG_FILENAME_ARRAY */
1313
 
void
1314
 
rest_test5 (void)
1315
 
{
1316
 
  GOptionContext *context;
1317
 
  gboolean retval;
1318
 
  GError *error = NULL;
1319
 
  gchar **argv;
1320
 
  int argc;
1321
 
  GOptionEntry entries [] = { 
1322
 
      { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
1323
 
      { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &array_test1_array, NULL, NULL },
1324
 
      { NULL } 
1325
 
  };
1326
 
        
1327
 
  context = g_option_context_new (NULL);
1328
 
  g_option_context_add_main_entries (context, entries, NULL);
1329
 
 
1330
 
  /* Now try parsing */
1331
 
  argv = split_string ("program foo --test bar", &argc);
1332
 
  
1333
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1334
 
  g_assert (retval);
1335
 
 
1336
 
  /* Check array */
1337
 
  g_assert (ignore_test1_boolean);
1338
 
  g_assert (strcmp (array_test1_array[0], "foo") == 0);
1339
 
  g_assert (strcmp (array_test1_array[1], "bar") == 0);
1340
 
  g_assert (array_test1_array[2] == NULL);
1341
 
 
1342
 
  g_strfreev (array_test1_array);
1343
 
  
1344
 
  g_strfreev (argv);
1345
 
  g_option_context_free (context);
1346
 
}
1347
 
 
1348
 
void
1349
 
unknown_short_test (void)
1350
 
{
1351
 
  GOptionContext *context;
1352
 
  gboolean retval;
1353
 
  GError *error = NULL;
1354
 
  gchar **argv;
1355
 
  int argc;
1356
 
  GOptionEntry entries [] = { { NULL } };
1357
 
 
1358
 
  context = g_option_context_new (NULL);
1359
 
  g_option_context_add_main_entries (context, entries, NULL);
1360
 
 
1361
 
  /* Now try parsing */
1362
 
  argv = split_string ("program -0", &argc);
1363
 
 
1364
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1365
 
  g_assert (!retval);
1366
 
 
1367
 
  g_strfreev (argv);
1368
 
  g_option_context_free (context);
1369
 
}
1370
 
 
1371
 
/* test that lone dashes are treated as non-options */
1372
 
void lonely_dash_test (void)
1373
 
{
1374
 
  GOptionContext *context;
1375
 
  gboolean retval;
1376
 
  GError *error = NULL;
1377
 
  gchar **argv;
1378
 
  int argc;
1379
 
 
1380
 
  context = g_option_context_new (NULL);
1381
 
 
1382
 
  /* Now try parsing */
1383
 
  argv = split_string ("program -", &argc);
1384
 
 
1385
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1386
 
 
1387
 
  g_assert (retval);
1388
 
 
1389
 
  g_assert (argv[1] && strcmp (argv[1], "-") == 0);
1390
 
 
1391
 
  g_strfreev (argv);
1392
 
  g_option_context_free (context);
1393
 
}
1394
 
 
1395
 
void
1396
 
missing_arg_test (void)
1397
 
{
1398
 
  GOptionContext *context;
1399
 
  gboolean retval;
1400
 
  GError *error = NULL;
1401
 
  gchar **argv;
1402
 
  int argc;
1403
 
  gchar *arg = NULL;
1404
 
  GOptionEntry entries [] =
1405
 
    { { "test", 't', 0, G_OPTION_ARG_STRING, &arg, NULL, NULL },
1406
 
      { NULL } };
1407
 
 
1408
 
  context = g_option_context_new (NULL);
1409
 
  g_option_context_add_main_entries (context, entries, NULL);
1410
 
 
1411
 
  /* Now try parsing */
1412
 
  argv = split_string ("program --test", &argc);
1413
 
 
1414
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1415
 
  g_assert (retval == FALSE);
1416
 
  g_clear_error (&error);
1417
 
 
1418
 
  g_strfreev (argv);
1419
 
 
1420
 
  /* Try parsing again */
1421
 
  argv = split_string ("program --t", &argc);
1422
 
 
1423
 
  retval = g_option_context_parse (context, &argc, &argv, &error);
1424
 
  g_assert (retval == FALSE);
1425
 
 
1426
 
  g_strfreev (argv);
1427
 
  g_option_context_free (context);
1428
 
}
1429
 
 
1430
 
int
1431
 
main (int argc, char **argv)
1432
 
{
1433
 
  /* Test that restoration on failure works */
1434
 
  error_test1_int = 0x12345678;
1435
 
  error_test1 ();
1436
 
  error_test2_string = "foo";
1437
 
  error_test2 ();
1438
 
  error_test3_boolean = FALSE;
1439
 
  error_test3 ();
1440
 
  
1441
 
  /* Test that special argument parsing works */
1442
 
  arg_test1 ();
1443
 
  arg_test2 ();
1444
 
  arg_test3 ();
1445
 
  arg_test4 ();
1446
 
  arg_test5 ();
1447
 
  arg_test6 ();
1448
 
 
1449
 
  /* Test string arrays */
1450
 
  array_test1 ();
1451
 
 
1452
 
  /* Test callback args */
1453
 
  callback_test1 ();
1454
 
  callback_test2 ();
1455
 
 
1456
 
  /* Test optional arg flag for callback */
1457
 
  callback_test_optional_1 ();
1458
 
  callback_test_optional_2 ();
1459
 
  callback_test_optional_3 ();
1460
 
  callback_test_optional_4 ();
1461
 
  callback_test_optional_5 ();
1462
 
  callback_test_optional_6 ();
1463
 
  callback_test_optional_7 ();
1464
 
  callback_test_optional_8 ();
1465
 
 
1466
 
  /* Test callback with G_OPTION_REMAINING */
1467
 
  callback_remaining_test1 ();
1468
 
  
1469
 
  /* Test ignoring options */
1470
 
  ignore_test1 ();
1471
 
  ignore_test2 ();
1472
 
  ignore_test3 ();
1473
 
 
1474
 
  add_test1 ();
1475
 
 
1476
 
  /* Test parsing empty args */
1477
 
  empty_test1 ();
1478
 
  empty_test2 ();
1479
 
  empty_test3 ();
1480
 
 
1481
 
  /* Test handling of rest args */
1482
 
  rest_test1 ();
1483
 
  rest_test2 ();
1484
 
  rest_test2a ();
1485
 
  rest_test2b ();
1486
 
  rest_test2c ();
1487
 
  rest_test2d ();
1488
 
  rest_test3 ();
1489
 
  rest_test4 ();
1490
 
  rest_test5 ();
1491
 
 
1492
 
  /* test for bug 166609 */
1493
 
  unknown_short_test ();
1494
 
 
1495
 
  /* test for bug 168008 */
1496
 
  lonely_dash_test ();
1497
 
 
1498
 
  /* test for bug 305576 */
1499
 
  missing_arg_test ();
1500
 
 
1501
 
  return 0;
1502
 
}