Commit 9f29d67a authored by Phil Willoughby's avatar Phil Willoughby Committed by Facebook Github Bot

Make ColdClassTest work on ancient compilers

Summary:
Some older versions of GCC/glibc/etc do not have the
std::is_trivially*_constructible or std::is_trivially*_assignable traits.

Reviewed By: yfeldblum

Differential Revision: D6285887

fbshipit-source-id: 1eb4ae4f899dc1f528321f9f087390291687aca3
parent d4018226
...@@ -21,23 +21,38 @@ ...@@ -21,23 +21,38 @@
using folly::ColdClass; using folly::ColdClass;
TEST(ColdClass, inheritance) { template <class TestClass>
static void validateInheritedClass() {
// The only verifiable property of ColdClass is that it must not disrupt the // The only verifiable property of ColdClass is that it must not disrupt the
// default constructor/destructor, default copy/move constructors and default // default constructor/destructor, default copy/move constructors and default
// copy/move assignment operators when a class derives from it. // copy/move assignment operators when a class derives from it.
struct TestStruct : ColdClass {};
EXPECT_TRUE(std::is_nothrow_default_constructible<TestStruct>::value);
EXPECT_TRUE(std::is_trivially_copy_constructible<TestStruct>::value);
EXPECT_TRUE(std::is_trivially_move_constructible<TestStruct>::value);
EXPECT_TRUE(std::is_trivially_copy_assignable<TestStruct>::value);
EXPECT_TRUE(std::is_trivially_move_assignable<TestStruct>::value);
EXPECT_TRUE(std::is_trivially_destructible<TestStruct>::value);
// Same again, but private inheritance. Should make no difference.
class TestClass : ColdClass {};
EXPECT_TRUE(std::is_nothrow_default_constructible<TestClass>::value); EXPECT_TRUE(std::is_nothrow_default_constructible<TestClass>::value);
#if !defined(__GLIBCXX__) || __GNUC__ >= 5
EXPECT_TRUE(std::is_trivially_copy_constructible<TestClass>::value); EXPECT_TRUE(std::is_trivially_copy_constructible<TestClass>::value);
EXPECT_TRUE(std::is_trivially_move_constructible<TestClass>::value); EXPECT_TRUE(std::is_trivially_move_constructible<TestClass>::value);
EXPECT_TRUE(std::is_trivially_copy_assignable<TestClass>::value); EXPECT_TRUE(std::is_trivially_copy_assignable<TestClass>::value);
EXPECT_TRUE(std::is_trivially_move_assignable<TestClass>::value); EXPECT_TRUE(std::is_trivially_move_assignable<TestClass>::value);
#endif
EXPECT_TRUE(std::is_nothrow_copy_constructible<TestClass>::value);
EXPECT_TRUE(std::is_nothrow_move_constructible<TestClass>::value);
EXPECT_TRUE(std::is_nothrow_copy_assignable<TestClass>::value);
EXPECT_TRUE(std::is_nothrow_move_assignable<TestClass>::value);
EXPECT_TRUE(std::is_trivially_destructible<TestClass>::value); EXPECT_TRUE(std::is_trivially_destructible<TestClass>::value);
} }
TEST(ColdClassTest, publicInheritance) {
struct TestPublic : ColdClass {};
validateInheritedClass<TestPublic>();
}
TEST(ColdClassTest, protectedInheritance) {
// Same again, but protected inheritance. Should make no difference.
class TestProtected : protected ColdClass {};
validateInheritedClass<TestProtected>();
}
TEST(ColdClassTest, privateInheritance) {
// Same again, but private inheritance. Should make no difference.
class TestPrivate : ColdClass {};
validateInheritedClass<TestPrivate>();
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment