diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index ee0b610..53ac706 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -1515,7 +1515,7 @@
         case GrColorType::kUnknown:          return "kUnknown";
         case GrColorType::kAlpha_8:          return "kAlpha_8";
         case GrColorType::kBGR_565:          return "kRGB_565";
-        case GrColorType::kABGR_4444:        return "kARGB_4444";
+        case GrColorType::kABGR_4444:        return "kABGR_4444";
         case GrColorType::kRGBA_8888:        return "kRGBA_8888";
         case GrColorType::kRGBA_8888_SRGB:   return "kRGBA_8888_SRGB";
         case GrColorType::kRGB_888x:         return "kRGB_888x";
diff --git a/tests/BackendAllocationTest.cpp b/tests/BackendAllocationTest.cpp
index 8632dad..276b80c 100644
--- a/tests/BackendAllocationTest.cpp
+++ b/tests/BackendAllocationTest.cpp
@@ -12,6 +12,8 @@
 #include "src/gpu/GrContextPriv.h"
 #include "src/image/SkImage_Base.h"
 #include "tests/Test.h"
+#include "tests/TestUtils.h"
+#include "tools/ToolUtils.h"
 
 #ifdef SK_GL
 #include "src/gpu/gl/GrGLGpu.h"
@@ -91,38 +93,51 @@
     context->deleteBackendTexture(backendTex);
 }
 
-static bool colors_eq(SkColor colA, SkColor colB, int tol) {
-    int maxDiff = 0;
-    for (int i = 0; i < 4; ++i) {
-        int diff = SkTAbs<int>((0xFF & (colA >> i*8)) - (0xFF & (colB >> i*8)));
-        if (maxDiff < diff) {
-            maxDiff = diff;
-        }
-    }
+static void check_solid_pixmap(skiatest::Reporter* reporter,
+                               const SkColor4f& expected, const SkPixmap& actual,
+                               SkColorType ct, const char* label) {
+    // we need 0.001f across the board just for noise
+    // we need 0.01f across the board for 1010102
+    const float tols[4] = {0.01f, 0.01f, 0.01f, 0.01f};
 
-    return maxDiff <= tol;
+    auto error = std::function<ComparePixmapsErrorReporter>(
+        [reporter, ct, label](int x, int y, const float diffs[4]) {
+            SkASSERT(x >= 0 && y >= 0);
+            ERRORF(reporter, "%s %s - mismatch at %d, %d (%f, %f, %f %f)",
+                   ToolUtils::colortype_name(ct), label, x, y,
+                   diffs[0], diffs[1], diffs[2], diffs[3]);
+        });
+
+    check_solid_pixels(expected, actual, tols, error);
 }
 
-static void compare_pixmaps(const SkPixmap& expected, const SkPixmap& actual,
-                            SkColorType colorType, skiatest::Reporter* reporter) {
-    SkASSERT(expected.info() == actual.info());
-    for (int y = 0; y < expected.height(); ++y) {
-        for (int x = 0; x < expected.width(); ++x) {
+static SkColor4f get_expected_color(SkColor4f orig, SkColorType ct) {
 
-            SkColor expectedCol = expected.getColor(x, y);
-            SkColor actualCol = actual.getColor(x, y);
+    uint32_t components = SkColorTypeComponentFlags(ct);
 
-            // GPU and raster differ a bit on kGray_8_SkColorType and kRGBA_1010102_SkColorType
-            if (colors_eq(actualCol, expectedCol, 12)) {
-                continue;
-            }
-
-            ERRORF(reporter,
-                   "Mismatched pixels at %d %d ct: %d expected: 0x%x actual: 0x%x\n",
-                   x, y, colorType, expectedCol, actualCol);
-            return;
-        }
+    if (components & kGray_SkColorTypeComponentFlag) {
+        // For the GPU backends, gray implies a single channel which is opaque.
+        return { orig.fA, orig.fA, orig.fA, 1 };
     }
+
+    float r = orig.fR, g = orig.fG, b = orig.fB, a = orig.fA;
+
+    // Missing channels are set to 0
+    if (!(components & kRed_SkColorTypeComponentFlag)) {
+        r = 0;
+    }
+    if (!(components & kGreen_SkColorTypeComponentFlag)) {
+        g = 0;
+    }
+    if (!(components & kBlue_SkColorTypeComponentFlag)) {
+        b = 0;
+    }
+    // except for missing alpha - which gets set to 1
+    if (!(components & kAlpha_SkColorTypeComponentFlag)) {
+        a = 1;
+    }
+
+    return { r, g, b, a };
 }
 
 // Test initialization of GrBackendObjects to a specific color
@@ -153,24 +168,7 @@
 
     SkImageInfo ii = SkImageInfo::Make(32, 32, skColorType, at);
 
-    SkColor4f rasterColor = color;
-    if (kGray_8_SkColorType == skColorType) {
-        // For the GPU backends, gray implies a single channel which is opaque.
-        rasterColor.fR = color.fA;
-        rasterColor.fG = color.fA;
-        rasterColor.fB = color.fA;
-        rasterColor.fA = 1.0f;
-    } else if (kAlpha_8_SkColorType == skColorType) {
-        // For the GPU backends, alpha implies a single alpha channel.
-        rasterColor.fR = 0;
-        rasterColor.fG = 0;
-        rasterColor.fB = 0;
-        rasterColor.fA = color.fA;
-    }
-
-    SkAutoPixmapStorage expected;
-    SkAssertResult(expected.tryAlloc(ii));
-    expected.erase(rasterColor);
+    SkColor4f expectedColor = get_expected_color(color, skColorType);
 
     SkAutoPixmapStorage actual;
     SkAssertResult(actual.tryAlloc(ii));
@@ -187,7 +185,8 @@
             bool result = surf->readPixels(actual, 0, 0);
             REPORTER_ASSERT(reporter, result);
 
-            compare_pixmaps(expected, actual, skColorType, reporter);
+            check_solid_pixmap(reporter, expectedColor, actual, skColorType,
+                               "SkSurface::readPixels");
 
             actual.erase(SkColors::kTransparent);
         }
@@ -212,7 +211,8 @@
                             colorType);
 #endif
                 } else {
-                    compare_pixmaps(expected, actual, skColorType, reporter);
+                    check_solid_pixmap(reporter, expectedColor, actual, skColorType,
+                                       "SkImage::readPixels");
                 }
             }
 
@@ -235,10 +235,6 @@
                 SkImageInfo newII = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType,
                                                       kPremul_SkAlphaType);
 
-                SkAutoPixmapStorage actual2;
-                SkAssertResult(actual2.tryAlloc(newII));
-                actual2.erase(SkColors::kTransparent);
-
                 sk_sp<SkSurface> surf = SkSurface::MakeRenderTarget(context,
                                                                     SkBudgeted::kNo,
                                                                     newII, 1,
@@ -263,15 +259,18 @@
                     canvas->clear(SK_ColorTRANSPARENT);
                     canvas->drawImageRect(img, r, &p);
 
+                    SkImageInfo readbackII = SkImageInfo::Make(rectSize, rectSize,
+                                                               kRGBA_8888_SkColorType,
+                                                               kPremul_SkAlphaType);
+                    SkAutoPixmapStorage actual2;
+                    SkAssertResult(actual2.tryAlloc(readbackII));
+                    actual2.erase(SkColors::kTransparent);
+
                     bool result = surf->readPixels(actual2, 0, 0);
                     REPORTER_ASSERT(reporter, result);
 
-                    SkColor actualColor = actual2.getColor(0, 0);
-
-                    if (!colors_eq(actualColor, rasterColor.toSkColor(), 1)) {
-                        ERRORF(reporter, "Pixel mismatch colorType %d: level: %d e: 0x%x a: 0x%x\n",
-                               skColorType, i, rasterColor.toSkColor(), actualColor);
-                    }
+                    check_solid_pixmap(reporter, expectedColor, actual2, skColorType,
+                                       "mip-level failure");
                 }
             }
         }
@@ -408,25 +407,24 @@
 
     struct {
         SkColorType   fColorType;
-        GrPixelConfig fConfig;
         SkColor4f     fColor;
     } combinations[] = {
-        { kAlpha_8_SkColorType,      kAlpha_8_GrPixelConfig,           kTransCol           },
-        { kRGB_565_SkColorType,      kRGB_565_GrPixelConfig,           SkColors::kRed      },
-        { kARGB_4444_SkColorType,    kRGBA_4444_GrPixelConfig,         SkColors::kGreen    },
-        { kRGBA_8888_SkColorType,    kRGBA_8888_GrPixelConfig,         SkColors::kBlue     },
-        { kRGB_888x_SkColorType,     kRGB_888_GrPixelConfig,           SkColors::kCyan     },
+        { kAlpha_8_SkColorType,      kTransCol                },
+        { kRGB_565_SkColorType,      SkColors::kRed           },
+        { kARGB_4444_SkColorType,    SkColors::kGreen         },
+        { kRGBA_8888_SkColorType,    SkColors::kBlue          },
+        { kRGB_888x_SkColorType,     SkColors::kCyan          },
         // TODO: readback is busted when alpha = 0.5f (perhaps premul vs. unpremul)
-        { kBGRA_8888_SkColorType,    kBGRA_8888_GrPixelConfig,         { 1, 0, 0, 1.0f }   },
+        { kBGRA_8888_SkColorType,    { 1, 0, 0, 1.0f }        },
         // TODO: readback is busted when alpha = 0.5f (perhaps premul vs. unpremul)
-        { kRGBA_1010102_SkColorType, kRGBA_1010102_GrPixelConfig,      { 0.5f, 0, 0, 1.0f }},
+        { kRGBA_1010102_SkColorType, { .25f, .5f, .75f, 1.0f }},
         // The kRGB_101010x_SkColorType has no Ganesh correlate
-        { kRGB_101010x_SkColorType,  kUnknown_GrPixelConfig,           { 0, 0.5f, 0, 0.5f }},
-        { kGray_8_SkColorType,       kGray_8_GrPixelConfig,            kGrayCol            },
-        { kRGBA_F16Norm_SkColorType, kRGBA_half_Clamped_GrPixelConfig, SkColors::kLtGray   },
-        { kRGBA_F16_SkColorType,     kRGBA_half_GrPixelConfig,         SkColors::kYellow   },
-        { kRGBA_F32_SkColorType,     kRGBA_float_GrPixelConfig,        SkColors::kGray     },
-        { kRG_88_SkColorType,        kRG_88_GrPixelConfig,             SkColors::kRed      },
+        { kRGB_101010x_SkColorType,  { 0, 0.5f, 0, 0.5f }     },
+        { kGray_8_SkColorType,       kGrayCol                 },
+        { kRGBA_F16Norm_SkColorType, SkColors::kLtGray        },
+        { kRGBA_F16_SkColorType,     SkColors::kYellow        },
+        { kRGBA_F32_SkColorType,     SkColors::kGray          },
+        { kRG_88_SkColorType,        { .25f, .75f, 0, 0 }     },
     };
 
     GR_STATIC_ASSERT(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
diff --git a/tests/ExtendedSkColorTypeTests.cpp b/tests/ExtendedSkColorTypeTests.cpp
index db8fb65..c334ebf 100644
--- a/tests/ExtendedSkColorTypeTests.cpp
+++ b/tests/ExtendedSkColorTypeTests.cpp
@@ -12,6 +12,7 @@
 
 #include "tests/Test.h"
 #include "tests/TestUtils.h"
+#include "tools/ToolUtils.h"
 
 static constexpr int kSize = 32;
 
@@ -151,14 +152,14 @@
 
 static void compare_pixmaps(skiatest::Reporter* reporter,
                             const SkPixmap& expected, const SkPixmap& actual,
-                            SkColorType nativeCT, const char* label) {
+                            SkColorType ct, const char* label) {
     const float tols[4] = {0.0f, 0.0f, 0.0f, 0};
 
     auto error = std::function<ComparePixmapsErrorReporter>(
-        [reporter, nativeCT, label](int x, int y, const float diffs[4]) {
+        [reporter, ct, label](int x, int y, const float diffs[4]) {
             SkASSERT(x >= 0 && y >= 0);
-            ERRORF(reporter, "%d %s - mismatch at %d, %d (%f, %f, %f %f)",
-                   nativeCT, label, x, y,
+            ERRORF(reporter, "%s %s - mismatch at %d, %d (%f, %f, %f %f)",
+                   ToolUtils::colortype_name(ct), label, x, y,
                    diffs[0], diffs[1], diffs[2], diffs[3]);
         });
 
diff --git a/tests/TestUtils.cpp b/tests/TestUtils.cpp
index 42cb808..b813ff8 100644
--- a/tests/TestUtils.cpp
+++ b/tests/TestUtils.cpp
@@ -177,6 +177,34 @@
     return true;
 }
 
+using AccessPixelFn = const float*(const char* floatBuffer, int x, int y);
+
+bool compare_pixels(int width, int height,
+                    const char* floatA, std::function<AccessPixelFn>& atA,
+                    const char* floatB, std::function<AccessPixelFn>& atB,
+                    const float tolRGBA[4], std::function<ComparePixmapsErrorReporter>& error) {
+
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; ++x) {
+            const float* rgbaA = atA(floatA, x, y);
+            const float* rgbaB = atB(floatB, x, y);
+            float diffs[4];
+            bool bad = false;
+            for (int i = 0; i < 4; ++i) {
+                diffs[i] = rgbaB[i] - rgbaA[i];
+                if (std::abs(diffs[i]) > std::abs(tolRGBA[i])) {
+                    bad = true;
+                }
+            }
+            if (bad) {
+                error(x, y, diffs);
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 bool compare_pixels(const GrPixelInfo& infoA, const char* a, size_t rowBytesA,
                     const GrPixelInfo& infoB, const char* b, size_t rowBytesB,
                     const float tolRGBA[4], std::function<ComparePixmapsErrorReporter>& error) {
@@ -210,28 +238,14 @@
     SkAssertResult(GrConvertPixels(floatInfo, floatA.get(), floatRowBytes, infoA, a, rowBytesA));
     SkAssertResult(GrConvertPixels(floatInfo, floatB.get(), floatRowBytes, infoB, b, rowBytesB));
 
-    auto at = [floatBpp, floatRowBytes](const char* floatBuffer, int x, int y) {
-        return reinterpret_cast<const float*>(floatBuffer + y * floatRowBytes + x * floatBpp);
-    };
-    for (int y = 0; y < infoA.height(); ++y) {
-        for (int x = 0; x < infoA.width(); ++x) {
-            const float* rgbaA = at(floatA.get(), x, y);
-            const float* rgbaB = at(floatB.get(), x, y);
-            float diffs[4];
-            bool bad = false;
-            for (int i = 0; i < 4; ++i) {
-                diffs[i] = rgbaB[i] - rgbaA[i];
-                if (std::abs(diffs[i]) > std::abs(tolRGBA[i])) {
-                    bad = true;
-                }
-            }
-            if (bad) {
-                error(x, y, diffs);
-                return false;
-            }
-        }
-    }
-    return true;
+    auto at = std::function<AccessPixelFn>(
+        [floatBpp, floatRowBytes](const char* floatBuffer, int x, int y) {
+            return reinterpret_cast<const float*>(floatBuffer + y * floatRowBytes + x * floatBpp);
+        });
+
+    return compare_pixels(infoA.width(), infoA.height(),
+                          floatA.get(), at, floatB.get(), at,
+                          tolRGBA, error);
 }
 
 bool compare_pixels(const SkPixmap& a, const SkPixmap& b, const float tolRGBA[4],
@@ -241,6 +255,47 @@
                           tolRGBA, error);
 }
 
+bool check_solid_pixels(const SkColor4f& col, const SkPixmap& pixmap,
+                        const float tolRGBA[4], std::function<ComparePixmapsErrorReporter>& error) {
+
+    size_t floatBpp = GrColorTypeBytesPerPixel(GrColorType::kRGBA_F32);
+
+    std::unique_ptr<char[]> floatA(new char[floatBpp]);
+    // First convert 'col' to be compatible with 'pixmap'
+    {
+        sk_sp<SkColorSpace> srcCS = SkColorSpace::MakeSRGBLinear();
+        GrPixelInfo srcInfo(GrColorType::kRGBA_F32, kUnpremul_SkAlphaType, std::move(srcCS), 1, 1);
+        GrPixelInfo dstInfo(GrColorType::kRGBA_F32, pixmap.alphaType(), pixmap.refColorSpace(), 1, 1);
+
+        SkAssertResult(GrConvertPixels(dstInfo, floatA.get(), floatBpp, srcInfo,
+                                       col.vec(), floatBpp));
+    }
+
+    size_t floatRowBytes = floatBpp * pixmap.width();
+    std::unique_ptr<char[]> floatB(new char[floatRowBytes * pixmap.height()]);
+    // Then convert 'pixmap' to RGBA_F32
+    {
+        GrPixelInfo dstInfo(GrColorType::kRGBA_F32, pixmap.alphaType(), pixmap.refColorSpace(),
+                            pixmap.width(), pixmap.height());
+
+        SkAssertResult(GrConvertPixels(dstInfo, floatB.get(), floatRowBytes, pixmap.info(),
+                                       pixmap.addr(), pixmap.rowBytes()));
+    }
+
+    auto atA = std::function<AccessPixelFn>(
+        [](const char* floatBuffer, int /* x */, int /* y */) {
+            return reinterpret_cast<const float*>(floatBuffer);
+        });
+
+    auto atB = std::function<AccessPixelFn>(
+        [floatBpp, floatRowBytes](const char* floatBuffer, int x, int y) {
+            return reinterpret_cast<const float*>(floatBuffer + y * floatRowBytes + x * floatBpp);
+        });
+
+    return compare_pixels(pixmap.width(), pixmap.height(), floatA.get(), atA, floatB.get(), atB,
+                          tolRGBA, error);
+}
+
 #include "src/utils/SkCharToGlyphCache.h"
 
 static SkGlyphID hash_to_glyph(uint32_t value) {
diff --git a/tests/TestUtils.h b/tests/TestUtils.h
index 660cdb4..347139d 100644
--- a/tests/TestUtils.h
+++ b/tests/TestUtils.h
@@ -75,3 +75,9 @@
 /** Convenience version of above that takes SkPixmap inputs. */
 bool compare_pixels(const SkPixmap& a, const SkPixmap& b, const float tolRGBA[4],
                     std::function<ComparePixmapsErrorReporter>& error);
+
+/**
+ * Convenience version that checks that 'pixmap' is a solid field of 'col'
+ */
+bool check_solid_pixels(const SkColor4f& col, const SkPixmap& pixmap,
+                        const float tolRGBA[4], std::function<ComparePixmapsErrorReporter>& error);