ColdClassTest.cpp File Reference

#include <folly/lang/ColdClass.h>
#include <folly/portability/GTest.h>
#include <type_traits>

Go to the source code of this file.

Functions
template<class TestClass >
static void	validateInheritedClass ()
	TEST (ColdClassTest, publicInheritance)
	TEST (ColdClassTest, protectedInheritance)
	TEST (ColdClassTest, privateInheritance)

Function Documentation

TEST	(	ColdClassTest	,
		publicInheritance
	)

Definition at line 43 of file ColdClassTest.cpp.

                                       {
  struct TestPublic : ColdClass {};
  validateInheritedClass<TestPublic>();
}

TEST	(	ColdClassTest	,
		protectedInheritance
	)

Definition at line 48 of file ColdClassTest.cpp.

                                          {
  // Same again, but protected inheritance. Should make no difference.
  class TestProtected : protected ColdClass {};
  validateInheritedClass<TestProtected>();
}

TEST	(	ColdClassTest	,
		privateInheritance
	)

Definition at line 54 of file ColdClassTest.cpp.

                                        {
  // Same again, but private inheritance. Should make no difference.
  class TestPrivate : ColdClass {};
  validateInheritedClass<TestPrivate>();
}

template<class TestClass >

static void validateInheritedClass ( )

static

Definition at line 25 of file ColdClassTest.cpp.

References EXPECT_TRUE, and value.

                                     {
  // The only verifiable property of ColdClass is that it must not disrupt the
  // default constructor/destructor, default copy/move constructors and default
  // copy/move assignment operators when a class derives from it.
  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_move_constructible<TestClass>::value);
  EXPECT_TRUE(std::is_trivially_copy_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);
}