ProducerConsumerQueueTest.cpp File Reference

#include <folly/ProducerConsumerQueue.h>
#include <atomic>
#include <chrono>
#include <memory>
#include <thread>
#include <vector>
#include <glog/logging.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (PCQ, QueueCorrectness)
	TEST (PCQ, PerfTest)
	TEST (PCQ, Destructor)
	TEST (PCQ, EmptyFull)
	TEST (PCQ, Capacity)

Function Documentation

TEST	(	PCQ	,
		QueueCorrectness
	)

Definition at line 234 of file ProducerConsumerQueueTest.cpp.

                            {
  correctnessTestType<std::string, true>("string (front+pop)");
  correctnessTestType<std::string>("string");
  correctnessTestType<int>("int");
  correctnessTestType<unsigned long long>("unsigned long long");
}

TEST	(	PCQ	,
		PerfTest
	)

Definition at line 241 of file ProducerConsumerQueueTest.cpp.

                    {
  perfTestType<std::string, true>("string (front+pop)");
  perfTestType<std::string>("string");
  perfTestType<int>("int");
  perfTestType<unsigned long long>("unsigned long long");
}

TEST	(	PCQ	,
		Destructor
	)

Definition at line 248 of file ProducerConsumerQueueTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, i, folly::ProducerConsumerQueue< T >::read(), and folly::ProducerConsumerQueue< T >::write().

                      {
  // Test that orphaned elements in a ProducerConsumerQueue are
  // destroyed.
  {
    folly::ProducerConsumerQueue<DtorChecker> queue(1024);
    for (int i = 0; i < 10; ++i) {
      EXPECT_TRUE(queue.write(DtorChecker()));
    }

    EXPECT_EQ(DtorChecker::numInstances, 10);

    {
      DtorChecker ignore;
      EXPECT_TRUE(queue.read(ignore));
      EXPECT_TRUE(queue.read(ignore));
    }

    EXPECT_EQ(DtorChecker::numInstances, 8);
  }

  EXPECT_EQ(DtorChecker::numInstances, 0);

  // Test the same thing in the case that the queue write pointer has
  // wrapped, but the read one hasn't.
  {
    folly::ProducerConsumerQueue<DtorChecker> queue(4);
    for (int i = 0; i < 3; ++i) {
      EXPECT_TRUE(queue.write(DtorChecker()));
    }
    EXPECT_EQ(DtorChecker::numInstances, 3);
    {
      DtorChecker ignore;
      EXPECT_TRUE(queue.read(ignore));
    }
    EXPECT_EQ(DtorChecker::numInstances, 2);
    EXPECT_TRUE(queue.write(DtorChecker()));
    EXPECT_EQ(DtorChecker::numInstances, 3);
  }
  EXPECT_EQ(DtorChecker::numInstances, 0);
}

TEST	(	PCQ	,
		EmptyFull
	)

Definition at line 289 of file ProducerConsumerQueueTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::ProducerConsumerQueue< T >::isEmpty(), folly::ProducerConsumerQueue< T >::isFull(), folly::ProducerConsumerQueue< T >::sizeGuess(), and folly::ProducerConsumerQueue< T >::write().

                     {
  folly::ProducerConsumerQueue<int> queue(3);
  EXPECT_TRUE(queue.isEmpty());
  EXPECT_FALSE(queue.isFull());

  EXPECT_TRUE(queue.write(1));
  EXPECT_FALSE(queue.isEmpty());
  EXPECT_FALSE(queue.isFull());

  EXPECT_TRUE(queue.write(2));
  EXPECT_FALSE(queue.isEmpty());
  EXPECT_TRUE(queue.isFull()); // Tricky: full after 2 writes, not 3.

  EXPECT_FALSE(queue.write(3));
  EXPECT_EQ(queue.sizeGuess(), 2);
}

TEST	(	PCQ	,
		Capacity
	)

Definition at line 306 of file ProducerConsumerQueueTest.cpp.

References folly::ProducerConsumerQueue< T >::capacity(), and EXPECT_EQ.

                    {
  folly::ProducerConsumerQueue<int> queue(3);
  EXPECT_EQ(queue.capacity(), 2); // PCQ max size is buffer size - 1.
}