161 lines
4.7 KiB
C++
161 lines
4.7 KiB
C++
/*//////////////////////////////////////////////////////////////////////////////
|
|
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
|
|
All rights reserved
|
|
|
|
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
|
|
|
|
------------------------------------------------------------------
|
|
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 3.0 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 for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library.
|
|
|
|
//////////////////////////////////////////////////////////////////////////////*/
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string>
|
|
|
|
#include "Core/Object.h"
|
|
#include "Core/Property.h"
|
|
#include "Core/Archives.h"
|
|
#include "Core/Serializable.h"
|
|
#include "testing-prototype.h"
|
|
|
|
using namespace uLib;
|
|
|
|
/**
|
|
* @brief A test class to demonstrate property registration via SERIALIZE_OBJECT.
|
|
*/
|
|
class TestObject : public Object {
|
|
public:
|
|
uLibTypeMacro(TestObject, Object)
|
|
|
|
TestObject() : m_Value(10.5f), m_Status("Initialized"), m_Counter(0) {}
|
|
|
|
float m_Value;
|
|
std::string m_Status;
|
|
int m_Counter;
|
|
|
|
// Static properties (registered in constructor/initializer)
|
|
ULIB_PROPERTY(int, StaticProp, 42)
|
|
|
|
ULIB_SERIALIZE_ACCESS
|
|
|
|
template <typename Ar>
|
|
void serialize(Ar& ar, unsigned int version) {
|
|
ar & HRP("value", m_Value, "mm").range(0, 100).set_default(1.);
|
|
ar & HRP("status", m_Status);
|
|
ar & HRP("counter", m_Counter);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
class TestObject2 : public TestObject {
|
|
public:
|
|
uLibTypeMacro(TestObject2, TestObject)
|
|
|
|
TestObject2() : TestObject(), m_Value2(20.5f) {}
|
|
|
|
float m_Value2;
|
|
|
|
ULIB_SERIALIZE_ACCESS
|
|
};
|
|
|
|
ULIB_SERIALIZABLE_OBJECT(TestObject2)
|
|
ULIB_SERIALIZE_OBJECT(TestObject2, TestObject) {
|
|
std::cout << "Serializing TestObject2" << std::endl;
|
|
// ar & boost::serialization::make_hrp("value2", ob.m_Value2, "mm").set_default(1.);
|
|
ar & HRP("value2", ob.m_Value2, "mm").set_default(1.);
|
|
}
|
|
|
|
|
|
int main() {
|
|
BEGIN_TESTING(Properties Serialization)
|
|
|
|
TestObject obj;
|
|
|
|
// 1. Initial state: check static property
|
|
ASSERT_EQUAL(obj.StaticProp, 42);
|
|
|
|
// 2. Activate dynamic properties via the property_register_archive
|
|
// This calls the serialize method with a special archive that populates m_DynamicProperties
|
|
ULIB_ACTIVATE_PROPERTIES(obj);
|
|
|
|
const auto& props = obj.GetProperties();
|
|
// This is problematic because GetProperties currently returns d->m_Properties (only static)
|
|
|
|
// For now, let's just assert on the dynamic property presence if possible
|
|
PropertyBase* pVal = obj.GetProperty("value");
|
|
ASSERT_NOT_NULL(pVal);
|
|
ASSERT_EQUAL(pVal->GetValueAsString(), "10.5");
|
|
ASSERT_EQUAL(pVal->GetUnits(), "mm");
|
|
|
|
// Check other dynamic properties
|
|
ASSERT_NOT_NULL(obj.GetProperty("status"));
|
|
ASSERT_NOT_NULL(obj.GetProperty("counter"));
|
|
|
|
// 4. Serialization round-trip (XML)
|
|
{
|
|
std::ofstream ofs("test_props.xml");
|
|
Archive::xml_oarchive(ofs) << NVP("test_obj", obj);
|
|
}
|
|
|
|
TestObject obj2;
|
|
obj2.m_Value = 0;
|
|
obj2.m_Status = "";
|
|
{
|
|
std::ifstream ifs("test_props.xml");
|
|
Archive::xml_iarchive(ifs) >> NVP("test_obj", obj2);
|
|
}
|
|
|
|
ASSERT_EQUAL(obj2.m_Value, 10.5f);
|
|
ASSERT_EQUAL(obj2.m_Status, "Initialized");
|
|
|
|
TestObject2 obj3;
|
|
obj3.m_Value = 12.5;
|
|
obj3.m_Status = "Initialized";
|
|
obj3.m_Value2 = 22.5;
|
|
|
|
ULIB_ACTIVATE_PROPERTIES(obj3);
|
|
|
|
PropertyBase* pVal3 = obj3.GetProperty("value2");
|
|
ASSERT_NOT_NULL(pVal3);
|
|
ASSERT_EQUAL(pVal3->GetValueAsString(), "22.5");
|
|
ASSERT_EQUAL(pVal3->GetUnits(), "mm");
|
|
|
|
// 5. Serialization round-trip (XML)
|
|
{
|
|
std::ofstream ofs("test_props2.xml");
|
|
Archive::xml_oarchive(ofs) << NVP("test_obj2", obj3);
|
|
}
|
|
|
|
TestObject2 obj4;
|
|
obj4.m_Value = 0;
|
|
obj4.m_Status = "";
|
|
obj4.m_Value2 = 0;
|
|
ULIB_ACTIVATE_PROPERTIES(obj4);
|
|
{
|
|
std::ifstream ifs("test_props2.xml");
|
|
Archive::xml_iarchive(ifs) >> NVP("test_obj2", obj4);
|
|
}
|
|
ASSERT_EQUAL(obj4.m_Value, 12.5f);
|
|
ASSERT_EQUAL(obj4.m_Status, "Initialized");
|
|
ASSERT_EQUAL(obj4.m_Value2, 22.5f);
|
|
|
|
|
|
END_TESTING
|
|
}
|