[libc++] Many any test fixes

[CaseyCarter]

Summary

Changes to non-portable behavior in <any> tests. Inline detailed description of each change is forthcoming. Changes are almost entirely in test code, with one behavioral change to <any> itself to fix self-swap behavior.

[CaseyCarter]

I'll push a revision with the whitespace changes reverted soon.

.gitignore

59

This is an editor byproduct, I suppose, not "MSVC libraries test harness". Let me know if anyone cares and I'll add a comment.

include/any

553

Don't blow up on self swap. This is the obvious (naive) fix; it's possible that someone who has looked at more of the implementation than this single function could devise a better fix.

test/libcxx/utilities/any/any.class/any.assign/value.pass.cpp

26

This behavior is not required by N4606, so I moved this test to the libcxx tree.

test/libcxx/utilities/any/any.class/any.cons/value.pass.cpp

24

Again, not required behavior (I am, of course, totally unbiased about whether this behavior is a good idea.)

test/libcxx/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

35

ibid.

test/std/utilities/any/any.class/any.assign/move.pass.cpp

43

Portability fix: don't rely on a moved-from any being empty. (Occurs more below)

93

Woops - I forgot to review the diff without -w. Will correct this unintended whitespace change.

test/std/utilities/any/any.class/any.assign/value.pass.cpp

69

Again, don't rely on any's moved-from state being empty.

123

Whitespace again (will fix).

172

I split out these non-portable tests into test/libcxx/utilities/any.class/any.assign/value.pass.cpp

test/std/utilities/any/any.class/any.cons/copy.pass.cpp

74

Typo in the original test.

test/std/utilities/any/any.class/any.cons/move.pass.cpp

80

More move behavior.

97

Another inadvertent whitespace change.

test/std/utilities/any/any.class/any.cons/value.pass.cpp

110

Non-portable behavior split into test/libcxx/utilities/any.class/any.cons/value.pass.cpp

143

Inadvertent whitespace change.

182

See above.

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

132

Ensure that LargeThrows is large, regardless of how bloated std::any may become.

234

Inadvertent whitespace change.

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

89

ibid.

92

New test: self-swap must have no effect.

test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

71–76

Possibly controversial: I'm going to propose that template<class T> any_cast(any&&) should require that T is not an lvalue reference type, so that it cannot return potentially dangling references. That means the portion of this test that performs any_cast<T>(any&&) must be conditioned on whether or not T is an lvalue reference type.

146

This code becomes ill-formed with the above proposed change.

198

Remove unused variable ca.

306

Non-standard behavior split out into test/libcxx/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

test/std/utilities/any/any.nonmembers/make_any.pass.cpp

102

Again, ensure that LargeThrows is large independent of the size of any.

[CaseyCarter]

Fix inadvertent whitespace changes.

[EricWF]

@CaseyCarter Thank you for the patch. I fixed most of your issues in r283606 {as well as a bunch of libc++ bugs).

I'm still deciding what to do about the in_place SFINAE tests, but I'll follow up on that shortly. As for this patch please update it if there are any fixes I missed, otherwise please close it.

test/libcxx/utilities/any/any.class/any.assign/value.pass.cpp

26

I thought this behavior was subject to a LWG PR, but I can't seem to find one.

I'll either create a LWG issue to standardize this behavior or remove the tests and fix libc++.

test/libcxx/utilities/any/any.class/any.cons/value.pass.cpp

24

I'm removing these tests all together.

test/libcxx/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

35

I'm removing these tests all together.

test/std/utilities/any/any.class/any.assign/value.pass.cpp

172

Same comment as above in regards to the in_place SFINAE tests.

test/std/utilities/any/any.class/any.cons/copy.pass.cpp

74

Ack. Fixing.

test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

146

I'm removing these tests.

[EricWF]

Addressed the issues about in_place SFINAE constraints in an inline comment.

test/libcxx/utilities/any/any.class/any.assign/value.pass.cpp

26

OK, so the ValueType ctor was constrained by http://cplusplus.github.io/LWG/lwg-active.html#2744 but that didn't touch the assignment operator. I think that's a mistake, and I'll look into adjusting the PR for 2744.

[CaseyCarter]

Ignoring the assignment from in_place_t issue for now, r283606 is good modulo a couple of tiny things that I'll just email you directly.

.gitignore

 # MSVC libraries test harness
 env.lst
 keep.lst
+.vscode/

include/any

 void any::swap(any & __rhs) _NOEXCEPT
 {
     if (__h && __rhs.__h) {
-        any __tmp;
-        __rhs.__call(_Action::_Move, &__tmp);
-        this->__call(_Action::_Move, &__rhs);
-        __tmp.__call(_Action::_Move, this);
+        if (this != &__rhs) {
+            any __tmp;
+            __rhs.__call(_Action::_Move, &__tmp);
+            this->__call(_Action::_Move, &__rhs);
+            __tmp.__call(_Action::_Move, this);
+        }
     }
     else if (__h) {
         this->__call(_Action::_Move, &__rhs);

test/libcxx/utilities/any/any.class/any.assign/value.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
+
+// <any>
+
+// template<class ValueType>
+// any& operator=(ValueType &&);
+
+// Test value copy and move assignment.
+
+#include <any>
+#include <type_traits>
+#include <utility>
+
+int main() {
+// Test that any& operator=(ValueType&&) is *never* selected for:
+// * std::in_place type.
+    {
+        using Tag = std::in_place_type_t<int>;
+        using RawTag = std::remove_reference_t<Tag>;
+        static_assert(!std::is_assignable<std::any, RawTag&&>::value, "");
+    }
+    {
+        struct Dummy { Dummy() = delete; };
+        using T = std::in_place_type_t<Dummy>;
+        static_assert(!std::is_assignable<std::any, T>::value, "");
+    }
+}

test/libcxx/utilities/any/any.class/any.cons/value.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
+
+// <any>
+
+// template <class Value> any(Value &&)
+
+#include <any>
+#include <cassert>
+
+#include "any_helpers.h"
+#include "test_macros.h"
+
+int main() {
+    // test construction from INSANE copy-but-not-movable types.
+    using Type = deleted_move;
+    {
+        deleted_move mv(42);
+        std::any a(mv);
+        assert(Type::count == 2);
+        assert(Type::copied == 1);
+        assert(Type::moved == 0);
+        assertContains<Type>(a, 42);
+    }
+    assert(Type::count == 0);
+    Type::reset();
+    {
+        deleted_move mv(42);
+        std::any a(std::move(mv));
+        assert(Type::count == 2);
+        assert(Type::copied == 1);
+        assert(Type::moved == 0);
+        assertContains<Type>(a, 42);
+    }
+    assert(Type::count == 0);
+    Type::reset();
+}

test/libcxx/utilities/any/any.nonmembers/any.cast/any_cast_reference.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
+
+// <any>
+
+// template <class ValueType>
+// ValueType const any_cast(any const&);
+//
+// template <class ValueType>
+// ValueType any_cast(any &);
+//
+// template <class ValueType>
+// ValueType any_cast(any &&);
+
+#include <any>
+#include <type_traits>
+#include <cassert>
+
+#include "any_helpers.h"
+#include "count_new.hpp"
+#include "test_macros.h"
+
+using std::any;
+using std::any_cast;
+
+// Test that I can retrieve INSANE copy-but-not-movable type from an any
+void test_cast_to_value_deleted_move()
+{
+    using Type = deleted_move;
+    {
+        std::any a(deleted_move(42));
+        assert(Type::count == 1);
+        assert(Type::copied == 1);
+        assert(Type::moved == 0);
+
+        Type const& t = any_cast<Type>(a);
+        assert(Type::count == 2);
+        assert(Type::copied == 2);
+        assert(Type::moved == 0);
+        assertContains<Type>(a, 42);
+    }
+    assert(Type::count == 0);
+    Type::reset();
+    {
+        std::any a(deleted_move(42));
+        std::any const& ca = a;
+        assert(Type::count == 1);
+        assert(Type::copied == 1);
+        assert(Type::moved == 0);
+
+        Type const& t = any_cast<Type>(ca);
+        assert(Type::count == 2);
+        assert(Type::copied == 2);
+        assert(Type::moved == 0);
+        assertContains<Type>(a, 42);
+    }
+    assert(Type::count == 0);
+    Type::reset();
+    {
+        std::any a(deleted_move(42));
+        assert(Type::count == 1);
+        assert(Type::copied == 1);
+        assert(Type::moved == 0);
+
+        Type&& t = any_cast<Type>(std::move(a));
+        assert(Type::count == 2);
+        assert(Type::copied == 2);
+        assert(Type::moved == 0);
+        assertContains<Type>(a, 42);
+    }
+    assert(Type::count == 0);
+    Type::reset();
+    {
+        std::any a(deleted_move(42));
+        std::any const& ca = a;
+        assert(Type::count == 1);
+        assert(Type::copied == 1);
+        assert(Type::moved == 0);
+
+        Type&& t = any_cast<Type>(std::move(ca));
+        assert(Type::count == 2);
+        assert(Type::copied == 2);
+        assert(Type::moved == 0);
+        assertContains<Type>(a, 42);
+    }
+    assert(Type::count == 0);
+    Type::reset();
+}
+
+int main() {
+    test_cast_to_value_deleted_move();
+}

test/std/utilities/any/any.class/any.assign/move.pass.cpp

         a = std::move(a2);
 
         assert(LHS::count == 1);
-        assert(RHS::count == 2);
+        assert(RHS::count == 2 + a2.has_value());
 
         assertContains<RHS>(a, 2);
-        assertEmpty<RHS>(a2);
+        if (a2.has_value())
+            assertContains<RHS>(a2, 0);
     }
     assert(LHS::count == 0);
     assert(RHS::count == 0);

     assert(LHS::count == 0);
     {
         any a;
-        any  a2((LHS(1)));
+        any a2((LHS(1)));
 
         assert(LHS::count == 1);
 
         a = std::move(a2);
 
-        assert(LHS::count == 1);
+        assert(LHS::count == 1 + a2.has_value());
 
         assertContains<LHS>(a, 1);
-        assertEmpty<LHS>(a2);
+        if (a2.has_value())
+            assertContains<LHS>(a2, 0);
     }
     assert(LHS::count == 0);
     {

test/std/utilities/any/any.class/any.assign/value.pass.cpp

 
 // <any>
 
-// any& operator=(any const &);
+// template<class ValueType>
+// any& operator=(ValueType &&);
 
 // Test value copy and move assignment.
 

         assert(RHS::moved >= 1);
         assert(RHS::copied == 0);
         assert(LHS::count == 0);
-        assert(RHS::count == 1);
+        assert(RHS::count == 1 + rhs.has_value());
 
         assertContains<RHS>(lhs, 2);
-        assertEmpty<RHS>(rhs);
+        if (rhs.has_value())
+            assertContains<RHS>(rhs, 0);
     }
     assert(LHS::count == 0);
     assert(RHS::count == 0);

 template <class Tp, bool Move = false>
 void test_assign_throws() {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
-    auto try_throw=
+    auto try_throw =
     [](any& lhs, auto&& rhs) {
         try {
             Move ? lhs = std::move(rhs)

 #endif
 }
 
-
-// Test that any& operator=(ValueType&&) is *never* selected for:
-// * std::in_place type.
-// * Non-copyable types
 void test_sfinae_constraints() {
-    {
-        using Tag = std::in_place_type_t<int>;
-        using RawTag = std::remove_reference_t<Tag>;
-        static_assert(!std::is_assignable<std::any, RawTag&&>::value, "");
-    }
-    {
-        struct Dummy { Dummy() = delete; };
-        using T = std::in_place_type_t<Dummy>;
-        static_assert(!std::is_assignable<std::any, T>::value, "");
-    }
-    {
-        // Test that the ValueType&& constructor SFINAE's away when the
-        // argument is non-copyable
-        struct NoCopy {
-          NoCopy() = default;
-          NoCopy(NoCopy const&) = delete;
-          NoCopy(NoCopy&&) = default;
-        };
-        static_assert(!std::is_assignable<std::any, NoCopy>::value, "");
-    }
+    // Test that the ValueType&& assignment SFINAE's away when the
+    // argument is non-copyable
+    struct NoCopy {
+      NoCopy() = default;
+      NoCopy(NoCopy const&) = delete;
+      NoCopy(NoCopy&&) = default;
+    };
+    static_assert(!std::is_assignable<std::any, NoCopy>::value, "");
 }
 
 int main() {

     test_assign_throws<large_throws_on_copy>();
     test_assign_throws<throws_on_move, /* Move = */ true>();
     test_sfinae_constraints();
-}
+}
 

test/std/utilities/any/any.class/any.cons/copy.pass.cpp

         assert(Type::copied == 1);
         assert(Type::count == 2);
         assertContains<Type>(a, 42);
-        assertContains<Type>(a, 42);
+        assertContains<Type>(a2, 42);
 
         // Modify a and check that a2 is unchanged
         modifyValue<Type>(a, -1);

test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp

     test_in_place_type_tracked<large_tracked_t>();
     test_ctor_sfinae();
     test_constructor_explicit();
-}
+}
 

test/std/utilities/any/any.class/any.cons/move.pass.cpp

 
         any a2(std::move(a));
 
-        assert(Type::moved >= 1); // zero or more move operations can be performed.
+        assert(Type::moved == 1 || Type::moved == 2); // zero or one move operations can be performed.
         assert(Type::copied == 0); // no copies can be performed.
-        assert(Type::count == 1);
-        assertEmpty(a); // Moves are always destructive.
+        assert(Type::count == 1 + a.has_value()); // Moves may be destructive.
         assertContains<Type>(a2, 42);
+        if (a.has_value())
+            assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
 }

test/std/utilities/any/any.class/any.cons/value.pass.cpp

     }
 }
 
-void test_non_moveable_type()
-{
-    using Type = deleted_move;
-    {
-        deleted_move mv(42);
-        std::any a(mv);
-        assert(Type::count == 2);
-        assert(Type::copied == 1);
-        assert(Type::moved == 0);
-        assertContains<Type>(a, 42);
-    }
-    assert(Type::count == 0);
-    Type::reset();
-    {
-        deleted_move mv(42);
-        std::any a(std::move(mv));
-        assert(Type::count == 2);
-        assert(Type::copied == 1);
-        assert(Type::moved == 0);
-        assertContains<Type>(a, 42);
-    }
-    assert(Type::count == 0);
-    Type::reset();
-}
-
-
 
 // Test that any(ValueType&&) is *never* selected for a std::in_place type.
 void test_sfinae_constraints() {

     test_copy_value_throws<small_throws_on_copy>();
     test_copy_value_throws<large_throws_on_copy>();
     test_move_value_throws();
-    test_non_moveable_type();
     test_sfinae_constraints();
-}
+}
 

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

 struct LargeThrows {
   LargeThrows(int) { throw 42; }
   LargeThrows(std::initializer_list<int>, int) { throw 42; }
-  int data[10];
+  int data[sizeof(std::any)];
 };
 static_assert(!IsSmallObject<LargeThrows>::value, "");
 

     test_emplace_throws<SmallThrows>();
     test_emplace_throws<LargeThrows>();
 #endif
-}
+}
 

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

       );
 }
 
+void test_self_swap()
+{
+    {
+        // empty
+        any a;
+        a.swap(a);
+        assertEmpty(a);
+    }
+    {
+        // small
+        any a{small{42}};
+        a.swap(a);
+        assertContains<small>(a, 42);
+    }
+    {
+        // large
+        any a{large{42}};
+        a.swap(a);
+        assertContains<large>(a, 42);
+    }
+}
+
 int main()
 {
     test_noexcept();

     test_swap<large1, large2>();
     test_swap<small, large>();
     test_swap<large, small>();
+    test_self_swap();
 }

test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

     static_assert(std::is_same<decltype(any_cast<int const&&>(ca)), int const&&>::value, "");
 }
 
-template <class Type, class ConstT = Type>
-void checkThrows(any& a)
+template <class Type>
+void checkThrowsRvalue(any&, std::true_type)
+{}
+
+template <class Type>
+void checkThrowsRvalue(any& a, std::false_type)
 {
-#if !defined(TEST_HAS_NO_EXCEPTIONS)
     try {
-        any_cast<Type>(a);
+        any_cast<Type>(static_cast<any&&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
+}
 
+template <class Type, class ConstT = Type>
+void checkThrows(any& a)
+{
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
     try {
-        any_cast<ConstT>(static_cast<any const&>(a));
+        any_cast<Type>(a);
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing

     }
 
     try {
-        any_cast<Type>(static_cast<any&&>(a));
+        any_cast<ConstT>(static_cast<any const&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
+
+    checkThrowsRvalue<Type>(a, std::is_lvalue_reference<Type>{});
 #endif
 }
 

             Type const &cv = any_cast<Type const&>(ca);
             assert(&cv == &v);
         }
-        // Check getting a type by reference from a non-const rvalue
-        {
-            Type& v = any_cast<Type&>(std::move(a));
-            assert(v.value == 42);
-
-            Type const &cv = any_cast<Type const&>(std::move(a));
-            assert(&cv == &v);
-        }
-        // Check getting a type by reference from a const rvalue any.
-        {
-            Type const& v = any_cast<Type const&>(std::move(ca));
-            assert(v.value == 42);
-
-            Type const &cv = any_cast<Type const&>(std::move(ca));
-            assert(&cv == &v);
-        }
-        // Check getting a type by reference from a const rvalue any.
+        // Check getting a type by rvalue reference from a non-const rvalue any.
         {
             Type&& v = any_cast<Type&&>(std::move(a));
             assert(v.value == 42);

             assert(&cv == &v);
             assert(any_cast<Type&>(a).value == 42);
         }
-        // Check getting a type by reference from a const rvalue any.
+        // Check getting a type by rvalue reference from a const rvalue any.
         {
             Type const&& v = any_cast<Type const&&>(std::move(a));
             assert(v.value == 42);

     Type::reset();
     {
         any a((Type(42)));
-        any const& ca = a;
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);

         }
         assert(Type::count == 1);
         Type::reset();
-        // Check getting Type by value from a non-const lvalue any.
+        // Check getting Type by value from a const lvalue any.
         // This should cause the const copy constructor to be called.
         {
             Type t = any_cast<Type>(static_cast<any const&>(a));

         assert(Type::count == 1);
         Type::reset();
         // Check getting Type by value from a non-const rvalue any.
-        // This should cause the non-const copy constructor to be called.
+        // This should cause the move constructor to be called.
         {
             Type t = any_cast<Type>(static_cast<any &&>(a));
 

     assert(Type::count == 0);
 }
 
-void test_cast_to_value_deleted_move()
-{
-    using Type = deleted_move;
-    {
-        std::any a(deleted_move(42));
-        assert(Type::count == 1);
-        assert(Type::copied == 1);
-        assert(Type::moved == 0);
-
-        Type const& t = any_cast<Type>(a);
-        assert(Type::count == 2);
-        assert(Type::copied == 2);
-        assert(Type::moved == 0);
-        assertContains<Type>(a, 42);
-    }
-    assert(Type::count == 0);
-    Type::reset();
-    {
-        std::any a(deleted_move(42));
-        std::any const& ca = a;
-        assert(Type::count == 1);
-        assert(Type::copied == 1);
-        assert(Type::moved == 0);
-
-        Type const& t = any_cast<Type>(ca);
-        assert(Type::count == 2);
-        assert(Type::copied == 2);
-        assert(Type::moved == 0);
-        assertContains<Type>(a, 42);
-    }
-    assert(Type::count == 0);
-    Type::reset();
-    {
-        std::any a(deleted_move(42));
-        assert(Type::count == 1);
-        assert(Type::copied == 1);
-        assert(Type::moved == 0);
-
-        Type&& t = any_cast<Type>(std::move(a));
-        assert(Type::count == 2);
-        assert(Type::copied == 2);
-        assert(Type::moved == 0);
-        assertContains<Type>(a, 42);
-    }
-    assert(Type::count == 0);
-    Type::reset();
-    {
-        std::any a(deleted_move(42));
-        std::any const& ca = a;
-        assert(Type::count == 1);
-        assert(Type::copied == 1);
-        assert(Type::moved == 0);
-
-        Type&& t = any_cast<Type>(std::move(ca));
-        assert(Type::count == 2);
-        assert(Type::copied == 2);
-        assert(Type::moved == 0);
-        assertContains<Type>(a, 42);
-    }
-    assert(Type::count == 0);
-    Type::reset();
-}
-
 // Even though you can't get a non-copyable class into std::any
 // the standard requires that these overloads compile and function.
 void test_non_copyable_ref() {

     test_cast_to_reference<large>();
     test_cast_to_value<small>();
     test_cast_to_value<large>();
-    test_cast_to_value_deleted_move();
     test_non_copyable_ref();
 }

test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp

     any_cast<no_copy>(static_cast<any &&>(a)); // expected-note {{requested here}}
     // expected-error@any:* 3 {{static_assert failed "_ValueType is required to be a reference or a CopyConstructible type."}}
     // expected-error@any:* 2 {{calling a private constructor of class 'no_copy'}}
-}
+}
 

test/std/utilities/any/any.nonmembers/make_any.pass.cpp

 struct LargeThrows {
   LargeThrows(int) { throw 42; }
   LargeThrows(std::initializer_list<int>, int) { throw 42; }
-  int data[10];
+  int data[sizeof(std::any)];
 };
 static_assert(!IsSmallObject<LargeThrows>::value, "");
 

 #ifndef TEST_HAS_NO_EXCEPTIONS
     test_make_any_throws<SmallThrows>();
     test_make_any_throws<LargeThrows>();
-
 #endif
-}
+}