From 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sat, 27 Apr 2024 20:24:20 +0200
Subject: Adding upstream version 14.2.21.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../libs/variant2/test/variant_move_construct.cpp  | 146 +++++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 src/boost/libs/variant2/test/variant_move_construct.cpp

(limited to 'src/boost/libs/variant2/test/variant_move_construct.cpp')

diff --git a/src/boost/libs/variant2/test/variant_move_construct.cpp b/src/boost/libs/variant2/test/variant_move_construct.cpp
new file mode 100644
index 00000000..dd83c8c1
--- /dev/null
+++ b/src/boost/libs/variant2/test/variant_move_construct.cpp
@@ -0,0 +1,146 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// 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/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    X1() {}
+    X1(X1 const&) {}
+    X1(X1&&) {}
+};
+
+inline bool operator==( X1, X1 ) { return true; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+
+struct X2
+{
+    X2() {}
+    X2(X2 const&) {}
+    X2(X2&&) {}
+};
+
+inline bool operator==( X2, X2 ) { return true; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+
+struct Y
+{
+    Y( Y&& ) = delete;
+};
+
+template<class V> static void test( V&& v )
+{
+    V v2( v );
+    V v3( std::move(v) );
+
+    BOOST_TEST_EQ( v2.index(), v3.index() );
+    BOOST_TEST( v2 == v3 );
+}
+
+int main()
+{
+    test( variant<int>() );
+    test( variant<int>(1) );
+
+    test( variant<int const>() );
+    test( variant<int const>(1) );
+
+    test( variant<int, float>() );
+    test( variant<int, float>(1) );
+    test( variant<int, float>(3.14f) );
+
+    test( variant<int const, float const>() );
+    test( variant<int const, float const>(1) );
+    test( variant<int const, float const>(3.14f) );
+
+    test( variant<std::string>() );
+    test( variant<std::string>("test") );
+
+    test( variant<std::string const>() );
+    test( variant<std::string const>("test") );
+
+    test( variant<int, float, std::string>() );
+    test( variant<int, float, std::string>(1) );
+    test( variant<int, float, std::string>(3.14f) );
+    test( variant<int, float, std::string>("test") );
+
+    test( variant<int, int>() );
+
+    test( variant<int, int, float>() );
+    test( variant<int, int, float>(3.14f) );
+
+    test( variant<int, int, float, float>() );
+
+    test( variant<int, int, float, float, std::string>("test") );
+
+    test( variant<std::string, std::string, float>() );
+
+    test( variant<X1 const>() );
+
+    test( variant<X1, X2>() );
+    test( variant<X1, X2, int>() );
+    test( variant<X1, X2, X2>() );
+    test( variant<X1, X1, X2, X2>() );
+
+    {
+        variant<X1, X2> v;
+        v.emplace<X2>();
+
+        test( std::move(v) );
+    }
+
+    {
+        variant<X1, X1, X2> v;
+        v.emplace<X2>();
+
+        test( std::move(v) );
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int, float>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int, int, float, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, int, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<int, X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<int, int, X1>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, X2, int, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_move_constructible<variant<X1, X2>>));
+
+#if !BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+        BOOST_TEST_TRAIT_FALSE((std::is_move_constructible<variant<int, float, Y>>));
+
+#endif
+    }
+
+    return boost::report_errors();
+}
-- 
cgit v1.2.3