xref: /aosp_15_r20/external/deqp/modules/glshared/glsStateQueryUtil.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

#ifndef _GLSSTATEQUERYUTIL_HPP
#define _GLSSTATEQUERYUTIL_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) 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 State Query test utils.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"
#include "tcuTestLog.hpp"
#include "tcuTestContext.hpp"
#include "tcuResultCollector.hpp"
#include "glwDefs.hpp"
#include "deMath.h"

namespace glu
{
class CallLogWrapper;
} // namespace glu

namespace deqp
{
namespace gls
{
namespace StateQueryUtil
{

#define GLS_COLLECT_GL_ERROR(RES, ERR, MSG)                                                          \
    do                                                                                               \
    {                                                                                                \
        const uint32_t err = (ERR);                                                                  \
        if (err != GL_NO_ERROR)                                                                      \
            (RES).fail(std::string("Got Error ") + glu::getErrorStr(err).toString() + ": " + (MSG)); \
    } while (false)

/*--------------------------------------------------------------------*//*!
 * \brief Rounds given float to the nearest integer (half up).
 *
 * Returns the nearest integer for a float argument. In the case that there
 * are two nearest integers at the equal distance (aka. the argument is of
 * form x.5), the integer with the higher value is chosen. (x.5 rounds to x+1)
 *//*--------------------------------------------------------------------*/
template <typename T>
T roundGLfloatToNearestIntegerHalfUp(float val)
{
    return (T)(deFloatFloor(val + 0.5f));
}

/*--------------------------------------------------------------------*//*!
 * \brief Rounds given float to the nearest integer (half down).
 *
 * Returns the nearest integer for a float argument. In the case that there
 * are two nearest integers at the equal distance (aka. the argument is of
 * form x.5), the integer with the higher value is chosen. (x.5 rounds to x)
 *//*--------------------------------------------------------------------*/
template <typename T>
T roundGLfloatToNearestIntegerHalfDown(float val)
{
    return (T)(deFloatCeil(val - 0.5f));
}

template <typename T>
class StateQueryMemoryWriteGuard
{
public:
    StateQueryMemoryWriteGuard(void);

    operator T &(void);
    T *operator&(void);

    bool isUndefined(void) const;
    bool isMemoryContaminated(void) const;
    bool isPreguardContaminated(void) const;
    bool isPostguardContaminated(void) const;
    bool verifyValidity(tcu::TestContext &testCtx) const;
    bool verifyValidity(tcu::ResultCollector &result) const;

    const T &get(void) const
    {
        return m_value;
    }

private:
    enum
    {
        WRITE_GUARD_VALUE = 0xDE
    };

    T m_preguard;
    T m_value;
    T m_postguard; // \note guards are not const qualified since the GL implementation might modify them
};

template <typename T>
StateQueryMemoryWriteGuard<T>::StateQueryMemoryWriteGuard(void)
{
    DE_STATIC_ASSERT(sizeof(T) * 3 == sizeof(StateQueryMemoryWriteGuard<T>)); // tightly packed

    deMemset(&m_preguard, WRITE_GUARD_VALUE, sizeof(m_preguard));
    deMemset(&m_value, WRITE_GUARD_VALUE, sizeof(m_value));
    deMemset(&m_postguard, WRITE_GUARD_VALUE, sizeof(m_postguard));
}

template <typename T>
StateQueryMemoryWriteGuard<T>::operator T &(void)
{
    return m_value;
}

template <typename T>
T *StateQueryMemoryWriteGuard<T>::operator&(void)
{
    return &m_value;
}

template <typename T>
bool StateQueryMemoryWriteGuard<T>::isUndefined() const
{
    for (size_t i = 0; i < sizeof(T); ++i)
        if (((uint8_t *)&m_value)[i] != (uint8_t)WRITE_GUARD_VALUE)
            return false;
    return true;
}

template <typename T>
bool StateQueryMemoryWriteGuard<T>::isMemoryContaminated() const
{
    return isPreguardContaminated() || isPostguardContaminated();
}

template <typename T>
bool StateQueryMemoryWriteGuard<T>::isPreguardContaminated(void) const
{
    for (size_t i = 0; i < sizeof(T); ++i)
        if (((uint8_t *)&m_preguard)[i] != (uint8_t)WRITE_GUARD_VALUE)
            return true;
    return false;
}

template <typename T>
bool StateQueryMemoryWriteGuard<T>::isPostguardContaminated(void) const
{
    for (size_t i = 0; i < sizeof(T); ++i)
        if (((uint8_t *)&m_postguard)[i] != (uint8_t)WRITE_GUARD_VALUE)
            return true;
    return false;
}

template <typename T>
bool StateQueryMemoryWriteGuard<T>::verifyValidity(tcu::TestContext &testCtx) const
{
    using tcu::TestLog;

    if (isPreguardContaminated())
    {
        testCtx.getLog() << TestLog::Message << "// ERROR: Pre-guard value was modified " << TestLog::EndMessage;
        if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || testCtx.getTestResult() == QP_TEST_RESULT_LAST)
            testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");

        return false;
    }
    else if (isPostguardContaminated())
    {
        testCtx.getLog() << TestLog::Message << "// ERROR: Post-guard value was modified " << TestLog::EndMessage;
        if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || testCtx.getTestResult() == QP_TEST_RESULT_LAST)
            testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");

        return false;
    }
    else if (isUndefined())
    {
        testCtx.getLog() << TestLog::Message << "// ERROR: Get* did not return a value" << TestLog::EndMessage;
        if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || testCtx.getTestResult() == QP_TEST_RESULT_LAST)
            testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did not return a value");

        return false;
    }

    return true;
}

template <typename T>
bool StateQueryMemoryWriteGuard<T>::verifyValidity(tcu::ResultCollector &result) const
{
    using tcu::TestLog;

    if (isPreguardContaminated())
    {
        result.fail("pre-guard value was modified");
        return false;
    }
    else if (isPostguardContaminated())
    {
        result.fail("post-guard value was modified");
        return false;
    }
    else if (isUndefined())
    {
        result.fail("Get* did not return a value");
        return false;
    }

    return true;
}

template <typename T>
std::ostream &operator<<(std::ostream &str, const StateQueryMemoryWriteGuard<T> &guard)
{
    return str << guard.get();
}

// Verifiers

enum QueryType
{
    QUERY_BOOLEAN = 0,
    QUERY_BOOLEAN_VEC4,
    QUERY_ISENABLED,
    QUERY_INTEGER,
    QUERY_INTEGER64,
    QUERY_FLOAT,

    // indexed
    QUERY_INDEXED_BOOLEAN,
    QUERY_INDEXED_BOOLEAN_VEC4,
    QUERY_INDEXED_ISENABLED,
    QUERY_INDEXED_INTEGER,
    QUERY_INDEXED_INTEGER_VEC4,
    QUERY_INDEXED_INTEGER64,
    QUERY_INDEXED_INTEGER64_VEC4,

    // attributes
    QUERY_ATTRIBUTE_INTEGER,
    QUERY_ATTRIBUTE_FLOAT,
    QUERY_ATTRIBUTE_PURE_INTEGER,
    QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER,

    // fb
    QUERY_FRAMEBUFFER_INTEGER,

    // program
    QUERY_PROGRAM_INTEGER,
    QUERY_PROGRAM_INTEGER_VEC3,

    // program pipeline
    QUERY_PIPELINE_INTEGER,

    // texture param
    QUERY_TEXTURE_PARAM_INTEGER,
    QUERY_TEXTURE_PARAM_FLOAT,
    QUERY_TEXTURE_PARAM_PURE_INTEGER,
    QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER,
    QUERY_TEXTURE_PARAM_INTEGER_VEC4,
    QUERY_TEXTURE_PARAM_FLOAT_VEC4,
    QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4,
    QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4,

    // texture level
    QUERY_TEXTURE_LEVEL_INTEGER,
    QUERY_TEXTURE_LEVEL_FLOAT,

    // pointer
    QUERY_POINTER,

    // object states
    QUERY_ISTEXTURE,

    // query queries
    QUERY_QUERY,

    // sampler state
    QUERY_SAMPLER_PARAM_INTEGER,
    QUERY_SAMPLER_PARAM_FLOAT,
    QUERY_SAMPLER_PARAM_PURE_INTEGER,
    QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER,
    QUERY_SAMPLER_PARAM_INTEGER_VEC4,
    QUERY_SAMPLER_PARAM_FLOAT_VEC4,
    QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4,
    QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4,

    QUERY_LAST
};

enum DataType
{
    DATATYPE_BOOLEAN = 0,
    DATATYPE_INTEGER,
    DATATYPE_INTEGER64,
    DATATYPE_FLOAT16,
    DATATYPE_FLOAT,
    DATATYPE_UNSIGNED_INTEGER,
    DATATYPE_INTEGER_VEC3,
    DATATYPE_FLOAT_VEC4,
    DATATYPE_INTEGER_VEC4,
    DATATYPE_INTEGER64_VEC4,
    DATATYPE_UNSIGNED_INTEGER_VEC4,
    DATATYPE_BOOLEAN_VEC4,
    DATATYPE_POINTER,

    DATATYPE_LAST
};

class QueriedState
{
public:
    typedef glw::GLint GLIntVec3[3];
    typedef glw::GLint GLIntVec4[4];
    typedef glw::GLuint GLUintVec4[4];
    typedef glw::GLfloat GLFloatVec4[4];
    typedef bool BooleanVec4[4];
    typedef glw::GLint64 GLInt64Vec4[4];

    QueriedState(void);
    explicit QueriedState(glw::GLint);
    explicit QueriedState(glw::GLint64);
    explicit QueriedState(bool);
    explicit QueriedState(glw::GLfloat);
    explicit QueriedState(glw::GLuint);
    explicit QueriedState(const GLIntVec3 &);
    explicit QueriedState(void *);
    explicit QueriedState(const GLIntVec4 &);
    explicit QueriedState(const GLUintVec4 &);
    explicit QueriedState(const GLFloatVec4 &);
    explicit QueriedState(const BooleanVec4 &);
    explicit QueriedState(const GLInt64Vec4 &);

    bool isUndefined(void) const;
    DataType getType(void) const;

    glw::GLint &getIntAccess(void);
    glw::GLint64 &getInt64Access(void);
    bool &getBoolAccess(void);
    glw::GLfloat &getFloatAccess(void);
    glw::GLuint &getUintAccess(void);
    GLIntVec3 &getIntVec3Access(void);
    void *&getPtrAccess(void);
    GLIntVec4 &getIntVec4Access(void);
    GLUintVec4 &getUintVec4Access(void);
    GLFloatVec4 &getFloatVec4Access(void);
    BooleanVec4 &getBooleanVec4Access(void);
    GLInt64Vec4 &getInt64Vec4Access(void);

private:
    DataType m_type;
    union
    {
        glw::GLint vInt;
        glw::GLint64 vInt64;
        bool vBool;
        glw::GLfloat vFloat;
        glw::GLuint vUint;
        GLIntVec3 vIntVec3;
        void *vPtr;
        GLIntVec4 vIntVec4;
        GLUintVec4 vUintVec4;
        GLFloatVec4 vFloatVec4;
        BooleanVec4 vBooleanVec4;
        GLInt64Vec4 vInt64Vec4;
    } m_v;
};

// query functions

void queryState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum pname,
                QueriedState &state);
void queryIndexedState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
                       int index, QueriedState &state);
void queryAttributeState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
                         int index, QueriedState &state);
void queryFramebufferState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
                           glw::GLenum pname, QueriedState &state);
void queryProgramState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint program,
                       glw::GLenum pname, QueriedState &state);
void queryPipelineState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint pipeline,
                        glw::GLenum pname, QueriedState &state);
void queryTextureParamState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
                            glw::GLenum pname, QueriedState &state);
void queryTextureLevelState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
                            int level, glw::GLenum pname, QueriedState &state);
void queryPointerState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum pname,
                       QueriedState &state);
void queryObjectState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint handle,
                      QueriedState &state);
void queryQueryState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
                     glw::GLenum pname, QueriedState &state);
void querySamplerState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint sampler,
                       glw::GLenum pname, QueriedState &state);

// verification functions

void verifyBoolean(tcu::ResultCollector &result, QueriedState &state, bool expected);
void verifyInteger(tcu::ResultCollector &result, QueriedState &state, int expected);
void verifyIntegerMin(tcu::ResultCollector &result, QueriedState &state, int minValue);
void verifyIntegerMax(tcu::ResultCollector &result, QueriedState &state, int maxValue);
void verifyIntegersEqual(tcu::ResultCollector &result, QueriedState &stateA, QueriedState &stateB);
void verifyFloat(tcu::ResultCollector &result, QueriedState &state, float expected);
void verifyFloatMin(tcu::ResultCollector &result, QueriedState &state, float minValue);
void verifyFloatMax(tcu::ResultCollector &result, QueriedState &state, float maxValue);
void verifyIntegerVec3(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec3 &expected);
void verifyIntegerVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec4 &expected);
void verifyUnsignedIntegerVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::UVec4 &expected);
void verifyFloatVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::Vec4 &expected);
void verifyBooleanVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::BVec4 &expected);
void verifyPointer(tcu::ResultCollector &result, QueriedState &state, const void *expected);
void verifyNormalizedI32Vec4(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec4 &expected);

// Helper functions that both query and verify

void verifyStateBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, bool expected,
                        QueryType type);
void verifyStateInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int expected,
                        QueryType type);
void verifyStateIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int minValue,
                           QueryType type);
void verifyStateIntegerMax(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int maxValue,
                           QueryType type);
void verifyStateIntegerEqualToOther(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                    glw::GLenum other, QueryType type);
void verifyStateFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float reference,
                      QueryType type);
void verifyStateFloatMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float minValue,
                         QueryType type);
void verifyStateFloatMax(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float maxValue,
                         QueryType type);
void verifyStatePointer(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, const void *expected,
                        QueryType type);
void verifyStateIndexedBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
                               bool expected, QueryType type);
void verifyStateIndexedBooleanVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
                                   const tcu::BVec4 &expected, QueryType type);
void verifyStateIndexedInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
                               int expected, QueryType type);
void verifyStateIndexedIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
                                  int minValue, QueryType type);
void verifyStateAttributeInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
                                 int expected, QueryType type);
void verifyStateFramebufferInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                   glw::GLenum pname, int expected, QueryType type);
void verifyStateFramebufferIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                      glw::GLenum pname, int minValue, QueryType type);
void verifyStateProgramInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint program,
                               glw::GLenum pname, int expected, QueryType type);
void verifyStateProgramIntegerVec3(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint program,
                                   glw::GLenum pname, const tcu::IVec3 &expected, QueryType type);
void verifyStatePipelineInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint pipeline,
                                glw::GLenum pname, int expected, QueryType type);
void verifyStateTextureParamInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                    glw::GLenum pname, int expected, QueryType type);
void verifyStateTextureParamFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                  glw::GLenum pname, float expected, QueryType type);
void verifyStateTextureParamFloatVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                      glw::GLenum pname, const tcu::Vec4 &expected, QueryType type);
void verifyStateTextureParamNormalizedI32Vec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                              glw::GLenum pname, const tcu::IVec4 &expected, QueryType type);
void verifyStateTextureParamIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                        glw::GLenum pname, const tcu::IVec4 &expected, QueryType type);
void verifyStateTextureParamUnsignedIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl,
                                                glw::GLenum target, glw::GLenum pname, const tcu::UVec4 &expected,
                                                QueryType type);
void verifyStateTextureLevelInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                                    int level, glw::GLenum pname, int expected, QueryType type);
void verifyStateObjectBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint handle, bool expected,
                              QueryType type);
void verifyStateQueryInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
                             glw::GLenum pname, int expected, QueryType type);
void verifyStateSamplerParamInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
                                    glw::GLenum pname, int expected, QueryType type);
void verifyStateSamplerParamFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
                                  glw::GLenum pname, float expected, QueryType type);
void verifyStateSamplerParamFloatVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
                                      glw::GLenum pname, const tcu::Vec4 &expected, QueryType type);
void verifyStateSamplerParamNormalizedI32Vec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl,
                                              glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4 &expected,
                                              QueryType type);
void verifyStateSamplerParamIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
                                        glw::GLenum pname, const tcu::IVec4 &expected, QueryType type);
void verifyStateSamplerParamUnsignedIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl,
                                                glw::GLuint sampler, glw::GLenum pname, const tcu::UVec4 &expected,
                                                QueryType type);

} // namespace StateQueryUtil
} // namespace gls
} // namespace deqp

#endif // _GLSSTATEQUERYUTIL_HPP