libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14, c++17
  10
  11 // We voluntarily use std::default_initializable on types that have redundant
  12 // or ignored cv-qualifiers -- don't warn about it.
  13 // ADDITIONAL_COMPILE_FLAGS(gcc-style-warnings): -Wno-ignored-qualifiers
  14
  15 // template<class T>
  16 //     concept default_initializable = constructible_from<T> &&
  17 //     requires { T{}; } &&
  18 //     is-default-initializable<T>;
  19
  20 #include <array>
  21 #include <concepts>
  22 #include <deque>
  23 #include <forward_list>
  24 #include <list>
  25 #include <map>
  26 #include <memory>
  27 #include <queue>
  28 #include <set>
  29 #include <span>
  30 #include <stack>
  31 #include <string>
  32 #include <string_view>
  33 #include <unordered_map>
  34 #include <unordered_set>
  35 #include <vector>
  36
  37 #include "test_macros.h"
  38
  39 struct Empty {};
  40
  41 struct CtorDefaulted {
  42   CtorDefaulted() = default;
  43 };
  44 struct CtorDeleted {
  45   CtorDeleted() = delete;
  46 };
  47 struct DtorDefaulted {
  48   ~DtorDefaulted() = default;
  49 };
  50 struct DtorDeleted {
  51   ~DtorDeleted() = delete;
  52 };
  53
  54 struct Noexcept {
  55   ~Noexcept() noexcept;
  56 };
  57 struct NoexceptTrue {
  58   ~NoexceptTrue() noexcept(true);
  59 };
  60 struct NoexceptFalse {
  61   ~NoexceptFalse() noexcept(false);
  62 };
  63
  64 struct CtorProtected {
  65 protected:
  66   CtorProtected() = default;
  67 };
  68 struct CtorPrivate {
  69 private:
  70   CtorPrivate() = default;
  71 };
  72 struct DtorProtected {
  73 protected:
  74   ~DtorProtected() = default;
  75 };
  76 struct DtorPrivate {
  77 private:
  78   ~DtorPrivate() = default;
  79 };
  80
  81 template <class T>
  82 struct NoexceptDependant {
  83   ~NoexceptDependant() noexcept(std::is_same_v<T, int>);
  84 };
  85
  86 struct CtorExplicit {
  87   explicit CtorExplicit() = default;
  88 };
  89 struct CtorArgument {
  90   CtorArgument(int) {}
  91 };
  92 struct CtorDefaultArgument {
  93   CtorDefaultArgument(int = 0) {}
  94 };
  95 struct CtorExplicitDefaultArgument {
  96   explicit CtorExplicitDefaultArgument(int = 0) {}
  97 };
  98
  99 struct Derived : public Empty {};
 100
 101 class Abstract {
 102   virtual void foo() = 0;
 103 };
 104
 105 class AbstractDestructor {
 106   virtual ~AbstractDestructor() = 0;
 107 };
 108
 109 class OperatorNewDeleted {
 110   void* operator new(std::size_t) = delete;
 111   void operator delete(void* ptr) = delete;
 112 };
 113
 114 [[maybe_unused]] auto Lambda = [](const int&, int&&, double){};
 115
 116 template<class T>
 117 void test_not_const()
 118 {
 119     static_assert( std::default_initializable<               T>);
 120     static_assert(!std::default_initializable<const          T>);
 121     static_assert( std::default_initializable<      volatile T>);
 122     static_assert(!std::default_initializable<const volatile T>);
 123 }
 124
 125 template<class T>
 126 void test_true()
 127 {
 128     static_assert( std::default_initializable<               T>);
 129     static_assert( std::default_initializable<const          T>);
 130     static_assert( std::default_initializable<      volatile T>);
 131     static_assert( std::default_initializable<const volatile T>);
 132 }
 133
 134 template<class T>
 135 void test_false()
 136 {
 137     static_assert(!std::default_initializable<               T>);
 138     static_assert(!std::default_initializable<const          T>);
 139     static_assert(!std::default_initializable<      volatile T>);
 140     static_assert(!std::default_initializable<const volatile T>);
 141 }
 142
 143 void test()
 144 {
 145     test_not_const<bool>();
 146     test_not_const<char>();
 147     test_not_const<int>();
 148     test_not_const<double>();
 149
 150     test_false    <void>();
 151     test_not_const<void*>();
 152
 153     test_not_const<int*>();
 154     test_false    <int[]>();
 155     test_not_const<int[1]>();
 156     test_false    <int&>();
 157     test_false    <int&&>();
 158
 159     test_true     <Empty>();
 160
 161     test_true     <CtorDefaulted>();
 162     test_false    <CtorDeleted>();
 163     test_true     <DtorDefaulted>();
 164     test_false    <DtorDeleted>();
 165
 166     test_true     <Noexcept>();
 167     test_true     <NoexceptTrue>();
 168     test_false    <NoexceptFalse>();
 169
 170     test_false    <CtorProtected>();
 171     test_false    <CtorPrivate>();
 172     test_false    <DtorProtected>();
 173     test_false    <DtorPrivate>();
 174
 175     test_true     <NoexceptDependant<int>>();
 176     test_false    <NoexceptDependant<double>>();
 177
 178     test_true     <CtorExplicit>();
 179     test_false    <CtorArgument>();
 180     test_true     <CtorDefaultArgument>();
 181     test_true     <CtorExplicitDefaultArgument>();
 182
 183     test_true     <Derived>();
 184     test_false    <Abstract>();
 185     test_false    <AbstractDestructor>();
 186
 187     test_true     <OperatorNewDeleted>();
 188
 189     test_true     <decltype(Lambda)>();
 190     test_not_const<void(*)(const int&)>();
 191     test_not_const<void(Empty::*)(const int&)               >();
 192     test_not_const<void(Empty::*)(const int&) const         >();
 193     test_not_const<void(Empty::*)(const int&)       volatile>();
 194     test_not_const<void(Empty::*)(const int&) const volatile>();
 195     test_not_const<void(Empty::*)(const int&) &>();
 196     test_not_const<void(Empty::*)(const int&) &&>();
 197     test_not_const<void(Empty::*)(const int&) noexcept>();
 198     test_not_const<void(Empty::*)(const int&) noexcept(true)>();
 199     test_not_const<void(Empty::*)(const int&) noexcept(false)>();
 200
 201     // Sequence containers
 202     test_true     <std::array<               int, 0>>();
 203     test_not_const<std::array<               int, 1>>();
 204     test_false    <std::array<const          int, 1>>();
 205     test_not_const<std::array<      volatile int, 1>>();
 206     test_false    <std::array<const volatile int, 1>>();
 207     test_true     <std::deque<               int>>();
 208 #ifdef _LIBCPP_VERSION
 209     test_true     <std::deque<const          int>>();
 210 #endif // _LIBCPP_VERSION
 211     test_true     <std::forward_list<int>>();
 212     test_true     <std::list<int>>();
 213     test_true     <std::vector<int>>();
 214
 215     // Associative containers
 216     test_true     <std::set<int>>();
 217     test_true     <std::map<int, int>>();
 218     test_true     <std::multiset<int>>();
 219     test_true     <std::multimap<int, int>>();
 220
 221     // Unordered associative containers
 222     test_true     <std::unordered_set<int>>();
 223     test_true     <std::unordered_map<int, int>>();
 224     test_true     <std::unordered_multiset<int>>();
 225     test_true     <std::unordered_multimap<int, int>>();
 226
 227     // Container adaptors
 228     test_true     <std::stack<               int>>();
 229 #ifdef _LIBCPP_VERSION
 230     test_true     <std::stack<const          int>>();
 231 #endif // _LIBCPP_VERSION
 232     test_true     <std::queue<int>>();
 233     test_true     <std::priority_queue<int>>();
 234
 235     test_true     <std::span<               int>>();
 236     test_true     <std::span<const          int>>();
 237     test_true     <std::span<      volatile int>>();
 238     test_true     <std::span<const volatile int>>();
 239
 240     // Strings
 241     test_true     <std::string>();
 242 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 243     test_true     <std::wstring>();
 244 #endif
 245     test_true     <std::u8string>();
 246     test_true     <std::u16string>();
 247     test_true     <std::u32string>();
 248
 249     // String views
 250     test_true     <std::string_view>();
 251 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 252     test_true     <std::wstring_view>();
 253 #endif
 254     test_true     <std::u8string_view>();
 255     test_true     <std::u16string_view>();
 256     test_true     <std::u32string_view>();
 257
 258     // Smart pointers
 259     test_true     <std::unique_ptr<int>>();
 260     test_true     <std::shared_ptr<int>>();
 261     test_true     <std::weak_ptr<int>>();
 262
 263 }