diff options
Diffstat (limited to 'src/boost/libs/any')
| -rw-r--r-- | src/boost/libs/any/CMakeLists.txt | 26 | ||||
| -rw-r--r-- | src/boost/libs/any/README.md | 15 | ||||
| -rw-r--r-- | src/boost/libs/any/index.html | 14 | ||||
| -rw-r--r-- | src/boost/libs/any/meta/libraries.json | 15 | ||||
| -rw-r--r-- | src/boost/libs/any/test/Jamfile.v2 | 22 | ||||
| -rw-r--r-- | src/boost/libs/any/test/any_cast_cv_failed.cpp | 14 | ||||
| -rw-r--r-- | src/boost/libs/any/test/any_test.cpp | 405 | ||||
| -rw-r--r-- | src/boost/libs/any/test/any_test_cv_to_rv_failed.cpp | 39 | ||||
| -rw-r--r-- | src/boost/libs/any/test/any_test_mplif.cpp | 19 | ||||
| -rw-r--r-- | src/boost/libs/any/test/any_test_rv.cpp | 331 | ||||
| -rw-r--r-- | src/boost/libs/any/test/any_test_temporary_to_ref_failed.cpp | 38 | ||||
| -rw-r--r-- | src/boost/libs/any/test/test.hpp | 321 |
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: | [](https://travis-ci.org/boostorg/any) [](https://ci.appveyor.com/project/apolukhin/any/branch/develop) | [](https://coveralls.io/r/boostorg/any?branch=develop) | [details...](http://www.boost.org/development/tests/develop/developer/any.html) +Master branch: | [](https://travis-ci.org/boostorg/any) [](https://ci.appveyor.com/project/apolukhin/any/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>(©), + "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-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) |