Squashed 'third_party/boostorg/any/' content from commit d962e21
Change-Id: I308196902114eb74127ee7bfff922a0b8a885a4d
git-subtree-dir: third_party/boostorg/any
git-subtree-split: d962e210f8fc0cfb99f475627563193ba09cbf16
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
new file mode 100644
index 0000000..ce2ba55
--- /dev/null
+++ b/test/Jamfile.v2
@@ -0,0 +1,20 @@
+# Copyright Vladimur Prus 2005. Use, modification and
+# distribution is subject to 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)
+#
+# For more information, see http://www.boost.org/libs/any
+#
+
+test-suite any :
+ [ run any_test.cpp ]
+ [ run any_test.cpp : : : <rtti>off <define>BOOST_NO_RTTI <define>BOOST_NO_TYPEID : any_test_no_rtti ]
+ [ run any_test_rv.cpp ]
+ [ run any_test_rv.cpp : : : <rtti>off <define>BOOST_NO_RTTI <define>BOOST_NO_TYPEID : any_test_rv_no_rtti ]
+ [ run any_test_mplif.cpp ]
+ [ compile-fail any_cast_cv_failed.cpp ]
+ [ compile-fail any_test_temporary_to_ref_failed.cpp ]
+ [ compile-fail any_test_cv_to_rv_failed.cpp ]
+ ;
+
+
diff --git a/test/any_cast_cv_failed.cpp b/test/any_cast_cv_failed.cpp
new file mode 100644
index 0000000..860240f
--- /dev/null
+++ b/test/any_cast_cv_failed.cpp
@@ -0,0 +1,14 @@
+// Copyright 2006 Alexander Nasonov.
+//
+// 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/any.hpp>
+
+int main()
+{
+ boost::any const a;
+ boost::any_cast<int&>(a);
+}
+
diff --git a/test/any_test.cpp b/test/any_test.cpp
new file mode 100644
index 0000000..4c65b0e
--- /dev/null
+++ b/test/any_test.cpp
@@ -0,0 +1,405 @@
+// what: unit tests for variant type boost::any
+// who: contributed by Kevlin Henney
+// when: July 2001, 2013, 2014
+// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+#include <utility>
+
+#include <boost/any.hpp>
+#include "test.hpp"
+
+namespace any_tests
+{
+ typedef test<const char *, void (*)()> test_case;
+ typedef const test_case * test_case_iterator;
+
+ extern const test_case_iterator begin, end;
+}
+
+int main()
+{
+ using namespace any_tests;
+ tester<test_case_iterator> test_suite(begin, end);
+ return test_suite() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+namespace any_tests // test suite
+{
+ void test_default_ctor();
+ void test_converting_ctor();
+ void test_copy_ctor();
+ void test_copy_assign();
+ void test_converting_assign();
+ void test_bad_cast();
+ void test_swap();
+ void test_null_copying();
+ void test_cast_to_reference();
+ void test_with_array();
+ void test_with_func();
+ void test_clear();
+ void test_vectors();
+ void test_addressof();
+
+ const test_case test_cases[] =
+ {
+ { "default construction", test_default_ctor },
+ { "single argument construction", test_converting_ctor },
+ { "copy construction", test_copy_ctor },
+ { "copy assignment operator", test_copy_assign },
+ { "converting assignment operator", test_converting_assign },
+ { "failed custom keyword cast", test_bad_cast },
+ { "swap member function", test_swap },
+ { "copying operations on a null", test_null_copying },
+ { "cast to reference types", test_cast_to_reference },
+ { "storing an array inside", test_with_array },
+ { "implicit cast of returned value",test_with_func },
+ { "clear() methods", test_clear },
+ { "testing with vectors", test_vectors },
+ { "class with operator&()", test_addressof }
+ };
+
+ const test_case_iterator begin = test_cases;
+ const test_case_iterator end =
+ test_cases + (sizeof test_cases / sizeof *test_cases);
+
+
+
+ struct copy_counter
+ {
+
+ public:
+
+ copy_counter() {}
+ copy_counter(const copy_counter&) { ++count; }
+ copy_counter& operator=(const copy_counter&) { ++count; return *this; }
+ static int get_count() { return count; }
+
+ private:
+
+ static int count;
+
+ };
+
+ int copy_counter::count = 0;
+}
+
+namespace any_tests // test definitions
+{
+ using namespace boost;
+
+ void test_default_ctor()
+ {
+ const any value;
+
+ check_true(value.empty(), "empty");
+ check_null(any_cast<int>(&value), "any_cast<int>");
+ check_equal(value.type(), boost::typeindex::type_id<void>(), "type");
+ }
+
+ void test_converting_ctor()
+ {
+ std::string text = "test message";
+ any value = text;
+
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), boost::typeindex::type_id<std::string>(), "type");
+ check_null(any_cast<int>(&value), "any_cast<int>");
+ check_non_null(any_cast<std::string>(&value), "any_cast<std::string>");
+ check_equal(
+ any_cast<std::string>(value), text,
+ "comparing cast copy against original text");
+ check_unequal(
+ any_cast<std::string>(&value), &text,
+ "comparing address in copy against original text");
+ }
+
+ void test_copy_ctor()
+ {
+ std::string text = "test message";
+ any original = text, copy = original;
+
+ check_false(copy.empty(), "empty");
+ check_equal(boost::typeindex::type_index(original.type()), copy.type(), "type");
+ check_equal(
+ any_cast<std::string>(original), any_cast<std::string>(copy),
+ "comparing cast copy against original");
+ check_equal(
+ text, any_cast<std::string>(copy),
+ "comparing cast copy against original text");
+ check_unequal(
+ any_cast<std::string>(&original),
+ any_cast<std::string>(©),
+ "comparing address in copy against original");
+ }
+
+ void test_copy_assign()
+ {
+ std::string text = "test message";
+ any original = text, copy;
+ any * assign_result = &(copy = original);
+
+ check_false(copy.empty(), "empty");
+ check_equal(boost::typeindex::type_index(original.type()), copy.type(), "type");
+ check_equal(
+ any_cast<std::string>(original), any_cast<std::string>(copy),
+ "comparing cast copy against cast original");
+ check_equal(
+ text, any_cast<std::string>(copy),
+ "comparing cast copy against original text");
+ check_unequal(
+ any_cast<std::string>(&original),
+ any_cast<std::string>(©),
+ "comparing address in copy against original");
+ check_equal(assign_result, ©, "address of assignment result");
+ }
+
+ void test_converting_assign()
+ {
+ std::string text = "test message";
+ any value;
+ any * assign_result = &(value = text);
+
+ check_false(value.empty(), "type");
+ check_equal(value.type(), boost::typeindex::type_id<std::string>(), "type");
+ check_null(any_cast<int>(&value), "any_cast<int>");
+ check_non_null(any_cast<std::string>(&value), "any_cast<std::string>");
+ check_equal(
+ any_cast<std::string>(value), text,
+ "comparing cast copy against original text");
+ check_unequal(
+ any_cast<std::string>(&value),
+ &text,
+ "comparing address in copy against original text");
+ check_equal(assign_result, &value, "address of assignment result");
+ }
+
+ void test_bad_cast()
+ {
+ std::string text = "test message";
+ any value = text;
+
+ TEST_CHECK_THROW(
+ any_cast<const char *>(value),
+ bad_any_cast,
+ "any_cast to incorrect type");
+ }
+
+ void test_swap()
+ {
+ std::string text = "test message";
+ any original = text, swapped;
+ std::string * original_ptr = any_cast<std::string>(&original);
+ any * swap_result = &original.swap(swapped);
+
+ check_true(original.empty(), "empty on original");
+ check_false(swapped.empty(), "empty on swapped");
+ check_equal(swapped.type(), boost::typeindex::type_id<std::string>(), "type");
+ check_equal(
+ text, any_cast<std::string>(swapped),
+ "comparing swapped copy against original text");
+ check_non_null(original_ptr, "address in pre-swapped original");
+ check_equal(
+ original_ptr,
+ any_cast<std::string>(&swapped),
+ "comparing address in swapped against original");
+ check_equal(swap_result, &original, "address of swap result");
+
+ any copy1 = copy_counter();
+ any copy2 = copy_counter();
+ int count = copy_counter::get_count();
+ swap(copy1, copy2);
+ check_equal(count, copy_counter::get_count(), "checking that free swap doesn't make any copies.");
+ }
+
+ void test_null_copying()
+ {
+ const any null;
+ any copied = null, assigned;
+ assigned = null;
+
+ check_true(null.empty(), "empty on null");
+ check_true(copied.empty(), "empty on copied");
+ check_true(assigned.empty(), "empty on copied");
+ }
+
+ void test_cast_to_reference()
+ {
+ any a(137);
+ const any b(a);
+
+ int & ra = any_cast<int &>(a);
+ int const & ra_c = any_cast<int const &>(a);
+ int volatile & ra_v = any_cast<int volatile &>(a);
+ int const volatile & ra_cv = any_cast<int const volatile&>(a);
+
+ check_true(
+ &ra == &ra_c && &ra == &ra_v && &ra == &ra_cv,
+ "cv references to same obj");
+
+ int const & rb_c = any_cast<int const &>(b);
+ int const volatile & rb_cv = any_cast<int const volatile &>(b);
+
+ check_true(&rb_c == &rb_cv, "cv references to copied const obj");
+ check_true(&ra != &rb_c, "copies hold different objects");
+
+ ++ra;
+ int incremented = any_cast<int>(a);
+ check_true(incremented == 138, "increment by reference changes value");
+
+ TEST_CHECK_THROW(
+ any_cast<char &>(a),
+ bad_any_cast,
+ "any_cast to incorrect reference type");
+
+ TEST_CHECK_THROW(
+ any_cast<const char &>(b),
+ bad_any_cast,
+ "any_cast to incorrect const reference type");
+ }
+
+ void test_with_array()
+ {
+ any value1("Char array");
+ any value2;
+ value2 = "Char array";
+
+ check_false(value1.empty(), "type");
+ check_false(value2.empty(), "type");
+
+ check_equal(value1.type(), boost::typeindex::type_id<const char*>(), "type");
+ check_equal(value2.type(), boost::typeindex::type_id<const char*>(), "type");
+
+ check_non_null(any_cast<const char*>(&value1), "any_cast<const char*>");
+ check_non_null(any_cast<const char*>(&value2), "any_cast<const char*>");
+ }
+
+ const std::string& returning_string1()
+ {
+ static const std::string ret("foo");
+ return ret;
+ }
+
+ std::string returning_string2()
+ {
+ static const std::string ret("foo");
+ return ret;
+ }
+
+ void test_with_func()
+ {
+ std::string s;
+ s = any_cast<std::string>(returning_string1());
+ s = any_cast<const std::string&>(returning_string1());
+
+ s = any_cast<std::string>(returning_string2());
+ s = any_cast<const std::string&>(returning_string2());
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(__INTEL_COMPILER) && !defined(__ICL) && (!defined(_MSC_VER) || _MSC_VER != 1600)
+ // Intel compiler thinks that it must choose the `any_cast(const any&)` function
+ // instead of the `any_cast(const any&&)`.
+ // Bug was not reported because of missing premier support account + annoying
+ // registrations requirements.
+
+ // MSVC-10 had a bug:
+ //
+ // any.hpp(291) : error C2440: 'return' : cannot convert.
+ // Conversion loses qualifiers
+ // any_test.cpp(304) : see reference to function template instantiation
+ //
+ // This issue was fixed in MSVC-11.
+
+ s = any_cast<std::string&&>(returning_string1());
+#endif
+
+ s = any_cast<std::string&&>(returning_string2());
+#endif
+ }
+
+
+ void test_clear()
+ {
+ std::string text = "test message";
+ any value = text;
+
+ check_false(value.empty(), "empty");
+
+ value.clear();
+ check_true(value.empty(), "non-empty after clear");
+
+ value.clear();
+ check_true(value.empty(), "non-empty after second clear");
+
+ value = text;
+ check_false(value.empty(), "empty");
+
+ value.clear();
+ check_true(value.empty(), "non-empty after clear");
+ }
+
+ // Following tests cover the case from #9462
+ // https://svn.boost.org/trac/boost/ticket/9462
+ boost::any makeVec()
+ {
+ return std::vector<int>(100 /*size*/, 7 /*value*/);
+ }
+
+ void test_vectors()
+ {
+ const std::vector<int>& vec = boost::any_cast<std::vector<int> >(makeVec());
+ check_equal(vec.size(), 100u, "size of vector extracted from boost::any");
+ check_equal(vec.back(), 7, "back value of vector extracted from boost::any");
+ check_equal(vec.front(), 7, "front value of vector extracted from boost::any");
+
+ std::vector<int> vec1 = boost::any_cast<std::vector<int> >(makeVec());
+ check_equal(vec1.size(), 100u, "size of second vector extracted from boost::any");
+ check_equal(vec1.back(), 7, "back value of second vector extracted from boost::any");
+ check_equal(vec1.front(), 7, "front value of second vector extracted from boost::any");
+
+ }
+
+ template<typename T>
+ class class_with_address_op {
+ public:
+ class_with_address_op(const T* p)
+ : ptr(p)
+ {}
+
+ const T** operator &() {
+ return &ptr;
+ }
+
+ const T* get() const {
+ return ptr;
+ }
+
+ private:
+ const T* ptr;
+ };
+
+ void test_addressof()
+ {
+ int val = 10;
+ const int* ptr = &val;
+ class_with_address_op<int> obj(ptr);
+ boost::any test_val(obj);
+
+ class_with_address_op<int> returned_obj = boost::any_cast<class_with_address_op<int> >(test_val);
+ check_equal(&val, returned_obj.get(), "any_cast incorrectly works with type that has operator&(): addresses differ");
+
+ check_true(!!boost::any_cast<class_with_address_op<int> >(&test_val), "any_cast incorrectly works with type that has operator&()");
+ check_equal(boost::unsafe_any_cast<class_with_address_op<int> >(&test_val)->get(), ptr, "unsafe_any_cast incorrectly works with type that has operator&()");
+ }
+
+}
+
+// Copyright Kevlin Henney, 2000, 2001. All rights reserved.
+// Copyright Antony Polukhin, 2013-2017.
+//
+// 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)
+//
diff --git a/test/any_test_cv_to_rv_failed.cpp b/test/any_test_cv_to_rv_failed.cpp
new file mode 100644
index 0000000..a4a34ed
--- /dev/null
+++ b/test/any_test_cv_to_rv_failed.cpp
@@ -0,0 +1,39 @@
+// Unit test for boost::any.
+//
+// See http://www.boost.org for most recent version, including documentation.
+//
+// Copyright Antony Polukhin, 2013-2014.
+//
+// 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 <cstdlib>
+#include <string>
+#include <utility>
+
+#include <boost/any.hpp>
+#include "test.hpp"
+#include <boost/move/move.hpp>
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+int main()
+{
+ BOOST_STATIC_ASSERT(false);
+ return EXIT_SUCCESS;
+}
+
+#else
+
+
+int main()
+{
+ boost::any const cvalue(10);
+ int i = boost::any_cast<int&&>(cvalue);
+ (void)i;
+ return EXIT_SUCCESS;
+}
+
+#endif
+
diff --git a/test/any_test_mplif.cpp b/test/any_test_mplif.cpp
new file mode 100644
index 0000000..b0da7c1
--- /dev/null
+++ b/test/any_test_mplif.cpp
@@ -0,0 +1,19 @@
+// Copyright Antony Polukhin, 2017.
+//
+// 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)
+
+// This tests the issue from https://svn.boost.org/trac/boost/ticket/12052
+
+#include <iostream>
+#include <boost/any.hpp>
+
+int main() {
+ boost::any a = 1;
+ std::cout << boost::any_cast<int>(a) << '\n';
+ a = 3.14;
+ std::cout << boost::any_cast<double>(a) << '\n';
+ a = true;
+ std::cout << std::boolalpha << boost::any_cast<bool>(a) << '\n';
+}
diff --git a/test/any_test_rv.cpp b/test/any_test_rv.cpp
new file mode 100644
index 0000000..0571c70
--- /dev/null
+++ b/test/any_test_rv.cpp
@@ -0,0 +1,331 @@
+// Unit test for boost::any.
+//
+// See http://www.boost.org for most recent version, including documentation.
+//
+// Copyright Antony Polukhin, 2013-2014.
+//
+// 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 <cstdlib>
+#include <string>
+#include <utility>
+
+#include <boost/any.hpp>
+#include "test.hpp"
+#include <boost/move/move.hpp>
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+int main()
+{
+ return EXIT_SUCCESS;
+}
+
+#else
+
+namespace any_tests
+{
+ typedef test<const char *, void (*)()> test_case;
+ typedef const test_case * test_case_iterator;
+
+ extern const test_case_iterator begin, end;
+}
+
+int main()
+{
+ using namespace any_tests;
+ tester<test_case_iterator> test_suite(begin, end);
+ return test_suite() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+namespace any_tests // test suite
+{
+ void test_move_construction();
+ void test_move_assignment();
+ void test_copy_construction();
+ void test_copy_assignment();
+
+ void test_move_construction_from_value();
+ void test_move_assignment_from_value();
+ void test_copy_construction_from_value();
+ void test_copy_assignment_from_value();
+ void test_construction_from_const_any_rv();
+ void test_cast_to_rv();
+
+
+ const test_case test_cases[] =
+ {
+ { "move construction of any", test_move_construction },
+ { "move assignment of any", test_move_assignment },
+ { "copy construction of any", test_copy_construction },
+ { "copy assignment of any", test_copy_assignment },
+
+ { "move construction from value", test_move_construction_from_value },
+ { "move assignment from value", test_move_assignment_from_value },
+ { "copy construction from value", test_copy_construction_from_value },
+ { "copy assignment from value", test_copy_assignment_from_value },
+ { "constructing from const any&&", test_construction_from_const_any_rv },
+ { "casting to rvalue reference", test_cast_to_rv }
+ };
+
+ const test_case_iterator begin = test_cases;
+ const test_case_iterator end =
+ test_cases + (sizeof test_cases / sizeof *test_cases);
+
+
+ class move_copy_conting_class {
+ public:
+ static unsigned int moves_count;
+ static unsigned int copy_count;
+
+ move_copy_conting_class(){}
+ move_copy_conting_class(move_copy_conting_class&& /*param*/) {
+ ++ moves_count;
+ }
+
+ move_copy_conting_class& operator=(move_copy_conting_class&& /*param*/) {
+ ++ moves_count;
+ return *this;
+ }
+
+ move_copy_conting_class(const move_copy_conting_class&) {
+ ++ copy_count;
+ }
+ move_copy_conting_class& operator=(const move_copy_conting_class& /*param*/) {
+ ++ copy_count;
+ return *this;
+ }
+ };
+
+ unsigned int move_copy_conting_class::moves_count = 0;
+ unsigned int move_copy_conting_class::copy_count = 0;
+}
+
+namespace any_tests // test definitions
+{
+ using namespace boost;
+
+ void test_move_construction()
+ {
+ any value0 = move_copy_conting_class();
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+ any value(boost::move(value0));
+
+ check(value0.empty(), "moved away value is empty");
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+ check_equal(
+ move_copy_conting_class::copy_count, 0u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ }
+
+ void test_move_assignment()
+ {
+ any value0 = move_copy_conting_class();
+ any value = move_copy_conting_class();
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+ value = boost::move(value0);
+
+ check(value0.empty(), "moved away is empty");
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+ check_equal(
+ move_copy_conting_class::copy_count, 0u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ }
+
+ void test_copy_construction()
+ {
+ any value0 = move_copy_conting_class();
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+ any value(value0);
+
+ check_false(value0.empty(), "copyed value is not empty");
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+ check_equal(
+ move_copy_conting_class::copy_count, 1u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ }
+
+ void test_copy_assignment()
+ {
+ any value0 = move_copy_conting_class();
+ any value = move_copy_conting_class();
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+ value = value0;
+
+ check_false(value0.empty(), "copyied value is not empty");
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+ check_equal(
+ move_copy_conting_class::copy_count, 1u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ }
+
+ void test_move_construction_from_value()
+ {
+ move_copy_conting_class value0;
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ any value(boost::move(value0));
+#else
+ any value(value0);
+#endif
+
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ check_equal(
+ move_copy_conting_class::copy_count, 0u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 1u,
+ "checking move counts");
+#endif
+
+ }
+
+ void test_move_assignment_from_value()
+ {
+ move_copy_conting_class value0;
+ any value;
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ value = boost::move(value0);
+#else
+ value = value0;
+#endif
+
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ check_equal(
+ move_copy_conting_class::copy_count, 0u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 1u,
+ "checking move counts");
+#endif
+
+ }
+
+ void test_copy_construction_from_value()
+ {
+ move_copy_conting_class value0;
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+ any value(value0);
+
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+
+ check_equal(
+ move_copy_conting_class::copy_count, 1u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ }
+
+ void test_copy_assignment_from_value()
+ {
+ move_copy_conting_class value0;
+ any value;
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+ value = value0;
+
+ check_false(value.empty(), "empty");
+ check_equal(value.type(), typeindex::type_id<move_copy_conting_class>(), "type");
+ check_non_null(any_cast<move_copy_conting_class>(&value), "any_cast<move_copy_conting_class>");
+
+ check_equal(
+ move_copy_conting_class::copy_count, 1u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ }
+
+ const any helper_method() {
+ return true;
+ }
+
+ const bool helper_method1() {
+ return true;
+ }
+
+ void test_construction_from_const_any_rv()
+ {
+ any values[] = {helper_method(), helper_method1() };
+ (void)values;
+ }
+
+ void test_cast_to_rv()
+ {
+ move_copy_conting_class value0;
+ any value;
+ value = value0;
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+
+ move_copy_conting_class value1 = any_cast<move_copy_conting_class&&>(value);
+
+ check_equal(
+ move_copy_conting_class::copy_count, 0u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 1u,
+ "checking move counts");
+ (void)value1;
+/* Following code shall fail to compile
+ const any cvalue = value0;
+ move_copy_conting_class::copy_count = 0;
+ move_copy_conting_class::moves_count = 0;
+
+ move_copy_conting_class value2 = any_cast<move_copy_conting_class&&>(cvalue);
+
+ check_equal(
+ move_copy_conting_class::copy_count, 1u,
+ "checking copy counts");
+ check_equal(
+ move_copy_conting_class::moves_count, 0u,
+ "checking move counts");
+ (void)value2;
+*/
+ }
+
+}
+
+#endif
+
diff --git a/test/any_test_temporary_to_ref_failed.cpp b/test/any_test_temporary_to_ref_failed.cpp
new file mode 100644
index 0000000..daa42ca
--- /dev/null
+++ b/test/any_test_temporary_to_ref_failed.cpp
@@ -0,0 +1,38 @@
+// Unit test for boost::any.
+//
+// See http://www.boost.org for most recent version, including documentation.
+//
+// Copyright Antony Polukhin, 2013-2014.
+//
+// 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 <cstdlib>
+#include <string>
+#include <utility>
+
+#include <boost/any.hpp>
+#include "test.hpp"
+#include <boost/move/move.hpp>
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+int main()
+{
+ BOOST_STATIC_ASSERT(false);
+ return EXIT_SUCCESS;
+}
+
+#else
+
+
+int main()
+{
+ int i = boost::any_cast<int&>(10);
+ (void)i;
+ return EXIT_SUCCESS;
+}
+
+#endif
+
diff --git a/test/appveyor.yml b/test/appveyor.yml
new file mode 100644
index 0000000..7da83ce
--- /dev/null
+++ b/test/appveyor.yml
@@ -0,0 +1,60 @@
+# Use, modification, and distribution are
+# subject to 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)
+#
+# Copyright Antony Polukhin 2016-2017.
+
+#
+# See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file
+# and how it can be used with Boost libraries.
+#
+# File revision #5
+
+init:
+ - set BRANCH_TO_TEST=%APPVEYOR_REPO_BRANCH% # Change to branch you wish to test. Use %APPVEYOR_REPO_BRANCH% for current branch.
+ - set BOOST_REMOVE=any # Remove this folder from lib from full clone of Boost. If you are testing `any` repo, write here `any`.
+
+###############################################################################################################
+# From this point and below code is same for all the Boost libs
+###############################################################################################################
+
+version: 1.64.{build}-{branch}
+
+# branches to build
+branches:
+ except:
+ - gh-pages
+
+skip_tags: true
+
+before_build:
+ - set PATH=%PATH%;C:\\MinGW\\bin
+ - echo "Testing %APPVEYOR_PROJECT_NAME%"
+ # Cloning Boost libraries (fast nondeep cloning)
+ - set BOOST=C:/boost-local
+ - git init %BOOST%
+ - cd %BOOST%
+ - git remote add --no-tags -t %BRANCH_TO_TEST% origin https://github.com/boostorg/boost.git
+ - git fetch --depth=1
+ - git checkout %BRANCH_TO_TEST%
+ - git submodule update --init --merge --jobs 16
+ - git remote set-branches --add origin %BRANCH_TO_TEST%
+ #- git pull --recurse-submodules # Updaes submodules to most recent version. Not required
+ - rm -rf %BOOST%/libs/%BOOST_REMOVE%
+ - mv %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%APPVEYOR_PROJECT_NAME%
+
+build_script:
+ - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x64
+ - bootstrap.bat
+ - b2.exe headers
+ - cd %BOOST%/libs/%APPVEYOR_PROJECT_NAME%/test
+
+after_build:
+before_test:
+test_script:
+ - ..\..\..\b2.exe address-model=32 architecture=x86 toolset=msvc,gcc cxxflags="-DBOOST_TRAVISCI_BUILD" -sBOOST_BUILD_PATH=.
+
+after_test:
+on_success:
+on_failure:
+on_finish:
diff --git a/test/test.hpp b/test/test.hpp
new file mode 100644
index 0000000..65a0c81
--- /dev/null
+++ b/test/test.hpp
@@ -0,0 +1,321 @@
+// what: simple unit test framework
+// who: developed by Kevlin Henney
+// when: November 2000
+// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.91
+
+#ifndef TEST_INCLUDED
+#define TEST_INCLUDED
+
+#include <boost/config.hpp>
+#include <exception>
+#include <iostream>
+#ifdef BOOST_NO_STRINGSTREAM
+#include <strstream> // for out-of-the-box g++ pre-2.95.3
+#else
+#include <sstream>
+#endif
+#include <string>
+
+namespace any_tests // test tuple comprises name and nullary function (object)
+{
+ template<typename string_type, typename function_type>
+ struct test
+ {
+ string_type name;
+ function_type action;
+
+ static test make(string_type name, function_type action)
+ {
+ test result; // MSVC aggreggate initializer bugs
+ result.name = name;
+ result.action = action;
+ return result;
+ }
+ };
+}
+
+namespace any_tests // failure exception used to indicate checked test failures
+{
+ class failure : public std::exception
+ {
+ public: // struction (default cases are OK)
+
+ failure(const std::string & why) throw()
+ : reason(why)
+ {
+ }
+
+ ~failure() throw() {}
+
+ public: // usage
+
+ virtual const char * what() const throw()
+ {
+ return reason.c_str();
+ }
+
+ private: // representation
+
+ std::string reason;
+
+ };
+}
+
+namespace any_tests // not_implemented exception used to mark unimplemented tests
+{
+ class not_implemented : public std::exception
+ {
+ public: // usage (default ctor and dtor are OK)
+
+ virtual const char * what() const throw()
+ {
+ return "not implemented";
+ }
+
+ };
+}
+
+namespace any_tests // test utilities
+{
+ inline void check(bool condition, const std::string & description)
+ {
+ if(!condition)
+ {
+ throw failure(description);
+ }
+ }
+
+ inline void check_true(bool value, const std::string & description)
+ {
+ check(value, "expected true: " + description);
+ }
+
+ inline void check_false(bool value, const std::string & description)
+ {
+ check(!value, "expected false: " + description);
+ }
+
+ template<typename lhs_type, typename rhs_type>
+ void check_equal(
+ const lhs_type & lhs, const rhs_type & rhs,
+ const std::string & description)
+ {
+ check(lhs == rhs, "expected equal values: " + description);
+ }
+
+ template<typename lhs_type, typename rhs_type>
+ void check_unequal(
+ const lhs_type & lhs, const rhs_type & rhs,
+ const std::string & description)
+ {
+ check(lhs != rhs, "expected unequal values: " + description);
+ }
+
+ inline void check_null(const void * ptr, const std::string & description)
+ {
+ check(!ptr, "expected null pointer: " + description);
+ }
+
+ inline void check_non_null(const void * ptr, const std::string & description)
+ {
+ check(ptr != 0, "expected non-null pointer: " + description);
+ }
+}
+
+#define TEST_CHECK_THROW(expression, exception, description) \
+ try \
+ { \
+ expression; \
+ throw ::any_tests::failure(description); \
+ } \
+ catch(exception &) \
+ { \
+ }
+
+namespace any_tests // memory tracking (enabled if test new and delete linked in)
+{
+ class allocations
+ {
+ public: // singleton access
+
+ static allocations & instance()
+ {
+ static allocations singleton;
+ return singleton;
+ }
+
+ public: // logging
+
+ void clear()
+ {
+ alloc_count = dealloc_count = 0;
+ }
+
+ void allocation()
+ {
+ ++alloc_count;
+ }
+
+ void deallocation()
+ {
+ ++dealloc_count;
+ }
+
+ public: // reporting
+
+ unsigned long allocated() const
+ {
+ return alloc_count;
+ }
+
+ unsigned long deallocated() const
+ {
+ return dealloc_count;
+ }
+
+ bool balanced() const
+ {
+ return alloc_count == dealloc_count;
+ }
+
+ private: // structors (default dtor is fine)
+
+ allocations()
+ : alloc_count(0), dealloc_count(0)
+ {
+ }
+
+ private: // prevention
+
+ allocations(const allocations &);
+ allocations & operator=(const allocations &);
+
+ private: // state
+
+ unsigned long alloc_count, dealloc_count;
+
+ };
+}
+
+namespace any_tests // tester is the driver class for a sequence of tests
+{
+ template<typename test_iterator>
+ class tester
+ {
+ public: // structors (default destructor is OK)
+
+ tester(test_iterator first_test, test_iterator after_last_test)
+ : begin(first_test), end(after_last_test)
+ {
+ }
+
+ public: // usage
+
+ bool operator()(); // returns true if all tests passed
+
+ private: // representation
+
+ test_iterator begin, end;
+
+ private: // prevention
+
+ tester(const tester &);
+ tester &operator=(const tester &);
+
+ };
+
+#if defined(__GNUC__) && defined(__SGI_STL_PORT) && (__GNUC__ < 3)
+ // function scope using declarations don't work:
+ using namespace std;
+#endif
+
+ template<typename test_iterator>
+ bool tester<test_iterator>::operator()()
+ {
+ using std::cerr;
+ using std::endl;
+ using std::ends;
+ using std::exception;
+ using std::flush;
+ using std::string;
+
+ unsigned long passed = 0, failed = 0, unimplemented = 0;
+
+ for(test_iterator current = begin; current != end; ++current)
+ {
+ cerr << "[" << current->name << "] " << flush;
+ string result = "passed"; // optimistic
+
+ try
+ {
+ allocations::instance().clear();
+ current->action();
+
+ if(!allocations::instance().balanced())
+ {
+ unsigned long allocated = allocations::instance().allocated();
+ unsigned long deallocated = allocations::instance().deallocated();
+#ifdef BOOST_NO_STRINGSTREAM
+ std::ostrstream report;
+#else
+ std::ostringstream report;
+#endif
+ report << "new/delete ("
+ << allocated << " allocated, "
+ << deallocated << " deallocated)"
+ << ends;
+ const string text = report.str();
+#ifdef BOOST_NO_STRINGSTREAM
+ report.freeze(false);
+#endif
+ throw failure(text);
+ }
+
+ ++passed;
+ }
+ catch(const failure & caught)
+ {
+ (result = "failed: ") += caught.what();
+ ++failed;
+ }
+ catch(const not_implemented &)
+ {
+ result = "not implemented";
+ ++unimplemented;
+ }
+ catch(const exception & caught)
+ {
+ (result = "exception: ") += caught.what();
+ ++failed;
+ }
+ catch(...)
+ {
+ result = "failed with unknown exception";
+ ++failed;
+ }
+
+ cerr << result << endl;
+ }
+
+ cerr << (passed + failed) << " tests: "
+ << passed << " passed, "
+ << failed << " failed";
+
+ if(unimplemented)
+ {
+ cerr << " (" << unimplemented << " not implemented)";
+ }
+
+ cerr << endl;
+
+ return failed == 0;
+ }
+}
+
+#endif
+
+// Copyright Kevlin Henney, 2000. All rights reserved.
+//
+// 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)