tests/StreamTest.cpp - platform/external/skqp - Gitiles

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

 #include "Resources.h"
 #include "SkData.h"
 #include "SkFrontBufferedStream.h"
 #include "SkOSFile.h"
 #include "SkOSPath.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "SkStreamPriv.h"
 #include "Test.h"

 #ifndef SK_BUILD_FOR_WIN
 #include <unistd.h>
 #include <fcntl.h>
 #endif

 #define MAX_SIZE    (256 * 1024)

 static void test_loop_stream(skiatest::Reporter* reporter, SkStream* stream,
                              const void* src, size_t len, int repeat) {
     SkAutoSMalloc<256> storage(len);
     void* tmp = storage.get();

     for (int i = 0; i < repeat; ++i) {
         size_t bytes = stream->read(tmp, len);
         REPORTER_ASSERT(reporter, bytes == len);
         REPORTER_ASSERT(reporter, !memcmp(tmp, src, len));
     }

     // expect EOF
     size_t bytes = stream->read(tmp, 1);
     REPORTER_ASSERT(reporter, 0 == bytes);
     // isAtEnd might not return true until after the first failing read.
     REPORTER_ASSERT(reporter, stream->isAtEnd());
 }

 static void test_filestreams(skiatest::Reporter* reporter, const char* tmpDir) {
     SkString path = SkOSPath::Join(tmpDir, "wstream_test");

     const char s[] = "abcdefghijklmnopqrstuvwxyz";

     {
         SkFILEWStream writer(path.c_str());
         if (!writer.isValid()) {
             ERRORF(reporter, "Failed to create tmp file %s\n", path.c_str());
             return;
         }

         for (int i = 0; i < 100; ++i) {
             writer.write(s, 26);
         }
     }

     {
         SkFILEStream stream(path.c_str());
         REPORTER_ASSERT(reporter, stream.isValid());
         test_loop_stream(reporter, &stream, s, 26, 100);

         std::unique_ptr<SkStreamAsset> stream2(stream.duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }

     {
         FILE* file = ::fopen(path.c_str(), "rb");
         SkFILEStream stream(file, SkFILEStream::kCallerPasses_Ownership);
         REPORTER_ASSERT(reporter, stream.isValid());
         test_loop_stream(reporter, &stream, s, 26, 100);

         std::unique_ptr<SkStreamAsset> stream2(stream.duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }
 }

 static void TestWStream(skiatest::Reporter* reporter) {
     SkDynamicMemoryWStream  ds;
     const char s[] = "abcdefghijklmnopqrstuvwxyz";
     int i;
     for (i = 0; i < 100; i++) {
         REPORTER_ASSERT(reporter, ds.write(s, 26));
     }
     REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);

     char* dst = new char[100 * 26 + 1];
     dst[100*26] = '*';
     ds.copyTo(dst);
     REPORTER_ASSERT(reporter, dst[100*26] == '*');
     for (i = 0; i < 100; i++) {
         REPORTER_ASSERT(reporter, memcmp(&dst[i * 26], s, 26) == 0);
     }

     {
         std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
         REPORTER_ASSERT(reporter, 100 * 26 == stream->getLength());
         REPORTER_ASSERT(reporter, ds.getOffset() == 0);
         test_loop_stream(reporter, stream.get(), s, 26, 100);

         std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);

         std::unique_ptr<SkStreamAsset> stream3(stream->fork());
         REPORTER_ASSERT(reporter, stream3->isAtEnd());
         char tmp;
         size_t bytes = stream->read(&tmp, 1);
         REPORTER_ASSERT(reporter, 0 == bytes);
         stream3->rewind();
         test_loop_stream(reporter, stream3.get(), s, 26, 100);
     }

     for (i = 0; i < 100; i++) {
         REPORTER_ASSERT(reporter, ds.write(s, 26));
     }
     REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);

     {
         sk_sp<SkData> data = ds.snapshotAsData();
         REPORTER_ASSERT(reporter, 100 * 26 == data->size());
         REPORTER_ASSERT(reporter, memcmp(dst, data->data(), data->size()) == 0);
     }

     {
         // Test that this works after a snapshot.
         std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
         REPORTER_ASSERT(reporter, ds.getOffset() == 0);
         test_loop_stream(reporter, stream.get(), s, 26, 100);

         std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }
     delete[] dst;

     SkString tmpDir = skiatest::GetTmpDir();
     if (!tmpDir.isEmpty()) {
         test_filestreams(reporter, tmpDir.c_str());
     }
 }

 static void TestPackedUInt(skiatest::Reporter* reporter) {
     // we know that packeduint tries to write 1, 2 or 4 bytes for the length,
     // so we test values around each of those transitions (and a few others)
     const size_t sizes[] = {
         0, 1, 2, 0xFC, 0xFD, 0xFE, 0xFF, 0x100, 0x101, 32767, 32768, 32769,
         0xFFFD, 0xFFFE, 0xFFFF, 0x10000, 0x10001,
         0xFFFFFD, 0xFFFFFE, 0xFFFFFF, 0x1000000, 0x1000001,
         0x7FFFFFFE, 0x7FFFFFFF, 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF
     };


     size_t i;
     char buffer[sizeof(sizes) * 4];

     SkMemoryWStream wstream(buffer, sizeof(buffer));
     for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
         bool success = wstream.writePackedUInt(sizes[i]);
         REPORTER_ASSERT(reporter, success);
     }
     wstream.flush();

     SkMemoryStream rstream(buffer, sizeof(buffer));
     for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
         size_t n = rstream.readPackedUInt();
         if (sizes[i] != n) {
             ERRORF(reporter, "sizes:%x != n:%x\n", i, sizes[i], n);
         }
     }
 }

 // Test that setting an SkMemoryStream to a nullptr data does not result in a crash when calling
 // methods that access fData.
 static void TestDereferencingData(SkMemoryStream* memStream) {
     memStream->read(nullptr, 0);
     memStream->getMemoryBase();
     (void)memStream->asData();
 }

 static void TestNullData() {
     SkMemoryStream memStream(nullptr);
     TestDereferencingData(&memStream);

     memStream.setData(nullptr);
     TestDereferencingData(&memStream);

 }

 DEF_TEST(Stream, reporter) {
     TestWStream(reporter);
     TestPackedUInt(reporter);
     TestNullData();
 }

 #ifndef SK_BUILD_FOR_IOS
 /**
  *  Tests peeking and then reading the same amount. The two should provide the
  *  same results.
  *  Returns the amount successfully read minus the amount successfully peeked.
  */
 static size_t compare_peek_to_read(skiatest::Reporter* reporter,
                                    SkStream* stream, size_t bytesToPeek) {
     // The rest of our tests won't be very interesting if bytesToPeek is zero.
     REPORTER_ASSERT(reporter, bytesToPeek > 0);
     SkAutoMalloc peekStorage(bytesToPeek);
     SkAutoMalloc readStorage(bytesToPeek);
     void* peekPtr = peekStorage.get();
     void* readPtr = peekStorage.get();

     const size_t bytesPeeked = stream->peek(peekPtr, bytesToPeek);
     const size_t bytesRead = stream->read(readPtr, bytesToPeek);

     // bytesRead should only be less than attempted if the stream is at the
     // end.
     REPORTER_ASSERT(reporter, bytesRead == bytesToPeek || stream->isAtEnd());

     // peek and read should behave the same, except peek returned to the
     // original position, so they read the same data.
     REPORTER_ASSERT(reporter, !memcmp(peekPtr, readPtr, bytesPeeked));

     // A stream should never be able to peek more than it can read.
     REPORTER_ASSERT(reporter, bytesRead >= bytesPeeked);

     return bytesRead - bytesPeeked;
 }

 static void test_fully_peekable_stream(skiatest::Reporter* r, SkStream* stream, size_t limit) {
     for (size_t i = 1; !stream->isAtEnd(); i++) {
         REPORTER_ASSERT(r, compare_peek_to_read(r, stream, i) == 0);
     }
 }

 static void test_peeking_front_buffered_stream(skiatest::Reporter* r,
                                                const SkStream& original,
                                                size_t bufferSize) {
     SkStream* dupe = original.duplicate();
     REPORTER_ASSERT(r, dupe != nullptr);
     std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(dupe, bufferSize));
     REPORTER_ASSERT(r, bufferedStream != nullptr);

     size_t peeked = 0;
     for (size_t i = 1; !bufferedStream->isAtEnd(); i++) {
         const size_t unpeekableBytes = compare_peek_to_read(r, bufferedStream.get(), i);
         if (unpeekableBytes > 0) {
             // This could not have returned a number greater than i.
             REPORTER_ASSERT(r, unpeekableBytes <= i);

             // We have reached the end of the buffer. Verify that it was at least
             // bufferSize.
             REPORTER_ASSERT(r, peeked + i - unpeekableBytes >= bufferSize);
             // No more peeking is supported.
             break;
         }
         peeked += i;
     }

     // Test that attempting to peek beyond the length of the buffer does not prevent rewinding.
     bufferedStream.reset(SkFrontBufferedStream::Create(original.duplicate(), bufferSize));
     REPORTER_ASSERT(r, bufferedStream != nullptr);

     const size_t bytesToPeek = bufferSize + 1;
     SkAutoMalloc peekStorage(bytesToPeek);
     SkAutoMalloc readStorage(bytesToPeek);

     for (size_t start = 0; start <= bufferSize; start++) {
         // Skip to the starting point
         REPORTER_ASSERT(r, bufferedStream->skip(start) == start);

         const size_t bytesPeeked = bufferedStream->peek(peekStorage.get(), bytesToPeek);
         if (0 == bytesPeeked) {
             // Peeking should only fail completely if we have read/skipped beyond the buffer.
             REPORTER_ASSERT(r, start >= bufferSize);
             break;
         }

         // Only read the amount that was successfully peeked.
         const size_t bytesRead = bufferedStream->read(readStorage.get(), bytesPeeked);
         REPORTER_ASSERT(r, bytesRead == bytesPeeked);
         REPORTER_ASSERT(r, !memcmp(peekStorage.get(), readStorage.get(), bytesPeeked));

         // This should be safe to rewind.
         REPORTER_ASSERT(r, bufferedStream->rewind());
     }
 }

 // This test uses file system operations that don't work out of the
 // box on iOS. It's likely that we don't need them on iOS. Ignoring for now.
 // TODO(stephana): Re-evaluate if we need this in the future.
 DEF_TEST(StreamPeek, reporter) {
     // Test a memory stream.
     const char gAbcs[] = "abcdefghijklmnopqrstuvwxyz";
     SkMemoryStream memStream(gAbcs, strlen(gAbcs), false);
     test_fully_peekable_stream(reporter, &memStream, memStream.getLength());

     // Test an arbitrary file stream. file streams do not support peeking.
     SkFILEStream fileStream(GetResourcePath("baby_tux.webp").c_str());
     REPORTER_ASSERT(reporter, fileStream.isValid());
     if (!fileStream.isValid()) {
         return;
     }
     SkAutoMalloc storage(fileStream.getLength());
     for (size_t i = 1; i < fileStream.getLength(); i++) {
         REPORTER_ASSERT(reporter, fileStream.peek(storage.get(), i) == 0);
     }

     // Now test some FrontBufferedStreams
     for (size_t i = 1; i < memStream.getLength(); i++) {
         test_peeking_front_buffered_stream(reporter, memStream, i);
     }
 }
 #endif

 // Asserts that asset == expected and is peekable.
 static void stream_peek_test(skiatest::Reporter* rep,
                              SkStreamAsset* asset,
                              const SkData* expected) {
     if (asset->getLength() != expected->size()) {
         ERRORF(rep, "Unexpected length.");
         return;
     }
     SkRandom rand;
     uint8_t buffer[4096];
     const uint8_t* expect = expected->bytes();
     for (size_t i = 0; i < asset->getLength(); ++i) {
         uint32_t maxSize =
                 SkToU32(SkTMin(sizeof(buffer), asset->getLength() - i));
         size_t size = rand.nextRangeU(1, maxSize);
         SkASSERT(size >= 1);
         SkASSERT(size <= sizeof(buffer));
         SkASSERT(size + i <= asset->getLength());
         if (asset->peek(buffer, size) < size) {
             ERRORF(rep, "Peek Failed!");
             return;
         }
         if (0 != memcmp(buffer, &expect[i], size)) {
             ERRORF(rep, "Peek returned wrong bytes!");
             return;
         }
         uint8_t value;
         REPORTER_ASSERT(rep, 1 == asset->read(&value, 1));
         if (value != expect[i]) {
             ERRORF(rep, "Read Failed!");
             return;
         }
     }
 }

 DEF_TEST(StreamPeek_BlockMemoryStream, rep) {
     const static int kSeed = 1234;
     SkRandom valueSource(kSeed);
     SkRandom rand(kSeed << 1);
     uint8_t buffer[4096];
     SkDynamicMemoryWStream dynamicMemoryWStream;
     for (int i = 0; i < 32; ++i) {
         // Randomize the length of the blocks.
         size_t size = rand.nextRangeU(1, sizeof(buffer));
         for (size_t j = 0; j < size; ++j) {
             buffer[j] = valueSource.nextU() & 0xFF;
         }
         dynamicMemoryWStream.write(buffer, size);
     }
     std::unique_ptr<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
     sk_sp<SkData> expected(SkData::MakeUninitialized(asset->getLength()));
     uint8_t* expectedPtr = static_cast<uint8_t*>(expected->writable_data());
     valueSource.setSeed(kSeed);  // reseed.
     // We want the exact same same "random" string of numbers to put
     // in expected. i.e.: don't rely on SkDynamicMemoryStream to work
     // correctly while we are testing SkDynamicMemoryStream.
     for (size_t i = 0; i < asset->getLength(); ++i) {
         expectedPtr[i] = valueSource.nextU() & 0xFF;
     }
     stream_peek_test(rep, asset.get(), expected.get());
 }

 namespace {
 class DumbStream : public SkStream {
 public:
     DumbStream(const uint8_t* data, size_t n)
         : fData(data), fCount(n), fIdx(0) {}
     size_t read(void* buffer, size_t size) override {
         size_t copyCount = SkTMin(fCount - fIdx, size);
         if (copyCount) {
             memcpy(buffer, &fData[fIdx], copyCount);
             fIdx += copyCount;
         }
         return copyCount;
     }
     bool isAtEnd() const override {
         return fCount == fIdx;
     }
  private:
     const uint8_t* fData;
     size_t fCount, fIdx;
 };
 }  // namespace

 static void stream_copy_test(skiatest::Reporter* reporter,
                              const void* srcData,
                              size_t N,
                              SkStream* stream) {
     SkDynamicMemoryWStream tgt;
     if (!SkStreamCopy(&tgt, stream)) {
         ERRORF(reporter, "SkStreamCopy failed");
         return;
     }
     sk_sp<SkData> data(tgt.detachAsData());
     if (data->size() != N) {
         ERRORF(reporter, "SkStreamCopy incorrect size");
         return;
     }
     if (0 != memcmp(data->data(), srcData, N)) {
         ERRORF(reporter, "SkStreamCopy bad copy");
     }
 }

 DEF_TEST(StreamCopy, reporter) {
     SkRandom random(123456);
     static const int N = 10000;
     SkAutoTMalloc<uint8_t> src((size_t)N);
     for (int j = 0; j < N; ++j) {
         src[j] = random.nextU() & 0xff;
     }
     // SkStreamCopy had two code paths; this test both.
     DumbStream dumbStream(src.get(), (size_t)N);
     stream_copy_test(reporter, src, N, &dumbStream);
     SkMemoryStream smartStream(src.get(), (size_t)N);
     stream_copy_test(reporter, src, N, &smartStream);
 }

 DEF_TEST(StreamEmptyStreamMemoryBase, r) {
     SkDynamicMemoryWStream tmp;
     std::unique_ptr<SkStreamAsset> asset(tmp.detachAsStream());
     REPORTER_ASSERT(r, nullptr == asset->getMemoryBase());
 }
	/*
	* Copyright 2011 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "Resources.h"
	#include "SkData.h"
	#include "SkFrontBufferedStream.h"
	#include "SkOSFile.h"
	#include "SkOSPath.h"
	#include "SkRandom.h"
	#include "SkStream.h"
	#include "SkStreamPriv.h"
	#include "Test.h"

	#ifndef SK_BUILD_FOR_WIN
	#include <unistd.h>
	#include <fcntl.h>
	#endif

	#define MAX_SIZE (256 * 1024)

	static void test_loop_stream(skiatest::Reporter* reporter, SkStream* stream,
	const void* src, size_t len, int repeat) {
	SkAutoSMalloc<256> storage(len);
	void* tmp = storage.get();

	for (int i = 0; i < repeat; ++i) {
	size_t bytes = stream->read(tmp, len);
	REPORTER_ASSERT(reporter, bytes == len);
	REPORTER_ASSERT(reporter, !memcmp(tmp, src, len));
	}

	// expect EOF
	size_t bytes = stream->read(tmp, 1);
	REPORTER_ASSERT(reporter, 0 == bytes);
	// isAtEnd might not return true until after the first failing read.
	REPORTER_ASSERT(reporter, stream->isAtEnd());
	}

	static void test_filestreams(skiatest::Reporter* reporter, const char* tmpDir) {
	SkString path = SkOSPath::Join(tmpDir, "wstream_test");

	const char s[] = "abcdefghijklmnopqrstuvwxyz";

	{
	SkFILEWStream writer(path.c_str());
	if (!writer.isValid()) {
	ERRORF(reporter, "Failed to create tmp file %s\n", path.c_str());
	return;
	}

	for (int i = 0; i < 100; ++i) {
	writer.write(s, 26);
	}
	}

	{
	SkFILEStream stream(path.c_str());
	REPORTER_ASSERT(reporter, stream.isValid());
	test_loop_stream(reporter, &stream, s, 26, 100);

	std::unique_ptr<SkStreamAsset> stream2(stream.duplicate());
	test_loop_stream(reporter, stream2.get(), s, 26, 100);
	}

	{
	FILE* file = ::fopen(path.c_str(), "rb");
	SkFILEStream stream(file, SkFILEStream::kCallerPasses_Ownership);
	REPORTER_ASSERT(reporter, stream.isValid());
	test_loop_stream(reporter, &stream, s, 26, 100);

	std::unique_ptr<SkStreamAsset> stream2(stream.duplicate());
	test_loop_stream(reporter, stream2.get(), s, 26, 100);
	}
	}

	static void TestWStream(skiatest::Reporter* reporter) {
	SkDynamicMemoryWStream ds;
	const char s[] = "abcdefghijklmnopqrstuvwxyz";
	int i;
	for (i = 0; i < 100; i++) {
	REPORTER_ASSERT(reporter, ds.write(s, 26));
	}
	REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);

	char* dst = new char[100 * 26 + 1];
	dst[10026] = '';
	ds.copyTo(dst);
	REPORTER_ASSERT(reporter, dst[10026] == '');
	for (i = 0; i < 100; i++) {
	REPORTER_ASSERT(reporter, memcmp(&dst[i * 26], s, 26) == 0);
	}

	{
	std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
	REPORTER_ASSERT(reporter, 100 * 26 == stream->getLength());
	REPORTER_ASSERT(reporter, ds.getOffset() == 0);
	test_loop_stream(reporter, stream.get(), s, 26, 100);

	std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
	test_loop_stream(reporter, stream2.get(), s, 26, 100);

	std::unique_ptr<SkStreamAsset> stream3(stream->fork());
	REPORTER_ASSERT(reporter, stream3->isAtEnd());
	char tmp;
	size_t bytes = stream->read(&tmp, 1);
	REPORTER_ASSERT(reporter, 0 == bytes);
	stream3->rewind();
	test_loop_stream(reporter, stream3.get(), s, 26, 100);
	}

	for (i = 0; i < 100; i++) {
	REPORTER_ASSERT(reporter, ds.write(s, 26));
	}
	REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);

	{
	sk_sp<SkData> data = ds.snapshotAsData();
	REPORTER_ASSERT(reporter, 100 * 26 == data->size());
	REPORTER_ASSERT(reporter, memcmp(dst, data->data(), data->size()) == 0);
	}

	{
	// Test that this works after a snapshot.
	std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
	REPORTER_ASSERT(reporter, ds.getOffset() == 0);
	test_loop_stream(reporter, stream.get(), s, 26, 100);

	std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
	test_loop_stream(reporter, stream2.get(), s, 26, 100);
	}
	delete[] dst;

	SkString tmpDir = skiatest::GetTmpDir();
	if (!tmpDir.isEmpty()) {
	test_filestreams(reporter, tmpDir.c_str());
	}
	}

	static void TestPackedUInt(skiatest::Reporter* reporter) {
	// we know that packeduint tries to write 1, 2 or 4 bytes for the length,
	// so we test values around each of those transitions (and a few others)
	const size_t sizes[] = {
	0, 1, 2, 0xFC, 0xFD, 0xFE, 0xFF, 0x100, 0x101, 32767, 32768, 32769,
	0xFFFD, 0xFFFE, 0xFFFF, 0x10000, 0x10001,
	0xFFFFFD, 0xFFFFFE, 0xFFFFFF, 0x1000000, 0x1000001,
	0x7FFFFFFE, 0x7FFFFFFF, 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF
	};


	size_t i;
	char buffer[sizeof(sizes) * 4];

	SkMemoryWStream wstream(buffer, sizeof(buffer));
	for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
	bool success = wstream.writePackedUInt(sizes[i]);
	REPORTER_ASSERT(reporter, success);
	}
	wstream.flush();

	SkMemoryStream rstream(buffer, sizeof(buffer));
	for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
	size_t n = rstream.readPackedUInt();
	if (sizes[i] != n) {
	ERRORF(reporter, "sizes:%x != n:%x\n", i, sizes[i], n);
	}
	}
	}

	// Test that setting an SkMemoryStream to a nullptr data does not result in a crash when calling
	// methods that access fData.
	static void TestDereferencingData(SkMemoryStream* memStream) {
	memStream->read(nullptr, 0);
	memStream->getMemoryBase();
	(void)memStream->asData();
	}

	static void TestNullData() {
	SkMemoryStream memStream(nullptr);
	TestDereferencingData(&memStream);

	memStream.setData(nullptr);
	TestDereferencingData(&memStream);

	}

	DEF_TEST(Stream, reporter) {
	TestWStream(reporter);
	TestPackedUInt(reporter);
	TestNullData();
	}

	#ifndef SK_BUILD_FOR_IOS
	/**
	* Tests peeking and then reading the same amount. The two should provide the
	* same results.
	* Returns the amount successfully read minus the amount successfully peeked.
	*/
	static size_t compare_peek_to_read(skiatest::Reporter* reporter,
	SkStream* stream, size_t bytesToPeek) {
	// The rest of our tests won't be very interesting if bytesToPeek is zero.
	REPORTER_ASSERT(reporter, bytesToPeek > 0);
	SkAutoMalloc peekStorage(bytesToPeek);
	SkAutoMalloc readStorage(bytesToPeek);
	void* peekPtr = peekStorage.get();
	void* readPtr = peekStorage.get();

	const size_t bytesPeeked = stream->peek(peekPtr, bytesToPeek);
	const size_t bytesRead = stream->read(readPtr, bytesToPeek);

	// bytesRead should only be less than attempted if the stream is at the
	// end.
	REPORTER_ASSERT(reporter, bytesRead == bytesToPeek \|\| stream->isAtEnd());

	// peek and read should behave the same, except peek returned to the
	// original position, so they read the same data.
	REPORTER_ASSERT(reporter, !memcmp(peekPtr, readPtr, bytesPeeked));

	// A stream should never be able to peek more than it can read.
	REPORTER_ASSERT(reporter, bytesRead >= bytesPeeked);

	return bytesRead - bytesPeeked;
	}

	static void test_fully_peekable_stream(skiatest::Reporter* r, SkStream* stream, size_t limit) {
	for (size_t i = 1; !stream->isAtEnd(); i++) {
	REPORTER_ASSERT(r, compare_peek_to_read(r, stream, i) == 0);
	}
	}

	static void test_peeking_front_buffered_stream(skiatest::Reporter* r,
	const SkStream& original,
	size_t bufferSize) {
	SkStream* dupe = original.duplicate();
	REPORTER_ASSERT(r, dupe != nullptr);
	std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(dupe, bufferSize));
	REPORTER_ASSERT(r, bufferedStream != nullptr);

	size_t peeked = 0;
	for (size_t i = 1; !bufferedStream->isAtEnd(); i++) {
	const size_t unpeekableBytes = compare_peek_to_read(r, bufferedStream.get(), i);
	if (unpeekableBytes > 0) {
	// This could not have returned a number greater than i.
	REPORTER_ASSERT(r, unpeekableBytes <= i);

	// We have reached the end of the buffer. Verify that it was at least
	// bufferSize.
	REPORTER_ASSERT(r, peeked + i - unpeekableBytes >= bufferSize);
	// No more peeking is supported.
	break;
	}
	peeked += i;
	}

	// Test that attempting to peek beyond the length of the buffer does not prevent rewinding.
	bufferedStream.reset(SkFrontBufferedStream::Create(original.duplicate(), bufferSize));
	REPORTER_ASSERT(r, bufferedStream != nullptr);

	const size_t bytesToPeek = bufferSize + 1;
	SkAutoMalloc peekStorage(bytesToPeek);
	SkAutoMalloc readStorage(bytesToPeek);

	for (size_t start = 0; start <= bufferSize; start++) {
	// Skip to the starting point
	REPORTER_ASSERT(r, bufferedStream->skip(start) == start);

	const size_t bytesPeeked = bufferedStream->peek(peekStorage.get(), bytesToPeek);
	if (0 == bytesPeeked) {
	// Peeking should only fail completely if we have read/skipped beyond the buffer.
	REPORTER_ASSERT(r, start >= bufferSize);
	break;
	}

	// Only read the amount that was successfully peeked.
	const size_t bytesRead = bufferedStream->read(readStorage.get(), bytesPeeked);
	REPORTER_ASSERT(r, bytesRead == bytesPeeked);
	REPORTER_ASSERT(r, !memcmp(peekStorage.get(), readStorage.get(), bytesPeeked));

	// This should be safe to rewind.
	REPORTER_ASSERT(r, bufferedStream->rewind());
	}
	}

	// This test uses file system operations that don't work out of the
	// box on iOS. It's likely that we don't need them on iOS. Ignoring for now.
	// TODO(stephana): Re-evaluate if we need this in the future.
	DEF_TEST(StreamPeek, reporter) {
	// Test a memory stream.
	const char gAbcs[] = "abcdefghijklmnopqrstuvwxyz";
	SkMemoryStream memStream(gAbcs, strlen(gAbcs), false);
	test_fully_peekable_stream(reporter, &memStream, memStream.getLength());

	// Test an arbitrary file stream. file streams do not support peeking.
	SkFILEStream fileStream(GetResourcePath("baby_tux.webp").c_str());
	REPORTER_ASSERT(reporter, fileStream.isValid());
	if (!fileStream.isValid()) {
	return;
	}
	SkAutoMalloc storage(fileStream.getLength());
	for (size_t i = 1; i < fileStream.getLength(); i++) {
	REPORTER_ASSERT(reporter, fileStream.peek(storage.get(), i) == 0);
	}

	// Now test some FrontBufferedStreams
	for (size_t i = 1; i < memStream.getLength(); i++) {
	test_peeking_front_buffered_stream(reporter, memStream, i);
	}
	}
	#endif

	// Asserts that asset == expected and is peekable.
	static void stream_peek_test(skiatest::Reporter* rep,
	SkStreamAsset* asset,
	const SkData* expected) {
	if (asset->getLength() != expected->size()) {
	ERRORF(rep, "Unexpected length.");
	return;
	}
	SkRandom rand;
	uint8_t buffer[4096];
	const uint8_t* expect = expected->bytes();
	for (size_t i = 0; i < asset->getLength(); ++i) {
	uint32_t maxSize =
	SkToU32(SkTMin(sizeof(buffer), asset->getLength() - i));
	size_t size = rand.nextRangeU(1, maxSize);
	SkASSERT(size >= 1);
	SkASSERT(size <= sizeof(buffer));
	SkASSERT(size + i <= asset->getLength());
	if (asset->peek(buffer, size) < size) {
	ERRORF(rep, "Peek Failed!");
	return;
	}
	if (0 != memcmp(buffer, &expect[i], size)) {
	ERRORF(rep, "Peek returned wrong bytes!");
	return;
	}
	uint8_t value;
	REPORTER_ASSERT(rep, 1 == asset->read(&value, 1));
	if (value != expect[i]) {
	ERRORF(rep, "Read Failed!");
	return;
	}
	}
	}

	DEF_TEST(StreamPeek_BlockMemoryStream, rep) {
	const static int kSeed = 1234;
	SkRandom valueSource(kSeed);
	SkRandom rand(kSeed << 1);
	uint8_t buffer[4096];
	SkDynamicMemoryWStream dynamicMemoryWStream;
	for (int i = 0; i < 32; ++i) {
	// Randomize the length of the blocks.
	size_t size = rand.nextRangeU(1, sizeof(buffer));
	for (size_t j = 0; j < size; ++j) {
	buffer[j] = valueSource.nextU() & 0xFF;
	}
	dynamicMemoryWStream.write(buffer, size);
	}
	std::unique_ptr<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
	sk_sp<SkData> expected(SkData::MakeUninitialized(asset->getLength()));
	uint8_t* expectedPtr = static_cast<uint8_t*>(expected->writable_data());
	valueSource.setSeed(kSeed); // reseed.
	// We want the exact same same "random" string of numbers to put
	// in expected. i.e.: don't rely on SkDynamicMemoryStream to work
	// correctly while we are testing SkDynamicMemoryStream.
	for (size_t i = 0; i < asset->getLength(); ++i) {
	expectedPtr[i] = valueSource.nextU() & 0xFF;
	}
	stream_peek_test(rep, asset.get(), expected.get());
	}

	namespace {
	class DumbStream : public SkStream {
	public:
	DumbStream(const uint8_t* data, size_t n)
	: fData(data), fCount(n), fIdx(0) {}
	size_t read(void* buffer, size_t size) override {
	size_t copyCount = SkTMin(fCount - fIdx, size);
	if (copyCount) {
	memcpy(buffer, &fData[fIdx], copyCount);
	fIdx += copyCount;
	}
	return copyCount;
	}
	bool isAtEnd() const override {
	return fCount == fIdx;
	}
	private:
	const uint8_t* fData;
	size_t fCount, fIdx;
	};
	} // namespace

	static void stream_copy_test(skiatest::Reporter* reporter,
	const void* srcData,
	size_t N,
	SkStream* stream) {
	SkDynamicMemoryWStream tgt;
	if (!SkStreamCopy(&tgt, stream)) {
	ERRORF(reporter, "SkStreamCopy failed");
	return;
	}
	sk_sp<SkData> data(tgt.detachAsData());
	if (data->size() != N) {
	ERRORF(reporter, "SkStreamCopy incorrect size");
	return;
	}
	if (0 != memcmp(data->data(), srcData, N)) {
	ERRORF(reporter, "SkStreamCopy bad copy");
	}
	}

	DEF_TEST(StreamCopy, reporter) {
	SkRandom random(123456);
	static const int N = 10000;
	SkAutoTMalloc<uint8_t> src((size_t)N);
	for (int j = 0; j < N; ++j) {
	src[j] = random.nextU() & 0xff;
	}
	// SkStreamCopy had two code paths; this test both.
	DumbStream dumbStream(src.get(), (size_t)N);
	stream_copy_test(reporter, src, N, &dumbStream);
	SkMemoryStream smartStream(src.get(), (size_t)N);
	stream_copy_test(reporter, src, N, &smartStream);
	}

	DEF_TEST(StreamEmptyStreamMemoryBase, r) {
	SkDynamicMemoryWStream tmp;
	std::unique_ptr<SkStreamAsset> asset(tmp.detachAsStream());
	REPORTER_ASSERT(r, nullptr == asset->getMemoryBase());
	}