modules/egl/teglQueryContextTests.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program EGL Module
  * ---------------------------------------
  *
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Config query tests.
  *//*--------------------------------------------------------------------*/

 #include "teglQueryContextTests.hpp"
 #include "teglRenderCase.hpp"
 #include "teglRenderCase.hpp"
 #include "egluCallLogWrapper.hpp"
 #include "egluStrUtil.hpp"
 #include "tcuCommandLine.hpp"
 #include "tcuTestLog.hpp"
 #include "tcuTestContext.hpp"

 #include "egluUtil.hpp"
 #include "egluNativeDisplay.hpp"
 #include "egluNativeWindow.hpp"
 #include "egluNativePixmap.hpp"

 #include "eglwLibrary.hpp"
 #include "eglwEnums.hpp"

 #include "deUniquePtr.hpp"
 #include "deSTLUtil.hpp"

 #include <vector>

 namespace deqp
 {
 namespace egl
 {

 using std::vector;
 using eglu::ConfigInfo;
 using tcu::TestLog;
 using namespace eglw;

 static EGLint getClientTypeFromAPIBit (EGLint apiBit)
 {
 	switch (apiBit)
 	{
 		case EGL_OPENGL_BIT:		return EGL_OPENGL_API;
 		case EGL_OPENGL_ES_BIT:		return EGL_OPENGL_ES_API;
 		case EGL_OPENGL_ES2_BIT:	return EGL_OPENGL_ES_API;
 		case EGL_OPENGL_ES3_BIT:	return EGL_OPENGL_ES_API;
 		case EGL_OPENVG_BIT:		return EGL_OPENVG_API;
 		default:
 			DE_ASSERT(false);
 			return 0;
 	}
 }

 static EGLint getMinClientMajorVersion (EGLint apiBit)
 {
 	switch (apiBit)
 	{
 		case EGL_OPENGL_BIT:		return 1;
 		case EGL_OPENGL_ES_BIT:		return 1;
 		case EGL_OPENGL_ES2_BIT:	return 2;
 		case EGL_OPENGL_ES3_BIT:	return 3;
 		case EGL_OPENVG_BIT:		return 1;
 		default:
 			DE_ASSERT(false);
 			return 0;
 	}
 }

 class GetCurrentContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
 {
 public:
 	GetCurrentContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
 		: SingleContextRenderCase	(eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
 		, eglu::CallLogWrapper		(eglTestCtx.getLibrary(), m_testCtx.getLog())
 	{
 	}

 	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
 	{
 		const Library&	egl	= m_eglTestCtx.getLibrary();
 		TestLog&		log	= m_testCtx.getLog();

 		DE_UNREF(display);
 		DE_UNREF(surface);
 		DE_UNREF(config);

 		enableLogging(true);

 		const EGLContext	gotContext	= eglGetCurrentContext();
 		EGLU_CHECK_MSG(egl, "eglGetCurrentContext");

 		if (gotContext == context)
 		{
 			log << TestLog::Message << "  Pass" << TestLog::EndMessage;
 		}
 		else if (gotContext == EGL_NO_CONTEXT)
 		{
 			log << TestLog::Message << "  Fail, got EGL_NO_CONTEXT" << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected EGL_NO_CONTEXT");
 		}
 		else if (gotContext != context)
 		{
 			log << TestLog::Message << "  Fail, call returned the wrong context. Expected: " << tcu::toHex(context) << ", got: " << tcu::toHex(gotContext) << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid context");
 		}

 		enableLogging(false);
 	}
 };

 class GetCurrentSurfaceCase : public SingleContextRenderCase, private eglu::CallLogWrapper
 {
 public:
 	GetCurrentSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
 		: SingleContextRenderCase	(eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
 		, eglu::CallLogWrapper		(eglTestCtx.getLibrary(), m_testCtx.getLog())
 	{
 	}

 	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
 	{
 		const Library&	egl	= m_eglTestCtx.getLibrary();
 		TestLog&		log	= m_testCtx.getLog();

 		DE_UNREF(display);
 		DE_UNREF(context);
 		DE_UNREF(config);

 		enableLogging(true);

 		const EGLContext	gotReadSurface	= eglGetCurrentSurface(EGL_READ);
 		EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_READ)");

 		const EGLContext	gotDrawSurface	= eglGetCurrentSurface(EGL_DRAW);
 		EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_DRAW)");

 		if (gotReadSurface == surface && gotDrawSurface == surface)
 		{
 			log << TestLog::Message << "  Pass" << TestLog::EndMessage;
 		}
 		else
 		{
 			log << TestLog::Message << "  Fail, read surface: " << tcu::toHex(gotReadSurface)
 									<< ", draw surface: " << tcu::toHex(gotDrawSurface)
 									<< ", expected: " << tcu::toHex(surface) << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface");
 		}

 		enableLogging(false);
 	}
 };

 class GetCurrentDisplayCase : public SingleContextRenderCase, private eglu::CallLogWrapper
 {
 public:
 	GetCurrentDisplayCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
 		: SingleContextRenderCase	(eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
 		, eglu::CallLogWrapper		(eglTestCtx.getLibrary(), m_testCtx.getLog())
 	{
 	}

 	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
 	{
 		const Library&	egl	= m_eglTestCtx.getLibrary();
 		TestLog&		log	= m_testCtx.getLog();

 		DE_UNREF(surface && context);
 		DE_UNREF(config);

 		enableLogging(true);

 		const EGLDisplay	gotDisplay	= eglGetCurrentDisplay();
 		EGLU_CHECK_MSG(egl, "eglGetCurrentDisplay");

 		if (gotDisplay == display)
 		{
 			log << TestLog::Message << "  Pass" << TestLog::EndMessage;
 		}
 		else if (gotDisplay == EGL_NO_DISPLAY)
 		{
 			log << TestLog::Message << "  Fail, got EGL_NO_DISPLAY" << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected EGL_NO_DISPLAY");
 		}
 		else if (gotDisplay != display)
 		{
 			log << TestLog::Message << "  Fail, call returned the wrong display. Expected: " << tcu::toHex(display) << ", got: " << tcu::toHex(gotDisplay) << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid display");
 		}

 		enableLogging(false);
 	}
 };

 class QueryContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
 {
 public:
 	QueryContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
 		: SingleContextRenderCase	(eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
 		, eglu::CallLogWrapper		(eglTestCtx.getLibrary(), m_testCtx.getLog())
 	{
 	}

 	EGLint getContextAttrib (EGLDisplay display, EGLContext context, EGLint attrib)
 	{
 		const Library&	egl	= m_eglTestCtx.getLibrary();
 		EGLint			value;
 		EGLU_CHECK_CALL(egl, queryContext(display, context, attrib, &value));

 		return value;
 	}

 	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
 	{
 		const Library&		egl		= m_eglTestCtx.getLibrary();
 		TestLog&			log		= m_testCtx.getLog();
 		const eglu::Version	version	= eglu::getVersion(egl, display);

 		DE_UNREF(surface);
 		enableLogging(true);

 		// Config ID
 		{
 			const EGLint	configID		= getContextAttrib(display, context, EGL_CONFIG_ID);
 			const EGLint	surfaceConfigID	= eglu::getConfigAttribInt(egl, display, config.config, EGL_CONFIG_ID);

 			if (configID != surfaceConfigID)
 			{
 				log << TestLog::Message << "  Fail, config ID doesn't match the one used to create the context." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid config ID");
 			}
 		}

 		// Client API type
 		if (version >= eglu::Version(1, 2))
 		{
 			const EGLint	clientType		= getContextAttrib(display, context, EGL_CONTEXT_CLIENT_TYPE);

 			if (clientType != getClientTypeFromAPIBit(config.apiBits))
 			{
 				log << TestLog::Message << "  Fail, client API type doesn't match." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid client API type");
 			}
 		}

 		// Client API version
 		if (version >= eglu::Version(1, 3))
 		{
 			const EGLint	clientVersion	= getContextAttrib(display, context, EGL_CONTEXT_CLIENT_VERSION);

 			// \todo [2014-10-21 mika] Query actual supported api version from client api to make this check stricter.
 			if (clientVersion < getMinClientMajorVersion(config.apiBits))
 			{
 				log << TestLog::Message << "  Fail, client API version doesn't match." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid client API version");
 			}
 		}

 		// Render buffer
 		if (version >= eglu::Version(1, 2))
 		{
 			const EGLint	renderBuffer	= getContextAttrib(display, context, EGL_RENDER_BUFFER);

 			if (config.surfaceTypeBit == EGL_PIXMAP_BIT && renderBuffer != EGL_SINGLE_BUFFER)
 			{
 				log << TestLog::Message << "  Fail, render buffer should be EGL_SINGLE_BUFFER for a pixmap surface." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
 			}
 			else if (config.surfaceTypeBit == EGL_PBUFFER_BIT && renderBuffer != EGL_BACK_BUFFER)
 			{
 				log << TestLog::Message << "  Fail, render buffer should be EGL_BACK_BUFFER for a pbuffer surface." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
 			}
 			else if (config.surfaceTypeBit == EGL_WINDOW_BIT && renderBuffer != EGL_SINGLE_BUFFER && renderBuffer != EGL_BACK_BUFFER)
 			{
 				log << TestLog::Message << "  Fail, render buffer should be either EGL_SINGLE_BUFFER or EGL_BACK_BUFFER for a window surface." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
 			}
 		}

 		enableLogging(false);

 		log << TestLog::Message << "  Pass" << TestLog::EndMessage;
 	}
 };

 class QueryAPICase : public TestCase, private eglu::CallLogWrapper
 {
 public:
 	QueryAPICase (EglTestContext& eglTestCtx, const char* name, const char* description)
 		: TestCase		(eglTestCtx, name, description)
 		, CallLogWrapper(eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
 	{
 	}

 	void init (void)
 	{
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	}

 	IterateResult iterate (void)
 	{
 		const Library&			egl				= m_eglTestCtx.getLibrary();
 		EGLDisplay				display			= eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 		tcu::TestLog&			log				= m_testCtx.getLog();
 		const EGLenum			apis[]			= { EGL_OPENGL_API, EGL_OPENGL_ES_API, EGL_OPENVG_API };
 		const vector<EGLenum>	supportedAPIs	= eglu::getClientAPIs(egl, display);

 		enableLogging(true);

 		{
 			const EGLenum	api	= eglQueryAPI();

 			if (api != EGL_OPENGL_ES_API && (de::contains(supportedAPIs.begin(), supportedAPIs.end(), EGL_OPENGL_ES_API)))
 			{
 				log << TestLog::Message << "  Fail, initial value should be EGL_OPENGL_ES_API if OpenGL ES is supported." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default value");
 			}
 			else if (api != EGL_NONE && !(de::contains(supportedAPIs.begin(), supportedAPIs.end(), EGL_OPENGL_ES_API)))
 			{
 				log << TestLog::Message << "  Fail, initial value should be EGL_NONE if OpenGL ES is not supported." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default value");
 			}
 		}

 		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(apis); ndx++)
 		{
 			const EGLenum	api	= apis[ndx];

 			log << TestLog::Message << TestLog::EndMessage;

 			if (de::contains(supportedAPIs.begin(), supportedAPIs.end(), api))
 			{
 				egl.bindAPI(api);

 				if (api != egl.queryAPI())
 				{
 					log << TestLog::Message << "  Fail, return value does not match previously bound API." << TestLog::EndMessage;
 					m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value");
 				}
 			}
 			else
 			{
 				log << TestLog::Message << eglu::getAPIStr(api) << " not supported." << TestLog::EndMessage;
 			}
 		}

 		enableLogging(false);
 		eglTerminate(display);
 		return STOP;
 	}
 };

 QueryContextTests::QueryContextTests (EglTestContext& eglTestCtx)
 	: TestCaseGroup(eglTestCtx, "query_context", "Rendering context query tests")
 {
 }

 QueryContextTests::~QueryContextTests (void)
 {
 }

 template<class QueryContextClass>
 void createQueryContextGroups (EglTestContext& eglTestCtx, tcu::TestCaseGroup* group)
 {
 	std::vector<RenderFilterList> filterLists;

 	getDefaultRenderFilterLists(filterLists, eglu::FilterList());

 	for (std::vector<RenderFilterList>::const_iterator listIter = filterLists.begin(); listIter != filterLists.end(); listIter++)
 		group->addChild(new QueryContextClass(eglTestCtx, listIter->getName(), "", *listIter, listIter->getSurfaceTypeMask()));
 }

 void QueryContextTests::init (void)
 {
 	{
 		tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "simple", "Simple API tests");
 		addChild(simpleGroup);

 		simpleGroup->addChild(new QueryAPICase(m_eglTestCtx, "query_api", "eglQueryAPI() test"));
 	}

 	// eglGetCurrentContext
 	{
 		tcu::TestCaseGroup* getCurrentContextGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_context", "eglGetCurrentContext() tests");
 		addChild(getCurrentContextGroup);

 		createQueryContextGroups<GetCurrentContextCase>(m_eglTestCtx, getCurrentContextGroup);
 	}

 	// eglGetCurrentSurface
 	{
 		tcu::TestCaseGroup* getCurrentSurfaceGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_surface", "eglGetCurrentSurface() tests");
 		addChild(getCurrentSurfaceGroup);

 		createQueryContextGroups<GetCurrentSurfaceCase>(m_eglTestCtx, getCurrentSurfaceGroup);
 	}

 	// eglGetCurrentDisplay
 	{
 		tcu::TestCaseGroup* getCurrentDisplayGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_display", "eglGetCurrentDisplay() tests");
 		addChild(getCurrentDisplayGroup);

 		createQueryContextGroups<GetCurrentDisplayCase>(m_eglTestCtx, getCurrentDisplayGroup);
 	}

 	// eglQueryContext
 	{
 		tcu::TestCaseGroup* queryContextGroup = new tcu::TestCaseGroup(m_testCtx, "query_context", "eglQueryContext() tests");
 		addChild(queryContextGroup);

 		createQueryContextGroups<QueryContextCase>(m_eglTestCtx, queryContextGroup);
 	}
 }

 } // egl
 } // deqp
	/*-------------------------------------------------------------------------
	* drawElements Quality Program EGL Module
	* ---------------------------------------
	*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Config query tests.
	//--------------------------------------------------------------------*/

	#include "teglQueryContextTests.hpp"
	#include "teglRenderCase.hpp"
	#include "teglRenderCase.hpp"
	#include "egluCallLogWrapper.hpp"
	#include "egluStrUtil.hpp"
	#include "tcuCommandLine.hpp"
	#include "tcuTestLog.hpp"
	#include "tcuTestContext.hpp"

	#include "egluUtil.hpp"
	#include "egluNativeDisplay.hpp"
	#include "egluNativeWindow.hpp"
	#include "egluNativePixmap.hpp"

	#include "eglwLibrary.hpp"
	#include "eglwEnums.hpp"

	#include "deUniquePtr.hpp"
	#include "deSTLUtil.hpp"

	#include <vector>

	namespace deqp
	{
	namespace egl
	{

	using std::vector;
	using eglu::ConfigInfo;
	using tcu::TestLog;
	using namespace eglw;

	static EGLint getClientTypeFromAPIBit (EGLint apiBit)
	{
	switch (apiBit)
	{
	case EGL_OPENGL_BIT: return EGL_OPENGL_API;
	case EGL_OPENGL_ES_BIT: return EGL_OPENGL_ES_API;
	case EGL_OPENGL_ES2_BIT: return EGL_OPENGL_ES_API;
	case EGL_OPENGL_ES3_BIT: return EGL_OPENGL_ES_API;
	case EGL_OPENVG_BIT: return EGL_OPENVG_API;
	default:
	DE_ASSERT(false);
	return 0;
	}
	}

	static EGLint getMinClientMajorVersion (EGLint apiBit)
	{
	switch (apiBit)
	{
	case EGL_OPENGL_BIT: return 1;
	case EGL_OPENGL_ES_BIT: return 1;
	case EGL_OPENGL_ES2_BIT: return 2;
	case EGL_OPENGL_ES3_BIT: return 3;
	case EGL_OPENVG_BIT: return 1;
	default:
	DE_ASSERT(false);
	return 0;
	}
	}

	class GetCurrentContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
	{
	public:
	GetCurrentContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
	: SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
	, eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
	{
	}

	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	TestLog& log = m_testCtx.getLog();

	DE_UNREF(display);
	DE_UNREF(surface);
	DE_UNREF(config);

	enableLogging(true);

	const EGLContext gotContext = eglGetCurrentContext();
	EGLU_CHECK_MSG(egl, "eglGetCurrentContext");

	if (gotContext == context)
	{
	log << TestLog::Message << " Pass" << TestLog::EndMessage;
	}
	else if (gotContext == EGL_NO_CONTEXT)
	{
	log << TestLog::Message << " Fail, got EGL_NO_CONTEXT" << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected EGL_NO_CONTEXT");
	}
	else if (gotContext != context)
	{
	log << TestLog::Message << " Fail, call returned the wrong context. Expected: " << tcu::toHex(context) << ", got: " << tcu::toHex(gotContext) << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid context");
	}

	enableLogging(false);
	}
	};

	class GetCurrentSurfaceCase : public SingleContextRenderCase, private eglu::CallLogWrapper
	{
	public:
	GetCurrentSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
	: SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
	, eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
	{
	}

	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	TestLog& log = m_testCtx.getLog();

	DE_UNREF(display);
	DE_UNREF(context);
	DE_UNREF(config);

	enableLogging(true);

	const EGLContext gotReadSurface = eglGetCurrentSurface(EGL_READ);
	EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_READ)");

	const EGLContext gotDrawSurface = eglGetCurrentSurface(EGL_DRAW);
	EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_DRAW)");

	if (gotReadSurface == surface && gotDrawSurface == surface)
	{
	log << TestLog::Message << " Pass" << TestLog::EndMessage;
	}
	else
	{
	log << TestLog::Message << " Fail, read surface: " << tcu::toHex(gotReadSurface)
	<< ", draw surface: " << tcu::toHex(gotDrawSurface)
	<< ", expected: " << tcu::toHex(surface) << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface");
	}

	enableLogging(false);
	}
	};

	class GetCurrentDisplayCase : public SingleContextRenderCase, private eglu::CallLogWrapper
	{
	public:
	GetCurrentDisplayCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
	: SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
	, eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
	{
	}

	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	TestLog& log = m_testCtx.getLog();

	DE_UNREF(surface && context);
	DE_UNREF(config);

	enableLogging(true);

	const EGLDisplay gotDisplay = eglGetCurrentDisplay();
	EGLU_CHECK_MSG(egl, "eglGetCurrentDisplay");

	if (gotDisplay == display)
	{
	log << TestLog::Message << " Pass" << TestLog::EndMessage;
	}
	else if (gotDisplay == EGL_NO_DISPLAY)
	{
	log << TestLog::Message << " Fail, got EGL_NO_DISPLAY" << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected EGL_NO_DISPLAY");
	}
	else if (gotDisplay != display)
	{
	log << TestLog::Message << " Fail, call returned the wrong display. Expected: " << tcu::toHex(display) << ", got: " << tcu::toHex(gotDisplay) << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid display");
	}

	enableLogging(false);
	}
	};

	class QueryContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
	{
	public:
	QueryContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
	: SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
	, eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
	{
	}

	EGLint getContextAttrib (EGLDisplay display, EGLContext context, EGLint attrib)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	EGLint value;
	EGLU_CHECK_CALL(egl, queryContext(display, context, attrib, &value));

	return value;
	}

	void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	TestLog& log = m_testCtx.getLog();
	const eglu::Version version = eglu::getVersion(egl, display);

	DE_UNREF(surface);
	enableLogging(true);

	// Config ID
	{
	const EGLint configID = getContextAttrib(display, context, EGL_CONFIG_ID);
	const EGLint surfaceConfigID = eglu::getConfigAttribInt(egl, display, config.config, EGL_CONFIG_ID);

	if (configID != surfaceConfigID)
	{
	log << TestLog::Message << " Fail, config ID doesn't match the one used to create the context." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid config ID");
	}
	}

	// Client API type
	if (version >= eglu::Version(1, 2))
	{
	const EGLint clientType = getContextAttrib(display, context, EGL_CONTEXT_CLIENT_TYPE);

	if (clientType != getClientTypeFromAPIBit(config.apiBits))
	{
	log << TestLog::Message << " Fail, client API type doesn't match." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid client API type");
	}
	}

	// Client API version
	if (version >= eglu::Version(1, 3))
	{
	const EGLint clientVersion = getContextAttrib(display, context, EGL_CONTEXT_CLIENT_VERSION);

	// \todo [2014-10-21 mika] Query actual supported api version from client api to make this check stricter.
	if (clientVersion < getMinClientMajorVersion(config.apiBits))
	{
	log << TestLog::Message << " Fail, client API version doesn't match." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid client API version");
	}
	}

	// Render buffer
	if (version >= eglu::Version(1, 2))
	{
	const EGLint renderBuffer = getContextAttrib(display, context, EGL_RENDER_BUFFER);

	if (config.surfaceTypeBit == EGL_PIXMAP_BIT && renderBuffer != EGL_SINGLE_BUFFER)
	{
	log << TestLog::Message << " Fail, render buffer should be EGL_SINGLE_BUFFER for a pixmap surface." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
	}
	else if (config.surfaceTypeBit == EGL_PBUFFER_BIT && renderBuffer != EGL_BACK_BUFFER)
	{
	log << TestLog::Message << " Fail, render buffer should be EGL_BACK_BUFFER for a pbuffer surface." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
	}
	else if (config.surfaceTypeBit == EGL_WINDOW_BIT && renderBuffer != EGL_SINGLE_BUFFER && renderBuffer != EGL_BACK_BUFFER)
	{
	log << TestLog::Message << " Fail, render buffer should be either EGL_SINGLE_BUFFER or EGL_BACK_BUFFER for a window surface." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
	}
	}

	enableLogging(false);

	log << TestLog::Message << " Pass" << TestLog::EndMessage;
	}
	};

	class QueryAPICase : public TestCase, private eglu::CallLogWrapper
	{
	public:
	QueryAPICase (EglTestContext& eglTestCtx, const char* name, const char* description)
	: TestCase (eglTestCtx, name, description)
	, CallLogWrapper(eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
	{
	}

	void init (void)
	{
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}

	IterateResult iterate (void)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	EGLDisplay display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
	tcu::TestLog& log = m_testCtx.getLog();
	const EGLenum apis[] = { EGL_OPENGL_API, EGL_OPENGL_ES_API, EGL_OPENVG_API };
	const vector<EGLenum> supportedAPIs = eglu::getClientAPIs(egl, display);

	enableLogging(true);

	{
	const EGLenum api = eglQueryAPI();

	if (api != EGL_OPENGL_ES_API && (de::contains(supportedAPIs.begin(), supportedAPIs.end(), EGL_OPENGL_ES_API)))
	{
	log << TestLog::Message << " Fail, initial value should be EGL_OPENGL_ES_API if OpenGL ES is supported." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default value");
	}
	else if (api != EGL_NONE && !(de::contains(supportedAPIs.begin(), supportedAPIs.end(), EGL_OPENGL_ES_API)))
	{
	log << TestLog::Message << " Fail, initial value should be EGL_NONE if OpenGL ES is not supported." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default value");
	}
	}

	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(apis); ndx++)
	{
	const EGLenum api = apis[ndx];

	log << TestLog::Message << TestLog::EndMessage;

	if (de::contains(supportedAPIs.begin(), supportedAPIs.end(), api))
	{
	egl.bindAPI(api);

	if (api != egl.queryAPI())
	{
	log << TestLog::Message << " Fail, return value does not match previously bound API." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value");
	}
	}
	else
	{
	log << TestLog::Message << eglu::getAPIStr(api) << " not supported." << TestLog::EndMessage;
	}
	}

	enableLogging(false);
	eglTerminate(display);
	return STOP;
	}
	};

	QueryContextTests::QueryContextTests (EglTestContext& eglTestCtx)
	: TestCaseGroup(eglTestCtx, "query_context", "Rendering context query tests")
	{
	}

	QueryContextTests::~QueryContextTests (void)
	{
	}

	template<class QueryContextClass>
	void createQueryContextGroups (EglTestContext& eglTestCtx, tcu::TestCaseGroup* group)
	{
	std::vector<RenderFilterList> filterLists;

	getDefaultRenderFilterLists(filterLists, eglu::FilterList());

	for (std::vector<RenderFilterList>::const_iterator listIter = filterLists.begin(); listIter != filterLists.end(); listIter++)
	group->addChild(new QueryContextClass(eglTestCtx, listIter->getName(), "", *listIter, listIter->getSurfaceTypeMask()));
	}

	void QueryContextTests::init (void)
	{
	{
	tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "simple", "Simple API tests");
	addChild(simpleGroup);

	simpleGroup->addChild(new QueryAPICase(m_eglTestCtx, "query_api", "eglQueryAPI() test"));
	}

	// eglGetCurrentContext
	{
	tcu::TestCaseGroup* getCurrentContextGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_context", "eglGetCurrentContext() tests");
	addChild(getCurrentContextGroup);

	createQueryContextGroups<GetCurrentContextCase>(m_eglTestCtx, getCurrentContextGroup);
	}

	// eglGetCurrentSurface
	{
	tcu::TestCaseGroup* getCurrentSurfaceGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_surface", "eglGetCurrentSurface() tests");
	addChild(getCurrentSurfaceGroup);

	createQueryContextGroups<GetCurrentSurfaceCase>(m_eglTestCtx, getCurrentSurfaceGroup);
	}

	// eglGetCurrentDisplay
	{
	tcu::TestCaseGroup* getCurrentDisplayGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_display", "eglGetCurrentDisplay() tests");
	addChild(getCurrentDisplayGroup);

	createQueryContextGroups<GetCurrentDisplayCase>(m_eglTestCtx, getCurrentDisplayGroup);
	}

	// eglQueryContext
	{
	tcu::TestCaseGroup* queryContextGroup = new tcu::TestCaseGroup(m_testCtx, "query_context", "eglQueryContext() tests");
	addChild(queryContextGroup);

	createQueryContextGroups<QueryContextCase>(m_eglTestCtx, queryContextGroup);
	}
	}

	} // egl
	} // deqp