//
// Copyright 2017 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.
//

// TextureMultisampleTest: Tests of multisampled texture

#include "test_utils/ANGLETest.h"

#include "test_utils/gl_raii.h"
#include "util/shader_utils.h"

using namespace angle;

namespace
{
// Sample positions of d3d standard pattern. Some of the sample positions might not the same as
// opengl.
using SamplePositionsArray                                            = std::array<float, 32>;
static constexpr std::array<SamplePositionsArray, 5> kSamplePositions = {
    {{{0.5f, 0.5f}},
     {{0.75f, 0.75f, 0.25f, 0.25f}},
     {{0.375f, 0.125f, 0.875f, 0.375f, 0.125f, 0.625f, 0.625f, 0.875f}},
     {{0.5625f, 0.3125f, 0.4375f, 0.6875f, 0.8125f, 0.5625f, 0.3125f, 0.1875f, 0.1875f, 0.8125f,
       0.0625f, 0.4375f, 0.6875f, 0.9375f, 0.9375f, 0.0625f}},
     {{0.5625f, 0.5625f, 0.4375f, 0.3125f, 0.3125f, 0.625f,  0.75f,   0.4375f,
       0.1875f, 0.375f,  0.625f,  0.8125f, 0.8125f, 0.6875f, 0.6875f, 0.1875f,
       0.375f,  0.875f,  0.5f,    0.0625f, 0.25f,   0.125f,  0.125f,  0.75f,
       0.0f,    0.5f,    0.9375f, 0.25f,   0.875f,  0.9375f, 0.0625f, 0.0f}}}};

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

    void testSetUp() override
    {
        glGenFramebuffers(1, &mFramebuffer);
        glGenTextures(1, &mTexture);

        ASSERT_GL_NO_ERROR();
    }

    void testTearDown() override
    {
        glDeleteFramebuffers(1, &mFramebuffer);
        mFramebuffer = 0;
        glDeleteTextures(1, &mTexture);
        mTexture = 0;
    }

    void texStorageMultisample(GLenum target,
                               GLint samples,
                               GLenum format,
                               GLsizei width,
                               GLsizei height,
                               GLboolean fixedsamplelocations);

    void getMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
    void sampleMaski(GLuint maskNumber, GLbitfield mask);

    GLuint mFramebuffer = 0;
    GLuint mTexture     = 0;

    // Returns a sample count that can be used with the given texture target for all the given
    // formats. Assumes that if format A supports a number of samples N and another format B
    // supports a number of samples M > N then format B also supports number of samples N.
    GLint getSamplesToUse(GLenum texTarget, const std::vector<GLenum> &formats)
    {
        GLint maxSamples = 65536;
        for (GLenum format : formats)
        {
            GLint maxSamplesFormat = 0;
            glGetInternalformativ(texTarget, format, GL_SAMPLES, 1, &maxSamplesFormat);
            maxSamples = std::min(maxSamples, maxSamplesFormat);
        }
        return maxSamples;
    }

    bool lessThanES31MultisampleExtNotSupported()
    {
        return getClientMajorVersion() <= 3 && getClientMinorVersion() < 1 &&
               !EnsureGLExtensionEnabled("GL_ANGLE_texture_multisample");
    }

    const char *multisampleTextureFragmentShader()
    {
        return R"(#version 300 es
#extension GL_ANGLE_texture_multisample : require
precision highp float;
precision highp int;

uniform highp sampler2DMS tex;
uniform int sampleNum;

in vec4 v_position;
out vec4 my_FragColor;

void main() {
    ivec2 texSize = textureSize(tex);
    ivec2 sampleCoords = ivec2((v_position.xy * 0.5 + 0.5) * vec2(texSize.xy - 1));
    my_FragColor = texelFetch(tex, sampleCoords, sampleNum);
}
)";
    }

    const char *blitArrayTextureLayerFragmentShader()
    {
        return R"(#version 300 es
#extension GL_OES_texture_storage_multisample_2d_array : require
precision highp float;
precision highp int;

uniform highp sampler2DMSArray tex;
uniform int layer;
uniform int sampleNum;

in vec4 v_position;
out vec4 my_FragColor;

void main() {
    ivec3 texSize = textureSize(tex);
    ivec2 sampleCoords = ivec2((v_position.xy * 0.5 + 0.5) * vec2(texSize.xy - 1));
    my_FragColor = texelFetch(tex, ivec3(sampleCoords, layer), sampleNum);
}
)";
    }

    const char *blitIntArrayTextureLayerFragmentShader()
    {
        return R"(#version 300 es
#extension GL_OES_texture_storage_multisample_2d_array : require
precision highp float;
precision highp int;

uniform highp isampler2DMSArray tex;
uniform int layer;
uniform int sampleNum;

in vec4 v_position;
out vec4 my_FragColor;

void main() {
    ivec3 texSize = textureSize(tex);
    ivec2 sampleCoords = ivec2((v_position.xy * 0.5 + 0.5) * vec2(texSize.xy - 1));
    my_FragColor = vec4(texelFetch(tex, ivec3(sampleCoords, layer), sampleNum));
}
)";
    }
};

class NegativeTextureMultisampleTest : public TextureMultisampleTest
{
  protected:
    NegativeTextureMultisampleTest() : TextureMultisampleTest() { setExtensionsEnabled(false); }
};

class TextureMultisampleArrayTest : public TextureMultisampleTest
{
  protected:
    TextureMultisampleArrayTest() : TextureMultisampleTest() { setExtensionsEnabled(false); }

    bool areMultisampleArraysAlwaysAvailable()
    {
        return getClientMajorVersion() == 3 && getClientMinorVersion() >= 2;
    }

    // Requests the GL_OES_texture_storage_multisample_2d_array extension and returns true if the
    // operation succeeds.
    bool requestArrayExtension()
    {
        return EnsureGLExtensionEnabled("GL_OES_texture_storage_multisample_2d_array");
    }

    void texStorage3DMultisample(GLenum target,
                                 GLint samples,
                                 GLenum internalformat,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLboolean fixedsamplelocations)
    {
        if (getClientMajorVersion() == 3 && getClientMinorVersion() >= 2)
        {
            glTexStorage3DMultisample(target, samples, internalformat, width, height, depth,
                                      fixedsamplelocations);
        }
        else
        {
            glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth,
                                         fixedsamplelocations);
        }
    }
};

void TextureMultisampleTest::texStorageMultisample(GLenum target,
                                                   GLint samples,
                                                   GLenum internalformat,
                                                   GLsizei width,
                                                   GLsizei height,
                                                   GLboolean fixedsamplelocations)
{
    if (getClientMajorVersion() <= 3 && getClientMinorVersion() < 1 &&
        EnsureGLExtensionEnabled("GL_ANGLE_texture_multisample"))
    {
        glTexStorage2DMultisampleANGLE(target, samples, internalformat, width, height,
                                       fixedsamplelocations);
    }
    else
    {
        glTexStorage2DMultisample(target, samples, internalformat, width, height,
                                  fixedsamplelocations);
    }
}

void TextureMultisampleTest::getMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
{
    if (getClientMajorVersion() <= 3 && getClientMinorVersion() < 1 &&
        EnsureGLExtensionEnabled("GL_ANGLE_texture_multisample"))
    {
        glGetMultisamplefvANGLE(pname, index, val);
    }
    else
    {
        glGetMultisamplefv(pname, index, val);
    }
}

void TextureMultisampleTest::sampleMaski(GLuint maskNumber, GLbitfield mask)
{
    if (getClientMajorVersion() <= 3 && getClientMinorVersion() < 1 &&
        EnsureGLExtensionEnabled("GL_ANGLE_texture_multisample"))
    {
        glSampleMaskiANGLE(maskNumber, mask);
    }
    else
    {
        glSampleMaski(maskNumber, mask);
    }
}

// Tests that if es version < 3.1, GL_TEXTURE_2D_MULTISAMPLE is not supported in
// GetInternalformativ. Checks that the number of samples returned is valid in case of ES >= 3.1.
TEST_P(TextureMultisampleTest, MultisampleTargetGetInternalFormativBase)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    // This query returns supported sample counts in descending order. If only one sample count is
    // queried, it should be the maximum one.
    GLint maxSamplesR8 = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_R8, GL_SAMPLES, 1, &maxSamplesR8);

    // GLES 3.1 section 19.3.1 specifies the required minimum of how many samples are supported.
    GLint maxColorTextureSamples;
    glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
    GLint maxSamples;
    glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
    GLint maxSamplesR8Required = std::min(maxColorTextureSamples, maxSamples);

    EXPECT_GE(maxSamplesR8, maxSamplesR8Required);
    ASSERT_GL_NO_ERROR();
}

// Tests that if es version < 3.1 and multisample extension is unsupported,
// GL_TEXTURE_2D_MULTISAMPLE_ANGLE is not supported in FramebufferTexture2D.
TEST_P(TextureMultisampleTest, MultisampleTargetFramebufferTexture2D)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());
    GLint samples = 1;
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, GL_RGBA8, 64, 64, GL_FALSE);

    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE,
                           mTexture, 0);

    ASSERT_GL_NO_ERROR();
}

// Tests basic functionality of glTexStorage2DMultisample.
TEST_P(TextureMultisampleTest, ValidateTextureStorageMultisampleParameters)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA8, 1, 1, GL_FALSE);
    ASSERT_GL_NO_ERROR();

    GLint params = 0;
    glGetTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_IMMUTABLE_FORMAT, &params);
    EXPECT_EQ(1, params);

    texStorageMultisample(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_ENUM);

    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA8, 0, 0, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_VALUE);

    GLint maxSize = 0;
    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA8, maxSize + 1, 1, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_VALUE);

    GLint maxSamples = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_R8, GL_SAMPLES, 1, &maxSamples);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, maxSamples + 1, GL_RGBA8, 1, 1, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_OPERATION);

    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 0, GL_RGBA8, 1, 1, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_VALUE);

    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA, 0, 0, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_VALUE);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA8, 1, 1, GL_FALSE);
    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
}

// Tests the value of MAX_INTEGER_SAMPLES is no less than 1.
// [OpenGL ES 3.1 SPEC Table 20.40]
TEST_P(TextureMultisampleTest, MaxIntegerSamples)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    // Fixed in recent mesa.  http://crbug.com/1071142
    ANGLE_SKIP_TEST_IF(IsVulkan() && IsLinux() && (IsIntel() || IsAMD()));

    GLint maxIntegerSamples;
    glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &maxIntegerSamples);
    EXPECT_GE(maxIntegerSamples, 1);
    EXPECT_NE(std::numeric_limits<GLint>::max(), maxIntegerSamples);
}

// Tests the value of MAX_COLOR_TEXTURE_SAMPLES is no less than 1.
// [OpenGL ES 3.1 SPEC Table 20.40]
TEST_P(TextureMultisampleTest, MaxColorTextureSamples)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());
    GLint maxColorTextureSamples;
    glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
    EXPECT_GE(maxColorTextureSamples, 1);
    EXPECT_NE(std::numeric_limits<GLint>::max(), maxColorTextureSamples);
}

// Tests the value of MAX_DEPTH_TEXTURE_SAMPLES is no less than 1.
// [OpenGL ES 3.1 SPEC Table 20.40]
TEST_P(TextureMultisampleTest, MaxDepthTextureSamples)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());
    GLint maxDepthTextureSamples;
    glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &maxDepthTextureSamples);
    EXPECT_GE(maxDepthTextureSamples, 1);
    EXPECT_NE(std::numeric_limits<GLint>::max(), maxDepthTextureSamples);
}

// Tests the maximum value of MAX_INTEGER_SAMPLES is supported
TEST_P(TextureMultisampleTest, MaxIntegerSamplesValid)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    // Fixed in recent mesa.  http://crbug.com/1071142
    ANGLE_SKIP_TEST_IF(IsVulkan() && IsLinux() && (IsIntel() || IsAMD()));

    GLint maxIntegerSamples;
    glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &maxIntegerSamples);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);

    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, maxIntegerSamples, GL_RGBA8I, 1, 1, GL_FALSE);
    ASSERT_GL_NO_ERROR();
}

// Tests the maximum value of MAX_COLOR_TEXTURE_SAMPLES is supported
TEST_P(TextureMultisampleTest, MaxColorTextureSamplesValid)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());
    GLint maxColorTextureSamples;
    glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, maxColorTextureSamples, GL_RGBA8, 1, 1,
                          GL_FALSE);
    ASSERT_GL_NO_ERROR();
}

// Tests the maximum value of MAX_DEPTH_TEXTURE_SAMPLES is supported
TEST_P(TextureMultisampleTest, MaxDepthTextureSamplesValid)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());
    GLint maxDepthTextureSamples;
    glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &maxDepthTextureSamples);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, maxDepthTextureSamples, GL_DEPTH_COMPONENT16,
                          1, 1, GL_FALSE);
    ASSERT_GL_NO_ERROR();
}

// Tests that multisample parameters are accepted by ES 3.1 or ES 3.0 and ANGLE_texture_multisample
TEST_P(TextureMultisampleTest, GetTexLevelParameter)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_get_tex_level_parameter"));

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 1, 1, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    GLfloat levelSamples = 0;
    glGetTexLevelParameterfvANGLE(GL_TEXTURE_2D_MULTISAMPLE, 0, GL_TEXTURE_SAMPLES, &levelSamples);
    EXPECT_EQ(levelSamples, 4);

    GLint fixedSampleLocation = false;
    glGetTexLevelParameterivANGLE(GL_TEXTURE_2D_MULTISAMPLE, 0, GL_TEXTURE_FIXED_SAMPLE_LOCATIONS,
                                  &fixedSampleLocation);
    EXPECT_EQ(fixedSampleLocation, 1);

    ASSERT_GL_NO_ERROR();
}

// The value of sample position should be equal to standard pattern on non-OpenGL backends.
TEST_P(TextureMultisampleTest, CheckSamplePositions)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    // OpenGL does not guarantee sample positions.
    ANGLE_SKIP_TEST_IF(IsOpenGL());

    GLint numSampleCounts = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 1,
                          &numSampleCounts);
    ASSERT_GT(numSampleCounts, 0);

    std::vector<GLint> sampleCounts(numSampleCounts);
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, numSampleCounts,
                          sampleCounts.data());

    GLfloat samplePosition[2];

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFramebuffer);

    for (const GLint sampleCount : sampleCounts)
    {
        GLTexture texture;
        size_t indexKey = static_cast<size_t>(ceil(log2(sampleCount)));
        glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, texture);
        texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, sampleCount, GL_RGBA8, 1, 1, GL_TRUE);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE,
                               texture, 0);
        EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
        ASSERT_GL_NO_ERROR();

        for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)
        {
            getMultisamplefv(GL_SAMPLE_POSITION, sampleIndex, samplePosition);
            EXPECT_EQ(samplePosition[0], kSamplePositions[indexKey][2 * sampleIndex]);
            EXPECT_EQ(samplePosition[1], kSamplePositions[indexKey][2 * sampleIndex + 1]);
        }
    }

    ASSERT_GL_NO_ERROR();
}

// Test textureSize and texelFetch when using ANGLE_texture_multisample extension
TEST_P(TextureMultisampleTest, SimpleTexelFetch)
{
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_texture_multisample"));

    ANGLE_GL_PROGRAM(texelFetchProgram, essl3_shaders::vs::Passthrough(),
                     multisampleTextureFragmentShader());

    GLint texLocation = glGetUniformLocation(texelFetchProgram, "tex");
    ASSERT_GE(texLocation, 0);
    GLint sampleNumLocation = glGetUniformLocation(texelFetchProgram, "sampleNum");
    ASSERT_GE(sampleNumLocation, 0);

    const GLsizei kWidth  = 4;
    const GLsizei kHeight = 4;

    std::vector<GLenum> testFormats = {GL_RGBA8};
    GLint samplesToUse              = getSamplesToUse(GL_TEXTURE_2D_MULTISAMPLE_ANGLE, testFormats);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ANGLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE_ANGLE, samplesToUse, GL_RGBA8, kWidth, kHeight,
                          GL_TRUE);
    ASSERT_GL_NO_ERROR();

    // Clear texture zero to green.
    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    GLColor clearColor = GLColor::green;

    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE_ANGLE,
                           mTexture, 0);
    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
    ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);
    glClearColor(clearColor.R / 255.0f, clearColor.G / 255.0f, clearColor.B / 255.0f,
                 clearColor.A / 255.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    ASSERT_GL_NO_ERROR();

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glUseProgram(texelFetchProgram);
    glViewport(0, 0, kWidth, kHeight);

    for (GLint sampleNum = 0; sampleNum < samplesToUse; ++sampleNum)
    {
        glUniform1i(sampleNumLocation, sampleNum);
        drawQuad(texelFetchProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
        ASSERT_GL_NO_ERROR();
        EXPECT_PIXEL_RECT_EQ(0, 0, kWidth, kHeight, clearColor);
    }
}

// Test toggling sample mask
TEST_P(TextureMultisampleTest, SampleMaskToggling)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    GLboolean enabled = false;

    EXPECT_FALSE(glIsEnabled(GL_SAMPLE_MASK));
    EXPECT_GL_NO_ERROR();

    glEnable(GL_SAMPLE_MASK);
    EXPECT_GL_NO_ERROR();

    EXPECT_TRUE(glIsEnabled(GL_SAMPLE_MASK));
    EXPECT_GL_NO_ERROR();

    glGetBooleanv(GL_SAMPLE_MASK, &enabled);
    EXPECT_GL_NO_ERROR();
    EXPECT_TRUE(enabled);

    glDisable(GL_SAMPLE_MASK);
    EXPECT_GL_NO_ERROR();

    EXPECT_FALSE(glIsEnabled(GL_SAMPLE_MASK));
    EXPECT_GL_NO_ERROR();

    glGetBooleanv(GL_SAMPLE_MASK, &enabled);
    EXPECT_GL_NO_ERROR();
    EXPECT_FALSE(enabled);
}

// Test setting and querying sample mask value
TEST_P(TextureMultisampleTest, SampleMaski)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    GLint maxSampleMaskWords = 0;
    glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &maxSampleMaskWords);
    sampleMaski(maxSampleMaskWords - 1, 0x1);
    ASSERT_GL_NO_ERROR();

    sampleMaski(maxSampleMaskWords, 0x1);
    ASSERT_GL_ERROR(GL_INVALID_VALUE);

    GLint sampleMaskValue = 0;
    glGetIntegeri_v(GL_SAMPLE_MASK_VALUE, 0, &sampleMaskValue);
    ASSERT_GL_NO_ERROR();
    EXPECT_EQ(sampleMaskValue, 0x1);
}

// Test MS rendering with known per-sample values and a global sample mask
TEST_P(TextureMultisampleTest, MaskedDrawWithSampleID)
{
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_texture_multisample"));
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_OES_sample_variables"));

    ANGLE_GL_PROGRAM(fetchProgram, essl3_shaders::vs::Passthrough(),
                     multisampleTextureFragmentShader());
    glUseProgram(fetchProgram);
    const GLint sampleLocation = glGetUniformLocation(fetchProgram, "sampleNum");
    ASSERT_GE(sampleLocation, 0);

    const char kFSDraw[] = R"(#version 300 es
#extension GL_OES_sample_variables : require
precision mediump float;
out vec4 color;

void main() {
    switch (gl_SampleID) {
        case 0: color = vec4(1.0, 0.0, 0.0, 1.0); break;
        case 1: color = vec4(0.0, 1.0, 0.0, 1.0); break;
        case 2: color = vec4(0.0, 0.0, 1.0, 1.0); break;
        case 3: color = vec4(1.0, 1.0, 1.0, 1.0); break;
        default: color = vec4(0.0); break;
    }
})";
    ANGLE_GL_PROGRAM(drawProgram, essl3_shaders::vs::Simple(), kFSDraw);

    const GLsizei kSize    = 64;
    const GLsizei kSamples = 4;
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ANGLE, mTexture);
    glTexStorage2DMultisampleANGLE(GL_TEXTURE_2D_MULTISAMPLE_ANGLE, kSamples, GL_RGBA8, kSize,
                                   kSize, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFramebuffer);
    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                           GL_TEXTURE_2D_MULTISAMPLE_ANGLE, mTexture, 0);
    ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_DRAW_FRAMEBUFFER);

    glEnable(GL_SAMPLE_MASK);
    glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
    glViewport(0, 0, kSize, kSize);
    ASSERT_GL_NO_ERROR();

    for (size_t mask = 0; mask < 16; ++mask)
    {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFramebuffer);

        // Clear the MS texture to magenta with zero sample mask, it must not affect clear ops
        glSampleMaskiANGLE(0, 0);
        glClear(GL_COLOR_BUFFER_BIT);
        ASSERT_GL_NO_ERROR();

        // Draw to the MS texture with a sample mask
        glSampleMaskiANGLE(0, mask);
        drawQuad(drawProgram, essl3_shaders::PositionAttrib(), 0.0f);
        ASSERT_GL_NO_ERROR();

        // Check all four samples
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
        glUniform1i(sampleLocation, 0);
        drawQuad(fetchProgram, essl3_shaders::PositionAttrib(), 0.0f);
        EXPECT_PIXEL_COLOR_EQ(kSize / 2, kSize / 2, (mask & 1) ? GLColor::red : GLColor::magenta)
            << "mask: " << mask;
        glUniform1i(sampleLocation, 1);
        drawQuad(fetchProgram, essl3_shaders::PositionAttrib(), 0.0f);
        EXPECT_PIXEL_COLOR_EQ(kSize / 2, kSize / 2, (mask & 2) ? GLColor::green : GLColor::magenta)
            << "mask: " << mask;
        glUniform1i(sampleLocation, 2);
        drawQuad(fetchProgram, essl3_shaders::PositionAttrib(), 0.0f);
        EXPECT_PIXEL_COLOR_EQ(kSize / 2, kSize / 2, (mask & 4) ? GLColor::blue : GLColor::magenta)
            << "mask: " << mask;
        glUniform1i(sampleLocation, 3);
        drawQuad(fetchProgram, essl3_shaders::PositionAttrib(), 0.0f);
        EXPECT_PIXEL_COLOR_EQ(kSize / 2, kSize / 2, (mask & 8) ? GLColor::white : GLColor::magenta)
            << "mask: " << mask;
    }
}

TEST_P(TextureMultisampleTest, ResolveToDefaultFramebuffer)
{
    ANGLE_SKIP_TEST_IF(lessThanES31MultisampleExtNotSupported());

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    texStorageMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, getWindowWidth(),
                          getWindowHeight(), GL_TRUE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE,
                           mTexture, 0);
    ASSERT_GL_NO_ERROR();

    // Clear the framebuffer
    glClearColor(0.25, 0.5, 0.75, 0.25);
    glClear(GL_COLOR_BUFFER_BIT);

    // Resolve into default framebuffer
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
    glClearColor(1, 0, 0, 1);
    glClear(GL_COLOR_BUFFER_BIT);
    glBlitFramebuffer(0, 0, getWindowWidth(), getWindowHeight(), 0, 0, getWindowWidth(),
                      getWindowHeight(), GL_COLOR_BUFFER_BIT, GL_NEAREST);
    ASSERT_GL_NO_ERROR();

    const GLColor kResult = GLColor(63, 127, 191, 63);
    const int w           = getWindowWidth() - 1;
    const int h           = getWindowHeight() - 1;
    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
    EXPECT_PIXEL_COLOR_NEAR(0, 0, kResult, 1);
    EXPECT_PIXEL_COLOR_NEAR(w, 0, kResult, 1);
    EXPECT_PIXEL_COLOR_NEAR(0, h, kResult, 1);
    EXPECT_PIXEL_COLOR_NEAR(w, h, kResult, 1);
    EXPECT_PIXEL_COLOR_NEAR(w / 2, h / 2, kResult, 1);
}

// Negative tests of multisample texture. When context less than ES 3.1 and
// ANGLE_texture_multisample not enabled, the feature isn't supported.
TEST_P(NegativeTextureMultisampleTest, Negative)
{
    // The extension must have been disabled in test init.
    ASSERT_FALSE(IsGLExtensionEnabled("GL_ANGLE_texture_multisample"));

    glEnable(GL_SAMPLE_MASK);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    EXPECT_FALSE(glIsEnabled(GL_SAMPLE_MASK));
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    GLboolean enabled = false;
    glGetBooleanv(GL_SAMPLE_MASK, &enabled);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    EXPECT_FALSE(enabled);

    glDisable(GL_SAMPLE_MASK);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    GLint maxSamples = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_R8, GL_SAMPLES, 1, &maxSamples);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    GLint maxColorTextureSamples;
    glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    GLint maxDepthTextureSamples;
    glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &maxDepthTextureSamples);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, mTexture);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    glTexStorage2DMultisampleANGLE(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 64, 64, GL_FALSE);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 64, 64, GL_FALSE);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE,
                           mTexture, 0);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    GLint params = 0;
    glGetTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_IMMUTABLE_FORMAT, &params);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    if (EnsureGLExtensionEnabled("GL_ANGLE_get_tex_level_parameter"))
    {
        GLfloat levelSamples = 0;
        glGetTexLevelParameterfvANGLE(GL_TEXTURE_2D_MULTISAMPLE, 0, GL_TEXTURE_SAMPLES,
                                      &levelSamples);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        GLint fixedSampleLocation = false;
        glGetTexLevelParameterivANGLE(GL_TEXTURE_2D_MULTISAMPLE, 0,
                                      GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, &fixedSampleLocation);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
    }

    GLfloat samplePosition[2];
    glGetMultisamplefvANGLE(GL_SAMPLE_POSITION, 0, samplePosition);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    glGetMultisamplefv(GL_SAMPLE_POSITION, 0, samplePosition);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    GLint maxSampleMaskWords = 0;
    glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &maxSampleMaskWords);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    glSampleMaskiANGLE(maxSampleMaskWords - 1, 0x1);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    glSampleMaski(maxSampleMaskWords - 1, 0x1);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    GLint sampleMaskValue = 0;
    glGetIntegeri_v(GL_SAMPLE_MASK_VALUE, 0, &sampleMaskValue);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
}

// Tests GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY query when the extension is not enabled.
TEST_P(TextureMultisampleArrayTest, MultisampleArrayTargetGetIntegerWithoutExtension)
{
    ASSERT(!IsGLExtensionEnabled("GL_OES_texture_storage_multisample_2d_array"));

    GLint binding = -1;
    glGetIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, &binding);
    if (areMultisampleArraysAlwaysAvailable())
    {
        EXPECT_GL_NO_ERROR();
        EXPECT_EQ(binding, 0);
    }
    else
    {
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
        EXPECT_EQ(binding, -1);
    }
}

// Tests GL_TEXTURE_2D_MULTISAMPLE_ARRAY target with GetInternalformativ when the
// extension is not enabled.
TEST_P(TextureMultisampleArrayTest, MultisampleArrayTargetGetInternalFormativWithoutExtension)
{
    ASSERT(!IsGLExtensionEnabled("GL_OES_texture_storage_multisample_2d_array"));

    GLint maxSamples = -1;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_RGBA8, GL_SAMPLES, 1, &maxSamples);
    if (areMultisampleArraysAlwaysAvailable())
    {
        EXPECT_GL_NO_ERROR();
        EXPECT_GT(maxSamples, 0);
    }
    else
    {
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
        EXPECT_EQ(maxSamples, -1);
    }
}

// Attempt to bind a texture to multisample array binding point when extension is not enabled.
TEST_P(TextureMultisampleArrayTest, BindMultisampleArrayTextureWithoutExtension)
{
    ASSERT(!IsGLExtensionEnabled("GL_OES_texture_storage_multisample_2d_array"));

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, mTexture);
    if (areMultisampleArraysAlwaysAvailable())
    {
        EXPECT_GL_NO_ERROR();
    }
    else
    {
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
    }
}

// Try to compile shaders using GL_OES_texture_storage_multisample_2d_array when the extension is
// not enabled.
TEST_P(TextureMultisampleArrayTest, ShaderWithoutExtension)
{
    ASSERT(!IsGLExtensionEnabled("GL_OES_texture_storage_multisample_2d_array"));

    constexpr char kFSRequiresExtension[] = R"(#version 300 es
#extension GL_OES_texture_storage_multisample_2d_array : require
out highp vec4 my_FragColor;

void main() {
        my_FragColor = vec4(0.0);
})";

    GLuint program = CompileProgram(essl3_shaders::vs::Simple(), kFSRequiresExtension);
    EXPECT_EQ(0u, program);

    constexpr char kFSEnableAndUseExtension[] = R"(#version 300 es
#extension GL_OES_texture_storage_multisample_2d_array : enable

uniform highp sampler2DMSArray tex;
out highp ivec4 outSize;

void main() {
        outSize = ivec4(textureSize(tex), 0);
})";

    program = CompileProgram(essl3_shaders::vs::Simple(), kFSEnableAndUseExtension);
    EXPECT_EQ(0u, program);
}

// Tests that GL_TEXTURE_2D_MULTISAMPLE_ARRAY is supported in GetInternalformativ.
TEST_P(TextureMultisampleArrayTest, MultisampleArrayTargetGetInternalFormativ)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    // This query returns supported sample counts in descending order. If only one sample count is
    // queried, it should be the maximum one.
    GLint maxSamplesRGBA8 = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_RGBA8, GL_SAMPLES, 1,
                          &maxSamplesRGBA8);
    GLint maxSamplesDepth = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_DEPTH_COMPONENT24, GL_SAMPLES, 1,
                          &maxSamplesDepth);
    ASSERT_GL_NO_ERROR();

    // GLES 3.1 section 19.3.1 specifies the required minimum of how many samples are supported.
    GLint maxColorTextureSamples;
    glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
    GLint maxDepthTextureSamples;
    glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &maxDepthTextureSamples);
    GLint maxSamples;
    glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);

    GLint maxSamplesRGBA8Required = std::min(maxColorTextureSamples, maxSamples);
    EXPECT_GE(maxSamplesRGBA8, maxSamplesRGBA8Required);

    GLint maxSamplesDepthRequired = std::min(maxDepthTextureSamples, maxSamples);
    EXPECT_GE(maxSamplesDepth, maxSamplesDepthRequired);
}

// Tests that TexImage3D call cannot be used for GL_TEXTURE_2D_MULTISAMPLE_ARRAY.
TEST_P(TextureMultisampleArrayTest, MultiSampleArrayTexImage)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    ASSERT_GL_NO_ERROR();

    glTexImage3D(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0, GL_RGBA8, 1, 1, 1, 0, GL_RGBA,
                 GL_UNSIGNED_BYTE, nullptr);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
}

// Tests passing invalid parameters to TexStorage3DMultisample.
TEST_P(TextureMultisampleArrayTest, InvalidTexStorage3DMultisample)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    ASSERT_GL_NO_ERROR();

    // Invalid target
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 2, GL_RGBA8, 1, 1, 1, GL_TRUE);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    // Samples 0
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0, GL_RGBA8, 1, 1, 1, GL_TRUE);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Unsized internalformat
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2, GL_RGBA, 1, 1, 1, GL_TRUE);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    // Width 0
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2, GL_RGBA8, 0, 1, 1, GL_TRUE);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Height 0
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2, GL_RGBA8, 1, 0, 1, GL_TRUE);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Depth 0
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2, GL_RGBA8, 1, 1, 0, GL_TRUE);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Tests passing invalid parameters to TexParameteri.
TEST_P(TextureMultisampleArrayTest, InvalidTexParameteri)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    ASSERT_GL_NO_ERROR();

    // None of the sampler parameters can be set on GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES.
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_MIN_LOD, 0);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_MAX_LOD, 0);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_COMPARE_MODE, GL_NONE);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_COMPARE_FUNC, GL_ALWAYS);
    EXPECT_GL_ERROR(GL_INVALID_ENUM);

    // Only valid base level on GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES is 0.
    glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, 1);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
}

// Test a valid TexStorage3DMultisample call and check that the queried texture level parameters
// match. Does not do any drawing.
TEST_P(TextureMultisampleArrayTest, TexStorage3DMultisample)
{
    ASSERT_TRUE(EnsureGLExtensionEnabled("GL_ANGLE_get_tex_level_parameter"));
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    GLint maxSamplesRGBA8 = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_RGBA8, GL_SAMPLES, 1,
                          &maxSamplesRGBA8);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    ASSERT_GL_NO_ERROR();

    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, maxSamplesRGBA8, GL_RGBA8, 8, 4, 2,
                            GL_TRUE);
    ASSERT_GL_NO_ERROR();

    GLint width = 0, height = 0, depth = 0, samples = 0;
    glGetTexLevelParameterivANGLE(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0, GL_TEXTURE_WIDTH, &width);
    glGetTexLevelParameterivANGLE(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0, GL_TEXTURE_HEIGHT,
                                  &height);
    glGetTexLevelParameterivANGLE(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0, GL_TEXTURE_DEPTH, &depth);
    glGetTexLevelParameterivANGLE(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0, GL_TEXTURE_SAMPLES,
                                  &samples);
    ASSERT_GL_NO_ERROR();

    EXPECT_EQ(8, width);
    EXPECT_EQ(4, height);
    EXPECT_EQ(2, depth);
    EXPECT_EQ(maxSamplesRGBA8, samples);
}

// Test for invalid FramebufferTextureLayer calls with GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES
// textures.
TEST_P(TextureMultisampleArrayTest, InvalidFramebufferTextureLayer)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    GLint maxSamplesRGBA8 = 0;
    glGetInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_RGBA8, GL_SAMPLES, 1,
                          &maxSamplesRGBA8);

    GLint maxArrayTextureLayers;
    glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &maxArrayTextureLayers);

    // Test framebuffer status with just a color texture attached.
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, maxSamplesRGBA8, GL_RGBA8, 4, 4, 2,
                            GL_TRUE);
    ASSERT_GL_NO_ERROR();

    // Test with mip level 1 and -1 (only level 0 is valid for multisample textures).
    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 1, 0);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, -1, 0);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Test with layer -1 and layer == MAX_ARRAY_TEXTURE_LAYERS
    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 0, -1);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 0,
                              maxArrayTextureLayers);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Attach layers of TEXTURE_2D_MULTISAMPLE_ARRAY textures to a framebuffer and check for
// completeness.
TEST_P(TextureMultisampleArrayTest, FramebufferCompleteness)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    std::vector<GLenum> testFormats = {{GL_RGBA8, GL_DEPTH_COMPONENT24, GL_DEPTH24_STENCIL8}};
    GLint samplesToUse = getSamplesToUse(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, testFormats);

    // Test framebuffer status with just a color texture attached.
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_RGBA8, 4, 4, 2,
                            GL_TRUE);
    ASSERT_GL_NO_ERROR();

    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 0, 0);
    ASSERT_GL_NO_ERROR();

    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
    ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);

    // Test framebuffer status with both color and depth textures attached.
    GLTexture depthTexture;
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, depthTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_DEPTH_COMPONENT24,
                            4, 4, 2, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthTexture, 0, 0);
    ASSERT_GL_NO_ERROR();

    status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
    ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);

    // Test with color and depth/stencil textures attached.
    GLTexture depthStencilTexture;
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, depthStencilTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_DEPTH24_STENCIL8,
                            4, 4, 2, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, depthStencilTexture, 0,
                              0);
    ASSERT_GL_NO_ERROR();

    status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
    ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);
}

// Attach a layer of TEXTURE_2D_MULTISAMPLE_ARRAY texture to a framebuffer, clear it, and resolve by
// blitting.
TEST_P(TextureMultisampleArrayTest, FramebufferColorClearAndBlit)
{
    if (!areMultisampleArraysAlwaysAvailable())
    {
        ANGLE_SKIP_TEST_IF(!requestArrayExtension());
    }

    const GLsizei kWidth  = 4;
    const GLsizei kHeight = 4;

    std::vector<GLenum> testFormats = {GL_RGBA8};
    GLint samplesToUse = getSamplesToUse(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, testFormats);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_RGBA8, kWidth,
                            kHeight, 2, GL_TRUE);

    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 0, 0);

    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
    ASSERT_GL_NO_ERROR();
    ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);

    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    GLFramebuffer resolveFramebuffer;
    GLTexture resolveTexture;
    glBindTexture(GL_TEXTURE_2D, resolveTexture);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kWidth, kHeight);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolveFramebuffer);
    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, resolveTexture,
                           0);
    glBlitFramebuffer(0, 0, kWidth, kHeight, 0, 0, kWidth, kHeight, GL_COLOR_BUFFER_BIT,
                      GL_NEAREST);
    ASSERT_GL_NO_ERROR();

    glBindFramebuffer(GL_READ_FRAMEBUFFER, resolveFramebuffer);
    EXPECT_PIXEL_RECT_EQ(0, 0, kWidth, kHeight, GLColor::green);
}

// Check the size of a multisample array texture in a shader.
TEST_P(TextureMultisampleArrayTest, TextureSizeInShader)
{
    ANGLE_SKIP_TEST_IF(!requestArrayExtension());

    constexpr char kFS[] = R"(#version 300 es
#extension GL_OES_texture_storage_multisample_2d_array : require

uniform highp sampler2DMSArray tex;
out highp vec4 my_FragColor;

void main() {
        my_FragColor = (textureSize(tex) == ivec3(8, 4, 2)) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
})";

    ANGLE_GL_PROGRAM(texSizeProgram, essl3_shaders::vs::Simple(), kFS);

    GLint texLocation = glGetUniformLocation(texSizeProgram, "tex");
    ASSERT_GE(texLocation, 0);

    const GLsizei kWidth  = 8;
    const GLsizei kHeight = 4;

    std::vector<GLenum> testFormats = {GL_RGBA8};
    GLint samplesToUse = getSamplesToUse(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, testFormats);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_RGBA8, kWidth,
                            kHeight, 2, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    drawQuad(texSizeProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    ASSERT_GL_NO_ERROR();

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

// Clear the layers of a multisample array texture, and then sample all the samples from all the
// layers in a shader.
TEST_P(TextureMultisampleArrayTest, SimpleTexelFetch)
{
    ANGLE_SKIP_TEST_IF(!requestArrayExtension());

    ANGLE_GL_PROGRAM(texelFetchProgram, essl3_shaders::vs::Passthrough(),
                     blitArrayTextureLayerFragmentShader());

    GLint texLocation = glGetUniformLocation(texelFetchProgram, "tex");
    ASSERT_GE(texLocation, 0);
    GLint layerLocation = glGetUniformLocation(texelFetchProgram, "layer");
    ASSERT_GE(layerLocation, 0);
    GLint sampleNumLocation = glGetUniformLocation(texelFetchProgram, "sampleNum");
    ASSERT_GE(layerLocation, 0);

    const GLsizei kWidth      = 4;
    const GLsizei kHeight     = 4;
    const GLsizei kLayerCount = 2;

    std::vector<GLenum> testFormats = {GL_RGBA8};
    GLint samplesToUse = getSamplesToUse(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, testFormats);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_RGBA8, kWidth,
                            kHeight, kLayerCount, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    // Clear layer zero to green and layer one to blue.
    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    std::vector<GLColor> clearColors = {{GLColor::green, GLColor::blue}};
    for (GLint i = 0; static_cast<GLsizei>(i) < kLayerCount; ++i)
    {
        glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 0, i);
        GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
        ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);
        const GLColor &clearColor = clearColors[i];
        glClearColor(clearColor.R / 255.0f, clearColor.G / 255.0f, clearColor.B / 255.0f,
                     clearColor.A / 255.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        ASSERT_GL_NO_ERROR();
    }

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glUseProgram(texelFetchProgram);
    glViewport(0, 0, kWidth, kHeight);
    for (GLint layer = 0; static_cast<GLsizei>(layer) < kLayerCount; ++layer)
    {
        glUniform1i(layerLocation, layer);
        for (GLint sampleNum = 0; sampleNum < samplesToUse; ++sampleNum)
        {
            glUniform1i(sampleNumLocation, sampleNum);
            drawQuad(texelFetchProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
            ASSERT_GL_NO_ERROR();
            EXPECT_PIXEL_RECT_EQ(0, 0, kWidth, kHeight, clearColors[layer]);
        }
    }
}

// Clear the layers of an integer multisample array texture, and then sample all the samples from
// all the layers in a shader.
TEST_P(TextureMultisampleArrayTest, IntegerTexelFetch)
{
    ANGLE_SKIP_TEST_IF(!requestArrayExtension());

    ANGLE_GL_PROGRAM(texelFetchProgram, essl3_shaders::vs::Passthrough(),
                     blitIntArrayTextureLayerFragmentShader());

    GLint texLocation = glGetUniformLocation(texelFetchProgram, "tex");
    ASSERT_GE(texLocation, 0);
    GLint layerLocation = glGetUniformLocation(texelFetchProgram, "layer");
    ASSERT_GE(layerLocation, 0);
    GLint sampleNumLocation = glGetUniformLocation(texelFetchProgram, "sampleNum");
    ASSERT_GE(layerLocation, 0);

    const GLsizei kWidth      = 4;
    const GLsizei kHeight     = 4;
    const GLsizei kLayerCount = 2;

    std::vector<GLenum> testFormats = {GL_RGBA8I};
    GLint samplesToUse = getSamplesToUse(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, testFormats);

    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, mTexture);
    texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, samplesToUse, GL_RGBA8I, kWidth,
                            kHeight, kLayerCount, GL_TRUE);
    ASSERT_GL_NO_ERROR();

    // Clear layer zero to green and layer one to blue.
    glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
    std::vector<GLColor> clearColors = {{GLColor::green, GLColor::blue}};
    for (GLint i = 0; static_cast<GLsizei>(i) < kLayerCount; ++i)
    {
        glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTexture, 0, i);
        GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
        ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, status);
        std::array<GLint, 4> intColor;
        for (size_t j = 0; j < intColor.size(); ++j)
        {
            intColor[j] = clearColors[i][j] / 255;
        }
        glClearBufferiv(GL_COLOR, 0, intColor.data());
        ASSERT_GL_NO_ERROR();
    }

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glUseProgram(texelFetchProgram);
    glViewport(0, 0, kWidth, kHeight);
    for (GLint layer = 0; static_cast<GLsizei>(layer) < kLayerCount; ++layer)
    {
        glUniform1i(layerLocation, layer);
        for (GLint sampleNum = 0; sampleNum < samplesToUse; ++sampleNum)
        {
            glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);
            glUniform1i(sampleNumLocation, sampleNum);
            drawQuad(texelFetchProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
            ASSERT_GL_NO_ERROR();
            EXPECT_PIXEL_RECT_EQ(0, 0, kWidth, kHeight, clearColors[layer]);
        }
    }
}

class TextureSampleShadingTest : public ANGLETest<>
{
  protected:
    TextureSampleShadingTest() {}
};

// Test that sample shading actually produces different interpolations per sample.  Note that
// variables such as gl_SampleID and gl_SamplePosition are avoided, as well as the |sample|
// qualifier as they automatically enable sample shading.
TEST_P(TextureSampleShadingTest, Basic)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_sample_shading"));

    constexpr GLsizei kSize        = 1;
    constexpr GLsizei kSampleCount = 4;

    // Create a multisampled texture and framebuffer.
    GLFramebuffer msaaFBO;
    glBindFramebuffer(GL_FRAMEBUFFER, msaaFBO);

    GLTexture msaaTexture;
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, msaaTexture);
    glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, kSampleCount, GL_RGBA8, kSize, kSize,
                              false);
    ASSERT_GL_NO_ERROR();
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE,
                           msaaTexture, 0);
    ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);

    // Enable sample shading and draw a gradient.
    glEnable(GL_SAMPLE_SHADING_OES);
    glMinSampleShadingOES(1.0f);

    ANGLE_GL_PROGRAM(gradientProgram, essl31_shaders::vs::Passthrough(),
                     essl31_shaders::fs::RedGreenGradient());
    glViewport(0, 0, kSize, kSize);
    drawQuad(gradientProgram, essl31_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    ASSERT_GL_NO_ERROR();

    // Create a buffer for verification.
    constexpr GLsizei kPixelChannels = 4;
    constexpr GLsizei kBufferSize =
        kSize * kSize * kSampleCount * kPixelChannels * sizeof(uint32_t);
    GLBuffer buffer;
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
    glBufferData(GL_SHADER_STORAGE_BUFFER, kBufferSize, nullptr, GL_STATIC_DRAW);
    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buffer);

    // Issue a dispatch call that copies the multisampled texture into a buffer.
    constexpr char kCS[] = R"(#version 310 es
layout(local_size_x=4, local_size_y=1, local_size_z=1) in;

uniform highp sampler2DMS imageIn;
layout(std430, binding = 0) buffer dataOut {
    uint data[];
};

void main()
{
    int sampleIndex = int(gl_GlobalInvocationID.x) % 4;

    vec4 color = texelFetch(imageIn, ivec2(0), sampleIndex);
    uvec4 unnormalized = uvec4(color * 255.0);

    int outIndex = sampleIndex * 4;

    data[outIndex    ] = unnormalized.r;
    data[outIndex + 1] = unnormalized.g;
    data[outIndex + 2] = unnormalized.b;
    data[outIndex + 3] = unnormalized.a;
})";

    ANGLE_GL_COMPUTE_PROGRAM(program, kCS);
    glUseProgram(program);

    // Bind the multisampled texture as sampler.
    GLint imageLocation = glGetUniformLocation(program, "imageIn");
    ASSERT_GE(imageLocation, 0);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, msaaTexture);
    glUniform1i(imageLocation, 0);

    glDispatchCompute(1, 1, 1);
    EXPECT_GL_NO_ERROR();

    // Verify that the buffer has correct data.
    glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);

    const uint32_t *ptr = reinterpret_cast<uint32_t *>(
        glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, kBufferSize, GL_MAP_READ_BIT));
    constexpr GLColor kExpectedColors[4] = {
        GLColor(96, 32, 0, 255),
        GLColor(223, 96, 0, 255),
        GLColor(32, 159, 0, 255),
        GLColor(159, 223, 0, 255),
    };
    for (GLsizei pixel = 0; pixel < kSampleCount; ++pixel)
    {
        for (GLsizei channel = 0; channel < kPixelChannels; ++channel)
        {
            EXPECT_NEAR(ptr[pixel * kPixelChannels + channel], kExpectedColors[pixel][channel], 1)
                << pixel << " " << channel;
        }
    }

    glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
}

// Test that sample shading actually produces different interpolations per sample when |sample| is
// missing from the shader.  Both varyings and I/O blocks are tested.  When |centroid| is specified,
// |sample| shouldn't be added.
TEST_P(TextureSampleShadingTest, NoSampleQualifier)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_sample_shading"));
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_sample_variables"));
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_shader_multisample_interpolation"));
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_shader_io_blocks"));

    constexpr GLsizei kSize        = 1;
    constexpr GLsizei kSampleCount = 4;

    // Create a multisampled texture and framebuffer.
    GLFramebuffer msaaFBO;
    glBindFramebuffer(GL_FRAMEBUFFER, msaaFBO);

    GLTexture msaaTexture;
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, msaaTexture);
    glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, kSampleCount, GL_RGBA8, kSize, kSize,
                              false);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE,
                           msaaTexture, 0);
    ASSERT_GL_NO_ERROR();
    ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);

    // Enable sample shading and draw
    glEnable(GL_SAMPLE_SHADING_OES);
    glMinSampleShadingOES(1.0f);

    constexpr char kVS[] = R"(#version 310 es
#extension GL_OES_shader_multisample_interpolation : require
#extension GL_EXT_shader_io_blocks : require

in mediump vec2 position;
out mediump vec2 gradient;
centroid out mediump vec2 constant;
out Block
{
    centroid mediump vec2 constant2;
    mediump vec2 gradient2;
    sample mediump vec2 gradient3;
};

out Inactive
{
    mediump vec2 gradient4;
};

void main()
{
    gradient = position;
    gradient2 = position;
    gradient3 = position;
    constant = position;
    constant2 = position;
    gl_Position = vec4(position, 0, 1);
})";

    constexpr char kFS[] = R"(#version 310 es
#extension GL_OES_shader_multisample_interpolation : require
#extension GL_OES_sample_variables : require
#extension GL_EXT_shader_io_blocks : require

in highp vec2 gradient;
centroid in highp vec2 constant;
in Block
{
    centroid mediump vec2 constant2;
    mediump vec2 gradient2;
    sample mediump vec2 gradient3;
};

in Inactive2
{
    mediump vec2 gradient4;
};

out mediump vec4 color;

void main()
{
    bool left = gl_SampleID == 0 || gl_SampleID == 2;
    bool top = gl_SampleID == 0 || gl_SampleID == 1;

    color = vec4(0);

    if (left)
        color.r = gradient.x < -0.1 && gradient2.x < -0.1 && gradient3.x < -0.1 ? 1. : 0.;
    else
        color.r = gradient.x > 0.1 && gradient2.x > 0.1 && gradient3.x > 0.1 ? 1. : 0.;

    if (top)
        color.g = gradient.y < -0.1 && gradient2.y < -0.1 && gradient3.y < -0.1 ? 1. : 0.;
    else
        color.g = gradient.y > 0.1 && gradient2.y > 0.1 && gradient3.y > 0.1 ? 1. : 0.;

    // centroid doesn't exactly behave consistently between implementations.  In particular, it does
    // _not_ necessarily evaluage the varying at the pixel center.  As a result, there isn't much
    // that can be verified here.  We'd rely on SPIR-V validation to make sure Sample is not added
    // to ids that already have Centroid specified (in the Vulkan backend)
    color.b = abs(constant.x) < 1. && abs(constant.y) < 1. ? 1. : 0.;
    color.a = abs(constant2.x) < 1. && abs(constant2.y) < 1. ? 1. : 0.;
})";

    ANGLE_GL_PROGRAM(program, kVS, kFS);
    glViewport(0, 0, kSize, kSize);
    drawQuad(program, "position", 0.5f);
    ASSERT_GL_NO_ERROR();

    // Resolve the framebuffer
    GLFramebuffer fbo;
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);

    GLTexture texture;
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kSize, kSize);
    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
    ASSERT_GL_NO_ERROR();
    ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_DRAW_FRAMEBUFFER);

    glBlitFramebuffer(0, 0, kSize, kSize, 0, 0, kSize, kSize, GL_COLOR_BUFFER_BIT, GL_LINEAR);

    glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);

    // Ensure the test passed on every sample location
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::white);
    ASSERT_GL_NO_ERROR();
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TextureMultisampleTest);
ANGLE_INSTANTIATE_TEST_ES3_AND_ES31(TextureMultisampleTest);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NegativeTextureMultisampleTest);
ANGLE_INSTANTIATE_TEST_ES3(NegativeTextureMultisampleTest);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TextureMultisampleArrayTest);
ANGLE_INSTANTIATE_TEST_ES3_AND_ES31_AND(TextureMultisampleArrayTest, ANGLE_ALL_TEST_PLATFORMS_ES32);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TextureSampleShadingTest);
ANGLE_INSTANTIATE_TEST_ES31(TextureSampleShadingTest);
}  // anonymous namespace