external/openglcts/modules/gl/gl4cMultiBindTests.hpp - third_party/vulkan-cts - Git at Google

 #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
	#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