PDF: Add (low-memory) SkPDFBitmap class

tests/DeflateWStream.cpp

Index: tests/DeflateWStream.cpp
diff --git a/tests/DeflateWStream.cpp b/tests/DeflateWStream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c307000e3c3f8f3fc09c2b8e14a235d84f49a0c
--- /dev/null
+++ b/tests/DeflateWStream.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Test.h"
+#include "SkDeflateWStream.h"
+#include "SkFlate.h"
+#include "SkRandom.h"
+
+DEF_TEST(SkDeflateWStream, r) {
+    if (!SkFlate::HaveFlate()) {

[mtklein, 2015/02/12 00:21:46]

Why do we pretend SkFlate::HaveFlate() is a runtime check?  It's always the same
as SK_HAS_ZLIB.  This might all be clearer if they were all preprocessor checks.
 Then you wouldn't have to define a phony SkDeflateWStream just to get things to
compile.

[hal.canary, 2015/02/12 21:28:03]

I agree.  I'll change this at some time.  I think the author of SkFlate wanted
to someday have a non-zlib-backed deflate.

+        return;
+    }
+    SkRandom random(123456);
+    for (int i = 0; i < 50; ++i) {
+        uint32_t size = random.nextULessThan(10000);
+        SkAutoTMalloc<uint8_t> buffer(size);
+        for (uint32_t i = 0; i < size; ++i) {
+            buffer[i] = random.nextU() & 0xff;
+        }
+
+        SkDynamicMemoryWStream dynamicMemoryWStream;
+        {
+            SkDeflateWStream deflateWStream(&dynamicMemoryWStream);
+            uint32_t j = 0;
+            while (j < size) {
+                uint32_t writeSize =
+                        SkTMin(size - j, random.nextRangeU(1, 400));
+                if (!deflateWStream.write(&buffer[j], writeSize)) {
+                    ERRORF(r, "something went wrong.");
+                    return;
+                }
+                j += writeSize;
+            }
+        }
+        SkAutoTDelete<SkStreamAsset> compressed(
+                dynamicMemoryWStream.detachAsStream());
+
+        SkDynamicMemoryWStream decompressedDynamicMemoryWStream;
+        SkAssertResult(SkFlate::Inflate(compressed,
+                                        &decompressedDynamicMemoryWStream));
+
+        SkAutoTDelete<SkStreamAsset> decompressed(
+                decompressedDynamicMemoryWStream.detachAsStream());
+
+        if (decompressed->getLength() != size) {
+            ERRORF(r, "Decompression failed to get right size [%d]."
+                   " %u != %u", i,  (unsigned)(decompressed->getLength()),
+                   (unsigned)size);
+            SkString s = SkStringPrintf("/tmp/deftst_compressed_%d", i);
+            SkFILEWStream o(s.c_str());
+            o.writeStream(compressed.get(), compressed->getLength());
+            compressed->rewind();
+
+            s = SkStringPrintf("/tmp/deftst_input_%d", i);
+            SkFILEWStream o2(s.c_str());
+            o2.write(&buffer[0], size);
+
+            continue;
+        }
+        uint32_t minLength = SkTMin(size,
+                                    (uint32_t)(decompressed->getLength()));
+        for (uint32_t i = 0; i < minLength; ++i) {
+            uint8_t c;
+            SkDEBUGCODE(size_t rb =)decompressed->read(&c, sizeof(uint8_t));
+            SkASSERT(sizeof(uint8_t) == rb);
+            if (buffer[i] != c) {
+                ERRORF(r, "Decompression failed at byte %u.", (unsigned)i);
+                break;
+            }
+        }
+    }
+}