SkJpegCodec

tests/SwizzlerTest.cpp

 /*
  * 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"
 
@@ skipping 24 matching lines @@
     uint8_t* imageData = storage.get() + offset;
     uint8_t* imageStart = imageData + rowBytes * startRow;
 
     // Fill image with the fill value starting at the indicated row
     SkSwizzler::Fill(imageStart, imageInfo, rowBytes, endRow - startRow + 1, colorOrIndex,
             colorTable);
 
     // Ensure that the pixels are filled properly
     // The bots should catch any memory corruption
     uint8_t* indexPtr = imageData + startRow * rowBytes;
+    uint8_t* grayPtr = indexPtr;
     uint32_t* colorPtr = (uint32_t*) indexPtr;
     for (uint32_t y = startRow; y <= endRow; 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]);
+            switch (imageInfo.colorType()) {
+                case kIndex_8_SkColorType:
+                    REPORTER_ASSERT(r, kFillIndex == indexPtr[x]);
+                    break;
+                case kN32_SkColorType:
+                    REPORTER_ASSERT(r, kFillColor == colorPtr[x]);
+                    break;
+                case kGray_8_SkColorType:
+                    // We always fill kGray with black
+                    REPORTER_ASSERT(r, (uint8_t) kFillColor == grayPtr[x]);
+                    break;
+                default:
+                    REPORTER_ASSERT(r, false);
+                    break;
             }
         }
         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
@@ skipping 13 matching lines @@
     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);
+            const SkImageInfo grayInfo = colorInfo.makeColorType(kGray_8_SkColorType);
 
             for (uint32_t padding : paddings) {
 
                 // Calculate row bytes
                 size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width +
                         padding;
                 size_t indexRowBytes = width + padding;
+                size_t grayRowBytes = indexRowBytes;
 
                 // 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 with all possible end rows
                     for (uint32_t startRow = 0; startRow < height; startRow++) {
                         for (uint32_t endRow = startRow; endRow < height; endRow++) {
 
                             // Fill with an index that we use to look up a color
                             check_fill(r, colorInfo, startRow, endRow, colorRowBytes, offset,
                                     kFillIndex, colorTable);
 
                             // Fill with a color
                             check_fill(r, colorInfo, startRow, endRow, colorRowBytes, offset,
                                     kFillColor, NULL);
 
                             // Fill with an index
                             check_fill(r, indexInfo, startRow, endRow, indexRowBytes, offset,
                                     kFillIndex, NULL);
+
+                            // Fill a grayscale image
+                            check_fill(r, grayInfo, startRow, endRow, grayRowBytes, offset,
+                                    kFillColor, NULL);
                         }
                     }
                 }
             }
         }
     }
 }