← Back to branch summary

~ubuntu-branches/ubuntu/lucid/alsa-lib/lucid

« back to all changes in this revision

Viewing changes to test/lsb/config.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2009-11-04 19:04:11 UTC
  • mfrom: (1.1.12 upstream) (2.2.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091104190411-igse8f4bzca8dq5x
Tags: 1.0.21a-1ubuntu1
* Merge from debian unstable, remaining changes:
  - debian/rules:
    + Don't bail when removing include/alsa
  - debian/control: Add Vcs-Bzr URI
  - Add configuration files for bluetooth/bluez-alsa and pulseaudio
  - debian/libasound2.install: Ship smixer plugins for native and bi-arch
    packages
  - drop libcxxtools-dev build dependency, its in universe
  - debian/patches/Fix-fpe-snd_pcm_mmap_begin.patch: Handle attempts to
    divide by zero

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/lsb/config.c
 
1
#include <stdlib.h>
 
2
#include <string.h>
 
3
#include <errno.h>
 
4
#include "test.h"
 
5
 
 
6
static int configs_equal(snd_config_t *c1, snd_config_t *c2);
 
7
 
 
8
/* checks if all children of c1 also occur in c2 */
 
9
static int subset_of(snd_config_t *c1, snd_config_t *c2)
 
10
{
 
11
        snd_config_iterator_t i, next;
 
12
        snd_config_t *e1, *e2;
 
13
        const char *id;
 
14
 
 
15
        snd_config_for_each(i, next, c1) {
 
16
                e1 = snd_config_iterator_entry(i);
 
17
                if (snd_config_get_id(e1, &id) < 0 || !id)
 
18
                        return 0;
 
19
                if (snd_config_search(c2, id, &e2) < 0)
 
20
                        return 0;
 
21
                if (!configs_equal(e1, e2))
 
22
                        return 0;
 
23
        }
 
24
        return 1;
 
25
}
 
26
 
 
27
/* checks if two configuration nodes are equal */
 
28
static int configs_equal(snd_config_t *c1, snd_config_t *c2)
 
29
{
 
30
        long i1, i2;
 
31
        long long i641, i642;
 
32
        const char *s1, *s2;
 
33
 
 
34
        if (snd_config_get_type(c1) != snd_config_get_type(c2))
 
35
                return 0;
 
36
        switch (snd_config_get_type(c1)) {
 
37
        case SND_CONFIG_TYPE_INTEGER:
 
38
                return snd_config_get_integer(c1, &i1) >= 0 &&
 
39
                        snd_config_get_integer(c2, &i2) >= 0 &&
 
40
                        i1 == i2;
 
41
        case SND_CONFIG_TYPE_INTEGER64:
 
42
                return snd_config_get_integer64(c1, &i641) >= 0 &&
 
43
                        snd_config_get_integer64(c2, &i642) >= 0 &&
 
44
                        i641 == i642;
 
45
        case SND_CONFIG_TYPE_STRING:
 
46
                return snd_config_get_string(c1, &s1) >= 0 &&
 
47
                        snd_config_get_string(c2, &s2) >= 0 &&
 
48
                        !s1 == !s2 &&
 
49
                        (!s1 || !strcmp(s1, s2));
 
50
        case SND_CONFIG_TYPE_COMPOUND:
 
51
                return subset_of(c1, c2) && subset_of(c2, c1);
 
52
        default:
 
53
                fprintf(stderr, "unknown configuration node type %d\n",
 
54
                        (int)snd_config_get_type(c1));
 
55
                return 0;
 
56
        }
 
57
}
 
58
 
 
59
static void test_top(void)
 
60
{
 
61
        snd_config_t *top;
 
62
        const char *id;
 
63
 
 
64
        if (ALSA_CHECK(snd_config_top(&top)) < 0)
 
65
                return;
 
66
 
 
67
        TEST_CHECK(snd_config_get_type(top) == SND_CONFIG_TYPE_COMPOUND);
 
68
        TEST_CHECK(snd_config_iterator_first(top) == snd_config_iterator_end(top));
 
69
        TEST_CHECK(snd_config_get_id(top, &id) >= 0 && id == NULL);
 
70
 
 
71
        ALSA_CHECK(snd_config_delete(top));
 
72
}
 
73
 
 
74
static void test_load(void)
 
75
{
 
76
        const char *config_text1 = "s='world';";
 
77
        const char *config_text2 = "c.elem 0";
 
78
        snd_config_t *loaded, *made, *c, *c2;
 
79
        snd_input_t *input;
 
80
 
 
81
        ALSA_CHECK(snd_config_top(&loaded));
 
82
        ALSA_CHECK(snd_config_imake_integer(&c, "i", 42));
 
83
        ALSA_CHECK(snd_config_add(loaded, c));
 
84
        ALSA_CHECK(snd_config_imake_string(&c, "s", "hello"));
 
85
        ALSA_CHECK(snd_config_add(loaded, c));
 
86
 
 
87
        ALSA_CHECK(snd_config_top(&made));
 
88
        ALSA_CHECK(snd_config_imake_string(&c, "s", "world"));
 
89
        ALSA_CHECK(snd_config_add(made, c));
 
90
        ALSA_CHECK(snd_config_imake_integer(&c, "i", 42));
 
91
        ALSA_CHECK(snd_config_add(made, c));
 
92
 
 
93
        ALSA_CHECK(snd_input_buffer_open(&input, config_text1, strlen(config_text1)));
 
94
        ALSA_CHECK(snd_config_load(loaded, input));
 
95
        ALSA_CHECK(snd_input_close(input));
 
96
        TEST_CHECK(configs_equal(loaded, made));
 
97
 
 
98
        ALSA_CHECK(snd_config_make_compound(&c, "c", 0));
 
99
        ALSA_CHECK(snd_config_add(made, c));
 
100
        ALSA_CHECK(snd_config_imake_integer(&c2, "elem", 0));
 
101
        ALSA_CHECK(snd_config_add(c, c2));
 
102
 
 
103
        ALSA_CHECK(snd_input_buffer_open(&input, config_text2, strlen(config_text2)));
 
104
        ALSA_CHECK(snd_config_load(loaded, input));
 
105
        ALSA_CHECK(snd_input_close(input));
 
106
        TEST_CHECK(configs_equal(loaded, made));
 
107
 
 
108
        ALSA_CHECK(snd_config_delete(loaded));
 
109
        ALSA_CHECK(snd_config_delete(made));
 
110
}
 
111
 
 
112
static void test_save(void)
 
113
{
 
114
        const char *text =
 
115
                "a.b.c 'x.y.z'\n"
 
116
                "xxx = yyy;\n"
 
117
                "q { qq=qqq }\n"
 
118
                "a [ 1 2 3 4 5 '...' ]\n";
 
119
        snd_config_t *orig, *saved;
 
120
        snd_input_t *input;
 
121
        snd_output_t *output;
 
122
        char *buf;
 
123
        size_t buf_size;
 
124
 
 
125
        ALSA_CHECK(snd_input_buffer_open(&input, text, strlen(text)));
 
126
        ALSA_CHECK(snd_config_top(&orig));
 
127
        ALSA_CHECK(snd_config_load(orig, input));
 
128
        ALSA_CHECK(snd_input_close(input));
 
129
        ALSA_CHECK(snd_output_buffer_open(&output));
 
130
        ALSA_CHECK(snd_config_save(orig, output));
 
131
        buf_size = snd_output_buffer_string(output, &buf);
 
132
        ALSA_CHECK(snd_input_buffer_open(&input, buf, buf_size));
 
133
        ALSA_CHECK(snd_config_top(&saved));
 
134
        ALSA_CHECK(snd_config_load(saved, input));
 
135
        ALSA_CHECK(snd_input_close(input));
 
136
        ALSA_CHECK(snd_output_close(output));
 
137
        TEST_CHECK(configs_equal(orig, saved));
 
138
        ALSA_CHECK(snd_config_delete(orig));
 
139
        ALSA_CHECK(snd_config_delete(saved));
 
140
}
 
141
 
 
142
static void test_update(void)
 
143
{
 
144
        ALSA_CHECK(snd_config_update_free_global());
 
145
        TEST_CHECK(snd_config == NULL);
 
146
        ALSA_CHECK(snd_config_update());
 
147
        TEST_CHECK(snd_config_get_type(snd_config) == SND_CONFIG_TYPE_COMPOUND);
 
148
        ALSA_CHECK(snd_config_update());
 
149
        TEST_CHECK(snd_config_get_type(snd_config) == SND_CONFIG_TYPE_COMPOUND);
 
150
        ALSA_CHECK(snd_config_update_free_global());
 
151
        TEST_CHECK(snd_config == NULL);
 
152
}
 
153
 
 
154
static void test_search(void)
 
155
{
 
156
        const char *text =
 
157
                "a 42\n"
 
158
                "b {\n"
 
159
                "    c cee\n"
 
160
                "    d {\n"
 
161
                "        e 2.71828\n"
 
162
                "    }\n"
 
163
                "}\n";
 
164
        snd_input_t *input;
 
165
        snd_config_t *top, *c;
 
166
        const char *id;
 
167
 
 
168
        ALSA_CHECK(snd_input_buffer_open(&input, text, strlen(text)));
 
169
        ALSA_CHECK(snd_config_top(&top));
 
170
        ALSA_CHECK(snd_config_load(top, input));
 
171
        ALSA_CHECK(snd_input_close(input));
 
172
 
 
173
        ALSA_CHECK(snd_config_search(top, "a", &c));
 
174
        ALSA_CHECK(snd_config_get_id(c, &id));
 
175
        TEST_CHECK(!strcmp(id, "a"));
 
176
        ALSA_CHECK(snd_config_search(top, "b.d.e", &c));
 
177
        ALSA_CHECK(snd_config_get_id(c, &id));
 
178
        TEST_CHECK(!strcmp(id, "e"));
 
179
        ALSA_CHECK(snd_config_search(top, "b.c", NULL));
 
180
        TEST_CHECK(snd_config_search(top, "x", NULL) == -ENOENT);
 
181
        TEST_CHECK(snd_config_search(top, "b.y", &c) == -ENOENT);
 
182
        TEST_CHECK(snd_config_search(top, "a.z", &c) == -ENOENT);
 
183
 
 
184
        ALSA_CHECK(snd_config_delete(top));
 
185
}
 
186
 
 
187
static void test_searchv(void)
 
188
{
 
189
        const char *text =
 
190
                "a 42\n"
 
191
                "b {\n"
 
192
                "    c cee\n"
 
193
                "    d {\n"
 
194
                "        e 2.71828\n"
 
195
                "    }\n"
 
196
                "}\n";
 
197
        snd_input_t *input;
 
198
        snd_config_t *top, *c;
 
199
        const char *id;
 
200
 
 
201
        ALSA_CHECK(snd_input_buffer_open(&input, text, strlen(text)));
 
202
        ALSA_CHECK(snd_config_top(&top));
 
203
        ALSA_CHECK(snd_config_load(top, input));
 
204
        ALSA_CHECK(snd_input_close(input));
 
205
 
 
206
        ALSA_CHECK(snd_config_searchv(top, &c, "a", NULL));
 
207
        ALSA_CHECK(snd_config_get_id(c, &id));
 
208
        TEST_CHECK(!strcmp(id, "a"));
 
209
        ALSA_CHECK(snd_config_searchv(top, &c, "b", "d.e", NULL));
 
210
        ALSA_CHECK(snd_config_get_id(c, &id));
 
211
        TEST_CHECK(!strcmp(id, "e"));
 
212
        ALSA_CHECK(snd_config_searchv(top, NULL, "b.c", NULL));
 
213
        TEST_CHECK(snd_config_searchv(top, NULL, "x", NULL) == -ENOENT);
 
214
        TEST_CHECK(snd_config_searchv(top, &c, "b.y", NULL) == -ENOENT);
 
215
        TEST_CHECK(snd_config_searchv(top, &c, "a", "z", NULL) == -ENOENT);
 
216
 
 
217
        ALSA_CHECK(snd_config_delete(top));
 
218
}
 
219
 
 
220
static void test_add(void)
 
221
{
 
222
        snd_config_t *c1, *c2, *c3, *c4, *c5;
 
223
        snd_config_iterator_t i;
 
224
        unsigned int count = 0;
 
225
 
 
226
        ALSA_CHECK(snd_config_top(&c1));
 
227
        ALSA_CHECK(snd_config_imake_integer(&c2, "c2", 0xc2));
 
228
        ALSA_CHECK(snd_config_add(c1, c2));
 
229
        ALSA_CHECK(snd_config_imake_string(&c3, "c3", "c3"));
 
230
        ALSA_CHECK(snd_config_add(c1, c3));
 
231
        for (i = snd_config_iterator_first(c1);
 
232
             i != snd_config_iterator_end(c1);
 
233
             i = snd_config_iterator_next(i))
 
234
                ++count;
 
235
        TEST_CHECK(count == 2);
 
236
        ALSA_CHECK(snd_config_search(c1, "c2", &c2));
 
237
        ALSA_CHECK(snd_config_search(c1, "c3", &c3));
 
238
        ALSA_CHECK(snd_config_top(&c4));
 
239
        TEST_CHECK(snd_config_add(c1, c4) == -EINVAL);
 
240
        ALSA_CHECK(snd_config_imake_integer(&c5, "c5", 5));
 
241
        ALSA_CHECK(snd_config_add(c4, c5));
 
242
        TEST_CHECK(snd_config_add(c1, c5) == -EINVAL);
 
243
        ALSA_CHECK(snd_config_delete(c4));
 
244
        ALSA_CHECK(snd_config_imake_integer(&c3, "c3", 333));
 
245
        TEST_CHECK(snd_config_add(c1, c3) == -EEXIST);
 
246
        ALSA_CHECK(snd_config_delete(c3));
 
247
        ALSA_CHECK(snd_config_delete(c1));
 
248
}
 
249
 
 
250
static void test_delete(void)
 
251
{
 
252
        snd_config_t *c;
 
253
 
 
254
        ALSA_CHECK(snd_config_top(&c));
 
255
        ALSA_CHECK(snd_config_delete(c));
 
256
        ALSA_CHECK(snd_config_imake_string(&c, "s", "..."));
 
257
        ALSA_CHECK(snd_config_delete(c));
 
258
}
 
259
 
 
260
static void test_copy(void)
 
261
{
 
262
        snd_config_t *c1, *c2, *c3;
 
263
        long value;
 
264
 
 
265
        ALSA_CHECK(snd_config_imake_integer(&c1, "c1", 123));
 
266
        ALSA_CHECK(snd_config_copy(&c2, c1));
 
267
        ALSA_CHECK(snd_config_set_integer(c1, 456));
 
268
        TEST_CHECK(snd_config_get_type(c2) == SND_CONFIG_TYPE_INTEGER);
 
269
        ALSA_CHECK(snd_config_get_integer(c2, &value));
 
270
        TEST_CHECK(value == 123);
 
271
        ALSA_CHECK(snd_config_delete(c1));
 
272
        ALSA_CHECK(snd_config_delete(c2));
 
273
        ALSA_CHECK(snd_config_top(&c1));
 
274
        ALSA_CHECK(snd_config_imake_integer(&c2, "a", 1));
 
275
        ALSA_CHECK(snd_config_add(c1, c2));
 
276
        ALSA_CHECK(snd_config_copy(&c3, c1));
 
277
        ALSA_CHECK(snd_config_set_integer(c2, 2));
 
278
        TEST_CHECK(!configs_equal(c1, c3));
 
279
        ALSA_CHECK(snd_config_search(c3, "a", &c2));
 
280
        ALSA_CHECK(snd_config_set_integer(c2, 2));
 
281
        TEST_CHECK(configs_equal(c1, c3));
 
282
        ALSA_CHECK(snd_config_delete(c1));
 
283
        ALSA_CHECK(snd_config_delete(c3));
 
284
}
 
285
 
 
286
static void test_make_integer(void)
 
287
{
 
288
        snd_config_t *c;
 
289
        const char *id;
 
290
        long value;
 
291
 
 
292
        ALSA_CHECK(snd_config_make_integer(&c, "i"));
 
293
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_INTEGER);
 
294
        ALSA_CHECK(snd_config_get_id(c, &id));
 
295
        TEST_CHECK(!strcmp(id, "i"));
 
296
        ALSA_CHECK(snd_config_get_integer(c, &value));
 
297
        TEST_CHECK(value == 0);
 
298
        ALSA_CHECK(snd_config_delete(c));
 
299
}
 
300
 
 
301
static void test_make_integer64(void)
 
302
{
 
303
        snd_config_t *c;
 
304
        const char *id;
 
305
        long long value;
 
306
 
 
307
        ALSA_CHECK(snd_config_make_integer64(&c, "i"));
 
308
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_INTEGER64);
 
309
        ALSA_CHECK(snd_config_get_id(c, &id));
 
310
        TEST_CHECK(!strcmp(id, "i"));
 
311
        ALSA_CHECK(snd_config_get_integer64(c, &value));
 
312
        TEST_CHECK(value == 0);
 
313
        ALSA_CHECK(snd_config_delete(c));
 
314
}
 
315
 
 
316
static void test_make_string(void)
 
317
{
 
318
        snd_config_t *c;
 
319
        const char *id;
 
320
        const char *value;
 
321
 
 
322
        ALSA_CHECK(snd_config_make_string(&c, "s"));
 
323
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_STRING);
 
324
        ALSA_CHECK(snd_config_get_id(c, &id));
 
325
        TEST_CHECK(!strcmp(id, "s"));
 
326
        ALSA_CHECK(snd_config_get_string(c, &value));
 
327
        TEST_CHECK(value == NULL);
 
328
        ALSA_CHECK(snd_config_delete(c));
 
329
}
 
330
 
 
331
static void test_make_compound(void)
 
332
{
 
333
        snd_config_t *c;
 
334
        const char *id;
 
335
 
 
336
        ALSA_CHECK(snd_config_make_compound(&c, "c", 0));
 
337
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_COMPOUND);
 
338
        ALSA_CHECK(snd_config_get_id(c, &id));
 
339
        TEST_CHECK(!strcmp(id, "c"));
 
340
        TEST_CHECK(snd_config_iterator_first(c) == snd_config_iterator_end(c));
 
341
        ALSA_CHECK(snd_config_delete(c));
 
342
}
 
343
 
 
344
static void test_imake_integer(void)
 
345
{
 
346
        snd_config_t *c;
 
347
        const char *id;
 
348
        long value;
 
349
 
 
350
        ALSA_CHECK(snd_config_imake_integer(&c, "i", 123));
 
351
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_INTEGER);
 
352
        ALSA_CHECK(snd_config_get_id(c, &id));
 
353
        TEST_CHECK(!strcmp(id, "i"));
 
354
        ALSA_CHECK(snd_config_get_integer(c, &value));
 
355
        TEST_CHECK(value == 123);
 
356
        ALSA_CHECK(snd_config_delete(c));
 
357
}
 
358
 
 
359
static void test_imake_integer64(void)
 
360
{
 
361
        snd_config_t *c;
 
362
        const char *id;
 
363
        long long value;
 
364
 
 
365
        ALSA_CHECK(snd_config_imake_integer64(&c, "i", 123456789012345LL));
 
366
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_INTEGER64);
 
367
        ALSA_CHECK(snd_config_get_id(c, &id));
 
368
        TEST_CHECK(!strcmp(id, "i"));
 
369
        ALSA_CHECK(snd_config_get_integer64(c, &value));
 
370
        TEST_CHECK(value == 123456789012345LL);
 
371
        ALSA_CHECK(snd_config_delete(c));
 
372
}
 
373
 
 
374
static void test_imake_string(void)
 
375
{
 
376
        snd_config_t *c;
 
377
        const char *id;
 
378
        const char *value;
 
379
 
 
380
        ALSA_CHECK(snd_config_imake_string(&c, "s", "xyzzy"));
 
381
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_STRING);
 
382
        ALSA_CHECK(snd_config_get_id(c, &id));
 
383
        TEST_CHECK(!strcmp(id, "s"));
 
384
        ALSA_CHECK(snd_config_get_string(c, &value));
 
385
        TEST_CHECK(!strcmp(value, "xyzzy"));
 
386
        ALSA_CHECK(snd_config_delete(c));
 
387
}
 
388
 
 
389
static void test_get_type(void)
 
390
{
 
391
        snd_config_t *c;
 
392
 
 
393
        ALSA_CHECK(snd_config_top(&c));
 
394
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_COMPOUND);
 
395
        ALSA_CHECK(snd_config_delete(c));
 
396
        ALSA_CHECK(snd_config_make_integer(&c, "i"));
 
397
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_INTEGER);
 
398
        ALSA_CHECK(snd_config_delete(c));
 
399
        ALSA_CHECK(snd_config_make_string(&c, "s"));
 
400
        TEST_CHECK(snd_config_get_type(c) == SND_CONFIG_TYPE_STRING);
 
401
        ALSA_CHECK(snd_config_delete(c));
 
402
}
 
403
 
 
404
static void test_set_integer(void)
 
405
{
 
406
        snd_config_t *c;
 
407
        long value;
 
408
 
 
409
        ALSA_CHECK(snd_config_make_integer(&c, "i"));
 
410
        ALSA_CHECK(snd_config_set_integer(c, 123));
 
411
        ALSA_CHECK(snd_config_get_integer(c, &value));
 
412
        TEST_CHECK(value == 123);
 
413
        ALSA_CHECK(snd_config_delete(c));
 
414
        ALSA_CHECK(snd_config_make_string(&c, "s"));
 
415
        TEST_CHECK(snd_config_set_integer(c, 123) == -EINVAL);
 
416
        ALSA_CHECK(snd_config_delete(c));
 
417
}
 
418
 
 
419
static void test_set_integer64(void)
 
420
{
 
421
        snd_config_t *c;
 
422
        long long value;
 
423
 
 
424
        ALSA_CHECK(snd_config_make_integer64(&c, "i"));
 
425
        ALSA_CHECK(snd_config_set_integer64(c, 123456789012345LL));
 
426
        ALSA_CHECK(snd_config_get_integer64(c, &value));
 
427
        TEST_CHECK(value == 123456789012345LL);
 
428
        ALSA_CHECK(snd_config_delete(c));
 
429
        ALSA_CHECK(snd_config_make_string(&c, "s"));
 
430
        TEST_CHECK(snd_config_set_integer64(c, 123) == -EINVAL);
 
431
        ALSA_CHECK(snd_config_delete(c));
 
432
}
 
433
 
 
434
static void test_set_string(void)
 
435
{
 
436
        snd_config_t *c;
 
437
        const char *value;
 
438
 
 
439
        ALSA_CHECK(snd_config_make_string(&c, "s"));
 
440
        ALSA_CHECK(snd_config_set_string(c, "string"));
 
441
        ALSA_CHECK(snd_config_get_string(c, &value));
 
442
        TEST_CHECK(!strcmp(value, "string"));
 
443
        ALSA_CHECK(snd_config_set_string(c, NULL));
 
444
        ALSA_CHECK(snd_config_get_string(c, &value));
 
445
        TEST_CHECK(value == NULL);
 
446
        ALSA_CHECK(snd_config_delete(c));
 
447
        ALSA_CHECK(snd_config_make_integer(&c, "i"));
 
448
        TEST_CHECK(snd_config_set_string(c, "") == -EINVAL);
 
449
        ALSA_CHECK(snd_config_delete(c));
 
450
}
 
451
 
 
452
static void test_set_ascii(void)
 
453
{
 
454
        snd_config_t *c;
 
455
        const char *s;
 
456
        long i;
 
457
 
 
458
        ALSA_CHECK(snd_config_make_string(&c, "s"));
 
459
        ALSA_CHECK(snd_config_set_ascii(c, "foo"));
 
460
        ALSA_CHECK(snd_config_get_string(c, &s));
 
461
        TEST_CHECK(!strcmp(s, "foo"));
 
462
        ALSA_CHECK(snd_config_delete(c));
 
463
        ALSA_CHECK(snd_config_make_integer(&c, "i"));
 
464
        ALSA_CHECK(snd_config_set_ascii(c, "23"));
 
465
        ALSA_CHECK(snd_config_get_integer(c, &i));
 
466
        TEST_CHECK(i == 23);
 
467
        TEST_CHECK(snd_config_set_ascii(c, "half blue") == -EINVAL);
 
468
        ALSA_CHECK(snd_config_delete(c));
 
469
        ALSA_CHECK(snd_config_top(&c));
 
470
        TEST_CHECK(snd_config_set_ascii(c, "0") == -EINVAL);
 
471
        ALSA_CHECK(snd_config_delete(c));
 
472
}
 
473
 
 
474
static void test_get_id(void)
 
475
{
 
476
        snd_config_t *c;
 
477
        const char *id;
 
478
 
 
479
        ALSA_CHECK(snd_config_make_integer(&c, "my_id"));
 
480
        ALSA_CHECK(snd_config_get_id(c, &id));
 
481
        TEST_CHECK(!strcmp(id, "my_id"));
 
482
        ALSA_CHECK(snd_config_delete(c));
 
483
}
 
484
 
 
485
#define test_get_integer test_set_integer
 
486
#define test_get_integer64 test_set_integer64
 
487
#define test_get_string test_set_string
 
488
 
 
489
static void test_get_ascii(void)
 
490
{
 
491
        snd_config_t *c;
 
492
        char *value;
 
493
 
 
494
        ALSA_CHECK(snd_config_imake_integer(&c, "i", 123));
 
495
        ALSA_CHECK(snd_config_get_ascii(c, &value));
 
496
        TEST_CHECK(!strcmp(value, "123"));
 
497
        free(value);
 
498
        ALSA_CHECK(snd_config_delete(c));
 
499
        ALSA_CHECK(snd_config_imake_string(&c, "s", "bar"));
 
500
        ALSA_CHECK(snd_config_get_ascii(c, &value));
 
501
        TEST_CHECK(!strcmp(value, "bar"));
 
502
        free(value);
 
503
        ALSA_CHECK(snd_config_delete(c));
 
504
        ALSA_CHECK(snd_config_top(&c));
 
505
        TEST_CHECK(snd_config_get_ascii(c, &value) == -EINVAL);
 
506
        ALSA_CHECK(snd_config_delete(c));
 
507
}
 
508
 
 
509
static void test_iterators(void)
 
510
{
 
511
        snd_config_t *c, *c2;
 
512
        snd_config_iterator_t i;
 
513
        long v;
 
514
 
 
515
        ALSA_CHECK(snd_config_top(&c));
 
516
        i = snd_config_iterator_first(c);
 
517
        TEST_CHECK(i == snd_config_iterator_end(c));
 
518
        ALSA_CHECK(snd_config_imake_integer(&c2, "one", 1));
 
519
        ALSA_CHECK(snd_config_add(c, c2));
 
520
        i = snd_config_iterator_first(c);
 
521
        TEST_CHECK(i != snd_config_iterator_end(c));
 
522
        c2 = snd_config_iterator_entry(i);
 
523
        ALSA_CHECK(snd_config_get_integer(c2, &v));
 
524
        TEST_CHECK(v == 1);
 
525
        i = snd_config_iterator_next(i);
 
526
        TEST_CHECK(i == snd_config_iterator_end(c));
 
527
        ALSA_CHECK(snd_config_delete(c));
 
528
}
 
529
 
 
530
static void test_for_each(void)
 
531
{
 
532
        snd_config_t *c, *c2;
 
533
        snd_config_iterator_t i, next;
 
534
        long v;
 
535
        unsigned int count = 0;
 
536
 
 
537
        ALSA_CHECK(snd_config_top(&c));
 
538
        ALSA_CHECK(snd_config_imake_integer(&c2, "one", 1));
 
539
        ALSA_CHECK(snd_config_add(c, c2));
 
540
        snd_config_for_each(i, next, c) {
 
541
                TEST_CHECK(i != snd_config_iterator_end(c));
 
542
                c2 = snd_config_iterator_entry(i);
 
543
                ALSA_CHECK(snd_config_get_integer(c2, &v));
 
544
                TEST_CHECK(v == 1);
 
545
                ++count;
 
546
        }
 
547
        TEST_CHECK(count == 1);
 
548
        ALSA_CHECK(snd_config_delete(c));
 
549
}
 
550
 
 
551
int main(void)
 
552
{
 
553
        test_top();
 
554
        test_load();
 
555
        test_save();
 
556
        test_update();
 
557
        test_search();
 
558
        test_searchv();
 
559
        test_add();
 
560
        test_delete();
 
561
        test_copy();
 
562
        test_make_integer();
 
563
        test_make_integer64();
 
564
        test_make_string();
 
565
        test_make_compound();
 
566
        test_imake_integer();
 
567
        test_imake_integer64();
 
568
        test_imake_string();
 
569
        test_get_type();
 
570
        test_set_integer();
 
571
        test_set_integer64();
 
572
        test_set_string();
 
573
        test_set_ascii();
 
574
        test_get_id();
 
575
        test_get_integer();
 
576
        test_get_integer64();
 
577
        test_get_string();
 
578
        test_get_ascii();
 
579
        test_iterators();
 
580
        test_for_each();
 
581
        return TEST_EXIT_CODE();
 
582
}