Make copy texture test more extensive

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -1101,6 +1101,8 @@ angle::Result FramebufferVk::readPixelsImpl(ContextVk *contextVk,
 {
     RendererVk *renderer = contextVk->getRenderer();
 
+    ANGLE_TRY(renderTarget->ensureImageInitialized(contextVk));
+
     vk::CommandBuffer *commandBuffer = nullptr;
     ANGLE_TRY(mFramebuffer.recordCommands(contextVk, &commandBuffer));
 

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -10,19 +10,26 @@
 #include "libANGLE/renderer/vulkan/RenderTargetVk.h"
 
 #include "libANGLE/renderer/vulkan/CommandGraph.h"
+#include "libANGLE/renderer/vulkan/TextureVk.h"
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace rx
 {
-RenderTargetVk::RenderTargetVk(vk::ImageHelper *image, vk::ImageView *imageView, size_t layerIndex)
-    : mImage(image), mImageView(imageView), mLayerIndex(layerIndex)
+RenderTargetVk::RenderTargetVk(vk::ImageHelper *image,
+                               vk::ImageView *imageView,
+                               size_t layerIndex,
+                               TextureVk *owner)
+    : mImage(image), mImageView(imageView), mLayerIndex(layerIndex), mOwner(owner)
 {}
 
 RenderTargetVk::~RenderTargetVk() {}
 
 RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
-    : mImage(other.mImage), mImageView(other.mImageView), mLayerIndex(other.mLayerIndex)
+    : mImage(other.mImage),
+      mImageView(other.mImageView),
+      mLayerIndex(other.mLayerIndex),
+      mOwner(other.mOwner)
 {}
 
 void RenderTargetVk::onColorDraw(vk::FramebufferHelper *framebufferVk,
@@ -107,6 +114,7 @@ void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image, vk::ImageView
     ASSERT(image && image->valid() && imageView && imageView->valid());
     mImage     = image;
     mImageView = imageView;
+    mOwner     = nullptr;
 }
 
 vk::ImageHelper *RenderTargetVk::getImageForRead(vk::RecordableGraphResource *readingResource,
@@ -133,4 +141,13 @@ vk::ImageHelper *RenderTargetVk::getImageForWrite(
     return mImage;
 }
 
+angle::Result RenderTargetVk::ensureImageInitialized(ContextVk *contextVk)
+{
+    if (mOwner)
+    {
+        return mOwner->ensureImageInitialized(contextVk);
+    }
+    return angle::Result::Continue;
+}
+
 }  // namespace rx

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -28,13 +28,19 @@ class RecordableGraphResource;
 class RenderPassDesc;
 }  // namespace vk
 
+class ContextVk;
+class TextureVk;
+
 // This is a very light-weight class that does not own to the resources it points to.
 // It's meant only to copy across some information from a FramebufferAttachment to the
 // business rendering logic. It stores Images and ImageViews by pointer for performance.
 class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 {
   public:
-    RenderTargetVk(vk::ImageHelper *image, vk::ImageView *imageView, size_t layerIndex);
+    RenderTargetVk(vk::ImageHelper *image,
+                   vk::ImageView *imageView,
+                   size_t layerIndex,
+                   TextureVk *ownwer);
     ~RenderTargetVk();
 
     // Used in std::vector initialization.
@@ -68,12 +74,18 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     // RenderTargetVk pointer.
     void updateSwapchainImage(vk::ImageHelper *image, vk::ImageView *imageView);
 
+    angle::Result ensureImageInitialized(ContextVk *contextVk);
+
   private:
     vk::ImageHelper *mImage;
     // Note that the draw and read image views are the same, given the requirements of a render
     // target.
     vk::ImageView *mImageView;
     size_t mLayerIndex;
+
+    // If owned by the texture, this will be non-nullptr, and is used to ensure texture changes
+    // are flushed.
+    TextureVk *mOwner;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -24,7 +24,7 @@ constexpr VkClearColorValue kBlackClearColorValue                 = {{0}};
 }  // anonymous namespace
 
 RenderbufferVk::RenderbufferVk(const gl::RenderbufferState &state)
-    : RenderbufferImpl(state), mRenderTarget(&mImage, &mImageView, 0)
+    : RenderbufferImpl(state), mRenderTarget(&mImage, &mImageView, 0, nullptr)
 {}
 
 RenderbufferVk::~RenderbufferVk() {}

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -74,7 +74,9 @@ constexpr VkImageUsageFlags kSurfaceVKDepthStencilImageUsageFlags =
 
 }  // namespace
 
-OffscreenSurfaceVk::AttachmentImage::AttachmentImage() : renderTarget(&image, &imageView, 0) {}
+OffscreenSurfaceVk::AttachmentImage::AttachmentImage()
+    : renderTarget(&image, &imageView, 0, nullptr)
+{}
 
 OffscreenSurfaceVk::AttachmentImage::~AttachmentImage() = default;
 
@@ -270,8 +272,8 @@ WindowSurfaceVk::WindowSurfaceVk(const egl::SurfaceState &surfaceState,
       mInstance(VK_NULL_HANDLE),
       mSwapchain(VK_NULL_HANDLE),
       mSwapchainPresentMode(VK_PRESENT_MODE_FIFO_KHR),
-      mColorRenderTarget(nullptr, nullptr, 0),
-      mDepthStencilRenderTarget(&mDepthStencilImage, &mDepthStencilImageView, 0),
+      mColorRenderTarget(nullptr, nullptr, 0, nullptr),
+      mDepthStencilRenderTarget(&mDepthStencilImage, &mDepthStencilImageView, 0, nullptr),
       mCurrentSwapchainImageIndex(0),
       mCurrentSwapSerialIndex(0)
 {}

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -383,7 +383,7 @@ PixelBuffer::SubresourceUpdate::SubresourceUpdate(const SubresourceUpdate &other
 // TextureVk implementation.
 TextureVk::TextureVk(const gl::TextureState &state, RendererVk *renderer)
     : TextureImpl(state),
-      mRenderTarget(&mImage, &mDrawBaseLevelImageView, 0),
+      mRenderTarget(&mImage, &mDrawBaseLevelImageView, 0, this),
       mPixelBuffer(renderer)
 {}
 
@@ -996,7 +996,7 @@ angle::Result TextureVk::initCubeMapRenderTargets(ContextVk *contextVk)
     {
         vk::ImageView *imageView;
         ANGLE_TRY(getLayerLevelDrawImageView(contextVk, cubeMapFaceIndex, 0, &imageView));
-        mCubeMapRenderTargets.emplace_back(&mImage, imageView, cubeMapFaceIndex);
+        mCubeMapRenderTargets.emplace_back(&mImage, imageView, cubeMapFaceIndex, this);
     }
     return angle::Result::Continue;
 }

src/tests/gl_tests/CopyTextureTest.cpp

@@ -74,6 +74,288 @@ class CopyTextureTest : public ANGLETest
         return true;
     }
 
+    void calculateCopyTextureResults(GLenum sourceFormat,
+                                     GLenum destFormat,
+                                     bool premultiplyAlpha,
+                                     bool unmultiplyAlpha,
+                                     const uint8_t *sourceColor,
+                                     GLColor *destColor)
+    {
+        GLColor color;
+
+        switch (sourceFormat)
+        {
+            case GL_RGB:
+                color = GLColor(sourceColor[0], sourceColor[1], sourceColor[2], 255);
+                break;
+            case GL_RGBA:
+                color = GLColor(sourceColor[0], sourceColor[1], sourceColor[2], sourceColor[3]);
+                break;
+            case GL_LUMINANCE:
+                color = GLColor(sourceColor[0], sourceColor[0], sourceColor[0], 255);
+                break;
+            case GL_ALPHA:
+                color = GLColor(0, 0, 0, sourceColor[0]);
+                break;
+            case GL_LUMINANCE_ALPHA:
+                color = GLColor(sourceColor[0], sourceColor[0], sourceColor[0], sourceColor[1]);
+                break;
+            case GL_BGRA_EXT:
+                color = GLColor(sourceColor[2], sourceColor[1], sourceColor[0], sourceColor[3]);
+                break;
+            default:
+                EXPECT_EQ(true, false);
+        }
+
+        if (premultiplyAlpha != unmultiplyAlpha)
+        {
+            float alpha = color.A / 255.0f;
+            if (premultiplyAlpha)
+            {
+                color.R *= alpha;
+                color.G *= alpha;
+                color.B *= alpha;
+            }
+            else if (unmultiplyAlpha && color.A != 0)
+            {
+                color.R /= alpha;
+                color.G /= alpha;
+                color.B /= alpha;
+            }
+        }
+
+        switch (destFormat)
+        {
+            case GL_RGB:
+                color.A = 255;
+                break;
+            case GL_RGBA:
+            case GL_BGRA_EXT:
+                break;
+            default:
+                EXPECT_EQ(true, false);
+        }
+
+        *destColor = color;
+    }
+
+    const uint8_t *getSourceColors(GLenum sourceFormat, size_t *colorCount, uint8_t *componentCount)
+    {
+        // Note: in all the following values, alpha is larger than RGB so unmultiply alpha doesn't
+        // overflow
+        constexpr static uint8_t kRgbaColors[7 * 4] = {
+            255u, 127u, 63u,  255u,  // 0
+            31u,  127u, 63u,  127u,  // 1
+            31u,  63u,  127u, 255u,  // 2
+            15u,  127u, 31u,  127u,  // 3
+            127u, 255u, 63u,  0u,    // 4
+            31u,  63u,  127u, 0u,    // 5
+            15u,  31u,  63u,  63u,   // 6
+        };
+
+        constexpr static uint8_t kRgbColors[7 * 3] = {
+            255u, 127u, 63u,   // 0
+            31u,  127u, 63u,   // 1
+            31u,  63u,  127u,  // 2
+            15u,  127u, 31u,   // 3
+            127u, 255u, 63u,   // 4
+            31u,  63u,  127u,  // 5
+            15u,  31u,  63u,   // 6
+        };
+
+        constexpr static uint8_t kLumColors[7 * 1] = {
+            255u,  // 0
+            163u,  // 1
+            78u,   // 2
+            114u,  // 3
+            51u,   // 4
+            0u,    // 5
+            217u,  // 6
+        };
+
+        constexpr static uint8_t kLumaColors[7 * 2] = {
+            255u, 255u,  // 0
+            67u,  163u,  // 1
+            78u,  231u,  // 2
+            8u,   114u,  // 3
+            51u,  199u,  // 4
+            0u,   173u,  // 5
+            34u,  217u,  // 6
+        };
+
+        constexpr static uint8_t kAlphaColors[7 * 1] = {
+            255u,  // 0
+            67u,   // 1
+            231u,  // 2
+            8u,    // 3
+            199u,  // 4
+            173u,  // 5
+            34u,   // 6
+        };
+
+        *colorCount = 7;
+
+        switch (sourceFormat)
+        {
+            case GL_RGB:
+                *componentCount = 3;
+                return kRgbColors;
+            case GL_RGBA:
+            case GL_BGRA_EXT:
+                *componentCount = 4;
+                return kRgbaColors;
+            case GL_LUMINANCE:
+                *componentCount = 1;
+                return kLumColors;
+            case GL_ALPHA:
+                *componentCount = 1;
+                return kAlphaColors;
+            case GL_LUMINANCE_ALPHA:
+                *componentCount = 2;
+                return kLumaColors;
+            default:
+                EXPECT_EQ(true, false);
+                return nullptr;
+        }
+    }
+
+    void initializeSourceTexture(GLenum sourceFormat,
+                                 const uint8_t *srcColors,
+                                 uint8_t componentCount)
+    {
+        // The texture is initialized as 2x2.  If the componentCount is 1 or 3, then the input data
+        // will have a row pitch of 2 or 6, which needs to be padded to 4 or 8 respectively.
+        uint8_t srcColorsPadded[4 * 4];
+        size_t srcRowPitch =
+            2 * componentCount + (componentCount == 1 || componentCount == 3 ? 2 : 0);
+        size_t inputRowPitch = 2 * componentCount;
+        for (size_t row = 0; row < 2; ++row)
+        {
+            memcpy(&srcColorsPadded[row * srcRowPitch], &srcColors[row * inputRowPitch],
+                   inputRowPitch);
+            memset(&srcColorsPadded[row * srcRowPitch + inputRowPitch], 0,
+                   srcRowPitch - inputRowPitch);
+        }
+
+        glBindTexture(GL_TEXTURE_2D, mTextures[0]);
+        glTexImage2D(GL_TEXTURE_2D, 0, sourceFormat, 2, 2, 0, sourceFormat, GL_UNSIGNED_BYTE,
+                     srcColorsPadded);
+    }
+
+    void testCopyTexture(GLenum sourceFormat,
+                         GLenum destFormat,
+                         bool flipY,
+                         bool premultiplyAlpha,
+                         bool unmultiplyAlpha)
+    {
+        if (!checkExtensions())
+        {
+            return;
+        }
+
+        size_t colorCount;
+        uint8_t componentCount;
+        const uint8_t *srcColors = getSourceColors(sourceFormat, &colorCount, &componentCount);
+
+        std::vector<GLColor> destColors(colorCount);
+        for (size_t i = 0; i < colorCount; ++i)
+        {
+            calculateCopyTextureResults(sourceFormat, destFormat, premultiplyAlpha, unmultiplyAlpha,
+                                        &srcColors[i * componentCount], &destColors[i]);
+        }
+
+        for (size_t i = 0; i < colorCount - 3; ++i)
+        {
+            initializeSourceTexture(sourceFormat, &srcColors[i * componentCount], componentCount);
+
+            glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, destFormat,
+                                  GL_UNSIGNED_BYTE, flipY, premultiplyAlpha, unmultiplyAlpha);
+
+            EXPECT_GL_NO_ERROR();
+
+            // Check that FB is complete.
+            EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+            if (flipY)
+            {
+                EXPECT_PIXEL_COLOR_NEAR(0, 0, destColors[i + 2], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 0, destColors[i + 3], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(0, 1, destColors[i + 0], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 1, destColors[i + 1], 1.0);
+            }
+            else
+            {
+                EXPECT_PIXEL_COLOR_NEAR(0, 0, destColors[i + 0], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 0, destColors[i + 1], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(0, 1, destColors[i + 2], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 1, destColors[i + 3], 1.0);
+            }
+
+            EXPECT_GL_NO_ERROR();
+        }
+    }
+
+    void testCopySubTexture(GLenum sourceFormat,
+                            GLenum destFormat,
+                            bool flipY,
+                            bool premultiplyAlpha,
+                            bool unmultiplyAlpha)
+    {
+        if (!checkExtensions())
+        {
+            return;
+        }
+
+        size_t colorCount;
+        uint8_t componentCount;
+        const uint8_t *srcColors = getSourceColors(sourceFormat, &colorCount, &componentCount);
+
+        std::vector<GLColor> destColors(colorCount);
+        for (size_t i = 0; i < colorCount; ++i)
+        {
+            calculateCopyTextureResults(sourceFormat, destFormat, premultiplyAlpha, unmultiplyAlpha,
+                                        &srcColors[i * componentCount], &destColors[i]);
+        }
+
+        for (size_t i = 0; i < colorCount - 3; ++i)
+        {
+            initializeSourceTexture(sourceFormat, &srcColors[i * componentCount], componentCount);
+
+            glBindTexture(GL_TEXTURE_2D, mTextures[1]);
+            glTexImage2D(GL_TEXTURE_2D, 0, destFormat, 2, 2, 0, destFormat, GL_UNSIGNED_BYTE,
+                         nullptr);
+
+            glCopySubTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, 0, 0, 0, 0, 2,
+                                     2, flipY, premultiplyAlpha, unmultiplyAlpha);
+
+            EXPECT_GL_NO_ERROR();
+
+            if (sourceFormat != GL_LUMINANCE && sourceFormat != GL_LUMINANCE_ALPHA &&
+                sourceFormat != GL_ALPHA)
+            {
+                // Check that FB is complete.
+                EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+            }
+
+            if (flipY)
+            {
+                EXPECT_PIXEL_COLOR_NEAR(0, 0, destColors[i + 2], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 0, destColors[i + 3], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(0, 1, destColors[i + 0], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 1, destColors[i + 1], 1.0);
+            }
+            else
+            {
+                EXPECT_PIXEL_COLOR_NEAR(0, 0, destColors[i + 0], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 0, destColors[i + 1], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(0, 1, destColors[i + 2], 1.0);
+                EXPECT_PIXEL_COLOR_NEAR(1, 1, destColors[i + 3], 1.0);
+            }
+
+            EXPECT_GL_NO_ERROR();
+        }
+    }
+
     void testGradientDownsampleUniqueValues(GLenum destFormat,
                                             GLenum destType,
                                             const std::array<size_t, 4> &expectedUniqueValues)
@@ -144,51 +426,13 @@ class CopyTextureTestES3 : public CopyTextureTest
 // Test to ensure that the basic functionality of the extension works.
 TEST_P(CopyTextureTest, BasicCopyTexture)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
-
-    GLColor pixels = GLColor::red;
-
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &pixels);
-
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, false, false, false);
-
-    EXPECT_GL_NO_ERROR();
-
-    EXPECT_PIXEL_COLOR_EQ(0, 0, pixels);
+    testCopyTexture(GL_RGBA, GL_RGBA, false, false, false);
 }
 
 // Test to ensure that the basic functionality of the extension works.
 TEST_P(CopyTextureTest, BasicCopySubTexture)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
-
-    GLColor pixels = GLColor::red;
-
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &pixels);
-
-    glBindTexture(GL_TEXTURE_2D, mTextures[1]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-
-    glCopySubTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, 0, 0, 0, 0, 1, 1,
-                             false, false, false);
-
-    EXPECT_GL_NO_ERROR();
-
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
-
-    EXPECT_PIXEL_COLOR_EQ(0, 0, pixels);
-
-    EXPECT_GL_NO_ERROR();
+    testCopySubTexture(GL_RGBA, GL_RGBA, false, false, false);
 }
 
 // Test that CopyTexture cannot redefine an immutable texture and CopySubTexture can copy data to
@@ -480,220 +724,2065 @@ TEST_P(CopyTextureTest, CopySubTextureOffset)
     glBindTexture(GL_TEXTURE_2D, mTextures[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, transparentPixels);
 
+    // Check that FB is complete.
+    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
     glCopySubTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, 1, 1, 0, 0, 1, 1,
                              false, false, false);
     EXPECT_GL_NO_ERROR();
+    EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor::red);
+
     glCopySubTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, 1, 0, 1, 0, 1, 1,
                              false, false, false);
     EXPECT_GL_NO_ERROR();
+    EXPECT_PIXEL_COLOR_EQ(1, 0, GLColor::green);
+
     glCopySubTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, 0, 1, 0, 1, 1, 1,
                              false, false, false);
     EXPECT_GL_NO_ERROR();
-
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+    EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::blue);
 
     EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::transparentBlack);
-    EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor::red);
-    EXPECT_PIXEL_COLOR_EQ(1, 0, GLColor::green);
-    EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::blue);
     EXPECT_GL_NO_ERROR();
 }
 
-// Test that flipping the Y component works correctly
-TEST_P(CopyTextureTest, FlipY)
+// Test every combination of copy [sub]texture parameters:
+// source: ALPHA, RGB, RGBA, LUMINANCE, LUMINANCE_ALPHA, BGRA_EXT
+// destination: RGB, RGBA, BGRA_EXT
+// flipY: false, true
+// premultiplyAlpha: false, true
+// unmultiplyAlpha: false, true
+TEST_P(CopyTextureTest, CopyTextureAToRGB)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
+    testCopyTexture(GL_ALPHA, GL_RGB, false, false, false);
+}
 
-    GLColor rgbaPixels[4] = {GLColor(255u, 255u, 255u, 255u), GLColor(127u, 127u, 127u, 127u),
-                             GLColor(63u, 63u, 63u, 127u), GLColor(255u, 255u, 255u, 0u)};
+TEST_P(CopyTextureTest, CopySubTextureAToRGB)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, false, false, false);
+}
 
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaPixels);
+TEST_P(CopyTextureTest, CopyTextureAToRGBUnmultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGB, false, false, true);
+}
 
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, GL_TRUE, GL_FALSE, GL_FALSE);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, false, false, true);
+}
 
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+TEST_P(CopyTextureTest, CopyTextureAToRGBPremultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGB, false, true, false);
+}
 
-    EXPECT_PIXEL_COLOR_EQ(0, 0, rgbaPixels[2]);
-    EXPECT_PIXEL_COLOR_EQ(1, 0, rgbaPixels[3]);
-    EXPECT_PIXEL_COLOR_EQ(0, 1, rgbaPixels[0]);
-    EXPECT_PIXEL_COLOR_EQ(1, 1, rgbaPixels[1]);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBPremultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, false, true, false);
 }
 
-// Test that premultipying the alpha on copy works correctly
-TEST_P(CopyTextureTest, PremultiplyAlpha)
+TEST_P(CopyTextureTest, CopyTextureAToRGBPremultiplyAlphaUnmultiplyAlpha)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
+    testCopyTexture(GL_ALPHA, GL_RGB, false, true, true);
+}
 
-    GLColor rgbaPixels[4] = {GLColor(255u, 255u, 255u, 255u), GLColor(255u, 255u, 255u, 127u),
-                             GLColor(127u, 127u, 127u, 127u), GLColor(255u, 255u, 255u, 0u)};
+TEST_P(CopyTextureTest, CopySubTextureAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, false, true, true);
+}
 
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaPixels);
+TEST_P(CopyTextureTest, CopyTextureAToRGBFlipY)
+{
+    testCopyTexture(GL_ALPHA, GL_RGB, true, false, false);
+}
 
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, GL_FALSE, GL_TRUE, GL_FALSE);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBFlipY)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, true, false, false);
+}
 
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+TEST_P(CopyTextureTest, CopyTextureAToRGBFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGB, true, false, true);
+}
 
-    EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor(255, 255, 255, 255), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(1, 0, GLColor(127, 127, 127, 127), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(0, 1, GLColor(63, 63, 63, 127), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(1, 1, GLColor(0, 0, 0, 0), 1.0);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, true, false, true);
 }
 
-// Test that unmultipying the alpha on copy works correctly
-TEST_P(CopyTextureTest, UnmultiplyAlpha)
+TEST_P(CopyTextureTest, CopyTextureAToRGBFlipYPremultiplyAlpha)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
+    testCopyTexture(GL_ALPHA, GL_RGB, true, true, false);
+}
 
-    GLColor rgbaPixels[4] = {GLColor(255u, 255u, 255u, 255u), GLColor(127u, 127u, 127u, 127u),
-                             GLColor(63u, 63u, 63u, 127u), GLColor(255u, 255u, 255u, 0u)};
+TEST_P(CopyTextureTest, CopySubTextureAToRGBFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, true, true, false);
+}
 
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaPixels);
+TEST_P(CopyTextureTest, CopyTextureAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGB, true, true, true);
+}
 
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, GL_FALSE, GL_FALSE, GL_TRUE);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGB, true, true, true);
+}
 
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+TEST_P(CopyTextureTest, CopyTextureAToRGBA)
+{
+    testCopyTexture(GL_ALPHA, GL_RGBA, false, false, false);
+}
 
-    EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor(255, 255, 255, 255), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(1, 0, GLColor(255, 255, 255, 127), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(0, 1, GLColor(127, 127, 127, 127), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(1, 1, GLColor(255, 255, 255, 0), 1.0);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBA)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, false, false, false);
 }
 
-// Test that unmultipying and premultiplying the alpha is the same as doing neither
-TEST_P(CopyTextureTest, UnmultiplyAndPremultiplyAlpha)
+TEST_P(CopyTextureTest, CopyTextureAToRGBAUnmultiplyAlpha)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
+    testCopyTexture(GL_ALPHA, GL_RGBA, false, false, true);
+}
 
-    GLColor rgbaPixels[4] = {GLColor(255u, 255u, 255u, 255u), GLColor(127u, 127u, 127u, 127u),
-                             GLColor(63u, 63u, 63u, 127u), GLColor(255u, 255u, 255u, 0u)};
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, false, false, true);
+}
 
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaPixels);
+TEST_P(CopyTextureTest, CopyTextureAToRGBAPremultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGBA, false, true, false);
+}
 
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, GL_FALSE, GL_TRUE, GL_TRUE);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAPremultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, false, true, false);
+}
 
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+TEST_P(CopyTextureTest, CopyTextureAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGBA, false, true, true);
+}
 
-    EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor(255, 255, 255, 255), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(1, 0, GLColor(127, 127, 127, 127), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(0, 1, GLColor(63, 63, 63, 127), 1.0);
-    EXPECT_PIXEL_COLOR_NEAR(1, 1, GLColor(255, 255, 255, 0), 1.0);
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, false, true, true);
 }
 
-// Test to ensure that CopyTexture works with LUMINANCE_ALPHA texture
-TEST_P(CopyTextureTest, LuminanceAlpha)
+TEST_P(CopyTextureTest, CopyTextureAToRGBAFlipY)
 {
-    if (!checkExtensions())
-    {
-        return;
-    }
+    testCopyTexture(GL_ALPHA, GL_RGBA, true, false, false);
+}
 
-    uint8_t originalPixels[] = {163u, 67u};
-    GLColor expectedPixels(163u, 163u, 163u, 67u);
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAFlipY)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, true, false, false);
+}
 
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 1, 1, 0, GL_LUMINANCE_ALPHA,
-                 GL_UNSIGNED_BYTE, &originalPixels);
+TEST_P(CopyTextureTest, CopyTextureAToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGBA, true, false, true);
+}
 
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, false, false, false);
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, true, false, true);
+}
 
-    EXPECT_GL_NO_ERROR();
+TEST_P(CopyTextureTest, CopyTextureAToRGBAFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_ALPHA, GL_RGBA, true, true, false);
+}
 
-    EXPECT_PIXEL_COLOR_EQ(0, 0, expectedPixels);
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, true, true, false);
 }
 
-// Test to ensure that CopyTexture works with LUMINANCE texture
-TEST_P(CopyTextureTest, Luminance)
+TEST_P(CopyTextureTest, CopyTextureAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
 {
-    if (!checkExtensions())
+    testCopyTexture(GL_ALPHA, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_ALPHA, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
     {
         return;
     }
-
-    uint8_t originalPixels[] = {57u};
-    GLColor expectedPixels(57u, 57u, 57u, 255u);
-
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
-                 &originalPixels);
-
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, false, false, false);
-
-    EXPECT_GL_NO_ERROR();
-
-    EXPECT_PIXEL_COLOR_EQ(0, 0, expectedPixels);
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, false, false, false);
 }
 
-// Test to ensure that CopyTexture works with ALPHA texture
-TEST_P(CopyTextureTest, Alpha)
+TEST_P(CopyTextureTest, CopySubTextureAToBGRA)
 {
-    if (!checkExtensions())
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
     {
         return;
     }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, false, false, false);
+}
 
-    uint8_t originalPixels[] = {77u};
-    GLColor expectedPixels(0u, 0u, 0u, 77u);
-
-    glBindTexture(GL_TEXTURE_2D, mTextures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 1, 1, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &originalPixels);
-
-    glCopyTextureCHROMIUM(mTextures[0], 0, GL_TEXTURE_2D, mTextures[1], 0, GL_RGBA,
-                          GL_UNSIGNED_BYTE, false, false, false);
-
-    EXPECT_GL_NO_ERROR();
-
-    EXPECT_PIXEL_COLOR_EQ(0, 0, expectedPixels);
+TEST_P(CopyTextureTest, CopyTextureAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, false, false, true);
 }
 
-// Test that copying to cube maps works
-TEST_P(CopyTextureTest, CubeMapTarget)
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAUnmultiplyAlpha)
 {
-    if (!checkExtensions())
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
     {
         return;
     }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, false, false, true);
+}
 
-    GLColor pixels = GLColor::red;
+TEST_P(CopyTextureTest, CopyTextureAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_ALPHA, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_ALPHA, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGB)
+{
+    testCopyTexture(GL_RGB, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGB)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBFlipY)
+{
+    testCopyTexture(GL_RGB, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBFlipY)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBA)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBA)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAFlipY)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAFlipY)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGB, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGB, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGB, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGB, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGB)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGB)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBFlipY)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBFlipY)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBA)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBA)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAFlipY)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAFlipY)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_RGBA, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_RGBA, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureRGBAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_RGBA, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureRGBAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_RGBA, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGB)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGB)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBFlipY)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBFlipY)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBA)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBA)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAFlipY)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAFlipY)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGB)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGB)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBFlipY)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBFlipY)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBA)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBA)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAFlipY)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAFlipY)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAFlipYUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAFlipYPremultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAFlipYPremultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureLAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureLAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_LUMINANCE_ALPHA, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGB)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGB)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGB, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToRGBAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_RGBA, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRA)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, false, true, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAFlipY)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, false, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAFlipYUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, false, true);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAFlipYPremultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, true, false);
+}
+
+TEST_P(CopyTextureTest, CopyTextureBGRAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopyTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, true, true);
+}
+
+TEST_P(CopyTextureTest, CopySubTextureBGRAToBGRAFlipYPremultiplyAlphaUnmultiplyAlpha)
+{
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+    testCopySubTexture(GL_BGRA_EXT, GL_BGRA_EXT, true, true, true);
+}
+
+// Test that copying to cube maps works
+TEST_P(CopyTextureTest, CubeMapTarget)
+{
+    if (!checkExtensions())
+    {
+        return;
+    }
+
+    // http://anglebug.com/1932
+    ANGLE_SKIP_TEST_IF(IsOSX() && IsIntel() && IsDesktopOpenGL());
+
+    GLColor pixels[7] = {
+        GLColor(10u, 13u, 16u, 19u), GLColor(20u, 23u, 26u, 29u), GLColor(30u, 33u, 36u, 39u),
+        GLColor(40u, 43u, 46u, 49u), GLColor(50u, 53u, 56u, 59u), GLColor(60u, 63u, 66u, 69u),
+        GLColor(70u, 73u, 76u, 79u),
+    };
 
     GLTexture textures[2];
 
-    glBindTexture(GL_TEXTURE_2D, textures[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &pixels);
+    glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
+    for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+         face++)
+    {
+        glTexImage2D(face, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    }
+
+    for (size_t i = 0; i < 2; ++i)
+    {
+        for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+             face++)
+        {
+            glBindTexture(GL_TEXTURE_2D, textures[0]);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                         &pixels[face - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i]);
+
+            glCopySubTextureCHROMIUM(textures[0], 0, face, textures[1], 0, 0, 0, 0, 0, 1, 1, false,
+                                     false, false);
+        }
+
+        EXPECT_GL_NO_ERROR();
+
+        GLFramebuffer fbo;
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+
+        for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+             face++)
+        {
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, face, textures[1], 0);
+
+            // Check that FB is complete.
+            EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+            EXPECT_PIXEL_COLOR_EQ(0, 0, pixels[face - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i]);
+
+            EXPECT_GL_NO_ERROR();
+        }
+    }
+}
+
+// Test BGRA to RGBA cube map copy
+TEST_P(CopyTextureTest, CubeMapTargetBGRA)
+{
+    if (!checkExtensions())
+    {
+        return;
+    }
+
+    if (!extensionEnabled("GL_EXT_texture_format_BGRA8888"))
+    {
+        return;
+    }
+
+    GLColor pixels[7] = {
+        GLColor(10u, 13u, 16u, 19u), GLColor(20u, 23u, 26u, 29u), GLColor(30u, 33u, 36u, 39u),
+        GLColor(40u, 43u, 46u, 49u), GLColor(50u, 53u, 56u, 59u), GLColor(60u, 63u, 66u, 69u),
+        GLColor(70u, 73u, 76u, 79u),
+    };
+
+    GLTexture textures[2];
 
     glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
     for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
@@ -702,22 +2791,106 @@ TEST_P(CopyTextureTest, CubeMapTarget)
         glTexImage2D(face, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
     }
 
-    glCopySubTextureCHROMIUM(textures[0], 0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, textures[1], 0, 0, 0,
-                             0, 0, 1, 1, false, false, false);
+    for (size_t i = 0; i < 2; ++i)
+    {
+        for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+             face++)
+        {
+            glBindTexture(GL_TEXTURE_2D, textures[0]);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, 1, 1, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE,
+                         &pixels[face - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i]);
 
-    EXPECT_GL_NO_ERROR();
+            glCopySubTextureCHROMIUM(textures[0], 0, face, textures[1], 0, 0, 0, 0, 0, 1, 1, false,
+                                     false, false);
+        }
 
-    GLFramebuffer fbo;
-    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-                           textures[1], 0);
+        EXPECT_GL_NO_ERROR();
 
-    // Check that FB is complete.
-    EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+        GLFramebuffer fbo;
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 
-    EXPECT_PIXEL_COLOR_EQ(0, 0, pixels);
+        for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+             face++)
+        {
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, face, textures[1], 0);
 
-    EXPECT_GL_NO_ERROR();
+            // Check that FB is complete.
+            EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+            GLColor converted = pixels[face - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i];
+            std::swap(converted.R, converted.B);
+            EXPECT_PIXEL_COLOR_EQ(0, 0, converted);
+
+            EXPECT_GL_NO_ERROR();
+        }
+    }
+}
+
+// Test cube map copies with RGB format
+TEST_P(CopyTextureTest, CubeMapTargetRGB)
+{
+    if (!checkExtensions())
+    {
+        return;
+    }
+
+    // http://anglebug.com/1932
+    ANGLE_SKIP_TEST_IF(IsOSX() && IsIntel() && IsDesktopOpenGL());
+
+    constexpr uint8_t pixels[16 * 7] = {
+        0u,   3u,   6u,   10u,  13u,  16u,  0, 0, 20u,  23u,  26u,  30u,  33u,  36u,  0, 0,  // 2x2
+        40u,  43u,  46u,  50u,  53u,  56u,  0, 0, 60u,  63u,  66u,  70u,  73u,  76u,  0, 0,  // 2x2
+        80u,  83u,  86u,  90u,  93u,  96u,  0, 0, 100u, 103u, 106u, 110u, 113u, 116u, 0, 0,  // 2x2
+        120u, 123u, 126u, 130u, 133u, 136u, 0, 0, 140u, 143u, 146u, 160u, 163u, 166u, 0, 0,  // 2x2
+        170u, 173u, 176u, 180u, 183u, 186u, 0, 0, 190u, 193u, 196u, 200u, 203u, 206u, 0, 0,  // 2x2
+        210u, 213u, 216u, 220u, 223u, 226u, 0, 0, 230u, 233u, 236u, 240u, 243u, 246u, 0, 0,  // 2x2
+        10u,  50u,  100u, 30u,  80u,  130u, 0, 0, 60u,  110u, 160u, 90u,  140u, 200u, 0, 0,  // 2x2
+    };
+
+    GLTexture textures[2];
+
+    glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
+    for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+         face++)
+    {
+        glTexImage2D(face, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
+    }
+
+    for (size_t i = 0; i < 2; ++i)
+    {
+        for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+             face++)
+        {
+            glBindTexture(GL_TEXTURE_2D, textures[0]);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE,
+                         &pixels[(face - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i) * 16]);
+
+            glCopySubTextureCHROMIUM(textures[0], 0, face, textures[1], 0, 0, 0, 0, 0, 2, 2, false,
+                                     false, false);
+        }
+
+        EXPECT_GL_NO_ERROR();
+
+        GLFramebuffer fbo;
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+
+        for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+             face++)
+        {
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, face, textures[1], 0);
+
+            // Check that FB is complete.
+            EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+            const uint8_t *faceData = &pixels[(face - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i) * 16];
+            EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(faceData[0], faceData[1], faceData[2], 255));
+            EXPECT_PIXEL_COLOR_EQ(1, 0, GLColor(faceData[3], faceData[4], faceData[5], 255));
+            EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor(faceData[8], faceData[9], faceData[10], 255));
+            EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor(faceData[11], faceData[12], faceData[13], 255));
+
+            EXPECT_GL_NO_ERROR();
+        }
+    }
 }
 
 // Test that copying to non-zero mipmaps works