modules/gl/gl4cMultiBindTests.hpp

#ifndef _GL4CMULTIBINDTESTS_HPP
#define _GL4CMULTIBINDTESTS_HPP
/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-2016 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  gl4cMultiBindTests.hpp
 * \brief Declares test classes for "Multi Bind" functionality.
 */ /*-------------------------------------------------------------------*/

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

namespace gl4cts
{
namespace MultiBind
{
/** Implementation of test ErrorsBindBuffers. Description follows:
 *
 * Verifies that BindBuffersBase and BindBuffersRange commands generate errors
 * as expected:
 * - INVALID_ENUM when <target> is not valid;
 * - INVALID_OPERATION when <first> + <count> is greater than allowed limit;
 * - INVALID_OPERATION if any value in <buffers> is not zero or the name of
 * existing buffer;
 * - INVALID_VALUE if any value in <offsets> is less than zero;
 * - INVALID_VALUE if any pair of <offsets> and <sizes> exceeds limits.
 **/
class ErrorsBindBuffersTest : public deqp::TestCase
{
public:
	/* Public methods */
	ErrorsBindBuffersTest(deqp::Context& context);

	virtual ~ErrorsBindBuffersTest()
	{
	}

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

/** Implementation of test ErrorsBindTextures. Description follows:
 *
 * Verifies that BindTextures generate errors as expected:
 * - INVALID_OPERATION when <first> + <count> exceed limits;
 * - INVALID_OPERATION if any value in <textures> is not zero or name of
 * existing texture.
 **/
class ErrorsBindTexturesTest : public deqp::TestCase
{
public:
	/* Public methods */
	ErrorsBindTexturesTest(deqp::Context& context);

	virtual ~ErrorsBindTexturesTest()
	{
	}

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

/** Implementation of test ErrorsBindSamplers. Description follows:
 *
 * Verifies that BindSamplers generate errors as expected:
 * - INVALID_OPERATION when <first> + <count> exceed limits;
 * - INVALID_OPERATION if any value in <samplers> is not zero or name of
 * existing texture.
 **/
class ErrorsBindSamplersTest : public deqp::TestCase
{
public:
	/* Public methods */
	ErrorsBindSamplersTest(deqp::Context& context);

	virtual ~ErrorsBindSamplersTest()
	{
	}

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

/** Implementation of test ErrorsBindImageTextures. Description follows:
 *
 * Verifies that BindImageTextures generate errors as expected:
 * - INVALID_OPERATION when <first> + <count> exceed limits;
 * - INVALID_OPERATION if any value in <textures> is not zero or name of
 * existing texture;
 * - INVALID_OPERATION if any entry found in <textures> has invalid internal
 * format at level 0;
 * - INVALID_OPERATION when any entry in <textures> has any of dimensions equal
 * to 0 at level 0.
 **/
class ErrorsBindImageTexturesTest : public deqp::TestCase
{
public:
	/* Public methods */
	ErrorsBindImageTexturesTest(deqp::Context& context);

	virtual ~ErrorsBindImageTexturesTest()
	{
	}

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

/** Implementation of test ErrorsBindVertexBuffers. Description follows:
 *
 * Verifies that BindVertexBuffers generate errors as expected:
 * - INVALID_OPERATION when <first> + <count> exceeds limits;
 * - INVALID_OPERATION if any value in <buffers> is not zero or the name of
 * existing buffer;
 * - INVALID_VALUE if any value in <offsets> or <strides> is less than zero.
 **/
class ErrorsBindVertexBuffersTest : public deqp::TestCase
{
public:
	/* Public methods */
	ErrorsBindVertexBuffersTest(deqp::Context& context);

	virtual ~ErrorsBindVertexBuffersTest()
	{
	}

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

/** Implementation of test FunctionalBindBuffersBase. Description follows:
 *
 * Verifies that BindBuffersBase works as expected.
 *
 * Steps to be done for each valid target:
 * - prepare MAX buffers with some store, where MAX is the maximum supported
 * amount of bindings points for tested target;
 *
 * - execute BindBufferBase to bind all buffers to tested target;
 * - inspect if bindings were modified;
 *
 * - execute BindBufferBase for first half of bindings with NULL as <buffers>
 * to unbind first half of bindings for tested target;
 * - inspect if bindings were modified;
 * - execute BindBufferBase for second half of bindings with NULL as <buffers>
 * to unbind rest of bindings;
 * - inspect if bindings were modified;
 *
 * - change <buffers> so first entry is invalid;
 * - execute BindBufferBase to bind all buffers to tested target; It is
 * expected that INVALID_OPERATION will be generated;
 * - inspect if all bindings but first were modified;
 *
 * - bind any buffer to first binding;
 * - execute BindBufferBase for 0 as <first>, 1 as <count> and <buffers> filled
 * with zeros to unbind 1st binding for tested target;
 * - inspect if bindings were modified;
 *
 * - unbind all buffers.
 **/
class FunctionalBindBuffersBaseTest : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalBindBuffersBaseTest(deqp::Context& context);

	virtual ~FunctionalBindBuffersBaseTest()
	{
	}

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

/** Implementation of test FunctionalBindBuffersRange. Description follows:
 *
 * Verifies that BindBuffersRange works as expected.
 *
 * Steps to be done for each valid target:
 * - prepare MAX buffers with some store, where MAX is the maximum supported
 * amount of bindings points for tested target;
 *
 * - execute BindBufferRange to bind all buffers to tested target;
 * - inspect if bindings were modified;
 *
 * - execute BindBufferRange for first half of bindings with NULL as <buffers>
 * to unbind first half of bindings for tested target;
 * - inspect if bindings were modified;
 * - execute BindBufferRange for second half of bindings with NULL as <buffers>
 * to unbind rest of bindings for tested target;
 * - inspect if bindings were modified;
 *
 * - change <buffers> so first entry is invalid;
 * - execute BindBufferRange to bind all buffers to tested target; It is
 * expected that INVALID_OPERATION will be generated;
 * - inspect if all bindings but first were modified;
 *
 * - bind any buffer to first binding;
 * - execute BindBufferRange for 0 as <first>, 1 as <count> and <buffers>
 * filled with zeros to unbind first binding for tested target;
 * - inspect if bindings were modified;
 *
 * - unbind all buffers.
 **/
class FunctionalBindBuffersRangeTest : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalBindBuffersRangeTest(deqp::Context& context);

	virtual ~FunctionalBindBuffersRangeTest()
	{
	}

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

/** Implementation of test FunctionalBindTextures. Description follows:
 *
 * Verify that BindTextures works as expected.
 *
 * Steps:
 * - prepare MAX_COMBINED_TEXTURE_IMAGE_UNITS textures with some store;
 * Use all valid texture targets;
 *
 * - execute BindTextures to bind all textures;
 * - inspect bindings of all texture units to verify that proper bindings were
 * set;
 *
 * - execute BindTextures for the first half of units with <textures> filled
 * with zeros, to unbind those units;
 * - inspect bindings of all texture units to verify that proper bindings were
 * unbound;
 *
 * - execute BindTextures for the second half of units with NULL as<textures>,
 * to unbind those units;
 * - inspect bindings of all texture units to verify that proper bindings were
 * unbound;
 *
 * - modify <textures> so first entry is invalid;
 * - execute BindTextures to bind all textures; It is expected that
 * INVALID_OPERATION will be generated;
 * - inspect bindings of all texture units to verify that proper bindings were
 * set;
 *
 * - unbind all textures.
 **/
class FunctionalBindTexturesTest : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalBindTexturesTest(deqp::Context& context);

	virtual ~FunctionalBindTexturesTest()
	{
	}

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

/** Implementation of test FunctionalBindSamplers. Description follows:
 *
 * Verify that BindSamplers works as expected.
 *
 * Steps:
 * - prepare MAX_COMBINED_TEXTURE_IMAGE_UNITS samplers;
 *
 * - execute BindSamplers to bind all samplers;
 * - inspect bindings to verify that proper samplers were set;
 *
 * - execute BindSamplers for first half of bindings with <samplers> filled
 * with zeros, to unbind those samplers;
 * - inspect bindings to verify that proper samplers were unbound;
 *
 * - execute BindSamplers for second half of bindings with NULL as <samplers>,
 * to unbind those samplers;
 * - inspect bindings to verify that proper samplers were unbound;
 *
 * - modify <samplers> so first entry is invalid;
 * - execute BindSamplers to bind all samplers; It is expected that
 * INVALID_OPERATION will be generated;
 * - inspect bindings to verify that proper samplers were set;
 *
 * - unbind all samplers.
 **/
class FunctionalBindSamplersTest : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalBindSamplersTest(deqp::Context& context);

	virtual ~FunctionalBindSamplersTest()
	{
	}

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

/** Implementation of test FunctionalBindImageTextures. Description follows:
 *
 * Verify that BindImageTextures works as expected.
 *
 * Steps:
 * - prepare MAX_IMAGE_UNITS textures; Use TEXTURE_1D, TEXTURE_1D_ARRAY,
 * TEXTURE_2D, TEXTURE_2D_ARRAY, TEXTURE_3D, TEXTURE_BUFFER, TEXTURE_CUBE_MAP
 * and TEXTURE_CUBE_MAP_ARRAY; If possible use rest of targets;
 *
 * - execute BindImageTextures to bind all images;
 * - inspect bindings to verify that proper images were set;
 *
 * - execute BindImageTextures for first half of units with <textures> filled
 * with zeros, to unbind those images;
 * - inspect bindings to verify that proper images were unbound;
 *
 * - execute BindImageTextures for second half of bindings with NULL as <samples>,
 * to unbind those images;
 * - inspect bindings to verify that proper images were unbound;
 *
 * - modify <textures> so first entry is invalid;
 * - execute BindImageTextures to bind all textures; It is expected that
 * INVALID_OPERATION will be generated;
 * - inspect bindings to verify that proper images were set;
 *
 * - unbind all images.
 **/
class FunctionalBindImageTexturesTest : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalBindImageTexturesTest(deqp::Context& context);

	virtual ~FunctionalBindImageTexturesTest()
	{
	}

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

/** Implementation of test FunctionalBindVertexBuffers. Description follows:
 *
 * Verify that BindVertexBuffers works as expected.
 *
 * Steps:
 * - prepare MAX_VERTEX_ATTRIB_BINDINGS buffers;
 *
 * - execute BindVertexBuffers to bind all buffer;
 * - inspect bindings to verify that proper buffers were set;
 *
 * - execute BindVertexBuffers for first half of bindings with <buffers> filled
 * with zeros, to unbind those buffers;
 * - inspect bindings to verify that proper buffers were unbound;
 *
 * - execute BindVertexBuffers for second half of bindings with NULL as
 * <buffers>, to unbind those buffers;
 * - inspect bindings to verify that proper buffers were unbound;
 *
 * - modify <buffers> so first entry is invalid;
 * - execute BindVertexBuffers to bind all buffers; It is expected that
 * INVALID_OPERATION will be generated;
 * - inspect bindings to verify that proper buffers were set;
 *
 * - unbind all buffers.
 **/
class FunctionalBindVertexBuffersTest : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalBindVertexBuffersTest(deqp::Context& context);

	virtual ~FunctionalBindVertexBuffersTest()
	{
	}

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

/** Implementation of test DispatchBindBuffersBase. Description follows:
 *
 * Verifies that BindBuffersBase command works as expected.
 *
 * In compute shader declare the GL_MAX_COMPUTE_UNIFORM_BLOCKS uniform blocks:
 *
 *   layout(std140, binding = 0) uniform B1 {vec4 a;} b1;
 *   layout(std140, binding = 0) uniform B2 {vec4 a;} b2;
 *
 *   ...
 *
 *   layout(std140, binding = (GL_MAX_COMPUTE_UNIFORM_BLOCKS-1)) uniform BX {
 *       vec4 a;
 *   } bx;
 *
 * The shader should sum b1.a, b2.a + ... + bx.a and store result in shader
 * storage buffer.
 *
 * In test program, create GL_MAX_COMPUTE_UNIFORM_BLOCKS buffers, bind them
 * using BindBuffersBase to B1 ... BX blocks, fill them with unique values.
 * Create and bind shader storage buffer for result. Dispatch compute shader.
 *
 * Test pass if the result is correct.
 **/
class DispatchBindBuffersBaseTest : public deqp::TestCase
{
public:
	/* Public methods */
	DispatchBindBuffersBaseTest(deqp::Context& context);

	virtual ~DispatchBindBuffersBaseTest()
	{
	}

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

/** Implementation of test DispatchBindBuffersRange. Description follows:
 *
 * Verifies that BindBuffersRange command works as expected.
 *
 * In compute shader create the 4 of uniform blocks:
 *
 *   layout(std140, binding = 0) uniform B1 {int a;} b1;
 *   layout(std140, binding = 1) uniform B2 {int a;} b2;
 *   layout(std140, binding = 2) uniform B4 {int a;} b3;
 *   layout(std140, binding = 3) uniform B4 {int a;} b4;
 *
 * The shader should be sum b1.a b2.a, b3.a b4.a and store result in shader
 * storage buffer.
 *
 *
 * In test program, create the buffer filled with the following 7 bytes:
 *
 *   { 0x00 0x01 0x00 0x01 0x00 0x01 0x00 }
 *
 * Bind buffer with BindBuffersRange with the following parameters:
 *   - <target>  GL_UNIFORM_BUFFER
 *   - <first>   0
 *   - <count>   4
 *   - <buffers> { ID, ID, ID, ID },
 *   - <offsets> { 0,  1,  2,  3 },
 *   - <sizes>   { 4,  4,  4,  4 }.
 *
 * Create and bind shader storage buffer for result. Dispatch compute shader.
 *
 * Test pass if the result is 0x02020202.
 **/
class DispatchBindBuffersRangeTest : public deqp::TestCase
{
public:
	/* Public methods */
	DispatchBindBuffersRangeTest(deqp::Context& context);

	virtual ~DispatchBindBuffersRangeTest()
	{
	}

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

/** Implementation of test DispatchBindTextures. Description follows:
 *
 * Verifies that BindTextures command works as expected.
 *
 * Modify DispatchBindBuffersBase test in the following aspects:
 *   - use R32UI textures instead of uniform blocks;
 *   - use GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS textures;
 *   - use all texture targets;
 *   - use 1x1x1 textures, sample point (0.5, 0.5, 0.5).
 **/
class DispatchBindTexturesTest : public deqp::TestCase
{
public:
	/* Public methods */
	DispatchBindTexturesTest(deqp::Context& context);
	virtual ~DispatchBindTexturesTest()
	{
	}

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

/** Implementation of test DispatchBindImageTextures. Description follows:
 *
 * Verifies that BindImageTextures command works as expected.
 *
 * Modify DispatchBindTextures test in the following aspects:
 *   - use image units instead of texture units.
 **/
class DispatchBindImageTexturesTest : public deqp::TestCase
{
public:
	/* Public methods */
	DispatchBindImageTexturesTest(deqp::Context& context);

	virtual ~DispatchBindImageTexturesTest()
	{
	}

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

/** Implementation of test DispatchBindSamplers. Description follows:
 *
 * Verifies that BindSamplers command works as expected.
 *
 * Prepare GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS 8x8 2D R32UI textures filled so
 * the edges are set to 1 and center area is set to 0.
 * Prepare GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS samplers. Set parameter
 * GL_TEXTURE_WRAP_S to GL_CLAMP_TO_EDGE for all samplers.
 *
 * Prepare compute program as in test DispatchBindTextures, but sample
 * point (1.5, 0.5, 0.5).
 *
 * Test pass when the result stored in storage buffer is equal to
 * GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS.
 **/
class DispatchBindSamplersTest : public deqp::TestCase
{
public:
	/* Public methods */
	DispatchBindSamplersTest(deqp::Context& context);

	virtual ~DispatchBindSamplersTest()
	{
	}

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

/** Implementation of test DrawBindVertexBuffers. Description follows:
 *
 * Verifies that BindVertexBuffers command works as expected.
 *
 * Prepare program consisting of vertex, geometry and fragment shader. Vertex
 * shader should:
 *   - declare GL_MAX_VERTEX_ATTRIB_BINDINGS attributes:
 *
 *     layout(location = 0) in vec4 attr_0;
 *     layout(location = 1) in vec4 attr_0;
 *
 *     ...
 *
 *     layout(location = GL_MAX_VERTEX_ATTRIB_BINDINGS - 1) in vec4 attr_X;
 *
 *   - calcualte sum of all attributes and store result in output varying.
 * Geometry shader should:
 *   - output fullscreen quad;
 *   - pass-through the value of summed attributes to fragment shader.
 * Fragment shader should pass-through the value of summed attributes to output
 * color.
 *
 * Prepare and bind vertex array object. Prepare ARRAY buffer filled with all
 * attributes. Values should be selected so the sum is equal 1.0 at each
 * channel. Use BindVertexBuffers to set up all attributes to use the buffer.
 *
 * Prepare framebuffer with 8x8 2D RGBA8 texture attached as color 0. Fill
 * texture with 0.
 *
 * Execute drawArrays for single vertex.
 *
 * Test pass if framebuffer is filled with value 1.
 **/
class DrawBindVertexBuffersTest : public deqp::TestCase
{
public:
	/* Public methods */
	DrawBindVertexBuffersTest(deqp::Context& context);

	virtual ~DrawBindVertexBuffersTest()
	{
	}

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

/** Group class for multi bind conformance tests */
class MultiBindTests : public deqp::TestCaseGroup
{
public:
	/* Public methods */
	MultiBindTests(deqp::Context& context);

	virtual ~MultiBindTests(void)
	{
	}

	virtual void init(void);

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

} /* gl4cts */

#endif // _GL4CMULTIBINDTESTS_HPP