//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// CopyTexture3DTest.cpp: Tests of the GL_ANGLE_copy_texture_3d extension

#include <array>

#include "common/unsafe_buffers.h"
#include "test_utils/ANGLETest.h"

#include "test_utils/gl_raii.h"

namespace angle
{

class CopyTexture3DTest : public ANGLETest<>
{
  protected:
    CopyTexture3DTest()
    {
        setWindowWidth(256);
        setWindowHeight(256);
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
    }

    void testSetUp() override
    {
        const char *vertexShaderSource   = getVertexShaderSource();
        const char *fragmentShaderSource = getFragmentShaderSource();

        mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
        ASSERT_NE(0u, mProgram);

        glUseProgram(mProgram);

        ASSERT_GL_NO_ERROR();
    }

    const char *getVertexShaderSource()
    {
        return "#version 300 es\n"
               "out vec3 texcoord;\n"
               "in vec4 position;\n"
               "void main()\n"
               "{\n"
               "    gl_Position = vec4(position.xy, 0.0, 1.0);\n"
               "    texcoord = (position.xyz * 0.5) + 0.5;\n"
               "}\n";
    }

    bool checkExtensions() const
    {
        if (!IsGLExtensionEnabled("GL_ANGLE_copy_texture_3d"))
        {
            std::cout << "Test skipped because GL_ANGLE_copy_texture_3d is not available."
                      << std::endl;
            return false;
        }

        EXPECT_NE(nullptr, glCopyTexture3DANGLE);
        EXPECT_NE(nullptr, glCopySubTexture3DANGLE);
        return true;
    }

    void testCopy(const GLenum testTarget,
                  const GLColor &sourceColor,
                  GLenum destInternalFormat,
                  GLenum destType,
                  bool flipY,
                  bool premultiplyAlpha,
                  bool unmultiplyAlpha,
                  const GLColor &expectedColor)
    {
        std::vector<GLColor> texDataColor(2u * 2u * 2u, sourceColor);

        glBindTexture(testTarget, sourceTexture);
        glTexImage3D(testTarget, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                     texDataColor.data());
        glTexParameteri(testTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(testTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(testTarget, GL_TEXTURE_BASE_LEVEL, 0);
        glTexParameteri(testTarget, GL_TEXTURE_MAX_LEVEL, 0);
        EXPECT_GL_NO_ERROR();

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(testTarget, destTexture);
        glCopyTexture3DANGLE(sourceTexture, 0, testTarget, destTexture, 0, destInternalFormat,
                             destType, flipY, premultiplyAlpha, unmultiplyAlpha);
        EXPECT_GL_NO_ERROR();

        GLRenderbuffer rbo;
        glBindRenderbuffer(GL_RENDERBUFFER, rbo);

        GLenum renderType = 0;

        switch (destInternalFormat)
        {
            case GL_RGB:
            case GL_RGBA:
            case GL_LUMINANCE:
            case GL_LUMINANCE_ALPHA:
            case GL_ALPHA:
            case GL_R8:
            case GL_RG:
            case GL_RG8:
            case GL_RGB8:
            case GL_RGBA8:
            case GL_RGBX8_ANGLE:
            case GL_SRGB8:
            case GL_RGB565:
            case GL_SRGB8_ALPHA8:
            case GL_RGB5_A1:
            case GL_RGBA4:
            case GL_R8_SNORM:
            case GL_RG8_SNORM:
            case GL_RGB8_SNORM:
            case GL_RGBA8_SNORM:
            case GL_RGB10_A2:
                renderType = GL_RGBA8;
                break;
            case GL_R8I:
            case GL_R16I:
            case GL_R32I:
            case GL_RG8I:
            case GL_RG16I:
            case GL_RG32I:
            case GL_RGB8I:
            case GL_RGB16I:
            case GL_RGB32I:
            case GL_RGBA8I:
            case GL_RGBA16I:
            case GL_RGBA32I:
                renderType = GL_RGBA8I;
                break;
            case GL_R8UI:
            case GL_R16UI:
            case GL_R32UI:
            case GL_RG8UI:
            case GL_RG16UI:
            case GL_RG32UI:
            case GL_RGB8UI:
            case GL_RGB16UI:
            case GL_RGB32UI:
            case GL_RGBA8UI:
            case GL_RGBA16UI:
            case GL_RGBA32UI:
            case GL_RGB10_A2UI:
                renderType = GL_RGBA8UI;
                break;
            case GL_R16F:
            case GL_RGB16F:
            case GL_RGB32F:
            case GL_R32F:
            case GL_RG16F:
            case GL_RG32F:
            case GL_RGBA16F:
            case GL_RGBA32F:
            case GL_R11F_G11F_B10F:
            case GL_RGB9_E5:
                renderType = GL_RGBA32F;
                break;
            default:
                ASSERT_TRUE(false);
        }

        glRenderbufferStorage(GL_RENDERBUFFER, renderType, 1, 1);

        GLFramebuffer fbo;
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);

        glTexParameteri(testTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(testTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(testTarget, GL_TEXTURE_BASE_LEVEL, 0);
        glTexParameteri(testTarget, GL_TEXTURE_MAX_LEVEL, 0);

        drawQuad(mProgram, "position", 0.5f);
        EXPECT_GL_NO_ERROR();

        if (renderType == GL_RGBA8)
        {
            uint32_t tolerance = 1;
            // The destination formats may be emulated, so the precision may be higher than
            // required.  Increase the tolerance to 2^(8-width).  8 is for the 8-bit format used for
            // emulation.  Even though Vulkan recommends round to nearest, it's not a requirement
            // so the full-range of precision is used as tolerance.
            switch (destType)
            {
                case GL_UNSIGNED_SHORT_5_6_5:
                    tolerance = 8;
                    break;
                case GL_UNSIGNED_SHORT_5_5_5_1:
                    tolerance = 8;
                    break;
                case GL_UNSIGNED_SHORT_4_4_4_4:
                    tolerance = 16;
                    break;
                default:
                    break;
            }
            switch (destInternalFormat)
            {
                case GL_RGB565:
                    tolerance = 8;
                    break;
                case GL_RGB5_A1:
                    tolerance = 8;
                    break;
                case GL_RGBA4:
                    tolerance = 16;
                    break;
                default:
                    break;
            }

            // If destination is SNORM, values in between representable values could round either
            // way.
            switch (destInternalFormat)
            {
                case GL_R8_SNORM:
                case GL_RG8_SNORM:
                case GL_RGB8_SNORM:
                case GL_RGBA8_SNORM:
                    tolerance *= 2;
                    break;
                default:
                    break;
            }

            GLColor actual;
            glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &actual.R);
            EXPECT_GL_NO_ERROR();
            EXPECT_COLOR_NEAR(expectedColor, actual, tolerance);
            return;
        }
        else if (renderType == GL_RGBA32F)
        {
            float expectedColorFloat[4] = {static_cast<float>(expectedColor.R) / 255,
                                           static_cast<float>(expectedColor.G) / 255,
                                           static_cast<float>(expectedColor.B) / 255,
                                           static_cast<float>(expectedColor.A) / 255};
            EXPECT_PIXEL_COLOR32F_NEAR(0, 0,
                                       GLColor32F(expectedColorFloat[0], expectedColorFloat[1],
                                                  expectedColorFloat[2], expectedColorFloat[3]),
                                       0.015);
            return;
        }
        else if (renderType == GL_RGBA8UI)
        {
            GLuint pixel[4] = {0};
            glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_UNSIGNED_INT, pixel);
            EXPECT_COLOR_NEAR(
                expectedColor,
                GLColor(static_cast<GLubyte>(pixel[0]), static_cast<GLubyte>(pixel[1]),
                        static_cast<GLubyte>(pixel[2]), static_cast<GLubyte>(pixel[3])),
                0.2);
        }
        else if (renderType == GL_RGBA8I)
        {
            GLint pixel[4] = {0};
            glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, pixel);
            EXPECT_COLOR_NEAR(
                expectedColor,
                GLColor(static_cast<GLubyte>(pixel[0]), static_cast<GLubyte>(pixel[1]),
                        static_cast<GLubyte>(pixel[2]), static_cast<GLubyte>(pixel[3])),
                0.2);
        }
        else
        {
            ASSERT_TRUE(false);
        }
    }

    void testUnsizedFormats(const GLenum testTarget);
    void testSnormFormats(const GLenum testTarget);
    void testUnsignedByteFormats(const GLenum testTarget);
    void testFloatFormats(const GLenum testTarget);
    void testIntFormats(const GLenum testTarget);
    void testUintFormats(const GLenum testTarget);

    virtual const char *getFragmentShaderSource() = 0;

    GLuint mProgram = 0;
    GLTexture sourceTexture;
    GLTexture destTexture;
};

class Texture3DCopy : public CopyTexture3DTest
{
  protected:
    Texture3DCopy() {}

    const char *getFragmentShaderSource() override
    {
        return "#version 300 es\n"
               "precision highp float;\n"
               "uniform highp sampler3D tex3D;\n"
               "in vec3 texcoord;\n"
               "out vec4 fragColor;\n"
               "void main()\n"
               "{\n"
               "    fragColor = texture(tex3D, vec3(texcoord.x, texcoord.z, texcoord.y));\n"
               "}\n";
    }
};

class Texture2DArrayCopy : public CopyTexture3DTest
{
  protected:
    Texture2DArrayCopy() {}

    const char *getFragmentShaderSource() override
    {
        return "#version 300 es\n"
               "precision highp float;\n"
               "uniform highp sampler2DArray tex2DArray;\n"
               "in vec3 texcoord;\n"
               "out vec4 fragColor;\n"
               "void main()\n"
               "{\n"
               "    fragColor = texture(tex2DArray, vec3(texcoord.x, texcoord.z, texcoord.y));\n"
               "}\n";
    }
};

// Test that glCopySubTexture3DANGLE correctly copies to and from a GL_TEXTURE_3D texture.
TEST_P(Texture3DCopy, CopySubTexture)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    std::vector<GLColor> texDataGreen(2u * 2u * 2u, GLColor::green);
    std::vector<GLColor> texDataRed(2u * 2u * 2u, GLColor::red);

    glBindTexture(GL_TEXTURE_3D, sourceTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataGreen.data());
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataRed.data());
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();
    glCopySubTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_3D, destTexture, 0, 0, 0, 0, 0, 0, 0, 2, 2,
                            2, false, false, false);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 0.5f);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
}

// Test that glCopyTexture3DANGLE correctly copies from a non-zero mipmap on a GL_TEXTURE_3D
// texture.
TEST_P(Texture3DCopy, CopyFromMipmap)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    std::vector<GLColor> texDataGreen(4u * 4u * 4u, GLColor::green);

    glBindTexture(GL_TEXTURE_3D, sourceTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataGreen.data());
    glTexImage3D(GL_TEXTURE_3D, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataGreen.data());
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 1);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 1);

    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();

    glCopyTexture3DANGLE(sourceTexture, 1, GL_TEXTURE_3D, destTexture, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                         false, false, false);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 0.5f);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
}

// Test that glCopySubTexture3DANGLE's offset and dimension parameters work correctly with a
// GL_TEXTURE_3D texture.
TEST_P(Texture3DCopy, OffsetSubCopy)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    std::array<GLColor, 27> rgbaPixels;

    // Create pixel data for a 3x3x3 red cube
    for (int i = 0; i < 27; i++)
    {
        rgbaPixels[i] = GLColor(255u, 0u, 0u, 255u);
    }

    // Change a pixel to create a 1x1x1 blue cube at (0, 0, 0)
    rgbaPixels[0] = GLColor(0u, 0u, 255u, 255u);

    // Change some pixels to green to create a 2x2x2 cube starting at (1, 1, 1)
    rgbaPixels[13] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[14] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[16] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[17] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[22] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[23] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[25] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[26] = GLColor(0u, 255u, 0u, 255u);

    glBindTexture(GL_TEXTURE_3D, sourceTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 3, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 rgbaPixels.data());
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

    EXPECT_GL_NO_ERROR();
    // Copy the 2x2x2 green cube into a new texture
    glCopySubTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_3D, destTexture, 0, 0, 0, 0, 1, 1, 1, 2, 2,
                            2, false, false, false);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);
    int width  = getWindowWidth() - 1;
    int height = getWindowHeight() - 1;

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::green);

    // Copy the 1x1x1 blue cube into the the 2x2x2 green cube at location (1, 1, 1)
    glCopySubTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_3D, destTexture, 0, 1, 1, 1, 0, 0, 0, 1, 1,
                            1, false, false, false);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::blue);
}

// Test that the flipY parameter works with a GL_TEXTURE_3D texture.
TEST_P(Texture3DCopy, FlipY)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Create a 2x2x2 cube. The top half is red. The bottom half is green.
    GLColor rgbaPixels[8] = {GLColor::green, GLColor::green, GLColor::red, GLColor::red,
                             GLColor::green, GLColor::green, GLColor::red, GLColor::red};

    glBindTexture(GL_TEXTURE_3D, sourceTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaPixels);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

    // mProgram creates a quad with the colors from the top (y-direction) layer of the 3D texture.
    // 3D pixel (<x>, <y>, <z>) is drawn to 2D pixel (<x>, <z>) for <y> = 1.
    drawQuad(mProgram, "position", 1.0f);

    int width  = getWindowWidth() - 1;
    int height = getWindowHeight() - 1;

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::red);

    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, destTexture);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    EXPECT_GL_NO_ERROR();

    // Flip the y coordinate. This will put the greem half on top, and the red half on the bottom.
    glCopyTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_3D, destTexture, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                         true, false, false);

    glBindTexture(GL_TEXTURE_3D, destTexture);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::green);
}

void CopyTexture3DTest::testUnsizedFormats(const GLenum testTarget)
{
    const GLColor kColorNoAlpha(250, 200, 150, 100);
    const GLColor kColorPreAlpha(250, 200, 150, 100);
    const GLColor kColorUnAlpha(101, 150, 200, 200);

    testCopy(testTarget, kColorNoAlpha, GL_RGB, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(250, 200, 150, 255));
    testCopy(testTarget, kColorPreAlpha, GL_RGB, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(98, 78, 59, 255));
    testCopy(testTarget, kColorUnAlpha, GL_RGB, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(128, 191, 255, 255));

    testCopy(testTarget, kColorNoAlpha, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, false, false, false,
             GLColor(247, 199, 148, 255));
    testCopy(testTarget, kColorPreAlpha, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, false, true, false,
             GLColor(99, 77, 57, 255));
    testCopy(testTarget, kColorUnAlpha, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, false, false, true,
             GLColor(132, 190, 255, 255));

    testCopy(testTarget, kColorNoAlpha, GL_RGBA, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(250, 200, 150, 100));
    testCopy(testTarget, kColorPreAlpha, GL_RGBA, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(98, 78, 59, 100));
    testCopy(testTarget, kColorUnAlpha, GL_RGBA, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(128, 191, 255, 200));

    testCopy(testTarget, kColorNoAlpha, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, false, false, false,
             GLColor(250, 200, 150, 100));
    testCopy(testTarget, kColorPreAlpha, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, false, true, false,
             GLColor(98, 78, 59, 100));
    testCopy(testTarget, kColorUnAlpha, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, false, false, true,
             GLColor(128, 191, 255, 200));

    testCopy(testTarget, kColorNoAlpha, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, false, false, false,
             GLColor(247, 198, 148, 0));
    testCopy(testTarget, kColorPreAlpha, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, false, true, false,
             GLColor(99, 82, 57, 0));
    testCopy(testTarget, kColorUnAlpha, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, false, false, true,
             GLColor(132, 189, 255, 255));

    testCopy(testTarget, kColorNoAlpha, GL_LUMINANCE, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(250, 250, 250, 255));
    testCopy(testTarget, kColorPreAlpha, GL_LUMINANCE, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(98, 98, 98, 255));
    testCopy(testTarget, kColorUnAlpha, GL_LUMINANCE, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(128, 128, 128, 255));

    testCopy(testTarget, kColorNoAlpha, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(250, 250, 250, 100));
    testCopy(testTarget, kColorPreAlpha, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(98, 98, 98, 100));
    testCopy(testTarget, kColorUnAlpha, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(128, 128, 128, 200));

    testCopy(testTarget, kColorNoAlpha, GL_ALPHA, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(0, 0, 0, 100));
    testCopy(testTarget, kColorNoAlpha, GL_ALPHA, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(0, 0, 0, 100));
    testCopy(testTarget, kColorNoAlpha, GL_ALPHA, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(0, 0, 0, 100));
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_3D with unsized
// formats.
TEST_P(Texture3DCopy, UnsizedFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testUnsizedFormats(GL_TEXTURE_3D);
}

void CopyTexture3DTest::testSnormFormats(const GLenum testTarget)
{
    const GLColor kColorNoAlpha(250, 200, 150, 190);
    const GLColor kColorPreAlpha(250, 200, 150, 190);
    const GLColor kColorUnAlpha(200, 150, 100, 230);

    testCopy(testTarget, kColorNoAlpha, GL_R8_SNORM, GL_BYTE, false, false, false,
             GLColor(251, 0, 0, 255));
    testCopy(testTarget, kColorPreAlpha, GL_R8_SNORM, GL_BYTE, false, true, false,
             GLColor(187, 0, 0, 255));
    testCopy(testTarget, kColorUnAlpha, GL_R8_SNORM, GL_BYTE, false, false, true,
             GLColor(221, 0, 0, 255));

    testCopy(testTarget, kColorNoAlpha, GL_RG8_SNORM, GL_BYTE, false, false, false,
             GLColor(251, 201, 0, 255));
    testCopy(testTarget, kColorPreAlpha, GL_RG8_SNORM, GL_BYTE, false, true, false,
             GLColor(187, 149, 0, 255));
    testCopy(testTarget, kColorUnAlpha, GL_RG8_SNORM, GL_BYTE, false, false, true,
             GLColor(221, 167, 0, 255));

    testCopy(testTarget, kColorNoAlpha, GL_RGB8_SNORM, GL_BYTE, false, false, false,
             GLColor(251, 201, 151, 255));
    testCopy(testTarget, kColorPreAlpha, GL_RGB8_SNORM, GL_BYTE, false, true, false,
             GLColor(187, 149, 112, 255));
    testCopy(testTarget, kColorUnAlpha, GL_RGB8_SNORM, GL_BYTE, false, false, true,
             GLColor(221, 167, 110, 255));

    testCopy(testTarget, kColorNoAlpha, GL_RGBA8_SNORM, GL_BYTE, false, false, false,
             GLColor(251, 201, 151, 191));
    testCopy(testTarget, kColorPreAlpha, GL_RGBA8_SNORM, GL_BYTE, false, true, false,
             GLColor(187, 149, 112, 191));
    testCopy(testTarget, kColorUnAlpha, GL_RGBA8_SNORM, GL_BYTE, false, false, true,
             GLColor(221, 167, 110, 231));

    testCopy(testTarget, GLColor(250, 200, 150, 100), GL_RGB10_A2, GL_UNSIGNED_INT_2_10_10_10_REV,
             false, false, false, GLColor(250, 200, 150, 85));
    testCopy(testTarget, GLColor(250, 200, 150, 200), GL_RGB10_A2, GL_UNSIGNED_INT_2_10_10_10_REV,
             false, true, false, GLColor(196, 157, 118, 170));
    testCopy(testTarget, GLColor(101, 150, 190, 200), GL_RGB10_A2, GL_UNSIGNED_INT_2_10_10_10_REV,
             false, false, true, GLColor(128, 191, 242, 170));
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_3D with snorm
// formats.
TEST_P(Texture3DCopy, SnormFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testSnormFormats(GL_TEXTURE_3D);
}

void CopyTexture3DTest::testUnsignedByteFormats(const GLenum testTarget)
{
    {
        const GLColor kColorNoAlpha(250, 200, 150, 100);
        const GLColor kColorPreAlpha(250, 200, 150, 100);
        const GLColor kColorUnAlpha(200, 150, 100, 230);

        testCopy(testTarget, kColorNoAlpha, GL_R8, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(250, 0, 0, 255));
        testCopy(testTarget, kColorPreAlpha, GL_R8, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(98, 0, 0, 255));
        testCopy(testTarget, kColorUnAlpha, GL_R8, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(221, 0, 0, 255));

        testCopy(testTarget, kColorNoAlpha, GL_RG8, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(250, 200, 0, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RG8, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(98, 78, 0, 255));
        testCopy(testTarget, kColorUnAlpha, GL_RG8, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(221, 167, 0, 255));

        testCopy(testTarget, kColorNoAlpha, GL_RGB8, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(250, 200, 150, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RGB8, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(98, 78, 59, 255));
        testCopy(testTarget, kColorUnAlpha, GL_RGB8, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(221, 167, 110, 255));

        testCopy(testTarget, kColorNoAlpha, GL_RGBA8, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(250, 200, 150, 100));
        testCopy(testTarget, kColorPreAlpha, GL_RGBA8, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(98, 78, 59, 100));
        testCopy(testTarget, kColorUnAlpha, GL_RGBA8, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(221, 167, 110, 230));

        testCopy(testTarget, kColorNoAlpha, GL_RGBA4, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(250, 200, 150, 100));
        testCopy(testTarget, kColorPreAlpha, GL_RGBA4, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(98, 78, 59, 100));
        testCopy(testTarget, kColorUnAlpha, GL_RGBA4, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(221, 167, 110, 230));

        testCopy(testTarget, kColorNoAlpha, GL_RGBA4, GL_UNSIGNED_SHORT_4_4_4_4, false, false,
                 false, GLColor(250, 200, 150, 100));
        testCopy(testTarget, kColorPreAlpha, GL_RGBA4, GL_UNSIGNED_SHORT_4_4_4_4, false, true,
                 false, GLColor(98, 78, 59, 100));
        testCopy(testTarget, kColorUnAlpha, GL_RGBA4, GL_UNSIGNED_SHORT_4_4_4_4, false, false, true,
                 GLColor(221, 167, 110, 230));

        testCopy(testTarget, kColorNoAlpha, GL_SRGB8, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(244, 148, 78, 255));
        testCopy(testTarget, kColorPreAlpha, GL_SRGB8, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(31, 19, 11, 255));
        testCopy(testTarget, GLColor(100, 150, 200, 210), GL_SRGB8, GL_UNSIGNED_BYTE, false, false,
                 true, GLColor(49, 120, 228, 255));

        testCopy(testTarget, kColorNoAlpha, GL_SRGB8_ALPHA8, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(244, 148, 78, 100));
        testCopy(testTarget, kColorPreAlpha, GL_SRGB8_ALPHA8, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(31, 19, 11, 100));
        testCopy(testTarget, GLColor(100, 150, 200, 210), GL_SRGB8_ALPHA8, GL_UNSIGNED_BYTE, false,
                 false, true, GLColor(49, 120, 228, 210));

        testCopy(testTarget, GLColor(250, 200, 150, 200), GL_RGB5_A1, GL_UNSIGNED_BYTE, false,
                 false, false, GLColor(247, 198, 148, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RGB5_A1, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(99, 82, 57, 0));
        testCopy(testTarget, kColorUnAlpha, GL_RGB5_A1, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(221, 167, 110, 255));

        if (IsGLExtensionEnabled("GL_ANGLE_rgbx_internal_format"))
        {
            testCopy(testTarget, kColorNoAlpha, GL_RGBX8_ANGLE, GL_UNSIGNED_BYTE, false, false,
                     false, GLColor(250, 200, 150, 255));
            testCopy(testTarget, kColorPreAlpha, GL_RGBX8_ANGLE, GL_UNSIGNED_BYTE, false, true,
                     false, GLColor(98, 78, 59, 255));
            testCopy(testTarget, kColorUnAlpha, GL_RGBX8_ANGLE, GL_UNSIGNED_BYTE, false, false,
                     true, GLColor(221, 167, 110, 255));
        }
    }

    {
        const GLColor kColorNoAlpha(250, 200, 150, 200);
        const GLColor kColorPreAlpha(250, 200, 150, 200);
        const GLColor kColorUnAlpha(101, 150, 190, 200);

        testCopy(testTarget, kColorNoAlpha, GL_RGB5_A1, GL_UNSIGNED_INT_2_10_10_10_REV, false,
                 false, false, GLColor(247, 198, 148, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RGB5_A1, GL_UNSIGNED_INT_2_10_10_10_REV, false,
                 true, false, GLColor(198, 156, 115, 255));
        testCopy(testTarget, kColorUnAlpha, GL_RGB5_A1, GL_UNSIGNED_INT_2_10_10_10_REV, false,
                 false, true, GLColor(132, 189, 242, 255));

        testCopy(testTarget, kColorNoAlpha, GL_RGB5_A1, GL_UNSIGNED_SHORT_5_5_5_1, false, false,
                 false, GLColor(247, 198, 148, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RGB5_A1, GL_UNSIGNED_SHORT_5_5_5_1, false, true,
                 false, GLColor(198, 156, 115, 255));
        testCopy(testTarget, kColorUnAlpha, GL_RGB5_A1, GL_UNSIGNED_SHORT_5_5_5_1, false, false,
                 true, GLColor(132, 189, 242, 255));

        testCopy(testTarget, kColorNoAlpha, GL_RGB565, GL_UNSIGNED_BYTE, false, false, false,
                 GLColor(247, 199, 148, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RGB565, GL_UNSIGNED_BYTE, false, true, false,
                 GLColor(198, 158, 115, 255));
        testCopy(testTarget, kColorUnAlpha, GL_RGB565, GL_UNSIGNED_BYTE, false, false, true,
                 GLColor(132, 190, 242, 255));

        testCopy(testTarget, kColorNoAlpha, GL_RGB565, GL_UNSIGNED_SHORT_5_6_5, false, false, false,
                 GLColor(247, 199, 148, 255));
        testCopy(testTarget, kColorPreAlpha, GL_RGB565, GL_UNSIGNED_SHORT_5_6_5, false, true, false,
                 GLColor(198, 158, 115, 255));
        testCopy(testTarget, kColorUnAlpha, GL_RGB565, GL_UNSIGNED_SHORT_5_6_5, false, false, true,
                 GLColor(132, 190, 242, 255));
    }
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_3D with unsigned
// byte formats.
TEST_P(Texture3DCopy, UnsignedByteFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testUnsignedByteFormats(GL_TEXTURE_3D);
}

void CopyTexture3DTest::testFloatFormats(const GLenum testTarget)
{
    std::vector<GLenum> floatTypes = {GL_FLOAT, GL_HALF_FLOAT, GL_UNSIGNED_INT_10F_11F_11F_REV,
                                      GL_UNSIGNED_INT_5_9_9_9_REV};

    const GLColor kColor(210, 200, 150, 235);

    for (GLenum floatType : floatTypes)
    {
        if (floatType != GL_UNSIGNED_INT_5_9_9_9_REV &&
            floatType != GL_UNSIGNED_INT_10F_11F_11F_REV)
        {
            testCopy(testTarget, kColor, GL_R16F, floatType, false, false, false,
                     GLColor(210, 0, 0, 255));
            testCopy(testTarget, kColor, GL_R16F, floatType, false, true, false,
                     GLColor(191, 0, 0, 255));
            testCopy(testTarget, kColor, GL_R16F, floatType, false, false, true,
                     GLColor(227, 0, 0, 255));

            testCopy(testTarget, kColor, GL_RG16F, floatType, false, false, false,
                     GLColor(210, 200, 0, 255));
            testCopy(testTarget, kColor, GL_RG16F, floatType, false, true, false,
                     GLColor(191, 184, 0, 255));
            testCopy(testTarget, kColor, GL_RG16F, floatType, false, false, true,
                     GLColor(227, 217, 0, 255));

            testCopy(testTarget, kColor, GL_RGB16F, floatType, false, false, false,
                     GLColor(210, 200, 150, 255));
            testCopy(testTarget, kColor, GL_RGB16F, floatType, false, true, false,
                     GLColor(191, 184, 138, 255));
            testCopy(testTarget, kColor, GL_RGB16F, floatType, false, false, true,
                     GLColor(227, 217, 161, 255));

            testCopy(testTarget, kColor, GL_RGBA16F, floatType, false, false, false,
                     GLColor(210, 200, 150, 235));
            testCopy(testTarget, kColor, GL_RGBA16F, floatType, false, true, false,
                     GLColor(191, 184, 138, 235));
            testCopy(testTarget, kColor, GL_RGBA16F, floatType, false, false, true,
                     GLColor(227, 217, 161, 235));
        }

        if (floatType != GL_UNSIGNED_INT_5_9_9_9_REV)
        {
            testCopy(testTarget, kColor, GL_R11F_G11F_B10F, floatType, false, false, false,
                     GLColor(210, 200, 148, 255));
            testCopy(testTarget, kColor, GL_R11F_G11F_B10F, floatType, false, true, false,
                     GLColor(191, 184, 138, 255));
            testCopy(testTarget, kColor, GL_R11F_G11F_B10F, floatType, false, false, true,
                     GLColor(227, 217, 161, 255));
        }

        if (floatType != GL_UNSIGNED_INT_10F_11F_11F_REV)
        {
            testCopy(testTarget, kColor, GL_RGB9_E5, floatType, false, false, false,
                     GLColor(210, 200, 148, 255));
            testCopy(testTarget, kColor, GL_RGB9_E5, floatType, false, true, false,
                     GLColor(192, 184, 138, 255));
            testCopy(testTarget, kColor, GL_RGB9_E5, floatType, false, false, true,
                     GLColor(227, 217, 161, 255));
        }
    }

    testCopy(testTarget, kColor, GL_R32F, GL_FLOAT, false, false, false, GLColor(210, 0, 0, 255));
    testCopy(testTarget, kColor, GL_R32F, GL_FLOAT, false, true, false, GLColor(191, 0, 0, 255));
    testCopy(testTarget, kColor, GL_R32F, GL_FLOAT, false, false, true, GLColor(227, 0, 0, 255));

    testCopy(testTarget, kColor, GL_RG32F, GL_FLOAT, false, false, false,
             GLColor(210, 200, 0, 255));
    testCopy(testTarget, kColor, GL_RG32F, GL_FLOAT, false, true, false, GLColor(191, 184, 0, 255));
    testCopy(testTarget, kColor, GL_RG32F, GL_FLOAT, false, false, true, GLColor(227, 217, 0, 255));

    testCopy(testTarget, kColor, GL_RGB32F, GL_FLOAT, false, false, false,
             GLColor(210, 200, 150, 255));
    testCopy(testTarget, kColor, GL_RGB32F, GL_FLOAT, false, true, false,
             GLColor(191, 184, 138, 255));
    testCopy(testTarget, kColor, GL_RGB32F, GL_FLOAT, false, false, true,
             GLColor(227, 217, 161, 255));

    testCopy(testTarget, kColor, GL_RGBA32F, GL_FLOAT, false, false, false,
             GLColor(210, 200, 150, 235));
    testCopy(testTarget, kColor, GL_RGBA32F, GL_FLOAT, false, true, false,
             GLColor(191, 184, 138, 235));
    testCopy(testTarget, kColor, GL_RGBA32F, GL_FLOAT, false, false, true,
             GLColor(227, 217, 161, 235));
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_3D with float
// formats.
TEST_P(Texture3DCopy, FloatFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testFloatFormats(GL_TEXTURE_3D);
}

void CopyTexture3DTest::testIntFormats(const GLenum testTarget)
{
    const GLColor kColor(255, 140, 150, 230);

    // Pixels will be read as if the most significant bit is data, not the sign. The expected colors
    // reflect this.
    testCopy(testTarget, kColor, GL_R8I, GL_BYTE, false, false, false, GLColor(127, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R8I, GL_BYTE, false, true, false, GLColor(115, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R8I, GL_BYTE, false, false, true, GLColor(127, 0, 0, 1));

    testCopy(testTarget, kColor, GL_R16I, GL_SHORT, false, false, false, GLColor(127, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R16I, GL_SHORT, false, true, false, GLColor(115, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R16I, GL_SHORT, false, false, true, GLColor(127, 0, 0, 1));

    testCopy(testTarget, kColor, GL_R32I, GL_INT, false, false, false, GLColor(127, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R32I, GL_INT, false, true, false, GLColor(115, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R32I, GL_INT, false, false, true, GLColor(127, 0, 0, 1));

    testCopy(testTarget, kColor, GL_RG8I, GL_BYTE, false, false, false, GLColor(127, 70, 0, 1));
    testCopy(testTarget, kColor, GL_RG8I, GL_BYTE, false, true, false, GLColor(115, 63, 0, 1));
    testCopy(testTarget, kColor, GL_RG8I, GL_BYTE, false, false, true, GLColor(127, 77, 0, 1));

    testCopy(testTarget, kColor, GL_RG16I, GL_SHORT, false, false, false, GLColor(127, 70, 0, 1));
    testCopy(testTarget, kColor, GL_RG16I, GL_SHORT, false, true, false, GLColor(115, 63, 0, 1));
    testCopy(testTarget, kColor, GL_RG16I, GL_SHORT, false, false, true, GLColor(127, 77, 0, 1));

    testCopy(testTarget, kColor, GL_RG32I, GL_INT, false, false, false, GLColor(127, 70, 0, 1));
    testCopy(testTarget, kColor, GL_RG32I, GL_INT, false, true, false, GLColor(115, 63, 0, 1));
    testCopy(testTarget, kColor, GL_RG32I, GL_INT, false, false, true, GLColor(127, 77, 0, 1));

    testCopy(testTarget, kColor, GL_RGB8I, GL_BYTE, false, false, false, GLColor(127, 70, 75, 1));
    testCopy(testTarget, kColor, GL_RGB8I, GL_BYTE, false, true, false, GLColor(115, 63, 67, 1));
    testCopy(testTarget, kColor, GL_RGB8I, GL_BYTE, false, false, true, GLColor(127, 77, 83, 1));

    testCopy(testTarget, kColor, GL_RGB16I, GL_SHORT, false, false, false, GLColor(127, 70, 75, 1));
    testCopy(testTarget, kColor, GL_RGB16I, GL_SHORT, false, true, false, GLColor(115, 63, 67, 1));
    testCopy(testTarget, kColor, GL_RGB16I, GL_SHORT, false, false, true, GLColor(127, 77, 83, 1));

    testCopy(testTarget, kColor, GL_RGB32I, GL_INT, false, false, false, GLColor(127, 70, 75, 1));
    testCopy(testTarget, kColor, GL_RGB32I, GL_INT, false, true, false, GLColor(115, 63, 67, 1));
    testCopy(testTarget, kColor, GL_RGB32I, GL_INT, false, false, true, GLColor(127, 77, 83, 1));

    testCopy(testTarget, kColor, GL_RGBA8I, GL_BYTE, false, false, false,
             GLColor(127, 70, 75, 115));
    testCopy(testTarget, kColor, GL_RGBA8I, GL_BYTE, false, true, false, GLColor(115, 63, 67, 115));
    testCopy(testTarget, kColor, GL_RGBA8I, GL_BYTE, false, false, true, GLColor(127, 77, 83, 115));

    testCopy(testTarget, kColor, GL_RGBA16I, GL_SHORT, false, false, false,
             GLColor(127, 70, 75, 115));
    testCopy(testTarget, kColor, GL_RGBA16I, GL_SHORT, false, true, false,
             GLColor(115, 63, 67, 115));
    testCopy(testTarget, kColor, GL_RGBA16I, GL_SHORT, false, false, true,
             GLColor(127, 77, 83, 115));

    testCopy(testTarget, kColor, GL_RGBA32I, GL_INT, false, false, false,
             GLColor(127, 70, 75, 115));
    testCopy(testTarget, kColor, GL_RGBA32I, GL_INT, false, true, false, GLColor(115, 63, 67, 115));
    testCopy(testTarget, kColor, GL_RGBA32I, GL_INT, false, false, true, GLColor(127, 77, 83, 115));
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_3D with integer
// formats.
TEST_P(Texture3DCopy, IntFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Vulkan multiplies source by 255 unconditionally, which is wrong for signed integer formats.
    // http://anglebug.com/42263339
    ANGLE_SKIP_TEST_IF(IsVulkan());

    constexpr char kFS[] =
        "#version 300 es\n"
        "precision highp float;\n"
        "uniform highp isampler3D tex3D;\n"
        "in vec3 texcoord;\n"
        "out ivec4 fragColor;\n"
        "void main()\n"
        "{\n"
        "    fragColor = texture(tex3D, vec3(texcoord.x, texcoord.z, texcoord.y));\n"
        "}\n";

    mProgram = CompileProgram(getVertexShaderSource(), kFS);
    ASSERT_NE(0u, mProgram);
    ASSERT_GL_NO_ERROR();

    glUseProgram(mProgram);

    testIntFormats(GL_TEXTURE_3D);
}

void CopyTexture3DTest::testUintFormats(const GLenum testTarget)
{
    const GLColor kColor(128, 84, 32, 100);

    testCopy(testTarget, kColor, GL_R8UI, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(128, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R8UI, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(50, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R8UI, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(255, 0, 0, 1));

    testCopy(testTarget, kColor, GL_R16UI, GL_UNSIGNED_SHORT, false, false, false,
             GLColor(128, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R16UI, GL_UNSIGNED_SHORT, false, true, false,
             GLColor(50, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R16UI, GL_UNSIGNED_SHORT, false, false, true,
             GLColor(255, 0, 0, 1));

    testCopy(testTarget, kColor, GL_R32UI, GL_UNSIGNED_INT, false, false, false,
             GLColor(128, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R32UI, GL_UNSIGNED_INT, false, true, false,
             GLColor(50, 0, 0, 1));
    testCopy(testTarget, kColor, GL_R32UI, GL_UNSIGNED_INT, false, false, true,
             GLColor(255, 0, 0, 1));

    testCopy(testTarget, kColor, GL_RG8UI, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(128, 84, 0, 1));
    testCopy(testTarget, kColor, GL_RG8UI, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(50, 32, 0, 1));
    testCopy(testTarget, kColor, GL_RG8UI, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(255, 214, 0, 1));

    testCopy(testTarget, kColor, GL_RG16UI, GL_UNSIGNED_SHORT, false, false, false,
             GLColor(128, 84, 0, 1));
    testCopy(testTarget, kColor, GL_RG16UI, GL_UNSIGNED_SHORT, false, true, false,
             GLColor(50, 32, 0, 1));
    testCopy(testTarget, kColor, GL_RG16UI, GL_UNSIGNED_SHORT, false, false, true,
             GLColor(255, 214, 0, 1));

    testCopy(testTarget, kColor, GL_RG32UI, GL_UNSIGNED_INT, false, false, false,
             GLColor(128, 84, 0, 1));
    testCopy(testTarget, kColor, GL_RG32UI, GL_UNSIGNED_INT, false, true, false,
             GLColor(50, 32, 0, 1));
    testCopy(testTarget, kColor, GL_RG32UI, GL_UNSIGNED_INT, false, false, true,
             GLColor(255, 214, 0, 1));

    testCopy(testTarget, kColor, GL_RGB8UI, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(128, 84, 32, 1));
    testCopy(testTarget, kColor, GL_RGB8UI, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(50, 32, 12, 1));
    testCopy(testTarget, kColor, GL_RGB8UI, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(255, 214, 81, 1));

    testCopy(testTarget, kColor, GL_RGB16UI, GL_UNSIGNED_SHORT, false, false, false,
             GLColor(128, 84, 32, 1));
    testCopy(testTarget, kColor, GL_RGB16UI, GL_UNSIGNED_SHORT, false, true, false,
             GLColor(50, 32, 12, 1));
    testCopy(testTarget, kColor, GL_RGB16UI, GL_UNSIGNED_SHORT, false, false, true,
             GLColor(255, 214, 81, 1));

    testCopy(testTarget, kColor, GL_RGB32UI, GL_UNSIGNED_INT, false, false, false,
             GLColor(128, 84, 32, 1));
    testCopy(testTarget, kColor, GL_RGB32UI, GL_UNSIGNED_INT, false, true, false,
             GLColor(50, 32, 12, 1));
    testCopy(testTarget, kColor, GL_RGB32UI, GL_UNSIGNED_INT, false, false, true,
             GLColor(255, 214, 81, 1));

    testCopy(testTarget, kColor, GL_RGBA8UI, GL_UNSIGNED_BYTE, false, false, false,
             GLColor(128, 84, 32, 100));
    testCopy(testTarget, kColor, GL_RGBA8UI, GL_UNSIGNED_BYTE, false, true, false,
             GLColor(50, 32, 12, 100));
    testCopy(testTarget, kColor, GL_RGBA8UI, GL_UNSIGNED_BYTE, false, false, true,
             GLColor(255, 214, 81, 100));

    testCopy(testTarget, kColor, GL_RGBA16UI, GL_UNSIGNED_SHORT, false, false, false,
             GLColor(128, 84, 32, 100));
    testCopy(testTarget, kColor, GL_RGBA16UI, GL_UNSIGNED_SHORT, false, true, false,
             GLColor(50, 32, 12, 100));
    testCopy(testTarget, kColor, GL_RGBA16UI, GL_UNSIGNED_SHORT, false, false, true,
             GLColor(255, 214, 81, 100));

    testCopy(testTarget, kColor, GL_RGBA32UI, GL_UNSIGNED_INT, false, false, false,
             GLColor(128, 84, 32, 100));
    testCopy(testTarget, kColor, GL_RGBA32UI, GL_UNSIGNED_INT, false, true, false,
             GLColor(50, 32, 12, 100));
    testCopy(testTarget, kColor, GL_RGBA32UI, GL_UNSIGNED_INT, false, false, true,
             GLColor(255, 214, 81, 100));

    testCopy(testTarget, kColor, GL_RGB10_A2UI, GL_UNSIGNED_INT_2_10_10_10_REV, false, false, false,
             GLColor(128, 84, 32, 3));
    testCopy(testTarget, kColor, GL_RGB10_A2UI, GL_UNSIGNED_INT_2_10_10_10_REV, false, true, false,
             GLColor(50, 32, 12, 3));
    testCopy(testTarget, kColor, GL_RGB10_A2UI, GL_UNSIGNED_INT_2_10_10_10_REV, false, false, true,
             GLColor(255, 214, 81, 3));
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_3D with unsigned
// integer formats.
TEST_P(Texture3DCopy, UintFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Vulkan multiplies source by 255 unconditionally, which is wrong for non-8-bit integer
    // formats.  http://anglebug.com/42263339
    ANGLE_SKIP_TEST_IF(IsVulkan());

    constexpr char kFS[] =
        "#version 300 es\n"
        "precision highp float;\n"
        "uniform highp usampler3D tex3D;\n"
        "in vec3 texcoord;\n"
        "out uvec4 fragColor;\n"
        "void main()\n"
        "{\n"
        "    fragColor = texture(tex3D, vec3(texcoord.x, texcoord.z, texcoord.y));\n"
        "}\n";

    mProgram = CompileProgram(getVertexShaderSource(), kFS);
    ASSERT_NE(0u, mProgram);
    ASSERT_GL_NO_ERROR();

    glUseProgram(mProgram);

    testUintFormats(GL_TEXTURE_3D);
}

// Test that glCopySubTexture3DANGLE correctly copies to and from a GL_TEXTURE_2D_ARRAY texture.
TEST_P(Texture2DArrayCopy, CopySubTexture)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    std::vector<GLColor> texDataGreen(2u * 2u * 2u, GLColor::green);
    std::vector<GLColor> texDataRed(2u * 2u * 2u, GLColor::red);

    glBindTexture(GL_TEXTURE_2D_ARRAY, sourceTexture);
    EXPECT_GL_NO_ERROR();
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataGreen.data());
    EXPECT_GL_NO_ERROR();
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D_ARRAY, destTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataRed.data());
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();
    glCopySubTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_2D_ARRAY, destTexture, 0, 0, 0, 0, 0, 0, 0,
                            2, 2, 2, false, false, false);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 0.5f);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
}

// Test that glCopyTexture3DANGLE correctly copies from a non-zero mipmap on a GL_TEXTURE_2D_ARRAY
// texture.
TEST_P(Texture2DArrayCopy, CopyFromMipmap)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    std::vector<GLColor> texDataGreen4(4u * 4u * 4u, GLColor::green);
    std::vector<GLColor> texDataGreen2(2u * 2u * 2u, GLColor::green);
    std::vector<GLColor> texDataRed2(2u * 2u * 2u, GLColor::red);

    glBindTexture(GL_TEXTURE_2D_ARRAY, sourceTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataGreen4.data());
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 texDataGreen2.data());
    EXPECT_GL_NO_ERROR();
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 1);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 1);
    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D_ARRAY, destTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);

    EXPECT_GL_NO_ERROR();
    glCopyTexture3DANGLE(sourceTexture, 1, GL_TEXTURE_2D_ARRAY, destTexture, 0, GL_RGBA,
                         GL_UNSIGNED_BYTE, false, false, false);

    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
}

// Test that glCopySubTexture3DANGLE's offset and dimension parameters work correctly with a
// GL_TEXTURE_2D_ARRAY texture.
TEST_P(Texture2DArrayCopy, OffsetSubCopy)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    std::array<GLColor, 27> rgbaPixels;

    // Create pixel data for a 3x3x3 red cube
    for (int i = 0; i < 27; i++)
    {
        rgbaPixels[i] = GLColor(255u, 0u, 0u, 255u);
    }

    // Change a pixel to create a 1x1x1 blue cube at (0, 0, 0)
    rgbaPixels[0] = GLColor(0u, 0u, 255u, 255u);

    // Change some pixels to green to create a 2x2x2 cube starting at (1, 1, 1)
    rgbaPixels[13] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[14] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[16] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[17] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[22] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[23] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[25] = GLColor(0u, 255u, 0u, 255u);
    rgbaPixels[26] = GLColor(0u, 255u, 0u, 255u);

    glBindTexture(GL_TEXTURE_2D_ARRAY, sourceTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 3, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 rgbaPixels.data());
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D_ARRAY, destTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

    EXPECT_GL_NO_ERROR();
    // Copy the 2x2x2 green cube into a new texture
    glCopySubTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_2D_ARRAY, destTexture, 0, 0, 0, 0, 1, 1, 1,
                            2, 2, 2, false, false, false);
    glBindTexture(GL_TEXTURE_2D_ARRAY, destTexture);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);
    int width  = getWindowWidth() - 1;
    int height = getWindowHeight() - 1;

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::green);

    // Copy the 1x1x1 blue cube into the the 2x2x2 green cube at location (1, 1, 1)
    glCopySubTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_2D_ARRAY, destTexture, 0, 1, 1, 1, 0, 0, 0,
                            1, 1, 1, false, false, false);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::blue);
}

// Test that the flipY parameter works with a GL_TEXTURE_2D_ARRAY texture.
TEST_P(Texture2DArrayCopy, FlipY)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Create a 2x2x2 cube. The top half is red. The bottom half is green.
    GLColor rgbaPixels[8] = {GLColor::green, GLColor::green, GLColor::red, GLColor::red,
                             GLColor::green, GLColor::green, GLColor::red, GLColor::red};

    glBindTexture(GL_TEXTURE_2D_ARRAY, sourceTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 rgbaPixels);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

    drawQuad(mProgram, "position", 1.0f);

    int width  = getWindowWidth() - 1;
    int height = getWindowHeight() - 1;

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::red);

    EXPECT_GL_NO_ERROR();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D_ARRAY, destTexture);
    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    EXPECT_GL_NO_ERROR();

    // Flip the y coordinate. This will put the greem half on top, and the red half on the bottom.
    glCopyTexture3DANGLE(sourceTexture, 0, GL_TEXTURE_2D_ARRAY, destTexture, 0, GL_RGBA,
                         GL_UNSIGNED_BYTE, true, false, false);

    glBindTexture(GL_TEXTURE_2D_ARRAY, destTexture);
    EXPECT_GL_NO_ERROR();
    drawQuad(mProgram, "position", 1.0f);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, height, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(width, height, GLColor::green);
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_2D_ARRAY with
// unsized formats.
TEST_P(Texture2DArrayCopy, UnsizedFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testUnsizedFormats(GL_TEXTURE_2D_ARRAY);
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_2D_ARRAY with
// snorm formats.
TEST_P(Texture2DArrayCopy, SnormFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testSnormFormats(GL_TEXTURE_2D_ARRAY);
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_2D_ARRAY with
// unsigned byte formats.
TEST_P(Texture2DArrayCopy, UnsignedByteFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Flay on Windows D3D11. http://anglebug.com/40644660
    ANGLE_SKIP_TEST_IF(IsWindows() && IsD3D11());

    testUnsignedByteFormats(GL_TEXTURE_2D_ARRAY);
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_2D_ARRAY with
// float formats.
TEST_P(Texture2DArrayCopy, FloatFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    testFloatFormats(GL_TEXTURE_2D_ARRAY);
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_2D_ARRAY with
// integer formats.
TEST_P(Texture2DArrayCopy, IntFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Vulkan multiplies source by 255 unconditionally, which is wrong for signed integer formats.
    // http://anglebug.com/42263339
    ANGLE_SKIP_TEST_IF(IsVulkan());

    constexpr char kFS[] =
        "#version 300 es\n"
        "precision highp float;\n"
        "uniform highp isampler2DArray tex2DArray;\n"
        "in vec3 texcoord;\n"
        "out ivec4 fragColor;\n"
        "void main()\n"
        "{\n"
        "    fragColor = texture(tex2DArray, vec3(texcoord.x, texcoord.z, texcoord.y));\n"
        "}\n";

    mProgram = CompileProgram(getVertexShaderSource(), kFS);
    ASSERT_NE(0u, mProgram);
    ASSERT_GL_NO_ERROR();

    glUseProgram(mProgram);

    testIntFormats(GL_TEXTURE_2D_ARRAY);
}

// Test passthrough, premultiply alpha, and unmultiply alpha copies for GL_TEXTURE_2D_ARRAY with
// unsigned integer formats.
TEST_P(Texture2DArrayCopy, UintFormats)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    // Vulkan multiplies source by 255 unconditionally, which is wrong for non-8-bit integer
    // formats.  http://anglebug.com/42263339
    ANGLE_SKIP_TEST_IF(IsVulkan());

    constexpr char kFS[] =
        "#version 300 es\n"
        "precision highp float;\n"
        "uniform highp usampler2DArray tex2DArray;\n"
        "in vec3 texcoord;\n"
        "out uvec4 fragColor;\n"
        "void main()\n"
        "{\n"
        "    fragColor = texture(tex2DArray, vec3(texcoord.x, texcoord.z, texcoord.y));\n"
        "}\n";

    mProgram = CompileProgram(getVertexShaderSource(), kFS);
    ASSERT_NE(0u, mProgram);
    ASSERT_GL_NO_ERROR();

    glUseProgram(mProgram);

    testUintFormats(GL_TEXTURE_2D_ARRAY);
}

// Test copy to different slices of 3D texture with RGB9_E5 format (which sometimes has to take the
// CPU copy path).
TEST_P(Texture3DCopy, RGB9E5Tex3D)
{
    ANGLE_SKIP_TEST_IF(!checkExtensions());

    constexpr char kVS[] = R"(#version 300 es
out vec2 texcoord;
in vec4 position;
void main()
{
    gl_Position = vec4(position.xy, 0.0, 1.0);
    texcoord = (position.xy * 0.5) + 0.5;
})";

    constexpr char kFS[] = R"(#version 300 es
precision highp float;
uniform lowp sampler3D tex3D;
uniform int slice;
in vec2 texcoord;
out vec4 color;
void main()
{
    color = texture(tex3D, vec3(texcoord, slice));
})";

    ANGLE_GL_PROGRAM(program, kVS, kFS);
    glUseProgram(program);

    const std::array<GLColor, 4> kData = {GLColor::red, GLColor::green, GLColor::blue,
                                          GLColor::yellow};

    GLTexture source;
    glBindTexture(GL_TEXTURE_3D, source);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, kData.data());

    GLTexture texture;
    glBindTexture(GL_TEXTURE_3D, texture);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB9_E5, 2, 2, 5, 0, GL_RGB, GL_FLOAT, nullptr);

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    const int w = getWindowWidth();
    const int h = getWindowHeight();
    glViewport(0, 0, w, h);

    for (uint32_t slice = 0; slice < 5; slice++)
    {
        glCopySubTexture3DANGLE(source, 0, GL_TEXTURE_3D, texture, 0, 0, 0, slice, 0, 0, 0, 2, 2, 1,
                                false, false, false);

        glClear(GL_COLOR_BUFFER_BIT);
        glUniform1i(glGetUniformLocation(program, "slice"), slice);
        drawQuad(program, "position", 0.5f);
        EXPECT_PIXEL_COLOR_EQ(w / 4, h / 4, kData[0]);
        EXPECT_PIXEL_COLOR_EQ(3 * w / 4, h / 4, kData[1]);
        EXPECT_PIXEL_COLOR_EQ(w / 4, 3 * h / 4, kData[2]);
        EXPECT_PIXEL_COLOR_EQ(3 * w / 4, 3 * h / 4, kData[3]);
    }

    ASSERT_GL_NO_ERROR();
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Texture3DCopy);
ANGLE_INSTANTIATE_TEST_ES3(Texture3DCopy);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Texture2DArrayCopy);
ANGLE_INSTANTIATE_TEST_ES3(Texture2DArrayCopy);

}  // namespace angle