Templetized SkWriter32 readTAt() & overwriteTAt()

tests/Writer32Test.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 "SkRandom.h"
 #include "SkReader32.h"
 #include "SkWriter32.h"
@@ skipping 60 matching lines @@
 
 static void test_ptr(skiatest::Reporter* reporter) {
     SkSWriter32<32> writer;
 
     void* p0 = reporter;
     void* p1 = &writer;
 
     // try writing ptrs where at least one of them may be at a non-multiple of
     // 8 boundary, to confirm this works on 64bit machines.
 
-    writer.writePtr(p0);
+    writer.writeT<void*>(p0);
     writer.write8(0x33);
-    writer.writePtr(p1);
+    writer.writeT<void*>(p1);
     writer.write8(0x66);
 
     size_t size = writer.bytesWritten();
     REPORTER_ASSERT(reporter, 2 * sizeof(void*) + 2 * sizeof(int32_t));
 
     char buffer[32];
     SkASSERT(sizeof(buffer) >= size);
     writer.flatten(buffer);
 
     SkReader32 reader(buffer, size);
     REPORTER_ASSERT(reporter, reader.readPtr() == p0);
     REPORTER_ASSERT(reporter, reader.readInt() == 0x33);
     REPORTER_ASSERT(reporter, reader.readPtr() == p1);
     REPORTER_ASSERT(reporter, reader.readInt() == 0x66);
 }
 
 static void test1(skiatest::Reporter* reporter, SkWriter32* writer) {
     const uint32_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     for (size_t i = 0; i < SK_ARRAY_COUNT(data); ++i) {
         REPORTER_ASSERT(reporter, i*4 == writer->bytesWritten());
         writer->write32(data[i]);
-        REPORTER_ASSERT(reporter, data[i] == writer->read32At(i*4));
+        REPORTER_ASSERT(reporter, data[i] == writer->readTAt<uint32_t>(i * 4));
     }
 
     char buffer[sizeof(data)];
     REPORTER_ASSERT(reporter, sizeof(buffer) == writer->bytesWritten());
     writer->flatten(buffer);
     REPORTER_ASSERT(reporter, !memcmp(data, buffer, sizeof(buffer)));
 }
 
 static void test2(skiatest::Reporter* reporter, SkWriter32* writer) {
     static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz";
@@ skipping 61 matching lines @@
         REPORTER_ASSERT(reporter, memcmp(readPtr, originalData.get(), len) == 0);
         // Ensure that the rest is padded with zeroes.
         const char* stop = readPtr + SkAlign4(len);
         readPtr += len;
         while (readPtr < stop) {
             REPORTER_ASSERT(reporter, *readPtr++ == 0);
         }
     }
 }
 
+static void testWriteT(skiatest::Reporter* reporter, SkWriter32* writer) {
+    const size_t padding = 64;
+
+    const uint32_t uint1 = 0x12345678;
+    const uint32_t uint2 = 0x98765432;
+    const SkScalar scalar1 = 1234.5678f;
+    const SkScalar scalar2 = 9876.5432f;
+    const SkRect rect1 = SkRect::MakeXYWH(1, 2, 3, 4);
+    const SkRect rect2 = SkRect::MakeXYWH(5, 6, 7, 8);
+
+    for (size_t i = 0; i < (padding >> 2); ++i) {
+        writer->write32(0);
+    }
+
+    writer->writeT<uint32_t>(uint1);
+    writer->writeT<SkRect>(rect1);
+    writer->writeT<SkScalar>(scalar1);
+
+    for (size_t i = 0; i < (padding >> 2); ++i) {
+        writer->write32(0);
+    }
+
+    REPORTER_ASSERT(reporter, writer->readTAt<uint32_t>(padding) == uint1);
+    REPORTER_ASSERT(reporter, writer->readTAt<SkRect>(padding + sizeof(uint32_t)) == rect1);
+    REPORTER_ASSERT(reporter, writer->readTAt<SkScalar>(
+                        padding + sizeof(uint32_t) + sizeof(SkRect)) == scalar1);
+
+    writer->writeTAt<uint32_t>(padding, uint2);
+    writer->writeTAt<SkRect>(padding + sizeof(uint32_t), rect2);
+    writer->writeTAt<SkScalar>(padding + sizeof(uint32_t) + sizeof(SkRect), scalar2);
+
+    REPORTER_ASSERT(reporter, writer->readTAt<uint32_t>(padding) == uint2);
+    REPORTER_ASSERT(reporter, writer->readTAt<SkRect>(padding + sizeof(uint32_t)) == rect2);
+    REPORTER_ASSERT(reporter, writer->readTAt<SkScalar>(
+                        padding + sizeof(uint32_t) + sizeof(SkRect)) == scalar2);
+}
+
 DEF_TEST(Writer32_dynamic, reporter) {
     SkWriter32 writer;
     test1(reporter, &writer);
 
     writer.reset();
     test2(reporter, &writer);
 
     writer.reset();
     testWritePad(reporter, &writer);
+
+    writer.reset();
+    testWriteT(reporter, &writer);
 }
 
 DEF_TEST(Writer32_contiguous, reporter) {
     uint32_t storage[256];
     SkWriter32 writer;
     writer.reset(storage, sizeof(storage));
     // This write is small enough to fit in storage, so it's contiguous.
     test1(reporter, &writer);
     REPORTER_ASSERT(reporter, writer.contiguousArray() != NULL);
 
@@ skipping 11 matching lines @@
 }
 
 DEF_TEST(Writer32_small, reporter) {
     SkSWriter32<8 * sizeof(intptr_t)> writer;
     test1(reporter, &writer);
     writer.reset(); // should just rewind our storage
     test2(reporter, &writer);
 
     writer.reset();
     testWritePad(reporter, &writer);
+
+    writer.reset();
+    testWriteT(reporter, &writer);
 }
 
 DEF_TEST(Writer32_large, reporter) {
     SkSWriter32<1024 * sizeof(intptr_t)> writer;
     test1(reporter, &writer);
     writer.reset(); // should just rewind our storage
     test2(reporter, &writer);
 
     writer.reset();
     testWritePad(reporter, &writer);
+
+    writer.reset();
+    testWriteT(reporter, &writer);
 }
 
 DEF_TEST(Writer32_misc, reporter) {
     test_reserve(reporter);
     test_string_null(reporter);
     test_ptr(reporter);
     test_rewind(reporter);
 }