src/third_party/skia/tests/ReadWriteAlphaTest.cpp

   1 /*
   2  * Copyright 2012 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 // This test is specific to the GPU backend.
   9 #if SK_SUPPORT_GPU && !defined(SK_BUILD_FOR_ANDROID)
  10
  11 #include "GrContextFactory.h"
  12 #include "SkGpuDevice.h"
  13 #include "Test.h"
  14
  15 static const int X_SIZE = 12;
  16 static const int Y_SIZE = 12;
  17
  18 DEF_GPUTEST(ReadWriteAlpha, reporter, factory) {
  19     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
  20         GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
  21         if (!GrContextFactory::IsRenderingGLContext(glType)) {
  22             continue;
  23         }
  24         GrContext* context = factory->get(glType);
  25         if (NULL == context) {
  26             continue;
  27         }
  28
  29         unsigned char textureData[X_SIZE][Y_SIZE];
  30
  31         memset(textureData, 0, X_SIZE * Y_SIZE);
  32
  33         GrTextureDesc desc;
  34
  35         // let Skia know we will be using this texture as a render target
  36         desc.fFlags     = kRenderTarget_GrTextureFlagBit;
  37         // it is a single channel texture
  38         desc.fConfig    = kAlpha_8_GrPixelConfig;
  39         desc.fWidth     = X_SIZE;
  40         desc.fHeight    = Y_SIZE;
  41
  42         // We are initializing the texture with zeros here
  43         GrTexture* texture = context->createUncachedTexture(desc, textureData, 0);
  44         if (!texture) {
  45             return;
  46         }
  47
  48         SkAutoTUnref<GrTexture> au(texture);
  49
  50         // create a distinctive texture
  51         for (int y = 0; y < Y_SIZE; ++y) {
  52             for (int x = 0; x < X_SIZE; ++x) {
  53                 textureData[x][y] = x*Y_SIZE+y;
  54             }
  55         }
  56
  57         // upload the texture
  58         texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
  59                              textureData, 0);
  60
  61         unsigned char readback[X_SIZE][Y_SIZE];
  62
  63         // clear readback to something non-zero so we can detect readback failures
  64         memset(readback, 0x1, X_SIZE * Y_SIZE);
  65
  66         // read the texture back
  67         texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
  68                             readback, 0);
  69
  70         // make sure the original & read back versions match
  71         bool match = true;
  72
  73         for (int y = 0; y < Y_SIZE; ++y) {
  74             for (int x = 0; x < X_SIZE; ++x) {
  75                 if (textureData[x][y] != readback[x][y]) {
  76                     match = false;
  77                 }
  78             }
  79         }
  80
  81         REPORTER_ASSERT(reporter, match);
  82
  83         // Now try writing on the single channel texture
  84         SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(texture->asRenderTarget(),
  85                                       SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType)));
  86         SkCanvas canvas(device);
  87
  88         SkPaint paint;
  89
  90         const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10);
  91
  92         paint.setColor(SK_ColorWHITE);
  93
  94         canvas.drawRect(rect, paint);
  95
  96         texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
  97                             readback, 0);
  98
  99         match = true;
 100
 101         for (int y = 0; y < Y_SIZE; ++y) {
 102             for (int x = 0; x < X_SIZE; ++x) {
 103                 if (0xFF != readback[x][y]) {
 104                     match = false;
 105                 }
 106             }
 107         }
 108
 109         REPORTER_ASSERT(reporter, match);
 110     }
 111 }
 112
 113 #endif