diff --git a/serialization/CMakeLists.txt b/serialization/CMakeLists.txt deleted file mode 100644 index a853ba8ec5158727fcd4bfd9752d6de398c5aefa..0000000000000000000000000000000000000000 --- a/serialization/CMakeLists.txt +++ /dev/null @@ -1 +0,0 @@ -add_subdirectory(cereal) diff --git a/serialization/cereal/CMakeLists.txt b/serialization/cereal/CMakeLists.txt deleted file mode 100644 index 1ae16bcd213401f6558a4ee80c2c5a8ef8c5f171..0000000000000000000000000000000000000000 --- a/serialization/cereal/CMakeLists.txt +++ /dev/null @@ -1,26 +0,0 @@ -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) - -SET(HDRS_SERIALIZATION ${HDRS_SERIALIZATION} - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_eigen_core.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_eigen_geometry.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_eigen_sparse.h - - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_local_parametrization_base.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_local_parametrization_homogeneous.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_local_parametrization_quaternion.h - - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_node_base.h - - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_sensor_intrinsic_base.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_sensor_odom2d_intrinsic.h - - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_processor_params_base.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_processor_odom2d_params.h - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_processor_odom3d_params.h - - ${CMAKE_CURRENT_SOURCE_DIR}/serialization_time_stamp.h - - ${CMAKE_CURRENT_SOURCE_DIR}/archives.h - ${CMAKE_CURRENT_SOURCE_DIR}/io.h - - PARENT_SCOPE) diff --git a/serialization/cereal/archives.h b/serialization/cereal/archives.h deleted file mode 100644 index d8c16fd180ef04049ceedaf268fa33782790d27a..0000000000000000000000000000000000000000 --- a/serialization/cereal/archives.h +++ /dev/null @@ -1,9 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_ARCHIVE_H_ -#define _WOLF_IO_CEREAL_ARCHIVE_H_ - -#include <cereal/archives/binary.hpp> -#include <cereal/archives/json.hpp> -#include <cereal/archives/portable_binary.hpp> -#include <cereal/archives/xml.hpp> - -#endif /* _WOLF_IO_CEREAL_ARCHIVE_H_ */ diff --git a/serialization/cereal/io.h b/serialization/cereal/io.h deleted file mode 100644 index 8a8e58c2d8a873b4d327e1c8639fc007cb8604aa..0000000000000000000000000000000000000000 --- a/serialization/cereal/io.h +++ /dev/null @@ -1,229 +0,0 @@ -#ifndef _WOLF_SERIALIZATION_CEREAL_IO_H_ -#define _WOLF_SERIALIZATION_CEREAL_IO_H_ - -#include <stdexcept> -#include "archives.h" - -//#include <cereal/types/tuple.hpp> - -namespace wolf { -namespace serialization { - -/// @todo demangle typeid.name ? -template <typename T> -inline const std::string& type_name(const T&) -{ - static const std::string typeid_name = typeid(T).name(); - return typeid_name; -} - -inline std::string extension(const std::string& file) -{ - const std::size_t p = file.find_last_of("."); - return (p != std::string::npos) ? file.substr(p) : ""; -} - -//struct Extensions -//{ -// constexpr static const char* bin = ".bin"; -// constexpr static const char* json = ".json"; -// constexpr static const char* xml = ".xml"; - -// constexpr static const char* fall_back = json; -//}; - -//enum class Extensions2 : std::size_t -//{ -// BIN = 0, -//// CBIN, -// JSON, -//// TEXT, -// XML, -//}; - -//template <char... Chars> -//struct constexp_str -//{ -// using type = constexp_str<Chars...>; - -// virtual ~constexp_str() = default; - -// constexpr static const char value[sizeof...(Chars)+1] = {Chars..., '\0'}; - -// constexpr static std::size_t size() { return sizeof...(Chars); } - -// constexpr static const char* c_str() { return &value[0]; } - -//// constexpr static bool comp(const std::string& s) { return s == value; } - -// /*constexpr*/ bool operator == (const std::string& s) { return s == value; } - -// constexpr /*static*/ operator const char* () { return c_str(); } -// constexpr /*static*/ operator std::string& () { return c_str(); } -//}; - -struct Extensions -{ -// template <char... Chars> -// struct EXT : constexp_str<Chars...> -// { -// // -// }; - -// struct BIN : EXT<'.','b','i','n'> { }; -// struct XML : EXT<'.','x','m','l'> { }; -// struct JSON : EXT<'.','j','s','o','n'> { }; - - struct EXT { virtual ~EXT() = default; }; - - struct BIN : EXT - { - constexpr static const char* value = ".bin"; - bool operator == (const std::string& s) { return value == s; } - }; - - struct XML : EXT - { - constexpr static const char* value = ".xml"; - bool operator == (const std::string& s) { return value == s; } - }; - - struct JSON : EXT - { - constexpr static const char* value = ".json"; - bool operator == (const std::string& s) { return value == s; } - }; -}; - -template <typename Ar> -void serialize_pack(Ar&&) -{ - // end of expansion -} - -template <typename Ar, typename T, typename... Args> -void serialize_pack(Ar&& archive, T&& object, Args&&... args) -{ - archive( cereal::make_nvp(type_name(object), std::forward<T>(object)) ); - serialize_pack(archive, std::forward<Args>(args)...); -} - -template <typename Ar, typename S, typename T, typename... Args> -void serialize(S& stream, T&& object, Args&&... args) -{ - Ar archive(stream); - archive( cereal::make_nvp(type_name(object), std::forward<T>(object)) ); - - serialize_pack(archive, std::forward<Args>(args)...); -} - -template <typename EXT, typename InAr, typename OutAr> -struct Serializer -{ - template <typename S, typename... T> - static void serialize_in(S& stream, T&... object) - { - serialize<InAr>(stream, object...); - } - - template <typename S, typename... T> - static void serialize_out(S& stream, T&&... object) - { - serialize<OutAr>(stream, std::forward<T>(object)...); - } - - template <typename... T> - static void save(std::string filename, T&&... o) - { - const std::string ext = serialization::extension(filename); - - if (ext != EXT::value) filename += EXT::value; - - std::ofstream os(filename); - serialize_out(os, std::forward<T>(o)...); - } - - template <typename... T> - static void load(std::string filename, T&... o) - { - const std::string ext = serialization::extension(filename); - - if (ext != EXT::value) filename += EXT::value; - - std::ifstream is(filename); - serialize_in(is, o...); - } -}; - -using SerializerBin = Serializer<Extensions::BIN, - cereal::BinaryInputArchive, - cereal::BinaryOutputArchive>; - -using SerializerXML = Serializer<Extensions::XML, - cereal::XMLInputArchive, - cereal::XMLOutputArchive>; - -using SerializerJSON = Serializer<Extensions::JSON, - cereal::JSONInputArchive, - cereal::JSONOutputArchive>; - -} /* namespace serialization */ - -template <typename... T> -void save(const std::string& filename, T&&... o) -throw(std::runtime_error) -{ - const std::string ext = serialization::extension(filename); - - if (ext == serialization::Extensions::BIN::value) - { - serialization::SerializerBin::save(filename, std::forward<T>(o)...); - } - else if (ext == serialization::Extensions::JSON::value) - { - serialization::SerializerJSON::save(filename, std::forward<T>(o)...); - } - else if (ext == serialization::Extensions::XML::value) - { - serialization::SerializerXML::save(filename, std::forward<T>(o)...); - } - else if (ext == "") // falback is json - { - serialization::SerializerJSON::save(filename, std::forward<T>(o)...); - } - else - { - throw std::runtime_error("Unknown file extension : " + filename); - } -} - -template <typename... T> -void load(const std::string& filename, T&... o) -{ - const std::string ext = serialization::extension(filename); - - if (ext == serialization::Extensions::BIN::value) - { - serialization::SerializerBin::load(filename, o...); - } - else if (ext == serialization::Extensions::XML::value) - { - serialization::SerializerXML::load(filename, o...); - } - else if (ext == serialization::Extensions::JSON::value) - { - serialization::SerializerJSON::load(filename, o...); - } - else if (ext == "") // falback is json - { - serialization::SerializerJSON::load(filename, o...); - } - else - { - throw std::runtime_error("Unknown file extension : " + filename); - } -} - -} /* namespace wolf */ - -#endif /* _WOLF_SERIALIZATION_CEREAL_IO_H_ */ diff --git a/serialization/cereal/serialization_eigen_core.h b/serialization/cereal/serialization_eigen_core.h deleted file mode 100644 index 8fb5b9b0c99637e7b4aed9efb3aaf68007aafb79..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_eigen_core.h +++ /dev/null @@ -1,125 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_EIGEN_H_ -#define _WOLF_IO_CEREAL_EIGEN_H_ - -// Wolf includes -#include <Eigen/Dense> -#include <cereal/cereal.hpp> - -namespace cereal { - -/** - * @brief Save Eigen::Matrix<...> to text based archives - */ -template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -inline typename std::enable_if<!traits::is_output_serializable<BinaryData<_Scalar>, Archive>::value, -void>::type save(Archive& ar, - const Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& mat) -{ - decltype(mat.rows()) rows = mat.rows(); - decltype(mat.cols()) cols = mat.cols(); - - ar(cereal::make_nvp("rows", rows)); - ar(cereal::make_nvp("cols", cols)); - - /// @todo find out something - std::cerr << "Saving Eigen type to text-based archive is NOT supported !\n"; -} - -/** - * @brief Save Eigen::Matrix<...> to binary based archives - */ -template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -inline typename std::enable_if<traits::is_output_serializable<BinaryData<_Scalar>, Archive>::value, -void>::type save(Archive& ar, - const Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& mat) -{ - decltype(mat.rows()) rows = mat.rows(); - decltype(mat.cols()) cols = mat.cols(); - - ar(rows); - ar(cols); - - ar(binary_data(mat.data(), static_cast<std::size_t>(rows * cols * sizeof(_Scalar)))); -} - -/** - * @brief Load compile-time sized Eigen::Matrix from text based archives - */ -template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -inline typename std::enable_if<!traits::is_input_serializable<BinaryData<_Scalar>, Archive>::value and - _Rows != Eigen::Dynamic and _Cols != Eigen::Dynamic, -void>::type load(Archive& ar, - Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& mat) -{ - decltype(mat.rows()) rows; - decltype(mat.cols()) cols; - - ar(cereal::make_nvp("rows", rows)); - ar(cereal::make_nvp("cols", cols)); - - /// @todo find out something - std::cerr << "Saving Eigen type to text-based archive is NOT supported !\n"; -} - -/** - * @brief Load dynamic sized Eigen::Matrix from text based archives - */ -template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -inline typename std::enable_if<!traits::is_input_serializable<BinaryData<_Scalar>, Archive>::value and - (_Rows == Eigen::Dynamic or _Cols == Eigen::Dynamic), -void>::type load(Archive& ar, - Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& mat) -{ - decltype(mat.rows()) rows; - decltype(mat.cols()) cols; - - ar(cereal::make_nvp("rows", rows)); - ar(cereal::make_nvp("cols", cols)); - - /// @todo find out something - std::cerr << "Saving Eigen type to text-based archive is NOT supported !\n"; - - //mat.resize(rows, cols); -} - -/** - * @brief Load compile-time sized Eigen::Matrix from binary based archives - */ -template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -inline typename std::enable_if<traits::is_input_serializable<BinaryData<_Scalar>, Archive>::value and - _Rows != Eigen::Dynamic and _Cols != Eigen::Dynamic, -void>::type load(Archive& ar, - Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& mat) -{ - decltype(mat.rows()) rows; - decltype(mat.cols()) cols; - - ar(rows); - ar(cols); - - ar(binary_data(mat.data(), static_cast<std::size_t>(rows * cols * sizeof(_Scalar)))); -} - -/** - * @brief Load dynamic sized Eigen::Matrix from binary based archives - */ -template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -inline typename std::enable_if<traits::is_input_serializable<BinaryData<_Scalar>, Archive>::value and - (_Rows == Eigen::Dynamic or _Cols == Eigen::Dynamic), -void>::type load(Archive& ar, - Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& mat) -{ - decltype(mat.rows()) rows; - decltype(mat.cols()) cols; - - ar(rows); - ar(cols); - - mat.resize(rows, cols); - - ar(binary_data(mat.data(), static_cast<std::size_t>(rows * cols * sizeof(_Scalar)))); -} - -} // namespace cereal - -#endif /* _WOLF_IO_CEREAL_EIGEN_H_ */ diff --git a/serialization/cereal/serialization_eigen_geometry.h b/serialization/cereal/serialization_eigen_geometry.h deleted file mode 100644 index f5d3ac61fa92c85d5c2b98670e86e5c6d3d68c24..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_eigen_geometry.h +++ /dev/null @@ -1,38 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_EIGEN_GEOMETRY_H_ -#define _WOLF_IO_CEREAL_EIGEN_GEOMETRY_H_ - -// Wolf includes -#include <Eigen/Geometry> - -#include "serialization_eigen_core.h" - -namespace cereal { - -template<class Archive, typename _Scalar, int _Dim, int _Mode, int _Options> -inline void save(Archive& ar, - const Eigen::Transform<_Scalar, _Dim, _Mode, _Options>& t) -{ - save(ar, t.matrix()); -} - -template<class Archive, typename _Scalar, int _Dim, int _Mode, int _Options> -inline void load(Archive& ar, - Eigen::Transform<_Scalar, _Dim, _Mode, _Options>& t) -{ - load(ar, t.matrix()); -} - -template<class Archive, typename _Scalar> -void serialize(Archive & ar, - Eigen::Quaternion<_Scalar>& q, - const std::uint32_t /*version*/) -{ - ar(cereal::make_nvp("w", q.w())); - ar(cereal::make_nvp("x", q.x())); - ar(cereal::make_nvp("y", q.y())); - ar(cereal::make_nvp("z", q.z())); -} - -} // namespace cereal - -#endif /* _WOLF_IO_CEREAL_EIGEN_GEOMETRY_H_ */ diff --git a/serialization/cereal/serialization_eigen_sparse.h b/serialization/cereal/serialization_eigen_sparse.h deleted file mode 100644 index 9039b6920bc74abb3b4ff9efa4e0b935674ca53f..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_eigen_sparse.h +++ /dev/null @@ -1,79 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_EIGEN_GEOMETRY_H_ -#define _WOLF_IO_CEREAL_EIGEN_GEOMETRY_H_ - -// Wolf includes -#include <Eigen/Sparse> - -#include "serialization_eigen_core.h" -#include <cereal/types/vector.hpp> - -namespace cereal { - -template<class Archive, typename Scalar, typename Index> -inline void save(Archive& ar, - const Eigen::Triplet<Scalar, Index>& t) -{ - ar(cereal::make_nvp("row", t.row())); - ar(cereal::make_nvp("col", t.col())); - ar(cereal::make_nvp("value", t.value())); -} - -template<class Archive, typename Scalar, typename Index> -inline void load(Archive& ar, - Eigen::Triplet<Scalar, Index>& t) -{ - Index row, col; - Scalar value; - - ar(cereal::make_nvp("row", row)); - ar(cereal::make_nvp("col", col)); - ar(cereal::make_nvp("value", value)); - - t = Eigen::Triplet<Scalar, Index>(row, col, value); -} - -template <class Archive, typename _Scalar, int _Options, typename _Index> -void save(Archive& ar, - const Eigen::SparseMatrix<_Scalar, _Options, _Index>& m) -{ - _Index inner_size = m.innerSize(); - _Index outer_size = m.outerSize(); - - using Triplet = Eigen::Triplet<_Scalar>; - std::vector<Triplet> triplets; - - for (_Index i=0; i < outer_size; ++i) - for (typename Eigen::SparseMatrix<_Scalar, _Options, _Index>::InnerIterator it(m,i); it; ++it) - triplets.emplace_back( it.row(), it.col(), it.value() ); - - ar(cereal::make_nvp("inner_size", inner_size)); - ar(cereal::make_nvp("outer_size", outer_size)); - ar(cereal::make_nvp("triplets", triplets)); -} - -template <class Archive, typename _Scalar, int _Options, typename _Index> -void load(Archive& ar, - Eigen::SparseMatrix<_Scalar, _Options, _Index>& m) -{ - _Index inner_size; - _Index outer_size; - - ar(cereal::make_nvp("inner_size", inner_size)); - ar(cereal::make_nvp("outer_size", outer_size)); - - _Index rows = (m.IsRowMajor)? outer_size : inner_size; - _Index cols = (m.IsRowMajor)? inner_size : outer_size; - - m.resize(rows, cols); - - using Triplet = Eigen::Triplet<_Scalar>; - std::vector<Triplet> triplets; - - ar(cereal::make_nvp("triplets", triplets)); - - m.setFromTriplets(triplets.begin(), triplets.end()); -} - -} // namespace cereal - -#endif /* _WOLF_IO_CEREAL_EIGEN_GEOMETRY_H_ */ diff --git a/serialization/cereal/serialization_local_parametrization_base.h b/serialization/cereal/serialization_local_parametrization_base.h deleted file mode 100644 index 1385e1af088678e853c0ab0ecb4f5d6a34f103a0..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_local_parametrization_base.h +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_LOCAL_PARAMETRIZATION_BASE_H_ -#define _WOLF_IO_CEREAL_LOCAL_PARAMETRIZATION_BASE_H_ - -#include "base/state_block/local_parametrization_base.h" - -#include <cereal/cereal.hpp> -#include <cereal/types/polymorphic.hpp> - -namespace cereal { - -// Since classes deriving from LocalParametrizationBase -// have default constructor calling the non-default -// LocalParametrizationBase constructor with pre-defined -// arguments, there is nothing to save here. -template<class Archive> -inline void serialize( - Archive& /*ar*/, - wolf::LocalParametrizationBase& /*lpb*/, - std::uint32_t const /*file_version*/) -{ - // -} - -} //namespace cereal - -#endif /* _WOLF_IO_CEREAL_LOCAL_PARAMETRIZATION_BASE_H_ */ diff --git a/serialization/cereal/serialization_local_parametrization_homogeneous.h b/serialization/cereal/serialization_local_parametrization_homogeneous.h deleted file mode 100644 index 9fcc656d5b86c51eb3995d1a11fbdcc80b1e98c4..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_local_parametrization_homogeneous.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_LOCAL_PARAMETRIZATION_BASE_HOMOGENEOUS_H_ -#define _WOLF_IO_CEREAL_LOCAL_PARAMETRIZATION_BASE_HOMOGENEOUS_H_ - -#include "core/local_parametrization_homogeneous.h" - -#include "serialization_local_parametrization_base.h" - -#include <cereal/cereal.hpp> - -CEREAL_REGISTER_TYPE_WITH_NAME(wolf::LocalParametrizationHomogeneous, - "LocalParametrizationHomogeneous"); - -namespace cereal { - -template<class Archive> -inline void serialize( - Archive& ar, - wolf::LocalParametrizationHomogeneous& lp, - std::uint32_t const /*file_version*/) -{ - ar( cereal::make_nvp("LocalParametrizationBase", - cereal::base_class<wolf::LocalParametrizationBase>(&lp)) ); -} - -} //namespace cereal - -#endif /* _WOLF_IO_CEREAL_LOCAL_PARAMETRIZATION_BASE_HOMOGENEOUS_H_ */ diff --git a/serialization/cereal/serialization_local_parametrization_quaternion.h b/serialization/cereal/serialization_local_parametrization_quaternion.h deleted file mode 100644 index 66fe30a361f0f1878a9444d9fb487ad2a068ad0d..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_local_parametrization_quaternion.h +++ /dev/null @@ -1,30 +0,0 @@ -#ifndef WOLF_IO_SERIALIZATION_LOCAL_PARAMETRIZATION_QUATERNION_H_ -#define WOLF_IO_SERIALIZATION_LOCAL_PARAMETRIZATION_QUATERNION_H_ - -#include "core/local_parametrization_quaternion.h" - -#include "serialization_local_parametrization_base.h" - -#include <cereal/cereal.hpp> - -CEREAL_REGISTER_TYPE_WITH_NAME(wolf::LocalParametrizationQuaternion<wolf::DQ_LOCAL>, - "wolf_LocalParametrizationQuaternion_DQ_LOCAL") - -CEREAL_REGISTER_TYPE_WITH_NAME(wolf::LocalParametrizationQuaternion<wolf::DQ_GLOBAL>, - "wolf_LocalParametrizationQuaternion_DQ_GLOBAL") - -namespace cereal { - -template<class Archive, unsigned int DeltaReference> -inline void serialize( - Archive &ar, - wolf::LocalParametrizationQuaternion<DeltaReference> &lp, - const unsigned int /*file_version*/) -{ - ar( cereal::make_nvp("LocalParametrizationBase", - cereal::base_class<wolf::LocalParametrizationBase>(&lp)) ); -} - -} //namespace boost - -#endif /* WOLF_IO_SERIALIZATION_LOCAL_PARAMETRIZATION_QUATERNION_H_ */ diff --git a/serialization/cereal/serialization_node_base.h b/serialization/cereal/serialization_node_base.h deleted file mode 100644 index a2c592d6982485de2aebf189e09e764b68022783..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_node_base.h +++ /dev/null @@ -1,77 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_NODE_BASE_H_ -#define _WOLF_IO_CEREAL_NODE_BASE_H_ - -// Wolf includes -#include "core/node_base.h" - -#include <cereal/cereal.hpp> -#include <cereal/types/polymorphic.hpp> - -namespace wolf { - -struct NodeBase::Serializer { - - template <class Archive> - static void serialize(Archive& ar, NodeBase& o, std::uint32_t const /*version*/) - { - ar( cereal::make_nvp("node_class_", o.node_category_) ); - ar( cereal::make_nvp("node_type_", o.node_type_) ); - ar( cereal::make_nvp("node_name_", o.node_name_) ); - ar( cereal::make_nvp("node_id_", o.node_id_) ); - -// ar( cereal::make_nvp("problem_ptr_", o.problem_ptr_) ); - - // Not sure what to do with this guy ... - //ar( cereal::make_nvp("node_id_count_", o.node_id_count_) ); - } - - template <class Archive> - static void load_and_construct( Archive& ar, cereal::construct<wolf::NodeBase>& construct, - std::uint32_t const /*version*/ ) - { - decltype(std::declval<wolf::NodeBase>().getCategory()) nb_class; - decltype(std::declval<wolf::NodeBase>().getType()) nb_type; - decltype(std::declval<wolf::NodeBase>().getName()) nb_name; - - ar( cereal::make_nvp("node_class_", nb_class) ); - ar( cereal::make_nvp("node_type_", nb_type) ); - ar( cereal::make_nvp("node_name_", nb_name) ); - - construct( nb_class, nb_type, nb_name ); - - ar( cereal::make_nvp("node_id_", construct->node_id_) ); - -// ar( cereal::make_nvp("problem_ptr_", construct->problem_ptr_) ); - - // Not sure what to do with this guy ... - //ar( cereal::make_nvp("node_id_count_", construct->node_id_count_) ); - } -}; - -} // namespace wolf - -namespace cereal { - -/// @note No default constructor thus the need -/// for these specializations -template <> -struct LoadAndConstruct<wolf::NodeBase> -{ - template <class Archive> - static void load_and_construct( Archive& ar, - cereal::construct<wolf::NodeBase>& construct, - std::uint32_t const version ) - { - wolf::NodeBase::Serializer::load_and_construct(ar, construct, version); - } -}; - -template <class Archive> -void serialize(Archive& ar, wolf::NodeBase& o, std::uint32_t const version) -{ - wolf::NodeBase::Serializer::serialize(ar, o, version); -} - -} // namespace cereal - -#endif /* _WOLF_IO_CEREAL_NODE_BASE_H_ */ diff --git a/serialization/cereal/serialization_processor_odom2d_params.h b/serialization/cereal/serialization_processor_odom2d_params.h deleted file mode 100644 index dc0416b94634ef8415919c26fa972c86edb99a00..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_processor_odom2d_params.h +++ /dev/null @@ -1,29 +0,0 @@ -#ifndef _WOLF_SERIALIZATION_CEREAL_PROCESSOR_ODOM2D_PARAMS_H_ -#define _WOLF_SERIALIZATION_CEREAL_PROCESSOR_ODOM2D_PARAMS_H_ - -// Wolf includes -#include "core/processor/processor_odom_2D.h" -#include "serialization_processor_params_base.h" - -namespace cereal { - -template <class Archive> -void serialize(Archive& ar, wolf::ProcessorParamsOdom2D& o, - std::uint32_t const /*version*/) -{ - ar( cereal::make_nvp("ProcessorParamsBase", - cereal::base_class<wolf::ProcessorParamsBase>(&o)) ); - - ar( cereal::make_nvp("cov_det_th_", o.cov_det) ); - ar( cereal::make_nvp("dist_traveled_th_", o.dist_traveled_th_) ); - ar( cereal::make_nvp("elapsed_time_th_", o.elapsed_time_th_) ); - ar( cereal::make_nvp("theta_traveled_th_", o.theta_traveled_th_) ); - ar( cereal::make_nvp("unmeasured_perturbation_std_", - o.unmeasured_perturbation_std) ); -} - -} // namespace cereal - -CEREAL_REGISTER_TYPE_WITH_NAME(wolf::ProcessorParamsOdom2D, "ProcessorParamsOdom2D") - -#endif /* _WOLF_SERIALIZATION_CEREAL_PROCESSOR_ODOM3D_PARAMS_H_ */ diff --git a/serialization/cereal/serialization_processor_odom3d_params.h b/serialization/cereal/serialization_processor_odom3d_params.h deleted file mode 100644 index d2fd7c077d868e4dafcfa209c10767415f092ab8..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_processor_odom3d_params.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef _WOLF_SERIALIZATION_CEREAL_PROCESSOR_ODOM3D_PARAMS_H_ -#define _WOLF_SERIALIZATION_CEREAL_PROCESSOR_ODOM3D_PARAMS_H_ - -// Wolf includes -#include "core/processor/processor_odom_3D.h" -#include "serialization_processor_params_base.h" - -namespace cereal { - -template <class Archive> -void serialize(Archive& ar, wolf::ProcessorParamsOdom3D& o, - std::uint32_t const /*version*/) -{ - ar( cereal::make_nvp("ProcessorParamsBase", - cereal::base_class<wolf::ProcessorParamsBase>(&o)) ); - - ar( cereal::make_nvp("angle_turned", o.angle_turned) ); - ar( cereal::make_nvp("dist_traveled", o.dist_traveled) ); - ar( cereal::make_nvp("max_buff_length", o.max_buff_length) ); - ar( cereal::make_nvp("max_time_span", o.max_time_span) ); -} - -} // namespace cereal - -CEREAL_REGISTER_TYPE_WITH_NAME(wolf::ProcessorParamsOdom3D, "ProcessorOdom3DParams") - -#endif /* _WOLF_SERIALIZATION_CEREAL_PROCESSOR_ODOM3D_PARAMS_H_ */ diff --git a/serialization/cereal/serialization_processor_params_base.h b/serialization/cereal/serialization_processor_params_base.h deleted file mode 100644 index 03ea158c07ea0c18516400a6c51618998efb9473..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_processor_params_base.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef _WOLF_SERIALIZATION_CEREAL_PROCESSOR_PARAM_BASE_H_ -#define _WOLF_SERIALIZATION_CEREAL_PROCESSOR_PARAM_BASE_H_ - -// Wolf includes -#include "core/processor/processor_base.h" - -#include <cereal/cereal.hpp> -#include <cereal/types/polymorphic.hpp> - -namespace cereal { - -template <class Archive> -void serialize(Archive& ar, wolf::ProcessorParamsBase& o, - std::uint32_t const /*version*/) -{ - ar( cereal::make_nvp("type", o.type) ); - ar( cereal::make_nvp("name", o.name) ); -} - -} // namespace cereal - -#endif /* _WOLF_SERIALIZATION_CEREAL_SENSOR_INTRINSIC_BASE_H_ */ diff --git a/serialization/cereal/serialization_sensor_intrinsic_base.h b/serialization/cereal/serialization_sensor_intrinsic_base.h deleted file mode 100644 index 86b2a9b482eb61dd290dd2d2723c41415ca11dae..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_sensor_intrinsic_base.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef _WOLF_SERIALIZATION_CEREAL_SENSOR_INTRINSIC_BASE_H_ -#define _WOLF_SERIALIZATION_CEREAL_SENSOR_INTRINSIC_BASE_H_ - -// Wolf includes -#include "core/sensor/sensor_base.h" - -#include <cereal/cereal.hpp> -#include <cereal/types/polymorphic.hpp> - -namespace cereal { - -template <class Archive> -void serialize(Archive& ar, wolf::IntrinsicsBase& o, - std::uint32_t const /*version*/) -{ - ar( cereal::make_nvp("type", o.type) ); - ar( cereal::make_nvp("name", o.name) ); -} - -} // namespace cereal - -// No need to register base -//CEREAL_REGISTER_TYPE_WITH_NAME(wolf::IntrinsicsBase, "IntrinsicsBase"); - -#endif /* _WOLF_SERIALIZATION_CEREAL_SENSOR_INTRINSIC_BASE_H_ */ diff --git a/serialization/cereal/serialization_sensor_odom2d_intrinsic.h b/serialization/cereal/serialization_sensor_odom2d_intrinsic.h deleted file mode 100644 index 17d4160b3751d0a13f0f28836234b500e6674400..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_sensor_odom2d_intrinsic.h +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef _WOLF_SERIALIZATION_CEREAL_SENSOR_ODOM2D_INTRINSIC_H_ -#define _WOLF_SERIALIZATION_CEREAL_SENSOR_ODOM2D_INTRINSIC_H_ - -// Wolf includes -#include "core/sensor/sensor_odom_2D.h" - -#include "serialization_sensor_intrinsic_base.h" - -namespace cereal { - -template <class Archive> -void serialize(Archive& ar, wolf::IntrinsicsOdom2D& o, - std::uint32_t const /*version*/) -{ - ar( cereal::make_nvp("IntrinsicsBase", - cereal::base_class<wolf::IntrinsicsBase>(&o)) ); - - ar( cereal::make_nvp("k_disp_to_disp", o.k_disp_to_disp) ); - ar( cereal::make_nvp("k_rot_to_rot", o.k_rot_to_rot) ); -} - -} // namespace cereal - -CEREAL_REGISTER_TYPE_WITH_NAME(wolf::IntrinsicsOdom2D, "IntrinsicsOdom2D") - -#endif /* _WOLF_SERIALIZATION_CEREAL_SENSOR_ODOM2D_INTRINSIC_H_ */ diff --git a/serialization/cereal/serialization_time_stamp.h b/serialization/cereal/serialization_time_stamp.h deleted file mode 100644 index f0c978d36415be7598f2ba6eb5b83bd9a5cb0a61..0000000000000000000000000000000000000000 --- a/serialization/cereal/serialization_time_stamp.h +++ /dev/null @@ -1,31 +0,0 @@ -#ifndef _WOLF_IO_CEREAL_TIME_STAMP_H_ -#define _WOLF_IO_CEREAL_TIME_STAMP_H_ - -// Wolf includes -#include "core/time_stamp.h" - -#include <cereal/cereal.hpp> - -namespace cereal { - -/// @note serialization versionning raise -/// a compile error here... -template <class Archive> -void save(Archive& ar, const wolf::TimeStamp& o/*, std::uint32_t const version*/) -{ - ar( cereal::make_nvp("value", o.get()) ); -} - -template <class Archive> -void load(Archive& ar, wolf::TimeStamp& o/*, std::uint32_t const version*/) -{ - auto val = o.get(); - - ar( cereal::make_nvp("value", val) ); - - o.set(val); -} - -} // namespace cereal - -#endif /* _WOLF_IO_CEREAL_TIME_STAMP_H_ */ diff --git a/test/serialization/CMakeLists.txt b/test/serialization/CMakeLists.txt deleted file mode 100644 index 6902132bd458245e2e45012662fdcf0b348b7d4a..0000000000000000000000000000000000000000 --- a/test/serialization/CMakeLists.txt +++ /dev/null @@ -1,4 +0,0 @@ -# cereal -IF(cereal_FOUND) - add_subdirectory(cereal) -ENDIF(cereal_FOUND) diff --git a/test/serialization/cereal/CMakeLists.txt b/test/serialization/cereal/CMakeLists.txt deleted file mode 100644 index 733a36e25921c4f7c142d59884fb5c9b7dd9e4e4..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/CMakeLists.txt +++ /dev/null @@ -1,43 +0,0 @@ -# NodeBase serialization class test -wolf_add_gtest(gtest_cereal_serialization_node_base gtest_serialization_node_base.cpp) -target_link_libraries(gtest_cereal_serialization_node_base ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_local_parametrization - gtest_serialization_local_parametrization.cpp) -target_link_libraries(gtest_cereal_serialization_local_parametrization ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_sensor_intrinsic_base - gtest_serialization_sensor_intrinsic_base.cpp) -target_link_libraries(gtest_cereal_serialization_sensor_intrinsic_base ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_sensor_odom2d_intrinsic - gtest_serialization_sensor_odom2d_intrinsic.cpp) -target_link_libraries(gtest_cereal_serialization_sensor_odom2d_intrinsic ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_save_load - gtest_serialization_save_load.cpp) -target_link_libraries(gtest_cereal_serialization_save_load ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_processor_odom3d_params - gtest_serialization_processor_odom3d_params.cpp) -target_link_libraries(gtest_cereal_serialization_processor_odom3d_params ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_processor_odom2d_params - gtest_serialization_processor_odom2d_params.cpp) -target_link_libraries(gtest_cereal_serialization_processor_odom2d_params ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_time_stamp - gtest_serialization_time_stamp.cpp) -target_link_libraries(gtest_cereal_serialization_time_stamp ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_eigen_core - gtest_serialization_eigen_core.cpp) -target_link_libraries(gtest_cereal_serialization_eigen_core ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_eigen_geometry - gtest_serialization_eigen_geometry.cpp) -target_link_libraries(gtest_cereal_serialization_eigen_geometry ${PROJECT_NAME}) - -wolf_add_gtest(gtest_cereal_serialization_eigen_sparse - gtest_serialization_eigen_sparse.cpp) -target_link_libraries(gtest_cereal_serialization_eigen_sparse ${PROJECT_NAME}) diff --git a/test/serialization/cereal/gtest_serialization_eigen_core.cpp b/test/serialization/cereal/gtest_serialization_eigen_core.cpp deleted file mode 100644 index 28859dd7a5b7db706e041489341bf4c010eb126e..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_eigen_core.cpp +++ /dev/null @@ -1,92 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_eigen_core.h" - -#include "../../../serialization/cereal/io.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationEigen : public testing::Test -{ -public: - - WolfTestCerealSerializationEigen() - { - nb_ = f_mat_t::Random(); - - dnb_ = d_mat_t::Random(10, 10); - } - - const std::string path_to_io = "/tmp/"; - const std::string filename = "serialization_eigen"; - - const std::vector<std::string> exts = {".bin"/*, ".xml", ".json"*/}; - - using f_mat_t = Eigen::Matrix<double, 5, 5>; - - using d_mat_t = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>; - - f_mat_t nb_; - - d_mat_t dnb_; -}; - -TEST_F(WolfTestCerealSerializationEigen, - CerealSerializationEigenFixedMat) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename + ext; - - ASSERT_NO_THROW( wolf::save( full_path, nb_ ) ) - << "Failed on saving " << full_path; - - WolfTestCerealSerializationEigen::f_mat_t nb_load; - - ASSERT_NO_THROW( wolf::load( full_path, nb_load ) ) - << "Failed on loading " << full_path; - - EXPECT_EQ(nb_load, nb_) << full_path; - } - - PRINTF("All good at " - "WolfTestCerealSerializationEigen::" - "CerealSerializationEigenFixedMat !\n"); -} - -TEST_F(WolfTestCerealSerializationEigen, - CerealSerializationEigenDynamicMat) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename + ext; - - ASSERT_NO_THROW( wolf::save( full_path, dnb_ ) ) - << "Failed on saving " << full_path; - - WolfTestCerealSerializationEigen::d_mat_t dnb_load; - - ASSERT_NO_THROW( wolf::load( full_path, dnb_load ) ) - << "Failed on loading " << full_path; - - EXPECT_EQ(dnb_load, dnb_) << full_path; - } - - PRINTF("All good at " - "WolfTestCerealSerializationEigen::" - "CerealSerializationEigenDynamicMat !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_eigen_geometry.cpp b/test/serialization/cereal/gtest_serialization_eigen_geometry.cpp deleted file mode 100644 index 87cafb4d5f171bafb74670348cd562ad49b1d306..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_eigen_geometry.cpp +++ /dev/null @@ -1,72 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "core/common/wolf.h" -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_eigen_geometry.h" - -#include "../../../serialization/cereal/io.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationEigenGeo : public testing::Test -{ -public: - - WolfTestCerealSerializationEigenGeo() - { - iso_2d_ = Eigen::Isometry2d(Eigen::Rotation2Dd(0.17)); - iso_2d_.translation() << 0.5, 1.8; - - q_d_ = Eigen::Vector4d().setRandom().normalized(); - - iso_3d_ = Eigen::Isometry3d(q_d_); - iso_3d_.translation() << -7.245, +3.88, 0.0001; - } - - const std::string path_to_io = "/tmp/"; - const std::string filename = "serialization_eigen_geo"; - - const std::vector<std::string> exts = {".bin"/*, ".xml", ".json"*/}; - - Eigen::Isometry2d iso_2d_; - Eigen::Isometry3d iso_3d_; - Eigen::Quaterniond q_d_; -}; - -TEST_F(WolfTestCerealSerializationEigenGeo, - CerealSerializationEigenIso2d) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename + ext; - - ASSERT_NO_THROW( wolf::save( full_path, iso_2d_, iso_3d_, q_d_) ) - << "Failed on saving " << full_path; - - Eigen::Isometry2d iso_2d_loaded; - Eigen::Isometry3d iso_3d_loaded; - Eigen::Quaterniond q_d_loaded; - - ASSERT_NO_THROW( wolf::load( full_path, iso_2d_loaded, iso_3d_loaded, q_d_loaded) ) - << "Failed on loading " << full_path; - - ASSERT_MATRIX_APPROX(iso_2d_.matrix(), iso_2d_loaded.matrix(), wolf::Constants::EPS); - ASSERT_MATRIX_APPROX(iso_3d_.matrix(), iso_3d_loaded.matrix(), wolf::Constants::EPS); - ASSERT_MATRIX_APPROX(q_d_.coeffs(), q_d_loaded.coeffs(), wolf::Constants::EPS); - } - - PRINT_TEST_FINISHED; -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_eigen_sparse.cpp b/test/serialization/cereal/gtest_serialization_eigen_sparse.cpp deleted file mode 100644 index 0b803afdd30778a58b9536343c5ba5248ec8a148..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_eigen_sparse.cpp +++ /dev/null @@ -1,114 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "core/common/wolf.h" -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_eigen_sparse.h" - -#include "../../../serialization/cereal/io.h" - -#include <fstream> - -class WolfTestCerealSerializationEigenSparse : public testing::Test -{ -public: - - using triplet_t = Eigen::Triplet<double>; - using sparse_mat_t = Eigen::SparseMatrix<double>; - - WolfTestCerealSerializationEigenSparse() - { - triplet_list_.reserve(10); - - for(int i=0; i<10; ++i) - triplet_list_.emplace_back(i,i,i*5); - - m_.resize(10, 10); - m_.setFromTriplets(triplet_list_.begin(), triplet_list_.end()); - } - - const std::string path_to_io = "/tmp/"; - const std::string filename_t = "serialization_eigen_triplet"; - const std::string filename_m = "serialization_eigen_sparse"; - - const std::vector<std::string> exts = {".bin", ".xml", ".json"}; - - triplet_t t_ = Eigen::Triplet<double>(1, 2, 5.5); - - std::vector<triplet_t> triplet_list_; - Eigen::SparseMatrix<double> m_; -}; - -TEST_F(WolfTestCerealSerializationEigenSparse, - CerealSerializationEigenTriplet) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename_t + ext; - - ASSERT_NO_THROW( wolf::save( full_path, t_) ) - << "Failed on saving " << full_path; - - triplet_t t; - - ASSERT_NO_THROW( wolf::load( full_path, t) ) - << "Failed on loading " << full_path; - - ASSERT_EQ(t_.row(), t.row()); - ASSERT_EQ(t_.col(), t.col()); - ASSERT_EQ(t_.value(), t.value()); - } - - PRINT_TEST_FINISHED; -} - -TEST_F(WolfTestCerealSerializationEigenSparse, - CerealSerializationEigenSparseMatrix) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename_m + ext; - - ASSERT_NO_THROW( wolf::save( full_path, m_) ) - << "Failed on saving " << full_path; - - sparse_mat_t m; - - ASSERT_NO_THROW( wolf::load( full_path, m) ) - << "Failed on loading " << full_path; - - ASSERT_EQ(m_.rows(), m.rows()); - ASSERT_EQ(m_.cols(), m.cols()); - - std::vector<triplet_t> triplet_list; - triplet_list.reserve(10); - - for (int k=0; k<m.outerSize(); ++k) - for (sparse_mat_t::InnerIterator it(m, k); it; ++it) - { - triplet_list.emplace_back(it.row(), it.col(), it.value()); - } - - ASSERT_EQ(triplet_list_.size(), triplet_list.size()); - - for (int i=0; i<triplet_list_.size(); ++i) - { - ASSERT_EQ(triplet_list_[i].row(), triplet_list[i].row()); - ASSERT_EQ(triplet_list_[i].col(), triplet_list[i].col()); - ASSERT_EQ(triplet_list_[i].value(), triplet_list[i].value()); - } - } - - PRINT_TEST_FINISHED; -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_local_parametrization.cpp b/test/serialization/cereal/gtest_serialization_local_parametrization.cpp deleted file mode 100644 index 3df34a27aa683fb5099cb8c108a25fe0f473f31b..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_local_parametrization.cpp +++ /dev/null @@ -1,571 +0,0 @@ -/* - * gtest_node_base_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_local_parametrization_quaternion.h" -#include "../../../serialization/cereal/serialization_local_parametrization_homogeneous.h" - -#include "../../../serialization/cereal/archives.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -/////////////////////////////////////// -/// LocalParametrizationHomogeneous /// -/////////////////////////////////////// - -const std::string path_to_io = "/tmp/"; - -TEST(TestSerialization, SerializationLocalParametrizationHomogeneousXML) -{ - { - std::ofstream os(path_to_io + "local_parametrization_serialization.xml"); - cereal::XMLOutputArchive archive(os); - - wolf::LocalParametrizationHomogeneous local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_serialization.xml"); - cereal::XMLInputArchive archive(is); - - wolf::LocalParametrizationHomogeneous local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationHomogeneousXML !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationHomogeneousPtrXML) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_ptr_serialization.xml"); - cereal::XMLOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationHomogeneous>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_ptr_serialization.xml"); - cereal::XMLInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationHomogeneous>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationHomogeneousPtrXML !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationHomogeneousJSON) -{ - { - std::ofstream os(path_to_io + "local_parametrization_serialization.json"); - cereal::JSONOutputArchive archive(os); - - wolf::LocalParametrizationHomogeneous local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_serialization.json"); - cereal::JSONInputArchive archive(is); - - wolf::LocalParametrizationHomogeneous local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationHomogeneousJSON !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationHomogeneousPtrJSON) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_ptr_serialization.json"); - cereal::JSONOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationHomogeneous>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_ptr_serialization.json"); - cereal::JSONInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationHomogeneous>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationHomogeneousPtrJSON !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationHomogeneousBIN) -{ - { - std::ofstream os(path_to_io + "local_parametrization_serialization.bin"); - cereal::BinaryOutputArchive archive(os); - - wolf::LocalParametrizationHomogeneous local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_serialization.bin"); - cereal::BinaryInputArchive archive(is); - - wolf::LocalParametrizationHomogeneous local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationHomogeneousBIN !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationHomogeneousPtrBIN) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_ptr_serialization.bin"); - cereal::BinaryOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationHomogeneous>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_ptr_serialization.bin"); - cereal::BinaryInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationHomogeneous>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationHomogeneousPtrBIN !\n"); -} - -////////////////////////////////////// -/// LocalParametrizationQuaternion /// -////////////////////////////////////// - -////////////////////////////////////// -/// LOCAL /// -////////////////////////////////////// - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionXML) -{ - { - std::ofstream os(path_to_io + "local_parametrization_quat_serialization.xml"); - cereal::XMLOutputArchive archive(os); - - wolf::LocalParametrizationQuaternionLocal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quat_serialization.xml"); - cereal::XMLInputArchive archive(is); - - wolf::LocalParametrizationQuaternionLocal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionXML !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionPtrXML) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_quat_ptr_serialization.xml"); - cereal::XMLOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationQuaternionLocal>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quat_ptr_serialization.xml"); - cereal::XMLInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationQuaternionLocal>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionPtrXML !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionJSON) -{ - { - std::ofstream os(path_to_io + "local_parametrization_quat_serialization.json"); - cereal::JSONOutputArchive archive(os); - - wolf::LocalParametrizationQuaternionLocal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quat_serialization.json"); - cereal::JSONInputArchive archive(is); - - wolf::LocalParametrizationQuaternionLocal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionJSON !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionPtrJSON) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_quat_ptr_serialization.json"); - cereal::JSONOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationQuaternionLocal>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quat_ptr_serialization.json"); - cereal::JSONInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationQuaternionLocal>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionPtrJSON !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionBIN) -{ - { - std::ofstream os(path_to_io + "local_parametrization_quat_serialization.bin"); - cereal::BinaryOutputArchive archive(os); - - wolf::LocalParametrizationQuaternionLocal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quat_serialization.bin"); - cereal::BinaryInputArchive archive(is); - - wolf::LocalParametrizationQuaternionLocal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionBIN !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionPtrBIN) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_quat_ptr_serialization.bin"); - cereal::BinaryOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationQuaternionLocal>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quat_ptr_serialization.bin"); - cereal::BinaryInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationQuaternionLocal>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionPtrBIN !\n"); -} - -////////////////////////////////////// -/// GLOBAL /// -////////////////////////////////////// - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionGlobalXML) -{ - { - std::ofstream os(path_to_io + "local_parametrization_quatg_serialization.xml"); - cereal::XMLOutputArchive archive(os); - - wolf::LocalParametrizationQuaternionGlobal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quatg_serialization.xml"); - cereal::XMLInputArchive archive(is); - - wolf::LocalParametrizationQuaternionGlobal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionGlobalXML !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionGlobalPtrXML) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_quatg_ptr_serialization.xml"); - cereal::XMLOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationQuaternionGlobal>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quatg_ptr_serialization.xml"); - cereal::XMLInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationQuaternionGlobal>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionGlobalPtrXML !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionGlobalJSON) -{ - { - std::ofstream os(path_to_io + "local_parametrization_quatg_serialization.json"); - cereal::JSONOutputArchive archive(os); - - wolf::LocalParametrizationQuaternionGlobal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quatg_serialization.json"); - cereal::JSONInputArchive archive(is); - - wolf::LocalParametrizationQuaternionGlobal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionGlobalJSON !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionGlobalPtrJSON) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_quatg_ptr_serialization.json"); - cereal::JSONOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationQuaternionGlobal>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quatg_ptr_serialization.json"); - cereal::JSONInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationQuaternionGlobal>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionGlobalPtrJSON !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionGlobalBIN) -{ - { - std::ofstream os(path_to_io + "local_parametrization_quatg_serialization.bin"); - cereal::BinaryOutputArchive archive(os); - - wolf::LocalParametrizationQuaternionGlobal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quatg_serialization.bin"); - cereal::BinaryInputArchive archive(is); - - wolf::LocalParametrizationQuaternionGlobal local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h.getGlobalSize(), 4); - ASSERT_EQ(local_param_h.getLocalSize(), 3); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionGlobalBIN !\n"); -} - -TEST(TestSerialization, SerializationLocalParametrizationQuaternionGlobalPtrBIN) -{ - using LocalParametrizationPtr = std::shared_ptr<wolf::LocalParametrizationBase> ; - - { - std::ofstream os(path_to_io + "local_parametrization_quatg_ptr_serialization.bin"); - cereal::BinaryOutputArchive archive(os); - - LocalParametrizationPtr local_param_h = - std::make_shared<wolf::LocalParametrizationQuaternionGlobal>(); - - ASSERT_NO_THROW( archive( local_param_h ) ); - } - - { - std::ifstream is(path_to_io + "local_parametrization_quatg_ptr_serialization.bin"); - cereal::BinaryInputArchive archive(is); - - LocalParametrizationPtr local_param_h; - - ASSERT_NO_THROW( archive( local_param_h ) ); - - ASSERT_EQ(local_param_h->getGlobalSize(), 4); - ASSERT_EQ(local_param_h->getLocalSize(), 3); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::LocalParametrizationQuaternionGlobal>(local_param_h) != nullptr); - } - - PRINTF("All good at TestSerialization::SerializationLocalParametrizationQuaternionGlobalPtrBIN !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_node_base.cpp b/test/serialization/cereal/gtest_serialization_node_base.cpp deleted file mode 100644 index 8b6140fe70f6afe484249361a516b59d8b5dcf7b..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_node_base.cpp +++ /dev/null @@ -1,247 +0,0 @@ -/* - * gtest_node_base_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_node_base.h" - -#include "../../../serialization/cereal/archives.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationNodeBase : public testing::Test -{ -public: - - WolfTestCerealSerializationNodeBase() /*: - nb(nb_class), - nb_ptr(std::make_shared<wolf::NodeBase>(nb_class))*/ - { - // - } - - const std::string path_to_io = "/tmp/"; - - decltype(std::declval<wolf::NodeBase>().getCategory()) nb_class = "Foo"; - decltype(std::declval<wolf::NodeBase>().getCategory()) nb_type = "Bar"; - decltype(std::declval<wolf::NodeBase>().getCategory()) nb_name = "Dummy"; - - decltype(std::declval<wolf::NodeBase>().nodeId()) id; - -// wolf::NodeBase nb; -// wolf::NodeBasePtr nb_ptr; -}; - -TEST_F(WolfTestCerealSerializationNodeBase, CerealSerializationNodeBaseXML) -{ - { - // This guy has node_id = 1 - wolf::NodeBase nb(nb_class, nb_type, nb_name); - - id = nb.nodeId(); - - std::ofstream os(path_to_io + "node_base_serialization.xml"); - cereal::XMLOutputArchive xml_archive(os); - - ASSERT_NO_THROW( xml_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "node_base_serialization.xml"); - cereal::XMLInputArchive xml_archive(is); - - // This guy has node_id = 2 - wolf::NodeBase nb("SuperDummy"); - - ASSERT_NO_THROW( xml_archive( nb ) ); - - ASSERT_EQ(nb.getCategory(), nb_class); - ASSERT_EQ(nb.getType(), nb_type); - ASSERT_EQ(nb.getName(), nb_name); - ASSERT_EQ(nb.nodeId(), id); - } - - PRINTF("All good at " - "WolfTestCerealSerializationNodeBase::CerealSerializationNodeBaseXML !\n"); -} - -TEST_F(WolfTestCerealSerializationNodeBase, CerealSerializationNodeBasePtrXML) -{ - { - // This guy has node_id = 3 - wolf::NodeBasePtr nb = std::make_shared<wolf::NodeBase>(nb_class, nb_type, nb_name); - - id = nb->nodeId(); - - std::ofstream os(path_to_io + "node_base_ptr_serialization.xml"); - cereal::XMLOutputArchive xml_archive(os); - - ASSERT_NO_THROW( xml_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "node_base_ptr_serialization.xml"); - cereal::XMLInputArchive xml_archive(is); - - wolf::NodeBasePtr nb; - - ASSERT_NO_THROW( xml_archive( nb ) ); - - ASSERT_EQ(nb->getCategory(), nb_class); - ASSERT_EQ(nb->getType(), nb_type); - ASSERT_EQ(nb->getName(), nb_name); - ASSERT_EQ(nb->nodeId(), id); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::NodeBase>(nb) != nullptr); - } - - PRINTF("All good at " - "WolfTestCerealSerializationNodeBase::CerealSerializationNodeBasePtrXML !\n"); -} - -TEST_F(WolfTestCerealSerializationNodeBase, CerealSerializationNodeBaseJSON) -{ - { - wolf::NodeBase nb(nb_class, nb_type, nb_name); - - id = nb.nodeId(); - - std::ofstream os(path_to_io + "node_base_serialization.json"); - cereal::JSONOutputArchive json_archive(os); - - ASSERT_NO_THROW( json_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "node_base_serialization.json"); - cereal::JSONInputArchive json_archive(is); - - wolf::NodeBase blank("This guy has node_id = 1"); - wolf::NodeBase nb("SuperDummy"); - - ASSERT_NO_THROW( json_archive( nb ) ); - - ASSERT_EQ(nb.getCategory(), nb_class); - ASSERT_EQ(nb.getType(), nb_type); - ASSERT_EQ(nb.getName(), nb_name); - ASSERT_EQ(nb.nodeId(), id); - } - - PRINTF("All good at " - "WolfTestCerealSerializationNodeBase::CerealSerializationNodeBaseJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationNodeBase, CerealSerializationNodeBasePtrJSON) -{ - { - wolf::NodeBasePtr nb = std::make_shared<wolf::NodeBase>(nb_class, nb_type, nb_name); - - id = nb->nodeId(); - - std::ofstream os(path_to_io + "node_base_ptr_serialization.json"); - cereal::JSONOutputArchive json_archive(os); - - ASSERT_NO_THROW( json_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "node_base_ptr_serialization.json"); - cereal::JSONInputArchive json_archive(is); - - wolf::NodeBasePtr nb; - - ASSERT_NO_THROW( json_archive( nb ) ); - - ASSERT_EQ(nb->getCategory(), nb_class); - ASSERT_EQ(nb->getType(), nb_type); - ASSERT_EQ(nb->getName(), nb_name); - ASSERT_EQ(nb->nodeId(), id); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::NodeBase>(nb) != nullptr); - } - - PRINTF("All good at " - "WolfTestCerealSerializationNodeBase::CerealSerializationNodeBasePtrJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationNodeBase, CerealSerializationNodeBaseBinary) -{ - { - wolf::NodeBase nb(nb_class, nb_type, nb_name); - - id = nb.nodeId(); - - std::ofstream os(path_to_io + "node_base_serialization.bin"); - cereal::BinaryOutputArchive bin_archive(os); - - ASSERT_NO_THROW( bin_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "node_base_serialization.bin"); - cereal::BinaryInputArchive bin_archive(is); - - wolf::NodeBase blank("This guy has node_id = 1"); - wolf::NodeBase nb("SuperDummy"); - - ASSERT_NO_THROW( bin_archive( nb ) ); - - ASSERT_EQ(nb.getCategory(), nb_class); - ASSERT_EQ(nb.getType(), nb_type); - ASSERT_EQ(nb.getName(), nb_name); - ASSERT_EQ(nb.nodeId(), id); - } - - PRINTF("All good at " - "WolfTestCerealSerializationNodeBase::CerealSerializationNodeBaseBinary !\n"); -} - -TEST_F(WolfTestCerealSerializationNodeBase, CerealSerializationNodeBasePtrBinary) -{ - { - wolf::NodeBasePtr nb = std::make_shared<wolf::NodeBase>(nb_class, nb_type, nb_name); - - id = nb->nodeId(); - - std::ofstream os(path_to_io + "node_base_ptr_serialization.bin"); - cereal::BinaryOutputArchive bin_archive(os); - - ASSERT_NO_THROW( bin_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "node_base_ptr_serialization.bin"); - cereal::BinaryInputArchive bin_archive(is); - - wolf::NodeBasePtr nb; - - ASSERT_NO_THROW( bin_archive( nb ) ); - - ASSERT_EQ(nb->getCategory(), nb_class); - ASSERT_EQ(nb->getType(), nb_type); - ASSERT_EQ(nb->getName(), nb_name); - ASSERT_EQ(nb->nodeId(), id); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::NodeBase>(nb) != nullptr); - } - - PRINTF("All good at " - "WolfTestCerealSerializationNodeBase::CerealSerializationNodeBasePtrBinary !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_processor_odom2d_params.cpp b/test/serialization/cereal/gtest_serialization_processor_odom2d_params.cpp deleted file mode 100644 index 89fbef3d69dff80688dd234b0cec3742233b9220..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_processor_odom2d_params.cpp +++ /dev/null @@ -1,108 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_processor_odom2d_params.h" - -#include "../../../serialization/cereal/io.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationProcessorParamsOdom2D : public testing::Test -{ -public: - - WolfTestCerealSerializationProcessorParamsOdom2D() - { - nb_.name = "NAME"; - nb_.type = "ODOM 2D"; - - nb_.dist_traveled_th_ = 0.17; - nb_.theta_traveled_th_ = 0.3; - nb_.cov_det = 0.4; - nb_.elapsed_time_th_ = 1.5; - nb_.unmeasured_perturbation_std = 1e-5; - } - - const std::string path_to_io = "/tmp/"; - const std::string filename = "serialization_processor_odom2d_params"; - const std::string ptr_ext = "_ptr"; - - const std::vector<std::string> exts = {".bin", ".xml", ".json"}; - - wolf::ProcessorParamsOdom2D nb_; -}; - -TEST_F(WolfTestCerealSerializationProcessorParamsOdom2D, - CerealSerializationProcessorParamsOdom2D) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename + ext; - - ASSERT_NO_THROW( wolf::save( full_path, nb_ ) ) - << "Failed on saving " << full_path; - - wolf::ProcessorParamsOdom2D nb_load; - - ASSERT_NO_THROW( wolf::load( full_path, nb_load ) ) - << "Failed on loading " << full_path; - - ASSERT_EQ(nb_load.type, nb_.type) << full_path; - ASSERT_EQ(nb_load.name, nb_.name) << full_path; - ASSERT_EQ(nb_load.dist_traveled_th_, nb_.dist_traveled_th_) << full_path; - ASSERT_EQ(nb_load.theta_traveled_th_, nb_.theta_traveled_th_) << full_path; - ASSERT_EQ(nb_load.cov_det, nb_.cov_det) << full_path; - ASSERT_EQ(nb_load.unmeasured_perturbation_std, - nb_.unmeasured_perturbation_std) << full_path; - - /// Testing BasePtr - - const std::string ptr_full_path = path_to_io + filename + ptr_ext + ext; - - { - wolf::ProcessorParamsBasePtr nb = - std::make_shared<wolf::ProcessorParamsOdom2D>(nb_); - - ASSERT_NO_THROW( wolf::save( ptr_full_path, nb ) ) - << "Failed on saving " << ptr_full_path; - } - - { - wolf::ProcessorParamsBasePtr nb; - - ASSERT_NO_THROW( wolf::load( ptr_full_path, nb ) ) - << "Failed on loading " << ptr_full_path; - - wolf::ProcessorParamsOdom2DPtr nb_cast = - std::dynamic_pointer_cast<wolf::ProcessorParamsOdom2D>(nb); - - ASSERT_TRUE(nb_cast != nullptr) - << "Failed on casting " << ptr_full_path; - - ASSERT_EQ(nb_cast->type, nb_.type) << full_path; - ASSERT_EQ(nb_cast->name, nb_.name) << full_path; - ASSERT_EQ(nb_cast->dist_traveled_th_, nb_.dist_traveled_th_) << full_path; - ASSERT_EQ(nb_cast->theta_traveled_th_, nb_.theta_traveled_th_) << full_path; - ASSERT_EQ(nb_cast->cov_det, nb_.cov_det) << full_path; - ASSERT_EQ(nb_cast->unmeasured_perturbation_std, - nb_.unmeasured_perturbation_std) << full_path; - } - } - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorParamsOdom2D::" - "CerealSerializationProcessorParamsOdom2D !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_processor_odom3d_params.cpp b/test/serialization/cereal/gtest_serialization_processor_odom3d_params.cpp deleted file mode 100644 index 41b2ca2f1b9c9eb6671ed81b4b04b5d97fb847d1..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_processor_odom3d_params.cpp +++ /dev/null @@ -1,246 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_processor_odom3d_params.h" - -#include "../../../serialization/cereal/io.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationProcessorOdom3DParams : public testing::Test -{ -public: - - WolfTestCerealSerializationProcessorOdom3DParams() - { - nb_.name = "NAME"; - //nb_.type = "ODOM 3D"; - - nb_.max_time_span = 1.5; - nb_.max_buff_length = 55.; - nb_.dist_traveled = .25; - nb_.angle_turned = .17; - } - - const std::string path_to_io = "/tmp/"; - - wolf::ProcessorParamsOdom3D nb_; -}; - -TEST_F(WolfTestCerealSerializationProcessorOdom3DParams, - CerealSerializationProcessorOdom3DParamsXML) -{ - const std::string filename(path_to_io + "params_odom3d_serialization.xml"); - - wolf::ProcessorParamsOdom3D nb_save; - nb_save.name = "NAME2"; - //nb_.type = "ODOM 3D"; - - nb_save.max_time_span = 2.5; - nb_save.max_buff_length = 52.; - nb_save.dist_traveled = .24; - nb_save.angle_turned = .18; - - ASSERT_NO_THROW( wolf::save( filename, nb_, nb_save, 10 ) ); - - { - wolf::ProcessorParamsOdom3D nb_load; - - ASSERT_NO_THROW( wolf::load( filename, nb_load ) ); - - ASSERT_EQ(nb_load.type, nb_.type); - ASSERT_EQ(nb_load.name, nb_.name); - ASSERT_EQ(nb_load.max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_load.max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_load.dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_load.angle_turned, nb_.angle_turned); - - wolf::ProcessorParamsOdom3D nb_load0, nb_load1; - int myint; - ASSERT_NO_THROW( wolf::load( filename, nb_load0, nb_load1, myint ) ); - - ASSERT_EQ(nb_load0.type, nb_.type); - ASSERT_EQ(nb_load0.name, nb_.name); - ASSERT_EQ(nb_load0.max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_load0.max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_load0.dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_load0.angle_turned, nb_.angle_turned); - - ASSERT_EQ(nb_load1.type, nb_save.type); - ASSERT_EQ(nb_load1.name, nb_save.name); - ASSERT_EQ(nb_load1.max_time_span, nb_save.max_time_span); - ASSERT_EQ(nb_load1.max_buff_length, nb_save.max_buff_length); - ASSERT_EQ(nb_load1.dist_traveled, nb_save.dist_traveled); - ASSERT_EQ(nb_load1.angle_turned, nb_save.angle_turned); - - ASSERT_EQ(myint, 10); - } - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorOdom3DParams::" - "CerealSerializationProcessorOdom3DParamsXML !\n"); -} - -TEST_F(WolfTestCerealSerializationProcessorOdom3DParams, - CerealSerializationProcessorParamsOdom3DPtrXML) -{ - const std::string filename(path_to_io + "params_odom3d_ptr_serialization.xml"); - - { - wolf::ProcessorParamsBasePtr nb = - std::make_shared<wolf::ProcessorParamsOdom3D>(nb_); - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::ProcessorParamsBasePtr nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - wolf::ProcessorParamsOdom3DPtr nb_cast = - std::dynamic_pointer_cast<wolf::ProcessorParamsOdom3D>(nb); - - ASSERT_TRUE(nb_cast != nullptr); - - ASSERT_EQ(nb_cast->type, nb_.type); - ASSERT_EQ(nb_cast->name, nb_.name); - ASSERT_EQ(nb_cast->max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_cast->max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_cast->dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_cast->angle_turned, nb_.angle_turned); - } - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorOdom3DParams::" - "CerealSerializationProcessorParamsOdom3DPtrXML !\n"); -} - -TEST_F(WolfTestCerealSerializationProcessorOdom3DParams, - CerealSerializationProcessorOdom3DParamsJSON) -{ - const std::string filename(path_to_io + "params_odom3d_serialization.json"); - - ASSERT_NO_THROW( wolf::save( filename, nb_ ) ); - - wolf::ProcessorParamsOdom3D nb_load; - - ASSERT_NO_THROW( wolf::load( filename, nb_load ) ); - - ASSERT_EQ(nb_load.type, nb_.type); - ASSERT_EQ(nb_load.name, nb_.name); - ASSERT_EQ(nb_load.max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_load.max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_load.dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_load.angle_turned, nb_.angle_turned); - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorOdom3DParams::" - "CerealSerializationProcessorOdom3DParamsJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationProcessorOdom3DParams, - CerealSerializationProcessorParamsOdom3DPtrJSON) -{ - const std::string filename(path_to_io + "params_odom3d_ptr_serialization.json"); - - { - wolf::ProcessorParamsBasePtr nb = - std::make_shared<wolf::ProcessorParamsOdom3D>(nb_); - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::ProcessorParamsBasePtr nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - wolf::ProcessorParamsOdom3DPtr nb_cast = - std::dynamic_pointer_cast<wolf::ProcessorParamsOdom3D>(nb); - - ASSERT_TRUE(nb_cast != nullptr); - - ASSERT_EQ(nb_cast->type, nb_.type); - ASSERT_EQ(nb_cast->name, nb_.name); - ASSERT_EQ(nb_cast->max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_cast->max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_cast->dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_cast->angle_turned, nb_.angle_turned); - } - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorOdom3DParams::" - "CerealSerializationProcessorParamsOdom3DPtrJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationProcessorOdom3DParams, - CerealSerializationProcessorOdom3DParamsBinary) -{ - const std::string filename(path_to_io + "params_odom3d_serialization.bin"); - - ASSERT_NO_THROW( wolf::save( filename, nb_ ) ); - - wolf::ProcessorParamsOdom3D nb_load; - - ASSERT_NO_THROW( wolf::load( filename, nb_load ) ); - - ASSERT_EQ(nb_load.type, nb_.type); - ASSERT_EQ(nb_load.name, nb_.name); - ASSERT_EQ(nb_load.max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_load.max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_load.dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_load.angle_turned, nb_.angle_turned); - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorOdom3DParams::" - "CerealSerializationProcessorOdom3DParamsBinary !\n"); -} - -TEST_F(WolfTestCerealSerializationProcessorOdom3DParams, - CerealSerializationProcessorParamsOdom3DPtrBinary) -{ - const std::string filename(path_to_io + "params_odom3d_ptr_serialization.bin"); - - { - wolf::ProcessorParamsBasePtr nb = - std::make_shared<wolf::ProcessorParamsOdom3D>(nb_); - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::ProcessorParamsBasePtr nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - wolf::ProcessorParamsOdom3DPtr nb_cast = - std::dynamic_pointer_cast<wolf::ProcessorParamsOdom3D>(nb); - - ASSERT_TRUE(nb_cast != nullptr); - - ASSERT_EQ(nb_cast->type, nb_.type); - ASSERT_EQ(nb_cast->name, nb_.name); - ASSERT_EQ(nb_cast->max_time_span, nb_.max_time_span); - ASSERT_EQ(nb_cast->max_buff_length, nb_.max_buff_length); - ASSERT_EQ(nb_cast->dist_traveled, nb_.dist_traveled); - ASSERT_EQ(nb_cast->angle_turned, nb_.angle_turned); - } - - PRINTF("All good at " - "WolfTestCerealSerializationProcessorOdom3DParams::" - "CerealSerializationProcessorParamsOdom3DPtrBinary !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_save_load.cpp b/test/serialization/cereal/gtest_serialization_save_load.cpp deleted file mode 100644 index 23241af4887a43db6d48f027b30481e3408ade49..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_save_load.cpp +++ /dev/null @@ -1,202 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/io.h" -#include "../../../serialization/cereal/serialization_sensor_odom2d_intrinsic.h" - -#include "../../../serialization/cereal/archives.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -namespace wolf { - -using IntrinsicsOdom2DPtr = std::shared_ptr<IntrinsicsOdom2D>; - -} - -class WolfTestCerealSerializationSaveLoad : public testing::Test -{ -public: - - WolfTestCerealSerializationSaveLoad() - { - // - } - - const std::string path_to_io = "/tmp/"; - - decltype(std::declval<wolf::IntrinsicsOdom2D>().type) nb_type = "TYPE"; - decltype(std::declval<wolf::IntrinsicsOdom2D>().name) nb_name = "NAME"; - decltype(std::declval<wolf::IntrinsicsOdom2D>().k_disp_to_disp) nb_k_disp_to_disp = 0.54; - decltype(std::declval<wolf::IntrinsicsOdom2D>().k_rot_to_rot) nb_k_rot_to_rot = 0.18; -}; - -TEST_F(WolfTestCerealSerializationSaveLoad, CerealSerializationSaveLoadExtension) -{ - const std::string xml = "/test/filename.xml"; - const std::string bin = "/test/filename.bin"; - const std::string json = "/test/filename.json"; - - ASSERT_EQ(wolf::serialization::extension(xml), ".xml"); - ASSERT_EQ(wolf::serialization::extension(bin), ".bin"); - ASSERT_EQ(wolf::serialization::extension(json), ".json"); -} - -TEST_F(WolfTestCerealSerializationSaveLoad, - CerealSerializationSaveLoadXML) -{ - const std::string filename = path_to_io + "save_load_serialization.xml"; - - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_type; - nb.name = nb_name; - nb.k_disp_to_disp = nb_k_disp_to_disp; - nb.k_rot_to_rot = nb_k_rot_to_rot; - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - ASSERT_EQ(nb.k_disp_to_disp, nb_k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationSaveLoad::" - "CerealSerializationSaveLoadXML !\n"); -} - -TEST_F(WolfTestCerealSerializationSaveLoad, - CerealSerializationSaveLoadJSON) -{ - const std::string filename = path_to_io + "save_load_serialization.json"; - - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_type; - nb.name = nb_name; - nb.k_disp_to_disp = nb_k_disp_to_disp; - nb.k_rot_to_rot = nb_k_rot_to_rot; - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - ASSERT_EQ(nb.k_disp_to_disp, nb_k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationSaveLoad::" - "CerealSerializationSaveLoadJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationSaveLoad, - CerealSerializationSaveLoadBinary) -{ - const std::string filename = path_to_io + "save_load_serialization.bin"; - - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_type; - nb.name = nb_name; - nb.k_disp_to_disp = nb_k_disp_to_disp; - nb.k_rot_to_rot = nb_k_rot_to_rot; - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - ASSERT_EQ(nb.k_disp_to_disp, nb_k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationSaveLoad::" - "CerealSerializationSaveLoadBinary !\n"); -} - -TEST_F(WolfTestCerealSerializationSaveLoad, - CerealSerializationSaveLoadNoExt) -{ - const std::string filename = path_to_io + "save_load_serialization_no_ext"; - - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_type; - nb.name = nb_name; - nb.k_disp_to_disp = nb_k_disp_to_disp; - nb.k_rot_to_rot = nb_k_rot_to_rot; - - ASSERT_NO_THROW( wolf::save( filename, nb ) ); - } - - { - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( wolf::load( filename, nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - ASSERT_EQ(nb.k_disp_to_disp, nb_k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationSaveLoad::" - "CerealSerializationSaveLoadNoExt !\n"); -} - -TEST_F(WolfTestCerealSerializationSaveLoad, - CerealSerializationSaveLoadUnknownExt) -{ - const std::string filename = path_to_io + "save_load_serialization.foo"; - - { - wolf::IntrinsicsOdom2D nb; - - ASSERT_THROW( wolf::save( filename, nb ), std::runtime_error ); - } - - { - wolf::IntrinsicsOdom2D nb; - - ASSERT_THROW( wolf::load( filename, nb ), std::runtime_error ); - } - - PRINTF("All good at " - "WolfTestCerealSerializationSaveLoad::" - "CerealSerializationSaveLoadUnknownExt !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_sensor_intrinsic_base.cpp b/test/serialization/cereal/gtest_serialization_sensor_intrinsic_base.cpp deleted file mode 100644 index a8a67dc1977d184a91a26cae2420f1a04ef5a0ee..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_sensor_intrinsic_base.cpp +++ /dev/null @@ -1,233 +0,0 @@ -/* - * gtest_intrinsics_base_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_sensor_intrinsic_base.h" - -#include "../../../serialization/cereal/archives.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationIntrinsicsBase : public testing::Test -{ -public: - - WolfTestCerealSerializationIntrinsicsBase() - { - // - } - - const std::string path_to_io = "/tmp/"; - - decltype(std::declval<wolf::IntrinsicsBase>().type) nb_type = "TYPE"; - decltype(std::declval<wolf::IntrinsicsBase>().name) nb_name = "NAME"; -}; - -TEST_F(WolfTestCerealSerializationIntrinsicsBase, - CerealSerializationIntrinsicsBaseXML) -{ - { - wolf::IntrinsicsBase nb; - nb.type = nb_type; - nb.name = nb_name; - - std::ofstream os(path_to_io + "intrinsics_base_serialization.xml"); - cereal::XMLOutputArchive xml_archive(os); - - ASSERT_NO_THROW( xml_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_base_serialization.xml"); - cereal::XMLInputArchive xml_archive(is); - - wolf::IntrinsicsBase nb; - - ASSERT_NO_THROW( xml_archive( nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsBase::" - "CerealSerializationIntrinsicsBaseXML !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsBase, - CerealSerializationIntrinsicsBasePtrXML) -{ - { - wolf::IntrinsicsBasePtr nb = std::make_shared<wolf::IntrinsicsBase>(); - nb->name = nb_name; - nb->type = nb_type; - - std::ofstream os(path_to_io + "intrinsics_base_ptr_serialization.xml"); - cereal::XMLOutputArchive xml_archive(os); - - ASSERT_NO_THROW( xml_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_base_ptr_serialization.xml"); - cereal::XMLInputArchive xml_archive(is); - - wolf::IntrinsicsBasePtr nb; - - ASSERT_NO_THROW( xml_archive( nb ) ); - - ASSERT_EQ(nb->type, nb_type); - ASSERT_EQ(nb->name, nb_name); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::IntrinsicsBase>(nb) != nullptr); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsBase::" - "CerealSerializationIntrinsicsBasePtrXML !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsBase, - CerealSerializationIntrinsicsBaseJSON) -{ - { - wolf::IntrinsicsBase nb; - nb.type = nb_type; - nb.name = nb_name; - - std::ofstream os(path_to_io + "intrinsics_base_serialization.json"); - cereal::JSONOutputArchive json_archive(os); - - ASSERT_NO_THROW( json_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_base_serialization.json"); - cereal::JSONInputArchive json_archive(is); - - wolf::IntrinsicsBase nb; - - ASSERT_NO_THROW( json_archive( nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsBase::" - "CerealSerializationIntrinsicsBaseJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsBase, - CerealSerializationIntrinsicsBasePtrJSON) -{ - { - wolf::IntrinsicsBasePtr nb = std::make_shared<wolf::IntrinsicsBase>(); - nb->name = nb_name; - nb->type = nb_type; - - std::ofstream os(path_to_io + "intrinsics_base_ptr_serialization.json"); - cereal::JSONOutputArchive json_archive(os); - - ASSERT_NO_THROW( json_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_base_ptr_serialization.json"); - cereal::JSONInputArchive json_archive(is); - - wolf::IntrinsicsBasePtr nb; - - ASSERT_NO_THROW( json_archive( nb ) ); - - ASSERT_EQ(nb->type, nb_type); - ASSERT_EQ(nb->name, nb_name); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::IntrinsicsBase>(nb) != nullptr); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsBase::" - "CerealSerializationIntrinsicsBasePtrJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsBase, - CerealSerializationIntrinsicsBaseBinary) -{ - { - wolf::IntrinsicsBase nb; - nb.type = nb_type; - nb.name = nb_name; - - std::ofstream os(path_to_io + "intrinsics_base_serialization.bin"); - cereal::BinaryOutputArchive bin_archive(os); - - ASSERT_NO_THROW( bin_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_base_serialization.bin"); - cereal::BinaryInputArchive bin_archive(is); - - wolf::IntrinsicsBase nb; - - ASSERT_NO_THROW( bin_archive( nb ) ); - - ASSERT_EQ(nb.type, nb_type); - ASSERT_EQ(nb.name, nb_name); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsBase::" - "CerealSerializationIntrinsicsBaseBinary !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsBase, CerealSerializationIntrinsicsBasePtrBinary) -{ - { - wolf::IntrinsicsBasePtr nb = std::make_shared<wolf::IntrinsicsBase>(); - nb->name = nb_name; - nb->type = nb_type; - - std::ofstream os(path_to_io + "intrinsics_base_ptr_serialization.bin"); - cereal::BinaryOutputArchive bin_archive(os); - - ASSERT_NO_THROW( bin_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_base_ptr_serialization.bin"); - cereal::BinaryInputArchive bin_archive(is); - - wolf::IntrinsicsBasePtr nb; - - ASSERT_NO_THROW( bin_archive( nb ) ); - - ASSERT_EQ(nb->type, nb_type); - ASSERT_EQ(nb->name, nb_name); - - ASSERT_TRUE( - std::dynamic_pointer_cast< - wolf::IntrinsicsBase>(nb) != nullptr); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsBase::" - "CerealSerializationIntrinsicsBasePtrBinary !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_sensor_odom2d_intrinsic.cpp b/test/serialization/cereal/gtest_serialization_sensor_odom2d_intrinsic.cpp deleted file mode 100644 index c5891c3d91d020293937236e582535ddd2e2beaf..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_sensor_odom2d_intrinsic.cpp +++ /dev/null @@ -1,256 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_sensor_odom2d_intrinsic.h" - -#include "../../../serialization/cereal/archives.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -namespace wolf { - -using IntrinsicsOdom2DPtr = std::shared_ptr<IntrinsicsOdom2D>; - -} - -class WolfTestCerealSerializationIntrinsicsOdom2D : public testing::Test -{ -public: - - WolfTestCerealSerializationIntrinsicsOdom2D() - { - nb_.k_disp_to_disp = 0.54; - nb_.k_rot_to_rot = 0.18; - nb_.name = "NAME"; - nb_.type = "TYPE"; - } - - const std::string path_to_io = "/tmp/"; - - wolf::IntrinsicsOdom2D nb_; -}; - -TEST_F(WolfTestCerealSerializationIntrinsicsOdom2D, - CerealSerializationIntrinsicsOdom2DXML) -{ - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_.type; - nb.name = nb_.name; - nb.k_disp_to_disp = nb_.k_disp_to_disp; - nb.k_rot_to_rot = nb_.k_rot_to_rot; - - std::ofstream os(path_to_io + "intrinsics_odom2d_serialization.xml"); - cereal::XMLOutputArchive xml_archive(os); - - ASSERT_NO_THROW( xml_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_odom2d_serialization.xml"); - cereal::XMLInputArchive xml_archive(is); - - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( xml_archive( nb ) ); - - ASSERT_EQ(nb.type, nb_.type); - ASSERT_EQ(nb.name, nb_.name); - ASSERT_EQ(nb.k_disp_to_disp, nb_.k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_.k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsOdom2D::" - "CerealSerializationIntrinsicsOdom2DXML !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsOdom2D, - CerealSerializationIntrinsicsOdom2DPtrXML) -{ - { - wolf::IntrinsicsBasePtr nb = std::make_shared<wolf::IntrinsicsOdom2D>(nb_); - - std::ofstream os(path_to_io + "intrinsics_odom2d_ptr_serialization.xml"); - cereal::XMLOutputArchive xml_archive(os); - - ASSERT_NO_THROW( xml_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_odom2d_ptr_serialization.xml"); - cereal::XMLInputArchive xml_archive(is); - - wolf::IntrinsicsBasePtr nb; - - ASSERT_NO_THROW( xml_archive( nb ) ); - - wolf::IntrinsicsOdom2DPtr nb_cast = - std::dynamic_pointer_cast<wolf::IntrinsicsOdom2D>(nb); - - ASSERT_TRUE(nb_cast != nullptr); - - ASSERT_EQ(nb_cast->type, nb_.type); - ASSERT_EQ(nb_cast->name, nb_.name); - ASSERT_EQ(nb_cast->k_disp_to_disp, nb_.k_disp_to_disp); - ASSERT_EQ(nb_cast->k_rot_to_rot, nb_.k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsOdom2D::" - "CerealSerializationIntrinsicsOdom2DPtrXML !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsOdom2D, - CerealSerializationIntrinsicsOdom2DJSON) -{ - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_.type; - nb.name = nb_.name; - nb.k_disp_to_disp = nb_.k_disp_to_disp; - nb.k_rot_to_rot = nb_.k_rot_to_rot; - - std::ofstream os(path_to_io + "intrinsics_odom2d_serialization.json"); - cereal::JSONOutputArchive json_archive(os); - - ASSERT_NO_THROW( json_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_odom2d_serialization.json"); - cereal::JSONInputArchive json_archive(is); - - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( json_archive( nb ) ); - - ASSERT_EQ(nb.type, nb_.type); - ASSERT_EQ(nb.name, nb_.name); - ASSERT_EQ(nb.k_disp_to_disp, nb_.k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_.k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsOdom2D::" - "CerealSerializationIntrinsicsOdom2DJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsOdom2D, - CerealSerializationIntrinsicsOdom2DPtrJSON) -{ - { - wolf::IntrinsicsBasePtr nb = std::make_shared<wolf::IntrinsicsOdom2D>(nb_); - - std::ofstream os(path_to_io + "intrinsics_odom2d_ptr_serialization.json"); - cereal::JSONOutputArchive json_archive(os); - - ASSERT_NO_THROW( json_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_odom2d_ptr_serialization.json"); - cereal::JSONInputArchive json_archive(is); - - wolf::IntrinsicsBasePtr nb; - - ASSERT_NO_THROW( json_archive( nb ) ); - - wolf::IntrinsicsOdom2DPtr nb_cast = - std::dynamic_pointer_cast<wolf::IntrinsicsOdom2D>(nb); - - ASSERT_TRUE(nb_cast != nullptr); - - ASSERT_EQ(nb_cast->type, nb_.type); - ASSERT_EQ(nb_cast->name, nb_.name); - ASSERT_EQ(nb_cast->k_disp_to_disp, nb_.k_disp_to_disp); - ASSERT_EQ(nb_cast->k_rot_to_rot, nb_.k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsOdom2D::" - "CerealSerializationIntrinsicsOdom2DPtrJSON !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsOdom2D, - CerealSerializationIntrinsicsOdom2DBinary) -{ - { - wolf::IntrinsicsOdom2D nb; - nb.type = nb_.type; - nb.name = nb_.name; - nb.k_disp_to_disp = nb_.k_disp_to_disp; - nb.k_rot_to_rot = nb_.k_rot_to_rot; - - std::ofstream os(path_to_io + "intrinsics_odom2d_serialization.bin"); - cereal::BinaryOutputArchive bin_archive(os); - - ASSERT_NO_THROW( bin_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_odom2d_serialization.bin"); - cereal::BinaryInputArchive bin_archive(is); - - wolf::IntrinsicsOdom2D nb; - - ASSERT_NO_THROW( bin_archive( nb ) ); - - ASSERT_EQ(nb.type, nb_.type); - ASSERT_EQ(nb.name, nb_.name); - ASSERT_EQ(nb.k_disp_to_disp, nb_.k_disp_to_disp); - ASSERT_EQ(nb.k_rot_to_rot, nb_.k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsOdom2D::" - "CerealSerializationIntrinsicsOdom2DBinary !\n"); -} - -TEST_F(WolfTestCerealSerializationIntrinsicsOdom2D, CerealSerializationIntrinsicsOdom2DPtrBinary) -{ - { - wolf::IntrinsicsBasePtr nb = std::make_shared<wolf::IntrinsicsOdom2D>(nb_); - - std::ofstream os(path_to_io + "intrinsics_odom2d_ptr_serialization.bin"); - cereal::BinaryOutputArchive bin_archive(os); - - ASSERT_NO_THROW( bin_archive( nb ) ); - } - - { - std::ifstream is(path_to_io + "intrinsics_odom2d_ptr_serialization.bin"); - cereal::BinaryInputArchive bin_archive(is); - - wolf::IntrinsicsBasePtr nb; - - ASSERT_NO_THROW( bin_archive( nb ) ); - - wolf::IntrinsicsOdom2DPtr nb_cast = - std::dynamic_pointer_cast<wolf::IntrinsicsOdom2D>(nb); - - ASSERT_TRUE(nb_cast != nullptr); - - ASSERT_EQ(nb_cast->type, nb_.type); - ASSERT_EQ(nb_cast->name, nb_.name); - ASSERT_EQ(nb_cast->k_disp_to_disp, nb_.k_disp_to_disp); - ASSERT_EQ(nb_cast->k_rot_to_rot, nb_.k_rot_to_rot); - } - - PRINTF("All good at " - "WolfTestCerealSerializationIntrinsicsOdom2D::" - "CerealSerializationIntrinsicsOdom2DPtrBinary !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/serialization/cereal/gtest_serialization_time_stamp.cpp b/test/serialization/cereal/gtest_serialization_time_stamp.cpp deleted file mode 100644 index 8dc4cd479ad8c3986fbd4286899ab1081b1a9af0..0000000000000000000000000000000000000000 --- a/test/serialization/cereal/gtest_serialization_time_stamp.cpp +++ /dev/null @@ -1,62 +0,0 @@ -/* - * gtest_intrinsics_odom2d_serialization.cpp - * - * Created on: Jul 16, 2017 - * Author: Jeremie Deray - */ - -#include "../../utils_gtest.h" - -#include "../../../serialization/cereal/serialization_time_stamp.h" - -#include "../../../serialization/cereal/io.h" - -#include <cereal/types/memory.hpp> -#include <fstream> - -class WolfTestCerealSerializationTimeStamp : public testing::Test -{ -public: - - WolfTestCerealSerializationTimeStamp() - { - nb_.setToNow(); - } - - const std::string path_to_io = "/tmp/"; - const std::string filename = "serialization_time_stamp"; - const std::string ptr_ext = "_ptr"; - - const std::vector<std::string> exts = {".bin", ".xml", ".json"}; - - wolf::TimeStamp nb_; -}; - -TEST_F(WolfTestCerealSerializationTimeStamp, - CerealSerializationTimeStamp) -{ - for (const auto ext : exts) - { - const std::string full_path = path_to_io + filename + ext; - - ASSERT_NO_THROW( wolf::save( full_path, nb_ ) ) - << "Failed on saving " << full_path; - - wolf::TimeStamp nb_load; - - ASSERT_NO_THROW( wolf::load( full_path, nb_load ) ) - << "Failed on loading " << full_path; - - ASSERT_EQ(nb_load, nb_) << full_path; - } - - PRINTF("All good at " - "WolfTestCerealSerializationTimeStamp::" - "CerealSerializationTimeStamp !\n"); -} - -int main(int argc, char **argv) -{ - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -}