19 #include <type_traits> 23 #include "gtest/gtest.h" 27 using ::testing::StaticAssertTypeEq;
29 template <
class T,
class U>
38 struct ConvertibleToReturnType {
39 operator ReturnType()
const;
47 struct TypeWithBarFunction {
50 ReturnType bar(T&&,
const StructB&, StructC&&) &&;
53 struct TypeWithBarFunctionAndConvertibleReturnType {
56 ConvertibleToReturnType bar(T&&,
const StructB&, StructC&&) &&;
59 template <
class Class,
class... Ts>
60 using BarIsCallableImpl =
61 decltype(std::declval<Class>().bar(std::declval<Ts>()...));
63 template <
class Class,
class... T>
67 template <
class Class,
class... T>
69 ReturnType, BarIsCallableImpl, Class, T...>;
72 TEST(IsDetectedTest, BasicUsage) {
73 EXPECT_TRUE((BarIsCallable<TypeWithBarFunction, StructA&,
const StructB&,
81 EXPECT_FALSE((BarIsCallable<TypeWithBarFunction&, StructA&,
const StructB&,
83 EXPECT_FALSE((BarIsCallable<TypeWithBarFunction, StructA,
const StructB&,
88 TEST(IsDetectedConvertibleTest, BasicUsage) {
89 EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&,
const StructB&,
91 EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB&,
93 EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB,
95 EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
96 StructA&,
const StructB&, StructC>::
value));
97 EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
98 StructA&, StructB&, StructC>::
value));
99 EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
100 StructA&, StructB, StructC>::
value));
104 EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction&, StructA&,
105 const StructB&, StructC>::
value));
106 EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction, StructA,
const StructB&,
108 EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType&,
109 StructA&,
const StructB&, StructC>::
value));
110 EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
111 StructA,
const StructB&, StructC>::
value));
114 TEST(VoidTTest, BasicUsage) {
115 StaticAssertTypeEq<void, absl::void_t<Dummy>>();
116 StaticAssertTypeEq<void, absl::void_t<Dummy, Dummy, Dummy>>();
119 TEST(ConjunctionTest, BasicBooleanLogic) {
129 static constexpr
bool value =
true;
133 static constexpr
bool value =
false;
136 TEST(ConjunctionTest, ShortCircuiting) {
139 EXPECT_TRUE((std::is_base_of<MyFalseType,
141 std::false_type>>::
value));
143 (std::is_base_of<MyTrueType,
147 TEST(DisjunctionTest, BasicBooleanLogic) {
156 TEST(DisjunctionTest, ShortCircuiting) {
161 std::true_type>>::
value));
163 std::is_base_of<MyFalseType,
167 TEST(NegationTest, BasicBooleanLogic) {
179 struct TrivialDestructor {
180 ~TrivialDestructor() =
default;
183 struct NontrivialDestructor {
184 ~NontrivialDestructor() {}
187 struct DeletedDestructor {
188 ~DeletedDestructor() =
delete;
191 class TrivialDefaultCtor {
193 TrivialDefaultCtor() =
default;
194 explicit TrivialDefaultCtor(
int n) : n_(n) {}
200 class NontrivialDefaultCtor {
202 NontrivialDefaultCtor() : n_(1) {}
208 class DeletedDefaultCtor {
210 DeletedDefaultCtor() =
delete;
211 explicit DeletedDefaultCtor(
int n) : n_(n) {}
217 class TrivialMoveCtor {
219 explicit TrivialMoveCtor(
int n) : n_(n) {}
220 TrivialMoveCtor(TrivialMoveCtor&&) =
default;
221 TrivialMoveCtor& operator=(
const TrivialMoveCtor& t) {
230 class NontrivialMoveCtor {
232 explicit NontrivialMoveCtor(
int n) : n_(n) {}
233 NontrivialMoveCtor(NontrivialMoveCtor&& t) noexcept : n_(t.n_) {}
234 NontrivialMoveCtor& operator=(
const NontrivialMoveCtor&) =
default;
240 class TrivialCopyCtor {
242 explicit TrivialCopyCtor(
int n) : n_(n) {}
243 TrivialCopyCtor(
const TrivialCopyCtor&) =
default;
244 TrivialCopyCtor& operator=(
const TrivialCopyCtor& t) {
253 class NontrivialCopyCtor {
255 explicit NontrivialCopyCtor(
int n) : n_(n) {}
256 NontrivialCopyCtor(
const NontrivialCopyCtor& t) : n_(t.n_) {}
257 NontrivialCopyCtor& operator=(
const NontrivialCopyCtor&) =
default;
263 class DeletedCopyCtor {
265 explicit DeletedCopyCtor(
int n) : n_(n) {}
266 DeletedCopyCtor(
const DeletedCopyCtor&) =
delete;
267 DeletedCopyCtor& operator=(
const DeletedCopyCtor&) =
default;
273 class TrivialMoveAssign {
275 explicit TrivialMoveAssign(
int n) : n_(n) {}
276 TrivialMoveAssign(
const TrivialMoveAssign& t) : n_(t.n_) {}
277 TrivialMoveAssign& operator=(TrivialMoveAssign&&) =
default;
278 ~TrivialMoveAssign() {}
283 class NontrivialMoveAssign {
285 explicit NontrivialMoveAssign(
int n) : n_(n) {}
286 NontrivialMoveAssign(
const NontrivialMoveAssign&) =
default;
287 NontrivialMoveAssign& operator=(NontrivialMoveAssign&& t) noexcept {
296 class TrivialCopyAssign {
298 explicit TrivialCopyAssign(
int n) : n_(n) {}
299 TrivialCopyAssign(
const TrivialCopyAssign& t) : n_(t.n_) {}
300 TrivialCopyAssign& operator=(
const TrivialCopyAssign& t) =
default;
301 ~TrivialCopyAssign() {}
306 class NontrivialCopyAssign {
308 explicit NontrivialCopyAssign(
int n) : n_(n) {}
309 NontrivialCopyAssign(
const NontrivialCopyAssign&) =
default;
310 NontrivialCopyAssign& operator=(
const NontrivialCopyAssign& t) {
319 class DeletedCopyAssign {
321 explicit DeletedCopyAssign(
int n) : n_(n) {}
322 DeletedCopyAssign(
const DeletedCopyAssign&) =
default;
323 DeletedCopyAssign& operator=(
const DeletedCopyAssign&) =
delete;
329 struct MovableNonCopyable {
330 MovableNonCopyable() =
default;
331 MovableNonCopyable(
const MovableNonCopyable&) =
delete;
332 MovableNonCopyable(MovableNonCopyable&&) =
default;
333 MovableNonCopyable& operator=(
const MovableNonCopyable&) =
delete;
334 MovableNonCopyable& operator=(MovableNonCopyable&&) =
default;
337 struct NonCopyableOrMovable {
338 NonCopyableOrMovable() =
default;
339 NonCopyableOrMovable(
const NonCopyableOrMovable&) =
delete;
340 NonCopyableOrMovable(NonCopyableOrMovable&&) =
delete;
341 NonCopyableOrMovable& operator=(
const NonCopyableOrMovable&) =
delete;
342 NonCopyableOrMovable& operator=(NonCopyableOrMovable&&) =
delete;
362 #define ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 1 371 #if !defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 3700 372 #define ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL 1 383 #if defined(__clang__) || defined(_MSC_VER) || \ 384 (defined(__GNUC__) && __GNUC__ < 5) 385 #define ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL 1 388 TEST(TypeTraitsTest, TestTrivialDestructor) {
418 #ifdef ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL 425 simple_pair<Trivial, TrivialDestructor>>::
value));
434 simple_pair<int, std::string>>::
value));
436 simple_pair<std::string, int>>::
value));
439 using int10 =
int[10];
441 using Trivial10 = Trivial[10];
443 using TrivialDestructor10 = TrivialDestructor[10];
447 using NontrivialDestructor10 = NontrivialDestructor[10];
451 TEST(TypeTraitsTest, TestTrivialDefaultCtor) {
486 #ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 497 simple_pair<int, char*>>::
value));
499 simple_pair<int, Trivial>>::
value));
501 simple_pair<int, TrivialDefaultCtor>>::
value));
512 simple_pair<int, std::string>>::
value));
514 simple_pair<std::string, int>>::
value));
517 using int10 =
int[10];
519 using Trivial10 = Trivial[10];
521 using TrivialDefaultCtor10 = TrivialDefaultCtor[10];
526 #ifdef ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL 527 using NontrivialDefaultCtor10 = NontrivialDefaultCtor[10];
533 TEST(TypeTraitsTest, TestTrivialMoveCtor) {
572 #ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 587 simple_pair<int, TrivialMoveCtor>>::
value));
597 simple_pair<int, std::string>>::
value));
599 simple_pair<std::string, int>>::
value));
602 using int10 =
int[10];
606 TEST(TypeTraitsTest, TestTrivialCopyCtor) {
647 #ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 662 simple_pair<int, TrivialCopyCtor>>::
value));
672 simple_pair<int, std::string>>::
value));
674 simple_pair<std::string, int>>::
value));
677 using int10 =
int[10];
681 TEST(TypeTraitsTest, TestTrivialMoveAssign) {
726 simple_pair<int, TrivialMoveAssign>>::
value));
736 simple_pair<int, std::string>>::
value));
738 simple_pair<std::string, int>>::
value));
741 using int10 =
int[10];
749 TEST(TypeTraitsTest, TestTrivialCopyAssign) {
795 simple_pair<int, TrivialCopyAssign>>::
value));
805 simple_pair<int, std::string>>::
value));
807 simple_pair<std::string, int>>::
value));
810 using int10 =
int[10];
818 TEST(TypeTraitsTest, TestTriviallyCopyable) {
848 const std::string*>::
value);
865 TrivialCopyAssign>::
value);
868 TrivialCopyCtor>::
value);
872 NontrivialCopyCtor>::
value);
874 NontrivialCopyAssign>::
value);
883 NonCopyableOrMovable>::
value);
887 DeletedCopyAssign>::
value);
894 simple_pair<int, char*>>::
value));
896 simple_pair<int, Trivial>>::
value));
903 std::vector<int>>::
value);
908 simple_pair<int, std::string>>::
value));
910 simple_pair<std::string, int>>::
value));
912 simple_pair<int, TrivialCopyAssign>>::
value));
915 using int10 =
int[10];
917 using int10x10 =
int[10][10];
928 #define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name, ...) \ 929 EXPECT_TRUE((std::is_same<typename std::trait_name<__VA_ARGS__>::type, \ 930 absl::trait_name##_t<__VA_ARGS__>>::value)) 932 TEST(TypeTraitsTest, TestRemoveCVAliases) {
949 TEST(TypeTraitsTest, TestAddCVAliases) {
966 TEST(TypeTraitsTest, TestReferenceAliases) {
989 TEST(TypeTraitsTest, TestPointerAliases) {
997 TEST(TypeTraitsTest, TestSignednessAliases) {
1009 TEST(TypeTraitsTest, TestExtentAliases) {
1021 TEST(TypeTraitsTest, TestAlignedStorageAlias) {
1091 TEST(TypeTraitsTest, TestDecay) {
1121 template <
typename T>
1127 template <
typename T,
1129 TypeEnum operator()(Wrap<T>)
const {
1133 template <
typename T,
1135 TypeEnum operator()(Wrap<T>)
const {
1139 template <
typename T,
1141 TypeEnum operator()(Wrap<T>)
const {
1146 } constexpr GetType = {};
1148 TEST(TypeTraitsTest, TestEnableIf) {
1149 EXPECT_EQ(TypeEnum::A, GetType(Wrap<TypeA>()));
1150 EXPECT_EQ(TypeEnum::B, GetType(Wrap<TypeB>()));
1154 TEST(TypeTraitsTest, TestConditional) {
1160 TEST(TypeTraitsTest, TestCommonType) {
1170 TEST(TypeTraitsTest, TestUnderlyingType) {
1171 enum class enum_char : char {};
1172 enum class enum_long_long : long long {};
1178 struct GetTypeExtT {
1179 template <
typename T>
1181 return GetType(std::forward<T>(
arg));
1184 TypeEnum operator()(Wrap<TypeD>)
const {
return TypeEnum::D; }
1185 } constexpr GetTypeExt = {};
1187 TEST(TypeTraitsTest, TestResultOf) {
1188 EXPECT_EQ(TypeEnum::A, GetTypeExt(Wrap<TypeA>()));
1189 EXPECT_EQ(TypeEnum::B, GetTypeExt(Wrap<TypeB>()));
1190 EXPECT_EQ(
TypeEnum::C, GetTypeExt(Wrap<TypeC>()));
1191 EXPECT_EQ(TypeEnum::D, GetTypeExt(Wrap<TypeD>()));
1194 template <
typename T>
1195 bool TestCopyAssign() {
1200 TEST(TypeTraitsTest, IsCopyAssignable) {
1201 EXPECT_TRUE(TestCopyAssign<int>());
1202 EXPECT_TRUE(TestCopyAssign<int&>());
1203 EXPECT_TRUE(TestCopyAssign<int&&>());
1206 EXPECT_TRUE(TestCopyAssign<S>());
1207 EXPECT_TRUE(TestCopyAssign<S&>());
1208 EXPECT_TRUE(TestCopyAssign<S&&>());
1212 explicit C(
C* c) : c_(c) {}
1218 EXPECT_TRUE(TestCopyAssign<C>());
1219 EXPECT_TRUE(TestCopyAssign<C&>());
1220 EXPECT_TRUE(TestCopyAssign<C&&>());
1223 #ifndef _LIBCPP_VERSION 1224 EXPECT_TRUE(TestCopyAssign<
int()>());
1225 EXPECT_TRUE(TestCopyAssign<
int(
int)
const>());
1226 EXPECT_TRUE(TestCopyAssign<
int(...)
volatile&>());
1227 EXPECT_TRUE(TestCopyAssign<
int(
int, ...)
const volatile&&>());
1228 #endif // _LIBCPP_VERSION 1231 template <
typename T>
1232 bool TestMoveAssign() {
1237 TEST(TypeTraitsTest, IsMoveAssignable) {
1238 EXPECT_TRUE(TestMoveAssign<int>());
1239 EXPECT_TRUE(TestMoveAssign<int&>());
1240 EXPECT_TRUE(TestMoveAssign<int&&>());
1243 EXPECT_TRUE(TestMoveAssign<S>());
1244 EXPECT_TRUE(TestMoveAssign<S&>());
1245 EXPECT_TRUE(TestMoveAssign<S&&>());
1249 explicit C(
C* c) : c_(c) {}
1251 void operator=(
const C&) =
delete;
1252 void operator=(
C&&) =
delete;
1257 EXPECT_TRUE(TestMoveAssign<C>());
1258 EXPECT_TRUE(TestMoveAssign<C&>());
1259 EXPECT_TRUE(TestMoveAssign<C&&>());
1262 #ifndef _LIBCPP_VERSION 1263 EXPECT_TRUE(TestMoveAssign<
int()>());
1264 EXPECT_TRUE(TestMoveAssign<
int(
int)
const>());
1265 EXPECT_TRUE(TestMoveAssign<
int(...)
volatile&>());
1266 EXPECT_TRUE(TestMoveAssign<
int(
int, ...)
const volatile&&>());
1267 #endif // _LIBCPP_VERSION 1272 struct DeletedSwap {
1275 void swap(DeletedSwap&, DeletedSwap&) =
delete;
1277 struct SpecialNoexceptSwap {
1278 SpecialNoexceptSwap(SpecialNoexceptSwap&&) {}
1279 SpecialNoexceptSwap& operator=(SpecialNoexceptSwap&&) {
return *
this; }
1280 ~SpecialNoexceptSwap() =
default;
1283 void swap(SpecialNoexceptSwap&, SpecialNoexceptSwap&) noexcept {}
1287 TEST(TypeTraitsTest, IsSwappable) {
1288 using absl::type_traits_internal::IsSwappable;
1296 struct NoConstruct {
1297 NoConstruct(NoConstruct&&) =
delete;
1298 NoConstruct& operator=(NoConstruct&&) {
return *
this; }
1299 ~NoConstruct() =
default;
1304 NoAssign(NoAssign&&) {}
1305 NoAssign& operator=(NoAssign&&) =
delete;
1306 ~NoAssign() =
default;
1316 TEST(TypeTraitsTest, IsNothrowSwappable) {
1317 using absl::type_traits_internal::IsNothrowSwappable;
1322 struct NonNoexceptMoves {
1323 NonNoexceptMoves(NonNoexceptMoves&&) {}
1324 NonNoexceptMoves& operator=(NonNoexceptMoves&&) {
return *
this; }
1325 ~NonNoexceptMoves() =
default;
1330 struct NoConstruct {
1331 NoConstruct(NoConstruct&&) =
delete;
1332 NoConstruct& operator=(NoConstruct&&) {
return *
this; }
1333 ~NoConstruct() =
default;
1339 NoAssign(NoAssign&&) {}
1340 NoAssign& operator=(NoAssign&&) =
delete;
1341 ~NoAssign() =
default;
typename std::result_of< T >::type result_of_t
typename std::enable_if< B, T >::type enable_if_t
IsSwappable< void()> StdSwapIsUnconstrained
void swap(absl::InlinedVector< T, N, A > &a, absl::InlinedVector< T, N, A > &b) noexcept(noexcept(a.swap(b)))
TEST(Symbolize, Unimplemented)
#define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name,...)