proxygen: folly::io::test Namespace Reference

Classes
class	AutomaticCodecTest

class	CompressionCorruptionTest

class	CompressionTest

class	CompressionVarintTest

class	ConstantDataHolder

class	DataHolder

class	RandomDataHolder

class	StreamingCompressionTest

class	StreamingUnitTest

class	TerminalCodecTest

Functions
uint64_t	hashIOBuf (const IOBuf *buf)

static std::vector< CodecType >	supportedCodecs (std::vector< CodecType > const &v)

static std::vector< CodecType >	availableCodecs ()

static std::vector< CodecType >	availableStreamCodecs ()

	TEST (CompressionTestNeedsUncompressedLength, Simple)

	TEST_P (CompressionTest, RandomData)

	TEST_P (CompressionTest, ConstantData)

	TEST_P (CompressionTest, RandomDataString)

	TEST_P (CompressionTest, ConstantDataString)

	INSTANTIATE_TEST_CASE_P (CompressionTest, CompressionTest, testing::Combine(testing::Values(-1, 0, 1, 12, 22, 25, 27), testing::Values(1, 2, 3, 8, 65), testing::ValuesIn(availableCodecs())))

uint64_t	oneBasedMsbPos (uint64_t number)

	TEST_P (CompressionVarintTest, RandomData)

	TEST_P (CompressionVarintTest, ConstantData)

	INSTANTIATE_TEST_CASE_P (CompressionVarintTest, CompressionVarintTest, testing::Combine(testing::Values(0, 1, 12, 22, 25, 27), testing::ValuesIn(supportedCodecs({CodecType::LZ4_VARINT_SIZE, CodecType::LZMA2_VARINT_SIZE,}))))

	TEST (LZMATest, UncompressBadVarint)

	TEST_P (CompressionCorruptionTest, RandomData)

	TEST_P (CompressionCorruptionTest, ConstantData)

	INSTANTIATE_TEST_CASE_P (CompressionCorruptionTest, CompressionCorruptionTest, testing::ValuesIn(supportedCodecs({CodecType::SNAPPY, CodecType::ZLIB, CodecType::LZMA2, CodecType::ZSTD, CodecType::LZ4_FRAME, CodecType::BZIP2,})))

static bool	codecHasFlush (CodecType type)

	TEST (StreamingUnitTest, needsDataLength)

	TEST_P (StreamingUnitTest, maxCompressedLength)

	TEST_P (StreamingUnitTest, getUncompressedLength)

	TEST_P (StreamingUnitTest, emptyData)

	TEST_P (StreamingUnitTest, noForwardProgress)

	TEST_P (StreamingUnitTest, stateTransitions)

	INSTANTIATE_TEST_CASE_P (StreamingUnitTest, StreamingUnitTest, testing::ValuesIn(availableStreamCodecs()))

static std::unique_ptr< IOBuf >	compressSome (StreamCodec *codec, ByteRange data, uint64_t bufferSize, StreamCodec::FlushOp flush)

static std::pair< bool, std::unique_ptr< IOBuf > >	uncompressSome (StreamCodec *codec, ByteRange &data, uint64_t bufferSize, StreamCodec::FlushOp flush)

	TEST_P (StreamingCompressionTest, resetStream)

	TEST_P (StreamingCompressionTest, compressStream)

	TEST_P (StreamingCompressionTest, uncompressStream)

	TEST_P (StreamingCompressionTest, testFlush)

	INSTANTIATE_TEST_CASE_P (StreamingCompressionTest, StreamingCompressionTest, testing::Combine(testing::Values(0, 1, 12, 22, 27), testing::Values(12, 17, 20), testing::ValuesIn(availableStreamCodecs())))

	TEST_P (AutomaticCodecTest, RandomData)

	TEST_P (AutomaticCodecTest, ConstantData)

	TEST_P (AutomaticCodecTest, ValidPrefixes)

	TEST_P (AutomaticCodecTest, NeedsUncompressedLength)

	TEST_P (AutomaticCodecTest, maxUncompressedLength)

	TEST_P (AutomaticCodecTest, DefaultCodec)

	TEST_P (AutomaticCodecTest, CustomCodec)

	TEST_P (AutomaticCodecTest, CustomDefaultCodec)

	TEST_P (AutomaticCodecTest, canUncompressOneBytes)

	INSTANTIATE_TEST_CASE_P (AutomaticCodecTest, AutomaticCodecTest, testing::ValuesIn(availableCodecs()))

	TEST_P (TerminalCodecTest, uncompressIfDefaultThrows)

	TEST_P (TerminalCodecTest, terminalOverridesDefaults)

	INSTANTIATE_TEST_CASE_P (TerminalCodecTest, TerminalCodecTest, testing::ValuesIn(autoUncompressionCodecTypes))

	TEST (ValidPrefixesTest, CustomCodec)

	TEST (CheckCompatibleTest, SimplePrefixSecond)

	TEST (CheckCompatibleTest, SimplePrefixFirst)

	TEST (CheckCompatibleTest, Empty)

	TEST (CheckCompatibleTest, ZstdPrefix)

	TEST (CheckCompatibleTest, ZstdDuplicate)

	TEST (CheckCompatibleTest, ZlibIsPrefix)

Variables
constexpr size_t	dataSizeLog2 = 27

RandomDataHolder	randomDataHolder (dataSizeLog2)

ConstantDataHolder	constantDataHolder (dataSizeLog2)

Function Documentation

static std::vector<CodecType> folly::io::test::availableCodecs ( )

static

Definition at line 144 of file CompressionTest.cpp.

References folly::io::hasCodec(), i, folly::io::NUM_CODEC_TYPES, and type.

Referenced by TEST_P().

                                               {
   std::vector<CodecType> codecs;
 
   for (size_t i = 0; i < static_cast<size_t>(CodecType::NUM_CODEC_TYPES); ++i) {
     auto type = static_cast<CodecType>(i);
     if (hasCodec(type)) {
       codecs.push_back(type);
     }
   }
 
   return codecs;
 }

static std::vector<CodecType> folly::io::test::availableStreamCodecs ( )

static

Definition at line 157 of file CompressionTest.cpp.

References folly::io::hasStreamCodec(), i, folly::io::NUM_CODEC_TYPES, and type.

Referenced by TEST_P().

                                                     {
   std::vector<CodecType> codecs;
 
   for (size_t i = 0; i < static_cast<size_t>(CodecType::NUM_CODEC_TYPES); ++i) {
     auto type = static_cast<CodecType>(i);
     if (hasStreamCodec(type)) {
       codecs.push_back(type);
     }
   }
 
   return codecs;
 }

static bool folly::io::test::codecHasFlush ( CodecType type )

static

Definition at line 462 of file CompressionTest.cpp.

References folly::io::BZIP2.

Referenced by folly::io::test::StreamingUnitTest::hasFlush(), and folly::io::test::StreamingCompressionTest::hasFlush().

                                           {
   return type != CodecType::BZIP2;
 }

static std::unique_ptr<IOBuf> folly::io::test::compressSome	(	StreamCodec *	codec,
		ByteRange	data,
		uint64_t	bufferSize,
		StreamCodec::FlushOp	flush
	)

static

Definition at line 819 of file CompressionTest.cpp.

References folly::IOBufQueue::append(), buffer(), folly::io::StreamCodec::compressStream(), folly::IOBuf::create(), folly::Range< Iter >::empty(), EXPECT_TRUE, folly::IOBufQueue::move(), folly::gen::move, folly::io::StreamCodec::NONE, and gmock_output_test::output.

Referenced by folly::io::test::StreamingCompressionTest::runCompressStreamTest(), folly::io::test::StreamingCompressionTest::runFlushTest(), and folly::io::test::StreamingCompressionTest::runResetStreamTest().

                               {
   bool result;
   IOBufQueue queue;
   do {
     auto buffer = IOBuf::create(bufferSize);
     buffer->append(buffer->capacity());
     MutableByteRange output{buffer->writableData(), buffer->length()};
 
     result = codec->compressStream(data, output, flush);
     buffer->trimEnd(output.size());
     queue.append(std::move(buffer));
 
   } while (!(flush == StreamCodec::FlushOp::NONE && data.empty()) && !result);
   EXPECT_TRUE(data.empty());
   return queue.move();
 }

uint64_t folly::io::test::hashIOBuf ( const IOBuf * buf )

Definition at line 83 of file CompressionTest.cpp.

References folly::hash::fnv64_buf(), folly::hash::FNV_64_HASH_START, h, folly::range(), and uint64_t.

Referenced by folly::io::test::StreamingCompressionTest::runCompressStreamTest(), folly::io::test::StreamingCompressionTest::runFlushTest(), folly::io::test::StreamingCompressionTest::runResetStreamTest(), folly::io::test::CompressionTest::runSimpleIOBufTest(), folly::io::test::CompressionVarintTest::runSimpleTest(), folly::io::test::CompressionCorruptionTest::runSimpleTest(), folly::io::test::AutomaticCodecTest::runSimpleTest(), folly::io::test::StreamingCompressionTest::runUncompressStreamTest(), and TEST_P().

                                      {
   uint64_t h = folly::hash::FNV_64_HASH_START;
   for (auto& range : *buf) {
     h = folly::hash::fnv64_buf(range.data(), range.size(), h);
   }
   return h;
 }

folly::io::test::INSTANTIATE_TEST_CASE_P	(	CompressionTest	,
		CompressionTest	,
		testing::Combine(testing::Values(-1, 0, 1, 12, 22, 25, 27), testing::Values(1, 2, 3, 8, 65), testing::ValuesIn(availableCodecs()))
	)

Referenced by TEST(), and TEST_P().

folly::io::test::INSTANTIATE_TEST_CASE_P	(	CompressionVarintTest	,
		CompressionVarintTest	,
		testing::Combine(testing::Values(0, 1, 12, 22, 25, 27), testing::ValuesIn(supportedCodecs({CodecType::LZ4_VARINT_SIZE, CodecType::LZMA2_VARINT_SIZE,})))
	)

folly::io::test::INSTANTIATE_TEST_CASE_P	(	CompressionCorruptionTest	,
		CompressionCorruptionTest	,
		testing::ValuesIn(supportedCodecs({CodecType::SNAPPY, CodecType::ZLIB, CodecType::LZMA2, CodecType::ZSTD, CodecType::LZ4_FRAME, CodecType::BZIP2,}))
	)

folly::io::test::INSTANTIATE_TEST_CASE_P	(	StreamingUnitTest	,
		StreamingUnitTest	,
		testing::ValuesIn(availableStreamCodecs())
	)

folly::io::test::INSTANTIATE_TEST_CASE_P	(	StreamingCompressionTest	,
		StreamingCompressionTest	,
		testing::Combine(testing::Values(0, 1, 12, 22, 27), testing::Values(12, 17, 20), testing::ValuesIn(availableStreamCodecs()))
	)

folly::io::test::INSTANTIATE_TEST_CASE_P	(	AutomaticCodecTest	,
		AutomaticCodecTest	,
		testing::ValuesIn(availableCodecs())
	)

folly::io::test::INSTANTIATE_TEST_CASE_P	(	TerminalCodecTest	,
		TerminalCodecTest	,
		testing::ValuesIn(autoUncompressionCodecTypes)
	)

uint64_t folly::io::test::oneBasedMsbPos ( uint64_t number )

inline

Definition at line 325 of file CompressionTest.cpp.

References uint64_t.

Referenced by folly::io::test::CompressionVarintTest::runSimpleTest().

                                                 {
   uint64_t pos = 0;
   for (; number > 0; ++pos, number >>= 1) {
   }
   return pos;
 }

static std::vector<CodecType> folly::io::test::supportedCodecs ( std::vector< CodecType > const & v )

static

Definition at line 134 of file CompressionTest.cpp.

References folly::test::begin(), folly::test::end(), and folly::io::hasCodec().

Referenced by TEST_P().

                                                                            {
   std::vector<CodecType> supported;
 
   std::copy_if(
       std::begin(v), std::end(v), std::back_inserter(supported), hasCodec);
 
   return supported;
 }

folly::io::test::TEST	(	CompressionTestNeedsUncompressedLength	,
		Simple
	)

Definition at line 170 of file CompressionTest.cpp.

References folly::io::BZIP2, EXPECT_EQ, folly::io::getCodec(), folly::io::GZIP, folly::io::hasCodec(), folly::io::LZ4, folly::io::LZ4_FRAME, folly::io::LZ4_VARINT_SIZE, folly::io::LZMA2, folly::io::LZMA2_VARINT_SIZE, folly::io::NO_COMPRESSION, folly::io::SNAPPY, type, folly::io::ZLIB, and folly::io::ZSTD.

Referenced by TEST().

                                                      {
   static const struct {
     CodecType type;
     bool needsUncompressedLength;
   } expectations[] = {
       {CodecType::NO_COMPRESSION, false},
       {CodecType::LZ4, true},
       {CodecType::SNAPPY, false},
       {CodecType::ZLIB, false},
       {CodecType::LZ4_VARINT_SIZE, false},
       {CodecType::LZMA2, false},
       {CodecType::LZMA2_VARINT_SIZE, false},
       {CodecType::ZSTD, false},
       {CodecType::GZIP, false},
       {CodecType::LZ4_FRAME, false},
       {CodecType::BZIP2, false},
   };
 
   for (auto const& test : expectations) {
     if (hasCodec(test.type)) {
       EXPECT_EQ(
           getCodec(test.type)->needsUncompressedLength(),
           test.needsUncompressedLength);
     }
   }
 }

folly::io::test::TEST	(	LZMATest	,
		UncompressBadVarint
	)

Definition at line 369 of file CompressionTest.cpp.

References buffer(), codec, folly::IOBuf::create(), EXPECT_THROW, folly::io::getStreamCodec(), folly::io::hasStreamCodec(), folly::kMaxVarintLength64, folly::io::LZMA2_VARINT_SIZE, gmock_output_test::output, and string.

                                     {
   if (hasStreamCodec(CodecType::LZMA2_VARINT_SIZE)) {
     std::string const str(kMaxVarintLength64 * 2, '\xff');
     ByteRange input((folly::StringPiece(str)));
     auto codec = getStreamCodec(CodecType::LZMA2_VARINT_SIZE);
     auto buffer = IOBuf::create(16);
     buffer->append(buffer->capacity());
     MutableByteRange output{buffer->writableData(), buffer->length()};
     EXPECT_THROW(codec->uncompressStream(input, output), std::runtime_error);
   }
 }

folly::io::test::TEST	(	StreamingUnitTest	,
		needsDataLength
	)

Definition at line 479 of file CompressionTest.cpp.

References EXPECT_EQ, folly::io::getStreamCodec(), folly::io::GZIP, folly::io::hasStreamCodec(), folly::io::LZMA2, folly::io::LZMA2_VARINT_SIZE, type, folly::io::ZLIB, and folly::io::ZSTD.

                                          {
   static const struct {
     CodecType type;
     bool needsDataLength;
   } expectations[] = {
       {CodecType::ZLIB, false},
       {CodecType::GZIP, false},
       {CodecType::LZMA2, false},
       {CodecType::LZMA2_VARINT_SIZE, true},
       {CodecType::ZSTD, false},
   };
 
   for (auto const& test : expectations) {
     if (hasStreamCodec(test.type)) {
       EXPECT_EQ(
           getStreamCodec(test.type)->needsDataLength(), test.needsDataLength);
     }
   }
 }

folly::io::test::TEST	(	ValidPrefixesTest	,
		CustomCodec
	)

Definition at line 1325 of file CompressionTest.cpp.

References EXPECT_TRUE, folly::io::getAutoUncompressionCodec(), folly::gen::move, folly::io::NO_COMPRESSION, and folly::none.

                                      {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("none", CodecType::NO_COMPRESSION));
   const auto none = getAutoUncompressionCodec(std::move(codecs));
   const auto prefixes = none->validPrefixes();
   const auto it = std::find(prefixes.begin(), prefixes.end(), "none");
   EXPECT_TRUE(it != prefixes.end());
 }

folly::io::test::TEST	(	CheckCompatibleTest	,
		SimplePrefixSecond
	)

Definition at line 1343 of file CompressionTest.cpp.

References EXPECT_THROW_IF_DEBUG, folly::io::getAutoUncompressionCodec(), folly::gen::move, and folly::io::NO_COMPRESSION.

                                               {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("abc", CodecType::NO_COMPRESSION));
   codecs.push_back(CustomCodec::create("ab", CodecType::NO_COMPRESSION));
   EXPECT_THROW_IF_DEBUG(
       getAutoUncompressionCodec(std::move(codecs)), std::invalid_argument);
 }

folly::io::test::TEST	(	CheckCompatibleTest	,
		SimplePrefixFirst
	)

Definition at line 1351 of file CompressionTest.cpp.

References EXPECT_THROW_IF_DEBUG, folly::io::getAutoUncompressionCodec(), folly::gen::move, and folly::io::NO_COMPRESSION.

                                              {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("ab", CodecType::NO_COMPRESSION));
   codecs.push_back(CustomCodec::create("abc", CodecType::NO_COMPRESSION));
   EXPECT_THROW_IF_DEBUG(
       getAutoUncompressionCodec(std::move(codecs)), std::invalid_argument);
 }

folly::io::test::TEST	(	CheckCompatibleTest	,
		Empty
	)

Definition at line 1359 of file CompressionTest.cpp.

References EXPECT_THROW_IF_DEBUG, folly::io::getAutoUncompressionCodec(), folly::gen::move, and folly::io::NO_COMPRESSION.

                                  {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("", CodecType::NO_COMPRESSION));
   EXPECT_THROW_IF_DEBUG(
       getAutoUncompressionCodec(std::move(codecs)), std::invalid_argument);
 }

folly::io::test::TEST	(	CheckCompatibleTest	,
		ZstdPrefix
	)

Definition at line 1366 of file CompressionTest.cpp.

References EXPECT_THROW_IF_DEBUG, folly::io::getAutoUncompressionCodec(), folly::gen::move, and folly::io::ZSTD.

                                       {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("\x28\xB5\x2F", CodecType::ZSTD));
   EXPECT_THROW_IF_DEBUG(
       getAutoUncompressionCodec(std::move(codecs)), std::invalid_argument);
 }

folly::io::test::TEST	(	CheckCompatibleTest	,
		ZstdDuplicate
	)

Definition at line 1373 of file CompressionTest.cpp.

References EXPECT_THROW_IF_DEBUG, folly::io::getAutoUncompressionCodec(), folly::gen::move, and folly::io::ZSTD.

                                          {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("\x28\xB5\x2F\xFD", CodecType::ZSTD));
   EXPECT_THROW_IF_DEBUG(
       getAutoUncompressionCodec(std::move(codecs)), std::invalid_argument);
 }

folly::io::test::TEST	(	CheckCompatibleTest	,
		ZlibIsPrefix
	)

Definition at line 1380 of file CompressionTest.cpp.

References codec, codec_, constantDataHolder, folly::io::test::DataHolder::data(), folly::Range< Iter >::data(), EXPECT_EQ, EXPECT_GT, EXPECT_THROW_IF_DEBUG, folly::io::getAutoUncompressionCodec(), folly::io::getCodec(), folly::io::getStreamCodec(), folly::io::GZIP, INSTANTIATE_TEST_CASE_P(), folly::gen::move, randomDataHolder, string, TEST(), test(), TEST_P(), folly::IOBuf::wrapBuffer(), folly::io::ZLIB, and folly::io::ZSTD.

                                         {
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("\x18\x76zzasdf", CodecType::ZSTD));
   EXPECT_THROW_IF_DEBUG(
       getAutoUncompressionCodec(std::move(codecs)), std::invalid_argument);
 }

folly::io::test::TEST_P	(	CompressionTest	,
		RandomData
	)

Definition at line 286 of file CompressionTest.cpp.

References randomDataHolder.

Referenced by TEST().

                                     {
   runSimpleIOBufTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	CompressionTest	,
		ConstantData
	)

Definition at line 290 of file CompressionTest.cpp.

References constantDataHolder.

                                       {
   runSimpleIOBufTest(constantDataHolder);
 }

folly::io::test::TEST_P	(	CompressionTest	,
		RandomDataString
	)

Definition at line 294 of file CompressionTest.cpp.

References randomDataHolder.

                                           {
   runSimpleStringTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	CompressionTest	,
		ConstantDataString
	)

Definition at line 298 of file CompressionTest.cpp.

References availableCodecs(), constantDataHolder, and INSTANTIATE_TEST_CASE_P().

                                             {
   runSimpleStringTest(constantDataHolder);
 }

folly::io::test::TEST_P	(	CompressionVarintTest	,
		RandomData
	)

Definition at line 351 of file CompressionTest.cpp.

References randomDataHolder.

                                           {
   runSimpleTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	CompressionVarintTest	,
		ConstantData
	)

Definition at line 355 of file CompressionTest.cpp.

References constantDataHolder, INSTANTIATE_TEST_CASE_P(), folly::io::LZ4_VARINT_SIZE, folly::io::LZMA2_VARINT_SIZE, and supportedCodecs().

                                             {
   runSimpleTest(constantDataHolder);
 }

folly::io::test::TEST_P	(	CompressionCorruptionTest	,
		RandomData
	)

Definition at line 439 of file CompressionTest.cpp.

References randomDataHolder.

                                               {
   runSimpleTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	CompressionCorruptionTest	,
		ConstantData
	)

Definition at line 443 of file CompressionTest.cpp.

References folly::io::BZIP2, constantDataHolder, INSTANTIATE_TEST_CASE_P(), folly::io::LZ4_FRAME, folly::io::LZMA2, folly::io::SNAPPY, supportedCodecs(), folly::io::ZLIB, and folly::io::ZSTD.

                                                 {
   runSimpleTest(constantDataHolder);
 }

folly::io::test::TEST_P	(	StreamingUnitTest	,
		maxCompressedLength
	)

Definition at line 499 of file CompressionTest.cpp.

References codec_, EXPECT_GE, and uint64_t.

                                                {
   for (uint64_t const length : {1, 10, 100, 1000, 10000, 100000, 1000000}) {
     EXPECT_GE(codec_->maxCompressedLength(length), length);
   }
 }

folly::io::test::TEST_P	(	StreamingUnitTest	,
		getUncompressedLength
	)

Definition at line 505 of file CompressionTest.cpp.

References codec_, folly::IOBuf::create(), folly::io::test::DataHolder::data(), folly::empty(), EXPECT_ANY_THROW, EXPECT_EQ, randomDataHolder, uint64_t, and folly::IOBuf::wrapBuffer().

                                                  {
   auto const empty = IOBuf::create(0);
   EXPECT_EQ(uint64_t(0), codec_->getUncompressedLength(empty.get()));
   EXPECT_EQ(uint64_t(0), codec_->getUncompressedLength(empty.get(), 0));
   EXPECT_ANY_THROW(codec_->getUncompressedLength(empty.get(), 1));
 
   auto const data = IOBuf::wrapBuffer(randomDataHolder.data(100));
   auto const compressed = codec_->compress(data.get());
 
   if (auto const length = codec_->getUncompressedLength(data.get())) {
     EXPECT_EQ(100, *length);
   }
   EXPECT_EQ(uint64_t(100), codec_->getUncompressedLength(data.get(), 100));
   // If the uncompressed length is stored in the frame, then make sure it throws
   // when it is given the wrong length.
   if (codec_->getUncompressedLength(data.get()) == uint64_t(100)) {
     EXPECT_ANY_THROW(codec_->getUncompressedLength(data.get(), 200));
   }
 }

folly::io::test::TEST_P	(	StreamingUnitTest	,
		emptyData
	)

Definition at line 525 of file CompressionTest.cpp.

References buffer(), codec_, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), folly::io::StreamCodec::END, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::io::StreamCodec::FLUSH, gmock_output_test::output, and folly::Range< Iter >::size().

                                      {
   ByteRange input{};
   auto buffer = IOBuf::create(codec_->maxCompressedLength(0));
   buffer->append(buffer->capacity());
   MutableByteRange output;
 
   // Test compressing empty data in one pass
   if (!codec_->needsDataLength()) {
     output = {buffer->writableData(), buffer->length()};
     EXPECT_TRUE(
         codec_->compressStream(input, output, StreamCodec::FlushOp::END));
   }
   codec_->resetStream(0);
   output = {buffer->writableData(), buffer->length()};
   EXPECT_TRUE(codec_->compressStream(input, output, StreamCodec::FlushOp::END));
 
   // Test uncompressing the compressed empty data is equivalent to the empty
   // string
   {
     size_t compressedSize = buffer->length() - output.size();
     auto const compressed =
         IOBuf::copyBuffer(buffer->writableData(), compressedSize);
     auto inputRange = compressed->coalesce();
     codec_->resetStream(0);
     output = {buffer->writableData(), buffer->length()};
     EXPECT_TRUE(codec_->uncompressStream(
         inputRange, output, StreamCodec::FlushOp::END));
     EXPECT_EQ(output.size(), buffer->length());
   }
 
   // Test compressing empty data with multiple calls to compressStream()
   {
     auto largeBuffer = IOBuf::create(codec_->maxCompressedLength(0) * 2);
     largeBuffer->append(largeBuffer->capacity());
     codec_->resetStream(0);
     output = {largeBuffer->writableData(), largeBuffer->length()};
     EXPECT_FALSE(codec_->compressStream(input, output));
     if (hasFlush()) {
       EXPECT_TRUE(
           codec_->compressStream(input, output, StreamCodec::FlushOp::FLUSH));
     }
     EXPECT_TRUE(
         codec_->compressStream(input, output, StreamCodec::FlushOp::END));
   }
 
   // Test uncompressing empty data
   output = {};
   codec_->resetStream();
   EXPECT_TRUE(codec_->uncompressStream(input, output));
   if (hasFlush()) {
     codec_->resetStream();
     EXPECT_TRUE(
         codec_->uncompressStream(input, output, StreamCodec::FlushOp::FLUSH));
   }
   codec_->resetStream();
   EXPECT_TRUE(
       codec_->uncompressStream(input, output, StreamCodec::FlushOp::END));
   codec_->resetStream(0);
   EXPECT_TRUE(codec_->uncompressStream(input, output));
   if (hasFlush()) {
     codec_->resetStream(0);
     EXPECT_TRUE(
         codec_->uncompressStream(input, output, StreamCodec::FlushOp::FLUSH));
   }
   codec_->resetStream(0);
   EXPECT_TRUE(
       codec_->uncompressStream(input, output, StreamCodec::FlushOp::END));
 }

folly::io::test::TEST_P	(	StreamingUnitTest	,
		noForwardProgress
	)

Definition at line 594 of file CompressionTest.cpp.

References codec_, folly::IOBuf::create(), folly::io::StreamCodec::END, EXPECT_FALSE, EXPECT_THROW, folly::io::StreamCodec::FLUSH, folly::io::StreamCodec::NONE, and gmock_output_test::output.

                                              {
   auto inBuffer = IOBuf::create(2);
   inBuffer->writableData()[0] = 'a';
   inBuffer->writableData()[1] = 'a';
   inBuffer->append(2);
   const auto compressed = codec_->compress(inBuffer.get());
   auto outBuffer = IOBuf::create(codec_->maxCompressedLength(2));
 
   ByteRange emptyInput;
   MutableByteRange emptyOutput;
 
   const std::array<StreamCodec::FlushOp, 3> flushOps = {{
       StreamCodec::FlushOp::NONE,
       StreamCodec::FlushOp::FLUSH,
       StreamCodec::FlushOp::END,
   }};
 
   // No progress is not okay twice in a row for all flush operations when
   // compressing
   for (const auto flushOp : flushOps) {
     if (flushOp == StreamCodec::FlushOp::FLUSH && !hasFlush()) {
       continue;
     }
     if (codec_->needsDataLength()) {
       codec_->resetStream(inBuffer->computeChainDataLength());
     } else {
       codec_->resetStream();
     }
     auto input = inBuffer->coalesce();
     MutableByteRange output = {outBuffer->writableTail(),
                                outBuffer->tailroom()};
     // Compress some data to avoid empty data special casing
     while (!input.empty()) {
       codec_->compressStream(input, output);
     }
     EXPECT_FALSE(codec_->compressStream(emptyInput, emptyOutput, flushOp));
     EXPECT_THROW(
         codec_->compressStream(emptyInput, emptyOutput, flushOp),
         std::runtime_error);
   }
 
   // No progress is not okay twice in a row for all flush operations when
   // uncompressing
   for (const auto flushOp : flushOps) {
     if (flushOp == StreamCodec::FlushOp::FLUSH && !hasFlush()) {
       continue;
     }
     codec_->resetStream();
     auto input = compressed->coalesce();
     // Remove the last byte so the operation is incomplete
     input.uncheckedSubtract(1);
     MutableByteRange output = {inBuffer->writableData(), inBuffer->length()};
     // Uncompress some data to avoid empty data special casing
     while (!input.empty()) {
       EXPECT_FALSE(codec_->uncompressStream(input, output));
     }
     EXPECT_FALSE(codec_->uncompressStream(emptyInput, emptyOutput, flushOp));
     EXPECT_THROW(
         codec_->uncompressStream(emptyInput, emptyOutput, flushOp),
         std::runtime_error);
   }
 }

folly::io::test::TEST_P	(	StreamingUnitTest	,
		stateTransitions
	)

Definition at line 657 of file CompressionTest.cpp.

References availableStreamCodecs(), codec_, folly::IOBuf::create(), folly::empty(), folly::io::StreamCodec::END, folly::symbolizer::test::expect(), EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, folly::io::StreamCodec::FLUSH, INSTANTIATE_TEST_CASE_P(), folly::io::StreamCodec::NONE, gmock_output_test::output, and folly::Range< Iter >::size().

                                             {
   auto inBuffer = IOBuf::create(2);
   inBuffer->writableData()[0] = 'a';
   inBuffer->writableData()[1] = 'a';
   inBuffer->append(2);
   auto compressed = codec_->compress(inBuffer.get());
   ByteRange const in = compressed->coalesce();
   auto outBuffer = IOBuf::create(codec_->maxCompressedLength(in.size()));
   MutableByteRange const out{outBuffer->writableTail(), outBuffer->tailroom()};
 
   auto compress = [&](StreamCodec::FlushOp flushOp = StreamCodec::FlushOp::NONE,
                       bool empty = false) {
     auto input = in;
     auto output = empty ? MutableByteRange{} : out;
     return codec_->compressStream(input, output, flushOp);
   };
   auto compress_all = [&](bool expect,
                           StreamCodec::FlushOp flushOp =
                               StreamCodec::FlushOp::NONE,
                           bool empty = false) {
     auto input = in;
     auto output = empty ? MutableByteRange{} : out;
     while (!input.empty()) {
       if (expect) {
         EXPECT_TRUE(codec_->compressStream(input, output, flushOp));
       } else {
         EXPECT_FALSE(codec_->compressStream(input, output, flushOp));
       }
     }
   };
   auto uncompress = [&](StreamCodec::FlushOp flushOp =
                             StreamCodec::FlushOp::NONE,
                         bool empty = false) {
     auto input = in;
     auto output = empty ? MutableByteRange{} : out;
     return codec_->uncompressStream(input, output, flushOp);
   };
 
   // compression flow
   if (!codec_->needsDataLength()) {
     codec_->resetStream();
     EXPECT_FALSE(compress());
     EXPECT_FALSE(compress());
     if (hasFlush()) {
       EXPECT_TRUE(compress(StreamCodec::FlushOp::FLUSH));
     }
     EXPECT_FALSE(compress());
     EXPECT_TRUE(compress(StreamCodec::FlushOp::END));
   }
   codec_->resetStream(in.size() * 5);
   compress_all(false);
   compress_all(false);
   if (hasFlush()) {
     compress_all(true, StreamCodec::FlushOp::FLUSH);
   }
   compress_all(false);
   compress_all(true, StreamCodec::FlushOp::END);
 
   // uncompression flow
   codec_->resetStream();
   EXPECT_FALSE(uncompress(StreamCodec::FlushOp::NONE, true));
   if (hasFlush()) {
     codec_->resetStream();
     EXPECT_FALSE(uncompress(StreamCodec::FlushOp::FLUSH, true));
   }
   codec_->resetStream();
   EXPECT_FALSE(uncompress(StreamCodec::FlushOp::NONE, true));
   codec_->resetStream();
   EXPECT_FALSE(uncompress(StreamCodec::FlushOp::NONE, true));
   if (hasFlush()) {
     codec_->resetStream();
     EXPECT_TRUE(uncompress(StreamCodec::FlushOp::FLUSH));
   }
   // compress -> uncompress
   codec_->resetStream(in.size());
   EXPECT_FALSE(compress());
   EXPECT_THROW(uncompress(), std::logic_error);
   // uncompress -> compress
   codec_->resetStream(inBuffer->computeChainDataLength());
   EXPECT_TRUE(uncompress(StreamCodec::FlushOp::NONE));
   EXPECT_THROW(compress(), std::logic_error);
   // end -> compress
   if (!codec_->needsDataLength()) {
     codec_->resetStream();
     EXPECT_FALSE(compress());
     EXPECT_TRUE(compress(StreamCodec::FlushOp::END));
     EXPECT_THROW(compress(), std::logic_error);
   }
   codec_->resetStream(in.size() * 2);
   compress_all(false);
   compress_all(true, StreamCodec::FlushOp::END);
   EXPECT_THROW(compress(), std::logic_error);
   // end -> uncompress
   codec_->resetStream();
   EXPECT_TRUE(uncompress(StreamCodec::FlushOp::END));
   EXPECT_THROW(uncompress(), std::logic_error);
   // flush -> compress
   if (hasFlush()) {
     codec_->resetStream(in.size());
     EXPECT_FALSE(compress(StreamCodec::FlushOp::FLUSH, true));
     EXPECT_THROW(compress(), std::logic_error);
   }
   // flush -> end
   if (hasFlush()) {
     codec_->resetStream(in.size());
     EXPECT_FALSE(compress(StreamCodec::FlushOp::FLUSH, true));
     EXPECT_THROW(compress(StreamCodec::FlushOp::END), std::logic_error);
   }
   // undefined -> compress
   codec_->compress(inBuffer.get());
   EXPECT_THROW(compress(), std::logic_error);
   codec_->uncompress(compressed.get(), inBuffer->computeChainDataLength());
   EXPECT_THROW(compress(), std::logic_error);
   // undefined -> undefined
   codec_->uncompress(compressed.get());
   codec_->compress(inBuffer.get());
 }

folly::io::test::TEST_P	(	StreamingCompressionTest	,
		resetStream
	)

Definition at line 877 of file CompressionTest.cpp.

References constantDataHolder, and randomDataHolder.

                                               {
   runResetStreamTest(constantDataHolder);
   runResetStreamTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	StreamingCompressionTest	,
		compressStream
	)

Definition at line 902 of file CompressionTest.cpp.

References constantDataHolder, and randomDataHolder.

                                                  {
   runCompressStreamTest(constantDataHolder);
   runCompressStreamTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	StreamingCompressionTest	,
		uncompressStream
	)

Definition at line 943 of file CompressionTest.cpp.

References constantDataHolder, and randomDataHolder.

                                                    {
   runUncompressStreamTest(constantDataHolder);
   runUncompressStreamTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	StreamingCompressionTest	,
		testFlush
	)

Definition at line 979 of file CompressionTest.cpp.

References availableStreamCodecs(), folly::io::BZIP2, constantDataHolder, folly::io::GZIP, INSTANTIATE_TEST_CASE_P(), folly::io::LZ4_FRAME, folly::io::LZMA2, randomDataHolder, folly::io::ZLIB, and folly::io::ZSTD.

                                             {
   if (!hasFlush()) {
     return;
   }
   runFlushTest(constantDataHolder);
   runFlushTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		RandomData
	)

Definition at line 1065 of file CompressionTest.cpp.

References randomDataHolder.

                                        {
   runSimpleTest(randomDataHolder);
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		ConstantData
	)

Definition at line 1069 of file CompressionTest.cpp.

References constantDataHolder.

                                          {
   runSimpleTest(constantDataHolder);
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		ValidPrefixes
	)

Definition at line 1073 of file CompressionTest.cpp.

References codec_, folly::IOBuf::COPY_BUFFER, folly::io::test::DataHolder::data(), EXPECT_FALSE, EXPECT_TRUE, and prefix().

                                           {
   const auto prefixes = codec_->validPrefixes();
   for (const auto& prefix : prefixes) {
     EXPECT_FALSE(prefix.empty());
     // Ensure that all strings are at least 8 bytes for LZMA2.
     // The bytes after the prefix should be ignored by `canUncompress()`.
     IOBuf data{IOBuf::COPY_BUFFER, prefix, 0, 8};
     data.append(8);
     EXPECT_TRUE(codec_->canUncompress(&data));
     EXPECT_TRUE(auto_->canUncompress(&data));
   }
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		NeedsUncompressedLength
	)

Definition at line 1086 of file CompressionTest.cpp.

References codec_, and EXPECT_TRUE.

                                                     {
   if (codec_->needsUncompressedLength()) {
     EXPECT_TRUE(auto_->needsUncompressedLength());
   }
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		maxUncompressedLength
	)

Definition at line 1092 of file CompressionTest.cpp.

References codec_, and EXPECT_LE.

                                                   {
   EXPECT_LE(codec_->maxUncompressedLength(), auto_->maxUncompressedLength());
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		DefaultCodec
	)

Definition at line 1096 of file CompressionTest.cpp.

References folly::IOBuf::cloneCoalescedAsValue(), codec_, folly::IOBuf::computeChainDataLength(), constantDataHolder, folly::IOBuf::copyBuffer(), folly::io::test::DataHolder::data(), EXPECT_EQ, EXPECT_TRUE, folly::io::getAutoUncompressionCodec(), folly::io::getCodec(), folly::io::test::DataHolder::hash(), hashIOBuf(), folly::gen::move, prefix(), prefix_, string, folly::IOBuf::trimStart(), type, uint64_t, folly::io::USER_DEFINED, folly::IOBuf::wrapBuffer(), and folly::io::ZSTD.

                                          {
   const uint64_t length = 42;
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(getCodec(CodecType::ZSTD));
   auto automatic =
       getAutoUncompressionCodec(std::move(codecs), getTerminalCodec());
   auto original = IOBuf::wrapBuffer(constantDataHolder.data(length));
   auto compressed = codec_->compress(original.get());
   std::unique_ptr<IOBuf> decompressed;
 
   if (automatic->needsUncompressedLength()) {
     decompressed = automatic->uncompress(compressed.get(), length);
   } else {
     decompressed = automatic->uncompress(compressed.get());
   }
 
   EXPECT_EQ(constantDataHolder.hash(length), hashIOBuf(decompressed.get()));
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		CustomCodec
	)

Definition at line 1164 of file CompressionTest.cpp.

References codec_, constantDataHolder, folly::io::test::DataHolder::data(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::io::getAutoUncompressionCodec(), folly::io::test::DataHolder::hash(), hashIOBuf(), folly::gen::move, uint64_t, folly::IOBuf::wrapBuffer(), and folly::io::ZSTD.

                                         {
   const uint64_t length = 42;
   auto ab = CustomCodec::create("ab", CodecType::ZSTD);
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("ab", CodecType::ZSTD));
   auto automatic =
       getAutoUncompressionCodec(std::move(codecs), getTerminalCodec());
   auto original = IOBuf::wrapBuffer(constantDataHolder.data(length));
 
   auto abCompressed = ab->compress(original.get());
   std::unique_ptr<IOBuf> abDecompressed;
   if (automatic->needsUncompressedLength()) {
     abDecompressed = automatic->uncompress(abCompressed.get(), length);
   } else {
     abDecompressed = automatic->uncompress(abCompressed.get());
   }
   EXPECT_TRUE(automatic->canUncompress(abCompressed.get()));
   EXPECT_FALSE(auto_->canUncompress(abCompressed.get()));
   EXPECT_EQ(constantDataHolder.hash(length), hashIOBuf(abDecompressed.get()));
 
   auto compressed = codec_->compress(original.get());
   std::unique_ptr<IOBuf> decompressed;
   if (automatic->needsUncompressedLength()) {
     decompressed = automatic->uncompress(compressed.get(), length);
   } else {
     decompressed = automatic->uncompress(compressed.get());
   }
   EXPECT_EQ(constantDataHolder.hash(length), hashIOBuf(decompressed.get()));
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		CustomDefaultCodec
	)

Definition at line 1194 of file CompressionTest.cpp.

References codec_, constantDataHolder, folly::io::test::DataHolder::data(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::io::getAutoUncompressionCodec(), folly::io::getCodec(), folly::io::test::DataHolder::hash(), hashIOBuf(), folly::io::LZ4_FRAME, folly::gen::move, folly::io::NO_COMPRESSION, folly::none, uint64_t, and folly::IOBuf::wrapBuffer().

                                                {
   const uint64_t length = 42;
   auto none = CustomCodec::create("none", CodecType::NO_COMPRESSION);
   std::vector<std::unique_ptr<Codec>> codecs;
   codecs.push_back(CustomCodec::create("none", CodecType::NO_COMPRESSION));
   codecs.push_back(getCodec(CodecType::LZ4_FRAME));
   auto automatic =
       getAutoUncompressionCodec(std::move(codecs), getTerminalCodec());
   auto original = IOBuf::wrapBuffer(constantDataHolder.data(length));
 
   auto noneCompressed = none->compress(original.get());
   std::unique_ptr<IOBuf> noneDecompressed;
   if (automatic->needsUncompressedLength()) {
     noneDecompressed = automatic->uncompress(noneCompressed.get(), length);
   } else {
     noneDecompressed = automatic->uncompress(noneCompressed.get());
   }
   EXPECT_TRUE(automatic->canUncompress(noneCompressed.get()));
   EXPECT_FALSE(auto_->canUncompress(noneCompressed.get()));
   EXPECT_EQ(constantDataHolder.hash(length), hashIOBuf(noneDecompressed.get()));
 
   auto compressed = codec_->compress(original.get());
   std::unique_ptr<IOBuf> decompressed;
   if (automatic->needsUncompressedLength()) {
     decompressed = automatic->uncompress(compressed.get(), length);
   } else {
     decompressed = automatic->uncompress(compressed.get());
   }
   EXPECT_EQ(constantDataHolder.hash(length), hashIOBuf(decompressed.get()));
 }

folly::io::test::TEST_P	(	AutomaticCodecTest	,
		canUncompressOneBytes
	)

Definition at line 1225 of file CompressionTest.cpp.

References availableCodecs(), codec_, folly::IOBuf::copyBuffer(), folly::IOBuf::CREATE, EXPECT_FALSE, INSTANTIATE_TEST_CASE_P(), folly::gen::move, folly::none, string, type, uint64_t, and uncompressed_.

                                                   {
   // No default codec can uncompress 1 bytes.
   IOBuf buf{IOBuf::CREATE, 1};
   buf.append(1);
   EXPECT_FALSE(codec_->canUncompress(&buf, 1));
   EXPECT_FALSE(codec_->canUncompress(&buf, folly::none));
   EXPECT_FALSE(auto_->canUncompress(&buf, 1));
   EXPECT_FALSE(auto_->canUncompress(&buf, folly::none));
 }

folly::io::test::TEST_P	(	TerminalCodecTest	,
		uncompressIfDefaultThrows
	)

Definition at line 1288 of file CompressionTest.cpp.

References codec_, EXPECT_ANY_THROW, EXPECT_EQ, EXPECT_TRUE, folly::io::getAutoUncompressionCodec(), string, folly::io::USER_DEFINED, and folly::IOBuf::wrapBuffer().

                                                      {
   std::string const original = "abc";
   auto const compressed = codec_->compress(original);
 
   // Sanity check: the automatic codec can uncompress the original string.
   auto const uncompressed = auto_->uncompress(compressed);
   EXPECT_EQ(uncompressed, original);
 
   // Truncate the compressed string.
   auto const truncated = compressed.substr(0, compressed.size() - 1);
   auto const truncatedBuf =
       IOBuf::wrapBuffer(truncated.data(), truncated.size());
   EXPECT_TRUE(auto_->canUncompress(truncatedBuf.get()));
   EXPECT_ANY_THROW(auto_->uncompress(truncated));
 
   // Expect the terminal codec to successfully uncompress the string.
   std::unique_ptr<Codec> terminal = getAutoUncompressionCodec(
       {}, ConstantCodec::create("dummyString", CodecType::USER_DEFINED));
   EXPECT_TRUE(terminal->canUncompress(truncatedBuf.get()));
   EXPECT_EQ(terminal->uncompress(truncated), "dummyString");
 }

folly::io::test::TEST_P	(	TerminalCodecTest	,
		terminalOverridesDefaults
	)

Definition at line 1312 of file CompressionTest.cpp.

References codec_, EXPECT_EQ, folly::io::getAutoUncompressionCodec(), INSTANTIATE_TEST_CASE_P(), and string.

                                                      {
   std::unique_ptr<Codec> terminal = getAutoUncompressionCodec(
       {}, ConstantCodec::create("dummyString", codecType_));
   std::string const original = "abc";
   auto const compressed = codec_->compress(original);
   EXPECT_EQ(terminal->uncompress(compressed), "dummyString");
 }

static std::pair<bool, std::unique_ptr<IOBuf> > folly::io::test::uncompressSome	(	StreamCodec *	codec,
		ByteRange &	data,
		uint64_t	bufferSize,
		StreamCodec::FlushOp	flush
	)

static

Definition at line 840 of file CompressionTest.cpp.

References folly::IOBufQueue::append(), buffer(), folly::IOBuf::create(), folly::IOBufQueue::move(), folly::gen::move, gmock_output_test::output, folly::IOBufQueue::tailroom(), and folly::io::StreamCodec::uncompressStream().

Referenced by folly::io::test::StreamingCompressionTest::runFlushTest(), and folly::io::test::StreamingCompressionTest::runUncompressStreamTest().

                               {
   bool result;
   IOBufQueue queue;
   do {
     auto buffer = IOBuf::create(bufferSize);
     buffer->append(buffer->capacity());
     MutableByteRange output{buffer->writableData(), buffer->length()};
 
     result = codec->uncompressStream(data, output, flush);
     buffer->trimEnd(output.size());
     queue.append(std::move(buffer));
 
   } while (queue.tailroom() == 0 && !result);
   return std::make_pair(result, queue.move());
 }

Variable Documentation

ConstantDataHolder folly::io::test::constantDataHolder(dataSizeLog2)

Referenced by TEST(), and TEST_P().

constexpr size_t folly::io::test::dataSizeLog2 = 27

Definition at line 129 of file CompressionTest.cpp.

RandomDataHolder folly::io::test::randomDataHolder(dataSizeLog2)

Referenced by TEST(), and TEST_P().

Classes

Functions

Variables

Function Documentation

Variable Documentation