diff --git a/test/assign.conversion.cpp b/test/assign.conversion.cpp
index aed268b..dcd6192 100644
--- a/test/assign.conversion.cpp
+++ b/test/assign.conversion.cpp
@@ -72,6 +72,20 @@ TEST_CASE("variant<Ts...>::operator=(T&&)", "[variant.assign]")
         CHECK(v.target_type() == typeid(int));
 #endif
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v = Dtor();
+
+            CHECK(v.which() == 1u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -88,7 +102,7 @@ TEST_CASE("variant<Ts...>::operator=(T&&)", "[variant.assign]")
 
     // different target
     {
-        eggs::variant<int, std::string> v(std::string{""});
+        eggs::variant<int, std::string> v(std::string(""));
 
         REQUIRE(bool(v) == true);
         REQUIRE(v.which() == 1u);
@@ -105,6 +119,20 @@ TEST_CASE("variant<Ts...>::operator=(T&&)", "[variant.assign]")
         CHECK(v.target_type() == typeid(int));
 #endif
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v = 42;
+
+            CHECK(v.which() == 0u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX98_HAS_EXCEPTIONS
         // exception-safety
         {
@@ -113,15 +141,15 @@ TEST_CASE("variant<Ts...>::operator=(T&&)", "[variant.assign]")
 
             REQUIRE(bool(v) == true);
             REQUIRE(v.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v = Throw{});
 
             CHECK(bool(v) == false);
             CHECK(v.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
diff --git a/test/assign.copy.cpp b/test/assign.copy.cpp
index 6b4c45d..3152502 100644
--- a/test/assign.copy.cpp
+++ b/test/assign.copy.cpp
@@ -41,6 +41,22 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...> const&)", "[variant.assign]"
         CHECK(bool(v2) == false);
         CHECK(v2.which() == v1.which());
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> const v1;
+            eggs::variant<int, Dtor> v2(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v1.which() == npos);
+            REQUIRE(v2.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v2 = v1;
+
+            CHECK(v2.which() == npos);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -116,6 +132,22 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...> const&)", "[variant.assign]"
         REQUIRE(v2.target<int>() != nullptr);
         CHECK(*v2.target<int>() == 42);
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> const v1(eggs::variants::in_place<Dtor>);
+            eggs::variant<int, Dtor> v2(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v1.which() == 1u);
+            REQUIRE(v2.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v2 = v1;
+
+            CHECK(v2.which() == 1u);
+            CHECK(Dtor::calls == 0u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -139,7 +171,7 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...> const&)", "[variant.assign]"
         REQUIRE(v1.which() == 0u);
         REQUIRE(*v1.target<int>() == 42);
 
-        eggs::variant<int, std::string> v2(std::string{""});
+        eggs::variant<int, std::string> v2(std::string(""));
 
         REQUIRE(bool(v2) == true);
         REQUIRE(v2.which() == 1u);
@@ -154,6 +186,22 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...> const&)", "[variant.assign]"
         REQUIRE(v2.target<int>() != nullptr);
         CHECK(*v2.target<int>() == 42);
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> const v1(42);
+            eggs::variant<int, Dtor> v2(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v1.which() == 0u);
+            REQUIRE(v2.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v2 = v1;
+
+            CHECK(v2.which() == 0u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX98_HAS_EXCEPTIONS
         // exception-safety
         {
@@ -167,7 +215,7 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...> const&)", "[variant.assign]"
 
             REQUIRE(bool(v2) == true);
             REQUIRE(v2.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v2 = v1);
 
@@ -175,9 +223,9 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...> const&)", "[variant.assign]"
             CHECK(bool(v2) == false);
             CHECK(v1.which() == 1u);
             CHECK(v2.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
diff --git a/test/assign.emplace.cpp b/test/assign.emplace.cpp
index db68742..4c7a272 100644
--- a/test/assign.emplace.cpp
+++ b/test/assign.emplace.cpp
@@ -72,6 +72,20 @@ TEST_CASE("variant<Ts...>::emplace<I>(Args&&...)", "[variant.assign]")
         CHECK(v.target_type() == typeid(int));
 #endif
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v.emplace<1>();
+
+            CHECK(v.which() == 1u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -88,7 +102,7 @@ TEST_CASE("variant<Ts...>::emplace<I>(Args&&...)", "[variant.assign]")
 
     // different target
     {
-        eggs::variant<int, std::string> v(std::string{""});
+        eggs::variant<int, std::string> v(std::string(""));
 
         REQUIRE(bool(v) == true);
         REQUIRE(v.which() == 1u);
@@ -105,6 +119,20 @@ TEST_CASE("variant<Ts...>::emplace<I>(Args&&...)", "[variant.assign]")
         CHECK(v.target_type() == typeid(int));
 #endif
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v.emplace<0>(42);
+
+            CHECK(v.which() == 0u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX98_HAS_EXCEPTIONS
         // exception-safety
         {
@@ -113,15 +141,15 @@ TEST_CASE("variant<Ts...>::emplace<I>(Args&&...)", "[variant.assign]")
 
             REQUIRE(bool(v) == true);
             REQUIRE(v.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v.emplace<1>(0));
 
             CHECK(bool(v) == false);
             CHECK(v.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
@@ -194,7 +222,7 @@ TEST_CASE("variant<Ts...>::emplace<I>(std::initializer_list<U>, Args&&...)", "[v
 
     // same target
     {
-        eggs::variant<int, std::string> v(std::string{""});
+        eggs::variant<int, std::string> v(std::string(""));
 
         REQUIRE(bool(v) == true);
         REQUIRE(v.which() == 1u);
@@ -252,15 +280,15 @@ TEST_CASE("variant<Ts...>::emplace<I>(std::initializer_list<U>, Args&&...)", "[v
 
             REQUIRE(bool(v) == true);
             REQUIRE(v.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v.emplace<1>({0}));
 
             CHECK(bool(v) == false);
             CHECK(v.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
@@ -351,6 +379,20 @@ TEST_CASE("variant<Ts...>::emplace<T>(Args&&...)", "[variant.assign]")
         CHECK(v.target_type() == typeid(int));
 #endif
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v.emplace<Dtor>();
+
+            CHECK(v.which() == 1u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -367,7 +409,7 @@ TEST_CASE("variant<Ts...>::emplace<T>(Args&&...)", "[variant.assign]")
 
     // different target
     {
-        eggs::variant<int, std::string> v(std::string{""});
+        eggs::variant<int, std::string> v(std::string(""));
 
         REQUIRE(bool(v) == true);
         REQUIRE(v.which() == 1u);
@@ -384,6 +426,20 @@ TEST_CASE("variant<Ts...>::emplace<T>(Args&&...)", "[variant.assign]")
         CHECK(v.target_type() == typeid(int));
 #endif
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v.emplace<int>(42);
+
+            CHECK(v.which() == 0u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX98_HAS_EXCEPTIONS
         // exception-safety
         {
@@ -392,15 +448,15 @@ TEST_CASE("variant<Ts...>::emplace<T>(Args&&...)", "[variant.assign]")
 
             REQUIRE(bool(v) == true);
             REQUIRE(v.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v.emplace<Throw>(0));
 
             CHECK(bool(v) == false);
             CHECK(v.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
@@ -455,7 +511,7 @@ TEST_CASE("variant<Ts...>::emplace<T>(std::initializer_list<U>, Args&&...)", "[v
 
     // same target
     {
-        eggs::variant<int, std::string> v(std::string{""});
+        eggs::variant<int, std::string> v(std::string(""));
 
         REQUIRE(bool(v) == true);
         REQUIRE(v.which() == 1u);
@@ -513,15 +569,15 @@ TEST_CASE("variant<Ts...>::emplace<T>(std::initializer_list<U>, Args&&...)", "[v
 
             REQUIRE(bool(v) == true);
             REQUIRE(v.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v.emplace<Throw>({0}));
 
             CHECK(bool(v) == false);
             CHECK(v.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
diff --git a/test/assign.move.cpp b/test/assign.move.cpp
index 99d3eca..5503829 100644
--- a/test/assign.move.cpp
+++ b/test/assign.move.cpp
@@ -41,6 +41,22 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...>&&)", "[variant.assign]")
         CHECK(bool(v2) == false);
         CHECK(v2.which() == v1.which());
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v1;
+            eggs::variant<int, Dtor> v2(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v1.which() == npos);
+            REQUIRE(v2.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v2 = std::move(v1);
+
+            CHECK(v2.which() == npos);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -114,6 +130,22 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...>&&)", "[variant.assign]")
         REQUIRE(v2.target<int>() != nullptr);
         CHECK(*v2.target<int>() == 42);
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v1(eggs::variants::in_place<Dtor>);
+            eggs::variant<int, Dtor> v2(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v1.which() == 1u);
+            REQUIRE(v2.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v2 = std::move(v1);
+
+            CHECK(v2.which() == 1u);
+            CHECK(Dtor::calls == 0u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
         {
@@ -137,7 +169,7 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...>&&)", "[variant.assign]")
         REQUIRE(v1.which() == 0u);
         REQUIRE(*v1.target<int>() == 42);
 
-        eggs::variant<int, std::string> v2(std::string{""});
+        eggs::variant<int, std::string> v2(std::string(""));
 
         REQUIRE(bool(v2) == true);
         REQUIRE(v2.which() == 1u);
@@ -151,6 +183,22 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...>&&)", "[variant.assign]")
         REQUIRE(v2.target<int>() != nullptr);
         CHECK(*v2.target<int>() == 42);
 
+        // dtor
+        {
+            eggs::variant<int, Dtor> v1(42);
+            eggs::variant<int, Dtor> v2(eggs::variants::in_place<Dtor>);
+
+            REQUIRE(v1.which() == 0u);
+            REQUIRE(v2.which() == 1u);
+            REQUIRE(Dtor::calls == 0u);
+
+            v2 = std::move(v1);
+
+            CHECK(v2.which() == 0u);
+            CHECK(Dtor::calls == 1u);
+        }
+        Dtor::calls = 0u;
+
 #if EGGS_CXX98_HAS_EXCEPTIONS
         // exception-safety
         {
@@ -165,7 +213,7 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...>&&)", "[variant.assign]")
 
             REQUIRE(bool(v2) == true);
             REQUIRE(v2.which() == 0u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             CHECK_THROWS(v2 = std::move(v1));
 
@@ -173,9 +221,9 @@ TEST_CASE("variant<Ts...>::operator=(variant<Ts...>&&)", "[variant.assign]")
             CHECK(bool(v2) == false);
             CHECK(v1.which() == 1u);
             CHECK(v2.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 #endif
 
 #if EGGS_CXX14_HAS_CONSTEXPR
diff --git a/test/dtor.cpp b/test/dtor.cpp
index 76b85a7..2b5d4bc 100644
--- a/test/dtor.cpp
+++ b/test/dtor.cpp
@@ -28,11 +28,11 @@ TEST_CASE("variant<Ts...>::~variant()", "[variant.dtor]")
             eggs::variant<int, Dtor> v;
             v.emplace<1>();
 
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
         }
-        CHECK(Dtor::called == true);
+        CHECK(Dtor::calls == 1u);
     }
-    Dtor::called = false;
+    Dtor::calls = 0u;
 
     // trivially_destructible
     {
diff --git a/test/dtor.hpp b/test/dtor.hpp
index e69cb2f..ab48841 100644
--- a/test/dtor.hpp
+++ b/test/dtor.hpp
@@ -8,14 +8,16 @@
 #ifndef EGGS_VARIANT_TEST_DTOR_HPP
 #define EGGS_VARIANT_TEST_DTOR_HPP
 
+#include <cstddef>
+
 struct Dtor
 {
-    static bool called;
+    static std::size_t calls;
     Dtor() = default;
-    ~Dtor() { called = true; }
+    ~Dtor() { ++calls; }
 };
 
-bool Dtor::called = false;
+std::size_t Dtor::calls = 0u;
 
 void swap(Dtor&, Dtor&) {}
 
diff --git a/test/rel.equality.cpp b/test/rel.equality.cpp
index e82cbb3..f40580c 100644
--- a/test/rel.equality.cpp
+++ b/test/rel.equality.cpp
@@ -69,7 +69,7 @@ TEST_CASE("operator==(variant<Ts...> const&, variant<Ts...> const&)", "[variant.
 
     // different members
     {
-        eggs::variant<int, std::string> const v1(std::string{""});
+        eggs::variant<int, std::string> const v1(std::string(""));
 
         REQUIRE(v1.which() == 1u);
         REQUIRE(*v1.target<std::string>() == "");
@@ -134,7 +134,7 @@ TEST_CASE("operator==(variant<Ts...> const&, T const&)", "[variant.rel]")
 
     // different members
     {
-        eggs::variant<int, std::string> const v1(std::string{""});
+        eggs::variant<int, std::string> const v1(std::string(""));
 
         REQUIRE(v1.which() == 1u);
         REQUIRE(*v1.target<std::string>() == "");
@@ -203,7 +203,7 @@ TEST_CASE("operator==(T const&, variant<Ts...> const&)", "[variant.rel]")
 
     // different members
     {
-        eggs::variant<int, std::string> const v1(std::string{""});
+        eggs::variant<int, std::string> const v1(std::string(""));
 
         REQUIRE(v1.which() == 1u);
         REQUIRE(*v1.target<std::string>() == "");
diff --git a/test/rel.order.cpp b/test/rel.order.cpp
index f5de5b6..dcd7e06 100644
--- a/test/rel.order.cpp
+++ b/test/rel.order.cpp
@@ -78,7 +78,7 @@ TEST_CASE("operator<(variant<Ts...> const&, variant<Ts...> const&)", "[variant.r
         REQUIRE(v1.which() == 0u);
         REQUIRE(*v1.target<int>() == 42);
 
-        eggs::variant<int, std::string> const v2(std::string{""});
+        eggs::variant<int, std::string> const v2(std::string(""));
 
         REQUIRE(v2.which() == 1u);
         REQUIRE(*v2.target<std::string>() == "");
@@ -149,7 +149,7 @@ TEST_CASE("operator<(variant<Ts...> const&, T const&)", "[variant.rel]")
         REQUIRE(v1.which() == 0u);
         REQUIRE(*v1.target<int>() == 42);
 
-        CHECK(v1 < std::string{""});
+        CHECK(v1 < std::string(""));
 
 #if EGGS_CXX11_HAS_CONSTEXPR
         // constexpr
@@ -219,7 +219,7 @@ TEST_CASE("operator<(T const&, variant<Ts...> const&)", "[variant.rel]")
 
     // different members
     {
-        eggs::variant<int, std::string> const v1(std::string{""});
+        eggs::variant<int, std::string> const v1(std::string(""));
 
         REQUIRE(v1.which() == 1u);
         REQUIRE(*v1.target<std::string>() == "");
diff --git a/test/swap.cpp b/test/swap.cpp
index ac459df..0bdb724 100644
--- a/test/swap.cpp
+++ b/test/swap.cpp
@@ -44,15 +44,15 @@ TEST_CASE("variant<Ts...>::swap(variant<Ts...>&)", "[variant.swap]")
 
             REQUIRE(v1.which() == npos);
             REQUIRE(v2.which() == 1u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             v1.swap(v2);
 
             CHECK(v1.which() == 1u);
             CHECK(v2.which() == npos);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
@@ -94,15 +94,15 @@ TEST_CASE("variant<Ts...>::swap(variant<Ts...>&)", "[variant.swap]")
 
             REQUIRE(v1.which() == 1u);
             REQUIRE(v2.which() == npos);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             v1.swap(v2);
 
             CHECK(v1.which() == npos);
             CHECK(v2.which() == 1u);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
@@ -147,15 +147,15 @@ TEST_CASE("variant<Ts...>::swap(variant<Ts...>&)", "[variant.swap]")
 
             REQUIRE(v1.which() == 1u);
             REQUIRE(v2.which() == 1u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             v1.swap(v2);
 
             CHECK(v1.which() == 1u);
             CHECK(v2.which() == 1u);
-            CHECK(Dtor::called == false);
+            CHECK(Dtor::calls == 0u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr
@@ -179,7 +179,7 @@ TEST_CASE("variant<Ts...>::swap(variant<Ts...>&)", "[variant.swap]")
         REQUIRE(v1.which() == 0u);
         REQUIRE(*v1.target<int>() == 42);
 
-        eggs::variant<int, std::string> v2(std::string{""});
+        eggs::variant<int, std::string> v2(std::string(""));
 
         REQUIRE(v2.which() == 1u);
         REQUIRE(*v2.target<std::string>() == "");
@@ -200,15 +200,15 @@ TEST_CASE("variant<Ts...>::swap(variant<Ts...>&)", "[variant.swap]")
 
             REQUIRE(v1.which() == 0u);
             REQUIRE(v2.which() == 1u);
-            REQUIRE(Dtor::called == false);
+            REQUIRE(Dtor::calls == 0u);
 
             v1.swap(v2);
 
             CHECK(v1.which() == 1u);
             CHECK(v2.which() == 0u);
-            CHECK(Dtor::called == true);
+            CHECK(Dtor::calls == 1u);
         }
-        Dtor::called = false;
+        Dtor::calls = 0u;
 
 #if EGGS_CXX14_HAS_CONSTEXPR
         // constexpr