TEST(ModelBase, ModificationNotificationTests)
{
Model model;
NotificationListener nl(model);
CHECK_CONDITION(nl.root == nullptr);
CHECK_INT_EQUAL(0, nl.modifiedNodes.size());
TestNodes::BinaryNode* root = dynamic_cast<TestNodes::BinaryNode*> (model.createRoot("BinaryNode"));
CHECK_CONDITION(root == nl.root);
model.beginModification(root, "make tree");
TestNodes::BinaryNode* left = new TestNodes::BinaryNode();
TestNodes::BinaryNode* right = new TestNodes::BinaryNode();
root->setLeft(left);
root->setRight(right);
model.endModification();
CHECK_INT_EQUAL(1, nl.modifiedNodes.size());
CHECK_CONDITION(nl.modifiedNodes[0] == root);
model.beginModification(left, "modify");
left->name()->set("Left text");
model.changeModificationTarget(right);
right->name()->set("Right text");
model.endModification();
CHECK_INT_EQUAL(4, nl.modifiedNodes.size());
CHECK_CONDITION(nl.modifiedNodes[0] == left);
CHECK_CONDITION(nl.modifiedNodes[1] == left->name());
CHECK_CONDITION(nl.modifiedNodes[2] == right);
CHECK_CONDITION(nl.modifiedNodes[3] == right->name());
nl.modifiedNodes.clear();
model.beginModification(nullptr);
model.undo();
model.undo();
model.endModification();
CHECK_INT_EQUAL(5, nl.modifiedNodes.size());
CHECK_CONDITION(nl.modifiedNodes[0] == right);
CHECK_CONDITION(nl.modifiedNodes[1] == right->name());
CHECK_CONDITION(nl.modifiedNodes[2] == left);
CHECK_CONDITION(nl.modifiedNodes[3] == left->name());
CHECK_CONDITION(nl.modifiedNodes[4] == root);
}
TEST(ModelBase, CompositeMetaData)
{
AttributeChain& metaExt = TestNodes::BinaryNode::getMetaData();
AttributeChain& metaUnit = TestNodes::BinaryNodeAccessUnit::getMetaData();
CHECK_INT_EQUAL(1, metaExt.numLevels());
CHECK_INT_EQUAL(2, metaUnit.numLevels());
CHECK_INT_EQUAL(5, metaExt.size());
CHECK_INT_EQUAL(0, metaUnit.size());
CHECK_CONDITION( metaUnit.level(0) == &metaExt);
CHECK_STR_EQUAL("name", metaExt[0].name());
CHECK_STR_EQUAL("left", metaExt[1].name());
CHECK_STR_EQUAL("right", metaExt[2].name());
CHECK_STR_EQUAL("_ext_PositionExtension_x", metaExt[3].name());
CHECK_STR_EQUAL("_ext_PositionExtension_y", metaExt[4].name());
CHECK_STR_EQUAL("Text", metaExt[0].type());
CHECK_STR_EQUAL("BinaryNode", metaExt[1].type());
CHECK_STR_EQUAL("BinaryNode", metaExt[2].type());
CHECK_STR_EQUAL("Integer", metaExt[3].type());
CHECK_STR_EQUAL("Integer", metaExt[4].type());
CHECK_CONDITION(metaExt[0].optional() == false);
CHECK_CONDITION(metaExt[1].optional() == true);
CHECK_CONDITION(metaExt[2].optional() == true);
CHECK_CONDITION(metaExt[3].optional() == false);
CHECK_CONDITION(metaExt[4].optional() == false);
CHECK_CONDITION(metaExt[0].partialHint() == false);
CHECK_CONDITION(metaExt[1].partialHint() == false);
CHECK_CONDITION(metaExt[2].partialHint() == false);
CHECK_CONDITION(metaExt[3].partialHint() == false);
CHECK_CONDITION(metaExt[4].partialHint() == false);
}
TEST(FilePersistence, LoadingList)
{
QString testDir = ":/FilePersistence/test/persisted";
Model::Model model;
FileStore store;
store.setBaseFolder(testDir);
model.load(&store, "partial");
TestNodes::PartialList* root = dynamic_cast<TestNodes::PartialList*> (model.root());
CHECK_CONDITION(root != nullptr);
Model::List* list = root->list();
CHECK_CONDITION(list != nullptr);
CHECK_STR_EQUAL("List", list->typeName() );
CHECK_CONDITION(list->isFullyLoaded() == false);
list->loadFully(store);
CHECK_CONDITION(list->isFullyLoaded());
CHECK_INT_EQUAL(4, list->size());
Model::Text* one = list->at<Model::Text>(0);
Model::Text* two = list->at<Model::Text>(1);
Model::Text* three = list->at<Model::Text>(2);
Model::Text* four = list->at<Model::Text>(3);
CHECK_CONDITION(one != nullptr);
CHECK_STR_EQUAL("one", one->get());
CHECK_CONDITION(two != nullptr);
CHECK_STR_EQUAL("two", two->get());
CHECK_CONDITION(three != nullptr);
CHECK_STR_EQUAL("three", three->get());
CHECK_CONDITION(four != nullptr);
CHECK_STR_EQUAL("four", four->get());
}
TEST(FilePersistence, LoadingTypedList)
{
QString testDir = ":/FilePersistence/test/persisted";
Model::Model model;
FileStore store;
store.setBaseFolder(testDir);
model.load(&store, "typedList");
Model::TypedList<Model::Text>* list = dynamic_cast<Model::TypedList<Model::Text>*> (model.root());
CHECK_CONDITION(list != nullptr);
CHECK_STR_EQUAL("TypedListOfText", list->typeName() );
CHECK_INT_EQUAL(2, list->size());
Model::Text* one = list->at(0);
Model::Text* two = list->at(1);
CHECK_CONDITION(one != nullptr);
CHECK_STR_EQUAL("one", one->get());
CHECK_CONDITION(two != nullptr);
CHECK_STR_EQUAL("two", two->get());
}
TEST(FilePersistence, LoadDataMultipleUnits)
{
QString testDir = ":/FilePersistence/test/persisted";
FileStore store;
store.setBaseFolder(testDir);
typedef PersistedValue< QString >* String;
typedef PersistedValue< QList<PersistedNode*> >* Composite;
// Root Node
Composite root = dynamic_cast<Composite> (store.loadCompleteNodeSubtree("units", nullptr));
CHECK_CONDITION(root);
CHECK_STR_EQUAL("BinaryNode", root->type() );
CHECK_STR_EQUAL("units", root->name());
CHECK_INT_EQUAL(0, root->id());
CHECK_CONDITION(!root->partialHint());
CHECK_CONDITION(!root->isNewPersistenceUnit());
CHECK_INT_EQUAL(3, root->value().size());
// Root Node children
String rootName = dynamic_cast<String> (root->value().at(0));
CHECK_CONDITION(rootName);
CHECK_STR_EQUAL("Text", rootName->type() );
CHECK_STR_EQUAL("name", rootName->name());
CHECK_INT_EQUAL(1, rootName->id());
CHECK_CONDITION(!rootName->partialHint());
CHECK_CONDITION(!rootName->isNewPersistenceUnit());
CHECK_STR_EQUAL("Root", rootName->value());
Composite left = dynamic_cast<Composite> (root->value().at(1));
CHECK_CONDITION(left);
CHECK_STR_EQUAL("BinaryNodePersistenceUnit", left->type() );
CHECK_STR_EQUAL("left", left->name());
CHECK_INT_EQUAL(2, left->id());
CHECK_CONDITION(!left->partialHint());
CHECK_CONDITION(left->isNewPersistenceUnit());
CHECK_INT_EQUAL(2, left->value().size());
Composite right = dynamic_cast<Composite> (root->value().at(2));
CHECK_CONDITION(right);
CHECK_STR_EQUAL("BinaryNode", right->type() );
CHECK_STR_EQUAL("right", right->name());
CHECK_INT_EQUAL(6, right->id());
CHECK_CONDITION(!right->partialHint());
CHECK_CONDITION(!right->isNewPersistenceUnit());
CHECK_INT_EQUAL(1, right->value().size());
// Left Node children
String leftName = dynamic_cast<String> (left->value().at(0));
CHECK_CONDITION(leftName);
CHECK_STR_EQUAL("Text", leftName->type() );
CHECK_STR_EQUAL("name", leftName->name());
CHECK_INT_EQUAL(3, leftName->id());
CHECK_CONDITION(!leftName->partialHint());
CHECK_CONDITION(!leftName->isNewPersistenceUnit());
CHECK_STR_EQUAL("Left child", leftName->value());
Composite leftleft = dynamic_cast<Composite> (left->value().at(1));
CHECK_CONDITION(leftleft);
CHECK_STR_EQUAL("BinaryNode", leftleft->type() );
CHECK_STR_EQUAL("left", leftleft->name());
CHECK_INT_EQUAL(4, leftleft->id());
CHECK_CONDITION(!leftleft->partialHint());
CHECK_CONDITION(!leftleft->isNewPersistenceUnit());
CHECK_INT_EQUAL(1, leftleft->value().size());
String leftleftName = dynamic_cast<String> (leftleft->value().at(0));
CHECK_CONDITION(leftleftName);
CHECK_STR_EQUAL("Text", leftleftName->type() );
CHECK_STR_EQUAL("name", leftleftName->name());
CHECK_INT_EQUAL(5, leftleftName->id());
CHECK_CONDITION(!leftleftName->partialHint());
CHECK_CONDITION(!leftleftName->isNewPersistenceUnit());
CHECK_STR_EQUAL("in a new unit", leftleftName->value());
// Right Node children
String rightName = dynamic_cast<String> (right->value().at(0));
CHECK_CONDITION(rightName);
CHECK_STR_EQUAL("Text", rightName->type() );
CHECK_STR_EQUAL("name", rightName->name());
CHECK_INT_EQUAL(7, rightName->id());
CHECK_CONDITION(!rightName->partialHint());
CHECK_CONDITION(!rightName->isNewPersistenceUnit());
CHECK_STR_EQUAL("Right child", rightName->value());
}
TEST(PLUGINNAME, SimpleTest)
{
CHECK_INT_EQUAL(1,1);
}
