mirror of
https://github.com/OPM/ResInsight.git
synced 2026-10-25 14:40:26 -05:00
Magne Sjaastad
9851afc621
Proxy fields usually reads and transforms data from other sources, usually other Pdm fields. This commit disables IO for proxy fields in the constructor. If XML serialization is required, this must be set on the proxy field, like this field.xmlCapability()->setIOWritable(true) field.xmlCapability()->setIOReadable(true)
609 lines
21 KiB
C++
609 lines
21 KiB
C++
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "cafAppEnum.h"
|
|
|
|
#include "cafPdmChildArrayField.h"
|
|
#include "cafPdmChildField.h"
|
|
#include "cafPdmDataValueField.h"
|
|
#include "cafPdmObjectHandle.h"
|
|
#include "cafPdmProxyValueField.h"
|
|
#include "cafPdmPtrField.h"
|
|
#include "cafPdmReferenceHelper.h"
|
|
#include "cafPdmXmlObjectHandle.h"
|
|
#include "cafPdmXmlObjectHandleMacros.h"
|
|
|
|
#include <QStringList>
|
|
#include <QXmlStreamWriter>
|
|
|
|
#include <memory>
|
|
|
|
class DemoPdmObject : public caf::PdmObjectHandle, public caf::PdmXmlObjectHandle
|
|
{
|
|
CAF_PDM_XML_HEADER_INIT;
|
|
|
|
public:
|
|
enum TestEnumType
|
|
{
|
|
T1,
|
|
T2,
|
|
T3
|
|
};
|
|
|
|
DemoPdmObject()
|
|
: PdmObjectHandle()
|
|
, PdmXmlObjectHandle( this, false )
|
|
{
|
|
CAF_PDM_XML_InitField( &m_proxyDoubleField, "BigNumber" );
|
|
m_proxyDoubleField.registerSetMethod( this, &DemoPdmObject::setDoubleMember );
|
|
m_proxyDoubleField.registerGetMethod( this, &DemoPdmObject::doubleMember );
|
|
m_proxyDoubleField.xmlCapability()->setIOWritable( true );
|
|
m_proxyDoubleField.xmlCapability()->setIOReadable( true );
|
|
|
|
CAF_PDM_XML_InitField( &m_proxyEnumField, "AppEnum" );
|
|
m_proxyEnumField.registerSetMethod( this, &DemoPdmObject::setEnumMember );
|
|
m_proxyEnumField.registerGetMethod( this, &DemoPdmObject::enumMember );
|
|
m_enumMember = T1;
|
|
|
|
CAF_PDM_XML_InitField( &m_appEnumField, "NativeAppEnum" );
|
|
}
|
|
|
|
~DemoPdmObject() {}
|
|
|
|
// Fields
|
|
|
|
caf::PdmProxyValueField<double> m_proxyDoubleField;
|
|
caf::PdmProxyValueField<caf::AppEnum<TestEnumType>> m_proxyEnumField;
|
|
caf::PdmDataValueField<caf::AppEnum<TestEnumType>> m_appEnumField;
|
|
|
|
private:
|
|
void setDoubleMember( const double& d )
|
|
{
|
|
m_doubleMember = d;
|
|
std::cout << "setDoubleMember" << std::endl;
|
|
}
|
|
double doubleMember() const
|
|
{
|
|
std::cout << "doubleMember" << std::endl;
|
|
return m_doubleMember;
|
|
}
|
|
|
|
void setEnumMember( const caf::AppEnum<TestEnumType>& val ) { m_enumMember = val; }
|
|
caf::AppEnum<TestEnumType> enumMember() const { return m_enumMember; }
|
|
|
|
double m_doubleMember;
|
|
TestEnumType m_enumMember;
|
|
};
|
|
|
|
CAF_PDM_XML_SOURCE_INIT( DemoPdmObject, "DemoPdmObject" );
|
|
|
|
namespace caf
|
|
{
|
|
template <>
|
|
void AppEnum<DemoPdmObject::TestEnumType>::setUp()
|
|
{
|
|
addItem( DemoPdmObject::T1, "T1", "An A letter" );
|
|
addItem( DemoPdmObject::T2, "T2", "A B letter", QStringList( { "T2_a", "T2_b" } ) );
|
|
addItem( DemoPdmObject::T3, "T3", "A B letter" );
|
|
|
|
// Use the following line to test the CAF_ASSERT that should trigger when equal alias texts are defined
|
|
// addItem( DemoPdmObject::T3, "T3", "A B letter", QStringList( { "T2_a", "T2_b" } ) );
|
|
|
|
setDefault( DemoPdmObject::T1 );
|
|
}
|
|
|
|
} // namespace caf
|
|
|
|
TEST( BaseTest, Delete )
|
|
{
|
|
DemoPdmObject* s2 = new DemoPdmObject;
|
|
delete s2;
|
|
}
|
|
|
|
#if 0
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Read/write Xml using PdmObjectGroup
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST(BaseTest, Start)
|
|
{
|
|
QString serializedString;
|
|
{
|
|
DemoPdmObject* a = new DemoPdmObject;
|
|
|
|
a->m_proxyDoubleField.setValue(2.5);
|
|
a->m_proxyEnumField.setValue(DemoPdmObject::T3);
|
|
|
|
ASSERT_DOUBLE_EQ(2.5, a->m_proxyDoubleField.value());
|
|
|
|
caf::PdmObjectGroup objGroup;
|
|
objGroup.addObject(a);
|
|
|
|
QXmlStreamWriter xmlStream(&serializedString);
|
|
xmlStream.setAutoFormatting(true);
|
|
objGroup.writeFields(xmlStream, NULL);
|
|
|
|
std::cout << serializedString.toStdString() << std::endl;
|
|
|
|
delete a;
|
|
}
|
|
|
|
/*
|
|
<PdmObjects>
|
|
<DemoPdmObject>
|
|
<BigNumber>2.5</BigNumber>
|
|
<TestEnumValue>T3</TestEnumValue>
|
|
</DemoPdmObject>
|
|
</PdmObjects>
|
|
*/
|
|
|
|
{
|
|
caf::PdmObjectGroup destinationObjectGroup;
|
|
QXmlStreamReader xmlStream(serializedString);
|
|
destinationObjectGroup.readFields(xmlStream, caf::PdmDefaultObjectFactory::instance(), NULL);
|
|
|
|
DemoPdmObject* a = dynamic_cast<DemoPdmObject*>(destinationObjectGroup.objects[0]);
|
|
|
|
ASSERT_DOUBLE_EQ(2.5, a->m_proxyDoubleField.value());
|
|
ASSERT_EQ(DemoPdmObject::T3, a->m_proxyEnumField());
|
|
|
|
}
|
|
}
|
|
#endif
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Read/write fields to a valid Xml document encoded in a QString
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, FieldWrite )
|
|
{
|
|
QString serializedString;
|
|
{
|
|
DemoPdmObject* a = new DemoPdmObject;
|
|
|
|
a->m_proxyDoubleField.setValue( 2.5 );
|
|
ASSERT_DOUBLE_EQ( 2.5, a->m_proxyDoubleField.value() );
|
|
|
|
serializedString = a->writeObjectToXmlString();
|
|
|
|
std::cout << serializedString.toStdString() << std::endl;
|
|
|
|
delete a;
|
|
}
|
|
|
|
/*
|
|
<DemoPdmObject>
|
|
<BigNumber>2.5</BigNumber>
|
|
<TestEnumValue>T3</TestEnumValue>
|
|
</DemoPdmObject>
|
|
*/
|
|
|
|
{
|
|
DemoPdmObject* a = new DemoPdmObject;
|
|
|
|
a->readObjectFromXmlString( serializedString, caf::PdmDefaultObjectFactory::instance() );
|
|
}
|
|
}
|
|
|
|
class InheritedDemoObj : public DemoPdmObject
|
|
{
|
|
CAF_PDM_XML_HEADER_INIT;
|
|
|
|
public:
|
|
InheritedDemoObj()
|
|
{
|
|
CAF_PDM_XML_InitField( &m_texts, "Texts" );
|
|
CAF_PDM_XML_InitField( &m_childArrayField, "DemoPdmObjectects" );
|
|
}
|
|
|
|
caf::PdmDataValueField<QString> m_texts;
|
|
caf::PdmChildArrayField<DemoPdmObject*> m_childArrayField;
|
|
};
|
|
CAF_PDM_XML_SOURCE_INIT( InheritedDemoObj, "InheritedDemoObj" );
|
|
|
|
class SimpleObj : public caf::PdmObjectHandle, public caf::PdmXmlObjectHandle
|
|
{
|
|
CAF_PDM_XML_HEADER_INIT;
|
|
|
|
public:
|
|
SimpleObj()
|
|
: PdmObjectHandle()
|
|
, PdmXmlObjectHandle( this, false )
|
|
, m_doubleMember( 0.0 )
|
|
{
|
|
CAF_PDM_XML_InitField( &m_position, "Position" );
|
|
CAF_PDM_XML_InitField( &m_dir, "Dir" );
|
|
CAF_PDM_XML_InitField( &m_up, "Up" );
|
|
|
|
CAF_PDM_XML_InitField( &m_singleFilePath, "m_singleFilePath" );
|
|
CAF_PDM_XML_InitField( &m_multipleFilePath, "m_multipleFilePath" );
|
|
|
|
CAF_PDM_XML_InitField( &m_proxyDouble, "m_proxyDouble" );
|
|
m_proxyDouble.registerSetMethod( this, &SimpleObj::setDoubleMember );
|
|
m_proxyDouble.registerGetMethod( this, &SimpleObj::doubleMember );
|
|
}
|
|
|
|
caf::PdmDataValueField<double> m_position;
|
|
caf::PdmDataValueField<double> m_dir;
|
|
caf::PdmDataValueField<int> m_up;
|
|
caf::PdmProxyValueField<double> m_proxyDouble;
|
|
|
|
caf::PdmDataValueField<caf::FilePath> m_singleFilePath;
|
|
caf::PdmDataValueField<std::vector<caf::FilePath>> m_multipleFilePath;
|
|
|
|
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_XML_SOURCE_INIT( SimpleObj, "SimpleObj" );
|
|
|
|
class ReferenceDemoPdmObject : public caf::PdmObjectHandle, public caf::PdmXmlObjectHandle
|
|
{
|
|
CAF_PDM_XML_HEADER_INIT;
|
|
|
|
public:
|
|
ReferenceDemoPdmObject()
|
|
: PdmObjectHandle()
|
|
, PdmXmlObjectHandle( this, false )
|
|
{
|
|
CAF_PDM_XML_InitField( &m_pointersField, "SimpleObjPtrField" );
|
|
CAF_PDM_XML_InitField( &m_simpleObjPtrField2, "SimpleObjPtrField2" );
|
|
}
|
|
|
|
~ReferenceDemoPdmObject() { delete m_pointersField(); }
|
|
|
|
// Fields
|
|
caf::PdmChildField<PdmObjectHandle*> m_pointersField;
|
|
caf::PdmChildArrayField<SimpleObj*> m_simpleObjPtrField2;
|
|
};
|
|
|
|
CAF_PDM_XML_SOURCE_INIT( ReferenceDemoPdmObject, "ReferenceDemoPdmObject" );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, PdmReferenceHelper )
|
|
{
|
|
DemoPdmObject* s1 = new DemoPdmObject;
|
|
DemoPdmObject* s2 = new DemoPdmObject;
|
|
DemoPdmObject* s3 = new DemoPdmObject;
|
|
|
|
InheritedDemoObj* ihd1 = new InheritedDemoObj;
|
|
ihd1->m_childArrayField.push_back( new DemoPdmObject );
|
|
|
|
ihd1->m_childArrayField.push_back( s1 );
|
|
ihd1->m_childArrayField.push_back( s2 );
|
|
ihd1->m_childArrayField.push_back( s3 );
|
|
|
|
{
|
|
QString refString = caf::PdmReferenceHelper::referenceFromRootToObject( ihd1, s3 );
|
|
QString expectedString = ihd1->m_childArrayField.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_childArrayField ) );
|
|
|
|
caf::PdmFieldHandle* fromRef = caf::PdmReferenceHelper::fieldFromReference( objA, refString );
|
|
EXPECT_TRUE( fromRef == &( ihd1->m_childArrayField ) );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, ChildArrayFieldSerializing )
|
|
{
|
|
DemoPdmObject* s1 = new DemoPdmObject;
|
|
s1->m_proxyDoubleField.setValue( 10 );
|
|
|
|
DemoPdmObject* s2 = new DemoPdmObject;
|
|
s2->m_proxyDoubleField.setValue( 20 );
|
|
|
|
DemoPdmObject* s3 = new DemoPdmObject;
|
|
s3->m_proxyDoubleField.setValue( 30 );
|
|
|
|
InheritedDemoObj* ihd1 = new InheritedDemoObj;
|
|
ihd1->m_childArrayField.push_back( s1 );
|
|
ihd1->m_childArrayField.push_back( s2 );
|
|
ihd1->m_childArrayField.push_back( s3 );
|
|
|
|
QString serializedString;
|
|
{
|
|
serializedString = ihd1->writeObjectToXmlString();
|
|
|
|
std::cout << serializedString.toStdString() << std::endl;
|
|
|
|
delete ihd1;
|
|
}
|
|
|
|
{
|
|
InheritedDemoObj* ihd1 = new InheritedDemoObj;
|
|
ASSERT_EQ( 0u, ihd1->m_childArrayField.size() );
|
|
|
|
QXmlStreamReader xmlStream( serializedString );
|
|
|
|
ihd1->readObjectFromXmlString( serializedString, caf::PdmDefaultObjectFactory::instance() );
|
|
|
|
ASSERT_DOUBLE_EQ( 10, ihd1->m_childArrayField[0]->m_proxyDoubleField.value() );
|
|
ASSERT_DOUBLE_EQ( 20, ihd1->m_childArrayField[1]->m_proxyDoubleField.value() );
|
|
ASSERT_DOUBLE_EQ( 30, ihd1->m_childArrayField[2]->m_proxyDoubleField.value() );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Testing that the QXmlStreamReader actually can not just read a list of fields.
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, QXMLStreamTest )
|
|
{
|
|
QString xmlText =
|
|
//"<DemoPdmObject>"
|
|
"<BigNumber>2.5</BigNumber>"
|
|
"<TestEnumValue>T3</TestEnumValue>"
|
|
"<TestEnumValue2>T3</TestEnumValue2>"
|
|
//"</DemoPdmObject>"
|
|
;
|
|
|
|
QXmlStreamReader inputStream( xmlText );
|
|
|
|
QXmlStreamReader::TokenType tt;
|
|
while ( !inputStream.atEnd() )
|
|
{
|
|
tt = inputStream.readNext();
|
|
std::cout << inputStream.name().toString().toStdString() << std::endl;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, FilePathSerializing )
|
|
{
|
|
SimpleObj* s1 = new SimpleObj;
|
|
|
|
QString newVal = "path with space";
|
|
s1->m_multipleFilePath.v().push_back( newVal );
|
|
s1->m_multipleFilePath.v().push_back( newVal );
|
|
|
|
s1->m_singleFilePath = newVal;
|
|
|
|
QString serializedString = s1->writeObjectToXmlString();
|
|
|
|
{
|
|
SimpleObj* ihd1 = new SimpleObj;
|
|
|
|
QXmlStreamReader xmlStream( serializedString );
|
|
|
|
ihd1->readObjectFromXmlString( serializedString, caf::PdmDefaultObjectFactory::instance() );
|
|
|
|
EXPECT_EQ( 2u, ihd1->m_multipleFilePath.v().size() );
|
|
EXPECT_EQ( newVal.toStdString(), ihd1->m_singleFilePath().path().toStdString() );
|
|
|
|
delete ihd1;
|
|
}
|
|
|
|
delete s1;
|
|
}
|
|
|
|
// Type deduction is different on other platforms than Windows
|
|
#ifdef WIN32
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, TestDataType )
|
|
{
|
|
SimpleObj* s1 = new SimpleObj;
|
|
|
|
{
|
|
auto dataTypeNameDouble = s1->m_position.xmlCapability()->dataTypeName();
|
|
EXPECT_EQ( "double", dataTypeNameDouble.toStdString() );
|
|
}
|
|
|
|
{
|
|
auto dataTypeNameDouble = s1->m_proxyDouble.xmlCapability()->dataTypeName();
|
|
EXPECT_EQ( "double", dataTypeNameDouble.toStdString() );
|
|
}
|
|
|
|
{
|
|
auto dataTypeNameDouble = s1->m_up.xmlCapability()->dataTypeName();
|
|
EXPECT_EQ( "int", dataTypeNameDouble.toStdString() );
|
|
}
|
|
|
|
{
|
|
auto dataTypeNameDouble = s1->m_singleFilePath.xmlCapability()->dataTypeName();
|
|
EXPECT_EQ( "class caf::FilePath", dataTypeNameDouble.toStdString() );
|
|
}
|
|
|
|
{
|
|
InheritedDemoObj* obj = new InheritedDemoObj;
|
|
auto dataTypeNameDouble = obj->m_texts.xmlCapability()->dataTypeName();
|
|
EXPECT_EQ( "class QString", dataTypeNameDouble.toStdString() );
|
|
}
|
|
|
|
delete s1;
|
|
}
|
|
#endif
|
|
|
|
TEST( BaseTest, AppEnumAlias )
|
|
{
|
|
{
|
|
auto* obj2 = new DemoPdmObject;
|
|
EXPECT_TRUE( obj2->m_appEnumField() == DemoPdmObject::TestEnumType::T1 );
|
|
|
|
QString xmlText = "<DemoPdmObject>"
|
|
"<BigNumber>0</BigNumber>"
|
|
"<AppEnum>T2</AppEnum>"
|
|
"<NativeAppEnum>T2_a</NativeAppEnum>"
|
|
"</DemoPdmObject>";
|
|
|
|
obj2->readObjectFromXmlString( xmlText, caf::PdmDefaultObjectFactory::instance() );
|
|
EXPECT_TRUE( obj2->m_appEnumField() == DemoPdmObject::TestEnumType::T2 );
|
|
}
|
|
|
|
{
|
|
auto* obj2 = new DemoPdmObject;
|
|
EXPECT_TRUE( obj2->m_appEnumField() == DemoPdmObject::TestEnumType::T1 );
|
|
|
|
QString xmlText = "<DemoPdmObject>"
|
|
"<BigNumber>0</BigNumber>"
|
|
"<AppEnum>T2</AppEnum>"
|
|
"<NativeAppEnum>T2_b</NativeAppEnum>"
|
|
"</DemoPdmObject>";
|
|
|
|
obj2->readObjectFromXmlString( xmlText, caf::PdmDefaultObjectFactory::instance() );
|
|
EXPECT_TRUE( obj2->m_appEnumField() == DemoPdmObject::TestEnumType::T2 );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Test object with clamped fields
|
|
//--------------------------------------------------------------------------------------------------
|
|
class ClampedFieldObject : public caf::PdmObjectHandle, public caf::PdmXmlObjectHandle
|
|
{
|
|
CAF_PDM_XML_HEADER_INIT;
|
|
|
|
public:
|
|
ClampedFieldObject()
|
|
: PdmObjectHandle()
|
|
, PdmXmlObjectHandle( this, false )
|
|
{
|
|
CAF_PDM_XML_InitField( &m_temperature, "Temperature" );
|
|
m_temperature.setRange( -273.15, 1000.0 );
|
|
|
|
CAF_PDM_XML_InitField( &m_age, "Age" );
|
|
m_age.setRange( 0, 150 );
|
|
|
|
CAF_PDM_XML_InitField( &m_percentage, "Percentage" );
|
|
m_percentage.setRange( 0.0, 100.0 );
|
|
|
|
CAF_PDM_XML_InitField( &m_minOnlyField, "MinOnlyField" );
|
|
m_minOnlyField.setMinValue( 0.0 );
|
|
|
|
CAF_PDM_XML_InitField( &m_maxOnlyField, "MaxOnlyField" );
|
|
m_maxOnlyField.setMaxValue( 100 );
|
|
|
|
CAF_PDM_XML_InitField( &m_unclampedField, "UnclampedField" );
|
|
}
|
|
|
|
caf::PdmDataValueField<double> m_temperature;
|
|
caf::PdmDataValueField<int> m_age;
|
|
caf::PdmDataValueField<double> m_percentage;
|
|
caf::PdmDataValueField<double> m_minOnlyField;
|
|
caf::PdmDataValueField<int> m_maxOnlyField;
|
|
caf::PdmDataValueField<double> m_unclampedField;
|
|
};
|
|
|
|
CAF_PDM_XML_SOURCE_INIT( ClampedFieldObject, "ClampedFieldObject" );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Test that values from XML are clamped to valid ranges
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, XmlImportClamping )
|
|
{
|
|
// Test clamping of values that exceed maximum
|
|
{
|
|
auto obj = std::make_unique<ClampedFieldObject>();
|
|
|
|
QString xmlText = "<ClampedFieldObject>"
|
|
"<Temperature>5000.0</Temperature>"
|
|
"<Age>200</Age>"
|
|
"<Percentage>150.0</Percentage>"
|
|
"<MinOnlyField>50.0</MinOnlyField>"
|
|
"<MaxOnlyField>50</MaxOnlyField>"
|
|
"<UnclampedField>9999.0</UnclampedField>"
|
|
"</ClampedFieldObject>";
|
|
|
|
obj->readObjectFromXmlString( xmlText, caf::PdmDefaultObjectFactory::instance() );
|
|
|
|
EXPECT_DOUBLE_EQ( 1000.0, obj->m_temperature() ); // Clamped to max
|
|
EXPECT_EQ( 150, obj->m_age() ); // Clamped to max
|
|
EXPECT_DOUBLE_EQ( 100.0, obj->m_percentage() ); // Clamped to max
|
|
EXPECT_DOUBLE_EQ( 50.0, obj->m_minOnlyField() ); // Within range
|
|
EXPECT_EQ( 50, obj->m_maxOnlyField() ); // Within range
|
|
EXPECT_DOUBLE_EQ( 9999.0, obj->m_unclampedField() ); // No clamping
|
|
}
|
|
|
|
// Test clamping of values that are below minimum
|
|
{
|
|
auto obj = std::make_unique<ClampedFieldObject>();
|
|
|
|
QString xmlText = "<ClampedFieldObject>"
|
|
"<Temperature>-500.0</Temperature>"
|
|
"<Age>-10</Age>"
|
|
"<Percentage>-50.0</Percentage>"
|
|
"<MinOnlyField>-100.0</MinOnlyField>"
|
|
"<MaxOnlyField>200</MaxOnlyField>"
|
|
"<UnclampedField>-9999.0</UnclampedField>"
|
|
"</ClampedFieldObject>";
|
|
|
|
obj->readObjectFromXmlString( xmlText, caf::PdmDefaultObjectFactory::instance() );
|
|
|
|
EXPECT_DOUBLE_EQ( -273.15, obj->m_temperature() ); // Clamped to min
|
|
EXPECT_EQ( 0, obj->m_age() ); // Clamped to min
|
|
EXPECT_DOUBLE_EQ( 0.0, obj->m_percentage() ); // Clamped to min
|
|
EXPECT_DOUBLE_EQ( 0.0, obj->m_minOnlyField() ); // Clamped to min
|
|
EXPECT_EQ( 100, obj->m_maxOnlyField() ); // Clamped to max
|
|
EXPECT_DOUBLE_EQ( -9999.0, obj->m_unclampedField() ); // No clamping
|
|
}
|
|
|
|
// Test that values within range are not modified
|
|
{
|
|
auto obj = std::make_unique<ClampedFieldObject>();
|
|
|
|
QString xmlText = "<ClampedFieldObject>"
|
|
"<Temperature>25.5</Temperature>"
|
|
"<Age>42</Age>"
|
|
"<Percentage>67.3</Percentage>"
|
|
"<MinOnlyField>123.45</MinOnlyField>"
|
|
"<MaxOnlyField>75</MaxOnlyField>"
|
|
"<UnclampedField>-123.456</UnclampedField>"
|
|
"</ClampedFieldObject>";
|
|
|
|
obj->readObjectFromXmlString( xmlText, caf::PdmDefaultObjectFactory::instance() );
|
|
|
|
EXPECT_DOUBLE_EQ( 25.5, obj->m_temperature() );
|
|
EXPECT_EQ( 42, obj->m_age() );
|
|
EXPECT_DOUBLE_EQ( 67.3, obj->m_percentage() );
|
|
EXPECT_DOUBLE_EQ( 123.45, obj->m_minOnlyField() );
|
|
EXPECT_EQ( 75, obj->m_maxOnlyField() );
|
|
EXPECT_DOUBLE_EQ( -123.456, obj->m_unclampedField() );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Test that proxy fields have IO disabled by default
|
|
//--------------------------------------------------------------------------------------------------
|
|
TEST( BaseTest, ProxyFieldIODisabled )
|
|
{
|
|
// Test with SimpleObj which has default proxy field IO behavior (disabled)
|
|
auto simpleObj = std::make_unique<SimpleObj>();
|
|
EXPECT_FALSE( simpleObj->m_proxyDouble.xmlCapability()->isIOReadable() );
|
|
EXPECT_FALSE( simpleObj->m_proxyDouble.xmlCapability()->isIOWritable() );
|
|
|
|
// Regular fields should still have IO enabled
|
|
EXPECT_TRUE( simpleObj->m_position.xmlCapability()->isIOReadable() );
|
|
EXPECT_TRUE( simpleObj->m_position.xmlCapability()->isIOWritable() );
|
|
|
|
// Note: DemoPdmObject explicitly enables IO for its proxy field for the ChildArrayFieldSerializing test
|
|
}
|