OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity
3c05fff768
ResInsight/Fwk/AppFwk/cafProjectDataModel/cafProjectDataModel_UnitTests/cafPdmBasicTest.cpp

998 lines
32 KiB
C++
Raw Blame History

//##################################################################################################
//
// Custom Visualization Core library
// Copyright (C) 2011-2013 Ceetron AS
//
// This library may be used under the terms of either the GNU General Public License or
// the GNU Lesser General Public License as follows:
//
// GNU General Public License Usage
// This library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
// for more details.
//
// GNU Lesser General Public License Usage
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2.1 of the License, or
// (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
// for more details.
//
//##################################################################################################
#include <iostream>
#include "gtest/gtest.h"
#include "cafAppEnum.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
#include "cafPdmDocument.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmObjectGroup.h"
#include "cafPdmPointer.h"
#include "cafPdmProxyValueField.h"
#include "cafPdmReferenceHelper.h"
#include <QFile>
#include <memory>
/// Demo objects to show the usage of the Pdm system
class SimpleObj: public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
SimpleObj() : PdmObject(),
m_doubleMember(0.0)
{
CAF_PDM_InitObject("SimpleObj", "", "Tooltip SimpleObj", "WhatsThis SimpleObj");
CAF_PDM_InitField(&m_position, "Position", 8765.2, "Position", "", "Tooltip", "WhatsThis");
CAF_PDM_InitField(&m_dir, "Dir", 123.56, "Direction", "", "Tooltip", "WhatsThis");
CAF_PDM_InitField(&m_up, "Up", 0.0, "Up value", "", "Tooltip", "WhatsThis" );
CAF_PDM_InitFieldNoDefault(&m_numbers, "Numbers", "Important Numbers", "", "Tooltip", "WhatsThis");
#if 1
m_proxyDouble.registerSetMethod(this, &SimpleObj::setDoubleMember);
m_proxyDouble.registerGetMethod(this, &SimpleObj::doubleMember);
AddUiCapabilityToField(&m_proxyDouble);
AddXmlCapabilityToField(&m_proxyDouble);
CAF_PDM_InitFieldNoDefault(&m_proxyDouble, "ProxyDouble", "ProxyDouble", "", "", "");
#endif
}
/// Assignment and copying of PDM objects is not focus for the features. This is only a
/// "would it work" test
SimpleObj(const SimpleObj& other)
: PdmObject()
{
CAF_PDM_InitField(&m_position, "Position", 8765.2, "Position", "", "", "WhatsThis");
CAF_PDM_InitField(&m_dir, "Dir", 123.56, "Direction", "", "", "WhatsThis");
CAF_PDM_InitField(&m_up, "Up", 0.0, "Up value", "", "", "WhatsThis" );
CAF_PDM_InitFieldNoDefault(&m_numbers, "Numbers", "Important Numbers", "", "", "WhatsThis");
m_position = other.m_position;
m_dir = other.m_dir;
m_up = other.m_up;
m_numbers = other.m_numbers;
m_doubleMember = other.m_doubleMember;
}
~SimpleObj() {}
caf::PdmField<double> m_position;
caf::PdmField<double> m_dir;
caf::PdmField<double> m_up;
caf::PdmField<std::vector<double> > m_numbers;
caf::PdmProxyValueField<double> m_proxyDouble;
void setDoubleMember(const double& d) { m_doubleMember = d; std::cout << "setDoubleMember" << std::endl; }
double doubleMember() const { std::cout << "doubleMember" << std::endl; return m_doubleMember; }
double m_doubleMember;
};
CAF_PDM_SOURCE_INIT(SimpleObj, "SimpleObj");
class DemoPdmObject: public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
DemoPdmObject()
{
CAF_PDM_InitObject("DemoPdmObject", "", "Tooltip DemoPdmObject", "WhatsThis DemoPdmObject");
CAF_PDM_InitField(&m_doubleField, "BigNumber", 0.0, "", "",
"Enter a big number here",
"This is a place you can enter a big real value if you want" );
CAF_PDM_InitField(&m_intField, "IntNumber", 0, "","",
"Enter some small number here",
"This is a place you can enter a small integer value if you want");
CAF_PDM_InitField(&m_textField, "TextField", QString("<EFBFBD><EFBFBD><EFBFBD> Test text end"), "TextField", "", "Tooltip", "WhatsThis");
CAF_PDM_InitFieldNoDefault(&m_simpleObjPtrField, "SimpleObjPtrField", "SimpleObjPtrField", "", "Tooltip", "WhatsThis");
CAF_PDM_InitFieldNoDefault(&m_simpleObjPtrField2, "SimpleObjPtrField2", "SimpleObjPtrField2", "", "Tooltip", "WhatsThis");
m_simpleObjPtrField2 = new SimpleObj;
}
~DemoPdmObject()
{
delete m_simpleObjPtrField();
delete m_simpleObjPtrField2();
}
// Fields
caf::PdmField<double> m_doubleField;
caf::PdmField<int> m_intField;
caf::PdmField<QString> m_textField;
caf::PdmChildField<SimpleObj*> m_simpleObjPtrField;
caf::PdmChildField<SimpleObj*> m_simpleObjPtrField2;
};
CAF_PDM_SOURCE_INIT(DemoPdmObject, "DemoPdmObject");
class InheritedDemoObj : public DemoPdmObject
{
CAF_PDM_HEADER_INIT;
public:
enum TestEnumType
{
T1, T2, T3
};
InheritedDemoObj()
{
CAF_PDM_InitObject("InheritedDemoObj", "", "ToolTip InheritedDemoObj", "Whatsthis InheritedDemoObj");
CAF_PDM_InitFieldNoDefault(&m_texts, "Texts", "Some words", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_testEnumField, "TestEnumValue", "An Enum", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_simpleObjectsField, "SimpleObjects", "SimpleObjectsField", "", "ToolTip SimpleObjectsField", "Whatsthis SimpleObjectsField");
}
~InheritedDemoObj()
{
m_simpleObjectsField.deleteAllChildObjects();
}
caf::PdmField<std::vector<QString> > m_texts;
caf::PdmField< caf::AppEnum<TestEnumType> > m_testEnumField;
caf::PdmChildArrayField<SimpleObj*> m_simpleObjectsField;
};
CAF_PDM_SOURCE_INIT(InheritedDemoObj, "InheritedDemoObj");
class MyPdmDocument : public caf::PdmDocument
{
CAF_PDM_HEADER_INIT;
public:
MyPdmDocument()
{
CAF_PDM_InitObject("PdmObjectCollection", "", "", "");
CAF_PDM_InitFieldNoDefault(&objects, "PdmObjects", "", "", "", "")
}
~MyPdmDocument()
{
objects.deleteAllChildObjects();
}
caf::PdmChildArrayField<PdmObjectHandle*> objects;
};
CAF_PDM_SOURCE_INIT(MyPdmDocument, "MyPdmDocument");
namespace caf
{
template<>
void AppEnum<InheritedDemoObj::TestEnumType>::setUp()
{
addItem(InheritedDemoObj::T1, "T1", "An A letter");
addItem(InheritedDemoObj::T2, "T2", "A B letter");
addItem(InheritedDemoObj::T3, "T3", "A B letter");
setDefault(InheritedDemoObj::T1);
}
}
TEST(BaseTest, Delete)
{
SimpleObj* s2 = new SimpleObj;
delete s2;
}
//--------------------------------------------------------------------------------------------------
/// This is a testbed to try out different aspects, instead of having a main in a prototype program
/// To be disabled when everything gets more mature.
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, Start)
{
DemoPdmObject* a = new DemoPdmObject;
caf::PdmObjectHandle* demo = caf::PdmDefaultObjectFactory::instance()->create("DemoPdmObject");
EXPECT_TRUE(demo != NULL);
QString xml;
QXmlStreamWriter xmlStream(&xml);
xmlStream.setAutoFormatting(true);
SimpleObj* s2 = new SimpleObj;
caf::PdmPointer<SimpleObj> sp;
sp = s2;
std::cout << sp.p() << std::endl;
{
SimpleObj s;
s.m_dir = 10000;
sp = &s;
a->m_textField = "Hei og h<>";
//*s2 = s;
a->m_simpleObjPtrField = s2;
s.writeFields(xmlStream);
}
a->writeFields(xmlStream);
caf::PdmObjectGroup og;
og.objects.push_back(a);
og.objects.push_back(new SimpleObj);
og.writeFields(xmlStream);
std::cout << sp.p() << std::endl,
std::cout << xml.toStdString() << std::endl;
}
//--------------------------------------------------------------------------------------------------
/// Test of PdmField operations
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, NormalPdmField)
{
class ObjectWithVectors : public caf::PdmObjectHandle
{
public:
ObjectWithVectors()
{
this->addField(&field1, "field1");
this->addField(&field2, "field2");
this->addField(&field3, "field3");
}
caf::PdmField<std::vector<double> > field1;
caf::PdmField<std::vector<double> > field2;
caf::PdmField<std::vector<double> > field3;
};
std::vector<double> testValue;
testValue.push_back(1.1);
testValue.push_back(1.2);
testValue.push_back(1.3);
std::vector<double> testValue2;
testValue2.push_back(2.1);
testValue2.push_back(2.2);
testValue2.push_back(2.3);
ObjectWithVectors myObj;
// Constructors
myObj.field2 = testValue;
EXPECT_EQ(1.3, myObj.field2.v()[2]);
myObj.field3 = myObj.field2;
EXPECT_EQ(1.3, myObj.field3.v()[2]);
EXPECT_EQ(size_t(0), myObj.field1().size());
// Operators
EXPECT_FALSE(myObj.field1 == myObj.field3);
myObj.field1 = myObj.field2;
EXPECT_EQ(1.3, myObj.field1()[2]);
myObj.field1 = testValue2;
EXPECT_EQ(2.3, myObj.field1()[2]);
myObj.field3 = myObj.field1;
EXPECT_TRUE(myObj.field1 == myObj.field3);
}
#if 0
//--------------------------------------------------------------------------------------------------
/// Test of PdmField of pointer operations
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, PointerPdmField)
{
SimpleObj* testValue = new SimpleObj;
testValue->m_numbers.v().push_back(1.1);
testValue->m_numbers.v().push_back(1.2);
testValue->m_numbers.v().push_back(1.3);
SimpleObj* testValue2 = new SimpleObj;
testValue->m_numbers.v().push_back(2.1);
testValue->m_numbers.v().push_back(2.2);
testValue->m_numbers.v().push_back(2.3);
// Constructors
caf::PdmField<SimpleObj*> field2(testValue);
EXPECT_EQ(testValue, field2.v());
caf::PdmField<SimpleObj*> field3(field2);
EXPECT_EQ(testValue, field3.v());
caf::PdmField<SimpleObj*> field1;
EXPECT_EQ((SimpleObj*)0, field1.v());
// Operators
EXPECT_FALSE(field1 == field3);
field1 = field2;
EXPECT_EQ(testValue, field1);
field1 = testValue2;
field3 = testValue2;
EXPECT_EQ(testValue2, field1);
EXPECT_TRUE(field1 == field3);
delete testValue;
delete testValue2;
EXPECT_EQ((SimpleObj*)0, field1);
EXPECT_EQ((SimpleObj*)0, field2);
EXPECT_EQ((SimpleObj*)0, field3);
}
#endif
//--------------------------------------------------------------------------------------------------
/// Test of PdmPointersField operations
//--------------------------------------------------------------------------------------------------
#if 0
TEST(BaseTest, PdmChildArrayField)
{
std::vector<caf::PdmFieldHandle*> parentFields;
InheritedDemoObj* ihd1 = new InheritedDemoObj;
SimpleObj* s1 = new SimpleObj;
SimpleObj* s2 = new SimpleObj;
SimpleObj* s3 = new SimpleObj;
// empty() number 1
EXPECT_TRUE(ihd1->m_simpleObjectsField.empty());
EXPECT_EQ(size_t(0), ihd1->m_simpleObjectsField.size());
// push_back()
ihd1->m_simpleObjectsField.push_back(s1);
ihd1->m_simpleObjectsField.push_back(s2);
ihd1->m_simpleObjectsField.push_back(s3);
s1->parentField(parentFields);
EXPECT_EQ(size_t(1), parentFields.size());
parentFields.clear();
// size()
EXPECT_EQ(size_t(3), ihd1->m_simpleObjectsField.size());
EXPECT_EQ(size_t(3), ihd1->m_simpleObjectsField.size());
// operator[]
EXPECT_EQ(s2, ihd1->m_simpleObjectsField[1]);
EXPECT_EQ(s3, ihd1->m_simpleObjectsField[2]);
// childObjects
std::vector<caf::PdmObjectHandle*> objects;
ihd1->m_simpleObjectsField.childObjects(&objects);
EXPECT_EQ(size_t(3), objects.size());
// Operator ==, Operator =
InheritedDemoObj* ihd2 = new InheritedDemoObj;
EXPECT_FALSE(ihd2->m_simpleObjectsField == ihd1->m_simpleObjectsField);
ihd2->m_simpleObjectsField = ihd1->m_simpleObjectsField;
EXPECT_TRUE(ihd2->m_simpleObjectsField == ihd1->m_simpleObjectsField);
s1->parentFields(parentFields);
EXPECT_EQ(size_t(2), parentFields.size());
parentFields.clear();
// set(), Operator=
ihd2->m_simpleObjectsField.set(1, NULL);
EXPECT_FALSE(ihd2->m_simpleObjectsField == ihd1->m_simpleObjectsField);
EXPECT_TRUE(NULL == ihd2->m_simpleObjectsField[1]);
s2->parentFields(parentFields);
EXPECT_EQ(size_t(1), parentFields.size());
parentFields.clear();
// removeAll(pointer)
ihd2->m_simpleObjectsField.removeChildObject(NULL);
EXPECT_EQ(size_t(2), ihd2->m_simpleObjectsField.size());
EXPECT_EQ(s3, ihd2->m_simpleObjectsField[1]);
EXPECT_EQ(s1, ihd2->m_simpleObjectsField[0]);
// insert()
ihd2->m_simpleObjectsField.insert(1, s2);
EXPECT_TRUE(ihd2->m_simpleObjectsField == ihd1->m_simpleObjectsField);
s2->parentFields(parentFields);
EXPECT_EQ(size_t(2), parentFields.size());
parentFields.clear();
// erase (index)
ihd2->m_simpleObjectsField.erase(1);
EXPECT_EQ(size_t(2), ihd2->m_simpleObjectsField.size());
EXPECT_EQ(s3, ihd2->m_simpleObjectsField[1]);
EXPECT_EQ(s1, ihd2->m_simpleObjectsField[0]);
s2->parentFields(parentFields);
EXPECT_EQ(size_t(1), parentFields.size());
parentFields.clear();
// clear()
ihd2->m_simpleObjectsField.clear();
EXPECT_EQ(size_t(0), ihd2->m_simpleObjectsField.size());
s1->parentFields(parentFields);
EXPECT_EQ(size_t(1), parentFields.size());
parentFields.clear();
}
#endif
template <>
inline void GTestStreamToHelper<QString>(std::ostream* os, const QString& val) {
*os << val.toLatin1().data();
}
//--------------------------------------------------------------------------------------------------
/// Tests the roundtrip: Create, write, read, write and checks that the first and second file are identical
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, ReadWrite)
{
QString xmlDocumentContentWithErrors;
{
MyPdmDocument xmlDoc;
// Create objects
DemoPdmObject* d1 = new DemoPdmObject;
DemoPdmObject* d2 = new DemoPdmObject;
InheritedDemoObj* id1 = new InheritedDemoObj;
InheritedDemoObj* id2 = new InheritedDemoObj;
SimpleObj* s1 = new SimpleObj;
SimpleObj s2;
s1->m_numbers.v().push_back(1.7);
// set some values
s2.m_numbers.v().push_back(2.4);
s2.m_numbers.v().push_back(2.5);
s2.m_numbers.v().push_back(2.6);
s2.m_numbers.v().push_back(2.7);
id1->m_texts.v().push_back("Hei");
id1->m_texts.v().push_back("og");
id1->m_texts.v().push_back("H<EFBFBD> test with whitespace");
d2->m_simpleObjPtrField = &s2;
d2->m_simpleObjPtrField2 = s1;
id1->m_simpleObjectsField.push_back(new SimpleObj);
id1->m_simpleObjectsField[0]->m_numbers.v().push_back(3.0);
id1->m_simpleObjectsField.push_back(new SimpleObj);
id1->m_simpleObjectsField[1]->m_numbers.v().push_back(3.1);
id1->m_simpleObjectsField[1]->m_numbers.v().push_back(3.11);
id1->m_simpleObjectsField[1]->m_numbers.v().push_back(3.12);
id1->m_simpleObjectsField[1]->m_numbers.v().push_back(3.13);
id1->m_simpleObjectsField.push_back(new SimpleObj);
id1->m_simpleObjectsField[2]->m_numbers.v().push_back(3.2);
id1->m_simpleObjectsField.push_back(new SimpleObj);
id1->m_simpleObjectsField[3]->m_numbers.v().push_back(3.3);
// Add to document
xmlDoc.objects.push_back(d1);
xmlDoc.objects.push_back(d2);
xmlDoc.objects.push_back(new SimpleObj);
xmlDoc.objects.push_back(id1);
xmlDoc.objects.push_back(id2);
// Write file
xmlDoc.fileName = "PdmTestFil.xml";
xmlDoc.writeFile();
caf::PdmObjectGroup pog;
for (size_t i = 0; i < xmlDoc.objects.size(); i++)
{
pog.addObject(xmlDoc.objects[i]);
}
{
std::vector<caf::PdmPointer<DemoPdmObject> > demoObjs;
pog.objectsByType(&demoObjs);
EXPECT_EQ(size_t(4), demoObjs.size());
}
{
std::vector<caf::PdmPointer<InheritedDemoObj> > demoObjs;
pog.objectsByType(&demoObjs);
EXPECT_EQ(size_t(2), demoObjs.size());
}
{
std::vector<caf::PdmPointer<SimpleObj> > demoObjs;
pog.objectsByType(&demoObjs);
EXPECT_EQ(size_t(1), demoObjs.size());
}
d2->m_simpleObjPtrField = NULL;
xmlDoc.objects.deleteAllChildObjects();
}
{
MyPdmDocument xmlDoc;
// Read file
xmlDoc.fileName = "PdmTestFil.xml";
xmlDoc.readFile();
caf::PdmObjectGroup pog;
for (size_t i = 0; i < xmlDoc.objects.size(); i++)
{
pog.addObject(xmlDoc.objects[i]);
}
// Test sample of that writing actually took place
std::vector<caf::PdmPointer<InheritedDemoObj> > ihDObjs;
pog.objectsByType(&ihDObjs);
EXPECT_EQ(size_t(2),ihDObjs.size() );
ASSERT_EQ(size_t(4), ihDObjs[0]->m_simpleObjectsField.size());
ASSERT_EQ(size_t(4), ihDObjs[0]->m_simpleObjectsField[1]->m_numbers().size());
EXPECT_EQ(3.13, ihDObjs[0]->m_simpleObjectsField[1]->m_numbers()[3]);
EXPECT_EQ(QString("<EFBFBD><EFBFBD><EFBFBD> Test text end"), ihDObjs[0]->m_textField());
// Write file
QFile xmlFile("PdmTestFil2.xml");
xmlFile.open(QIODevice::WriteOnly | QIODevice::Text);
xmlDoc.writeFile(&xmlFile);
xmlFile.close();
}
// Check that the files are identical
{
QFile f1("PdmTestFil.xml");
QFile f2("PdmTestFil2.xml");
f1.open(QIODevice::ReadOnly | QIODevice::Text);
f2.open(QIODevice::ReadOnly | QIODevice::Text);
QByteArray ba1 = f1.readAll();
QByteArray ba2 = f2.readAll();
bool equal = ba1 == ba2;
EXPECT_TRUE(equal);
// Then test how errors are handled
{
int pos = 0;
int occurenceCount = 0;
while (occurenceCount < 1)
{
pos = ba1.indexOf("<SimpleObj>", pos+1);
occurenceCount++;
}
ba1.insert(pos+1, "Error");
}
{
int pos = 0;
int occurenceCount = 0;
while (occurenceCount < 1)
{
pos = ba1.indexOf("</SimpleObj>", pos +1);
occurenceCount++;
}
ba1.insert(pos+2, "Error");
}
{
int pos = 0;
int occurenceCount = 0;
while (occurenceCount < 6) // Second position in a pointersfield
{
pos = ba1.indexOf("<SimpleObj>", pos +1);
occurenceCount++;
}
ba1.insert(pos+1, "Error");
}
{
int pos = 0;
int occurenceCount = 0;
while (occurenceCount < 6) // Second position in a pointersfield
{
pos = ba1.indexOf("</SimpleObj>", pos +1);
occurenceCount++;
}
ba1.insert(pos+2, "Error");
}
{
int pos = ba1.indexOf("<BigNumber>");
ba1.insert(pos+1, "Error");
pos = ba1.indexOf("</BigNumber>");
ba1.insert(pos+2, "Error");
}
{
int pos = 0;
int occurenceCount = 0;
while (occurenceCount < 4)
{
pos = ba1.indexOf("<Numbers>", pos +1);
occurenceCount++;
}
ba1.insert(pos+1, "Error");
}
{
int pos = 0;
int occurenceCount = 0;
while (occurenceCount < 4)
{
pos = ba1.indexOf("</Numbers>", pos +1);
occurenceCount++;
}
ba1.insert(pos+2, "Error");
}
// Write the edited document
QFile f3("PdmTestFilWithError.xml");
f3.open(QIODevice::WriteOnly | QIODevice::Text);
f3.write(ba1);
f3.close();
// Read the document containing errors
MyPdmDocument xmlErrorDoc;
xmlErrorDoc.fileName = "PdmTestFilWithError.xml";
xmlErrorDoc.readFile();
caf::PdmObjectGroup pog;
for (size_t i = 0; i < xmlErrorDoc.objects.size(); i++)
{
pog.addObject(xmlErrorDoc.objects[i]);
}
// Check the pointersfield
std::vector<caf::PdmPointer<InheritedDemoObj> > ihDObjs;
pog.objectsByType(&ihDObjs);
EXPECT_EQ(size_t(2), ihDObjs.size() );
ASSERT_EQ(size_t(3), ihDObjs[0]->m_simpleObjectsField.size());
// check single pointer field
std::vector<caf::PdmPointer<DemoPdmObject> > demoObjs;
pog.objectsByType(&demoObjs);
EXPECT_EQ(size_t(4), demoObjs.size() );
EXPECT_TRUE(demoObjs[0]->m_simpleObjPtrField == NULL );
EXPECT_TRUE(demoObjs[0]->m_simpleObjPtrField2 != NULL );
// check single pointer field
std::vector<caf::PdmPointer<SimpleObj> > simpleObjs;
pog.objectsByType(&simpleObjs);
EXPECT_EQ(size_t(1), simpleObjs.size() );
EXPECT_EQ(size_t(0), simpleObjs[0]->m_numbers().size());
}
}
//--------------------------------------------------------------------------------------------------
/// Tests the features of PdmPointer
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmPointer)
{
caf::PdmDocument * d = new caf::PdmDocument;
{
caf::PdmPointer<caf::PdmDocument> p;
EXPECT_TRUE(p == NULL);
}
{
caf::PdmPointer<caf::PdmDocument> p(d);
caf::PdmPointer<caf::PdmDocument> p2(p);
EXPECT_TRUE(p == d && p2 == d);
EXPECT_TRUE(p.p() == d);
p = 0;
EXPECT_TRUE(p == NULL);
EXPECT_TRUE(p.isNull());
EXPECT_TRUE(p2 == d);
p = p2;
EXPECT_TRUE(p == d );
delete d;
EXPECT_TRUE(p.isNull() && p2.isNull());
}
caf::PdmPointer<DemoPdmObject> p3(new DemoPdmObject());
delete p3;
}
//--------------------------------------------------------------------------------------------------
/// Tests the PdmFactory
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmObjectFactory)
{
{
SimpleObj* s = dynamic_cast<SimpleObj*> (caf::PdmDefaultObjectFactory::instance()->create("SimpleObj"));
EXPECT_TRUE(s != NULL);
}
{
DemoPdmObject* s = dynamic_cast<DemoPdmObject*> (caf::PdmDefaultObjectFactory::instance()->create("DemoPdmObject"));
EXPECT_TRUE(s != NULL);
delete s;
}
{
InheritedDemoObj* s = dynamic_cast<InheritedDemoObj*> (caf::PdmDefaultObjectFactory::instance()->create("InheritedDemoObj"));
EXPECT_TRUE(s != NULL);
}
{
caf::PdmDocument* s = dynamic_cast<caf::PdmDocument*> (caf::PdmDefaultObjectFactory::instance()->create("PdmDocument"));
EXPECT_TRUE(s != NULL);
}
{
caf::PdmObjectGroup* s = dynamic_cast<caf::PdmObjectGroup*> (caf::PdmDefaultObjectFactory::instance()->create("PdmObjectGroup"));
EXPECT_TRUE(s != NULL);
}
}
//--------------------------------------------------------------------------------------------------
/// Validate Xml keywords
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, ValidXmlKeywords)
{
EXPECT_TRUE(caf::PdmXmlObjectHandle::isValidXmlElementName("Valid_name"));
EXPECT_FALSE(caf::PdmXmlObjectHandle::isValidXmlElementName("2Valid_name"));
EXPECT_FALSE(caf::PdmXmlObjectHandle::isValidXmlElementName(".Valid_name"));
EXPECT_FALSE(caf::PdmXmlObjectHandle::isValidXmlElementName("xml_Valid_name"));
EXPECT_FALSE(caf::PdmXmlObjectHandle::isValidXmlElementName("Valid_name_with_space "));
}
TEST(BaseTest, PdmPointersFieldInsertVector)
{
InheritedDemoObj* ihd1 = new InheritedDemoObj;
SimpleObj* s1 = new SimpleObj;
SimpleObj* s2 = new SimpleObj;
SimpleObj* s3 = new SimpleObj;
caf::PdmObjectGroup pdmGroup;
pdmGroup.addObject(s1);
pdmGroup.addObject(s2);
pdmGroup.addObject(s3);
std::vector<caf::PdmPointer<SimpleObj> > typedObjects;
pdmGroup.objectsByType(&typedObjects);
EXPECT_EQ(size_t(3), typedObjects.size());
std::vector<caf::PdmPointer<SimpleObj> > objs;
objs.push_back(new SimpleObj);
objs.push_back(new SimpleObj);
objs.push_back(new SimpleObj);
ihd1->m_simpleObjectsField.insert(ihd1->m_simpleObjectsField.size(), objs);
EXPECT_EQ(size_t(3), ihd1->m_simpleObjectsField.size());
delete ihd1;
}
TEST(BaseTest, PdmObjectGroupCopyOfTypedObjects)
{
SimpleObj* s1 = new SimpleObj;
s1->m_position = 1000;
s1->m_numbers.v().push_back(10);
SimpleObj* s2 = new SimpleObj;
s2->m_position = 2000;
SimpleObj* s3 = new SimpleObj;
s3->m_position = 3000;
InheritedDemoObj* ihd1 = new InheritedDemoObj;
caf::PdmObjectGroup og;
og.objects.push_back(s1);
og.objects.push_back(s2);
og.objects.push_back(s3);
og.objects.push_back(ihd1);
std::vector<caf::PdmPointer<SimpleObj> > simpleObjList;
og.createCopyByType(&simpleObjList, caf::PdmDefaultObjectFactory::instance());
EXPECT_EQ(size_t(3), simpleObjList.size());
EXPECT_EQ(1000, simpleObjList[0]->m_position);
EXPECT_EQ(size_t(1), simpleObjList[0]->m_numbers.v().size());
EXPECT_EQ(10, simpleObjList[0]->m_numbers.v()[0]);
EXPECT_EQ(2000, simpleObjList[1]->m_position);
EXPECT_EQ(3000, simpleObjList[2]->m_position);
std::vector<caf::PdmPointer<InheritedDemoObj> > inheritObjList;
og.createCopyByType(&inheritObjList, caf::PdmDefaultObjectFactory::instance());
EXPECT_EQ(size_t(1), inheritObjList.size());
og.deleteObjects();
EXPECT_EQ(size_t(3), simpleObjList.size());
EXPECT_EQ(size_t(1), inheritObjList.size());
}
//--------------------------------------------------------------------------------------------------
/// PdmChildArrayFieldHandle
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmChildArrayFieldHandle)
{
// virtual size_t size() const = 0;
// virtual bool empty() const = 0;
// virtual void clear() = 0;
// virtual PdmObject* createAppendObject(int indexAfter) = 0;
// virtual void erase(size_t index) = 0;
// virtual void deleteAllChildObjects() = 0;
//
// virtual PdmObject* at(size_t index) = 0;
//
// bool hasSameFieldCountForAllObjects();
SimpleObj* s1 = new SimpleObj;
s1->m_position = 1000;
s1->m_numbers.v().push_back(10);
SimpleObj* s2 = new SimpleObj;
s2->m_position = 2000;
SimpleObj* s3 = new SimpleObj;
s3->m_position = 3000;
InheritedDemoObj* ihd1 = new InheritedDemoObj;
caf::PdmChildArrayFieldHandle* listField = &(ihd1->m_simpleObjectsField);
EXPECT_EQ(0, listField->size());
EXPECT_TRUE(listField->hasSameFieldCountForAllObjects());
EXPECT_TRUE(listField->empty());
ihd1->m_simpleObjectsField.push_back(new SimpleObj);
EXPECT_EQ(1, listField->size());
EXPECT_TRUE(listField->hasSameFieldCountForAllObjects());
EXPECT_FALSE(listField->empty());
ihd1->m_simpleObjectsField.push_back(s1);
ihd1->m_simpleObjectsField.push_back(s2);
ihd1->m_simpleObjectsField.push_back(s3);
EXPECT_EQ(4, listField->size());
EXPECT_TRUE(listField->hasSameFieldCountForAllObjects());
EXPECT_FALSE(listField->empty());
listField->erase(0);
EXPECT_EQ(3, listField->size());
EXPECT_TRUE(listField->hasSameFieldCountForAllObjects());
EXPECT_FALSE(listField->empty());
listField->deleteAllChildObjects();
EXPECT_EQ(0, listField->size());
EXPECT_TRUE(listField->hasSameFieldCountForAllObjects());
EXPECT_TRUE(listField->empty());
}
class ReferenceDemoPdmObject: public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
ReferenceDemoPdmObject()
{
CAF_PDM_InitObject("ReferenceDemoPdmObject", "", "Tooltip DemoPdmObject", "WhatsThis DemoPdmObject");
CAF_PDM_InitFieldNoDefault(&m_pointersField, "SimpleObjPtrField", "SimpleObjPtrField", "", "Tooltip", "WhatsThis");
CAF_PDM_InitFieldNoDefault(&m_simpleObjPtrField2, "SimpleObjPtrField2", "SimpleObjPtrField2", "", "Tooltip", "WhatsThis");
}
// Fields
caf::PdmChildField<PdmObjectHandle*> m_pointersField;
caf::PdmChildArrayField<SimpleObj*> m_simpleObjPtrField2;
};
CAF_PDM_SOURCE_INIT(ReferenceDemoPdmObject, "ReferenceDemoPdmObject");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(BaseTest, PdmReferenceHelper)
{
SimpleObj* s1 = new SimpleObj;
s1->m_position = 1000;
s1->m_numbers.v().push_back(10);
SimpleObj* s2 = new SimpleObj;
s2->m_position = 2000;
SimpleObj* s3 = new SimpleObj;
s3->m_position = 3000;
InheritedDemoObj* ihd1 = new InheritedDemoObj;
ihd1->m_simpleObjectsField.push_back(new SimpleObj);
ihd1->m_simpleObjectsField.push_back(s1);
ihd1->m_simpleObjectsField.push_back(s2);
ihd1->m_simpleObjectsField.push_back(s3);
{
QString refString = caf::PdmReferenceHelper::referenceFromRootToObject(NULL, s3);
EXPECT_TRUE(refString.isEmpty());
refString = caf::PdmReferenceHelper::referenceFromRootToObject(ihd1, s3);
QString expectedString = ihd1->m_simpleObjectsField.keyword() + " 3";
EXPECT_STREQ(refString.toLatin1(), expectedString.toLatin1());
caf::PdmObjectHandle* fromRef = caf::PdmReferenceHelper::objectFromReference(ihd1, refString);
EXPECT_TRUE(fromRef == s3);
}
ReferenceDemoPdmObject* objA = new ReferenceDemoPdmObject;
objA->m_pointersField = ihd1;
{
QString refString = caf::PdmReferenceHelper::referenceFromRootToObject(objA, s3);
caf::PdmObjectHandle* fromRef = caf::PdmReferenceHelper::objectFromReference(objA, refString);
EXPECT_TRUE(fromRef == s3);
}
// Test reference to field
{
QString refString = caf::PdmReferenceHelper::referenceFromRootToField(objA, &(ihd1->m_simpleObjectsField));
caf::PdmFieldHandle* fromRef = caf::PdmReferenceHelper::fieldFromReference(objA, refString);
EXPECT_TRUE(fromRef == &(ihd1->m_simpleObjectsField));
}
}
Reference in New Issue View Git Blame Copy Permalink