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

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // UNSUPPORTED: c++98, c++03, c++11, c++14
  11
  12 // <any>
  13
  14 // template <class Value> any(Value &&)
  15
  16 // Test construction from a value.
  17 // Concerns:
  18 // ---------
  19 // 1. The value is properly move/copied depending on the value category.
  20 // 2. Both small and large values are properly handled.
  21
  22
  23 #include <any>
  24 #include <cassert>
  25
  26 #include "any_helpers.h"
  27 #include "count_new.hpp"
  28 #include "test_macros.h"
  29
  30 using std::any;
  31 using std::any_cast;
  32
  33 template <class Type>
  34 void test_copy_value_throws()
  35 {
  36 #if !defined(TEST_HAS_NO_EXCEPTIONS)
  37     assert(Type::count == 0);
  38     {
  39         Type const t(42);
  40         assert(Type::count == 1);
  41         try {
  42             any const a2(t);
  43             assert(false);
  44         } catch (my_any_exception const &) {
  45             // do nothing
  46         } catch (...) {
  47             assert(false);
  48         }
  49         assert(Type::count == 1);
  50         assert(t.value == 42);
  51     }
  52     assert(Type::count == 0);
  53 #endif
  54 }
  55
  56 void test_move_value_throws()
  57 {
  58 #if !defined(TEST_HAS_NO_EXCEPTIONS)
  59     assert(throws_on_move::count == 0);
  60     {
  61         throws_on_move v;
  62         assert(throws_on_move::count == 1);
  63         try {
  64             any const a(std::move(v));
  65             assert(false);
  66         } catch (my_any_exception const &) {
  67             // do nothing
  68         } catch (...) {
  69             assert(false);
  70         }
  71         assert(throws_on_move::count == 1);
  72     }
  73     assert(throws_on_move::count == 0);
  74 #endif
  75 }
  76
  77 template <class Type>
  78 void test_copy_move_value() {
  79     // constructing from a small type should perform no allocations.
  80     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
  81     assert(Type::count == 0);
  82     Type::reset();
  83     {
  84         Type t(42);
  85         assert(Type::count == 1);
  86
  87         any a(t);
  88
  89         assert(Type::count == 2);
  90         assert(Type::copied == 1);
  91         assert(Type::moved == 0);
  92         assertContains<Type>(a, 42);
  93     }
  94     assert(Type::count == 0);
  95     Type::reset();
  96     {
  97         Type t(42);
  98         assert(Type::count == 1);
  99
 100         any a(std::move(t));
 101
 102         assert(Type::count == 2);
 103         assert(Type::copied == 0);
 104         assert(Type::moved == 1);
 105         assertContains<Type>(a, 42);
 106     }
 107 }
 108
 109 // Test that any(ValueType&&) is *never* selected for a std::in_place_type_t specialization.
 110 void test_sfinae_constraints() {
 111     using BadTag = std::in_place_type_t<int>;
 112     using OKTag = std::in_place_t;
 113     // Test that the tag type is properly handled in SFINAE
 114     BadTag t = std::in_place_type<int>;
 115     OKTag ot = std::in_place;
 116     {
 117         std::any a(t);
 118         assertContains<int>(a, 0);
 119     }
 120     {
 121         std::any a(std::move(t));
 122         assertContains<int>(a, 0);
 123     }
 124     {
 125         std::any a(ot);
 126         assert(containsType<OKTag>(a));
 127     }
 128     {
 129         struct Dummy { Dummy() = delete; };
 130         using T = std::in_place_type_t<Dummy>;
 131         static_assert(!std::is_constructible<std::any, T>::value, "");
 132     }
 133     {
 134         // Test that the ValueType&& constructor SFINAE's away when the
 135         // argument is non-copyable
 136         struct NoCopy {
 137           NoCopy() = default;
 138           NoCopy(NoCopy const&) = delete;
 139           NoCopy(int) {}
 140         };
 141         static_assert(!std::is_constructible<std::any, NoCopy>::value, "");
 142         static_assert(!std::is_constructible<std::any, NoCopy&>::value, "");
 143         static_assert(!std::is_convertible<NoCopy, std::any>::value, "");
 144     }
 145 }
 146
 147 int main() {
 148     test_copy_move_value<small>();
 149     test_copy_move_value<large>();
 150     test_copy_value_throws<small_throws_on_copy>();
 151     test_copy_value_throws<large_throws_on_copy>();
 152     test_move_value_throws();
 153     test_sfinae_constraints();
 154 }