libstdc++-v3/testsuite/20_util/is_constructible/value-2.cc

   1 // { dg-options "-std=gnu++0x" }
   2 // { dg-do compile }
   3
   4 // Copyright (C) 2011-2013 Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11 //
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING3.  If not see
  19 // <http://www.gnu.org/licenses/>.
  20
  21 #include <type_traits>
  22 #include <initializer_list>
  23 #include <testsuite_tr1.h>
  24
  25 using namespace __gnu_test::construct;
  26
  27 static_assert(std::is_constructible<int, int>::value, "Error");
  28 static_assert(std::is_constructible<std::nullptr_t, std::nullptr_t>::value,
  29               "Error");
  30 static_assert(std::is_constructible<E, E>::value, "Error");
  31 static_assert(std::is_constructible<SE, SE>::value, "Error");
  32 static_assert(std::is_constructible<OpE, OpE>::value, "Error");
  33 static_assert(std::is_constructible<OpSE, OpSE>::value, "Error");
  34 static_assert(std::is_constructible<Empty, Empty>::value, "Error");
  35 static_assert(std::is_constructible<B, B>::value, "Error");
  36 static_assert(std::is_constructible<U, U>::value, "Error");
  37 static_assert(std::is_constructible<int B::*, int B::*>::value, "Error");
  38 static_assert(std::is_constructible<Ellipsis, Ellipsis>::value, "Error");
  39 static_assert(std::is_constructible<int*, int*>::value, "Error");
  40 static_assert(std::is_constructible<void*, void*>::value, "Error");
  41 static_assert(std::is_constructible<Any, Any>::value, "Error");
  42 static_assert(std::is_constructible<nAny, nAny>::value, "Error");
  43 static_assert(std::is_constructible<std::initializer_list<int>,
  44               std::initializer_list<int>>::value, "Error");
  45 static_assert(std::is_constructible<DelDef, DelDef>::value, "Error");
  46
  47 static_assert(!std::is_constructible<void, void>::value, "Error");
  48 static_assert(!std::is_constructible<Abstract, Abstract>::value, "Error");
  49 static_assert(!std::is_constructible<int[], int[]>::value, "Error");
  50 static_assert(!std::is_constructible<int[1], int[1]>::value, "Error");
  51 static_assert(!std::is_constructible<DelCopy, const DelCopy&>::value, "Error");
  52 static_assert(!std::is_constructible<DelCopy, DelCopy&&>::value, "Error");
  53 static_assert(!std::is_constructible<DelCopy, DelCopy>::value, "Error");
  54 static_assert(!std::is_constructible<DelDtor, void>::value, "Error");
  55 static_assert(!std::is_constructible<DelDtor, int>::value, "Error");
  56 static_assert(!std::is_constructible<DelDtor, DelDtor>::value, "Error");
  57 static_assert(!std::is_constructible<DelDtor, DelDtor&&>::value, "Error");
  58 static_assert(!std::is_constructible<DelDtor, const DelDtor&>::value, "Error");
  59
  60 static_assert(std::is_constructible<DelEllipsis, const DelEllipsis&>::value,
  61               "Error");
  62 static_assert(std::is_constructible<DelEllipsis, DelEllipsis&&>::value,
  63               "Error");
  64 static_assert(std::is_constructible<DelEllipsis, DelEllipsis>::value, "Error");
  65 static_assert(!std::is_constructible<DelEllipsis, void>::value, "Error");
  66 static_assert(!std::is_constructible<DelEllipsis, std::nullptr_t>::value,
  67               "Error");
  68 static_assert(!std::is_constructible<DelEllipsis, B>::value, "Error");
  69 static_assert(!std::is_constructible<DelEllipsis, Empty>::value, "Error");
  70 static_assert(!std::is_constructible<DelEllipsis, E>::value, "Error");
  71 static_assert(!std::is_constructible<DelEllipsis, SE>::value, "Error");
  72 static_assert(!std::is_constructible<DelEllipsis, OpE>::value, "Error");
  73 static_assert(!std::is_constructible<DelEllipsis, OpSE>::value, "Error");
  74 static_assert(!std::is_constructible<DelEllipsis, void()>::value, "Error");
  75 static_assert(!std::is_constructible<DelEllipsis, void() const>::value,
  76               "Error");
  77 static_assert(!std::is_constructible<DelEllipsis, int[1]>::value, "Error");
  78 static_assert(!std::is_constructible<DelEllipsis, int[]>::value, "Error");
  79 static_assert(!std::is_constructible<DelEllipsis, int*>::value, "Error");
  80 static_assert(!std::is_constructible<DelEllipsis, void*>::value, "Error");
  81 static_assert(!std::is_constructible<DelEllipsis, int B::*>::value, "Error");
  82 static_assert(!std::is_constructible<DelEllipsis, int D::*>::value, "Error");
  83 static_assert(!std::is_constructible<DelEllipsis, Abstract>::value, "Error");
  84 static_assert(!std::is_constructible<int, DelImplicitTo<int>>::value, "Error");
  85 static_assert(!std::is_constructible<std::nullptr_t,
  86               DelImplicitTo<std::nullptr_t>>::value, "Error");
  87 static_assert(!std::is_constructible<int&,
  88               DelImplicitTo<const int&>>::value, "Error");
  89
  90 static_assert(!std::is_constructible<int, void>::value, "Error");
  91 static_assert(!std::is_constructible<void, int>::value, "Error");
  92 static_assert(std::is_constructible<void*, int*>::value, "Error");
  93 static_assert(!std::is_constructible<int*, void*>::value, "Error");
  94 static_assert(std::is_constructible<int*, std::nullptr_t>::value, "Error");
  95 static_assert(!std::is_constructible<std::nullptr_t, int*>::value, "Error");
  96 static_assert(!std::is_constructible<Empty, E>::value, "Error");
  97 static_assert(!std::is_constructible<Empty, SE>::value, "Error");
  98 static_assert(!std::is_constructible<Empty, OpE>::value, "Error");
  99 static_assert(!std::is_constructible<Empty, OpSE>::value, "Error");
 100 static_assert(!std::is_constructible<Empty, void>::value, "Error");
 101 static_assert(!std::is_constructible<Empty, void*>::value, "Error");
 102 static_assert(!std::is_constructible<Empty, std::nullptr_t>::value, "Error");
 103 static_assert(!std::is_constructible<Empty, int[]>::value, "Error");
 104 static_assert(!std::is_constructible<Empty, int[3]>::value, "Error");
 105 static_assert(!std::is_constructible<Empty, int>::value, "Error");
 106 static_assert(!std::is_constructible<Abstract, int>::value, "Error");
 107 static_assert(!std::is_constructible<Abstract, std::nullptr_t>::value, "Error");
 108 static_assert(!std::is_constructible<std::nullptr_t, Abstract>::value, "Error");
 109 static_assert(!std::is_constructible<Abstract, int[]>::value, "Error");
 110 static_assert(std::is_constructible<B, D>::value, "Error");
 111 static_assert(!std::is_constructible<D, B>::value, "Error");
 112 static_assert(!std::is_constructible<int[], int[1]>::value, "Error");
 113 static_assert(!std::is_constructible<int[1], int[]>::value, "Error");
 114 static_assert(!std::is_constructible<int[], Empty>::value, "Error");
 115 static_assert(!std::is_constructible<int[], std::nullptr_t>::value, "Error");
 116 static_assert(!std::is_constructible<int[1], Abstract>::value, "Error");
 117
 118 static_assert(std::is_constructible<const int*, int*>::value, "Error");
 119 static_assert(std::is_constructible<const void*, void*>::value, "Error");
 120 static_assert(std::is_constructible<const void*, int*>::value, "Error");
 121 static_assert(!std::is_constructible<int*, const void*>::value, "Error");
 122
 123 static_assert(std::is_constructible<int, E>::value, "Error");
 124 static_assert(!std::is_constructible<E, int>::value, "Error");
 125 static_assert(!std::is_constructible<E, E2>::value, "Error");
 126 static_assert(std::is_constructible<E, E>::value, "Error");
 127 static_assert(std::is_constructible<bool, E>::value, "Error");
 128 static_assert(!std::is_constructible<E, bool>::value, "Error");
 129 static_assert(std::is_constructible<double, E>::value, "Error");
 130 static_assert(!std::is_constructible<E, double>::value, "Error");
 131 static_assert(!std::is_constructible<std::nullptr_t, E>::value, "Error");
 132 static_assert(!std::is_constructible<E, std::nullptr_t>::value, "Error");
 133
 134 static_assert(std::is_constructible<int, OpE>::value, "Error");
 135 static_assert(!std::is_constructible<OpE, int>::value, "Error");
 136 static_assert(!std::is_constructible<OpE, E2>::value, "Error");
 137 static_assert(std::is_constructible<OpE, OpE>::value, "Error");
 138 static_assert(std::is_constructible<bool, OpE>::value, "Error");
 139 static_assert(!std::is_constructible<OpE, bool>::value, "Error");
 140 static_assert(std::is_constructible<double, OpE>::value, "Error");
 141 static_assert(!std::is_constructible<OpE, double>::value, "Error");
 142 static_assert(!std::is_constructible<std::nullptr_t, OpE>::value, "Error");
 143 static_assert(!std::is_constructible<OpE, std::nullptr_t>::value, "Error");
 144
 145 static_assert(!std::is_constructible<int, SE>::value, "Error");
 146 static_assert(!std::is_constructible<SE, int>::value, "Error");
 147 static_assert(!std::is_constructible<E, SE>::value, "Error");
 148 static_assert(!std::is_constructible<SE, SE2>::value, "Error");
 149 static_assert(std::is_constructible<SE, SE>::value, "Error");
 150 static_assert(!std::is_constructible<bool, SE>::value, "Error");
 151 static_assert(!std::is_constructible<SE, bool>::value, "Error");
 152 static_assert(!std::is_constructible<double, SE>::value, "Error");
 153 static_assert(!std::is_constructible<SE, double>::value, "Error");
 154 static_assert(!std::is_constructible<std::nullptr_t, SE>::value, "Error");
 155 static_assert(!std::is_constructible<SE, std::nullptr_t>::value, "Error");
 156
 157 static_assert(!std::is_constructible<int, OpSE>::value, "Error");
 158 static_assert(!std::is_constructible<OpSE, int>::value, "Error");
 159 static_assert(!std::is_constructible<OpE, OpSE>::value, "Error");
 160 static_assert(!std::is_constructible<OpSE, SE2>::value, "Error");
 161 static_assert(std::is_constructible<OpSE, OpSE>::value, "Error");
 162 static_assert(!std::is_constructible<bool, OpSE>::value, "Error");
 163 static_assert(!std::is_constructible<OpSE, bool>::value, "Error");
 164 static_assert(!std::is_constructible<double, OpSE>::value, "Error");
 165 static_assert(!std::is_constructible<OpSE, double>::value, "Error");
 166 static_assert(!std::is_constructible<std::nullptr_t, OpSE>::value, "Error");
 167 static_assert(!std::is_constructible<OpSE, std::nullptr_t>::value, "Error");
 168
 169 static_assert(!std::is_constructible<D*, B*>::value, "Error");
 170 static_assert(!std::is_constructible<const volatile D*, B*>::value, "Error");
 171 static_assert(!std::is_constructible<D*, const volatile B*>::value, "Error");
 172
 173 static_assert(!std::is_constructible<D*, B* const>::value, "Error");
 174 static_assert(!std::is_constructible<const volatile D*, B* const>::value,
 175               "Error");
 176 static_assert(!std::is_constructible<D*, const volatile B* const>::value,
 177               "Error");
 178
 179 static_assert(!std::is_constructible<D*, B*&>::value, "Error");
 180 static_assert(!std::is_constructible<const volatile D*, B*&>::value, "Error");
 181 static_assert(!std::is_constructible<D*, const volatile B*&>::value, "Error");
 182
 183 static_assert(!std::is_constructible<int B::*, int D::*>::value, "Error");
 184 static_assert(!std::is_constructible<const volatile int B::*, int D::*>::value,
 185               "Error");
 186 static_assert(!std::is_constructible<int B::*, const volatile int D::*>::value,
 187               "Error");
 188
 189 static_assert(!std::is_constructible<int B::*, int D::* const>::value, "Error");
 190 static_assert(!std::is_constructible<const volatile int B::*,
 191               int D::* const>::value, "Error");
 192 static_assert(!std::is_constructible<int B::*,
 193               const volatile int D::* const>::value, "Error");
 194
 195 static_assert(!std::is_constructible<int B::*, int D::*&>::value, "Error");
 196 static_assert(!std::is_constructible<const volatile int B::*,
 197               int D::*&>::value, "Error");
 198 static_assert(!std::is_constructible<int B::*,
 199               const volatile int D::*&>::value, "Error");
 200
 201 static_assert(!std::is_constructible<int B::*, int D::* const &>::value,
 202               "Error");
 203 static_assert(!std::is_constructible<const volatile int B::*,
 204               int D::* const &>::value, "Error");
 205 static_assert(!std::is_constructible<int B::*,
 206               const volatile int D::* const &>::value, "Error");
 207
 208 static_assert(!std::is_constructible<int&&, int&>::value, "Error");
 209 static_assert(!std::is_constructible<const int&&, int&>::value, "Error");
 210
 211 static_assert(std::is_constructible<B&, D&>::value, "Error");
 212 static_assert(std::is_constructible<B&&, D&&>::value, "Error");
 213 static_assert(std::is_constructible<const B&, D&>::value, "Error");
 214 static_assert(std::is_constructible<const B&&, D&&>::value, "Error");
 215 static_assert(!std::is_constructible<B&, const D&>::value, "Error");
 216 static_assert(!std::is_constructible<B&&, const D&&>::value, "Error");
 217
 218 static_assert(!std::is_constructible<D&, B&>::value, "Error");
 219 static_assert(!std::is_constructible<D&&, B&&>::value, "Error");
 220 static_assert(!std::is_constructible<D&, const B&>::value, "Error");
 221 static_assert(!std::is_constructible<D&&, const B&&>::value, "Error");
 222 static_assert(!std::is_constructible<const D&, B&>::value, "Error");
 223 static_assert(!std::is_constructible<const D&&, B&&>::value, "Error");
 224
 225 static_assert(!std::is_constructible<B&&, B&>::value, "Error");
 226 static_assert(!std::is_constructible<B&&, D&>::value, "Error");
 227 static_assert(std::is_constructible<B&&, ImplicitTo<D&&>>::value, "Error");
 228 static_assert(std::is_constructible<B&&, ImplicitTo<D&&>&>::value, "Error");
 229 static_assert(std::is_constructible<int&&, double&>::value, "Error");
 230 static_assert(std::is_constructible<const int&,
 231               ImplicitTo<int&>&>::value, "Error");
 232 static_assert(std::is_constructible<const int&,
 233               ImplicitTo<int&>>::value, "Error");
 234 static_assert(std::is_constructible<const int&,
 235               ExplicitTo<int&>&>::value, "Error");
 236 static_assert(std::is_constructible<const int&,
 237               ExplicitTo<int&>>::value, "Error");
 238
 239 static_assert(!std::is_constructible<B&&, ExplicitTo<D&&>>::value, "Error");
 240 static_assert(!std::is_constructible<B&&, ExplicitTo<D&&>&>::value, "Error");
 241
 242 static_assert(!std::is_constructible<B&, B&&>::value, "Error");
 243 static_assert(!std::is_constructible<D&, B&&>::value, "Error");
 244 static_assert(!std::is_constructible<B&, D&&>::value, "Error");
 245
 246 static_assert(std::is_constructible<void(&)(), void(&)()>::value, "Error");
 247 static_assert(std::is_constructible<void(&&)(), void(&&)()>::value, "Error");
 248 static_assert(std::is_constructible<void(&&)(), void()>::value, "Error");
 249
 250 static_assert(!std::is_constructible<void>::value, "Error" );
 251 static_assert(!std::is_constructible<void, int>::value, "Error" );
 252 static_assert(!std::is_constructible<void, int, double>::value, "Error" );
 253
 254 static_assert(!std::is_constructible<int&>::value, "Error" );
 255 static_assert(!std::is_constructible<const int&>::value, "Error" );
 256 static_assert(!std::is_constructible<int&, int, int>::value, "Error" );
 257 static_assert(!std::is_constructible<const int&, int, int>::value, "Error" );
 258
 259 static_assert(std::is_constructible<void(&)(), void()>::value, "Error");
 260 static_assert(std::is_constructible<void(&)(), void(&&)()>::value, "Error");
 261
 262 static_assert(std::is_constructible<int&, int&>::value, "Error");
 263 static_assert(!std::is_constructible<int&, const int&>::value, "Error");
 264 static_assert(!std::is_constructible<int&, int>::value, "Error");
 265 static_assert(!std::is_constructible<int&, int&&>::value, "Error");
 266 static_assert(!std::is_constructible<int&, const int&&>::value, "Error");
 267 static_assert(std::is_constructible<const int&, int&>::value, "Error");
 268 static_assert(std::is_constructible<const int&, int>::value, "Error");
 269 static_assert(std::is_constructible<const int&, const int>::value, "Error");
 270 static_assert(std::is_constructible<const int&, int&&>::value, "Error");
 271 static_assert(std::is_constructible<const int&, const int&&>::value, "Error");
 272 static_assert(std::is_constructible<volatile int&, int&>::value, "Error");
 273 static_assert(!std::is_constructible<volatile int&, const int&>::value,
 274               "Error");
 275 static_assert(!std::is_constructible<volatile int&, int>::value, "Error");
 276 static_assert(!std::is_constructible<volatile int&, int&&>::value, "Error");
 277 static_assert(!std::is_constructible<volatile int&, const int&&>::value,
 278               "Error");
 279 static_assert(std::is_constructible<const volatile int&, int&>::value, "Error");
 280 static_assert(!std::is_constructible<const volatile int&, int>::value, "Error");
 281 static_assert(!std::is_constructible<const volatile int&, const int>::value,
 282               "Error");
 283 static_assert(!std::is_constructible<const volatile int&, int&&>::value,
 284               "Error");
 285 static_assert(!std::is_constructible<const volatile int&, const int&&>::value,
 286               "Error");
 287
 288 static_assert(std::is_constructible<int&&, int>::value, "Error");
 289 static_assert(std::is_constructible<int&&, int&&>::value, "Error");
 290 static_assert(!std::is_constructible<int&&, const int&&>::value, "Error");
 291 static_assert(!std::is_constructible<int&&, int&>::value, "Error");
 292 static_assert(!std::is_constructible<int&&, const int&>::value, "Error");
 293 static_assert(std::is_constructible<int&&, double&>::value, "Error");
 294 static_assert(std::is_constructible<const int&&, int>::value, "Error");
 295 static_assert(std::is_constructible<const int&&, int&&>::value, "Error");
 296 static_assert(std::is_constructible<const int&&, const int>::value, "Error");
 297 static_assert(std::is_constructible<const int&&, const int&&>::value, "Error");
 298 static_assert(!std::is_constructible<int&&, const int&>::value, "Error");
 299 static_assert(!std::is_constructible<const int&&, int&>::value, "Error");
 300 static_assert(!std::is_constructible<const int&&, const int&>::value, "Error");
 301 static_assert(std::is_constructible<volatile int&&, int>::value, "Error");
 302 static_assert(std::is_constructible<volatile int&&, int&&>::value, "Error");
 303 static_assert(!std::is_constructible<volatile int&&, const int&&>::value,
 304               "Error");
 305 static_assert(!std::is_constructible<volatile int&&, int&>::value, "Error");
 306 static_assert(!std::is_constructible<volatile int&&, const int&>::value,
 307               "Error");
 308 static_assert(std::is_constructible<volatile int&&, double&>::value, "Error");
 309 static_assert(std::is_constructible<volatile const int&&, int>::value, "Error");
 310 static_assert(std::is_constructible<const volatile int&&, int&&>::value,
 311               "Error");
 312 static_assert(std::is_constructible<const volatile int&&, const int>::value,
 313               "Error");
 314 static_assert(std::is_constructible<const volatile int&&, const int&&>::value,
 315               "Error");
 316 static_assert(!std::is_constructible<volatile int&&, const int&>::value,
 317               "Error");
 318 static_assert(!std::is_constructible<const volatile int&&, int&>::value,
 319               "Error");
 320 static_assert(!std::is_constructible<const volatile int&&,
 321               const int&>::value, "Error");
 322
 323 static_assert(std::is_constructible<Empty&, Empty&>::value, "Error");
 324 static_assert(!std::is_constructible<Empty&, const Empty&>::value, "Error");
 325 static_assert(!std::is_constructible<Empty&, Empty>::value, "Error");
 326 static_assert(!std::is_constructible<Empty&, Empty&&>::value, "Error");
 327 static_assert(!std::is_constructible<Empty&, const Empty&&>::value, "Error");
 328 static_assert(std::is_constructible<const Empty&, Empty&>::value, "Error");
 329 static_assert(std::is_constructible<const Empty&, Empty>::value, "Error");
 330 static_assert(std::is_constructible<const Empty&, const Empty>::value, "Error");
 331 static_assert(std::is_constructible<const Empty&, Empty&&>::value, "Error");
 332 static_assert(std::is_constructible<const Empty&, const Empty&&>::value,
 333               "Error");
 334 static_assert(std::is_constructible<volatile Empty&, Empty&>::value, "Error");
 335 static_assert(!std::is_constructible<volatile Empty&, const Empty&>::value,
 336               "Error");
 337 static_assert(!std::is_constructible<volatile Empty&, Empty>::value, "Error");
 338 static_assert(!std::is_constructible<volatile Empty&, Empty&&>::value, "Error");
 339 static_assert(!std::is_constructible<volatile Empty&, const Empty&&>::value,
 340               "Error");
 341 static_assert(std::is_constructible<const volatile Empty&, Empty&>::value,
 342               "Error");
 343 static_assert(!std::is_constructible<const volatile Empty&, Empty>::value,
 344               "Error");
 345 static_assert(!std::is_constructible<const volatile Empty&,
 346               const Empty>::value, "Error");
 347 static_assert(!std::is_constructible<const volatile Empty&,
 348               Empty&&>::value, "Error");
 349 static_assert(!std::is_constructible<const volatile Empty&,
 350               const Empty&&>::value, "Error");
 351
 352 static_assert(std::is_constructible<Empty&&, Empty>::value, "Error");
 353 static_assert(std::is_constructible<Empty&&, Empty&&>::value, "Error");
 354 static_assert(!std::is_constructible<Empty&&, const Empty&&>::value, "Error");
 355 static_assert(!std::is_constructible<Empty&&, Empty&>::value, "Error");
 356 static_assert(!std::is_constructible<Empty&&, const Empty&>::value, "Error");
 357 static_assert(!std::is_constructible<Empty&&, double&>::value, "Error");
 358 static_assert(!std::is_constructible<Empty&&, const double&>::value, "Error");
 359 static_assert(std::is_constructible<const Empty&&, Empty>::value, "Error");
 360 static_assert(std::is_constructible<const Empty&&, Empty&&>::value, "Error");
 361 static_assert(std::is_constructible<const Empty&&, const Empty>::value,
 362               "Error");
 363 static_assert(std::is_constructible<const Empty&&, const Empty&&>::value,
 364               "Error");
 365 static_assert(!std::is_constructible<Empty&&, const Empty&>::value, "Error");
 366 static_assert(!std::is_constructible<const Empty&&, Empty&>::value, "Error");
 367 static_assert(!std::is_constructible<const Empty&&, const Empty&>::value,
 368               "Error");
 369 static_assert(std::is_constructible<volatile Empty&&, Empty>::value, "Error");
 370 static_assert(std::is_constructible<volatile Empty&&, Empty&&>::value, "Error");
 371 static_assert(!std::is_constructible<volatile Empty&&, const Empty&&>::value,
 372               "Error");
 373 static_assert(!std::is_constructible<volatile Empty&&, Empty&>::value, "Error");
 374 static_assert(!std::is_constructible<volatile Empty&&, const Empty&>::value,
 375               "Error");
 376 static_assert(!std::is_constructible<volatile Empty&&, double&>::value,
 377               "Error");
 378 static_assert(!std::is_constructible<volatile Empty&&, const double&>::value,
 379               "Error");
 380 static_assert(std::is_constructible<const volatile Empty&&, Empty>::value,
 381               "Error");
 382 static_assert(std::is_constructible<const volatile Empty&&, Empty&&>::value,
 383               "Error");
 384 static_assert(std::is_constructible<const volatile Empty&&,
 385               const Empty>::value, "Error");
 386 static_assert(std::is_constructible<const volatile Empty&&,
 387               const Empty&&>::value, "Error");
 388 static_assert(!std::is_constructible<volatile Empty&&,
 389               const Empty&>::value, "Error");
 390 static_assert(!std::is_constructible<const volatile Empty&&,
 391               Empty&>::value, "Error");
 392 static_assert(!std::is_constructible<const volatile Empty&&,
 393               const Empty&>::value, "Error");
 394
 395 static_assert(std::is_constructible<Ellipsis, int>::value, "Error");
 396 static_assert(std::is_constructible<Ellipsis, Empty>::value, "Error");
 397 static_assert(std::is_constructible<Ellipsis, std::nullptr_t>::value, "Error");
 398 static_assert(std::is_constructible<Ellipsis, int[]>::value, "Error");
 399 static_assert(std::is_constructible<Ellipsis, int[1]>::value, "Error");
 400 static_assert(!std::is_constructible<Ellipsis, void>::value, "Error");
 401
 402 static_assert(std::is_constructible<int(&)[1], int(&)[1]>::value, "Error");
 403 static_assert(std::is_constructible<const int(&)[1],
 404               int(&)[1]>::value, "Error");
 405 static_assert(std::is_constructible<volatile int(&)[1],
 406               int(&)[1]>::value, "Error");
 407 static_assert(std::is_constructible<const volatile int(&)[1],
 408               int(&)[1]>::value, "Error");
 409 static_assert(!std::is_constructible<int(&)[1],
 410               const int(&)[1]>::value, "Error");
 411 static_assert(!std::is_constructible<const int(&)[1],
 412               volatile int(&)[1]>::value, "Error");
 413
 414 static_assert(std::is_constructible<int(&)[], int(&)[]>::value, "Error");
 415
 416 static_assert(!std::is_constructible<int(&)[1], int(&)[2]>::value, "Error");
 417 static_assert(!std::is_constructible<int(&)[1], int&>::value, "Error");
 418 static_assert(!std::is_constructible<int&, int(&)[1]>::value, "Error");
 419
 420 static_assert(!std::is_constructible<U, int>::value, "Error");
 421 static_assert(!std::is_constructible<U, Empty>::value, "Error");
 422
 423 static_assert(!std::is_constructible<void(), void()>::value, "Error");
 424 static_assert(!std::is_constructible<void(), int>::value, "Error");
 425 static_assert(!std::is_constructible<void(), Abstract>::value, "Error");
 426 static_assert(!std::is_constructible<void(), std::nullptr_t>::value, "Error");
 427 static_assert(!std::is_constructible<void(), Empty>::value, "Error");
 428 static_assert(!std::is_constructible<void(), U>::value, "Error");
 429 static_assert(!std::is_constructible<void(), E>::value, "Error");
 430 static_assert(!std::is_constructible<void(), SE>::value, "Error");
 431 static_assert(!std::is_constructible<void(), OpE>::value, "Error");
 432 static_assert(!std::is_constructible<void(), OpSE>::value, "Error");
 433 static_assert(!std::is_constructible<void(), int[]>::value, "Error");
 434 static_assert(!std::is_constructible<void(), int[1]>::value, "Error");
 435
 436 static_assert(!std::is_constructible<void() const,
 437               void() volatile>::value, "Error");
 438 static_assert(!std::is_constructible<void() const, int>::value, "Error");
 439 static_assert(!std::is_constructible<void() const, Abstract>::value, "Error");
 440 static_assert(!std::is_constructible<void() const, std::nullptr_t>::value,
 441               "Error");
 442 static_assert(!std::is_constructible<void() const, Empty>::value, "Error");
 443 static_assert(!std::is_constructible<void() const, U>::value, "Error");
 444 static_assert(!std::is_constructible<void() const, E>::value, "Error");
 445 static_assert(!std::is_constructible<void() const, SE>::value, "Error");
 446 static_assert(!std::is_constructible<void() const, OpE>::value, "Error");
 447 static_assert(!std::is_constructible<void() const, OpSE>::value, "Error");
 448 static_assert(!std::is_constructible<void() const, int[]>::value, "Error");
 449 static_assert(!std::is_constructible<void() const, int[1]>::value, "Error");
 450
 451 static_assert(!std::is_constructible<void(int), void()>::value, "Error");
 452 static_assert(!std::is_constructible<int, void()>::value, "Error");
 453 static_assert(!std::is_constructible<Abstract, void()>::value, "Error");
 454 static_assert(!std::is_constructible<std::nullptr_t, void()>::value, "Error");
 455 static_assert(!std::is_constructible<Empty, void()>::value, "Error");
 456 static_assert(!std::is_constructible<U, void()>::value, "Error");
 457 static_assert(!std::is_constructible<E, void()>::value, "Error");
 458 static_assert(!std::is_constructible<SE, void()>::value, "Error");
 459 static_assert(!std::is_constructible<OpE, void()>::value, "Error");
 460 static_assert(!std::is_constructible<OpSE, void()>::value, "Error");
 461 static_assert(!std::is_constructible<int[], void()>::value, "Error");
 462 static_assert(!std::is_constructible<int[1], void()>::value, "Error");
 463
 464 static_assert(!std::is_constructible<void(int) const,
 465               void() const>::value, "Error");
 466 static_assert(!std::is_constructible<int, void() const>::value, "Error");
 467 static_assert(!std::is_constructible<Abstract, void() const>::value, "Error");
 468 static_assert(!std::is_constructible<std::nullptr_t, void() const>::value,
 469               "Error");
 470 static_assert(!std::is_constructible<Empty, void() const>::value, "Error");
 471 static_assert(!std::is_constructible<U, void() const>::value, "Error");
 472 static_assert(!std::is_constructible<E, void() const>::value, "Error");
 473 static_assert(!std::is_constructible<SE, void() const>::value, "Error");
 474 static_assert(!std::is_constructible<OpE, void() const>::value, "Error");
 475 static_assert(!std::is_constructible<OpSE, void() const>::value, "Error");
 476 static_assert(!std::is_constructible<int[], void() const>::value, "Error");
 477 static_assert(!std::is_constructible<int[1], void() const>::value, "Error");
 478
 479 static_assert(!std::is_constructible<void, int, int>::value, "Error");
 480 static_assert(!std::is_constructible<void, Empty, B>::value, "Error");
 481 static_assert(!std::is_constructible<void, Empty, Empty>::value, "Error");
 482 static_assert(!std::is_constructible<void, U, Empty>::value, "Error");
 483 static_assert(!std::is_constructible<void, U, U>::value, "Error");
 484 static_assert(!std::is_constructible<void, std::nullptr_t,
 485               std::nullptr_t>::value, "Error");
 486 static_assert(!std::is_constructible<void, int[1], int[1]>::value, "Error");
 487 static_assert(!std::is_constructible<void, int[], int[]>::value, "Error");
 488 static_assert(!std::is_constructible<void, void, int>::value, "Error");
 489 static_assert(!std::is_constructible<void, void, void>::value, "Error");
 490 static_assert(!std::is_constructible<void, void(), void()>::value, "Error");
 491 static_assert(!std::is_constructible<void, void() const,
 492               void() volatile>::value, "Error");
 493
 494 static_assert(!std::is_constructible<int, int, int>::value, "Error");
 495 static_assert(!std::is_constructible<const int, int, int>::value, "Error");
 496 static_assert(!std::is_constructible<int, void, int>::value, "Error");
 497 static_assert(!std::is_constructible<const int, void, int>::value, "Error");
 498 static_assert(!std::is_constructible<int, void, void>::value, "Error");
 499 static_assert(!std::is_constructible<const int, void, void>::value, "Error");
 500 static_assert(!std::is_constructible<bool, int, int>::value, "Error");
 501 static_assert(!std::is_constructible<const bool, int, int>::value, "Error");
 502 static_assert(!std::is_constructible<std::nullptr_t, int, int>::value, "Error");
 503 static_assert(!std::is_constructible<const std::nullptr_t, int, int>::value,
 504               "Error");
 505 static_assert(!std::is_constructible<std::nullptr_t, void, int>::value,
 506               "Error");
 507 static_assert(!std::is_constructible<const std::nullptr_t, void, int>::value,
 508               "Error");
 509 static_assert(!std::is_constructible<std::nullptr_t, void, void>::value,
 510               "Error");
 511 static_assert(!std::is_constructible<const std::nullptr_t, void, void>::value,
 512               "Error");
 513 static_assert(!std::is_constructible<E, int, int>::value, "Error");
 514 static_assert(!std::is_constructible<const E, int, int>::value, "Error");
 515 static_assert(!std::is_constructible<E, void, int>::value, "Error");
 516 static_assert(!std::is_constructible<const E, void, int>::value, "Error");
 517 static_assert(!std::is_constructible<E, void, void>::value, "Error");
 518 static_assert(!std::is_constructible<const E, void, void>::value, "Error");
 519 static_assert(!std::is_constructible<SE, int, int>::value, "Error");
 520 static_assert(!std::is_constructible<const SE, int, int>::value, "Error");
 521 static_assert(!std::is_constructible<SE, void, int>::value, "Error");
 522 static_assert(!std::is_constructible<const SE, void, int>::value, "Error");
 523 static_assert(!std::is_constructible<SE, void, void>::value, "Error");
 524 static_assert(!std::is_constructible<const SE, void, void>::value, "Error");
 525 static_assert(!std::is_constructible<OpE, int, int>::value, "Error");
 526 static_assert(!std::is_constructible<const OpE, int, int>::value, "Error");
 527 static_assert(!std::is_constructible<OpE, void, int>::value, "Error");
 528 static_assert(!std::is_constructible<const OpE, void, int>::value, "Error");
 529 static_assert(!std::is_constructible<OpE, void, void>::value, "Error");
 530 static_assert(!std::is_constructible<const OpE, void, void>::value, "Error");
 531 static_assert(!std::is_constructible<OpSE, int, int>::value, "Error");
 532 static_assert(!std::is_constructible<const OpSE, int, int>::value, "Error");
 533 static_assert(!std::is_constructible<OpSE, void, int>::value, "Error");
 534 static_assert(!std::is_constructible<const OpSE, void, int>::value, "Error");
 535 static_assert(!std::is_constructible<OpSE, void, void>::value, "Error");
 536 static_assert(!std::is_constructible<const OpSE, void, void>::value, "Error");
 537 static_assert(!std::is_constructible<Empty, int, int>::value, "Error");
 538 static_assert(!std::is_constructible<const Empty, int, int>::value, "Error");
 539 static_assert(!std::is_constructible<Empty, void, int>::value, "Error");
 540 static_assert(!std::is_constructible<const Empty, void, int>::value, "Error");
 541 static_assert(!std::is_constructible<Empty, void, void>::value, "Error");
 542 static_assert(!std::is_constructible<const Empty, void, void>::value, "Error");
 543 static_assert(!std::is_constructible<U, int, int>::value, "Error");
 544 static_assert(!std::is_constructible<const U, int, int>::value, "Error");
 545 static_assert(!std::is_constructible<U, void, int>::value, "Error");
 546 static_assert(!std::is_constructible<const U, void, int>::value, "Error");
 547 static_assert(!std::is_constructible<U, void, void>::value, "Error");
 548 static_assert(!std::is_constructible<const U, void, void>::value, "Error");
 549 static_assert(!std::is_constructible<B, int, int>::value, "Error");
 550 static_assert(!std::is_constructible<const B, int, int>::value, "Error");
 551 static_assert(!std::is_constructible<B, void, int>::value, "Error");
 552 static_assert(!std::is_constructible<const B, void, int>::value, "Error");
 553 static_assert(!std::is_constructible<B, void, void>::value, "Error");
 554 static_assert(!std::is_constructible<const B, void, void>::value, "Error");
 555 static_assert(!std::is_constructible<Any, int, int>::value, "Error");
 556 static_assert(!std::is_constructible<const Any, int, int>::value, "Error");
 557 static_assert(!std::is_constructible<Any, void, int>::value, "Error");
 558 static_assert(!std::is_constructible<const Any, void, int>::value, "Error");
 559 static_assert(!std::is_constructible<Any, void, void>::value, "Error");
 560 static_assert(!std::is_constructible<const Any, void, void>::value, "Error");
 561 static_assert(!std::is_constructible<nAny, void, int>::value, "Error");
 562 static_assert(!std::is_constructible<const nAny, void, int>::value, "Error");
 563 static_assert(!std::is_constructible<nAny, void, void>::value, "Error");
 564 static_assert(!std::is_constructible<const nAny, void, void>::value, "Error");
 565 static_assert(!std::is_constructible<FromArgs<>, int, int>::value, "Error");
 566 static_assert(!std::is_constructible<const FromArgs<>, int, int>::value,
 567               "Error");
 568 static_assert(!std::is_constructible<FromArgs<>, void, int>::value, "Error");
 569 static_assert(!std::is_constructible<const FromArgs<>, void, int>::value,
 570               "Error");
 571 static_assert(!std::is_constructible<FromArgs<>, void, void>::value, "Error");
 572 static_assert(!std::is_constructible<const FromArgs<>, void, void>::value,
 573               "Error");
 574 static_assert(!std::is_constructible<Abstract, int, int>::value, "Error");
 575 static_assert(!std::is_constructible<const Abstract, int, int>::value, "Error");
 576 static_assert(!std::is_constructible<Abstract, void, int>::value, "Error");
 577 static_assert(!std::is_constructible<const Abstract, void, int>::value,
 578               "Error");
 579 static_assert(!std::is_constructible<Abstract, void, void>::value, "Error");
 580 static_assert(!std::is_constructible<const Abstract, void, void>::value,
 581               "Error");
 582 static_assert(!std::is_constructible<AbstractDelDtor, int, int>::value,
 583               "Error");
 584 static_assert(!std::is_constructible<const AbstractDelDtor, int, int>::value,
 585               "Error");
 586 static_assert(!std::is_constructible<AbstractDelDtor, void, int>::value,
 587               "Error");
 588 static_assert(!std::is_constructible<const AbstractDelDtor, void, int>::value,
 589               "Error");
 590 static_assert(!std::is_constructible<AbstractDelDtor, void, void>::value,
 591               "Error");
 592 static_assert(!std::is_constructible<const AbstractDelDtor, void, void>::value,
 593               "Error");
 594 static_assert(!std::is_constructible<int[1], int, int>::value, "Error");
 595 static_assert(!std::is_constructible<const int[1], int, int>::value, "Error");
 596 static_assert(!std::is_constructible<int[1], void, int>::value, "Error");
 597 static_assert(!std::is_constructible<const int[1], void, int>::value, "Error");
 598 static_assert(!std::is_constructible<int[1], void, void>::value, "Error");
 599 static_assert(!std::is_constructible<const int[1], void, void>::value, "Error");
 600 static_assert(!std::is_constructible<int&, int, int>::value, "Error");
 601 static_assert(!std::is_constructible<int&, void, int>::value, "Error");
 602 static_assert(!std::is_constructible<int&, void, void>::value, "Error");
 603 static_assert(!std::is_constructible<int&, int&, int&>::value, "Error");
 604 static_assert(!std::is_constructible<int&, void, int&>::value, "Error");
 605 static_assert(!std::is_constructible<int&, void, void>::value, "Error");
 606 static_assert(!std::is_constructible<std::nullptr_t&, int, int>::value,
 607               "Error");
 608 static_assert(!std::is_constructible<std::nullptr_t&, void, int>::value,
 609               "Error");
 610 static_assert(!std::is_constructible<std::nullptr_t&, void, void>::value,
 611               "Error");
 612 static_assert(!std::is_constructible<E&, int, int>::value, "Error");
 613 static_assert(!std::is_constructible<E&, void, int>::value, "Error");
 614 static_assert(!std::is_constructible<E&, void, void>::value, "Error");
 615 static_assert(!std::is_constructible<SE&, int, int>::value, "Error");
 616 static_assert(!std::is_constructible<SE&, void, int>::value, "Error");
 617 static_assert(!std::is_constructible<SE&, void, void>::value, "Error");
 618 static_assert(!std::is_constructible<OpE&, int, int>::value, "Error");
 619 static_assert(!std::is_constructible<OpE&, void, int>::value, "Error");
 620 static_assert(!std::is_constructible<OpE&, void, void>::value, "Error");
 621 static_assert(!std::is_constructible<OpSE&, int, int>::value, "Error");
 622 static_assert(!std::is_constructible<OpSE&, void, int>::value, "Error");
 623 static_assert(!std::is_constructible<OpSE&, void, void>::value, "Error");
 624 static_assert(!std::is_constructible<Empty&, int, int>::value, "Error");
 625 static_assert(!std::is_constructible<Empty&, void, int>::value, "Error");
 626 static_assert(!std::is_constructible<Empty&, void, void>::value, "Error");
 627 static_assert(!std::is_constructible<U&, int, int>::value, "Error");
 628 static_assert(!std::is_constructible<U&, void, int>::value, "Error");
 629 static_assert(!std::is_constructible<U&, void, void>::value, "Error");
 630 static_assert(!std::is_constructible<B&, int, int>::value, "Error");
 631 static_assert(!std::is_constructible<B&, void, int>::value, "Error");
 632 static_assert(!std::is_constructible<B&, void, void>::value, "Error");
 633 static_assert(!std::is_constructible<Any&, int, int>::value, "Error");
 634 static_assert(!std::is_constructible<Any&, void, int>::value, "Error");
 635 static_assert(!std::is_constructible<Any&, void, void>::value, "Error");
 636 static_assert(!std::is_constructible<nAny&, void, int>::value, "Error");
 637 static_assert(!std::is_constructible<nAny&, void, void>::value, "Error");
 638 static_assert(!std::is_constructible<FromArgs<>&, int, int>::value, "Error");
 639 static_assert(!std::is_constructible<FromArgs<>&, void, int>::value, "Error");
 640 static_assert(!std::is_constructible<FromArgs<>&, void, void>::value, "Error");
 641 static_assert(!std::is_constructible<Abstract&, int, int>::value, "Error");
 642 static_assert(!std::is_constructible<Abstract&, void, int>::value, "Error");
 643 static_assert(!std::is_constructible<Abstract&, void, void>::value, "Error");
 644 static_assert(!std::is_constructible<int(&)[1], int, int>::value, "Error");
 645 static_assert(!std::is_constructible<int(&)[1], void, int>::value, "Error");
 646 static_assert(!std::is_constructible<int(&)[1], void, void>::value, "Error");
 647
 648 static_assert(!std::is_constructible<void(), int, int>::value, "Error");
 649 static_assert(!std::is_constructible<void(), void, int>::value, "Error");
 650 static_assert(!std::is_constructible<void(), void, void>::value, "Error");
 651 static_assert(!std::is_constructible<void(), void(), int>::value, "Error");
 652 static_assert(!std::is_constructible<void(), void(), void()>::value, "Error");
 653
 654 static_assert(!std::is_constructible<void() const, int, int>::value, "Error");
 655 static_assert(!std::is_constructible<void() const, void, int>::value, "Error");
 656 static_assert(!std::is_constructible<void() const, void, void>::value, "Error");
 657 static_assert(!std::is_constructible<void() const, void() volatile,
 658               int>::value, "Error");
 659 static_assert(!std::is_constructible<void() const, void() volatile const,
 660               void() const>::value, "Error");
 661
 662 static_assert(!std::is_constructible<FromArgs<int>, int, int>::value, "Error");
 663 static_assert(!std::is_constructible<const FromArgs<int>, int, int>::value,
 664               "Error");
 665 static_assert(!std::is_constructible<FromArgs<int>, void, int>::value, "Error");
 666 static_assert(!std::is_constructible<const FromArgs<int>, void, int>::value,
 667               "Error");
 668 static_assert(!std::is_constructible<FromArgs<int, int>, void, int>::value,
 669               "Error");
 670 static_assert(!std::is_constructible<const FromArgs<int, int>, void,
 671               int>::value, "Error");
 672
 673 static_assert(!std::is_constructible<DelDtor, int, B, U>::value, "Error");
 674 static_assert(!std::is_constructible<const DelDtor, int, B, U>::value, "Error");
 675 static_assert(!std::is_constructible<DelDtor, int>::value, "Error");
 676 static_assert(!std::is_constructible<const DelDtor, int>::value, "Error");
 677 static_assert(!std::is_constructible<DelDtor>::value, "Error");
 678 static_assert(!std::is_constructible<const DelDtor>::value, "Error");
 679 static_assert(!std::is_constructible<DelDtor, void*, void(&)()>::value,
 680               "Error");
 681 static_assert(!std::is_constructible<const DelDtor, void*, void(&)()>::value,
 682               "Error");
 683
 684 static_assert(!std::is_constructible<AbstractDelDtor>::value, "Error");
 685 static_assert(!std::is_constructible<const AbstractDelDtor>::value, "Error");
 686 static_assert(!std::is_constructible<DelEllipsis>::value, "Error");
 687 static_assert(!std::is_constructible<const DelEllipsis>::value, "Error");
 688 static_assert(!std::is_constructible<DelEllipsis, double>::value, "Error");
 689 static_assert(!std::is_constructible<const DelEllipsis, double>::value,
 690               "Error");
 691 static_assert(!std::is_constructible<DelEllipsis, double, int&>::value,
 692               "Error");
 693 static_assert(!std::is_constructible<const DelEllipsis, double, int&>::value,
 694               "Error");
 695 static_assert(!std::is_constructible<DelnAny>::value, "Error");
 696 static_assert(!std::is_constructible<const DelnAny>::value, "Error");
 697 static_assert(!std::is_constructible<DelnAny, int>::value, "Error");
 698 static_assert(!std::is_constructible<const DelnAny, int>::value, "Error");
 699 static_assert(!std::is_constructible<DelnAny, int, void*>::value, "Error");
 700 static_assert(!std::is_constructible<const DelnAny, int, void*>::value,
 701               "Error");
 702 static_assert(!std::is_constructible<DelnAny, Empty, B, D>::value, "Error");
 703 static_assert(!std::is_constructible<const DelnAny, Empty, B, D>::value,
 704               "Error");
 705
 706 // Deleted members in unions with non-trivial members:
 707 static_assert(!std::is_constructible<NontrivialUnion>::value, "Error");
 708 static_assert(!std::is_constructible<NontrivialUnion,
 709               const NontrivialUnion&>::value, "Error");
 710
 711 // Unusual copy:
 712 static_assert(!std::is_constructible<UnusualCopy>::value, "Error");
 713 static_assert(!std::is_constructible<UnusualCopy, UnusualCopy>::value, "Error");
 714 static_assert(!std::is_constructible<UnusualCopy,
 715               UnusualCopy&&>::value, "Error");
 716 static_assert(!std::is_constructible<UnusualCopy,
 717               const UnusualCopy&>::value, "Error");
 718 static_assert(std::is_constructible<UnusualCopy, UnusualCopy&>::value, "Error");
 719
 720 static_assert(std::is_constructible<FromArgs<int, char>,
 721               int, char>::value, "Error");
 722 static_assert(std::is_constructible<const FromArgs<int, char>,
 723               int, char>::value, "Error");
 724 static_assert(std::is_constructible<FromArgs<int, char>,
 725               int, int>::value, "Error");
 726 static_assert(std::is_constructible<const FromArgs<int, char>,
 727               int, int>::value, "Error");
 728 static_assert(std::is_constructible<nAny, int, int>::value, "Error");
 729 static_assert(std::is_constructible<const nAny, int, int>::value, "Error");
 730 static_assert(std::is_constructible<FromArgs<int, char>,
 731               ImplicitTo<int>, ImplicitTo<char>>::value, "Error");
 732 static_assert(std::is_constructible<const FromArgs<int, char>,
 733               ImplicitTo<int>, ImplicitTo<char>>::value, "Error");
 734 static_assert(std::is_constructible<Ellipsis, int, char>::value, "Error");
 735 static_assert(std::is_constructible<const Ellipsis, int, char>::value, "Error");
 736 static_assert(std::is_constructible<Ellipsis, B, U, int&>::value, "Error");
 737 static_assert(std::is_constructible<const Ellipsis,
 738               B, U, int&>::value, "Error");
 739 static_assert(std::is_constructible<nAny, B, U, int&>::value, "Error");
 740 static_assert(std::is_constructible<const nAny, B, U, int&>::value, "Error");
 741 static_assert(std::is_constructible<FromArgs<std::initializer_list<int>,
 742               std::initializer_list<B>>, std::initializer_list<int>,
 743               std::initializer_list<B>>::value, "Error");
 744 static_assert(std::is_constructible<const FromArgs<std::initializer_list<int>,
 745               std::initializer_list<B>>, std::initializer_list<int>,
 746               std::initializer_list<B>>::value, "Error");
 747 static_assert(std::is_constructible<FromArgs<std::initializer_list<int>,
 748               std::initializer_list<B>>, std::initializer_list<int>&,
 749               std::initializer_list<B>&>::value, "Error");
 750 static_assert(!std::is_constructible<FromArgs<std::initializer_list<int>&,
 751               std::initializer_list<B>&>, std::initializer_list<int>,
 752               std::initializer_list<B>>::value, "Error");
 753
 754 static_assert(!std::is_constructible<FromArgs<std::initializer_list<int>>,
 755               int, int>::value, "Error");
 756 static_assert(!std::is_constructible<const
 757               FromArgs<std::initializer_list<int>>, int, int>::value, "Error");
 758 static_assert(!std::is_constructible<B[2], B, B>::value, "Error");
 759 static_assert(!std::is_constructible<const B[2], B, B>::value, "Error");
 760 static_assert(!std::is_constructible<U[2], U, U>::value, "Error");
 761 static_assert(!std::is_constructible<const U[2], U, U>::value, "Error");
 762
 763 static_assert(!std::is_constructible<E, E, E>::value, "Error");
 764 static_assert(!std::is_constructible<const E, E, E>::value, "Error");
 765 static_assert(!std::is_constructible<SE, SE, SE>::value, "Error");
 766 static_assert(!std::is_constructible<const SE, SE, SE>::value, "Error");
 767 static_assert(!std::is_constructible<E, B, std::nullptr_t>::value, "Error");
 768 static_assert(!std::is_constructible<const E, B, std::nullptr_t>::value,
 769               "Error");
 770 static_assert(!std::is_constructible<SE, B, std::nullptr_t>::value, "Error");
 771 static_assert(!std::is_constructible<const SE, B, std::nullptr_t>::value,
 772               "Error");
 773 static_assert(!std::is_constructible<E, int[], int[]>::value, "Error");
 774 static_assert(!std::is_constructible<const E, int[], int[]>::value, "Error");
 775 static_assert(!std::is_constructible<SE, int[], int[]>::value, "Error");
 776 static_assert(!std::is_constructible<const SE, int[], int[]>::value, "Error");
 777
 778 static_assert(!std::is_constructible<OpE, OpE, OpE>::value, "Error");
 779 static_assert(!std::is_constructible<const OpE, OpE, OpE>::value, "Error");
 780 static_assert(!std::is_constructible<OpSE, OpSE, OpSE>::value, "Error");
 781 static_assert(!std::is_constructible<const OpSE, OpSE, OpSE>::value, "Error");
 782 static_assert(!std::is_constructible<OpE, B, std::nullptr_t>::value, "Error");
 783 static_assert(!std::is_constructible<const OpE, B, std::nullptr_t>::value,
 784               "Error");
 785 static_assert(!std::is_constructible<OpSE, B, std::nullptr_t>::value, "Error");
 786 static_assert(!std::is_constructible<const OpSE, B, std::nullptr_t>::value,
 787               "Error");
 788 static_assert(!std::is_constructible<OpE, int[], int[]>::value, "Error");
 789 static_assert(!std::is_constructible<const OpE, int[], int[]>::value, "Error");
 790 static_assert(!std::is_constructible<OpSE, int[], int[]>::value, "Error");
 791 static_assert(!std::is_constructible<const OpSE, int[], int[]>::value, "Error");
 792
 793 static_assert(!std::is_constructible<int[], int, int>::value, "Error");
 794 static_assert(!std::is_constructible<const int[], int, int>::value, "Error");
 795
 796 static_assert(std::is_constructible<int&, ImplicitTo<int&>>::value, "Error");
 797 static_assert(std::is_constructible<const int&, ImplicitTo<int&&>>::value,
 798               "Error");
 799 static_assert(std::is_constructible<int&&, ImplicitTo<int&&>>::value, "Error");
 800 static_assert(std::is_constructible<const int&, ImplicitTo<int>>::value,
 801               "Error");
 802
 803 static_assert(!std::is_constructible<const int&, ExplicitTo<int>>::value,
 804               "Error");
 805 static_assert(!std::is_constructible<int&&, ExplicitTo<int>>::value, "Error");
 806
 807 // Binding through reference-compatible type is required to perform
 808 // direct-initialization as described in [over.match.ref] p. 1 b. 1:
 809 static_assert(std::is_constructible<int&, ExplicitTo<int&>>::value, "Error");
 810 static_assert(std::is_constructible<const int&, ExplicitTo<int&&>>::value,
 811               "Error");
 812 static_assert(std::is_constructible<int&&, ExplicitTo<int&&>>::value, "Error");
 813
 814 // Binding through temporary behaves like copy-initialization,
 815 // see [dcl.init.ref] p. 5, very last sub-bullet:
 816 static_assert(!std::is_constructible<const int&, ExplicitTo<double&&>>::value,
 817               "Error");
 818 static_assert(!std::is_constructible<int&&, ExplicitTo<double&&>>::value,
 819               "Error");
 820
 821 static_assert(std::is_constructible<void(&&)(), void(&)()>::value, "Error");