Home | History | Annotate | Download | only in performance 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES 2.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 "es2pRedundantStateChangeTests.hpp"
     25 #include "glsStateChangePerfTestCases.hpp"
     26 #include "gluShaderProgram.hpp"
     27 #include "glwFunctions.hpp"
     28 #include "glwEnums.hpp"
     29 
     30 namespace deqp
     31 {
     32 namespace gles2
     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(depth_func, "Change depth func.",
    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 			gl.enable(GL_DEPTH_TEST);
    413 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    414 		}),
    415 		MACRO_BLOCK({
    416 			gl.depthFunc(GL_GEQUAL);
    417 		})
    418 	)
    419 
    420 
    421 	ADD_TESTCASE(depth_mask, "Toggle depth mask.",
    422 		true,
    423 		false,
    424 		MACRO_BLOCK({
    425 			requireCoordBuffers(1);
    426 			requireTextures(1);
    427 			requirePrograms(1);
    428 
    429 			gl.useProgram(m_programs[0]->getProgram());
    430 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    431 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    432 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    433 
    434 			gl.enableVertexAttribArray(coordLoc);
    435 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    436 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    437 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    438 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    439 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    440 
    441 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    442 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    443 
    444 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    445 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    446 
    447 			gl.uniform1i(samplerLoc, 0);
    448 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    449 
    450 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    451 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    452 
    453 			gl.enable(GL_DEPTH_TEST);
    454 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    455 
    456 			gl.depthFunc(GL_LEQUAL);
    457 			GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
    458 		}),
    459 		MACRO_BLOCK({
    460 			gl.depthMask(GL_FALSE);
    461 		})
    462 	)
    463 
    464 	ADD_TESTCASE(depth_rangef, "Change depth range.",
    465 		true,
    466 		false,
    467 		MACRO_BLOCK({
    468 			requireCoordBuffers(1);
    469 			requireTextures(1);
    470 			requirePrograms(1);
    471 
    472 			gl.useProgram(m_programs[0]->getProgram());
    473 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    474 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    475 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    476 
    477 			gl.enableVertexAttribArray(coordLoc);
    478 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    479 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    480 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    481 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    482 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    483 
    484 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    485 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    486 
    487 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    488 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    489 
    490 			gl.uniform1i(samplerLoc, 0);
    491 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    492 
    493 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    494 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    495 		}),
    496 		MACRO_BLOCK({
    497 			gl.depthRangef(0.0f, 1.0f);
    498 		})
    499 	)
    500 
    501 	ADD_TESTCASE(blend_equation, "Change blend equation.",
    502 		true,
    503 		false,
    504 		MACRO_BLOCK({
    505 			requireCoordBuffers(1);
    506 			requireTextures(1);
    507 			requirePrograms(1);
    508 
    509 			gl.useProgram(m_programs[0]->getProgram());
    510 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    511 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    512 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    513 
    514 			gl.enableVertexAttribArray(coordLoc);
    515 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    516 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    517 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    518 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    519 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    520 
    521 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    522 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    523 
    524 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    525 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    526 
    527 			gl.uniform1i(samplerLoc, 0);
    528 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    529 
    530 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    531 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    532 
    533 			gl.enable(GL_BLEND);
    534 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    535 		}),
    536 		MACRO_BLOCK({
    537 			gl.blendEquation(GL_FUNC_SUBTRACT);
    538 		})
    539 	)
    540 
    541 	ADD_TESTCASE(blend_func, "Change blend function.",
    542 		true,
    543 		false,
    544 		MACRO_BLOCK({
    545 			requireCoordBuffers(1);
    546 			requireTextures(1);
    547 			requirePrograms(1);
    548 
    549 			gl.useProgram(m_programs[0]->getProgram());
    550 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    551 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    552 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    553 
    554 			gl.enableVertexAttribArray(coordLoc);
    555 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    556 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    557 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    558 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    559 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    560 
    561 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    562 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    563 
    564 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    565 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    566 
    567 			gl.uniform1i(samplerLoc, 0);
    568 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    569 
    570 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    571 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    572 
    573 			gl.enable(GL_BLEND);
    574 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    575 		}),
    576 		MACRO_BLOCK({
    577 			gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    578 		})
    579 	)
    580 
    581 	ADD_TESTCASE(polygon_offset, "Change polygon offset.",
    582 		true,
    583 		false,
    584 		MACRO_BLOCK({
    585 			requireCoordBuffers(1);
    586 			requireTextures(1);
    587 			requirePrograms(1);
    588 
    589 			gl.useProgram(m_programs[0]->getProgram());
    590 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    591 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    592 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    593 
    594 			gl.enableVertexAttribArray(coordLoc);
    595 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    596 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    597 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    598 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    599 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    600 
    601 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    602 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    603 
    604 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    605 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    606 
    607 			gl.uniform1i(samplerLoc, 0);
    608 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    609 
    610 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    611 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    612 
    613 			gl.enable(GL_POLYGON_OFFSET_FILL);
    614 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    615 		}),
    616 		MACRO_BLOCK({
    617 			gl.polygonOffset(0.0f, 0.0f);
    618 		})
    619 	)
    620 
    621 	ADD_TESTCASE(sample_coverage, "Sample coverage.",
    622 		true,
    623 		false,
    624 		MACRO_BLOCK({
    625 			requireCoordBuffers(1);
    626 			requireTextures(1);
    627 			requirePrograms(1);
    628 
    629 			gl.useProgram(m_programs[0]->getProgram());
    630 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    631 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    632 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    633 
    634 			gl.enableVertexAttribArray(coordLoc);
    635 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    636 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    637 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    638 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    639 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    640 
    641 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    642 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    643 
    644 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    645 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    646 
    647 			gl.uniform1i(samplerLoc, 0);
    648 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    649 
    650 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    651 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    652 		}),
    653 		MACRO_BLOCK({
    654 			gl.sampleCoverage(0.25f, GL_TRUE);
    655 		})
    656 	)
    657 
    658 	ADD_TESTCASE(viewport, "Change viewport.",
    659 		true,
    660 		false,
    661 		MACRO_BLOCK({
    662 			requireCoordBuffers(1);
    663 			requireTextures(1);
    664 			requirePrograms(1);
    665 
    666 			gl.useProgram(m_programs[0]->getProgram());
    667 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    668 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    669 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    670 
    671 			gl.enableVertexAttribArray(coordLoc);
    672 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    673 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    674 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    675 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    676 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    677 
    678 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    679 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    680 
    681 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    682 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    683 
    684 			gl.uniform1i(samplerLoc, 0);
    685 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    686 
    687 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    688 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    689 		}),
    690 		MACRO_BLOCK({
    691 			gl.viewport(10, 11, 5, 6);
    692 		})
    693 	)
    694 
    695 	ADD_TESTCASE(scissor, "Change scissor box.",
    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 			gl.enable(GL_SCISSOR_TEST);
    728 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    729 		}),
    730 		MACRO_BLOCK({
    731 			gl.scissor(17, 13, 5, 8);
    732 		})
    733 	)
    734 
    735 	ADD_TESTCASE(color_mask, "Change color mask.",
    736 		true,
    737 		false,
    738 		MACRO_BLOCK({
    739 			requireCoordBuffers(1);
    740 			requireTextures(1);
    741 			requirePrograms(1);
    742 
    743 			gl.useProgram(m_programs[0]->getProgram());
    744 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    745 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    746 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    747 
    748 			gl.enableVertexAttribArray(coordLoc);
    749 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    750 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    751 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    752 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    753 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    754 
    755 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    756 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    757 
    758 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    759 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    760 
    761 			gl.uniform1i(samplerLoc, 0);
    762 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    763 
    764 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    765 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    766 		}),
    767 		MACRO_BLOCK({
    768 			gl.colorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE);
    769 		})
    770 	)
    771 
    772 	ADD_TESTCASE(cull_face, "Change culling mode.",
    773 		true,
    774 		false,
    775 		MACRO_BLOCK({
    776 			requireCoordBuffers(1);
    777 			requireTextures(1);
    778 			requirePrograms(1);
    779 
    780 			gl.useProgram(m_programs[0]->getProgram());
    781 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    782 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    783 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    784 
    785 			gl.enableVertexAttribArray(coordLoc);
    786 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    787 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    788 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    789 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    790 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    791 
    792 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    793 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    794 
    795 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    796 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    797 
    798 			gl.uniform1i(samplerLoc, 0);
    799 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    800 
    801 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    802 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    803 
    804 			gl.enable(GL_CULL_FACE);
    805 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    806 		}),
    807 		MACRO_BLOCK({
    808 			gl.cullFace(GL_FRONT);
    809 		})
    810 	)
    811 
    812 	ADD_TESTCASE(front_face, "Change front face.",
    813 		true,
    814 		false,
    815 		MACRO_BLOCK({
    816 			requireCoordBuffers(1);
    817 			requireTextures(1);
    818 			requirePrograms(1);
    819 
    820 			gl.useProgram(m_programs[0]->getProgram());
    821 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    822 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    823 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    824 
    825 			gl.enableVertexAttribArray(coordLoc);
    826 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    827 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    828 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    829 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    830 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    831 
    832 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    833 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    834 
    835 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    836 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    837 
    838 			gl.uniform1i(samplerLoc, 0);
    839 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    840 
    841 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    842 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    843 
    844 			gl.enable(GL_CULL_FACE);
    845 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    846 		}),
    847 		MACRO_BLOCK({
    848 			gl.frontFace(GL_CCW);
    849 		})
    850 	)
    851 
    852 	ADD_TESTCASE(stencil_mask, "Change stencil mask.",
    853 		true,
    854 		false,
    855 		MACRO_BLOCK({
    856 			requireCoordBuffers(1);
    857 			requireTextures(1);
    858 			requirePrograms(1);
    859 
    860 			gl.useProgram(m_programs[0]->getProgram());
    861 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    862 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    863 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    864 
    865 			gl.enableVertexAttribArray(coordLoc);
    866 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    867 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    868 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    869 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    870 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    871 
    872 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    873 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    874 
    875 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    876 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    877 
    878 			gl.uniform1i(samplerLoc, 0);
    879 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    880 
    881 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    882 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    883 
    884 			gl.enable(GL_STENCIL_TEST);
    885 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    886 
    887 			gl.stencilFunc(GL_LEQUAL, 0, 0);
    888 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
    889 
    890 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    891 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
    892 
    893 			gl.clearStencil(0);
    894 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
    895 			gl.clear(GL_STENCIL_BUFFER_BIT);
    896 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
    897 		}),
    898 		MACRO_BLOCK({
    899 			gl.stencilMask(0xDD);
    900 		})
    901 	)
    902 
    903 	ADD_TESTCASE(stencil_func, "Change stencil func.",
    904 		true,
    905 		false,
    906 		MACRO_BLOCK({
    907 			requireCoordBuffers(1);
    908 			requireTextures(1);
    909 			requirePrograms(1);
    910 
    911 			gl.useProgram(m_programs[0]->getProgram());
    912 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    913 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    914 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    915 
    916 			gl.enableVertexAttribArray(coordLoc);
    917 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    918 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    919 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    920 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    921 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    922 
    923 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    924 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    925 
    926 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    927 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    928 
    929 			gl.uniform1i(samplerLoc, 0);
    930 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    931 
    932 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    933 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    934 
    935 			gl.enable(GL_STENCIL_TEST);
    936 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    937 
    938 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    939 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
    940 			gl.clearStencil(0);
    941 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
    942 			gl.clear(GL_STENCIL_BUFFER_BIT);
    943 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
    944 		}),
    945 		MACRO_BLOCK({
    946 			gl.stencilFunc(GL_LEQUAL, 0, 0xFF);
    947 		})
    948 	)
    949 
    950 	ADD_TESTCASE(stencil_op, "Change stencil op.",
    951 		true,
    952 		false,
    953 		MACRO_BLOCK({
    954 			requireCoordBuffers(1);
    955 			requireTextures(1);
    956 			requirePrograms(1);
    957 
    958 			gl.useProgram(m_programs[0]->getProgram());
    959 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
    960 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
    961 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
    962 
    963 			gl.enableVertexAttribArray(coordLoc);
    964 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
    965 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
    966 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
    967 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    968 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
    969 
    970 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
    971 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
    972 
    973 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
    974 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
    975 
    976 			gl.uniform1i(samplerLoc, 0);
    977 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
    978 
    979 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
    980 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
    981 
    982 			gl.enable(GL_STENCIL_TEST);
    983 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
    984 
    985 			gl.stencilFunc(GL_LEQUAL, 0, 0);
    986 			GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
    987 
    988 			gl.clearStencil(0);
    989 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
    990 
    991 			gl.clear(GL_STENCIL_BUFFER_BIT);
    992 			GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
    993 		}),
    994 		MACRO_BLOCK({
    995 			gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    996 		})
    997 	)
    998 
    999 	ADD_TESTCASE(bind_array_buffer, "Change array buffer and refresh vertex attrib pointer.",
   1000 		true,
   1001 		false,
   1002 		MACRO_BLOCK({
   1003 			requireCoordBuffers(1);
   1004 			requireTextures(1);
   1005 			requirePrograms(1);
   1006 
   1007 			gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
   1008 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
   1009 			gl.linkProgram(m_programs[0]->getProgram());
   1010 			GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
   1011 
   1012 			gl.useProgram(m_programs[0]->getProgram());
   1013 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1014 
   1015 			gl.enableVertexAttribArray(0);
   1016 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1017 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1018 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1019 			gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1020 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1021 
   1022 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1023 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1024 
   1025 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1026 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1027 
   1028 			gl.uniform1i(samplerLoc, 0);
   1029 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1030 
   1031 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1032 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1033 		}),
   1034 		MACRO_BLOCK({
   1035 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1036 			gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1037 		})
   1038 	)
   1039 
   1040 	ADD_TESTCASE(element_array_buffer, "Change element array buffer.",
   1041 		false,
   1042 		true,
   1043 		MACRO_BLOCK({
   1044 			requireCoordBuffers(1);
   1045 			requireIndexBuffers(1);
   1046 			requireTextures(1);
   1047 			requirePrograms(1);
   1048 
   1049 			gl.useProgram(m_programs[0]->getProgram());
   1050 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1051 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1052 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1053 
   1054 			gl.enableVertexAttribArray(coordLoc);
   1055 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1056 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1057 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1058 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1059 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1060 
   1061 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1062 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1063 
   1064 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1065 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1066 
   1067 			gl.uniform1i(samplerLoc, 0);
   1068 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1069 
   1070 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1071 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1072 
   1073 			gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
   1074 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1075 		}),
   1076 		MACRO_BLOCK({
   1077 			gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
   1078 		})
   1079 	)
   1080 
   1081 	ADD_TESTCASE(bind_texture, "Change texture binding.",
   1082 		true,
   1083 		false,
   1084 		MACRO_BLOCK({
   1085 			requireCoordBuffers(1);
   1086 			requireTextures(1);
   1087 			requirePrograms(1);
   1088 
   1089 			gl.useProgram(m_programs[0]->getProgram());
   1090 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1091 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1092 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1093 
   1094 			gl.enableVertexAttribArray(coordLoc);
   1095 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1096 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1097 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1098 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1099 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1100 
   1101 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1102 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1103 
   1104 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1105 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1106 
   1107 			gl.uniform1i(samplerLoc, 0);
   1108 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1109 
   1110 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1111 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1112 		}),
   1113 		MACRO_BLOCK({
   1114 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1115 		})
   1116 	)
   1117 
   1118 	ADD_TESTCASE(use_program, "Change used program.",
   1119 		true,
   1120 		false,
   1121 		MACRO_BLOCK({
   1122 			requireCoordBuffers(1);
   1123 			requireTextures(1);
   1124 			requirePrograms(1);
   1125 
   1126 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1127 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1128 
   1129 			gl.enableVertexAttribArray(coordLoc);
   1130 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1131 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1132 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1133 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1134 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1135 
   1136 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1137 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1138 
   1139 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1140 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1141 			gl.useProgram(m_programs[0]->getProgram());
   1142 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1143 			gl.uniform1i(samplerLoc, 0);
   1144 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1145 
   1146 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1147 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1148 		}),
   1149 		MACRO_BLOCK({
   1150 			gl.useProgram(m_programs[0]->getProgram());
   1151 		})
   1152 	)
   1153 
   1154 	ADD_TESTCASE(tex_parameter_min_filter, "Change texture parameter min filter.",
   1155 		true,
   1156 		false,
   1157 		MACRO_BLOCK({
   1158 			requireCoordBuffers(1);
   1159 			requireTextures(1);
   1160 			requirePrograms(1);
   1161 
   1162 			gl.useProgram(m_programs[0]->getProgram());
   1163 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1164 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1165 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1166 
   1167 			gl.enableVertexAttribArray(coordLoc);
   1168 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1169 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1170 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1171 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1172 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1173 
   1174 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1175 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1176 
   1177 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1178 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1179 
   1180 			gl.uniform1i(samplerLoc, 0);
   1181 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1182 
   1183 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1184 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1185 		}),
   1186 		MACRO_BLOCK({
   1187 			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   1188 		})
   1189 	)
   1190 
   1191 	ADD_TESTCASE(tex_parameter_mag_filter, "Change texture parameter mag filter.",
   1192 		true,
   1193 		false,
   1194 		MACRO_BLOCK({
   1195 			requireCoordBuffers(1);
   1196 			requireTextures(1);
   1197 			requirePrograms(1);
   1198 
   1199 			gl.useProgram(m_programs[0]->getProgram());
   1200 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1201 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1202 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1203 
   1204 			gl.enableVertexAttribArray(coordLoc);
   1205 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1206 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1207 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1208 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1209 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1210 
   1211 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1212 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1213 
   1214 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1215 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1216 
   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.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   1225 		})
   1226 	)
   1227 
   1228 	ADD_TESTCASE(tex_parameter_wrap, "Change texture parameter wrap 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_WRAP_S, GL_REPEAT);
   1262 		})
   1263 	)
   1264 
   1265 	ADD_TESTCASE(bind_framebuffer, "Change framebuffer.",
   1266 		true,
   1267 		false,
   1268 		MACRO_BLOCK({
   1269 			requireCoordBuffers(1);
   1270 			requireTextures(1);
   1271 			requireFramebuffers(1);
   1272 			requirePrograms(1);
   1273 
   1274 			gl.useProgram(m_programs[0]->getProgram());
   1275 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1276 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1277 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1278 
   1279 			gl.enableVertexAttribArray(coordLoc);
   1280 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1281 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1282 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1283 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1284 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1285 
   1286 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1287 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1288 
   1289 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1290 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1291 
   1292 			gl.uniform1i(samplerLoc, 0);
   1293 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1294 
   1295 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1296 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1297 
   1298 			gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
   1299 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");
   1300 		}),
   1301 		MACRO_BLOCK({
   1302 			gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
   1303 		})
   1304 	)
   1305 
   1306 	ADD_TESTCASE(blend_color, "Change blend color.",
   1307 		true,
   1308 		false,
   1309 		MACRO_BLOCK({
   1310 			requireCoordBuffers(1);
   1311 			requireTextures(1);
   1312 			requirePrograms(1);
   1313 
   1314 			gl.useProgram(m_programs[0]->getProgram());
   1315 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
   1316 			GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
   1317 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
   1318 
   1319 			gl.enableVertexAttribArray(coordLoc);
   1320 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
   1321 			gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
   1322 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
   1323 			gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   1324 			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
   1325 
   1326 			GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
   1327 			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
   1328 
   1329 			gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
   1330 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
   1331 
   1332 			gl.uniform1i(samplerLoc, 0);
   1333 			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
   1334 
   1335 			gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
   1336 			GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
   1337 
   1338 			gl.enable(GL_BLEND);
   1339 			GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
   1340 
   1341 			gl.blendFunc(GL_CONSTANT_COLOR, GL_CONSTANT_COLOR);
   1342 			GLU_EXPECT_NO_ERROR(gl.getError(), "glBlendFunc()");
   1343 		}),
   1344 		MACRO_BLOCK({
   1345 			gl.blendColor(0.75f, 0.75f, 0.75f, 0.75f);
   1346 		})
   1347 	)
   1348 }
   1349 
   1350 } // Performance
   1351 } // gles2
   1352 } // deqp
   1353