From 89e3588c9b1bd04129ffae96b884763f53fa242d Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Wed, 31 May 2017 20:48:17 +0300
Subject: [PATCH] Add test/variant_destroy

---
 test/Jamfile             |   1 +
 test/variant_destroy.cpp | 205 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 206 insertions(+)
 create mode 100644 test/variant_destroy.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 771cbf9..323ec4d 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -36,3 +36,4 @@ run variant_emplace_index.cpp : : : $(REQ) ;
 run variant_emplace_type.cpp : : : $(REQ) ;
 run variant_swap.cpp : : : $(REQ) ;
 run variant_eq_ne.cpp : : : $(REQ) ;
+run variant_destroy.cpp : : : $(REQ) ;
diff --git a/test/variant_destroy.cpp b/test/variant_destroy.cpp
new file mode 100644
index 0000000..392a2d7
--- /dev/null
+++ b/test/variant_destroy.cpp
@@ -0,0 +1,205 @@
+
+// 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;
+
+struct X1
+{
+    static int instances;
+
+    int v;
+
+    X1(): v(0) { ++instances; }
+    explicit X1(int v): v(v) { ++instances; }
+    X1(X1 const& r): v(r.v) { ++instances; }
+    X1(X1&& r): v(r.v) { ++instances; }
+
+    ~X1() noexcept { --instances; }
+
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+int X1::instances = 0;
+
+struct X2
+{
+    static int instances;
+
+    int v;
+
+    X2(): v(0) { ++instances; }
+    explicit X2(int v): v(v) { ++instances; }
+    X2(X2 const& r): v(r.v) { ++instances; }
+    X2(X2&& r): v(r.v) { ++instances; }
+
+    ~X2() noexcept { --instances; }
+
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+int X2::instances = 0;
+
+struct Y1
+{
+    static int instances;
+
+    int v;
+
+    Y1() noexcept: v(0) { ++instances; }
+    explicit Y1(int v) noexcept: v(v) { ++instances; }
+    Y1(Y1 const& r) noexcept: v(r.v) { ++instances; }
+    Y1(Y1&& r) noexcept: v(r.v) { ++instances; }
+
+    ~Y1() noexcept { --instances; }
+
+    Y1& operator=( Y1 const& r ) noexcept { v = r.v; return *this; }
+    Y1& operator=( Y1&& r ) noexcept { v = r.v; return *this; }
+};
+
+int Y1::instances = 0;
+
+struct Y2
+{
+    static int instances;
+
+    int v;
+
+    Y2() noexcept: v(0) { ++instances; }
+    explicit Y2(int v) noexcept: v(v) { ++instances; }
+    Y2(Y2 const& r) noexcept: v(r.v) { ++instances; }
+    Y2(Y2&& r) noexcept: v(r.v) { ++instances; }
+
+    ~Y2() noexcept { --instances; }
+
+    Y2& operator=( Y2 const& r ) noexcept { v = r.v; return *this; }
+    Y2& operator=( Y2&& r ) noexcept { v = r.v; return *this; }
+};
+
+int Y2::instances = 0;
+
+int main()
+{
+    BOOST_TEST_EQ( Y1::instances, 0 );
+
+    {
+        variant<Y1> v;
+        BOOST_TEST_EQ( Y1::instances, 1 );
+
+        {
+            variant<Y1> v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+
+            v = v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+        }
+
+        BOOST_TEST_EQ( Y1::instances, 1 );
+
+        v = Y1{1};
+        BOOST_TEST_EQ( Y1::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( Y1::instances, 0 );
+    BOOST_TEST_EQ( Y2::instances, 0 );
+
+    {
+        variant<Y1, Y2> v;
+
+        BOOST_TEST_EQ( Y1::instances, 1 );
+        BOOST_TEST_EQ( Y2::instances, 0 );
+
+        {
+            variant<Y1, Y2> v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+            BOOST_TEST_EQ( Y2::instances, 0 );
+
+            v = v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+            BOOST_TEST_EQ( Y2::instances, 0 );
+
+            v2 = Y2{1};
+            BOOST_TEST_EQ( Y1::instances, 1 );
+            BOOST_TEST_EQ( Y2::instances, 1 );
+
+            v = v2;
+            BOOST_TEST_EQ( Y1::instances, 0 );
+            BOOST_TEST_EQ( Y2::instances, 2 );
+        }
+
+        BOOST_TEST_EQ( Y1::instances, 0 );
+        BOOST_TEST_EQ( Y2::instances, 1 );
+
+        v.emplace<0>();
+
+        BOOST_TEST_EQ( Y1::instances, 1 );
+        BOOST_TEST_EQ( Y2::instances, 0 );
+
+        v.emplace<Y2>();
+
+        BOOST_TEST_EQ( Y1::instances, 0 );
+        BOOST_TEST_EQ( Y2::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( Y1::instances, 0 );
+    BOOST_TEST_EQ( Y2::instances, 0 );
+
+    BOOST_TEST_EQ( X1::instances, 0 );
+    BOOST_TEST_EQ( X2::instances, 0 );
+
+    {
+        variant<X1, X2> v;
+
+        BOOST_TEST_EQ( X1::instances, 1 );
+        BOOST_TEST_EQ( X2::instances, 0 );
+
+        {
+            variant<X1, X2> v2;
+            BOOST_TEST_EQ( X1::instances, 2 );
+            BOOST_TEST_EQ( X2::instances, 0 );
+
+            v = v2;
+            BOOST_TEST_EQ( X1::instances, 2 );
+            BOOST_TEST_EQ( X2::instances, 0 );
+
+            v2 = X2{1};
+            BOOST_TEST_EQ( X1::instances, 1 );
+            BOOST_TEST_EQ( X2::instances, 1 );
+
+            v = v2;
+            BOOST_TEST_EQ( X1::instances, 0 );
+            BOOST_TEST_EQ( X2::instances, 2 );
+        }
+
+        BOOST_TEST_EQ( X1::instances, 0 );
+        BOOST_TEST_EQ( X2::instances, 1 );
+
+        v.emplace<0>();
+
+        BOOST_TEST_EQ( X1::instances, 1 );
+        BOOST_TEST_EQ( X2::instances, 0 );
+
+        v.emplace<X2>();
+
+        BOOST_TEST_EQ( X1::instances, 0 );
+        BOOST_TEST_EQ( X2::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X1::instances, 0 );
+    BOOST_TEST_EQ( X2::instances, 0 );
+
+    return boost::report_errors();
+}