QueueTest Class Reference

Inheritance diagram for QueueTest:

Public Member Functions
	QueueTest (uint32_t maxSize, IntQueue::FdType type)
void	sendOne ()
void	putMessages ()
void	multiConsumer ()
void	maxQueueSize ()
void	maxReadAtOnce ()
void	destroyCallback ()
void	useAfterFork ()
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()
virtual	~Test ()

Public Attributes
IntQueue	queue
IntQueue	terminationQueue

Protected Member Functions
virtual void	SetUp ()
void	MapTester (const Queue< int > *q)
virtual void	SetUp ()
virtual void	SetUp ()
void	MapTester (const Queue< int > *q)
virtual void	SetUp ()
virtual void	SetUp ()
void	MapTester (const Queue< int > *q)
virtual void	SetUp ()
Protected Member Functions inherited from QuickTest
virtual void	TearDown ()
virtual void	TearDown ()
virtual void	TearDown ()
Protected Member Functions inherited from testing::Test
	Test ()
	Test ()
	Test ()

Static Protected Member Functions
static int	Double (int n)
static int	Double (int n)
static int	Double (int n)

Protected Attributes
Queue< int >	q0_
Queue< int >	q1_
Queue< int >	q2_
Protected Attributes inherited from QuickTest
time_t	start_time_

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)

Detailed Description

Definition at line 70 of file sample3_unittest.cc.

Constructor & Destructor Documentation

QueueTest::QueueTest ( uint32_t  maxSize, IntQueue::FdType  type  )

inlineexplicit

Definition at line 55 of file NotificationQueueTest.cpp.

      : queue(maxSize, type), terminationQueue(maxSize, type) {}

Member Function Documentation

void QueueTest::destroyCallback

(

)

Definition at line 349 of file NotificationQueueTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, g(), folly::EventBase::loop(), folly::pushmi::__adl::noexcept(), and value.

Referenced by TEST().

                                {
  // Rather than using QueueConsumer, define a separate class for the destroy
  // test.  The DestroyTestConsumer will delete itself inside the
  // messageAvailable() callback.  With a regular QueueConsumer this would
  // destroy the std::function object while the function is running, which we
  // should probably avoid doing.  This uses a pointer to a std::function to
  // avoid destroying the function object.
  class DestroyTestConsumer : public IntQueue::Consumer {
   public:
    void messageAvailable(int&& value) noexcept override {
      DestructorGuard g(this);
      if (fn && *fn) {
        (*fn)(value);
      }
    }

    std::function<void(int)>* fn;

   protected:
    ~DestroyTestConsumer() override = default;
  };

  EventBase eventBase;
  // Create a queue and add 2 messages to it
  queue.putMessage(1);
  queue.putMessage(2);

  // Create two QueueConsumers allocated on the heap.
  // Have whichever one gets called first destroy both of the QueueConsumers.
  // This way one consumer will be destroyed from inside its messageAvailable()
  // callback, and one consume will be destroyed when it isn't inside
  // messageAvailable().
  std::unique_ptr<DestroyTestConsumer, DelayedDestruction::Destructor>
      consumer1(new DestroyTestConsumer);
  std::unique_ptr<DestroyTestConsumer, DelayedDestruction::Destructor>
      consumer2(new DestroyTestConsumer);
  std::function<void(int)> fn = [&](int) {
    consumer1 = nullptr;
    consumer2 = nullptr;
  };
  consumer1->fn = &fn;
  consumer2->fn = &fn;

  consumer1->startConsuming(&eventBase, &queue);
  consumer2->startConsuming(&eventBase, &queue);

  // Run the event loop.
  eventBase.loop();

  // One of the consumers should have fired, received the message,
  // then destroyed both consumers.
  EXPECT_TRUE(!consumer1);
  EXPECT_TRUE(!consumer2);
  // One message should be left in the queue
  int result = 1;
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(2, result);
}

static int QueueTest::Double ( int  n )

inlinestaticprotected

Definition at line 91 of file sample3_unittest.cc.

Referenced by MapTester().

                           {
    return 2*n;
  }

static int QueueTest::Double ( int  n )

inlinestaticprotected

Definition at line 91 of file sample3_unittest.cc.

                           {
    return 2*n;
  }

static int QueueTest::Double ( int  n )

inlinestaticprotected

Definition at line 91 of file sample3_unittest.cc.

                           {
    return 2*n;
  }

void QueueTest::MapTester ( const Queue< int > *  q )

inlineprotected

Definition at line 96 of file sample3_unittest.cc.

References ASSERT_EQ, Double(), EXPECT_EQ, Queue< E >::Head(), Queue< E >::Map(), QueueNode< E >::next(), q0_, q1_, q2_, and Queue< E >::Size().

                                       {
    // Creates a new queue, where each element is twice as big as the
    // corresponding one in q.
    const Queue<int> * const new_q = q->Map(Double);

    // Verifies that the new queue has the same size as q.
    ASSERT_EQ(q->Size(), new_q->Size());

    // Verifies the relationship between the elements of the two queues.
    for ( const QueueNode<int> * n1 = q->Head(), * n2 = new_q->Head();
          n1 != NULL; n1 = n1->next(), n2 = n2->next() ) {
      EXPECT_EQ(2 * n1->element(), n2->element());
    }

    delete new_q;
  }

void QueueTest::MapTester ( const Queue< int > *  q )

inlineprotected

Definition at line 96 of file sample3_unittest.cc.

References ASSERT_EQ, Double(), EXPECT_EQ, Queue< E >::Head(), Queue< E >::Map(), QueueNode< E >::next(), and Queue< E >::Size().

Referenced by TEST_F().

                                       {
    // Creates a new queue, where each element is twice as big as the
    // corresponding one in q.
    const Queue<int> * const new_q = q->Map(Double);

    // Verifies that the new queue has the same size as q.
    ASSERT_EQ(q->Size(), new_q->Size());

    // Verifies the relationship between the elements of the two queues.
    for ( const QueueNode<int> * n1 = q->Head(), * n2 = new_q->Head();
          n1 != NULL; n1 = n1->next(), n2 = n2->next() ) {
      EXPECT_EQ(2 * n1->element(), n2->element());
    }

    delete new_q;
  }

void QueueTest::MapTester ( const Queue< int > *  q )

inlineprotected

Definition at line 96 of file sample3_unittest.cc.

References ASSERT_EQ, Double(), EXPECT_EQ, Queue< E >::Head(), Queue< E >::Map(), QueueNode< E >::next(), q0_, q1_, q2_, and Queue< E >::Size().

                                       {
    // Creates a new queue, where each element is twice as big as the
    // corresponding one in q.
    const Queue<int> * const new_q = q->Map(Double);

    // Verifies that the new queue has the same size as q.
    ASSERT_EQ(q->Size(), new_q->Size());

    // Verifies the relationship between the elements of the two queues.
    for ( const QueueNode<int> * n1 = q->Head(), * n2 = new_q->Head();
          n1 != NULL; n1 = n1->next(), n2 = n2->next() ) {
      EXPECT_EQ(2 * n1->element(), n2->element());
    }

    delete new_q;
  }

void QueueTest::maxQueueSize

(

)

Definition at line 218 of file NotificationQueueTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, folly::gen::move, and val.

Referenced by TEST().

                             {
  // Create a queue with a maximum size of 5, and fill it up

  for (int n = 0; n < 5; ++n) {
    queue.tryPutMessage(n);
  }

  // Calling tryPutMessage() now should fail
  EXPECT_THROW(queue.tryPutMessage(5), std::overflow_error);

  EXPECT_FALSE(queue.tryPutMessageNoThrow(5));
  int val = 5;
  EXPECT_FALSE(queue.tryPutMessageNoThrow(std::move(val)));

  // Pop a message from the queue
  int result = -1;
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(0, result);

  // We should be able to write another message now that we popped one off.
  queue.tryPutMessage(5);
  // But now we are full again.
  EXPECT_THROW(queue.tryPutMessage(6), std::overflow_error);
  // putMessage() should let us exceed the maximum
  queue.putMessage(6);

  // Pull another mesage off
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(1, result);

  // tryPutMessage() should still fail since putMessage() actually put us over
  // the max.
  EXPECT_THROW(queue.tryPutMessage(7), std::overflow_error);

  // Pull another message off and try again
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(2, result);
  queue.tryPutMessage(7);

  // Now pull all the remaining messages off
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(3, result);
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(4, result);
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(5, result);
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(6, result);
  EXPECT_TRUE(queue.tryConsume(result));
  EXPECT_EQ(7, result);

  // There should be no messages left
  result = -1;
  EXPECT_TRUE(!queue.tryConsume(result));
  EXPECT_EQ(-1, result);
}

void QueueTest::maxReadAtOnce

(

)

Definition at line 275 of file NotificationQueueTest.cpp.

References EXPECT_EQ, QueueConsumer::fn, folly::EventBase::loop(), QueueConsumer::messages, folly::EventBase::runInLoop(), folly::NotificationQueue< MessageT >::Consumer::setMaxReadAtOnce(), folly::NotificationQueue< MessageT >::Consumer::startConsuming(), folly::EventBase::terminateLoopSoon(), uint32_t, and value.

Referenced by TEST().

                              {
  // Add 100 messages to the queue
  for (int n = 0; n < 100; ++n) {
    queue.putMessage(n);
  }

  EventBase eventBase;

  // Record how many messages were processed each loop iteration.
  uint32_t messagesThisLoop = 0;
  std::vector<uint32_t> messagesPerLoop;
  std::function<void()> loopFinished = [&] {
    // Record the current number of messages read this loop
    messagesPerLoop.push_back(messagesThisLoop);
    // Reset messagesThisLoop to 0 for the next loop
    messagesThisLoop = 0;

    // To prevent use-after-free bugs when eventBase destructs,
    // prevent calling runInLoop any more after the test is finished.
    // 55 == number of times loop should run.
    if (messagesPerLoop.size() != 55) {
      // Reschedule ourself to run at the end of the next loop
      eventBase.runInLoop(loopFinished);
    }
  };
  // Schedule the first call to loopFinished
  eventBase.runInLoop(loopFinished);

  QueueConsumer consumer;
  // Read the first 50 messages 10 at a time.
  consumer.setMaxReadAtOnce(10);
  consumer.fn = [&](int value) {
    ++messagesThisLoop;
    // After 50 messages, drop to reading only 1 message at a time.
    if (value == 50) {
      consumer.setMaxReadAtOnce(1);
    }
    // Terminate the loop when we reach the end of the messages.
    if (value == 99) {
      eventBase.terminateLoopSoon();
    }
  };
  consumer.startConsuming(&eventBase, &queue);

  // Run the event loop until the consumer terminates it
  eventBase.loop();

  // The consumer should have read all 100 messages in order
  EXPECT_EQ(100, consumer.messages.size());
  for (int n = 0; n < 100; ++n) {
    EXPECT_EQ(n, consumer.messages.at(n));
  }

  // Currently EventBase happens to still run the loop callbacks even after
  // terminateLoopSoon() is called.  However, we don't really want to depend on
  // this behavior.  In case this ever changes in the future, add
  // messagesThisLoop to messagesPerLoop in loop callback isn't invoked for the
  // last loop iteration.
  if (messagesThisLoop > 0) {
    messagesPerLoop.push_back(messagesThisLoop);
    messagesThisLoop = 0;
  }

  // For the first 5 loops it should have read 10 messages each time.
  // After that it should have read 1 messages per loop for the next 50 loops.
  EXPECT_EQ(55, messagesPerLoop.size());
  for (int n = 0; n < 5; ++n) {
    EXPECT_EQ(10, messagesPerLoop.at(n));
  }
  for (int n = 5; n < 55; ++n) {
    EXPECT_EQ(1, messagesPerLoop.at(n));
  }
}

void QueueTest::multiConsumer

(

)

Definition at line 138 of file NotificationQueueTest.cpp.

References EXPECT_EQ, EXPECT_GE, EXPECT_LT, QueueConsumer::fn, folly::EventBase::loop(), messages, folly::EventBase::runInEventBaseThread(), folly::NotificationQueue< MessageT >::Consumer::startConsuming(), folly::NotificationQueue< MessageT >::Consumer::stopConsuming(), threads, uint32_t, and value.

Referenced by TEST().

                              {
  uint32_t numConsumers = 8;
  uint32_t numMessages = 10000;

  // Create several consumers each running in their own EventBase thread
  vector<QueueConsumer> consumers(numConsumers);
  vector<ScopedEventBaseThread> threads(numConsumers);

  for (uint32_t consumerIdx = 0; consumerIdx < numConsumers; ++consumerIdx) {
    QueueConsumer* consumer = &consumers[consumerIdx];

    consumer->fn = [consumer, consumerIdx, this](int value) {
      // Treat 0 as a signal to stop.
      if (value == 0) {
        consumer->stopConsuming();
        // Put a message on the terminationQueue to indicate we have stopped
        terminationQueue.putMessage(consumerIdx);
      }
    };

    EventBase* eventBase = threads[consumerIdx].getEventBase();
    eventBase->runInEventBaseThread([eventBase, consumer, this] {
      consumer->startConsuming(eventBase, &queue);
    });
  }

  // Now add a number of messages from this thread
  // Start at 1 rather than 0, since 0 is the signal to stop.
  for (uint32_t n = 1; n < numMessages; ++n) {
    queue.putMessage(n);
  }
  // Now add a 0 for each consumer, to signal them to stop
  for (uint32_t n = 0; n < numConsumers; ++n) {
    queue.putMessage(0);
  }

  // Wait until we get notified that all of the consumers have stopped
  // We use a separate notification queue for this.
  QueueConsumer terminationConsumer;
  vector<uint32_t> consumersStopped(numConsumers, 0);
  uint32_t consumersRemaining = numConsumers;
  terminationConsumer.fn = [&](int consumerIdx) {
    --consumersRemaining;
    if (consumersRemaining == 0) {
      terminationConsumer.stopConsuming();
    }

    EXPECT_GE(consumerIdx, 0);
    EXPECT_LT(consumerIdx, numConsumers);
    ++consumersStopped[consumerIdx];
  };
  EventBase eventBase;
  terminationConsumer.startConsuming(&eventBase, &terminationQueue);
  eventBase.loop();

  // Verify that we saw exactly 1 stop message for each consumer
  for (uint32_t n = 0; n < numConsumers; ++n) {
    EXPECT_EQ(1, consumersStopped[n]);
  }

  // Validate that every message sent to the main queue was received exactly
  // once.
  vector<int> messageCount(numMessages, 0);
  for (uint32_t n = 0; n < numConsumers; ++n) {
    for (int msg : consumers[n].messages) {
      EXPECT_GE(msg, 0);
      EXPECT_LT(msg, numMessages);
      ++messageCount[msg];
    }
  }

  // 0 is the signal to stop, and should have been received once by each
  // consumer
  EXPECT_EQ(numConsumers, messageCount[0]);
  // All other messages should have been received exactly once
  for (uint32_t n = 1; n < numMessages; ++n) {
    EXPECT_EQ(1, messageCount[n]);
  }
}

void QueueTest::putMessages

(

)

Definition at line 93 of file NotificationQueueTest.cpp.

References EXPECT_EQ, QueueConsumer::fn, folly::EventBase::loop(), QueueConsumer::messages, folly::NotificationQueue< MessageT >::Consumer::startConsuming(), and folly::NotificationQueue< MessageT >::Consumer::stopConsuming().

                            {
  EventBase eventBase;

  QueueConsumer consumer;
  QueueConsumer consumer2;
  consumer.fn = [&](int msg) {
    // Stop consuming after we receive a message with value 0, and start
    // consumer2
    if (msg == 0) {
      consumer.stopConsuming();
      consumer2.startConsuming(&eventBase, &queue);
    }
  };
  consumer2.fn = [&](int msg) {
    // Stop consuming after we receive a message with value 0
    if (msg == 0) {
      consumer2.stopConsuming();
    }
  };
  consumer.startConsuming(&eventBase, &queue);

  list<int> msgList = {1, 2, 3, 4};
  vector<int> msgVector = {5, 0, 9, 8, 7, 6, 7, 7, 8, 8, 2, 9, 6, 6, 10, 2, 0};
  // Call putMessages() several times to add messages to the queue
  queue.putMessages(msgList.begin(), msgList.end());
  queue.putMessages(msgVector.begin() + 2, msgVector.begin() + 4);
  // Test sending 17 messages, the pipe-based queue calls write in 16 byte
  // chunks
  queue.putMessages(msgVector.begin(), msgVector.end());

  // Loop until the consumer has stopped
  eventBase.loop();

  vector<int> expectedMessages = {1, 2, 3, 4, 9, 8, 7, 5, 0};
  vector<int> expectedMessages2 = {9, 8, 7, 6, 7, 7, 8, 8, 2, 9, 6, 10, 2, 0};
  EXPECT_EQ(expectedMessages.size(), consumer.messages.size());
  for (unsigned int idx = 0; idx < expectedMessages.size(); ++idx) {
    EXPECT_EQ(expectedMessages[idx], consumer.messages.at(idx));
  }
  EXPECT_EQ(expectedMessages2.size(), consumer2.messages.size());
  for (unsigned int idx = 0; idx < expectedMessages2.size(); ++idx) {
    EXPECT_EQ(expectedMessages2[idx], consumer2.messages.at(idx));
  }
}

void QueueTest::sendOne

(

)

Definition at line 70 of file NotificationQueueTest.cpp.

References EXPECT_EQ, QueueConsumer::fn, folly::ScopedEventBaseThread::getEventBase(), folly::EventBase::loop(), QueueConsumer::messages, messages, folly::EventBase::runInEventBaseThread(), folly::NotificationQueue< MessageT >::Consumer::startConsuming(), and folly::NotificationQueue< MessageT >::Consumer::stopConsuming().

Referenced by TEST().

                        {
  // Create a notification queue and a callback in this thread
  EventBase eventBase;

  QueueConsumer consumer;
  consumer.fn = [&](int) {
    // Stop consuming after we receive 1 message
    consumer.stopConsuming();
  };
  consumer.startConsuming(&eventBase, &queue);

  // Start a new EventBase thread to put a message on our queue
  ScopedEventBaseThread t1;
  t1.getEventBase()->runInEventBaseThread([&] { this->queue.putMessage(5); });

  // Loop until we receive the message
  eventBase.loop();

  const auto& messages = consumer.messages;
  EXPECT_EQ(1, messages.size());
  EXPECT_EQ(5, messages.at(0));
}

virtual void QueueTest::SetUp ( )

inlineprotectedvirtual

Reimplemented from testing::Test.

Definition at line 77 of file sample3_unittest.cc.

References Queue< E >::Enqueue(), q1_, and q2_.

                       {
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

virtual void QueueTest::SetUp ( )

inlineprotectedvirtual

Reimplemented from testing::Test.

Definition at line 77 of file sample3_unittest.cc.

References Queue< E >::Enqueue(), q1_, and q2_.

                       {
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

virtual void QueueTest::SetUp ( )

inlineprotectedvirtual

Reimplemented from testing::Test.

Definition at line 77 of file sample3_unittest.cc.

References Queue< E >::Enqueue(), q1_, and q2_.

                       {
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

virtual void QueueTest::SetUp ( )

inlineprotectedvirtual

Reimplemented from testing::Test.

Definition at line 146 of file sample5_unittest.cc.

References QuickTest::SetUp().

                       {
    // First, we need to set up the super fixture (QuickTest).
    QuickTest::SetUp();

    // Second, some additional setup for this fixture.
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

virtual void QueueTest::SetUp ( )

inlineprotectedvirtual

Reimplemented from testing::Test.

Definition at line 146 of file sample5_unittest.cc.

References QuickTest::SetUp().

                       {
    // First, we need to set up the super fixture (QuickTest).
    QuickTest::SetUp();

    // Second, some additional setup for this fixture.
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

virtual void QueueTest::SetUp ( )

inlineprotectedvirtual

Reimplemented from testing::Test.

Definition at line 146 of file sample5_unittest.cc.

References QuickTest::SetUp().

                       {
    // First, we need to set up the super fixture (QuickTest).
    QuickTest::SetUp();

    // Second, some additional setup for this fixture.
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

void QueueTest::useAfterFork

(

)

Member Data Documentation

Queue< int > QueueTest::q0_

protected

Definition at line 114 of file sample3_unittest.cc.

Referenced by MapTester(), and TEST_F().

Queue< int > QueueTest::q1_

protected

Definition at line 115 of file sample3_unittest.cc.

Referenced by MapTester(), SetUp(), and TEST_F().

Queue< int > QueueTest::q2_

protected

Definition at line 116 of file sample3_unittest.cc.

Referenced by MapTester(), SetUp(), and TEST_F().

IntQueue QueueTest::queue

Definition at line 66 of file NotificationQueueTest.cpp.

IntQueue QueueTest::terminationQueue

Definition at line 67 of file NotificationQueueTest.cpp.

---

The documentation for this class was generated from the following files:

• proxygen/fizz/build_/gtest/src/gtest/googletest/samples/sample3_unittest.cc
• proxygen/fizz/build_/gtest/src/gtest/googletest/samples/sample5_unittest.cc
• proxygen/folly/folly/io/async/test/NotificationQueueTest.cpp