modules/egl/teglClientExtensionTests.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 EGL_EXT_client_extensions tests
  *//*--------------------------------------------------------------------*/

 #include "teglClientExtensionTests.hpp"

 #include "tcuTestLog.hpp"

 #include "egluUtil.hpp"

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

 #include "deStringUtil.hpp"
 #include "deSTLUtil.hpp"

 #include <vector>
 #include <set>
 #include <string>
 #include <sstream>

 using std::string;
 using std::vector;
 using std::set;

 using tcu::TestLog;

 using namespace eglw;

 namespace deqp
 {
 namespace egl
 {
 namespace
 {

 static const char* const s_displayExtensionList[] =
 {
 	"EGL_KHR_config_attribs",
 	"EGL_KHR_lock_surface",
 	"EGL_KHR_image",
 	"EGL_KHR_vg_parent_image",
 	"EGL_KHR_gl_texture_2D_image",
 	"EGL_KHR_gl_texture_cubemap_image",
 	"EGL_KHR_gl_texture_3D_image",
 	"EGL_KHR_gl_renderbuffer_image",
 	"EGL_KHR_reusable_sync",
 	"EGL_KHR_image_base",
 	"EGL_KHR_image_pixmap",
 	"EGL_IMG_context_priority",
 	"EGL_KHR_lock_surface2",
 	"EGL_NV_coverage_sample",
 	"EGL_NV_depth_nonlinear",
 	"EGL_NV_sync",
 	"EGL_KHR_fence_sync",
 	"EGL_HI_clientpixmap",
 	"EGL_HI_colorformats",
 	"EGL_MESA_drm_image",
 	"EGL_NV_post_sub_buffer",
 	"EGL_ANGLE_query_surface_pointer",
 	"EGL_ANGLE_surface_d3d_texture_2d_share_handle",
 	"EGL_NV_coverage_sample_resolve",
 //	"EGL_NV_system_time",	\todo [mika] Unclear which one this is
 	"EGL_KHR_stream",
 	"EGL_KHR_stream_consumer_gltexture",
 	"EGL_KHR_stream_producer_eglsurface",
 	"EGL_KHR_stream_producer_aldatalocator",
 	"EGL_KHR_stream_fifo",
 	"EGL_EXT_create_context_robustness",
 	"EGL_ANGLE_d3d_share_handle_client_buffer",
 	"EGL_KHR_create_context",
 	"EGL_KHR_surfaceless_context",
 	"EGL_KHR_stream_cross_process_fd",
 	"EGL_EXT_multiview_window",
 	"EGL_KHR_wait_sync",
 	"EGL_NV_post_convert_rounding",
 	"EGL_NV_native_query",
 	"EGL_NV_3dvision_surface",
 	"EGL_ANDROID_framebuffer_target",
 	"EGL_ANDROID_blob_cache",
 	"EGL_ANDROID_image_native_buffer",
 	"EGL_ANDROID_native_fence_sync",
 	"EGL_ANDROID_recordable",
 	"EGL_EXT_buffer_age",
 	"EGL_EXT_image_dma_buf_import",
 	"EGL_ARM_pixmap_multisample_discard",
 	"EGL_EXT_swap_buffers_with_damage",
 	"EGL_NV_stream_sync",
 	"EGL_KHR_cl_event",
 	"EGL_KHR_get_all_proc_addresses"
 };

 static const char* const s_clientExtensionList[] =
 {
 	"EGL_EXT_platform_base",
 	"EGL_EXT_client_extensions",
 	"EGL_EXT_platform_x11",
 	"EGL_KHR_client_get_all_proc_addresses",
 	"EGL_MESA_platform_gbm",
 	"EGL_EXT_platform_wayland"
 };

 class BaseTest : public TestCase
 {
 public:
 					BaseTest	(EglTestContext& eglTestCtx);
 	IterateResult	iterate		(void);
 };

 BaseTest::BaseTest (EglTestContext& eglTestCtx)
 	: TestCase(eglTestCtx, "base", "Basic tests for EGL_EXT_client_extensions")
 {
 }

 TestCase::IterateResult BaseTest::iterate (void)
 {
 	const Library&		egl					= m_eglTestCtx.getLibrary();
 	const char* const	clientExtesionsStr	= egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
 	const EGLint		eglError			= egl.getError();

 	if (eglError == EGL_BAD_DISPLAY)
 		TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
 	else if (eglError != EGL_SUCCESS)
 		throw eglu::Error(eglError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);

 	TCU_CHECK(clientExtesionsStr);

 	{
 		bool				found		= false;
 		std::istringstream	stream		(clientExtesionsStr);
 		string				extension;

 		while (std::getline(stream, extension, ' '))
 		{
 			if (extension == "EGL_EXT_client_extensions")
 			{
 				found = true;
 				break;
 			}
 		}

 		if (found)
 			m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 		else
 		{
 			m_testCtx.getLog() << TestLog::Message << "eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) didn't fail, but extension string doesn't contain EGL_EXT_client_extensions" <<TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 		}
 	}

 	return STOP;
 }

 class CheckExtensionsTest : public TestCase
 {
 public:
 					CheckExtensionsTest	(EglTestContext& eglTestCtx);
 	IterateResult	iterate				(void);
 };

 CheckExtensionsTest::CheckExtensionsTest (EglTestContext& eglTestCtx)
 	: TestCase(eglTestCtx, "extensions", "Check that returned extensions are client or display extensions")
 {
 }

 TestCase::IterateResult CheckExtensionsTest::iterate (void)
 {
 	const Library&		egl						= m_eglTestCtx.getLibrary();
 	bool				isOk					= true;
 	const char* const	clientExtensionsStr		= egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
 	const EGLint		eglQueryError			= egl.getError();

 	set<string>			knownClientExtensions	(s_clientExtensionList, s_clientExtensionList + DE_LENGTH_OF_ARRAY(s_clientExtensionList));
 	set<string>			knownDisplayExtensions	(s_displayExtensionList, s_displayExtensionList + DE_LENGTH_OF_ARRAY(s_displayExtensionList));

 	vector<string>		displayExtensions;
 	vector<string>		clientExtensions;

 	if (eglQueryError == EGL_BAD_DISPLAY)
 		TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
 	else if (eglQueryError != EGL_SUCCESS)
 		throw eglu::Error(eglQueryError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);

 	TCU_CHECK(clientExtensionsStr);

 	clientExtensions = de::splitString(clientExtensionsStr, ' ');

 	{
 		EGLDisplay	display	= eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

 		displayExtensions = de::splitString(egl.queryString(display, EGL_EXTENSIONS), ' ');

 		egl.terminate(display);
 	}

 	for (int extNdx = 0; extNdx < (int)clientExtensions.size(); extNdx++)
 	{
 		if (knownDisplayExtensions.find(clientExtensions[extNdx]) != knownDisplayExtensions.end())
 		{
 			m_testCtx.getLog() << TestLog::Message << "'" << clientExtensions[extNdx] << "' is not client extension" << TestLog::EndMessage;
 			isOk = false;
 		}
 	}

 	for (int extNdx = 0; extNdx < (int)displayExtensions.size(); extNdx++)
 	{
 		if (knownClientExtensions.find(displayExtensions[extNdx]) != knownClientExtensions.end())
 		{
 			m_testCtx.getLog() << TestLog::Message << "'" << displayExtensions[extNdx] << "' is not display extension" << TestLog::EndMessage;
 			isOk = false;
 		}
 	}

 	if (isOk)
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	else
 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 	return STOP;
 }


 class DisjointTest : public TestCase
 {
 public:
 					DisjointTest	(EglTestContext& eglTestCtx);
 	IterateResult	iterate			(void);
 };

 DisjointTest::DisjointTest (EglTestContext& eglTestCtx)
 	: TestCase(eglTestCtx, "disjoint", "Check that client and display extensions are disjoint")
 {
 }

 TestCase::IterateResult DisjointTest::iterate (void)
 {
 	const Library&		egl					= m_eglTestCtx.getLibrary();
 	const char*	const	clientExtensionsStr	= egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
 	const EGLint		eglQueryError		= egl.getError();

 	if (eglQueryError == EGL_BAD_DISPLAY)
 		TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
 	else if (eglQueryError != EGL_SUCCESS)
 		throw eglu::Error(eglQueryError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);

 	vector<string>		displayExtensions;
 	vector<string>		clientExtensions;

 	clientExtensions = de::splitString(clientExtensionsStr, ' ');

 	{
 		EGLDisplay	display	= eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

 		displayExtensions = de::splitString(egl.queryString(display, EGL_EXTENSIONS), ' ');

 		egl.terminate(display);
 	}

 	// Log client extensions
 	{
 		const tcu::ScopedLogSection section(m_testCtx.getLog(), "Client extensions", "Client extensions");

 		for (int extNdx = 0; extNdx < (int)clientExtensions.size(); extNdx++)
 			m_testCtx.getLog() << TestLog::Message << clientExtensions[extNdx] << TestLog::EndMessage;
 	}

 	// Log display extensions
 	{
 		const tcu::ScopedLogSection section(m_testCtx.getLog(), "Display extensions", "Display extensions");

 		for (int extNdx = 0; extNdx < (int)displayExtensions.size(); extNdx++)
 			m_testCtx.getLog() << TestLog::Message << displayExtensions[extNdx] << TestLog::EndMessage;
 	}

 	// Check that sets are disjoint
 	{
 		set<string>			commonExtensionSet;
 		const set<string>	clientExtensionSet(clientExtensions.begin(), clientExtensions.end());
 		const set<string>	displayExtensionSet(displayExtensions.begin(), displayExtensions.end());

 		for (set<string>::const_iterator iter = clientExtensionSet.begin(); iter != clientExtensionSet.end(); ++iter)
 		{
 			if (displayExtensionSet.find(*iter) != displayExtensionSet.end())
 				commonExtensionSet.insert(*iter);
 		}

 		for (set<string>::const_iterator iter = commonExtensionSet.begin(); iter != commonExtensionSet.end(); ++iter)
 			m_testCtx.getLog() << TestLog::Message << "Extension '" << *iter << "' exists in client and display extension sets." << TestLog::EndMessage;

 		if (commonExtensionSet.empty())
 			m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 		else
 		{
 			m_testCtx.getLog() << TestLog::Message << "Extension sets are not disjoint" << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 		}
 	}

 	return STOP;
 }

 } // anonymous

 ClientExtensionTests::ClientExtensionTests (EglTestContext& eglTestCtx)
 	: TestCaseGroup(eglTestCtx, "client_extensions", "Test for EGL_EXT_client_extensions")
 {
 }

 void ClientExtensionTests::init (void)
 {
 	addChild(new BaseTest(m_eglTestCtx));
 	addChild(new DisjointTest(m_eglTestCtx));
 	addChild(new CheckExtensionsTest(m_eglTestCtx));
 }

 } // 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 EGL_EXT_client_extensions tests
	//--------------------------------------------------------------------*/

	#include "teglClientExtensionTests.hpp"

	#include "tcuTestLog.hpp"

	#include "egluUtil.hpp"

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

	#include "deStringUtil.hpp"
	#include "deSTLUtil.hpp"

	#include <vector>
	#include <set>
	#include <string>
	#include <sstream>

	using std::string;
	using std::vector;
	using std::set;

	using tcu::TestLog;

	using namespace eglw;

	namespace deqp
	{
	namespace egl
	{
	namespace
	{

	static const char* const s_displayExtensionList[] =
	{
	"EGL_KHR_config_attribs",
	"EGL_KHR_lock_surface",
	"EGL_KHR_image",
	"EGL_KHR_vg_parent_image",
	"EGL_KHR_gl_texture_2D_image",
	"EGL_KHR_gl_texture_cubemap_image",
	"EGL_KHR_gl_texture_3D_image",
	"EGL_KHR_gl_renderbuffer_image",
	"EGL_KHR_reusable_sync",
	"EGL_KHR_image_base",
	"EGL_KHR_image_pixmap",
	"EGL_IMG_context_priority",
	"EGL_KHR_lock_surface2",
	"EGL_NV_coverage_sample",
	"EGL_NV_depth_nonlinear",
	"EGL_NV_sync",
	"EGL_KHR_fence_sync",
	"EGL_HI_clientpixmap",
	"EGL_HI_colorformats",
	"EGL_MESA_drm_image",
	"EGL_NV_post_sub_buffer",
	"EGL_ANGLE_query_surface_pointer",
	"EGL_ANGLE_surface_d3d_texture_2d_share_handle",
	"EGL_NV_coverage_sample_resolve",
	// "EGL_NV_system_time", \todo [mika] Unclear which one this is
	"EGL_KHR_stream",
	"EGL_KHR_stream_consumer_gltexture",
	"EGL_KHR_stream_producer_eglsurface",
	"EGL_KHR_stream_producer_aldatalocator",
	"EGL_KHR_stream_fifo",
	"EGL_EXT_create_context_robustness",
	"EGL_ANGLE_d3d_share_handle_client_buffer",
	"EGL_KHR_create_context",
	"EGL_KHR_surfaceless_context",
	"EGL_KHR_stream_cross_process_fd",
	"EGL_EXT_multiview_window",
	"EGL_KHR_wait_sync",
	"EGL_NV_post_convert_rounding",
	"EGL_NV_native_query",
	"EGL_NV_3dvision_surface",
	"EGL_ANDROID_framebuffer_target",
	"EGL_ANDROID_blob_cache",
	"EGL_ANDROID_image_native_buffer",
	"EGL_ANDROID_native_fence_sync",
	"EGL_ANDROID_recordable",
	"EGL_EXT_buffer_age",
	"EGL_EXT_image_dma_buf_import",
	"EGL_ARM_pixmap_multisample_discard",
	"EGL_EXT_swap_buffers_with_damage",
	"EGL_NV_stream_sync",
	"EGL_KHR_cl_event",
	"EGL_KHR_get_all_proc_addresses"
	};

	static const char* const s_clientExtensionList[] =
	{
	"EGL_EXT_platform_base",
	"EGL_EXT_client_extensions",
	"EGL_EXT_platform_x11",
	"EGL_KHR_client_get_all_proc_addresses",
	"EGL_MESA_platform_gbm",
	"EGL_EXT_platform_wayland"
	};

	class BaseTest : public TestCase
	{
	public:
	BaseTest (EglTestContext& eglTestCtx);
	IterateResult iterate (void);
	};

	BaseTest::BaseTest (EglTestContext& eglTestCtx)
	: TestCase(eglTestCtx, "base", "Basic tests for EGL_EXT_client_extensions")
	{
	}

	TestCase::IterateResult BaseTest::iterate (void)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	const char* const clientExtesionsStr = egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
	const EGLint eglError = egl.getError();

	if (eglError == EGL_BAD_DISPLAY)
	TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
	else if (eglError != EGL_SUCCESS)
	throw eglu::Error(eglError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);

	TCU_CHECK(clientExtesionsStr);

	{
	bool found = false;
	std::istringstream stream (clientExtesionsStr);
	string extension;

	while (std::getline(stream, extension, ' '))
	{
	if (extension == "EGL_EXT_client_extensions")
	{
	found = true;
	break;
	}
	}

	if (found)
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
	{
	m_testCtx.getLog() << TestLog::Message << "eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) didn't fail, but extension string doesn't contain EGL_EXT_client_extensions" <<TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}
	}

	return STOP;
	}

	class CheckExtensionsTest : public TestCase
	{
	public:
	CheckExtensionsTest (EglTestContext& eglTestCtx);
	IterateResult iterate (void);
	};

	CheckExtensionsTest::CheckExtensionsTest (EglTestContext& eglTestCtx)
	: TestCase(eglTestCtx, "extensions", "Check that returned extensions are client or display extensions")
	{
	}

	TestCase::IterateResult CheckExtensionsTest::iterate (void)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	bool isOk = true;
	const char* const clientExtensionsStr = egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
	const EGLint eglQueryError = egl.getError();

	set<string> knownClientExtensions (s_clientExtensionList, s_clientExtensionList + DE_LENGTH_OF_ARRAY(s_clientExtensionList));
	set<string> knownDisplayExtensions (s_displayExtensionList, s_displayExtensionList + DE_LENGTH_OF_ARRAY(s_displayExtensionList));

	vector<string> displayExtensions;
	vector<string> clientExtensions;

	if (eglQueryError == EGL_BAD_DISPLAY)
	TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
	else if (eglQueryError != EGL_SUCCESS)
	throw eglu::Error(eglQueryError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);

	TCU_CHECK(clientExtensionsStr);

	clientExtensions = de::splitString(clientExtensionsStr, ' ');

	{
	EGLDisplay display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

	displayExtensions = de::splitString(egl.queryString(display, EGL_EXTENSIONS), ' ');

	egl.terminate(display);
	}

	for (int extNdx = 0; extNdx < (int)clientExtensions.size(); extNdx++)
	{
	if (knownDisplayExtensions.find(clientExtensions[extNdx]) != knownDisplayExtensions.end())
	{
	m_testCtx.getLog() << TestLog::Message << "'" << clientExtensions[extNdx] << "' is not client extension" << TestLog::EndMessage;
	isOk = false;
	}
	}

	for (int extNdx = 0; extNdx < (int)displayExtensions.size(); extNdx++)
	{
	if (knownClientExtensions.find(displayExtensions[extNdx]) != knownClientExtensions.end())
	{
	m_testCtx.getLog() << TestLog::Message << "'" << displayExtensions[extNdx] << "' is not display extension" << TestLog::EndMessage;
	isOk = false;
	}
	}

	if (isOk)
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	return STOP;
	}


	class DisjointTest : public TestCase
	{
	public:
	DisjointTest (EglTestContext& eglTestCtx);
	IterateResult iterate (void);
	};

	DisjointTest::DisjointTest (EglTestContext& eglTestCtx)
	: TestCase(eglTestCtx, "disjoint", "Check that client and display extensions are disjoint")
	{
	}

	TestCase::IterateResult DisjointTest::iterate (void)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	const char* const clientExtensionsStr = egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
	const EGLint eglQueryError = egl.getError();

	if (eglQueryError == EGL_BAD_DISPLAY)
	TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
	else if (eglQueryError != EGL_SUCCESS)
	throw eglu::Error(eglQueryError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);

	vector<string> displayExtensions;
	vector<string> clientExtensions;

	clientExtensions = de::splitString(clientExtensionsStr, ' ');

	{
	EGLDisplay display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

	displayExtensions = de::splitString(egl.queryString(display, EGL_EXTENSIONS), ' ');

	egl.terminate(display);
	}

	// Log client extensions
	{
	const tcu::ScopedLogSection section(m_testCtx.getLog(), "Client extensions", "Client extensions");

	for (int extNdx = 0; extNdx < (int)clientExtensions.size(); extNdx++)
	m_testCtx.getLog() << TestLog::Message << clientExtensions[extNdx] << TestLog::EndMessage;
	}

	// Log display extensions
	{
	const tcu::ScopedLogSection section(m_testCtx.getLog(), "Display extensions", "Display extensions");

	for (int extNdx = 0; extNdx < (int)displayExtensions.size(); extNdx++)
	m_testCtx.getLog() << TestLog::Message << displayExtensions[extNdx] << TestLog::EndMessage;
	}

	// Check that sets are disjoint
	{
	set<string> commonExtensionSet;
	const set<string> clientExtensionSet(clientExtensions.begin(), clientExtensions.end());
	const set<string> displayExtensionSet(displayExtensions.begin(), displayExtensions.end());

	for (set<string>::const_iterator iter = clientExtensionSet.begin(); iter != clientExtensionSet.end(); ++iter)
	{
	if (displayExtensionSet.find(*iter) != displayExtensionSet.end())
	commonExtensionSet.insert(*iter);
	}

	for (set<string>::const_iterator iter = commonExtensionSet.begin(); iter != commonExtensionSet.end(); ++iter)
	m_testCtx.getLog() << TestLog::Message << "Extension '" << *iter << "' exists in client and display extension sets." << TestLog::EndMessage;

	if (commonExtensionSet.empty())
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
	{
	m_testCtx.getLog() << TestLog::Message << "Extension sets are not disjoint" << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}
	}

	return STOP;
	}

	} // anonymous

	ClientExtensionTests::ClientExtensionTests (EglTestContext& eglTestCtx)
	: TestCaseGroup(eglTestCtx, "client_extensions", "Test for EGL_EXT_client_extensions")
	{
	}

	void ClientExtensionTests::init (void)
	{
	addChild(new BaseTest(m_eglTestCtx));
	addChild(new DisjointTest(m_eglTestCtx));
	addChild(new CheckExtensionsTest(m_eglTestCtx));
	}

	} // egl
	} // deqp