[libcxx][test] Expand LWG2857 coverage

[CaseyCarter]

Summary

• Cover optional's emplace-from-initializer_list overload
• Verify that any::emplace and optional::emplace return a reference to the correct type even for throwing cases

test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp

void test_emplace_type() {
     assert(Type::count == 0);
     Type::reset();
     {
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
 
         auto &v = a.emplace<Type>();
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
     Type::reset();
     {
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
 
         auto &v = a.emplace<Type>(101);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 101);
     }
     assert(Type::count == 0);
     Type::reset();
     {
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
 
         auto &v = a.emplace<Type>(-1, 42, -1);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);
     Type::reset();
 }
 
 template <class Type>
 void test_emplace_type_tracked() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     {
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>();
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type>(a);
     }
     {
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>(-1, 42, -1);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type, int, int, int>(a);
     }
     // initializer_list constructor tests
     {
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>({-1, 42, -1});
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type, std::initializer_list<int>>(a);
     }
     {
         int x = 42;
         any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>({-1, 42, -1}, x);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
-    assert(&v == std::any_cast<Type>(&a));
+        assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type, std::initializer_list<int>, int&>(a);
     }
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 

 template <class Type>
 void test_emplace_throws()
 {
     // any stores small type
     {
         std::any a(small{42});
         assert(small::count == 1);
         try {
-            a.emplace<Type>(101);
+            auto &v = a.emplace<Type>(101);
+            static_assert( std::is_same_v<Type&, decltype(v)>, "" );
             assert(false);
         } catch (int const&) {
         }
         assert(small::count == 0);
     }
     {
         std::any a(small{42});
         assert(small::count == 1);
         try {
-            a.emplace<Type>({1, 2, 3}, 101);
+            auto &v = a.emplace<Type>({1, 2, 3}, 101);
+            static_assert( std::is_same_v<Type&, decltype(v)>, "" );
             assert(false);
         } catch (int const&) {
         }
         assert(small::count == 0);
     }
     // any stores large type
     {
         std::any a(large{42});
         assert(large::count == 1);
         try {
-            a.emplace<Type>(101);
+            auto &v = a.emplace<Type>(101);
+            static_assert( std::is_same_v<Type&, decltype(v)>, "" );
             assert(false);
         } catch (int const&) {
         }
         assert(large::count == 0);
     }
     {
         std::any a(large{42});
         assert(large::count == 1);
         try {
-            a.emplace<Type>({1, 2, 3}, 101);
+            auto &v = a.emplace<Type>({1, 2, 3}, 101);
+            static_assert( std::is_same_v<Type&, decltype(v)>, "" );
             assert(false);
         } catch (int const&) {
         }
         assert(large::count == 0);
     }
 }
 
 #endif

test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     Y::dtor_called = false;
     {
         Y y;
         optional<Y> opt(y);
         try
         {
             assert(static_cast<bool>(opt) == true);
             assert(Y::dtor_called == false);
-            opt.emplace(1);
+            auto &v = opt.emplace(1);
+            static_assert( std::is_same_v<Y&, decltype(v)>, "" );
+            assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
             assert(static_cast<bool>(opt) == false);
             assert(Y::dtor_called == true);
         }
     }
 #endif
 }

test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <optional>
 
 // template <class U, class... Args>
-//   void optional<T>::emplace(initializer_list<U> il, Args&&... args);
+//   T& optional<T>::emplace(initializer_list<U> il, Args&&... args);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
 

 bool Z::dtor_called = false;
 
 int main()
 {
     {
         X x;
         optional<X> opt(x);
         assert(X::dtor_called == false);
-        opt.emplace({1, 2});
+        auto &v = opt.emplace({1, 2});
+        static_assert( std::is_same_v<X&, decltype(v)>, "" );
         assert(X::dtor_called == true);
         assert(*opt == X({1, 2}));
+        assert(&v == &*opt);
     }
     {
         optional<std::vector<int>> opt;
-        opt.emplace({1, 2, 3}, std::allocator<int>());
+        auto &v = opt.emplace({1, 2, 3}, std::allocator<int>());
+        static_assert( std::is_same_v<std::vector<int>&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
         assert(*opt == std::vector<int>({1, 2, 3}));
+        assert(&v == &*opt);
     }
     {
         optional<Y> opt;
-        opt.emplace({1, 2});
+        auto &v = opt.emplace({1, 2});
+        static_assert( std::is_same_v<Y&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
         assert(*opt == Y({1, 2}));
+        assert(&v == &*opt);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         Z z;
         optional<Z> opt(z);
         try
         {
             assert(static_cast<bool>(opt) == true);
             assert(Z::dtor_called == false);
-            opt.emplace({1, 2});
+            auto &v = opt.emplace({1, 2});
+            static_assert( std::is_same_v<Z&, decltype(v)>, "" );
+            assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
             assert(static_cast<bool>(opt) == false);
             assert(Z::dtor_called == true);
         }
     }
 #endif
 }