void ProvidersTest::test_OutfitProviders()
{
Atlas::Message::Element value;
//Check if we get the right entity in outfit query
auto provider = CreateProvider( { "entity", "outfit", "hands" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.Ptr() == m_glovesEntity);
//Check for outfit's property query
provider = CreateProvider( { "entity", "outfit", "hands", "color" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.String() == "brown");
//Check if we get the right entity in nested outfit query
provider = CreateProvider(
{ "entity", "outfit", "hands", "outfit", "thumb" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.Ptr() == m_cloth);
//Check for nested outfit's property
provider = CreateProvider( { "entity", "outfit", "hands", "outfit", "thumb",
"color" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.String() == "green");
}
void ServerInfo::processServer(const RootEntity &svr)
{
Atlas::Message::Element element;
if (!svr->copyAttr("ruleset", element) && element.isString()) {
_ruleset = element.String();
} else {
return;
}
_name = svr->getName();
if (!svr->copyAttr("clients", element) && element.isInt()) {
_clients = (int)element.Int();
} else {
return;
}
if (!svr->copyAttr("server", element) && element.isString()) {
_server = element.String();
} else {
return;
}
if (!svr->copyAttr("uptime", element) && element.isFloat()) {
_uptime = element.Float();
} else {
return;
}
m_status = VALID;
if (!svr->copyAttr("entities", element) && element.isInt()) {
_entities = element.Int();
}
if (!svr->copyAttr("version", element) && element.isString()) {
m_version = element.String();
}
if (!svr->copyAttr("builddate", element) && element.isString()) {
m_buildDate = element.String();
}
if (!svr->copyAttr("assets", element) && element.isList()) {
for (auto& url : element.List()) {
if (url.isString()) {
m_assets.emplace_back(url.String());
}
}
}
}
void EntityProperty::set(const Atlas::Message::Element & val)
{
// INT id?
if (val.isString()) {
const std::string & id = val.String();
if (m_data.get() == 0 || m_data->getId() != id) {
debug(std::cout << "Assigning " << id << std::endl << std::flush;);
if (id.empty()) {
m_data = EntityRef(0);
} else {
LocatedEntity * e = BaseWorld::instance().getEntity(id);
if (e != 0) {
debug(std::cout << "Assigned" << std::endl << std::flush;);
m_data = EntityRef(e);
}
Py::Object CyPy_Element::wrap(Atlas::Message::Element value)
{
if (value.isNone()) {
return Py::None();
} else if (value.isString()) {
return Py::String(value.String());
} else if (value.isInt()) {
return Py::Long(value.Int());
} else if (value.isFloat()) {
return Py::Float(value.Float());
} else if (value.isList()) {
return CyPy_ElementList::wrap(value.List());
} else {
return CyPy_ElementMap::wrap(value.Map());
}
}
Py::Object CyPy_Element::asPyObject(const Atlas::Message::Element& obj, bool useNativePythonType)
{
switch (obj.getType()) {
case Element::TYPE_INT:
return Py::Long(obj.Int());
case Element::TYPE_FLOAT:
return Py::Float(obj.Float());
case Element::TYPE_STRING:
return Py::String(obj.String());
case Element::TYPE_MAP:
return mapAsPyObject(obj.Map(), useNativePythonType);
case Element::TYPE_LIST:
return listAsPyObject(obj.List(), useNativePythonType);
default:
break;
}
return Py::None();
}
void Property<std::string>::set(const Atlas::Message::Element & e)
{
if (e.isString()) {
this->m_data = e.String();
}
}
void EmberEntity::onImaginary(const Atlas::Objects::Root& act)
{
Atlas::Message::Element attr;
if (act->copyAttr("description", attr) && attr.isString()) {
std::string message = getName() + " " + attr.asString() + ".";
ConsoleBackend::getSingletonPtr()->pushMessage(message, "info");
S_LOG_VERBOSE("Entity: " << this->getId() << " (" << this->getName() << ") imaginary: " << attr.String());
}
Entity::onImaginary(act);
}
int main(int argc, char ** argv)
{
loadConfig(argc, argv);
database_flag = false;
init_python_api();
int ret;
{
World e("1", 1);
TestWorld test_world(e);
Anonymous attributes;
EntityBuilder::init(test_world);
Ruleset::init();
assert(Ruleset::instance() != 0);
assert(EntityBuilder::instance() != 0);
assert(EntityBuilder::instance()->newEntity("1", 1, "world", attributes) == 0);
assert(EntityBuilder::instance()->newEntity("1", 1, "nonexistant", attributes) == 0);
assert(EntityBuilder::instance()->newEntity("1", 1, "thing", attributes) != 0);
Ruleset::del();
assert(Ruleset::instance() == 0);
EntityBuilder::del();
assert(EntityBuilder::instance() == 0);
Inheritance::clear();
}
{
World e("1", 1);
TestWorld test_world(e);
Anonymous attributes;
Atlas::Message::Element val;
EntityBuilder::init(test_world);
Ruleset::init();
assert(Ruleset::instance() != 0);
Entity * test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
assert(!test_ent->getAttr("funky", val));
assert(val.isNone());
attributes->setAttr("funky", "true");
test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
Ruleset::del();
assert(Ruleset::instance() == 0);
EntityBuilder::del();
assert(EntityBuilder::instance() == 0);
Inheritance::clear();
}
{
// Create a test world.
World e("1", 1);
TestWorld test_world(e);
Atlas::Message::Element val;
// Instance of EntityBuilder with all protected methods exposed
// for testing
ExposedEntityBuilder * entity_factory = new ExposedEntityBuilder(test_world);
// Instance of Ruleset with all protected methods exposed
// for testing
EntityBuilder * test_eb = EntityBuilder::instance();
assert(test_eb == entity_factory);
ExposedRuleset test_ruleset(test_eb);
// Attributes for test entities being created
Anonymous attributes;
// Create an entity which is an instance of one of the core classes
Entity * test_ent = test_eb->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
// Check the created entity does not have the attribute values we
// will be testing later
assert(!test_ent->getAttr("funky", val));
assert(val.isNone());
// Set a test attribute
attributes->setAttr("funky", "true");
// Create another entity, and check that it has picked up the new
// attribute value
test_ent = test_eb->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Check that creating an entity of a type we know we have not yet
// installed results in a null pointer.
assert(test_eb->newEntity("1", 1, "custom_type", attributes) == 0);
// Set up a type description for a new type, and install it.
{
Root custom_type_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "test_value";
test_custom_type_attr["visibility"] = "public";
attrs["test_custom_type_attr"] = test_custom_type_attr;
custom_type_description->setAttr("attributes", attrs);
custom_type_description->setId("custom_type");
custom_type_description->setParents(std::list<std::string>(1, "thing"));
std::string dependent, reason;
ret = test_ruleset.installEntityClass("custom_type", "thing", custom_type_description, dependent, reason);
assert(ret == 0);
assert(dependent.empty());
assert(reason.empty());
}
// Check that the factory dictionary now contains a factory for
// the custom type we just installed.
EntityKit * custom_type_factory = test_eb->getClassFactory("custom_type");
assert(custom_type_factory != 0);
// Check the factory has the attributes we described on the custom
// type.
MapType::const_iterator J = custom_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
// Create an instance of our custom type, ensuring that it works.
test_ent = test_eb->newEntity("1", 1, "custom_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
// Check that creating an entity of a type we know we have not yet
// installed results in a null pointer.
assert(test_eb->newEntity("1", 1, "custom_inherited_type", attributes) == 0);
// Set up a type description for a second new type which inherits
// from the first, and install it.
{
Root custom_inherited_type_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "test_inherited_value";
test_custom_type_attr["visibility"] = "public";
attrs["test_custom_inherited_type_attr"] = test_custom_type_attr;
custom_inherited_type_description->setAttr("attributes", attrs);
custom_inherited_type_description->setId("custom_inherited_type");
custom_inherited_type_description->setParents(std::list<std::string>(1, "custom_type"));
std::string dependent, reason;
ret = test_ruleset.installEntityClass("custom_inherited_type", "custom_type", custom_inherited_type_description, dependent, reason);
assert(ret == 0);
assert(dependent.empty());
assert(reason.empty());
}
// Check that the factory dictionary does contain the factory for
// the second newly installed type
EntityKit * custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory has inherited the attributes from the
// first custom type
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
// Check that the factory has the attributes specified when installing
// it
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_inherited_value");
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// second custom type was installed
assert(test_ent->getAttr("test_custom_inherited_type_attr", val));
assert(val.isString());
assert(val.String() == "test_inherited_value");
// FIXME TODO Modify a type, and ensure attribute propagate to inherited types.
// Make sure than attempting to modify a non-existant type fails
{
Anonymous nonexistant_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "no_value";
test_custom_type_attr["visibility"] = "public";
attrs["no_custom_type_attr"] = test_custom_type_attr;
nonexistant_description->setId("nonexistant");
nonexistant_description->setAttr("attributes", attrs);
ret = test_ruleset.modifyRule("nonexistant", nonexistant_description);
assert(ret != 0);
}
// Modify the second custom type removing its custom attribute
{
Anonymous new_custom_inherited_type_description;
new_custom_inherited_type_description->setId("custom_inherited_type");
new_custom_inherited_type_description->setAttr("attributes", MapType());
// No parents
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret != 0);
// empty parents
new_custom_inherited_type_description->setParents(std::list<std::string>());
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret != 0);
// wrong parents
new_custom_inherited_type_description->setParents(std::list<std::string>(1, "wrong_parent"));
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret != 0);
new_custom_inherited_type_description->setParents(std::list<std::string>(1, "custom_type"));
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret == 0);
}
// Check that the factory dictionary does contain the factory for
// the second newly installed type
custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory has inherited the attributes from the
// first custom type
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
// Check that the factory no longer has the attributes we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Make sure test nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant", val));
// Make sure nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant_attribute", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// second custom type was installed
assert(!test_ent->getAttr("test_custom_inherited_type_attr", val));
// Modify the first custom type removing its custom attribute
{
Anonymous new_custom_type_description;
new_custom_type_description->setId("custom_type");
new_custom_type_description->setAttr("attributes", MapType());
new_custom_type_description->setParents(std::list<std::string>(1, "thing"));
ret = test_ruleset.modifyRule("custom_type", new_custom_type_description);
assert(ret == 0);
}
// Check that the factory dictionary now contains a factory for
// the custom type we just installed.
custom_type_factory = test_eb->getClassFactory("custom_type");
assert(custom_type_factory != 0);
// Check the factory has the attributes we described on the custom
// type.
J = custom_type_factory->m_attributes.find("test_custom_type_attr");
assert(J == custom_type_factory->m_attributes.end());
// Create an instance of our custom type, ensuring that it works.
test_ent = test_eb->newEntity("1", 1, "custom_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type no longer has the custom attribute
assert(!test_ent->getAttr("test_custom_type_attr", val));
// Check that the factory dictionary does contain the factory for
// the second newly installed type
custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory no longer has inherited the attributes
// from the first custom type which we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Check that the factory no longer has the attributes we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Make sure test nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant", val));
// Make sure nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant_attribute", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(!test_ent->getAttr("test_custom_type_attr", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// second custom type was installed
assert(!test_ent->getAttr("test_custom_inherited_type_attr", val));
// Add more custom attributes to the first type
{
Anonymous new_custom_type_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "test_value";
test_custom_type_attr["visibility"] = "public";
attrs["test_custom_type_attr"] = test_custom_type_attr;
MapType new_custom_type_attr;
new_custom_type_attr["default"] = "new_value";
new_custom_type_attr["visibility"] = "public";
attrs["new_custom_type_attr"] = new_custom_type_attr;
new_custom_type_description->setId("custom_type");
new_custom_type_description->setAttr("attributes", attrs);
new_custom_type_description->setParents(std::list<std::string>(1, "thing"));
ret = test_ruleset.modifyRule("custom_type", new_custom_type_description);
assert(ret == 0);
}
// Check that the factory dictionary now contains a factory for
// the custom type we just installed.
custom_type_factory = test_eb->getClassFactory("custom_type");
// Check the factory has the attributes we described on the custom
// type.
J = custom_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
J = custom_type_factory->m_attributes.find("new_custom_type_attr");
assert(J != custom_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "new_value");
// Create an instance of our custom type, ensuring that it works.
test_ent = test_eb->newEntity("1", 1, "custom_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type now has the custom attributes
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
assert(test_ent->getAttr("new_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "new_value");
// Check that the factory dictionary does contain the factory for
// the second newly installed type
custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory now has inherited the attributes
// from the first custom type
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
J = custom_inherited_type_factory->m_attributes.find("new_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "new_value");
// Check that the factory no longer has the attributes we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Make sure test nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant", val));
// Make sure nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant_attribute", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
assert(test_ent->getAttr("new_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "new_value");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type no longer has the attribute described when the
// second custom type was installed
assert(!test_ent->getAttr("test_custom_inherited_type_attr", val));
}
}