external/openglcts/modules/common/glcKHRDebugTests.hpp

#ifndef _GLCKHRDEBUGTESTS_HPP
#define _GLCKHRDEBUGTESTS_HPP
/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-2018 The Khronos Group Inc.
 *
 * 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
 */ /*-------------------------------------------------------------------*/

/**
 * \file  glcKHRDebugTests.hpp
 * \brief Declares test classes for "KHR Debug" functionality.
 */ /*-------------------------------------------------------------------*/

#include "glcTestCase.hpp"
#include "glwDefs.hpp"

#include "deThreadLocal.hpp"

namespace glu
{
class RenderContext;
}

namespace glw
{
class Functions;
}

namespace glcts
{
namespace KHRDebug
{
/** Base of all test cases.
 * Manages rendering context
 **/
class TestBase
{
public:
	/* Public methods */
	TestBase(tcu::TestContext& testContext, glu::ApiType apiType, bool is_debug);
	virtual ~TestBase();

protected:
	/* Protected methods */
	void init();
	void done();

	/* Protected fields */
	const glw::Functions* m_gl;
	const bool			  m_is_debug;
	glu::RenderContext*   m_rc;

private:
	/* Private methods */
	void initDebug();
	void initNonDebug();

	/* Private fields */
	tcu::TestContext&	m_testContext;
	glu::ApiType		m_apiType;
};

/** Implementation of test APIErrors. Description follows:
 *
 * This test verifies that errors are generated as expected.
 *
 * This test should be executed for DEBUG and NON-DEBUG contexts.
 *
 * DebugMessageControl function should generate:
 * - INVALID_ENUM when <source> is invalid;
 * - INVALID_ENUM when <type> is invalid;
 * - INVALID_ENUM when <severity> is invalid;
 * - INVALID_VALUE when <count> is negative;
 * - INVALID_OPERATION when <count> is not zero and <source> is DONT_CARE;
 * - INVALID_OPERATION when <count> is not zero and <type> is DONT_CARE;
 * - INVALID_OPERATION when <count> is not zero and <severity> is not
 * DONT_CARE.
 *
 * GetDebugMessageLog function should generate:
 * - INVALID_VALUE when <bufSize> is negative and messageLog is not NULL.
 *
 * DebugMessageInsert function should generate:
 * - INVALID_ENUM when <source> is not DEBUG_SOURCE_APPLICATION or
 * DEBUG_SOURCE_THIRD_PARTY;
 * - INVALID_ENUM when <type> is invalid;
 * - INVALID_ENUM when <severity> is invalid;
 * - INVALID_VALUE when length of string <buf> is not less than
 * MAX_DEBUG_MESSAGE_LENGTH.
 *
 * PushDebugGroup function should generate:
 * - INVALID_ENUM when <source> is not DEBUG_SOURCE_APPLICATION or
 * DEBUG_SOURCE_THIRD_PARTY;
 * - INVALID_VALUE when length of string <message> is not less than
 * MAX_DEBUG_MESSAGE_LENGTH;
 * - STACK_OVERFLOW when stack contains MAX_DEBUG_GROUP_STACK_DEPTH entries.
 *
 * PopDebugGroup function should generate:
 * - STACK_UNDERFLOW when stack contains no entries.
 *
 * ObjectLabel function should generate:
 * - INVALID_ENUM when <identifier> is invalid;
 * - INVALID_VALUE when if <name> is not valid object name of type specified by
 * <identifier>;
 * - INVALID_VALUE when length of string <label> is not less than
 * MAX_LABEL_LENGTH.
 *
 * GetObjectLabel function should generate:
 * - INVALID_ENUM when <identifier> is invalid;
 * - INVALID_VALUE when if <name> is not valid object name of type specified by
 * <identifier>;
 * - INVALID_VALUE when <bufSize> is negative.
 *
 * ObjectPtrLabel function should generate:
 * - INVALID_VALUE when <ptr> is not the name of sync object;
 * - INVALID_VALUE when length of string <label> is not less than
 * MAX_LABEL_LENGTH.
 *
 * GetObjectPtrLabel function should generate:
 * - INVALID_VALUE when <ptr> is not the name of sync object;
 * - INVALID_VALUE when <bufSize> is negative.
 *
 * GetPointerv function should generate:
 * - INVALID_ENUM when <pname> is invalid.
 **/
class APIErrorsTest : public TestBase, public tcu::TestCase
{
public:
	/* Public methods */
	APIErrorsTest(tcu::TestContext& testCtx, glu::ApiType apiType, bool is_debug, const glw::GLchar* name);

	virtual ~APIErrorsTest()
	{
	}

	/* Public methods inherited from TestCase */
	virtual tcu::TestNode::IterateResult iterate(void);
};

/** Implementation of test Labels. Description follows:
 *
 * This test verifies that it is possible to assign and query labels.
 *
 * This test should be executed for DEBUG and NON-DEBUG contexts.
 *
 * For each valid object type:
 * - create new object;
 * - query label; It is expected that result will be an empty string and length
 * will be zero;
 * - assign label to object;
 * - query label; It is expected that result will be equal to the provided
 * label and length will be correct;
 * - query length only; Correct value is expected;
 * - query label with <bufSize> less than actual length of label; It is
 * expected that only <bufSize> characters will be stored in buffer (including
 * NULL);
 * - query label with <bufSize> equal zero; It is expected that buffer contents
 * will not be modified;
 * - assign empty string as label to object;
 * - query label, it is expected that result will be an empty string and length
 * will be zero;
 * - assign NULL as label to object;
 * - query label, it is expected that result will be an empty string and length
 * will be zero;
 * - delete object.
 **/
class LabelsTest : public tcu::TestCase, public TestBase
{
public:
	/* Public methods */
	LabelsTest(tcu::TestContext& testCtx, glu::ApiType apiType, bool is_debug, const glw::GLchar* name);

	virtual ~LabelsTest()
	{
	}

	/* Public methods inherited from TestCase */
	virtual tcu::TestNode::IterateResult iterate(void);

private:
	/* Private routines */
	static glw::GLuint createBuffer(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createFramebuffer(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createProgram(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createProgramPipeline(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createQuery(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createRenderbuffer(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createSampler(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createShader(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createTexture(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createTransformFeedback(const glw::Functions* gl, const glu::RenderContext* rc);
	static glw::GLuint createVertexArray(const glw::Functions* gl, const glu::RenderContext* rc);

	static glw::GLvoid deleteBuffer(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteFramebuffer(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteProgram(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteProgramPipeline(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteQuery(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteRenderbuffer(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteSampler(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteShader(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteTexture(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteTransformFeedback(const glw::Functions* gl, glw::GLuint id);
	static glw::GLvoid deleteVertexArray(const glw::Functions* gl, glw::GLuint id);
};

/** Implementation of test ReceivingMessages. Description follows:
 *
 * This test verifies that it is possible to receive messages.
 *
 * This test should be executed for DEBUG contexts only.
 *
 * Callback used during the test should make use of <userParam> to inform the
 * test about any calls.
 *
 * Steps:
 * - verify that the state of DEBUG_OUTPUT is enabled as it should be by
 * default;
 * - verify that state of DEBUG_CALLBACK_FUNCTION and
 * DEBUG_CALLBACK_USER_PARAM are NULL;
 *
 * - insert a message with DebugMessageInsert;
 * - inspect message log to check if the message is reported;
 * - inspect message log again, there should be no messages;
 *
 * - disable DEBUG_OUTPUT;
 * - insert a message with DebugMessageInsert;
 * - inspect message log again, there should be no messages;
 *
 * - enable DEBUG_OUTPUT;
 * - register debug message callback with DebugMessageCallback;
 * - verify that the state of DEBUG_CALLBACK_FUNCTION and
 * DEBUG_CALLBACK_USER_PARAM are correct;
 * - insert a message with DebugMessageInsert;
 * - it is expected that debug message callback will be executed for
 * the message;
 * - inspect message log to check there are no messages;
 *
 * - disable DEBUG_OUTPUT;
 * - insert a message with DebugMessageInsert;
 * - debug message callback should not be called;
 * - inspect message log to check there are no messages;
 *
 * - enable DEBUG_OUTPUT;
 * - execute DebugMessageControl with <type> DEBUG_TYPE_ERROR, <severity>
 * DEBUG_SEVERITY_HIGH and <enabled> FALSE;
 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_ERROR
 * and <severity> DEBUG_SEVERITY_MEDIUM;
 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER
 * and <severity> DEBUG_SEVERITY_HIGH;
 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER
 * and <severity> DEBUG_SEVERITY_LOW;
 * - debug message callback should not be called;
 * - inspect message log to check there are no messages;
 *
 * - set NULL as debug message callback;
 * - verify that state of DEBUG_CALLBACK_FUNCTION and
 * DEBUG_CALLBACK_USER_PARAM are NULL;
 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_ERROR
 * and <severity> DEBUG_SEVERITY_MEDIUM;
 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER
 * and <severity> DEBUG_SEVERITY_HIGH;
 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER
 * and <severity> DEBUG_SEVERITY_LOW;
 * - inspect message log to check there are no messages;
 *
 * - execute DebugMessageControl to enable messages of <type> DEBUG_TYPE_ERROR
 * and <severity> DEBUG_SEVERITY_HIGH.
 *
 * - insert MAX_DEBUG_LOGGED_MESSAGES + 1 unique messages with
 * DebugMessageInsert;
 * - check state of DEBUG_LOGGED_MESSAGES; It is expected that
 * MAX_DEBUG_LOGGED_MESSAGES will be reported;
 *
 * If MAX_DEBUG_LOGGED_MESSAGES is greater than 1:
 * - inspect first half of the message log by specifying proper <count>; Verify
 * that messages are reported in order from the oldest to the newest; Check
 * that <count> messages were stored into provided buffers;
 * - check state of DEBUG_LOGGED_MESSAGES; It is expected that <count> messages
 * were removed from log;
 * - inspect rest of the message log with <bufSize> too small to held last
 * message; Verify that messages are reported in order from the oldest to the
 * newest; Verify that maximum <bufSize> characters were written to
 * <messageLog>;
 * - check state of DEBUG_LOGGED_MESSAGES; It is expected that one message is
 * available;
 * - fetch the message and verify it is the newest one;
 **/
class ReceivingMessagesTest : public tcu::TestCase, public TestBase
{
public:
	/* Public methods */
	ReceivingMessagesTest(tcu::TestContext& testCtx, glu::ApiType apiType);

	virtual ~ReceivingMessagesTest()
	{
	}

	/* Public methods inherited from TestCase */
	virtual tcu::TestNode::IterateResult iterate(void);

private:
	/* Private routines */
	static void GLW_APIENTRY debug_proc(glw::GLenum source, glw::GLenum type, glw::GLuint id, glw::GLenum severity,
										glw::GLsizei length, const glw::GLchar* message, const void* info);

	void inspectCallbackCounter(glw::GLuint& callback_counter, glw::GLuint expected_number_of_messages) const;

	void inspectDebugState(glw::GLboolean expected_state, glw::GLDEBUGPROC expected_callback,
						   glw::GLvoid* expected_user_info) const;

	void inspectMessageLog(glw::GLuint expected_number_of_messages) const;
};

/** Implementation of test Groups. Description follows:
 *
 * This test verifies that debug message groups can be used to control which
 * messages are being generated.
 *
 * This test should be executed for DEBUG contexts only.
 *
 * Steps:
 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 1;
 *
 * - insert message with <type> DEBUG_TYPE_ERROR;
 * - inspect message log to check if the message is reported;
 * - insert message with <type> DEBUG_TYPE_OTHER;
 * - inspect message log to check if the message is reported;
 *
 * - push debug group with unique <id> and <message>;
 * - inspect message log to check if the message about push is reported;
 * - disable messages with <type> DEBUG_TYPE_ERROR;
 * - insert message with <type> DEBUG_TYPE_ERROR;
 * - inspect message log to check there are no messages;
 * - insert message with <type> DEBUG_TYPE_OTHER;
 * - inspect message log to check if the message is reported;
 *
 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 2;
 *
 * - push debug group with unique <id> and <message>;
 * - inspect message log to check if the message about push is reported;
 * - disable messages with <type> DEBUG_TYPE_OTHER;
 * - insert message with <type> DEBUG_TYPE_ERROR;
 * - inspect message log to check there are no messages;
 * - insert message with <type> DEBUG_TYPE_OTHER;
 * - inspect message log to check there are no messages;
 *
 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 3;
 *
 * - pop debug group;
 * - inspect message log to check if the message about pop is reported and
 * corresponds with the second push;
 * - insert message with <type> DEBUG_TYPE_ERROR;
 * - inspect message log to check there are no messages;
 * - insert message with <type> DEBUG_TYPE_OTHER;
 * - inspect message log to check if the message is reported;
 *
 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 2;
 *
 * - pop debug group;
 * - inspect message log to check if the message about pop is reported and
 * corresponds with the first push;
 * - insert message with <type> DEBUG_TYPE_ERROR;
 * - inspect message log to check if the message is reported;
 * - insert message with <type> DEBUG_TYPE_OTHER;
 * - inspect message log to check if the message is reported;
 *
 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 1.
 **/
class GroupsTest : public tcu::TestCase, public TestBase
{
public:
	/* Public methods */
	GroupsTest(tcu::TestContext& testCtx, glu::ApiType apiType);

	virtual ~GroupsTest()
	{
	}

	/* Public methods inherited from TestCase */
	virtual tcu::TestNode::IterateResult iterate(void);

private:
	/* Private routines */
	void inspectGroupStack(glw::GLuint expected_depth) const;
	void inspectMessageLog(glw::GLenum expected_source, glw::GLenum expected_type, glw::GLuint expected_id,
						   glw::GLenum expected_severity, glw::GLsizei expected_length,
						   const glw::GLchar* expected_label) const;
	void verifyEmptyLog() const;
};

/** Implementation of test SynchronousCalls. Description follows:
 *
 * This test verifies that implementation execute debug message callback in
 * synchronous way when DEBUG_OUTPUT_SYNCHRONOUS is enabled.
 *
 * This test should be executed for DEBUG contexts only.
 *
 * Steps:
 * - create an instance of the following structure
 * - set callback_executed to 0;
 * - enable DEBUG_OUTPUT_SYNCHRONOUS;
 * - register debug message callback with DebugMessageCallback; Provide the
 * instance of UserParam structure as <userParam>; Routine should do the
 * following:
 *   * set callback_executed to 1;
 *   * store thread_id;
 * - insert a message with DebugMessageInsert;
 * - check if:
 *   * callback_executed is set to 1;
 *   * the message is recorded by the current thread.
 * - reset userParam object;
 * - execute BindBufferBase with GL_ARRAY_BUFFER <target>, GL_INVALID_ENUM
 * error should be generated;
 * - test pass if:
 *   * callback_executed is set to 0 - implementation does not send messages;
 *   * callback_executed is set to 1 and thread_id is the same
 *   as "test" thread - implementation sent message to proper thread;
 **/
class SynchronousCallsTest : public tcu::TestCase, public TestBase
{
public:
	/* Public methods */
	SynchronousCallsTest(tcu::TestContext& testCtx, glu::ApiType apiType);
	~SynchronousCallsTest(void);

	/* Public methods inherited from TestCase */
	virtual tcu::TestNode::IterateResult iterate(void);

private:
	/* Private routines */
	static void GLW_APIENTRY debug_proc(glw::GLenum source, glw::GLenum type, glw::GLuint id, glw::GLenum severity,
										glw::GLsizei length, const glw::GLchar* message, const void* info);

	de::ThreadLocal m_tls;
	deUint32		m_uid;
};
} /* KHRDebug */

/** Group class for khr debug conformance tests */
class KHRDebugTests : public tcu::TestCaseGroup
{
public:
	/* Public methods */
	KHRDebugTests(tcu::TestContext& testCtx, glu::ApiType apiType);

	virtual ~KHRDebugTests(void)
	{
	}

	virtual void init(void);

private:
	/* Private methods */
	KHRDebugTests(const KHRDebugTests& other);
	KHRDebugTests& operator=(const KHRDebugTests& other);

	/* Private members */
	glu::ApiType m_apiType;
};

} /* glcts */

#endif // _GLCKHRDEBUGTESTS_HPP