xref: /aosp_15_r20/external/deqp/modules/gles31/functional/es31fSampleVariableTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 Module
 * -------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Sample variable tests
 *//*--------------------------------------------------------------------*/

#include "es31fSampleVariableTests.hpp"
#include "es31fMultisampleShaderRenderCase.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuFormatUtil.hpp"
#include "tcuStringTemplate.hpp"
#include "gluContextInfo.hpp"
#include "gluShaderProgram.hpp"
#include "gluRenderContext.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deStringUtil.hpp"

namespace deqp
{

using std::map;
using std::string;

namespace gles31
{
namespace Functional
{
namespace
{

class Verifier
{
public:
    virtual bool verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const = 0;
    virtual void logInfo(tcu::TestLog &log) const                                     = 0;
};

class ColorVerifier : public Verifier
{
public:
    ColorVerifier(const tcu::Vec3 &_color, int _threshold = 8)
        : m_color(tcu::Vec4(_color.x(), _color.y(), _color.z(), 1.0f))
        , m_threshold(tcu::IVec3(_threshold))
    {
    }

    ColorVerifier(const tcu::Vec3 &_color, tcu::IVec3 _threshold)
        : m_color(tcu::Vec4(_color.x(), _color.y(), _color.z(), 1.0f))
        , m_threshold(_threshold)
    {
    }

    bool verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const
    {
        DE_UNREF(position);
        return !tcu::boolAny(
            tcu::greaterThan(tcu::abs(m_color.toIVec().swizzle(0, 1, 2) - testColor.toIVec().swizzle(0, 1, 2)),
                             tcu::IVec3(m_threshold)));
    }

    void logInfo(tcu::TestLog &log) const
    {
        // full threshold? print * for clarity
        log << tcu::TestLog::Message << "Expecting unicolored image, color = RGB("
            << ((m_threshold[0] >= 255) ? ("*") : (de::toString(m_color.getRed()))) << ", "
            << ((m_threshold[1] >= 255) ? ("*") : (de::toString(m_color.getGreen()))) << ", "
            << ((m_threshold[2] >= 255) ? ("*") : (de::toString(m_color.getBlue()))) << ")" << tcu::TestLog::EndMessage;
    }

    const tcu::RGBA m_color;
    const tcu::IVec3 m_threshold;
};

class FullBlueSomeGreenVerifier : public Verifier
{
public:
    FullBlueSomeGreenVerifier(void)
    {
    }

    bool verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const
    {
        DE_UNREF(position);

        // Values from 0.0 and 1.0 are accurate

        if (testColor.getRed() != 0)
            return false;
        if (testColor.getGreen() == 0)
            return false;
        if (testColor.getBlue() != 255)
            return false;
        return true;
    }

    void logInfo(tcu::TestLog &log) const
    {
        log << tcu::TestLog::Message << "Expecting color c = (0.0, x, 1.0), x > 0.0" << tcu::TestLog::EndMessage;
    }
};

class NoRedVerifier : public Verifier
{
public:
    NoRedVerifier(void)
    {
    }

    bool verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const
    {
        DE_UNREF(position);
        return testColor.getRed() == 0;
    }

    void logInfo(tcu::TestLog &log) const
    {
        log << tcu::TestLog::Message << "Expecting zero-valued red channel." << tcu::TestLog::EndMessage;
    }
};

class SampleAverageVerifier : public Verifier
{
public:
    SampleAverageVerifier(int _numSamples);

    bool verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const;
    void logInfo(tcu::TestLog &log) const;

    const int m_numSamples;
    const bool m_isStatisticallySignificant;
    float m_distanceThreshold;
};

SampleAverageVerifier::SampleAverageVerifier(int _numSamples)
    : m_numSamples(_numSamples)
    , m_isStatisticallySignificant(_numSamples >= 4)
    , m_distanceThreshold(0.0f)
{
    // approximate Bates distribution as normal
    const float variance          = (1.0f / (12.0f * (float)m_numSamples));
    const float standardDeviation = deFloatSqrt(variance);

    // 95% of means of sample positions are within 2 standard deviations if
    // they were randomly assigned. Sample patterns are expected to be more
    // uniform than a random pattern.
    m_distanceThreshold = 2 * standardDeviation;
}

bool SampleAverageVerifier::verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const
{
    DE_UNREF(position);
    DE_ASSERT(m_isStatisticallySignificant);

    const tcu::Vec2 avgPosition((float)testColor.getGreen() / 255.0f, (float)testColor.getBlue() / 255.0f);
    const tcu::Vec2 distanceFromCenter = tcu::abs(avgPosition - tcu::Vec2(0.5f, 0.5f));

    return distanceFromCenter.x() < m_distanceThreshold && distanceFromCenter.y() < m_distanceThreshold;
}

void SampleAverageVerifier::logInfo(tcu::TestLog &log) const
{
    log << tcu::TestLog::Message
        << "Expecting average sample position to be near the pixel center. Maximum per-axis distance "
        << m_distanceThreshold << tcu::TestLog::EndMessage;
}

class PartialDiscardVerifier : public Verifier
{
public:
    PartialDiscardVerifier(void)
    {
    }

    bool verify(const tcu::RGBA &testColor, const tcu::IVec2 &position) const
    {
        DE_UNREF(position);

        return (testColor.getGreen() != 0) && (testColor.getGreen() != 255);
    }

    void logInfo(tcu::TestLog &log) const
    {
        log << tcu::TestLog::Message << "Expecting color non-zero and non-saturated green channel"
            << tcu::TestLog::EndMessage;
    }
};

static bool verifyImageWithVerifier(const tcu::Surface &resultImage, tcu::TestLog &log, const Verifier &verifier,
                                    bool logOnSuccess = true)
{
    tcu::Surface errorMask(resultImage.getWidth(), resultImage.getHeight());
    bool error = false;

    tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));

    if (logOnSuccess)
    {
        log << tcu::TestLog::Message << "Verifying image." << tcu::TestLog::EndMessage;
        verifier.logInfo(log);
    }

    for (int y = 0; y < resultImage.getHeight(); ++y)
        for (int x = 0; x < resultImage.getWidth(); ++x)
        {
            const tcu::RGBA color = resultImage.getPixel(x, y);

            // verify color value is valid for this pixel position
            if (!verifier.verify(color, tcu::IVec2(x, y)))
            {
                error = true;
                errorMask.setPixel(x, y, tcu::RGBA::red());
            }
        }

    if (error)
    {
        // describe the verification logic if we haven't already
        if (!logOnSuccess)
            verifier.logInfo(log);

        log << tcu::TestLog::Message << "Image verification failed." << tcu::TestLog::EndMessage
            << tcu::TestLog::ImageSet("Verification", "Image Verification")
            << tcu::TestLog::Image("Result", "Result image", resultImage.getAccess())
            << tcu::TestLog::Image("ErrorMask", "Error Mask", errorMask.getAccess()) << tcu::TestLog::EndImageSet;
    }
    else if (logOnSuccess)
    {
        log << tcu::TestLog::Message << "Image verification passed." << tcu::TestLog::EndMessage
            << tcu::TestLog::ImageSet("Verification", "Image Verification")
            << tcu::TestLog::Image("Result", "Result image", resultImage.getAccess()) << tcu::TestLog::EndImageSet;
    }

    return !error;
}

class MultisampleRenderCase : public MultisampleShaderRenderUtil::MultisampleRenderCase
{
public:
    MultisampleRenderCase(Context &context, const char *name, const char *desc, int numSamples, RenderTarget target,
                          int renderSize, int flags = 0);
    virtual ~MultisampleRenderCase(void);

    virtual void init(void);
};

MultisampleRenderCase::MultisampleRenderCase(Context &context, const char *name, const char *desc, int numSamples,
                                             RenderTarget target, int renderSize, int flags)
    : MultisampleShaderRenderUtil::MultisampleRenderCase(context, name, desc, numSamples, target, renderSize, flags)
{
    DE_ASSERT(target < TARGET_LAST);
}

MultisampleRenderCase::~MultisampleRenderCase(void)
{
    MultisampleRenderCase::deinit();
}

void MultisampleRenderCase::init(void)
{
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    if (!supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_variables"))
        TCU_THROW(NotSupportedError,
                  "Test requires GL_OES_sample_variables extension or a context version 3.2 or higher.");

    MultisampleShaderRenderUtil::MultisampleRenderCase::init();
}

class NumSamplesCase : public MultisampleRenderCase
{
public:
    NumSamplesCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target);
    ~NumSamplesCase(void);

    std::string genFragmentSource(int numTargetSamples) const;
    bool verifyImage(const tcu::Surface &resultImage);

private:
    enum
    {
        RENDER_SIZE = 64
    };
};

NumSamplesCase::NumSamplesCase(Context &context, const char *name, const char *desc, int sampleCount,
                               RenderTarget target)
    : MultisampleRenderCase(context, name, desc, sampleCount, target, RENDER_SIZE)
{
}

NumSamplesCase::~NumSamplesCase(void)
{
}

std::string NumSamplesCase::genFragmentSource(int numTargetSamples) const
{
    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = (supportsES32orGL45) ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                       getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = (supportsES32orGL45) ? "" : "#extension GL_OES_sample_variables : require";

    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_EXTENSION}\n"
           "layout(location = 0) out mediump vec4 fragColor;\n"
           "void main (void)\n"
           "{\n"
           "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
           "    if (gl_NumSamples == "
        << numTargetSamples
        << ")\n"
           "        fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
           "}\n";

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool NumSamplesCase::verifyImage(const tcu::Surface &resultImage)
{
    return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), NoRedVerifier());
}

class MaxSamplesCase : public MultisampleRenderCase
{
public:
    MaxSamplesCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target);
    ~MaxSamplesCase(void);

private:
    void preDraw(void);
    std::string genFragmentSource(int numTargetSamples) const;
    bool verifyImage(const tcu::Surface &resultImage);

    enum
    {
        RENDER_SIZE = 64
    };
};

MaxSamplesCase::MaxSamplesCase(Context &context, const char *name, const char *desc, int sampleCount,
                               RenderTarget target)
    : MultisampleRenderCase(context, name, desc, sampleCount, target, RENDER_SIZE)
{
}

MaxSamplesCase::~MaxSamplesCase(void)
{
}

void MaxSamplesCase::preDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    int32_t maxSamples       = -1;

    // query samples
    {
        gl.getIntegerv(GL_MAX_SAMPLES, &maxSamples);
        GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_MAX_SAMPLES");

        m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLES = " << maxSamples << tcu::TestLog::EndMessage;
    }

    // set samples
    {
        const int maxSampleLoc = gl.getUniformLocation(m_program->getProgram(), "u_maxSamples");
        if (maxSampleLoc == -1)
            throw tcu::TestError("Location of u_maxSamples was -1");

        gl.uniform1i(maxSampleLoc, maxSamples);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set u_maxSamples uniform");

        m_testCtx.getLog() << tcu::TestLog::Message << "Set u_maxSamples = " << maxSamples << tcu::TestLog::EndMessage;
    }
}

std::string MaxSamplesCase::genFragmentSource(int numTargetSamples) const
{
    DE_UNREF(numTargetSamples);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = (supportsES32orGL45) ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                       getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = (supportsES32orGL45) ? "" : "#extension GL_OES_sample_variables : require";

    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_EXTENSION}\n"
           "layout(location = 0) out mediump vec4 fragColor;\n"
           "uniform mediump int u_maxSamples;\n"
           "void main (void)\n"
           "{\n"
           "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
           "    if (gl_MaxSamples == u_maxSamples)\n"
           "        fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
           "}\n";

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool MaxSamplesCase::verifyImage(const tcu::Surface &resultImage)
{
    return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), NoRedVerifier());
}

class SampleIDCase : public MultisampleRenderCase
{
public:
    SampleIDCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target);
    ~SampleIDCase(void);

    void init(void);

private:
    std::string genFragmentSource(int numTargetSamples) const;
    bool verifyImage(const tcu::Surface &resultImage);
    bool verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers);

    enum
    {
        RENDER_SIZE = 64
    };
    enum VerificationMode
    {
        VERIFY_USING_SAMPLES,
        VERIFY_USING_SELECTION,
    };

    const VerificationMode m_vericationMode;
};

SampleIDCase::SampleIDCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target)
    : MultisampleRenderCase(context, name, desc, sampleCount, target, RENDER_SIZE,
                            MultisampleShaderRenderUtil::MultisampleRenderCase::FLAG_VERIFY_MSAA_TEXTURE_SAMPLE_BUFFERS)
    , m_vericationMode((target == TARGET_TEXTURE) ? (VERIFY_USING_SAMPLES) : (VERIFY_USING_SELECTION))
{
}

SampleIDCase::~SampleIDCase(void)
{
}

void SampleIDCase::init(void)
{
    // log the test method and expectations
    if (m_vericationMode == VERIFY_USING_SAMPLES)
        m_testCtx.getLog()
            << tcu::TestLog::Message
            << "Writing gl_SampleID to the green channel of the texture and verifying texture values, expecting:\n"
            << "    1) 0 with non-multisample targets.\n"
            << "    2) value N at sample index N of a multisample texture\n"
            << tcu::TestLog::EndMessage;
    else if (m_vericationMode == VERIFY_USING_SELECTION)
        m_testCtx.getLog()
            << tcu::TestLog::Message
            << "Selecting a single sample id for each pixel and writing color only if gl_SampleID == selected.\n"
            << "Expecting all output pixels to be partially (multisample) or fully (singlesample) colored.\n"
            << tcu::TestLog::EndMessage;
    else
        DE_ASSERT(false);

    MultisampleRenderCase::init();
}

std::string SampleIDCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = (supportsES32orGL45) ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                       getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = (supportsES32orGL45) ? "" : "#extension GL_OES_sample_variables : require";

    if (m_vericationMode == VERIFY_USING_SAMPLES)
    {
        // encode the id to the output, and then verify it during sampling
        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "void main (void)\n"
               "{\n"
               "    highp float normalizedSample = float(gl_SampleID) / float("
            << numTargetSamples
            << ");\n"
               "    fragColor = vec4(0.0, normalizedSample, 1.0, 1.0);\n"
               "}\n";
    }
    else if (m_vericationMode == VERIFY_USING_SELECTION)
    {
        if (numTargetSamples == 1)
        {
            // single sample, just verify value is 0
            buf << "${GLSL_VERSION_DECL}\n"
                   "${GLSL_EXTENSION}\n"
                   "layout(location = 0) out mediump vec4 fragColor;\n"
                   "void main (void)\n"
                   "{\n"
                   "    if (gl_SampleID == 0)\n"
                   "        fragColor = vec4(0.0, 1.0, 1.0, 1.0);\n"
                   "    else\n"
                   "        fragColor = vec4(0.0, 0.0, 1.0, 1.0);\n"
                   "}\n";
        }
        else
        {
            // select only one sample per PIXEL
            buf << "${GLSL_VERSION_DECL}\n"
                   "${GLSL_EXTENSION}\n"
                   "in highp vec4 v_position;\n"
                   "layout(location = 0) out mediump vec4 fragColor;\n"
                   "void main (void)\n"
                   "{\n"
                   "    highp vec2 relPosition = (v_position.xy + vec2(1.0, 1.0)) / 2.0;\n"
                   "    highp ivec2 pixelPos = ivec2(floor(relPosition * "
                << (int)RENDER_SIZE
                << ".0));\n"
                   "    highp int selectedID = abs(pixelPos.x + 17 * pixelPos.y) % "
                << numTargetSamples
                << ";\n"
                   "\n"
                   "    if (gl_SampleID == selectedID)\n"
                   "        fragColor = vec4(0.0, 1.0, 1.0, 1.0);\n"
                   "    else\n"
                   "        fragColor = vec4(0.0, 0.0, 1.0, 1.0);\n"
                   "}\n";
        }
    }
    else
        DE_ASSERT(false);

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool SampleIDCase::verifyImage(const tcu::Surface &resultImage)
{
    if (m_vericationMode == VERIFY_USING_SAMPLES)
    {
        // never happens
        DE_ASSERT(false);
        return false;
    }
    else if (m_vericationMode == VERIFY_USING_SELECTION)
    {
        // should result in full blue and some green everywhere
        return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), FullBlueSomeGreenVerifier());
    }
    else
    {
        DE_ASSERT(false);
        return false;
    }
}

bool SampleIDCase::verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers)
{
    // Verify all sample buffers
    bool allOk = true;

    // Log layers
    {
        m_testCtx.getLog() << tcu::TestLog::ImageSet("SampleBuffers", "Image sample buffers");
        for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
            m_testCtx.getLog() << tcu::TestLog::Image("Buffer" + de::toString(sampleNdx),
                                                      "Sample " + de::toString(sampleNdx),
                                                      resultBuffers[sampleNdx].getAccess());
        m_testCtx.getLog() << tcu::TestLog::EndImageSet;
    }

    m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample buffers" << tcu::TestLog::EndMessage;
    for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
    {
        // sample id should be sample index
        const int threshold       = 255 / 4 / m_numTargetSamples + 1;
        const float sampleIdColor = (float)sampleNdx / (float)m_numTargetSamples;

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample " << (sampleNdx + 1) << "/"
                           << (int)resultBuffers.size() << tcu::TestLog::EndMessage;
        allOk &= verifyImageWithVerifier(
            resultBuffers[sampleNdx], m_testCtx.getLog(),
            ColorVerifier(tcu::Vec3(0.0f, sampleIdColor, 1.0f), tcu::IVec3(1, threshold, 1)), false);
    }

    if (!allOk)
        m_testCtx.getLog() << tcu::TestLog::Message << "Sample buffer verification failed" << tcu::TestLog::EndMessage;

    return allOk;
}

class SamplePosDistributionCase : public MultisampleRenderCase
{
public:
    SamplePosDistributionCase(Context &context, const char *name, const char *desc, int sampleCount,
                              RenderTarget target);
    ~SamplePosDistributionCase(void);

    void init(void);

private:
    enum
    {
        RENDER_SIZE = 64
    };

    std::string genFragmentSource(int numTargetSamples) const;
    bool verifyImage(const tcu::Surface &resultImage);
    bool verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers);
};

SamplePosDistributionCase::SamplePosDistributionCase(Context &context, const char *name, const char *desc,
                                                     int sampleCount, RenderTarget target)
    : MultisampleRenderCase(context, name, desc, sampleCount, target, RENDER_SIZE,
                            MultisampleShaderRenderUtil::MultisampleRenderCase::FLAG_VERIFY_MSAA_TEXTURE_SAMPLE_BUFFERS)
{
}

SamplePosDistributionCase::~SamplePosDistributionCase(void)
{
}

void SamplePosDistributionCase::init(void)
{
    // log the test method and expectations
    if (m_renderTarget == TARGET_TEXTURE)
    {
        m_testCtx.getLog()
            << tcu::TestLog::Message << "Verifying gl_SamplePosition value:\n"
            << "    1) With non-multisample targets: Expect the center of the pixel.\n"
            << "    2) With multisample targets:\n"
            << "        a) Expect legal sample position.\n"
            << "        b) Sample position is unique within the set of all sample positions of a pixel.\n"
            << "        c) Sample position distribution is uniform or almost uniform.\n"
            << tcu::TestLog::EndMessage;
    }
    else
    {
        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying gl_SamplePosition value:\n"
                           << "    1) With non-multisample targets: Expect the center of the pixel.\n"
                           << "    2) With multisample targets:\n"
                           << "        a) Expect legal sample position.\n"
                           << "        b) Sample position distribution is uniform or almost uniform.\n"
                           << tcu::TestLog::EndMessage;
    }

    MultisampleRenderCase::init();
}

std::string SamplePosDistributionCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);
    DE_UNREF(numTargetSamples);

    const bool multisampleTarget = (m_numRequestedSamples > 0) || (m_renderTarget == TARGET_DEFAULT &&
                                                                   m_context.getRenderTarget().getNumSamples() > 1);
    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = (supportsES32orGL45) ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                       getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = (supportsES32orGL45) ? "\n" : "#extension GL_OES_sample_variables : require\n";

    if (multisampleTarget)
    {
        // encode the position to the output, use red channel as error channel
        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "void main (void)\n"
               "{\n"
               "    if (gl_SamplePosition.x < 0.0 || gl_SamplePosition.x > 1.0 || gl_SamplePosition.y < 0.0 || "
               "gl_SamplePosition.y > 1.0)\n"
               "        fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
               "    else\n"
               "        fragColor = vec4(0.0, gl_SamplePosition.x, gl_SamplePosition.y, 1.0);\n"
               "}\n";
    }
    else
    {
        // verify value is ok
        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "void main (void)\n"
               "{\n"
               "    if (gl_SamplePosition.x != 0.5 || gl_SamplePosition.y != 0.5)\n"
               "        fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
               "    else\n"
               "        fragColor = vec4(0.0, gl_SamplePosition.x, gl_SamplePosition.y, 1.0);\n"
               "}\n";
    }

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool SamplePosDistributionCase::verifyImage(const tcu::Surface &resultImage)
{
    const int sampleCount =
        (m_renderTarget == TARGET_DEFAULT) ? (m_context.getRenderTarget().getNumSamples()) : (m_numRequestedSamples);
    SampleAverageVerifier verifier(sampleCount);

    // check there is nothing in the error channel
    if (!verifyImageWithVerifier(resultImage, m_testCtx.getLog(), NoRedVerifier()))
        return false;

    // position average should be around 0.5, 0.5
    if (verifier.m_isStatisticallySignificant && !verifyImageWithVerifier(resultImage, m_testCtx.getLog(), verifier))
        throw MultisampleShaderRenderUtil::QualityWarning(
            "Bias detected, sample positions are not uniformly distributed within the pixel");

    return true;
}

bool SamplePosDistributionCase::verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers)
{
    const int width       = resultBuffers[0].getWidth();
    const int height      = resultBuffers[0].getHeight();
    bool allOk            = true;
    bool distibutionError = false;

    // Check sample range, uniqueness, and distribution, log layers
    {
        m_testCtx.getLog() << tcu::TestLog::ImageSet("SampleBuffers", "Image sample buffers");
        for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
            m_testCtx.getLog() << tcu::TestLog::Image("Buffer" + de::toString(sampleNdx),
                                                      "Sample " + de::toString(sampleNdx),
                                                      resultBuffers[sampleNdx].getAccess());
        m_testCtx.getLog() << tcu::TestLog::EndImageSet;
    }

    // verify range
    {
        bool rangeOk = true;

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample position range" << tcu::TestLog::EndMessage;
        for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
        {
            // shader does the check, just check the shader error output (red)
            m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample " << (sampleNdx + 1) << "/"
                               << (int)resultBuffers.size() << tcu::TestLog::EndMessage;
            rangeOk &= verifyImageWithVerifier(resultBuffers[sampleNdx], m_testCtx.getLog(), NoRedVerifier(), false);
        }

        if (!rangeOk)
        {
            allOk = false;

            m_testCtx.getLog() << tcu::TestLog::Message << "Sample position verification failed."
                               << tcu::TestLog::EndMessage;
        }
    }

    // Verify uniqueness
    {
        bool uniquenessOk = true;
        tcu::Surface errorMask(width, height);
        std::vector<tcu::Vec2> samplePositions(resultBuffers.size());
        int printCount            = 0;
        const int printFloodLimit = 5;

        tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample position uniqueness."
                           << tcu::TestLog::EndMessage;

        for (int y = 0; y < height; ++y)
            for (int x = 0; x < width; ++x)
            {
                bool samplePosNotUnique = false;

                for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
                {
                    const tcu::RGBA color = resultBuffers[sampleNdx].getPixel(x, y);
                    samplePositions[sampleNdx] =
                        tcu::Vec2((float)color.getGreen() / 255.0f, (float)color.getBlue() / 255.0f);
                }

                // Just check there are no two samples with same positions
                for (int sampleNdxA = 0;
                     sampleNdxA < (int)resultBuffers.size() && (!samplePosNotUnique || printCount < printFloodLimit);
                     ++sampleNdxA)
                    for (int sampleNdxB = sampleNdxA + 1; sampleNdxB < (int)resultBuffers.size() &&
                                                          (!samplePosNotUnique || printCount < printFloodLimit);
                         ++sampleNdxB)
                    {
                        if (samplePositions[sampleNdxA] == samplePositions[sampleNdxB])
                        {
                            if (++printCount <= printFloodLimit)
                            {
                                m_testCtx.getLog() << tcu::TestLog::Message << "Pixel (" << x << ", " << y
                                                   << "): Samples " << sampleNdxA << " and " << sampleNdxB
                                                   << " have the same position." << tcu::TestLog::EndMessage;
                            }

                            samplePosNotUnique = true;
                            uniquenessOk       = false;
                            errorMask.setPixel(x, y, tcu::RGBA::red());
                        }
                    }
            }

        // end result
        if (!uniquenessOk)
        {
            if (printCount > printFloodLimit)
                m_testCtx.getLog() << tcu::TestLog::Message << "...\n"
                                   << "Omitted " << (printCount - printFloodLimit) << " error descriptions."
                                   << tcu::TestLog::EndMessage;

            m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed." << tcu::TestLog::EndMessage
                               << tcu::TestLog::ImageSet("Verification", "Image Verification")
                               << tcu::TestLog::Image("ErrorMask", "Error Mask", errorMask.getAccess())
                               << tcu::TestLog::EndImageSet;

            allOk = false;
        }
    }

    // check distribution
    {
        const SampleAverageVerifier verifier(m_numTargetSamples);
        tcu::Surface errorMask(width, height);
        int printCount            = 0;
        const int printFloodLimit = 5;

        tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));

        // don't bother with small sample counts
        if (verifier.m_isStatisticallySignificant)
        {
            m_testCtx.getLog() << tcu::TestLog::Message
                               << "Verifying sample position distribution is (nearly) unbiased."
                               << tcu::TestLog::EndMessage;
            verifier.logInfo(m_testCtx.getLog());

            for (int y = 0; y < height; ++y)
                for (int x = 0; x < width; ++x)
                {
                    tcu::IVec3 colorSum(0, 0, 0);

                    // color average

                    for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
                    {
                        const tcu::RGBA color = resultBuffers[sampleNdx].getPixel(x, y);
                        colorSum.x() += color.getRed();
                        colorSum.y() += color.getBlue();
                        colorSum.z() += color.getGreen();
                    }

                    colorSum.x() /= m_numTargetSamples;
                    colorSum.y() /= m_numTargetSamples;
                    colorSum.z() /= m_numTargetSamples;

                    // verify average sample position

                    if (!verifier.verify(tcu::RGBA(colorSum.x(), colorSum.y(), colorSum.z(), 0), tcu::IVec2(x, y)))
                    {
                        if (++printCount <= printFloodLimit)
                        {
                            m_testCtx.getLog() << tcu::TestLog::Message << "Pixel (" << x << ", " << y
                                               << "): Sample distribution is biased." << tcu::TestLog::EndMessage;
                        }

                        distibutionError = true;
                        errorMask.setPixel(x, y, tcu::RGBA::red());
                    }
                }

            // sub-verification result
            if (distibutionError)
            {
                if (printCount > printFloodLimit)
                    m_testCtx.getLog() << tcu::TestLog::Message << "...\n"
                                       << "Omitted " << (printCount - printFloodLimit) << " error descriptions."
                                       << tcu::TestLog::EndMessage;

                m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed." << tcu::TestLog::EndMessage
                                   << tcu::TestLog::ImageSet("Verification", "Image Verification")
                                   << tcu::TestLog::Image("ErrorMask", "Error Mask", errorMask.getAccess())
                                   << tcu::TestLog::EndImageSet;
            }
        }
    }

    // results
    if (!allOk)
        return false;
    else if (distibutionError)
        throw MultisampleShaderRenderUtil::QualityWarning(
            "Bias detected, sample positions are not uniformly distributed within the pixel");
    else
    {
        m_testCtx.getLog() << tcu::TestLog::Message << "Verification ok." << tcu::TestLog::EndMessage;
        return true;
    }
}

class SamplePosCorrectnessCase : public MultisampleRenderCase
{
public:
    SamplePosCorrectnessCase(Context &context, const char *name, const char *desc, int sampleCount,
                             RenderTarget target);
    ~SamplePosCorrectnessCase(void);

    void init(void);

private:
    enum
    {
        RENDER_SIZE = 32
    };

    void preDraw(void);
    void postDraw(void);

    std::string genVertexSource(int numTargetSamples) const;
    std::string genFragmentSource(int numTargetSamples) const;
    bool verifyImage(const tcu::Surface &resultImage);

    bool m_useSampleQualifier;
};

SamplePosCorrectnessCase::SamplePosCorrectnessCase(Context &context, const char *name, const char *desc,
                                                   int sampleCount, RenderTarget target)
    : MultisampleRenderCase(context, name, desc, sampleCount, target, RENDER_SIZE)
    , m_useSampleQualifier(false)
{
}

SamplePosCorrectnessCase::~SamplePosCorrectnessCase(void)
{
}

void SamplePosCorrectnessCase::init(void)
{
    auto ctxType            = m_context.getRenderContext().getType();
    const bool isES32orGL45 = glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
                              glu::contextSupports(ctxType, glu::ApiType::core(4, 5));

    // requirements: per-invocation interpolation required
    if (!isES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") &&
        !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_shading"))
        TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation or GL_OES_sample_shading "
                                     "extension or a context version 3.2 or higher.");

    // prefer to use the sample qualifier path
    m_useSampleQualifier = m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation");

    // log the test method and expectations
    m_testCtx.getLog() << tcu::TestLog::Message << "Verifying gl_SamplePosition correctness:\n"
                       << "    1) Varying values should be sampled at the sample position.\n"
                       << " => fract(screenSpacePosition) == gl_SamplePosition\n"
                       << tcu::TestLog::EndMessage;

    MultisampleRenderCase::init();
}

void SamplePosCorrectnessCase::preDraw(void)
{
    if (!m_useSampleQualifier)
    {
        const glw::Functions &gl = m_context.getRenderContext().getFunctions();

        // use GL_OES_sample_shading to set per fragment sample invocation interpolation
        gl.enable(GL_SAMPLE_SHADING);
        gl.minSampleShading(1.0f);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set ratio");

        m_testCtx.getLog() << tcu::TestLog::Message << "Enabling per-sample interpolation with GL_SAMPLE_SHADING."
                           << tcu::TestLog::EndMessage;
    }
}

void SamplePosCorrectnessCase::postDraw(void)
{
    if (!m_useSampleQualifier)
    {
        const glw::Functions &gl = m_context.getRenderContext().getFunctions();

        gl.disable(GL_SAMPLE_SHADING);
        gl.minSampleShading(1.0f);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set ratio");
    }
}

std::string SamplePosCorrectnessCase::genVertexSource(int numTargetSamples) const
{
    DE_UNREF(numTargetSamples);
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));

    std::ostringstream buf;
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                     getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = supportsES32orGL45   ? "" :
                                m_useSampleQualifier ? "#extension GL_OES_shader_multisample_interpolation : require" :
                                                       "";

    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_EXTENSION}\n"
        << "in highp vec4 a_position;\n"
        << ((m_useSampleQualifier) ? ("sample ") : (""))
        << "out highp vec4 v_position;\n"
           "void main (void)\n"
           "{\n"
           "    gl_Position = a_position;\n"
           "    v_position = a_position;\n"
           "}\n";

    return tcu::StringTemplate(buf.str()).specialize(args);
}

std::string SamplePosCorrectnessCase::genFragmentSource(int numTargetSamples) const
{
    DE_UNREF(numTargetSamples);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"]     = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                         getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_SAMPLE_EXTENSION"] = supportsES32orGL45 ? "" : "#extension GL_OES_sample_variables : require";
    args["GLSL_MULTISAMPLE_EXTENSION"] =
        supportsES32orGL45   ? "" :
        m_useSampleQualifier ? "#extension GL_OES_shader_multisample_interpolation : require" :
                               "";

    // encode the position to the output, use red channel as error channel
    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_SAMPLE_EXTENSION}\n"
           "${GLSL_MULTISAMPLE_EXTENSION}\n"
        << ((m_useSampleQualifier) ? ("sample ") : (""))
        << "in highp vec4 v_position;\n"
           "layout(location = 0) out mediump vec4 fragColor;\n"
           "void main (void)\n"
           "{\n"
           "    const highp float maxDistance = 0.15625; // 4 subpixel bits. Assume 3 accurate bits + 0.03125 for "
           "other errors\n" // 0.03125 = mediump epsilon when value = 32 (RENDER_SIZE)
           "\n"
           "    highp vec2 screenSpacePosition = (v_position.xy + vec2(1.0, 1.0)) / 2.0 * "
        << (int)RENDER_SIZE
        << ".0;\n"
           "    highp ivec2 nearbyPixel = ivec2(floor(screenSpacePosition));\n"
           "    bool allOk = false;\n"
           "\n"
           "    // sample at edge + inaccuaries may cause us to round to any neighboring pixel\n"
           "    // check all neighbors for any match\n"
           "    for (highp int dy = -1; dy <= 1; ++dy)\n"
           "    for (highp int dx = -1; dx <= 1; ++dx)\n"
           "    {\n"
           "        highp ivec2 currentPixel = nearbyPixel + ivec2(dx, dy);\n"
           "        highp vec2 candidateSamplingPos = vec2(currentPixel) + gl_SamplePosition.xy;\n"
           "        highp vec2 positionDiff = abs(candidateSamplingPos - screenSpacePosition);\n"
           "        if (positionDiff.x < maxDistance && positionDiff.y < maxDistance)\n"
           "            allOk = true;\n"
           "    }\n"
           "\n"
           "    if (allOk)\n"
           "        fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
           "    else\n"
           "        fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
           "}\n";

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool SamplePosCorrectnessCase::verifyImage(const tcu::Surface &resultImage)
{
    return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), NoRedVerifier());
}

class SampleMaskBaseCase : public MultisampleRenderCase
{
public:
    enum ShaderRunMode
    {
        RUN_PER_PIXEL = 0,
        RUN_PER_SAMPLE,
        RUN_PER_TWO_SAMPLES,

        RUN_LAST
    };

    SampleMaskBaseCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target,
                       int renderSize, ShaderRunMode runMode, int flags = 0);
    virtual ~SampleMaskBaseCase(void);

protected:
    virtual void init(void);
    virtual void preDraw(void);
    virtual void postDraw(void);
    virtual bool verifyImage(const tcu::Surface &resultImage);

    const ShaderRunMode m_runMode;
};

SampleMaskBaseCase::SampleMaskBaseCase(Context &context, const char *name, const char *desc, int sampleCount,
                                       RenderTarget target, int renderSize, ShaderRunMode runMode, int flags)
    : MultisampleRenderCase(context, name, desc, sampleCount, target, renderSize, flags)
    , m_runMode(runMode)
{
    DE_ASSERT(runMode < RUN_LAST);
}

SampleMaskBaseCase::~SampleMaskBaseCase(void)
{
}

void SampleMaskBaseCase::init(void)
{
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    // required extra extension
    if (m_runMode == RUN_PER_TWO_SAMPLES && !supportsES32orGL45 &&
        !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_shading"))
        TCU_THROW(NotSupportedError,
                  "Test requires GL_OES_sample_shading extension or a context version 3.2 or higher.");

    MultisampleRenderCase::init();
}

void SampleMaskBaseCase::preDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    if (m_runMode == RUN_PER_TWO_SAMPLES)
    {
        gl.enable(GL_SAMPLE_SHADING);
        gl.minSampleShading(0.5f);
        GLU_EXPECT_NO_ERROR(gl.getError(), "enable sample shading");

        m_testCtx.getLog() << tcu::TestLog::Message << "Enabled GL_SAMPLE_SHADING, value = 0.5"
                           << tcu::TestLog::EndMessage;
    }
}

void SampleMaskBaseCase::postDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    if (m_runMode == RUN_PER_TWO_SAMPLES)
    {
        gl.disable(GL_SAMPLE_SHADING);
        gl.minSampleShading(1.0f);
        GLU_EXPECT_NO_ERROR(gl.getError(), "disable sample shading");
    }
}

bool SampleMaskBaseCase::verifyImage(const tcu::Surface &resultImage)
{
    // shader does the verification
    return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), NoRedVerifier());
}

class SampleMaskCase : public SampleMaskBaseCase
{
public:
    SampleMaskCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target);
    ~SampleMaskCase(void);

    void init(void);
    void preDraw(void);
    void postDraw(void);

private:
    enum
    {
        RENDER_SIZE = 64
    };

    std::string genFragmentSource(int numTargetSamples) const;
};

SampleMaskCase::SampleMaskCase(Context &context, const char *name, const char *desc, int sampleCount,
                               RenderTarget target)
    : SampleMaskBaseCase(context, name, desc, sampleCount, target, RENDER_SIZE, RUN_PER_PIXEL)
{
}

SampleMaskCase::~SampleMaskCase(void)
{
}

void SampleMaskCase::init(void)
{
    // log the test method and expectations
    m_testCtx.getLog()
        << tcu::TestLog::Message
        << "Verifying gl_SampleMaskIn value with SAMPLE_MASK state. gl_SampleMaskIn does not contain any bits set that "
           "are have been killed by SAMPLE_MASK state. Expecting:\n"
        << "    1) With multisample targets: gl_SampleMaskIn AND ~(SAMPLE_MASK) should be zero.\n"
        << "    2) With non-multisample targets: SAMPLE_MASK state is only ANDed as a multisample operation. "
           "gl_SampleMaskIn should only have its last bit set regardless of SAMPLE_MASK state.\n"
        << tcu::TestLog::EndMessage;

    SampleMaskBaseCase::init();
}

void SampleMaskCase::preDraw(void)
{
    const glw::Functions &gl     = m_context.getRenderContext().getFunctions();
    const bool multisampleTarget = (m_numRequestedSamples > 0) || (m_renderTarget == TARGET_DEFAULT &&
                                                                   m_context.getRenderTarget().getNumSamples() > 1);
    const uint32_t fullMask      = (uint32_t)0xAAAAAAAAUL;
    const uint32_t maskMask      = (1U << m_numTargetSamples) - 1;
    const uint32_t effectiveMask = fullMask & maskMask;

    // set test mask
    gl.enable(GL_SAMPLE_MASK);
    gl.sampleMaski(0, effectiveMask);
    GLU_EXPECT_NO_ERROR(gl.getError(), "set mask");

    m_testCtx.getLog() << tcu::TestLog::Message << "Setting sample mask " << tcu::Format::Hex<4>(effectiveMask)
                       << tcu::TestLog::EndMessage;

    // set multisample case uniforms
    if (multisampleTarget)
    {
        const int maskLoc = gl.getUniformLocation(m_program->getProgram(), "u_sampleMask");
        if (maskLoc == -1)
            throw tcu::TestError("Location of u_mask was -1");

        gl.uniform1ui(maskLoc, effectiveMask);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set mask uniform");
    }

    // base class logic
    SampleMaskBaseCase::preDraw();
}

void SampleMaskCase::postDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    const uint32_t fullMask  = (1U << m_numTargetSamples) - 1;

    gl.disable(GL_SAMPLE_MASK);
    gl.sampleMaski(0, fullMask);
    GLU_EXPECT_NO_ERROR(gl.getError(), "set mask");

    // base class logic
    SampleMaskBaseCase::postDraw();
}

std::string SampleMaskCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);

    const bool multisampleTarget = (m_numRequestedSamples > 0) || (m_renderTarget == TARGET_DEFAULT &&
                                                                   m_context.getRenderTarget().getNumSamples() > 1);
    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                     getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = supportsES32orGL45 ? "" : "#extension GL_OES_sample_variables : require";

    // test supports only one sample mask word
    if (numTargetSamples > 32)
        TCU_THROW(NotSupportedError, "Sample count larger than 32 is not supported.");

    if (multisampleTarget)
    {
        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "uniform highp uint u_sampleMask;\n"
               "void main (void)\n"
               "{\n"
               "    if ((uint(gl_SampleMaskIn[0]) & (~u_sampleMask)) != 0u)\n"
               "        fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
               "    else\n"
               "        fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
               "}\n";
    }
    else
    {
        // non-multisample targets don't get multisample operations like ANDing with mask

        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "uniform highp uint u_sampleMask;\n"
               "void main (void)\n"
               "{\n"
               "    if (gl_SampleMaskIn[0] != 1)\n"
               "        fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
               "    else\n"
               "        fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
               "}\n";
    }

    return tcu::StringTemplate(buf.str()).specialize(args);
}

class SampleMaskCountCase : public SampleMaskBaseCase
{
public:
    SampleMaskCountCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target,
                        ShaderRunMode runMode);
    ~SampleMaskCountCase(void);

    void init(void);
    void preDraw(void);
    void postDraw(void);

private:
    enum
    {
        RENDER_SIZE = 64
    };

    std::string genFragmentSource(int numTargetSamples) const;
};

SampleMaskCountCase::SampleMaskCountCase(Context &context, const char *name, const char *desc, int sampleCount,
                                         RenderTarget target, ShaderRunMode runMode)
    : SampleMaskBaseCase(context, name, desc, sampleCount, target, RENDER_SIZE, runMode)
{
    DE_ASSERT(runMode < RUN_LAST);
}

SampleMaskCountCase::~SampleMaskCountCase(void)
{
}

void SampleMaskCountCase::init(void)
{
    // log the test method and expectations
    if (m_runMode == RUN_PER_PIXEL)
        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying gl_SampleMaskIn.\n"
                           << "    Fragment shader may be invoked [1, numSamples] times.\n"
                           << " => gl_SampleMaskIn should have the number of bits set in range [1, numSamples]\n"
                           << tcu::TestLog::EndMessage;
    else if (m_runMode == RUN_PER_SAMPLE)
        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying gl_SampleMaskIn.\n"
                           << "    Fragment will be invoked numSamples times.\n"
                           << " => gl_SampleMaskIn should have only one bit set.\n"
                           << tcu::TestLog::EndMessage;
    else if (m_runMode == RUN_PER_TWO_SAMPLES)
        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying gl_SampleMaskIn.\n"
                           << "    Fragment shader may be invoked [ceil(numSamples/2), numSamples] times.\n"
                           << " => gl_SampleMaskIn should have the number of bits set in range [1, numSamples - "
                              "ceil(numSamples/2) + 1]:\n"
                           << tcu::TestLog::EndMessage;
    else
        DE_ASSERT(false);

    SampleMaskBaseCase::init();
}

void SampleMaskCountCase::preDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    if (m_runMode == RUN_PER_PIXEL)
    {
        const int maxLoc      = gl.getUniformLocation(m_program->getProgram(), "u_maxBitCount");
        const int minLoc      = gl.getUniformLocation(m_program->getProgram(), "u_minBitCount");
        const int minBitCount = 1;
        const int maxBitCount = m_numTargetSamples;

        if (maxLoc == -1)
            throw tcu::TestError("Location of u_maxBitCount was -1");
        if (minLoc == -1)
            throw tcu::TestError("Location of u_minBitCount was -1");

        gl.uniform1i(minLoc, minBitCount);
        gl.uniform1i(maxLoc, maxBitCount);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set limits");

        m_testCtx.getLog() << tcu::TestLog::Message << "Setting minBitCount = " << minBitCount
                           << ", maxBitCount = " << maxBitCount << tcu::TestLog::EndMessage;
    }
    else if (m_runMode == RUN_PER_TWO_SAMPLES)
    {
        const int maxLoc = gl.getUniformLocation(m_program->getProgram(), "u_maxBitCount");
        const int minLoc = gl.getUniformLocation(m_program->getProgram(), "u_minBitCount");

        // Worst case: all but one shader invocations get one sample, one shader invocation the rest of the samples
        const int minInvocationCount = ((m_numTargetSamples + 1) / 2);
        const int minBitCount        = 1;
        const int maxBitCount        = m_numTargetSamples - ((minInvocationCount - 1) * minBitCount);

        if (maxLoc == -1)
            throw tcu::TestError("Location of u_maxBitCount was -1");
        if (minLoc == -1)
            throw tcu::TestError("Location of u_minBitCount was -1");

        gl.uniform1i(minLoc, minBitCount);
        gl.uniform1i(maxLoc, maxBitCount);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set limits");

        m_testCtx.getLog() << tcu::TestLog::Message << "Setting minBitCount = " << minBitCount
                           << ", maxBitCount = " << maxBitCount << tcu::TestLog::EndMessage;
    }

    SampleMaskBaseCase::preDraw();
}

void SampleMaskCountCase::postDraw(void)
{
    SampleMaskBaseCase::postDraw();
}

std::string SampleMaskCountCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                     getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = supportsES32orGL45 ? "" : "#extension GL_OES_sample_variables : require";

    // test supports only one sample mask word
    if (numTargetSamples > 32)
        TCU_THROW(NotSupportedError, "Sample count larger than 32 is not supported.");

    // count the number of the bits in gl_SampleMask

    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_EXTENSION}\n"
           "layout(location = 0) out mediump vec4 fragColor;\n";

    if (m_runMode != RUN_PER_SAMPLE)
        buf << "uniform highp int u_minBitCount;\n"
               "uniform highp int u_maxBitCount;\n";

    buf << "void main (void)\n"
           "{\n"
           "    mediump int maskBitCount = 0;\n"
           "    for (int i = 0; i < 32; ++i)\n"
           "        if (((gl_SampleMaskIn[0] >> i) & 0x01) == 0x01)\n"
           "            ++maskBitCount;\n"
           "\n";

    if (m_runMode == RUN_PER_SAMPLE)
    {
        // check the validity here
        buf << "    // force per-sample shading\n"
               "    highp float blue = float(gl_SampleID);\n"
               "\n"
               "    if (maskBitCount != 1)\n"
               "        fragColor = vec4(1.0, 0.0, blue, 1.0);\n"
               "    else\n"
               "        fragColor = vec4(0.0, 1.0, blue, 1.0);\n"
               "}\n";
    }
    else
    {
        // check the validity here
        buf << "    if (maskBitCount < u_minBitCount || maskBitCount > u_maxBitCount)\n"
               "        fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
               "    else\n"
               "        fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
               "}\n";
    }

    return tcu::StringTemplate(buf.str()).specialize(args);
}

class SampleMaskUniqueCase : public SampleMaskBaseCase
{
public:
    SampleMaskUniqueCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target,
                         ShaderRunMode runMode);
    ~SampleMaskUniqueCase(void);

    void init(void);

private:
    enum
    {
        RENDER_SIZE = 64
    };

    std::string genFragmentSource(int numTargetSamples) const;
    bool verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers);
};

SampleMaskUniqueCase::SampleMaskUniqueCase(Context &context, const char *name, const char *desc, int sampleCount,
                                           RenderTarget target, ShaderRunMode runMode)
    : SampleMaskBaseCase(context, name, desc, sampleCount, target, RENDER_SIZE, runMode,
                         MultisampleShaderRenderUtil::MultisampleRenderCase::FLAG_VERIFY_MSAA_TEXTURE_SAMPLE_BUFFERS)
{
    DE_ASSERT(runMode == RUN_PER_SAMPLE);
    DE_ASSERT(target == TARGET_TEXTURE);
}

SampleMaskUniqueCase::~SampleMaskUniqueCase(void)
{
}

void SampleMaskUniqueCase::init(void)
{
    // log the test method and expectations
    m_testCtx.getLog()
        << tcu::TestLog::Message << "Verifying gl_SampleMaskIn.\n"
        << "    Fragment will be invoked numSamples times.\n"
        << " => gl_SampleMaskIn should have only one bit set\n"
        << " => and that bit index should be unique within other fragment shader invocations of that pixel.\n"
        << "    Writing sampleMask bit index to green channel in render shader. Verifying uniqueness in sampler "
           "shader.\n"
        << tcu::TestLog::EndMessage;

    SampleMaskBaseCase::init();
}

std::string SampleMaskUniqueCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                     getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = supportsES32orGL45 ? "" : "#extension GL_OES_sample_variables : require";

    // test supports only one sample mask word
    if (numTargetSamples > 32)
        TCU_THROW(NotSupportedError, "Sample count larger than 32 is not supported.");

    // find our sampleID by searching for unique bit.
    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_EXTENSION}\n"
           "layout(location = 0) out mediump vec4 fragColor;\n"
           "void main (void)\n"
           "{\n"
           "    mediump int firstIndex = -1;\n"
           "    for (int i = 0; i < 32; ++i)\n"
           "    {\n"
           "        if (((gl_SampleMaskIn[0] >> i) & 0x01) == 0x01)\n"
           "        {\n"
           "            firstIndex = i;\n"
           "            break;\n"
           "        }\n"
           "    }\n"
           "\n"
           "    bool notUniqueError = false;\n"
           "    for (int i = firstIndex + 1; i < 32; ++i)\n"
           "        if (((gl_SampleMaskIn[0] >> i) & 0x01) == 0x01)\n"
           "            notUniqueError = true;\n"
           "\n"
           "    highp float encodedSampleId = float(firstIndex) / "
        << numTargetSamples
        << ".0;\n"
           "\n"
           "    // force per-sample shading\n"
           "    highp float blue = float(gl_SampleID);\n"
           "\n"
           "    if (notUniqueError)\n"
           "        fragColor = vec4(1.0, 0.0, blue, 1.0);\n"
           "    else\n"
           "        fragColor = vec4(0.0, encodedSampleId, blue, 1.0);\n"
           "}\n";

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool SampleMaskUniqueCase::verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers)
{
    const int width  = resultBuffers[0].getWidth();
    const int height = resultBuffers[0].getHeight();
    bool allOk       = true;

    // Log samples
    {
        m_testCtx.getLog() << tcu::TestLog::ImageSet("SampleBuffers", "Image sample buffers");
        for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
            m_testCtx.getLog() << tcu::TestLog::Image("Buffer" + de::toString(sampleNdx),
                                                      "Sample " + de::toString(sampleNdx),
                                                      resultBuffers[sampleNdx].getAccess());
        m_testCtx.getLog() << tcu::TestLog::EndImageSet;
    }

    // check for earlier errors (in fragment shader)
    {
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Verifying fragment shader invocation found only one set sample mask bit."
                           << tcu::TestLog::EndMessage;

        for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
        {
            // shader does the check, just check the shader error output (red)
            m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample " << (sampleNdx + 1) << "/"
                               << (int)resultBuffers.size() << tcu::TestLog::EndMessage;
            allOk &= verifyImageWithVerifier(resultBuffers[sampleNdx], m_testCtx.getLog(), NoRedVerifier(), false);
        }

        if (!allOk)
        {
            // can't check the uniqueness if the masks don't work at all
            m_testCtx.getLog()
                << tcu::TestLog::Message
                << "Could not get mask information from the rendered image, cannot continue verification."
                << tcu::TestLog::EndMessage;
            return false;
        }
    }

    // verify index / index ranges

    if (m_numRequestedSamples == 0)
    {
        // single sample target, expect index=0

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample mask bit index is 0."
                           << tcu::TestLog::EndMessage;

        // only check the mask index
        allOk &= verifyImageWithVerifier(resultBuffers[0], m_testCtx.getLog(),
                                         ColorVerifier(tcu::Vec3(0.0f, 0.0f, 0.0f), tcu::IVec3(255, 8, 255)), false);
    }
    else
    {
        // check uniqueness

        tcu::Surface errorMask(width, height);
        bool uniquenessOk         = true;
        int printCount            = 0;
        const int printFloodLimit = 5;
        std::vector<int> maskBitIndices(resultBuffers.size());

        tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying per-invocation sample mask bit is unique."
                           << tcu::TestLog::EndMessage;

        for (int y = 0; y < height; ++y)
            for (int x = 0; x < width; ++x)
            {
                bool maskNdxNotUnique = false;

                // decode index
                for (int sampleNdx = 0; sampleNdx < (int)resultBuffers.size(); ++sampleNdx)
                {
                    const tcu::RGBA color = resultBuffers[sampleNdx].getPixel(x, y);
                    maskBitIndices[sampleNdx] =
                        (int)deFloatRound((float)color.getGreen() / 255.0f * (float)m_numTargetSamples);
                }

                // just check there are no two invocations with the same bit index
                for (int sampleNdxA = 0;
                     sampleNdxA < (int)resultBuffers.size() && (!maskNdxNotUnique || printCount < printFloodLimit);
                     ++sampleNdxA)
                    for (int sampleNdxB = sampleNdxA + 1;
                         sampleNdxB < (int)resultBuffers.size() && (!maskNdxNotUnique || printCount < printFloodLimit);
                         ++sampleNdxB)
                    {
                        if (maskBitIndices[sampleNdxA] == maskBitIndices[sampleNdxB])
                        {
                            if (++printCount <= printFloodLimit)
                            {
                                m_testCtx.getLog() << tcu::TestLog::Message << "Pixel (" << x << ", " << y
                                                   << "): Samples " << sampleNdxA << " and " << sampleNdxB
                                                   << " have the same sample mask. (Single bit at index "
                                                   << maskBitIndices[sampleNdxA] << ")" << tcu::TestLog::EndMessage;
                            }

                            maskNdxNotUnique = true;
                            uniquenessOk     = false;
                            errorMask.setPixel(x, y, tcu::RGBA::red());
                        }
                    }
            }

        // end result
        if (!uniquenessOk)
        {
            if (printCount > printFloodLimit)
                m_testCtx.getLog() << tcu::TestLog::Message << "...\n"
                                   << "Omitted " << (printCount - printFloodLimit) << " error descriptions."
                                   << tcu::TestLog::EndMessage;

            m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed." << tcu::TestLog::EndMessage
                               << tcu::TestLog::ImageSet("Verification", "Image Verification")
                               << tcu::TestLog::Image("ErrorMask", "Error Mask", errorMask.getAccess())
                               << tcu::TestLog::EndImageSet;

            allOk = false;
        }
    }

    return allOk;
}

class SampleMaskUniqueSetCase : public SampleMaskBaseCase
{
public:
    SampleMaskUniqueSetCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target,
                            ShaderRunMode runMode);
    ~SampleMaskUniqueSetCase(void);

    void init(void);
    void deinit(void);

private:
    enum
    {
        RENDER_SIZE = 64
    };

    void preDraw(void);
    void postDraw(void);
    std::string genFragmentSource(int numTargetSamples) const;
    bool verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers);
    std::string getIterationDescription(int iteration) const;

    void preTest(void);
    void postTest(void);

    std::vector<tcu::Surface> m_iterationSampleBuffers;
};

SampleMaskUniqueSetCase::SampleMaskUniqueSetCase(Context &context, const char *name, const char *desc, int sampleCount,
                                                 RenderTarget target, ShaderRunMode runMode)
    : SampleMaskBaseCase(context, name, desc, sampleCount, target, RENDER_SIZE, runMode,
                         MultisampleShaderRenderUtil::MultisampleRenderCase::FLAG_VERIFY_MSAA_TEXTURE_SAMPLE_BUFFERS)
{
    DE_ASSERT(runMode == RUN_PER_TWO_SAMPLES);
    DE_ASSERT(target == TARGET_TEXTURE);

    // high and low bits
    m_numIterations = 2;
}

SampleMaskUniqueSetCase::~SampleMaskUniqueSetCase(void)
{
}

void SampleMaskUniqueSetCase::init(void)
{
    // log the test method and expectations
    m_testCtx.getLog() << tcu::TestLog::Message << "Verifying gl_SampleMaskIn.\n"
                       << "    Fragment shader may be invoked [ceil(numSamples/2), numSamples] times.\n"
                       << " => Each invocation should have unique bit set\n"
                       << "    Writing highest and lowest bit index to color channels in render shader. Verifying:\n"
                       << "        1) no other invocation contains these bits in sampler shader.\n"
                       << "        2) number of invocations is at least ceil(numSamples/2).\n"
                       << tcu::TestLog::EndMessage;

    SampleMaskBaseCase::init();
}

void SampleMaskUniqueSetCase::deinit(void)
{
    m_iterationSampleBuffers.clear();
}

void SampleMaskUniqueSetCase::preDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    const int selectorLoc    = gl.getUniformLocation(m_program->getProgram(), "u_bitSelector");

    gl.uniform1ui(selectorLoc, (uint32_t)m_iteration);
    GLU_EXPECT_NO_ERROR(gl.getError(), "set u_bitSelector");

    m_testCtx.getLog() << tcu::TestLog::Message << "Setting u_bitSelector = " << m_iteration
                       << tcu::TestLog::EndMessage;

    SampleMaskBaseCase::preDraw();
}

void SampleMaskUniqueSetCase::postDraw(void)
{
    SampleMaskBaseCase::postDraw();
}

std::string SampleMaskUniqueSetCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                     getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = supportsES32orGL45 ? "" : "#extension GL_OES_sample_variables : require";

    // test supports only one sample mask word
    if (numTargetSamples > 32)
        TCU_THROW(NotSupportedError, "Sample count larger than 32 is not supported.");

    // output min and max sample id
    buf << "${GLSL_VERSION_DECL}\n"
           "${GLSL_EXTENSION}\n"
           "uniform highp uint u_bitSelector;\n"
           "layout(location = 0) out mediump vec4 fragColor;\n"
           "void main (void)\n"
           "{\n"
           "    highp int selectedBits;\n"
           "    if (u_bitSelector == 0u)\n"
           "        selectedBits = (gl_SampleMaskIn[0] & 0xFFFF);\n"
           "    else\n"
           "        selectedBits = ((gl_SampleMaskIn[0] >> 16) & 0xFFFF);\n"
           "\n"
           "    // encode bits to color\n"
           "    highp int redBits = selectedBits & 31;\n"
           "    highp int greenBits = (selectedBits >> 5) & 63;\n"
           "    highp int blueBits = (selectedBits >> 11) & 31;\n"
           "\n"
           "    fragColor = vec4(float(redBits) / float(31), float(greenBits) / float(63), float(blueBits) / "
           "float(31), 1.0);\n"
           "}\n";

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool SampleMaskUniqueSetCase::verifySampleBuffers(const std::vector<tcu::Surface> &resultBuffers)
{
    // we need results from all passes to do verification. Store results and verify later (at postTest).

    DE_ASSERT(m_numTargetSamples == (int)resultBuffers.size());
    for (int ndx = 0; ndx < m_numTargetSamples; ++ndx)
        m_iterationSampleBuffers[m_iteration * m_numTargetSamples + ndx] = resultBuffers[ndx];

    return true;
}

std::string SampleMaskUniqueSetCase::getIterationDescription(int iteration) const
{
    if (iteration == 0)
        return "Reading low bits";
    else if (iteration == 1)
        return "Reading high bits";
    else
        DE_ASSERT(false);
    return "";
}

void SampleMaskUniqueSetCase::preTest(void)
{
    m_iterationSampleBuffers.resize(m_numTargetSamples * 2);
}

void SampleMaskUniqueSetCase::postTest(void)
{
    DE_ASSERT((m_iterationSampleBuffers.size() % 2) == 0);
    DE_ASSERT((int)m_iterationSampleBuffers.size() / 2 == m_numTargetSamples);

    const int width  = m_iterationSampleBuffers[0].getWidth();
    const int height = m_iterationSampleBuffers[0].getHeight();
    bool allOk       = true;
    std::vector<tcu::TextureLevel> sampleCoverage(m_numTargetSamples);
    const tcu::ScopedLogSection section(m_testCtx.getLog(), "Verify", "Verify masks");

    // convert color layers to 32 bit coverage masks, 2 passes per coverage

    for (int sampleNdx = 0; sampleNdx < (int)sampleCoverage.size(); ++sampleNdx)
    {
        sampleCoverage[sampleNdx].setStorage(
            tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32), width, height);

        for (int y = 0; y < height; ++y)
            for (int x = 0; x < width; ++x)
            {
                const tcu::RGBA lowColor = m_iterationSampleBuffers[sampleNdx].getPixel(x, y);
                const tcu::RGBA highColor =
                    m_iterationSampleBuffers[sampleNdx + (int)sampleCoverage.size()].getPixel(x, y);
                uint16_t low;
                uint16_t high;

                {
                    int redBits   = (int)deFloatRound((float)lowColor.getRed() / 255.0f * 31);
                    int greenBits = (int)deFloatRound((float)lowColor.getGreen() / 255.0f * 63);
                    int blueBits  = (int)deFloatRound((float)lowColor.getBlue() / 255.0f * 31);

                    low = (uint16_t)(redBits | (greenBits << 5) | (blueBits << 11));
                }
                {
                    int redBits   = (int)deFloatRound((float)highColor.getRed() / 255.0f * 31);
                    int greenBits = (int)deFloatRound((float)highColor.getGreen() / 255.0f * 63);
                    int blueBits  = (int)deFloatRound((float)highColor.getBlue() / 255.0f * 31);

                    high = (uint16_t)(redBits | (greenBits << 5) | (blueBits << 11));
                }

                sampleCoverage[sampleNdx].getAccess().setPixel(tcu::UVec4((((uint32_t)high) << 16) | low, 0, 0, 0), x,
                                                               y);
            }
    }

    // verify masks

    if (m_numRequestedSamples == 0)
    {
        // single sample target, expect mask = 0x01
        const int printFloodLimit = 5;
        int printCount            = 0;

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying sample mask is 0x00000001."
                           << tcu::TestLog::EndMessage;

        for (int y = 0; y < height; ++y)
            for (int x = 0; x < width; ++x)
            {
                uint32_t mask = sampleCoverage[0].getAccess().getPixelUint(x, y).x();
                if (mask != 0x01)
                {
                    allOk = false;

                    if (++printCount <= printFloodLimit)
                    {
                        m_testCtx.getLog()
                            << tcu::TestLog::Message << "Pixel (" << x << ", " << y << "): Invalid mask, got "
                            << tcu::Format::Hex<8>(mask) << ", expected " << tcu::Format::Hex<8>(0x01) << "\n"
                            << tcu::TestLog::EndMessage;
                    }
                }
            }

        if (!allOk && printCount > printFloodLimit)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "...\n"
                               << "Omitted " << (printCount - printFloodLimit) << " error descriptions."
                               << tcu::TestLog::EndMessage;
        }
    }
    else
    {
        // check uniqueness
        {
            bool uniquenessOk         = true;
            int printCount            = 0;
            const int printFloodLimit = 5;

            m_testCtx.getLog() << tcu::TestLog::Message << "Verifying invocation sample masks do not share bits."
                               << tcu::TestLog::EndMessage;

            for (int y = 0; y < height; ++y)
                for (int x = 0; x < width; ++x)
                {
                    bool maskBitsNotUnique = false;

                    for (int sampleNdxA = 0;
                         sampleNdxA < m_numTargetSamples && (!maskBitsNotUnique || printCount < printFloodLimit);
                         ++sampleNdxA)
                        for (int sampleNdxB = sampleNdxA + 1;
                             sampleNdxB < m_numTargetSamples && (!maskBitsNotUnique || printCount < printFloodLimit);
                             ++sampleNdxB)
                        {
                            const uint32_t maskA = sampleCoverage[sampleNdxA].getAccess().getPixelUint(x, y).x();
                            const uint32_t maskB = sampleCoverage[sampleNdxB].getAccess().getPixelUint(x, y).x();

                            // equal mask == emitted by the same invocation
                            if (maskA != maskB)
                            {
                                // shares samples?
                                if (maskA & maskB)
                                {
                                    maskBitsNotUnique = true;
                                    uniquenessOk      = false;

                                    if (++printCount <= printFloodLimit)
                                    {
                                        m_testCtx.getLog()
                                            << tcu::TestLog::Message << "Pixel (" << x << ", " << y << "):\n"
                                            << "\tSamples " << sampleNdxA << " and " << sampleNdxB
                                            << " share mask bits\n"
                                            << "\tMask" << sampleNdxA << " = " << tcu::Format::Hex<8>(maskA) << "\n"
                                            << "\tMask" << sampleNdxB << " = " << tcu::Format::Hex<8>(maskB) << "\n"
                                            << tcu::TestLog::EndMessage;
                                    }
                                }
                            }
                        }
                }

            if (!uniquenessOk)
            {
                allOk = false;

                if (printCount > printFloodLimit)
                    m_testCtx.getLog() << tcu::TestLog::Message << "...\n"
                                       << "Omitted " << (printCount - printFloodLimit) << " error descriptions."
                                       << tcu::TestLog::EndMessage;
            }
        }

        // check number of sample mask bit groups is valid ( == number of invocations )
        {
            const uint32_t minNumInvocations = (uint32_t)de::max(1, (m_numTargetSamples + 1) / 2);
            bool countOk                     = true;
            int printCount                   = 0;
            const int printFloodLimit        = 5;

            m_testCtx.getLog() << tcu::TestLog::Message
                               << "Verifying cardinality of separate sample mask bit sets. Expecting equal to the "
                                  "number of invocations, (greater or equal to "
                               << minNumInvocations << ")" << tcu::TestLog::EndMessage;

            for (int y = 0; y < height; ++y)
                for (int x = 0; x < width; ++x)
                {
                    std::set<uint32_t> masks;

                    for (int maskNdx = 0; maskNdx < m_numTargetSamples; ++maskNdx)
                    {
                        const uint32_t mask = sampleCoverage[maskNdx].getAccess().getPixelUint(x, y).x();
                        masks.insert(mask);
                    }

                    if ((int)masks.size() < (int)minNumInvocations)
                    {
                        if (++printCount <= printFloodLimit)
                        {
                            m_testCtx.getLog() << tcu::TestLog::Message << "Pixel (" << x << ", " << y
                                               << "): Pixel invocations had only " << (int)masks.size()
                                               << " separate mask sets. Expected " << minNumInvocations
                                               << " or more. Found masks:" << tcu::TestLog::EndMessage;

                            for (std::set<uint32_t>::iterator it = masks.begin(); it != masks.end(); ++it)
                                m_testCtx.getLog()
                                    << tcu::TestLog::Message << "\tMask: " << tcu::Format::Hex<8>(*it) << "\n"
                                    << tcu::TestLog::EndMessage;
                        }

                        countOk = false;
                    }
                }

            if (!countOk)
            {
                allOk = false;

                if (printCount > printFloodLimit)
                    m_testCtx.getLog() << tcu::TestLog::Message << "...\n"
                                       << "Omitted " << (printCount - printFloodLimit) << " error descriptions."
                                       << tcu::TestLog::EndMessage;
            }
        }
    }

    if (!allOk)
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
}

class SampleMaskWriteCase : public SampleMaskBaseCase
{
public:
    enum TestMode
    {
        TEST_DISCARD = 0,
        TEST_INVERSE,

        TEST_LAST
    };
    SampleMaskWriteCase(Context &context, const char *name, const char *desc, int sampleCount, RenderTarget target,
                        ShaderRunMode runMode, TestMode testMode);
    ~SampleMaskWriteCase(void);

    void init(void);
    void preDraw(void);
    void postDraw(void);

private:
    enum
    {
        RENDER_SIZE = 64
    };

    std::string genFragmentSource(int numTargetSamples) const;
    bool verifyImage(const tcu::Surface &resultImage);

    const TestMode m_testMode;
};

SampleMaskWriteCase::SampleMaskWriteCase(Context &context, const char *name, const char *desc, int sampleCount,
                                         RenderTarget target, ShaderRunMode runMode, TestMode testMode)
    : SampleMaskBaseCase(context, name, desc, sampleCount, target, RENDER_SIZE, runMode)
    , m_testMode(testMode)
{
    DE_ASSERT(testMode < TEST_LAST);
}

SampleMaskWriteCase::~SampleMaskWriteCase(void)
{
}

void SampleMaskWriteCase::init(void)
{
    // log the test method and expectations
    if (m_testMode == TEST_DISCARD)
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Discarding half of the samples using gl_SampleMask, expecting:\n"
                           << "    1) half intensity on multisample targets (numSamples > 1)\n"
                           << "    2) full discard on multisample targets (numSamples == 1)\n"
                           << "    3) full intensity (no discard) on singlesample targets. (Mask is only applied as a "
                              "multisample operation.)\n"
                           << tcu::TestLog::EndMessage;
    else if (m_testMode == TEST_INVERSE)
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Discarding half of the samples using GL_SAMPLE_MASK, setting inverse mask in fragment "
                              "shader using gl_SampleMask, expecting:\n"
                           << "    1) full discard on multisample targets (mask & modifiedCoverge == 0)\n"
                           << "    2) full intensity (no discard) on singlesample targets. (Mask and coverage is only "
                              "applied as a multisample operation.)\n"
                           << tcu::TestLog::EndMessage;
    else
        DE_ASSERT(false);

    SampleMaskBaseCase::init();
}

void SampleMaskWriteCase::preDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    if (m_testMode == TEST_INVERSE)
    {
        // set mask to 0xAAAA.., set inverse mask bit coverage in shader

        const int maskLoc   = gl.getUniformLocation(m_program->getProgram(), "u_mask");
        const uint32_t mask = (uint32_t)0xAAAAAAAAUL;

        if (maskLoc == -1)
            throw tcu::TestError("Location of u_mask was -1");

        gl.enable(GL_SAMPLE_MASK);
        gl.sampleMaski(0, mask);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set mask");

        gl.uniform1ui(maskLoc, mask);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set mask uniform");

        m_testCtx.getLog() << tcu::TestLog::Message << "Setting sample mask " << tcu::Format::Hex<4>(mask)
                           << tcu::TestLog::EndMessage;
    }

    SampleMaskBaseCase::preDraw();
}

void SampleMaskWriteCase::postDraw(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    if (m_testMode == TEST_INVERSE)
    {
        const uint32_t fullMask = (1U << m_numTargetSamples) - 1;

        gl.disable(GL_SAMPLE_MASK);
        gl.sampleMaski(0, fullMask);
        GLU_EXPECT_NO_ERROR(gl.getError(), "set mask");
    }

    SampleMaskBaseCase::postDraw();
}

std::string SampleMaskWriteCase::genFragmentSource(int numTargetSamples) const
{
    DE_ASSERT(numTargetSamples != 0);
    DE_UNREF(numTargetSamples);

    std::ostringstream buf;
    const bool supportsES32orGL45 =
        glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
    map<string, string> args;
    args["GLSL_VERSION_DECL"] = supportsES32orGL45 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) :
                                                     getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    args["GLSL_EXTENSION"]    = supportsES32orGL45 ? "" : "#extension GL_OES_sample_variables : require";

    if (m_testMode == TEST_DISCARD)
    {
        // mask out every other coverage bit

        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "void main (void)\n"
               "{\n"
               "    for (int i = 0; i < gl_SampleMask.length(); ++i)\n"
               "        gl_SampleMask[i] = int(0xAAAAAAAA);\n"
               "\n";

        if (m_runMode == RUN_PER_SAMPLE)
            buf << "    // force per-sample shading\n"
                   "    highp float blue = float(gl_SampleID);\n"
                   "\n"
                   "    fragColor = vec4(0.0, 1.0, blue, 1.0);\n"
                   "}\n";
        else
            buf << "    fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
                   "}\n";
    }
    else if (m_testMode == TEST_INVERSE)
    {
        // inverse every coverage bit

        buf << "${GLSL_VERSION_DECL}\n"
               "${GLSL_EXTENSION}\n"
               "layout(location = 0) out mediump vec4 fragColor;\n"
               "uniform highp uint u_mask;\n"
               "void main (void)\n"
               "{\n"
               "    gl_SampleMask[0] = int(~u_mask);\n"
               "\n";

        if (m_runMode == RUN_PER_SAMPLE)
            buf << "    // force per-sample shading\n"
                   "    highp float blue = float(gl_SampleID);\n"
                   "\n"
                   "    fragColor = vec4(0.0, 1.0, blue, 1.0);\n"
                   "}\n";
        else
            buf << "    fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
                   "}\n";
    }
    else
        DE_ASSERT(false);

    return tcu::StringTemplate(buf.str()).specialize(args);
}

bool SampleMaskWriteCase::verifyImage(const tcu::Surface &resultImage)
{
    const bool singleSampleTarget = m_numRequestedSamples == 0 && !(m_renderTarget == TARGET_DEFAULT &&
                                                                    m_context.getRenderTarget().getNumSamples() > 1);

    if (m_testMode == TEST_DISCARD)
    {
        if (singleSampleTarget)
        {
            // single sample case => multisample operations are not effective => don't discard anything
            // expect green
            return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), ColorVerifier(tcu::Vec3(0.0f, 1.0f, 0.0f)));
        }
        else if (m_numTargetSamples == 1)
        {
            // total discard, expect black
            return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), ColorVerifier(tcu::Vec3(0.0f, 0.0f, 0.0f)));
        }
        else
        {
            // partial discard, expect something between black and green
            return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), PartialDiscardVerifier());
        }
    }
    else if (m_testMode == TEST_INVERSE)
    {
        if (singleSampleTarget)
        {
            // single sample case => multisample operations are not effective => don't discard anything
            // expect green
            return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), ColorVerifier(tcu::Vec3(0.0f, 1.0f, 0.0f)));
        }
        else
        {
            // total discard, expect black
            return verifyImageWithVerifier(resultImage, m_testCtx.getLog(), ColorVerifier(tcu::Vec3(0.0f, 0.0f, 0.0f)));
        }
    }
    else
    {
        DE_ASSERT(false);
        return false;
    }
}

} // namespace

SampleVariableTests::SampleVariableTests(Context &context)
    : TestCaseGroup(context, "sample_variables", "Test sample variables")
{
}

SampleVariableTests::~SampleVariableTests(void)
{
}

void SampleVariableTests::init(void)
{
    tcu::TestCaseGroup *const numSampleGroup = new tcu::TestCaseGroup(m_testCtx, "num_samples", "Test NumSamples");
    tcu::TestCaseGroup *const maxSampleGroup = new tcu::TestCaseGroup(m_testCtx, "max_samples", "Test MaxSamples");
    tcu::TestCaseGroup *const sampleIDGroup  = new tcu::TestCaseGroup(m_testCtx, "sample_id", "Test SampleID");
    tcu::TestCaseGroup *const samplePosGroup = new tcu::TestCaseGroup(m_testCtx, "sample_pos", "Test SamplePosition");
    tcu::TestCaseGroup *const sampleMaskInGroup =
        new tcu::TestCaseGroup(m_testCtx, "sample_mask_in", "Test SampleMaskIn");
    tcu::TestCaseGroup *const sampleMaskGroup = new tcu::TestCaseGroup(m_testCtx, "sample_mask", "Test SampleMask");

    addChild(numSampleGroup);
    addChild(maxSampleGroup);
    addChild(sampleIDGroup);
    addChild(samplePosGroup);
    addChild(sampleMaskInGroup);
    addChild(sampleMaskGroup);

    static const struct RenderTarget
    {
        const char *name;
        const char *desc;
        int numSamples;
        MultisampleRenderCase::RenderTarget target;
    } targets[] = {
        {"default_framebuffer", "Test with default framebuffer", 0, MultisampleRenderCase::TARGET_DEFAULT},
        {"singlesample_texture", "Test with singlesample texture", 0, MultisampleRenderCase::TARGET_TEXTURE},
        {"multisample_texture_1", "Test with multisample texture", 1, MultisampleRenderCase::TARGET_TEXTURE},
        {"multisample_texture_2", "Test with multisample texture", 2, MultisampleRenderCase::TARGET_TEXTURE},
        {"multisample_texture_4", "Test with multisample texture", 4, MultisampleRenderCase::TARGET_TEXTURE},
        {"multisample_texture_8", "Test with multisample texture", 8, MultisampleRenderCase::TARGET_TEXTURE},
        {"multisample_texture_16", "Test with multisample texture", 16, MultisampleRenderCase::TARGET_TEXTURE},
        {"singlesample_rbo", "Test with singlesample rbo", 0, MultisampleRenderCase::TARGET_RENDERBUFFER},
        {"multisample_rbo_1", "Test with multisample rbo", 1, MultisampleRenderCase::TARGET_RENDERBUFFER},
        {"multisample_rbo_2", "Test with multisample rbo", 2, MultisampleRenderCase::TARGET_RENDERBUFFER},
        {"multisample_rbo_4", "Test with multisample rbo", 4, MultisampleRenderCase::TARGET_RENDERBUFFER},
        {"multisample_rbo_8", "Test with multisample rbo", 8, MultisampleRenderCase::TARGET_RENDERBUFFER},
        {"multisample_rbo_16", "Test with multisample rbo", 16, MultisampleRenderCase::TARGET_RENDERBUFFER},
    };

    // .num_samples
    {
        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            numSampleGroup->addChild(new NumSamplesCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                        targets[targetNdx].numSamples, targets[targetNdx].target));
    }

    // .max_samples
    {
        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            maxSampleGroup->addChild(new MaxSamplesCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                        targets[targetNdx].numSamples, targets[targetNdx].target));
    }

    // .sample_ID
    {
        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            sampleIDGroup->addChild(new SampleIDCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                     targets[targetNdx].numSamples, targets[targetNdx].target));
    }

    // .sample_pos
    {{tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "correctness", "Test SamplePos correctness");
    samplePosGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        group->addChild(new SamplePosCorrectnessCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                     targets[targetNdx].numSamples, targets[targetNdx].target));
}

{
    tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "distribution", "Test SamplePos distribution");
    samplePosGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        group->addChild(new SamplePosDistributionCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                      targets[targetNdx].numSamples, targets[targetNdx].target));
}
} // namespace Functional

// .sample_mask_in
{// .sample_mask
 {tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "sample_mask", "Test with GL_SAMPLE_MASK");
sampleMaskInGroup->addChild(group);

for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
    group->addChild(new SampleMaskCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                       targets[targetNdx].numSamples, targets[targetNdx].target));
} // namespace gles31
// .bit_count_per_pixel
{
    tcu::TestCaseGroup *const group =
        new tcu::TestCaseGroup(m_testCtx, "bit_count_per_pixel", "Test number of coverage bits");
    sampleMaskInGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        group->addChild(new SampleMaskCountCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                targets[targetNdx].numSamples, targets[targetNdx].target,
                                                SampleMaskCountCase::RUN_PER_PIXEL));
}
// .bit_count_per_sample
{
    tcu::TestCaseGroup *const group =
        new tcu::TestCaseGroup(m_testCtx, "bit_count_per_sample", "Test number of coverage bits");
    sampleMaskInGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        group->addChild(new SampleMaskCountCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                targets[targetNdx].numSamples, targets[targetNdx].target,
                                                SampleMaskCountCase::RUN_PER_SAMPLE));
}
// .bit_count_per_two_samples
{
    tcu::TestCaseGroup *const group =
        new tcu::TestCaseGroup(m_testCtx, "bit_count_per_two_samples", "Test number of coverage bits");
    sampleMaskInGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        group->addChild(new SampleMaskCountCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                targets[targetNdx].numSamples, targets[targetNdx].target,
                                                SampleMaskCountCase::RUN_PER_TWO_SAMPLES));
}
// .bits_unique_per_sample
{
    tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "bits_unique_per_sample", "Test coverage bits");
    sampleMaskInGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        if (targets[targetNdx].target == MultisampleRenderCase::TARGET_TEXTURE)
            group->addChild(new SampleMaskUniqueCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                     targets[targetNdx].numSamples, targets[targetNdx].target,
                                                     SampleMaskUniqueCase::RUN_PER_SAMPLE));
}
// .bits_unique_per_two_samples
{
    tcu::TestCaseGroup *const group =
        new tcu::TestCaseGroup(m_testCtx, "bits_unique_per_two_samples", "Test coverage bits");
    sampleMaskInGroup->addChild(group);

    for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
        if (targets[targetNdx].target == MultisampleRenderCase::TARGET_TEXTURE)
            group->addChild(new SampleMaskUniqueSetCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                        targets[targetNdx].numSamples, targets[targetNdx].target,
                                                        SampleMaskUniqueCase::RUN_PER_TWO_SAMPLES));
}
} // namespace deqp

// .sample_mask
{
    // .discard_half_per_pixel
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "discard_half_per_pixel", "Test coverage bits");
        sampleMaskGroup->addChild(group);

        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            group->addChild(new SampleMaskWriteCase(
                m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples,
                targets[targetNdx].target, SampleMaskWriteCase::RUN_PER_PIXEL, SampleMaskWriteCase::TEST_DISCARD));
    }
    // .discard_half_per_sample
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "discard_half_per_sample", "Test coverage bits");
        sampleMaskGroup->addChild(group);

        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            group->addChild(new SampleMaskWriteCase(
                m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples,
                targets[targetNdx].target, SampleMaskWriteCase::RUN_PER_SAMPLE, SampleMaskWriteCase::TEST_DISCARD));
    }
    // .discard_half_per_two_samples
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "discard_half_per_two_samples", "Test coverage bits");
        sampleMaskGroup->addChild(group);

        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            group->addChild(new SampleMaskWriteCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                    targets[targetNdx].numSamples, targets[targetNdx].target,
                                                    SampleMaskWriteCase::RUN_PER_TWO_SAMPLES,
                                                    SampleMaskWriteCase::TEST_DISCARD));
    }

    // .discard_half_per_two_samples
    {
        tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "inverse_per_pixel", "Test coverage bits");
        sampleMaskGroup->addChild(group);

        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            group->addChild(new SampleMaskWriteCase(
                m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples,
                targets[targetNdx].target, SampleMaskWriteCase::RUN_PER_PIXEL, SampleMaskWriteCase::TEST_INVERSE));
    }
    // .inverse_per_sample
    {
        tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "inverse_per_sample", "Test coverage bits");
        sampleMaskGroup->addChild(group);

        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            group->addChild(new SampleMaskWriteCase(
                m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples,
                targets[targetNdx].target, SampleMaskWriteCase::RUN_PER_SAMPLE, SampleMaskWriteCase::TEST_INVERSE));
    }
    // .inverse_per_two_samples
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "inverse_per_two_samples", "Test coverage bits");
        sampleMaskGroup->addChild(group);

        for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
            group->addChild(new SampleMaskWriteCase(m_context, targets[targetNdx].name, targets[targetNdx].desc,
                                                    targets[targetNdx].numSamples, targets[targetNdx].target,
                                                    SampleMaskWriteCase::RUN_PER_TWO_SAMPLES,
                                                    SampleMaskWriteCase::TEST_INVERSE));
    }
}
}

} // Functional
} // gles31
} // deqp