/* * Copyright (C) 2020 Linux Studio Plugins Project * (C) 2020 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 21 февр. 2020 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include namespace lsp { using namespace lsp::expr; } UTEST_BEGIN("runtime.expr", parameters) #define OK(expr) UTEST_ASSERT(expr == STATUS_OK); #define FC(a, b) UTEST_ASSERT(float_equals_relative(a, b)); #define EC(a, b) UTEST_ASSERT(a == b); typedef struct values_t { ssize_t iv; double fv; bool bv; LSPString sv; LSPString sv2; value_t xv; } values_t; void test_add() { Parameters p; value_t v; LSPString tmp, k; // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); UTEST_ASSERT(tmp.set_utf8("string1")); OK(p.add_string("4", &tmp)); OK(p.add_bool("5", true)); OK(p.add_null("6")); OK(p.add_undef("7")); v.type = VT_INT; v.v_int = 42; OK(p.add("8", &v)); UTEST_ASSERT(p.size() == 8); // Append named parameters(2) UTEST_ASSERT(k.set_utf8("1")); OK(p.add_int(&k, 456)); UTEST_ASSERT(k.set_utf8("2")); OK(p.add_float(&k, 880.0)); UTEST_ASSERT(k.set_utf8("3")); OK(p.add_cstring(&k, "stringA")); UTEST_ASSERT(tmp.set_utf8("stringB")); UTEST_ASSERT(k.set_utf8("4")); OK(p.add_string(&k, &tmp)); UTEST_ASSERT(k.set_utf8("5")); OK(p.add_bool(&k, false)); UTEST_ASSERT(k.set_utf8("6")); OK(p.add_null(&k)); UTEST_ASSERT(k.set_utf8("7")); OK(p.add_undef(&k)); UTEST_ASSERT(k.set_utf8("8")); v.type = VT_FLOAT; v.v_int = 42.0; OK(p.add(&k, &v)); UTEST_ASSERT(p.size() == 16); // Append anonymous parameters OK(p.add_int(789)); OK(p.add_float(220.0)); OK(p.add_cstring("test0")); UTEST_ASSERT(tmp.set_utf8("test1")); OK(p.add_string(&tmp)); OK(p.add_bool(true)); OK(p.add_null()); OK(p.add_undef()); v.type = VT_BOOL; v.v_int = true; OK(p.add(&v)); UTEST_ASSERT(p.size() == 24); // Validate values_t vv; init_value(&vv.xv); size_t i=0; // Part 1 check vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int(i++, &vv.iv)); OK(p.get_float(i++, &vv.fv)); OK(p.get_string(i++, &vv.sv)); OK(p.get_string(i++, &vv.sv2)); OK(p.get_bool(i++, &vv.bv)); OK(p.get_null(i++)); OK(p.get_undef(i++)); OK(p.get(i++, &vv.xv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(vv.sv2.equals_ascii("string1")); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); // Part 2 check vv.iv = 0; vv.fv = 0.0; vv.bv = true; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int(i++, &vv.iv)); OK(p.get_float(i++, &vv.fv)); OK(p.get_string(i++, &vv.sv)); OK(p.get_string(i++, &vv.sv2)); OK(p.get_bool(i++, &vv.bv)); OK(p.get_null(i++)); OK(p.get_undef(i++)); OK(p.get(i++, &vv.xv)); UTEST_ASSERT(vv.iv == 456); UTEST_ASSERT(vv.fv == 880.0); UTEST_ASSERT(vv.sv.equals_ascii("stringA")); UTEST_ASSERT(vv.sv2.equals_ascii("stringB")); UTEST_ASSERT(vv.bv == false); UTEST_ASSERT(vv.xv.type == VT_FLOAT); UTEST_ASSERT(vv.xv.v_int == 42.0); // Part 3 vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int(i++, &vv.iv)); OK(p.get_float(i++, &vv.fv)); OK(p.get_string(i++, &vv.sv)); OK(p.get_string(i++, &vv.sv2)); OK(p.get_bool(i++, &vv.bv)); OK(p.get_null(i++)); OK(p.get_undef(i++)); OK(p.get(i++, &vv.xv)); UTEST_ASSERT(vv.iv == 789); UTEST_ASSERT(vv.fv == 220.0); UTEST_ASSERT(vv.sv.equals_ascii("test0")); UTEST_ASSERT(vv.sv2.equals_ascii("test1")); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.xv.type == VT_BOOL); UTEST_ASSERT(vv.xv.v_bool == true); // Part 4 UTEST_ASSERT(p.get_int(i, &vv.iv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.get_float(i, &vv.fv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.get_bool(i, &vv.bv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.get_string(i, &vv.sv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.get(i, &vv.xv) == STATUS_INVALID_VALUE); // Validate fetching parameters by name (part 1) vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int("1", &vv.iv)); OK(p.get_float("2", &vv.fv)); OK(p.get_string("3", &vv.sv)); OK(p.get_string("4", &vv.sv2)); OK(p.get_bool("5", &vv.bv)); OK(p.get_null("6")); OK(p.get_undef("7")); OK(p.get("8", &vv.xv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(vv.sv2.equals_ascii("string1")); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); UTEST_ASSERT(p.get_int("9", &vv.iv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get_float("9", &vv.fv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get_bool("9", &vv.bv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get_string("9", &vv.sv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get("9", &vv.xv) == STATUS_NOT_FOUND); // Validate fetching parameters by name (part 2) vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); UTEST_ASSERT(k.set_utf8("1")); OK(p.get_int(&k, &vv.iv)); UTEST_ASSERT(k.set_utf8("2")); OK(p.get_float(&k, &vv.fv)); UTEST_ASSERT(k.set_utf8("3")); OK(p.get_string(&k, &vv.sv)); UTEST_ASSERT(k.set_utf8("4")); OK(p.get_string(&k, &vv.sv2)); UTEST_ASSERT(k.set_utf8("5")); OK(p.get_bool(&k, &vv.bv)); UTEST_ASSERT(k.set_utf8("6")); OK(p.get_null(&k)); UTEST_ASSERT(k.set_utf8("7")); OK(p.get_undef(&k)); UTEST_ASSERT(k.set_utf8("8")); OK(p.get(&k, &vv.xv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(vv.sv2.equals_ascii("string1")); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.get_int(&k, &vv.iv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get_float(&k, &vv.fv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get_bool(&k, &vv.bv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get_string(&k, &vv.sv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.get(&k, &vv.xv) == STATUS_NOT_FOUND); destroy_value(&vv.xv); } void test_insert() { Parameters p; value_t v; LSPString tmp, k; values_t vv; init_value(&vv.xv); // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); UTEST_ASSERT(tmp.set_utf8("string1")); OK(p.add_string("4", &tmp)); OK(p.add_bool("5", true)); OK(p.add_null("6")); OK(p.add_undef("7")); v.type = VT_INT; v.v_int = 42; OK(p.add("8", &v)); UTEST_ASSERT(p.size() == 8); // Insert named parameters OK(p.insert_int(0, "1", 456)); OK(p.insert_float(1, "2", 220.0)); OK(p.insert_string(2, "3", "stringA")); UTEST_ASSERT(tmp.set_utf8("stringB")); OK(p.insert_string(3, "4", &tmp)); OK(p.insert_bool(4, "5", false)); OK(p.insert_null(5, "6")); OK(p.insert_undef(6, "7")); v.type = VT_FLOAT; v.v_int = 42.0; OK(p.insert(7, "8", &v)); UTEST_ASSERT(p.size() == 16); // Check parameter types // Validate fetching parameters by name (part 1) vv.iv = 0; vv.bv = true; vv.fv = 0.0; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int("1", &vv.iv)); OK(p.get_float("2", &vv.fv)); OK(p.get_string("3", &vv.sv)); OK(p.get_string("4", &vv.sv2)); OK(p.get_bool("5", &vv.bv)); OK(p.get_null("6")); OK(p.get_undef("7")); OK(p.get("8", &vv.xv)); UTEST_ASSERT(vv.iv == 456); UTEST_ASSERT(vv.fv == 220.0); UTEST_ASSERT(vv.sv.equals_ascii("stringA")); UTEST_ASSERT(vv.sv2.equals_ascii("stringB")); UTEST_ASSERT(vv.bv == false); UTEST_ASSERT(vv.xv.type == VT_FLOAT); UTEST_ASSERT(vv.xv.v_int == 42.0); // Insert more named parameters UTEST_ASSERT(k.set_utf8("1")); OK(p.insert_int(0, &k, 789)); UTEST_ASSERT(k.set_utf8("2")); OK(p.insert_float(1, &k, 880.0)); UTEST_ASSERT(k.set_utf8("3")); OK(p.insert_string(2, &k, "testA")); UTEST_ASSERT(k.set_utf8("4")); UTEST_ASSERT(tmp.set_utf8("testB")); OK(p.insert_string(3, &k, &tmp)); UTEST_ASSERT(k.set_utf8("5")); OK(p.insert_bool(4, &k, true)); UTEST_ASSERT(k.set_utf8("6")); OK(p.insert_null(5, &k)); UTEST_ASSERT(k.set_utf8("7")); OK(p.insert_undef(6, &k)); v.type = VT_BOOL; v.v_bool = true; UTEST_ASSERT(k.set_utf8("8")); OK(p.insert(7, &k, &v)); UTEST_ASSERT(p.size() == 24); // Check parameter types // Validate fetching parameters by name (part 1) vv.iv = 0; vv.bv = false; vv.fv = 0.0; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int("1", &vv.iv)); OK(p.get_float("2", &vv.fv)); OK(p.get_string("3", &vv.sv)); OK(p.get_string("4", &vv.sv2)); OK(p.get_bool("5", &vv.bv)); OK(p.get_null("6")); OK(p.get_undef("7")); OK(p.get("8", &vv.xv)); UTEST_ASSERT(vv.iv == 789); UTEST_ASSERT(vv.fv == 880.0); UTEST_ASSERT(vv.sv.equals_ascii("testA")); UTEST_ASSERT(vv.sv2.equals_ascii("testB")); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.xv.type == VT_BOOL); UTEST_ASSERT(vv.xv.v_int == true); // Test invalid inserts UTEST_ASSERT(p.insert_int(100, 789) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.insert_float(100, 1.0) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.insert_cstring(100, "abc") == STATUS_INVALID_VALUE); UTEST_ASSERT(p.insert_string(100, &tmp) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.insert_null(100) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.insert_undef(100) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.insert(100, &v) == STATUS_INVALID_VALUE); } void test_cast() { Parameters p; value_t v; LSPString tmp, k; values_t vv; init_value(&vv.xv); // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); UTEST_ASSERT(tmp.set_utf8("456")); OK(p.add_string("4", &tmp)); OK(p.add_bool("5", true)); OK(p.add_null("6")); OK(p.add_undef("7")); v.type = VT_INT; v.v_int = 42; OK(p.add("8", &v)); UTEST_ASSERT(p.size() == 8); // Check casts to int OK(p.as_int(size_t(0), &v.v_int)); UTEST_ASSERT(v.v_int == 123); OK(p.as_int(1, &v.v_int)); UTEST_ASSERT(v.v_int == 440); UTEST_ASSERT(p.as_int(2, &v.v_int) == STATUS_BAD_TYPE); OK(p.as_int(3, &v.v_int)); UTEST_ASSERT(v.v_int == 456); OK(p.as_int(4, &v.v_int)); UTEST_ASSERT(v.v_int == 1); UTEST_ASSERT(p.as_int(5, &v.v_int) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_int(6, &v.v_int) == STATUS_BAD_TYPE); OK(p.as_value(7, &v, VT_INT)); UTEST_ASSERT(v.type == VT_INT); UTEST_ASSERT(v.v_int == 42); UTEST_ASSERT(p.as_int(8, &v.v_int) == STATUS_INVALID_VALUE); OK(p.as_int("1", &v.v_int)); UTEST_ASSERT(v.v_int == 123); OK(p.as_int("2", &v.v_int)); UTEST_ASSERT(v.v_int == 440); UTEST_ASSERT(p.as_int("3", &v.v_int) == STATUS_BAD_TYPE); OK(p.as_int("4", &v.v_int)); UTEST_ASSERT(v.v_int == 456); OK(p.as_int("5", &v.v_int)); UTEST_ASSERT(v.v_int == 1); UTEST_ASSERT(p.as_int("6", &v.v_int) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_int("7", &v.v_int) == STATUS_BAD_TYPE); OK(p.as_value("8", &v, VT_INT)); UTEST_ASSERT(v.type == VT_INT); UTEST_ASSERT(v.v_int == 42); UTEST_ASSERT(p.as_int("9", &v.v_int) == STATUS_NOT_FOUND); UTEST_ASSERT(k.set_utf8("1")); OK(p.as_int(&k, &v.v_int)); UTEST_ASSERT(v.v_int == 123); UTEST_ASSERT(k.set_utf8("2")); OK(p.as_int(&k, &v.v_int)); UTEST_ASSERT(v.v_int == 440); UTEST_ASSERT(k.set_utf8("3")); UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("4")); OK(p.as_int(&k, &v.v_int)); UTEST_ASSERT(v.v_int == 456); UTEST_ASSERT(k.set_utf8("5")); OK(p.as_int(&k, &v.v_int)); UTEST_ASSERT(v.v_int == 1); UTEST_ASSERT(k.set_utf8("6")); UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("7")); UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("8")); OK(p.as_value(&k, &v, VT_INT)); UTEST_ASSERT(v.type == VT_INT); UTEST_ASSERT(v.v_int == 42); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.as_int(&k, &v.v_int) == STATUS_NOT_FOUND); // Check casts to float OK(p.as_float(size_t(0), &v.v_float)); FC(v.v_float, 123.0); OK(p.as_float(1, &v.v_float)); FC(v.v_float, 440.0); UTEST_ASSERT(p.as_float(2, &v.v_float) == STATUS_BAD_TYPE); OK(p.as_float(3, &v.v_float)); FC(v.v_float, 456.0); OK(p.as_float(4, &v.v_float)); FC(v.v_float, 1.0); UTEST_ASSERT(p.as_float(5, &v.v_float) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_float(6, &v.v_float) == STATUS_BAD_TYPE); OK(p.as_value(7, &v, VT_FLOAT)); UTEST_ASSERT(v.type == VT_FLOAT); FC(v.v_float, 42.0); UTEST_ASSERT(p.as_float(8, &v.v_float) == STATUS_INVALID_VALUE); OK(p.as_float("1", &v.v_float)); FC(v.v_float, 123.0); OK(p.as_float("2", &v.v_float)); FC(v.v_float, 440.0); UTEST_ASSERT(p.as_float("3", &v.v_float) == STATUS_BAD_TYPE); OK(p.as_float("4", &v.v_float)); FC(v.v_float, 456.0); OK(p.as_float("5", &v.v_float)); FC(v.v_float, 1.0); UTEST_ASSERT(p.as_float("6", &v.v_float) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_float("7", &v.v_float) == STATUS_BAD_TYPE); OK(p.as_value("8", &v, VT_FLOAT)); UTEST_ASSERT(v.type == VT_FLOAT); FC(v.v_float, 42.0); UTEST_ASSERT(p.as_float("9", &v.v_float) == STATUS_NOT_FOUND); UTEST_ASSERT(k.set_utf8("1")); OK(p.as_float(&k, &v.v_float)); FC(v.v_float, 123.0); UTEST_ASSERT(k.set_utf8("2")); OK(p.as_float(&k, &v.v_float)); FC(v.v_float, 440.0); UTEST_ASSERT(k.set_utf8("3")); UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("4")); OK(p.as_float(&k, &v.v_float)); FC(v.v_float, 456.0); UTEST_ASSERT(k.set_utf8("5")); OK(p.as_float(&k, &v.v_float)); FC(v.v_float, 1.0); UTEST_ASSERT(k.set_utf8("6")); UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("7")); UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("8")); OK(p.as_value(&k, &v, VT_FLOAT)); UTEST_ASSERT(v.type == VT_FLOAT); FC(v.v_float, 42.0); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.as_float(&k, &v.v_float) == STATUS_NOT_FOUND); // Check casts to bool OK(p.as_bool(size_t(0), &v.v_bool)); EC(v.v_bool, true); OK(p.as_bool(1, &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(p.as_bool(2, &v.v_bool) == STATUS_BAD_TYPE); OK(p.as_bool(3, &v.v_bool)); EC(v.v_bool, true); OK(p.as_bool(4, &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(p.as_bool(5, &v.v_bool) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_bool(6, &v.v_bool) == STATUS_BAD_TYPE); OK(p.as_value(7, &v, VT_BOOL)); UTEST_ASSERT(v.type == VT_BOOL); EC(v.v_bool, true); UTEST_ASSERT(p.as_bool(8, &v.v_bool) == STATUS_INVALID_VALUE); OK(p.as_bool("1", &v.v_bool)); EC(v.v_bool, true); OK(p.as_bool("2", &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(p.as_bool("3", &v.v_bool) == STATUS_BAD_TYPE); OK(p.as_bool("4", &v.v_bool)); EC(v.v_bool, true); OK(p.as_bool("5", &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(p.as_bool("6", &v.v_bool) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_bool("7", &v.v_bool) == STATUS_BAD_TYPE); OK(p.as_value("8", &v, VT_BOOL)); UTEST_ASSERT(v.type == VT_BOOL); EC(v.v_bool, true); UTEST_ASSERT(p.as_bool("9", &v.v_bool) == STATUS_NOT_FOUND); UTEST_ASSERT(k.set_utf8("1")); OK(p.as_bool(&k, &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(k.set_utf8("2")); OK(p.as_bool(&k, &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(k.set_utf8("3")); UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("4")); OK(p.as_bool(&k, &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(k.set_utf8("5")); OK(p.as_bool(&k, &v.v_bool)); EC(v.v_bool, true); UTEST_ASSERT(k.set_utf8("6")); UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("7")); UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("8")); OK(p.as_value(&k, &v, VT_BOOL)); UTEST_ASSERT(v.type == VT_BOOL); EC(v.v_bool, true); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.as_bool(&k, &v.v_bool) == STATUS_NOT_FOUND); // Check casts to string OK(p.as_string(size_t(0), &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("123")); OK(p.as_string(1, &vv.sv)); UTEST_ASSERT(vv.sv.starts_with_ascii("440.")); OK(p.as_string(2, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("string0")); OK(p.as_string(3, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("456")); OK(p.as_string(4, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("true")); UTEST_ASSERT(p.as_string(5, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_string(6, &vv.sv) == STATUS_BAD_TYPE); OK(p.as_value(7, &vv.xv, VT_STRING)); UTEST_ASSERT(vv.xv.type == VT_STRING); UTEST_ASSERT(vv.xv.v_str->equals_ascii("42")); UTEST_ASSERT(p.as_string(8, &vv.sv) == STATUS_INVALID_VALUE); OK(p.as_string("1", &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("123")); OK(p.as_string("2", &vv.sv)); UTEST_ASSERT(vv.sv.starts_with_ascii("440.")); OK(p.as_string("3", &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("string0")); OK(p.as_string("4", &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("456")); OK(p.as_string("5", &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("true")); UTEST_ASSERT(p.as_string("6", &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.as_string("7", &vv.sv) == STATUS_BAD_TYPE); OK(p.as_value("8", &vv.xv, VT_STRING)); UTEST_ASSERT(vv.xv.type == VT_STRING); UTEST_ASSERT(vv.xv.v_str->equals_ascii("42")); UTEST_ASSERT(p.as_string("9", &vv.sv) == STATUS_NOT_FOUND); UTEST_ASSERT(k.set_utf8("1")); OK(p.as_string(&k, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("123")); UTEST_ASSERT(k.set_utf8("2")); OK(p.as_string(&k, &vv.sv)); UTEST_ASSERT(vv.sv.starts_with_ascii("440.")); UTEST_ASSERT(k.set_utf8("3")); OK(p.as_string(&k, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(k.set_utf8("4")); OK(p.as_string(&k, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("456")); UTEST_ASSERT(k.set_utf8("5")); OK(p.as_string(&k, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("true")); UTEST_ASSERT(k.set_utf8("6")); UTEST_ASSERT(p.as_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("7")); UTEST_ASSERT(p.as_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(k.set_utf8("8")); OK(p.as_value(&k, &vv.xv, VT_STRING)); UTEST_ASSERT(vv.xv.type == VT_STRING); UTEST_ASSERT(vv.xv.v_str->equals_ascii("42")); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.as_string(&k, &vv.sv) == STATUS_NOT_FOUND); // Check casts to null OK(p.as_null(size_t(0))); OK(p.as_null(1)); OK(p.as_null(2)); OK(p.as_null(3)); OK(p.as_null(4)); OK(p.as_null(5)); OK(p.as_null(6)); OK(p.as_value(7, &vv.xv, VT_NULL)); UTEST_ASSERT(vv.xv.type == VT_NULL); UTEST_ASSERT(p.as_null(8) == STATUS_INVALID_VALUE); OK(p.as_null("1")); OK(p.as_null("2")); OK(p.as_null("3")); OK(p.as_null("4")); OK(p.as_null("5")); OK(p.as_null("6")); OK(p.as_null("7")); OK(p.as_value("8", &vv.xv, VT_NULL)); UTEST_ASSERT(vv.xv.type == VT_NULL); UTEST_ASSERT(p.as_null("9") == STATUS_NOT_FOUND); UTEST_ASSERT(k.set_utf8("1")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("2")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("3")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("4")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("5")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("6")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("7")); OK(p.as_null(&k)); UTEST_ASSERT(k.set_utf8("8")); OK(p.as_value(&k, &vv.xv, VT_NULL)); UTEST_ASSERT(vv.xv.type == VT_NULL); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.as_null(&k) == STATUS_NOT_FOUND); // Check casts to undef OK(p.as_undef(size_t(0))); OK(p.as_undef(1)); OK(p.as_undef(2)); OK(p.as_undef(3)); OK(p.as_undef(4)); OK(p.as_undef(5)); OK(p.as_undef(6)); OK(p.as_value(7, &vv.xv, VT_UNDEF)); UTEST_ASSERT(vv.xv.type == VT_UNDEF); UTEST_ASSERT(p.as_undef(8) == STATUS_INVALID_VALUE); OK(p.as_undef("1")); OK(p.as_undef("2")); OK(p.as_undef("3")); OK(p.as_undef("4")); OK(p.as_undef("5")); OK(p.as_undef("6")); OK(p.as_undef("7")); OK(p.as_value("8", &vv.xv, VT_UNDEF)); UTEST_ASSERT(vv.xv.type == VT_UNDEF); UTEST_ASSERT(p.as_undef("9") == STATUS_NOT_FOUND); UTEST_ASSERT(k.set_utf8("1")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("2")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("3")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("4")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("5")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("6")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("7")); OK(p.as_undef(&k)); UTEST_ASSERT(k.set_utf8("8")); OK(p.as_value(&k, &vv.xv, VT_UNDEF)); UTEST_ASSERT(vv.xv.type == VT_UNDEF); UTEST_ASSERT(k.set_utf8("9")); UTEST_ASSERT(p.as_undef(&k) == STATUS_NOT_FOUND); } void test_set() { Parameters p; value_t v; LSPString tmp, k; values_t vv; init_value(&vv.xv); size_t i=0; OK(p.add_undef("1")); OK(p.add_undef("2")); OK(p.add_undef("3")); OK(p.add_undef("4")); OK(p.add_undef("5")); OK(p.add_undef("6")); OK(p.add_undef("7")); OK(p.add_undef("8")); // Test setting by index OK(p.set_int(size_t(0), 123)); OK(p.set_float(1, 220.0)); OK(p.set_bool(2, true)); OK(p.set_cstring(3, "string0")); UTEST_ASSERT(tmp.set_ascii("string1")); OK(p.set_string(4, &tmp)); OK(p.set_null(5)); OK(p.set_undef(6)); v.type = VT_INT; v.v_int = 42; OK(p.set(7, &v)); UTEST_ASSERT(p.set_int(8, 456) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set_float(8, 440.0) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set_bool(8, false) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set_cstring(8, "bad") == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set_string(8, &tmp) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set_null(8) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set_undef(8) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.set(8, &v) == STATUS_INVALID_VALUE); // Validate values i = 0; vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int(i++, &vv.iv)); OK(p.get_float(i++, &vv.fv)); OK(p.get_bool(i++, &vv.bv)); OK(p.get_string(i++, &vv.sv)); OK(p.get_string(i++, &vv.sv2)); OK(p.get_null(i++)); OK(p.get_undef(i++)); OK(p.get(i++, &vv.xv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(vv.fv == 220.0); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(vv.sv2.equals_ascii("string1")); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); // Test setting by name OK(p.set_int("1", 456)); OK(p.set_float("2", 440.0)); OK(p.set_bool("3", false)); OK(p.set_cstring("4", "stringA")); UTEST_ASSERT(tmp.set_ascii("stringB")); OK(p.set_string("5", &tmp)); OK(p.set_null("6")); OK(p.set_undef("7")); v.type = VT_FLOAT; v.v_float = 42.0; OK(p.set("8", &v)); // Validate values i = 0; vv.iv = 0; vv.fv = 0.0; vv.bv = true; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int(i++, &vv.iv)); OK(p.get_float(i++, &vv.fv)); OK(p.get_bool(i++, &vv.bv)); OK(p.get_string(i++, &vv.sv)); OK(p.get_string(i++, &vv.sv2)); OK(p.get_null(i++)); OK(p.get_undef(i++)); OK(p.get(i++, &vv.xv)); UTEST_ASSERT(vv.iv == 456); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(vv.bv == false); UTEST_ASSERT(vv.sv.equals_ascii("stringA")); UTEST_ASSERT(vv.sv2.equals_ascii("stringB")); UTEST_ASSERT(vv.xv.type == VT_FLOAT); UTEST_ASSERT(vv.xv.v_float == 42.0); // Test setting non-existing values OK(p.set_int("9", 123)); OK(p.set_float("10", 220.0)); OK(p.set_bool("11", true)); OK(p.set_cstring("12", "string0")); UTEST_ASSERT(tmp.set_ascii("string1")); OK(p.set_string("13", &tmp)); OK(p.set_null("14")); OK(p.set_undef("15")); v.type = VT_INT; v.v_int = 42; OK(p.set("16", &v)); UTEST_ASSERT(p.size() == 16); UTEST_ASSERT(p.get_index("9") == 8); UTEST_ASSERT(p.get_index("10") == 9); UTEST_ASSERT(p.get_index("11") == 10); UTEST_ASSERT(p.get_index("12") == 11); UTEST_ASSERT(p.get_index("13") == 12); UTEST_ASSERT(p.get_index("14") == 13); UTEST_ASSERT(p.get_index("15") == 14); UTEST_ASSERT(p.get_index("16") == 15); // Test setting by name (2) UTEST_ASSERT(k.set_ascii("1")); OK(p.set_int(&k, 789)); UTEST_ASSERT(k.set_ascii("2")); OK(p.set_float(&k, 880.0)); UTEST_ASSERT(k.set_ascii("3")); OK(p.set_bool(&k, true)); UTEST_ASSERT(k.set_ascii("4")); OK(p.set_cstring(&k, "testA")); UTEST_ASSERT(tmp.set_ascii("testB")); UTEST_ASSERT(k.set_ascii("5")); OK(p.set_string(&k, &tmp)); UTEST_ASSERT(k.set_ascii("6")); OK(p.set_null(&k)); UTEST_ASSERT(k.set_ascii("7")); OK(p.set_undef(&k)); v.type = VT_INT; v.v_int = 42; UTEST_ASSERT(k.set_ascii("8")); OK(p.set(&k, &v)); // Validate values i = 0; vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); OK(p.get_int(i++, &vv.iv)); OK(p.get_float(i++, &vv.fv)); OK(p.get_bool(i++, &vv.bv)); OK(p.get_string(i++, &vv.sv)); OK(p.get_string(i++, &vv.sv2)); OK(p.get_null(i++)); OK(p.get_undef(i++)); OK(p.get(i++, &vv.xv)); UTEST_ASSERT(vv.iv == 789); UTEST_ASSERT(vv.fv == 880.0); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(vv.sv.equals_ascii("testA")); UTEST_ASSERT(vv.sv2.equals_ascii("testB")); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); // Test setting non-existing values UTEST_ASSERT(k.set_ascii("17")); OK(p.set_int(&k, 123)); UTEST_ASSERT(k.set_ascii("18")); OK(p.set_float(&k, 220.0)); UTEST_ASSERT(k.set_ascii("19")); OK(p.set_bool(&k, true)); UTEST_ASSERT(k.set_ascii("20")); OK(p.set_cstring(&k, "string0")); UTEST_ASSERT(tmp.set_ascii("string1")); UTEST_ASSERT(k.set_ascii("21")); OK(p.set_string(&k, &tmp)); UTEST_ASSERT(k.set_ascii("22")); OK(p.set_null(&k)); UTEST_ASSERT(k.set_ascii("23")); OK(p.set_undef(&k)); v.type = VT_INT; v.v_int = 42; UTEST_ASSERT(k.set_ascii("24")); OK(p.set(&k, &v)); UTEST_ASSERT(p.size() == 24); UTEST_ASSERT(k.set_ascii("17")); UTEST_ASSERT(p.get_index(&k) == 16); UTEST_ASSERT(k.set_ascii("18")); UTEST_ASSERT(p.get_index(&k) == 17); UTEST_ASSERT(k.set_ascii("19")); UTEST_ASSERT(p.get_index(&k) == 18); UTEST_ASSERT(k.set_ascii("20")); UTEST_ASSERT(p.get_index(&k) == 19); UTEST_ASSERT(k.set_ascii("21")); UTEST_ASSERT(p.get_index(&k) == 20); UTEST_ASSERT(k.set_ascii("22")); UTEST_ASSERT(p.get_index(&k) == 21); UTEST_ASSERT(k.set_ascii("23")); UTEST_ASSERT(p.get_index(&k) == 22); UTEST_ASSERT(k.set_ascii("24")); UTEST_ASSERT(p.get_index(&k) == 23); } void test_remove() { Parameters p; value_t v; LSPString tmp, k; values_t vv; init_value(&vv.xv); size_t i=0; // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); OK(p.add_bool("4", true)); OK(p.add_null("5")); OK(p.add_undef("6")); v.type = VT_INT; v.v_int = 42; OK(p.add("7", &v)); // Remove parameters by index vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(i, VT_FLOAT, &v) == STATUS_BAD_TYPE); OK(p.remove_int(i, &vv.iv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(i, VT_INT, &v) == STATUS_BAD_TYPE); OK(p.remove_float(i, &vv.fv)); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(i, VT_NULL, &v) == STATUS_BAD_TYPE); OK(p.remove_string(i, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(i, VT_STRING, &v) == STATUS_BAD_TYPE); OK(p.remove_bool(i, &vv.bv)); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(i, VT_UNDEF, &v) == STATUS_BAD_TYPE); OK(p.remove_null(i)); UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(i) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(i, VT_BOOL, &v) == STATUS_BAD_TYPE); OK(p.remove_undef(i)); OK(p.remove(i, &vv.xv)); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); UTEST_ASSERT(p.remove_int(i, &vv.iv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove_float(i, &vv.fv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove_bool(i, &vv.bv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove_string(i, &vv.sv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove_null(i) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove_undef(i) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove_value(i, VT_STRING, &v) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.remove(i, &vv.xv) == STATUS_INVALID_VALUE); UTEST_ASSERT(p.size() == 0); // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); OK(p.add_bool("4", true)); OK(p.add_null("5")); OK(p.add_undef("6")); v.type = VT_INT; v.v_int = 42; OK(p.add("7", &v)); // Remove parameters by name vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); UTEST_ASSERT(p.remove_float("1", &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string("1", &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool("1", &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null("1") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef("1") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value("1", VT_FLOAT, &v) == STATUS_BAD_TYPE); OK(p.remove_int("1", &vv.iv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(p.remove_int("2", &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string("2", &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool("2", &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null("2") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef("2") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value("2", VT_INT, &v) == STATUS_BAD_TYPE); OK(p.remove_float("2", &vv.fv)); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(p.remove_int("3", &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float("3", &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool("3", &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null("3") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef("3") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value("3", VT_NULL, &v) == STATUS_BAD_TYPE); OK(p.remove_string("3", &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(p.remove_int("4", &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float("4", &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string("4", &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null("4") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef("4") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value("4", VT_STRING, &v) == STATUS_BAD_TYPE); OK(p.remove_bool("4", &vv.bv)); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(p.remove_int("5", &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float("5", &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string("5", &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool("5", &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef("5") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value("5", VT_UNDEF, &v) == STATUS_BAD_TYPE); OK(p.remove_null("5")); UTEST_ASSERT(p.remove_int("6", &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float("6", &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string("6", &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool("6", &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null("6") == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value("6", VT_BOOL, &v) == STATUS_BAD_TYPE); OK(p.remove_undef("6")); OK(p.remove("7", &vv.xv)); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); UTEST_ASSERT(p.remove_int("8", &vv.iv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_float("8", &vv.fv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_string("8", &vv.sv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_bool("8", &vv.bv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_null("8") == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_undef("8") == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_value("8", VT_BOOL, &v) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove("8", &v) == STATUS_NOT_FOUND); UTEST_ASSERT(p.size() == 0); // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); OK(p.add_bool("4", true)); OK(p.add_null("5")); OK(p.add_undef("6")); v.type = VT_INT; v.v_int = 42; OK(p.add("7", &v)); // Remove parameters by name (2) vv.iv = 0; vv.fv = 0.0; vv.bv = false; vv.sv.clear(); vv.sv2.clear(); destroy_value(&vv.xv); UTEST_ASSERT(k.set_ascii("1")); UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(&k, VT_FLOAT, &v) == STATUS_BAD_TYPE); OK(p.remove_int(&k, &vv.iv)); UTEST_ASSERT(vv.iv == 123); UTEST_ASSERT(k.set_ascii("2")); UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(&k, VT_INT, &v) == STATUS_BAD_TYPE); OK(p.remove_float(&k, &vv.fv)); UTEST_ASSERT(vv.fv == 440.0); UTEST_ASSERT(k.set_ascii("3")); UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(&k, VT_NULL, &v) == STATUS_BAD_TYPE); OK(p.remove_string(&k, &vv.sv)); UTEST_ASSERT(vv.sv.equals_ascii("string0")); UTEST_ASSERT(k.set_ascii("4")); UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(&k, VT_STRING, &v) == STATUS_BAD_TYPE); OK(p.remove_bool(&k, &vv.bv)); UTEST_ASSERT(vv.bv == true); UTEST_ASSERT(k.set_ascii("5")); UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_undef(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(&k, VT_UNDEF, &v) == STATUS_BAD_TYPE); OK(p.remove_null(&k)); UTEST_ASSERT(k.set_ascii("6")); UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_null(&k) == STATUS_BAD_TYPE); UTEST_ASSERT(p.remove_value(&k, VT_BOOL, &v) == STATUS_BAD_TYPE); OK(p.remove_undef(&k)); UTEST_ASSERT(k.set_ascii("7")); OK(p.remove(&k, &vv.xv)); UTEST_ASSERT(vv.xv.type == VT_INT); UTEST_ASSERT(vv.xv.v_int == 42); UTEST_ASSERT(k.set_ascii("8")); UTEST_ASSERT(p.remove_int(&k, &vv.iv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_float(&k, &vv.fv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_string(&k, &vv.sv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_bool(&k, &vv.bv) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_null(&k) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_undef(&k) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove_value(&k, VT_BOOL, &v) == STATUS_NOT_FOUND); UTEST_ASSERT(p.remove(&k, &v) == STATUS_NOT_FOUND); UTEST_ASSERT(p.size() == 0); destroy_value(&vv.xv); } void test_get_type() { Parameters p; LSPString tmp, k; values_t vv; init_value(&vv.xv); // Append named parameters OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); OK(p.add_bool("4", true)); OK(p.add_null("5")); OK(p.add_undef("6")); // Get names OK(p.get_name(0, &k)); UTEST_ASSERT(p.get_type(size_t(0)) == VT_INT); UTEST_ASSERT(k.equals_ascii("1")); OK(p.get_name(1, &k)); UTEST_ASSERT(p.get_type(1) == VT_FLOAT); UTEST_ASSERT(k.equals_ascii("2")); OK(p.get_name(2, &k)); UTEST_ASSERT(p.get_type(2) == VT_STRING); UTEST_ASSERT(k.equals_ascii("3")); OK(p.get_name(3, &k)); UTEST_ASSERT(p.get_type(3) == VT_BOOL); UTEST_ASSERT(k.equals_ascii("4")); OK(p.get_name(4, &k)); UTEST_ASSERT(p.get_type(4) == VT_NULL); UTEST_ASSERT(k.equals_ascii("5")); OK(p.get_name(5, &k)); UTEST_ASSERT(p.get_type(5) == VT_UNDEF); UTEST_ASSERT(k.equals_ascii("6")); UTEST_ASSERT(p.get_type(6) == -STATUS_INVALID_VALUE); UTEST_ASSERT(p.get_name(6, &k) == STATUS_INVALID_VALUE); // Get indexes UTEST_ASSERT(p.get_index("1") == 0); UTEST_ASSERT(p.get_type("1") == VT_INT); UTEST_ASSERT(p.get_index("2") == 1); UTEST_ASSERT(p.get_type("2") == VT_FLOAT); UTEST_ASSERT(p.get_index("3") == 2); UTEST_ASSERT(p.get_type("3") == VT_STRING); UTEST_ASSERT(p.get_index("4") == 3); UTEST_ASSERT(p.get_type("4") == VT_BOOL); UTEST_ASSERT(p.get_index("5") == 4); UTEST_ASSERT(p.get_type("5") == VT_NULL); UTEST_ASSERT(p.get_index("6") == 5); UTEST_ASSERT(p.get_type("6") == VT_UNDEF); UTEST_ASSERT(p.get_index("7") == -STATUS_NOT_FOUND); UTEST_ASSERT(p.get_type("7") == -STATUS_NOT_FOUND); // Get indexes (LSPString) UTEST_ASSERT(k.set_ascii("1")); UTEST_ASSERT(p.get_index(&k) == 0); UTEST_ASSERT(p.get_type(&k) == VT_INT); UTEST_ASSERT(k.set_ascii("2")); UTEST_ASSERT(p.get_index(&k) == 1); UTEST_ASSERT(p.get_type(&k) == VT_FLOAT); UTEST_ASSERT(k.set_ascii("3")); UTEST_ASSERT(p.get_index(&k) == 2); UTEST_ASSERT(p.get_type(&k) == VT_STRING); UTEST_ASSERT(k.set_ascii("4")); UTEST_ASSERT(p.get_index(&k) == 3); UTEST_ASSERT(p.get_type(&k) == VT_BOOL); UTEST_ASSERT(k.set_ascii("5")); UTEST_ASSERT(p.get_index(&k) == 4); UTEST_ASSERT(p.get_type(&k) == VT_NULL); UTEST_ASSERT(k.set_ascii("6")); UTEST_ASSERT(p.get_index(&k) == 5); UTEST_ASSERT(p.get_type(&k) == VT_UNDEF); UTEST_ASSERT(k.set_ascii("7")); UTEST_ASSERT(p.get_index(&k) == -STATUS_NOT_FOUND); UTEST_ASSERT(p.get_type(&k) == -STATUS_NOT_FOUND); destroy_value(&vv.xv); } void test_set_operations() { Parameters p; OK(p.add_int("1", 123)); OK(p.add_float("2", 440.0)); OK(p.add_cstring("3", "string0")); OK(p.add_bool("4", true)); OK(p.add_null("5")); OK(p.add_undef("6")); UTEST_ASSERT(p.size() == 6); // Check clones Parameters *tmp = p.clone(); UTEST_ASSERT(tmp->size() == 6); UTEST_ASSERT(tmp->get_type("1") == VT_INT); UTEST_ASSERT(tmp->get_type("2") == VT_FLOAT); UTEST_ASSERT(tmp->get_type("3") == VT_STRING); UTEST_ASSERT(tmp->get_type("4") == VT_BOOL); UTEST_ASSERT(tmp->get_type("5") == VT_NULL); UTEST_ASSERT(tmp->get_type("6") == VT_UNDEF); // Clear tmp->clear(); UTEST_ASSERT(tmp->size() == 0); // Add parameters OK(tmp->add_int("4", 42)); OK(tmp->add(&p, 3, 6)); OK(tmp->insert(0, &p, 0, 3)); UTEST_ASSERT(tmp->size() == 7); UTEST_ASSERT(tmp->get_type("1") == VT_INT); UTEST_ASSERT(tmp->get_type("2") == VT_FLOAT); UTEST_ASSERT(tmp->get_type("3") == VT_STRING); UTEST_ASSERT(tmp->get_type("4") == VT_INT); UTEST_ASSERT(tmp->get_type("5") == VT_NULL); UTEST_ASSERT(tmp->get_type("6") == VT_UNDEF); UTEST_ASSERT(tmp->get_type(size_t(0)) == VT_INT); UTEST_ASSERT(tmp->get_type(1) == VT_FLOAT); UTEST_ASSERT(tmp->get_type(2) == VT_STRING); UTEST_ASSERT(tmp->get_type(3) == VT_INT); UTEST_ASSERT(tmp->get_type(4) == VT_BOOL); UTEST_ASSERT(tmp->get_type(5) == VT_NULL); UTEST_ASSERT(tmp->get_type(6) == VT_UNDEF); // Remove parameters OK(tmp->remove(2, 5)); UTEST_ASSERT(tmp->size() == 4); UTEST_ASSERT(tmp->get_type(size_t(0)) == VT_INT); UTEST_ASSERT(tmp->get_type(1) == VT_FLOAT); UTEST_ASSERT(tmp->get_type(2) == VT_NULL); UTEST_ASSERT(tmp->get_type(3) == VT_UNDEF); // Test swap p.swap(tmp); UTEST_ASSERT(p.size() == 4); UTEST_ASSERT(tmp->size() == 6); delete tmp; } UTEST_MAIN { printf("Testing add functions...\n"); test_add(); printf("Testing insert functions...\n"); test_insert(); printf("Testing cast functions...\n"); test_cast(); printf("Testing set functions...\n"); test_set(); printf("Testing remove functions...\n"); test_remove(); printf("Testing get_type functions...\n"); test_get_type(); printf("Testing functions for manipulating set of parameters...\n"); test_set_operations(); } UTEST_END