folly::io::test::StreamingCompressionTest Class Reference

Inheritance diagram for folly::io::test::StreamingCompressionTest:

Protected Member Functions
bool	hasFlush () const
void	SetUp () override
void	runResetStreamTest (DataHolder const &dh)
void	runCompressStreamTest (DataHolder const &dh)
void	runUncompressStreamTest (DataHolder const &dh)
void	runFlushTest (DataHolder const &dh)

Private Member Functions
std::vector< ByteRange >	split (ByteRange data) const

Private Attributes
uint64_t	uncompressedLength_
size_t	chunkSize_
std::unique_ptr< StreamCodec >	codec_

Detailed Description

Definition at line 780 of file CompressionTest.cpp.

Member Function Documentation

bool folly::io::test::StreamingCompressionTest::hasFlush ( ) const

inlineprotected

Definition at line 783 of file CompressionTest.cpp.

References folly::io::test::codecHasFlush().

                        {
    return codecHasFlush(std::get<2>(GetParam()));
  }

void folly::io::test::StreamingCompressionTest::runCompressStreamTest ( DataHolder const &  dh )

protected

Definition at line 882 of file CompressionTest.cpp.

References codec_, folly::io::test::compressSome(), folly::io::test::DataHolder::data(), folly::empty(), folly::io::StreamCodec::END, EXPECT_EQ, folly::io::test::DataHolder::hash(), folly::io::test::hashIOBuf(), folly::io::StreamCodec::NONE, and folly::split().

                                     {
  auto const inputs = split(dh.data(uncompressedLength_));

  IOBufQueue queue;
  codec_->resetStream(uncompressedLength_);
  // Compress many inputs in a row
  for (auto const input : inputs) {
    queue.append(compressSome(
        codec_.get(), input, chunkSize_, StreamCodec::FlushOp::NONE));
  }
  // Finish the operation with empty input.
  ByteRange empty;
  queue.append(
      compressSome(codec_.get(), empty, chunkSize_, StreamCodec::FlushOp::END));

  auto const uncompressed = codec_->uncompress(queue.front());
  EXPECT_EQ(dh.hash(uncompressedLength_), hashIOBuf(uncompressed.get()));
}

void folly::io::test::StreamingCompressionTest::runFlushTest ( DataHolder const &  dh )

protected

Definition at line 948 of file CompressionTest.cpp.

References codec_, folly::io::test::compressSome(), folly::io::test::DataHolder::data(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::io::StreamCodec::FLUSH, folly::io::getStreamCodec(), folly::io::test::hashIOBuf(), folly::split(), folly::io::test::uncompressSome(), and folly::IOBuf::wrapBuffer().

                                                                {
  auto const inputs = split(dh.data(uncompressedLength_));
  auto uncodec = getStreamCodec(codec_->type());

  if (codec_->needsDataLength()) {
    codec_->resetStream(uncompressedLength_);
  } else {
    codec_->resetStream();
  }
  for (auto input : inputs) {
    // Compress some data and flush the stream
    auto compressed = compressSome(
        codec_.get(), input, chunkSize_, StreamCodec::FlushOp::FLUSH);
    auto compressedRange = compressed->coalesce();
    // Uncompress the compressed data
    auto result = uncompressSome(
        uncodec.get(),
        compressedRange,
        chunkSize_,
        StreamCodec::FlushOp::FLUSH);
    // All compressed data should have been consumed
    EXPECT_TRUE(compressedRange.empty());
    // The frame isn't complete
    EXPECT_FALSE(result.first);
    // The uncompressed data should be exactly the input data
    EXPECT_EQ(input.size(), result.second->computeChainDataLength());
    auto const data = IOBuf::wrapBuffer(input);
    EXPECT_EQ(hashIOBuf(data.get()), hashIOBuf(result.second.get()));
  }
}

void folly::io::test::StreamingCompressionTest::runResetStreamTest ( DataHolder const &  dh )

protected

Definition at line 860 of file CompressionTest.cpp.

References codec_, folly::io::test::compressSome(), folly::io::test::DataHolder::data(), folly::io::StreamCodec::END, EXPECT_EQ, folly::io::test::DataHolder::hash(), folly::io::test::hashIOBuf(), and folly::io::StreamCodec::NONE.

                                                                      {
  auto const input = dh.data(uncompressedLength_);
  // Compress some but leave state unclean
  codec_->resetStream(uncompressedLength_);
  compressSome(codec_.get(), input, chunkSize_, StreamCodec::FlushOp::NONE);
  // Reset stream and compress all
  if (codec_->needsDataLength()) {
    codec_->resetStream(uncompressedLength_);
  } else {
    codec_->resetStream();
  }
  auto compressed =
      compressSome(codec_.get(), input, chunkSize_, StreamCodec::FlushOp::END);
  auto const uncompressed = codec_->uncompress(compressed.get(), input.size());
  EXPECT_EQ(dh.hash(uncompressedLength_), hashIOBuf(uncompressed.get()));
}

void folly::io::test::StreamingCompressionTest::runUncompressStreamTest ( DataHolder const &  dh )

protected

Definition at line 907 of file CompressionTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, codec_, folly::io::test::DataHolder::data(), folly::io::StreamCodec::END, EXPECT_TRUE, folly::io::StreamCodec::FLUSH, folly::io::test::hashIOBuf(), folly::io::StreamCodec::NONE, folly::io::test::uncompressSome(), and folly::IOBuf::wrapBuffer().

                                     {
  const auto flush =
      hasFlush() ? StreamCodec::FlushOp::FLUSH : StreamCodec::FlushOp::NONE;
  auto const data = IOBuf::wrapBuffer(dh.data(uncompressedLength_));
  // Concatenate 3 compressed frames in a row
  auto compressed = codec_->compress(data.get());
  compressed->prependChain(codec_->compress(data.get()));
  compressed->prependChain(codec_->compress(data.get()));
  // Pass all 3 compressed frames in one input buffer
  auto input = compressed->coalesce();
  // Uncompress the first frame
  codec_->resetStream(data->computeChainDataLength());
  {
    auto const result = uncompressSome(codec_.get(), input, chunkSize_, flush);
    ASSERT_TRUE(result.first);
    ASSERT_EQ(hashIOBuf(data.get()), hashIOBuf(result.second.get()));
  }
  // Uncompress the second frame
  codec_->resetStream();
  {
    auto const result = uncompressSome(
        codec_.get(), input, chunkSize_, StreamCodec::FlushOp::END);
    ASSERT_TRUE(result.first);
    ASSERT_EQ(hashIOBuf(data.get()), hashIOBuf(result.second.get()));
  }
  // Uncompress the third frame
  codec_->resetStream();
  {
    auto const result = uncompressSome(codec_.get(), input, chunkSize_, flush);
    ASSERT_TRUE(result.first);
    ASSERT_EQ(hashIOBuf(data.get()), hashIOBuf(result.second.get()));
  }
  EXPECT_TRUE(input.empty());
}

void folly::io::test::StreamingCompressionTest::SetUp ( )

inlineoverrideprotected

Definition at line 787 of file CompressionTest.cpp.

References codec_, folly::io::test::DataHolder::data(), folly::io::getStreamCodec(), folly::split(), and uint64_t.

                        {
    auto const tup = GetParam();
    uncompressedLength_ = uint64_t(1) << std::get<0>(tup);
    chunkSize_ = size_t(1) << std::get<1>(tup);
    codec_ = getStreamCodec(std::get<2>(tup));
  }

std::vector< ByteRange > folly::io::test::StreamingCompressionTest::split ( ByteRange  data ) const

private

Definition at line 807 of file CompressionTest.cpp.

References folly::Range< Iter >::empty(), min, folly::Range< Iter >::size(), folly::Range< Iter >::subpiece(), and folly::Range< Iter >::uncheckedAdvance().

                                                                         {
  size_t const pieces = std::max<size_t>(1, data.size() / chunkSize_);
  std::vector<ByteRange> result;
  result.reserve(pieces + 1);
  while (!data.empty()) {
    size_t const pieceSize = std::min(data.size(), chunkSize_);
    result.push_back(data.subpiece(0, pieceSize));
    data.uncheckedAdvance(pieceSize);
  }
  return result;
}

Member Data Documentation

size_t folly::io::test::StreamingCompressionTest::chunkSize_

private

Definition at line 803 of file CompressionTest.cpp.

std::unique_ptr<StreamCodec> folly::io::test::StreamingCompressionTest::codec_

private

Definition at line 804 of file CompressionTest.cpp.

uint64_t folly::io::test::StreamingCompressionTest::uncompressedLength_

private

Definition at line 802 of file CompressionTest.cpp.

---

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

• proxygen/folly/folly/compression/test/CompressionTest.cpp