SkBlockMemoryStream implements peek()

tests/StreamTest.cpp

 /*
  * 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"
@@ skipping 255 matching lines @@
     for (size_t i = 1; i < fileStream.getLength(); i++) {
         REPORTER_ASSERT(reporter, !fileStream.peek(storage.get(), i));
     }
 
     // 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 (unsigned i = 0; i < asset->getLength(); ++i) {
+        size_t size = (rand.nextU() % sizeof(buffer)) + 1;

[scroggo, 2015/05/20 15:43:35]

Why not rand.nextRangeU(1, sizeof(buffer))?

[hal.canary, 2015/05/21 13:28:02]

Done.

+        size = SkTMin(size, asset->getLength() - i);
+        if (size > 0) {

[scroggo, 2015/05/20 15:43:35]

Can size ever be 0? I guess with an empty asset? It does not look like we ever
create one. (Though if we did, it seems like this test would fail below when we
try to read it.)

[hal.canary, 2015/05/21 13:28:02]

Done.

Of course size is always > 0!

+            SkASSERT(size <= sizeof(buffer));
+            if (!asset->peek(buffer, size)) {
+                ERRORF(rep, "Peek Failed!");
+                return;
+            }
+            if (0 != memcmp(buffer, &expect[i], size)) {
+                ERRORF(rep, "Peek returned wrong bytes!");
+                return;
+            }
+        }
+        uint8_t value;
+        asset->read(&value, 1);

[scroggo, 2015/05/20 15:43:35]

Check the return value too?

[hal.canary, 2015/05/21 13:28:02]

Done.

+        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.nextU() % sizeof(buffer)) + 1;
+        SkASSERT(size <= sizeof(buffer));
+        for (unsigned j = 0; j < size; ++j) {
+            buffer[j] = valueSource.nextU() & 0xFF;
+        }
+        dynamicMemoryWStream.write(buffer, size);
+    }
+    SkAutoTDelete<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
+    SkAutoTUnref<SkData> expected(SkData::NewUninitialized(asset->getLength()));
+    uint8_t* expectedPtr = static_cast<uint8_t*>(expected->writable_data());
+    valueSource.setSeed(kSeed);  // reseed.

[scroggo, 2015/05/20 15:43:35]

So if I understand correctly, you're just trying to get the same random string
of numbers to put in expected?

[hal.canary, 2015/05/21 13:28:02]

Acknowledged.

+    for (unsigned i = 0; i < asset->getLength(); ++i) {
+        expectedPtr[i] = valueSource.nextU() & 0xFF;
+    }
+    stream_peek_test(rep, asset, expected);
+}