Home | History | Annotate | Download | only in functional
      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 Prerequisite tests.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "es2fPrerequisiteTests.hpp"
     25 #include "deRandom.h"
     26 #include "tcuRGBA.hpp"
     27 #include "tcuSurface.hpp"
     28 #include "tcuTextureUtil.hpp"
     29 #include "tcuTestLog.hpp"
     30 #include "tcuRenderTarget.hpp"
     31 #include "gluPixelTransfer.hpp"
     32 #include "gluStateReset.hpp"
     33 
     34 #include "glw.h"
     35 
     36 using tcu::RGBA;
     37 using tcu::Surface;
     38 using tcu::TestLog;
     39 
     40 namespace deqp
     41 {
     42 namespace gles2
     43 {
     44 namespace Functional
     45 {
     46 
     47 class StateResetCase : public TestCase
     48 {
     49 public:
     50 										StateResetCase	(Context& context);
     51 	virtual								~StateResetCase	(void);
     52 	virtual TestCase::IterateResult		iterate			(void);
     53 };
     54 
     55 StateResetCase::StateResetCase (Context& context)
     56 	: TestCase(context, "state_reset", "State Reset Test")
     57 {
     58 }
     59 
     60 StateResetCase::~StateResetCase (void)
     61 {
     62 }
     63 
     64 TestCase::IterateResult StateResetCase::iterate (void)
     65 {
     66 	try
     67 	{
     68 		glu::resetState(m_context.getRenderContext());
     69 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
     70 	}
     71 	catch (const tcu::TestError& e)
     72 	{
     73 		m_testCtx.getLog() << e;
     74 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
     75 	}
     76 
     77 	return TestCase::STOP;
     78 }
     79 
     80 class ClearColorCase : public TestCase
     81 {
     82 public:
     83 										ClearColorCase		(Context& context);
     84 	virtual								~ClearColorCase		(void);
     85 	virtual TestCase::IterateResult		iterate				(void);
     86 
     87 private:
     88 	RGBA		m_clearColor;
     89 	int			m_numIters;
     90 	int			m_curIter;
     91 };
     92 
     93 ClearColorCase::ClearColorCase (Context& context)
     94 	: TestCase		(context, "clear_color", "glClearColor test")
     95 	, m_numIters	(10)
     96 	, m_curIter		(0)
     97 {
     98 }
     99 
    100 ClearColorCase::~ClearColorCase (void)
    101 {
    102 }
    103 
    104 TestCase::IterateResult ClearColorCase::iterate (void)
    105 {
    106 	int r = 0;
    107 	int g = 0;
    108 	int b = 0;
    109 	int a = 255;
    110 
    111 	switch (m_curIter)
    112 	{
    113 		case 0:
    114 			// Black, skip
    115 			break;
    116 		case 1:
    117 			r = 255;
    118 			g = 255;
    119 			b = 255;
    120 			break;
    121 		case 2:
    122 			r = 255;
    123 			break;
    124 		case 3:
    125 			g = 255;
    126 			break;
    127 		case 4:
    128 			b = 255;
    129 			break;
    130 		default:
    131 			deRandom rnd;
    132 			deRandom_init(&rnd, deInt32Hash(m_curIter));
    133 			r = (int)(deRandom_getUint32(&rnd) & 0xFF);
    134 			g = (int)(deRandom_getUint32(&rnd) & 0xFF);
    135 			b = (int)(deRandom_getUint32(&rnd) & 0xFF);
    136 			a = (int)(deRandom_getUint32(&rnd) & 0xFF);
    137 			break;
    138 
    139 	};
    140 
    141 	glClearColor(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
    142 	glClear(GL_COLOR_BUFFER_BIT);
    143 
    144 	GLU_CHECK_MSG("CLES2 ClearColor failed.");
    145 
    146 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    147 
    148 	return (++m_curIter < m_numIters) ? CONTINUE : STOP;
    149 }
    150 
    151 class ReadPixelsCase : public TestCase
    152 {
    153 public:
    154 										ReadPixelsCase		(Context& context);
    155 	virtual								~ReadPixelsCase		(void);
    156 	virtual TestCase::IterateResult		iterate				(void);
    157 
    158 private:
    159 	int m_numIters;
    160 	int m_curIter;
    161 };
    162 
    163 ReadPixelsCase::ReadPixelsCase (Context& context)
    164 	: TestCase(context, "read_pixels", "Read pixels test")
    165 	, m_numIters(20)
    166 	, m_curIter(0)
    167 {
    168 }
    169 
    170 ReadPixelsCase::~ReadPixelsCase (void)
    171 {
    172 }
    173 
    174 TestCase::IterateResult ReadPixelsCase::iterate (void)
    175 {
    176 	const tcu::RenderTarget&	renderTarget	= m_context.getRenderTarget();
    177 	tcu::PixelFormat			pixelFormat		= renderTarget.getPixelFormat();
    178 	int							targetWidth		= renderTarget.getWidth();
    179 	int							targetHeight	= renderTarget.getHeight();
    180 	int							x				= 0;
    181 	int							y				= 0;
    182 	int							imageWidth		= 0;
    183 	int							imageHeight		= 0;
    184 
    185 	deRandom rnd;
    186 	deRandom_init(&rnd, deInt32Hash(m_curIter));
    187 
    188 	switch (m_curIter)
    189 	{
    190 		case 0:
    191 			// Fullscreen
    192 			x = 0;
    193 			y = 0;
    194 			imageWidth  = targetWidth;
    195 			imageHeight = targetHeight;
    196 			break;
    197 		case 1:
    198 			// Upper left corner
    199 			x = 0;
    200 			y = 0;
    201 			imageWidth = targetWidth / 2;
    202 			imageHeight = targetHeight / 2;
    203 			break;
    204 		case 2:
    205 			// Lower right corner
    206 			x = targetWidth / 2;
    207 			y = targetHeight / 2;
    208 			imageWidth = targetWidth - x;
    209 			imageHeight = targetHeight - y;
    210 			break;
    211 		default:
    212 			x = deRandom_getUint32(&rnd) % (targetWidth - 1);
    213 			y = deRandom_getUint32(&rnd) % (targetHeight - 1);
    214 			imageWidth = 1 + (deRandom_getUint32(&rnd) % (targetWidth - x - 1));
    215 			imageHeight = 1 + (deRandom_getUint32(&rnd) % (targetHeight - y - 1));
    216 			break;
    217 	}
    218 
    219 	Surface	resImage(imageWidth, imageHeight);
    220 	Surface	refImage(imageWidth, imageHeight);
    221 	Surface	diffImage(imageWidth, imageHeight);
    222 
    223 	int r = (int)(deRandom_getUint32(&rnd) & 0xFF);
    224 	int g = (int)(deRandom_getUint32(&rnd) & 0xFF);
    225 	int b = (int)(deRandom_getUint32(&rnd) & 0xFF);
    226 
    227 	tcu::clear(refImage.getAccess(), tcu::IVec4(r, g, b, 255));
    228 	glClearColor(r/255.0f, g/255.0f, b/255.0f, 1.0f);
    229 	glClear(GL_COLOR_BUFFER_BIT);
    230 
    231 	glu::readPixels(m_context.getRenderContext(), x, y, resImage.getAccess());
    232 	GLU_CHECK_MSG("glReadPixels() failed.");
    233 
    234 	RGBA colorThreshold = pixelFormat.getColorThreshold();
    235 	RGBA matchColor(0, 255, 0, 255);
    236 	RGBA diffColor(255, 0, 0, 255);
    237 	bool isImageOk = true;
    238 
    239 	for (int j = 0; j < imageHeight; j++)
    240 	{
    241 		for (int i = 0; i < imageWidth; i++)
    242 		{
    243 			RGBA		resRGBA		= resImage.getPixel(i, j);
    244 			RGBA		refRGBA		= refImage.getPixel(i, j);
    245 			bool		isPixelOk	= compareThreshold(refRGBA, resRGBA, colorThreshold);
    246 			diffImage.setPixel(i, j, isPixelOk ? matchColor : diffColor);
    247 
    248 			isImageOk = isImageOk && isPixelOk;
    249 		}
    250 	}
    251 
    252 	if (isImageOk)
    253 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    254 	else
    255 	{
    256 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    257 
    258 		TestLog& log = m_testCtx.getLog();
    259 		log << TestLog::ImageSet("Result", "Resulting framebuffer")
    260 			<< TestLog::Image("Result",		"Resulting framebuffer",	resImage)
    261 			<< TestLog::Image("Reference",	"Reference image",			refImage)
    262 			<< TestLog::Image("DiffMask",	"Failing pixels",			diffImage)
    263 			<< TestLog::EndImageSet;
    264 	}
    265 
    266 	return (++m_curIter < m_numIters) ? CONTINUE : STOP;
    267 }
    268 
    269 PrerequisiteTests::PrerequisiteTests (Context& context)
    270 	: TestCaseGroup(context, "prerequisite", "Prerequisite Test Cases")
    271 {
    272 }
    273 
    274 PrerequisiteTests::~PrerequisiteTests (void)
    275 {
    276 }
    277 
    278 void PrerequisiteTests::init (void)
    279 {
    280 	addChild(new StateResetCase(m_context));
    281 	addChild(new ClearColorCase(m_context));
    282 	addChild(new ReadPixelsCase(m_context));
    283 }
    284 
    285 } // Functional
    286 } // gles
    287 } // deqp
    288