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 */
subset_of(snd_config_t * c1,snd_config_t * 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 */
configs_equal(snd_config_t * c1,snd_config_t * c2)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 
test_top(void)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 
test_load(void)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 
test_save(void)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 
test_update(void)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 
test_search(void)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 
test_searchv(void)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 
test_add(void)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 
test_delete(void)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 
test_copy(void)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 
test_make_integer(void)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 
test_make_integer64(void)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 
test_make_string(void)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 
test_make_compound(void)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 
test_imake_integer(void)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 
test_imake_integer64(void)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 
test_imake_string(void)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 
test_get_type(void)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 
test_set_integer(void)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 
test_set_integer64(void)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 
test_set_string(void)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 
test_set_ascii(void)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 
test_get_id(void)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 
test_get_ascii(void)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 
test_iterators(void)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 
test_for_each(void)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 
main(void)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 }
583