TraitsTest.cpp File Reference

#include <folly/Traits.h>
#include <cstring>
#include <string>
#include <type_traits>
#include <utility>
#include <folly/ScopeGuard.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	T1
struct	T2
struct	T3
struct	T5
struct	F1
struct	F2
struct	F3
struct	F4
struct	folly::IsRelocatable< T1 >

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——

Functions
	TEST (Traits, has_member_type)
template<>
	folly::FOLLY_ASSUME_RELOCATABLE (T2)
	TEST (Traits, scalars)
	TEST (Traits, containers)
	TEST (Traits, original)
	TEST (Traits, typedefd)
	TEST (Traits, unset)
	TEST (Traits, bitAndInit)
	TEST (Trait, logicOperators)
	TEST (Traits, is_negative)
	TEST (Traits, relational)
template<typename T , typename... Args>
void	testIsRelocatable (Args &&...args)
	TEST (Traits, actuallyRelocatable)
	TEST (Traits, void_t)
	TEST (Traits, type_t)
	TEST (Traits, remove_cvref)
	TEST (Traits, like)

Function Documentation

TEST	(	Traits	,
		has_member_type
	)

Definition at line 35 of file TraitsTest.cpp.

References EXPECT_TRUE, and folly::value().

                              {
  struct membership_no {};
  struct membership_yes {
    using x = void;
  };

  EXPECT_TRUE((is_same<false_type, has_member_type_x<membership_no>>::value));
  EXPECT_TRUE((is_same<true_type, has_member_type_x<membership_yes>>::value));
}

TEST	(	Traits	,
		scalars
	)

Definition at line 71 of file TraitsTest.cpp.

References EXPECT_TRUE.

                      {
  EXPECT_TRUE(IsRelocatable<int>::value);
  EXPECT_TRUE(IsRelocatable<bool>::value);
  EXPECT_TRUE(IsRelocatable<double>::value);
  EXPECT_TRUE(IsRelocatable<void*>::value);
}

TEST	(	Traits	,
		containers
	)

Definition at line 78 of file TraitsTest.cpp.

References EXPECT_TRUE, and folly::value().

                         {
  EXPECT_TRUE(IsRelocatable<vector<F1>>::value);
  EXPECT_TRUE((IsRelocatable<pair<F1, F1>>::value));
  EXPECT_TRUE((IsRelocatable<pair<T1, T2>>::value));
}

TEST	(	Traits	,
		original
	)

Definition at line 84 of file TraitsTest.cpp.

References EXPECT_TRUE.

                       {
  EXPECT_TRUE(IsRelocatable<T1>::value);
  EXPECT_TRUE(IsRelocatable<T2>::value);
}

TEST	(	Traits	,
		typedefd
	)

Definition at line 89 of file TraitsTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                       {
  EXPECT_TRUE(IsRelocatable<T3>::value);
  EXPECT_TRUE(IsRelocatable<T5>::value);
  EXPECT_FALSE(IsRelocatable<F2>::value);
  EXPECT_FALSE(IsRelocatable<F3>::value);
}

TEST	(	Traits	,
		unset
	)

Definition at line 96 of file TraitsTest.cpp.

References EXPECT_TRUE.

                    {
  EXPECT_TRUE(IsRelocatable<F1>::value);
  EXPECT_TRUE(IsRelocatable<F4>::value);
}

TEST	(	Traits	,
		bitAndInit
	)

Definition at line 101 of file TraitsTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::value().

                         {
  EXPECT_TRUE(IsZeroInitializable<int>::value);
  EXPECT_FALSE(IsZeroInitializable<vector<int>>::value);
}

TEST	(	Trait	,
		logicOperators
	)

Definition at line 106 of file TraitsTest.cpp.

References folly::value().

                            {
  static_assert(Conjunction<true_type>::value, "");
  static_assert(!Conjunction<false_type>::value, "");
  static_assert(is_same<Conjunction<true_type>::type, true_type>::value, "");
  static_assert(is_same<Conjunction<false_type>::type, false_type>::value, "");
  static_assert(Conjunction<true_type, true_type>::value, "");
  static_assert(!Conjunction<true_type, false_type>::value, "");

  static_assert(Disjunction<true_type>::value, "");
  static_assert(!Disjunction<false_type>::value, "");
  static_assert(is_same<Disjunction<true_type>::type, true_type>::value, "");
  static_assert(is_same<Disjunction<false_type>::type, false_type>::value, "");
  static_assert(Disjunction<true_type, true_type>::value, "");
  static_assert(Disjunction<true_type, false_type>::value, "");

  static_assert(!Negation<true_type>::value, "");
  static_assert(Negation<false_type>::value, "");
}

TEST	(	Traits	,
		is_negative
	)

Definition at line 125 of file TraitsTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, folly::is_negative(), and folly::is_non_positive().

                          {
  EXPECT_TRUE(folly::is_negative(-1));
  EXPECT_FALSE(folly::is_negative(0));
  EXPECT_FALSE(folly::is_negative(1));
  EXPECT_FALSE(folly::is_negative(0u));
  EXPECT_FALSE(folly::is_negative(1u));

  EXPECT_TRUE(folly::is_non_positive(-1));
  EXPECT_TRUE(folly::is_non_positive(0));
  EXPECT_FALSE(folly::is_non_positive(1));
  EXPECT_TRUE(folly::is_non_positive(0u));
  EXPECT_FALSE(folly::is_non_positive(1u));
}

TEST	(	Traits	,
		relational
	)

Definition at line 139 of file TraitsTest.cpp.

References testing::Args(), EXPECT_FALSE, EXPECT_TRUE, folly::T, folly::TEST(), type, value, and folly::value().

                         {
  // We test, especially, the edge cases to make sure we don't
  // trip -Wtautological-comparisons

  EXPECT_FALSE((folly::less_than<uint8_t, 0u, uint8_t>(0u)));
  EXPECT_FALSE((folly::less_than<uint8_t, 0u, uint8_t>(254u)));
  EXPECT_FALSE((folly::less_than<uint8_t, 255u, uint8_t>(255u)));
  EXPECT_TRUE((folly::less_than<uint8_t, 255u, uint8_t>(254u)));

  EXPECT_FALSE((folly::greater_than<uint8_t, 0u, uint8_t>(0u)));
  EXPECT_TRUE((folly::greater_than<uint8_t, 0u, uint8_t>(254u)));
  EXPECT_FALSE((folly::greater_than<uint8_t, 255u, uint8_t>(255u)));
  EXPECT_FALSE((folly::greater_than<uint8_t, 255u, uint8_t>(254u)));
}

TEST	(	Traits	,
		actuallyRelocatable
	)

Definition at line 217 of file TraitsTest.cpp.

References testing::Args(), string, and folly::T.

                                  {
  // Ensure that we test stack and heap allocation for strings with in-situ
  // capacity
  testIsRelocatable<std::string>("1");
  testIsRelocatable<std::string>(sizeof(std::string) + 1, 'x');

  testIsRelocatable<std::vector<char>>(5, 'g');
}

TEST	(	Traits	,
		void_t
	)

Definition at line 246 of file TraitsTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, value, and folly::value().

                     {
  EXPECT_TRUE((::std::is_same<folly::void_t<>, void>::value));
  EXPECT_TRUE((::std::is_same<folly::void_t<int>, void>::value));
  EXPECT_TRUE((::std::is_same<folly::void_t<int, short>, void>::value));
  EXPECT_TRUE(
      (::std::is_same<folly::void_t<int, short, std::string>, void>::value));
  EXPECT_TRUE((::has_value_type<std::string>::value));
  EXPECT_FALSE((::has_value_type<int>::value));
}

TEST	(	Traits	,
		type_t
	)

Definition at line 256 of file TraitsTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, string, and folly::value().

                     {
  EXPECT_TRUE((::std::is_same<folly::type_t<float>, float>::value));
  EXPECT_TRUE((::std::is_same<folly::type_t<float, int>, float>::value));
  EXPECT_TRUE((::std::is_same<folly::type_t<float, int, short>, float>::value));
  EXPECT_TRUE(
      (::std::is_same<folly::type_t<float, int, short, std::string>, float>::
           value));
  EXPECT_TRUE((
      ::std::is_constructible<::container<std::string>, some_tag, std::string>::
          value));
  EXPECT_FALSE(
      (::std::is_constructible<::container<std::string>, some_tag, float>::
           value));
}

TEST	(	Traits	,
		remove_cvref
	)

Definition at line 271 of file TraitsTest.cpp.

References EXPECT_TRUE, and folly::value().

                           {
  using folly::remove_cvref;
  using folly::remove_cvref_t;

  // test all possible c-ref qualifiers without volatile
  EXPECT_TRUE((std::is_same<remove_cvref_t<int>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int&&>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int&&>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int&>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int&>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int const>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int const>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int const&>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int const&>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int const&&>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int const&&>::type, int>::value));

  // test all possible c-ref qualifiers with volatile
  EXPECT_TRUE((std::is_same<remove_cvref_t<int volatile>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int volatile>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int volatile&&>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int volatile&&>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int volatile&>, int>::value));
  EXPECT_TRUE((std::is_same<remove_cvref<int volatile&>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int volatile const>, int>::value));
  EXPECT_TRUE(
      (std::is_same<remove_cvref<int volatile const>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int volatile const&>, int>::value));
  EXPECT_TRUE(
      (std::is_same<remove_cvref<int volatile const&>::type, int>::value));

  EXPECT_TRUE((std::is_same<remove_cvref_t<int volatile const&&>, int>::value));
  EXPECT_TRUE(
      (std::is_same<remove_cvref<int volatile const&&>::type, int>::value));
}

TEST	(	Traits	,
		like
	)

Definition at line 317 of file TraitsTest.cpp.

References EXPECT_TRUE, and folly::value().

                   {
  EXPECT_TRUE((std::is_same<like_t<int, char>, char>::value));
  EXPECT_TRUE((std::is_same<like_t<int const, char>, char const>::value));
  EXPECT_TRUE((std::is_same<like_t<int volatile, char>, char volatile>::value));
  EXPECT_TRUE(
      (std::is_same<like_t<int const volatile, char>, char const volatile>::
           value));
  EXPECT_TRUE((std::is_same<like_t<int&, char>, char&>::value));
  EXPECT_TRUE((std::is_same<like_t<int const&, char>, char const&>::value));
  EXPECT_TRUE(
      (std::is_same<like_t<int volatile&, char>, char volatile&>::value));
  EXPECT_TRUE(
      (std::is_same<like_t<int const volatile&, char>, char const volatile&>::
           value));
  EXPECT_TRUE((std::is_same<like_t<int&&, char>, char&&>::value));
  EXPECT_TRUE((std::is_same<like_t<int const&&, char>, char const&&>::value));
  EXPECT_TRUE(
      (std::is_same<like_t<int volatile&&, char>, char volatile&&>::value));
  EXPECT_TRUE(
      (std::is_same<like_t<int const volatile&&, char>, char const volatile&&>::
           value));
}

template<typename T , typename... Args>

void testIsRelocatable

(

Args &&...

args

)

Definition at line 185 of file TraitsTest.cpp.

References EXPECT_EQ, folly::gen::move, SCOPE_EXIT, and folly::T.

                                       {
  if (!IsRelocatable<T>::value) {
    return;
  }

  // We use placement new on zeroed memory to avoid garbage subsections
  char vsrc[sizeof(T)] = {0};
  char vdst[sizeof(T)] = {0};
  char vcpy[sizeof(T)];

  T* src = new (vsrc) T(std::forward<Args>(args)...);
  SCOPE_EXIT {
    src->~T();
  };
  std::memcpy(vcpy, vsrc, sizeof(T));
  T deep(*src);
  T* dst = new (vdst) T(std::move(*src));
  SCOPE_EXIT {
    dst->~T();
  };

  EXPECT_EQ(deep, *dst);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
  EXPECT_EQ(deep, *reinterpret_cast<T*>(vcpy));
#pragma GCC diagnostic pop

  // This test could technically fail; however, this is what relocation
  // almost always means, so it's a good test to have
  EXPECT_EQ(std::memcmp(vcpy, vdst, sizeof(T)), 0);
}