summaryrefslogtreecommitdiffstats
path: root/src/boost/libs/any
diff options
context:
space:
mode:
Diffstat (limited to 'src/boost/libs/any')
-rw-r--r--src/boost/libs/any/CMakeLists.txt26
-rw-r--r--src/boost/libs/any/README.md15
-rw-r--r--src/boost/libs/any/index.html14
-rw-r--r--src/boost/libs/any/meta/libraries.json15
-rw-r--r--src/boost/libs/any/test/Jamfile.v222
-rw-r--r--src/boost/libs/any/test/any_cast_cv_failed.cpp14
-rw-r--r--src/boost/libs/any/test/any_test.cpp405
-rw-r--r--src/boost/libs/any/test/any_test_cv_to_rv_failed.cpp39
-rw-r--r--src/boost/libs/any/test/any_test_mplif.cpp19
-rw-r--r--src/boost/libs/any/test/any_test_rv.cpp331
-rw-r--r--src/boost/libs/any/test/any_test_temporary_to_ref_failed.cpp38
-rw-r--r--src/boost/libs/any/test/test.hpp321
12 files changed, 1259 insertions, 0 deletions
diff --git a/src/boost/libs/any/CMakeLists.txt b/src/boost/libs/any/CMakeLists.txt
new file mode 100644
index 000000000..275470a56
--- /dev/null
+++ b/src/boost/libs/any/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright 2019 Mike Dev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+#
+# NOTE: CMake support for Boost.Mpl is currently experimental at best
+# and the interface is likely to change in the future
+
+
+cmake_minimum_required( VERSION 3.5 )
+project( BoostAny LANGUAGES CXX )
+
+add_library( boost_any INTERFACE )
+add_library( Boost::any ALIAS boost_any )
+
+target_include_directories( boost_any INTERFACE include )
+
+target_link_libraries( boost_any
+ INTERFACE
+ Boost::config
+ Boost::core
+ Boost::static_assert
+ Boost::throw_exception
+ Boost::type_index
+ Boost::type_traits
+)
+
diff --git a/src/boost/libs/any/README.md b/src/boost/libs/any/README.md
new file mode 100644
index 000000000..72fbf0047
--- /dev/null
+++ b/src/boost/libs/any/README.md
@@ -0,0 +1,15 @@
+# [Boost.Any](http://boost.org/libs/any)
+Boost.Any is a part of the [Boost C++ Libraries](http://github.com/boostorg). It is a safe, generic container for single values of different value types.
+
+### Test results
+@ | Build | Tests coverage | More info
+----------------|-------------- | -------------- |-----------
+Develop branch: | [![Build Status](https://travis-ci.org/boostorg/any.svg?branch=develop)](https://travis-ci.org/boostorg/any) [![Build status](https://ci.appveyor.com/api/projects/status/dmugl75nfhjnx7ot/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/any/branch/develop) | [![Coverage Status](https://coveralls.io/repos/boostorg/any/badge.png?branch=develop)](https://coveralls.io/r/boostorg/any?branch=develop) | [details...](http://www.boost.org/development/tests/develop/developer/any.html)
+Master branch: | [![Build Status](https://travis-ci.org/boostorg/any.svg?branch=master)](https://travis-ci.org/boostorg/any) [![Build status](https://ci.appveyor.com/api/projects/status/dmugl75nfhjnx7ot/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/any/branch/master) | [![Coverage Status](https://coveralls.io/repos/boostorg/any/badge.png?branch=master)](https://coveralls.io/r/boostorg/any?branch=master) | [details...](http://www.boost.org/development/tests/master/developer/any.html)
+
+
+[Open Issues](https://svn.boost.org/trac/boost/query?status=!closed&component=any)
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
diff --git a/src/boost/libs/any/index.html b/src/boost/libs/any/index.html
new file mode 100644
index 000000000..18d07f16b
--- /dev/null
+++ b/src/boost/libs/any/index.html
@@ -0,0 +1,14 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/any.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/any.html">../../doc/html/any.html</a>
+<hr>
+<p>© Copyright Beman Dawes, 2001</p>
+<p> Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html> \ No newline at end of file
diff --git a/src/boost/libs/any/meta/libraries.json b/src/boost/libs/any/meta/libraries.json
new file mode 100644
index 000000000..ffb12d00f
--- /dev/null
+++ b/src/boost/libs/any/meta/libraries.json
@@ -0,0 +1,15 @@
+{
+ "key": "any",
+ "name": "Any",
+ "authors": [
+ "Kevlin Henney"
+ ],
+ "description": "Safe, generic container for single values of different value types.",
+ "std": [ "c++17" ],
+ "category": [
+ "Data"
+ ],
+ "maintainers": [
+ "Antony Polukhin <antoshkka -at- gmail.com>"
+ ]
+}
diff --git a/src/boost/libs/any/test/Jamfile.v2 b/src/boost/libs/any/test/Jamfile.v2
new file mode 100644
index 000000000..a3e8f259f
--- /dev/null
+++ b/src/boost/libs/any/test/Jamfile.v2
@@ -0,0 +1,22 @@
+# 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
+#
+
+import testing ;
+
+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/src/boost/libs/any/test/any_cast_cv_failed.cpp b/src/boost/libs/any/test/any_cast_cv_failed.cpp
new file mode 100644
index 000000000..778f770cb
--- /dev/null
+++ b/src/boost/libs/any/test/any_cast_cv_failed.cpp
@@ -0,0 +1,14 @@
+// Copyright 2006 Alexander Nasonov.
+// Copyright Antony Polukhin, 2013-2019.
+//
+// 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/src/boost/libs/any/test/any_test.cpp b/src/boost/libs/any/test/any_test.cpp
new file mode 100644
index 000000000..87fb0762c
--- /dev/null
+++ b/src/boost/libs/any/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>(&copy),
+ "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>(&copy),
+ "comparing address in copy against original");
+ check_equal(assign_result, &copy, "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-2019.
+//
+// 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/src/boost/libs/any/test/any_test_cv_to_rv_failed.cpp b/src/boost/libs/any/test/any_test_cv_to_rv_failed.cpp
new file mode 100644
index 000000000..906f1f9c8
--- /dev/null
+++ b/src/boost/libs/any/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-2019.
+//
+// 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/src/boost/libs/any/test/any_test_mplif.cpp b/src/boost/libs/any/test/any_test_mplif.cpp
new file mode 100644
index 000000000..91f490a28
--- /dev/null
+++ b/src/boost/libs/any/test/any_test_mplif.cpp
@@ -0,0 +1,19 @@
+// Copyright Antony Polukhin, 2017-2019.
+//
+// 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/src/boost/libs/any/test/any_test_rv.cpp b/src/boost/libs/any/test/any_test_rv.cpp
new file mode 100644
index 000000000..3f752ef35
--- /dev/null
+++ b/src/boost/libs/any/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-2019.
+//
+// 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(), "copied 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(), "copied 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/src/boost/libs/any/test/any_test_temporary_to_ref_failed.cpp b/src/boost/libs/any/test/any_test_temporary_to_ref_failed.cpp
new file mode 100644
index 000000000..9db0097f2
--- /dev/null
+++ b/src/boost/libs/any/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-2019.
+//
+// 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/src/boost/libs/any/test/test.hpp b/src/boost/libs/any/test/test.hpp
new file mode 100644
index 000000000..65a0c8137
--- /dev/null
+++ b/src/boost/libs/any/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)