libstdc++-v3/testsuite/20_util/is_assignable/value.cc

   1 // { dg-do compile { target c++11 } }
   2
   3 // Copyright (C) 2011-2019 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING3.  If not see
  18 // <http://www.gnu.org/licenses/>.
  19
  20 #include <type_traits>
  21 #include <initializer_list>
  22 #include <testsuite_tr1.h>
  23
  24 using namespace __gnu_test::assign;
  25
  26 static_assert(std::is_assignable<int&, int>::value, "Error");
  27 static_assert(std::is_assignable<int&, const int>::value, "Error");
  28 static_assert(std::is_assignable<int&, int&>::value, "Error");
  29 static_assert(std::is_assignable<int&, const int&>::value, "Error");
  30
  31 static_assert(!std::is_assignable<int, int>::value, "Error");
  32 static_assert(!std::is_assignable<int, const int>::value, "Error");
  33 static_assert(!std::is_assignable<int, int&>::value, "Error");
  34 static_assert(!std::is_assignable<int, const int&>::value, "Error");
  35
  36 static_assert(!std::is_assignable<const int, int>::value, "Error");
  37 static_assert(!std::is_assignable<const int, const int>::value, "Error");
  38 static_assert(!std::is_assignable<const int, int&>::value, "Error");
  39 static_assert(!std::is_assignable<const int, const int&>::value, "Error");
  40
  41 static_assert(!std::is_assignable<const int&, int>::value, "Error");
  42 static_assert(!std::is_assignable<const int&, const int>::value, "Error");
  43 static_assert(!std::is_assignable<const int&, int&>::value, "Error");
  44 static_assert(!std::is_assignable<const int&, const int&>::value, "Error");
  45
  46 static_assert(std::is_assignable<Empty&, Empty>::value, "Error");
  47 static_assert(std::is_assignable<Empty&, const Empty>::value, "Error");
  48 static_assert(std::is_assignable<Empty&, Empty&>::value, "Error");
  49 static_assert(std::is_assignable<Empty&, const Empty&>::value, "Error");
  50 static_assert(std::is_assignable<Empty, Empty>::value, "Error");
  51 static_assert(std::is_assignable<Empty, const Empty>::value, "Error");
  52 static_assert(std::is_assignable<Empty, Empty&>::value, "Error");
  53 static_assert(std::is_assignable<Empty, const Empty&>::value, "Error");
  54
  55 static_assert(std::is_assignable<B&, B>::value, "Error");
  56 static_assert(std::is_assignable<B&, const B>::value, "Error");
  57 static_assert(std::is_assignable<B&, B&>::value, "Error");
  58 static_assert(std::is_assignable<B&, const B&>::value, "Error");
  59 static_assert(std::is_assignable<B, B>::value, "Error");
  60 static_assert(std::is_assignable<B, const B>::value, "Error");
  61 static_assert(std::is_assignable<B, B&>::value, "Error");
  62 static_assert(std::is_assignable<B, const B&>::value, "Error");
  63
  64 static_assert(std::is_assignable<bool&, bool>::value, "Error");
  65 static_assert(std::is_assignable<bool&, const bool>::value, "Error");
  66 static_assert(std::is_assignable<bool&, bool&>::value, "Error");
  67 static_assert(std::is_assignable<bool&, const bool&>::value, "Error");
  68
  69 // bool is a fundamental type that does not allow assignment to an rvalue:
  70 static_assert(!std::is_assignable<bool, bool>::value, "Error");
  71 static_assert(!std::is_assignable<bool, const bool>::value, "Error");
  72 static_assert(!std::is_assignable<bool, bool&>::value, "Error");
  73 static_assert(!std::is_assignable<bool, const bool&>::value, "Error");
  74
  75 static_assert(std::is_assignable<std::nullptr_t&,
  76 std::nullptr_t>::value, "Error");
  77 static_assert(std::is_assignable<std::nullptr_t&, const
  78 std::nullptr_t>::value, "Error");
  79 static_assert(std::is_assignable<std::nullptr_t&,
  80 std::nullptr_t&>::value, "Error");
  81 static_assert(std::is_assignable<std::nullptr_t&, const
  82 std::nullptr_t&>::value, "Error");
  83
  84 // std::nullptr_t is a fundamental type that does not allow
  85 // assignment to an rvalue:
  86 static_assert(!std::is_assignable<std::nullptr_t,
  87 std::nullptr_t>::value, "Error");
  88 static_assert(!std::is_assignable<std::nullptr_t, const
  89 std::nullptr_t>::value, "Error");
  90 static_assert(!std::is_assignable<std::nullptr_t,
  91 std::nullptr_t&>::value, "Error");
  92 static_assert(!std::is_assignable<std::nullptr_t, const
  93 std::nullptr_t&>::value, "Error");
  94
  95 static_assert(std::is_assignable<E&, E>::value, "Error");
  96 static_assert(std::is_assignable<E&, const E>::value, "Error");
  97 static_assert(std::is_assignable<E&, E&>::value, "Error");
  98 static_assert(std::is_assignable<E&, const E&>::value, "Error");
  99
 100 static_assert(std::is_assignable<int&, E>::value, "Error");
 101 static_assert(std::is_assignable<int&, const E>::value, "Error");
 102 static_assert(std::is_assignable<int&, E&>::value, "Error");
 103 static_assert(std::is_assignable<int&, const E&>::value, "Error");
 104
 105 static_assert(!std::is_assignable<E&, int>::value, "Error");
 106 static_assert(!std::is_assignable<E&, const int>::value, "Error");
 107 static_assert(!std::is_assignable<E&, int&>::value, "Error");
 108 static_assert(!std::is_assignable<E&, const int&>::value, "Error");
 109
 110 static_assert(!std::is_assignable<E&, E2>::value, "Error");
 111 static_assert(!std::is_assignable<E&, const E2>::value, "Error");
 112 static_assert(!std::is_assignable<E&, E2&>::value, "Error");
 113 static_assert(!std::is_assignable<E&, const E2&>::value, "Error");
 114
 115 // E is not a class type and thus does not allow assignment to an rvalue:
 116 static_assert(!std::is_assignable<E, E>::value, "Error");
 117 static_assert(!std::is_assignable<E, const E>::value, "Error");
 118 static_assert(!std::is_assignable<E, E&>::value, "Error");
 119 static_assert(!std::is_assignable<E, const E&>::value, "Error");
 120
 121 static_assert(std::is_assignable<SE&, SE>::value, "Error");
 122 static_assert(std::is_assignable<SE&, const SE>::value, "Error");
 123 static_assert(std::is_assignable<SE&, SE&>::value, "Error");
 124 static_assert(std::is_assignable<SE&, const SE&>::value, "Error");
 125
 126 static_assert(!std::is_assignable<int&, SE>::value, "Error");
 127 static_assert(!std::is_assignable<int&, const SE>::value, "Error");
 128 static_assert(!std::is_assignable<int&, SE&>::value, "Error");
 129 static_assert(!std::is_assignable<int&, const SE&>::value, "Error");
 130
 131 static_assert(!std::is_assignable<SE&, int>::value, "Error");
 132 static_assert(!std::is_assignable<SE&, const int>::value, "Error");
 133 static_assert(!std::is_assignable<SE&, int&>::value, "Error");
 134 static_assert(!std::is_assignable<SE&, const int&>::value, "Error");
 135
 136 // SE is not a class type and thus does not allow assignment to an rvalue:
 137 static_assert(!std::is_assignable<SE, SE>::value, "Error");
 138 static_assert(!std::is_assignable<SE, const SE>::value, "Error");
 139 static_assert(!std::is_assignable<SE, SE&>::value, "Error");
 140 static_assert(!std::is_assignable<SE, const SE&>::value, "Error");
 141
 142 static_assert(std::is_assignable<AnyAssign&, int>::value, "Error");
 143 static_assert(std::is_assignable<AnyAssign&, std::nullptr_t>::value, "Error");
 144 static_assert(std::is_assignable<AnyAssign&, E>::value, "Error");
 145 static_assert(std::is_assignable<AnyAssign&, SE>::value, "Error");
 146 static_assert(std::is_assignable<AnyAssign&, Empty>::value, "Error");
 147 static_assert(std::is_assignable<AnyAssign&, U>::value, "Error");
 148 static_assert(std::is_assignable<AnyAssign&, int&>::value, "Error");
 149 static_assert(std::is_assignable<AnyAssign&, std::nullptr_t&>::value, "Error");
 150 static_assert(std::is_assignable<AnyAssign&, E&>::value, "Error");
 151 static_assert(std::is_assignable<AnyAssign&, SE&>::value, "Error");
 152 static_assert(std::is_assignable<AnyAssign&, Empty&>::value, "Error");
 153 static_assert(std::is_assignable<AnyAssign&, U&>::value, "Error");
 154 static_assert(std::is_assignable<AnyAssign&, AnyAssign>::value, "Error");
 155 static_assert(std::is_assignable<AnyAssign&,
 156 std::initializer_list<int>>::value, "Error");
 157
 158 static_assert(std::is_assignable<AnyAssign&, int[1]>::value, "Error");
 159 static_assert(std::is_assignable<AnyAssign&,
 160 std::nullptr_t[1]>::value, "Error");
 161 static_assert(std::is_assignable<AnyAssign&, E[1]>::value, "Error");
 162 static_assert(std::is_assignable<AnyAssign&, SE[1]>::value, "Error");
 163 static_assert(std::is_assignable<AnyAssign&, int(&)[1]>::value, "Error");
 164 static_assert(std::is_assignable<AnyAssign&,
 165 std::nullptr_t(&)[1]>::value, "Error");
 166 static_assert(std::is_assignable<AnyAssign&, E(&)[1]>::value, "Error");
 167 static_assert(std::is_assignable<AnyAssign&, SE(&)[1]>::value, "Error");
 168
 169 static_assert(std::is_assignable<int&, E>::value, "Error");
 170 static_assert(!std::is_assignable<int&, SE>::value, "Error");
 171 static_assert(std::is_assignable<bool&, E>::value, "Error");
 172 static_assert(!std::is_assignable<bool&, SE>::value, "Error");
 173 static_assert(std::is_assignable<bool&, void*>::value, "Error");
 174 static_assert(std::is_assignable<bool&, int B::*>::value, "Error");
 175 static_assert(std::is_assignable<bool&, void*>::value, "Error");
 176 static_assert(!std::is_assignable<bool&, std::nullptr_t>::value, "Error");
 177
 178 static_assert(std::is_assignable<std::nullptr_t&,
 179 std::nullptr_t>::value, "Error");
 180 static_assert(std::is_assignable<void*&, std::nullptr_t>::value, "Error");
 181 static_assert(std::is_assignable<int*&, std::nullptr_t>::value, "Error");
 182 static_assert(std::is_assignable<int B::*&, std::nullptr_t>::value, "Error");
 183 static_assert(!std::is_assignable<std::nullptr_t&, bool>::value, "Error");
 184 static_assert(!std::is_assignable<void*&, bool>::value, "Error");
 185 static_assert(!std::is_assignable<E&, bool>::value, "Error");
 186 static_assert(!std::is_assignable<SE&, bool>::value, "Error");
 187
 188 static_assert(std::is_assignable<std::initializer_list<int>&,
 189 std::initializer_list<int>>::value, "Error");
 190 static_assert(std::is_assignable<std::initializer_list<int>&,
 191 std::initializer_list<int>&&>::value, "Error");
 192 static_assert(std::is_assignable<std::initializer_list<int>&, const
 193 std::initializer_list<int>&&>::value, "Error");
 194 static_assert(std::is_assignable<std::initializer_list<int>&,
 195 std::initializer_list<int>&>::value, "Error");
 196 static_assert(std::is_assignable<std::initializer_list<int>&, const
 197 std::initializer_list<int>&>::value, "Error");
 198 static_assert(!std::is_assignable<const std::initializer_list<int>&,
 199 std::initializer_list<int>>::value, "Error");
 200
 201 static_assert(!std::is_assignable<const AnyAssign&, int>::value, "Error");
 202 static_assert(!std::is_assignable<AnyAssign&, void>::value, "Error");
 203
 204 static_assert(!std::is_assignable<void, int>::value, "Error");
 205 static_assert(!std::is_assignable<const void, int>::value, "Error");
 206 static_assert(!std::is_assignable<int, void>::value, "Error");
 207 static_assert(!std::is_assignable<int, const void>::value, "Error");
 208 static_assert(!std::is_assignable<const int, void>::value, "Error");
 209 static_assert(!std::is_assignable<const int, const void>::value, "Error");
 210 static_assert(!std::is_assignable<int&, void>::value, "Error");
 211 static_assert(!std::is_assignable<int&, const void>::value, "Error");
 212 static_assert(!std::is_assignable<const int&, void>::value, "Error");
 213 static_assert(!std::is_assignable<const int&, const void>::value, "Error");
 214 static_assert(!std::is_assignable<void, void>::value, "Error");
 215 static_assert(!std::is_assignable<const void, void>::value, "Error");
 216 static_assert(!std::is_assignable<const void, const void>::value, "Error");
 217
 218 static_assert(!std::is_assignable<int[1], int[1]>::value, "Error");
 219 static_assert(!std::is_assignable<int(&)[1], int[1]>::value, "Error");
 220 static_assert(!std::is_assignable<int(&)[1], int(&)[1]>::value, "Error");
 221 static_assert(!std::is_assignable<int[2], int[1]>::value, "Error");
 222 static_assert(!std::is_assignable<int(&)[2], int[1]>::value, "Error");
 223 static_assert(!std::is_assignable<int(&)[2], int(&)[1]>::value, "Error");
 224 static_assert(!std::is_assignable<int[1], void>::value, "Error");
 225 static_assert(!std::is_assignable<int(&)[1], void>::value, "Error");
 226 static_assert(!std::is_assignable<void, int[1]>::value, "Error");
 227 static_assert(!std::is_assignable<void, int(&)[1]>::value, "Error");
 228
 229 static_assert(!std::is_assignable<int[], int[]>::value, "Error");
 230 static_assert(!std::is_assignable<int(&)[], int[]>::value, "Error");
 231 static_assert(!std::is_assignable<int(&)[], int(&)[]>::value, "Error");
 232 static_assert(!std::is_assignable<int[1], int[]>::value, "Error");
 233 static_assert(!std::is_assignable<int(&)[1], int[]>::value, "Error");
 234 static_assert(!std::is_assignable<int(&)[1], int(&)[]>::value, "Error");
 235 static_assert(!std::is_assignable<int[], int[1]>::value, "Error");
 236 static_assert(!std::is_assignable<int(&)[], int[1]>::value, "Error");
 237 static_assert(!std::is_assignable<int(&)[], int(&)[1]>::value, "Error");
 238 static_assert(!std::is_assignable<int[], void>::value, "Error");
 239 static_assert(!std::is_assignable<int(&)[], void>::value, "Error");
 240 static_assert(!std::is_assignable<void, int[]>::value, "Error");
 241 static_assert(!std::is_assignable<void, int(&)[]>::value, "Error");
 242
 243 static_assert(std::is_assignable<DelCopyAssign&,
 244 DelCopyAssign>::value, "Error");
 245 static_assert(!std::is_assignable<DelCopyAssign&, const
 246 DelCopyAssign>::value, "Error");
 247 static_assert(!std::is_assignable<DelCopyAssign&,
 248 DelCopyAssign&>::value, "Error");
 249 static_assert(!std::is_assignable<DelCopyAssign&, const
 250 DelCopyAssign&>::value, "Error");
 251 static_assert(!std::is_assignable<DelCopyAssign&, void>::value, "Error");
 252 static_assert(!std::is_assignable<DelCopyAssign&, void()>::value, "Error");
 253 static_assert(!std::is_assignable<DelCopyAssign&, void(&)()>::value, "Error");
 254 static_assert(!std::is_assignable<DelCopyAssign&, int>::value, "Error");
 255
 256 static_assert(std::is_assignable<DelAnyAssign&,
 257 DelAnyAssign&&>::value, "Error");
 258 static_assert(std::is_assignable<DelAnyAssign&, const
 259 DelAnyAssign&>::value, "Error");
 260 static_assert(std::is_assignable<DelAnyAssign,
 261 DelAnyAssign&&>::value, "Error");
 262 static_assert(std::is_assignable<DelAnyAssign, const
 263 DelAnyAssign&>::value, "Error");
 264
 265 static_assert(!std::is_assignable<const DelAnyAssign&,
 266 DelAnyAssign&&>::value, "Error");
 267 static_assert(!std::is_assignable<const DelAnyAssign&, const
 268 DelAnyAssign&>::value, "Error");
 269 static_assert(!std::is_assignable<const DelAnyAssign,
 270 DelAnyAssign&&>::value, "Error");
 271 static_assert(!std::is_assignable<const DelAnyAssign, const
 272 DelAnyAssign&>::value, "Error");
 273
 274 static_assert(!std::is_assignable<DelAnyAssign&, int>::value, "Error");
 275 static_assert(!std::is_assignable<DelAnyAssign&, int&>::value, "Error");
 276 static_assert(!std::is_assignable<DelAnyAssign&, const int&>::value, "Error");
 277 static_assert(!std::is_assignable<DelAnyAssign&, void>::value, "Error");
 278 static_assert(!std::is_assignable<DelAnyAssign&, void()>::value, "Error");
 279 static_assert(!std::is_assignable<DelAnyAssign&,
 280   void() const>::value, "Error");
 281 static_assert(!std::is_assignable<DelAnyAssign&, void(&)()>::value, "Error");
 282 static_assert(!std::is_assignable<DelAnyAssign&, void(&&)()>::value, "Error");
 283 static_assert(!std::is_assignable<DelAnyAssign&,
 284 std::nullptr_t>::value, "Error");
 285 static_assert(!std::is_assignable<DelAnyAssign&,
 286 std::nullptr_t&>::value, "Error");
 287 static_assert(!std::is_assignable<DelAnyAssign&,
 288 std::initializer_list<int>>::value, "Error");
 289 static_assert(!std::is_assignable<DelAnyAssign&,
 290 std::initializer_list<int>&>::value, "Error");
 291 static_assert(!std::is_assignable<DelAnyAssign&, bool>::value, "Error");
 292 static_assert(!std::is_assignable<DelAnyAssign&, bool&>::value, "Error");
 293 static_assert(!std::is_assignable<DelAnyAssign&, E>::value, "Error");
 294 static_assert(!std::is_assignable<DelAnyAssign&, E&>::value, "Error");
 295 static_assert(!std::is_assignable<DelAnyAssign&, SE>::value, "Error");
 296 static_assert(!std::is_assignable<DelAnyAssign&, SE&>::value, "Error");
 297 static_assert(!std::is_assignable<DelAnyAssign&, Empty>::value, "Error");
 298 static_assert(!std::is_assignable<DelAnyAssign&, Empty&>::value, "Error");
 299 static_assert(!std::is_assignable<DelAnyAssign&, B>::value, "Error");
 300 static_assert(!std::is_assignable<DelAnyAssign&, B&>::value, "Error");
 301 static_assert(!std::is_assignable<DelAnyAssign&, U>::value, "Error");
 302 static_assert(!std::is_assignable<DelAnyAssign&, U&>::value, "Error");
 303 static_assert(!std::is_assignable<DelAnyAssign&, void*>::value, "Error");
 304 static_assert(!std::is_assignable<DelAnyAssign&, int*>::value, "Error");
 305 static_assert(!std::is_assignable<DelAnyAssign&, B*>::value, "Error");
 306 static_assert(!std::is_assignable<DelAnyAssign&, D*>::value, "Error");
 307 static_assert(!std::is_assignable<DelAnyAssign&, int B::*>::value, "Error");
 308 static_assert(!std::is_assignable<DelAnyAssign&, int D::*>::value, "Error");
 309 static_assert(!std::is_assignable<DelAnyAssign&, int[]>::value, "Error");
 310 static_assert(!std::is_assignable<DelAnyAssign&, int[1]>::value, "Error");
 311 static_assert(!std::is_assignable<DelAnyAssign&, int(&)[]>::value, "Error");
 312 static_assert(!std::is_assignable<DelAnyAssign&, int(&)[1]>::value, "Error");
 313
 314 static_assert(!std::is_assignable<void(), void>::value, "Error");
 315 static_assert(!std::is_assignable<void, void()>::value, "Error");
 316 static_assert(!std::is_assignable<void(), void()>::value, "Error");
 317
 318 static_assert(!std::is_assignable<void(&)(), void>::value, "Error");
 319 static_assert(!std::is_assignable<void, void(&)()>::value, "Error");
 320 static_assert(!std::is_assignable<void(&)(), void(&)()>::value, "Error");
 321 static_assert(!std::is_assignable<void(&)(), void()>::value, "Error");
 322 static_assert(!std::is_assignable<void(), void(&)()>::value, "Error");
 323
 324 static_assert(std::is_assignable<int&, ImplicitTo<int>>::value, "Error");
 325 static_assert(!std::is_assignable<int&, ExplicitTo<int>>::value, "Error");
 326 static_assert(!std::is_assignable<int, ImplicitTo<int>>::value, "Error");
 327 static_assert(!std::is_assignable<int, ExplicitTo<int>>::value, "Error");
 328 static_assert(!std::is_assignable<const int, ImplicitTo<int>>::value, "Error");
 329 static_assert(!std::is_assignable<const int, ExplicitTo<int>>::value, "Error");
 330 static_assert(!std::is_assignable<const int&,
 331 ImplicitTo<int>>::value, "Error");
 332 static_assert(!std::is_assignable<const int&,
 333 ExplicitTo<int>>::value, "Error");
 334
 335 static_assert(std::is_assignable<DelImplicitTo<int>&,
 336 DelImplicitTo<int>>::value, "Error");
 337 static_assert(std::is_assignable<DelImplicitTo<int>,
 338 DelImplicitTo<int>>::value, "Error");
 339 static_assert(!std::is_assignable<int&, DelImplicitTo<int>>::value, "Error");
 340 static_assert(!std::is_assignable<int, DelImplicitTo<int>>::value, "Error");
 341 static_assert(!std::is_assignable<const int&,
 342 DelImplicitTo<int>>::value, "Error");
 343 static_assert(!std::is_assignable<const int,
 344 DelImplicitTo<int>>::value, "Error");
 345 static_assert(!std::is_assignable<int&, DelExplicitTo<int>>::value, "Error");
 346 static_assert(!std::is_assignable<int, DelExplicitTo<int>>::value, "Error");
 347 static_assert(!std::is_assignable<const int&,
 348 DelExplicitTo<int>>::value, "Error");
 349 static_assert(!std::is_assignable<const int,
 350 DelExplicitTo<int>>::value, "Error");
 351
 352 static_assert(std::is_assignable<B&, B>::value, "Error");
 353 static_assert(std::is_assignable<B&, D>::value, "Error");
 354 static_assert(std::is_assignable<B&, B&>::value, "Error");
 355 static_assert(std::is_assignable<B&, D&>::value, "Error");
 356 static_assert(!std::is_assignable<const B&, B&>::value, "Error");
 357 static_assert(!std::is_assignable<const B&, D&>::value, "Error");
 358 static_assert(!std::is_assignable<D&, B>::value, "Error");
 359 static_assert(!std::is_assignable<D&, B&>::value, "Error");
 360
 361 static_assert(std::is_assignable<B*&, B*>::value, "Error");
 362 static_assert(std::is_assignable<B*&, D*>::value, "Error");
 363 static_assert(std::is_assignable<const B*&, D*>::value, "Error");
 364 static_assert(std::is_assignable<const B*&, const D*>::value, "Error");
 365 static_assert(std::is_assignable<B*&, B*&>::value, "Error");
 366 static_assert(std::is_assignable<B*&, D*&>::value, "Error");
 367 static_assert(std::is_assignable<const B*&, B*&>::value, "Error");
 368 static_assert(std::is_assignable<const B*&, D*&>::value, "Error");
 369 static_assert(!std::is_assignable<B* const&, B*&>::value, "Error");
 370 static_assert(!std::is_assignable<B* const&, D*&>::value, "Error");
 371 static_assert(!std::is_assignable<D*&, B*>::value, "Error");
 372 static_assert(!std::is_assignable<D*&, B*&>::value, "Error");
 373
 374 static_assert(std::is_assignable<MO&, MO>::value, "Error");
 375 static_assert(std::is_assignable<MO&, MO&&>::value, "Error");
 376 static_assert(std::is_assignable<MO, MO>::value, "Error");
 377 static_assert(std::is_assignable<MO, MO&&>::value, "Error");
 378
 379 static_assert(!std::is_assignable<const MO&, MO>::value, "Error");
 380 static_assert(!std::is_assignable<const MO&, MO&&>::value, "Error");
 381 static_assert(!std::is_assignable<MO&, const MO&&>::value, "Error");
 382 static_assert(!std::is_assignable<MO&, MO&>::value, "Error");
 383 static_assert(!std::is_assignable<MO&, const MO&>::value, "Error");
 384 static_assert(!std::is_assignable<const MO, MO>::value, "Error");
 385 static_assert(!std::is_assignable<const MO, MO&&>::value, "Error");
 386 static_assert(!std::is_assignable<MO, const MO&&>::value, "Error");
 387 static_assert(!std::is_assignable<MO, MO&>::value, "Error");
 388 static_assert(!std::is_assignable<MO, const MO&>::value, "Error");
 389
 390 static_assert(!std::is_assignable<NontrivialUnion&,
 391 NontrivialUnion>::value, "Error");
 392 static_assert(!std::is_assignable<NontrivialUnion&,
 393 NontrivialUnion&&>::value, "Error");
 394 static_assert(!std::is_assignable<NontrivialUnion&,
 395 NontrivialUnion&>::value, "Error");
 396 static_assert(!std::is_assignable<NontrivialUnion&, const
 397 NontrivialUnion&>::value, "Error");
 398 static_assert(!std::is_assignable<NontrivialUnion&, const
 399 NontrivialUnion&&>::value, "Error");
 400
 401 static_assert(std::is_assignable<Abstract&, Abstract>::value, "Error");
 402 static_assert(std::is_assignable<Abstract&, Abstract&&>::value, "Error");
 403 static_assert(std::is_assignable<Abstract&, Abstract&>::value, "Error");
 404 static_assert(std::is_assignable<Abstract&, const Abstract&>::value, "Error");
 405 static_assert(std::is_assignable<Abstract&, const Abstract&&>::value, "Error");
 406 static_assert(std::is_assignable<Abstract&&, Abstract>::value, "Error");
 407 static_assert(std::is_assignable<Abstract&&, Abstract&&>::value, "Error");
 408 static_assert(std::is_assignable<Abstract&&, Abstract&>::value, "Error");
 409 static_assert(std::is_assignable<Abstract&&, const Abstract&>::value, "Error");
 410 static_assert(std::is_assignable<Abstract&&, const
 411 Abstract&&>::value, "Error");
 412
 413 static_assert(std::is_assignable<AbstractDelDtor&,
 414 AbstractDelDtor>::value, "Error");
 415 static_assert(std::is_assignable<AbstractDelDtor&,
 416 AbstractDelDtor&&>::value, "Error");
 417 static_assert(std::is_assignable<AbstractDelDtor&,
 418 AbstractDelDtor&>::value, "Error");
 419 static_assert(std::is_assignable<AbstractDelDtor&, const
 420 AbstractDelDtor&>::value, "Error");
 421 static_assert(std::is_assignable<AbstractDelDtor&, const
 422 AbstractDelDtor&&>::value, "Error");
 423 static_assert(std::is_assignable<AbstractDelDtor&&,
 424 AbstractDelDtor>::value, "Error");
 425 static_assert(std::is_assignable<AbstractDelDtor&&,
 426 AbstractDelDtor&&>::value, "Error");
 427 static_assert(std::is_assignable<AbstractDelDtor&&,
 428 AbstractDelDtor&>::value, "Error");
 429 static_assert(std::is_assignable<AbstractDelDtor&&, const
 430 AbstractDelDtor&>::value, "Error");
 431 static_assert(std::is_assignable<AbstractDelDtor&&, const
 432 AbstractDelDtor&&>::value, "Error");
 433
 434 static_assert(std::is_assignable<DelDef&, DelDef>::value, "Error");
 435 static_assert(std::is_assignable<DelDef&, DelDef&&>::value, "Error");
 436 static_assert(std::is_assignable<DelDef&, DelDef&>::value, "Error");
 437 static_assert(std::is_assignable<DelDef&, const DelDef&>::value, "Error");
 438 static_assert(std::is_assignable<DelDef&, const DelDef&&>::value, "Error");
 439 static_assert(std::is_assignable<DelDef&&, DelDef>::value, "Error");
 440 static_assert(std::is_assignable<DelDef&&, DelDef&&>::value, "Error");
 441 static_assert(std::is_assignable<DelDef&&, DelDef&>::value, "Error");
 442 static_assert(std::is_assignable<DelDef&&, const DelDef&>::value, "Error");
 443 static_assert(std::is_assignable<DelDef&&, const DelDef&&>::value, "Error");
 444
 445 static_assert(std::is_assignable<Ellipsis&, Ellipsis>::value, "Error");
 446 static_assert(std::is_assignable<Ellipsis&, const Ellipsis>::value, "Error");
 447 static_assert(std::is_assignable<Ellipsis&, Ellipsis&>::value, "Error");
 448 static_assert(std::is_assignable<Ellipsis&, const Ellipsis&>::value, "Error");
 449 static_assert(std::is_assignable<Ellipsis, Ellipsis>::value, "Error");
 450 static_assert(std::is_assignable<Ellipsis, const Ellipsis>::value, "Error");
 451 static_assert(std::is_assignable<Ellipsis, Ellipsis&>::value, "Error");
 452 static_assert(std::is_assignable<Ellipsis, const Ellipsis&>::value, "Error");
 453
 454 static_assert(!std::is_assignable<Ellipsis&, void>::value, "Error");
 455
 456 static_assert(std::is_assignable<Ellipsis&, int>::value, "Error");
 457 static_assert(std::is_assignable<Ellipsis&, const int>::value, "Error");
 458 static_assert(std::is_assignable<Ellipsis&, int&>::value, "Error");
 459 static_assert(std::is_assignable<Ellipsis&, const int&>::value, "Error");
 460 static_assert(std::is_assignable<Ellipsis&, Empty>::value, "Error");
 461 static_assert(std::is_assignable<Ellipsis&, const Empty>::value, "Error");
 462 static_assert(std::is_assignable<Ellipsis&, Empty&>::value, "Error");
 463 static_assert(std::is_assignable<Ellipsis&, const Empty&>::value, "Error");
 464 static_assert(std::is_assignable<Ellipsis&, E>::value, "Error");
 465 static_assert(std::is_assignable<Ellipsis&, const E>::value, "Error");
 466 static_assert(std::is_assignable<Ellipsis&, E&>::value, "Error");
 467 static_assert(std::is_assignable<Ellipsis&, const E&>::value, "Error");
 468 static_assert(std::is_assignable<Ellipsis&, SE>::value, "Error");
 469 static_assert(std::is_assignable<Ellipsis&, const SE>::value, "Error");
 470 static_assert(std::is_assignable<Ellipsis&, SE&>::value, "Error");
 471 static_assert(std::is_assignable<Ellipsis&, const SE&>::value, "Error");
 472 static_assert(std::is_assignable<Ellipsis&, bool>::value, "Error");
 473 static_assert(std::is_assignable<Ellipsis&, const bool>::value, "Error");
 474 static_assert(std::is_assignable<Ellipsis&, bool&>::value, "Error");
 475 static_assert(std::is_assignable<Ellipsis&, const bool&>::value, "Error");
 476 static_assert(std::is_assignable<Ellipsis&, std::nullptr_t>::value, "Error");
 477 static_assert(std::is_assignable<Ellipsis&, const
 478 std::nullptr_t>::value, "Error");
 479 static_assert(std::is_assignable<Ellipsis&, std::nullptr_t&>::value, "Error");
 480 static_assert(std::is_assignable<Ellipsis&, const
 481 std::nullptr_t&>::value, "Error");
 482 static_assert(std::is_assignable<Ellipsis&, void*>::value, "Error");
 483 static_assert(std::is_assignable<Ellipsis&, const void*>::value, "Error");
 484 static_assert(std::is_assignable<Ellipsis&, void*&>::value, "Error");
 485 static_assert(std::is_assignable<Ellipsis&, const void*&>::value, "Error");
 486 static_assert(std::is_assignable<Ellipsis&, void()>::value, "Error");
 487 static_assert(std::is_assignable<Ellipsis&, void(&)()>::value, "Error");
 488
 489 static_assert(std::is_assignable<DelEllipsis&, DelEllipsis>::value, "Error");
 490 static_assert(std::is_assignable<DelEllipsis&, const
 491 DelEllipsis>::value, "Error");
 492 static_assert(std::is_assignable<DelEllipsis&, DelEllipsis&>::value, "Error");
 493 static_assert(std::is_assignable<DelEllipsis&, const
 494 DelEllipsis&>::value, "Error");
 495 static_assert(std::is_assignable<DelEllipsis, DelEllipsis>::value, "Error");
 496 static_assert(std::is_assignable<DelEllipsis, const
 497 DelEllipsis>::value, "Error");
 498 static_assert(std::is_assignable<DelEllipsis, DelEllipsis&>::value, "Error");
 499 static_assert(std::is_assignable<DelEllipsis, const
 500 DelEllipsis&>::value, "Error");
 501
 502 static_assert(!std::is_assignable<DelEllipsis&, void>::value, "Error");
 503 static_assert(!std::is_assignable<DelEllipsis&, int>::value, "Error");
 504 static_assert(!std::is_assignable<DelEllipsis&, const int>::value, "Error");
 505 static_assert(!std::is_assignable<DelEllipsis&, int&>::value, "Error");
 506 static_assert(!std::is_assignable<DelEllipsis&, const int&>::value, "Error");
 507 static_assert(!std::is_assignable<DelEllipsis&, Empty>::value, "Error");
 508 static_assert(!std::is_assignable<DelEllipsis&, const Empty>::value, "Error");
 509 static_assert(!std::is_assignable<DelEllipsis&, Empty&>::value, "Error");
 510 static_assert(!std::is_assignable<DelEllipsis&, const Empty&>::value, "Error");
 511 static_assert(!std::is_assignable<DelEllipsis&, E>::value, "Error");
 512 static_assert(!std::is_assignable<DelEllipsis&, const E>::value, "Error");
 513 static_assert(!std::is_assignable<DelEllipsis&, E&>::value, "Error");
 514 static_assert(!std::is_assignable<DelEllipsis&, const E&>::value, "Error");
 515 static_assert(!std::is_assignable<DelEllipsis&, SE>::value, "Error");
 516 static_assert(!std::is_assignable<DelEllipsis&, const SE>::value, "Error");
 517 static_assert(!std::is_assignable<DelEllipsis&, SE&>::value, "Error");
 518 static_assert(!std::is_assignable<DelEllipsis&, const SE&>::value, "Error");
 519 static_assert(!std::is_assignable<DelEllipsis&, bool>::value, "Error");
 520 static_assert(!std::is_assignable<DelEllipsis&, const bool>::value, "Error");
 521 static_assert(!std::is_assignable<DelEllipsis&, bool&>::value, "Error");
 522 static_assert(!std::is_assignable<DelEllipsis&, const bool&>::value, "Error");
 523 static_assert(!std::is_assignable<DelEllipsis&,
 524 std::nullptr_t>::value, "Error");
 525 static_assert(!std::is_assignable<DelEllipsis&, const
 526 std::nullptr_t>::value, "Error");
 527 static_assert(!std::is_assignable<DelEllipsis&,
 528 std::nullptr_t&>::value, "Error");
 529 static_assert(!std::is_assignable<DelEllipsis&, const
 530 std::nullptr_t&>::value, "Error");
 531 static_assert(!std::is_assignable<DelEllipsis&, void*>::value, "Error");
 532 static_assert(!std::is_assignable<DelEllipsis&, const void*>::value, "Error");
 533 static_assert(!std::is_assignable<DelEllipsis&, void*&>::value, "Error");
 534 static_assert(!std::is_assignable<DelEllipsis&, const void*&>::value, "Error");
 535 static_assert(!std::is_assignable<DelEllipsis&, void()>::value, "Error");
 536 static_assert(!std::is_assignable<DelEllipsis&, void(&)()>::value, "Error");
 537
 538 static_assert(std::is_assignable<FromArgs<int>&, int>::value, "Error");
 539 static_assert(std::is_assignable<FromArgs<int>&, const int>::value, "Error");
 540 static_assert(!std::is_assignable<FromArgs<int>&,
 541 ImplicitTo<int>>::value, "Error");
 542 static_assert(!std::is_assignable<FromArgs<int>&, ImplicitTo<const
 543 int>>::value, "Error");
 544 static_assert(!std::is_assignable<FromArgs<int>&,
 545 ExplicitTo<int>>::value, "Error");
 546 static_assert(!std::is_assignable<FromArgs<int>&, ExplicitTo<const
 547 int>>::value, "Error");
 548
 549 static_assert(!std::is_assignable<DelFromArgs<int>&, int>::value, "Error");
 550 static_assert(!std::is_assignable<DelFromArgs<int>&, const
 551 int>::value, "Error");
 552
 553 static_assert(std::is_assignable<void(*&)(),
 554 ImplicitTo<void(*)()>>::value, "Error");
 555 static_assert(!std::is_assignable<void(*&)(),
 556 ExplicitTo<void(*)()>>::value, "Error");
 557
 558 static_assert(std::is_assignable<UAssignAll&, UAssignAll>::value, "Error");
 559 static_assert(std::is_assignable<UAssignAll&, const
 560 UAssignAll>::value, "Error");
 561 static_assert(std::is_assignable<UAssignAll&, UAssignAll&>::value, "Error");
 562 static_assert(std::is_assignable<UAssignAll&, const
 563 UAssignAll&>::value, "Error");
 564
 565 static_assert(std::is_assignable<UAssignAll, UAssignAll>::value, "Error");
 566 static_assert(std::is_assignable<UAssignAll, const
 567 UAssignAll>::value, "Error");
 568 static_assert(std::is_assignable<UAssignAll, UAssignAll&>::value, "Error");
 569 static_assert(std::is_assignable<UAssignAll, const
 570 UAssignAll&>::value, "Error");
 571
 572 static_assert(!std::is_assignable<UAssignAll&, void>::value, "Error");
 573 static_assert(!std::is_assignable<const UAssignAll&, void>::value, "Error");
 574 static_assert(!std::is_assignable<const UAssignAll&,
 575 UAssignAll>::value, "Error");
 576 static_assert(!std::is_assignable<const UAssignAll&, const
 577 UAssignAll>::value, "Error");
 578 static_assert(!std::is_assignable<const UAssignAll&,
 579 UAssignAll&>::value, "Error");
 580 static_assert(!std::is_assignable<const UAssignAll&, const
 581 UAssignAll&>::value, "Error");
 582 static_assert(!std::is_assignable<UAssignAll&, void() const>::value, "Error");
 583 static_assert(!std::is_assignable<UAssignAll&, void() &>::value, "Error");
 584 static_assert(!std::is_assignable<UAssignAll&, void() const volatile &&>::value, "Error");
 585
 586 static_assert(std::is_assignable<UAssignAll&, int>::value, "Error");
 587 static_assert(std::is_assignable<UAssignAll&, int&>::value, "Error");
 588 static_assert(std::is_assignable<UAssignAll&, E>::value, "Error");
 589 static_assert(std::is_assignable<UAssignAll&, E&>::value, "Error");
 590 static_assert(std::is_assignable<UAssignAll&, SE>::value, "Error");
 591 static_assert(std::is_assignable<UAssignAll&, SE&>::value, "Error");
 592 static_assert(std::is_assignable<UAssignAll&, double>::value, "Error");
 593 static_assert(std::is_assignable<UAssignAll&, double&>::value, "Error");
 594 static_assert(std::is_assignable<UAssignAll&, Empty>::value, "Error");
 595 static_assert(std::is_assignable<UAssignAll&, Empty&>::value, "Error");
 596 static_assert(std::is_assignable<UAssignAll&, B>::value, "Error");
 597 static_assert(std::is_assignable<UAssignAll&, B&>::value, "Error");
 598 static_assert(std::is_assignable<UAssignAll&, U>::value, "Error");
 599 static_assert(std::is_assignable<UAssignAll&, U&>::value, "Error");
 600 static_assert(std::is_assignable<UAssignAll&, std::nullptr_t>::value, "Error");
 601 static_assert(std::is_assignable<UAssignAll&,
 602 std::nullptr_t&>::value, "Error");
 603 static_assert(std::is_assignable<UAssignAll&, void()>::value, "Error");
 604 static_assert(std::is_assignable<UAssignAll&, void(&)()>::value, "Error");
 605 static_assert(std::is_assignable<UAssignAll&, void(*)()>::value, "Error");
 606 static_assert(std::is_assignable<UAssignAll&, void(*&)()>::value, "Error");
 607 static_assert(std::is_assignable<UAssignAll&, int*>::value, "Error");
 608 static_assert(std::is_assignable<UAssignAll&, int*&>::value, "Error");
 609 static_assert(std::is_assignable<UAssignAll&, void*>::value, "Error");
 610 static_assert(std::is_assignable<UAssignAll&, void*&>::value, "Error");
 611 static_assert(std::is_assignable<UAssignAll&, const int*>::value, "Error");
 612 static_assert(std::is_assignable<UAssignAll&, const int*&>::value, "Error");
 613 static_assert(std::is_assignable<UAssignAll&, const void*>::value, "Error");
 614 static_assert(std::is_assignable<UAssignAll&, const void*&>::value, "Error");
 615 static_assert(std::is_assignable<UAssignAll&, int[1]>::value, "Error");
 616 static_assert(std::is_assignable<UAssignAll&, int(&)[1]>::value, "Error");
 617 static_assert(std::is_assignable<UAssignAll&, int[]>::value, "Error");
 618 static_assert(std::is_assignable<UAssignAll&, int(&)[]>::value, "Error");
 619
 620 static_assert(!std::is_assignable<UDelAssignAll&, int>::value, "Error");
 621 static_assert(!std::is_assignable<UDelAssignAll&, int&>::value, "Error");
 622 static_assert(!std::is_assignable<UDelAssignAll&, E>::value, "Error");
 623 static_assert(!std::is_assignable<UDelAssignAll&, E&>::value, "Error");
 624 static_assert(!std::is_assignable<UDelAssignAll&, SE>::value, "Error");
 625 static_assert(!std::is_assignable<UDelAssignAll&, SE&>::value, "Error");
 626 static_assert(!std::is_assignable<UDelAssignAll&, double>::value, "Error");
 627 static_assert(!std::is_assignable<UDelAssignAll&, double&>::value, "Error");
 628 static_assert(!std::is_assignable<UDelAssignAll&, Empty>::value, "Error");
 629 static_assert(!std::is_assignable<UDelAssignAll&, Empty&>::value, "Error");
 630 static_assert(!std::is_assignable<UDelAssignAll&, B>::value, "Error");
 631 static_assert(!std::is_assignable<UDelAssignAll&, B&>::value, "Error");
 632 static_assert(!std::is_assignable<UDelAssignAll&, U>::value, "Error");
 633 static_assert(!std::is_assignable<UDelAssignAll&, U&>::value, "Error");
 634 static_assert(!std::is_assignable<UDelAssignAll&,
 635 std::nullptr_t>::value, "Error");
 636 static_assert(!std::is_assignable<UDelAssignAll&,
 637 std::nullptr_t&>::value, "Error");
 638 static_assert(!std::is_assignable<UDelAssignAll&, void()>::value, "Error");
 639 static_assert(!std::is_assignable<UDelAssignAll&, void(&)()>::value, "Error");
 640 static_assert(!std::is_assignable<UDelAssignAll&, void()
 641  const>::value, "Error");
 642 static_assert(!std::is_assignable<UDelAssignAll&, void(*)()>::value, "Error");
 643 static_assert(!std::is_assignable<UDelAssignAll&, void(*&)()>::value, "Error");
 644 static_assert(!std::is_assignable<UDelAssignAll&, int*>::value, "Error");
 645 static_assert(!std::is_assignable<UDelAssignAll&, int*&>::value, "Error");
 646 static_assert(!std::is_assignable<UDelAssignAll&, void*>::value, "Error");
 647 static_assert(!std::is_assignable<UDelAssignAll&, void*&>::value, "Error");
 648 static_assert(!std::is_assignable<UDelAssignAll&, const int*>::value, "Error");
 649 static_assert(!std::is_assignable<UDelAssignAll&, const
 650 int*&>::value, "Error");
 651 static_assert(!std::is_assignable<UDelAssignAll&, const
 652 void*>::value, "Error");
 653 static_assert(!std::is_assignable<UDelAssignAll&, const
 654 void*&>::value, "Error");
 655 static_assert(!std::is_assignable<UDelAssignAll&, int[1]>::value, "Error");
 656 static_assert(!std::is_assignable<UDelAssignAll&, int(&)[1]>::value, "Error");
 657 static_assert(!std::is_assignable<UDelAssignAll&, int[]>::value, "Error");
 658 static_assert(!std::is_assignable<UDelAssignAll&, int(&)[]>::value, "Error");
 659
 660 static_assert(!std::is_assignable<void(&)(), std::nullptr_t>::value, "Error");
 661 static_assert(!std::is_assignable<std::nullptr_t, void(&)()>::value, "Error");
 662 static_assert(!std::is_assignable<void(&)(), int[]>::value, "Error");
 663 static_assert(!std::is_assignable<int[], void(&)()>::value, "Error");
 664 static_assert(!std::is_assignable<int[], std::nullptr_t>::value, "Error");
 665 static_assert(!std::is_assignable<std::nullptr_t, int[]>::value, "Error");
 666 static_assert(!std::is_assignable<int[1], std::nullptr_t>::value, "Error");
 667 static_assert(!std::is_assignable<std::nullptr_t, int[1]>::value, "Error");
 668 static_assert(!std::is_assignable<void, std::nullptr_t>::value, "Error");
 669 static_assert(!std::is_assignable<std::nullptr_t, void>::value, "Error");
 670 static_assert(!std::is_assignable<const D&, B&>::value, "Error");
 671 static_assert(!std::is_assignable<const B&, B&>::value, "Error");
 672
 673 static_assert(std::is_assignable<B&, const D&>::value, "Error");
 674 static_assert(std::is_assignable<B&, const B&>::value, "Error");
 675 static_assert(std::is_assignable<int&, const int&>::value, "Error");
 676 static_assert(std::is_assignable<int&, const double&>::value, "Error");