/*-------------------------------------------------------------------------
 * 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 Transform feedback tests.
 *//*--------------------------------------------------------------------*/

#include "es3fTransformFeedbackTests.hpp"
#include "tcuTestLog.hpp"
#include "tcuSurface.hpp"
#include "tcuImageCompare.hpp"
#include "tcuVector.hpp"
#include "tcuFormatUtil.hpp"
#include "tcuRenderTarget.hpp"
#include "gluShaderUtil.hpp"
#include "gluVarType.hpp"
#include "gluVarTypeUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluObjectWrapper.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deMemory.h"
#include "deString.h"

#include <set>
#include <map>
#include <algorithm>

using std::set;
using std::string;
using std::vector;

using std::map;
using std::set;

using tcu::TestLog;

namespace deqp
{
namespace gles3
{
namespace Functional
{
namespace TransformFeedback
{

enum
{
    VIEWPORT_WIDTH  = 128,
    VIEWPORT_HEIGHT = 128,
    BUFFER_GUARD_MULTIPLIER =
        2 //!< stride*BUFFER_GUARD_MULTIPLIER bytes are added to the end of tf buffer and used to check for overruns.
};

enum Interpolation
{
    INTERPOLATION_SMOOTH = 0,
    INTERPOLATION_FLAT,
    INTERPOLATION_CENTROID,

    INTERPOLATION_LAST
};

static const char *getInterpolationName(Interpolation interp)
{
    switch (interp)
    {
    case INTERPOLATION_SMOOTH:
        return "smooth";
    case INTERPOLATION_FLAT:
        return "flat";
    case INTERPOLATION_CENTROID:
        return "centroid";
    default:
        DE_ASSERT(false);
        return DE_NULL;
    }
}

struct Varying
{
    Varying(const char *name_, const glu::VarType &type_, Interpolation interp_)
        : name(name_)
        , type(type_)
        , interpolation(interp_)
    {
    }

    std::string name;            //!< Variable name.
    glu::VarType type;           //!< Variable type.
    Interpolation interpolation; //!< Interpolation mode (smooth, flat, centroid).
};

struct VaryingNameEquals
{
    VaryingNameEquals(const std::string &name_) : name(name_)
    {
    }
    bool operator()(const Varying &var) const
    {
        return var.name == name;
    }

    std::string name;
};

struct Attribute
{
    Attribute(const std::string &name_, const glu::VarType &type_, int offset_)
        : name(name_)
        , type(type_)
        , offset(offset_)
    {
    }

    std::string name;
    glu::VarType type;
    int offset;
};

struct AttributeNameEquals
{
    AttributeNameEquals(const std::string &name_) : name(name_)
    {
    }
    bool operator()(const Attribute &attr) const
    {
        return attr.name == name;
    }

    std::string name;
};

struct Output
{
    Output(void) : bufferNdx(0), offset(0)
    {
    }

    std::string name;
    glu::VarType type;
    int bufferNdx;
    int offset;
    vector<const Attribute *> inputs;
};

struct DrawCall
{
    DrawCall(int numElements_, bool tfEnabled_) : numElements(numElements_), transformFeedbackEnabled(tfEnabled_)
    {
    }

    DrawCall(void) : numElements(0), transformFeedbackEnabled(false)
    {
    }

    int numElements;
    bool transformFeedbackEnabled;
};

std::ostream &operator<<(std::ostream &str, const DrawCall &call)
{
    return str << "(" << call.numElements << ", " << (call.transformFeedbackEnabled ? "resumed" : "paused") << ")";
}

class ProgramSpec
{
public:
    ProgramSpec(void);
    ~ProgramSpec(void);

    glu::StructType *createStruct(const char *name);
    void addVarying(const char *name, const glu::VarType &type, Interpolation interp);
    void addTransformFeedbackVarying(const char *name);

    const vector<glu::StructType *> &getStructs(void) const
    {
        return m_structs;
    }
    const vector<Varying> &getVaryings(void) const
    {
        return m_varyings;
    }
    const vector<string> &getTransformFeedbackVaryings(void) const
    {
        return m_transformFeedbackVaryings;
    }
    bool isPointSizeUsed(void) const;

private:
    ProgramSpec(const ProgramSpec &other);
    ProgramSpec &operator=(const ProgramSpec &other);

    vector<glu::StructType *> m_structs;
    vector<Varying> m_varyings;
    vector<string> m_transformFeedbackVaryings;
};

// ProgramSpec

ProgramSpec::ProgramSpec(void)
{
}

ProgramSpec::~ProgramSpec(void)
{
    for (vector<glu::StructType *>::iterator i = m_structs.begin(); i != m_structs.end(); i++)
        delete *i;
}

glu::StructType *ProgramSpec::createStruct(const char *name)
{
    m_structs.reserve(m_structs.size() + 1);
    m_structs.push_back(new glu::StructType(name));
    return m_structs.back();
}

void ProgramSpec::addVarying(const char *name, const glu::VarType &type, Interpolation interp)
{
    m_varyings.push_back(Varying(name, type, interp));
}

void ProgramSpec::addTransformFeedbackVarying(const char *name)
{
    m_transformFeedbackVaryings.push_back(name);
}

bool ProgramSpec::isPointSizeUsed(void) const
{
    return std::find(m_transformFeedbackVaryings.begin(), m_transformFeedbackVaryings.end(), "gl_PointSize") !=
           m_transformFeedbackVaryings.end();
}

static bool isProgramSupported(const glw::Functions &gl, const ProgramSpec &spec, uint32_t tfMode)
{
    int maxVertexAttribs           = 0;
    int maxTfInterleavedComponents = 0;
    int maxTfSeparateAttribs       = 0;
    int maxTfSeparateComponents    = 0;

    gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
    gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &maxTfInterleavedComponents);
    gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTfSeparateAttribs);
    gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, &maxTfSeparateComponents);

    // Check vertex attribs.
    int totalVertexAttribs = 1 /* a_position */ + (spec.isPointSizeUsed() ? 1 : 0);
    for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++)
    {
        for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&var->type);
             vecIter != glu::VectorTypeIterator::end(&var->type); vecIter++)
            totalVertexAttribs += 1;
    }

    if (totalVertexAttribs > maxVertexAttribs)
        return false; // Vertex attribute count exceeded.

    // Check varyings.
    int totalTfComponents = 0;
    int totalTfAttribs    = 0;
    for (vector<string>::const_iterator iter = spec.getTransformFeedbackVaryings().begin();
         iter != spec.getTransformFeedbackVaryings().end(); iter++)
    {
        const string &name = *iter;
        int numComponents  = 0;

        if (name == "gl_Position")
            numComponents = 4;
        else if (name == "gl_PointSize")
            numComponents = 1;
        else
        {
            string varName = glu::parseVariableName(name.c_str());
            const Varying &varying =
                *std::find_if(spec.getVaryings().begin(), spec.getVaryings().end(), VaryingNameEquals(varName));
            glu::TypeComponentVector varPath;

            glu::parseTypePath(name.c_str(), varying.type, varPath);
            numComponents = glu::getVarType(varying.type, varPath).getScalarSize();
        }

        if (tfMode == GL_SEPARATE_ATTRIBS && numComponents > maxTfSeparateComponents)
            return false; // Per-attribute component count exceeded.

        totalTfComponents += numComponents;
        totalTfAttribs += 1;
    }

    if (tfMode == GL_SEPARATE_ATTRIBS && totalTfAttribs > maxTfSeparateAttribs)
        return false;

    if (tfMode == GL_INTERLEAVED_ATTRIBS && totalTfComponents > maxTfInterleavedComponents)
        return false;

    return true;
}

// Program

static std::string getAttributeName(const char *varyingName, const glu::TypeComponentVector &path)
{
    std::ostringstream str;

    str << "a_" << (deStringBeginsWith(varyingName, "v_") ? varyingName + 2 : varyingName);

    for (glu::TypeComponentVector::const_iterator iter = path.begin(); iter != path.end(); iter++)
    {
        const char *prefix = DE_NULL;

        switch (iter->type)
        {
        case glu::VarTypeComponent::STRUCT_MEMBER:
            prefix = "_m";
            break;
        case glu::VarTypeComponent::ARRAY_ELEMENT:
            prefix = "_e";
            break;
        case glu::VarTypeComponent::MATRIX_COLUMN:
            prefix = "_c";
            break;
        case glu::VarTypeComponent::VECTOR_COMPONENT:
            prefix = "_s";
            break;
        default:
            DE_ASSERT(false);
        }

        str << prefix << iter->index;
    }

    return str.str();
}

static void genShaderSources(const ProgramSpec &spec, std::string &vertSource, std::string &fragSource,
                             bool pointSizeRequired)
{
    std::ostringstream vtx;
    std::ostringstream frag;
    bool addPointSize = spec.isPointSizeUsed();

    vtx << "#version 300 es\n"
        << "in highp vec4 a_position;\n";
    frag << "#version 300 es\n"
         << "layout(location = 0) out mediump vec4 o_color;\n"
         << "uniform highp vec4 u_scale;\n"
         << "uniform highp vec4 u_bias;\n";

    if (addPointSize)
        vtx << "in highp float a_pointSize;\n";

    // Declare attributes.
    for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++)
    {
        const char *name         = var->name.c_str();
        const glu::VarType &type = var->type;

        for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&type);
             vecIter != glu::VectorTypeIterator::end(&type); vecIter++)
        {
            glu::VarType attribType = glu::getVarType(type, vecIter.getPath());
            string attribName       = getAttributeName(name, vecIter.getPath());

            vtx << "in " << glu::declare(attribType, attribName.c_str()) << ";\n";
        }
    }

    // Declare vayrings.
    for (int ndx = 0; ndx < 2; ndx++)
    {
        const char *inout       = ndx ? "in" : "out";
        std::ostringstream &str = ndx ? frag : vtx;

        // Declare structs that have type name.
        for (vector<glu::StructType *>::const_iterator structIter = spec.getStructs().begin();
             structIter != spec.getStructs().end(); structIter++)
        {
            const glu::StructType *structPtr = *structIter;
            if (structPtr->hasTypeName())
                str << glu::declare(structPtr) << ";\n";
        }

        for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++)
            str << getInterpolationName(var->interpolation) << " " << inout << " "
                << glu::declare(var->type, var->name.c_str()) << ";\n";
    }

    vtx << "\nvoid main (void)\n{\n"
        << "\tgl_Position = a_position;\n";
    frag << "\nvoid main (void)\n{\n"
         << "\thighp vec4 res = vec4(0.0);\n";

    if (addPointSize)
        vtx << "\tgl_PointSize = a_pointSize;\n";
    else if (pointSizeRequired)
        vtx << "\tgl_PointSize = 1.0;\n";

    // Generate assignments / usage.
    for (vector<Varying>::const_iterator var = spec.getVaryings().begin(); var != spec.getVaryings().end(); var++)
    {
        const char *name         = var->name.c_str();
        const glu::VarType &type = var->type;

        for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&type);
             vecIter != glu::VectorTypeIterator::end(&type); vecIter++)
        {
            glu::VarType subType = glu::getVarType(type, vecIter.getPath());
            string attribName    = getAttributeName(name, vecIter.getPath());

            DE_ASSERT(subType.isBasicType() && glu::isDataTypeScalarOrVector(subType.getBasicType()));

            // Vertex: assign from attribute.
            vtx << "\t" << name << vecIter << " = " << attribName << ";\n";

            // Fragment: add to res variable.
            int scalarSize = glu::getDataTypeScalarSize(subType.getBasicType());

            frag << "\tres += ";
            if (scalarSize == 1)
                frag << "vec4(" << name << vecIter << ")";
            else if (scalarSize == 2)
                frag << "vec2(" << name << vecIter << ").xxyy";
            else if (scalarSize == 3)
                frag << "vec3(" << name << vecIter << ").xyzx";
            else if (scalarSize == 4)
                frag << "vec4(" << name << vecIter << ")";

            frag << ";\n";
        }
    }

    frag << "\to_color = res * u_scale + u_bias;\n";

    vtx << "}\n";
    frag << "}\n";

    vertSource = vtx.str();
    fragSource = frag.str();
}

static glu::ShaderProgram *createVertexCaptureProgram(const glu::RenderContext &context, const ProgramSpec &spec,
                                                      uint32_t bufferMode, uint32_t primitiveType)
{
    std::string vertSource, fragSource;

    genShaderSources(spec, vertSource, fragSource, primitiveType == GL_POINTS /* Is point size required? */);

    return new glu::ShaderProgram(context, glu::ProgramSources()
                                               << glu::VertexSource(vertSource) << glu::FragmentSource(fragSource)
                                               << glu::TransformFeedbackVaryings<vector<string>::const_iterator>(
                                                      spec.getTransformFeedbackVaryings().begin(),
                                                      spec.getTransformFeedbackVaryings().end())
                                               << glu::TransformFeedbackMode(bufferMode));
}

// Helpers.

static void computeInputLayout(vector<Attribute> &attributes, int &inputStride, const vector<Varying> &varyings,
                               bool usePointSize)
{
    inputStride = 0;

    // Add position.
    attributes.push_back(
        Attribute("a_position", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), inputStride));
    inputStride += 4 * (int)sizeof(uint32_t);

    if (usePointSize)
    {
        attributes.push_back(
            Attribute("a_pointSize", glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), inputStride));
        inputStride += 1 * (int)sizeof(uint32_t);
    }

    // Compute attribute vector.
    for (vector<Varying>::const_iterator var = varyings.begin(); var != varyings.end(); var++)
    {
        for (glu::VectorTypeIterator vecIter = glu::VectorTypeIterator::begin(&var->type);
             vecIter != glu::VectorTypeIterator::end(&var->type); vecIter++)
        {
            glu::VarType type = vecIter.getType();
            string name       = getAttributeName(var->name.c_str(), vecIter.getPath());

            attributes.push_back(Attribute(name, type, inputStride));
            inputStride += glu::getDataTypeScalarSize(type.getBasicType()) * (int)sizeof(uint32_t);
        }
    }
}

static void computeTransformFeedbackOutputs(vector<Output> &transformFeedbackOutputs,
                                            const vector<Attribute> &attributes, const vector<Varying> &varyings,
                                            const vector<string> &transformFeedbackVaryings, uint32_t bufferMode)
{
    int accumulatedSize = 0;

    transformFeedbackOutputs.resize(transformFeedbackVaryings.size());
    for (int varNdx = 0; varNdx < (int)transformFeedbackVaryings.size(); varNdx++)
    {
        const string &name = transformFeedbackVaryings[varNdx];
        int bufNdx         = (bufferMode == GL_SEPARATE_ATTRIBS ? varNdx : 0);
        int offset         = (bufferMode == GL_SEPARATE_ATTRIBS ? 0 : accumulatedSize);
        Output &output     = transformFeedbackOutputs[varNdx];

        output.name      = name;
        output.bufferNdx = bufNdx;
        output.offset    = offset;

        if (name == "gl_Position")
        {
            const Attribute *posIn =
                &(*std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_position")));
            output.type = posIn->type;
            output.inputs.push_back(posIn);
        }
        else if (name == "gl_PointSize")
        {
            const Attribute *sizeIn =
                &(*std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_pointSize")));
            output.type = sizeIn->type;
            output.inputs.push_back(sizeIn);
        }
        else
        {
            string varName         = glu::parseVariableName(name.c_str());
            const Varying &varying = *std::find_if(varyings.begin(), varyings.end(), VaryingNameEquals(varName));
            glu::TypeComponentVector varPath;

            glu::parseTypePath(name.c_str(), varying.type, varPath);

            output.type = glu::getVarType(varying.type, varPath);

            // Add all vectorized attributes as inputs.
            for (glu::VectorTypeIterator iter = glu::VectorTypeIterator::begin(&output.type);
                 iter != glu::VectorTypeIterator::end(&output.type); iter++)
            {
                // Full path.
                glu::TypeComponentVector fullPath(varPath.size() + iter.getPath().size());

                std::copy(varPath.begin(), varPath.end(), fullPath.begin());
                std::copy(iter.getPath().begin(), iter.getPath().end(), fullPath.begin() + varPath.size());

                string attribName = getAttributeName(varName.c_str(), fullPath);
                const Attribute *attrib =
                    &(*std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals(attribName)));

                output.inputs.push_back(attrib);
            }
        }

        accumulatedSize += output.type.getScalarSize() * (int)sizeof(uint32_t);
    }
}

static uint32_t signExtend(uint32_t value, uint32_t numBits)
{
    DE_ASSERT(numBits >= 1u && numBits <= 32u);
    if (numBits == 32u)
        return value;
    else if ((value & (1u << (numBits - 1u))) == 0u)
        return value;
    else
        return value | ~((1u << numBits) - 1u);
}

static void genAttributeData(const Attribute &attrib, uint8_t *basePtr, int stride, int numElements, de::Random &rnd)
{
    const int elementSize          = (int)sizeof(uint32_t);
    const bool isFloat             = glu::isDataTypeFloatOrVec(attrib.type.getBasicType());
    const bool isInt               = glu::isDataTypeIntOrIVec(attrib.type.getBasicType());
    const bool isUint              = glu::isDataTypeUintOrUVec(attrib.type.getBasicType());
    const glu::Precision precision = attrib.type.getPrecision();
    const int numComps             = glu::getDataTypeScalarSize(attrib.type.getBasicType());

    for (int elemNdx = 0; elemNdx < numElements; elemNdx++)
    {
        for (int compNdx = 0; compNdx < numComps; compNdx++)
        {
            int offset = attrib.offset + elemNdx * stride + compNdx * elementSize;
            if (isFloat)
            {
                float *comp = (float *)(basePtr + offset);
                switch (precision)
                {
                case glu::PRECISION_LOWP:
                    *comp = 0.0f + 0.25f * (float)rnd.getInt(0, 4);
                    break;
                case glu::PRECISION_MEDIUMP:
                    *comp = rnd.getFloat(-1e3f, 1e3f);
                    break;
                case glu::PRECISION_HIGHP:
                    *comp = rnd.getFloat(-1e5f, 1e5f);
                    break;
                default:
                    DE_ASSERT(false);
                }
            }
            else if (isInt)
            {
                int *comp = (int *)(basePtr + offset);
                switch (precision)
                {
                case glu::PRECISION_LOWP:
                    *comp = (int)signExtend(rnd.getUint32() & 0xff, 8);
                    break;
                case glu::PRECISION_MEDIUMP:
                    *comp = (int)signExtend(rnd.getUint32() & 0xffff, 16);
                    break;
                case glu::PRECISION_HIGHP:
                    *comp = (int)rnd.getUint32();
                    break;
                default:
                    DE_ASSERT(false);
                }
            }
            else if (isUint)
            {
                uint32_t *comp = (uint32_t *)(basePtr + offset);
                switch (precision)
                {
                case glu::PRECISION_LOWP:
                    *comp = rnd.getUint32() & 0xff;
                    break;
                case glu::PRECISION_MEDIUMP:
                    *comp = rnd.getUint32() & 0xffff;
                    break;
                case glu::PRECISION_HIGHP:
                    *comp = rnd.getUint32();
                    break;
                default:
                    DE_ASSERT(false);
                }
            }
            else
                DE_ASSERT(false);
        }
    }
}

static void genInputData(const vector<Attribute> &attributes, int numInputs, int inputStride, uint8_t *inputBasePtr,
                         de::Random &rnd)
{
    // Random positions.
    const Attribute &position = *std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_position"));

    for (int ndx = 0; ndx < numInputs; ndx++)
    {
        uint8_t *ptr           = inputBasePtr + position.offset + inputStride * ndx;
        *((float *)(ptr + 0))  = rnd.getFloat(-1.2f, 1.2f);
        *((float *)(ptr + 4))  = rnd.getFloat(-1.2f, 1.2f);
        *((float *)(ptr + 8))  = rnd.getFloat(-1.2f, 1.2f);
        *((float *)(ptr + 12)) = rnd.getFloat(0.1f, 2.0f);
    }

    // Point size.
    vector<Attribute>::const_iterator pointSizePos =
        std::find_if(attributes.begin(), attributes.end(), AttributeNameEquals("a_pointSize"));
    if (pointSizePos != attributes.end())
    {
        for (int ndx = 0; ndx < numInputs; ndx++)
        {
            uint8_t *ptr    = inputBasePtr + pointSizePos->offset + inputStride * ndx;
            *((float *)ptr) = rnd.getFloat(1.0f, 8.0f);
        }
    }

    // Random data for rest of components.
    for (vector<Attribute>::const_iterator attrib = attributes.begin(); attrib != attributes.end(); attrib++)
    {
        if (attrib->name == "a_position" || attrib->name == "a_pointSize")
            continue;

        genAttributeData(*attrib, inputBasePtr, inputStride, numInputs, rnd);
    }
}

static uint32_t getTransformFeedbackOutputCount(uint32_t primitiveType, int numElements)
{
    switch (primitiveType)
    {
    case GL_TRIANGLES:
        return numElements - numElements % 3;
    case GL_TRIANGLE_STRIP:
        return de::max(0, numElements - 2) * 3;
    case GL_TRIANGLE_FAN:
        return de::max(0, numElements - 2) * 3;
    case GL_LINES:
        return numElements - numElements % 2;
    case GL_LINE_STRIP:
        return de::max(0, numElements - 1) * 2;
    case GL_LINE_LOOP:
        return numElements > 1 ? numElements * 2 : 0;
    case GL_POINTS:
        return numElements;

    default:
        DE_ASSERT(false);
        return 0;
    }
}

static uint32_t getTransformFeedbackPrimitiveCount(uint32_t primitiveType, int numElements)
{
    switch (primitiveType)
    {
    case GL_TRIANGLES:
        return numElements / 3;
    case GL_TRIANGLE_STRIP:
        return de::max(0, numElements - 2);
    case GL_TRIANGLE_FAN:
        return de::max(0, numElements - 2);
    case GL_LINES:
        return numElements / 2;
    case GL_LINE_STRIP:
        return de::max(0, numElements - 1);
    case GL_LINE_LOOP:
        return numElements > 1 ? numElements : 0;
    case GL_POINTS:
        return numElements;

    default:
        DE_ASSERT(false);
        return 0;
    }
}

static uint32_t getTransformFeedbackPrimitiveMode(uint32_t primitiveType)
{
    switch (primitiveType)
    {
    case GL_TRIANGLES:
    case GL_TRIANGLE_STRIP:
    case GL_TRIANGLE_FAN:
        return GL_TRIANGLES;

    case GL_LINES:
    case GL_LINE_LOOP:
    case GL_LINE_STRIP:
        return GL_LINES;

    case GL_POINTS:
        return GL_POINTS;

    default:
        DE_ASSERT(false);
        return 0;
    }
}

static int getAttributeIndex(uint32_t primitiveType, int numInputs, int outNdx)
{
    switch (primitiveType)
    {
    case GL_TRIANGLES:
        return outNdx;
    case GL_LINES:
        return outNdx;
    case GL_POINTS:
        return outNdx;

    case GL_TRIANGLE_STRIP:
    {
        int triNdx = outNdx / 3;
        int vtxNdx = outNdx % 3;
        return (triNdx % 2 != 0 && vtxNdx < 2) ? (triNdx + 1 - vtxNdx) : (triNdx + vtxNdx);
    }

    case GL_TRIANGLE_FAN:
        return (outNdx % 3 != 0) ? (outNdx / 3 + outNdx % 3) : 0;

    case GL_LINE_STRIP:
        return outNdx / 2 + outNdx % 2;

    case GL_LINE_LOOP:
    {
        int inNdx = outNdx / 2 + outNdx % 2;
        return inNdx < numInputs ? inNdx : 0;
    }

    default:
        DE_ASSERT(false);
        return 0;
    }
}

static bool compareTransformFeedbackOutput(tcu::TestLog &log, uint32_t primitiveType, const Output &output,
                                           int numInputs, const uint8_t *inBasePtr, int inStride,
                                           const uint8_t *outBasePtr, int outStride)
{
    bool isOk     = true;
    int outOffset = output.offset;

    for (int attrNdx = 0; attrNdx < (int)output.inputs.size(); attrNdx++)
    {
        const Attribute &attribute = *output.inputs[attrNdx];
        glu::DataType type         = attribute.type.getBasicType();
        int numComponents          = glu::getDataTypeScalarSize(type);
        glu::Precision precision   = attribute.type.getPrecision();
        glu::DataType scalarType   = glu::getDataTypeScalarType(type);
        int numOutputs             = getTransformFeedbackOutputCount(primitiveType, numInputs);

        for (int outNdx = 0; outNdx < numOutputs; outNdx++)
        {
            int inNdx = getAttributeIndex(primitiveType, numInputs, outNdx);

            for (int compNdx = 0; compNdx < numComponents; compNdx++)
            {
                const uint8_t *inPtr  = inBasePtr + inStride * inNdx + attribute.offset + compNdx * sizeof(uint32_t);
                const uint8_t *outPtr = outBasePtr + outStride * outNdx + outOffset + compNdx * sizeof(uint32_t);
                uint32_t inVal        = *(const uint32_t *)inPtr;
                uint32_t outVal       = *(const uint32_t *)outPtr;
                bool isEqual          = false;

                if (scalarType == glu::TYPE_FLOAT)
                {
                    // ULP comparison is used for highp and mediump. Lowp uses threshold-comparison.
                    switch (precision)
                    {
                    case glu::PRECISION_HIGHP:
                        isEqual = de::abs((int)inVal - (int)outVal) < 2;
                        break;
                    case glu::PRECISION_MEDIUMP:
                        isEqual = de::abs((int)inVal - (int)outVal) < 2 + (1 << 13);
                        break;
                    case glu::PRECISION_LOWP:
                    {
                        float inF  = *(const float *)inPtr;
                        float outF = *(const float *)outPtr;
                        isEqual    = de::abs(inF - outF) < 0.1f;
                        break;
                    }
                    default:
                        DE_ASSERT(false);
                    }
                }
                else
                    isEqual = (inVal == outVal); // Bit-exact match required for integer types.

                if (!isEqual)
                {
                    log << TestLog::Message << "Mismatch in " << output.name << " (" << attribute.name
                        << "), output = " << outNdx << ", input = " << inNdx << ", component = " << compNdx
                        << TestLog::EndMessage;
                    isOk = false;
                    break;
                }
            }

            if (!isOk)
                break;
        }

        if (!isOk)
            break;

        outOffset += numComponents * (int)sizeof(uint32_t);
    }

    return isOk;
}

static int computeTransformFeedbackPrimitiveCount(uint32_t primitiveType, const DrawCall *first, const DrawCall *end)
{
    int primCount = 0;

    for (const DrawCall *call = first; call != end; ++call)
    {
        if (call->transformFeedbackEnabled)
            primCount += getTransformFeedbackPrimitiveCount(primitiveType, call->numElements);
    }

    return primCount;
}

static void writeBufferGuard(const glw::Functions &gl, uint32_t target, int bufferSize, int guardSize)
{
    uint8_t *ptr = (uint8_t *)gl.mapBufferRange(target, bufferSize, guardSize, GL_MAP_WRITE_BIT);
    if (ptr)
        deMemset(ptr, 0xcd, guardSize);
    gl.unmapBuffer(target);
    GLU_EXPECT_NO_ERROR(gl.getError(), "guardband write");
}

static bool verifyGuard(const uint8_t *ptr, int guardSize)
{
    for (int ndx = 0; ndx < guardSize; ndx++)
    {
        if (ptr[ndx] != 0xcd)
            return false;
    }
    return true;
}

static void logTransformFeedbackVaryings(TestLog &log, const glw::Functions &gl, uint32_t program)
{
    int numTfVaryings = 0;
    int maxNameLen    = 0;

    gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYINGS, &numTfVaryings);
    gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &maxNameLen);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Query TF varyings");

    log << TestLog::Message << "GL_TRANSFORM_FEEDBACK_VARYINGS = " << numTfVaryings << TestLog::EndMessage;

    vector<char> nameBuf(maxNameLen + 1);

    for (int ndx = 0; ndx < numTfVaryings; ndx++)
    {
        glw::GLsizei size = 0;
        glw::GLenum type  = 0;

        gl.getTransformFeedbackVarying(program, ndx, (glw::GLsizei)nameBuf.size(), DE_NULL, &size, &type, &nameBuf[0]);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTransformFeedbackVarying()");

        const glu::DataType dataType = glu::getDataTypeFromGLType(type);
        const std::string typeName   = dataType != glu::TYPE_LAST ?
                                           std::string(glu::getDataTypeName(dataType)) :
                                           (std::string("unknown(") + tcu::toHex(type).toString() + ")");

        log << TestLog::Message << (const char *)&nameBuf[0] << ": " << typeName << "[" << size << "]"
            << TestLog::EndMessage;
    }
}

class TransformFeedbackCase : public TestCase
{
public:
    TransformFeedbackCase(Context &context, const char *name, const char *desc, uint32_t bufferMode,
                          uint32_t primitiveType);
    ~TransformFeedbackCase(void);

    void init(void);
    void deinit(void);
    IterateResult iterate(void);

protected:
    ProgramSpec m_progSpec;
    uint32_t m_bufferMode;
    uint32_t m_primitiveType;

private:
    TransformFeedbackCase(const TransformFeedbackCase &other);
    TransformFeedbackCase &operator=(const TransformFeedbackCase &other);

    bool runTest(const DrawCall *first, const DrawCall *end, uint32_t seed);

    // Derived from ProgramSpec in init()
    int m_inputStride;
    vector<Attribute> m_attributes;
    vector<Output> m_transformFeedbackOutputs;
    vector<int> m_bufferStrides;

    // GL state.
    glu::ShaderProgram *m_program;
    glu::TransformFeedback *m_transformFeedback;
    vector<uint32_t> m_outputBuffers;

    int m_iterNdx;
};

TransformFeedbackCase::TransformFeedbackCase(Context &context, const char *name, const char *desc, uint32_t bufferMode,
                                             uint32_t primitiveType)
    : TestCase(context, name, desc)
    , m_bufferMode(bufferMode)
    , m_primitiveType(primitiveType)
    , m_inputStride(0)
    , m_program(DE_NULL)
    , m_transformFeedback(DE_NULL)
    , m_iterNdx(0)
{
}

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

static bool hasArraysInTFVaryings(const ProgramSpec &spec)
{
    for (vector<string>::const_iterator tfVar = spec.getTransformFeedbackVaryings().begin();
         tfVar != spec.getTransformFeedbackVaryings().end(); ++tfVar)
    {
        string varName = glu::parseVariableName(tfVar->c_str());
        vector<Varying>::const_iterator varIter =
            std::find_if(spec.getVaryings().begin(), spec.getVaryings().end(), VaryingNameEquals(varName));

        if (varName == "gl_Position" || varName == "gl_PointSize")
            continue;

        DE_ASSERT(varIter != spec.getVaryings().end());

        if (varIter->type.isArrayType())
            return true;
    }

    return false;
}

void TransformFeedbackCase::init(void)
{
    TestLog &log             = m_testCtx.getLog();
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    DE_ASSERT(!m_program);
    m_program = createVertexCaptureProgram(m_context.getRenderContext(), m_progSpec, m_bufferMode, m_primitiveType);

    log << *m_program;
    if (!m_program->isOk())
    {
        const bool linkFail = m_program->getShaderInfo(glu::SHADERTYPE_VERTEX).compileOk &&
                              m_program->getShaderInfo(glu::SHADERTYPE_FRAGMENT).compileOk &&
                              !m_program->getProgramInfo().linkOk;

        if (linkFail)
        {
            if (!isProgramSupported(gl, m_progSpec, m_bufferMode))
                throw tcu::NotSupportedError("Implementation limits execeeded", "", __FILE__, __LINE__);
            else if (hasArraysInTFVaryings(m_progSpec))
                throw tcu::NotSupportedError("Capturing arrays is not supported (undefined in specification)", "",
                                             __FILE__, __LINE__);
            else
                throw tcu::TestError("Link failed", "", __FILE__, __LINE__);
        }
        else
            throw tcu::TestError("Compile failed", "", __FILE__, __LINE__);
    }

    log << TestLog::Message << "Transform feedback varyings: "
        << tcu::formatArray(m_progSpec.getTransformFeedbackVaryings().begin(),
                            m_progSpec.getTransformFeedbackVaryings().end())
        << TestLog::EndMessage;

    // Print out transform feedback points reported by GL.
    log << TestLog::Message << "Transform feedback varyings reported by compiler:" << TestLog::EndMessage;
    logTransformFeedbackVaryings(log, gl, m_program->getProgram());

    // Compute input specification.
    computeInputLayout(m_attributes, m_inputStride, m_progSpec.getVaryings(), m_progSpec.isPointSizeUsed());

    // Build list of varyings used in transform feedback.
    computeTransformFeedbackOutputs(m_transformFeedbackOutputs, m_attributes, m_progSpec.getVaryings(),
                                    m_progSpec.getTransformFeedbackVaryings(), m_bufferMode);
    DE_ASSERT(!m_transformFeedbackOutputs.empty());

    // Buffer strides.
    DE_ASSERT(m_bufferStrides.empty());
    if (m_bufferMode == GL_SEPARATE_ATTRIBS)
    {
        for (vector<Output>::const_iterator outIter = m_transformFeedbackOutputs.begin();
             outIter != m_transformFeedbackOutputs.end(); outIter++)
            m_bufferStrides.push_back(outIter->type.getScalarSize() * (int)sizeof(uint32_t));
    }
    else
    {
        int totalSize = 0;
        for (vector<Output>::const_iterator outIter = m_transformFeedbackOutputs.begin();
             outIter != m_transformFeedbackOutputs.end(); outIter++)
            totalSize += outIter->type.getScalarSize() * (int)sizeof(uint32_t);

        m_bufferStrides.push_back(totalSize);
    }

    // \note Actual storage is allocated in iterate().
    m_outputBuffers.resize(m_bufferStrides.size());
    gl.genBuffers((glw::GLsizei)m_outputBuffers.size(), &m_outputBuffers[0]);

    DE_ASSERT(!m_transformFeedback);
    m_transformFeedback = new glu::TransformFeedback(m_context.getRenderContext());

    GLU_EXPECT_NO_ERROR(gl.getError(), "init");

    m_iterNdx = 0;
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}

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

    if (!m_outputBuffers.empty())
    {
        gl.deleteBuffers((glw::GLsizei)m_outputBuffers.size(), &m_outputBuffers[0]);
        m_outputBuffers.clear();
    }

    delete m_transformFeedback;
    m_transformFeedback = DE_NULL;

    delete m_program;
    m_program = DE_NULL;

    // Clean up state.
    m_attributes.clear();
    m_transformFeedbackOutputs.clear();
    m_bufferStrides.clear();
    m_inputStride = 0;
}

TransformFeedbackCase::IterateResult TransformFeedbackCase::iterate(void)
{
    // Test cases.
    static const DrawCall s_elemCount1[]   = {DrawCall(1, true)};
    static const DrawCall s_elemCount2[]   = {DrawCall(2, true)};
    static const DrawCall s_elemCount3[]   = {DrawCall(3, true)};
    static const DrawCall s_elemCount4[]   = {DrawCall(4, true)};
    static const DrawCall s_elemCount123[] = {DrawCall(123, true)};
    static const DrawCall s_basicPause1[]  = {DrawCall(64, true), DrawCall(64, false), DrawCall(64, true)};
    static const DrawCall s_basicPause2[]  = {DrawCall(13, true), DrawCall(5, true), DrawCall(17, false),
                                              DrawCall(3, true), DrawCall(7, false)};
    static const DrawCall s_startPaused[]  = {DrawCall(123, false), DrawCall(123, true)};
    static const DrawCall s_random1[]      = {DrawCall(65, true),  DrawCall(135, false), DrawCall(74, true),
                                              DrawCall(16, false), DrawCall(226, false), DrawCall(9, true),
                                              DrawCall(174, false)};
    static const DrawCall s_random2[]      = {DrawCall(217, true), DrawCall(171, true), DrawCall(147, true),
                                              DrawCall(152, false), DrawCall(55, true)};

    static const struct
    {
        const DrawCall *calls;
        int numCalls;
    } s_iterations[] = {
#define ITER(ARR) {ARR, DE_LENGTH_OF_ARRAY(ARR)}
        ITER(s_elemCount1),   ITER(s_elemCount2),  ITER(s_elemCount3),  ITER(s_elemCount4),
        ITER(s_elemCount123), ITER(s_basicPause1), ITER(s_basicPause2), ITER(s_startPaused),
        ITER(s_random1),      ITER(s_random2)
#undef ITER
    };

    TestLog &log          = m_testCtx.getLog();
    bool isOk             = true;
    uint32_t seed         = deStringHash(getName()) ^ deInt32Hash(m_iterNdx);
    int numIterations     = DE_LENGTH_OF_ARRAY(s_iterations);
    const DrawCall *first = s_iterations[m_iterNdx].calls;
    const DrawCall *end   = s_iterations[m_iterNdx].calls + s_iterations[m_iterNdx].numCalls;

    std::string sectionName = std::string("Iteration") + de::toString(m_iterNdx + 1);
    std::string sectionDesc =
        std::string("Iteration ") + de::toString(m_iterNdx + 1) + " / " + de::toString(numIterations);
    tcu::ScopedLogSection section(log, sectionName, sectionDesc);

    log << TestLog::Message << "Testing " << s_iterations[m_iterNdx].numCalls
        << " draw calls, (element count, TF state): " << tcu::formatArray(first, end) << TestLog::EndMessage;

    isOk = runTest(first, end, seed);

    if (!isOk)
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result comparison failed");

    m_iterNdx += 1;
    return (isOk && m_iterNdx < numIterations) ? CONTINUE : STOP;
}

bool TransformFeedbackCase::runTest(const DrawCall *first, const DrawCall *end, uint32_t seed)
{
    TestLog &log             = m_testCtx.getLog();
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    de::Random rnd(seed);
    int numInputs  = 0; //!< Sum of element counts in calls.
    int numOutputs = 0; //!< Sum of output counts for calls that have transform feedback enabled.
    int width      = m_context.getRenderContext().getRenderTarget().getWidth();
    int height     = m_context.getRenderContext().getRenderTarget().getHeight();
    int viewportW  = de::min((int)VIEWPORT_WIDTH, width);
    int viewportH  = de::min((int)VIEWPORT_HEIGHT, height);
    int viewportX  = rnd.getInt(0, width - viewportW);
    int viewportY  = rnd.getInt(0, height - viewportH);
    tcu::Surface frameWithTf(viewportW, viewportH);
    tcu::Surface frameWithoutTf(viewportW, viewportH);
    glu::Query primitiveQuery(m_context.getRenderContext());
    bool outputsOk = true;
    bool imagesOk  = true;
    bool queryOk   = true;

    // Compute totals.
    for (const DrawCall *call = first; call != end; call++)
    {
        numInputs += call->numElements;
        numOutputs +=
            call->transformFeedbackEnabled ? getTransformFeedbackOutputCount(m_primitiveType, call->numElements) : 0;
    }

    // Input data.
    vector<uint8_t> inputData(m_inputStride * numInputs);
    genInputData(m_attributes, numInputs, m_inputStride, &inputData[0], rnd);

    gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback->get());
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback()");

    // Allocate storage for transform feedback output buffers and bind to targets.
    for (int bufNdx = 0; bufNdx < (int)m_outputBuffers.size(); bufNdx++)
    {
        uint32_t buffer      = m_outputBuffers[bufNdx];
        int stride           = m_bufferStrides[bufNdx];
        int target           = bufNdx;
        int size             = stride * numOutputs;
        int guardSize        = stride * BUFFER_GUARD_MULTIPLIER;
        const uint32_t usage = GL_DYNAMIC_READ;

        gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer);
        gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, size + guardSize, DE_NULL, usage);
        writeBufferGuard(gl, GL_TRANSFORM_FEEDBACK_BUFFER, size, guardSize);

        // \todo [2012-07-30 pyry] glBindBufferRange()?
        gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, target, buffer);

        GLU_EXPECT_NO_ERROR(gl.getError(), "transform feedback buffer setup");
    }

    // Setup attributes.
    for (vector<Attribute>::const_iterator attrib = m_attributes.begin(); attrib != m_attributes.end(); attrib++)
    {
        int loc                  = gl.getAttribLocation(m_program->getProgram(), attrib->name.c_str());
        glu::DataType scalarType = glu::getDataTypeScalarType(attrib->type.getBasicType());
        int numComponents        = glu::getDataTypeScalarSize(attrib->type.getBasicType());
        const void *ptr          = &inputData[0] + attrib->offset;

        if (loc >= 0)
        {
            gl.enableVertexAttribArray(loc);

            if (scalarType == glu::TYPE_FLOAT)
                gl.vertexAttribPointer(loc, numComponents, GL_FLOAT, GL_FALSE, m_inputStride, ptr);
            else if (scalarType == glu::TYPE_INT)
                gl.vertexAttribIPointer(loc, numComponents, GL_INT, m_inputStride, ptr);
            else if (scalarType == glu::TYPE_UINT)
                gl.vertexAttribIPointer(loc, numComponents, GL_UNSIGNED_INT, m_inputStride, ptr);
        }
    }

    // Setup viewport.
    gl.viewport(viewportX, viewportY, viewportW, viewportH);

    // Setup program.
    gl.useProgram(m_program->getProgram());

    gl.uniform4fv(gl.getUniformLocation(m_program->getProgram(), "u_scale"), 1, tcu::Vec4(0.01f).getPtr());
    gl.uniform4fv(gl.getUniformLocation(m_program->getProgram(), "u_bias"), 1, tcu::Vec4(0.5f).getPtr());

    // Enable query.
    gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, *primitiveQuery);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN)");

    // Draw.
    {
        int offset     = 0;
        bool tfEnabled = true;

        gl.clear(GL_COLOR_BUFFER_BIT);

        gl.beginTransformFeedback(getTransformFeedbackPrimitiveMode(m_primitiveType));

        for (const DrawCall *call = first; call != end; call++)
        {
            // Pause or resume transform feedback if necessary.
            if (call->transformFeedbackEnabled != tfEnabled)
            {
                if (call->transformFeedbackEnabled)
                    gl.resumeTransformFeedback();
                else
                    gl.pauseTransformFeedback();
                tfEnabled = call->transformFeedbackEnabled;
            }

            gl.drawArrays(m_primitiveType, offset, call->numElements);
            offset += call->numElements;
        }

        // Resume feedback before finishing it.
        if (!tfEnabled)
            gl.resumeTransformFeedback();

        gl.endTransformFeedback();
        GLU_EXPECT_NO_ERROR(gl.getError(), "render");
    }

    gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN)");

    // Check and log query status right after submit
    {
        uint32_t available = GL_FALSE;
        gl.getQueryObjectuiv(*primitiveQuery, GL_QUERY_RESULT_AVAILABLE, &available);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv()");

        log << TestLog::Message << "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN status after submit: "
            << (available != GL_FALSE ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
    }

    // Compare result buffers.
    for (int bufferNdx = 0; bufferNdx < (int)m_outputBuffers.size(); bufferNdx++)
    {
        uint32_t buffer    = m_outputBuffers[bufferNdx];
        int stride         = m_bufferStrides[bufferNdx];
        int size           = stride * numOutputs;
        int guardSize      = stride * BUFFER_GUARD_MULTIPLIER;
        const void *bufPtr = DE_NULL;

        // Bind buffer for reading.
        gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer);
        bufPtr = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size + guardSize, GL_MAP_READ_BIT);
        GLU_EXPECT_NO_ERROR(gl.getError(), "mapping buffer");

        // Verify all output variables that are written to this buffer.
        for (vector<Output>::const_iterator out = m_transformFeedbackOutputs.begin();
             out != m_transformFeedbackOutputs.end(); out++)
        {
            if (out->bufferNdx != bufferNdx)
                continue;

            int inputOffset  = 0;
            int outputOffset = 0;

            // Process all draw calls and check ones with transform feedback enabled.
            for (const DrawCall *call = first; call != end; call++)
            {
                if (call->transformFeedbackEnabled)
                {
                    const uint8_t *inputPtr  = &inputData[0] + inputOffset * m_inputStride;
                    const uint8_t *outputPtr = (const uint8_t *)bufPtr + outputOffset * stride;

                    if (!compareTransformFeedbackOutput(log, m_primitiveType, *out, call->numElements, inputPtr,
                                                        m_inputStride, outputPtr, stride))
                    {
                        outputsOk = false;
                        break;
                    }
                }

                inputOffset += call->numElements;
                outputOffset += call->transformFeedbackEnabled ?
                                    getTransformFeedbackOutputCount(m_primitiveType, call->numElements) :
                                    0;
            }
        }

        // Verify guardband.
        if (!verifyGuard((const uint8_t *)bufPtr + size, guardSize))
        {
            log << TestLog::Message << "Error: Transform feedback buffer overrun detected" << TestLog::EndMessage;
            outputsOk = false;
        }

        gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
    }

    // Check status after mapping buffers.
    {
        const bool mustBeReady  = !m_outputBuffers.empty(); // Mapping buffer forces synchronization.
        const int expectedCount = computeTransformFeedbackPrimitiveCount(m_primitiveType, first, end);
        uint32_t available      = GL_FALSE;
        uint32_t numPrimitives  = 0;

        gl.getQueryObjectuiv(*primitiveQuery, GL_QUERY_RESULT_AVAILABLE, &available);
        gl.getQueryObjectuiv(*primitiveQuery, GL_QUERY_RESULT, &numPrimitives);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv()");

        if (!mustBeReady && available == GL_FALSE)
        {
            log << TestLog::Message
                << "ERROR: GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN result not available after mapping buffers!"
                << TestLog::EndMessage;
            queryOk = false;
        }

        log << TestLog::Message << "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = " << numPrimitives
            << TestLog::EndMessage;

        if ((int)numPrimitives != expectedCount)
        {
            log << TestLog::Message << "ERROR: Expected " << expectedCount << " primitives!" << TestLog::EndMessage;
            queryOk = false;
        }
    }

    // Clear transform feedback state.
    gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
    for (int bufNdx = 0; bufNdx < (int)m_outputBuffers.size(); bufNdx++)
    {
        gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0);
        gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, bufNdx, 0);
    }

    // Read back rendered image.
    glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, frameWithTf.getAccess());

    // Render without transform feedback.
    {
        int offset = 0;

        gl.clear(GL_COLOR_BUFFER_BIT);

        for (const DrawCall *call = first; call != end; call++)
        {
            gl.drawArrays(m_primitiveType, offset, call->numElements);
            offset += call->numElements;
        }

        GLU_EXPECT_NO_ERROR(gl.getError(), "render");
        glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, frameWithoutTf.getAccess());
    }

    // Compare images with and without transform feedback.
    imagesOk = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", frameWithoutTf, frameWithTf,
                                          tcu::RGBA(1, 1, 1, 1), tcu::COMPARE_LOG_ON_ERROR);

    if (imagesOk)
        m_testCtx.getLog() << TestLog::Message
                           << "Rendering result comparison between TF enabled and TF disabled passed."
                           << TestLog::EndMessage;
    else
        m_testCtx.getLog() << TestLog::Message
                           << "ERROR: Rendering result comparison between TF enabled and TF disabled failed!"
                           << TestLog::EndMessage;

    return outputsOk && imagesOk && queryOk;
}

// Test cases.

class PositionCase : public TransformFeedbackCase
{
public:
    PositionCase(Context &context, const char *name, const char *desc, uint32_t bufferType, uint32_t primitiveType)
        : TransformFeedbackCase(context, name, desc, bufferType, primitiveType)
    {
        m_progSpec.addTransformFeedbackVarying("gl_Position");
    }
};

class PointSizeCase : public TransformFeedbackCase
{
public:
    PointSizeCase(Context &context, const char *name, const char *desc, uint32_t bufferType, uint32_t primitiveType)
        : TransformFeedbackCase(context, name, desc, bufferType, primitiveType)
    {
        m_progSpec.addTransformFeedbackVarying("gl_PointSize");
    }
};

class BasicTypeCase : public TransformFeedbackCase
{
public:
    BasicTypeCase(Context &context, const char *name, const char *desc, uint32_t bufferType, uint32_t primitiveType,
                  glu::DataType type, glu::Precision precision, Interpolation interpolation)
        : TransformFeedbackCase(context, name, desc, bufferType, primitiveType)
    {
        m_progSpec.addVarying("v_varA", glu::VarType(type, precision), interpolation);
        m_progSpec.addVarying("v_varB", glu::VarType(type, precision), interpolation);

        m_progSpec.addTransformFeedbackVarying("v_varA");
        m_progSpec.addTransformFeedbackVarying("v_varB");
    }
};

class BasicArrayCase : public TransformFeedbackCase
{
public:
    BasicArrayCase(Context &context, const char *name, const char *desc, uint32_t bufferType, uint32_t primitiveType,
                   glu::DataType type, glu::Precision precision, Interpolation interpolation)
        : TransformFeedbackCase(context, name, desc, bufferType, primitiveType)
    {
        if (glu::isDataTypeMatrix(type) || m_bufferMode == GL_SEPARATE_ATTRIBS)
        {
            // \note For matrix types we need to use reduced array sizes or otherwise we will exceed maximum attribute (16)
            //         or transform feedback component count (64).
            //         On separate attribs mode maximum component count per varying is 4.
            m_progSpec.addVarying("v_varA", glu::VarType(glu::VarType(type, precision), 1), interpolation);
            m_progSpec.addVarying("v_varB", glu::VarType(glu::VarType(type, precision), 2), interpolation);
        }
        else
        {
            m_progSpec.addVarying("v_varA", glu::VarType(glu::VarType(type, precision), 3), interpolation);
            m_progSpec.addVarying("v_varB", glu::VarType(glu::VarType(type, precision), 4), interpolation);
        }

        m_progSpec.addTransformFeedbackVarying("v_varA");
        m_progSpec.addTransformFeedbackVarying("v_varB");
    }
};

class ArrayElementCase : public TransformFeedbackCase
{
public:
    ArrayElementCase(Context &context, const char *name, const char *desc, uint32_t bufferType, uint32_t primitiveType,
                     glu::DataType type, glu::Precision precision, Interpolation interpolation)
        : TransformFeedbackCase(context, name, desc, bufferType, primitiveType)
    {
        m_progSpec.addVarying("v_varA", glu::VarType(glu::VarType(type, precision), 3), interpolation);
        m_progSpec.addVarying("v_varB", glu::VarType(glu::VarType(type, precision), 4), interpolation);

        m_progSpec.addTransformFeedbackVarying("v_varA[1]");
        m_progSpec.addTransformFeedbackVarying("v_varB[0]");
        m_progSpec.addTransformFeedbackVarying("v_varB[3]");
    }
};

class RandomCase : public TransformFeedbackCase
{
public:
    RandomCase(Context &context, const char *name, const char *desc, uint32_t bufferType, uint32_t primitiveType,
               uint32_t seed, bool elementCapture)
        : TransformFeedbackCase(context, name, desc, bufferType, primitiveType)
        , m_seed(seed)
        , m_elementCapture(elementCapture)
    {
    }

    void init(void)
    {
        // \note Hard-coded indices and hackery are used when indexing this, beware.
        static const glu::DataType typeCandidates[] = {
            glu::TYPE_FLOAT,        glu::TYPE_FLOAT_VEC2,   glu::TYPE_FLOAT_VEC3,   glu::TYPE_FLOAT_VEC4,
            glu::TYPE_INT,          glu::TYPE_INT_VEC2,     glu::TYPE_INT_VEC3,     glu::TYPE_INT_VEC4,
            glu::TYPE_UINT,         glu::TYPE_UINT_VEC2,    glu::TYPE_UINT_VEC3,    glu::TYPE_UINT_VEC4,

            glu::TYPE_FLOAT_MAT2,   glu::TYPE_FLOAT_MAT2X3, glu::TYPE_FLOAT_MAT2X4,

            glu::TYPE_FLOAT_MAT3X2, glu::TYPE_FLOAT_MAT3,   glu::TYPE_FLOAT_MAT3X4,

            glu::TYPE_FLOAT_MAT4X2, glu::TYPE_FLOAT_MAT4X3, glu::TYPE_FLOAT_MAT4};

        static const glu::Precision precisions[] = {glu::PRECISION_LOWP, glu::PRECISION_MEDIUMP, glu::PRECISION_HIGHP};

        static const Interpolation interpModes[] = {INTERPOLATION_FLAT, INTERPOLATION_SMOOTH, INTERPOLATION_CENTROID};

        const int maxAttributeVectors = 16;
        //        const int    maxTransformFeedbackComponents = 64; // \note It is enough to limit attribute set size.
        bool isSeparateMode                = m_bufferMode == GL_SEPARATE_ATTRIBS;
        int maxTransformFeedbackVars       = isSeparateMode ? 4 : maxAttributeVectors;
        const float arrayWeight            = 0.3f;
        const float positionWeight         = 0.7f;
        const float pointSizeWeight        = 0.1f;
        const float captureFullArrayWeight = 0.5f;

        de::Random rnd(m_seed);
        bool usePosition          = rnd.getFloat() < positionWeight;
        bool usePointSize         = rnd.getFloat() < pointSizeWeight;
        int numAttribVectorsToUse = rnd.getInt(1, maxAttributeVectors - 1 /*position*/ - (usePointSize ? 1 : 0));

        int numAttributeVectors = 0;
        int varNdx              = 0;

        // Generate varyings.
        while (numAttributeVectors < numAttribVectorsToUse)
        {
            int maxVecs = isSeparateMode ? de::min(2 /*at most 2*mat2*/, numAttribVectorsToUse - numAttributeVectors) :
                                           numAttribVectorsToUse - numAttributeVectors;
            const glu::DataType *begin = &typeCandidates[0];
            const glu::DataType *end   = begin + (maxVecs >= 4 ? 21 :
                                                  maxVecs >= 3 ? 18 :
                                                  maxVecs >= 2 ? (isSeparateMode ? 13 : 15) :
                                                                 12);

            glu::DataType type = rnd.choose<glu::DataType>(begin, end);
            glu::Precision precision =
                rnd.choose<glu::Precision>(&precisions[0], &precisions[0] + DE_LENGTH_OF_ARRAY(precisions));
            Interpolation interp =
                glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT ?
                    rnd.choose<Interpolation>(&interpModes[0], &interpModes[0] + DE_LENGTH_OF_ARRAY(interpModes)) :
                    INTERPOLATION_FLAT;
            int numVecs      = glu::isDataTypeMatrix(type) ? glu::getDataTypeMatrixNumColumns(type) : 1;
            int numComps     = glu::getDataTypeScalarSize(type);
            int maxArrayLen  = de::max(1, isSeparateMode ? 4 / numComps : maxVecs / numVecs);
            bool useArray    = rnd.getFloat() < arrayWeight;
            int arrayLen     = useArray ? rnd.getInt(1, maxArrayLen) : 1;
            std::string name = "v_var" + de::toString(varNdx);

            if (useArray)
                m_progSpec.addVarying(name.c_str(), glu::VarType(glu::VarType(type, precision), arrayLen), interp);
            else
                m_progSpec.addVarying(name.c_str(), glu::VarType(type, precision), interp);

            numAttributeVectors += arrayLen * numVecs;
            varNdx += 1;
        }

        // Generate transform feedback candidate set.
        vector<string> tfCandidates;

        if (usePosition)
            tfCandidates.push_back("gl_Position");
        if (usePointSize)
            tfCandidates.push_back("gl_PointSize");

        for (int ndx = 0; ndx < varNdx /* num varyings */; ndx++)
        {
            const Varying &var = m_progSpec.getVaryings()[ndx];

            if (var.type.isArrayType())
            {
                const bool captureFull = m_elementCapture ? (rnd.getFloat() < captureFullArrayWeight) : true;

                if (captureFull)
                    tfCandidates.push_back(var.name);
                else
                {
                    const int numElem = var.type.getArraySize();
                    for (int elemNdx = 0; elemNdx < numElem; elemNdx++)
                        tfCandidates.push_back(var.name + "[" + de::toString(elemNdx) + "]");
                }
            }
            else
                tfCandidates.push_back(var.name);
        }

        // Pick random selection.
        vector<string> tfVaryings(de::min((int)tfCandidates.size(), maxTransformFeedbackVars));
        rnd.choose(tfCandidates.begin(), tfCandidates.end(), tfVaryings.begin(), (int)tfVaryings.size());
        rnd.shuffle(tfVaryings.begin(), tfVaryings.end());

        for (vector<string>::const_iterator var = tfVaryings.begin(); var != tfVaryings.end(); var++)
            m_progSpec.addTransformFeedbackVarying(var->c_str());

        TransformFeedbackCase::init();
    }

private:
    uint32_t m_seed;
    bool m_elementCapture;
};

} // namespace TransformFeedback

using namespace TransformFeedback;

TransformFeedbackTests::TransformFeedbackTests(Context &context)
    : TestCaseGroup(context, "transform_feedback", "Transform feedback tests")
{
}

TransformFeedbackTests::~TransformFeedbackTests(void)
{
}

void TransformFeedbackTests::init(void)
{
    static const struct
    {
        const char *name;
        uint32_t mode;
    } bufferModes[] = {{"separate", GL_SEPARATE_ATTRIBS}, {"interleaved", GL_INTERLEAVED_ATTRIBS}};

    static const struct
    {
        const char *name;
        uint32_t type;
    } primitiveTypes[] = {
        {"points", GL_POINTS}, {"lines", GL_LINES}, {"triangles", GL_TRIANGLES}

        // Not supported by GLES3.
        //        { "line_strip", GL_LINE_STRIP        },
        //        { "line_loop", GL_LINE_LOOP        },
        //        { "triangle_fan", GL_TRIANGLE_FAN        },
        //        { "triangle_strip", GL_TRIANGLE_STRIP    }
    };

    static const glu::DataType basicTypes[] = {glu::TYPE_FLOAT,        glu::TYPE_FLOAT_VEC2,   glu::TYPE_FLOAT_VEC3,
                                               glu::TYPE_FLOAT_VEC4,   glu::TYPE_FLOAT_MAT2,   glu::TYPE_FLOAT_MAT2X3,
                                               glu::TYPE_FLOAT_MAT2X4, glu::TYPE_FLOAT_MAT3X2, glu::TYPE_FLOAT_MAT3,
                                               glu::TYPE_FLOAT_MAT3X4, glu::TYPE_FLOAT_MAT4X2, glu::TYPE_FLOAT_MAT4X3,
                                               glu::TYPE_FLOAT_MAT4,   glu::TYPE_INT,          glu::TYPE_INT_VEC2,
                                               glu::TYPE_INT_VEC3,     glu::TYPE_INT_VEC4,     glu::TYPE_UINT,
                                               glu::TYPE_UINT_VEC2,    glu::TYPE_UINT_VEC3,    glu::TYPE_UINT_VEC4};

    static const glu::Precision precisions[] = {glu::PRECISION_LOWP, glu::PRECISION_MEDIUMP, glu::PRECISION_HIGHP};

    static const struct
    {
        const char *name;
        Interpolation interp;
    } interpModes[] = {
        {"smooth", INTERPOLATION_SMOOTH}, {"flat", INTERPOLATION_FLAT}, {"centroid", INTERPOLATION_CENTROID}};

    // .position
    {
        tcu::TestCaseGroup *positionGroup =
            new tcu::TestCaseGroup(m_testCtx, "position", "gl_Position capture using transform feedback");
        addChild(positionGroup);

        for (int primitiveType = 0; primitiveType < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveType++)
        {
            for (int bufferMode = 0; bufferMode < DE_LENGTH_OF_ARRAY(bufferModes); bufferMode++)
            {
                string name = string(primitiveTypes[primitiveType].name) + "_" + bufferModes[bufferMode].name;
                positionGroup->addChild(new PositionCase(m_context, name.c_str(), "", bufferModes[bufferMode].mode,
                                                         primitiveTypes[primitiveType].type));
            }
        }
    }

    // .point_size
    {
        tcu::TestCaseGroup *pointSizeGroup =
            new tcu::TestCaseGroup(m_testCtx, "point_size", "gl_PointSize capture using transform feedback");
        addChild(pointSizeGroup);

        for (int primitiveType = 0; primitiveType < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveType++)
        {
            for (int bufferMode = 0; bufferMode < DE_LENGTH_OF_ARRAY(bufferModes); bufferMode++)
            {
                string name = string(primitiveTypes[primitiveType].name) + "_" + bufferModes[bufferMode].name;
                pointSizeGroup->addChild(new PointSizeCase(m_context, name.c_str(), "", bufferModes[bufferMode].mode,
                                                           primitiveTypes[primitiveType].type));
            }
        }
    }

    // .basic_type
    {
        tcu::TestCaseGroup *basicTypeGroup =
            new tcu::TestCaseGroup(m_testCtx, "basic_types", "Basic types in transform feedback");
        addChild(basicTypeGroup);

        for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++)
        {
            tcu::TestCaseGroup *modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, "");
            uint32_t bufferMode           = bufferModes[bufferModeNdx].mode;
            basicTypeGroup->addChild(modeGroup);

            for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++)
            {
                tcu::TestCaseGroup *primitiveGroup =
                    new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, "");
                uint32_t primitiveType = primitiveTypes[primitiveTypeNdx].type;
                modeGroup->addChild(primitiveGroup);

                for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(basicTypes); typeNdx++)
                {
                    glu::DataType type = basicTypes[typeNdx];
                    bool isFloat       = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT;

                    for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++)
                    {
                        glu::Precision precision = precisions[precNdx];

                        string name = string(glu::getPrecisionName(precision)) + "_" + glu::getDataTypeName(type);
                        primitiveGroup->addChild(
                            new BasicTypeCase(m_context, name.c_str(), "", bufferMode, primitiveType, type, precision,
                                              isFloat ? INTERPOLATION_SMOOTH : INTERPOLATION_FLAT));
                    }
                }
            }
        }
    }

    // .array
    {
        tcu::TestCaseGroup *arrayGroup = new tcu::TestCaseGroup(m_testCtx, "array", "Capturing whole array in TF");
        addChild(arrayGroup);

        for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++)
        {
            tcu::TestCaseGroup *modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, "");
            uint32_t bufferMode           = bufferModes[bufferModeNdx].mode;
            arrayGroup->addChild(modeGroup);

            for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++)
            {
                tcu::TestCaseGroup *primitiveGroup =
                    new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, "");
                uint32_t primitiveType = primitiveTypes[primitiveTypeNdx].type;
                modeGroup->addChild(primitiveGroup);

                for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(basicTypes); typeNdx++)
                {
                    glu::DataType type = basicTypes[typeNdx];
                    bool isFloat       = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT;

                    for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++)
                    {
                        glu::Precision precision = precisions[precNdx];

                        string name = string(glu::getPrecisionName(precision)) + "_" + glu::getDataTypeName(type);
                        primitiveGroup->addChild(
                            new BasicArrayCase(m_context, name.c_str(), "", bufferMode, primitiveType, type, precision,
                                               isFloat ? INTERPOLATION_SMOOTH : INTERPOLATION_FLAT));
                    }
                }
            }
        }
    }

    // .array_element
    {
        tcu::TestCaseGroup *arrayElemGroup =
            new tcu::TestCaseGroup(m_testCtx, "array_element", "Capturing single array element in TF");
        addChild(arrayElemGroup);

        for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++)
        {
            tcu::TestCaseGroup *modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, "");
            uint32_t bufferMode           = bufferModes[bufferModeNdx].mode;
            arrayElemGroup->addChild(modeGroup);

            for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++)
            {
                tcu::TestCaseGroup *primitiveGroup =
                    new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, "");
                uint32_t primitiveType = primitiveTypes[primitiveTypeNdx].type;
                modeGroup->addChild(primitiveGroup);

                for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(basicTypes); typeNdx++)
                {
                    glu::DataType type = basicTypes[typeNdx];
                    bool isFloat       = glu::getDataTypeScalarType(type) == glu::TYPE_FLOAT;

                    for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++)
                    {
                        glu::Precision precision = precisions[precNdx];

                        string name = string(glu::getPrecisionName(precision)) + "_" + glu::getDataTypeName(type);
                        primitiveGroup->addChild(
                            new ArrayElementCase(m_context, name.c_str(), "", bufferMode, primitiveType, type,
                                                 precision, isFloat ? INTERPOLATION_SMOOTH : INTERPOLATION_FLAT));
                    }
                }
            }
        }
    }

    // .interpolation
    {
        tcu::TestCaseGroup *interpolationGroup = new tcu::TestCaseGroup(
            m_testCtx, "interpolation", "Different interpolation modes in transform feedback varyings");
        addChild(interpolationGroup);

        for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(interpModes); modeNdx++)
        {
            Interpolation interp          = interpModes[modeNdx].interp;
            tcu::TestCaseGroup *modeGroup = new tcu::TestCaseGroup(m_testCtx, interpModes[modeNdx].name, "");

            interpolationGroup->addChild(modeGroup);

            for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++)
            {
                glu::Precision precision = precisions[precNdx];

                for (int primitiveType = 0; primitiveType < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveType++)
                {
                    for (int bufferMode = 0; bufferMode < DE_LENGTH_OF_ARRAY(bufferModes); bufferMode++)
                    {
                        string name = string(glu::getPrecisionName(precision)) + "_vec4_" +
                                      primitiveTypes[primitiveType].name + "_" + bufferModes[bufferMode].name;
                        modeGroup->addChild(new BasicTypeCase(m_context, name.c_str(), "", bufferModes[bufferMode].mode,
                                                              primitiveTypes[primitiveType].type, glu::TYPE_FLOAT_VEC4,
                                                              precision, interp));
                    }
                }
            }
        }
    }

    // .random
    {
        tcu::TestCaseGroup *randomGroup =
            new tcu::TestCaseGroup(m_testCtx, "random", "Randomized transform feedback cases");
        addChild(randomGroup);

        for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++)
        {
            tcu::TestCaseGroup *modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, "");
            uint32_t bufferMode           = bufferModes[bufferModeNdx].mode;
            randomGroup->addChild(modeGroup);

            for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++)
            {
                tcu::TestCaseGroup *primitiveGroup =
                    new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, "");
                uint32_t primitiveType = primitiveTypes[primitiveTypeNdx].type;
                modeGroup->addChild(primitiveGroup);

                for (int ndx = 0; ndx < 10; ndx++)
                {
                    uint32_t seed = deInt32Hash(bufferMode) ^ deInt32Hash(primitiveType) ^ deInt32Hash(ndx);
                    primitiveGroup->addChild(new RandomCase(m_context, de::toString(ndx + 1).c_str(), "", bufferMode,
                                                            primitiveType, seed, true));
                }
            }
        }
    }

    // .random_full_array_capture
    {
        tcu::TestCaseGroup *randomNecGroup =
            new tcu::TestCaseGroup(m_testCtx, "random_full_array_capture",
                                   "Randomized transform feedback cases without array element capture");
        addChild(randomNecGroup);

        for (int bufferModeNdx = 0; bufferModeNdx < DE_LENGTH_OF_ARRAY(bufferModes); bufferModeNdx++)
        {
            tcu::TestCaseGroup *modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[bufferModeNdx].name, "");
            uint32_t bufferMode           = bufferModes[bufferModeNdx].mode;
            randomNecGroup->addChild(modeGroup);

            for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveTypeNdx++)
            {
                tcu::TestCaseGroup *primitiveGroup =
                    new tcu::TestCaseGroup(m_testCtx, primitiveTypes[primitiveTypeNdx].name, "");
                uint32_t primitiveType = primitiveTypes[primitiveTypeNdx].type;
                modeGroup->addChild(primitiveGroup);

                for (int ndx = 0; ndx < 10; ndx++)
                {
                    uint32_t seed = deInt32Hash(bufferMode) ^ deInt32Hash(primitiveType) ^ deInt32Hash(ndx);
                    primitiveGroup->addChild(new RandomCase(m_context, de::toString(ndx + 1).c_str(), "", bufferMode,
                                                            primitiveType, seed, false));
                }
            }
        }
    }
}

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