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