mirror of
https://github.com/OPM/ResInsight.git
synced 2026-10-26 07:00:17 -05:00
590 lines
20 KiB
C++
590 lines
20 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 );
|
|
|
|
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() );
|
|
}
|
|
}
|