/*-------------------------------------------------------------------------
 * 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 Multi threaded EGL tests
 *//*--------------------------------------------------------------------*/
#include "teglMultiThreadTests.hpp"

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

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

#include "deRandom.hpp"

#include "deThread.hpp"
#include "deMutex.hpp"
#include "deSemaphore.hpp"

#include "deAtomic.h"
#include "deClock.h"

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

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

using std::vector;
using std::string;
using std::pair;
using std::set;
using std::ostringstream;

using namespace eglw;

namespace deqp
{
namespace egl
{

class ThreadLog
{
public:
	class BeginMessageToken	{};
	class EndMessageToken	{};

	struct Message
	{
					Message	(deUint64 timeUs_, const char* msg_) : timeUs(timeUs_), msg(msg_) {}

		deUint64	timeUs;
		string		msg;
	};

								ThreadLog	(void)						{ m_messages.reserve(100); }

	ThreadLog&					operator<<	(const BeginMessageToken&)	{ return *this; }
	ThreadLog&					operator<<	(const EndMessageToken&);

	template<class T>
	ThreadLog&					operator<<	(const T& t)				{ m_message << t; return *this; }
	const vector<Message>&		getMessages (void) const				{ return m_messages; }

	static BeginMessageToken	BeginMessage;
	static EndMessageToken		EndMessage;

private:
	ostringstream		m_message;
	vector<Message>		m_messages;
};

ThreadLog& ThreadLog::operator<< (const EndMessageToken&)
{
	m_messages.push_back(Message(deGetMicroseconds(), m_message.str().c_str()));
	m_message.str("");
	return *this;
}

ThreadLog::BeginMessageToken	ThreadLog::BeginMessage;
ThreadLog::EndMessageToken		ThreadLog::EndMessage;

class MultiThreadedTest;

class TestThread : public de::Thread
{
public:
	enum ThreadStatus
	{
		THREADSTATUS_NOT_STARTED = 0,
		THREADSTATUS_RUNNING,
		THREADSTATUS_READY,

		THREADSTATUS_NOT_SUPPORTED,
		THREADSTATUS_ERROR
	};

					TestThread	(MultiThreadedTest& test, int id);
	void			run			(void);

	ThreadStatus	getStatus	(void) const	{ return m_status; }
	ThreadLog&		getLog		(void)			{ return m_log; }

	int				getId		(void) const	{ return m_id; }

	void			setStatus	(ThreadStatus status)	{ m_status = status; }

	const Library&	getLibrary	(void) const;

	// Test has stopped
	class TestStop {};


private:
	MultiThreadedTest&	m_test;
	const int			m_id;
	ThreadStatus		m_status;
	ThreadLog			m_log;
};

class MultiThreadedTest : public TestCase
{
public:
							MultiThreadedTest	(EglTestContext& eglTestCtx, const char* name, const char* description, int threadCount, deUint64 timeoutUs);
	virtual					~MultiThreadedTest	(void);

	void					init				(void);
	void					deinit				(void);

	virtual bool			runThread			(TestThread& thread) = 0;
	virtual IterateResult	iterate				(void);
	bool					execTest			(TestThread& thread);

	const Library&			getLibrary			(void) const { return m_eglTestCtx.getLibrary(); }

protected:
	void					barrier				(TestThread& thread);

private:
	int						m_threadCount;
	bool					m_initialized;
	deUint64				m_startTimeUs;
	const deUint64			m_timeoutUs;
	vector<TestThread*>		m_threads;

	volatile deInt32		m_barrierWaiters;
	de::Semaphore			m_barrierSemaphore1;
	de::Semaphore			m_barrierSemaphore2;

protected:
	EGLDisplay				m_display;
};

inline const Library& TestThread::getLibrary (void) const
{
	return m_test.getLibrary();
}

TestThread::TestThread (MultiThreadedTest& test, int id)
	: m_test	(test)
	, m_id		(id)
	, m_status	(THREADSTATUS_NOT_STARTED)
{
}

void TestThread::run (void)
{
	m_status = THREADSTATUS_RUNNING;

	try
	{
		if (m_test.execTest(*this))
			m_status = THREADSTATUS_READY;
		else
			m_status = THREADSTATUS_ERROR;
	}
	catch (const TestThread::TestStop&)
	{
		getLog() << ThreadLog::BeginMessage << "Thread stopped" << ThreadLog::EndMessage;
	}
	catch (const tcu::NotSupportedError& e)
	{
		getLog() << ThreadLog::BeginMessage << "Not supported: '" << e.what() << "'" << ThreadLog::EndMessage;
	}
	catch (const std::exception& e)
	{
		getLog() << ThreadLog::BeginMessage << "Got exception: '" << e.what() << "'" << ThreadLog::EndMessage;
	}
	catch (...)
	{
		getLog() << ThreadLog::BeginMessage << "Unknown exception" << ThreadLog::EndMessage;
	}
}

bool MultiThreadedTest::execTest (TestThread& thread)
{
	bool isOk = false;

	try
	{
		isOk = runThread(thread);
	}
	catch (const TestThread::TestStop&)
	{
		// Thread exited due to error in other thread
		throw;
	}
	catch (const tcu::NotSupportedError&)
	{
		// Set status of each thread
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
			m_threads[threadNdx]->setStatus(TestThread::THREADSTATUS_NOT_SUPPORTED);

		// Release barriers
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
		{
			m_barrierSemaphore1.increment();
			m_barrierSemaphore2.increment();
		}

		throw;
	}
	catch(...)
	{
		// Set status of each thread
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
			m_threads[threadNdx]->setStatus(TestThread::THREADSTATUS_ERROR);

		// Release barriers
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
		{
			m_barrierSemaphore1.increment();
			m_barrierSemaphore2.increment();
		}

		throw;
	}

	return isOk;
}

MultiThreadedTest::MultiThreadedTest (EglTestContext& eglTestCtx, const char* name, const char* description, int threadCount, deUint64 timeoutUs)
	: TestCase				(eglTestCtx, name, description)
	, m_threadCount			(threadCount)
	, m_initialized			(false)
	, m_startTimeUs			(0)
	, m_timeoutUs			(timeoutUs)

	, m_barrierWaiters		(0)
	, m_barrierSemaphore1	(0, 0)
	, m_barrierSemaphore2	(1, 0)

	, m_display				(EGL_NO_DISPLAY)
{
}

MultiThreadedTest::~MultiThreadedTest (void)
{
	for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
		delete m_threads[threadNdx];
	m_threads.clear();
}

void MultiThreadedTest::init (void)
{
	m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
}

void MultiThreadedTest::deinit (void)
{
	if (m_display != EGL_NO_DISPLAY)
	{
		m_eglTestCtx.getLibrary().terminate(m_display);
		m_display = EGL_NO_DISPLAY;
	}
}

void MultiThreadedTest::barrier (TestThread& thread)
{
	{
		const deInt32 waiters = deAtomicIncrement32(&m_barrierWaiters);

		if (waiters == m_threadCount)
		{
			m_barrierSemaphore2.decrement();
			m_barrierSemaphore1.increment();
		}
		else
		{
			m_barrierSemaphore1.decrement();
			m_barrierSemaphore1.increment();
		}
	}

	{
		const deInt32 waiters = deAtomicDecrement32(&m_barrierWaiters);

		if (waiters == 0)
		{
			m_barrierSemaphore1.decrement();
			m_barrierSemaphore2.increment();
		}
		else
		{
			m_barrierSemaphore2.decrement();
			m_barrierSemaphore2.increment();
		}
	}

	// Barrier was released due an error in other thread
	if (thread.getStatus() != TestThread::THREADSTATUS_RUNNING)
		throw TestThread::TestStop();
}

TestCase::IterateResult MultiThreadedTest::iterate (void)
{
	if (!m_initialized)
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "Thread timeout limit: " << m_timeoutUs << "us" << tcu::TestLog::EndMessage;

		// Create threads
		m_threads.reserve(m_threadCount);

		for (int threadNdx = 0; threadNdx < m_threadCount; threadNdx++)
			m_threads.push_back(new TestThread(*this, threadNdx));

		m_startTimeUs = deGetMicroseconds();

		// Run threads
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
			m_threads[threadNdx]->start();

		m_initialized = true;
	}

	int readyCount = 0;
	for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
	{
		if (m_threads[threadNdx]->getStatus() != TestThread::THREADSTATUS_RUNNING)
			readyCount++;
	}

	if (readyCount == m_threadCount)
	{
		// Join threads
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
			m_threads[threadNdx]->join();

		bool isOk			= true;
		bool notSupported	= false;

		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
		{
			if (m_threads[threadNdx]->getStatus() == TestThread::THREADSTATUS_ERROR)
				isOk = false;

			if (m_threads[threadNdx]->getStatus() == TestThread::THREADSTATUS_NOT_SUPPORTED)
				notSupported = true;
		}

		// Get logs
		{
			vector<int> messageNdx;

			messageNdx.resize(m_threads.size(), 0);

			while (true)
			{
				int			nextThreadNdx		= -1;
				deUint64	nextThreadTimeUs	= 0;

				for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
				{
					if (messageNdx[threadNdx] >= (int)m_threads[threadNdx]->getLog().getMessages().size())
						continue;

					if (nextThreadNdx == -1 || nextThreadTimeUs > m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs)
					{
						nextThreadNdx		= threadNdx;
						nextThreadTimeUs	= m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs;
					}
				}

				if (nextThreadNdx == -1)
					break;

				m_testCtx.getLog() << tcu::TestLog::Message << "[" << (nextThreadTimeUs - m_startTimeUs) << "] (" << nextThreadNdx << ") " << m_threads[nextThreadNdx]->getLog().getMessages()[messageNdx[nextThreadNdx]].msg << tcu::TestLog::EndMessage;

				messageNdx[nextThreadNdx]++;
			}
		}

		// Destroy threads
		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
			delete m_threads[threadNdx];

		m_threads.clear();

		// Set result
		if (isOk)
		{
			if (notSupported)
				m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");
			else
				m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
		}
		else
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");

		return STOP;
	}
	else
	{
		// Check for timeout
		const deUint64 currentTimeUs = deGetMicroseconds();

		if (currentTimeUs - m_startTimeUs > m_timeoutUs)
		{
			// Get logs
			{
				vector<int> messageNdx;

				messageNdx.resize(m_threads.size(), 0);

				while (true)
				{
					int			nextThreadNdx		= -1;
					deUint64	nextThreadTimeUs	= 0;

					for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
					{
						if (messageNdx[threadNdx] >= (int)m_threads[threadNdx]->getLog().getMessages().size())
							continue;

						if (nextThreadNdx == -1 || nextThreadTimeUs > m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs)
						{
							nextThreadNdx		= threadNdx;
							nextThreadTimeUs	= m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs;
						}
					}

					if (nextThreadNdx == -1)
						break;

					m_testCtx.getLog() << tcu::TestLog::Message << "[" << (nextThreadTimeUs - m_startTimeUs) << "] (" << nextThreadNdx << ") " << m_threads[nextThreadNdx]->getLog().getMessages()[messageNdx[nextThreadNdx]].msg << tcu::TestLog::EndMessage;

					messageNdx[nextThreadNdx]++;
				}
			}

			m_testCtx.getLog() << tcu::TestLog::Message << "[" << (currentTimeUs - m_startTimeUs) << "] (-) Timeout, Limit: " << m_timeoutUs << "us" << tcu::TestLog::EndMessage;
			m_testCtx.getLog() << tcu::TestLog::Message << "[" << (currentTimeUs - m_startTimeUs) << "] (-) Trying to perform resource cleanup..." << tcu::TestLog::EndMessage;

			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
			return STOP;
		}

		// Sleep
		deSleep(10);
	}

	return CONTINUE;
}

namespace
{

const char* configAttributeToString (EGLint e)
{
	switch (e)
	{
		case EGL_BUFFER_SIZE:				return "EGL_BUFFER_SIZE";
		case EGL_RED_SIZE:					return "EGL_RED_SIZE";
		case EGL_GREEN_SIZE:				return "EGL_GREEN_SIZE";
		case EGL_BLUE_SIZE:					return "EGL_BLUE_SIZE";
		case EGL_LUMINANCE_SIZE:			return "EGL_LUMINANCE_SIZE";
		case EGL_ALPHA_SIZE:				return "EGL_ALPHA_SIZE";
		case EGL_ALPHA_MASK_SIZE:			return "EGL_ALPHA_MASK_SIZE";
		case EGL_BIND_TO_TEXTURE_RGB:		return "EGL_BIND_TO_TEXTURE_RGB";
		case EGL_BIND_TO_TEXTURE_RGBA:		return "EGL_BIND_TO_TEXTURE_RGBA";
		case EGL_COLOR_BUFFER_TYPE:			return "EGL_COLOR_BUFFER_TYPE";
		case EGL_CONFIG_CAVEAT:				return "EGL_CONFIG_CAVEAT";
		case EGL_CONFIG_ID:					return "EGL_CONFIG_ID";
		case EGL_CONFORMANT:				return "EGL_CONFORMANT";
		case EGL_DEPTH_SIZE:				return "EGL_DEPTH_SIZE";
		case EGL_LEVEL:						return "EGL_LEVEL";
		case EGL_MAX_PBUFFER_WIDTH:			return "EGL_MAX_PBUFFER_WIDTH";
		case EGL_MAX_PBUFFER_HEIGHT:		return "EGL_MAX_PBUFFER_HEIGHT";
		case EGL_MAX_PBUFFER_PIXELS:		return "EGL_MAX_PBUFFER_PIXELS";
		case EGL_MAX_SWAP_INTERVAL:			return "EGL_MAX_SWAP_INTERVAL";
		case EGL_MIN_SWAP_INTERVAL:			return "EGL_MIN_SWAP_INTERVAL";
		case EGL_NATIVE_RENDERABLE:			return "EGL_NATIVE_RENDERABLE";
		case EGL_NATIVE_VISUAL_ID:			return "EGL_NATIVE_VISUAL_ID";
		case EGL_NATIVE_VISUAL_TYPE:		return "EGL_NATIVE_VISUAL_TYPE";
		case EGL_RENDERABLE_TYPE:			return "EGL_RENDERABLE_TYPE";
		case EGL_SAMPLE_BUFFERS:			return "EGL_SAMPLE_BUFFERS";
		case EGL_SAMPLES:					return "EGL_SAMPLES";
		case EGL_STENCIL_SIZE:				return "EGL_STENCIL_SIZE";
		case EGL_SURFACE_TYPE:				return "EGL_SURFACE_TYPE";
		case EGL_TRANSPARENT_TYPE:			return "EGL_TRANSPARENT_TYPE";
		case EGL_TRANSPARENT_RED_VALUE:		return "EGL_TRANSPARENT_RED_VALUE";
		case EGL_TRANSPARENT_GREEN_VALUE:	return "EGL_TRANSPARENT_GREEN_VALUE";
		case EGL_TRANSPARENT_BLUE_VALUE:	return "EGL_TRANSPARENT_BLUE_VALUE";
		default:							return "<Unknown>";
	}
}

} // anonymous

class MultiThreadedConfigTest : public MultiThreadedTest
{
public:
				MultiThreadedConfigTest		(EglTestContext& context, const char* name, const char* description, int getConfigs, int chooseConfigs, int query);
	bool		runThread					(TestThread& thread);

private:
	const int	m_getConfigs;
	const int	m_chooseConfigs;
	const int	m_query;
};

MultiThreadedConfigTest::MultiThreadedConfigTest (EglTestContext& context, const char* name, const char* description, int getConfigs, int chooseConfigs, int query)
	: MultiThreadedTest (context, name, description, 2, 20000000/*us = 20s*/) // \todo [mika] Set timeout to something relevant to frameworks timeout?
	, m_getConfigs		(getConfigs)
	, m_chooseConfigs	(chooseConfigs)
	, m_query			(query)
{
}

bool MultiThreadedConfigTest::runThread (TestThread& thread)
{
	const Library&		egl		= getLibrary();
	de::Random			rnd		(deInt32Hash(thread.getId() + 10435));
	vector<EGLConfig>	configs;

	barrier(thread);

	for (int getConfigsNdx = 0; getConfigsNdx < m_getConfigs; getConfigsNdx++)
	{
		EGLint configCount;

		// Get number of configs
		{
			EGLBoolean result;

			result = egl.getConfigs(m_display, NULL, 0, &configCount);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglGetConfigs(" << m_display << ", NULL, 0, " << configCount << ")" <<  ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglGetConfigs()");

			if (!result)
				return false;
		}

		configs.resize(configs.size() + configCount);

		// Get configs
		if (configCount != 0)
		{
			EGLBoolean result;

			result = egl.getConfigs(m_display, &(configs[configs.size() - configCount]), configCount, &configCount);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglGetConfigs(" << m_display << ", &configs' " << configCount << ", " << configCount << ")" <<  ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglGetConfigs()");

			if (!result)
				return false;
		}

		// Pop configs to stop config list growing
		if (configs.size() > 40)
		{
			configs.erase(configs.begin() + 40, configs.end());
		}
		else
		{
			const int popCount = rnd.getInt(0, (int)(configs.size()-2));

			configs.erase(configs.begin() + (configs.size() - popCount), configs.end());
		}
	}

	for (int chooseConfigsNdx = 0; chooseConfigsNdx < m_chooseConfigs; chooseConfigsNdx++)
	{
		EGLint configCount;

		static const EGLint attribList[] = {
			EGL_NONE
		};

		// Get number of configs
		{
			EGLBoolean result;

			result = egl.chooseConfig(m_display, attribList, NULL, 0, &configCount);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglChooseConfig(" << m_display << ", { EGL_NONE }, NULL, 0, " << configCount << ")" <<  ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglChooseConfig()");

			if (!result)
				return false;
		}

		configs.resize(configs.size() + configCount);

		// Get configs
		if (configCount != 0)
		{
			EGLBoolean result;

			result = egl.chooseConfig(m_display, attribList, &(configs[configs.size() - configCount]), configCount, &configCount);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglChooseConfig(" << m_display << ", { EGL_NONE }, &configs, " << configCount << ", " << configCount << ")" <<  ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglChooseConfig()");

			if (!result)
				return false;
		}

		// Pop configs to stop config list growing
		if (configs.size() > 40)
		{
			configs.erase(configs.begin() + 40, configs.end());
		}
		else
		{
			const int popCount = rnd.getInt(0, (int)(configs.size()-2));

			configs.erase(configs.begin() + (configs.size() - popCount), configs.end());
		}
	}

	{
		// Perform queries on configs
		static const EGLint attributes[] =
		{
			EGL_BUFFER_SIZE,
			EGL_RED_SIZE,
			EGL_GREEN_SIZE,
			EGL_BLUE_SIZE,
			EGL_LUMINANCE_SIZE,
			EGL_ALPHA_SIZE,
			EGL_ALPHA_MASK_SIZE,
			EGL_BIND_TO_TEXTURE_RGB,
			EGL_BIND_TO_TEXTURE_RGBA,
			EGL_COLOR_BUFFER_TYPE,
			EGL_CONFIG_CAVEAT,
			EGL_CONFIG_ID,
			EGL_CONFORMANT,
			EGL_DEPTH_SIZE,
			EGL_LEVEL,
			EGL_MAX_PBUFFER_WIDTH,
			EGL_MAX_PBUFFER_HEIGHT,
			EGL_MAX_PBUFFER_PIXELS,
			EGL_MAX_SWAP_INTERVAL,
			EGL_MIN_SWAP_INTERVAL,
			EGL_NATIVE_RENDERABLE,
			EGL_NATIVE_VISUAL_ID,
			EGL_NATIVE_VISUAL_TYPE,
			EGL_RENDERABLE_TYPE,
			EGL_SAMPLE_BUFFERS,
			EGL_SAMPLES,
			EGL_STENCIL_SIZE,
			EGL_SURFACE_TYPE,
			EGL_TRANSPARENT_TYPE,
			EGL_TRANSPARENT_RED_VALUE,
			EGL_TRANSPARENT_GREEN_VALUE,
			EGL_TRANSPARENT_BLUE_VALUE
		};

		for (int queryNdx = 0; queryNdx < m_query; queryNdx++)
		{
			const EGLint	attribute	= attributes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(attributes)-1)];
			EGLConfig		config		= configs[rnd.getInt(0, (int)(configs.size()-1))];
			EGLint			value;
			EGLBoolean		result;

			result = egl.getConfigAttrib(m_display, config, attribute, &value);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglGetConfigAttrib(" << m_display << ", " << config << ", " << configAttributeToString(attribute) << ", " << value << ")" <<  ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglGetConfigAttrib()");

			if (!result)
				return false;
		}
	}

	return true;
}

class MultiThreadedObjectTest : public MultiThreadedTest
{
public:
	enum Type
	{
		TYPE_PBUFFER			= (1<<0),
		TYPE_PIXMAP				= (1<<1),
		TYPE_WINDOW				= (1<<2),
		TYPE_SINGLE_WINDOW		= (1<<3),
		TYPE_CONTEXT			= (1<<4)
	};

					MultiThreadedObjectTest			(EglTestContext& context, const char* name, const char* description, deUint32 types);
					~MultiThreadedObjectTest		(void);

	virtual void	deinit							(void);

	bool			runThread						(TestThread& thread);

	void			createDestroyObjects			(TestThread& thread, int count);
	void			pushObjectsToShared				(TestThread& thread);
	void			pullObjectsFromShared			(TestThread& thread, int pbufferCount, int pixmapCount, int windowCount, int contextCount);
	void			querySetSharedObjects			(TestThread& thread, int count);
	void			destroyObjects					(TestThread& thread);

private:
	EGLConfig			m_config;
	de::Random			m_rnd0;
	de::Random			m_rnd1;
	Type				m_types;

	volatile deUint32	m_hasWindow;

	vector<pair<eglu::NativePixmap*, EGLSurface> >	m_sharedNativePixmaps;
	vector<pair<eglu::NativePixmap*, EGLSurface> >	m_nativePixmaps0;
	vector<pair<eglu::NativePixmap*, EGLSurface> >	m_nativePixmaps1;

	vector<pair<eglu::NativeWindow*, EGLSurface> >	m_sharedNativeWindows;
	vector<pair<eglu::NativeWindow*, EGLSurface> >	m_nativeWindows0;
	vector<pair<eglu::NativeWindow*, EGLSurface> >	m_nativeWindows1;

	vector<EGLSurface>								m_sharedPbuffers;
	vector<EGLSurface>								m_pbuffers0;
	vector<EGLSurface>								m_pbuffers1;

	vector<EGLContext>								m_sharedContexts;
	vector<EGLContext>								m_contexts0;
	vector<EGLContext>								m_contexts1;
};

MultiThreadedObjectTest::MultiThreadedObjectTest (EglTestContext& context, const char* name, const char* description, deUint32 type)
	: MultiThreadedTest (context, name, description, 2, 20000000/*us = 20s*/) // \todo [mika] Set timeout to something relevant to frameworks timeout?
	, m_config			(DE_NULL)
	, m_rnd0			(58204327)
	, m_rnd1			(230983)
	, m_types			((Type)type)
	, m_hasWindow		(0)
{
}

MultiThreadedObjectTest::~MultiThreadedObjectTest (void)
{
	deinit();
}

void MultiThreadedObjectTest::deinit (void)
{
	const Library&		egl		= getLibrary();

	// Clear pbuffers
	for (int pbufferNdx = 0; pbufferNdx < (int)m_pbuffers0.size(); pbufferNdx++)
	{
		if (m_pbuffers0[pbufferNdx] != EGL_NO_SURFACE)
		{
			egl.destroySurface(m_display, m_pbuffers0[pbufferNdx]);
			EGLU_CHECK_MSG(egl, "eglDestroySurface()");
			m_pbuffers0[pbufferNdx] = EGL_NO_SURFACE;
		}
	}
	m_pbuffers0.clear();

	for (int pbufferNdx = 0; pbufferNdx < (int)m_pbuffers1.size(); pbufferNdx++)
	{
		if (m_pbuffers1[pbufferNdx] != EGL_NO_SURFACE)
		{
			egl.destroySurface(m_display, m_pbuffers1[pbufferNdx]);
			EGLU_CHECK_MSG(egl, "eglDestroySurface()");
			m_pbuffers1[pbufferNdx] = EGL_NO_SURFACE;
		}
	}
	m_pbuffers1.clear();

	for (int pbufferNdx = 0; pbufferNdx < (int)m_sharedPbuffers.size(); pbufferNdx++)
	{
		if (m_sharedPbuffers[pbufferNdx] != EGL_NO_SURFACE)
		{
			egl.destroySurface(m_display, m_sharedPbuffers[pbufferNdx]);
			EGLU_CHECK_MSG(egl, "eglDestroySurface()");
			m_sharedPbuffers[pbufferNdx] = EGL_NO_SURFACE;
		}
	}
	m_sharedPbuffers.clear();

	for (int contextNdx = 0; contextNdx < (int)m_sharedContexts.size(); contextNdx++)
	{
		if (m_sharedContexts[contextNdx] != EGL_NO_CONTEXT)
		{
			egl.destroyContext(m_display, m_sharedContexts[contextNdx]);
			EGLU_CHECK_MSG(egl, "eglDestroyContext()");
			m_sharedContexts[contextNdx] =  EGL_NO_CONTEXT;
		}
	}
	m_sharedContexts.clear();

	for (int contextNdx = 0; contextNdx < (int)m_contexts0.size(); contextNdx++)
	{
		if (m_contexts0[contextNdx] != EGL_NO_CONTEXT)
		{
			egl.destroyContext(m_display, m_contexts0[contextNdx]);
			EGLU_CHECK_MSG(egl, "eglDestroyContext()");
			m_contexts0[contextNdx] =  EGL_NO_CONTEXT;
		}
	}
	m_contexts0.clear();

	for (int contextNdx = 0; contextNdx < (int)m_contexts1.size(); contextNdx++)
	{
		if (m_contexts1[contextNdx] != EGL_NO_CONTEXT)
		{
			egl.destroyContext(m_display, m_contexts1[contextNdx]);
			EGLU_CHECK_MSG(egl, "eglDestroyContext()");
			m_contexts1[contextNdx] =  EGL_NO_CONTEXT;
		}
	}
	m_contexts1.clear();

	// Clear pixmaps
	for (int pixmapNdx = 0; pixmapNdx < (int)m_nativePixmaps0.size(); pixmapNdx++)
	{
		if (m_nativePixmaps0[pixmapNdx].second != EGL_NO_SURFACE)
			EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativePixmaps0[pixmapNdx].second));

		m_nativePixmaps0[pixmapNdx].second = EGL_NO_SURFACE;
		delete m_nativePixmaps0[pixmapNdx].first;
		m_nativePixmaps0[pixmapNdx].first = NULL;
	}
	m_nativePixmaps0.clear();

	for (int pixmapNdx = 0; pixmapNdx < (int)m_nativePixmaps1.size(); pixmapNdx++)
	{
		if (m_nativePixmaps1[pixmapNdx].second != EGL_NO_SURFACE)
			EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativePixmaps1[pixmapNdx].second));

		m_nativePixmaps1[pixmapNdx].second = EGL_NO_SURFACE;
		delete m_nativePixmaps1[pixmapNdx].first;
		m_nativePixmaps1[pixmapNdx].first = NULL;
	}
	m_nativePixmaps1.clear();

	for (int pixmapNdx = 0; pixmapNdx < (int)m_sharedNativePixmaps.size(); pixmapNdx++)
	{
		if (m_sharedNativePixmaps[pixmapNdx].second != EGL_NO_SURFACE)
			EGLU_CHECK_CALL(egl, destroySurface(m_display, m_sharedNativePixmaps[pixmapNdx].second));

		m_sharedNativePixmaps[pixmapNdx].second = EGL_NO_SURFACE;
		delete m_sharedNativePixmaps[pixmapNdx].first;
		m_sharedNativePixmaps[pixmapNdx].first = NULL;
	}
	m_sharedNativePixmaps.clear();

	// Clear windows
	for (int windowNdx = 0; windowNdx < (int)m_nativeWindows1.size(); windowNdx++)
	{
		if (m_nativeWindows1[windowNdx].second != EGL_NO_SURFACE)
			EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativeWindows1[windowNdx].second));

		m_nativeWindows1[windowNdx].second = EGL_NO_SURFACE;
		delete m_nativeWindows1[windowNdx].first;
		m_nativeWindows1[windowNdx].first = NULL;
	}
	m_nativeWindows1.clear();

	for (int windowNdx = 0; windowNdx < (int)m_nativeWindows0.size(); windowNdx++)
	{
		if (m_nativeWindows0[windowNdx].second != EGL_NO_SURFACE)
			EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativeWindows0[windowNdx].second));

		m_nativeWindows0[windowNdx].second = EGL_NO_SURFACE;
		delete m_nativeWindows0[windowNdx].first;
		m_nativeWindows0[windowNdx].first = NULL;
	}
	m_nativeWindows0.clear();

	for (int windowNdx = 0; windowNdx < (int)m_sharedNativeWindows.size(); windowNdx++)
	{
		if (m_sharedNativeWindows[windowNdx].second != EGL_NO_SURFACE)
			EGLU_CHECK_CALL(egl, destroySurface(m_display, m_sharedNativeWindows[windowNdx].second));

		m_sharedNativeWindows[windowNdx].second = EGL_NO_SURFACE;
		delete m_sharedNativeWindows[windowNdx].first;
		m_sharedNativeWindows[windowNdx].first = NULL;
	}
	m_sharedNativeWindows.clear();

	MultiThreadedTest::deinit();
}

bool MultiThreadedObjectTest::runThread (TestThread& thread)
{
	const Library&		egl		= getLibrary();

	if (thread.getId() == 0)
	{
		EGLint surfaceTypes = 0;

		if ((m_types & TYPE_WINDOW) != 0)
			surfaceTypes |= EGL_WINDOW_BIT;

		if ((m_types & TYPE_PBUFFER) != 0)
			surfaceTypes |= EGL_PBUFFER_BIT;

		if ((m_types & TYPE_PIXMAP) != 0)
			surfaceTypes |= EGL_PIXMAP_BIT;

		EGLint configCount;
		EGLint attribList[] =
		{
			EGL_SURFACE_TYPE, surfaceTypes,
			EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
			EGL_NONE
		};

		EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount));

		if (configCount == 0)
			TCU_THROW(NotSupportedError, "No usable config found");
	}

	barrier(thread);

	// Create / Destroy Objects
	if ((m_types & TYPE_SINGLE_WINDOW) != 0 && (m_types & TYPE_PBUFFER) == 0 && (m_types & TYPE_PIXMAP) == 0 && (m_types & TYPE_CONTEXT) == 0)
	{
		if (thread.getId() == 0)
			createDestroyObjects(thread, 1);
	}
	else
		createDestroyObjects(thread, 100);

	// Push first threads objects to shared
	if (thread.getId() == 0)
		pushObjectsToShared(thread);

	barrier(thread);

	// Push second threads objects to shared
	if (thread.getId() == 1)
		pushObjectsToShared(thread);

	barrier(thread);

	// Make queries from shared surfaces
	querySetSharedObjects(thread, 100);

	barrier(thread);

	// Pull surfaces for first thread from shared surfaces
	if (thread.getId() == 0)
		pullObjectsFromShared(thread, (int)(m_sharedPbuffers.size()/2), (int)(m_sharedNativePixmaps.size()/2), (int)(m_sharedNativeWindows.size()/2), (int)(m_sharedContexts.size()/2));

	barrier(thread);

	// Pull surfaces for second thread from shared surfaces
	if (thread.getId() == 1)
		pullObjectsFromShared(thread, (int)m_sharedPbuffers.size(), (int)m_sharedNativePixmaps.size(), (int)m_sharedNativeWindows.size(), (int)m_sharedContexts.size());

	barrier(thread);

	// Create / Destroy Objects
	if ((m_types & TYPE_SINGLE_WINDOW) == 0)
		createDestroyObjects(thread, 100);

	// Destroy surfaces
	destroyObjects(thread);

	return true;
}

void MultiThreadedObjectTest::createDestroyObjects (TestThread& thread, int count)
{
	const Library&									egl			= getLibrary();
	de::Random&										rnd			= (thread.getId() == 0 ? m_rnd0 : m_rnd1);
	vector<EGLSurface>&								pbuffers	= (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
	vector<pair<eglu::NativeWindow*, EGLSurface> >&	windows		= (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
	vector<pair<eglu::NativePixmap*, EGLSurface> >&	pixmaps		= (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
	vector<EGLContext>&								contexts	= (thread.getId() == 0 ? m_contexts0 : m_contexts1);
	set<Type>										objectTypes;

	if ((m_types & TYPE_PBUFFER) != 0)
		objectTypes.insert(TYPE_PBUFFER);

	if ((m_types & TYPE_PIXMAP) != 0)
		objectTypes.insert(TYPE_PIXMAP);

	if ((m_types & TYPE_WINDOW) != 0)
		objectTypes.insert(TYPE_WINDOW);

	if ((m_types & TYPE_CONTEXT) != 0)
		objectTypes.insert(TYPE_CONTEXT);

	for (int createDestroyNdx = 0; createDestroyNdx < count; createDestroyNdx++)
	{
		bool create;
		Type type;

		if (pbuffers.size() > 5 && ((m_types & TYPE_PBUFFER) != 0))
		{
			create	= false;
			type	= TYPE_PBUFFER;
		}
		else if (windows.size() > 5 && ((m_types & TYPE_WINDOW) != 0))
		{
			create	= false;
			type	= TYPE_WINDOW;
		}
		else if (pixmaps.size() > 5 && ((m_types & TYPE_PIXMAP) != 0))
		{
			create	= false;
			type	= TYPE_PIXMAP;
		}
		else if (contexts.size() > 5 && ((m_types & TYPE_CONTEXT) != 0))
		{
			create	= false;
			type	= TYPE_CONTEXT;
		}
		else if (pbuffers.size() < 3 && ((m_types & TYPE_PBUFFER) != 0))
		{
			create	= true;
			type	= TYPE_PBUFFER;
		}
		else if (pixmaps.size() < 3 && ((m_types & TYPE_PIXMAP) != 0))
		{
			create	= true;
			type	= TYPE_PIXMAP;
		}
		else if (contexts.size() < 3 && ((m_types & TYPE_CONTEXT) != 0))
		{
			create	= true;
			type	= TYPE_CONTEXT;
		}
		else if (windows.size() < 3 && ((m_types & TYPE_WINDOW) != 0) && ((m_types & TYPE_SINGLE_WINDOW) == 0))
		{
			create	= true;
			type	= TYPE_WINDOW;
		}
		else if (windows.empty() && (m_hasWindow == 0) && ((m_types & TYPE_WINDOW) != 0) && ((m_types & TYPE_SINGLE_WINDOW) != 0))
		{
			create	= true;
			type	= TYPE_WINDOW;
		}
		else
		{
			create = rnd.getBool();

			if (!create && windows.empty())
				objectTypes.erase(TYPE_WINDOW);

			type = rnd.choose<Type>(objectTypes.begin(), objectTypes.end());
		}

		if (create)
		{
			switch (type)
			{
				case TYPE_PBUFFER:
				{
					EGLSurface surface;

					const EGLint attributes[] =
					{
						EGL_WIDTH,	64,
						EGL_HEIGHT,	64,

						EGL_NONE
					};

					surface = egl.createPbufferSurface(m_display, m_config, attributes);
					thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreatePbufferSurface(" << m_display << ", " << m_config << ", { EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE })" << ThreadLog::EndMessage;
					EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()");

					pbuffers.push_back(surface);

					break;
				}

				case TYPE_WINDOW:
				{
					const eglu::NativeWindowFactory&	windowFactory	= eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());

					if ((m_types & TYPE_SINGLE_WINDOW) != 0)
					{
						if (deAtomicCompareExchange32(&m_hasWindow, 0, 1) == 0)
						{
							eglu::NativeWindow* window	= DE_NULL;
							EGLSurface			surface = EGL_NO_SURFACE;

							try
							{
								window = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, eglu::WindowParams(64, 64, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
								surface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, m_display, m_config, DE_NULL);

								thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreateWindowSurface()" << ThreadLog::EndMessage;
								windows.push_back(std::make_pair(window, surface));
							}
							catch (const std::exception&)
							{
								if (surface != EGL_NO_SURFACE)
									EGLU_CHECK_CALL(egl, destroySurface(m_display, surface));
								delete window;
								m_hasWindow = 0;
								throw;
							}
						}
						else
						{
							createDestroyNdx--;
						}
					}
					else
					{
						eglu::NativeWindow* window	= DE_NULL;
						EGLSurface			surface = EGL_NO_SURFACE;

						try
						{
							window	= windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, eglu::WindowParams(64, 64, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
							surface	= eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, m_display, m_config, DE_NULL);

							thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreateWindowSurface()" << ThreadLog::EndMessage;
							windows.push_back(std::make_pair(window, surface));
						}
						catch (const std::exception&)
						{
							if (surface != EGL_NO_SURFACE)
								EGLU_CHECK_CALL(egl, destroySurface(m_display, surface));
							delete window;
							throw;
						}
					}
					break;
				}

				case TYPE_PIXMAP:
				{
					const eglu::NativePixmapFactory&	pixmapFactory	= eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
					eglu::NativePixmap*					pixmap			= DE_NULL;
					EGLSurface							surface			= EGL_NO_SURFACE;

					try
					{
						pixmap	= pixmapFactory.createPixmap(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, 64, 64);
						surface	= eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, m_display, m_config, DE_NULL);

						thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreatePixmapSurface()" << ThreadLog::EndMessage;
						pixmaps.push_back(std::make_pair(pixmap, surface));
					}
					catch (const std::exception&)
					{
						if (surface != EGL_NO_SURFACE)
							EGLU_CHECK_CALL(egl, destroySurface(m_display, surface));
						delete pixmap;
						throw;
					}
					break;
				}

				case TYPE_CONTEXT:
				{
					EGLContext context;

					EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
					thread.getLog() << ThreadLog::BeginMessage << "eglBindAPI(EGL_OPENGL_ES_API)" << ThreadLog::EndMessage;

					const EGLint attributes[] =
					{
						EGL_CONTEXT_CLIENT_VERSION, 2,
						EGL_NONE
					};

					context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attributes);
					thread.getLog() << ThreadLog::BeginMessage << context << " = eglCreateContext(" << m_display << ", " << m_config << ", EGL_NO_CONTEXT, { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE })" << ThreadLog::EndMessage;
					EGLU_CHECK_MSG(egl, "eglCreateContext()");
					contexts.push_back(context);
					break;
				}

				default:
					DE_ASSERT(false);
			};
		}
		else
		{
			switch (type)
			{
				case TYPE_PBUFFER:
				{
					const int pbufferNdx = rnd.getInt(0, (int)(pbuffers.size()-1));
					EGLBoolean result;

					result = egl.destroySurface(m_display, pbuffers[pbufferNdx]);
					thread.getLog() << ThreadLog::BeginMessage << result << " = eglDestroySurface(" << m_display << ", " << pbuffers[pbufferNdx] << ")" << ThreadLog::EndMessage;
					EGLU_CHECK_MSG(egl, "eglDestroySurface()");

					pbuffers.erase(pbuffers.begin() + pbufferNdx);

					break;
				}

				case TYPE_WINDOW:
				{
					const int windowNdx = rnd.getInt(0, (int)(windows.size()-1));

					thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << windows[windowNdx].second << ")" << ThreadLog::EndMessage;

					EGLU_CHECK_CALL(egl, destroySurface(m_display, windows[windowNdx].second));
					windows[windowNdx].second = EGL_NO_SURFACE;
					delete windows[windowNdx].first;
					windows[windowNdx].first = DE_NULL;
					windows.erase(windows.begin() + windowNdx);

					if ((m_types & TYPE_SINGLE_WINDOW) != 0)
						m_hasWindow = 0;

					break;
				}

				case TYPE_PIXMAP:
				{
					const int pixmapNdx = rnd.getInt(0, (int)(pixmaps.size()-1));

					thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << pixmaps[pixmapNdx].second << ")" << ThreadLog::EndMessage;
					EGLU_CHECK_CALL(egl, destroySurface(m_display, pixmaps[pixmapNdx].second));
					pixmaps[pixmapNdx].second = EGL_NO_SURFACE;
					delete pixmaps[pixmapNdx].first;
					pixmaps[pixmapNdx].first = DE_NULL;
					pixmaps.erase(pixmaps.begin() + pixmapNdx);

					break;
				}

				case TYPE_CONTEXT:
				{
					const int contextNdx = rnd.getInt(0, (int)(contexts.size()-1));

					EGLU_CHECK_CALL(egl, destroyContext(m_display, contexts[contextNdx]));
					thread.getLog() << ThreadLog::BeginMessage << "eglDestroyContext(" << m_display << ", " << contexts[contextNdx]  << ")" << ThreadLog::EndMessage;
					contexts.erase(contexts.begin() + contextNdx);

					break;
				}

				default:
					DE_ASSERT(false);
			}

		}
	}
}

void MultiThreadedObjectTest::pushObjectsToShared (TestThread& thread)
{
	vector<EGLSurface>&									pbuffers	= (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
	vector<pair<eglu::NativeWindow*, EGLSurface> >&		windows		= (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
	vector<pair<eglu::NativePixmap*, EGLSurface> >&		pixmaps		= (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
	vector<EGLContext>&									contexts	= (thread.getId() == 0 ? m_contexts0 : m_contexts1);

	for (int pbufferNdx = 0; pbufferNdx < (int)pbuffers.size(); pbufferNdx++)
		m_sharedPbuffers.push_back(pbuffers[pbufferNdx]);

	pbuffers.clear();

	for (int windowNdx = 0; windowNdx < (int)windows.size(); windowNdx++)
		m_sharedNativeWindows.push_back(windows[windowNdx]);

	windows.clear();

	for (int pixmapNdx = 0; pixmapNdx < (int)pixmaps.size(); pixmapNdx++)
		m_sharedNativePixmaps.push_back(pixmaps[pixmapNdx]);

	pixmaps.clear();

	for (int contextNdx = 0; contextNdx < (int)contexts.size(); contextNdx++)
		m_sharedContexts.push_back(contexts[contextNdx]);

	contexts.clear();
}

void MultiThreadedObjectTest::pullObjectsFromShared (TestThread& thread, int pbufferCount, int pixmapCount, int windowCount, int contextCount)
{
	de::Random&											rnd			= (thread.getId() == 0 ? m_rnd0 : m_rnd1);
	vector<EGLSurface>&									pbuffers	= (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
	vector<pair<eglu::NativeWindow*, EGLSurface> >&		windows		= (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
	vector<pair<eglu::NativePixmap*, EGLSurface> >&		pixmaps		= (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
	vector<EGLContext>&									contexts	= (thread.getId() == 0 ? m_contexts0 : m_contexts1);

	for (int pbufferNdx = 0; pbufferNdx < pbufferCount; pbufferNdx++)
	{
		const int ndx = rnd.getInt(0, (int)(m_sharedPbuffers.size()-1));

		pbuffers.push_back(m_sharedPbuffers[ndx]);
		m_sharedPbuffers.erase(m_sharedPbuffers.begin() + ndx);
	}

	for (int pixmapNdx = 0; pixmapNdx < pixmapCount; pixmapNdx++)
	{
		const int ndx = rnd.getInt(0, (int)(m_sharedNativePixmaps.size()-1));

		pixmaps.push_back(m_sharedNativePixmaps[ndx]);
		m_sharedNativePixmaps.erase(m_sharedNativePixmaps.begin() + ndx);
	}

	for (int windowNdx = 0; windowNdx < windowCount; windowNdx++)
	{
		const int ndx = rnd.getInt(0, (int)(m_sharedNativeWindows.size()-1));

		windows.push_back(m_sharedNativeWindows[ndx]);
		m_sharedNativeWindows.erase(m_sharedNativeWindows.begin() + ndx);
	}

	for (int contextNdx = 0; contextNdx < contextCount; contextNdx++)
	{
		const int ndx = rnd.getInt(0, (int)(m_sharedContexts.size()-1));

		contexts.push_back(m_sharedContexts[ndx]);
		m_sharedContexts.erase(m_sharedContexts.begin() + ndx);
	}
}

void MultiThreadedObjectTest::querySetSharedObjects (TestThread& thread, int count)
{
	const Library&		egl		= getLibrary();
	de::Random&			rnd		= (thread.getId() == 0 ? m_rnd0 : m_rnd1);
	vector<Type>		objectTypes;

	if ((m_types & TYPE_PBUFFER) != 0)
		objectTypes.push_back(TYPE_PBUFFER);

	if ((m_types & TYPE_PIXMAP) != 0)
		objectTypes.push_back(TYPE_PIXMAP);

	if (!m_sharedNativeWindows.empty() && (m_types & TYPE_WINDOW) != 0)
		objectTypes.push_back(TYPE_WINDOW);

	if ((m_types & TYPE_CONTEXT) != 0)
		objectTypes.push_back(TYPE_CONTEXT);

	for (int queryNdx = 0; queryNdx < count; queryNdx++)
	{
		const Type	type		= rnd.choose<Type>(objectTypes.begin(), objectTypes.end());
		EGLSurface	surface		= EGL_NO_SURFACE;
		EGLContext	context		= EGL_NO_CONTEXT;

		switch (type)
		{
			case TYPE_PBUFFER:
				surface = m_sharedPbuffers[rnd.getInt(0, (int)(m_sharedPbuffers.size()-1))];
				break;

			case TYPE_PIXMAP:
				surface = m_sharedNativePixmaps[rnd.getInt(0, (int)(m_sharedNativePixmaps.size()-1))].second;
				break;

			case TYPE_WINDOW:
				surface = m_sharedNativeWindows[rnd.getInt(0, (int)(m_sharedNativeWindows.size()-1))].second;
				break;

			case TYPE_CONTEXT:
				context = m_sharedContexts[rnd.getInt(0, (int)(m_sharedContexts.size()-1))];
				break;

			default:
				DE_ASSERT(false);
		}

		if (surface != EGL_NO_SURFACE)
		{
			static const EGLint queryAttributes[] =
			{
				EGL_LARGEST_PBUFFER,
				EGL_HEIGHT,
				EGL_WIDTH
			};

			const EGLint	attribute	= queryAttributes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(queryAttributes) - 1)];
			EGLBoolean		result;
			EGLint			value;

			result = egl.querySurface(m_display, surface, attribute, &value);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglQuerySurface(" << m_display << ", " << surface << ", " << attribute << ", " << value << ")" << ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglQuerySurface()");

		}
		else if (context != EGL_NO_CONTEXT)
		{
			static const EGLint attributes[] =
			{
				EGL_CONFIG_ID,
				EGL_CONTEXT_CLIENT_TYPE,
				EGL_CONTEXT_CLIENT_VERSION,
				EGL_RENDER_BUFFER
			};

			const EGLint	attribute = attributes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(attributes)-1)];
			EGLint			value;
			EGLBoolean		result;

			result = egl.queryContext(m_display, context, attribute, &value);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglQueryContext(" << m_display << ", " << context << ", " << attribute << ", " << value << ")" << ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglQueryContext()");

		}
		else
			DE_ASSERT(false);
	}
}

void MultiThreadedObjectTest::destroyObjects (TestThread& thread)
{
	const Library&										egl			= getLibrary();
	vector<EGLSurface>&									pbuffers	= (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
	vector<pair<eglu::NativeWindow*, EGLSurface> >&		windows		= (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
	vector<pair<eglu::NativePixmap*, EGLSurface> >&		pixmaps		= (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
	vector<EGLContext>&									contexts	= (thread.getId() == 0 ? m_contexts0 : m_contexts1);

	for (int pbufferNdx = 0; pbufferNdx < (int)pbuffers.size(); pbufferNdx++)
	{
		if (pbuffers[pbufferNdx] != EGL_NO_SURFACE)
		{
			// Destroy EGLSurface
			EGLBoolean result;

			result = egl.destroySurface(m_display, pbuffers[pbufferNdx]);
			thread.getLog() << ThreadLog::BeginMessage << result << " = eglDestroySurface(" << m_display << ", " << pbuffers[pbufferNdx] << ")" << ThreadLog::EndMessage;
			EGLU_CHECK_MSG(egl, "eglDestroySurface()");
			pbuffers[pbufferNdx] = EGL_NO_SURFACE;
		}
	}
	pbuffers.clear();

	for (int windowNdx = 0; windowNdx < (int)windows.size(); windowNdx++)
	{
		if (windows[windowNdx].second != EGL_NO_SURFACE)
		{
			thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << windows[windowNdx].second << ")" << ThreadLog::EndMessage;
			EGLU_CHECK_CALL(egl, destroySurface(m_display, windows[windowNdx].second));
			windows[windowNdx].second = EGL_NO_SURFACE;
		}

		if (windows[windowNdx].first)
		{
			delete windows[windowNdx].first;
			windows[windowNdx].first = NULL;
		}
	}
	windows.clear();

	for (int pixmapNdx = 0; pixmapNdx < (int)pixmaps.size(); pixmapNdx++)
	{
		if (pixmaps[pixmapNdx].first != EGL_NO_SURFACE)
		{
			thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << pixmaps[pixmapNdx].second << ")" << ThreadLog::EndMessage;
			EGLU_CHECK_CALL(egl, destroySurface(m_display, pixmaps[pixmapNdx].second));
			pixmaps[pixmapNdx].second = EGL_NO_SURFACE;
		}

		if (pixmaps[pixmapNdx].first)
		{
			delete pixmaps[pixmapNdx].first;
			pixmaps[pixmapNdx].first = NULL;
		}
	}
	pixmaps.clear();

	for (int contextNdx = 0; contextNdx < (int)contexts.size(); contextNdx++)
	{
		if (contexts[contextNdx] != EGL_NO_CONTEXT)
		{
			EGLU_CHECK_CALL(egl, destroyContext(m_display, contexts[contextNdx]));
			thread.getLog() << ThreadLog::BeginMessage << "eglDestroyContext(" << m_display << ", " << contexts[contextNdx]  << ")" << ThreadLog::EndMessage;
			contexts[contextNdx] = EGL_NO_CONTEXT;
		}
	}
	contexts.clear();
}

MultiThreadedTests::MultiThreadedTests (EglTestContext& context)
	: TestCaseGroup(context, "multithread", "Multithreaded EGL tests")
{
}

void MultiThreadedTests::init (void)
{
	// Config tests
	addChild(new MultiThreadedConfigTest(m_eglTestCtx,	"config",	"",	30,	30,	30));

	// Object tests
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer",								"", MultiThreadedObjectTest::TYPE_PBUFFER));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pixmap",								"", MultiThreadedObjectTest::TYPE_PIXMAP));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"window",								"", MultiThreadedObjectTest::TYPE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"single_window",						"", MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"context",								"", MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_pixmap",						"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_window",						"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_single_window",				"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_context",						"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pixmap_window",						"", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pixmap_single_window",					"", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pixmap_context",						"", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"window_context",						"", MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"single_window_context",				"", MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_pixmap_window",				"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_pixmap_single_window",			"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_pixmap_context",				"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_window_context",				"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_single_window_context",		"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pixmap_window_context",				"", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pixmap_single_window_context",			"", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));

	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_pixmap_window_context",		"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
	addChild(new MultiThreadedObjectTest(m_eglTestCtx,	"pbuffer_pixmap_single_window_context",	"", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
}

} // egl
} // deqp