void Qtilities::Testing::TestObserver::testTreeChildrenContainment() {
// Example tree using tree node classes to simplify test:
QList<QObject*> children;
TreeNode* rootNode = new TreeNode("Root");
TreeNode* parentNode1 = rootNode->addNode("Parent 1");
children << parentNode1;
TreeNode* parentNode2 = rootNode->addNode("Parent 2");
children << parentNode2;
children << parentNode1->addItem("Child 1");
children << parentNode1->addItem("Child 2");
children << parentNode2->addItem("Child 3");
children << parentNode2->addItem("Child 4");
TreeItem* item = parentNode2->addItem("Child 5");
children << item;
// Now create and add a contained observer:
TreeNode* containedNode = new TreeNode("Contained Node");
children << containedNode;
children << containedNode->addItem("Contained Item 1");
children << containedNode->addItem("Contained Item 2");
children << containedNode->addItem("Contained Item 3");
containedNode->setParent(item);
QList<QObject*> children_verify = rootNode->treeChildren();
foreach (QObject* obj, children)
QVERIFY(children_verify.contains(obj) == true);
}
void Qtilities::Testing::TestObserverRelationalTable::testVisitorIDs() {
QList<QObject*> children;
TreeNode* rootNode = new TreeNode("Root");
TreeNode* parentNode1 = rootNode->addNode("Parent 1");
children << parentNode1;
TreeNode* parentNode2 = rootNode->addNode("Parent 2");
children << parentNode2;
children << parentNode1->addItem("Child 1");
children << parentNode1->addItem("Child 2");
children << parentNode2->addItem("Child 3");
children << parentNode2->addItem("Child 4");
children << parentNode2->addItem("Child 5");
// The VISITOR_ID property should not exist on any objects:
foreach (QObject* obj, children)
QVERIFY(ObjectManager::propertyExists(obj,qti_prop_VISITOR_ID) == false);
// Construct relational table:
ObserverRelationalTable* table = new ObserverRelationalTable(rootNode);
// Now check that all children got the VISITOR_ID property:
foreach (QObject* obj, children)
QVERIFY(ObjectManager::propertyExists(obj,qti_prop_VISITOR_ID) == true);
// Now delete the table:
delete table;
// Now check that the VISITOR_ID property was removed from all objects:
foreach (QObject* obj, children)
QVERIFY(ObjectManager::propertyExists(obj,qti_prop_VISITOR_ID) == false);
}
void Qtilities::Testing::TestObserverRelationalTable::testCompare() {
//LOG_INFO("TestObserverRelationalTable::testCompare() start:");
// Remember for the same observers use compare(), for different observer use diff()
TreeNode* observerA = new TreeNode("Observer A");
TreeNode* parentNode1 = observerA->addNode("Parent 1");
TreeNode* parentNode2 = observerA->addNode("Parent 2");
parentNode1->addItem("Child 1");
parentNode1->addItem("Child 2");
parentNode2->addItem("Child 3");
parentNode2->addItem("Child 4");
ObserverRelationalTable tableA(observerA);
ObserverRelationalTable tableB(observerA);
QVERIFY(tableA.compare(tableB) == true);
TreeItem* shared_item = parentNode2->addItem("Child 5");
// The tables should not have changed yet:
QVERIFY(tableA.compare(tableB) == true);
tableA.refresh();
// Now A should be up to date and B not:
QVERIFY(tableA.compare(tableB) == false);
tableB.refresh();
// Now both should be up to date:
QVERIFY(tableA.compare(tableB) == true);
// Check difference in object relationships
parentNode1->addItem(shared_item);
tableA.refresh();
QVERIFY(tableA.compare(tableB) == false);
tableB.refresh();
QVERIFY(tableA.compare(tableB) == true);
//LOG_INFO("TestObserverRelationalTable::testCompare() end:");
}
void Qtilities::Testing::TestObserver::testTreeContains() {
// Example tree using tree node classes to simplify test:
QList<QObject*> children;
TreeNode* rootNode = new TreeNode("Root");
TreeNode* parentNode1 = rootNode->addNode("Parent 1");
children << parentNode1;
TreeNode* parentNode2 = rootNode->addNode("Parent 2");
children << parentNode2;
children << parentNode1->addItem("Child 1");
children << parentNode1->addItem("Child 2");
children << parentNode2->addItem("Child 3");
children << parentNode2->addItem("Child 4");
children << parentNode2->addItem("Child 5");
foreach (QObject* obj, children)
QVERIFY(rootNode->treeContains(obj) == true);
}
void Qtilities::Testing::TestObserver::testRecursiveAttachmentContained() {
// Example tree using tree node classes to simplify test:
TreeNode* rootNode = new TreeNode("Root");
TreeNode* childNode = rootNode->addNode("Parent Node");
TreeItem* item = childNode->addItem("Child Item");
// Now create and add a contained observer:
TreeNode* containedNode = new TreeNode("Contained Node");
containedNode->setParent(item);
QVERIFY(containedNode->attachSubject(rootNode) == false);
}
void Qtilities::Testing::TestObserver::testTreeAt() {
// Example tree using tree node classes to simplify test:
TreeNode* rootNode = new TreeNode("Root");
TreeNode* parentNode1 = rootNode->addNode("Parent 1");
TreeNode* parentNode2 = rootNode->addNode("Parent 2");
parentNode1->addItem("Child 1");
parentNode1->addItem("Child 2");
parentNode2->addItem("Child 3");
parentNode2->addItem("Child 4");
TreeItem* item = parentNode2->addItem("Child 5");
QVERIFY(rootNode->treeAt(6) == item);
}
void Qtilities::Testing::TestObserver::testTreeChildren() {
// Example tree using tree node classes to simplify test:
QList<QObject*> children;
TreeNode* rootNode = new TreeNode("Root");
TreeNode* parentNode1 = rootNode->addNode("Parent 1");
children << parentNode1;
TreeNode* parentNode2 = rootNode->addNode("Parent 2");
children << parentNode2;
children << parentNode1->addItem("Child 1");
children << parentNode1->addItem("Child 2");
children << parentNode2->addItem("Child 3");
children << parentNode2->addItem("Child 4");
children << parentNode2->addItem("Child 5");
QList<QObject*> children_verify = rootNode->treeChildren();
foreach (QObject* obj, children)
QVERIFY(children_verify.contains(obj) == true);
QList<QObject*> nodes_verify = rootNode->treeChildren("Qtilities::CoreGui::TreeNode");
QVERIFY(nodes_verify.count() == 2);
QList<QObject*> items_verify = rootNode->treeChildren("Qtilities::CoreGui::TreeItem");
QVERIFY(items_verify.count() == 5);
}
int main(int argc, char *argv[])
{
QtilitiesApplication a(argc, argv);
QtilitiesApplication::setOrganizationName("YourOrganization");
QtilitiesApplication::setOrganizationDomain("YourDomain");
QtilitiesApplication::setApplicationName("My Application");
QtilitiesApplication::setApplicationVersion("1.0");
// Set the application export version:
QtilitiesApplication::setApplicationExportVersion(0);
// We need to set a QWidget as the application's main window in order for proxy actions to work:
QWidget* proxy_widget = new QWidget;
QtilitiesApplication::setMainWindow(proxy_widget);
// Register our VersionDetails class in the Qtilities factory:
FactoryItemID version_info_id("Version Details");
OBJECT_MANAGER->registerFactoryInterface(&VersionDetails::factory,version_info_id);
// Next create a TreeNode with a couple of our classes attached to it:
TreeNode* node = new TreeNode("TestNode");
VersionDetails* ver1 = new VersionDetails;
ver1->setDescriptionBrief("Version 1 Brief");
ver1->setDescriptionDetailed("Version 1 Brief");
ver1->setVersionMajor(0);
ver1->setVersionMinor(0);
VersionDetails* ver2 = new VersionDetails;
ver2->setDescriptionBrief("Version 2 Brief");
ver2->setDescriptionDetailed("Version 2 Brief");
ver2->setVersionMajor(1);
ver2->setVersionMinor(2);
node->attachSubject(ver1);
node->attachSubject(ver2);
node->addNode("NewNode");
// Next export the node to a file:
node->saveToFile("Output_Version_0.xml");
node->setApplicationExportVersion(1);
node->saveToFile("Output_Version_1.xml");
ObserverWidget* view = new ObserverWidget(node);
view->show();
return a.exec();
}
void Qtilities::Testing::TestObserver::testTreeAtContainment() {
// Example tree using tree node classes to simplify test:
TreeNode* rootNode = new TreeNode("Root");
TreeNode* parentNode1 = rootNode->addNode("Parent 1");
TreeNode* parentNode2 = rootNode->addNode("Parent 2");
parentNode1->addItem("Child 1");
parentNode1->addItem("Child 2");
parentNode2->addItem("Child 3");
parentNode2->addItem("Child 4");
TreeItem* item = parentNode2->addItem("Child 5");
// Now create and add a contained observer:
TreeNode* containedNode = new TreeNode("Contained Node");
containedNode->addItem("Contained Item 1");
containedNode->addItem("Contained Item 2");
TreeItem* test_item = containedNode->addItem("Contained Item 3");
containedNode->setParent(item);
LOG_INFO(QString::number(rootNode->treeCount()));
QVERIFY(rootNode->treeAt(10) == test_item);
}
void Qtilities::Testing::TestSubjectIterator::testIterationComplex() {
TreeNode node;
TreeNode* nodeA = node.addNode("A");
TreeNode* nodeB = node.addNode("B");
nodeA->addItem("1");
TreeItem* shared_item = nodeA->addItem("2");
nodeA->addItem("3");
nodeB->addItem("4");
nodeB->addItem("5");
nodeB->attachSubject(shared_item);
nodeB->addItem("6");
// If we want to iterate through the subjects in nodeA:
SubjectIterator<QObject> itrA(nodeA,SubjectIterator<QObject>::IterateChildren);
QVERIFY(itrA.current() != 0);
// In this case item1 will be skipped:
QStringList testListA;
testListA << itrA.current()->objectName();
while (itrA.hasNext()) {
testListA << itrA.next()->objectName();
}
QCOMPARE(testListA.count(), 3);
QCOMPARE(testListA.at(0), QString("1"));
QCOMPARE(testListA.at(1), QString("2"));
QCOMPARE(testListA.at(2), QString("3"));
// If we want to iterate through the subjects in nodeB:
SubjectIterator<QObject> itrB(nodeB,SubjectIterator<QObject>::IterateChildren);
// In this case item1 will be skipped:
QStringList testListB;
testListB << itrB.current()->objectName();
while (itrB.hasNext()) {
testListB << itrB.next()->objectName();
}
QCOMPARE(testListB.count(), 4);
QCOMPARE(testListB.at(0), QString("4"));
QCOMPARE(testListB.at(1), QString("5"));
QCOMPARE(testListB.at(2), QString("2"));
QCOMPARE(testListB.at(3), QString("6"));
// If we want to iterate through the subjects in nodeB:
SubjectIterator<QObject> itrC(shared_item,nodeB);
// In this case item1 will be skipped:
QStringList testListC;
testListC << itrC.current()->objectName();
while (itrC.hasNext()) {
testListC << itrC.next()->objectName();
}
QCOMPARE(testListC.count(), 2);
QCOMPARE(testListC.at(0), QString("2"));
QCOMPARE(testListC.at(1), QString("6"));
// If we want to iterate through the subjects in nodeB:
SubjectIterator<QObject> itrD(shared_item,nodeA);
// In this case item1 will be skipped:
QStringList testListD;
testListD << itrD.current()->objectName();
while (itrD.hasNext()) {
testListD << itrD.next()->objectName();
}
QCOMPARE(testListD.count(), 2);
QCOMPARE(testListD.at(0), QString("2"));
QCOMPARE(testListD.at(1), QString("3"));
}
int main(int argc, char *argv[])
{
QtilitiesApplication a(argc, argv);
QtilitiesApplication::setOrganizationName("Jaco Naude");
QtilitiesApplication::setOrganizationDomain("Qtilities");
QtilitiesApplication::setApplicationName("Qtilities Tester");
QtilitiesApplication::setApplicationVersion(QtilitiesApplication::qtilitiesVersionString());
// Create the observer widget in tree mode:
ObserverWidget* observer_widget = new ObserverWidget;
observer_widget->resize(600,850);
QtilitiesApplication::setMainWindow(observer_widget);
Log->setLoggerSessionConfigPath(QtilitiesApplication::applicationSessionPath());
LOG_INITIALIZE();
TreeNode* rootNodeCategorized = new TreeNode("Root");
rootNodeCategorized->enableCategorizedDisplay();
// TODO: This breaks the toolbar for some reason... Looks like a display issue since it only happens in QTabWidget:
rootNodeCategorized->displayHints()->setDisplayFlagsHint(ObserverHints::ItemView | ObserverHints::ActionToolBar);
rootNodeCategorized->displayHints()->setActionHints(ObserverHints::ActionAllHints);
rootNodeCategorized->displayHints()->setCategoryEditingFlags(ObserverHints::CategoriesEditableAllLevels | ObserverHints::CategoriesAcceptSubjectDrops);
rootNodeCategorized->displayHints()->setDragDropHint(ObserverHints::AllowDrags);
rootNodeCategorized->addItem("Child 1",QtilitiesCategory("Category 1::A",QString("::")));
rootNodeCategorized->addItem("Child 2",QtilitiesCategory("Category 1::B",QString("::")));
rootNodeCategorized->addItem("Child 3");
rootNodeCategorized->addItem("Child 4",QtilitiesCategory("Category 2"));
TreeItem* modified_item = rootNodeCategorized->addItem("Child 5",QtilitiesCategory("Category 2"));
rootNodeCategorized->displayHints()->setModificationStateDisplayHint(ObserverHints::CharacterModificationStateDisplay);
modified_item->setModificationState(true);
// Init and show the observer widget:
observer_widget->setObserverContext(rootNodeCategorized);
observer_widget->initialize();
// Test the tree model:
new ModelTest(observer_widget->proxyModel());
// Test the table model:
//new ModelTest(observer_widget->tableModel());
observer_widget->show();
QStringList items;
items << "A" << "B" << "C";
rootNodeCategorized->addItems(items);
TreeNode* nodeA = rootNodeCategorized->addNode("Node A");
nodeA->copyHints(rootNodeCategorized->displayHints());
TreeNode* nodeB = rootNodeCategorized->addNode("Node B");
nodeB->copyHints(rootNodeCategorized->displayHints());
nodeA->addItem("Child 1",QtilitiesCategory("Category 3::A",QString("::")));
nodeA->addItem("Child 2",QtilitiesCategory("Category 4::B",QString("::")));
nodeA->addItem("Child 3");
nodeA->addItem("Child 4",QtilitiesCategory("Category 5"));
nodeB->addItem("Child 1",QtilitiesCategory("Category 6::A",QString("::")));
nodeB->addItem("Child 2",QtilitiesCategory("Category 7::B",QString("::")));
nodeB->addItem("Child 3");
nodeB->addItem("Child 4",QtilitiesCategory("Category 8"));
return a.exec();
}
void Qtilities::Testing::TestObserver::testRecursiveAttachment() {
// Example tree using tree node classes to simplify test:
TreeNode* rootNode = new TreeNode("Root");
TreeNode* childNode = rootNode->addNode("Parent 1");
QVERIFY(childNode->attachSubject(rootNode) == false);
}
