Debian Codegraph @

modules/lsp-runtime-lib/src/test/utest/expr/parameters.cpp

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 21 февр. 2020 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/test-fw/utest.h>
23 #include <lsp-plug.in/test-fw/helpers.h>
24 #include <lsp-plug.in/expr/Parameters.h>
25
26 namespace lsp
27 {
28 using namespace lsp::expr;
29 }
30
31 UTEST_BEGIN("runtime.expr", parameters)
32 #define OK(expr) UTEST_ASSERT(expr == STATUS_OK);
33 #define FC(a, b) UTEST_ASSERT(float_equals_relative(a, b));
34 #define EC(a, b) UTEST_ASSERT(a == b);
35
36 typedef struct values_t
37 {
38 ssize_t iv;
39 double fv;
40 bool bv;
41 LSPString sv;
42 LSPString sv2;
43 value_t xv;
44 } values_t;
45
46 void test_add()
47 {
48 Parameters p;
49 value_t v;
50
51 LSPString tmp, k;
52
53 // Append named parameters
54 OK(p.add_int("1", 123));
55 OK(p.add_float("2", 440.0));
56 OK(p.add_cstring("3", "string0"));
57 UTEST_ASSERT(tmp.set_utf8("string1"));
58 OK(p.add_string("4", &tmp));
59 OK(p.add_bool("5", true));
60 OK(p.add_null("6"));
61 OK(p.add_undef("7"));
62 v.type = VT_INT;
63 v.v_int = 42;
64 OK(p.add("8", &v));
65
66 UTEST_ASSERT(p.size() == 8);
67
68 // Append named parameters(2)
69 UTEST_ASSERT(k.set_utf8("1"));
70 OK(p.add_int(&k, 456));
71 UTEST_ASSERT(k.set_utf8("2"));
72 OK(p.add_float(&k, 880.0));
73 UTEST_ASSERT(k.set_utf8("3"));
74 OK(p.add_cstring(&k, "stringA"));
75 UTEST_ASSERT(tmp.set_utf8("stringB"));
76 UTEST_ASSERT(k.set_utf8("4"));
77 OK(p.add_string(&k, &tmp));
78 UTEST_ASSERT(k.set_utf8("5"));
79 OK(p.add_bool(&k, false));
80 UTEST_ASSERT(k.set_utf8("6"));
81 OK(p.add_null(&k));
82 UTEST_ASSERT(k.set_utf8("7"));
83 OK(p.add_undef(&k));
84 UTEST_ASSERT(k.set_utf8("8"));
85 v.type = VT_FLOAT;
86 v.v_int = 42.0;
87 OK(p.add(&k, &v));
88
89 UTEST_ASSERT(p.size() == 16);
90
91 // Append anonymous parameters
92 OK(p.add_int(789));
93 OK(p.add_float(220.0));
94 OK(p.add_cstring("test0"));
95 UTEST_ASSERT(tmp.set_utf8("test1"));
96 OK(p.add_string(&tmp));
97 OK(p.add_bool(true));
98 OK(p.add_null());
99 OK(p.add_undef());
100 v.type = VT_BOOL;
101 v.v_int = true;
102 OK(p.add(&v));
103
104 UTEST_ASSERT(p.size() == 24);
105
106 // Validate
107 values_t vv;
108 init_value(&vv.xv);
109 size_t i=0;
110
111 // Part 1 check
112 vv.iv = 0;
113 vv.fv = 0.0;
114 vv.bv = false;
115 vv.sv.clear();
116 vv.sv2.clear();
117 destroy_value(&vv.xv);
118
119 OK(p.get_int(i++, &vv.iv));
120 OK(p.get_float(i++, &vv.fv));
121 OK(p.get_string(i++, &vv.sv));
122 OK(p.get_string(i++, &vv.sv2));
123 OK(p.get_bool(i++, &vv.bv));
124 OK(p.get_null(i++));
125 OK(p.get_undef(i++));
126 OK(p.get(i++, &vv.xv));
127
128 UTEST_ASSERT(vv.iv == 123);
129 UTEST_ASSERT(vv.fv == 440.0);
130 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
131 UTEST_ASSERT(vv.sv2.equals_ascii("string1"));
132 UTEST_ASSERT(vv.bv == true);
133 UTEST_ASSERT(vv.xv.type == VT_INT);
134 UTEST_ASSERT(vv.xv.v_int == 42);
135
136 // Part 2 check
137 vv.iv = 0;
138 vv.fv = 0.0;
139 vv.bv = true;
140 vv.sv.clear();
141 vv.sv2.clear();
142 destroy_value(&vv.xv);
143
144 OK(p.get_int(i++, &vv.iv));
145 OK(p.get_float(i++, &vv.fv));
146 OK(p.get_string(i++, &vv.sv));
147 OK(p.get_string(i++, &vv.sv2));
148 OK(p.get_bool(i++, &vv.bv));
149 OK(p.get_null(i++));
150 OK(p.get_undef(i++));
151 OK(p.get(i++, &vv.xv));
152
153 UTEST_ASSERT(vv.iv == 456);
154 UTEST_ASSERT(vv.fv == 880.0);
155 UTEST_ASSERT(vv.sv.equals_ascii("stringA"));
156 UTEST_ASSERT(vv.sv2.equals_ascii("stringB"));
157 UTEST_ASSERT(vv.bv == false);
158 UTEST_ASSERT(vv.xv.type == VT_FLOAT);
159 UTEST_ASSERT(vv.xv.v_int == 42.0);
160
161 // Part 3
162 vv.iv = 0;
163 vv.fv = 0.0;
164 vv.bv = false;
165 vv.sv.clear();
166 vv.sv2.clear();
167 destroy_value(&vv.xv);
168
169 OK(p.get_int(i++, &vv.iv));
170 OK(p.get_float(i++, &vv.fv));
171 OK(p.get_string(i++, &vv.sv));
172 OK(p.get_string(i++, &vv.sv2));
173 OK(p.get_bool(i++, &vv.bv));
174 OK(p.get_null(i++));
175 OK(p.get_undef(i++));
176 OK(p.get(i++, &vv.xv));
177
178 UTEST_ASSERT(vv.iv == 789);
179 UTEST_ASSERT(vv.fv == 220.0);
180 UTEST_ASSERT(vv.sv.equals_ascii("test0"));
181 UTEST_ASSERT(vv.sv2.equals_ascii("test1"));
182 UTEST_ASSERT(vv.bv == true);
183 UTEST_ASSERT(vv.xv.type == VT_BOOL);
184 UTEST_ASSERT(vv.xv.v_bool == true);
185
186 // Part 4
187 UTEST_ASSERT(p.get_int(i, &vv.iv) == STATUS_INVALID_VALUE);
188 UTEST_ASSERT(p.get_float(i, &vv.fv) == STATUS_INVALID_VALUE);
189 UTEST_ASSERT(p.get_bool(i, &vv.bv) == STATUS_INVALID_VALUE);
190 UTEST_ASSERT(p.get_string(i, &vv.sv) == STATUS_INVALID_VALUE);
191 UTEST_ASSERT(p.get(i, &vv.xv) == STATUS_INVALID_VALUE);
192
193 // Validate fetching parameters by name (part 1)
194 vv.iv = 0;
195 vv.fv = 0.0;
196 vv.bv = false;
197 vv.sv.clear();
198 vv.sv2.clear();
199 destroy_value(&vv.xv);
200
201 OK(p.get_int("1", &vv.iv));
202 OK(p.get_float("2", &vv.fv));
203 OK(p.get_string("3", &vv.sv));
204 OK(p.get_string("4", &vv.sv2));
205 OK(p.get_bool("5", &vv.bv));
206 OK(p.get_null("6"));
207 OK(p.get_undef("7"));
208 OK(p.get("8", &vv.xv));
209
210 UTEST_ASSERT(vv.iv == 123);
211 UTEST_ASSERT(vv.fv == 440.0);
212 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
213 UTEST_ASSERT(vv.sv2.equals_ascii("string1"));
214 UTEST_ASSERT(vv.bv == true);
215 UTEST_ASSERT(vv.xv.type == VT_INT);
216 UTEST_ASSERT(vv.xv.v_int == 42);
217
218 UTEST_ASSERT(p.get_int("9", &vv.iv) == STATUS_NOT_FOUND);
219 UTEST_ASSERT(p.get_float("9", &vv.fv) == STATUS_NOT_FOUND);
220 UTEST_ASSERT(p.get_bool("9", &vv.bv) == STATUS_NOT_FOUND);
221 UTEST_ASSERT(p.get_string("9", &vv.sv) == STATUS_NOT_FOUND);
222 UTEST_ASSERT(p.get("9", &vv.xv) == STATUS_NOT_FOUND);
223
224 // Validate fetching parameters by name (part 2)
225 vv.iv = 0;
226 vv.fv = 0.0;
227 vv.bv = false;
228 vv.sv.clear();
229 vv.sv2.clear();
230 destroy_value(&vv.xv);
231
232 UTEST_ASSERT(k.set_utf8("1"));
233 OK(p.get_int(&k, &vv.iv));
234 UTEST_ASSERT(k.set_utf8("2"));
235 OK(p.get_float(&k, &vv.fv));
236 UTEST_ASSERT(k.set_utf8("3"));
237 OK(p.get_string(&k, &vv.sv));
238 UTEST_ASSERT(k.set_utf8("4"));
239 OK(p.get_string(&k, &vv.sv2));
240 UTEST_ASSERT(k.set_utf8("5"));
241 OK(p.get_bool(&k, &vv.bv));
242 UTEST_ASSERT(k.set_utf8("6"));
243 OK(p.get_null(&k));
244 UTEST_ASSERT(k.set_utf8("7"));
245 OK(p.get_undef(&k));
246 UTEST_ASSERT(k.set_utf8("8"));
247 OK(p.get(&k, &vv.xv));
248
249 UTEST_ASSERT(vv.iv == 123);
250 UTEST_ASSERT(vv.fv == 440.0);
251 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
252 UTEST_ASSERT(vv.sv2.equals_ascii("string1"));
253 UTEST_ASSERT(vv.bv == true);
254 UTEST_ASSERT(vv.xv.type == VT_INT);
255 UTEST_ASSERT(vv.xv.v_int == 42);
256
257 UTEST_ASSERT(k.set_utf8("9"));
258 UTEST_ASSERT(p.get_int(&k, &vv.iv) == STATUS_NOT_FOUND);
259 UTEST_ASSERT(p.get_float(&k, &vv.fv) == STATUS_NOT_FOUND);
260 UTEST_ASSERT(p.get_bool(&k, &vv.bv) == STATUS_NOT_FOUND);
261 UTEST_ASSERT(p.get_string(&k, &vv.sv) == STATUS_NOT_FOUND);
262 UTEST_ASSERT(p.get(&k, &vv.xv) == STATUS_NOT_FOUND);
263
264 destroy_value(&vv.xv);
265 }
266
267 void test_insert()
268 {
269 Parameters p;
270 value_t v;
271 LSPString tmp, k;
272 values_t vv;
273 init_value(&vv.xv);
274
275 // Append named parameters
276 OK(p.add_int("1", 123));
277 OK(p.add_float("2", 440.0));
278 OK(p.add_cstring("3", "string0"));
279 UTEST_ASSERT(tmp.set_utf8("string1"));
280 OK(p.add_string("4", &tmp));
281 OK(p.add_bool("5", true));
282 OK(p.add_null("6"));
283 OK(p.add_undef("7"));
284 v.type = VT_INT;
285 v.v_int = 42;
286 OK(p.add("8", &v));
287
288 UTEST_ASSERT(p.size() == 8);
289
290 // Insert named parameters
291 OK(p.insert_int(0, "1", 456));
292 OK(p.insert_float(1, "2", 220.0));
293 OK(p.insert_string(2, "3", "stringA"));
294 UTEST_ASSERT(tmp.set_utf8("stringB"));
295 OK(p.insert_string(3, "4", &tmp));
296 OK(p.insert_bool(4, "5", false));
297 OK(p.insert_null(5, "6"));
298 OK(p.insert_undef(6, "7"));
299 v.type = VT_FLOAT;
300 v.v_int = 42.0;
301 OK(p.insert(7, "8", &v));
302
303 UTEST_ASSERT(p.size() == 16);
304
305 // Check parameter types
306 // Validate fetching parameters by name (part 1)
307 vv.iv = 0;
308 vv.bv = true;
309 vv.fv = 0.0;
310 vv.sv.clear();
311 vv.sv2.clear();
312 destroy_value(&vv.xv);
313
314 OK(p.get_int("1", &vv.iv));
315 OK(p.get_float("2", &vv.fv));
316 OK(p.get_string("3", &vv.sv));
317 OK(p.get_string("4", &vv.sv2));
318 OK(p.get_bool("5", &vv.bv));
319 OK(p.get_null("6"));
320 OK(p.get_undef("7"));
321 OK(p.get("8", &vv.xv));
322
323 UTEST_ASSERT(vv.iv == 456);
324 UTEST_ASSERT(vv.fv == 220.0);
325 UTEST_ASSERT(vv.sv.equals_ascii("stringA"));
326 UTEST_ASSERT(vv.sv2.equals_ascii("stringB"));
327 UTEST_ASSERT(vv.bv == false);
328 UTEST_ASSERT(vv.xv.type == VT_FLOAT);
329 UTEST_ASSERT(vv.xv.v_int == 42.0);
330
331 // Insert more named parameters
332 UTEST_ASSERT(k.set_utf8("1"));
333 OK(p.insert_int(0, &k, 789));
334 UTEST_ASSERT(k.set_utf8("2"));
335 OK(p.insert_float(1, &k, 880.0));
336 UTEST_ASSERT(k.set_utf8("3"));
337 OK(p.insert_string(2, &k, "testA"));
338 UTEST_ASSERT(k.set_utf8("4"));
339 UTEST_ASSERT(tmp.set_utf8("testB"));
340 OK(p.insert_string(3, &k, &tmp));
341 UTEST_ASSERT(k.set_utf8("5"));
342 OK(p.insert_bool(4, &k, true));
343 UTEST_ASSERT(k.set_utf8("6"));
344 OK(p.insert_null(5, &k));
345 UTEST_ASSERT(k.set_utf8("7"));
346 OK(p.insert_undef(6, &k));
347 v.type = VT_BOOL;
348 v.v_bool = true;
349 UTEST_ASSERT(k.set_utf8("8"));
350 OK(p.insert(7, &k, &v));
351
352 UTEST_ASSERT(p.size() == 24);
353
354 // Check parameter types
355 // Validate fetching parameters by name (part 1)
356 vv.iv = 0;
357 vv.bv = false;
358 vv.fv = 0.0;
359 vv.sv.clear();
360 vv.sv2.clear();
361 destroy_value(&vv.xv);
362
363 OK(p.get_int("1", &vv.iv));
364 OK(p.get_float("2", &vv.fv));
365 OK(p.get_string("3", &vv.sv));
366 OK(p.get_string("4", &vv.sv2));
367 OK(p.get_bool("5", &vv.bv));
368 OK(p.get_null("6"));
369 OK(p.get_undef("7"));
370 OK(p.get("8", &vv.xv));
371
372 UTEST_ASSERT(vv.iv == 789);
373 UTEST_ASSERT(vv.fv == 880.0);
374 UTEST_ASSERT(vv.sv.equals_ascii("testA"));
375 UTEST_ASSERT(vv.sv2.equals_ascii("testB"));
376 UTEST_ASSERT(vv.bv == true);
377 UTEST_ASSERT(vv.xv.type == VT_BOOL);
378 UTEST_ASSERT(vv.xv.v_int == true);
379
380 // Test invalid inserts
381 UTEST_ASSERT(p.insert_int(100, 789) == STATUS_INVALID_VALUE);
382 UTEST_ASSERT(p.insert_float(100, 1.0) == STATUS_INVALID_VALUE);
383 UTEST_ASSERT(p.insert_cstring(100, "abc") == STATUS_INVALID_VALUE);
384 UTEST_ASSERT(p.insert_string(100, &tmp) == STATUS_INVALID_VALUE);
385 UTEST_ASSERT(p.insert_null(100) == STATUS_INVALID_VALUE);
386 UTEST_ASSERT(p.insert_undef(100) == STATUS_INVALID_VALUE);
387 UTEST_ASSERT(p.insert(100, &v) == STATUS_INVALID_VALUE);
388
389 }
390
391 void test_cast()
392 {
393 Parameters p;
394 value_t v;
395 LSPString tmp, k;
396 values_t vv;
397 init_value(&vv.xv);
398
399 // Append named parameters
400 OK(p.add_int("1", 123));
401 OK(p.add_float("2", 440.0));
402 OK(p.add_cstring("3", "string0"));
403 UTEST_ASSERT(tmp.set_utf8("456"));
404 OK(p.add_string("4", &tmp));
405 OK(p.add_bool("5", true));
406 OK(p.add_null("6"));
407 OK(p.add_undef("7"));
408 v.type = VT_INT;
409 v.v_int = 42;
410 OK(p.add("8", &v));
411
412 UTEST_ASSERT(p.size() == 8);
413
414 // Check casts to int
415 OK(p.as_int(size_t(0), &v.v_int));
416 UTEST_ASSERT(v.v_int == 123);
417 OK(p.as_int(1, &v.v_int));
418 UTEST_ASSERT(v.v_int == 440);
419 UTEST_ASSERT(p.as_int(2, &v.v_int) == STATUS_BAD_TYPE);
420 OK(p.as_int(3, &v.v_int));
421 UTEST_ASSERT(v.v_int == 456);
422 OK(p.as_int(4, &v.v_int));
423 UTEST_ASSERT(v.v_int == 1);
424 UTEST_ASSERT(p.as_int(5, &v.v_int) == STATUS_BAD_TYPE);
425 UTEST_ASSERT(p.as_int(6, &v.v_int) == STATUS_BAD_TYPE);
426 OK(p.as_value(7, &v, VT_INT));
427 UTEST_ASSERT(v.type == VT_INT);
428 UTEST_ASSERT(v.v_int == 42);
429 UTEST_ASSERT(p.as_int(8, &v.v_int) == STATUS_INVALID_VALUE);
430
431 OK(p.as_int("1", &v.v_int));
432 UTEST_ASSERT(v.v_int == 123);
433 OK(p.as_int("2", &v.v_int));
434 UTEST_ASSERT(v.v_int == 440);
435 UTEST_ASSERT(p.as_int("3", &v.v_int) == STATUS_BAD_TYPE);
436 OK(p.as_int("4", &v.v_int));
437 UTEST_ASSERT(v.v_int == 456);
438 OK(p.as_int("5", &v.v_int));
439 UTEST_ASSERT(v.v_int == 1);
440 UTEST_ASSERT(p.as_int("6", &v.v_int) == STATUS_BAD_TYPE);
441 UTEST_ASSERT(p.as_int("7", &v.v_int) == STATUS_BAD_TYPE);
442 OK(p.as_value("8", &v, VT_INT));
443 UTEST_ASSERT(v.type == VT_INT);
444 UTEST_ASSERT(v.v_int == 42);
445 UTEST_ASSERT(p.as_int("9", &v.v_int) == STATUS_NOT_FOUND);
446
447 UTEST_ASSERT(k.set_utf8("1"));
448 OK(p.as_int(&k, &v.v_int));
449 UTEST_ASSERT(v.v_int == 123);
450 UTEST_ASSERT(k.set_utf8("2"));
451 OK(p.as_int(&k, &v.v_int));
452 UTEST_ASSERT(v.v_int == 440);
453 UTEST_ASSERT(k.set_utf8("3"));
454 UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_BAD_TYPE);
455 UTEST_ASSERT(k.set_utf8("4"));
456 OK(p.as_int(&k, &v.v_int));
457 UTEST_ASSERT(v.v_int == 456);
458 UTEST_ASSERT(k.set_utf8("5"));
459 OK(p.as_int(&k, &v.v_int));
460 UTEST_ASSERT(v.v_int == 1);
461 UTEST_ASSERT(k.set_utf8("6"));
462 UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_BAD_TYPE);
463 UTEST_ASSERT(k.set_utf8("7"));
464 UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_BAD_TYPE);
465 UTEST_ASSERT(k.set_utf8("8"));
466 OK(p.as_value(&k, &v, VT_INT));
467 UTEST_ASSERT(v.type == VT_INT);
468 UTEST_ASSERT(v.v_int == 42);
469 UTEST_ASSERT(k.set_utf8("9"));
470 UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_NOT_FOUND);
471
472 // Check casts to float
473 OK(p.as_float(size_t(0), &v.v_float));
474 FC(v.v_float, 123.0);
475 OK(p.as_float(1, &v.v_float));
476 FC(v.v_float, 440.0);
477 UTEST_ASSERT(p.as_float(2, &v.v_float) == STATUS_BAD_TYPE);
478 OK(p.as_float(3, &v.v_float));
479 FC(v.v_float, 456.0);
480 OK(p.as_float(4, &v.v_float));
481 FC(v.v_float, 1.0);
482 UTEST_ASSERT(p.as_float(5, &v.v_float) == STATUS_BAD_TYPE);
483 UTEST_ASSERT(p.as_float(6, &v.v_float) == STATUS_BAD_TYPE);
484 OK(p.as_value(7, &v, VT_FLOAT));
485 UTEST_ASSERT(v.type == VT_FLOAT);
486 FC(v.v_float, 42.0);
487 UTEST_ASSERT(p.as_float(8, &v.v_float) == STATUS_INVALID_VALUE);
488
489 OK(p.as_float("1", &v.v_float));
490 FC(v.v_float, 123.0);
491 OK(p.as_float("2", &v.v_float));
492 FC(v.v_float, 440.0);
493 UTEST_ASSERT(p.as_float("3", &v.v_float) == STATUS_BAD_TYPE);
494 OK(p.as_float("4", &v.v_float));
495 FC(v.v_float, 456.0);
496 OK(p.as_float("5", &v.v_float));
497 FC(v.v_float, 1.0);
498 UTEST_ASSERT(p.as_float("6", &v.v_float) == STATUS_BAD_TYPE);
499 UTEST_ASSERT(p.as_float("7", &v.v_float) == STATUS_BAD_TYPE);
500 OK(p.as_value("8", &v, VT_FLOAT));
501 UTEST_ASSERT(v.type == VT_FLOAT);
502 FC(v.v_float, 42.0);
503 UTEST_ASSERT(p.as_float("9", &v.v_float) == STATUS_NOT_FOUND);
504
505 UTEST_ASSERT(k.set_utf8("1"));
506 OK(p.as_float(&k, &v.v_float));
507 FC(v.v_float, 123.0);
508 UTEST_ASSERT(k.set_utf8("2"));
509 OK(p.as_float(&k, &v.v_float));
510 FC(v.v_float, 440.0);
511 UTEST_ASSERT(k.set_utf8("3"));
512 UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_BAD_TYPE);
513 UTEST_ASSERT(k.set_utf8("4"));
514 OK(p.as_float(&k, &v.v_float));
515 FC(v.v_float, 456.0);
516 UTEST_ASSERT(k.set_utf8("5"));
517 OK(p.as_float(&k, &v.v_float));
518 FC(v.v_float, 1.0);
519 UTEST_ASSERT(k.set_utf8("6"));
520 UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_BAD_TYPE);
521 UTEST_ASSERT(k.set_utf8("7"));
522 UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_BAD_TYPE);
523 UTEST_ASSERT(k.set_utf8("8"));
524 OK(p.as_value(&k, &v, VT_FLOAT));
525 UTEST_ASSERT(v.type == VT_FLOAT);
526 FC(v.v_float, 42.0);
527 UTEST_ASSERT(k.set_utf8("9"));
528 UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_NOT_FOUND);
529
530 // Check casts to bool
531 OK(p.as_bool(size_t(0), &v.v_bool));
532 EC(v.v_bool, true);
533 OK(p.as_bool(1, &v.v_bool));
534 EC(v.v_bool, true);
535 UTEST_ASSERT(p.as_bool(2, &v.v_bool) == STATUS_BAD_TYPE);
536 OK(p.as_bool(3, &v.v_bool));
537 EC(v.v_bool, true);
538 OK(p.as_bool(4, &v.v_bool));
539 EC(v.v_bool, true);
540 UTEST_ASSERT(p.as_bool(5, &v.v_bool) == STATUS_BAD_TYPE);
541 UTEST_ASSERT(p.as_bool(6, &v.v_bool) == STATUS_BAD_TYPE);
542 OK(p.as_value(7, &v, VT_BOOL));
543 UTEST_ASSERT(v.type == VT_BOOL);
544 EC(v.v_bool, true);
545 UTEST_ASSERT(p.as_bool(8, &v.v_bool) == STATUS_INVALID_VALUE);
546
547 OK(p.as_bool("1", &v.v_bool));
548 EC(v.v_bool, true);
549 OK(p.as_bool("2", &v.v_bool));
550 EC(v.v_bool, true);
551 UTEST_ASSERT(p.as_bool("3", &v.v_bool) == STATUS_BAD_TYPE);
552 OK(p.as_bool("4", &v.v_bool));
553 EC(v.v_bool, true);
554 OK(p.as_bool("5", &v.v_bool));
555 EC(v.v_bool, true);
556 UTEST_ASSERT(p.as_bool("6", &v.v_bool) == STATUS_BAD_TYPE);
557 UTEST_ASSERT(p.as_bool("7", &v.v_bool) == STATUS_BAD_TYPE);
558 OK(p.as_value("8", &v, VT_BOOL));
559 UTEST_ASSERT(v.type == VT_BOOL);
560 EC(v.v_bool, true);
561 UTEST_ASSERT(p.as_bool("9", &v.v_bool) == STATUS_NOT_FOUND);
562
563 UTEST_ASSERT(k.set_utf8("1"));
564 OK(p.as_bool(&k, &v.v_bool));
565 EC(v.v_bool, true);
566 UTEST_ASSERT(k.set_utf8("2"));
567 OK(p.as_bool(&k, &v.v_bool));
568 EC(v.v_bool, true);
569 UTEST_ASSERT(k.set_utf8("3"));
570 UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_BAD_TYPE);
571 UTEST_ASSERT(k.set_utf8("4"));
572 OK(p.as_bool(&k, &v.v_bool));
573 EC(v.v_bool, true);
574 UTEST_ASSERT(k.set_utf8("5"));
575 OK(p.as_bool(&k, &v.v_bool));
576 EC(v.v_bool, true);
577 UTEST_ASSERT(k.set_utf8("6"));
578 UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_BAD_TYPE);
579 UTEST_ASSERT(k.set_utf8("7"));
580 UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_BAD_TYPE);
581 UTEST_ASSERT(k.set_utf8("8"));
582 OK(p.as_value(&k, &v, VT_BOOL));
583 UTEST_ASSERT(v.type == VT_BOOL);
584 EC(v.v_bool, true);
585 UTEST_ASSERT(k.set_utf8("9"));
586 UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_NOT_FOUND);
587
588 // Check casts to string
589 OK(p.as_string(size_t(0), &vv.sv));
590 UTEST_ASSERT(vv.sv.equals_ascii("123"));
591 OK(p.as_string(1, &vv.sv));
592 UTEST_ASSERT(vv.sv.starts_with_ascii("440."));
593 OK(p.as_string(2, &vv.sv));
594 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
595 OK(p.as_string(3, &vv.sv));
596 UTEST_ASSERT(vv.sv.equals_ascii("456"));
597 OK(p.as_string(4, &vv.sv));
598 UTEST_ASSERT(vv.sv.equals_ascii("true"));
599 UTEST_ASSERT(p.as_string(5, &vv.sv) == STATUS_BAD_TYPE);
600 UTEST_ASSERT(p.as_string(6, &vv.sv) == STATUS_BAD_TYPE);
601 OK(p.as_value(7, &vv.xv, VT_STRING));
602 UTEST_ASSERT(vv.xv.type == VT_STRING);
603 UTEST_ASSERT(vv.xv.v_str->equals_ascii("42"));
604 UTEST_ASSERT(p.as_string(8, &vv.sv) == STATUS_INVALID_VALUE);
605
606 OK(p.as_string("1", &vv.sv));
607 UTEST_ASSERT(vv.sv.equals_ascii("123"));
608 OK(p.as_string("2", &vv.sv));
609 UTEST_ASSERT(vv.sv.starts_with_ascii("440."));
610 OK(p.as_string("3", &vv.sv));
611 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
612 OK(p.as_string("4", &vv.sv));
613 UTEST_ASSERT(vv.sv.equals_ascii("456"));
614 OK(p.as_string("5", &vv.sv));
615 UTEST_ASSERT(vv.sv.equals_ascii("true"));
616 UTEST_ASSERT(p.as_string("6", &vv.sv) == STATUS_BAD_TYPE);
617 UTEST_ASSERT(p.as_string("7", &vv.sv) == STATUS_BAD_TYPE);
618 OK(p.as_value("8", &vv.xv, VT_STRING));
619 UTEST_ASSERT(vv.xv.type == VT_STRING);
620 UTEST_ASSERT(vv.xv.v_str->equals_ascii("42"));
621 UTEST_ASSERT(p.as_string("9", &vv.sv) == STATUS_NOT_FOUND);
622
623 UTEST_ASSERT(k.set_utf8("1"));
624 OK(p.as_string(&k, &vv.sv));
625 UTEST_ASSERT(vv.sv.equals_ascii("123"));
626 UTEST_ASSERT(k.set_utf8("2"));
627 OK(p.as_string(&k, &vv.sv));
628 UTEST_ASSERT(vv.sv.starts_with_ascii("440."));
629 UTEST_ASSERT(k.set_utf8("3"));
630 OK(p.as_string(&k, &vv.sv));
631 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
632 UTEST_ASSERT(k.set_utf8("4"));
633 OK(p.as_string(&k, &vv.sv));
634 UTEST_ASSERT(vv.sv.equals_ascii("456"));
635 UTEST_ASSERT(k.set_utf8("5"));
636 OK(p.as_string(&k, &vv.sv));
637 UTEST_ASSERT(vv.sv.equals_ascii("true"));
638 UTEST_ASSERT(k.set_utf8("6"));
639 UTEST_ASSERT(p.as_string(&k, &vv.sv) == STATUS_BAD_TYPE);
640 UTEST_ASSERT(k.set_utf8("7"));
641 UTEST_ASSERT(p.as_string(&k, &vv.sv) == STATUS_BAD_TYPE);
642 UTEST_ASSERT(k.set_utf8("8"));
643 OK(p.as_value(&k, &vv.xv, VT_STRING));
644 UTEST_ASSERT(vv.xv.type == VT_STRING);
645 UTEST_ASSERT(vv.xv.v_str->equals_ascii("42"));
646 UTEST_ASSERT(k.set_utf8("9"));
647 UTEST_ASSERT(p.as_string(&k, &vv.sv) == STATUS_NOT_FOUND);
648
649 // Check casts to null
650 OK(p.as_null(size_t(0)));
651 OK(p.as_null(1));
652 OK(p.as_null(2));
653 OK(p.as_null(3));
654 OK(p.as_null(4));
655 OK(p.as_null(5));
656 OK(p.as_null(6));
657 OK(p.as_value(7, &vv.xv, VT_NULL));
658 UTEST_ASSERT(vv.xv.type == VT_NULL);
659 UTEST_ASSERT(p.as_null(8) == STATUS_INVALID_VALUE);
660
661 OK(p.as_null("1"));
662 OK(p.as_null("2"));
663 OK(p.as_null("3"));
664 OK(p.as_null("4"));
665 OK(p.as_null("5"));
666 OK(p.as_null("6"));
667 OK(p.as_null("7"));
668 OK(p.as_value("8", &vv.xv, VT_NULL));
669 UTEST_ASSERT(vv.xv.type == VT_NULL);
670 UTEST_ASSERT(p.as_null("9") == STATUS_NOT_FOUND);
671
672 UTEST_ASSERT(k.set_utf8("1"));
673 OK(p.as_null(&k));
674 UTEST_ASSERT(k.set_utf8("2"));
675 OK(p.as_null(&k));
676 UTEST_ASSERT(k.set_utf8("3"));
677 OK(p.as_null(&k));
678 UTEST_ASSERT(k.set_utf8("4"));
679 OK(p.as_null(&k));
680 UTEST_ASSERT(k.set_utf8("5"));
681 OK(p.as_null(&k));
682 UTEST_ASSERT(k.set_utf8("6"));
683 OK(p.as_null(&k));
684 UTEST_ASSERT(k.set_utf8("7"));
685 OK(p.as_null(&k));
686 UTEST_ASSERT(k.set_utf8("8"));
687 OK(p.as_value(&k, &vv.xv, VT_NULL));
688 UTEST_ASSERT(vv.xv.type == VT_NULL);
689 UTEST_ASSERT(k.set_utf8("9"));
690 UTEST_ASSERT(p.as_null(&k) == STATUS_NOT_FOUND);
691
692 // Check casts to undef
693 OK(p.as_undef(size_t(0)));
694 OK(p.as_undef(1));
695 OK(p.as_undef(2));
696 OK(p.as_undef(3));
697 OK(p.as_undef(4));
698 OK(p.as_undef(5));
699 OK(p.as_undef(6));
700 OK(p.as_value(7, &vv.xv, VT_UNDEF));
701 UTEST_ASSERT(vv.xv.type == VT_UNDEF);
702 UTEST_ASSERT(p.as_undef(8) == STATUS_INVALID_VALUE);
703
704 OK(p.as_undef("1"));
705 OK(p.as_undef("2"));
706 OK(p.as_undef("3"));
707 OK(p.as_undef("4"));
708 OK(p.as_undef("5"));
709 OK(p.as_undef("6"));
710 OK(p.as_undef("7"));
711 OK(p.as_value("8", &vv.xv, VT_UNDEF));
712 UTEST_ASSERT(vv.xv.type == VT_UNDEF);
713 UTEST_ASSERT(p.as_undef("9") == STATUS_NOT_FOUND);
714
715 UTEST_ASSERT(k.set_utf8("1"));
716 OK(p.as_undef(&k));
717 UTEST_ASSERT(k.set_utf8("2"));
718 OK(p.as_undef(&k));
719 UTEST_ASSERT(k.set_utf8("3"));
720 OK(p.as_undef(&k));
721 UTEST_ASSERT(k.set_utf8("4"));
722 OK(p.as_undef(&k));
723 UTEST_ASSERT(k.set_utf8("5"));
724 OK(p.as_undef(&k));
725 UTEST_ASSERT(k.set_utf8("6"));
726 OK(p.as_undef(&k));
727 UTEST_ASSERT(k.set_utf8("7"));
728 OK(p.as_undef(&k));
729 UTEST_ASSERT(k.set_utf8("8"));
730 OK(p.as_value(&k, &vv.xv, VT_UNDEF));
731 UTEST_ASSERT(vv.xv.type == VT_UNDEF);
732 UTEST_ASSERT(k.set_utf8("9"));
733 UTEST_ASSERT(p.as_undef(&k) == STATUS_NOT_FOUND);
734 }
735
736 void test_set()
737 {
738 Parameters p;
739 value_t v;
740 LSPString tmp, k;
741 values_t vv;
742 init_value(&vv.xv);
743 size_t i=0;
744
745 OK(p.add_undef("1"));
746 OK(p.add_undef("2"));
747 OK(p.add_undef("3"));
748 OK(p.add_undef("4"));
749 OK(p.add_undef("5"));
750 OK(p.add_undef("6"));
751 OK(p.add_undef("7"));
752 OK(p.add_undef("8"));
753
754 // Test setting by index
755 OK(p.set_int(size_t(0), 123));
756 OK(p.set_float(1, 220.0));
757 OK(p.set_bool(2, true));
758 OK(p.set_cstring(3, "string0"));
759 UTEST_ASSERT(tmp.set_ascii("string1"));
760 OK(p.set_string(4, &tmp));
761 OK(p.set_null(5));
762 OK(p.set_undef(6));
763 v.type = VT_INT;
764 v.v_int = 42;
765 OK(p.set(7, &v));
766
767 UTEST_ASSERT(p.set_int(8, 456) == STATUS_INVALID_VALUE);
768 UTEST_ASSERT(p.set_float(8, 440.0) == STATUS_INVALID_VALUE);
769 UTEST_ASSERT(p.set_bool(8, false) == STATUS_INVALID_VALUE);
770 UTEST_ASSERT(p.set_cstring(8, "bad") == STATUS_INVALID_VALUE);
771 UTEST_ASSERT(p.set_string(8, &tmp) == STATUS_INVALID_VALUE);
772 UTEST_ASSERT(p.set_null(8) == STATUS_INVALID_VALUE);
773 UTEST_ASSERT(p.set_undef(8) == STATUS_INVALID_VALUE);
774 UTEST_ASSERT(p.set(8, &v) == STATUS_INVALID_VALUE);
775
776 // Validate values
777 i = 0;
778 vv.iv = 0;
779 vv.fv = 0.0;
780 vv.bv = false;
781 vv.sv.clear();
782 vv.sv2.clear();
783 destroy_value(&vv.xv);
784
785 OK(p.get_int(i++, &vv.iv));
786 OK(p.get_float(i++, &vv.fv));
787 OK(p.get_bool(i++, &vv.bv));
788 OK(p.get_string(i++, &vv.sv));
789 OK(p.get_string(i++, &vv.sv2));
790 OK(p.get_null(i++));
791 OK(p.get_undef(i++));
792 OK(p.get(i++, &vv.xv));
793
794 UTEST_ASSERT(vv.iv == 123);
795 UTEST_ASSERT(vv.fv == 220.0);
796 UTEST_ASSERT(vv.bv == true);
797 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
798 UTEST_ASSERT(vv.sv2.equals_ascii("string1"));
799 UTEST_ASSERT(vv.xv.type == VT_INT);
800 UTEST_ASSERT(vv.xv.v_int == 42);
801
802 // Test setting by name
803 OK(p.set_int("1", 456));
804 OK(p.set_float("2", 440.0));
805 OK(p.set_bool("3", false));
806 OK(p.set_cstring("4", "stringA"));
807 UTEST_ASSERT(tmp.set_ascii("stringB"));
808 OK(p.set_string("5", &tmp));
809 OK(p.set_null("6"));
810 OK(p.set_undef("7"));
811 v.type = VT_FLOAT;
812 v.v_float = 42.0;
813 OK(p.set("8", &v));
814
815 // Validate values
816 i = 0;
817 vv.iv = 0;
818 vv.fv = 0.0;
819 vv.bv = true;
820 vv.sv.clear();
821 vv.sv2.clear();
822 destroy_value(&vv.xv);
823
824 OK(p.get_int(i++, &vv.iv));
825 OK(p.get_float(i++, &vv.fv));
826 OK(p.get_bool(i++, &vv.bv));
827 OK(p.get_string(i++, &vv.sv));
828 OK(p.get_string(i++, &vv.sv2));
829 OK(p.get_null(i++));
830 OK(p.get_undef(i++));
831 OK(p.get(i++, &vv.xv));
832
833 UTEST_ASSERT(vv.iv == 456);
834 UTEST_ASSERT(vv.fv == 440.0);
835 UTEST_ASSERT(vv.bv == false);
836 UTEST_ASSERT(vv.sv.equals_ascii("stringA"));
837 UTEST_ASSERT(vv.sv2.equals_ascii("stringB"));
838 UTEST_ASSERT(vv.xv.type == VT_FLOAT);
839 UTEST_ASSERT(vv.xv.v_float == 42.0);
840
841 // Test setting non-existing values
842 OK(p.set_int("9", 123));
843 OK(p.set_float("10", 220.0));
844 OK(p.set_bool("11", true));
845 OK(p.set_cstring("12", "string0"));
846 UTEST_ASSERT(tmp.set_ascii("string1"));
847 OK(p.set_string("13", &tmp));
848 OK(p.set_null("14"));
849 OK(p.set_undef("15"));
850 v.type = VT_INT;
851 v.v_int = 42;
852 OK(p.set("16", &v));
853
854 UTEST_ASSERT(p.size() == 16);
855 UTEST_ASSERT(p.get_index("9") == 8);
856 UTEST_ASSERT(p.get_index("10") == 9);
857 UTEST_ASSERT(p.get_index("11") == 10);
858 UTEST_ASSERT(p.get_index("12") == 11);
859 UTEST_ASSERT(p.get_index("13") == 12);
860 UTEST_ASSERT(p.get_index("14") == 13);
861 UTEST_ASSERT(p.get_index("15") == 14);
862 UTEST_ASSERT(p.get_index("16") == 15);
863
864 // Test setting by name (2)
865 UTEST_ASSERT(k.set_ascii("1"));
866 OK(p.set_int(&k, 789));
867 UTEST_ASSERT(k.set_ascii("2"));
868 OK(p.set_float(&k, 880.0));
869 UTEST_ASSERT(k.set_ascii("3"));
870 OK(p.set_bool(&k, true));
871 UTEST_ASSERT(k.set_ascii("4"));
872 OK(p.set_cstring(&k, "testA"));
873 UTEST_ASSERT(tmp.set_ascii("testB"));
874 UTEST_ASSERT(k.set_ascii("5"));
875 OK(p.set_string(&k, &tmp));
876 UTEST_ASSERT(k.set_ascii("6"));
877 OK(p.set_null(&k));
878 UTEST_ASSERT(k.set_ascii("7"));
879 OK(p.set_undef(&k));
880 v.type = VT_INT;
881 v.v_int = 42;
882 UTEST_ASSERT(k.set_ascii("8"));
883 OK(p.set(&k, &v));
884
885 // Validate values
886 i = 0;
887 vv.iv = 0;
888 vv.fv = 0.0;
889 vv.bv = false;
890 vv.sv.clear();
891 vv.sv2.clear();
892 destroy_value(&vv.xv);
893
894 OK(p.get_int(i++, &vv.iv));
895 OK(p.get_float(i++, &vv.fv));
896 OK(p.get_bool(i++, &vv.bv));
897 OK(p.get_string(i++, &vv.sv));
898 OK(p.get_string(i++, &vv.sv2));
899 OK(p.get_null(i++));
900 OK(p.get_undef(i++));
901 OK(p.get(i++, &vv.xv));
902
903 UTEST_ASSERT(vv.iv == 789);
904 UTEST_ASSERT(vv.fv == 880.0);
905 UTEST_ASSERT(vv.bv == true);
906 UTEST_ASSERT(vv.sv.equals_ascii("testA"));
907 UTEST_ASSERT(vv.sv2.equals_ascii("testB"));
908 UTEST_ASSERT(vv.xv.type == VT_INT);
909 UTEST_ASSERT(vv.xv.v_int == 42);
910
911 // Test setting non-existing values
912 UTEST_ASSERT(k.set_ascii("17"));
913 OK(p.set_int(&k, 123));
914 UTEST_ASSERT(k.set_ascii("18"));
915 OK(p.set_float(&k, 220.0));
916 UTEST_ASSERT(k.set_ascii("19"));
917 OK(p.set_bool(&k, true));
918 UTEST_ASSERT(k.set_ascii("20"));
919 OK(p.set_cstring(&k, "string0"));
920 UTEST_ASSERT(tmp.set_ascii("string1"));
921 UTEST_ASSERT(k.set_ascii("21"));
922 OK(p.set_string(&k, &tmp));
923 UTEST_ASSERT(k.set_ascii("22"));
924 OK(p.set_null(&k));
925 UTEST_ASSERT(k.set_ascii("23"));
926 OK(p.set_undef(&k));
927 v.type = VT_INT;
928 v.v_int = 42;
929 UTEST_ASSERT(k.set_ascii("24"));
930 OK(p.set(&k, &v));
931
932 UTEST_ASSERT(p.size() == 24);
933 UTEST_ASSERT(k.set_ascii("17"));
934 UTEST_ASSERT(p.get_index(&k) == 16);
935 UTEST_ASSERT(k.set_ascii("18"));
936 UTEST_ASSERT(p.get_index(&k) == 17);
937 UTEST_ASSERT(k.set_ascii("19"));
938 UTEST_ASSERT(p.get_index(&k) == 18);
939 UTEST_ASSERT(k.set_ascii("20"));
940 UTEST_ASSERT(p.get_index(&k) == 19);
941 UTEST_ASSERT(k.set_ascii("21"));
942 UTEST_ASSERT(p.get_index(&k) == 20);
943 UTEST_ASSERT(k.set_ascii("22"));
944 UTEST_ASSERT(p.get_index(&k) == 21);
945 UTEST_ASSERT(k.set_ascii("23"));
946 UTEST_ASSERT(p.get_index(&k) == 22);
947 UTEST_ASSERT(k.set_ascii("24"));
948 UTEST_ASSERT(p.get_index(&k) == 23);
949 }
950
951 void test_remove()
952 {
953 Parameters p;
954 value_t v;
955 LSPString tmp, k;
956 values_t vv;
957 init_value(&vv.xv);
958 size_t i=0;
959
960 // Append named parameters
961 OK(p.add_int("1", 123));
962 OK(p.add_float("2", 440.0));
963 OK(p.add_cstring("3", "string0"));
964 OK(p.add_bool("4", true));
965 OK(p.add_null("5"));
966 OK(p.add_undef("6"));
967 v.type = VT_INT;
968 v.v_int = 42;
969 OK(p.add("7", &v));
970
971 // Remove parameters by index
972 vv.iv = 0;
973 vv.fv = 0.0;
974 vv.bv = false;
975 vv.sv.clear();
976 vv.sv2.clear();
977 destroy_value(&vv.xv);
978
979 UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE);
980 UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE);
981 UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE);
982 UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE);
983 UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE);
984 UTEST_ASSERT(p.remove_value(i, VT_FLOAT, &v) == STATUS_BAD_TYPE);
985 OK(p.remove_int(i, &vv.iv));
986 UTEST_ASSERT(vv.iv == 123);
987
988 UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE);
989 UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE);
990 UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE);
991 UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE);
992 UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE);
993 UTEST_ASSERT(p.remove_value(i, VT_INT, &v) == STATUS_BAD_TYPE);
994 OK(p.remove_float(i, &vv.fv));
995 UTEST_ASSERT(vv.fv == 440.0);
996
997 UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE);
998 UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE);
999 UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE);
1000 UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE);
1001 UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE);
1002 UTEST_ASSERT(p.remove_value(i, VT_NULL, &v) == STATUS_BAD_TYPE);
1003 OK(p.remove_string(i, &vv.sv));
1004 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
1005
1006 UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE);
1007 UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE);
1008 UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE);
1009 UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE);
1010 UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE);
1011 UTEST_ASSERT(p.remove_value(i, VT_STRING, &v) == STATUS_BAD_TYPE);
1012 OK(p.remove_bool(i, &vv.bv));
1013 UTEST_ASSERT(vv.bv == true);
1014
1015 UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE);
1016 UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE);
1017 UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE);
1018 UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE);
1019 UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE);
1020 UTEST_ASSERT(p.remove_value(i, VT_UNDEF, &v) == STATUS_BAD_TYPE);
1021 OK(p.remove_null(i));
1022
1023 UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE);
1024 UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE);
1025 UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE);
1026 UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE);
1027 UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE);
1028 UTEST_ASSERT(p.remove_value(i, VT_BOOL, &v) == STATUS_BAD_TYPE);
1029 OK(p.remove_undef(i));
1030
1031 OK(p.remove(i, &vv.xv));
1032 UTEST_ASSERT(vv.xv.type == VT_INT);
1033 UTEST_ASSERT(vv.xv.v_int == 42);
1034
1035 UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_INVALID_VALUE);
1036 UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_INVALID_VALUE);
1037 UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_INVALID_VALUE);
1038 UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_INVALID_VALUE);
1039 UTEST_ASSERT(p.remove_null(i) == STATUS_INVALID_VALUE);
1040 UTEST_ASSERT(p.remove_undef(i) == STATUS_INVALID_VALUE);
1041 UTEST_ASSERT(p.remove_value(i, VT_STRING, &v) == STATUS_INVALID_VALUE);
1042 UTEST_ASSERT(p.remove(i, &vv.xv) == STATUS_INVALID_VALUE);
1043
1044 UTEST_ASSERT(p.size() == 0);
1045
1046 // Append named parameters
1047 OK(p.add_int("1", 123));
1048 OK(p.add_float("2", 440.0));
1049 OK(p.add_cstring("3", "string0"));
1050 OK(p.add_bool("4", true));
1051 OK(p.add_null("5"));
1052 OK(p.add_undef("6"));
1053 v.type = VT_INT;
1054 v.v_int = 42;
1055 OK(p.add("7", &v));
1056
1057 // Remove parameters by name
1058 vv.iv = 0;
1059 vv.fv = 0.0;
1060 vv.bv = false;
1061 vv.sv.clear();
1062 vv.sv2.clear();
1063 destroy_value(&vv.xv);
1064
1065 UTEST_ASSERT(p.remove_float("1", &vv.fv) == STATUS_BAD_TYPE);
1066 UTEST_ASSERT(p.remove_string("1", &vv.sv) == STATUS_BAD_TYPE);
1067 UTEST_ASSERT(p.remove_bool("1", &vv.bv) == STATUS_BAD_TYPE);
1068 UTEST_ASSERT(p.remove_null("1") == STATUS_BAD_TYPE);
1069 UTEST_ASSERT(p.remove_undef("1") == STATUS_BAD_TYPE);
1070 UTEST_ASSERT(p.remove_value("1", VT_FLOAT, &v) == STATUS_BAD_TYPE);
1071 OK(p.remove_int("1", &vv.iv));
1072 UTEST_ASSERT(vv.iv == 123);
1073
1074 UTEST_ASSERT(p.remove_int("2", &vv.iv) == STATUS_BAD_TYPE);
1075 UTEST_ASSERT(p.remove_string("2", &vv.sv) == STATUS_BAD_TYPE);
1076 UTEST_ASSERT(p.remove_bool("2", &vv.bv) == STATUS_BAD_TYPE);
1077 UTEST_ASSERT(p.remove_null("2") == STATUS_BAD_TYPE);
1078 UTEST_ASSERT(p.remove_undef("2") == STATUS_BAD_TYPE);
1079 UTEST_ASSERT(p.remove_value("2", VT_INT, &v) == STATUS_BAD_TYPE);
1080 OK(p.remove_float("2", &vv.fv));
1081 UTEST_ASSERT(vv.fv == 440.0);
1082
1083 UTEST_ASSERT(p.remove_int("3", &vv.iv) == STATUS_BAD_TYPE);
1084 UTEST_ASSERT(p.remove_float("3", &vv.fv) == STATUS_BAD_TYPE);
1085 UTEST_ASSERT(p.remove_bool("3", &vv.bv) == STATUS_BAD_TYPE);
1086 UTEST_ASSERT(p.remove_null("3") == STATUS_BAD_TYPE);
1087 UTEST_ASSERT(p.remove_undef("3") == STATUS_BAD_TYPE);
1088 UTEST_ASSERT(p.remove_value("3", VT_NULL, &v) == STATUS_BAD_TYPE);
1089 OK(p.remove_string("3", &vv.sv));
1090 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
1091
1092 UTEST_ASSERT(p.remove_int("4", &vv.iv) == STATUS_BAD_TYPE);
1093 UTEST_ASSERT(p.remove_float("4", &vv.fv) == STATUS_BAD_TYPE);
1094 UTEST_ASSERT(p.remove_string("4", &vv.sv) == STATUS_BAD_TYPE);
1095 UTEST_ASSERT(p.remove_null("4") == STATUS_BAD_TYPE);
1096 UTEST_ASSERT(p.remove_undef("4") == STATUS_BAD_TYPE);
1097 UTEST_ASSERT(p.remove_value("4", VT_STRING, &v) == STATUS_BAD_TYPE);
1098 OK(p.remove_bool("4", &vv.bv));
1099 UTEST_ASSERT(vv.bv == true);
1100
1101 UTEST_ASSERT(p.remove_int("5", &vv.iv) == STATUS_BAD_TYPE);
1102 UTEST_ASSERT(p.remove_float("5", &vv.fv) == STATUS_BAD_TYPE);
1103 UTEST_ASSERT(p.remove_string("5", &vv.sv) == STATUS_BAD_TYPE);
1104 UTEST_ASSERT(p.remove_bool("5", &vv.bv) == STATUS_BAD_TYPE);
1105 UTEST_ASSERT(p.remove_undef("5") == STATUS_BAD_TYPE);
1106 UTEST_ASSERT(p.remove_value("5", VT_UNDEF, &v) == STATUS_BAD_TYPE);
1107 OK(p.remove_null("5"));
1108
1109 UTEST_ASSERT(p.remove_int("6", &vv.iv) == STATUS_BAD_TYPE);
1110 UTEST_ASSERT(p.remove_float("6", &vv.fv) == STATUS_BAD_TYPE);
1111 UTEST_ASSERT(p.remove_string("6", &vv.sv) == STATUS_BAD_TYPE);
1112 UTEST_ASSERT(p.remove_bool("6", &vv.bv) == STATUS_BAD_TYPE);
1113 UTEST_ASSERT(p.remove_null("6") == STATUS_BAD_TYPE);
1114 UTEST_ASSERT(p.remove_value("6", VT_BOOL, &v) == STATUS_BAD_TYPE);
1115 OK(p.remove_undef("6"));
1116
1117 OK(p.remove("7", &vv.xv));
1118 UTEST_ASSERT(vv.xv.type == VT_INT);
1119 UTEST_ASSERT(vv.xv.v_int == 42);
1120
1121 UTEST_ASSERT(p.remove_int("8", &vv.iv) == STATUS_NOT_FOUND);
1122 UTEST_ASSERT(p.remove_float("8", &vv.fv) == STATUS_NOT_FOUND);
1123 UTEST_ASSERT(p.remove_string("8", &vv.sv) == STATUS_NOT_FOUND);
1124 UTEST_ASSERT(p.remove_bool("8", &vv.bv) == STATUS_NOT_FOUND);
1125 UTEST_ASSERT(p.remove_null("8") == STATUS_NOT_FOUND);
1126 UTEST_ASSERT(p.remove_undef("8") == STATUS_NOT_FOUND);
1127 UTEST_ASSERT(p.remove_value("8", VT_BOOL, &v) == STATUS_NOT_FOUND);
1128 UTEST_ASSERT(p.remove("8", &v) == STATUS_NOT_FOUND);
1129
1130 UTEST_ASSERT(p.size() == 0);
1131
1132 // Append named parameters
1133 OK(p.add_int("1", 123));
1134 OK(p.add_float("2", 440.0));
1135 OK(p.add_cstring("3", "string0"));
1136 OK(p.add_bool("4", true));
1137 OK(p.add_null("5"));
1138 OK(p.add_undef("6"));
1139 v.type = VT_INT;
1140 v.v_int = 42;
1141 OK(p.add("7", &v));
1142
1143 // Remove parameters by name (2)
1144 vv.iv = 0;
1145 vv.fv = 0.0;
1146 vv.bv = false;
1147 vv.sv.clear();
1148 vv.sv2.clear();
1149 destroy_value(&vv.xv);
1150
1151 UTEST_ASSERT(k.set_ascii("1"));
1152 UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE);
1153 UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE);
1154 UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE);
1155 UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE);
1156 UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE);
1157 UTEST_ASSERT(p.remove_value(&k, VT_FLOAT, &v) == STATUS_BAD_TYPE);
1158 OK(p.remove_int(&k, &vv.iv));
1159 UTEST_ASSERT(vv.iv == 123);
1160
1161 UTEST_ASSERT(k.set_ascii("2"));
1162 UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE);
1163 UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE);
1164 UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE);
1165 UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE);
1166 UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE);
1167 UTEST_ASSERT(p.remove_value(&k, VT_INT, &v) == STATUS_BAD_TYPE);
1168 OK(p.remove_float(&k, &vv.fv));
1169 UTEST_ASSERT(vv.fv == 440.0);
1170
1171 UTEST_ASSERT(k.set_ascii("3"));
1172 UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE);
1173 UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE);
1174 UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE);
1175 UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE);
1176 UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE);
1177 UTEST_ASSERT(p.remove_value(&k, VT_NULL, &v) == STATUS_BAD_TYPE);
1178 OK(p.remove_string(&k, &vv.sv));
1179 UTEST_ASSERT(vv.sv.equals_ascii("string0"));
1180
1181 UTEST_ASSERT(k.set_ascii("4"));
1182 UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE);
1183 UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE);
1184 UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE);
1185 UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE);
1186 UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE);
1187 UTEST_ASSERT(p.remove_value(&k, VT_STRING, &v) == STATUS_BAD_TYPE);
1188 OK(p.remove_bool(&k, &vv.bv));
1189 UTEST_ASSERT(vv.bv == true);
1190
1191 UTEST_ASSERT(k.set_ascii("5"));
1192 UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE);
1193 UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE);
1194 UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE);
1195 UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE);
1196 UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE);
1197 UTEST_ASSERT(p.remove_value(&k, VT_UNDEF, &v) == STATUS_BAD_TYPE);
1198 OK(p.remove_null(&k));
1199
1200 UTEST_ASSERT(k.set_ascii("6"));
1201 UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE);
1202 UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE);
1203 UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE);
1204 UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE);
1205 UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE);
1206 UTEST_ASSERT(p.remove_value(&k, VT_BOOL, &v) == STATUS_BAD_TYPE);
1207 OK(p.remove_undef(&k));
1208
1209 UTEST_ASSERT(k.set_ascii("7"));
1210 OK(p.remove(&k, &vv.xv));
1211 UTEST_ASSERT(vv.xv.type == VT_INT);
1212 UTEST_ASSERT(vv.xv.v_int == 42);
1213
1214 UTEST_ASSERT(k.set_ascii("8"));
1215 UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_NOT_FOUND);
1216 UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_NOT_FOUND);
1217 UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_NOT_FOUND);
1218 UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_NOT_FOUND);
1219 UTEST_ASSERT(p.remove_null(&k) == STATUS_NOT_FOUND);
1220 UTEST_ASSERT(p.remove_undef(&k) == STATUS_NOT_FOUND);
1221 UTEST_ASSERT(p.remove_value(&k, VT_BOOL, &v) == STATUS_NOT_FOUND);
1222 UTEST_ASSERT(p.remove(&k, &v) == STATUS_NOT_FOUND);
1223
1224 UTEST_ASSERT(p.size() == 0);
1225
1226 destroy_value(&vv.xv);
1227 }
1228
1229 void test_get_type()
1230 {
1231 Parameters p;
1232 LSPString tmp, k;
1233 values_t vv;
1234 init_value(&vv.xv);
1235
1236 // Append named parameters
1237 OK(p.add_int("1", 123));
1238 OK(p.add_float("2", 440.0));
1239 OK(p.add_cstring("3", "string0"));
1240 OK(p.add_bool("4", true));
1241 OK(p.add_null("5"));
1242 OK(p.add_undef("6"));
1243
1244 // Get names
1245 OK(p.get_name(0, &k));
1246 UTEST_ASSERT(p.get_type(size_t(0)) == VT_INT);
1247 UTEST_ASSERT(k.equals_ascii("1"));
1248 OK(p.get_name(1, &k));
1249 UTEST_ASSERT(p.get_type(1) == VT_FLOAT);
1250 UTEST_ASSERT(k.equals_ascii("2"));
1251 OK(p.get_name(2, &k));
1252 UTEST_ASSERT(p.get_type(2) == VT_STRING);
1253 UTEST_ASSERT(k.equals_ascii("3"));
1254 OK(p.get_name(3, &k));
1255 UTEST_ASSERT(p.get_type(3) == VT_BOOL);
1256 UTEST_ASSERT(k.equals_ascii("4"));
1257 OK(p.get_name(4, &k));
1258 UTEST_ASSERT(p.get_type(4) == VT_NULL);
1259 UTEST_ASSERT(k.equals_ascii("5"));
1260 OK(p.get_name(5, &k));
1261 UTEST_ASSERT(p.get_type(5) == VT_UNDEF);
1262 UTEST_ASSERT(k.equals_ascii("6"));
1263 UTEST_ASSERT(p.get_type(6) == -STATUS_INVALID_VALUE);
1264 UTEST_ASSERT(p.get_name(6, &k) == STATUS_INVALID_VALUE);
1265
1266 // Get indexes
1267 UTEST_ASSERT(p.get_index("1") == 0);
1268 UTEST_ASSERT(p.get_type("1") == VT_INT);
1269 UTEST_ASSERT(p.get_index("2") == 1);
1270 UTEST_ASSERT(p.get_type("2") == VT_FLOAT);
1271 UTEST_ASSERT(p.get_index("3") == 2);
1272 UTEST_ASSERT(p.get_type("3") == VT_STRING);
1273 UTEST_ASSERT(p.get_index("4") == 3);
1274 UTEST_ASSERT(p.get_type("4") == VT_BOOL);
1275 UTEST_ASSERT(p.get_index("5") == 4);
1276 UTEST_ASSERT(p.get_type("5") == VT_NULL);
1277 UTEST_ASSERT(p.get_index("6") == 5);
1278 UTEST_ASSERT(p.get_type("6") == VT_UNDEF);
1279 UTEST_ASSERT(p.get_index("7") == -STATUS_NOT_FOUND);
1280 UTEST_ASSERT(p.get_type("7") == -STATUS_NOT_FOUND);
1281
1282 // Get indexes (LSPString)
1283 UTEST_ASSERT(k.set_ascii("1"));
1284 UTEST_ASSERT(p.get_index(&k) == 0);
1285 UTEST_ASSERT(p.get_type(&k) == VT_INT);
1286 UTEST_ASSERT(k.set_ascii("2"));
1287 UTEST_ASSERT(p.get_index(&k) == 1);
1288 UTEST_ASSERT(p.get_type(&k) == VT_FLOAT);
1289 UTEST_ASSERT(k.set_ascii("3"));
1290 UTEST_ASSERT(p.get_index(&k) == 2);
1291 UTEST_ASSERT(p.get_type(&k) == VT_STRING);
1292 UTEST_ASSERT(k.set_ascii("4"));
1293 UTEST_ASSERT(p.get_index(&k) == 3);
1294 UTEST_ASSERT(p.get_type(&k) == VT_BOOL);
1295 UTEST_ASSERT(k.set_ascii("5"));
1296 UTEST_ASSERT(p.get_index(&k) == 4);
1297 UTEST_ASSERT(p.get_type(&k) == VT_NULL);
1298 UTEST_ASSERT(k.set_ascii("6"));
1299 UTEST_ASSERT(p.get_index(&k) == 5);
1300 UTEST_ASSERT(p.get_type(&k) == VT_UNDEF);
1301 UTEST_ASSERT(k.set_ascii("7"));
1302 UTEST_ASSERT(p.get_index(&k) == -STATUS_NOT_FOUND);
1303 UTEST_ASSERT(p.get_type(&k) == -STATUS_NOT_FOUND);
1304
1305 destroy_value(&vv.xv);
1306 }
1307
1308 void test_set_operations()
1309 {
1310 Parameters p;
1311 OK(p.add_int("1", 123));
1312 OK(p.add_float("2", 440.0));
1313 OK(p.add_cstring("3", "string0"));
1314 OK(p.add_bool("4", true));
1315 OK(p.add_null("5"));
1316 OK(p.add_undef("6"));
1317 UTEST_ASSERT(p.size() == 6);
1318
1319 // Check clones
1320 Parameters *tmp = p.clone();
1321 UTEST_ASSERT(tmp->size() == 6);
1322 UTEST_ASSERT(tmp->get_type("1") == VT_INT);
1323 UTEST_ASSERT(tmp->get_type("2") == VT_FLOAT);
1324 UTEST_ASSERT(tmp->get_type("3") == VT_STRING);
1325 UTEST_ASSERT(tmp->get_type("4") == VT_BOOL);
1326 UTEST_ASSERT(tmp->get_type("5") == VT_NULL);
1327 UTEST_ASSERT(tmp->get_type("6") == VT_UNDEF);
1328
1329 // Clear
1330 tmp->clear();
1331 UTEST_ASSERT(tmp->size() == 0);
1332
1333 // Add parameters
1334 OK(tmp->add_int("4", 42));
1335 OK(tmp->add(&p, 3, 6));
1336 OK(tmp->insert(0, &p, 0, 3));
1337 UTEST_ASSERT(tmp->size() == 7);
1338
1339 UTEST_ASSERT(tmp->get_type("1") == VT_INT);
1340 UTEST_ASSERT(tmp->get_type("2") == VT_FLOAT);
1341 UTEST_ASSERT(tmp->get_type("3") == VT_STRING);
1342 UTEST_ASSERT(tmp->get_type("4") == VT_INT);
1343 UTEST_ASSERT(tmp->get_type("5") == VT_NULL);
1344 UTEST_ASSERT(tmp->get_type("6") == VT_UNDEF);
1345
1346 UTEST_ASSERT(tmp->get_type(size_t(0)) == VT_INT);
1347 UTEST_ASSERT(tmp->get_type(1) == VT_FLOAT);
1348 UTEST_ASSERT(tmp->get_type(2) == VT_STRING);
1349 UTEST_ASSERT(tmp->get_type(3) == VT_INT);
1350 UTEST_ASSERT(tmp->get_type(4) == VT_BOOL);
1351 UTEST_ASSERT(tmp->get_type(5) == VT_NULL);
1352 UTEST_ASSERT(tmp->get_type(6) == VT_UNDEF);
1353
1354 // Remove parameters
1355 OK(tmp->remove(2, 5));
1356 UTEST_ASSERT(tmp->size() == 4);
1357
1358 UTEST_ASSERT(tmp->get_type(size_t(0)) == VT_INT);
1359 UTEST_ASSERT(tmp->get_type(1) == VT_FLOAT);
1360 UTEST_ASSERT(tmp->get_type(2) == VT_NULL);
1361 UTEST_ASSERT(tmp->get_type(3) == VT_UNDEF);
1362
1363 // Test swap
1364 p.swap(tmp);
1365 UTEST_ASSERT(p.size() == 4);
1366 UTEST_ASSERT(tmp->size() == 6);
1367
1368 delete tmp;
1369 }
1370
1371 UTEST_MAIN
1372 {
1373 printf("Testing add functions...\n");
1374 test_add();
1375
1376 printf("Testing insert functions...\n");
1377 test_insert();
1378
1379 printf("Testing cast functions...\n");
1380 test_cast();
1381
1382 printf("Testing set functions...\n");
1383 test_set();
1384
1385 printf("Testing remove functions...\n");
1386 test_remove();
1387
1388 printf("Testing get_type functions...\n");
1389 test_get_type();
1390
1391 printf("Testing functions for manipulating set of parameters...\n");
1392 test_set_operations();
1393 }
1394
1395 UTEST_END
1396
1397
1398
1399
1400