TEST(TestVariant, VariantTypeNull)
{
CVariant a;
EXPECT_TRUE(a.isNull());
EXPECT_EQ(CVariant::VariantTypeNull, a.type());
}
bool CSmartPlaylist::Save(CVariant &obj, bool full /* = true */) const
{
if (obj.type() == CVariant::VariantTypeConstNull)
return false;
obj.clear();
// add "type", "name" and "match"
obj["type"] = m_playlistType;
obj["match"] = m_matchAllRules ? "all" : "one";
if (full)
obj["name"] = m_playlistName;
// add "rules"
obj["rules"] = CVariant(CVariant::VariantTypeArray);
for (vector<CSmartPlaylistRule>::const_iterator it = m_playlistRules.begin(); it != m_playlistRules.end(); ++it)
it->Save(obj["rules"]);
// add "limit"
if (full && m_limit)
obj["limit"] = m_limit;
// add "order"
if (full && m_orderField != SortByNone)
{
obj["order"] = CVariant(CVariant::VariantTypeObject);
obj["order"]["method"] = CSmartPlaylistRule::TranslateOrder(m_orderField);
obj["order"]["direction"] = m_orderAscending ? "ascending" : "descending";
}
return true;
}
TEST(TestVariant, VariantTypeObject)
{
CVariant a;
a["key"] = "value";
EXPECT_TRUE(a.isObject());
EXPECT_EQ(CVariant::VariantTypeObject, a.type());
}
bool CJSONVariantWriter::InternalWrite(yajl_gen g, const CVariant &value)
{
bool success = false;
switch (value.type())
{
case CVariant::VariantTypeInteger:
success = yajl_gen_status_ok == yajl_gen_integer(g, (long long int)value.asInteger());
break;
case CVariant::VariantTypeUnsignedInteger:
success = yajl_gen_status_ok == yajl_gen_integer(g, (long long int)value.asUnsignedInteger());
break;
case CVariant::VariantTypeDouble:
success = yajl_gen_status_ok == yajl_gen_double(g, value.asDouble());
break;
case CVariant::VariantTypeBoolean:
success = yajl_gen_status_ok == yajl_gen_bool(g, value.asBoolean() ? 1 : 0);
break;
case CVariant::VariantTypeString:
success = yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)value.c_str(), (size_t)value.size());
break;
case CVariant::VariantTypeArray:
success = yajl_gen_status_ok == yajl_gen_array_open(g);
for (CVariant::const_iterator_array itr = value.begin_array(); itr != value.end_array() && success; ++itr)
success &= InternalWrite(g, *itr);
if (success)
success = yajl_gen_status_ok == yajl_gen_array_close(g);
break;
case CVariant::VariantTypeObject:
success = yajl_gen_status_ok == yajl_gen_map_open(g);
for (CVariant::const_iterator_map itr = value.begin_map(); itr != value.end_map() && success; ++itr)
{
success &= yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)itr->first.c_str(), (size_t)itr->first.length());
if (success)
success &= InternalWrite(g, itr->second);
}
if (success)
success &= yajl_gen_status_ok == yajl_gen_map_close(g);
break;
case CVariant::VariantTypeConstNull:
case CVariant::VariantTypeNull:
default:
success = yajl_gen_status_ok == yajl_gen_null(g);
break;
}
return success;
}
TEST(TestVariant, VariantFromMap)
{
std::map<std::string, std::string> strMap;
strMap["key"] = "value";
CVariant a = strMap;
EXPECT_TRUE(a.isObject());
EXPECT_TRUE(a.size() == 1);
EXPECT_EQ(CVariant::VariantTypeObject, a.type());
EXPECT_TRUE(a.isMember("key"));
EXPECT_TRUE(a["key"].isString());
EXPECT_STREQ(a["key"].asString().c_str(), "value");
std::map<std::string, CVariant> variantMap;
variantMap["key"] = CVariant("value");
CVariant b = variantMap;
EXPECT_TRUE(b.isObject());
EXPECT_TRUE(b.size() == 1);
EXPECT_EQ(CVariant::VariantTypeObject, b.type());
EXPECT_TRUE(b.isMember("key"));
EXPECT_TRUE(b["key"].isString());
EXPECT_STREQ(b["key"].asString().c_str(), "value");
}
bool CFileUtil::writeVariant(IFileObject* file, const CVariant& value)
{
EVariantType type = value.type();
if ( !file->write(&type, sizeof(uint8)) ) return false;
switch(type)
{
case VT_NONE:
break;
case VT_BOOLEAN:
{
bool writebool;
if ( !value.get(writebool) || !file->write(&writebool, sizeof(bool)) ) return false;
}
break;
case VT_UINT:
{
uint64 writeuint;
if ( !value.get(writeuint) || !file->write(&writeuint, sizeof(uint64)) ) return false;
}
break;
case VT_INT:
{
int64 writeint;
if ( !value.get(writeint) || !file->write(&writeint, sizeof(int64)) ) return false;
}
break;
case VT_DOUBLE:
{
double writedouble;
if ( !value.get(writedouble) || !file->write(&writedouble, sizeof(double)) ) return false;
}
break;
case VT_STRING:
{
CString writestr;
if ( !value.get(writestr) || !CFileUtil::writeString(file, writestr) ) return false;
}
break;
default:
return false;
}
return true;
}
TEST(TestVariant, iterator_map)
{
CVariant a;
a["key1"] = "string";
a["key2"] = "string";
a["key3"] = "string";
a["key4"] = "string";
EXPECT_TRUE(a.isObject());
EXPECT_EQ(CVariant::VariantTypeObject, a.type());
CVariant::iterator_map it;
for (it = a.begin_map(); it != a.end_map(); it++)
{
EXPECT_STREQ("string", it->second.c_str());
}
CVariant::const_iterator_map const_it;
for (const_it = a.begin_map(); const_it != a.end_map(); const_it++)
{
EXPECT_STREQ("string", const_it->second.c_str());
}
}
