Home | History | Annotate | Download | only in performance 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES 3.0 Module
      3  * -------------------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief Redundant state change performance tests.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "es3pRedundantStateChangeTests.hpp"
     25 #include "glsStateChangePerfTestCases.hpp"
     26 #include "gluShaderProgram.hpp"
     27 #include "glwFunctions.hpp"
     28 #include "glwEnums.hpp"
     29 
     30 namespace deqp
     31 {
     32 namespace gles3
     33 {
     34 namespace Performance
     35 {
     36 
     37 using namespace glw; // GL types
     38 
     39 namespace
     40 {
     41 
     42 enum
     43 {
     44 	VIEWPORT_WIDTH	= 24,
     45 	VIEWPORT_HEIGHT	= 24
     46 };
     47 
     48 class RedundantStateChangeCase : public gls::StateChangePerformanceCase
     49 {
     50 public:
     51 					RedundantStateChangeCase	(Context& context, int drawCallCount, int triangleCount, bool drawArrays, bool useIndexBuffer, const char* name, const char* description);
     52 					~RedundantStateChangeCase	(void);
     53 
     54 protected:
     55 	virtual void	renderTest					(const glw::Functions& gl);
     56 	virtual void	renderReference				(const glw::Functions& gl);
     57 	virtual void	changeState					(const glw::Functions& gl) = 0;
     58 };
     59 
     60 RedundantStateChangeCase::RedundantStateChangeCase (Context& context, int drawCallCount, int triangleCount, bool drawArrays, bool useIndexBuffer, const char* name, const char* description)
     61 	: gls::StateChangePerformanceCase(context.getTestContext(), context.getRenderContext(), name, description,
     62 									  (useIndexBuffer	? DRAWTYPE_INDEXED_BUFFER	:
     63 									   drawArrays		? DRAWTYPE_NOT_INDEXED		:
     64 														  DRAWTYPE_INDEXED_USER_PTR), drawCallCount, triangleCount)
     65 {
     66 	DE_ASSERT(!useIndexBuffer || !drawArrays);
     67 }
     68 
     69 RedundantStateChangeCase::~RedundantStateChangeCase (void)
     70 {
     71 }
     72 
     73 void RedundantStateChangeCase::renderTest (const glw::Functions& gl)
     74 {
     75 	for (int callNdx = 0; callNdx < m_callCount; callNdx++)
     76 	{
     77 		changeState(gl);
     78 		callDraw(gl);
     79 	}
     80 }
     81 
     82 void RedundantStateChangeCase::renderReference (const glw::Functions& gl)
     83 {
     84 	changeState(gl);
     85 
     86 	for (int callNdx = 0; callNdx < m_callCount; callNdx++)
     87 		callDraw(gl);
     88 }
     89 
     90 } // anonymous
     91 
     92 RedundantStateChangeTests::RedundantStateChangeTests (Context& context)
     93 	: TestCaseGroup(context, "redundant_state_change_draw", "Test performance with redundant sate changes between rendering.")
     94 {
     95 }
     96 
     97 RedundantStateChangeTests::~RedundantStateChangeTests (void)
     98 {
     99 }
    100 
    101 #define MACRO_BLOCK(...) __VA_ARGS__
    102 
    103 #define ADD_TESTCASE(NAME, DESC, DRAWARRAYS, INDEXBUFFER, INIT_FUNC, CHANGE_FUNC)\
    104 do {\
    105 	class RedundantStateChangeCase_ ## NAME : public RedundantStateChangeCase\
    106 	{\
    107 	public:\
    108 			RedundantStateChangeCase_ ## NAME (Context& context, int drawCallCount, int triangleCount, const char* name, const char* description)\
    109 				: RedundantStateChangeCase(context, drawCallCount, triangleCount, (DRAWARRAYS), (INDEXBUFFER), name, description)\
    110 			{}\
    111 		virtual void setupInitialState (const glw::Functions& gl)\
    112 		{\
    113 			INIT_FUNC\
    114 		}\
    115 		virtual void changeState (const glw::Functions& gl)\
    116 		{\
    117 			CHANGE_FUNC\
    118 		}\
    119 	};\
    120 	manySmallCallsGroup->addChild	(new RedundantStateChangeCase_ ## NAME (m_context,1000,2,#NAME,(DESC)));\
    121 	fewBigCallsGroup->addChild		(new RedundantStateChangeCase_ ## NAME (m_context,10,200,#NAME,(DESC)));\
    122 } while (0);
    123 
    124 void RedundantStateChangeTests::init (void)
    125 {
    126 	tcu::TestCaseGroup* const	manySmallCallsGroup	= new tcu::TestCaseGroup(m_testCtx, "many_small_calls",	"1000 calls, 2 triangles in each");
    127 	tcu::TestCaseGroup* const	fewBigCallsGroup	= new tcu::TestCaseGroup(m_testCtx, "few_big_calls",	"10 calls, 200 triangles in each");
    128 
    129 	addChild(manySmallCallsGroup);
    130 	addChild(fewBigCallsGroup);
    131 
    132 	ADD_TESTCASE(blend, "Enable/Disable blending.",
    133 		true,
    134 		false,
    135 		MACRO_BLOCK({
    136 			requireCoordBuffers(1);
    137 			requireTextures(1);
    138 			requirePrograms(1);
    139 
    140 			gl.useProgram(m_programs[0]->getProgram());
    141 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    142 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    143 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    144 
    145 			gl.enableVertexAttribArray(coordLoc);
    146 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    147 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    148 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    149 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    150 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    151 
    152 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    153 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    154 
    155 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    156 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    157 
    158 			gl.uniform1i(samplerLoc, 0);
    159 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    160 
    161 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    162 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    163 		}),
    164 		MACRO_BLOCK({
    165 			gl.enable(GL_BLEND);
    166 		})
    167 	)
    168 
    169 	ADD_TESTCASE(depth_test, "Enable/Disable depth test.",
    170 		true,
    171 		false,
    172 		MACRO_BLOCK({
    173 			requireCoordBuffers(1);
    174 			requireTextures(1);
    175 			requirePrograms(1);
    176 
    177 			gl.useProgram(m_programs[0]->getProgram());
    178 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    179 
    180 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    181 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    182 
    183 			gl.enableVertexAttribArray(coordLoc);
    184 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    185 
    186 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    187 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    188 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    189 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    190 
    191 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    192 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    193 
    194 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    195 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    196 
    197 			gl.uniform1i(samplerLoc, 0);
    198 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    199 
    200 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    201 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    202 
    203 			gl.depthFunc(GL_LEQUAL);
    204 			GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
    205 		}),
    206 		MACRO_BLOCK({
    207 			gl.enable(GL_DEPTH_TEST);
    208 		})
    209 	)
    210 
    211 	ADD_TESTCASE(stencil_test, "Enable/Disable stencil test.",
    212 		true,
    213 		false,
    214 		MACRO_BLOCK({
    215 			requireCoordBuffers(1);
    216 			requireTextures(1);
    217 			requirePrograms(1);
    218 
    219 			gl.useProgram(m_programs[0]->getProgram());
    220 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    221 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    222 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    223 
    224 			gl.enableVertexAttribArray(coordLoc);
    225 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    226 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    227 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    228 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    229 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    230 
    231 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    232 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    233 
    234 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    235 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    236 
    237 			gl.uniform1i(samplerLoc, 0);
    238 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    239 
    240 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    241 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    242 
    243 			gl.stencilFunc(GL_LEQUAL, 0, 0);
    244 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
    245 
    246 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    247 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
    248 
    249 			gl.clearStencil(0);
    250 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
    251 			gl.clear(GL_STENCIL_BUFFER_BIT);
    252 
    253 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
    254 		}),
    255 		MACRO_BLOCK({
    256 			gl.enable(GL_STENCIL_TEST);
    257 		})
    258 	)
    259 
    260 	ADD_TESTCASE(scissor_test, "Enable/Disable scissor test.",
    261 		true,
    262 		false,
    263 		MACRO_BLOCK({
    264 			requireCoordBuffers(1);
    265 			requireTextures(1);
    266 			requirePrograms(1);
    267 
    268 			gl.useProgram(m_programs[0]->getProgram());
    269 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    270 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    271 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    272 
    273 			gl.enableVertexAttribArray(coordLoc);
    274 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    275 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    276 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    277 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    278 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    279 
    280 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    281 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    282 
    283 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    284 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    285 
    286 			gl.uniform1i(samplerLoc, 0);
    287 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    288 
    289 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    290 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    291 
    292 			gl.scissor(2, 3, 12, 13);
    293 			GLU_EXPECT_NO_ERROR(gl.getError(), "glScissor()");
    294 		}),
    295 		MACRO_BLOCK({
    296 			gl.enable(GL_SCISSOR_TEST);
    297 		})
    298 	)
    299 
    300 	ADD_TESTCASE(dither, "Enable/Disable dithering.",
    301 		true,
    302 		false,
    303 		MACRO_BLOCK({
    304 			requireCoordBuffers(1);
    305 			requireTextures(1);
    306 			requirePrograms(1);
    307 
    308 			gl.useProgram(m_programs[0]->getProgram());
    309 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    310 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    311 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    312 
    313 			gl.enableVertexAttribArray(coordLoc);
    314 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    315 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    316 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    317 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    318 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    319 
    320 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    321 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    322 
    323 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    324 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    325 
    326 			gl.uniform1i(samplerLoc, 0);
    327 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    328 
    329 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    330 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    331 		}),
    332 		MACRO_BLOCK({
    333 			gl.enable(GL_DITHER);
    334 		})
    335 	)
    336 
    337 	ADD_TESTCASE(culling, "Enable/Disable culling.",
    338 		true,
    339 		false,
    340 		MACRO_BLOCK({
    341 			requireCoordBuffers(1);
    342 			requireTextures(1);
    343 			requirePrograms(1);
    344 
    345 			gl.useProgram(m_programs[0]->getProgram());
    346 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    347 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    348 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    349 
    350 			gl.enableVertexAttribArray(coordLoc);
    351 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    352 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    353 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    354 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    355 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    356 
    357 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    358 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    359 
    360 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    361 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    362 
    363 			gl.uniform1i(samplerLoc, 0);
    364 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    365 
    366 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    367 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    368 
    369 			gl.frontFace(GL_CW);
    370 			GLU_EXPECT_NO_ERROR(gl.getError(), "glFrontFace()");
    371 
    372 			gl.cullFace(GL_FRONT);
    373 			GLU_EXPECT_NO_ERROR(gl.getError(), "glCullFace()");
    374 		}),
    375 		MACRO_BLOCK({
    376 			gl.enable(GL_CULL_FACE);
    377 		})
    378 	)
    379 
    380 	ADD_TESTCASE(rasterizer_discard, "Disable RASTERIZER_DISCARD.",
    381 		true,
    382 		false,
    383 		MACRO_BLOCK({
    384 			requireCoordBuffers(1);
    385 			requireTextures(1);
    386 			requirePrograms(1);
    387 
    388 			gl.useProgram(m_programs[0]->getProgram());
    389 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    390 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    391 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    392 
    393 			gl.enableVertexAttribArray(coordLoc);
    394 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    395 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    396 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    397 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    398 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    399 
    400 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    401 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    402 
    403 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    404 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    405 
    406 			gl.uniform1i(samplerLoc, 0);
    407 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    408 
    409 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    410 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    411 		}),
    412 		MACRO_BLOCK({
    413 			gl.disable(GL_RASTERIZER_DISCARD);
    414 		})
    415 	)
    416 
    417 	ADD_TESTCASE(primitive_restart_fixed_index, "Enable PRIMITIVE_RESTART_FIXED_INDEX.",
    418 		true,
    419 		false,
    420 		MACRO_BLOCK({
    421 			requireCoordBuffers(1);
    422 			requireTextures(1);
    423 			requirePrograms(1);
    424 
    425 			gl.useProgram(m_programs[0]->getProgram());
    426 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    427 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    428 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    429 
    430 			gl.enableVertexAttribArray(coordLoc);
    431 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    432 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    433 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    434 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    435 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    436 
    437 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    438 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    439 
    440 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    441 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    442 
    443 			gl.uniform1i(samplerLoc, 0);
    444 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    445 
    446 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    447 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    448 		}),
    449 		MACRO_BLOCK({
    450 			gl.enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
    451 		})
    452 	)
    453 
    454 	ADD_TESTCASE(depth_func, "Change depth func.",
    455 		true,
    456 		false,
    457 		MACRO_BLOCK({
    458 			requireCoordBuffers(1);
    459 			requireTextures(1);
    460 			requirePrograms(1);
    461 
    462 			gl.useProgram(m_programs[0]->getProgram());
    463 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    464 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    465 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    466 
    467 			gl.enableVertexAttribArray(coordLoc);
    468 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    469 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    470 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    471 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    472 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    473 
    474 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    475 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    476 
    477 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    478 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    479 
    480 			gl.uniform1i(samplerLoc, 0);
    481 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    482 
    483 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    484 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    485 
    486 			gl.enable(GL_DEPTH_TEST);
    487 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    488 		}),
    489 		MACRO_BLOCK({
    490 			gl.depthFunc(GL_GEQUAL);
    491 		})
    492 	)
    493 
    494 
    495 	ADD_TESTCASE(depth_mask, "Toggle depth mask.",
    496 		true,
    497 		false,
    498 		MACRO_BLOCK({
    499 			requireCoordBuffers(1);
    500 			requireTextures(1);
    501 			requirePrograms(1);
    502 
    503 			gl.useProgram(m_programs[0]->getProgram());
    504 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    505 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    506 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    507 
    508 			gl.enableVertexAttribArray(coordLoc);
    509 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    510 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    511 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    512 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    513 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    514 
    515 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    516 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    517 
    518 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    519 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    520 
    521 			gl.uniform1i(samplerLoc, 0);
    522 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    523 
    524 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    525 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    526 
    527 			gl.enable(GL_DEPTH_TEST);
    528 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    529 
    530 			gl.depthFunc(GL_LEQUAL);
    531 			GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
    532 		}),
    533 		MACRO_BLOCK({
    534 			gl.depthMask(GL_FALSE);
    535 		})
    536 	)
    537 
    538 	ADD_TESTCASE(depth_rangef, "Change depth range.",
    539 		true,
    540 		false,
    541 		MACRO_BLOCK({
    542 			requireCoordBuffers(1);
    543 			requireTextures(1);
    544 			requirePrograms(1);
    545 
    546 			gl.useProgram(m_programs[0]->getProgram());
    547 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    548 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    549 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    550 
    551 			gl.enableVertexAttribArray(coordLoc);
    552 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    553 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    554 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    555 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    556 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    557 
    558 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    559 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    560 
    561 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    562 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    563 
    564 			gl.uniform1i(samplerLoc, 0);
    565 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    566 
    567 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    568 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    569 		}),
    570 		MACRO_BLOCK({
    571 			gl.depthRangef(0.0f, 1.0f);
    572 		})
    573 	)
    574 
    575 	ADD_TESTCASE(blend_equation, "Change blend equation.",
    576 		true,
    577 		false,
    578 		MACRO_BLOCK({
    579 			requireCoordBuffers(1);
    580 			requireTextures(1);
    581 			requirePrograms(1);
    582 
    583 			gl.useProgram(m_programs[0]->getProgram());
    584 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    585 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    586 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    587 
    588 			gl.enableVertexAttribArray(coordLoc);
    589 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    590 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    591 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    592 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    593 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    594 
    595 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    596 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    597 
    598 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    599 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    600 
    601 			gl.uniform1i(samplerLoc, 0);
    602 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    603 
    604 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    605 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    606 
    607 			gl.enable(GL_BLEND);
    608 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    609 		}),
    610 		MACRO_BLOCK({
    611 			gl.blendEquation(GL_FUNC_SUBTRACT);
    612 		})
    613 	)
    614 
    615 	ADD_TESTCASE(blend_func, "Change blend function.",
    616 		true,
    617 		false,
    618 		MACRO_BLOCK({
    619 			requireCoordBuffers(1);
    620 			requireTextures(1);
    621 			requirePrograms(1);
    622 
    623 			gl.useProgram(m_programs[0]->getProgram());
    624 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    625 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    626 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    627 
    628 			gl.enableVertexAttribArray(coordLoc);
    629 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    630 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    631 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    632 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    633 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    634 
    635 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    636 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    637 
    638 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    639 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    640 
    641 			gl.uniform1i(samplerLoc, 0);
    642 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    643 
    644 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    645 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    646 
    647 			gl.enable(GL_BLEND);
    648 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    649 		}),
    650 		MACRO_BLOCK({
    651 			gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    652 		})
    653 	)
    654 
    655 	ADD_TESTCASE(polygon_offset, "Change polygon offset.",
    656 		true,
    657 		false,
    658 		MACRO_BLOCK({
    659 			requireCoordBuffers(1);
    660 			requireTextures(1);
    661 			requirePrograms(1);
    662 
    663 			gl.useProgram(m_programs[0]->getProgram());
    664 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    665 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    666 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    667 
    668 			gl.enableVertexAttribArray(coordLoc);
    669 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    670 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    671 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    672 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    673 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    674 
    675 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    676 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    677 
    678 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    679 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    680 
    681 			gl.uniform1i(samplerLoc, 0);
    682 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    683 
    684 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    685 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    686 
    687 			gl.enable(GL_POLYGON_OFFSET_FILL);
    688 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    689 		}),
    690 		MACRO_BLOCK({
    691 			gl.polygonOffset(0.0f, 0.0f);
    692 		})
    693 	)
    694 
    695 	ADD_TESTCASE(sample_coverage, "Sample coverage.",
    696 		true,
    697 		false,
    698 		MACRO_BLOCK({
    699 			requireCoordBuffers(1);
    700 			requireTextures(1);
    701 			requirePrograms(1);
    702 
    703 			gl.useProgram(m_programs[0]->getProgram());
    704 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    705 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    706 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    707 
    708 			gl.enableVertexAttribArray(coordLoc);
    709 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    710 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    711 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    712 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    713 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    714 
    715 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    716 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    717 
    718 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    719 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    720 
    721 			gl.uniform1i(samplerLoc, 0);
    722 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    723 
    724 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    725 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    726 		}),
    727 		MACRO_BLOCK({
    728 			gl.sampleCoverage(0.25f, GL_TRUE);
    729 		})
    730 	)
    731 
    732 	ADD_TESTCASE(viewport, "Change viewport.",
    733 		true,
    734 		false,
    735 		MACRO_BLOCK({
    736 			requireCoordBuffers(1);
    737 			requireTextures(1);
    738 			requirePrograms(1);
    739 
    740 			gl.useProgram(m_programs[0]->getProgram());
    741 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    742 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    743 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    744 
    745 			gl.enableVertexAttribArray(coordLoc);
    746 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    747 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    748 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    749 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    750 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    751 
    752 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    753 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    754 
    755 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    756 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    757 
    758 			gl.uniform1i(samplerLoc, 0);
    759 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    760 
    761 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    762 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    763 		}),
    764 		MACRO_BLOCK({
    765 			gl.viewport(10, 11, 5, 6);
    766 		})
    767 	)
    768 
    769 	ADD_TESTCASE(scissor, "Change scissor box.",
    770 		true,
    771 		false,
    772 		MACRO_BLOCK({
    773 			requireCoordBuffers(1);
    774 			requireTextures(1);
    775 			requirePrograms(1);
    776 
    777 			gl.useProgram(m_programs[0]->getProgram());
    778 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    779 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    780 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    781 
    782 			gl.enableVertexAttribArray(coordLoc);
    783 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    784 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    785 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    786 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    787 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    788 
    789 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    790 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    791 
    792 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    793 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    794 
    795 			gl.uniform1i(samplerLoc, 0);
    796 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    797 
    798 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    799 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    800 
    801 			gl.enable(GL_SCISSOR_TEST);
    802 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    803 		}),
    804 		MACRO_BLOCK({
    805 			gl.scissor(17, 13, 5, 8);
    806 		})
    807 	)
    808 
    809 	ADD_TESTCASE(color_mask, "Change color mask.",
    810 		true,
    811 		false,
    812 		MACRO_BLOCK({
    813 			requireCoordBuffers(1);
    814 			requireTextures(1);
    815 			requirePrograms(1);
    816 
    817 			gl.useProgram(m_programs[0]->getProgram());
    818 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    819 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    820 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    821 
    822 			gl.enableVertexAttribArray(coordLoc);
    823 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    824 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    825 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    826 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    827 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    828 
    829 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    830 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    831 
    832 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    833 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    834 
    835 			gl.uniform1i(samplerLoc, 0);
    836 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    837 
    838 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    839 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    840 		}),
    841 		MACRO_BLOCK({
    842 			gl.colorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE);
    843 		})
    844 	)
    845 
    846 	ADD_TESTCASE(cull_face, "Change culling mode.",
    847 		true,
    848 		false,
    849 		MACRO_BLOCK({
    850 			requireCoordBuffers(1);
    851 			requireTextures(1);
    852 			requirePrograms(1);
    853 
    854 			gl.useProgram(m_programs[0]->getProgram());
    855 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    856 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    857 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    858 
    859 			gl.enableVertexAttribArray(coordLoc);
    860 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    861 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    862 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    863 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    864 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    865 
    866 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    867 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    868 
    869 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    870 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    871 
    872 			gl.uniform1i(samplerLoc, 0);
    873 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    874 
    875 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    876 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    877 
    878 			gl.enable(GL_CULL_FACE);
    879 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    880 		}),
    881 		MACRO_BLOCK({
    882 			gl.cullFace(GL_FRONT);
    883 		})
    884 	)
    885 
    886 	ADD_TESTCASE(front_face, "Change front face.",
    887 		true,
    888 		false,
    889 		MACRO_BLOCK({
    890 			requireCoordBuffers(1);
    891 			requireTextures(1);
    892 			requirePrograms(1);
    893 
    894 			gl.useProgram(m_programs[0]->getProgram());
    895 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    896 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    897 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    898 
    899 			gl.enableVertexAttribArray(coordLoc);
    900 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    901 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    902 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    903 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    904 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    905 
    906 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    907 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    908 
    909 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    910 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    911 
    912 			gl.uniform1i(samplerLoc, 0);
    913 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    914 
    915 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    916 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    917 
    918 			gl.enable(GL_CULL_FACE);
    919 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    920 		}),
    921 		MACRO_BLOCK({
    922 			gl.frontFace(GL_CCW);
    923 		})
    924 	)
    925 
    926 	ADD_TESTCASE(stencil_mask, "Change stencil mask.",
    927 		true,
    928 		false,
    929 		MACRO_BLOCK({
    930 			requireCoordBuffers(1);
    931 			requireTextures(1);
    932 			requirePrograms(1);
    933 
    934 			gl.useProgram(m_programs[0]->getProgram());
    935 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    936 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    937 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    938 
    939 			gl.enableVertexAttribArray(coordLoc);
    940 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    941 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    942 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    943 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    944 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    945 
    946 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    947 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    948 
    949 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    950 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    951 
    952 			gl.uniform1i(samplerLoc, 0);
    953 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    954 
    955 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    956 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    957 
    958 			gl.enable(GL_STENCIL_TEST);
    959 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    960 
    961 			gl.stencilFunc(GL_LEQUAL, 0, 0);
    962 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
    963 
    964 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    965 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
    966 
    967 			gl.clearStencil(0);
    968 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
    969 			gl.clear(GL_STENCIL_BUFFER_BIT);
    970 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
    971 		}),
    972 		MACRO_BLOCK({
    973 			gl.stencilMask(0xDD);
    974 		})
    975 	)
    976 
    977 	ADD_TESTCASE(stencil_func, "Change stencil func.",
    978 		true,
    979 		false,
    980 		MACRO_BLOCK({
    981 			requireCoordBuffers(1);
    982 			requireTextures(1);
    983 			requirePrograms(1);
    984 
    985 			gl.useProgram(m_programs[0]->getProgram());
    986 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    987 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    988 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    989 
    990 			gl.enableVertexAttribArray(coordLoc);
    991 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    992 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    993 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    994 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    995 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    996 
    997 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    998 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    999 
   1000 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1001 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1002 
   1003 			gl.uniform1i(samplerLoc, 0);
   1004 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1005 
   1006 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1007 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1008 
   1009 			gl.enable(GL_STENCIL_TEST);
   1010 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
   1011 
   1012 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
   1013 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
   1014 			gl.clearStencil(0);
   1015 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
   1016 			gl.clear(GL_STENCIL_BUFFER_BIT);
   1017 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
   1018 		}),
   1019 		MACRO_BLOCK({
   1020 			gl.stencilFunc(GL_LEQUAL, 0, 0xFF);
   1021 		})
   1022 	)
   1023 
   1024 	ADD_TESTCASE(stencil_op, "Change stencil op.",
   1025 		true,
   1026 		false,
   1027 		MACRO_BLOCK({
   1028 			requireCoordBuffers(1);
   1029 			requireTextures(1);
   1030 			requirePrograms(1);
   1031 
   1032 			gl.useProgram(m_programs[0]->getProgram());
   1033 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1034 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1035 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1036 
   1037 			gl.enableVertexAttribArray(coordLoc);
   1038 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1039 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1040 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1041 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1042 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1043 
   1044 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1045 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1046 
   1047 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1048 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1049 
   1050 			gl.uniform1i(samplerLoc, 0);
   1051 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1052 
   1053 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1054 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1055 
   1056 			gl.enable(GL_STENCIL_TEST);
   1057 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
   1058 
   1059 			gl.stencilFunc(GL_LEQUAL, 0, 0);
   1060 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
   1061 
   1062 			gl.clearStencil(0);
   1063 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
   1064 
   1065 			gl.clear(GL_STENCIL_BUFFER_BIT);
   1066 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
   1067 		}),
   1068 		MACRO_BLOCK({
   1069 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
   1070 		})
   1071 	)
   1072 
   1073 	ADD_TESTCASE(bind_array_buffer, "Change array buffer and refresh vertex attrib pointer.",
   1074 		true,
   1075 		false,
   1076 		MACRO_BLOCK({
   1077 			requireCoordBuffers(1);
   1078 			requireTextures(1);
   1079 			requirePrograms(1);
   1080 
   1081 			gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
   1082 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
   1083 			gl.linkProgram(m_programs[0]->getProgram());
   1084 			GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
   1085 
   1086 			gl.useProgram(m_programs[0]->getProgram());
   1087 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1088 
   1089 			gl.enableVertexAttribArray(0);
   1090 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1091 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1092 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1093 			gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1094 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1095 
   1096 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1097 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1098 
   1099 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1100 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1101 
   1102 			gl.uniform1i(samplerLoc, 0);
   1103 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1104 
   1105 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1106 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1107 		}),
   1108 		MACRO_BLOCK({
   1109 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1110 			gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1111 		})
   1112 	)
   1113 
   1114 	ADD_TESTCASE(element_array_buffer, "Change element array buffer.",
   1115 		false,
   1116 		true,
   1117 		MACRO_BLOCK({
   1118 			requireCoordBuffers(1);
   1119 			requireIndexBuffers(1);
   1120 			requireTextures(1);
   1121 			requirePrograms(1);
   1122 
   1123 			gl.useProgram(m_programs[0]->getProgram());
   1124 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1125 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1126 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1127 
   1128 			gl.enableVertexAttribArray(coordLoc);
   1129 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1130 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1131 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1132 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1133 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1134 
   1135 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1136 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1137 
   1138 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1139 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1140 
   1141 			gl.uniform1i(samplerLoc, 0);
   1142 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1143 
   1144 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1145 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1146 
   1147 			gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
   1148 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1149 		}),
   1150 		MACRO_BLOCK({
   1151 			gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
   1152 		})
   1153 	)
   1154 
   1155 	ADD_TESTCASE(bind_texture, "Change texture binding.",
   1156 		true,
   1157 		false,
   1158 		MACRO_BLOCK({
   1159 			requireCoordBuffers(1);
   1160 			requireTextures(1);
   1161 			requirePrograms(1);
   1162 
   1163 			gl.useProgram(m_programs[0]->getProgram());
   1164 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1165 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1166 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1167 
   1168 			gl.enableVertexAttribArray(coordLoc);
   1169 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1170 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1171 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1172 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1173 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1174 
   1175 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1176 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1177 
   1178 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1179 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1180 
   1181 			gl.uniform1i(samplerLoc, 0);
   1182 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1183 
   1184 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1185 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1186 		}),
   1187 		MACRO_BLOCK({
   1188 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1189 		})
   1190 	)
   1191 
   1192 	ADD_TESTCASE(use_program, "Change used program.",
   1193 		true,
   1194 		false,
   1195 		MACRO_BLOCK({
   1196 			requireCoordBuffers(1);
   1197 			requireTextures(1);
   1198 			requirePrograms(1);
   1199 
   1200 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1201 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1202 
   1203 			gl.enableVertexAttribArray(coordLoc);
   1204 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1205 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1206 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1207 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1208 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1209 
   1210 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1211 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1212 
   1213 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1214 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1215 			gl.useProgram(m_programs[0]->getProgram());
   1216 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1217 			gl.uniform1i(samplerLoc, 0);
   1218 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1219 
   1220 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1221 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1222 		}),
   1223 		MACRO_BLOCK({
   1224 			gl.useProgram(m_programs[0]->getProgram());
   1225 		})
   1226 	)
   1227 
   1228 	ADD_TESTCASE(tex_parameter_min_filter, "Change texture parameter min filter.",
   1229 		true,
   1230 		false,
   1231 		MACRO_BLOCK({
   1232 			requireCoordBuffers(1);
   1233 			requireTextures(1);
   1234 			requirePrograms(1);
   1235 
   1236 			gl.useProgram(m_programs[0]->getProgram());
   1237 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1238 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1239 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1240 
   1241 			gl.enableVertexAttribArray(coordLoc);
   1242 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1243 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1244 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1245 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1246 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1247 
   1248 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1249 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1250 
   1251 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1252 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1253 
   1254 			gl.uniform1i(samplerLoc, 0);
   1255 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1256 
   1257 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1258 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1259 		}),
   1260 		MACRO_BLOCK({
   1261 			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   1262 		})
   1263 	)
   1264 
   1265 	ADD_TESTCASE(tex_parameter_mag_filter, "Change texture parameter mag filter.",
   1266 		true,
   1267 		false,
   1268 		MACRO_BLOCK({
   1269 			requireCoordBuffers(1);
   1270 			requireTextures(1);
   1271 			requirePrograms(1);
   1272 
   1273 			gl.useProgram(m_programs[0]->getProgram());
   1274 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1275 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1276 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1277 
   1278 			gl.enableVertexAttribArray(coordLoc);
   1279 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1280 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1281 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1282 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1283 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1284 
   1285 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1286 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1287 
   1288 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1289 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1290 
   1291 			gl.uniform1i(samplerLoc, 0);
   1292 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1293 
   1294 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1295 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1296 		}),
   1297 		MACRO_BLOCK({
   1298 			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   1299 		})
   1300 	)
   1301 
   1302 	ADD_TESTCASE(tex_parameter_wrap, "Change texture parameter wrap filter.",
   1303 		true,
   1304 		false,
   1305 		MACRO_BLOCK({
   1306 			requireCoordBuffers(1);
   1307 			requireTextures(1);
   1308 			requirePrograms(1);
   1309 
   1310 			gl.useProgram(m_programs[0]->getProgram());
   1311 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1312 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1313 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1314 
   1315 			gl.enableVertexAttribArray(coordLoc);
   1316 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1317 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1318 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1319 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1320 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1321 
   1322 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1323 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1324 
   1325 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1326 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1327 
   1328 			gl.uniform1i(samplerLoc, 0);
   1329 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1330 
   1331 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1332 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1333 		}),
   1334 		MACRO_BLOCK({
   1335 			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   1336 		})
   1337 	)
   1338 
   1339 	ADD_TESTCASE(bind_framebuffer, "Change framebuffer.",
   1340 		true,
   1341 		false,
   1342 		MACRO_BLOCK({
   1343 			requireCoordBuffers(1);
   1344 			requireTextures(1);
   1345 			requireFramebuffers(1);
   1346 			requirePrograms(1);
   1347 
   1348 			gl.useProgram(m_programs[0]->getProgram());
   1349 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1350 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1351 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1352 
   1353 			gl.enableVertexAttribArray(coordLoc);
   1354 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1355 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1356 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1357 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1358 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1359 
   1360 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1361 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1362 
   1363 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1364 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1365 
   1366 			gl.uniform1i(samplerLoc, 0);
   1367 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1368 
   1369 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1370 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1371 
   1372 			gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
   1373 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");
   1374 		}),
   1375 		MACRO_BLOCK({
   1376 			gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
   1377 		})
   1378 	)
   1379 
   1380 	ADD_TESTCASE(blend_color, "Change blend color.",
   1381 		true,
   1382 		false,
   1383 		MACRO_BLOCK({
   1384 			requireCoordBuffers(1);
   1385 			requireTextures(1);
   1386 			requirePrograms(1);
   1387 
   1388 			gl.useProgram(m_programs[0]->getProgram());
   1389 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1390 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1391 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1392 
   1393 			gl.enableVertexAttribArray(coordLoc);
   1394 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1395 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1396 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1397 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1398 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1399 
   1400 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1401 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1402 
   1403 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1404 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1405 
   1406 			gl.uniform1i(samplerLoc, 0);
   1407 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1408 
   1409 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1410 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1411 
   1412 			gl.enable(GL_BLEND);
   1413 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
   1414 
   1415 			gl.blendFunc(GL_CONSTANT_COLOR, GL_CONSTANT_COLOR);
   1416 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBlendFunc()");
   1417 		}),
   1418 		MACRO_BLOCK({
   1419 			gl.blendColor(0.75f, 0.75f, 0.75f, 0.75f);
   1420 		})
   1421 	)
   1422 
   1423 	ADD_TESTCASE(sampler, "Change sampler binding.",
   1424 		true,
   1425 		false,
   1426 		MACRO_BLOCK({
   1427 			requireCoordBuffers(1);
   1428 			requireTextures(1);
   1429 			requirePrograms(1);
   1430 			requireSamplers(1);
   1431 
   1432 			gl.useProgram(m_programs[0]->getProgram());
   1433 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1434 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1435 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1436 
   1437 			gl.enableVertexAttribArray(coordLoc);
   1438 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1439 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1440 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1441 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1442 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1443 
   1444 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1445 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1446 
   1447 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1448 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1449 
   1450 			gl.uniform1i(samplerLoc, 0);
   1451 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1452 
   1453 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1454 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1455 
   1456 			gl.bindSampler(0, m_samplers[0]);
   1457 			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   1458 			GLU_EXPECT_NO_ERROR(gl.getError(), "Sampler setup");
   1459 		}),
   1460 		MACRO_BLOCK({
   1461 			gl.bindSampler(0, m_samplers[0]);
   1462 		})
   1463 	)
   1464 
   1465 	ADD_TESTCASE(bind_vertex_array, "Change vertex array binding.",
   1466 		true,
   1467 		false,
   1468 		MACRO_BLOCK({
   1469 			requireCoordBuffers(1);
   1470 			requireTextures(1);
   1471 			requirePrograms(1);
   1472 			requireVertexArrays(1);
   1473 
   1474 			gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
   1475 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
   1476 			gl.linkProgram(m_programs[0]->getProgram());
   1477 			GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
   1478 
   1479 			gl.useProgram(m_programs[0]->getProgram());
   1480 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1481 
   1482 			gl.bindVertexArray(m_vertexArrays[0]);
   1483 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray()");
   1484 			gl.enableVertexAttribArray(0);
   1485 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1486 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1487 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1488 			gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1489 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1490 
   1491 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1492 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1493 
   1494 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1495 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1496 
   1497 			gl.uniform1i(samplerLoc, 0);
   1498 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1499 
   1500 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1501 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1502 		}),
   1503 		MACRO_BLOCK({
   1504 			gl.bindVertexArray(m_vertexArrays[0]);
   1505 		})
   1506 	)
   1507 }
   1508 
   1509 } // Performance
   1510 } // gles3
   1511 } // deqp
   1512