Commit a79b8628 authored by Dominik Charousset's avatar Dominik Charousset

Streamline serialization test using new fixtures

parent c4c211f6
...@@ -26,6 +26,7 @@ ...@@ -26,6 +26,7 @@
#include <set> #include <set>
#include <list> #include <list>
#include <stack> #include <stack>
#include <tuple>
#include <locale> #include <locale>
#include <memory> #include <memory>
#include <string> #include <string>
...@@ -43,7 +44,6 @@ ...@@ -43,7 +44,6 @@
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <tuple>
#include "caf/message.hpp" #include "caf/message.hpp"
#include "caf/announce.hpp" #include "caf/announce.hpp"
...@@ -57,15 +57,15 @@ ...@@ -57,15 +57,15 @@
#include "caf/primitive_variant.hpp" #include "caf/primitive_variant.hpp"
#include "caf/binary_serializer.hpp" #include "caf/binary_serializer.hpp"
#include "caf/binary_deserializer.hpp" #include "caf/binary_deserializer.hpp"
#include "caf/detail/get_mac_addresses.hpp" #include "caf/await_all_actors_done.hpp"
#include "caf/detail/ieee_754.hpp"
#include "caf/detail/int_list.hpp" #include "caf/detail/int_list.hpp"
#include "caf/detail/safe_equal.hpp"
#include "caf/detail/type_traits.hpp" #include "caf/detail/type_traits.hpp"
#include "caf/detail/get_mac_addresses.hpp"
#include "caf/detail/abstract_uniform_type_info.hpp" #include "caf/detail/abstract_uniform_type_info.hpp"
#include "caf/detail/ieee_754.hpp"
#include "caf/detail/safe_equal.hpp"
using namespace std; using namespace std;
using namespace caf; using namespace caf;
...@@ -123,89 +123,82 @@ enum class test_enum { ...@@ -123,89 +123,82 @@ enum class test_enum {
}; };
struct common_fixture { struct common_fixture {
common_fixture(int32_t i32 = -345, int32_t i32 = -345;
test_enum te = test_enum::b, test_enum te = test_enum::b;
string str = "Lorem ipsum dolor sit amet.") string str = "Lorem ipsum dolor sit amet.";
: i32(i32), te(te), str(str), rs{string(str.rbegin(), str.rend())} { raw_struct rs;
message msg;
common_fixture() {
announce<test_enum>("test_enum");
announce(typeid(raw_struct), uniform_type_info_ptr{new raw_struct_type_info});
rs.str.assign(string(str.rbegin(), str.rend()));
msg = make_message(i32, te, str, rs); msg = make_message(i32, te, str, rs);
} }
int32_t i32; ~common_fixture() {
test_enum te; await_all_actors_done();
string str; shutdown();
raw_struct rs; }
message msg; };
} fixture = {};
template<typename F, typename T> template <class T>
void apply_func(F&& f, T&& t) { void apply(binary_serializer& bs, const T& x) {
f(std::forward<T>(t)); bs << x;
} }
template<typename F, typename T, typename... Ts> template <class T>
void apply_func(F&& f, T&& t, Ts&&... ts) { void apply(binary_deserializer& bd, T* x) {
f(std::forward<T>(t)); uniform_typeid<T>()->deserialize(x, &bd);
apply_func(std::forward<F>(f), std::forward<Ts>(ts)...);
} }
struct binary_util { template <class T>
static actor_namespace*& serialization_namespace() { struct binary_util_fun {
static actor_namespace* ns = nullptr; binary_util_fun(T& ref) : m_ref(ref) {
return ns; // nop
} }
T& m_ref;
template <typename T, typename... Ts> void operator()() const {
static string serialize(T&& t, Ts&&... ts) { // end of recursion
std::stringstream ss;
binary_serializer bs {
std::ostreambuf_iterator<char>(ss),
serialization_namespace()
};
apply_func(
serializer_lambda{&bs},
std::forward<T>(t), std::forward<Ts>(ts)...
);
return ss.str();
} }
template <class U, class... Us>
template <typename T, typename... Ts> void operator()(U&& x, Us&&... xs) const {
static void deserialize(string const& buff, T* t, Ts*... ts) { apply(m_ref, x);
binary_deserializer bd { (*this)(std::forward<Us>(xs)...);
buff.data(), buff.size(),
serialization_namespace()
};
apply_func(deserializer_lambda{&bd}, t, ts...);
} }
};
private: class binary_util {
struct serializer_lambda { public:
serializer_lambda(binary_serializer* bs) : bs(bs) {} template <class T, class... Ts>
binary_serializer* bs; static vector<char> serialize(const T& x, const Ts&... xs) {
template <typename T> vector<char> buf;
void operator()(T&& x) const { binary_serializer bs{std::back_inserter(buf)};
*bs << x; binary_util_fun<binary_serializer> f{bs};
f(x, xs...);
return buf;
} }
};
struct deserializer_lambda { template <class T, class... Ts>
deserializer_lambda(binary_deserializer* bd) : bd(bd) {} static void deserialize(const vector<char>& buf, T* x, Ts*... xs) {
binary_deserializer* bd; binary_deserializer bd{buf.data(), buf.size()};
template <typename T> binary_util_fun<binary_deserializer> f{bd};
void operator()(T* x) const { f(x, xs...);
uniform_typeid<T>()->deserialize(x, bd);
} }
};
}; };
struct is_message { struct is_message {
explicit is_message(message& msg) : msg(msg) {} explicit is_message(message& msg) : msg(msg) {
message msg; // nop
}
template <typename T, typename... Ts> message& msg;
bool equal(T&& t, Ts&&... ts) {
template <class T, class... Ts>
bool equal(T&& v, Ts&&... vs) {
bool ok = false; bool ok = false;
// work around for gcc bug // work around for gcc bug
auto tup = tie(t, ts...); auto tup = tie(v, vs...);
message_handler impl { message_handler impl {
[&](T const& u, Ts const&... us) { [&](T const& u, Ts const&... us) {
ok = tup == tie(u, us...); ok = tup == tie(u, us...);
...@@ -218,8 +211,9 @@ struct is_message { ...@@ -218,8 +211,9 @@ struct is_message {
} // namespace <anonymous> } // namespace <anonymous>
CAF_TEST_FIXTURE_SCOPE(serialization_tests, common_fixture)
CAF_TEST(test_serialization) { CAF_TEST(test_serialization) {
announce<test_enum>("test_enum");
using token = std::integral_constant<int, detail::impl_id<strmap>()>; using token = std::integral_constant<int, detail::impl_id<strmap>()>;
CAF_CHECK_EQUAL(detail::is_iterable<strmap>::value, true); CAF_CHECK_EQUAL(detail::is_iterable<strmap>::value, true);
CAF_CHECK_EQUAL(detail::is_stl_compliant_list<vector<int>>::value, true); CAF_CHECK_EQUAL(detail::is_stl_compliant_list<vector<int>>::value, true);
...@@ -228,8 +222,6 @@ CAF_TEST(test_serialization) { ...@@ -228,8 +222,6 @@ CAF_TEST(test_serialization) {
CAF_CHECK_EQUAL(detail::impl_id<strmap>(), 2); CAF_CHECK_EQUAL(detail::impl_id<strmap>(), 2);
CAF_CHECK_EQUAL(token::value, 2); CAF_CHECK_EQUAL(token::value, 2);
announce(typeid(raw_struct), uniform_type_info_ptr{new raw_struct_type_info});
auto nid = detail::singletons::get_node_id(); auto nid = detail::singletons::get_node_id();
auto nid_str = to_string(nid); auto nid_str = to_string(nid);
CAF_MESSAGE("nid_str = " << nid_str); CAF_MESSAGE("nid_str = " << nid_str);
...@@ -256,51 +248,51 @@ CAF_TEST(test_ieee_754) { ...@@ -256,51 +248,51 @@ CAF_TEST(test_ieee_754) {
} }
CAF_TEST(test_int32_t) { CAF_TEST(test_int32_t) {
auto buff = binary_util::serialize(fixture.i32); auto buf = binary_util::serialize(i32);
int32_t i32; int32_t x;
binary_util::deserialize(buff, &i32); binary_util::deserialize(buf, &x);
CAF_CHECK_EQUAL(fixture.i32, i32); CAF_CHECK_EQUAL(i32, x);
} }
CAF_TEST(test_enum) { CAF_TEST(test_enum) {
auto buff = binary_util::serialize(fixture.te); auto buf = binary_util::serialize(te);
test_enum te; test_enum x;
binary_util::deserialize(buff, &te); binary_util::deserialize(buf, &x);
CAF_CHECK(fixture.te == te); CAF_CHECK(te == x);
} }
CAF_TEST(test_string) { CAF_TEST(test_string) {
auto buff = binary_util::serialize(fixture.str); auto buf = binary_util::serialize(str);
string str; string x;
binary_util::deserialize(buff, &str); binary_util::deserialize(buf, &x);
CAF_CHECK_EQUAL(fixture.str, str); CAF_CHECK_EQUAL(str, x);
} }
CAF_TEST(test_raw_struct) { CAF_TEST(test_raw_struct) {
auto buff = binary_util::serialize(fixture.rs); auto buf = binary_util::serialize(rs);
raw_struct rs; raw_struct x;
binary_util::deserialize(buff, &rs); binary_util::deserialize(buf, &x);
CAF_CHECK(fixture.rs == rs); CAF_CHECK(rs == x);
} }
CAF_TEST(test_single_message) { CAF_TEST(test_single_message) {
auto buff = binary_util::serialize(fixture.msg); auto buf = binary_util::serialize(msg);
message msg; message x;
binary_util::deserialize(buff, &msg); binary_util::deserialize(buf, &x);
CAF_CHECK(fixture.msg == msg); CAF_CHECK(msg == x);
CAF_CHECK(is_message(msg).equal(fixture.i32, fixture.te, fixture.str, fixture.rs)); CAF_CHECK(is_message(x).equal(i32, te, str, rs));
} }
CAF_TEST(test_multiple_messages) { CAF_TEST(test_multiple_messages) {
auto m = make_message(fixture.rs, fixture.te); auto m = make_message(rs, te);
auto buff = binary_util::serialize(fixture.te, m, fixture.msg); auto buf = binary_util::serialize(te, m, msg);
test_enum t; test_enum t;
message m1; message m1;
message m2; message m2;
binary_util::deserialize(buff, &t, &m1, &m2); binary_util::deserialize(buf, &t, &m1, &m2);
CAF_CHECK(tie(t, m1, m2) == tie(fixture.te, m, fixture.msg)); CAF_CHECK(tie(t, m1, m2) == tie(te, m, msg));
CAF_CHECK(is_message(m1).equal(fixture.rs, fixture.te)); CAF_CHECK(is_message(m1).equal(rs, te));
CAF_CHECK(is_message(m2).equal(fixture.i32, fixture.te, fixture.str, fixture.rs)); CAF_CHECK(is_message(m2).equal(i32, te, str, rs));
} }
CAF_TEST(test_string_serialization) { CAF_TEST(test_string_serialization) {
...@@ -314,5 +306,6 @@ CAF_TEST(test_string_serialization) { ...@@ -314,5 +306,6 @@ CAF_TEST(test_string_serialization) {
} }
CAF_CHECK(*m == input); CAF_CHECK(*m == input);
CAF_CHECK_EQUAL(to_string(*m), to_string(input)); CAF_CHECK_EQUAL(to_string(*m), to_string(input));
shutdown();
} }
CAF_TEST_FIXTURE_SCOPE_END()
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment