TEST(Value, InvalidReference)
{
AnyValue v;
auto r = v.asReference();
EXPECT_FALSE(r.isValid());
EXPECT_EQ(AnyReference{}, r);
}
State(AnyValue inArg)
: mStorage(inArg.copyIfImmutable()),
widthOfX(&mStorage[0]),
coef(TransparentHandle::create(&mStorage[1]),
widthOfX),
numRows(&mStorage[1 + widthOfX]),
X_transp_Az(TransparentHandle::create(&mStorage[2 + widthOfX]),
widthOfX),
X_transp_AX(TransparentHandle::create(&mStorage[2 + 2 * widthOfX]),
widthOfX, widthOfX),
logLikelihood(&mStorage[2 + widthOfX * widthOfX + 2 * widthOfX])
{ }
QVariant Run::valueStackTopItem() const
{
VMMutex_->lock();
AnyValue value;
value = vm->returnCode();
VMMutex_->unlock();
QVariant result;
if (value.isValid()) {
if (value.type() == VT_int) {
result = QVariant(value.toInt());
}
else if (value.type() == VT_real) {
result = QVariant(value.toReal());
}
else if (value.type() == VT_bool) {
result = QVariant(value.toBool());
}
else if (value.type() == VT_char) {
result = QVariant(QChar(value.toChar()));
}
else if (value.type() == VT_string) {
result = QVariant(QString::fromStdWString(value.toString()));
}
}
return result;
}
TEST(Value, DefaultMap)
{ // this one has tricky code and deserves a test)
TypeInterface* dmt = TypeInterface::fromSignature(qi::Signature("{si}"));
AnyValue val = AnyValue(AnyReference(dmt), false, true);
ASSERT_EQ(0u, val.size());
val["foo"].update(12);
ASSERT_EQ(1u, val.size());
ASSERT_EQ(12, val.find("foo").toInt());
ASSERT_EQ(0, val.find("bar").type());
val.insert(std::string("bar"), 13);
ASSERT_EQ(13, val.element<int>("bar"));
val.element<int>("foo") = 10;
ASSERT_EQ(10, val.find("foo").toInt());
AnyIterator b = val.begin();
AnyIterator end = val.end();
qi::int64_t sum = 0;
while (b != end)
{
AnyReference deref = *b;
sum += deref[1].toInt();
++b;
}
ASSERT_EQ(23, sum);
AnyIterator b2 = val.begin();
AnyIterator end2 = val.end();
sum = 0;
while (b2 != end2)
{
AnyReference deref = *b2;
AnyIterator it = b2;
sum += deref[1].toInt();
ASSERT_EQ(b2++, it);
}
ASSERT_EQ(23, sum);
AnyReference valCopy = val.clone();
ASSERT_EQ(13, valCopy.element<int>("bar"));
ASSERT_EQ(2u, valCopy.size());
// reset val, checks valCopy still works
val.reset();
val = AnyValue::from(5);
ASSERT_EQ(13, valCopy.element<int>("bar"));
ASSERT_EQ(2u, valCopy.size());
valCopy.destroy();
}
TEST(Value, InvalidValue)
{
AnyValue v;
EXPECT_FALSE(v.isValid());
EXPECT_EQ(AnyValue{}, v);
}
Json::Value JsonSerializer::toValue(AnyValue val) const
{
auto info = val.type_info();
if (val.isType<bool>())
{
bool v = val.as<bool>();
return Json::Value(v);
}
else if (info.isIntegral())
{
if (info.isUnsigned())
{
uint64_t v = val.as<uint64_t>();
return Json::Value((Json::Value::UInt64)v);
}
else {
int64_t v = val.as<int64_t>();
return Json::Value((Json::Value::Int64)v);
}
}
else if (info.isFloatingPoint())
{
double v = val.as<double>();
return Json::Value(v);
}
else if (val.isType<std::vector<AnyValue>>())
{
Json::Value res = Json::arrayValue;
std::vector<AnyValue> v = val.as < std::vector<AnyValue>>();
for (AnyValue any : v)
res.append(this->toValue(any));
return res;
}
else if (val.isType<Bundle>())
{
Json::Value res = Json::objectValue;
Bundle b = val.as<Bundle>();
for (const auto& val : b)
{
res[val.first] = this->toValue(val.second);
}
return res;
}
else if (val.isType<std::nullptr_t>())
{
return Json::nullValue;
}
else if (val.isSerializable())
{
return this->toValue(val.serialize());
}
else if (val.isConvertibleTo<std::string>())
{
std::string v = val.as<std::string>();
return Json::Value(v);
}
else
{
throw std::logic_error("Type is not convertible.");
}
}
