xref: /external/deqp/modules/egl/teglTestPackage.cpp

/*-------------------------------------------------------------------------
 * 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 Test Package
 *//*--------------------------------------------------------------------*/

#include "teglTestPackage.hpp"

#include "tcuTestLog.hpp"
#include "tcuPlatform.hpp"
#include "tcuCommandLine.hpp"

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

#include "teglInfoTests.hpp"
#include "teglCreateContextTests.hpp"
#include "teglQueryContextTests.hpp"
#include "teglCreateSurfaceTests.hpp"
#include "teglQuerySurfaceTests.hpp"
#include "teglChooseConfigTests.hpp"
#include "teglQueryConfigTests.hpp"
#include "teglColorClearTests.hpp"
#include "teglRenderTests.hpp"
#include "teglImageTests.hpp"
#include "teglGLES2SharingTests.hpp"
#include "teglNegativeApiTests.hpp"
#include "teglSyncTests.hpp"
#include "teglMultiThreadTests.hpp"
#include "teglGetProcAddressTests.hpp"
#include "teglMemoryStressTests.hpp"
#include "teglMakeCurrentPerfTests.hpp"
#include "teglGLES2SharedRenderingPerfTests.hpp"
#include "teglPreservingSwapTests.hpp"
#include "teglClientExtensionTests.hpp"
#include "teglCreateContextExtTests.hpp"
#include "teglSurfacelessContextTests.hpp"
#include "teglSwapBuffersTests.hpp"
#include "teglNativeColorMappingTests.hpp"
#include "teglNativeCoordMappingTests.hpp"
#include "teglResizeTests.hpp"

#include <typeinfo>

using std::vector;

namespace deqp
{
namespace egl
{

class StressTests : public TestCaseGroup
{
public:
	StressTests (EglTestContext& eglTestCtx)
		: TestCaseGroup(eglTestCtx, "stress", "EGL stress tests")
	{
	}

	void init (void)
	{
		addChild(new MemoryStressTests(m_eglTestCtx));
	}
};

class PerformanceTests : public TestCaseGroup
{
public:
	PerformanceTests (EglTestContext& eglTestCtx)
		: TestCaseGroup(eglTestCtx, "performance", "EGL performance tests")
	{
	}

	void init (void)
	{
		addChild(new MakeCurrentPerfTests			(m_eglTestCtx));
		addChild(new GLES2SharedRenderingPerfTests	(m_eglTestCtx));
	}
};

class FunctionalTests : public TestCaseGroup
{
public:
	FunctionalTests (EglTestContext& eglTestCtx)
		: TestCaseGroup(eglTestCtx, "functional", "EGL functional tests")
	{
	}

	void init (void)
	{
		addChild(new CreateContextTests			(m_eglTestCtx));
		addChild(new QueryContextTests			(m_eglTestCtx));
		addChild(new CreateSurfaceTests			(m_eglTestCtx));
		addChild(new QuerySurfaceTests			(m_eglTestCtx));
		addChild(new QueryConfigTests			(m_eglTestCtx));
		addChild(new ChooseConfigTests			(m_eglTestCtx));
		addChild(new ColorClearTests			(m_eglTestCtx));
		addChild(new RenderTests				(m_eglTestCtx));
		addChild(new ImageTests					(m_eglTestCtx));
		addChild(new SharingTests				(m_eglTestCtx));
		addChild(new NegativeApiTests			(m_eglTestCtx));
		addChild(new FenceSyncTests				(m_eglTestCtx));
		addChild(new MultiThreadedTests			(m_eglTestCtx));
		addChild(new GetProcAddressTests		(m_eglTestCtx));
		addChild(new PreservingSwapTests		(m_eglTestCtx));
		addChild(new ClientExtensionTests		(m_eglTestCtx));
		addChild(new CreateContextExtTests		(m_eglTestCtx));
		addChild(new SurfacelessContextTests	(m_eglTestCtx));
		addChild(new SwapBuffersTests			(m_eglTestCtx));
		addChild(new NativeColorMappingTests	(m_eglTestCtx));
		addChild(new NativeCoordMappingTests	(m_eglTestCtx));
		addChild(new ReusableSyncTests			(m_eglTestCtx));
		addChild(new ResizeTests				(m_eglTestCtx));
	}
};

TestCaseWrapper::TestCaseWrapper (EglTestContext& eglTestCtx)
	: tcu::TestCaseWrapper	(eglTestCtx.getTestContext())
	, m_eglTestCtx			(eglTestCtx)
{
}

TestCaseWrapper::~TestCaseWrapper (void)
{
}

bool TestCaseWrapper::initTestCase (tcu::TestCase* testCase)
{
	tcu::TestLog& log = m_eglTestCtx.getTestContext().getLog();

	// Create display
	try
	{
		m_eglTestCtx.createDefaultDisplay();
	}
	catch (const std::exception& e)
	{
		log << e;
		m_eglTestCtx.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Failed to initialize EGL for default display");
		return false;
	}

	return tcu::TestCaseWrapper::initTestCase(testCase);
}

bool TestCaseWrapper::deinitTestCase (tcu::TestCase* testCase)
{
	tcu::TestLog& log = m_eglTestCtx.getTestContext().getLog();

	bool deinitOk = tcu::TestCaseWrapper::deinitTestCase(testCase);

	// Destroy display
	try
	{
		TCU_CHECK_EGL_CALL(eglMakeCurrent(m_eglTestCtx.getDisplay().getEGLDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
		m_eglTestCtx.destroyDefaultDisplay();
	}
	catch (const std::exception& e)
	{
		log << e;
		log << tcu::TestLog::Message << "Error in EGL deinit, test program will teminate." << tcu::TestLog::EndMessage;
		return false;
	}

	return deinitOk;
}

tcu::TestNode::IterateResult TestCaseWrapper::iterateTestCase (tcu::TestCase* testCase)
{
	return tcu::TestCaseWrapper::iterateTestCase(testCase);
}

PackageContext::PackageContext (tcu::TestContext& testCtx)
	: m_eglTestCtx	(DE_NULL)
	, m_caseWrapper	(DE_NULL)
{
	const eglu::NativeDisplayFactoryRegistry&	dpyFactoryRegistry	= testCtx.getPlatform().getEGLPlatform().getNativeDisplayFactoryRegistry();
	const char* const							displayFactoryName	= testCtx.getCommandLine().getEGLDisplayType();
	const char* const							windowFactoryName	= testCtx.getCommandLine().getEGLWindowType();
	const char* const							pixmapFactoryName	= testCtx.getCommandLine().getEGLPixmapType();

	const eglu::NativeDisplayFactory*			displayFactory		= DE_NULL;
	const eglu::NativeWindowFactory*			windowFactory		= DE_NULL;
	const eglu::NativePixmapFactory*			pixmapFactory		= DE_NULL;

	if (dpyFactoryRegistry.empty())
	{
		tcu::print("ERROR: Platform doesn't support any EGL native display types!\n");
		throw tcu::NotSupportedError("Platform doesn't have EGL any native display factories", DE_NULL, __FILE__, __LINE__);
	}

	if (!displayFactoryName)
		displayFactory = dpyFactoryRegistry.getDefaultFactory();
	else
	{
		displayFactory = dpyFactoryRegistry.getFactoryByName(displayFactoryName);

		if (!displayFactory)
		{
			tcu::print("ERROR: Unknown/unsupported EGL native display type '%s'\n", displayFactoryName);
			tcu::print("Supported EGL native display types:\n");

			for (int factoryNdx = 0; factoryNdx < (int)dpyFactoryRegistry.getFactoryCount(); factoryNdx++)
			{
				const char* name = dpyFactoryRegistry.getFactoryByIndex(factoryNdx)->getName();
				const char* desc = dpyFactoryRegistry.getFactoryByIndex(factoryNdx)->getDescription();

				tcu::print("  %s: %s\n", name, desc);
			}

			throw tcu::NotSupportedError(("Unknown EGL native display type '" + std::string(displayFactoryName) + "'.").c_str(), DE_NULL, __FILE__, __LINE__);
		}
	}

	tcu::print("Using EGL native display type '%s'\n", displayFactory->getName());

	if (!displayFactory->getNativeWindowRegistry().empty())
	{
		windowFactory = windowFactoryName ? displayFactory->getNativeWindowRegistry().getFactoryByName(windowFactoryName)
										  : displayFactory->getNativeWindowRegistry().getDefaultFactory();

		if (!windowFactory)
		{
			DE_ASSERT(windowFactoryName);
			tcu::print("ERROR: Unknown/unsupported EGL native window type '%s'\n", windowFactoryName);
			tcu::print("Supported EGL native window types for native display '%s':\n", displayFactory->getName());

			for (int factoryNdx = 0; factoryNdx < (int)displayFactory->getNativeWindowRegistry().getFactoryCount(); factoryNdx++)
			{
				const char* name = displayFactory->getNativeWindowRegistry().getFactoryByIndex(factoryNdx)->getName();
				const char* desc = displayFactory->getNativeWindowRegistry().getFactoryByIndex(factoryNdx)->getDescription();

				tcu::print("  %s: %s\n", name, desc);
			}

			throw tcu::NotSupportedError(("Unknown EGL native window type '" + std::string(windowFactoryName) + "'").c_str(), DE_NULL, __FILE__, __LINE__);
		}
	}
	else
		tcu::print("Warning: EGL native display doesn't have any native window types.\n");

	if (!displayFactory->getNativePixmapRegistry().empty())
	{
		pixmapFactory = pixmapFactoryName ? displayFactory->getNativePixmapRegistry().getFactoryByName(pixmapFactoryName)
										  : displayFactory->getNativePixmapRegistry().getDefaultFactory();

		if (!pixmapFactory)
		{
			DE_ASSERT(pixmapFactoryName);
			tcu::print("ERROR: Unknown/unsupported EGL native pixmap type '%s'\n", pixmapFactoryName);
			tcu::print("Supported EGL native pixmap types for native display '%s':\n", displayFactory->getName());

			for (int factoryNdx = 0; factoryNdx < (int)displayFactory->getNativePixmapRegistry().getFactoryCount(); factoryNdx++)
			{
				const char* name = displayFactory->getNativePixmapRegistry().getFactoryByIndex(factoryNdx)->getName();
				const char* desc = displayFactory->getNativePixmapRegistry().getFactoryByIndex(factoryNdx)->getDescription();

				tcu::print("  %s: %s\n", name, desc);
			}

			throw tcu::NotSupportedError(("Unknown EGL native pixmap type '" + std::string(pixmapFactoryName) + "'").c_str(), DE_NULL, __FILE__, __LINE__);
		}
	}
	else
		tcu::print("Warning: EGL native display doesn't have any native pixmap types.\n");

	if (windowFactory)
		tcu::print("Using EGL native window type '%s'\n", windowFactory->getName());
	if (pixmapFactory)
		tcu::print("Using EGL native pixmap type '%s'\n", pixmapFactory->getName());

	try
	{
		m_eglTestCtx	= new EglTestContext(testCtx, *displayFactory, windowFactory, pixmapFactory);
		m_caseWrapper	= new TestCaseWrapper(*m_eglTestCtx);
	}
	catch (...)
	{
		delete m_caseWrapper;
		delete m_eglTestCtx;

		throw;
	}
}

PackageContext::~PackageContext (void)
{
	delete m_caseWrapper;
	delete m_eglTestCtx;
}

TestPackage::TestPackage (tcu::TestContext& testCtx)
	: tcu::TestPackage	(testCtx, "dEQP-EGL", "dEQP EGL Tests")
	, m_packageCtx		(DE_NULL)
	, m_archive			(testCtx.getRootArchive(), "egl/")
{
}

TestPackage::~TestPackage (void)
{
	// Destroy children first since destructors may access context.
	TestNode::deinit();
	delete m_packageCtx;
}

void TestPackage::init (void)
{
	DE_ASSERT(!m_packageCtx);
	m_packageCtx = new PackageContext(m_testCtx);

	try
	{
		addChild(new InfoTests				(m_packageCtx->getEglTestContext()));
		addChild(new FunctionalTests		(m_packageCtx->getEglTestContext()));
		addChild(new PerformanceTests		(m_packageCtx->getEglTestContext()));
		addChild(new StressTests			(m_packageCtx->getEglTestContext()));
	}
	catch (...)
	{
		delete m_packageCtx;
		m_packageCtx = DE_NULL;

		throw;
	}
}

void TestPackage::deinit (void)
{
	tcu::TestNode::deinit();
	delete m_packageCtx;
	m_packageCtx = DE_NULL;
}

} // egl
} // deqp