CaseyCarter created this revision.
As the saying goes, "works on my machine."
NOTE: libc++ variant does not yet implement LWG2857 and will not pass these
tests; MSVC variant does.
Changes under `TEST_VARIANT_HAS_NO_REFERENCES` are dry-coded; I figure that's
better than nothing.
https://reviews.llvm.org/D32107
Files:
test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -15,7 +15,7 @@
// template <class ...Types> class variant;
// template <class T, class U, class ...Args>
-// void emplace(initializer_list<U> il,Args&&... args);
+// T& emplace(initializer_list<U> il,Args&&... args);
#include <cassert>
#include <string>
@@ -70,13 +70,19 @@
void test_basic() {
using V = std::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
V v;
- v.emplace<InitList>({1, 2, 3});
+ auto& ref1 = v.emplace<InitList>({1, 2, 3});
+ static_assert(std::is_same_v<InitList&,decltype(ref1)>, "");
assert(std::get<InitList>(v).size == 3);
- v.emplace<InitListArg>({1, 2, 3, 4}, 42);
+ assert(&ref1 == &std::get<InitList>(v));
+ auto& ref2 = v.emplace<InitListArg>({1, 2, 3, 4}, 42);
+ static_assert(std::is_same_v<InitListArg&,decltype(ref2)>, "");
assert(std::get<InitListArg>(v).size == 4);
assert(std::get<InitListArg>(v).value == 42);
- v.emplace<InitList>({1});
+ assert(&ref == &std::get<InitListArg>(v));
+ auto& ref3 = v.emplace<InitList>({1});
+ static_assert(std::is_same_v<InitList&,decltype(ref3)>, "");
assert(std::get<InitList>(v).size == 1);
+ assert(&ref3 == &std::get<InitList>(v));
}
int main() {
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -14,7 +14,7 @@
// template <class ...Types> class variant;
-// template <class T, class ...Args> void emplace(Args&&... args);
+// template <class T, class ...Args> T& emplace(Args&&... args);
#include <cassert>
#include <string>
@@ -86,24 +86,34 @@
{
using V = std::variant<int>;
V v(42);
- v.emplace<int>();
+ auto& ref1 = v.emplace<int>();
+ static_assert(std::is_same_v<int&, decltype(ref1)>, "");
assert(std::get<0>(v) == 0);
- v.emplace<int>(42);
+ assert(&ref1 == &std::get<0>(v));
+ auto& ref2 = v.emplace<int>(42);
+ static_assert(std::is_same_v<int&, decltype(ref2)>, "");
assert(std::get<0>(v) == 42);
+ assert(&ref2 == &std::get<0>(v));
}
{
using V =
std::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
const int x = 100;
V v(std::in_place_type<int>, -1);
// default emplace a value
- v.emplace<long>();
+ auto& ref1 = v.emplace<long>();
+ static_assert(std::is_same_v<long&, decltype(ref1)>, "");
assert(std::get<1>(v) == 0);
- v.emplace<const void *>(&x);
+ assert(&ref1 == &std::get<1>(v));
+ auto& ref2 = v.emplace<const void *>(&x);
+ static_assert(std::is_same_v<const void *&, decltype(ref2)>, "");
assert(std::get<2>(v) == &x);
+ assert(&ref2 == &std::get<2>(v));
// emplace with multiple args
- v.emplace<std::string>(3, 'a');
+ auto& ref3 = v.emplace<std::string>(3, 'a');
+ static_assert(std::is_same_v<std::string&, decltype(ref3)>, "");
assert(std::get<4>(v) == "aaa");
+ assert(&ref3 == &std::get<4>(v));
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{
@@ -114,20 +124,30 @@
int z = 43;
V v(std::in_place_index<0>, -1);
// default emplace a value
- v.emplace<long>();
+ auto& ref1 = v.emplace<long>();
+ static_assert(std::is_same_v<long&, decltype(ref1)>, "");
assert(std::get<long>(v) == 0);
+ assert(&ref1 == &std::get<long>(v));
// emplace a reference
- v.emplace<const int &>(x);
+ auto& ref2 = v.emplace<const int &>(x);
+ static_assert(std::is_same_v<const int&, decltype(ref2)>, "");
assert(&std::get<const int &>(v) == &x);
+ assert(&ref2 == &std::get<const int &>(v));
// emplace an rvalue reference
- v.emplace<int &&>(std::move(y));
+ auto& ref3 = v.emplace<int &&>(std::move(y));
+ static_assert(std::is_same_v<int &&, decltype(ref3)>, "");
assert(&std::get<int &&>(v) == &y);
+ assert(&ref3 == &std::get<int &&>(v));
// re-emplace a new reference over the active member
- v.emplace<int &&>(std::move(z));
+ auto& ref4 = v.emplace<int &&>(std::move(z));
+ static_assert(std::is_same_v<int &, decltype(ref4)>, "");
assert(&std::get<int &&>(v) == &z);
+ assert(&ref4 == &std::get<int &&>(v));
// emplace with multiple args
- v.emplace<std::string>(3, 'a');
+ auto& ref5 = v.emplace<std::string>(3, 'a');
+ static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
assert(std::get<std::string>(v) == "aaa");
+ assert(&ref5 == &std::get<std::string>(v));
}
#endif
}
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -15,7 +15,7 @@
// template <class ...Types> class variant;
// template <size_t I, class U, class ...Args>
-// void emplace(initializer_list<U> il,Args&&... args);
+// variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il,Args&&... args);
#include <cassert>
#include <string>
@@ -70,13 +70,19 @@
void test_basic() {
using V = std::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
V v;
- v.emplace<1>({1, 2, 3});
+ auto& ref1 = v.emplace<1>({1, 2, 3});
+ static_assert(std::is_same_v<InitList&, decltype(ref1)>, "");
assert(std::get<1>(v).size == 3);
- v.emplace<2>({1, 2, 3, 4}, 42);
+ assert(&ref1 == &std::get<1>(v));
+ auto& ref2 = v.emplace<2>({1, 2, 3, 4}, 42);
+ static_assert(std::is_same_v<InitListArg&, decltype(ref2)>, "");
assert(std::get<2>(v).size == 4);
assert(std::get<2>(v).value == 42);
- v.emplace<1>({1});
+ assert(&ref2 == &std::get<2>(v));
+ auto& ref3 = v.emplace<1>({1});
+ static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
assert(std::get<1>(v).size == 1);
+ assert(&ref3 == &std::get<1>(v));
}
int main() {
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -14,7 +14,8 @@
// template <class ...Types> class variant;
-// template <size_t I, class ...Args> void emplace(Args&&... args);
+// template <size_t I, class ...Args>
+// variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
#include <cassert>
#include <string>
@@ -85,24 +86,34 @@
{
using V = std::variant<int>;
V v(42);
- v.emplace<0>();
+ auto& ref1 = v.emplace<0>();
+ static_assert(std::is_same_v<int&, decltype(ref1)>, "");
assert(std::get<0>(v) == 0);
- v.emplace<0>(42);
+ assert(&ref1 == &std::get<0>(v));
+ auto& ref2 = v.emplace<0>(42);
+ static_assert(std::is_same_v<int&, decltype(ref2)>, "");
assert(std::get<0>(v) == 42);
+ assert(&ref2 == &std::get<0>(v));
}
{
using V =
std::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
const int x = 100;
V v(std::in_place_index<0>, -1);
// default emplace a value
- v.emplace<1>();
+ auto& ref1 = v.emplace<1>();
+ static_assert(std::is_same_v<long&, decltype(ref1)>, "");
assert(std::get<1>(v) == 0);
- v.emplace<2>(&x);
+ assert(&ref1 == &std::get<1>(v));
+ auto& ref2 = v.emplace<2>(&x);
+ static_assert(std::is_same_v<const void*&, decltype(ref2)>, "");
assert(std::get<2>(v) == &x);
+ assert(&ref2 == &std::get<2>(v));
// emplace with multiple args
- v.emplace<4>(3, 'a');
+ auto& ref3 = v.emplace<4>(3, 'a');
+ static_assert(std::is_same_v<std::string&, decltype(ref3)>, "");
assert(std::get<4>(v) == "aaa");
+ assert(&ref3 == &std::get<4>(v));
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{
@@ -113,20 +124,30 @@
int z = 43;
V v(std::in_place_index<0>, -1);
// default emplace a value
- v.emplace<1>();
+ auto& ref1 = v.emplace<1>();
+ static_assert(std::is_same_v<long&, decltype(ref1)>, "");
assert(std::get<1>(v) == 0);
+ assert(&ref1 == &std::get<1>(v));
// emplace a reference
- v.emplace<2>(x);
+ auto& ref2 = v.emplace<2>(x);
+ static_assert(std::is_same_v<&, decltype(ref)>, "");
assert(&std::get<2>(v) == &x);
+ assert(&ref2 == &std::get<2>(v));
// emplace an rvalue reference
- v.emplace<3>(std::move(y));
+ auto& ref3 = v.emplace<3>(std::move(y));
+ static_assert(std::is_same_v<&, decltype(ref)>, "");
assert(&std::get<3>(v) == &y);
+ assert(&ref3 == &std::get<3>(v));
// re-emplace a new reference over the active member
- v.emplace<3>(std::move(z));
+ auto& ref4 = v.emplace<3>(std::move(z));
+ static_assert(std::is_same_v<&, decltype(ref)>, "");
assert(&std::get<3>(v) == &z);
+ assert(&ref4 == &std::get<3>(v));
// emplace with multiple args
- v.emplace<5>(3, 'a');
+ auto& ref5 = v.emplace<5>(3, 'a');
+ static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
assert(std::get<5>(v) == "aaa");
+ assert(&ref5 == &std::get<5>(v));
}
#endif
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
