wehub/alibaba--zvec
1
0
Fork 0
Code Issues Pull Requests Actions 4 Deployments Models Agent Notes Packages Projects Releases Wiki Activity
Files
main
alibaba--zvec/tests/ailego/container/params_test.cc
T
wehub-resource-sync be3ef883e1 chore: import upstream snapshot with attribution
2026-07-13 12:47:42 +08:00

392 lines
14 KiB
C++
Raw Permalink Blame History

// Copyright 2025-present the zvec project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <gtest/gtest.h>
#include <zvec/ailego/container/params.h>
using namespace zvec;
using namespace zvec::ailego;
TEST(Params, General) {
Params params;
Params params1;
EXPECT_TRUE(params.empty());
EXPECT_TRUE(params1.empty());
params1.merge(params);
char test_string1[] = "test1";
params.set(test_string1, test_string1);
const char *test_string2 = "test2";
params.set(test_string2, test_string2);
params.set("11111", "11111");
params.set("22222", params1);
params.set("true", true);
params.set("-8", int8_t(-8));
params.set("-16", int16_t(-16));
params.set("-32", int32_t(-32));
params.set("-64", int64_t(-64));
params.set("8", uint8_t(8));
params.set("16", uint16_t(16));
params.set("32", uint32_t(32));
params.set("64", uint64_t(64));
params.set("100.0", float(100.0f));
params.set("1000.0", double(1000.0f));
params.set(std::string("string"), "string");
EXPECT_FALSE(params.empty());
EXPECT_TRUE(params.has("64"));
EXPECT_TRUE(params.has("32"));
EXPECT_TRUE(params.has("16"));
EXPECT_TRUE(params.has("8"));
EXPECT_TRUE(params.has("-64"));
EXPECT_TRUE(params.has("-32"));
EXPECT_TRUE(params.has("-16"));
EXPECT_TRUE(params.has("-8"));
EXPECT_TRUE(params.has("true"));
EXPECT_FALSE(params.has("false"));
EXPECT_FALSE(params.has(""));
EXPECT_TRUE(params.has("100.0"));
EXPECT_TRUE(params.has("1000.0"));
EXPECT_FALSE(params.has("10000.0"));
EXPECT_TRUE(params.has("string"));
EXPECT_EQ("1", params.get_as_string("true"));
EXPECT_EQ("-8", params.get_as_string("-8"));
EXPECT_EQ("-16", params.get_as_string("-16"));
EXPECT_EQ("-32", params.get_as_string("-32"));
EXPECT_EQ("-64", params.get_as_string("-64"));
EXPECT_EQ("8", params.get_as_string("8"));
EXPECT_EQ("16", params.get_as_string("16"));
EXPECT_EQ("32", params.get_as_string("32"));
EXPECT_EQ("64", params.get_as_string("64"));
EXPECT_EQ("100.000000", params.get_as_string("100.0"));
EXPECT_EQ("1000.000000", params.get_as_string("1000.0"));
EXPECT_EQ("", params.get_as_string("10000.0"));
EXPECT_EQ(64u, params.get_as_uint64("64"));
EXPECT_EQ(32u, params.get_as_uint64("32"));
EXPECT_EQ(16u, params.get_as_uint64("16"));
EXPECT_EQ(8u, params.get_as_uint64("8"));
EXPECT_EQ((uint64_t)(-64), params.get_as_uint64("-64"));
EXPECT_EQ((uint64_t)(-32), params.get_as_uint64("-32"));
EXPECT_EQ((uint64_t)(-16), params.get_as_uint64("-16"));
EXPECT_EQ((uint64_t)(-8), params.get_as_uint64("-8"));
EXPECT_EQ(1u, params.get_as_uint64("true"));
EXPECT_EQ(100u, params.get_as_uint64("100.0"));
EXPECT_EQ(1000u, params.get_as_uint64("1000.0"));
EXPECT_EQ(0u, params.get_as_uint64("10000.0"));
EXPECT_EQ(64u, params.get_as_uint32("64"));
EXPECT_EQ(32u, params.get_as_uint32("32"));
EXPECT_EQ(16u, params.get_as_uint32("16"));
EXPECT_EQ(8u, params.get_as_uint32("8"));
EXPECT_EQ(4294967232u, params.get_as_uint32("-64"));
EXPECT_EQ((uint32_t)(-32), params.get_as_uint32("-32"));
EXPECT_EQ((uint32_t)(-16), params.get_as_uint32("-16"));
EXPECT_EQ((uint32_t)(-8), params.get_as_uint32("-8"));
EXPECT_EQ(1u, params.get_as_uint32("true"));
EXPECT_EQ(100u, params.get_as_uint32("100.0"));
EXPECT_EQ(1000u, params.get_as_uint32("1000.0"));
EXPECT_EQ(0u, params.get_as_uint32("10000.0"));
EXPECT_EQ(64u, params.get_as_uint16("64"));
EXPECT_EQ(32u, params.get_as_uint16("32"));
EXPECT_EQ(16u, params.get_as_uint16("16"));
EXPECT_EQ(8u, params.get_as_uint16("8"));
EXPECT_EQ(65472u, params.get_as_uint16("-64"));
EXPECT_EQ(65504u, params.get_as_uint16("-32"));
EXPECT_EQ((uint16_t)(-16), params.get_as_uint16("-16"));
EXPECT_EQ((uint16_t)(-8), params.get_as_uint16("-8"));
EXPECT_EQ(1u, params.get_as_uint16("true"));
EXPECT_EQ(100u, params.get_as_uint16("100.0"));
EXPECT_EQ(1000u, params.get_as_uint16("1000.0"));
EXPECT_EQ(0u, params.get_as_uint16("10000.0"));
EXPECT_EQ(64u, params.get_as_uint8("64"));
EXPECT_EQ(32u, params.get_as_uint8("32"));
EXPECT_EQ(32u, params.get_as_uint8("32"));
EXPECT_EQ(8u, params.get_as_uint8("8"));
EXPECT_EQ(192u, params.get_as_uint8("-64"));
EXPECT_EQ(224u, params.get_as_uint8("-32"));
EXPECT_EQ(240u, params.get_as_uint8("-16"));
EXPECT_EQ((uint8_t)(-8), params.get_as_uint8("-8"));
EXPECT_EQ(1u, params.get_as_uint8("true"));
EXPECT_EQ(100u, params.get_as_uint8("100.0"));
EXPECT_EQ(232u, params.get_as_uint8("1000.0"));
EXPECT_EQ(0u, params.get_as_uint8("10000.0"));
EXPECT_TRUE(params.get_as_bool("64"));
EXPECT_TRUE(params.get_as_bool("32"));
EXPECT_TRUE(params.get_as_bool("16"));
EXPECT_TRUE(params.get_as_bool("8"));
EXPECT_TRUE(params.get_as_bool("-64"));
EXPECT_TRUE(params.get_as_bool("-32"));
EXPECT_TRUE(params.get_as_bool("-16"));
EXPECT_TRUE(params.get_as_bool("-8"));
EXPECT_TRUE(params.get_as_bool("true"));
EXPECT_FALSE(params.get_as_bool("false"));
EXPECT_FALSE(params.get_as_bool(""));
EXPECT_TRUE(params.get_as_bool("100.0"));
EXPECT_TRUE(params.get_as_bool("1000.0"));
EXPECT_FALSE(params.get_as_bool("10000.0"));
EXPECT_FALSE(params.get_as_bool("string"));
EXPECT_EQ(64, params.get_as_int64("64"));
EXPECT_EQ(32, params.get_as_int64("32"));
EXPECT_EQ(16, params.get_as_int64("16"));
EXPECT_EQ(8, params.get_as_int64("8"));
EXPECT_EQ(-64, params.get_as_int64("-64"));
EXPECT_EQ(-32, params.get_as_int64("-32"));
EXPECT_EQ(-16, params.get_as_int64("-16"));
EXPECT_EQ(-8, params.get_as_int64("-8"));
EXPECT_EQ(1, params.get_as_int64("true"));
EXPECT_EQ(100, params.get_as_int64("100.0"));
EXPECT_EQ(1000, params.get_as_int64("1000.0"));
EXPECT_EQ(0, params.get_as_int64("10000.0"));
EXPECT_EQ(64, params.get_as_int32("64"));
EXPECT_EQ(32, params.get_as_int32("32"));
EXPECT_EQ(16, params.get_as_int32("16"));
EXPECT_EQ(8, params.get_as_int32("8"));
EXPECT_EQ(-64, params.get_as_int32("-64"));
EXPECT_EQ(-32, params.get_as_int32("-32"));
EXPECT_EQ(-16, params.get_as_int32("-16"));
EXPECT_EQ(-8, params.get_as_int32("-8"));
EXPECT_EQ(1, params.get_as_int32("true"));
EXPECT_EQ(100, params.get_as_int32("100.0"));
EXPECT_EQ(1000, params.get_as_int32("1000.0"));
EXPECT_EQ(0, params.get_as_int32("10000.0"));
params1.merge(params);
EXPECT_EQ(64, params.get_as_int16("64"));
EXPECT_EQ(32, params.get_as_int16("32"));
EXPECT_EQ(16, params.get_as_int16("16"));
EXPECT_EQ(8, params.get_as_int16("8"));
EXPECT_EQ(-64, params.get_as_int16("-64"));
EXPECT_EQ(-32, params.get_as_int16("-32"));
EXPECT_EQ(-16, params.get_as_int16("-16"));
EXPECT_EQ(-8, params.get_as_int16("-8"));
EXPECT_EQ(1, params.get_as_int16("true"));
EXPECT_EQ(100, params.get_as_int16("100.0"));
EXPECT_EQ(1000, params.get_as_int16("1000.0"));
EXPECT_EQ(0, params.get_as_int16("10000.0"));
params1.merge(params);
EXPECT_EQ(64, params.get_as_int8("64"));
EXPECT_EQ(32, params.get_as_int8("32"));
EXPECT_EQ(16, params.get_as_int8("16"));
EXPECT_EQ(8, params.get_as_int8("8"));
EXPECT_EQ(-64, params.get_as_int8("-64"));
EXPECT_EQ(-32, params.get_as_int8("-32"));
EXPECT_EQ(-16, params.get_as_int8("-16"));
EXPECT_EQ(-8, params.get_as_int8("-8"));
EXPECT_EQ(1, params.get_as_int8("true"));
EXPECT_EQ(100, params.get_as_int8("100.0"));
EXPECT_EQ(-24, params.get_as_int8("1000.0"));
EXPECT_EQ(0, params.get_as_int8("10000.0"));
params1.merge(params);
params.erase("64");
params.erase("32");
params.erase("16");
params.erase("8");
params.erase("-64");
params.erase("-32");
params.erase("-16");
params.erase("-8");
params.erase("true");
params.erase("false");
params.erase("");
params.erase("100.0");
params.erase("1000.0");
params.erase("10000.0");
params.erase("string");
params1.merge(params);
params.clear();
}
TEST(Params, OverloadedOperator) {
Params params;
Params params1;
char test_string1[] = "test1";
params[test_string1] = test_string1;
const char *test_string2 = "test2";
params[test_string2] = test_string2;
params["11111"] = "11111";
params["22222"] = params1;
params["true"] = true;
params["-8"] = int8_t(-8);
params["-16"] = int16_t(-16);
params["-32"] = int32_t(-32);
params["-64"] = int64_t(-64);
params["8"] = uint8_t(8);
params["16"] = uint16_t(16);
params["32"] = uint32_t(32);
params["64"] = uint64_t(64);
params["100.0"] = float(100.0f);
params["1000.0"] = double(1000.0f);
params["size_t"] = size_t(1234);
params[std::string("string")] = std::string("string");
EXPECT_EQ(64u, params.get_as_uint64("64"));
EXPECT_EQ(32u, params.get_as_uint64("32"));
EXPECT_EQ(16u, params.get_as_uint64("16"));
EXPECT_EQ(8u, params.get_as_uint64("8"));
EXPECT_EQ((uint64_t)(-64), params.get_as_uint64("-64"));
EXPECT_EQ((uint64_t)(-32), params.get_as_uint64("-32"));
EXPECT_EQ((uint64_t)(-16), params.get_as_uint64("-16"));
EXPECT_EQ((uint64_t)(-8), params.get_as_uint64("-8"));
EXPECT_EQ(1u, params.get_as_uint64("true"));
EXPECT_EQ(100u, params.get_as_uint64("100.0"));
EXPECT_EQ(1000u, params.get_as_uint64("1000.0"));
EXPECT_EQ(0u, params.get_as_uint64("10000.0"));
EXPECT_EQ(1234u, params.get_as_uint64("size_t"));
EXPECT_EQ(1234u, params.get_as_uint32("size_t"));
std::cout << "float: " << typeid(float).name() << std::endl;
std::cout << "double: " << typeid(double).name() << std::endl;
std::cout << "long double: " << typeid(long double).name() << std::endl;
std::cout << "char: " << typeid(char).name() << std::endl;
std::cout << "signed char: " << typeid(signed char).name() << std::endl;
std::cout << "unsigned char: " << typeid(unsigned char).name() << std::endl;
std::cout << "short int: " << typeid(short int).name() << std::endl;
std::cout << "int: " << typeid(int).name() << std::endl;
std::cout << "long int: " << typeid(long int).name() << std::endl;
std::cout << "long long int: " << typeid(long long int).name() << std::endl;
std::cout << "unsigned short int: " << typeid(unsigned short int).name()
<< std::endl;
std::cout << "unsigned int: " << typeid(unsigned int).name() << std::endl;
std::cout << "unsigned long int: " << typeid(unsigned long int).name()
<< std::endl;
std::cout << "unsigned long long int: "
<< typeid(unsigned long long int).name() << std::endl;
size_t size;
EXPECT_TRUE(params.get("8", &size));
EXPECT_TRUE(params.get("16", &size));
EXPECT_TRUE(params.get("32", &size));
EXPECT_TRUE(params.get("64", &size));
EXPECT_TRUE(params.get("-8", &size));
EXPECT_TRUE(params.get("-16", &size));
EXPECT_TRUE(params.get("-32", &size));
EXPECT_TRUE(params.get("-64", &size));
EXPECT_TRUE(params.get("size_t", &size));
}
TEST(Params, GeneralString) {
Params params;
EXPECT_TRUE(params.empty());
params.set("11111", "11111");
params.set("22222", "22222");
params.set("yes", "yes");
params.set("no", "no");
params.set("No", "No");
params.set("Yes", "Yes");
params.set("true", "true");
params.set("True", "True");
params.set("False", "False");
params.set("false", "false");
params.set("string", "string");
EXPECT_TRUE(params.get_as_bool("yes"));
EXPECT_TRUE(params.get_as_bool("Yes"));
EXPECT_TRUE(params.get_as_bool("True"));
EXPECT_TRUE(params.get_as_bool("true"));
EXPECT_FALSE(params.get_as_bool("No"));
EXPECT_FALSE(params.get_as_bool("no"));
EXPECT_FALSE(params.get_as_bool("False"));
EXPECT_FALSE(params.get_as_bool("false"));
EXPECT_FALSE(params.get_as_bool("string"));
EXPECT_TRUE(params.get_as_bool("11111"));
EXPECT_EQ(103, params.get_as_int8("11111"));
EXPECT_EQ(11111, params.get_as_int16("11111"));
EXPECT_EQ(11111, params.get_as_int32("11111"));
EXPECT_EQ(11111, params.get_as_int64("11111"));
EXPECT_EQ(103u, params.get_as_uint8("11111"));
EXPECT_EQ(11111u, params.get_as_uint16("11111"));
EXPECT_EQ(11111u, params.get_as_uint32("11111"));
EXPECT_EQ(11111u, params.get_as_uint64("11111"));
EXPECT_FLOAT_EQ(11111.0, params.get_as_float("11111"));
EXPECT_FLOAT_EQ(11111.0, params.get_as_double("11111"));
EXPECT_TRUE(params.get_as_bool("22222"));
EXPECT_EQ(-50, params.get_as_int8("22222"));
EXPECT_EQ(22222, params.get_as_int16("22222"));
EXPECT_EQ(22222, params.get_as_int32("22222"));
EXPECT_EQ(22222, params.get_as_int64("22222"));
EXPECT_EQ(206u, params.get_as_uint8("22222"));
EXPECT_EQ(22222u, params.get_as_uint16("22222"));
EXPECT_EQ(22222u, params.get_as_uint32("22222"));
EXPECT_EQ(22222u, params.get_as_uint64("22222"));
EXPECT_FLOAT_EQ(22222.0, params.get_as_float("22222"));
EXPECT_FLOAT_EQ(22222.0, params.get_as_double("22222"));
}
TEST(Params, ParseFromEnvironment) {
Params params;
Params::ParseFromEnvironment(&params);
std::cout << params.get_as_string("PATH") << std::endl;
}
TEST(Params, ParseFromBuffer) {
std::string str =
"{ -1111: -1111.11, -2222: -2222, 1111: 1111, 2222: "
"\"2222\", 1: true, \'object\' : { } }";
Params params;
Params::ParseFromBuffer(str, &params);
ASSERT_FLOAT_EQ(-1111.11, params.get_as_float("-1111"));
ASSERT_EQ(-2222, params.get_as_int32("-2222"));
ASSERT_EQ(1111, params.get_as_int32("1111"));
ASSERT_EQ(true, params.get_as_bool("1"));
ASSERT_EQ(std::string("2222"), params.get_as_string("2222"));
ASSERT_TRUE(params.has("object"));
std::string str1 = "{proxima.general.cluster.count: 4000 }";
Params::ParseFromBuffer(str1, &params);
ASSERT_TRUE(params.has("proxima.general.cluster.count"));
uint32_t count = 0;
params.get("proxima.general.cluster.count", &count);
ASSERT_EQ(4000u, count);
}
TEST(Params, SerializeToBuffer) {
std::string str =
"{ -1111: -1111.11, -2222: -2222, 1111: 1111, 2222: "
"\"2222\", 1: true, \'object\' : "
"{ \"eeee\": false, \'null\':null } }";
Params params;
Params::ParseFromBuffer(str, &params);
params.set("unsupported_string_pointer", &str);
params.set("supported_string", str);
std::string str1 = params.debug_string();
printf("%s\n", str1.c_str());
Params params1;
EXPECT_TRUE(Params::ParseFromBuffer(str1, &params1));
EXPECT_EQ(str1, params1.debug_string());
}
Reference in New Issue View Git Blame Copy Permalink