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."); } }