OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

andrea-dev #1

Merged
andrea merged 19 commits from andrea-dev into main 2026-03-06 17:17:52 +01:00
Conversation 1 Commits 19 Files Changed 135 +830 -1056
24 changed files with 830 additions and 1056 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit d56758d0b3 - Show all commits

2
CMake/uLibTargetMacros.cmake
View File

@@ -82,7 +82,7 @@ ENDMACRO(uLib_add_target)
# TESTS and LIBRARIES must be defined # TESTS and LIBRARIES must be defined
macro(uLib_add_tests name) macro(uLib_add_tests name)
foreach(tn ${TESTS}) foreach(tn ${TESTS})
add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp) add_executable(${tn} ${tn}.cpp)
add_test(NAME ${tn} COMMAND ${tn}) add_test(NAME ${tn} COMMAND ${tn})
target_link_libraries(${tn} ${LIBRARIES}) target_link_libraries(${tn} ${LIBRARIES})

3
CMakeLists.txt
View File

@@ -76,6 +76,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
# CTEST framework # CTEST framework
include(CTest)
enable_testing() enable_testing()
@@ -85,7 +86,7 @@ set(Boost_USE_STATIC_LIBS OFF)
set(Boost_USE_MULTITHREADED ON) set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_STATIC_RUNTIME OFF) set(Boost_USE_STATIC_RUNTIME OFF)
message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}") message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED) find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
include_directories(${Boost_INCLUDE_DIRS}) include_directories(${Boost_INCLUDE_DIRS})
find_package(Eigen3 CONFIG REQUIRED) find_package(Eigen3 CONFIG REQUIRED)

861
src/Core/Archives.h
View File

File diff suppressed because it is too large Load Diff

13
src/Core/CMakeLists.txt
View File

@@ -1,10 +1,9 @@
set(HEADERS Options.h set(HEADERS Archives.h Array.h Collection.h Debug.h Export.h Function.h Macros.h Mpl.h Object.h Options.h Serializable.h Signal.h Singleton.h SmartPointer.h StaticInterface.h StringReader.h Types.h Uuid.h Vector.h)
StaticInterface.h)
set(SOURCES Options.cpp) set(SOURCES Archives.cpp Debug.cpp Object.cpp Options.cpp Serializable.cpp Signal.cpp Uuid.cpp)
set(LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY}) set(LIBRARIES Boost::program_options)
set(libname ${PACKAGE_LIBPREFIX}Core) set(libname ${PACKAGE_LIBPREFIX}Core)
set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE) set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -23,5 +22,7 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core) install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

96
src/Core/Export.h
View File

@@ -23,95 +23,85 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_EXPORT_H #ifndef U_CORE_EXPORT_H
#define U_CORE_EXPORT_H #define U_CORE_EXPORT_H
#include <utility>
#include <cstddef> // NULL #include <cstddef> // NULL
#include <iostream> #include <iostream>
#include <utility>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/preprocessor/stringize.hpp> #include <boost/preprocessor/stringize.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_polymorphic.hpp> #include <boost/type_traits/is_polymorphic.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/and.hpp> #include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp> #include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp> #include <boost/mpl/bool.hpp>
#include <boost/mpl/not.hpp>
#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
#include <boost/serialization/static_warning.hpp>
#include <boost/serialization/assume_abstract.hpp> #include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
#include <boost/serialization/force_include.hpp> #include <boost/serialization/force_include.hpp>
#include <boost/serialization/singleton.hpp> #include <boost/serialization/singleton.hpp>
#include <boost/serialization/static_warning.hpp>
#include <boost/archive/detail/register_archive.hpp> #include <boost/archive/detail/register_archive.hpp>
#include "Core/Archives.h" #include "Core/Archives.h"
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
namespace uLib { namespace uLib {
namespace Archive { namespace Archive {
namespace detail { namespace detail {
namespace extra_detail { namespace extra_detail {
template<class T> template <class T> struct guid_initializer {
struct guid_initializer void export_guid(boost::mpl::false_) const {
{ // generates the statically-initialized objects whose constructors
void export_guid(mpl::false_) const { // register the information allowing serialization of T objects
// generates the statically-initialized objects whose constructors // through pointers to their base classes.
// register the information allowing serialization of T objects boost::archive::detail::instantiate_ptr_serialization(
// through pointers to their base classes. (T *)0, 0, uLib::Archive::detail::adl_tag());
boost::archive::detail:: }
instantiate_ptr_serialization((T*)0, 0, void export_guid(boost::mpl::true_) const {}
uLib::Archive::detail::adl_tag()); guid_initializer const &export_guid() const {
} BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
void export_guid(mpl::true_) const { // note: exporting an abstract base class will have no effect
} // and cannot be used to instantitiate serialization code
guid_initializer const & export_guid() const { // (one might be using this in a DLL to instantiate code)
BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value); // BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
// note: exporting an abstract base class will have no effect export_guid(boost::serialization::is_abstract<T>());
// and cannot be used to instantitiate serialization code return *this;
// (one might be using this in a DLL to instantiate code) }
//BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
export_guid(boost::serialization::is_abstract< T >());
return *this;
}
}; };
template<typename T> template <typename T> struct init_guid;
struct init_guid;
} // anonymous } // namespace extra_detail
} // namespace detail } // namespace detail
} // namespace Archive } // namespace Archive
} // namespace uLib } // namespace uLib
#define ULIB_CLASS_EXPORT_IMPLEMENT(T) \
namespace uLib { \
#define ULIB_CLASS_EXPORT_IMPLEMENT(T) \ namespace Archive { \
namespace uLib { \ namespace detail { \
namespace Archive { \ namespace extra_detail { \
namespace detail { \ template <> struct init_guid<T> { \
namespace extra_detail { \ static guid_initializer<T> const &g; \
template<> \ }; \
struct init_guid< T > { \ guid_initializer<T> const &init_guid<T>::g = \
static guid_initializer< T > const & g; \ ::boost::serialization::singleton< \
}; \ guid_initializer<T>>::get_mutable_instance() \
guid_initializer< T > const & init_guid< T >::g = \ .export_guid(); \
::boost::serialization::singleton< \ } \
guid_initializer< T > \ } \
>::get_mutable_instance().export_guid(); \ } \
}}}} \ } \
/**/ /**/
#endif // EXPORT_H #endif // EXPORT_H

2
src/Core/Object.cpp
View File

@@ -110,11 +110,13 @@ bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
const char *name) { const char *name) {
ObjectPrivate::Signal s = {fptr, std::string(name), sig}; ObjectPrivate::Signal s = {fptr, std::string(name), sig};
d->sigv.push_back(s); d->sigv.push_back(s);
return true;
} }
bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) { bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
ObjectPrivate::Slot s = {fptr, std::string(name)}; ObjectPrivate::Slot s = {fptr, std::string(name)};
d->slov.push_back(s); d->slov.push_back(s);
return true;
} }
SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const { SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {

5
src/Core/Object.h
View File

@@ -107,6 +107,7 @@ public:
// if(sig && slo) // if(sig && slo)
// return Object::connect(sig,slo->operator ()(),receiver); // return Object::connect(sig,slo->operator ()(),receiver);
// else return false; // else return false;
return false;
} }
// Qt5 style connector // // Qt5 style connector //
@@ -119,11 +120,13 @@ public:
typename FunctionPointer<Func2>::SignalSignature> typename FunctionPointer<Func2>::SignalSignature>
SigT; SigT;
ConnectSignal(sigb, slof, receiver); ConnectSignal(sigb, slof, receiver);
return true;
} }
template <typename FuncT> template <typename FuncT>
static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) { static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
ConnectSignal(sigb, slof, receiver); ConnectSignal(sigb, slof, receiver);
return true;
} }
template <typename FuncT> template <typename FuncT>
@@ -139,7 +142,7 @@ public:
} }
template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) { template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
this->addSlotImpl(GenericMFPtr(fun), name); return this->addSlotImpl(GenericMFPtr(fun), name);
} }
template <typename FuncT> template <typename FuncT>

148
src/Core/Signal.h
View File

@@ -23,21 +23,19 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_SIGNAL_H #ifndef U_CORE_SIGNAL_H
#define U_CORE_SIGNAL_H #define U_CORE_SIGNAL_H
#include <boost/typeof/typeof.hpp> #include <boost/typeof/typeof.hpp>
#include <boost/signals2/signal.hpp> #include <boost/signals2/signal.hpp>
#include <boost/signals2/slot.hpp>
#include <boost/signals2/signal_type.hpp> #include <boost/signals2/signal_type.hpp>
#include <boost/signals2/slot.hpp>
#include "Function.h" #include "Function.h"
#include <boost/bind/bind.hpp>
using namespace boost::placeholders;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -48,12 +46,12 @@
#define slots #define slots
#define signals /*virtual void init_signals();*/ public #define signals /*virtual void init_signals();*/ public
#define emit #define emit
#define SLOT(a) BOOST_STRINGIZE(a) #define SLOT(a) BOOST_STRINGIZE(a)
#define SIGNAL(a) BOOST_STRINGIZE(a) #define SIGNAL(a) BOOST_STRINGIZE(a)
#define _ULIB_DETAIL_SIGNAL_EMIT(_name,...) \ #define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...) \
static BOOST_AUTO(sig,this->findOrAddSignal(&_name)); \ static BOOST_AUTO(sig, this->findOrAddSignal(&_name)); \
sig->operator()(__VA_ARGS__); sig->operator()(__VA_ARGS__);
/** /**
* Utility macro to implement signal emission implementa una delle seguenti: * Utility macro to implement signal emission implementa una delle seguenti:
@@ -66,103 +64,105 @@
* // cast automatico // * // cast automatico //
* static BOOST_AUTO(sig,this->findOrAddSignal(&Ob1::V0)); * static BOOST_AUTO(sig,this->findOrAddSignal(&Ob1::V0));
* sig->operator()(); * sig->operator()();
*/ */
#define ULIB_SIGNAL_EMIT(_name,...) _ULIB_DETAIL_SIGNAL_EMIT(_name,__VA_ARGS__) #define ULIB_SIGNAL_EMIT(_name, ...) \
_ULIB_DETAIL_SIGNAL_EMIT(_name, __VA_ARGS__)
namespace uLib { namespace uLib {
// A boost::signal wrapper structure /////////////////////////////////////////// // A boost::signal wrapper structure ///////////////////////////////////////////
// TODO ... // TODO ...
typedef boost::signals2::signal_base SignalBase; typedef boost::signals2::signal_base SignalBase;
template <typename T> template <typename T> struct Signal {
struct Signal { typedef boost::signals2::signal<T> type;
typedef boost::signals2::signal<T> type;
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
namespace detail { namespace detail {
template <typename FuncT, int arity> struct ConnectSignal {};
template <typename FuncT, int arity> template <typename FuncT> struct ConnectSignal<FuncT, 0> {
struct ConnectSignal {}; static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
template <typename FuncT> typedef
struct ConnectSignal< FuncT, 0 > { typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) { SigT;
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT; reinterpret_cast<SigT *>(sigb)->connect(slof);
reinterpret_cast<SigT*>(sigb)->connect(slof); }
}
}; };
template <typename FuncT> template <typename FuncT> struct ConnectSignal<FuncT, 1> {
struct ConnectSignal< FuncT, 1 > { static void connect(SignalBase *sigb, FuncT slof,
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) { typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT; typedef
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver)); typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
} SigT;
reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
}
}; };
template <typename FuncT> template <typename FuncT> struct ConnectSignal<FuncT, 2> {
struct ConnectSignal< FuncT, 2 > { static void connect(SignalBase *sigb, FuncT slof,
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) { typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT; typedef
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1)); typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
} SigT;
reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
}
}; };
template <typename FuncT> template <typename FuncT> struct ConnectSignal<FuncT, 3> {
struct ConnectSignal< FuncT, 3 > { static void connect(SignalBase *sigb, FuncT slof,
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) { typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT; typedef
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2)); typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
} SigT;
reinterpret_cast<SigT *>(sigb)->connect(
boost::bind(slof, receiver, _1, _2));
}
}; };
template <typename FuncT> template <typename FuncT> struct ConnectSignal<FuncT, 4> {
struct ConnectSignal< FuncT, 4 > { static void connect(SignalBase *sigb, FuncT slof,
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) { typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT; typedef
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3)); typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
} SigT;
reinterpret_cast<SigT *>(sigb)->connect(
boost::bind(slof, receiver, _1, _2, _3));
}
}; };
template <typename FuncT> template <typename FuncT> struct ConnectSignal<FuncT, 5> {
struct ConnectSignal< FuncT, 5 > { static void connect(SignalBase *sigb, FuncT slof,
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) { typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT; typedef
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3,_4)); typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
} SigT;
reinterpret_cast<SigT *>(sigb)->connect(
boost::bind(slof, receiver, _1, _2, _3, _4));
}
}; };
} // namespace detail
} // detail template <typename FuncT> SignalBase *NewSignal(FuncT f) {
// seems to work wow !
return new Signal<void()>::type;
template <typename FuncT>
SignalBase *NewSignal(FuncT f) {
// seems to work wow !
return new Signal<void()>::type;
} }
template <typename FuncT> template <typename FuncT>
void ConnectSignal(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) void ConnectSignal(SignalBase *sigb, FuncT slof,
{ typename FunctionPointer<FuncT>::Object *receiver) {
detail::ConnectSignal< FuncT, FunctionPointer<FuncT>::arity >::connect(sigb,slof,receiver); detail::ConnectSignal<FuncT, FunctionPointer<FuncT>::arity>::connect(
sigb, slof, receiver);
} }
} // namespace uLib
} // uLib
#endif // SIGNAL_H #endif // SIGNAL_H

7
src/Core/testing/CMakeLists.txt
View File

@@ -24,9 +24,8 @@ set( TESTS
set(LIBRARIES set(LIBRARIES
${PACKAGE_LIBPREFIX}Core ${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math ${PACKAGE_LIBPREFIX}Math
${Boost_SERIALIZATION_LIBRARY} Boost::serialization
${Boost_SIGNALS_LIBRARY} Boost::program_options
${Boost_PROGRAM_OPTIONS_LIBRARY}
${ROOT_LIBRARIES} ${ROOT_LIBRARIES}
) )
uLib_add_tests(${uLib-module}) uLib_add_tests(Core)

80
src/Core/testing/SerializeDreadDiamondTest.cpp
View File

@@ -23,13 +23,10 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include <fstream> #include <fstream>
#include <typeinfo> #include <iostream>
#include <string> #include <string>
#include <typeinfo>
#include "Core/Object.h" #include "Core/Object.h"
@@ -37,78 +34,43 @@
using namespace uLib; using namespace uLib;
struct A : Object {
uLibTypeMacro(A, Object) A() : numa(5552368) {}
int numa;
struct A : Object {
uLibTypeMacro(A,Object)
A() : numa(5552368) {}
int numa;
}; };
ULIB_SERIALIZABLE_OBJECT(A) ULIB_SERIALIZABLE_OBJECT(A)
ULIB_SERIALIZE_OBJECT(A,Object) { ULIB_SERIALIZE_OBJECT(A, Object) { ar &AR(numa); }
ar & AR(numa);
}
struct B : virtual Object { struct B : virtual Object {
uLibTypeMacro(B,Object) uLibTypeMacro(B, Object) B() : numb(5552369) {}
B() : numb(5552369) {} int numb;
int numb;
}; };
ULIB_SERIALIZABLE_OBJECT(B) ULIB_SERIALIZABLE_OBJECT(B)
ULIB_SERIALIZE_OBJECT(B,Object) { ar & AR(numb); } ULIB_SERIALIZE_OBJECT(B, Object) { ar &AR(numb); }
struct C : B { struct C : B {
uLibTypeMacro(C,B) uLibTypeMacro(C, B) C() : numc(5552370) {}
C() : numc(5552370) {} int numc;
int numc;
}; };
ULIB_SERIALIZABLE_OBJECT(C) ULIB_SERIALIZABLE_OBJECT(C)
ULIB_SERIALIZE_OBJECT(C,B) { ar & AR(numc); } ULIB_SERIALIZE_OBJECT(C, B) { ar &AR(numc); }
struct D : A,B { struct D : A, B {
uLibTypeMacro(D,A,B) uLibTypeMacro(D, A, B)
D() : numd(5552371) {} D()
int numd; : numd(5552371) {}
int numd;
}; };
ULIB_SERIALIZABLE_OBJECT(D) ULIB_SERIALIZABLE_OBJECT(D)
ULIB_SERIALIZE_OBJECT(D,A,B) { ar & AR(numd); } ULIB_SERIALIZE_OBJECT(D, A, B) { ar &AR(numd); }
int main() {
A o;
Archive::xml_oarchive(std::cout) << NVP(o);
main() {
A o; o.init_properties();
Archive::xml_oarchive(std::cout) << NVP(o);
} }

192
src/Core/testing/SerializeTest.cpp
View File

@@ -23,20 +23,16 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include <fstream> #include <fstream>
#include <iostream>
#include "Core/Object.h"
#include "Core/Archives.h" #include "Core/Archives.h"
#include "Core/Object.h"
#include "testing-prototype.h" #include "testing-prototype.h"
using namespace uLib; using namespace uLib;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -45,63 +41,51 @@ using namespace uLib;
struct V3f { struct V3f {
float x,y,z; float x, y, z;
V3f() V3f() { x = y = z = 0; }
{ x = y = z =0; }
V3f(float x, float y, float z) : V3f(float x, float y, float z) : x(x), y(y), z(z) {}
x(x), y(y), z(z) {}
template <class Archive> template <class Archive> void serialize(Archive &ar, unsigned int v) {
void serialize (Archive &ar,unsigned int v) { ar & "<" & NVP(x) & NVP(y) & NVP(z) & ">";
ar }
& "<" & NVP(x) & NVP(y) & NVP(z) & ">";
}
}; };
ULIB_CLASS_EXPORT_KEY(V3f); ULIB_CLASS_EXPORT_KEY(V3f);
ULIB_CLASS_EXPORT_IMPLEMENT(V3f); ULIB_CLASS_EXPORT_IMPLEMENT(V3f);
inline std::ostream &operator<<(std::ostream &o, const V3f &v) {
inline std::ostream & Archive::hrt_oarchive(o) << v;
operator <<(std::ostream &o, const V3f &v) { return o;
Archive::hrt_oarchive(o) << v;
return o;
} }
inline std::istream & inline std::istream &operator>>(std::istream &is, V3f &v) {
operator >>(std::istream &is, V3f &v) { Archive::hrt_iarchive(is) >> v;
Archive::hrt_iarchive(is) >> v; return is;
return is;
} }
int test_V3f() { int test_V3f() {
// testing human readble archive with simple serializable structure // // testing human readble archive with simple serializable structure //
V3f v1(1,2,3),v2,v3,v4; V3f v1(1, 2, 3), v2, v3, v4;
std::cout << "v --> " << v1 << "\n"; std::cout << "v --> " << v1 << "\n";
std::stringstream ss; ss << v1; std::stringstream ss;
std::cout << "ss.v --> " << ss.str() << "\n"; ss << v1;
std::cout << "ss.v --> " << ss.str() << "\n";
Archive::hrt_iarchive ar(ss); ar >> v2; Archive::hrt_iarchive ar(ss);
std::cout << "v2 --> " << v2 << "\n"; ar >> v2;
std::cout << "v2 --> " << v2 << "\n";
std::stringstream("<2 3 4>") >> v3; std::stringstream("<2 3 4>") >> v3;
std::cout << "v3 --> " << v3 << "\n"; std::cout << "v3 --> " << v3 << "\n";
// std::cout << "insert V3f string to parse: "; std::cin >> v4; // std::cout << "insert V3f string to parse: "; std::cin >> v4;
// std::cout << "v4 --> " << v4 << "\n"; // std::cout << "v4 --> " << v4 << "\n";
return (1); return (1);
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -109,104 +93,72 @@ int test_V3f() {
// OBJECT SERIALIZATION // // OBJECT SERIALIZATION //
class A : public virtual Object { class A : public virtual Object {
uLibTypeMacro(A,Object) uLibTypeMacro(A, Object) ULIB_SERIALIZE_ACCESS public : A() : m_a(5552368) {}
ULIB_SERIALIZE_ACCESS
public:
A() : m_a(5552368) {}
properties() { void init_properties();
std::string p_a; std::string p_a;
};
uLibRefMacro(a, int);
uLibRefMacro (a,int);
private: private:
int m_a; int m_a;
}; };
void A::init_properties() { void A::init_properties() { p_a = "A property string"; }
$_init();
$$.p_a = "A property string";
}
ULIB_SERIALIZABLE_OBJECT(A) ULIB_SERIALIZABLE_OBJECT(A)
ULIB_SERIALIZE_OBJECT(A,Object) { ULIB_SERIALIZE_OBJECT(A, Object) {
ar ar & "Object A : " & "--> m_a = " & AR(m_a) & "\n" & "Object A properties: " &
& "Object A : " "---> p_a = " & AR(p_a) & "\n";
& "--> m_a = " & AR(m_a)
& "\n";
} }
ULIB_SERIALIZE_OBJECT_PROPS(A) {
ar
& "Object A properties: "
& "---> p_a = " & AR(p_a) & "\n";
}
int testing_xml_class() { int testing_xml_class() {
A a; a.init_properties(); A a;
a.init_properties();
{ {
std::ofstream file("test.xml"); std::ofstream file("test.xml");
Archive::xml_oarchive(file) << NVP(a); Archive::xml_oarchive(file) << NVP(a);
} }
a.a() = 0; a.a() = 0;
a.$$.p_a = "zero string"; a.p_a = "zero string";
{ {
std::ifstream file("test.xml"); std::ifstream file("test.xml");
Archive::xml_iarchive(file) >> NVP(a); Archive::xml_iarchive(file) >> NVP(a);
} }
Archive::xml_oarchive(std::cout) << NVP(a); Archive::xml_oarchive(std::cout) << NVP(a);
return ( a.a() == 5552368 && a.$$.p_a == "A property string" ); return (a.a() == 5552368 && a.p_a == "A property string");
} }
int testing_hrt_class() { int testing_hrt_class() {
A a; a.init_properties(); A a;
a.init_properties();
{ {
std::ofstream file("test.xml"); std::ofstream file("test.xml");
Archive::hrt_oarchive(file) << NVP(a); Archive::hrt_oarchive(file) << NVP(a);
} }
a.a() = 0; a.a() = 0;
a.$$.p_a = "zero string"; a.p_a = "zero string";
{ {
// ERRORE FIX ! // ERRORE FIX !
// std::ifstream file("test.xml"); // std::ifstream file("test.xml");
// Archive::hrt_iarchive(file) >> NVP(a); // Archive::hrt_iarchive(file) >> NVP(a);
} }
Archive::hrt_oarchive(std::cout) << NVP(a); Archive::hrt_oarchive(std::cout) << NVP(a);
return ( a.a() == 5552368 && a.$$.p_a == "A property string" ); return (a.a() == 5552368 && a.p_a == "A property string");
} }
int main() { int main() {
BEGIN_TESTING(Serialize Test); BEGIN_TESTING(Serialize Test);
TEST1( test_V3f() ); TEST1(test_V3f());
TEST1( testing_xml_class() ); TEST1(testing_xml_class());
// testing_hrt_class(); ///// << ERRORE in HRT with properties // testing_hrt_class(); ///// << ERRORE in HRT with properties
END_TESTING; END_TESTING;
} }

85
src/Core/testing/StaticInterfaceTest.cpp
View File

@@ -23,90 +23,73 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include <iostream> #include <iostream>
#include "testing-prototype.h" #include "testing-prototype.h"
#include <Core/StaticInterface.h> #include <Core/StaticInterface.h>
namespace uLib { namespace uLib {
//// INTERFACE TO COMPLEX CLASS ///// //// INTERFACE TO COMPLEX CLASS /////
namespace Interface { namespace Interface {
struct Test { struct Test {
MAKE_TRAITS MAKE_TRAITS
template<class Self> void check_structural() { template <class Self> void check_structural() {
uLibCheckFunction(Self,test,bool,int,float); uLibCheckFunction(Self, test, bool, int, float);
uLibCheckMember(Self,testmemb,int); uLibCheckMember(Self, testmemb, int);
} }
}; };
} } // namespace Interface
struct Test { struct Test {
bool test(int i, float f){} bool test(int i, float f) { return true; }
int testmemb; int testmemb;
}; };
//// INTERFAC TO SIMPLE CLASS /////////// //// INTERFAC TO SIMPLE CLASS ///////////
namespace Interface { namespace Interface {
struct Simple { struct Simple {
MAKE_TRAITS MAKE_TRAITS
template<class Self> void check_structural() { template <class Self> void check_structural() {
uLibCheckMember(Self,memb1,int); uLibCheckMember(Self, memb1, int);
uLibCheckMember(Self,memb2,float); uLibCheckMember(Self, memb2, float);
} }
}; };
} } // namespace Interface
struct Simple { struct Simple {
int memb1; int memb1;
float memb2; float memb2;
}; };
///////////////////////// /////////////////////////
template <class T> template <class T> class UseTest {
class UseTest {
public: public:
UseTest() { UseTest() {
Interface::IsA<T,Interface::Test>(); Interface::IsA<T, Interface::Test>();
T t; T t;
int i; float f; int i;
t.test(i,f); float f;
} t.test(i, f);
}
}; };
template <class T> template <class T> class UseSimple {
class UseSimple {
public: public:
UseSimple() { UseSimple() { Interface::IsA<T, Interface::Simple>(); }
Interface::IsA<T,Interface::Simple>();
}
}; };
} // namespace uLib
int main() {
BEGIN_TESTING(Static Interface);
uLib::UseTest<uLib::Test> u;
uLib::UseSimple<uLib::Simple> s;
END_TESTING;
} }
int main()
{
BEGIN_TESTING(Static Interface);
uLib::UseTest<uLib::Test> u;
uLib::UseSimple<uLib::Simple> s;
END_TESTING;
}

5
src/Detectors/CMakeLists.txt
View File

@@ -5,3 +5,8 @@ set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
install(FILES ${HEADERS} install(FILES ${HEADERS}
DESTINATION ${INSTALL_INC_DIR}/Detectors) DESTINATION ${INSTALL_INC_DIR}/Detectors)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

23
src/Detectors/testing/CMakeLists.txt
View File

@@ -1,18 +1,15 @@
# TESTS # TESTS
set( TESTS set( TESTS
GDMLSolidTest # GDMLSolidTest
HierarchicalEncodingTest HierarchicalEncodingTest
) )
#set(LIBRARIES set(LIBRARIES
# ${PACKAGE_LIBPREFIX}Core ${PACKAGE_LIBPREFIX}Core
# ${PACKAGE_LIBPREFIX}Math ${PACKAGE_LIBPREFIX}Math
# ${PACKAGE_LIBPREFIX}Detectors Boost::serialization
# ${Boost_SERIALIZATION_LIBRARY} Boost::program_options
# ${Boost_SIGNALS_LIBRARY} Eigen3::Eigen
# ${Boost_PROGRAM_OPTIONS_LIBRARY} ${ROOT_LIBRARIES}
# ${Eigen_LIBRARY} )
# ${Geant4_LIBRARIES} uLib_add_tests(Detectors)
# ${ROOT_LIBRARIES}
#)
uLib_add_tests(${uLib-module})

7
src/Math/CMakeLists.txt
View File

@@ -54,7 +54,8 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Math) install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Math)
# TESTING if(BUILD_TESTING)
# include(uLibTargetMacros) include(uLibTargetMacros)
# add_subdirectory(testing) add_subdirectory(testing)
endif()

120
src/Math/testing/AccumulatorTest.cpp
View File

@@ -23,88 +23,90 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include "Math/Accumulator.h" #include "Math/Accumulator.h"
#include "testing-prototype.h" #include "testing-prototype.h"
#include <TRandom.h> #include <TRandom.h>
#include <iostream>
#include <vector>
// #include <boost/accumulators/framework/accumulator_set.hpp>
//#include <boost/accumulators/framework/accumulator_set.hpp> // #include <boost/accumulators/statistics/count.hpp>
//#include <boost/accumulators/statistics/count.hpp> // #include <boost/accumulators/accumulators.hpp>
//#include <boost/accumulators/accumulators.hpp>
using namespace uLib; using namespace uLib;
int test_ABTrim() { int test_ABTrim() {
Accumulator_ABTrim<float> acc; Accumulator_ABTrim<float> acc;
acc.SetABTrim(1,1); acc.SetABTrim(1, 1);
std::vector<float> v; std::vector<float> v;
for(float tmpf : {1,5,5,5,300}) v.push_back(tmpf); for (float tmpf : {1, 5, 5, 5, 300})
//v << 1,5,5,5,300; v.push_back(tmpf);
// v << 1,5,5,5,300;
for(std::vector<float>::iterator itr=v.begin(); itr<v.end(); itr++) for (std::vector<float>::iterator itr = v.begin(); itr < v.end(); itr++)
acc += *itr; acc += *itr;
// TODO missing operator << // TODO missing operator <<
//std::cout << "Accumulating Trim(1,1) vector: " // std::cout << "Accumulating Trim(1,1) vector: "
// << v << " ... out = " << acc() << "\n"; // << v << " ... out = " << acc() << "\n";
return( acc() == 15.0 );
return (acc() == 15.0);
} }
int test_Mean() { int test_Mean() {
Accumulator_Mean<float> mean; Accumulator_Mean<float> mean;
TRandom rnd; TRandom rnd;
const int c = 10000000; const int c = 10000000;
std::vector<float> v; std::vector<float> v;
v.reserve(c); v.reserve(c);
for(int i=0;i<c;++i) v.push_back( rnd.Gaus(2000,5) ); for (int i = 0; i < c; ++i)
v.push_back(rnd.Gaus(2000, 5));
float m = 0;
for(int i=0;i<c;++i) m += v[i];
m /= c;
std::cout << "simple mean: " << m << "\n";
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
float m = 0;
for (int i = 0; i < c; ++i)
m += v[i];
m /= c;
std::cout << "simple mean: " << m << "\n";
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
return 1;
} }
int main(void) { int main(void) {
BEGIN_TESTING(Accumulator); BEGIN_TESTING(Accumulator);
//TEST1( test_ABTrim() ); // TEST1( test_ABTrim() );
test_Mean(); test_Mean();
END_TESTING; END_TESTING;
} }

2
src/Math/testing/CMakeLists.txt
View File

@@ -17,6 +17,8 @@ set(TESTS
set(LIBRARIES set(LIBRARIES
${PACKAGE_LIBPREFIX}Core ${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math ${PACKAGE_LIBPREFIX}Math
Boost::serialization
Eigen3::Eigen
) )
uLib_add_tests(Math) uLib_add_tests(Math)

25
src/Math/testing/TriangleMeshTest.cpp
View File

@@ -23,30 +23,25 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include "testing-prototype.h" #include "testing-prototype.h"
#include "Math/TriangleMesh.h" #include "Math/TriangleMesh.h"
#include <iostream>
using namespace uLib; using namespace uLib;
int main() int main() {
{ BEGIN_TESTING(Triangle Mesh);
BEGIN_TESTING(Triangle Mesh);
TriangleMesh mesh; TriangleMesh mesh;
mesh.AddPoint(Vector3f(0,0,0)); mesh.AddPoint(Vector3f(0, 0, 0));
mesh.AddPoint(Vector3f(0,1,0)); mesh.AddPoint(Vector3f(0, 1, 0));
mesh.AddPoint(Vector3f(1,0,0)); mesh.AddPoint(Vector3f(1, 0, 0));
mesh.AddTriangle(Vector3i(0,1,2)); mesh.AddTriangle(Vector3i(0, 1, 2));
mesh.PrintSelf(std::cout);
mesh.PrintSelf(std::cout); END_TESTING;
END_TESTING;
} }

185
src/Math/testing/VoxRaytracerTest.cpp
View File

@@ -23,129 +23,114 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include "Math/StructuredGrid.h"
#include "Math/VoxRaytracer.h" #include "Math/VoxRaytracer.h"
#include "Math/StructuredGrid.h"
#include "testing-prototype.h" #include "testing-prototype.h"
#include <iostream>
using namespace uLib; using namespace uLib;
int Vector4f0(Vector4f c) {
int Vector4f0(Vector4f c)
{
c(3) = 0; c(3) = 0;
if ( fabs(c(0)) < 0.001 && fabs(c(1)) < 0.001 && fabs(c(2)) < 0.001 ) if (fabs(c(0)) < 0.001 && fabs(c(1)) < 0.001 && fabs(c(2)) < 0.001)
return 0; return 0;
else else
return 1; return 1;
} }
//bool Comapare(const &t1, const T2 &t2) // bool Comapare(const &t1, const T2 &t2)
//{ //{
// int out = 0; // int out = 0;
// out += t1.vox_id != t2.vox_id; // out += t1.vox_id != t2.vox_id;
// out += (fabs(t1.L) - fabs(t2.L)) > 0.001; // out += (fabs(t1.L) - fabs(t2.L)) > 0.001;
// return out == 0; // return out == 0;
//} // }
typedef VoxRaytracer Raytracer; typedef VoxRaytracer Raytracer;
int main() int main() {
{ BEGIN_TESTING(Math VoxRaytracer);
BEGIN_TESTING(Math VoxRaytracer);
StructuredGrid img(Vector3i(2,2,2)); StructuredGrid img(Vector3i(2, 2, 2));
img.SetSpacing(Vector3f(2,2,2)); img.SetSpacing(Vector3f(2, 2, 2));
img.SetPosition(Vector3f(-2,0,-2)); img.SetPosition(Vector3f(-2, 0, -2));
{ {
HLine3f line; HLine3f line;
line.origin << 0.1, 4.1, 0.1, 1; line.origin << 0.1, 4.1, 0.1, 1;
line.direction << 0.1, -0.1, 0.1,0; line.direction << 0.1, -0.1, 0.1, 0;
Raytracer rt(img); Raytracer rt(img);
HPoint3f pt; HPoint3f pt;
TEST1( rt.GetEntryPoint(line,pt) ); TEST1(rt.GetEntryPoint(line, pt));
TEST0( Vector4f0( pt - HPoint3f(0.2,4,0.2) ) ); TEST0(Vector4f0(pt - HPoint3f(0.2, 4, 0.2)));
}
{
HLine3f line;
line.origin << 4, 0, 4, 1;
line.direction << -0.1, 0.1, -0.1, 0;
Raytracer rt(img);
HPoint3f pt;
TEST1(rt.GetEntryPoint(line, pt));
TEST0(Vector4f0(pt - HPoint3f(2, 2, 2)));
}
{ // Test a point inside image //
StructuredGrid img(Vector3i(4, 4, 4));
img.SetSpacing(Vector3f(2, 2, 2));
img.SetPosition(Vector3f(-4, -4, -4));
Raytracer ray(img);
HPoint3f pt;
HLine3f line;
line.origin = HPoint3f(-3, -3, -3);
// line.direction = HVector3f(1,1,1); //
TEST1(ray.GetEntryPoint(line, pt));
TEST1(pt == HPoint3f(-3, -3, -3));
Raytracer::RayData rdata =
ray.TraceBetweenPoints(HPoint3f(-3, -3, -3), HPoint3f(3, 3, 3));
for (const Raytracer::RayData::Element &el : rdata.Data()) {
std::cout << " " << el.vox_id << " , " << el.L << "\n";
} }
}
{ {
HLine3f line; HPoint3f pt1(1, -0.5, 1);
line.origin << 4,0,4, 1; HPoint3f pt2(1, 4.5, 1);
line.direction << -0.1, 0.1, -0.1, 0; Raytracer rt(img);
Raytracer rt(img);
HPoint3f pt;
TEST1( rt.GetEntryPoint(line,pt) );
TEST0( Vector4f0( pt - HPoint3f(2,2,2) ) );
}
{ // Test a point inside image // Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
StructuredGrid img(Vector3i(4,4,4)); TEST1(ray.Data().size() == 2);
img.SetSpacing(Vector3f(2,2,2)); TEST1(ray.Data().at(0).vox_id == 6);
img.SetPosition(Vector3f(-4,-4,-4)); TEST1(ray.Data().at(1).vox_id == 7);
Raytracer ray(img); ray.PrintSelf(std::cout);
HPoint3f pt; }
HLine3f line;
line.origin = HPoint3f(-3,-3,-3);
// line.direction = HVector3f(1,1,1); //
TEST1( ray.GetEntryPoint(line,pt) );
TEST1( pt == HPoint3f(-3,-3,-3) );
Raytracer::RayData rdata = ray.TraceBetweenPoints(HPoint3f(-3,-3,-3), HPoint3f(3,3,3)); {
for(const Raytracer::RayData::Element &el : rdata.Data()) HPoint3f pt1(5, 1, 1);
{ HPoint3f pt2(-3, 1, 1);
std::cout << " " << el.vox_id << " , " << el.L << "\n"; Raytracer rt(img);
}
}
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
TEST1(ray.Data().size() == 2);
TEST1(ray.Data().at(0).vox_id == 6);
TEST1(ray.Data().at(1).vox_id == 4);
ray.PrintSelf(std::cout);
}
{ {
HPoint3f pt1(1,-0.5,1); HPoint3f pt1(1, 1, 1);
HPoint3f pt2(1,4.5,1); HPoint3f pt2(-1, 3, -1);
Raytracer rt(img); Raytracer rt(img);
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2); Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
TEST1( ray.Data().size() == 2 ); TEST1(ray.Data().size() == 4);
TEST1( ray.Data().at(0).vox_id == 6 ); TEST1(ray.Data().at(0).vox_id == 6);
TEST1( ray.Data().at(1).vox_id == 7 ); TEST1(ray.Data().at(1).vox_id == 4);
ray.PrintSelf(std::cout); TEST1(ray.Data().at(2).vox_id == 5);
} TEST1(ray.Data().at(3).vox_id == 1);
ray.PrintSelf(std::cout);
}
{ END_TESTING
HPoint3f pt1(5,1,1);
HPoint3f pt2(-3,1,1);
Raytracer rt(img);
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
TEST1( ray.Data().size() == 2 );
TEST1( ray.Data().at(0).vox_id == 6 );
TEST1( ray.Data().at(1).vox_id == 4 );
ray.PrintSelf(std::cout);
}
{
HPoint3f pt1(1,1,1);
HPoint3f pt2(-1,3,-1);
Raytracer rt(img);
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
TEST1( ray.Data().size() == 4 );
TEST1( ray.Data().at(0).vox_id == 6 );
TEST1( ray.Data().at(1).vox_id == 4 );
TEST1( ray.Data().at(2).vox_id == 5 );
TEST1( ray.Data().at(3).vox_id == 1 );
ray.PrintSelf(std::cout);
}
END_TESTING
} }

5
src/Root/CMakeLists.txt
View File

@@ -62,4 +62,7 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Root) install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Root)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

7
src/Root/testing/CMakeLists.txt
View File

@@ -8,9 +8,8 @@ set(LIBRARIES
${PACKAGE_LIBPREFIX}Core ${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math ${PACKAGE_LIBPREFIX}Math
${PACKAGE_LIBPREFIX}Root ${PACKAGE_LIBPREFIX}Root
${Boost_SERIALIZATION_LIBRARY} Boost::serialization
${Boost_SIGNALS_LIBRARY} Boost::program_options
${Boost_PROGRAM_OPTIONS_LIBRARY}
${ROOT_LIBRARIES} ${ROOT_LIBRARIES}
) )
uLib_add_tests(${uLib-module}) uLib_add_tests(Root)

4
src/Vtk/CMakeLists.txt
View File

@@ -36,3 +36,7 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk) install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

4
src/Vtk/testing/CMakeLists.txt
View File

@@ -14,5 +14,5 @@ set(LIBRARIES
${PACKAGE_LIBPREFIX}Vtk ${PACKAGE_LIBPREFIX}Vtk
) )
include(${VTK_USE_FILE}) # include(${VTK_USE_FILE})
uLib_add_tests(${uLib-module}) uLib_add_tests(Vtk)

5
src/utils/make_recipe/src/CMakeLists.txt
View File

@@ -67,9 +67,8 @@ if(ULIB_FOUND)
############################################################################ ############################################################################
# MANUAL INLCLUDE EXTERNAL DEPENDENCIES # MANUAL INLCLUDE EXTERNAL DEPENDENCIES
# ${Boost_SERIALIZATION_LIBRARY} # Boost::serialization
# ${Boost_SIGNALS_LIBRARY} # Boost::program_options
# ${Boost_PROGRAM_OPTIONS_LIBRARY}
# ${Geant4_LIBRARIES} # ${Geant4_LIBRARIES}
# ${ROOT_LIBRARIES} # ${ROOT_LIBRARIES}
# ${VTK_LIBRARIES} # all VTK libs # ${VTK_LIBRARIES} # all VTK libs