301 lines
7.3 KiB
C++
301 lines
7.3 KiB
C++
// #include <list>
|
|
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
|
|
#include <doctest/doctest.h>
|
|
// #include <chrono>
|
|
#include <iostream>
|
|
|
|
// #include "../common/adc_utils.h"
|
|
|
|
|
|
// #include "../common/adc_value_holder.h"
|
|
// #include "../common/adc_value.h"
|
|
#include "../common/adc_valholder.h"
|
|
|
|
|
|
static double dbl_val = 99.99;
|
|
|
|
double gdbl()
|
|
{
|
|
return dbl_val;
|
|
}
|
|
|
|
|
|
void sdbl(const double& v)
|
|
{
|
|
dbl_val = v;
|
|
}
|
|
|
|
|
|
bool vdbl(const double& v)
|
|
{
|
|
if (v < 1.0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
TEST_CASE("[ADC VALUEHOLDER]")
|
|
{
|
|
int int_val = 10;
|
|
|
|
auto getter = [&int_val]() { return int_val; };
|
|
auto setter = [&int_val](const int& v) { int_val = v; };
|
|
|
|
|
|
adc::AdcValueHolder vh(getter, setter);
|
|
auto vah = adc::makeArithmValue<adc::AdcValueHolder>(getter, setter);
|
|
|
|
vh = 77;
|
|
|
|
REQUIRE_EQ(int_val, 77);
|
|
|
|
vh = 100;
|
|
|
|
int res = vh;
|
|
|
|
REQUIRE_EQ(res, 100);
|
|
|
|
CHECK_THROWS_WITH_AS(vh = 1.1, "conversion function is not defined", std::system_error);
|
|
|
|
std::cout << "int_val = " << int_val << "\n";
|
|
|
|
const double dv = 33.33;
|
|
vah = dv;
|
|
|
|
REQUIRE_EQ(int_val, 33);
|
|
|
|
vah = 100;
|
|
auto res_long = static_cast<unsigned long>(vah);
|
|
|
|
REQUIRE_EQ(res_long, 100ul);
|
|
|
|
vah = -10.1234;
|
|
REQUIRE_EQ(int_val, -10);
|
|
|
|
|
|
|
|
std::string str = "THIS IS A STRING";
|
|
|
|
auto sget = [&str]() { return str; };
|
|
auto sset = [&str](const std::string& s) { str = s; };
|
|
|
|
|
|
adc::AdcValueHolder vsh(sget, sset);
|
|
|
|
auto lls = [](const char* v) { return std::string(v); };
|
|
vsh.addConvertFunc([&str](const std::string&) { return str.c_str(); }, lls);
|
|
|
|
vsh = "NEW VALUE";
|
|
|
|
REQUIRE_EQ(str, "NEW VALUE");
|
|
|
|
const char* sptr = vsh;
|
|
|
|
std::cout << "SPTR: " << sptr << "\n";
|
|
|
|
REQUIRE_EQ(std::strcmp(sptr, "NEW VALUE"), 0);
|
|
|
|
// vah = vsh;
|
|
|
|
|
|
// vah = 10;
|
|
|
|
|
|
// adc::AdcSerializingValueHolder svh(adc::AdcValueHolder::defaultTrivialConvTypes, getter, setter);
|
|
auto svh = adc::makeArithmValue<adc::AdcSerializingValueHolder>(getter, setter);
|
|
|
|
svh = 77.65412;
|
|
|
|
std::cout << "SERIALIZED: " << svh.serialize<std::string>() << "\n";
|
|
|
|
std::string sval = "123";
|
|
svh.deserialize(sval);
|
|
float fl = svh;
|
|
std::cout << "DESERIALIZED: " << fl << "\n";
|
|
|
|
|
|
// adc::AdcSerializingValueHolder svhs(
|
|
// sget, sset, [](const std::string& s) { return s; }, [](const std::string& s) { return s; });
|
|
|
|
// svh = svhs;
|
|
|
|
// svh = 10;
|
|
}
|
|
|
|
/*
|
|
|
|
TEST_CASE("[ADC VALUEHOLDER]")
|
|
{
|
|
int int_val = 10;
|
|
|
|
auto getter = [&int_val]() { return int_val; };
|
|
auto setter = [&int_val](const int& v) { int_val = v; };
|
|
auto validator = [](const int& v) {
|
|
if (v < 0)
|
|
return false;
|
|
else
|
|
return true;
|
|
};
|
|
|
|
// adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
|
|
adc::AdcValueHolder vht(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter);
|
|
adc::AdcValueHolder vh(getter, setter, validator);
|
|
// auto vah = adc::make_arith_valueholder(getter, setter);
|
|
auto vah = adc::makeArithmValue<adc::AdcValueHolder>(getter, setter);
|
|
|
|
vh = 77;
|
|
|
|
REQUIRE_EQ(int_val, 77);
|
|
|
|
vh = 100;
|
|
|
|
int res = vh;
|
|
|
|
REQUIRE_EQ(res, 100);
|
|
|
|
CHECK_THROWS_WITH_AS(vh = 1.1, "conversion function is not defined", std::system_error);
|
|
CHECK_THROWS_WITH_AS(vh = -3, "user value is not valid", std::system_error);
|
|
|
|
std::cout << "int_val = " << int_val << "\n";
|
|
|
|
const double dv = 33.33;
|
|
vah = dv;
|
|
|
|
REQUIRE_EQ(int_val, 33);
|
|
|
|
vah = 100;
|
|
auto res_long = static_cast<unsigned long>(vah);
|
|
|
|
REQUIRE_EQ(res_long, 100ul);
|
|
|
|
vah = -10.1234;
|
|
REQUIRE_EQ(int_val, -10);
|
|
|
|
|
|
|
|
std::string str = "THIS IS A STRING";
|
|
|
|
auto sget = [&str]() { return str; };
|
|
auto sset = [&str](const std::string& s) { str = s; };
|
|
auto sval = [](const std::string& s) {
|
|
if (s.size())
|
|
return true;
|
|
else
|
|
return false;
|
|
};
|
|
|
|
|
|
adc::AdcValueHolder vsh(sget, sset, sval);
|
|
|
|
// vsh.addConvertFunc<const char*>([](std::any& v) { v = std::string(std::any_cast<const char*>(v)); },
|
|
// [](std::any& v) {
|
|
// auto sval = std::any_cast<std::string>(&v);
|
|
// v = sval->c_str();
|
|
// });
|
|
|
|
auto lls = [](const char* v) { return std::string(v); };
|
|
vsh.addConvertFunc([&str](const std::string&) { return str.c_str(); }, lls);
|
|
|
|
vsh = "NEW VALUE";
|
|
|
|
REQUIRE_EQ(str, "NEW VALUE");
|
|
|
|
const char* sptr = vsh;
|
|
|
|
std::cout << "SPTR: " << sptr << "\n";
|
|
|
|
REQUIRE_EQ(std::strcmp(sptr, "NEW VALUE"), 0);
|
|
|
|
using namespace std::literals;
|
|
|
|
CHECK_THROWS_WITH_AS(vsh = ""s, "user value is not valid", std::system_error);
|
|
|
|
std::string ss = "\t\t1, 2, 3, 4,5 ";
|
|
|
|
std::vector<int> vv;
|
|
adc::utils::AdcValueRangeFromCharRange(vv, ss, ",");
|
|
|
|
for (auto v : vv) {
|
|
std::cout << "v = " << v << "\n";
|
|
}
|
|
|
|
std::list<char> ll;
|
|
adc::utils::AdcCharRangeFromValueRange(ll, vv, "<>");
|
|
for (auto ch : ll) {
|
|
std::cout << ch;
|
|
}
|
|
std::cout << "\n";
|
|
|
|
ss.clear();
|
|
adc::utils::AdcCharRangeFromValueRange(ss, vv, "<>");
|
|
std::cout << "STR: [" << ss << "]\n";
|
|
|
|
|
|
std::tuple<int, float> tp{7, 77.77};
|
|
ss = "3, 33.33";
|
|
adc::utils::AdcTupleFromCharRange(tp, ss, ",");
|
|
|
|
std::cout << "TP: {" << std::get<0>(tp) << ", " << std::get<1>(tp) << "}\n";
|
|
|
|
std::get<1>(tp) = 77.77;
|
|
|
|
ll.clear();
|
|
adc::utils::AdcCharRangeFromTuple(ll, tp, "::");
|
|
|
|
for (auto ch : ll) {
|
|
std::cout << ch;
|
|
}
|
|
std::cout << "\n";
|
|
|
|
|
|
ss = ";\t";
|
|
// adc::utils::AdcDefaultSerializer sr{"; "};
|
|
adc::utils::AdcDefaultSerializer sr{ss};
|
|
std::cout << "SR: " << sr(std::list<float>{11.11, 22.22, 33.33}) << "\n";
|
|
ss = ",\t";
|
|
std::cout << "SR: " << sr.setDelimiter(" , ")(std::vector<float>{11.11, 22.22, 33.33}) << "\n";
|
|
|
|
|
|
int zz;
|
|
auto t1 = std::chrono::system_clock::now();
|
|
for (int i = 10; i < 1000000; ++i) {
|
|
vah = i;
|
|
zz = (int)vah + 10;
|
|
}
|
|
auto t2 = std::chrono::system_clock::now();
|
|
std::cout << "ZZ = " << zz << "\n";
|
|
|
|
std::cout << "ELAPS: " << std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count() << " mksec\n";
|
|
|
|
|
|
|
|
// adc::AdcSerializingValueHolder svh(getter, setter, validator, adc::AdcValueHolder::_defaultTrivialConvTypes);
|
|
adc::AdcSerializingValueHolder svh(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter, validator);
|
|
|
|
svh = 77.65412;
|
|
|
|
std::cout << "SERIALIZED: " << svh.serialize() << "\n";
|
|
|
|
svh.deserialize("123");
|
|
float fl = svh;
|
|
std::cout << "DESERIALIZED: " << fl << "\n";
|
|
|
|
// vsh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
|
|
|
|
// fl = vsh;
|
|
// std::cout << "VSH: " << fl << "\n";
|
|
|
|
// svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
|
|
svh.resetValueHolder(adc::AdcValueHolder::_defaultTrivialConvTypes, gdbl, sdbl, vdbl);
|
|
// svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
|
|
// [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
|
|
std::cout << "SERIALIZED: " << svh.serialize() << "\n";
|
|
svh.deserialize("123.123");
|
|
res = svh;
|
|
std::cout << "DESERIALIZED: " << res << "\n";
|
|
}
|
|
|
|
*/
|