tests/FrontBufferedStreamTest.cpp - skia - Git at Google

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 // Make sure SkUserConfig.h is included so #defines are available on
 // Android.
 #include "include/core/SkTypes.h"
 #ifdef SK_ENABLE_ANDROID_UTILS
 #include "client_utils/android/FrontBufferedStream.h"
 #include "include/codec/SkCodec.h"
 #include "include/core/SkBitmap.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkStream.h"
 #include "src/base/SkAutoMalloc.h"
 #include "tests/Test.h"

 static void test_read(skiatest::Reporter* reporter, SkStream* bufferedStream,
                       const void* expectations, size_t bytesToRead) {
     // output for reading bufferedStream.
     SkAutoMalloc storage(bytesToRead);

     const size_t bytesRead = bufferedStream->read(storage.get(), bytesToRead);
     REPORTER_ASSERT(reporter, bytesRead == bytesToRead || bufferedStream->isAtEnd());
     REPORTER_ASSERT(reporter, memcmp(storage.get(), expectations, bytesRead) == 0);
 }

 static void test_rewind(skiatest::Reporter* reporter,
                         SkStream* bufferedStream, bool shouldSucceed) {
     const bool success = bufferedStream->rewind();
     REPORTER_ASSERT(reporter, success == shouldSucceed);
 }

 // Test that hasLength() returns the correct value, based on the stream
 // being wrapped. A length can only be known if the wrapped stream has a
 // length and it has a position (so its initial position can be taken into
 // account when computing the length).
 static void test_hasLength(skiatest::Reporter* reporter,
                            const SkStream& bufferedStream,
                            const SkStream& streamBeingBuffered) {
     if (streamBeingBuffered.hasLength() && streamBeingBuffered.hasPosition()) {
         REPORTER_ASSERT(reporter, bufferedStream.hasLength());
     } else {
         REPORTER_ASSERT(reporter, !bufferedStream.hasLength());
     }
 }

 // All tests will buffer this string, and compare output to the original.
 // The string is long to ensure that all of our lengths being tested are
 // smaller than the string length.
 const char gAbcs[] = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx";

 // Tests reading the stream across boundaries of what has been buffered so far and what
 // the total buffer size is.
 static void test_incremental_buffering(skiatest::Reporter* reporter, size_t bufferSize) {
     // NOTE: For this and other tests in this file, we cheat and continue to refer to the
     // wrapped stream, but that's okay because we know the wrapping stream has not been
     // deleted yet (and we only call const methods in it).
     SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();

     auto bufferedStream = android::skia::FrontBufferedStream::Make(
             std::unique_ptr<SkStream>(memStream), bufferSize);

     test_hasLength(reporter, *bufferedStream, *memStream);

     // First, test reading less than the max buffer size.
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 2);

     // Now test rewinding back to the beginning and reading less than what was
     // already buffered.
     test_rewind(reporter, bufferedStream.get(), true);
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 4);

     // Now test reading part of what was buffered, and buffering new data.
     test_read(reporter, bufferedStream.get(), gAbcs + bufferSize / 4, bufferSize / 2);

     // Now test reading what was buffered, buffering new data, and
     // reading directly from the stream.
     test_rewind(reporter, bufferedStream.get(), true);
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize << 1);

     // We have reached the end of the buffer, so rewinding will fail.
     // This test assumes that the stream is larger than the buffer; otherwise the
     // result of rewind should be true.
     test_rewind(reporter, bufferedStream.get(), false);
 }

 static void test_perfectly_sized_buffer(skiatest::Reporter* reporter, size_t bufferSize) {
     SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
     auto bufferedStream = android::skia::FrontBufferedStream::Make(
             std::unique_ptr<SkStream>(memStream), bufferSize);
     test_hasLength(reporter, *bufferedStream, *memStream);

     // Read exactly the amount that fits in the buffer.
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);

     // Rewinding should succeed.
     test_rewind(reporter, bufferedStream.get(), true);

     // Once again reading buffered info should succeed
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);

     // Read past the size of the buffer. At this point, we cannot return.
     test_read(reporter, bufferedStream.get(), gAbcs + memStream->getPosition(), 1);
     test_rewind(reporter, bufferedStream.get(), false);
 }

 static void test_skipping(skiatest::Reporter* reporter, size_t bufferSize) {
     SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
     auto bufferedStream = android::skia::FrontBufferedStream::Make(
         std::unique_ptr<SkStream>(memStream), bufferSize);
     test_hasLength(reporter, *bufferedStream, *memStream);

     // Skip half the buffer.
     bufferedStream->skip(bufferSize / 2);

     // Rewind, then read part of the buffer, which should have been read.
     test_rewind(reporter, bufferedStream.get(), true);
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 4);

     // Now skip beyond the buffered piece, but still within the total buffer.
     bufferedStream->skip(bufferSize / 2);

     // Test that reading will still work.
     test_read(reporter, bufferedStream.get(), gAbcs + memStream->getPosition(), bufferSize / 4);

     test_rewind(reporter, bufferedStream.get(), true);
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
 }

 // A custom class whose isAtEnd behaves the way Android's stream does - since it is an adaptor to a
 // Java InputStream, it does not know that it is at the end until it has attempted to read beyond
 // the end and failed. Used by test_read_beyond_buffer.
 class AndroidLikeMemoryStream : public SkMemoryStream {
 public:
     AndroidLikeMemoryStream(void* data, size_t size, bool ownMemory)
         : INHERITED(data, size, ownMemory)
         , fIsAtEnd(false) {}

     size_t read(void* dst, size_t requested) override {
         size_t bytesRead = this->INHERITED::read(dst, requested);
         if (bytesRead < requested) {
             fIsAtEnd = true;
         }
         return bytesRead;
     }

     bool isAtEnd() const override {
         return fIsAtEnd;
     }

 private:
     bool fIsAtEnd;
     using INHERITED = SkMemoryStream;
 };

 // This test ensures that buffering the exact length of the stream and attempting to read beyond it
 // does not invalidate the buffer.
 static void test_read_beyond_buffer(skiatest::Reporter* reporter, size_t bufferSize) {
     // Use a stream that behaves like Android's stream.
     AndroidLikeMemoryStream* memStream =
             new AndroidLikeMemoryStream((void*)gAbcs, bufferSize, false);

     // Create a buffer that matches the length of the stream.
     auto bufferedStream = android::skia::FrontBufferedStream::Make(
             std::unique_ptr<SkStream>(memStream), bufferSize);
     test_hasLength(reporter, *bufferedStream, *memStream);

     // Attempt to read one more than the bufferSize
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize + 1);
     test_rewind(reporter, bufferedStream.get(), true);

     // Ensure that the initial read did not invalidate the buffer.
     test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
 }

 // Mock stream that optionally has a length and/or position. Tests that FrontBufferedStream's
 // length depends on the stream it's buffering having a length and position.
 class LengthOptionalStream : public SkStream {
 public:
     LengthOptionalStream(bool hasLength, bool hasPosition)
         : fHasLength(hasLength)
         , fHasPosition(hasPosition)
     {}

     bool hasLength() const override {
         return fHasLength;
     }

     bool hasPosition() const override {
         return fHasPosition;
     }

     size_t read(void*, size_t) override {
         return 0;
     }

     bool isAtEnd() const override {
         return true;
     }

 private:
     const bool fHasLength;
     const bool fHasPosition;
 };

 // Test all possible combinations of the wrapped stream having a length and a position.
 static void test_length_combos(skiatest::Reporter* reporter, size_t bufferSize) {
     for (int hasLen = 0; hasLen <= 1; hasLen++) {
         for (int hasPos = 0; hasPos <= 1; hasPos++) {
             LengthOptionalStream* stream =
                     new LengthOptionalStream(SkToBool(hasLen), SkToBool(hasPos));
             auto buffered = android::skia::FrontBufferedStream::Make(
                     std::unique_ptr<SkStream>(stream), bufferSize);
             test_hasLength(reporter, *buffered, *stream);
         }
     }
 }

 // Test using a stream with an initial offset.
 static void test_initial_offset(skiatest::Reporter* reporter, size_t bufferSize) {
     SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);

     // Skip a few characters into the memStream, so that bufferedStream represents an offset into
     // the stream it wraps.
     const size_t arbitraryOffset = 17;
     memStream->skip(arbitraryOffset);
     auto bufferedStream = android::skia::FrontBufferedStream::Make(
             std::unique_ptr<SkStream>(memStream), bufferSize);

     // Since SkMemoryStream has a length, bufferedStream must also.
     REPORTER_ASSERT(reporter, bufferedStream->hasLength());

     const size_t amountToRead = 10;
     const size_t bufferedLength = bufferedStream->getLength();
     size_t currentPosition = 0;

     // Read the stream in chunks. After each read, the position must match currentPosition,
     // which sums the amount attempted to read, unless the end of the stream has been reached.
     // Importantly, the end should not have been reached until currentPosition == bufferedLength.
     while (currentPosition < bufferedLength) {
         REPORTER_ASSERT(reporter, !bufferedStream->isAtEnd());
         test_read(reporter, bufferedStream.get(), gAbcs + arbitraryOffset + currentPosition,
                   amountToRead);
         currentPosition = std::min(currentPosition + amountToRead, bufferedLength);
         REPORTER_ASSERT(reporter, memStream->getPosition() - arbitraryOffset == currentPosition);
     }
     REPORTER_ASSERT(reporter, bufferedStream->isAtEnd());
     REPORTER_ASSERT(reporter, bufferedLength == currentPosition);
 }

 static void test_buffers(skiatest::Reporter* reporter, size_t bufferSize) {
     test_incremental_buffering(reporter, bufferSize);
     test_perfectly_sized_buffer(reporter, bufferSize);
     test_skipping(reporter, bufferSize);
     test_read_beyond_buffer(reporter, bufferSize);
     test_length_combos(reporter, bufferSize);
     test_initial_offset(reporter, bufferSize);
 }

 DEF_TEST(FrontBufferedStream, reporter) {
     // Test 6 and 64, which are used by Android, as well as another arbitrary length.
     test_buffers(reporter, 6);
     test_buffers(reporter, 15);
     test_buffers(reporter, 64);
 }

 // Test that a FrontBufferedStream does not allow reading after the end of a stream.
 // This class is a mock SkStream which reports that it is at the end on the first
 // read (simulating a failure). Then it tracks whether someone calls read() again.
 class FailingStream : public SkStream {
 public:
     FailingStream()
     : fAtEnd(false)
     {}

     size_t read(void* buffer, size_t size) override {
         SkASSERT(!fAtEnd);
         fAtEnd = true;
         return 0;
     }

     bool isAtEnd() const override {
         return fAtEnd;
     }

 private:
     bool fAtEnd;
 };

 DEF_TEST(ShortFrontBufferedStream, reporter) {
     FailingStream* failingStream = new FailingStream;
     auto stream = android::skia::FrontBufferedStream::Make(
             std::unique_ptr<SkStream>(failingStream), 64);

     // This will fail to create a codec.  However, what we really want to test is that we
     // won't read past the end of the stream.
     std::unique_ptr<SkCodec> codec(SkCodec::MakeFromStream(std::move(stream)));
 }
 #endif // SK_ENABLE_ANDROID_UTILS
	/*
	* Copyright 2013 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	// Make sure SkUserConfig.h is included so #defines are available on
	// Android.
	#include "include/core/SkTypes.h"
	#ifdef SK_ENABLE_ANDROID_UTILS
	#include "client_utils/android/FrontBufferedStream.h"
	#include "include/codec/SkCodec.h"
	#include "include/core/SkBitmap.h"
	#include "include/core/SkRefCnt.h"
	#include "include/core/SkStream.h"
	#include "src/base/SkAutoMalloc.h"
	#include "tests/Test.h"

	static void test_read(skiatest::Reporter* reporter, SkStream* bufferedStream,
	const void* expectations, size_t bytesToRead) {
	// output for reading bufferedStream.
	SkAutoMalloc storage(bytesToRead);

	const size_t bytesRead = bufferedStream->read(storage.get(), bytesToRead);
	REPORTER_ASSERT(reporter, bytesRead == bytesToRead \|\| bufferedStream->isAtEnd());
	REPORTER_ASSERT(reporter, memcmp(storage.get(), expectations, bytesRead) == 0);
	}

	static void test_rewind(skiatest::Reporter* reporter,
	SkStream* bufferedStream, bool shouldSucceed) {
	const bool success = bufferedStream->rewind();
	REPORTER_ASSERT(reporter, success == shouldSucceed);
	}

	// Test that hasLength() returns the correct value, based on the stream
	// being wrapped. A length can only be known if the wrapped stream has a
	// length and it has a position (so its initial position can be taken into
	// account when computing the length).
	static void test_hasLength(skiatest::Reporter* reporter,
	const SkStream& bufferedStream,
	const SkStream& streamBeingBuffered) {
	if (streamBeingBuffered.hasLength() && streamBeingBuffered.hasPosition()) {
	REPORTER_ASSERT(reporter, bufferedStream.hasLength());
	} else {
	REPORTER_ASSERT(reporter, !bufferedStream.hasLength());
	}
	}

	// All tests will buffer this string, and compare output to the original.
	// The string is long to ensure that all of our lengths being tested are
	// smaller than the string length.
	const char gAbcs[] = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx";

	// Tests reading the stream across boundaries of what has been buffered so far and what
	// the total buffer size is.
	static void test_incremental_buffering(skiatest::Reporter* reporter, size_t bufferSize) {
	// NOTE: For this and other tests in this file, we cheat and continue to refer to the
	// wrapped stream, but that's okay because we know the wrapping stream has not been
	// deleted yet (and we only call const methods in it).
	SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();

	auto bufferedStream = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(memStream), bufferSize);

	test_hasLength(reporter, bufferedStream, memStream);

	// First, test reading less than the max buffer size.
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 2);

	// Now test rewinding back to the beginning and reading less than what was
	// already buffered.
	test_rewind(reporter, bufferedStream.get(), true);
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 4);

	// Now test reading part of what was buffered, and buffering new data.
	test_read(reporter, bufferedStream.get(), gAbcs + bufferSize / 4, bufferSize / 2);

	// Now test reading what was buffered, buffering new data, and
	// reading directly from the stream.
	test_rewind(reporter, bufferedStream.get(), true);
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize << 1);

	// We have reached the end of the buffer, so rewinding will fail.
	// This test assumes that the stream is larger than the buffer; otherwise the
	// result of rewind should be true.
	test_rewind(reporter, bufferedStream.get(), false);
	}

	static void test_perfectly_sized_buffer(skiatest::Reporter* reporter, size_t bufferSize) {
	SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
	auto bufferedStream = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(memStream), bufferSize);
	test_hasLength(reporter, bufferedStream, memStream);

	// Read exactly the amount that fits in the buffer.
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);

	// Rewinding should succeed.
	test_rewind(reporter, bufferedStream.get(), true);

	// Once again reading buffered info should succeed
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);

	// Read past the size of the buffer. At this point, we cannot return.
	test_read(reporter, bufferedStream.get(), gAbcs + memStream->getPosition(), 1);
	test_rewind(reporter, bufferedStream.get(), false);
	}

	static void test_skipping(skiatest::Reporter* reporter, size_t bufferSize) {
	SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
	auto bufferedStream = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(memStream), bufferSize);
	test_hasLength(reporter, bufferedStream, memStream);

	// Skip half the buffer.
	bufferedStream->skip(bufferSize / 2);

	// Rewind, then read part of the buffer, which should have been read.
	test_rewind(reporter, bufferedStream.get(), true);
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 4);

	// Now skip beyond the buffered piece, but still within the total buffer.
	bufferedStream->skip(bufferSize / 2);

	// Test that reading will still work.
	test_read(reporter, bufferedStream.get(), gAbcs + memStream->getPosition(), bufferSize / 4);

	test_rewind(reporter, bufferedStream.get(), true);
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
	}

	// A custom class whose isAtEnd behaves the way Android's stream does - since it is an adaptor to a
	// Java InputStream, it does not know that it is at the end until it has attempted to read beyond
	// the end and failed. Used by test_read_beyond_buffer.
	class AndroidLikeMemoryStream : public SkMemoryStream {
	public:
	AndroidLikeMemoryStream(void* data, size_t size, bool ownMemory)
	: INHERITED(data, size, ownMemory)
	, fIsAtEnd(false) {}

	size_t read(void* dst, size_t requested) override {
	size_t bytesRead = this->INHERITED::read(dst, requested);
	if (bytesRead < requested) {
	fIsAtEnd = true;
	}
	return bytesRead;
	}

	bool isAtEnd() const override {
	return fIsAtEnd;
	}

	private:
	bool fIsAtEnd;
	using INHERITED = SkMemoryStream;
	};

	// This test ensures that buffering the exact length of the stream and attempting to read beyond it
	// does not invalidate the buffer.
	static void test_read_beyond_buffer(skiatest::Reporter* reporter, size_t bufferSize) {
	// Use a stream that behaves like Android's stream.
	AndroidLikeMemoryStream* memStream =
	new AndroidLikeMemoryStream((void*)gAbcs, bufferSize, false);

	// Create a buffer that matches the length of the stream.
	auto bufferedStream = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(memStream), bufferSize);
	test_hasLength(reporter, bufferedStream, memStream);

	// Attempt to read one more than the bufferSize
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize + 1);
	test_rewind(reporter, bufferedStream.get(), true);

	// Ensure that the initial read did not invalidate the buffer.
	test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
	}

	// Mock stream that optionally has a length and/or position. Tests that FrontBufferedStream's
	// length depends on the stream it's buffering having a length and position.
	class LengthOptionalStream : public SkStream {
	public:
	LengthOptionalStream(bool hasLength, bool hasPosition)
	: fHasLength(hasLength)
	, fHasPosition(hasPosition)
	{}

	bool hasLength() const override {
	return fHasLength;
	}

	bool hasPosition() const override {
	return fHasPosition;
	}

	size_t read(void*, size_t) override {
	return 0;
	}

	bool isAtEnd() const override {
	return true;
	}

	private:
	const bool fHasLength;
	const bool fHasPosition;
	};

	// Test all possible combinations of the wrapped stream having a length and a position.
	static void test_length_combos(skiatest::Reporter* reporter, size_t bufferSize) {
	for (int hasLen = 0; hasLen <= 1; hasLen++) {
	for (int hasPos = 0; hasPos <= 1; hasPos++) {
	LengthOptionalStream* stream =
	new LengthOptionalStream(SkToBool(hasLen), SkToBool(hasPos));
	auto buffered = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(stream), bufferSize);
	test_hasLength(reporter, buffered, stream);
	}
	}
	}

	// Test using a stream with an initial offset.
	static void test_initial_offset(skiatest::Reporter* reporter, size_t bufferSize) {
	SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);

	// Skip a few characters into the memStream, so that bufferedStream represents an offset into
	// the stream it wraps.
	const size_t arbitraryOffset = 17;
	memStream->skip(arbitraryOffset);
	auto bufferedStream = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(memStream), bufferSize);

	// Since SkMemoryStream has a length, bufferedStream must also.
	REPORTER_ASSERT(reporter, bufferedStream->hasLength());

	const size_t amountToRead = 10;
	const size_t bufferedLength = bufferedStream->getLength();
	size_t currentPosition = 0;

	// Read the stream in chunks. After each read, the position must match currentPosition,
	// which sums the amount attempted to read, unless the end of the stream has been reached.
	// Importantly, the end should not have been reached until currentPosition == bufferedLength.
	while (currentPosition < bufferedLength) {
	REPORTER_ASSERT(reporter, !bufferedStream->isAtEnd());
	test_read(reporter, bufferedStream.get(), gAbcs + arbitraryOffset + currentPosition,
	amountToRead);
	currentPosition = std::min(currentPosition + amountToRead, bufferedLength);
	REPORTER_ASSERT(reporter, memStream->getPosition() - arbitraryOffset == currentPosition);
	}
	REPORTER_ASSERT(reporter, bufferedStream->isAtEnd());
	REPORTER_ASSERT(reporter, bufferedLength == currentPosition);
	}

	static void test_buffers(skiatest::Reporter* reporter, size_t bufferSize) {
	test_incremental_buffering(reporter, bufferSize);
	test_perfectly_sized_buffer(reporter, bufferSize);
	test_skipping(reporter, bufferSize);
	test_read_beyond_buffer(reporter, bufferSize);
	test_length_combos(reporter, bufferSize);
	test_initial_offset(reporter, bufferSize);
	}

	DEF_TEST(FrontBufferedStream, reporter) {
	// Test 6 and 64, which are used by Android, as well as another arbitrary length.
	test_buffers(reporter, 6);
	test_buffers(reporter, 15);
	test_buffers(reporter, 64);
	}

	// Test that a FrontBufferedStream does not allow reading after the end of a stream.
	// This class is a mock SkStream which reports that it is at the end on the first
	// read (simulating a failure). Then it tracks whether someone calls read() again.
	class FailingStream : public SkStream {
	public:
	FailingStream()
	: fAtEnd(false)
	{}

	size_t read(void* buffer, size_t size) override {
	SkASSERT(!fAtEnd);
	fAtEnd = true;
	return 0;
	}

	bool isAtEnd() const override {
	return fAtEnd;
	}

	private:
	bool fAtEnd;
	};

	DEF_TEST(ShortFrontBufferedStream, reporter) {
	FailingStream* failingStream = new FailingStream;
	auto stream = android::skia::FrontBufferedStream::Make(
	std::unique_ptr<SkStream>(failingStream), 64);

	// This will fail to create a codec. However, what we really want to test is that we
	// won't read past the end of the stream.
	std::unique_ptr<SkCodec> codec(SkCodec::MakeFromStream(std::move(stream)));
	}
	#endif // SK_ENABLE_ANDROID_UTILS