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