418 lines
15 KiB
C++
418 lines
15 KiB
C++
// Copyright (c) 2017 Levon Tarakchyan
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#include "boost/config.hpp"
|
|
|
|
#include "boost/core/lightweight_test.hpp"
|
|
#include "boost/variant.hpp"
|
|
#include "boost/variant/apply_visitor.hpp"
|
|
#include "boost/variant/multivisitors.hpp"
|
|
#include "boost/lexical_cast.hpp"
|
|
|
|
#define lcs(val) boost::lexical_cast<std::string>(val)
|
|
|
|
struct construction_logger
|
|
{
|
|
int val_;
|
|
|
|
construction_logger(int val) : val_(val)
|
|
{
|
|
std::cout << val_ << " constructed\n";
|
|
}
|
|
|
|
construction_logger(const construction_logger& cl) :
|
|
val_(cl.val_)
|
|
{
|
|
std::cout << val_ << " copy constructed\n";
|
|
}
|
|
|
|
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
|
construction_logger(construction_logger&& cl) :
|
|
val_(cl.val_)
|
|
{
|
|
std::cout << val_ << " move constructed\n";
|
|
}
|
|
#endif
|
|
|
|
friend std::ostream& operator << (std::ostream& os, const construction_logger& cl)
|
|
{
|
|
return os << cl.val_;
|
|
}
|
|
|
|
friend std::istream& operator << (std::istream& is, construction_logger& cl)
|
|
{
|
|
return is >> cl.val_;
|
|
}
|
|
};
|
|
|
|
struct lex_streamer_explicit : boost::static_visitor<std::string>
|
|
{
|
|
template <class T>
|
|
std::string operator()(const T& val) const
|
|
{
|
|
return lcs(val);
|
|
}
|
|
|
|
template <class T, class V>
|
|
std::string operator()(const T& val, const V& val2) const
|
|
{
|
|
return lcs(val) + '+' + lcs(val2);
|
|
}
|
|
|
|
template <class T, class V, class P, class S>
|
|
std::string operator()(const T& val, const V& val2, const P& val3, const S& val4) const
|
|
{
|
|
return lcs(val) + '+' + lcs(val2) + '+' + lcs(val3) + '+' + lcs(val4);
|
|
}
|
|
};
|
|
|
|
struct lvalue_rvalue_detector : boost::static_visitor<std::string>
|
|
{
|
|
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
|
template <class T>
|
|
std::string operator()(T&&) const
|
|
{
|
|
return std::is_lvalue_reference<T>::value ? "lvalue reference"
|
|
: "rvalue reference";
|
|
}
|
|
|
|
template <class T, class V>
|
|
std::string operator()(T&& t, V&& v) const
|
|
{
|
|
return operator()(std::forward<T>(t)) + ", " + operator()(std::forward<V>(v));
|
|
}
|
|
|
|
template <class T, class V, class P>
|
|
std::string operator()(T&& t, V&& v, P&& p) const
|
|
{
|
|
return operator()(std::forward<T>(t), std::forward<V>(v)) + ", " + operator()(std::forward<P>(p));
|
|
}
|
|
|
|
template <class T, class V, class P, class S>
|
|
std::string operator()(T&& t, V&& v, P&& p, S&& s) const
|
|
{
|
|
return operator()(std::forward<T>(t), std::forward<V>(v), std::forward<P>(p)) + ", " + operator()(std::forward<S>(s));
|
|
}
|
|
#else
|
|
template <class T>
|
|
std::string operator()(T&) const
|
|
{
|
|
return "lvalue reference";
|
|
}
|
|
|
|
template <class T, class V>
|
|
std::string operator()(T&, V&) const
|
|
{
|
|
return "lvalue reference, lvalue reference";
|
|
}
|
|
|
|
template <class T, class V, class P>
|
|
std::string operator()(T&, V&, P&) const
|
|
{
|
|
return "lvalue reference, lvalue reference, lvalue reference";
|
|
}
|
|
|
|
template <class T, class V, class P, class S>
|
|
std::string operator()(T&, V&, P&, S&) const
|
|
{
|
|
return "lvalue reference, lvalue reference, lvalue reference, lvalue reference";
|
|
}
|
|
#endif
|
|
};
|
|
|
|
typedef boost::variant<construction_logger, std::string> variant_type;
|
|
|
|
void test_const_ref_parameter(const variant_type& test_var)
|
|
{
|
|
std::cout << "Testing const lvalue reference visitable\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var) == "lvalue reference");
|
|
}
|
|
|
|
void test_const_ref_parameter2(const variant_type& test_var, const variant_type& test_var2)
|
|
{
|
|
std::cout << "Testing const lvalue reference visitable\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var, test_var2) == "lvalue reference, lvalue reference");
|
|
}
|
|
|
|
void test_const_ref_parameter4(const variant_type& test_var, const variant_type& test_var2, const variant_type& test_var3, const variant_type& test_var4)
|
|
{
|
|
std::cout << "Testing const lvalue reference visitable with multivisitor\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var, test_var2, test_var3, test_var4)
|
|
== "lvalue reference, lvalue reference, lvalue reference, lvalue reference");
|
|
}
|
|
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
|
|
|
|
void test_rvalue_parameter(variant_type&& test_var)
|
|
{
|
|
std::cout << "Testing rvalue visitable\n";
|
|
|
|
const auto expected_val = lcs(test_var);
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var)) == "rvalue reference");
|
|
}
|
|
|
|
void test_rvalue_parameter2(variant_type&& test_var, variant_type&& test_var2)
|
|
{
|
|
std::cout << "Testing rvalue visitable\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var), std::move(test_var2)) == "rvalue reference, rvalue reference");
|
|
}
|
|
|
|
void test_rvalue_parameter4(variant_type&& test_var, variant_type&& test_var2, variant_type&& test_var3, variant_type&& test_var4)
|
|
{
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing rvalue visitable with multivisitor\n";
|
|
|
|
auto result = boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var), std::move(test_var2), std::move(test_var3), std::move(test_var4));
|
|
std::cout << "result: " << result << std::endl;
|
|
BOOST_TEST(result == "rvalue reference, rvalue reference, rvalue reference, rvalue reference");
|
|
#else
|
|
(void)test_var;
|
|
(void)test_var2;
|
|
(void)test_var3;
|
|
(void)test_var4;
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
|
|
|
|
#define FORWARD(x) std::forward<decltype(x)>(x)
|
|
|
|
void test_cpp14_visitor(const variant_type& test_var)
|
|
{
|
|
std::cout << "Testing const lvalue visitable for c++14\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v) { return lvalue_rvalue_detector()(FORWARD(v)); }, test_var) == "lvalue reference");
|
|
}
|
|
|
|
void test_cpp14_mutable_visitor(const variant_type& test_var)
|
|
{
|
|
std::cout << "Testing const lvalue visitable for c++14 with inline mutable lambda\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v) mutable -> auto { return lvalue_rvalue_detector()(FORWARD(v)); }, test_var) == "lvalue reference");
|
|
}
|
|
|
|
void test_cpp14_visitor(const variant_type& test_var, const variant_type& test_var2)
|
|
{
|
|
std::cout << "Testing const lvalue visitable for c++14\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& vv) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(vv)); }, test_var, test_var2)
|
|
== "lvalue reference, lvalue reference");
|
|
}
|
|
|
|
void test_cpp14_visitor(const variant_type& test_var, const variant_type& test_var2, const variant_type& test_var3)
|
|
{
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing const lvalue visitable for c++14\n";
|
|
|
|
auto result = boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
|
|
test_var, test_var2, test_var3);
|
|
std::cout << "result: " << result << std::endl;
|
|
BOOST_TEST(result == "lvalue reference, lvalue reference, lvalue reference");
|
|
#else
|
|
(void)test_var;
|
|
(void)test_var2;
|
|
(void)test_var3;
|
|
#endif
|
|
}
|
|
|
|
void test_cpp14_visitor(variant_type& test_var)
|
|
{
|
|
std::cout << "Testing lvalue visitable for c++14\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto& v) { return lvalue_rvalue_detector()(v); }, test_var) == "lvalue reference");
|
|
}
|
|
|
|
void test_cpp14_mutable_visitor(variant_type& test_var)
|
|
{
|
|
std::cout << "Testing lvalue visitable for c++14 with inline mutable lambda\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto& v) mutable -> auto { return lvalue_rvalue_detector()(v); }, test_var) == "lvalue reference");
|
|
}
|
|
|
|
void test_cpp14_visitor(variant_type& test_var, variant_type& test_var2)
|
|
{
|
|
std::cout << "Testing lvalue visitable for c++14\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto& v, auto& vv) { return lvalue_rvalue_detector()(v, vv); }, test_var, test_var2)
|
|
== "lvalue reference, lvalue reference");
|
|
}
|
|
|
|
void test_cpp14_visitor(variant_type& test_var, variant_type& test_var2, variant_type& test_var3)
|
|
{
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing lvalue visitable for c++14\n";
|
|
|
|
auto result = boost::apply_visitor([](auto& v, auto& t, auto& p) { return lvalue_rvalue_detector()(v, t, p); },
|
|
test_var, test_var2, test_var3);
|
|
std::cout << "result: " << result << std::endl;
|
|
BOOST_TEST(result == "lvalue reference, lvalue reference, lvalue reference");
|
|
#else
|
|
(void)test_var;
|
|
(void)test_var2;
|
|
(void)test_var3;
|
|
#endif
|
|
}
|
|
|
|
void test_cpp14_visitor(variant_type&& test_var)
|
|
{
|
|
std::cout << "Testing rvalue visitable for c++14\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v) { return lvalue_rvalue_detector()(FORWARD(v)); }, std::move(test_var)) == "rvalue reference");
|
|
}
|
|
|
|
void test_cpp14_visitor(variant_type&& test_var, variant_type&& test_var2)
|
|
{
|
|
std::cout << "Testing rvalue visitable for c++14\n";
|
|
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& vv) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(vv)); }, std::move(test_var), std::move(test_var2))
|
|
== "rvalue reference, rvalue reference");
|
|
}
|
|
|
|
void test_cpp14_visitor(variant_type&& test_var, variant_type&& test_var2, variant_type&& test_var3)
|
|
{
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing rvalue visitable for c++14\n";
|
|
|
|
auto result = boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
|
|
std::move(test_var), std::move(test_var2), std::move(test_var3));
|
|
std::cout << "result: " << result << std::endl;
|
|
BOOST_TEST(result == "rvalue reference, rvalue reference, rvalue reference");
|
|
#else
|
|
(void)test_var;
|
|
(void)test_var2;
|
|
(void)test_var3;
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
|
|
void run_const_lvalue_ref_tests()
|
|
{
|
|
const variant_type v1(1), v2(2), v3(3), v4(4);
|
|
test_const_ref_parameter(v1);
|
|
test_const_ref_parameter2(v1, v2);
|
|
test_const_ref_parameter4(v1, v2, v3, v4);
|
|
}
|
|
|
|
void run_rvalue_ref_tests()
|
|
{
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
|
|
variant_type v1(10), v2(20), v3(30);
|
|
test_rvalue_parameter(boost::move(v1));
|
|
test_rvalue_parameter2(boost::move(v2), boost::move(v3));
|
|
|
|
variant_type vv1(100), vv2(200), vv3(300), vv4(400);
|
|
test_rvalue_parameter4(boost::move(vv1), boost::move(vv2), boost::move(vv3), boost::move(vv4));
|
|
#endif
|
|
}
|
|
|
|
void run_mixed_tests()
|
|
{
|
|
variant_type v1(1), v2(2);
|
|
|
|
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
|
#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
|
|
std::cout << "Testing lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, variant_type(10)) == "lvalue reference, rvalue reference");
|
|
|
|
std::cout << "Testing rvalue + lvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), variant_type(10), v1) == "rvalue reference, lvalue reference");
|
|
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing rvalue + lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), variant_type(10), v1, variant_type(20)) == "rvalue reference, lvalue reference, rvalue reference");
|
|
|
|
std::cout << "Testing lvalue + rvalue + lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, variant_type(10), v2, variant_type(20)) == "lvalue reference, rvalue reference, lvalue reference, rvalue reference");
|
|
#endif
|
|
|
|
#endif // #ifndef BOOST_NO_CXX11_REF_QUALIFIERS
|
|
|
|
#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
|
std::cout << "Testing lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, v1) == "lvalue reference, lvalue reference");
|
|
|
|
std::cout << "Testing rvalue + lvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), static_cast<const variant_type&>(variant_type(10)), v1) == "lvalue reference, lvalue reference");
|
|
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing rvalue + lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), static_cast<const variant_type&>(variant_type(10)), v1, static_cast<const variant_type&>(variant_type(20))) == "lvalue reference, lvalue reference, lvalue reference");
|
|
|
|
std::cout << "Testing lvalue + rvalue + lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, static_cast<const variant_type&>(variant_type(10)), v2, static_cast<const variant_type&>(variant_type(20))) == "lvalue reference, lvalue reference, lvalue reference, lvalue reference");
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void run_cpp14_mixed_tests()
|
|
{
|
|
#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
|
|
variant_type v1(1), v2(2);
|
|
|
|
std::cout << "Testing lvalue + rvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t)); },
|
|
v1, variant_type(10)) == "lvalue reference, rvalue reference");
|
|
|
|
std::cout << "Testing rvalue + lvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t)); },
|
|
variant_type(10), v1) == "rvalue reference, lvalue reference");
|
|
|
|
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
|
std::cout << "Testing rvalue + lvalue + lvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
|
|
variant_type(10), v1, v2) == "rvalue reference, lvalue reference, lvalue reference");
|
|
|
|
std::cout << "Testing lvalue + rvalue + lvalue visitable\n";
|
|
BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
|
|
v1, variant_type(10), v2) == "lvalue reference, rvalue reference, lvalue reference");
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void run_cpp14_tests()
|
|
{
|
|
#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
|
|
variant_type const c1(10), c2(20), c3(30);
|
|
variant_type v1(10), v2(20), v3(30);
|
|
|
|
test_cpp14_visitor(c1);
|
|
test_cpp14_mutable_visitor(c1);
|
|
test_cpp14_visitor(c2, c3);
|
|
test_cpp14_visitor(c1, c2, c3);
|
|
|
|
test_cpp14_visitor(v1);
|
|
test_cpp14_mutable_visitor(v1);
|
|
test_cpp14_visitor(v2, v3);
|
|
test_cpp14_visitor(v1, v2, v3);
|
|
|
|
test_cpp14_visitor(boost::move(v1));
|
|
test_cpp14_visitor(boost::move(v2), boost::move(v3));
|
|
|
|
variant_type vv1(100), vv2(200), vv3(300);
|
|
test_cpp14_visitor(boost::move(vv1), boost::move(vv2), boost::move(vv3));
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
int main()
|
|
{
|
|
run_const_lvalue_ref_tests();
|
|
run_rvalue_ref_tests();
|
|
run_mixed_tests();
|
|
run_cpp14_mixed_tests();
|
|
run_cpp14_tests();
|
|
|
|
return boost::report_errors();
|
|
}
|