libstdc++-v3/testsuite/20_util/tuple/dr2729.cc

   1 // Copyright (C) 2018-2019 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-do compile { target c++11 } }
  19
  20 #include <tuple>
  21 #include <testsuite_tr1.h>
  22
  23 using std::tuple;
  24 using std::pair;
  25 using __gnu_test::assign::AnyAssign;
  26 using __gnu_test::assign::DelAnyAssign;
  27 using __gnu_test::assign::DelCopyAssign;
  28 using __gnu_test::CopyConsOnlyType;
  29
  30 // Copy assignment:
  31 template<typename T>
  32 constexpr bool copy() { return std::is_copy_assignable<T>::value; }
  33
  34 // Move assigmment:
  35 template<typename T>
  36 constexpr bool move() { return std::is_move_assignable<T>::value; }
  37
  38 static_assert( copy<tuple<>>(), "");
  39 static_assert( move<tuple<>>(), "");
  40
  41 static_assert( copy<tuple<int>>(), "");
  42 static_assert( copy<tuple<AnyAssign>>(), "");
  43 static_assert( copy<tuple<int, int>>(), "");
  44 static_assert( copy<tuple<AnyAssign, AnyAssign>>(), "");
  45 static_assert( copy<tuple<int, AnyAssign>>(), "");
  46 static_assert( copy<tuple<AnyAssign, int>>(), "");
  47 static_assert( copy<tuple<int, int, int>>(), "");
  48 static_assert( copy<tuple<AnyAssign, AnyAssign, AnyAssign>>(), "");
  49 static_assert( copy<tuple<int, AnyAssign, AnyAssign>>(), "");
  50 static_assert( copy<tuple<AnyAssign, int, AnyAssign>>(), "");
  51 static_assert( copy<tuple<AnyAssign, AnyAssign, int>>(), "");
  52
  53 static_assert( move<tuple<int>>(), "");
  54 static_assert( move<tuple<AnyAssign>>(), "");
  55 static_assert( move<tuple<int, int>>(), "");
  56 static_assert( move<tuple<AnyAssign, AnyAssign>>(), "");
  57 static_assert( move<tuple<int, AnyAssign>>(), "");
  58 static_assert( move<tuple<AnyAssign, int>>(), "");
  59 static_assert( move<tuple<int, int, int>>(), "");
  60 static_assert( move<tuple<AnyAssign, AnyAssign, AnyAssign>>(), "");
  61 static_assert( move<tuple<int, AnyAssign, AnyAssign>>(), "");
  62 static_assert( move<tuple<AnyAssign, int, AnyAssign>>(), "");
  63 static_assert( move<tuple<AnyAssign, AnyAssign, int>>(), "");
  64
  65 static_assert( ! copy<tuple<DelCopyAssign>>(), "");
  66 static_assert( ! copy<tuple<DelCopyAssign, int>>(), "");
  67 static_assert( ! copy<tuple<int, DelCopyAssign>>(), "");
  68 static_assert( ! copy<tuple<DelCopyAssign, int, int>>(), "");
  69 static_assert( ! copy<tuple<int, DelCopyAssign, int>>(), "");
  70 static_assert( ! copy<tuple<int, int, DelCopyAssign>>(), "");
  71
  72 static_assert( move<tuple<DelCopyAssign>>(), "");
  73 static_assert( move<tuple<DelCopyAssign, int>>(), "");
  74 static_assert( move<tuple<int, DelCopyAssign>>(), "");
  75 static_assert( move<tuple<DelCopyAssign, int, int>>(), "");
  76 static_assert( move<tuple<int, DelCopyAssign, int>>(), "");
  77 static_assert( move<tuple<int, int, DelCopyAssign>>(), "");
  78
  79 static_assert( ! move<tuple<CopyConsOnlyType>>(), "");
  80 static_assert( ! move<tuple<CopyConsOnlyType, int>>(), "");
  81 static_assert( ! move<tuple<int, CopyConsOnlyType>>(), "");
  82 static_assert( ! move<tuple<CopyConsOnlyType, int, int>>(), "");
  83 static_assert( ! move<tuple<int, CopyConsOnlyType, int>>(), "");
  84 static_assert( ! move<tuple<int, int, CopyConsOnlyType>>(), "");
  85
  86 // Assignment from different types of tuple (and pair):
  87 template<typename To, typename From>
  88 constexpr bool assign() { return std::is_assignable<To&, From>::value; }
  89
  90 // 0-tuples
  91 static_assert( ! assign<tuple<>, tuple<int>>(), "" );
  92 static_assert( ! assign<tuple<>, const tuple<int>&>(), "" );
  93
  94 // 1-tuples
  95 static_assert( ! assign<tuple<int>, tuple<>>(), "" );
  96 static_assert( ! assign<tuple<int>, const tuple<>&>(), "" );
  97 static_assert( ! assign<tuple<AnyAssign>, tuple<>>(), "" );
  98 static_assert( ! assign<tuple<AnyAssign>, tuple<int, int>>(), "" );
  99 static_assert( ! assign<tuple<AnyAssign>, pair<int, int>>(), "" );
 100
 101 static_assert( ! assign<tuple<void*>, tuple<int>>(), "" );
 102 static_assert( ! assign<tuple<void*>, const tuple<int>&>(), "" );
 103
 104 static_assert( assign<tuple<long>, tuple<int>>(), "" );
 105 static_assert( assign<tuple<long>, tuple<int>&>(), "" );
 106 static_assert( assign<tuple<long>, const tuple<int>>(), "" );
 107 static_assert( assign<tuple<long>, const tuple<int>&>(), "" );
 108
 109 // 2-tuples
 110 static_assert( assign<tuple<long, long>, tuple<int, int>>(), "" );
 111 static_assert( assign<tuple<long, long>, tuple<int, int>&>(), "" );
 112 static_assert( assign<tuple<long, long>, const tuple<int, int>>(), "" );
 113 static_assert( assign<tuple<long, long>, const tuple<int, int>&>(), "" );
 114
 115 static_assert( assign<tuple<long, long>, pair<int, int>>(), "" );
 116 static_assert( assign<tuple<long, long>, const pair<int, int>&>(), "" );
 117 static_assert( assign<tuple<long, long>, pair<int, int>>(), "" );
 118 static_assert( assign<tuple<long, long>, const pair<int, int>&&>(), "" );
 119
 120 static_assert( assign<tuple<DelCopyAssign, AnyAssign>,
 121                       tuple<DelCopyAssign, int>>(), "" );
 122 static_assert( ! assign<tuple<DelCopyAssign, AnyAssign>,
 123                         tuple<DelCopyAssign, int>&>(), "" );
 124 static_assert( ! assign<tuple<DelCopyAssign, AnyAssign>,
 125                         const tuple<DelCopyAssign, int>&>(), "" );
 126 static_assert( ! assign<tuple<DelCopyAssign, AnyAssign>,
 127                         const tuple<DelCopyAssign, int>&&>(), "" );
 128
 129 static_assert( assign<tuple<AnyAssign, DelCopyAssign>,
 130                       tuple<int, DelCopyAssign>>(), "" );
 131 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign>,
 132                         tuple<int, DelCopyAssign>&>(), "" );
 133 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign>,
 134                         const tuple<int, DelCopyAssign>&>(), "" );
 135 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign>,
 136                         const tuple<int, DelCopyAssign>&&>(), "" );
 137
 138 static_assert( ! assign<tuple<void*, int>,
 139                         tuple<int, int>>(), "" );
 140 static_assert( ! assign<tuple<void*, int>,
 141                         const tuple<int, int>&>(), "" );
 142
 143 static_assert( assign<tuple<DelCopyAssign, AnyAssign>,
 144                       pair<DelCopyAssign, int>>(), "" );
 145 static_assert( ! assign<tuple<DelCopyAssign, AnyAssign>,
 146                         pair<DelCopyAssign, int>&>(), "" );
 147 static_assert( ! assign<tuple<DelCopyAssign, AnyAssign>,
 148                         const pair<DelCopyAssign, int>&>(), "" );
 149 static_assert( ! assign<tuple<DelCopyAssign, AnyAssign>,
 150                         const pair<DelCopyAssign, int>&&>(), "" );
 151
 152 static_assert( assign<tuple<AnyAssign, DelCopyAssign>,
 153                       pair<int, DelCopyAssign>>(), "" );
 154 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign>,
 155                         pair<int, DelCopyAssign>&>(), "" );
 156 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign>,
 157                         const pair<int, DelCopyAssign>&>(), "" );
 158 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign>,
 159                         const pair<int, DelCopyAssign>&&>(), "" );
 160
 161 static_assert( ! assign<tuple<void*, int>,
 162                         pair<int, int>>(), "" );
 163 static_assert( ! assign<tuple<void*, int>,
 164                         const pair<int, int>&>(), "" );
 165
 166 // 3-tuples
 167 static_assert( assign<tuple<AnyAssign, DelCopyAssign, AnyAssign>,
 168                       tuple<int, DelCopyAssign, int>>(), "" );
 169 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign, AnyAssign>,
 170                         tuple<int, DelCopyAssign, int>&>(), "" );
 171 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign, AnyAssign>,
 172                         const tuple<int, DelCopyAssign, int>&>(), "" );
 173 static_assert( ! assign<tuple<AnyAssign, DelCopyAssign, AnyAssign>,
 174                         const tuple<int, DelCopyAssign, int>&&>(), "" );
 175
 176 static_assert( ! assign<tuple<int, void*, int>,
 177                         tuple<int, int, int>>(), "" );
 178 static_assert( ! assign<tuple<int, void*, int>,
 179                         const tuple<int, int, int>&>(), "" );