F14SetTest.cpp File Reference

#include <folly/container/F14Set.h>
#include <unordered_map>
#include <folly/Conv.h>
#include <folly/FBString.h>
#include <folly/container/test/F14TestUtil.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
template<template< typename, typename, typename, typename > class TSet>
void	testCustomSwap ()
	TEST (F14Set, customSwap)
	TEST (F14Set, getAllocatedMemorySize)
template<typename S >
void	runVisitContiguousRangesTest (int n)
template<typename S >
void	runVisitContiguousRangesTest ()
	TEST (F14ValueSet, visitContiguousRanges)
	TEST (F14NodeSet, visitContiguousRanges)
	TEST (F14VectorSet, visitContiguousRanges)
	TEST (F14FastSet, visitContiguousRanges)

Function Documentation

template<typename S >

void runVisitContiguousRangesTest

(

int

n

)

Definition at line 127 of file F14SetTest.cpp.

References ASSERT_TRUE, b, EXPECT_FALSE, EXPECT_TRUE, and i.

                                         {
  S set;

  for (int i = 0; i < n; ++i) {
    set.insert(i);
    set.erase(i / 2);
  }

  std::unordered_map<uintptr_t, bool> visited;
  for (auto& entry : set) {
    visited[reinterpret_cast<uintptr_t>(&entry)] = false;
  }

  set.visitContiguousRanges([&](auto b, auto e) {
    for (auto i = b; i != e; ++i) {
      auto iter = visited.find(reinterpret_cast<uintptr_t>(i));
      ASSERT_TRUE(iter != visited.end());
      EXPECT_FALSE(iter->second);
      iter->second = true;
    }
  });

  // ensure no entries were skipped
  for (auto& e : visited) {
    EXPECT_TRUE(e.second);
  }
}

template<typename S >

void runVisitContiguousRangesTest

(

)

Definition at line 156 of file F14SetTest.cpp.

                                    {
  runVisitContiguousRangesTest<S>(0); // empty
  runVisitContiguousRangesTest<S>(5); // single chunk
  runVisitContiguousRangesTest<S>(1000); // many chunks
}

TEST	(	F14Set	,
		customSwap
	)

Definition at line 43 of file F14SetTest.cpp.

References count, EXPECT_EQ, EXPECT_GE, EXPECT_GT, folly::f14::detail::getF14IntrinsicsMode(), i, folly::f14::detail::None, folly::f14::resetTracking(), s, folly::size(), folly::f14::testAllocatedBlockCount, and folly::f14::testAllocatedMemorySize.

                         {
  testCustomSwap<folly::F14ValueSet>();
  testCustomSwap<folly::F14NodeSet>();
  testCustomSwap<folly::F14VectorSet>();
  testCustomSwap<folly::F14FastSet>();
}

TEST	(	F14Set	,
		getAllocatedMemorySize
	)

Definition at line 117 of file F14SetTest.cpp.

                                     {
  runAllocatedMemorySizeTests<bool>();
  runAllocatedMemorySizeTests<int>();
  runAllocatedMemorySizeTests<long>();
  runAllocatedMemorySizeTests<double>();
  runAllocatedMemorySizeTests<std::string>();
  runAllocatedMemorySizeTests<folly::fbstring>();
}

TEST	(	F14ValueSet	,
		visitContiguousRanges
	)

Definition at line 162 of file F14SetTest.cpp.

                                         {
  runVisitContiguousRangesTest<folly::F14ValueSet<int>>();
}

TEST	(	F14NodeSet	,
		visitContiguousRanges
	)

Definition at line 166 of file F14SetTest.cpp.

                                        {
  runVisitContiguousRangesTest<folly::F14NodeSet<int>>();
}

TEST	(	F14VectorSet	,
		visitContiguousRanges
	)

Definition at line 170 of file F14SetTest.cpp.

                                          {
  runVisitContiguousRangesTest<folly::F14VectorSet<int>>();
}

TEST	(	F14FastSet	,
		visitContiguousRanges
	)

Definition at line 174 of file F14SetTest.cpp.

References folly::F14TableStats::compute(), EXPECT_EQ, EXPECT_FALSE, EXPECT_GT, EXPECT_NE, EXPECT_TRUE, h, i, k, folly::gen::move, populate(), s, simple, string, folly::f14::swap(), folly::pushmi::detail::t, folly::T, folly::TEST(), uint64_t, val, and verify().

                                        {
  runVisitContiguousRangesTest<folly::F14FastSet<int>>();
}

template<template< typename, typename, typename, typename > class TSet>

void testCustomSwap

(

)

Definition at line 27 of file F14SetTest.cpp.

References dist, EXPECT_EQ, folly::f14::resetTracking(), and folly::f14::swap().

                      {
  using std::swap;

  TSet<
      int,
      folly::f14::DefaultHasher<int>,
      folly::f14::DefaultKeyEqual<int>,
      folly::f14::SwapTrackingAlloc<int>>
      m0, m1;
  folly::f14::resetTracking();
  swap(m0, m1);

  EXPECT_EQ(
      0, folly::f14::Tracked<0>::counts.dist(folly::f14::Counts{0, 0, 0, 0}));
}