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 eglu::ConfigInfo;
 using std::vector;
 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);
     }
 }

 } // namespace egl
 } // namespace 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 eglu::ConfigInfo;
	using std::vector;
	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);
	}
	}

	} // namespace egl
	} // namespace deqp