F14MapTest.cpp File Reference

#include <folly/container/F14Map.h>
#include <algorithm>
#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, typename > class TMap>
void	testCustomSwap ()
	TEST (F14Map, customSwap)
	TEST (F14Map, getAllocatedMemorySize)
template<typename M >
void	runVisitContiguousRangesTest (int n)
template<typename M >
void	runVisitContiguousRangesTest ()
	TEST (F14ValueMap, visitContiguousRanges)
	TEST (F14NodeMap, visitContiguousRanges)
	TEST (F14VectorMap, visitContiguousRanges)
	TEST (F14FastMap, visitContiguousRanges)

Function Documentation

template<typename M >

void runVisitContiguousRangesTest

(

int

n

)

Definition at line 132 of file F14MapTest.cpp.

References ASSERT_TRUE, b, EXPECT_FALSE, EXPECT_TRUE, i, M, and map().

                                         {
  M map;

  for (int i = 0; i < n; ++i) {
    map[i] = i;
    map.erase(i / 2);
  }

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

  map.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 M >

void runVisitContiguousRangesTest

(

)

Definition at line 161 of file F14MapTest.cpp.

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

TEST	(	F14Map	,
		customSwap
	)

Definition at line 46 of file F14MapTest.cpp.

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

                         {
  testCustomSwap<folly::F14ValueMap>();
  testCustomSwap<folly::F14NodeMap>();
  testCustomSwap<folly::F14VectorMap>();
  testCustomSwap<folly::F14FastMap>();
}

TEST	(	F14Map	,
		getAllocatedMemorySize
	)

Definition at line 121 of file F14MapTest.cpp.

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

TEST	(	F14ValueMap	,
		visitContiguousRanges
	)

Definition at line 167 of file F14MapTest.cpp.

                                         {
  runVisitContiguousRangesTest<folly::F14ValueMap<int, int>>();
}

TEST	(	F14NodeMap	,
		visitContiguousRanges
	)

Definition at line 171 of file F14MapTest.cpp.

                                        {
  runVisitContiguousRangesTest<folly::F14NodeMap<int, int>>();
}

TEST	(	F14VectorMap	,
		visitContiguousRanges
	)

Definition at line 175 of file F14MapTest.cpp.

                                          {
  runVisitContiguousRangesTest<folly::F14VectorMap<int, int>>();
}

TEST	(	F14FastMap	,
		visitContiguousRanges
	)

Definition at line 179 of file F14MapTest.cpp.

References folly::as_const(), b, folly::F14TableStats::compute(), dist, EXPECT_EQ, EXPECT_FALSE, EXPECT_GE, EXPECT_NE, EXPECT_THROW, EXPECT_TRUE, folly::gen::first, bm::free(), h, i, folly::INFO, k, folly::f14::limitTestAllocations(), m, M, map(), max, min, folly::gen::move, name, populate(), folly::f14::resetTracking(), s, simple, string, folly::f14::swap(), folly::pushmi::detail::t, folly::T, folly::TEST(), folly::f14::testAllocatedMemorySize, uint64_t, folly::f14::unlimitTestAllocations(), v, val, verify(), x, and folly::fibers::yield().

                                        {
  runVisitContiguousRangesTest<folly::F14FastMap<int, int>>();
}

template<template< typename, typename, typename, typename, typename > class TMap>

void testCustomSwap

(

)

Definition at line 29 of file F14MapTest.cpp.

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

                      {
  using std::swap;

  TMap<
      int,
      int,
      folly::f14::DefaultHasher<int>,
      folly::f14::DefaultKeyEqual<int>,
      folly::f14::SwapTrackingAlloc<std::pair<int const, 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}));
}