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

#include "es31fShaderPackingFunctionTests.hpp"
#include "glsShaderExecUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
#include "tcuFloat.hpp"
#include "deRandom.hpp"
#include "deMath.h"
#include "deString.h"

namespace deqp
{
namespace gles31
{
namespace Functional
{

using std::string;
using tcu::TestLog;
using namespace gls::ShaderExecUtil;

namespace
{

inline uint32_t getUlpDiff(float a, float b)
{
    const uint32_t aBits = tcu::Float32(a).bits();
    const uint32_t bBits = tcu::Float32(b).bits();
    return aBits > bBits ? aBits - bBits : bBits - aBits;
}

struct HexFloat
{
    const float value;
    HexFloat(const float value_) : value(value_)
    {
    }
};

std::ostream &operator<<(std::ostream &str, const HexFloat &v)
{
    return str << v.value << " / " << tcu::toHex(tcu::Float32(v.value).bits());
}

} // namespace

// ShaderPackingFunctionCase

class ShaderPackingFunctionCase : public TestCase
{
public:
    ShaderPackingFunctionCase(Context &context, const char *name, const char *description, glu::ShaderType shaderType);
    ~ShaderPackingFunctionCase(void);

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

protected:
    glu::ShaderType m_shaderType;
    ShaderSpec m_spec;
    ShaderExecutor *m_executor;

private:
    ShaderPackingFunctionCase(const ShaderPackingFunctionCase &other);
    ShaderPackingFunctionCase &operator=(const ShaderPackingFunctionCase &other);
};

ShaderPackingFunctionCase::ShaderPackingFunctionCase(Context &context, const char *name, const char *description,
                                                     glu::ShaderType shaderType)
    : TestCase(context, name, description)
    , m_shaderType(shaderType)
    , m_executor(DE_NULL)
{
    m_spec.version = glu::getContextTypeGLSLVersion(context.getRenderContext().getType());
}

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

void ShaderPackingFunctionCase::init(void)
{
    DE_ASSERT(!m_executor);

    m_executor = createExecutor(m_context.getRenderContext(), m_shaderType, m_spec);
    m_testCtx.getLog() << m_executor;

    if (!m_executor->isOk())
        throw tcu::TestError("Compile failed");
}

void ShaderPackingFunctionCase::deinit(void)
{
    delete m_executor;
    m_executor = DE_NULL;
}

// Test cases

class PackSnorm2x16Case : public ShaderPackingFunctionCase
{
public:
    PackSnorm2x16Case(Context &context, glu::ShaderType shaderType, glu::Precision precision)
        : ShaderPackingFunctionCase(
              context,
              (string("packsnorm2x16") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(),
              "packSnorm2x16", shaderType)
        , m_precision(precision)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC2, precision)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = packSnorm2x16(in0);";
    }

    IterateResult iterate(void)
    {
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<tcu::Vec2> inputs;
        std::vector<uint32_t> outputs;
        const int                    maxDiff = m_precision == glu::PRECISION_HIGHP    ? 1        : // Rounding only.
                                                  m_precision == glu::PRECISION_MEDIUMP    ? 33    : // (2^-10) * (2^15) + 1
                                                  m_precision == glu::PRECISION_LOWP    ? 129    : 0;    // (2^-8) * (2^15) + 1

        // Special values to check.
        inputs.push_back(tcu::Vec2(0.0f, 0.0f));
        inputs.push_back(tcu::Vec2(-1.0f, 1.0f));
        inputs.push_back(tcu::Vec2(0.5f, -0.5f));
        inputs.push_back(tcu::Vec2(-1.5f, 1.5f));
        inputs.push_back(tcu::Vec2(0.25f, -0.75f));

        // Random values, mostly in range.
        for (int ndx = 0; ndx < 15; ndx++)
        {
            const float x = rnd.getFloat() * 2.5f - 1.25f;
            const float y = rnd.getFloat() * 2.5f - 1.25f;
            inputs.push_back(tcu::Vec2(x, y));
        }

        // Large random values.
        for (int ndx = 0; ndx < 80; ndx++)
        {
            const float x = rnd.getFloat() * 1e6f - 0.5e6f;
            const float y = rnd.getFloat() * 1e6f - 0.5e6f;
            inputs.push_back(tcu::Vec2(x, y));
        }

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < numValues; valNdx++)
            {
                const uint16_t ref0 =
                    (uint16_t)de::clamp(deRoundFloatToInt32(de::clamp(inputs[valNdx].x(), -1.0f, 1.0f) * 32767.0f),
                                        -(1 << 15), (1 << 15) - 1);
                const uint16_t ref1 =
                    (uint16_t)de::clamp(deRoundFloatToInt32(de::clamp(inputs[valNdx].y(), -1.0f, 1.0f) * 32767.0f),
                                        -(1 << 15), (1 << 15) - 1);
                const uint32_t ref  = (ref1 << 16) | ref0;
                const uint32_t res  = outputs[valNdx];
                const uint16_t res0 = (uint16_t)(res & 0xffff);
                const uint16_t res1 = (uint16_t)(res >> 16);
                const int diff0     = de::abs((int)ref0 - (int)res0);
                const int diff1     = de::abs((int)ref1 - (int)res1);

                if (diff0 > maxDiff || diff1 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx
                                           << ", expected packSnorm2x16(" << inputs[valNdx] << ") = " << tcu::toHex(ref)
                                           << ", got " << tcu::toHex(res) << "\n  diffs = (" << diff0 << ", " << diff1
                                           << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }

private:
    glu::Precision m_precision;
};

class UnpackSnorm2x16Case : public ShaderPackingFunctionCase
{
public:
    UnpackSnorm2x16Case(Context &context, glu::ShaderType shaderType)
        : ShaderPackingFunctionCase(context, (string("unpacksnorm2x16") + getShaderTypePostfix(shaderType)).c_str(),
                                    "unpackSnorm2x16", shaderType)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = unpackSnorm2x16(in0);";
    }

    IterateResult iterate(void)
    {
        const uint32_t maxDiff = 1; // Rounding error.
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<uint32_t> inputs;
        std::vector<tcu::Vec2> outputs;

        inputs.push_back(0x00000000u);
        inputs.push_back(0x7fff8000u);
        inputs.push_back(0x80007fffu);
        inputs.push_back(0xffffffffu);
        inputs.push_back(0x0001fffeu);

        // Random values.
        for (int ndx = 0; ndx < 95; ndx++)
            inputs.push_back(rnd.getUint32());

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const int16_t in0 = (int16_t)(uint16_t)(inputs[valNdx] & 0xffff);
                const int16_t in1 = (int16_t)(uint16_t)(inputs[valNdx] >> 16);
                const float ref0  = de::clamp(float(in0) / 32767.f, -1.0f, 1.0f);
                const float ref1  = de::clamp(float(in1) / 32767.f, -1.0f, 1.0f);
                const float res0  = outputs[valNdx].x();
                const float res1  = outputs[valNdx].y();

                const uint32_t diff0 = getUlpDiff(ref0, res0);
                const uint32_t diff1 = getUlpDiff(ref1, res1);

                if (diff0 > maxDiff || diff1 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n"
                                           << "  expected unpackSnorm2x16(" << tcu::toHex(inputs[valNdx]) << ") = "
                                           << "vec2(" << HexFloat(ref0) << ", " << HexFloat(ref1) << ")"
                                           << ", got vec2(" << HexFloat(res0) << ", " << HexFloat(res1) << ")"
                                           << "\n  ULP diffs = (" << diff0 << ", " << diff1
                                           << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }
};

class PackUnorm2x16Case : public ShaderPackingFunctionCase
{
public:
    PackUnorm2x16Case(Context &context, glu::ShaderType shaderType, glu::Precision precision)
        : ShaderPackingFunctionCase(
              context,
              (string("packunorm2x16") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(),
              "packUnorm2x16", shaderType)
        , m_precision(precision)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC2, precision)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = packUnorm2x16(in0);";
    }

    IterateResult iterate(void)
    {
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<tcu::Vec2> inputs;
        std::vector<uint32_t> outputs;
        const int                    maxDiff = m_precision == glu::PRECISION_HIGHP    ? 1        : // Rounding only.
                                                  m_precision == glu::PRECISION_MEDIUMP    ? 65    : // (2^-10) * (2^16) + 1
                                                  m_precision == glu::PRECISION_LOWP    ? 257    : 0;    // (2^-8) * (2^16) + 1

        // Special values to check.
        inputs.push_back(tcu::Vec2(0.0f, 0.0f));
        inputs.push_back(tcu::Vec2(0.5f, 1.0f));
        inputs.push_back(tcu::Vec2(1.0f, 0.5f));
        inputs.push_back(tcu::Vec2(-0.5f, 1.5f));
        inputs.push_back(tcu::Vec2(0.25f, 0.75f));

        // Random values, mostly in range.
        for (int ndx = 0; ndx < 15; ndx++)
        {
            const float x = rnd.getFloat() * 1.25f;
            const float y = rnd.getFloat() * 1.25f;
            inputs.push_back(tcu::Vec2(x, y));
        }

        // Large random values.
        for (int ndx = 0; ndx < 80; ndx++)
        {
            const float x = rnd.getFloat() * 1e6f - 1e5f;
            const float y = rnd.getFloat() * 1e6f - 1e5f;
            inputs.push_back(tcu::Vec2(x, y));
        }

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const uint16_t ref0 = (uint16_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].x(), 0.0f, 1.0f) * 65535.0f), 0, (1 << 16) - 1);
                const uint16_t ref1 = (uint16_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].y(), 0.0f, 1.0f) * 65535.0f), 0, (1 << 16) - 1);
                const uint32_t ref  = (ref1 << 16) | ref0;
                const uint32_t res  = outputs[valNdx];
                const uint16_t res0 = (uint16_t)(res & 0xffff);
                const uint16_t res1 = (uint16_t)(res >> 16);
                const int diff0     = de::abs((int)ref0 - (int)res0);
                const int diff1     = de::abs((int)ref1 - (int)res1);

                if (diff0 > maxDiff || diff1 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx
                                           << ", expected packUnorm2x16(" << inputs[valNdx] << ") = " << tcu::toHex(ref)
                                           << ", got " << tcu::toHex(res) << "\n  diffs = (" << diff0 << ", " << diff1
                                           << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }

private:
    glu::Precision m_precision;
};

class UnpackUnorm2x16Case : public ShaderPackingFunctionCase
{
public:
    UnpackUnorm2x16Case(Context &context, glu::ShaderType shaderType)
        : ShaderPackingFunctionCase(context, (string("unpackunorm2x16") + getShaderTypePostfix(shaderType)).c_str(),
                                    "unpackUnorm2x16", shaderType)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = unpackUnorm2x16(in0);";
    }

    IterateResult iterate(void)
    {
        const uint32_t maxDiff = 1; // Rounding error.
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<uint32_t> inputs;
        std::vector<tcu::Vec2> outputs;

        inputs.push_back(0x00000000u);
        inputs.push_back(0x7fff8000u);
        inputs.push_back(0x80007fffu);
        inputs.push_back(0xffffffffu);
        inputs.push_back(0x0001fffeu);

        // Random values.
        for (int ndx = 0; ndx < 95; ndx++)
            inputs.push_back(rnd.getUint32());

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const uint16_t in0 = (uint16_t)(inputs[valNdx] & 0xffff);
                const uint16_t in1 = (uint16_t)(inputs[valNdx] >> 16);
                const float ref0   = float(in0) / 65535.0f;
                const float ref1   = float(in1) / 65535.0f;
                const float res0   = outputs[valNdx].x();
                const float res1   = outputs[valNdx].y();

                const uint32_t diff0 = getUlpDiff(ref0, res0);
                const uint32_t diff1 = getUlpDiff(ref1, res1);

                if (diff0 > maxDiff || diff1 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n"
                                           << "  expected unpackUnorm2x16(" << tcu::toHex(inputs[valNdx]) << ") = "
                                           << "vec2(" << HexFloat(ref0) << ", " << HexFloat(ref1) << ")"
                                           << ", got vec2(" << HexFloat(res0) << ", " << HexFloat(res1) << ")"
                                           << "\n  ULP diffs = (" << diff0 << ", " << diff1
                                           << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }
};

class PackHalf2x16Case : public ShaderPackingFunctionCase
{
public:
    PackHalf2x16Case(Context &context, glu::ShaderType shaderType)
        : ShaderPackingFunctionCase(context, (string("packhalf2x16") + getShaderTypePostfix(shaderType)).c_str(),
                                    "packHalf2x16", shaderType)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_HIGHP)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = packHalf2x16(in0);";
    }

    IterateResult iterate(void)
    {
        const int maxDiff = 0; // Values can be represented exactly in mediump.
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<tcu::Vec2> inputs;
        std::vector<uint32_t> outputs;

        // Special values to check.
        inputs.push_back(tcu::Vec2(0.0f, 0.0f));
        inputs.push_back(tcu::Vec2(0.5f, 1.0f));
        inputs.push_back(tcu::Vec2(1.0f, 0.5f));
        inputs.push_back(tcu::Vec2(-0.5f, 1.5f));
        inputs.push_back(tcu::Vec2(0.25f, 0.75f));

        // Random values.
        {
            const int minExp = -14;
            const int maxExp = 15;

            for (int ndx = 0; ndx < 95; ndx++)
            {
                tcu::Vec2 v;
                for (int c = 0; c < 2; c++)
                {
                    const int s             = rnd.getBool() ? 1 : -1;
                    const int exp           = rnd.getInt(minExp, maxExp);
                    const uint32_t mantissa = rnd.getUint32() & ((1 << 23) - 1);

                    v[c] = tcu::Float32::construct(s, exp ? exp : 1 /* avoid denormals */, (1u << 23) | mantissa)
                               .asFloat();
                }
                inputs.push_back(v);
            }
        }

        // Convert input values to fp16 and back to make sure they can be represented exactly in mediump.
        for (std::vector<tcu::Vec2>::iterator inVal = inputs.begin(); inVal != inputs.end(); ++inVal)
            *inVal = tcu::Vec2(tcu::Float16(inVal->x()).asFloat(), tcu::Float16(inVal->y()).asFloat());

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const uint16_t ref0 = (uint16_t)tcu::Float16(inputs[valNdx].x()).bits();
                const uint16_t ref1 = (uint16_t)tcu::Float16(inputs[valNdx].y()).bits();
                const uint32_t ref  = (ref1 << 16) | ref0;
                const uint32_t res  = outputs[valNdx];
                const uint16_t res0 = (uint16_t)(res & 0xffff);
                const uint16_t res1 = (uint16_t)(res >> 16);
                const int diff0     = de::abs((int)ref0 - (int)res0);
                const int diff1     = de::abs((int)ref1 - (int)res1);

                if (diff0 > maxDiff || diff1 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx
                                           << ", expected packHalf2x16(" << inputs[valNdx] << ") = " << tcu::toHex(ref)
                                           << ", got " << tcu::toHex(res) << "\n  diffs = (" << diff0 << ", " << diff1
                                           << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }
};

class UnpackHalf2x16Case : public ShaderPackingFunctionCase
{
public:
    UnpackHalf2x16Case(Context &context, glu::ShaderType shaderType)
        : ShaderPackingFunctionCase(context, (string("unpackhalf2x16") + getShaderTypePostfix(shaderType)).c_str(),
                                    "unpackHalf2x16", shaderType)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_MEDIUMP)));

        m_spec.source = "out0 = unpackHalf2x16(in0);";
    }

    IterateResult iterate(void)
    {
        const int maxDiff = 0; // All bits must be accurate.
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<uint32_t> inputs;
        std::vector<tcu::Vec2> outputs;

        // Special values.
        inputs.push_back((tcu::Float16(0.0f).bits() << 16) | tcu::Float16(1.0f).bits());
        inputs.push_back((tcu::Float16(1.0f).bits() << 16) | tcu::Float16(0.0f).bits());
        inputs.push_back((tcu::Float16(-1.0f).bits() << 16) | tcu::Float16(0.5f).bits());
        inputs.push_back((tcu::Float16(0.5f).bits() << 16) | tcu::Float16(-0.5f).bits());

        // Construct random values.
        {
            const int minExp   = -14;
            const int maxExp   = 15;
            const int mantBits = 10;

            for (int ndx = 0; ndx < 96; ndx++)
            {
                uint32_t inVal = 0;
                for (int c = 0; c < 2; c++)
                {
                    const int s             = rnd.getBool() ? 1 : -1;
                    const int exp           = rnd.getInt(minExp, maxExp);
                    const uint32_t mantissa = rnd.getUint32() & ((1 << mantBits) - 1);
                    const uint16_t value =
                        tcu::Float16::construct(s, exp ? exp : 1 /* avoid denorm */, (uint16_t)((1u << 10) | mantissa))
                            .bits();

                    inVal |= value << (16 * c);
                }
                inputs.push_back(inVal);
            }
        }

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const uint16_t in0 = (uint16_t)(inputs[valNdx] & 0xffff);
                const uint16_t in1 = (uint16_t)(inputs[valNdx] >> 16);
                const float ref0   = tcu::Float16(in0).asFloat();
                const float ref1   = tcu::Float16(in1).asFloat();
                const float res0   = outputs[valNdx].x();
                const float res1   = outputs[valNdx].y();

                const uint32_t refBits0 = tcu::Float32(ref0).bits();
                const uint32_t refBits1 = tcu::Float32(ref1).bits();
                const uint32_t resBits0 = tcu::Float32(res0).bits();
                const uint32_t resBits1 = tcu::Float32(res1).bits();

                const int diff0 = de::abs((int)refBits0 - (int)resBits0);
                const int diff1 = de::abs((int)refBits1 - (int)resBits1);

                if (diff0 > maxDiff || diff1 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n"
                                           << "  expected unpackHalf2x16(" << tcu::toHex(inputs[valNdx]) << ") = "
                                           << "vec2(" << ref0 << " / " << tcu::toHex(refBits0) << ", " << ref1 << " / "
                                           << tcu::toHex(refBits1) << ")"
                                           << ", got vec2(" << res0 << " / " << tcu::toHex(resBits0) << ", " << res1
                                           << " / " << tcu::toHex(resBits1) << ")"
                                           << "\n  ULP diffs = (" << diff0 << ", " << diff1
                                           << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }
};

class PackSnorm4x8Case : public ShaderPackingFunctionCase
{
public:
    PackSnorm4x8Case(Context &context, glu::ShaderType shaderType, glu::Precision precision)
        : ShaderPackingFunctionCase(
              context,
              (string("packsnorm4x8") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(),
              "packSnorm4x8", shaderType)
        , m_precision(precision)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC4, precision)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = packSnorm4x8(in0);";
    }

    IterateResult iterate(void)
    {
        de::Random rnd(deStringHash(getName()) ^ 0x42f2c0);
        std::vector<tcu::Vec4> inputs;
        std::vector<uint32_t> outputs;
        const int                    maxDiff = m_precision == glu::PRECISION_HIGHP    ? 1    : // Rounding only.
                                                  m_precision == glu::PRECISION_MEDIUMP    ? 1    : // (2^-10) * (2^7) + 1
                                                  m_precision == glu::PRECISION_LOWP    ? 2    : 0;    // (2^-8) * (2^7) + 1

        // Special values to check.
        inputs.push_back(tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f));
        inputs.push_back(tcu::Vec4(-1.0f, 1.0f, -1.0f, 1.0f));
        inputs.push_back(tcu::Vec4(0.5f, -0.5f, -0.5f, 0.5f));
        inputs.push_back(tcu::Vec4(-1.5f, 1.5f, -1.5f, 1.5f));
        inputs.push_back(tcu::Vec4(0.25f, -0.75f, -0.25f, 0.75f));

        // Random values, mostly in range.
        for (int ndx = 0; ndx < 15; ndx++)
        {
            const float x = rnd.getFloat() * 2.5f - 1.25f;
            const float y = rnd.getFloat() * 2.5f - 1.25f;
            const float z = rnd.getFloat() * 2.5f - 1.25f;
            const float w = rnd.getFloat() * 2.5f - 1.25f;
            inputs.push_back(tcu::Vec4(x, y, z, w));
        }

        // Large random values.
        for (int ndx = 0; ndx < 80; ndx++)
        {
            const float x = rnd.getFloat() * 1e6f - 0.5e6f;
            const float y = rnd.getFloat() * 1e6f - 0.5e6f;
            const float z = rnd.getFloat() * 1e6f - 0.5e6f;
            const float w = rnd.getFloat() * 1e6f - 0.5e6f;
            inputs.push_back(tcu::Vec4(x, y, z, w));
        }

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < numValues; valNdx++)
            {
                const uint16_t ref0 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].x(), -1.0f, 1.0f) * 127.0f), -(1 << 7), (1 << 7) - 1);
                const uint16_t ref1 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].y(), -1.0f, 1.0f) * 127.0f), -(1 << 7), (1 << 7) - 1);
                const uint16_t ref2 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].z(), -1.0f, 1.0f) * 127.0f), -(1 << 7), (1 << 7) - 1);
                const uint16_t ref3 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].w(), -1.0f, 1.0f) * 127.0f), -(1 << 7), (1 << 7) - 1);
                const uint32_t ref =
                    (uint32_t(ref3) << 24) | (uint32_t(ref2) << 16) | (uint32_t(ref1) << 8) | uint32_t(ref0);
                const uint32_t res  = outputs[valNdx];
                const uint16_t res0 = (uint8_t)(res & 0xff);
                const uint16_t res1 = (uint8_t)((res >> 8) & 0xff);
                const uint16_t res2 = (uint8_t)((res >> 16) & 0xff);
                const uint16_t res3 = (uint8_t)((res >> 24) & 0xff);
                const int diff0     = de::abs((int)ref0 - (int)res0);
                const int diff1     = de::abs((int)ref1 - (int)res1);
                const int diff2     = de::abs((int)ref2 - (int)res2);
                const int diff3     = de::abs((int)ref3 - (int)res3);

                if (diff0 > maxDiff || diff1 > maxDiff || diff2 > maxDiff || diff3 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog()
                            << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ", expected packSnorm4x8("
                            << inputs[valNdx] << ") = " << tcu::toHex(ref) << ", got " << tcu::toHex(res)
                            << "\n  diffs = " << tcu::IVec4(diff0, diff1, diff2, diff3) << ", max diff = " << maxDiff
                            << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }

private:
    glu::Precision m_precision;
};

class UnpackSnorm4x8Case : public ShaderPackingFunctionCase
{
public:
    UnpackSnorm4x8Case(Context &context, glu::ShaderType shaderType)
        : ShaderPackingFunctionCase(context, (string("unpacksnorm4x8") + getShaderTypePostfix(shaderType)).c_str(),
                                    "unpackSnorm4x8", shaderType)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = unpackSnorm4x8(in0);";
    }

    IterateResult iterate(void)
    {
        const uint32_t maxDiff = 1; // Rounding error.
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<uint32_t> inputs;
        std::vector<tcu::Vec4> outputs;

        inputs.push_back(0x00000000u);
        inputs.push_back(0x7fff8000u);
        inputs.push_back(0x80007fffu);
        inputs.push_back(0xffffffffu);
        inputs.push_back(0x0001fffeu);

        // Random values.
        for (int ndx = 0; ndx < 95; ndx++)
            inputs.push_back(rnd.getUint32());

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const int8_t in0 = (int8_t)(uint8_t)(inputs[valNdx] & 0xff);
                const int8_t in1 = (int8_t)(uint8_t)((inputs[valNdx] >> 8) & 0xff);
                const int8_t in2 = (int8_t)(uint8_t)((inputs[valNdx] >> 16) & 0xff);
                const int8_t in3 = (int8_t)(uint8_t)(inputs[valNdx] >> 24);
                const float ref0 = de::clamp(float(in0) / 127.f, -1.0f, 1.0f);
                const float ref1 = de::clamp(float(in1) / 127.f, -1.0f, 1.0f);
                const float ref2 = de::clamp(float(in2) / 127.f, -1.0f, 1.0f);
                const float ref3 = de::clamp(float(in3) / 127.f, -1.0f, 1.0f);
                const float res0 = outputs[valNdx].x();
                const float res1 = outputs[valNdx].y();
                const float res2 = outputs[valNdx].z();
                const float res3 = outputs[valNdx].w();

                const uint32_t diff0 = getUlpDiff(ref0, res0);
                const uint32_t diff1 = getUlpDiff(ref1, res1);
                const uint32_t diff2 = getUlpDiff(ref2, res2);
                const uint32_t diff3 = getUlpDiff(ref3, res3);

                if (diff0 > maxDiff || diff1 > maxDiff || diff2 > maxDiff || diff3 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n"
                                           << "  expected unpackSnorm4x8(" << tcu::toHex(inputs[valNdx]) << ") = "
                                           << "vec4(" << HexFloat(ref0) << ", " << HexFloat(ref1) << ", "
                                           << HexFloat(ref2) << ", " << HexFloat(ref3) << ")"
                                           << ", got vec4(" << HexFloat(res0) << ", " << HexFloat(res1) << ", "
                                           << HexFloat(res2) << ", " << HexFloat(res3) << ")"
                                           << "\n  ULP diffs = (" << diff0 << ", " << diff1 << ", " << diff2 << ", "
                                           << diff3 << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }
};

class PackUnorm4x8Case : public ShaderPackingFunctionCase
{
public:
    PackUnorm4x8Case(Context &context, glu::ShaderType shaderType, glu::Precision precision)
        : ShaderPackingFunctionCase(
              context,
              (string("packunorm4x8") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(),
              "packUnorm4x8", shaderType)
        , m_precision(precision)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC4, precision)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = packUnorm4x8(in0);";
    }

    IterateResult iterate(void)
    {
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<tcu::Vec4> inputs;
        std::vector<uint32_t> outputs;
        const int                    maxDiff = m_precision == glu::PRECISION_HIGHP    ? 1    : // Rounding only.
                                                  m_precision == glu::PRECISION_MEDIUMP    ? 1    : // (2^-10) * (2^8) + 1
                                                  m_precision == glu::PRECISION_LOWP    ? 2    : 0;    // (2^-8) * (2^8) + 1

        // Special values to check.
        inputs.push_back(tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f));
        inputs.push_back(tcu::Vec4(-1.0f, 1.0f, -1.0f, 1.0f));
        inputs.push_back(tcu::Vec4(0.5f, -0.5f, -0.5f, 0.5f));
        inputs.push_back(tcu::Vec4(-1.5f, 1.5f, -1.5f, 1.5f));
        inputs.push_back(tcu::Vec4(0.25f, -0.75f, -0.25f, 0.75f));

        // Random values, mostly in range.
        for (int ndx = 0; ndx < 15; ndx++)
        {
            const float x = rnd.getFloat() * 1.25f - 0.125f;
            const float y = rnd.getFloat() * 1.25f - 0.125f;
            const float z = rnd.getFloat() * 1.25f - 0.125f;
            const float w = rnd.getFloat() * 1.25f - 0.125f;
            inputs.push_back(tcu::Vec4(x, y, z, w));
        }

        // Large random values.
        for (int ndx = 0; ndx < 80; ndx++)
        {
            const float x = rnd.getFloat() * 1e6f - 1e5f;
            const float y = rnd.getFloat() * 1e6f - 1e5f;
            const float z = rnd.getFloat() * 1e6f - 1e5f;
            const float w = rnd.getFloat() * 1e6f - 1e5f;
            inputs.push_back(tcu::Vec4(x, y, z, w));
        }

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const uint16_t ref0 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].x(), 0.0f, 1.0f) * 255.0f), 0, (1 << 8) - 1);
                const uint16_t ref1 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].y(), 0.0f, 1.0f) * 255.0f), 0, (1 << 8) - 1);
                const uint16_t ref2 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].z(), 0.0f, 1.0f) * 255.0f), 0, (1 << 8) - 1);
                const uint16_t ref3 = (uint8_t)de::clamp(
                    deRoundFloatToInt32(de::clamp(inputs[valNdx].w(), 0.0f, 1.0f) * 255.0f), 0, (1 << 8) - 1);
                const uint32_t ref =
                    (uint32_t(ref3) << 24) | (uint32_t(ref2) << 16) | (uint32_t(ref1) << 8) | uint32_t(ref0);
                const uint32_t res  = outputs[valNdx];
                const uint16_t res0 = (uint8_t)(res & 0xff);
                const uint16_t res1 = (uint8_t)((res >> 8) & 0xff);
                const uint16_t res2 = (uint8_t)((res >> 16) & 0xff);
                const uint16_t res3 = (uint8_t)((res >> 24) & 0xff);
                const int diff0     = de::abs((int)ref0 - (int)res0);
                const int diff1     = de::abs((int)ref1 - (int)res1);
                const int diff2     = de::abs((int)ref2 - (int)res2);
                const int diff3     = de::abs((int)ref3 - (int)res3);

                if (diff0 > maxDiff || diff1 > maxDiff || diff2 > maxDiff || diff3 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog()
                            << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ", expected packUnorm4x8("
                            << inputs[valNdx] << ") = " << tcu::toHex(ref) << ", got " << tcu::toHex(res)
                            << "\n  diffs = " << tcu::IVec4(diff0, diff1, diff2, diff3) << ", max diff = " << maxDiff
                            << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }

private:
    glu::Precision m_precision;
};

class UnpackUnorm4x8Case : public ShaderPackingFunctionCase
{
public:
    UnpackUnorm4x8Case(Context &context, glu::ShaderType shaderType)
        : ShaderPackingFunctionCase(context, (string("unpackunorm4x8") + getShaderTypePostfix(shaderType)).c_str(),
                                    "unpackUnorm4x8", shaderType)
    {
        m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
        m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)));

        m_spec.source = "out0 = unpackUnorm4x8(in0);";
    }

    IterateResult iterate(void)
    {
        const uint32_t maxDiff = 1; // Rounding error.
        de::Random rnd(deStringHash(getName()) ^ 0x776002);
        std::vector<uint32_t> inputs;
        std::vector<tcu::Vec4> outputs;

        inputs.push_back(0x00000000u);
        inputs.push_back(0x7fff8000u);
        inputs.push_back(0x80007fffu);
        inputs.push_back(0xffffffffu);
        inputs.push_back(0x0001fffeu);

        // Random values.
        for (int ndx = 0; ndx < 95; ndx++)
            inputs.push_back(rnd.getUint32());

        outputs.resize(inputs.size());

        m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values"
                           << tcu::TestLog::EndMessage;

        {
            const void *in = &inputs[0];
            void *out      = &outputs[0];

            m_executor->useProgram();
            m_executor->execute((int)inputs.size(), &in, &out);
        }

        // Verify
        {
            const int numValues = (int)inputs.size();
            const int maxPrints = 10;
            int numFailed       = 0;

            for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++)
            {
                const uint8_t in0 = (uint8_t)(inputs[valNdx] & 0xff);
                const uint8_t in1 = (uint8_t)((inputs[valNdx] >> 8) & 0xff);
                const uint8_t in2 = (uint8_t)((inputs[valNdx] >> 16) & 0xff);
                const uint8_t in3 = (uint8_t)(inputs[valNdx] >> 24);
                const float ref0  = de::clamp(float(in0) / 255.f, 0.0f, 1.0f);
                const float ref1  = de::clamp(float(in1) / 255.f, 0.0f, 1.0f);
                const float ref2  = de::clamp(float(in2) / 255.f, 0.0f, 1.0f);
                const float ref3  = de::clamp(float(in3) / 255.f, 0.0f, 1.0f);
                const float res0  = outputs[valNdx].x();
                const float res1  = outputs[valNdx].y();
                const float res2  = outputs[valNdx].z();
                const float res3  = outputs[valNdx].w();

                const uint32_t diff0 = getUlpDiff(ref0, res0);
                const uint32_t diff1 = getUlpDiff(ref1, res1);
                const uint32_t diff2 = getUlpDiff(ref2, res2);
                const uint32_t diff3 = getUlpDiff(ref3, res3);

                if (diff0 > maxDiff || diff1 > maxDiff || diff2 > maxDiff || diff3 > maxDiff)
                {
                    if (numFailed < maxPrints)
                    {
                        m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n"
                                           << "  expected unpackUnorm4x8(" << tcu::toHex(inputs[valNdx]) << ") = "
                                           << "vec4(" << HexFloat(ref0) << ", " << HexFloat(ref1) << ", "
                                           << HexFloat(ref2) << ", " << HexFloat(ref3) << ")"
                                           << ", got vec4(" << HexFloat(res0) << ", " << HexFloat(res1) << ", "
                                           << HexFloat(res2) << ", " << HexFloat(res3) << ")"
                                           << "\n  ULP diffs = (" << diff0 << ", " << diff1 << ", " << diff2 << ", "
                                           << diff3 << "), max diff = " << maxDiff << TestLog::EndMessage;
                    }
                    else if (numFailed == maxPrints)
                        m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;

                    numFailed += 1;
                }
            }

            m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed"
                               << TestLog::EndMessage;

            m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    numFailed == 0 ? "Pass" : "Result comparison failed");
        }

        return STOP;
    }
};

ShaderPackingFunctionTests::ShaderPackingFunctionTests(Context &context)
    : TestCaseGroup(context, "pack_unpack", "Floating-point pack and unpack function tests")
{
}

ShaderPackingFunctionTests::~ShaderPackingFunctionTests(void)
{
}

void ShaderPackingFunctionTests::init(void)
{
    // New built-in functions in GLES 3.1
    {
        const glu::ShaderType allShaderTypes[] = {glu::SHADERTYPE_VERTEX,
                                                  glu::SHADERTYPE_TESSELLATION_CONTROL,
                                                  glu::SHADERTYPE_TESSELLATION_EVALUATION,
                                                  glu::SHADERTYPE_GEOMETRY,
                                                  glu::SHADERTYPE_FRAGMENT,
                                                  glu::SHADERTYPE_COMPUTE};

        // packSnorm4x8
        for (int prec = 0; prec < glu::PRECISION_LAST; prec++)
        {
            for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(allShaderTypes); shaderTypeNdx++)
                addChild(new PackSnorm4x8Case(m_context, allShaderTypes[shaderTypeNdx], glu::Precision(prec)));
        }

        // unpackSnorm4x8
        for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(allShaderTypes); shaderTypeNdx++)
            addChild(new UnpackSnorm4x8Case(m_context, allShaderTypes[shaderTypeNdx]));

        // packUnorm4x8
        for (int prec = 0; prec < glu::PRECISION_LAST; prec++)
        {
            for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(allShaderTypes); shaderTypeNdx++)
                addChild(new PackUnorm4x8Case(m_context, allShaderTypes[shaderTypeNdx], glu::Precision(prec)));
        }

        // unpackUnorm4x8
        for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(allShaderTypes); shaderTypeNdx++)
            addChild(new UnpackUnorm4x8Case(m_context, allShaderTypes[shaderTypeNdx]));
    }

    // GLES 3 functions in new shader types.
    {
        const glu::ShaderType newShaderTypes[] = {glu::SHADERTYPE_GEOMETRY, glu::SHADERTYPE_COMPUTE};

        // packSnorm2x16
        for (int prec = 0; prec < glu::PRECISION_LAST; prec++)
        {
            for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(newShaderTypes); shaderTypeNdx++)
                addChild(new PackSnorm2x16Case(m_context, newShaderTypes[shaderTypeNdx], glu::Precision(prec)));
        }

        // unpackSnorm2x16
        for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(newShaderTypes); shaderTypeNdx++)
            addChild(new UnpackSnorm2x16Case(m_context, newShaderTypes[shaderTypeNdx]));

        // packUnorm2x16
        for (int prec = 0; prec < glu::PRECISION_LAST; prec++)
        {
            for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(newShaderTypes); shaderTypeNdx++)
                addChild(new PackUnorm2x16Case(m_context, newShaderTypes[shaderTypeNdx], glu::Precision(prec)));
        }

        // unpackUnorm2x16
        for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(newShaderTypes); shaderTypeNdx++)
            addChild(new UnpackUnorm2x16Case(m_context, newShaderTypes[shaderTypeNdx]));

        // packHalf2x16
        for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(newShaderTypes); shaderTypeNdx++)
            addChild(new PackHalf2x16Case(m_context, newShaderTypes[shaderTypeNdx]));

        // unpackHalf2x16
        for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(newShaderTypes); shaderTypeNdx++)
            addChild(new UnpackHalf2x16Case(m_context, newShaderTypes[shaderTypeNdx]));
    }
}

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