void Tasktest::test_sequence()
{
m_task->nextTick(1.5);
Atlas::Message::Element val;
m_task->getAttr("foo", val);
assert(val.isNone());
m_task->setAttr("foo", 1);
m_task->getAttr("foo", val);
assert(val.isInt());
assert(!m_task->obsolete());
OpVector res;
assert(res.empty());
Atlas::Objects::Operation::Generic c;
c->setParents(std::list<std::string>(1, "generic"));
m_task->initTask(c, res);
Operation op;
m_task->operation(op, res);
m_task->irrelevant();
assert(m_task->obsolete());
}
int main()
{
int ret = 0;
Operation op;
{
Task * task;
OpVector res;
if (0) {
task->TickOperation(op, res);
}
}
Entity ent1("1", 1), ent2("2", 2);
Character chr("3", 3);
{
Fell fell(chr, ent1, ent2);
fell.nextTick(1.5);
Atlas::Message::Element val;
fell.getAttr("foo", val);
assert(val.isNone());
fell.setAttr("foo", 1);
fell.getAttr("foo", val);
assert(val.isInt());
assert(!fell.obsolete());
OpVector res;
assert(res.empty());
Atlas::Objects::Operation::Generic c;
fell.initTask(c, res);
assert(!res.empty());
fell.TickOperation(op, res);
fell.irrelevant();
assert(fell.obsolete());
}
return ret;
}
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());
}
}
void EntityImporterBase::start(const std::string& filename)
{
S_LOG_VERBOSE("Starting import from " << filename);
auto factories = Atlas::Objects::Factories::instance();
auto rootObj = loadFromFile(filename);
if (!rootObj.isValid()) {
EventCompleted.emit();
return;
}
Atlas::Message::Element metaElem;
Atlas::Message::Element entitiesElem;
Atlas::Message::Element mindsElem;
Atlas::Message::Element rulesElem;
rootObj->copyAttr("meta", metaElem);
rootObj->copyAttr("entities", entitiesElem);
rootObj->copyAttr("minds", mindsElem);
if (rootObj->copyAttr("rules", rulesElem) == 0) {
if (!rulesElem.isList()) {
S_LOG_WARNING("Rules element is not list.");
EventCompleted.emit();
return;
} else {
for (auto& ruleMessage : rulesElem.asList()) {
if (ruleMessage.isMap()) {
auto object = factories->createObject(ruleMessage.asMap());
if (object.isValid()) {
if (!object->isDefaultId()) {
mPersistedRules.insert(std::make_pair(object->getId(), object));
}
}
}
}
}
}
if (!entitiesElem.isNone() && !entitiesElem.isList()) {
S_LOG_WARNING("Entities element is not list.");
EventCompleted.emit();
return;
}
if (!mindsElem.isNone() && !mindsElem.isList()) {
S_LOG_WARNING("Minds element is not list.");
EventCompleted.emit();
return;
}
if (!entitiesElem.isNone()) {
for (auto& entityMessage : entitiesElem.asList()) {
if (entityMessage.isMap()) {
auto& entityMap = entityMessage.asMap();
auto object = factories->createObject(entityMap);
if (object.isValid()) {
if (!object->isDefaultId()) {
registerEntityReferences(object->getId(), entityMap);
mPersistedEntities.insert(std::make_pair(object->getId(), object));
}
}
}
}
}
//If we should resume the world, check if the world has a "suspended" property,
//and disable it if so.
if (mResumeWorld) {
auto I = mPersistedEntities.find("0");
if (I != mPersistedEntities.end()) {
if (I->second->hasAttr("suspended")) {
I->second->setAttr("suspended", 0);
S_LOG_INFO("Resuming suspended world.");
}
}
}
if (!mindsElem.isNone()) {
for (auto& mindMessage : mindsElem.asList()) {
if (mindMessage.isMap()) {
auto object = factories->createObject(mindMessage.asMap());
if (object.isValid()) {
if (!object->isDefaultId()) {
mPersistedMinds.insert(std::make_pair(object->getId(), object));
}
}
}
}
}
S_LOG_INFO("Starting loading of world. Number of entities: " << mPersistedEntities.size() << " Number of minds: " << mPersistedMinds.size() << " Number of rules: " << mPersistedRules.size());
mStats.entitiesCount = static_cast<unsigned int>(mPersistedEntities.size());
mStats.mindsCount = static_cast<unsigned int>(mPersistedMinds.size());
mStats.rulesCount = static_cast<unsigned int>(mPersistedRules.size());
EventProgress.emit();
if (mPersistedRules.empty()) {
startEntityWalking();
} else {
startRuleWalking();
}
}
int main()
{
// Test constructor
{
new LocatedEntityTest("1", 1);
}
// Test destructor
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
delete e;
}
// Test checkRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
assert(e->checkRef() == 0);
delete e;
}
// Test incRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->incRef();
assert(e->checkRef() == 1);
delete e;
}
// Test decRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->incRef();
e->decRef();
assert(e->checkRef() == 0);
delete e;
}
// Test decRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->decRef();
// Enitity deleted - verified as not leaked
}
// Test setAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->setAttr("foo", "bar");
e->decRef();
}
// Test setAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->setAttr("foo", "bar");
e->setAttr("foo", 23);
e->decRef();
}
// Test getAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttr("foo", val);
assert(ret == -1);
assert(val.isNone());
e->decRef();
}
// Test getAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
e->setAttr("foo", "bar");
int ret = e->getAttr("foo", val);
assert(ret == 0);
assert(val.isString());
e->decRef();
}
// Test getAttrType()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttrType("foo", val, Element::TYPE_STRING);
assert(ret == -1);
assert(val.isNone());
e->decRef();
}
// Test getAttrType()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttrType("id", val, Element::TYPE_STRING);
assert(ret == 0);
assert(val.isString());
e->decRef();
}
// Test getAttrType()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttrType("id", val, Element::TYPE_FLOAT);
assert(ret != 0);
assert(val.isString());
e->decRef();
}
// Test hasAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
bool ret = e->hasAttr("foo");
assert(ret == false);
e->decRef();
}
// Test hasAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
e->setAttr("foo", "bar");
bool ret = e->hasAttr("foo");
assert(ret == true);
e->decRef();
}
LocatedEntitytest t;
return t.run();
}
Py::Object CyPy_Task::getattro(const Py::String& name)
{
auto nameStr = name.as_string();
if (nameStr == "usage") {
return CyPy_UsageInstance::wrap(m_value->m_usageInstance);
}
if (nameStr == "actor") {
return CyPy_LocatedEntity::wrap(m_value->m_usageInstance.actor);
}
if (nameStr == "tool") {
return CyPy_LocatedEntity::wrap(m_value->m_usageInstance.tool);
}
// if (nameStr == "targets") {
// Py::List list(m_value->m_usageInstance.targets.size());
// for (size_t i = 0; i < m_value->m_usageInstance.targets.size(); ++i) {
// list[i] = CyPy_EntityLocation::wrap(m_value->m_usageInstance.targets[i]);
// }
// return list;
// }
// if (nameStr == "consumed") {
// Py::List list(m_value->m_usageInstance.consumed.size());
// for (size_t i = 0; i < m_value->m_usageInstance.consumed.size(); ++i) {
// list[i] = CyPy_EntityLocation::wrap(m_value->m_usageInstance.consumed[i]);
// }
// return list;
// }
if (nameStr == "definition") {
return CyPy_Usage::wrap(m_value->m_usageInstance.definition);
}
if (nameStr == "op") {
return CyPy_Operation::wrap(m_value->m_usageInstance.op);
}
if (nameStr == "progress") {
return Py::Float(m_value->progress());
}
if (nameStr == "duration") {
if (!m_value->m_duration) {
return Py::None();
}
return Py::Float(*m_value->m_duration);
}
if (nameStr == "tick_interval") {
if (!m_value->m_tick_interval) {
return Py::None();
}
return Py::Float(*m_value->m_tick_interval);
}
if (nameStr == "name") {
return Py::String(m_value->name());
}
Atlas::Message::Element val;
if (m_value->getAttr(name, val) == 0) {
if (val.isNone()) {
return Py::None();
} else {
return CyPy_Element::wrap(val);
}
}
return PythonExtensionBase::getattro(name);
}
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));
}
}