Require valueless to be first, add test

2017-06-14 01:04:36 +03:00
parent 44d2ead565
commit 4de9f80487
3 changed files with 249 additions and 11 deletions
@@ -0,0 +1,235 @@
+
+// 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 <type_traits>
+#include <utility>
+#include <string>
+#include <stdexcept>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+enum E1
+{
+    e1
+};
+
+enum E2
+{
+    e2
+};
+
+struct X1
+{
+    X1() = default;
+    X1( E2 ) { throw std::runtime_error( "X1(E2)" ); }
+};
+
+STATIC_ASSERT( std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_constructible<X1, E2>::value );
+STATIC_ASSERT( std::is_trivially_destructible<X1>::value );
+
+struct X2
+{
+    X2() = default;
+    ~X2();
+    X2( E2 ) { throw std::runtime_error( "X1(E2)" ); }
+};
+
+X2::~X2() {}
+
+STATIC_ASSERT( std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_constructible<X2, E2>::value );
+STATIC_ASSERT( !std::is_trivially_destructible<X2>::value );
+
+struct X3
+{
+    X3() = default;
+    X3( X3 const& ) {}
+    X3( X3&& ) {}
+};
+
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X3>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X3>::value );
+STATIC_ASSERT( std::is_trivially_destructible<X3>::value );
+
+int main()
+{
+    {
+        variant<monostate, E1, X1> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 1 );
+            BOOST_TEST_EQ( get<1>(v), e1 );
+        }
+    }
+
+    {
+        variant<X3, E1, X1> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 1 );
+            BOOST_TEST_EQ( get<1>(v), e1 );
+        }
+    }
+
+    {
+        variant<valueless, E1, X1> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            // all types are trivial, so we get a constexpr path
+            // and v.index() stays 1
+
+            BOOST_TEST( v.index() == 0 || v.index() == 1 );
+
+            if( v.index() == 1 )
+            {
+                BOOST_TEST_EQ( get<1>(v), e1 );
+            }
+        }
+    }
+
+    {
+        variant<monostate, E1, X1, valueless> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 1 );
+            BOOST_TEST_EQ( get<1>(v), e1 );
+        }
+    }
+
+    {
+        variant<monostate, E1, X2> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 1 );
+            BOOST_TEST_EQ( get<1>(v), e1 );
+        }
+    }
+
+    {
+        variant<X3, E1, X2> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 1 );
+            BOOST_TEST_EQ( get<1>(v), e1 );
+        }
+    }
+
+    {
+        variant<valueless, E1, X2> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 0 );
+        }
+    }
+
+    {
+        variant<monostate, E1, X2, valueless> v;
+
+        v = e1;
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), e1 );
+
+        try
+        {
+            v = e2;
+            BOOST_ERROR( "`v = e2;` failed to throw" );
+        }
+        catch( std::exception const& )
+        {
+            BOOST_TEST_EQ( v.index(), 1 );
+            BOOST_TEST_EQ( get<1>(v), e1 );
+        }
+    }
+
+    return boost::report_errors();
+}