GenericFilterTest.cpp File Reference

#include <deque>
#include <folly/Memory.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <map>
#include <proxygen/lib/utils/FilterChain.h>
#include <stdlib.h>

Go to the source code of this file.

Classes
class	TesterInterface
class	TesterInterface::Callback
class	MockTester
class	MockTesterCallback
class	TestFilter< Owned >
class	TestFilterNoCallback< Owned >
class	TestFilterNoCall< Owned >
class	TestFilterNoCallbackNoCall< Owned >
class	GenericFilterTest< Owned >
class	TestFilterOddDeleteDo
class	TestFilterOddDeleteOn< Owned >

Namespaces
	detail

Typedefs
using	OwnedGenericFilterTest = GenericFilterTest< true >
using	UnownedGenericFilterTest = GenericFilterTest< false >

Functions
template<typename T >
T *	detail::get_pointer (const unique_ptr< T > &ptr)
template<typename T >
T *	detail::get_pointer (T *ptr)
template<bool Owned>
std::enable_if< Owned, unique_ptr< MockTester > >::type	getTester ()
template<bool Owned>
std::enable_if<!Owned, MockTester * >::type	getTester ()
	TEST_F (OwnedGenericFilterTest, EmptyChain)
	TEST_F (OwnedGenericFilterTest, SingleElemChain)
	TEST_F (OwnedGenericFilterTest, MultiElemChain)
	TEST_F (OwnedGenericFilterTest, MultiElemMultiAdd)
	TEST_F (OwnedGenericFilterTest, Wants)
	TEST_F (OwnedGenericFilterTest, WantsMultiAdd)
	TEST_F (OwnedGenericFilterTest, WantsMultiAddHard)
	TEST_F (OwnedGenericFilterTest, ChangeCallback)
	TEST_F (UnownedGenericFilterTest, All)
	TEST_F (OwnedGenericFilterTest, SetNullCb)
	TEST_F (UnownedGenericFilterTest, DeleteDo)
	TEST_F (UnownedGenericFilterTest, DeleteOn)
	TEST_F (OwnedGenericFilterTest, DeleteChain)
	TEST_F (OwnedGenericFilterTest, GetChainEnd)
	TEST_F (OwnedGenericFilterTest, SetDestination)
	TEST_F (OwnedGenericFilterTest, Foreach)

Typedef Documentation

using OwnedGenericFilterTest = GenericFilterTest<true>

Definition at line 241 of file GenericFilterTest.cpp.

using UnownedGenericFilterTest = GenericFilterTest<false>

Definition at line 242 of file GenericFilterTest.cpp.

Function Documentation

template<bool Owned>

std::enable_if<Owned, unique_ptr<MockTester> >::type getTester

(

)

Definition at line 122 of file GenericFilterTest.cpp.

                                                                     {
  return std::make_unique<MockTester>();
}

template<bool Owned>

std::enable_if<!Owned, MockTester*>::type getTester

(

)

Definition at line 127 of file GenericFilterTest.cpp.

                                                           {
  return new MockTester();
}

TEST_F	(	OwnedGenericFilterTest	,
		EmptyChain
	)

Definition at line 244 of file GenericFilterTest.cpp.

References folly::basicTest().

                                           {
  basicTest();
}

TEST_F	(	OwnedGenericFilterTest	,
		SingleElemChain
	)

Definition at line 248 of file GenericFilterTest.cpp.

References folly::basicTest(), EXPECT_EQ, folly::pushmi::operators::filter, and folly::gen::move.

                                                {
  auto filterUnique = std::make_unique<TestFilter<true>>();
  auto filter = filterUnique.get();
  chain().addFilters(std::move(filterUnique));
  EXPECT_EQ(filter->do_, 0);
  EXPECT_EQ(filter->on_, 0);
  basicTest();
  EXPECT_EQ(filter->do_, 1);
  EXPECT_EQ(filter->on_, 1);
}

TEST_F	(	OwnedGenericFilterTest	,
		MultiElemChain
	)

Definition at line 259 of file GenericFilterTest.cpp.

References folly::basicTest(), TestFilter< Owned >::do_, EXPECT_EQ, folly::gen::move, and TestFilter< Owned >::on_.

                                               {
  auto f1 = std::make_unique<TestFilter<true>>();
  auto f2 = std::make_unique<TestFilter<true>>();
  auto f3 = std::make_unique<TestFilter<true>>();
  TestFilter<true>* fp1 = f1.get();
  TestFilter<true>* fp2 = f2.get();
  TestFilter<true>* fp3 = f3.get();
  chain().addFilters(std::move(f1), std::move(f2), std::move(f3));
  basicTest();
  EXPECT_EQ(fp1->do_, 1);
  EXPECT_EQ(fp1->on_, 1);
  EXPECT_EQ(fp2->do_, 1);
  EXPECT_EQ(fp2->on_, 1);
  EXPECT_EQ(fp3->do_, 1);
  EXPECT_EQ(fp3->on_, 1);
}

TEST_F	(	OwnedGenericFilterTest	,
		MultiElemMultiAdd
	)

Definition at line 276 of file GenericFilterTest.cpp.

References folly::basicTest(), EXPECT_EQ, folly::pushmi::operators::filter, i, and folly::gen::move.

                                                  {
  std::deque<TestFilter<true>*> filters;
  for (unsigned i = 0; i < 10; ++i) {
    auto filter = std::make_unique<TestFilter<true>>();
    filters.push_back(filter.get());
    chain().addFilters(std::move(filter));
  }
  basicTest();
  for (auto filter: filters) {
    EXPECT_EQ(filter->do_, 1);
    EXPECT_EQ(filter->on_, 1);
  }
}

TEST_F	(	OwnedGenericFilterTest	,
		Wants
	)

Definition at line 290 of file GenericFilterTest.cpp.

References folly::basicTest(), TestFilter< Owned >::do_, EXPECT_EQ, folly::gen::move, and TestFilter< Owned >::on_.

                                      {
  auto f1 = std::make_unique<TestFilter<true>>();
  auto f2 = std::make_unique<TestFilterNoCallback<true>>();
  auto f3 = std::make_unique<TestFilterNoCall<true>>();
  auto f4 = std::make_unique<TestFilterNoCallbackNoCall<true>>();
  TestFilter<true>* fp1 = f1.get();
  TestFilter<true>* fp2 = f2.get();
  TestFilter<true>* fp3 = f3.get();
  TestFilter<true>* fp4 = f4.get();
  chain().addFilters(std::move(f1), std::move(f2),
                    std::move(f3), std::move(f4));
  basicTest();
  EXPECT_EQ(fp1->do_, 1);
  EXPECT_EQ(fp1->on_, 1);
  // Only calls
  EXPECT_EQ(fp2->do_, 1);
  EXPECT_EQ(fp2->on_, 0);
  // Only callbacks
  EXPECT_EQ(fp3->do_, 0);
  EXPECT_EQ(fp3->on_, 1);
  // No callbacks or calls
  EXPECT_EQ(fp4->do_, 0);
  EXPECT_EQ(fp4->on_, 0);
}

TEST_F	(	OwnedGenericFilterTest	,
		WantsMultiAdd
	)

Definition at line 315 of file GenericFilterTest.cpp.

References folly::basicTest(), TestFilter< Owned >::do_, EXPECT_EQ, folly::gen::move, and TestFilter< Owned >::on_.

                                              {
  auto f1 = std::make_unique<TestFilterNoCallback<true>>();
  auto f2 = std::make_unique<TestFilterNoCall<true>>();
  TestFilter<true>* fp1 = f1.get();
  TestFilter<true>* fp2 = f2.get();
  chain().addFilters(std::move(f1));
  basicTest();

  EXPECT_EQ(fp1->do_, 1);
  EXPECT_EQ(fp1->on_, 0);
  EXPECT_EQ(fp2->do_, 0);
  EXPECT_EQ(fp2->on_, 0);

  chain().addFilters(std::move(f2));
  basicTest();

  EXPECT_EQ(fp1->do_, 2);
  EXPECT_EQ(fp1->on_, 0);
  EXPECT_EQ(fp2->do_, 0);
  EXPECT_EQ(fp2->on_, 1);
}

TEST_F	(	OwnedGenericFilterTest	,
		WantsMultiAddHard
	)

Definition at line 337 of file GenericFilterTest.cpp.

References EXPECT_EQ, f, and i.

                                                  {
  const unsigned NUM_FILTERS = 5000;
  auto filters = getRandomFilters(NUM_FILTERS);
  // Now check the counts on each filter. Filters are pushed to the front
  // of the chain, so filters towards the front have low call/callback counts
  for (unsigned i = 0; i < NUM_FILTERS; ++i) {
    auto f = filters[i];
    if (f->kWantsCalls_) {
      EXPECT_EQ(f->do_, i + 1);
    } else {
      EXPECT_EQ(f->do_, 0);
    }
    if (f->kWantsCallbacks_) {
      EXPECT_EQ(f->on_, i + 1);
    } else {
      EXPECT_EQ(f->on_, 0);
    }
  }
}

TEST_F	(	OwnedGenericFilterTest	,
		ChangeCallback
	)

Definition at line 357 of file GenericFilterTest.cpp.

References folly::basicTest(), TestFilter< Owned >::do_, EXPECT_CALL, EXPECT_EQ, f, folly::gen::move, and TestFilter< Owned >::on_.

                                               {
  // The call-only filter in the chain doesn't want callbacks, so doing
  // chain()->setCallback() is an error! Instead, must use chain().setCallback()
  auto f = std::make_unique<TestFilterNoCallback<true>>();
  MockTesterCallback callback2;

  TestFilter<true>* fp = f.get();
  chain().addFilters(std::move(f));
  basicTest();

  EXPECT_EQ(fp->do_, 1);
  EXPECT_EQ(fp->on_, 0);

  chain().setCallback(&callback2);
  EXPECT_EQ(actor_->cb_, &callback2);
  EXPECT_CALL(callback2, onA());
  actor_->cb_->onA();

  EXPECT_EQ(fp->on_, 0);
}

TEST_F	(	UnownedGenericFilterTest	,
		All
	)

Definition at line 378 of file GenericFilterTest.cpp.

References EXPECT_EQ, f, and i.

                                      {
  const unsigned NUM_FILTERS = 5000;
  auto filters = getRandomFilters(NUM_FILTERS);
  // Now check the counts on each filter
  unsigned i = 0;
  for (auto f: filters) {
    if (f->kWantsCalls_) {
      EXPECT_EQ(f->do_, i + 1);
    } else {
      EXPECT_EQ(f->do_, 0);
    }
    if (f->kWantsCallbacks_) {
      EXPECT_EQ(f->on_, i + 1);
    } else {
      EXPECT_EQ(f->on_, 0);
    }
    delete f;
    ++i;
  }
  delete actor_;
}

TEST_F	(	OwnedGenericFilterTest	,
		SetNullCb
	)

Definition at line 400 of file GenericFilterTest.cpp.

References ASSERT_EQ, and f.

                                          {
  // Some objects have a special behavior when the callback is set to
  // nullptr. So in this case, we need to make sure it propagates
  auto filters = getRandomFilters(100);
  chain().setCallback(nullptr);
  CHECK(nullptr == actor_->cb_);

  testFilters(filters, nullptr);

  MockTesterCallback head;
  chain().setCallback(&head);

  testFilters(filters, &head);

  TesterInterface::Callback* cb = &head;
  for (auto f: filters) {
    if (f->kWantsCallbacks_) {
      cb = f;
    }
  }
  // The actor's callback should be the last filter in the chain that
  // wants callbacks
  ASSERT_EQ(actor_->cb_, cb);
}

TEST_F	(	UnownedGenericFilterTest	,
		DeleteDo
	)

Definition at line 446 of file GenericFilterTest.cpp.

References folly::basicTest(), EXPECT_CALL, EXPECT_EQ, and i.

                                           {
  // Test where a filter in the middle of the chain deletes itself early
  int deletions = 0;

  for (unsigned i = 0; i < 4; ++i) {
    chain().addFilters(new TestFilterOddDeleteDo(&deletions));
  }

  for (unsigned i = 0; i < 2; ++i) {
    // First time around, the odd id's get deleted
    // Second time should just forward the calls normally
    EXPECT_CALL(*actor_, doA());
    chain()->doA();
    EXPECT_EQ(deletions, (i + 1) * 2);
  }
  basicTest();
  delete actor_;
}

TEST_F	(	UnownedGenericFilterTest	,
		DeleteOn
	)

Definition at line 485 of file GenericFilterTest.cpp.

References folly::basicTest(), callback_, EXPECT_CALL, EXPECT_EQ, and i.

                                           {
  // Test where a filter in the middle of the chain deletes itself early
  int deletions = 0;

  for (unsigned i = 0; i < 4; ++i) {
    chain().addFilters(new TestFilterOddDeleteOn<>(&deletions));
  }

  for (unsigned i = 0; i < 2; ++i) {
    // First time around, the odd id's get deleted
    // Second time should just forward the calls normally
    EXPECT_CALL(callback_, onA());
    actor_->cb_->onA();
    EXPECT_EQ(deletions, (i + 1) * 2);
  }
  basicTest();
  delete actor_;
}

TEST_F	(	OwnedGenericFilterTest	,
		DeleteChain
	)

Definition at line 504 of file GenericFilterTest.cpp.

References EXPECT_EQ, i, and folly::make_unique().

                                            {
  // Add some filters to the chain and reset the chain. Make sure all the
  // filters are deleted.
  const unsigned NUM_FILTERS = 1000;
  int deletions = 0;
  for (unsigned i = 0; i < NUM_FILTERS; ++i) {
    chain().addFilters(
      std::make_unique<TestFilterOddDeleteOn<true>>(&deletions));
  }
  chain_.reset();
  EXPECT_EQ(deletions, NUM_FILTERS);
}

TEST_F	(	OwnedGenericFilterTest	,
		GetChainEnd
	)

Definition at line 517 of file GenericFilterTest.cpp.

References EXPECT_EQ, and i.

                                            {
  for (unsigned i = 1; i < 100; ++i) {
    auto filters = getRandomFilters(i);
    EXPECT_EQ(actor_, &chain().getChainEnd());
  }
}

TEST_F	(	OwnedGenericFilterTest	,
		SetDestination
	)

Definition at line 524 of file GenericFilterTest.cpp.

References EXPECT_CALL, and folly::gen::move.

                                               {
  auto filters = getRandomFilters(20);
  EXPECT_CALL(*actor_, doA());
  chain()->doA();
  auto tester2 = getTester<true>();
  actor_ = tester2.get();
  auto oldTester = chain().setDestination(std::move(tester2));
  EXPECT_CALL(*actor_, doA());
  chain()->doA();
}

TEST_F	(	OwnedGenericFilterTest	,
		Foreach
	)

Definition at line 535 of file GenericFilterTest.cpp.

References count, EXPECT_EQ, folly::pushmi::operators::filter, and TesterInterface::setCallback().

                                        {
  auto filters = getRandomFilters(20);
  size_t count = 0;
  chain().foreach([&count] (GenericFilter<TesterInterface,
                            TesterInterface::Callback,
                            &TesterInterface::setCallback, true,
                            std::default_delete<TesterInterface> >* filter) {
                    if (dynamic_cast<TestFilter<true>*>(filter)) {
                      count++;
                    }
                  });
  EXPECT_EQ(count, 20);
}