ParallelMapTest.cpp File Reference

#include <vector>
#include <glog/logging.h>
#include <folly/Memory.h>
#include <folly/gen/Base.h>
#include <folly/gen/ParallelMap.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (Pmap, InfiniteEquivalent)
	TEST (Pmap, Empty)
	TEST (Pmap, Rvalues)
int	main (int argc, char *argv[])

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 157 of file ParallelMapTest.cpp.

References testing::InitGoogleTest(), and RUN_ALL_TESTS().

                                 {
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  return RUN_ALL_TESTS();
}

TEST	(	Pmap	,
		InfiniteEquivalent
	)

Definition at line 29 of file ParallelMapTest.cpp.

References folly::gen::as(), EXPECT_EQ, folly::gen::map(), folly::gen::pmap(), folly::gen::seq(), folly::gen::until(), and x.

                               {
  // apply
  {
    // clang-format off
    auto mapResult
      = seq(1)
      | map([](int x) { return x * x; })
      | until([](int x) { return x > 1000 * 1000; })
      | as<std::vector<int>>();

    auto pmapResult
      = seq(1)
      | pmap([](int x) { return x * x; }, 4)
      | until([](int x) { return x > 1000 * 1000; })
      | as<std::vector<int>>();
    // clang-format on

    EXPECT_EQ(pmapResult, mapResult);
  }

  // foreach
  {
    // clang-format off
    auto mapResult
      = seq(1, 10)
      | map([](int x) { return x * x; })
      | as<std::vector<int>>();

    auto pmapResult
      = seq(1, 10)
      | pmap([](int x) { return x * x; }, 4)
      | as<std::vector<int>>();
    // clang-format on

    EXPECT_EQ(pmapResult, mapResult);
  }
}

TEST	(	Pmap	,
		Empty
	)

Definition at line 67 of file ParallelMapTest.cpp.

References folly::gen::as(), EXPECT_EQ, folly::gen::map(), folly::gen::pmap(), folly::gen::seq(), folly::gen::until(), and x.

                  {
  // apply
  {
    // clang-format off
    auto mapResult
      = seq(1)
      | map([](int x) { return x * x; })
      | until([](int) { return true; })
      | as<std::vector<int>>();

    auto pmapResult
      = seq(1)
      | pmap([](int x) { return x * x; }, 4)
      | until([](int) { return true; })
      | as<std::vector<int>>();
    // clang-format on

    EXPECT_EQ(mapResult.size(), 0);
    EXPECT_EQ(pmapResult, mapResult);
  }

  // foreach
  {
    // clang-format off
    auto mapResult
      = empty<int>()
      | map([](int x) { return x * x; })
      | as<std::vector<int>>();

    auto pmapResult
      = empty<int>()
      | pmap([](int x) { return x * x; }, 4)
      | as<std::vector<int>>();
    // clang-format on

    EXPECT_EQ(mapResult.size(), 0);
    EXPECT_EQ(pmapResult, mapResult);
  }
}

TEST	(	Pmap	,
		Rvalues
	)

Definition at line 107 of file ParallelMapTest.cpp.

References EXPECT_EQ, folly::gen::map(), folly::gen::pmap(), folly::gen::seq(), folly::gen::sum, folly::gen::take(), and x.

                    {
  // apply
  {
    // clang-format off
    auto mapResult
        = seq(1)
        | map([](int x) { return std::make_unique<int>(x); })
        | map([](std::unique_ptr<int> x) {
            return std::make_unique<int>(*x * *x); })
        | map([](std::unique_ptr<int> x) { return *x; })
        | take(1000)
        | sum;

    auto pmapResult
        = seq(1)
        | pmap([](int x) { return std::make_unique<int>(x); })
        | pmap([](std::unique_ptr<int> x) {
            return std::make_unique<int>(*x * *x); })
        | pmap([](std::unique_ptr<int> x) { return *x; })
        | take(1000)
        | sum;
    // clang-format on

    EXPECT_EQ(pmapResult, mapResult);
  }

  // foreach
  {
    // clang-format off
    auto mapResult
        = seq(1, 1000)
        | map([](int x) { return std::make_unique<int>(x); })
        | map([](std::unique_ptr<int> x) {
            return std::make_unique<int>(*x * *x); })
        | map([](std::unique_ptr<int> x) { return *x; })
        | sum;

    auto pmapResult
        = seq(1, 1000)
        | pmap([](int x) { return std::make_unique<int>(x); })
        | pmap([](std::unique_ptr<int> x) {
            return std::make_unique<int>(*x * *x); })
        | pmap([](std::unique_ptr<int> x) { return *x; })
        | sum;
    // clang-format on

    EXPECT_EQ(pmapResult, mapResult);
  }
}