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