***Disables swizzles to 565.
We may want to enable swizzles to 565
for images that are encoded in a format
similar to 565, however, we do not want
to take images that decode naturally to
kN32 and then convert them to 565.
***Enable swizzles to kIndex_8. For images
encoded in a color table format, we suggest
that they be decoded to kIndex_8. When we
decode, we only allow conversion to kIndex_8
if it matches the suggested color type (except
wbmp which seems good as is).
***Modify dm to test images that decode to
kIndex_8.
BUG=skia:3257
BUG=skia:3440
Review URL: https://codereview.chromium.org/1055743003
diff --git a/tests/SwizzlerTest.cpp b/tests/SwizzlerTest.cpp
new file mode 100644
index 0000000..1355f3b
--- /dev/null
+++ b/tests/SwizzlerTest.cpp
@@ -0,0 +1,112 @@
+/*
+ * 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 "SkSwizzler.h"
+#include "Test.h"
+
+// These are the values that we will look for to indicate that the fill was successful
+static const uint8_t kFillIndex = 0x1;
+static const uint32_t kFillColor = 0x22334455;
+
+static void check_fill(skiatest::Reporter* r,
+ const SkImageInfo& imageInfo,
+ uint32_t startRow,
+ size_t rowBytes,
+ uint32_t offset,
+ uint32_t colorOrIndex,
+ SkPMColor* colorTable) {
+
+ // Calculate the total size of the image in bytes. Use the smallest possible size.
+ // The offset value tells us to adjust the pointer from the memory we allocate in order
+ // to test on different memory alignments. If offset is nonzero, we need to increase the
+ // size of the memory we allocate in order to make sure that we have enough. We are
+ // still allocating the smallest possible size.
+ const size_t totalBytes = imageInfo.getSafeSize(rowBytes) + offset;
+
+ // Create fake image data where every byte has a value of 0
+ SkAutoTDelete<uint8_t> storage((uint8_t*) sk_malloc_throw(totalBytes));
+ memset(storage.get(), 0, totalBytes);
+ // Adjust the pointer in order to test on different memory alignments
+ uint8_t* imageData = storage.get() + offset;
+
+ // Fill image with the fill value starting at the indicated row
+ SkSwizzler::Fill(imageData, imageInfo, rowBytes, startRow, colorOrIndex, colorTable);
+
+ // Ensure that the pixels are filled properly
+ // The bots should catch any memory corruption
+ uint8_t* indexPtr = imageData + startRow * rowBytes;
+ uint32_t* colorPtr = (uint32_t*) indexPtr;
+ for (int32_t y = startRow; y < imageInfo.height(); y++) {
+ for (int32_t x = 0; x < imageInfo.width(); x++) {
+ if (kIndex_8_SkColorType == imageInfo.colorType()) {
+ REPORTER_ASSERT(r, kFillIndex == indexPtr[x]);
+ } else {
+ REPORTER_ASSERT(r, kFillColor == colorPtr[x]);
+ }
+ }
+ indexPtr += rowBytes;
+ colorPtr = (uint32_t*) indexPtr;
+ }
+}
+
+// Test Fill() with different combinations of dimensions, alignment, and padding
+DEF_TEST(SwizzlerFill, r) {
+ // Set up a color table
+ SkPMColor colorTable[kFillIndex + 1];
+ colorTable[kFillIndex] = kFillColor;
+ // Apart from the fill index, we will leave the other colors in the color table uninitialized.
+ // If we incorrectly try to fill with this uninitialized memory, the bots will catch it.
+
+ // Test on an invalid width and representative widths
+ const uint32_t widths[] = { 0, 10, 50 };
+
+ // In order to call Fill(), there must be at least one row to fill
+ // Test on the smallest possible height and representative heights
+ const uint32_t heights[] = { 1, 5, 10 };
+
+ // Test on interesting possibilities for row padding
+ const uint32_t paddings[] = { 0, 1, 2, 3, 4 };
+
+ // Iterate over test dimensions
+ for (uint32_t width : widths) {
+ for (uint32_t height : heights) {
+
+ // Create image info objects
+ const SkImageInfo colorInfo = SkImageInfo::MakeN32(width, height,
+ kUnknown_SkAlphaType);
+ const SkImageInfo indexInfo = colorInfo.makeColorType(kIndex_8_SkColorType);
+
+ for (uint32_t padding : paddings) {
+
+ // Calculate row bytes
+ size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width +
+ padding;
+ size_t indexRowBytes = width + padding;
+
+ // If there is padding, we can invent an offset to change the memory alignment
+ for (uint32_t offset = 0; offset <= padding; offset++) {
+
+ // Test all possible start rows
+ for (uint32_t startRow = 0; startRow < height; startRow++) {
+
+ // Fill with an index that we use to look up a color
+ check_fill(r, colorInfo, startRow, colorRowBytes, offset, kFillIndex,
+ colorTable);
+
+ // Fill with a color
+ check_fill(r, colorInfo, startRow, colorRowBytes, offset, kFillColor,
+ NULL);
+
+ // Fill with an index
+ check_fill(r, indexInfo, startRow, indexRowBytes, offset, kFillIndex,
+ NULL);
+ }
+ }
+ }
+ }
+ }
+}