Quelle  TestSnappyStreams.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gtest/gtest.h"
#include "Helpers.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/SnappyCompressOutputStream.h"
#include "mozilla/SnappyUncompressInputStream.h"
#include "nsIPipe.h"
#include "nsStreamUtils.h"
#include "nsString.h"
#include "nsStringStream.h"
#include "nsTArray.h"

#include "snappy/snappy.h"

namespace {

using mozilla::SnappyCompressOutputStream;
using mozilla::SnappyUncompressInputStream;

static already_AddRefed<nsIOutputStream> CompressPipe(
    nsIInputStream** aReaderOut) {
  nsCOMPtr<nsIOutputStream> pipeWriter;
  NS_NewPipe(aReaderOut, getter_AddRefs(pipeWriter));

  nsCOMPtr<nsIOutputStream> compress =
      new SnappyCompressOutputStream(pipeWriter);
  return compress.forget();
}

// Verify the given number of bytes compresses to a smaller number of bytes.
static void TestCompress(uint32_t aNumBytes) {
  // Don't permit this test on small data sizes as snappy can slightly
  // bloat very small content.
  ASSERT_GT(aNumBytes, 1024u);

  nsCOMPtr<nsIInputStream> pipeReader;
  nsCOMPtr<nsIOutputStream> compress = CompressPipe(getter_AddRefs(pipeReader));
  ASSERT_TRUE(compress);

  nsTArray<char> inputData;
  testing::CreateData(aNumBytes, inputData);

  testing::WriteAllAndClose(compress, inputData);

  nsAutoCString outputData;
  nsresult rv = NS_ConsumeStream(pipeReader, UINT32_MAX, outputData);
  ASSERT_NS_SUCCEEDED(rv);

  ASSERT_LT(outputData.Length(), inputData.Length());
}

// Verify that the given number of bytes can be compressed and uncompressed
// successfully.
static void TestCompressUncompress(uint32_t aNumBytes) {
  nsCOMPtr<nsIInputStream> pipeReader;
  nsCOMPtr<nsIOutputStream> compress = CompressPipe(getter_AddRefs(pipeReader));
  ASSERT_TRUE(compress);

  nsCOMPtr<nsIInputStream> uncompress =
      new SnappyUncompressInputStream(pipeReader);

  nsTArray<char> inputData;
  testing::CreateData(aNumBytes, inputData);

  testing::WriteAllAndClose(compress, inputData);

  nsAutoCString outputData;
  nsresult rv = NS_ConsumeStream(uncompress, UINT32_MAX, outputData);
  ASSERT_NS_SUCCEEDED(rv);

  ASSERT_EQ(inputData.Length(), outputData.Length());
  for (uint32_t i = 0; i < inputData.Length(); ++i) {
    EXPECT_EQ(inputData[i], outputData.get()[i]) << "Byte " << i;
  }
}

static void TestUncompressCorrupt(const char* aCorruptData,
                                  uint32_t aCorruptLength) {
  nsCOMPtr<nsIInputStream> source;
  nsresult rv = NS_NewByteInputStream(
      getter_AddRefs(source), mozilla::Span(aCorruptData, aCorruptLength),
      NS_ASSIGNMENT_DEPEND);
  ASSERT_NS_SUCCEEDED(rv);

  nsCOMPtr<nsIInputStream> uncompress = new SnappyUncompressInputStream(source);

  nsAutoCString outputData;
  rv = NS_ConsumeStream(uncompress, UINT32_MAX, outputData);
  ASSERT_EQ(NS_ERROR_CORRUPTED_CONTENT, rv);
}

}  // namespace

TEST(SnappyStream, Compress_32k)
{
  TestCompress(32 * 1024);
}

TEST(SnappyStream, Compress_64k)
{
  TestCompress(64 * 1024);
}

TEST(SnappyStream, Compress_128k)
{
  TestCompress(128 * 1024);
}

TEST(SnappyStream, CompressUncompress_0)
{
  TestCompressUncompress(0);
}

TEST(SnappyStream, CompressUncompress_1)
{
  TestCompressUncompress(1);
}

TEST(SnappyStream, CompressUncompress_32)
{
  TestCompressUncompress(32);
}

TEST(SnappyStream, CompressUncompress_1k)
{
  TestCompressUncompress(1024);
}

TEST(SnappyStream, CompressUncompress_32k)
{
  TestCompressUncompress(32 * 1024);
}

TEST(SnappyStream, CompressUncompress_64k)
{
  TestCompressUncompress(64 * 1024);
}

TEST(SnappyStream, CompressUncompress_128k)
{
  TestCompressUncompress(128 * 1024);
}

// Test buffers that are not exactly power-of-2 in length to try to
// exercise more edge cases.  The number 13 is arbitrary.

TEST(SnappyStream, CompressUncompress_256k_less_13)
{
  TestCompressUncompress((256 * 1024) - 13);
}

TEST(SnappyStream, CompressUncompress_256k)
{
  TestCompressUncompress(256 * 1024);
}

TEST(SnappyStream, CompressUncompress_256k_plus_13)
{
  TestCompressUncompress((256 * 1024) + 13);
}

TEST(SnappyStream, UncompressCorruptStreamIdentifier)
{
  static const char data[] = "This is not a valid compressed stream";
  TestUncompressCorrupt(data, strlen(data));
}

TEST(SnappyStream, UncompressCorruptCompressedDataLength)
{
  static const char data[] =
      "\xff\x06\x00\x00sNaPpY"  // stream identifier
      "\x00\x99\x00\x00This is not a valid compressed stream";
  static const uint32_t dataLength = (sizeof(data) / sizeof(const char)) - 1;
  TestUncompressCorrupt(data, dataLength);
}

TEST(SnappyStream, UncompressCorruptCompressedDataContent)
{
  static const char data[] =
      "\xff\x06\x00\x00sNaPpY"  // stream identifier
      "\x00\x25\x00\x00This is not a valid compressed stream";
  static const uint32_t dataLength = (sizeof(data) / sizeof(const char)) - 1;
  TestUncompressCorrupt(data, dataLength);
}

TEST(SnappyStream, UncompressCorruptCompressDataLengthTooLarge)
{
  uint32_t compressedBufferLength =
      mozilla::detail::SnappyFrameUtils::MaxCompressedBufferLength(
          snappy::kBlockSize);
  uint32_t badLength = compressedBufferLength * 2;

  std::vector<char> data;
  static const char streamIdentifier[] = "\xff\x06\x00\x00sNaPpY";
  data.assign(std::begin(streamIdentifier), std::end(streamIdentifier) - 1);
  data.push_back(0);
  data.push_back(static_cast<char>(badLength));  // little-endian
  data.push_back(static_cast<char>(badLength >> 8));
  data.push_back(static_cast<char>(badLength >> 16));

  // Ensure there is actually enough data in the buffer to read
  // badLength bytes.
  data.resize(data.size() + badLength, 'X');

  TestUncompressCorrupt(data.data(), data.size());
}