xref: /aosp_15_r20/external/deqp/modules/gles3/functional/es3fShaderDerivateTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 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 Shader derivate function tests.
 *
 * \todo [2013-06-25 pyry] Missing features:
 *  - lines and points
 *  - projected coordinates
 *  - continous non-trivial functions (sin, exp)
 *  - non-continous functions (step)
 *//*--------------------------------------------------------------------*/

#include "es3fShaderDerivateTests.hpp"
#include "gluShaderProgram.hpp"
#include "gluRenderContext.hpp"
#include "gluDrawUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluShaderUtil.hpp"
#include "gluStrUtil.hpp"
#include "gluTextureUtil.hpp"
#include "gluTexture.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuRGBA.hpp"
#include "tcuFloat.hpp"
#include "tcuInterval.hpp"
#include "deRandom.hpp"
#include "deUniquePtr.hpp"
#include "deString.h"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "glsShaderRenderCase.hpp" // gls::setupDefaultUniforms()

#include <sstream>

namespace deqp
{
namespace gles3
{
namespace Functional
{

using std::map;
using std::ostringstream;
using std::string;
using std::vector;
using tcu::TestLog;

enum
{
    VIEWPORT_WIDTH      = 167,
    VIEWPORT_HEIGHT     = 103,
    FBO_WIDTH           = 99,
    FBO_HEIGHT          = 133,
    MAX_FAILED_MESSAGES = 10
};

enum DerivateFunc
{
    DERIVATE_DFDX = 0,
    DERIVATE_DFDY,
    DERIVATE_FWIDTH,

    DERIVATE_LAST
};

enum SurfaceType
{
    SURFACETYPE_DEFAULT_FRAMEBUFFER = 0,
    SURFACETYPE_UNORM_FBO,
    SURFACETYPE_FLOAT_FBO, // \note Uses RGBA32UI fbo actually, since FP rendertargets are not in core spec.

    SURFACETYPE_LAST
};

// Utilities

namespace
{

class AutoFbo
{
public:
    AutoFbo(const glw::Functions &gl) : m_gl(gl), m_fbo(0)
    {
    }

    ~AutoFbo(void)
    {
        if (m_fbo)
            m_gl.deleteFramebuffers(1, &m_fbo);
    }

    void gen(void)
    {
        DE_ASSERT(!m_fbo);
        m_gl.genFramebuffers(1, &m_fbo);
    }

    uint32_t operator*(void) const
    {
        return m_fbo;
    }

private:
    const glw::Functions &m_gl;
    uint32_t m_fbo;
};

class AutoRbo
{
public:
    AutoRbo(const glw::Functions &gl) : m_gl(gl), m_rbo(0)
    {
    }

    ~AutoRbo(void)
    {
        if (m_rbo)
            m_gl.deleteRenderbuffers(1, &m_rbo);
    }

    void gen(void)
    {
        DE_ASSERT(!m_rbo);
        m_gl.genRenderbuffers(1, &m_rbo);
    }

    uint32_t operator*(void) const
    {
        return m_rbo;
    }

private:
    const glw::Functions &m_gl;
    uint32_t m_rbo;
};

} // namespace

static const char *getDerivateFuncName(DerivateFunc func)
{
    switch (func)
    {
    case DERIVATE_DFDX:
        return "dFdx";
    case DERIVATE_DFDY:
        return "dFdy";
    case DERIVATE_FWIDTH:
        return "fwidth";
    default:
        DE_ASSERT(false);
        return DE_NULL;
    }
}

static const char *getDerivateFuncCaseName(DerivateFunc func)
{
    switch (func)
    {
    case DERIVATE_DFDX:
        return "dfdx";
    case DERIVATE_DFDY:
        return "dfdy";
    case DERIVATE_FWIDTH:
        return "fwidth";
    default:
        DE_ASSERT(false);
        return DE_NULL;
    }
}

static inline tcu::BVec4 getDerivateMask(glu::DataType type)
{
    switch (type)
    {
    case glu::TYPE_FLOAT:
        return tcu::BVec4(true, false, false, false);
    case glu::TYPE_FLOAT_VEC2:
        return tcu::BVec4(true, true, false, false);
    case glu::TYPE_FLOAT_VEC3:
        return tcu::BVec4(true, true, true, false);
    case glu::TYPE_FLOAT_VEC4:
        return tcu::BVec4(true, true, true, true);
    default:
        DE_ASSERT(false);
        return tcu::BVec4(true);
    }
}

static inline tcu::Vec4 readDerivate(const tcu::ConstPixelBufferAccess &surface, const tcu::Vec4 &derivScale,
                                     const tcu::Vec4 &derivBias, int x, int y)
{
    return (surface.getPixel(x, y) - derivBias) / derivScale;
}

static inline tcu::UVec4 getCompExpBits(const tcu::Vec4 &v)
{
    return tcu::UVec4(tcu::Float32(v[0]).exponentBits(), tcu::Float32(v[1]).exponentBits(),
                      tcu::Float32(v[2]).exponentBits(), tcu::Float32(v[3]).exponentBits());
}

float computeFloatingPointError(const float value, const int numAccurateBits)
{
    const int numGarbageBits = 23 - numAccurateBits;
    const uint32_t mask      = (1u << numGarbageBits) - 1u;
    const int exp            = (tcu::Float32(value).exponent() < -3) ? -3 : tcu::Float32(value).exponent();

    return tcu::Float32::construct(+1, exp, (1u << 23) | mask).asFloat() -
           tcu::Float32::construct(+1, exp, 1u << 23).asFloat();
}

static int getNumMantissaBits(const glu::Precision precision)
{
    switch (precision)
    {
    case glu::PRECISION_HIGHP:
        return 23;
    case glu::PRECISION_MEDIUMP:
        return 10;
    case glu::PRECISION_LOWP:
        return 6;
    default:
        DE_ASSERT(false);
        return 0;
    }
}

static int getMinExponent(const glu::Precision precision)
{
    switch (precision)
    {
    case glu::PRECISION_HIGHP:
        return -126;
    case glu::PRECISION_MEDIUMP:
        return -14;
    case glu::PRECISION_LOWP:
        return -8;
    default:
        DE_ASSERT(false);
        return 0;
    }
}

static float getSingleULPForExponent(int exp, int numMantissaBits)
{
    if (numMantissaBits > 0)
    {
        DE_ASSERT(numMantissaBits <= 23);

        const int ulpBitNdx = 23 - numMantissaBits;
        return tcu::Float32::construct(+1, exp, (1 << 23) | (1 << ulpBitNdx)).asFloat() -
               tcu::Float32::construct(+1, exp, (1 << 23)).asFloat();
    }
    else
    {
        DE_ASSERT(numMantissaBits == 0);
        return tcu::Float32::construct(+1, exp, (1 << 23)).asFloat();
    }
}

static float getSingleULPForValue(float value, int numMantissaBits)
{
    const int exp = tcu::Float32(value).exponent();
    return getSingleULPForExponent(exp, numMantissaBits);
}

static float convertFloatFlushToZeroRtn(float value, int minExponent, int numAccurateBits)
{
    if (value == 0.0f)
    {
        return 0.0f;
    }
    else
    {
        const tcu::Float32 inputFloat = tcu::Float32(value);
        const int numTruncatedBits    = 23 - numAccurateBits;
        const uint32_t truncMask      = (1u << numTruncatedBits) - 1u;

        if (value > 0.0f)
        {
            if (value > 0.0f && tcu::Float32(value).exponent() < minExponent)
            {
                // flush to zero if possible
                return 0.0f;
            }
            else
            {
                // just mask away non-representable bits
                return tcu::Float32::construct(+1, inputFloat.exponent(), inputFloat.mantissa() & ~truncMask).asFloat();
            }
        }
        else
        {
            if (inputFloat.mantissa() & truncMask)
            {
                // decrement one ulp if truncated bits are non-zero (i.e. if value is not representable)
                return tcu::Float32::construct(-1, inputFloat.exponent(), inputFloat.mantissa() & ~truncMask)
                           .asFloat() -
                       getSingleULPForExponent(inputFloat.exponent(), numAccurateBits);
            }
            else
            {
                // value is representable, no need to do anything
                return value;
            }
        }
    }
}

static float convertFloatFlushToZeroRtp(float value, int minExponent, int numAccurateBits)
{
    return -convertFloatFlushToZeroRtn(-value, minExponent, numAccurateBits);
}

static float addErrorUlp(float value, float numUlps, int numMantissaBits)
{
    return value + numUlps * getSingleULPForValue(value, numMantissaBits);
}

enum
{
    INTERPOLATION_LOST_BITS = 3, // number mantissa of bits allowed to be lost in varying interpolation
};

static int getInterpolationLostBitsWarning(const glu::Precision precision)
{
    // number mantissa of bits allowed to be lost in varying interpolation
    switch (precision)
    {
    case glu::PRECISION_HIGHP:
        return 9;
    case glu::PRECISION_MEDIUMP:
        return 3;
    case glu::PRECISION_LOWP:
        return 3;
    default:
        DE_ASSERT(false);
        return 0;
    }
}

static inline tcu::Vec4 getDerivateThreshold(const glu::Precision precision, const tcu::Vec4 &valueMin,
                                             const tcu::Vec4 &valueMax, const tcu::Vec4 &expectedDerivate)
{
    const int baseBits           = getNumMantissaBits(precision);
    const tcu::UVec4 derivExp    = getCompExpBits(expectedDerivate);
    const tcu::UVec4 maxValueExp = max(getCompExpBits(valueMin), getCompExpBits(valueMax));
    const tcu::UVec4 numBitsLost = maxValueExp - min(maxValueExp, derivExp);
    const tcu::IVec4 numAccurateBits =
        max(baseBits - numBitsLost.asInt() - (int)INTERPOLATION_LOST_BITS, tcu::IVec4(0));

    return tcu::Vec4(computeFloatingPointError(expectedDerivate[0], numAccurateBits[0]),
                     computeFloatingPointError(expectedDerivate[1], numAccurateBits[1]),
                     computeFloatingPointError(expectedDerivate[2], numAccurateBits[2]),
                     computeFloatingPointError(expectedDerivate[3], numAccurateBits[3]));
}

static inline tcu::Vec4 getDerivateThresholdWarning(const glu::Precision precision, const tcu::Vec4 &valueMin,
                                                    const tcu::Vec4 &valueMax, const tcu::Vec4 &expectedDerivate)
{
    const int baseBits           = getNumMantissaBits(precision);
    const tcu::UVec4 derivExp    = getCompExpBits(expectedDerivate);
    const tcu::UVec4 maxValueExp = max(getCompExpBits(valueMin), getCompExpBits(valueMax));
    const tcu::UVec4 numBitsLost = maxValueExp - min(maxValueExp, derivExp);
    const tcu::IVec4 numAccurateBits =
        max(baseBits - numBitsLost.asInt() - getInterpolationLostBitsWarning(precision), tcu::IVec4(0));

    return tcu::Vec4(computeFloatingPointError(expectedDerivate[0], numAccurateBits[0]),
                     computeFloatingPointError(expectedDerivate[1], numAccurateBits[1]),
                     computeFloatingPointError(expectedDerivate[2], numAccurateBits[2]),
                     computeFloatingPointError(expectedDerivate[3], numAccurateBits[3]));
}

namespace
{

struct LogVecComps
{
    const tcu::Vec4 &v;
    int numComps;

    LogVecComps(const tcu::Vec4 &v_, int numComps_) : v(v_), numComps(numComps_)
    {
    }
};

std::ostream &operator<<(std::ostream &str, const LogVecComps &v)
{
    DE_ASSERT(de::inRange(v.numComps, 1, 4));
    if (v.numComps == 1)
        return str << v.v[0];
    else if (v.numComps == 2)
        return str << v.v.toWidth<2>();
    else if (v.numComps == 3)
        return str << v.v.toWidth<3>();
    else
        return str << v.v;
}

} // namespace

enum VerificationLogging
{
    LOG_ALL = 0,
    LOG_NOTHING
};

static qpTestResult verifyConstantDerivate(tcu::TestLog &log, const tcu::ConstPixelBufferAccess &result,
                                           const tcu::PixelBufferAccess &errorMask, glu::DataType dataType,
                                           const tcu::Vec4 &reference, const tcu::Vec4 &threshold,
                                           const tcu::Vec4 &scale, const tcu::Vec4 &bias,
                                           VerificationLogging logPolicy = LOG_ALL)
{
    const int numComps    = glu::getDataTypeFloatScalars(dataType);
    const tcu::BVec4 mask = tcu::logicalNot(getDerivateMask(dataType));
    int numFailedPixels   = 0;

    if (logPolicy == LOG_ALL)
        log << TestLog::Message << "Expecting " << LogVecComps(reference, numComps) << " with threshold "
            << LogVecComps(threshold, numComps) << TestLog::EndMessage;

    for (int y = 0; y < result.getHeight(); y++)
    {
        for (int x = 0; x < result.getWidth(); x++)
        {
            const tcu::Vec4 resDerivate = readDerivate(result, scale, bias, x, y);
            const bool isOk =
                tcu::allEqual(tcu::logicalOr(tcu::lessThanEqual(tcu::abs(reference - resDerivate), threshold), mask),
                              tcu::BVec4(true));

            if (!isOk)
            {
                if (numFailedPixels < MAX_FAILED_MESSAGES && logPolicy == LOG_ALL)
                    log << TestLog::Message << "FAIL: got " << LogVecComps(resDerivate, numComps)
                        << ", diff = " << LogVecComps(tcu::abs(reference - resDerivate), numComps) << ", at x = " << x
                        << ", y = " << y << TestLog::EndMessage;
                numFailedPixels += 1;
                errorMask.setPixel(tcu::RGBA::red().toVec(), x, y);
            }
        }
    }

    if (numFailedPixels >= MAX_FAILED_MESSAGES && logPolicy == LOG_ALL)
        log << TestLog::Message << "..." << TestLog::EndMessage;

    if (numFailedPixels > 0 && logPolicy == LOG_ALL)
        log << TestLog::Message << "FAIL: found " << numFailedPixels << " failed pixels" << TestLog::EndMessage;

    return (numFailedPixels == 0) ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL;
}

struct Linear2DFunctionEvaluator
{
    tcu::Matrix<float, 4, 3> matrix;

    //      .-----.
    //      | s_x |
    //  M x | s_y |
    //      | 1.0 |
    //      '-----'
    tcu::Vec4 evaluateAt(float screenX, float screenY) const;
};

tcu::Vec4 Linear2DFunctionEvaluator::evaluateAt(float screenX, float screenY) const
{
    const tcu::Vec3 position(screenX, screenY, 1.0f);
    return matrix * position;
}

static qpTestResult reverifyConstantDerivateWithFlushRelaxations(
    tcu::TestLog &log, const tcu::ConstPixelBufferAccess &result, const tcu::PixelBufferAccess &errorMask,
    glu::DataType dataType, glu::Precision precision, const tcu::Vec4 &derivScale, const tcu::Vec4 &derivBias,
    const tcu::Vec4 &surfaceThreshold, DerivateFunc derivateFunc, const Linear2DFunctionEvaluator &function)
{
    DE_ASSERT(result.getWidth() == errorMask.getWidth());
    DE_ASSERT(result.getHeight() == errorMask.getHeight());
    DE_ASSERT(derivateFunc == DERIVATE_DFDX || derivateFunc == DERIVATE_DFDY);

    const tcu::IVec4 red(255, 0, 0, 255);
    const tcu::IVec4 green(0, 255, 0, 255);
    const float divisionErrorUlps = 2.5f;

    const int numComponents = glu::getDataTypeFloatScalars(dataType);
    const int numBits       = getNumMantissaBits(precision);
    const int minExponent   = getMinExponent(precision);

    const int numVaryingSampleBits = numBits - INTERPOLATION_LOST_BITS;
    int numFailedPixels            = 0;

    tcu::clear(errorMask, green);

    // search for failed pixels
    for (int y = 0; y < result.getHeight(); ++y)
        for (int x = 0; x < result.getWidth(); ++x)
        {
            //                 flushToZero?(f2z?(functionValueCurrent) - f2z?(functionValueBefore))
            // flushToZero? ( ------------------------------------------------------------------------ +- 2.5 ULP )
            //                                                  dx

            const tcu::Vec4 resultDerivative = readDerivate(result, derivScale, derivBias, x, y);

            // sample at the front of the back pixel and the back of the front pixel to cover the whole area of
            // legal sample positions. In general case this is NOT OK, but we know that the target function is
            // (mostly*) linear which allows us to take the sample points at arbitrary points. This gets us the
            // maximum difference possible in exponents which are used in error bound calculations.
            // * non-linearity may happen around zero or with very high function values due to subnorms not
            //   behaving well.
            const tcu::Vec4 functionValueForward  = (derivateFunc == DERIVATE_DFDX) ?
                                                        (function.evaluateAt((float)x + 2.0f, (float)y + 0.5f)) :
                                                        (function.evaluateAt((float)x + 0.5f, (float)y + 2.0f));
            const tcu::Vec4 functionValueBackward = (derivateFunc == DERIVATE_DFDX) ?
                                                        (function.evaluateAt((float)x - 1.0f, (float)y + 0.5f)) :
                                                        (function.evaluateAt((float)x + 0.5f, (float)y - 1.0f));

            bool anyComponentFailed = false;

            // check components separately
            for (int c = 0; c < numComponents; ++c)
            {
                // Simulate interpolation. Add allowed interpolation error and round to target precision. Allow one half ULP (i.e. correct rounding)
                const tcu::Interval forwardComponent(
                    convertFloatFlushToZeroRtn(addErrorUlp((float)functionValueForward[c], -0.5f, numVaryingSampleBits),
                                               minExponent, numBits),
                    convertFloatFlushToZeroRtp(addErrorUlp((float)functionValueForward[c], +0.5f, numVaryingSampleBits),
                                               minExponent, numBits));
                const tcu::Interval backwardComponent(
                    convertFloatFlushToZeroRtn(
                        addErrorUlp((float)functionValueBackward[c], -0.5f, numVaryingSampleBits), minExponent,
                        numBits),
                    convertFloatFlushToZeroRtp(
                        addErrorUlp((float)functionValueBackward[c], +0.5f, numVaryingSampleBits), minExponent,
                        numBits));
                const int maxValueExp = de::max(de::max(tcu::Float32(forwardComponent.lo()).exponent(),
                                                        tcu::Float32(forwardComponent.hi()).exponent()),
                                                de::max(tcu::Float32(backwardComponent.lo()).exponent(),
                                                        tcu::Float32(backwardComponent.hi()).exponent()));

                // subtraction in numerator will likely cause a cancellation of the most
                // significant bits. Apply error bounds.

                const tcu::Interval numerator(forwardComponent - backwardComponent);
                const int numeratorLoExp      = tcu::Float32(numerator.lo()).exponent();
                const int numeratorHiExp      = tcu::Float32(numerator.hi()).exponent();
                const int numeratorLoBitsLost = de::max(
                    0,
                    maxValueExp -
                        numeratorLoExp); //!< must clamp to zero since if forward and backward components have different
                const int numeratorHiBitsLost = de::max(
                    0, maxValueExp - numeratorHiExp); //!< sign, numerator might have larger exponent than its operands.
                const int numeratorLoBits = de::max(0, numBits - numeratorLoBitsLost);
                const int numeratorHiBits = de::max(0, numBits - numeratorHiBitsLost);

                const tcu::Interval numeratorRange(
                    convertFloatFlushToZeroRtn((float)numerator.lo(), minExponent, numeratorLoBits),
                    convertFloatFlushToZeroRtp((float)numerator.hi(), minExponent, numeratorHiBits));

                const tcu::Interval divisionRange =
                    numeratorRange /
                    3.0f; // legal sample area is anywhere within this and neighboring pixels (i.e. size = 3)
                const tcu::Interval divisionResultRange(
                    convertFloatFlushToZeroRtn(addErrorUlp((float)divisionRange.lo(), -divisionErrorUlps, numBits),
                                               minExponent, numBits),
                    convertFloatFlushToZeroRtp(addErrorUlp((float)divisionRange.hi(), +divisionErrorUlps, numBits),
                                               minExponent, numBits));
                const tcu::Interval finalResultRange(divisionResultRange.lo() - surfaceThreshold[c],
                                                     divisionResultRange.hi() + surfaceThreshold[c]);

                if (resultDerivative[c] >= finalResultRange.lo() && resultDerivative[c] <= finalResultRange.hi())
                {
                    // value ok
                }
                else
                {
                    if (numFailedPixels < MAX_FAILED_MESSAGES)
                        log << tcu::TestLog::Message << "Error in pixel at " << x << ", " << y << " with component "
                            << c << " (channel " << ("rgba"[c]) << ")\n"
                            << "\tGot pixel value " << result.getPixelInt(x, y) << "\n"
                            << "\t\tdFd" << ((derivateFunc == DERIVATE_DFDX) ? ('x') : ('y'))
                            << " ~= " << resultDerivative[c] << "\n"
                            << "\t\tdifference to a valid range: "
                            << ((resultDerivative[c] < finalResultRange.lo()) ? ("-") : ("+"))
                            << ((resultDerivative[c] < finalResultRange.lo()) ?
                                    (finalResultRange.lo() - resultDerivative[c]) :
                                    (resultDerivative[c] - finalResultRange.hi()))
                            << "\n"
                            << "\tDerivative value range:\n"
                            << "\t\tMin: " << finalResultRange.lo() << "\n"
                            << "\t\tMax: " << finalResultRange.hi() << "\n"
                            << tcu::TestLog::EndMessage;

                    ++numFailedPixels;
                    anyComponentFailed = true;
                }
            }

            if (anyComponentFailed)
                errorMask.setPixel(red, x, y);
        }

    if (numFailedPixels >= MAX_FAILED_MESSAGES)
        log << TestLog::Message << "..." << TestLog::EndMessage;

    if (numFailedPixels > 0)
        log << TestLog::Message << "FAIL: found " << numFailedPixels << " failed pixels" << TestLog::EndMessage;

    return (numFailedPixels == 0) ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL;
}

// TriangleDerivateCase

class TriangleDerivateCase : public TestCase
{
public:
    TriangleDerivateCase(Context &context, const char *name, const char *description);
    ~TriangleDerivateCase(void);

    IterateResult iterate(void);

protected:
    virtual void setupRenderState(uint32_t program)
    {
        DE_UNREF(program);
    }
    virtual qpTestResult verify(const tcu::ConstPixelBufferAccess &result,
                                const tcu::PixelBufferAccess &errorMask) = DE_NULL;

    tcu::IVec2 getViewportSize(void) const;
    tcu::Vec4 getSurfaceThreshold(void) const;

    glu::DataType m_dataType;
    glu::Precision m_precision;

    glu::DataType m_coordDataType;
    glu::Precision m_coordPrecision;

    std::string m_fragmentSrc;

    tcu::Vec4 m_coordMin;
    tcu::Vec4 m_coordMax;
    tcu::Vec4 m_derivScale;
    tcu::Vec4 m_derivBias;

    SurfaceType m_surfaceType;
    int m_numSamples;
    uint32_t m_hint;

    bool m_useAsymmetricCoords;
};

TriangleDerivateCase::TriangleDerivateCase(Context &context, const char *name, const char *description)
    : TestCase(context, name, description)
    , m_dataType(glu::TYPE_LAST)
    , m_precision(glu::PRECISION_LAST)
    , m_coordDataType(glu::TYPE_LAST)
    , m_coordPrecision(glu::PRECISION_LAST)
    , m_surfaceType(SURFACETYPE_DEFAULT_FRAMEBUFFER)
    , m_numSamples(0)
    , m_hint(GL_DONT_CARE)
    , m_useAsymmetricCoords(false)
{
    DE_ASSERT(m_surfaceType != SURFACETYPE_DEFAULT_FRAMEBUFFER || m_numSamples == 0);
}

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

static std::string genVertexSource(glu::DataType coordType, glu::Precision precision)
{
    DE_ASSERT(glu::isDataTypeFloatOrVec(coordType));

    const char *vertexTmpl = "#version 300 es\n"
                             "in highp vec4 a_position;\n"
                             "in ${PRECISION} ${DATATYPE} a_coord;\n"
                             "out ${PRECISION} ${DATATYPE} v_coord;\n"
                             "void main (void)\n"
                             "{\n"
                             "    gl_Position = a_position;\n"
                             "    v_coord = a_coord;\n"
                             "}\n";

    map<string, string> vertexParams;

    vertexParams["PRECISION"] = glu::getPrecisionName(precision);
    vertexParams["DATATYPE"]  = glu::getDataTypeName(coordType);

    return tcu::StringTemplate(vertexTmpl).specialize(vertexParams);
}

inline tcu::IVec2 TriangleDerivateCase::getViewportSize(void) const
{
    if (m_surfaceType == SURFACETYPE_DEFAULT_FRAMEBUFFER)
    {
        const int width  = de::min<int>(m_context.getRenderTarget().getWidth(), VIEWPORT_WIDTH);
        const int height = de::min<int>(m_context.getRenderTarget().getHeight(), VIEWPORT_HEIGHT);
        return tcu::IVec2(width, height);
    }
    else
        return tcu::IVec2(FBO_WIDTH, FBO_HEIGHT);
}

TriangleDerivateCase::IterateResult TriangleDerivateCase::iterate(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    const glu::ShaderProgram program(
        m_context.getRenderContext(),
        glu::makeVtxFragSources(genVertexSource(m_coordDataType, m_coordPrecision), m_fragmentSrc));
    de::Random rnd(deStringHash(getName()) ^ 0xbbc24);
    const bool useFbo             = m_surfaceType != SURFACETYPE_DEFAULT_FRAMEBUFFER;
    const uint32_t fboFormat      = m_surfaceType == SURFACETYPE_FLOAT_FBO ? GL_RGBA32UI : GL_RGBA8;
    const tcu::IVec2 viewportSize = getViewportSize();
    const int viewportX = useFbo ? 0 : rnd.getInt(0, m_context.getRenderTarget().getWidth() - viewportSize.x());
    const int viewportY = useFbo ? 0 : rnd.getInt(0, m_context.getRenderTarget().getHeight() - viewportSize.y());
    AutoFbo fbo(gl);
    AutoRbo rbo(gl);
    tcu::TextureLevel result;

    m_testCtx.getLog() << program;

    if (!program.isOk())
        TCU_FAIL("Compile failed");

    if (useFbo)
    {
        m_testCtx.getLog() << TestLog::Message << "Rendering to FBO, format = " << glu::getTextureFormatStr(fboFormat)
                           << ", samples = " << m_numSamples << TestLog::EndMessage;

        fbo.gen();
        rbo.gen();

        gl.bindRenderbuffer(GL_RENDERBUFFER, *rbo);
        gl.renderbufferStorageMultisample(GL_RENDERBUFFER, m_numSamples, fboFormat, viewportSize.x(), viewportSize.y());
        gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
        gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *rbo);
        TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
    }
    else
    {
        const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();

        m_testCtx.getLog() << TestLog::Message << "Rendering to default framebuffer\n"
                           << "\tColor depth: R=" << pixelFormat.redBits << ", G=" << pixelFormat.greenBits
                           << ", B=" << pixelFormat.blueBits << ", A=" << pixelFormat.alphaBits << TestLog::EndMessage;
    }

    m_testCtx.getLog() << TestLog::Message << "in: " << m_coordMin << " -> " << m_coordMax << "\n"
                       << (m_useAsymmetricCoords ? "v_coord.x = in.x * (x+y)/2\n" : "v_coord.x = in.x * x\n")
                       << (m_useAsymmetricCoords ? "v_coord.y = in.y * (x+y)/2\n" : "v_coord.y = in.y * y\n")
                       << "v_coord.z = in.z * (x+y)/2\n"
                       << "v_coord.w = in.w * (1 - (x+y)/2)\n"
                       << TestLog::EndMessage << TestLog::Message << "u_scale: " << m_derivScale
                       << ", u_bias: " << m_derivBias << " (displayed values have scale/bias removed)"
                       << TestLog::EndMessage << TestLog::Message << "Viewport: " << viewportSize.x() << "x"
                       << viewportSize.y() << TestLog::EndMessage << TestLog::Message
                       << "GL_FRAGMENT_SHADER_DERIVATE_HINT: " << glu::getHintModeStr(m_hint) << TestLog::EndMessage;

    // Draw
    {
        const float positions[] = {-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
                                   1.0f,  -1.0f, 0.0f, 1.0f, 1.0f,  1.0f, 0.0f, 1.0f};
        float coords[]          = {m_coordMin.x(),
                                   m_coordMin.y(),
                                   m_coordMin.z(),
                                   m_coordMax.w(),
                                   m_coordMin.x(),
                                   m_coordMax.y(),
                                   (m_coordMin.z() + m_coordMax.z()) * 0.5f,
                                   (m_coordMin.w() + m_coordMax.w()) * 0.5f,
                                   m_coordMax.x(),
                                   m_coordMin.y(),
                                   (m_coordMin.z() + m_coordMax.z()) * 0.5f,
                                   (m_coordMin.w() + m_coordMax.w()) * 0.5f,
                                   m_coordMax.x(),
                                   m_coordMax.y(),
                                   m_coordMax.z(),
                                   m_coordMin.w()};

        // For linear tests we want varying data x and y to vary along both axes
        // to get nonzero x for dfdy and nonzero y for dfdx. To make the gradient
        // the same for both triangles we set vertices 2 and 3 to middle values.
        // This way the values go from min -> (max+min) / 2 or (max+min) / 2 -> max
        // depending on the triangle, but the derivative is the same for both.
        if (m_useAsymmetricCoords)
        {
            coords[4] = coords[8] = (m_coordMin.x() + m_coordMax.x()) * 0.5f;
            coords[5] = coords[9] = (m_coordMin.y() + m_coordMax.y()) * 0.5f;
        }

        const glu::VertexArrayBinding vertexArrays[] = {glu::va::Float("a_position", 4, 4, 0, &positions[0]),
                                                        glu::va::Float("a_coord", 4, 4, 0, &coords[0])};
        const uint16_t indices[]                     = {0, 2, 1, 2, 3, 1};

        gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f);
        gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
        gl.disable(GL_DITHER);

        gl.useProgram(program.getProgram());

        {
            const int scaleLoc = gl.getUniformLocation(program.getProgram(), "u_scale");
            const int biasLoc  = gl.getUniformLocation(program.getProgram(), "u_bias");

            switch (m_dataType)
            {
            case glu::TYPE_FLOAT:
                gl.uniform1f(scaleLoc, m_derivScale.x());
                gl.uniform1f(biasLoc, m_derivBias.x());
                break;

            case glu::TYPE_FLOAT_VEC2:
                gl.uniform2fv(scaleLoc, 1, m_derivScale.getPtr());
                gl.uniform2fv(biasLoc, 1, m_derivBias.getPtr());
                break;

            case glu::TYPE_FLOAT_VEC3:
                gl.uniform3fv(scaleLoc, 1, m_derivScale.getPtr());
                gl.uniform3fv(biasLoc, 1, m_derivBias.getPtr());
                break;

            case glu::TYPE_FLOAT_VEC4:
                gl.uniform4fv(scaleLoc, 1, m_derivScale.getPtr());
                gl.uniform4fv(biasLoc, 1, m_derivBias.getPtr());
                break;

            default:
                DE_ASSERT(false);
            }
        }

        gls::setupDefaultUniforms(m_context.getRenderContext(), program.getProgram());
        setupRenderState(program.getProgram());

        gl.hint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT, m_hint);
        GLU_EXPECT_NO_ERROR(gl.getError(), "Setup program state");

        gl.viewport(viewportX, viewportY, viewportSize.x(), viewportSize.y());
        glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays),
                  &vertexArrays[0], glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
        GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
    }

    // Read back results
    {
        const bool isMSAA = useFbo && m_numSamples > 0;
        AutoFbo resFbo(gl);
        AutoRbo resRbo(gl);

        // Resolve if necessary
        if (isMSAA)
        {
            resFbo.gen();
            resRbo.gen();

            gl.bindRenderbuffer(GL_RENDERBUFFER, *resRbo);
            gl.renderbufferStorageMultisample(GL_RENDERBUFFER, 0, fboFormat, viewportSize.x(), viewportSize.y());
            gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, *resFbo);
            gl.framebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *resRbo);
            TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);

            gl.blitFramebuffer(0, 0, viewportSize.x(), viewportSize.y(), 0, 0, viewportSize.x(), viewportSize.y(),
                               GL_COLOR_BUFFER_BIT, GL_NEAREST);
            GLU_EXPECT_NO_ERROR(gl.getError(), "Resolve blit");

            gl.bindFramebuffer(GL_READ_FRAMEBUFFER, *resFbo);
        }

        switch (m_surfaceType)
        {
        case SURFACETYPE_DEFAULT_FRAMEBUFFER:
        case SURFACETYPE_UNORM_FBO:
            result.setStorage(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8),
                              viewportSize.x(), viewportSize.y());
            glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, result);
            break;

        case SURFACETYPE_FLOAT_FBO:
        {
            const tcu::TextureFormat dataFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT);
            const tcu::TextureFormat transferFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32);

            result.setStorage(dataFormat, viewportSize.x(), viewportSize.y());
            glu::readPixels(m_context.getRenderContext(), viewportX, viewportY,
                            tcu::PixelBufferAccess(transferFormat, result.getWidth(), result.getHeight(),
                                                   result.getDepth(), result.getAccess().getDataPtr()));
            break;
        }

        default:
            DE_ASSERT(false);
        }

        GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
    }

    // Verify
    {
        tcu::Surface errorMask(result.getWidth(), result.getHeight());
        tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec());

        const qpTestResult testResult = verify(result.getAccess(), errorMask.getAccess());
        const char *failStr           = "Fail";

        m_testCtx.getLog() << TestLog::ImageSet("Result", "Result images")
                           << TestLog::Image("Rendered", "Rendered image", result);

        if (testResult != QP_TEST_RESULT_PASS)
            m_testCtx.getLog() << TestLog::Image("ErrorMask", "Error mask", errorMask);

        m_testCtx.getLog() << TestLog::EndImageSet;

        if (testResult == QP_TEST_RESULT_PASS)
            failStr = "Pass";
        else if (testResult == QP_TEST_RESULT_QUALITY_WARNING)
            failStr = "QualityWarning";

        m_testCtx.setTestResult(testResult, failStr);
    }

    return STOP;
}

tcu::Vec4 TriangleDerivateCase::getSurfaceThreshold(void) const
{
    switch (m_surfaceType)
    {
    case SURFACETYPE_DEFAULT_FRAMEBUFFER:
    {
        const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();
        const tcu::IVec4 channelBits(pixelFormat.redBits, pixelFormat.greenBits, pixelFormat.blueBits,
                                     pixelFormat.alphaBits);
        const tcu::IVec4 intThreshold = tcu::IVec4(1) << (8 - channelBits);
        const tcu::Vec4 normThreshold = intThreshold.asFloat() / 255.0f;

        return normThreshold;
    }

    case SURFACETYPE_UNORM_FBO:
        return tcu::IVec4(1).asFloat() / 255.0f;
    case SURFACETYPE_FLOAT_FBO:
        return tcu::Vec4(0.0f);
    default:
        DE_ASSERT(false);
        return tcu::Vec4(0.0f);
    }
}

// ConstantDerivateCase

class ConstantDerivateCase : public TriangleDerivateCase
{
public:
    ConstantDerivateCase(Context &context, const char *name, const char *description, DerivateFunc func,
                         glu::DataType type);
    ~ConstantDerivateCase(void)
    {
    }

    void init(void);

protected:
    qpTestResult verify(const tcu::ConstPixelBufferAccess &result, const tcu::PixelBufferAccess &errorMask);

private:
    DerivateFunc m_func;
};

ConstantDerivateCase::ConstantDerivateCase(Context &context, const char *name, const char *description,
                                           DerivateFunc func, glu::DataType type)
    : TriangleDerivateCase(context, name, description)
    , m_func(func)
{
    m_dataType       = type;
    m_precision      = glu::PRECISION_HIGHP;
    m_coordDataType  = m_dataType;
    m_coordPrecision = m_precision;
}

void ConstantDerivateCase::init(void)
{
    const char *fragmentTmpl = "#version 300 es\n"
                               "layout(location = 0) out mediump vec4 o_color;\n"
                               "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
                               "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
                               "void main (void)\n"
                               "{\n"
                               "    ${PRECISION} ${DATATYPE} res = ${FUNC}(${VALUE}) * u_scale + u_bias;\n"
                               "    o_color = ${CAST_TO_OUTPUT};\n"
                               "}\n";
    map<string, string> fragmentParams;
    fragmentParams["PRECISION"]      = glu::getPrecisionName(m_precision);
    fragmentParams["DATATYPE"]       = glu::getDataTypeName(m_dataType);
    fragmentParams["FUNC"]           = getDerivateFuncName(m_func);
    fragmentParams["VALUE"]          = m_dataType == glu::TYPE_FLOAT_VEC4 ? "vec4(1.0, 7.2, -1e5, 0.0)" :
                                       m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec3(1e2, 8.0, 0.01)" :
                                       m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec2(-0.0, 2.7)" :
                                                                            /* TYPE_FLOAT */ "7.7";
    fragmentParams["CAST_TO_OUTPUT"] = m_dataType == glu::TYPE_FLOAT_VEC4 ? "res" :
                                       m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec4(res, 1.0)" :
                                       m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec4(res, 0.0, 1.0)" :
                                                                            /* TYPE_FLOAT */ "vec4(res, 0.0, 0.0, 1.0)";

    m_fragmentSrc = tcu::StringTemplate(fragmentTmpl).specialize(fragmentParams);

    m_derivScale = tcu::Vec4(1e3f, 1e3f, 1e3f, 1e3f);
    m_derivBias  = tcu::Vec4(0.5f, 0.5f, 0.5f, 0.5f);
}

qpTestResult ConstantDerivateCase::verify(const tcu::ConstPixelBufferAccess &result,
                                          const tcu::PixelBufferAccess &errorMask)
{
    const tcu::Vec4 reference(0.0f); // Derivate of constant argument should always be 0
    const tcu::Vec4 threshold = getSurfaceThreshold() / abs(m_derivScale);

    return verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType, reference, threshold, m_derivScale,
                                  m_derivBias);
}

// LinearDerivateCase

class LinearDerivateCase : public TriangleDerivateCase
{
public:
    LinearDerivateCase(Context &context, const char *name, const char *description, DerivateFunc func,
                       glu::DataType type, glu::Precision precision, uint32_t hint, SurfaceType surfaceType,
                       int numSamples, const char *fragmentSrcTmpl);
    ~LinearDerivateCase(void)
    {
    }

    void init(void);

protected:
    qpTestResult verify(const tcu::ConstPixelBufferAccess &result, const tcu::PixelBufferAccess &errorMask);

private:
    DerivateFunc m_func;
    std::string m_fragmentTmpl;
};

LinearDerivateCase::LinearDerivateCase(Context &context, const char *name, const char *description, DerivateFunc func,
                                       glu::DataType type, glu::Precision precision, uint32_t hint,
                                       SurfaceType surfaceType, int numSamples, const char *fragmentSrcTmpl)
    : TriangleDerivateCase(context, name, description)
    , m_func(func)
    , m_fragmentTmpl(fragmentSrcTmpl)
{
    m_dataType            = type;
    m_precision           = precision;
    m_coordDataType       = m_dataType;
    m_coordPrecision      = m_precision;
    m_hint                = hint;
    m_surfaceType         = surfaceType;
    m_numSamples          = numSamples;
    m_useAsymmetricCoords = true;
}

void LinearDerivateCase::init(void)
{
    const tcu::IVec2 viewportSize = getViewportSize();
    const float w                 = float(viewportSize.x());
    const float h                 = float(viewportSize.y());
    const bool packToInt          = m_surfaceType == SURFACETYPE_FLOAT_FBO;
    map<string, string> fragmentParams;

    fragmentParams["OUTPUT_TYPE"] = glu::getDataTypeName(packToInt ? glu::TYPE_UINT_VEC4 : glu::TYPE_FLOAT_VEC4);
    fragmentParams["OUTPUT_PREC"] = glu::getPrecisionName(packToInt ? glu::PRECISION_HIGHP : m_precision);
    fragmentParams["PRECISION"]   = glu::getPrecisionName(m_precision);
    fragmentParams["DATATYPE"]    = glu::getDataTypeName(m_dataType);
    fragmentParams["FUNC"]        = getDerivateFuncName(m_func);

    if (packToInt)
    {
        fragmentParams["CAST_TO_OUTPUT"] =
            m_dataType == glu::TYPE_FLOAT_VEC4 ? "floatBitsToUint(res)" :
            m_dataType == glu::TYPE_FLOAT_VEC3 ? "floatBitsToUint(vec4(res, 1.0))" :
            m_dataType == glu::TYPE_FLOAT_VEC2 ? "floatBitsToUint(vec4(res, 0.0, 1.0))" :
                                                 /* TYPE_FLOAT */ "floatBitsToUint(vec4(res, 0.0, 0.0, 1.0))";
    }
    else
    {
        fragmentParams["CAST_TO_OUTPUT"] =
            m_dataType == glu::TYPE_FLOAT_VEC4 ? "res" :
            m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec4(res, 1.0)" :
            m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec4(res, 0.0, 1.0)" :
                                                 /* TYPE_FLOAT */ "vec4(res, 0.0, 0.0, 1.0)";
    }

    m_fragmentSrc = tcu::StringTemplate(m_fragmentTmpl.c_str()).specialize(fragmentParams);

    switch (m_precision)
    {
    case glu::PRECISION_HIGHP:
        m_coordMin = tcu::Vec4(-97.f, 0.2f, 71.f, 74.f);
        m_coordMax = tcu::Vec4(-13.2f, -77.f, 44.f, 76.f);
        break;

    case glu::PRECISION_MEDIUMP:
        m_coordMin = tcu::Vec4(-37.0f, 47.f, -7.f, 0.0f);
        m_coordMax = tcu::Vec4(-1.0f, 12.f, 7.f, 19.f);
        break;

    case glu::PRECISION_LOWP:
        m_coordMin = tcu::Vec4(0.0f, -1.0f, 0.0f, 1.0f);
        m_coordMax = tcu::Vec4(1.0f, 1.0f, -1.0f, -1.0f);
        break;

    default:
        DE_ASSERT(false);
    }

    if (m_surfaceType == SURFACETYPE_FLOAT_FBO)
    {
        // No scale or bias used for accuracy.
        m_derivScale = tcu::Vec4(1.0f);
        m_derivBias  = tcu::Vec4(0.0f);
    }
    else
    {
        // Compute scale - bias that normalizes to 0..1 range.
        const tcu::Vec4 dx = (m_coordMax - m_coordMin) / tcu::Vec4(w, w, w * 0.5f, -w * 0.5f);
        const tcu::Vec4 dy = (m_coordMax - m_coordMin) / tcu::Vec4(h, h, h * 0.5f, -h * 0.5f);

        switch (m_func)
        {
        case DERIVATE_DFDX:
            m_derivScale = 0.5f / dx;
            break;

        case DERIVATE_DFDY:
            m_derivScale = 0.5f / dy;
            break;

        case DERIVATE_FWIDTH:
            m_derivScale = 0.5f / (tcu::abs(dx) + tcu::abs(dy));
            break;

        default:
            DE_ASSERT(false);
        }

        m_derivBias = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
    }
}

qpTestResult LinearDerivateCase::verify(const tcu::ConstPixelBufferAccess &result,
                                        const tcu::PixelBufferAccess &errorMask)
{
    const tcu::Vec4 xScale = tcu::Vec4(0.5f, 0.5f, 0.5f, -0.5f);
    const tcu::Vec4 yScale = tcu::Vec4(0.5f, 0.5f, 0.5f, -0.5f);

    const tcu::Vec4 surfaceThreshold = getSurfaceThreshold() / abs(m_derivScale);

    if (m_func == DERIVATE_DFDX || m_func == DERIVATE_DFDY)
    {
        const bool isX               = m_func == DERIVATE_DFDX;
        const float div              = isX ? float(result.getWidth()) : float(result.getHeight());
        const tcu::Vec4 scale        = isX ? xScale : yScale;
        tcu::Vec4 reference          = ((m_coordMax - m_coordMin) / div);
        const tcu::Vec4 opThreshold  = getDerivateThreshold(m_precision, m_coordMin, m_coordMax, reference);
        const tcu::Vec4 opThresholdW = getDerivateThresholdWarning(m_precision, m_coordMin, m_coordMax, reference);
        const tcu::Vec4 threshold    = max(surfaceThreshold, opThreshold);
        const tcu::Vec4 thresholdW   = max(surfaceThreshold, opThresholdW);
        const int numComps           = glu::getDataTypeFloatScalars(m_dataType);

        /* adjust the reference value for the correct dfdx or dfdy sample adjacency */
        reference = reference * scale;

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying result image.\n"
                           << "\tValid derivative is " << LogVecComps(reference, numComps) << " with threshold "
                           << LogVecComps(threshold, numComps) << tcu::TestLog::EndMessage;

        // short circuit if result is strictly within the normal value error bounds.
        // This improves performance significantly.
        if (verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType, reference, threshold,
                                   m_derivScale, m_derivBias, LOG_NOTHING) == QP_TEST_RESULT_PASS)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "No incorrect derivatives found, result valid."
                               << tcu::TestLog::EndMessage;

            return QP_TEST_RESULT_PASS;
        }

        // Check with relaxed threshold value
        if (verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType, reference, thresholdW,
                                   m_derivScale, m_derivBias, LOG_NOTHING) == QP_TEST_RESULT_PASS)
        {
            m_testCtx.getLog() << tcu::TestLog::Message
                               << "No incorrect derivatives found, result valid with quality warning."
                               << tcu::TestLog::EndMessage;

            return QP_TEST_RESULT_QUALITY_WARNING;
        }

        // some pixels exceed error bounds calculated for normal values. Verify that these
        // potentially invalid pixels are in fact valid due to (for example) subnorm flushing.

        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Initial verification failed, verifying image by calculating accurate error bounds for "
                              "each result pixel.\n"
                           << "\tVerifying each result derivative is within its range of legal result values."
                           << tcu::TestLog::EndMessage;

        {
            const tcu::IVec2 viewportSize = getViewportSize();
            const float w                 = float(viewportSize.x());
            const float h                 = float(viewportSize.y());
            const tcu::Vec4 valueRamp     = (m_coordMax - m_coordMin);
            Linear2DFunctionEvaluator function;

            function.matrix.setRow(0,
                                   tcu::Vec3((valueRamp.x() / w) / 2.0f, (valueRamp.x() / h) / 2.0f, m_coordMin.x()));
            function.matrix.setRow(1,
                                   tcu::Vec3((valueRamp.y() / w) / 2.0f, (valueRamp.y() / h) / 2.0f, m_coordMin.y()));
            function.matrix.setRow(2, tcu::Vec3(valueRamp.z() / w, valueRamp.z() / h, m_coordMin.z() + m_coordMin.z()) /
                                          2.0f);
            function.matrix.setRow(
                3, tcu::Vec3(-valueRamp.w() / w, -valueRamp.w() / h, m_coordMax.w() + m_coordMax.w()) / 2.0f);

            return reverifyConstantDerivateWithFlushRelaxations(m_testCtx.getLog(), result, errorMask, m_dataType,
                                                                m_precision, m_derivScale, m_derivBias,
                                                                surfaceThreshold, m_func, function);
        }
    }
    else
    {
        DE_ASSERT(m_func == DERIVATE_FWIDTH);
        const float w = float(result.getWidth());
        const float h = float(result.getHeight());

        const tcu::Vec4 dx          = ((m_coordMax - m_coordMin) / w) * xScale;
        const tcu::Vec4 dy          = ((m_coordMax - m_coordMin) / h) * yScale;
        const tcu::Vec4 reference   = tcu::abs(dx) + tcu::abs(dy);
        const tcu::Vec4 dxThreshold = getDerivateThreshold(m_precision, m_coordMin * xScale, m_coordMax * xScale, dx);
        const tcu::Vec4 dyThreshold = getDerivateThreshold(m_precision, m_coordMin * yScale, m_coordMax * yScale, dy);
        const tcu::Vec4 dxThresholdW =
            getDerivateThresholdWarning(m_precision, m_coordMin * xScale, m_coordMax * xScale, dx);
        const tcu::Vec4 dyThresholdW =
            getDerivateThresholdWarning(m_precision, m_coordMin * yScale, m_coordMax * yScale, dy);
        const tcu::Vec4 threshold  = max(surfaceThreshold, max(dxThreshold, dyThreshold));
        const tcu::Vec4 thresholdW = max(surfaceThreshold, max(dxThresholdW, dyThresholdW));
        qpTestResult testResult    = QP_TEST_RESULT_FAIL;

        testResult = verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType, reference, threshold,
                                            m_derivScale, m_derivBias);

        // return if result is pass
        if (testResult == QP_TEST_RESULT_PASS)
            return testResult;

        // re-check with relaxed threshold
        testResult = verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType, reference, thresholdW,
                                            m_derivScale, m_derivBias);

        // if with relaxed threshold test is passing then mark the result with quality warning.
        if (testResult == QP_TEST_RESULT_PASS)
            testResult = QP_TEST_RESULT_QUALITY_WARNING;

        return testResult;
    }
}

// TextureDerivateCase

class TextureDerivateCase : public TriangleDerivateCase
{
public:
    TextureDerivateCase(Context &context, const char *name, const char *description, DerivateFunc func,
                        glu::DataType type, glu::Precision precision, uint32_t hint, SurfaceType surfaceType,
                        int numSamples);
    ~TextureDerivateCase(void);

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

protected:
    void setupRenderState(uint32_t program);
    qpTestResult verify(const tcu::ConstPixelBufferAccess &result, const tcu::PixelBufferAccess &errorMask);

private:
    DerivateFunc m_func;

    tcu::Vec4 m_texValueMin;
    tcu::Vec4 m_texValueMax;
    glu::Texture2D *m_texture;
};

TextureDerivateCase::TextureDerivateCase(Context &context, const char *name, const char *description, DerivateFunc func,
                                         glu::DataType type, glu::Precision precision, uint32_t hint,
                                         SurfaceType surfaceType, int numSamples)
    : TriangleDerivateCase(context, name, description)
    , m_func(func)
    , m_texture(DE_NULL)
{
    m_dataType       = type;
    m_precision      = precision;
    m_coordDataType  = glu::TYPE_FLOAT_VEC2;
    m_coordPrecision = glu::PRECISION_HIGHP;
    m_hint           = hint;
    m_surfaceType    = surfaceType;
    m_numSamples     = numSamples;
}

TextureDerivateCase::~TextureDerivateCase(void)
{
    delete m_texture;
}

void TextureDerivateCase::init(void)
{
    // Generate shader
    {
        const char *fragmentTmpl = "#version 300 es\n"
                                   "in highp vec2 v_coord;\n"
                                   "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
                                   "uniform ${PRECISION} sampler2D u_sampler;\n"
                                   "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
                                   "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
                                   "void main (void)\n"
                                   "{\n"
                                   "    ${PRECISION} vec4 tex = texture(u_sampler, v_coord);\n"
                                   "    ${PRECISION} ${DATATYPE} res = ${FUNC}(tex${SWIZZLE}) * u_scale + u_bias;\n"
                                   "    o_color = ${CAST_TO_OUTPUT};\n"
                                   "}\n";

        const bool packToInt = m_surfaceType == SURFACETYPE_FLOAT_FBO;
        map<string, string> fragmentParams;

        fragmentParams["OUTPUT_TYPE"] = glu::getDataTypeName(packToInt ? glu::TYPE_UINT_VEC4 : glu::TYPE_FLOAT_VEC4);
        fragmentParams["OUTPUT_PREC"] = glu::getPrecisionName(packToInt ? glu::PRECISION_HIGHP : m_precision);
        fragmentParams["PRECISION"]   = glu::getPrecisionName(m_precision);
        fragmentParams["DATATYPE"]    = glu::getDataTypeName(m_dataType);
        fragmentParams["FUNC"]        = getDerivateFuncName(m_func);
        fragmentParams["SWIZZLE"]     = m_dataType == glu::TYPE_FLOAT_VEC4 ? "" :
                                        m_dataType == glu::TYPE_FLOAT_VEC3 ? ".xyz" :
                                        m_dataType == glu::TYPE_FLOAT_VEC2 ? ".xy" :
                                                                             /* TYPE_FLOAT */ ".x";

        if (packToInt)
        {
            fragmentParams["CAST_TO_OUTPUT"] =
                m_dataType == glu::TYPE_FLOAT_VEC4 ? "floatBitsToUint(res)" :
                m_dataType == glu::TYPE_FLOAT_VEC3 ? "floatBitsToUint(vec4(res, 1.0))" :
                m_dataType == glu::TYPE_FLOAT_VEC2 ? "floatBitsToUint(vec4(res, 0.0, 1.0))" :
                                                     /* TYPE_FLOAT */ "floatBitsToUint(vec4(res, 0.0, 0.0, 1.0))";
        }
        else
        {
            fragmentParams["CAST_TO_OUTPUT"] =
                m_dataType == glu::TYPE_FLOAT_VEC4 ? "res" :
                m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec4(res, 1.0)" :
                m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec4(res, 0.0, 1.0)" :
                                                     /* TYPE_FLOAT */ "vec4(res, 0.0, 0.0, 1.0)";
        }

        m_fragmentSrc = tcu::StringTemplate(fragmentTmpl).specialize(fragmentParams);
    }

    // Texture size matches viewport and nearest sampling is used. Thus texture sampling
    // is equal to just interpolating the texture value range.

    // Determine value range for texture.

    switch (m_precision)
    {
    case glu::PRECISION_HIGHP:
        m_texValueMin = tcu::Vec4(-97.f, 0.2f, 71.f, 74.f);
        m_texValueMax = tcu::Vec4(-13.2f, -77.f, 44.f, 76.f);
        break;

    case glu::PRECISION_MEDIUMP:
        m_texValueMin = tcu::Vec4(-37.0f, 47.f, -7.f, 0.0f);
        m_texValueMax = tcu::Vec4(-1.0f, 12.f, 7.f, 19.f);
        break;

    case glu::PRECISION_LOWP:
        m_texValueMin = tcu::Vec4(0.0f, -1.0f, 0.0f, 1.0f);
        m_texValueMax = tcu::Vec4(1.0f, 1.0f, -1.0f, -1.0f);
        break;

    default:
        DE_ASSERT(false);
    }

    // Lowp and mediump cases use RGBA16F format, while highp uses RGBA32F.
    {
        const tcu::IVec2 viewportSize = getViewportSize();
        DE_ASSERT(!m_texture);
        m_texture = new glu::Texture2D(m_context.getRenderContext(),
                                       m_precision == glu::PRECISION_HIGHP ? GL_RGBA32F : GL_RGBA16F, viewportSize.x(),
                                       viewportSize.y());
        m_texture->getRefTexture().allocLevel(0);
    }

    // Texture coordinates
    m_coordMin = tcu::Vec4(0.0f);
    m_coordMax = tcu::Vec4(1.0f);

    // Fill with gradients.
    {
        const tcu::PixelBufferAccess level0 = m_texture->getRefTexture().getLevel(0);
        for (int y = 0; y < level0.getHeight(); y++)
        {
            for (int x = 0; x < level0.getWidth(); x++)
            {
                const float xf = (float(x) + 0.5f) / float(level0.getWidth());
                const float yf = (float(y) + 0.5f) / float(level0.getHeight());
                // Make x and y data to have dependency to both axes so that dfdx(tex).y and dfdy(tex).x are nonzero.
                const tcu::Vec4 s =
                    tcu::Vec4(xf + yf / 2.0f, yf + xf / 2.0f, (xf + yf) / 2.0f, 1.0f - (xf + yf) / 2.0f);

                level0.setPixel(m_texValueMin + (m_texValueMax - m_texValueMin) * s, x, y);
            }
        }
    }

    m_texture->upload();

    if (m_surfaceType == SURFACETYPE_FLOAT_FBO)
    {
        // No scale or bias used for accuracy.
        m_derivScale = tcu::Vec4(1.0f);
        m_derivBias  = tcu::Vec4(0.0f);
    }
    else
    {
        // Compute scale - bias that normalizes to 0..1 range.
        const tcu::IVec2 viewportSize = getViewportSize();
        const float w                 = float(viewportSize.x());
        const float h                 = float(viewportSize.y());
        const tcu::Vec4 dx            = (m_texValueMax - m_texValueMin) / tcu::Vec4(w, w, w * 0.5f, -w * 0.5f);
        const tcu::Vec4 dy            = (m_texValueMax - m_texValueMin) / tcu::Vec4(h, h, h * 0.5f, -h * 0.5f);

        switch (m_func)
        {
        case DERIVATE_DFDX:
            m_derivScale = 0.5f / dx;
            break;

        case DERIVATE_DFDY:
            m_derivScale = 0.5f / dy;
            break;

        case DERIVATE_FWIDTH:
            m_derivScale = 0.5f / (tcu::abs(dx) + tcu::abs(dy));
            break;

        default:
            DE_ASSERT(false);
        }

        m_derivBias = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
    }
}

void TextureDerivateCase::deinit(void)
{
    delete m_texture;
    m_texture = DE_NULL;
}

void TextureDerivateCase::setupRenderState(uint32_t program)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    const int texUnit        = 1;

    gl.activeTexture(GL_TEXTURE0 + texUnit);
    gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
    gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    gl.uniform1i(gl.getUniformLocation(program, "u_sampler"), texUnit);
}

qpTestResult TextureDerivateCase::verify(const tcu::ConstPixelBufferAccess &result,
                                         const tcu::PixelBufferAccess &errorMask)
{
    // \note Edges are ignored in comparison
    if (result.getWidth() < 2 || result.getHeight() < 2)
        throw tcu::NotSupportedError("Too small viewport");

    tcu::ConstPixelBufferAccess compareArea =
        tcu::getSubregion(result, 1, 1, result.getWidth() - 2, result.getHeight() - 2);
    tcu::PixelBufferAccess maskArea =
        tcu::getSubregion(errorMask, 1, 1, errorMask.getWidth() - 2, errorMask.getHeight() - 2);
    const tcu::Vec4 xScale = tcu::Vec4(1.0f, 0.5f, 0.5f, -0.5f);
    const tcu::Vec4 yScale = tcu::Vec4(0.5f, 1.0f, 0.5f, -0.5f);
    const float w          = float(result.getWidth());
    const float h          = float(result.getHeight());

    const tcu::Vec4 surfaceThreshold = getSurfaceThreshold() / abs(m_derivScale);

    if (m_func == DERIVATE_DFDX || m_func == DERIVATE_DFDY)
    {
        const bool isX              = m_func == DERIVATE_DFDX;
        const float div             = isX ? w : h;
        const tcu::Vec4 scale       = isX ? xScale : yScale;
        tcu::Vec4 reference         = ((m_texValueMax - m_texValueMin) / div);
        const tcu::Vec4 opThreshold = getDerivateThreshold(m_precision, m_texValueMin, m_texValueMax, reference);
        const tcu::Vec4 opThresholdW =
            getDerivateThresholdWarning(m_precision, m_texValueMin, m_texValueMax, reference);
        const tcu::Vec4 threshold  = max(surfaceThreshold, opThreshold);
        const tcu::Vec4 thresholdW = max(surfaceThreshold, opThresholdW);
        const int numComps         = glu::getDataTypeFloatScalars(m_dataType);

        /* adjust the reference value for the correct dfdx or dfdy sample adjacency */
        reference = reference * scale;

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying result image.\n"
                           << "\tValid derivative is " << LogVecComps(reference, numComps) << " with threshold "
                           << LogVecComps(threshold, numComps) << tcu::TestLog::EndMessage;

        // short circuit if result is strictly within the normal value error bounds.
        // This improves performance significantly.
        if (verifyConstantDerivate(m_testCtx.getLog(), compareArea, maskArea, m_dataType, reference, threshold,
                                   m_derivScale, m_derivBias, LOG_NOTHING) == QP_TEST_RESULT_PASS)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "No incorrect derivatives found, result valid."
                               << tcu::TestLog::EndMessage;

            return QP_TEST_RESULT_PASS;
        }

        m_testCtx.getLog() << tcu::TestLog::Message << "Verifying result image.\n"
                           << "\tValid derivative is " << LogVecComps(reference, numComps) << " with Warning threshold "
                           << LogVecComps(thresholdW, numComps) << tcu::TestLog::EndMessage;

        // Re-check with relaxed threshold
        if (verifyConstantDerivate(m_testCtx.getLog(), compareArea, maskArea, m_dataType, reference, thresholdW,
                                   m_derivScale, m_derivBias, LOG_NOTHING) == QP_TEST_RESULT_PASS)
        {
            m_testCtx.getLog() << tcu::TestLog::Message
                               << "No incorrect derivatives found, result valid with quality warning."
                               << tcu::TestLog::EndMessage;

            return QP_TEST_RESULT_QUALITY_WARNING;
        }

        // some pixels exceed error bounds calculated for normal values. Verify that these
        // potentially invalid pixels are in fact valid due to (for example) subnorm flushing.

        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Initial verification failed, verifying image by calculating accurate error bounds for "
                              "each result pixel.\n"
                           << "\tVerifying each result derivative is within its range of legal result values."
                           << tcu::TestLog::EndMessage;

        {
            const tcu::Vec4 valueRamp = (m_texValueMax - m_texValueMin);
            Linear2DFunctionEvaluator function;

            function.matrix.setRow(0, tcu::Vec3(valueRamp.x() / w, (valueRamp.x() / h) / 2.0f, m_texValueMin.x()));
            function.matrix.setRow(1, tcu::Vec3((valueRamp.y() / w) / 2.0f, valueRamp.y() / h, m_texValueMin.y()));
            function.matrix.setRow(
                2, tcu::Vec3(valueRamp.z() / w, valueRamp.z() / h, m_texValueMin.z() + m_texValueMin.z()) / 2.0f);
            function.matrix.setRow(
                3, tcu::Vec3(-valueRamp.w() / w, -valueRamp.w() / h, m_texValueMax.w() + m_texValueMax.w()) / 2.0f);

            return reverifyConstantDerivateWithFlushRelaxations(m_testCtx.getLog(), compareArea, maskArea, m_dataType,
                                                                m_precision, m_derivScale, m_derivBias,
                                                                surfaceThreshold, m_func, function);
        }
    }
    else
    {
        DE_ASSERT(m_func == DERIVATE_FWIDTH);
        const tcu::Vec4 dx        = ((m_texValueMax - m_texValueMin) / w) * xScale;
        const tcu::Vec4 dy        = ((m_texValueMax - m_texValueMin) / h) * yScale;
        const tcu::Vec4 reference = tcu::abs(dx) + tcu::abs(dy);
        const tcu::Vec4 dxThreshold =
            getDerivateThreshold(m_precision, m_texValueMin * xScale, m_texValueMax * xScale, dx);
        const tcu::Vec4 dyThreshold =
            getDerivateThreshold(m_precision, m_texValueMin * yScale, m_texValueMax * yScale, dy);
        const tcu::Vec4 dxThresholdW =
            getDerivateThresholdWarning(m_precision, m_texValueMin * xScale, m_texValueMax * xScale, dx);
        const tcu::Vec4 dyThresholdW =
            getDerivateThresholdWarning(m_precision, m_texValueMin * yScale, m_texValueMax * yScale, dy);
        const tcu::Vec4 threshold  = max(surfaceThreshold, max(dxThreshold, dyThreshold));
        const tcu::Vec4 thresholdW = max(surfaceThreshold, max(dxThresholdW, dyThresholdW));
        qpTestResult testResult    = QP_TEST_RESULT_FAIL;

        testResult = verifyConstantDerivate(m_testCtx.getLog(), compareArea, maskArea, m_dataType, reference, threshold,
                                            m_derivScale, m_derivBias);

        if (testResult == QP_TEST_RESULT_PASS)
            return testResult;

        // Re-Check with relaxed threshold
        testResult = verifyConstantDerivate(m_testCtx.getLog(), compareArea, maskArea, m_dataType, reference,
                                            thresholdW, m_derivScale, m_derivBias);

        // If test is passing with relaxed threshold then mark quality warning
        if (testResult == QP_TEST_RESULT_PASS)
            testResult = QP_TEST_RESULT_QUALITY_WARNING;

        return testResult;
    }
}

ShaderDerivateTests::ShaderDerivateTests(Context &context)
    : TestCaseGroup(context, "derivate", "Derivate Function Tests")
{
}

ShaderDerivateTests::~ShaderDerivateTests(void)
{
}

struct FunctionSpec
{
    std::string name;
    DerivateFunc function;
    glu::DataType dataType;
    glu::Precision precision;

    FunctionSpec(const std::string &name_, DerivateFunc function_, glu::DataType dataType_, glu::Precision precision_)
        : name(name_)
        , function(function_)
        , dataType(dataType_)
        , precision(precision_)
    {
    }
};

void ShaderDerivateTests::init(void)
{
    static const struct
    {
        const char *name;
        const char *description;
        const char *source;
    } s_linearDerivateCases[] = {
        {"linear", "Basic derivate of linearly interpolated argument",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res = ${FUNC}(v_coord) * u_scale + u_bias;\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"in_function", "Derivate of linear function argument",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "\n"
         "${PRECISION} ${DATATYPE} computeRes (${PRECISION} ${DATATYPE} value)\n"
         "{\n"
         "    return ${FUNC}(v_coord) * u_scale + u_bias;\n"
         "}\n"
         "\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res = computeRes(v_coord);\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"static_if", "Derivate of linearly interpolated value in static if",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res;\n"
         "    if (false)\n"
         "        res = ${FUNC}(-v_coord) * u_scale + u_bias;\n"
         "    else\n"
         "        res = ${FUNC}(v_coord) * u_scale + u_bias;\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"static_loop", "Derivate of linearly interpolated value in static loop",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res = ${DATATYPE}(0.0);\n"
         "    for (int i = 0; i < 2; i++)\n"
         "        res += ${FUNC}(v_coord * float(i));\n"
         "    res = res * u_scale + u_bias;\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"static_switch", "Derivate of linearly interpolated value in static switch",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res;\n"
         "    switch (1)\n"
         "    {\n"
         "        case 0: res = ${FUNC}(-v_coord) * u_scale + u_bias;    break;\n"
         "        case 1: res = ${FUNC}(v_coord) * u_scale + u_bias;    break;\n"
         "    }\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"uniform_if", "Derivate of linearly interpolated value in uniform if",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "uniform bool ub_true;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res;\n"
         "    if (ub_true)"
         "        res = ${FUNC}(v_coord) * u_scale + u_bias;\n"
         "    else\n"
         "        res = ${FUNC}(-v_coord) * u_scale + u_bias;\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"uniform_loop", "Derivate of linearly interpolated value in uniform loop",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "uniform int ui_two;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res = ${DATATYPE}(0.0);\n"
         "    for (int i = 0; i < ui_two; i++)\n"
         "        res += ${FUNC}(v_coord * float(i));\n"
         "    res = res * u_scale + u_bias;\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
        {"uniform_switch", "Derivate of linearly interpolated value in uniform switch",

         "#version 300 es\n"
         "in ${PRECISION} ${DATATYPE} v_coord;\n"
         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
         "uniform int ui_one;\n"
         "void main (void)\n"
         "{\n"
         "    ${PRECISION} ${DATATYPE} res;\n"
         "    switch (ui_one)\n"
         "    {\n"
         "        case 0: res = ${FUNC}(-v_coord) * u_scale + u_bias;    break;\n"
         "        case 1: res = ${FUNC}(v_coord) * u_scale + u_bias;    break;\n"
         "    }\n"
         "    o_color = ${CAST_TO_OUTPUT};\n"
         "}\n"},
    };

    static const struct
    {
        const char *name;
        SurfaceType surfaceType;
        int numSamples;
    } s_fboConfigs[] = {
        {"fbo", SURFACETYPE_DEFAULT_FRAMEBUFFER, 0},
        {"fbo_msaa2", SURFACETYPE_UNORM_FBO, 2},
        {"fbo_msaa4", SURFACETYPE_UNORM_FBO, 4},
        {"fbo_float", SURFACETYPE_FLOAT_FBO, 0},
    };

    static const struct
    {
        const char *name;
        uint32_t hint;
    } s_hints[] = {
        {"fastest", GL_FASTEST},
        {"nicest", GL_NICEST},
    };

    static const struct
    {
        const char *name;
        SurfaceType surfaceType;
        int numSamples;
    } s_hintFboConfigs[] = {{"default", SURFACETYPE_DEFAULT_FRAMEBUFFER, 0},
                            {"fbo_msaa4", SURFACETYPE_UNORM_FBO, 4},
                            {"fbo_float", SURFACETYPE_FLOAT_FBO, 0}};

    static const struct
    {
        const char *name;
        SurfaceType surfaceType;
        int numSamples;
        uint32_t hint;
    } s_textureConfigs[] = {
        {"basic", SURFACETYPE_DEFAULT_FRAMEBUFFER, 0, GL_DONT_CARE},
        {"msaa4", SURFACETYPE_UNORM_FBO, 4, GL_DONT_CARE},
        {"float_fastest", SURFACETYPE_FLOAT_FBO, 0, GL_FASTEST},
        {"float_nicest", SURFACETYPE_FLOAT_FBO, 0, GL_NICEST},
    };

    // .dfdx, .dfdy, .fwidth
    for (int funcNdx = 0; funcNdx < DERIVATE_LAST; funcNdx++)
    {
        const DerivateFunc function = DerivateFunc(funcNdx);
        tcu::TestCaseGroup *const functionGroup =
            new tcu::TestCaseGroup(m_testCtx, getDerivateFuncCaseName(function), getDerivateFuncName(function));
        addChild(functionGroup);

        // .constant - no precision variants, checks that derivate of constant arguments is 0
        {
            tcu::TestCaseGroup *const constantGroup =
                new tcu::TestCaseGroup(m_testCtx, "constant", "Derivate of constant argument");
            functionGroup->addChild(constantGroup);

            for (int vecSize = 1; vecSize <= 4; vecSize++)
            {
                const glu::DataType dataType = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
                constantGroup->addChild(
                    new ConstantDerivateCase(m_context, glu::getDataTypeName(dataType), "", function, dataType));
            }
        }

        // Cases based on LinearDerivateCase
        for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(s_linearDerivateCases); caseNdx++)
        {
            tcu::TestCaseGroup *const linearCaseGroup = new tcu::TestCaseGroup(
                m_testCtx, s_linearDerivateCases[caseNdx].name, s_linearDerivateCases[caseNdx].description);
            const char *source = s_linearDerivateCases[caseNdx].source;
            functionGroup->addChild(linearCaseGroup);

            for (int vecSize = 1; vecSize <= 4; vecSize++)
            {
                for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
                {
                    const glu::DataType dataType   = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
                    const glu::Precision precision = glu::Precision(precNdx);
                    const SurfaceType surfaceType  = SURFACETYPE_DEFAULT_FRAMEBUFFER;
                    const int numSamples           = 0;
                    const uint32_t hint            = GL_DONT_CARE;
                    ostringstream caseName;

                    if (caseNdx != 0 && precision == glu::PRECISION_LOWP)
                        continue; // Skip as lowp doesn't actually produce any bits when rendered to default FB.

                    caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);

                    linearCaseGroup->addChild(new LinearDerivateCase(m_context, caseName.str().c_str(), "", function,
                                                                     dataType, precision, hint, surfaceType, numSamples,
                                                                     source));
                }
            }
        }

        // Fbo cases
        for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(s_fboConfigs); caseNdx++)
        {
            tcu::TestCaseGroup *const fboGroup =
                new tcu::TestCaseGroup(m_testCtx, s_fboConfigs[caseNdx].name, "Derivate usage when rendering into FBO");
            const char *source            = s_linearDerivateCases[0].source; // use source from .linear group
            const SurfaceType surfaceType = s_fboConfigs[caseNdx].surfaceType;
            const int numSamples          = s_fboConfigs[caseNdx].numSamples;
            functionGroup->addChild(fboGroup);

            for (int vecSize = 1; vecSize <= 4; vecSize++)
            {
                for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
                {
                    const glu::DataType dataType   = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
                    const glu::Precision precision = glu::Precision(precNdx);
                    const uint32_t hint            = GL_DONT_CARE;
                    ostringstream caseName;

                    if (surfaceType != SURFACETYPE_FLOAT_FBO && precision == glu::PRECISION_LOWP)
                        continue; // Skip as lowp doesn't actually produce any bits when rendered to U8 RT.

                    caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);

                    fboGroup->addChild(new LinearDerivateCase(m_context, caseName.str().c_str(), "", function, dataType,
                                                              precision, hint, surfaceType, numSamples, source));
                }
            }
        }

        // .fastest, .nicest
        for (int hintCaseNdx = 0; hintCaseNdx < DE_LENGTH_OF_ARRAY(s_hints); hintCaseNdx++)
        {
            tcu::TestCaseGroup *const hintGroup =
                new tcu::TestCaseGroup(m_testCtx, s_hints[hintCaseNdx].name, "Shader derivate hints");
            const char *source  = s_linearDerivateCases[0].source; // use source from .linear group
            const uint32_t hint = s_hints[hintCaseNdx].hint;
            functionGroup->addChild(hintGroup);

            for (int fboCaseNdx = 0; fboCaseNdx < DE_LENGTH_OF_ARRAY(s_hintFboConfigs); fboCaseNdx++)
            {
                tcu::TestCaseGroup *const fboGroup =
                    new tcu::TestCaseGroup(m_testCtx, s_hintFboConfigs[fboCaseNdx].name, "");
                const SurfaceType surfaceType = s_hintFboConfigs[fboCaseNdx].surfaceType;
                const int numSamples          = s_hintFboConfigs[fboCaseNdx].numSamples;
                hintGroup->addChild(fboGroup);

                for (int vecSize = 1; vecSize <= 4; vecSize++)
                {
                    for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
                    {
                        const glu::DataType dataType =
                            vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
                        const glu::Precision precision = glu::Precision(precNdx);
                        ostringstream caseName;

                        if (surfaceType != SURFACETYPE_FLOAT_FBO && precision == glu::PRECISION_LOWP)
                            continue; // Skip as lowp doesn't actually produce any bits when rendered to U8 RT.

                        caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);

                        fboGroup->addChild(new LinearDerivateCase(m_context, caseName.str().c_str(), "", function,
                                                                  dataType, precision, hint, surfaceType, numSamples,
                                                                  source));
                    }
                }
            }
        }

        // .texture
        {
            tcu::TestCaseGroup *const textureGroup =
                new tcu::TestCaseGroup(m_testCtx, "texture", "Derivate of texture lookup result");
            functionGroup->addChild(textureGroup);

            for (int texCaseNdx = 0; texCaseNdx < DE_LENGTH_OF_ARRAY(s_textureConfigs); texCaseNdx++)
            {
                tcu::TestCaseGroup *const caseGroup =
                    new tcu::TestCaseGroup(m_testCtx, s_textureConfigs[texCaseNdx].name, "");
                const SurfaceType surfaceType = s_textureConfigs[texCaseNdx].surfaceType;
                const int numSamples          = s_textureConfigs[texCaseNdx].numSamples;
                const uint32_t hint           = s_textureConfigs[texCaseNdx].hint;
                textureGroup->addChild(caseGroup);

                for (int vecSize = 1; vecSize <= 4; vecSize++)
                {
                    for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
                    {
                        const glu::DataType dataType =
                            vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
                        const glu::Precision precision = glu::Precision(precNdx);
                        ostringstream caseName;

                        if (surfaceType != SURFACETYPE_FLOAT_FBO && precision == glu::PRECISION_LOWP)
                            continue; // Skip as lowp doesn't actually produce any bits when rendered to U8 RT.

                        caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);

                        caseGroup->addChild(new TextureDerivateCase(m_context, caseName.str().c_str(), "", function,
                                                                    dataType, precision, hint, surfaceType,
                                                                    numSamples));
                    }
                }
            }
        }
    }
}

} // namespace Functional
} // namespace gles3
} // namespace deqp