ForeachTest.cpp File Reference

#include <folly/container/Foreach.h>
#include <array>
#include <initializer_list>
#include <iterator>
#include <list>
#include <map>
#include <string>
#include <tuple>
#include <vector>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	folly::test::TestRValueConstruct
class	folly::test::TestAdlIterable
class	folly::test::TestBothIndexingAndIter
class	folly::test::TestBothIndexingAndIter::Iterator

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——
	folly::test

Functions
auto	folly::test::begin (TestAdlIterable &instance)
auto	folly::test::begin (const TestAdlIterable &instance)
auto	folly::test::end (TestAdlIterable &instance)
auto	folly::test::end (const TestAdlIterable &instance)
	TEST (Foreach, ForEachFunctionBasic)
	TEST (Foreach, ForEachFunctionBasicRuntimeOneArg)
	TEST (Foreach, ForEachFunctionBasicRuntimeTwoArg)
	TEST (Foreach, ForEachFunctionBasicRuntimeThreeArg)
	TEST (Foreach, ForEachFunctionBasicTupleOneArg)
	TEST (Foreach, ForEachFunctionBasicTupleTwoArg)
	TEST (Foreach, ForEachFunctionBreakRuntimeOneArg)
	TEST (Foreach, ForEachFunctionBreakRuntimeTwoArg)
	TEST (Foreach, ForEachFunctionBreakRuntimeThreeArg)
	TEST (Foreach, ForEachFunctionBreakTupleOneArg)
	TEST (Foreach, ForEachFunctionBreakTupleTwoArg)
	TEST (Foreach, ForEachFunctionArray)
	TEST (Foreach, ForEachFunctionInitializerListBasic)
	TEST (Foreach, ForEachFunctionTestForward)
	TEST (Foreach, ForEachFunctionAdlIterable)
	TEST (ForEach, FetchRandomAccessIterator)
	TEST (ForEach, FetchIndexing)
	TEST (ForEach, FetchTuple)
	TEST (ForEach, FetchTestPreferIterator)
	TEST (Foreach, ForEachRvalue)
	TEST (Foreach, ForEachNested)
	TEST (Foreach, ForEachKV)
	TEST (Foreach, ForEachKVBreak)
	TEST (Foreach, ForEachKvWithMultiMap)
	TEST (Foreach, ForEachEnumerate)
	TEST (Foreach, ForEachEnumerateBreak)
	TEST (Foreach, ForEachRangeR)

Function Documentation

TEST	(	Foreach	,
		ForEachFunctionBasic
	)

Definition at line 104 of file ForeachTest.cpp.

References EXPECT_TRUE, folly::for_each(), std::tr1::make_tuple(), and folly::range().

                                    {
  auto range = std::make_tuple(1, 2, 3);
  auto result_range = std::vector<int>{};
  auto correct_result_range = std::vector<int>{1, 2, 3};

  folly::for_each(range, [&](auto ele) { result_range.push_back(ele); });

  EXPECT_TRUE(std::equal(
      result_range.begin(), result_range.end(), correct_result_range.begin()));
}

TEST	(	Foreach	,
		ForEachFunctionBasicRuntimeOneArg
	)

Definition at line 115 of file ForeachTest.cpp.

References current, EXPECT_EQ, folly::for_each(), and folly::range().

                                                 {
  auto range = std::vector<int>{1, 2, 3};
  auto current = 0;
  folly::for_each(range, [&](auto ele) {
    if (current == 0) {
      EXPECT_EQ(ele, 1);
    } else if (current == 1) {
      EXPECT_EQ(ele, 2);
    } else {
      EXPECT_EQ(ele, 3);
    }
    ++current;
  });
}

TEST	(	Foreach	,
		ForEachFunctionBasicRuntimeTwoArg
	)

Definition at line 130 of file ForeachTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::for_each(), and folly::range().

                                                 {
  auto range = std::vector<int>{1, 2, 3};
  folly::for_each(range, [](auto ele, auto index) {
    EXPECT_TRUE(index < 3);
    if (index == 0) {
      EXPECT_EQ(ele, 1);
    } else if (index == 1) {
      EXPECT_EQ(ele, 2);
    } else if (index == 2) {
      EXPECT_EQ(ele, 3);
    }
  });
}

TEST	(	Foreach	,
		ForEachFunctionBasicRuntimeThreeArg
	)

Definition at line 144 of file ForeachTest.cpp.

References EXPECT_TRUE, folly::for_each(), and folly::range().

                                                   {
  auto range = std::list<int>{1, 2, 3};
  auto result_range = std::list<int>{1, 3};
  folly::for_each(range, [&](auto ele, auto, auto iter) {
    if (ele == 2) {
      range.erase(iter);
    }
  });
  EXPECT_TRUE(std::equal(range.begin(), range.end(), result_range.begin()));
}

TEST	(	Foreach	,
		ForEachFunctionBasicTupleOneArg
	)

Definition at line 155 of file ForeachTest.cpp.

References current, EXPECT_EQ, folly::for_each(), std::tr1::make_tuple(), and folly::range().

                                               {
  auto range = std::make_tuple(1, 2, 3);
  auto current = 0;
  folly::for_each(range, [&](auto ele) {
    if (current == 0) {
      EXPECT_EQ(ele, 1);
    } else if (current == 1) {
      EXPECT_EQ(ele, 2);
    } else {
      EXPECT_EQ(ele, 3);
    }
    ++current;
  });
}

TEST	(	Foreach	,
		ForEachFunctionBasicTupleTwoArg
	)

Definition at line 170 of file ForeachTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::for_each(), std::tr1::make_tuple(), and folly::range().

                                               {
  auto range = std::make_tuple(1, 2, 3);
  folly::for_each(range, [](auto ele, auto index) {
    EXPECT_TRUE(index < 3);
    if (index == 0) {
      EXPECT_EQ(ele, 1);
    } else if (index == 1) {
      EXPECT_EQ(ele, 2);
    } else if (index == 2) {
      EXPECT_EQ(ele, 3);
    }
  });
}

TEST	(	Foreach	,
		ForEachFunctionBreakRuntimeOneArg
	)

Definition at line 184 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), folly::loop_break, folly::loop_continue, and folly::range().

                                                 {
  auto range = std::vector<int>{1, 2, 3};
  auto iterations = 0;
  folly::for_each(range, [&](auto) {
    ++iterations;
    if (iterations == 1) {
      return folly::loop_break;
    }
    return folly::loop_continue;
  });
  EXPECT_EQ(iterations, 1);
}

TEST	(	Foreach	,
		ForEachFunctionBreakRuntimeTwoArg
	)

Definition at line 197 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), folly::loop_break, folly::loop_continue, and folly::range().

                                                 {
  auto range = std::vector<int>{1, 2, 3};
  auto iterations = 0;
  folly::for_each(range, [&](auto, auto index) {
    ++iterations;
    if (index == 1) {
      return folly::loop_break;
    }
    return folly::loop_continue;
  });
  EXPECT_EQ(iterations, 2);
}

TEST	(	Foreach	,
		ForEachFunctionBreakRuntimeThreeArg
	)

Definition at line 210 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), folly::loop_break, folly::loop_continue, and folly::range().

                                                   {
  auto range = std::vector<int>{1, 2, 3};
  auto iterations = 0;
  folly::for_each(range, [&](auto, auto index, auto) {
    ++iterations;
    if (index == 1) {
      return folly::loop_break;
    }
    return folly::loop_continue;
  });
  EXPECT_EQ(iterations, 2);
}

TEST	(	Foreach	,
		ForEachFunctionBreakTupleOneArg
	)

Definition at line 223 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), folly::loop_break, folly::loop_continue, and folly::range().

                                               {
  auto range = std::vector<int>{1, 2, 3};
  auto iterations = 0;
  folly::for_each(range, [&](auto) {
    ++iterations;
    if (iterations == 1) {
      return folly::loop_break;
    }
    return folly::loop_continue;
  });
  EXPECT_EQ(iterations, 1);
}

TEST	(	Foreach	,
		ForEachFunctionBreakTupleTwoArg
	)

Definition at line 236 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), folly::loop_break, folly::loop_continue, and folly::range().

                                               {
  auto range = std::vector<int>{1, 2, 3};
  auto iterations = 0;
  folly::for_each(range, [&](auto, auto index) {
    ++iterations;
    if (index == 1) {
      return folly::loop_break;
    }
    return folly::loop_continue;
  });
  EXPECT_EQ(iterations, 2);
}

TEST	(	Foreach	,
		ForEachFunctionArray
	)

Definition at line 249 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), folly::loop_break, folly::loop_continue, and folly::range().

                                    {
  auto range = std::array<int, 3>{{1, 2, 3}};
  auto iterations = 0;
  folly::for_each(range, [&](auto, auto index) {
    ++iterations;
    if (index == 1) {
      return folly::loop_break;
    }
    return folly::loop_continue;
  });
  EXPECT_EQ(iterations, 2);
}

TEST	(	Foreach	,
		ForEachFunctionInitializerListBasic
	)

Definition at line 262 of file ForeachTest.cpp.

References folly::for_each().

                                                   {
  folly::for_each(std::initializer_list<int>{1, 2, 3}, [](auto ele) { ++ele; });
}

TEST	(	Foreach	,
		ForEachFunctionTestForward
	)

Definition at line 266 of file ForeachTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, folly::for_each(), std::tr1::make_tuple(), and folly::gen::move.

                                          {
  using folly::test::TestRValueConstruct;
  auto range_one = std::vector<TestRValueConstruct>{};
  range_one.resize(3);

  folly::for_each(std::move(range_one), [](auto ele) {
    EXPECT_FALSE(ele.constructed_from_rvalue);
  });

  folly::for_each(
      std::make_tuple(TestRValueConstruct{}, TestRValueConstruct{}),
      [](auto ele) { EXPECT_TRUE(ele.constructed_from_rvalue); });
}

TEST	(	Foreach	,
		ForEachFunctionAdlIterable
	)

Definition at line 280 of file ForeachTest.cpp.

References EXPECT_EQ, folly::for_each(), and folly::range().

                                          {
  auto range = test::TestAdlIterable{};
  auto iterations = 0;
  folly::for_each(range, [&](auto ele, auto index) {
    ++iterations;
    EXPECT_EQ(ele, index);
  });
  EXPECT_EQ(iterations, 4);
}

TEST	(	ForEach	,
		FetchRandomAccessIterator
	)

Definition at line 290 of file ForeachTest.cpp.

References EXPECT_EQ, and folly::fetch().

                                         {
  auto vec = std::vector<int>{1, 2, 3};
  auto& second = folly::fetch(vec, 1);
  EXPECT_EQ(second, 2);
  second = 3;
  EXPECT_EQ(second, 3);
}

TEST	(	ForEach	,
		FetchIndexing
	)

Definition at line 298 of file ForeachTest.cpp.

References EXPECT_EQ, and folly::fetch().

                             {
  auto mp = std::map<int, int>{{1, 2}};
  auto& ele = folly::fetch(mp, 1);
  EXPECT_EQ(ele, 2);
  ele = 3;
  EXPECT_EQ(ele, 3);
}

TEST	(	ForEach	,
		FetchTuple
	)

Definition at line 306 of file ForeachTest.cpp.

References EXPECT_EQ, folly::fetch(), and std::tr1::make_tuple().

                          {
  auto mp = std::make_tuple(1, 2, 3);
  auto& ele = folly::fetch(mp, std::integral_constant<int, 1>{});
  EXPECT_EQ(ele, 2);
  ele = 3;
  EXPECT_EQ(ele, 3);
}

TEST	(	ForEach	,
		FetchTestPreferIterator
	)

Definition at line 314 of file ForeachTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::fetch(), and folly::range().

                                       {
  auto range = test::TestBothIndexingAndIter{};
  auto& ele = folly::fetch(range, 0);
  EXPECT_TRUE(range.called_begin);
  EXPECT_EQ(ele, 0);
  ele = 2;
  EXPECT_EQ(folly::fetch(range, 0), 2);
}

TEST	(	Foreach	,
		ForEachRvalue
	)

Definition at line 323 of file ForeachTest.cpp.

References EXPECT_EQ, FOR_EACH, FOR_EACH_R, and string.

                             {
  const char* const hello = "hello";
  int n = 0;
  FOR_EACH (it, std::string(hello)) { ++n; }
  EXPECT_EQ(strlen(hello), n);
  FOR_EACH_R (it, std::string(hello)) {
    --n;
    EXPECT_EQ(hello[n], *it);
  }
  EXPECT_EQ(0, n);
}

TEST	(	Foreach	,
		ForEachNested
	)

Definition at line 335 of file ForeachTest.cpp.

References EXPECT_EQ, FOR_EACH, i, and string.

                             {
  const std::string hello = "hello";
  size_t n = 0;
  FOR_EACH (i, hello) {
    FOR_EACH (j, hello) { ++n; }
  }
  auto len = hello.size();
  EXPECT_EQ(len * len, n);
}

TEST	(	Foreach	,
		ForEachKV
	)

Definition at line 345 of file ForeachTest.cpp.

References EXPECT_EQ, FOR_EACH_KV, string, testMap(), folly::value(), and values().

                         {
  std::map<std::string, int> testMap;
  testMap["abc"] = 1;
  testMap["def"] = 2;
  std::string keys = "";
  int values = 0;
  int numEntries = 0;
  FOR_EACH_KV (key, value, testMap) {
    keys += key;
    values += value;
    ++numEntries;
  }
  EXPECT_EQ("abcdef", keys);
  EXPECT_EQ(3, values);
  EXPECT_EQ(2, numEntries);
}

TEST	(	Foreach	,
		ForEachKVBreak
	)

Definition at line 362 of file ForeachTest.cpp.

References EXPECT_EQ, FOR_EACH_KV, string, testMap(), folly::value(), and values().

                              {
  std::map<std::string, int> testMap;
  testMap["abc"] = 1;
  testMap["def"] = 2;
  std::string keys = "";
  int values = 0;
  int numEntries = 0;
  FOR_EACH_KV (key, value, testMap) {
    keys += key;
    values += value;
    ++numEntries;
    break;
  }
  EXPECT_EQ("abc", keys);
  EXPECT_EQ(1, values);
  EXPECT_EQ(1, numEntries);
}

TEST	(	Foreach	,
		ForEachKvWithMultiMap
	)

Definition at line 380 of file ForeachTest.cpp.

References EXPECT_EQ, FOR_EACH_KV, string, testMap(), folly::value(), and values().

                                     {
  std::multimap<std::string, int> testMap;
  testMap.insert(std::make_pair("abc", 1));
  testMap.insert(std::make_pair("abc", 2));
  testMap.insert(std::make_pair("def", 3));
  std::string keys = "";
  int values = 0;
  int numEntries = 0;
  FOR_EACH_KV (key, value, testMap) {
    keys += key;
    values += value;
    ++numEntries;
  }
  EXPECT_EQ("abcabcdef", keys);
  EXPECT_EQ(6, values);
  EXPECT_EQ(3, numEntries);
}

TEST	(	Foreach	,
		ForEachEnumerate
	)

Definition at line 398 of file ForeachTest.cpp.

References EXPECT_EQ, and FOR_EACH_ENUMERATE.

                                {
  std::vector<int> vv;
  int sumAA = 0;
  int sumIter = 0;
  int numIterations = 0;
  FOR_EACH_ENUMERATE (aa, iter, vv) {
    sumAA += aa;
    sumIter += *iter;
    ++numIterations;
  }
  EXPECT_EQ(sumAA, 0);
  EXPECT_EQ(sumIter, 0);
  EXPECT_EQ(numIterations, 0);

  vv.push_back(1);
  vv.push_back(3);
  vv.push_back(5);
  FOR_EACH_ENUMERATE (aa, iter, vv) {
    sumAA += aa;
    sumIter += *iter;
    ++numIterations;
  }
  EXPECT_EQ(sumAA, 3); // 0 + 1 + 2
  EXPECT_EQ(sumIter, 9); // 1 + 3 + 5
  EXPECT_EQ(numIterations, 3);
}

TEST	(	Foreach	,
		ForEachEnumerateBreak
	)

Definition at line 425 of file ForeachTest.cpp.

References EXPECT_EQ, and FOR_EACH_ENUMERATE.

                                     {
  std::vector<int> vv;
  int sumAA = 0;
  int sumIter = 0;
  int numIterations = 0;
  vv.push_back(1);
  vv.push_back(2);
  vv.push_back(4);
  vv.push_back(8);
  FOR_EACH_ENUMERATE (aa, iter, vv) {
    sumAA += aa;
    sumIter += *iter;
    ++numIterations;
    if (aa == 1) {
      break;
    }
  }
  EXPECT_EQ(sumAA, 1); // 0 + 1
  EXPECT_EQ(sumIter, 3); // 1 + 2
  EXPECT_EQ(numIterations, 2);
}

TEST	(	Foreach	,
		ForEachRangeR
	)

Definition at line 447 of file ForeachTest.cpp.

References EXPECT_EQ, FOR_EACH_RANGE_R, i, and sum().

                             {
  int sum = 0;

  FOR_EACH_RANGE_R (i, 0, 0) { sum += i; }
  EXPECT_EQ(0, sum);

  FOR_EACH_RANGE_R (i, 0, -1) { sum += i; }
  EXPECT_EQ(0, sum);

  FOR_EACH_RANGE_R (i, 0, 5) { sum += i; }
  EXPECT_EQ(10, sum);

  std::list<int> lst = {0, 1, 2, 3, 4};
  sum = 0;
  FOR_EACH_RANGE_R (i, lst.begin(), lst.end()) { sum += *i; }
  EXPECT_EQ(10, sum);
}