// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @test 

*/

#include "egltestcommonsession.h"

#include "egltestcommonutils.h"

#include "egltestcommonsgimageinfo.h"

#include <test/tefunit.h>

#include <e32cmn.h>

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

#include <sgresource/sgresource.h>

#else

#include <graphics/sgresourceinternal.h>

#include <graphics/sgresource.h>

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

#include <VG/openvg.h>

#include <GLES/gl.h>

#define	CHECK_EXPECTED_ERROR(aFunctionReturnValue) \

	if(!(CheckExpectedError(aFunctionReturnValue))) \

		{ \

		ERR_PRINTF2(_L("thread %d: Unexpected EGL error information"), iThreadIdx); \

		User::Leave(KErrTEFUnitFail); \

		}

const TMapEglConfigToPixelFormat KMapEglConfigToPixelFormat[] =

	{

	{16, 0, 5,6,5, 0, 							EGL_RGB_BUFFER, EUidPixelFormatRGB_565, EColor64K},

	{32, 0, 8,8,8, 0,							EGL_RGB_BUFFER, EUidPixelFormatXRGB_8888, EColor16MU},

    {32, 8, 8,8,8, EGL_VG_ALPHA_FORMAT_NONPRE, 	EGL_RGB_BUFFER, EUidPixelFormatARGB_8888, EColor16MA},

	{32, 8, 8,8,8, EGL_VG_ALPHA_FORMAT_PRE, 	EGL_RGB_BUFFER, EUidPixelFormatARGB_8888_PRE, EColor16MAP}

	};

EXPORT_C CTestEglSession::CTestEglSession(CTestExecuteLogger& aLogger, EGLDisplay& aDisplay, TInt aThreadIdx)

	: iLogger(aLogger), iThreadIdx(aThreadIdx), iExtensionGroupCached(EIsUndefined), iDisplay(aDisplay), iExpectedErrorCode(EGL_SUCCESS)

	{}

EXPORT_C CTestEglSession* CTestEglSession::NewLC(CTestExecuteLogger& aLogger, EGLDisplay& aDisplay, TInt aThreadIdx)

	{

	CTestEglSession* self = new (ELeave) CTestEglSession(aLogger, aDisplay, aThreadIdx);

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CTestEglSession* CTestEglSession::NewL(CTestExecuteLogger& aLogger, EGLDisplay& aDisplay, TInt aThreadIdx)

	{

	CTestEglSession* self = CTestEglSession::NewLC(aLogger, aDisplay, aThreadIdx);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CTestEglSession::~CTestEglSession()

	{

	iExtensionStrings.Reset();

	EGLBoolean ret;

	if (iDisplay != EGL_NO_DISPLAY)

		{

		// Unbind and destroy context only if we successfuly created it

		if (iContext != EGL_NO_CONTEXT)

		    {

            INFO_PRINTF2(_L("thread %d: Calling eglMakeCurrent(NULL values) from ~CTestEglSession..."), iThreadIdx);

            ret = eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

            if(ret == EGL_FALSE)

                {

                WARN_PRINTF3(_L("thread %d: eglMakeCurrent returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());

                }

            // Warn because this should be done by the test, rather than relying on the d'tor

            // which may not leave if there is an error (so no CHECK_EXPECTED_ERROR)

            WARN_PRINTF2(_L("thread %d: Calling eglDestroyContext() from ~CTestEglSession..."), iThreadIdx);

            ret = eglDestroyContext(iDisplay, iContext);

            if(ret == EGL_FALSE)

                {

                WARN_PRINTF3(_L("thread %d: eglDestroyContext returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());

                }   

		    }

		if (iSurface != EGL_NO_SURFACE)

			{

			// Warn because this should be done by the test, rather than relying on the d'tor

			// which may not leave if there is an error (so no CHECK_EXPECTED_ERROR)

			WARN_PRINTF2(_L("thread %d: Calling eglDestroySurface() from ~CTestEglSession..."), iThreadIdx);

			ret = eglDestroySurface(iDisplay, iSurface);

			if(ret == EGL_FALSE)

				{

				WARN_PRINTF3(_L("thread %d: eglDestroySurface returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());

				}	

			}

		if (iTerminateDisplay)

			{

			INFO_PRINTF1(_L("Calling eglTerminate..."));

			ret = eglTerminate(iDisplay);

			iDisplay = EGL_NO_DISPLAY;

			if(ret == EGL_FALSE)

				{

				WARN_PRINTF3(_L("thread %d: eglTerminate returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());

				}	

			}

		}

	// Only destroy native resource after the surface and context that wraps it has been destroyed.

	delete iFbsBitmap;

	CloseFbsSession();

	iSgImage.Close();

	CloseSgDriver();

	}

EXPORT_C void CTestEglSession::SetExpectedError(EGLint aExpectedErrorCode)

	{

	VERBOSE_INFO_PRINTF3(_L("thread %d: Setting the expected error code for the next EGL call to %x"), iThreadIdx, aExpectedErrorCode);

		{

		iExpectedErrorCode = aExpectedErrorCode; 

		}

	}

EXPORT_C void CTestEglSession::ResetExpectedError()

	{

	iExpectedErrorCode = EGL_SUCCESS;

	}

/**

Checks whether the call to an EGL method returned the correct error information.

The method checks whether eglGetError() returns the expected error value as specified by calling SetExpectedError()

It also checks that the value returned by the EGL method was appropriate for the expected error value.

@param aFunctionReturnValue Pass in the value retured from the EGL method

@return Whether the expected error information was returned from a call to an EGL method.

*/

EXPORT_C TBool CTestEglSession::CheckExpectedError(EGLint aFunctionReturnValue)

	{

	TBool isExpectedError = ETrue;

	EGLint eglErr = eglGetError();

	// First check that we got the correct return value

	if ((iExpectedErrorCode == EGL_SUCCESS) && !aFunctionReturnValue)

		{

		ERR_PRINTF3(_L("thread %d: Wrong function return value: %d"), iThreadIdx, aFunctionReturnValue);

		isExpectedError = EFalse;

		}

	// Also check that we got the 

	if (eglErr != iExpectedErrorCode) 

		{

		ERR_PRINTF4(_L("thread %d: eglGetError() returned %x, but expected %x"), iThreadIdx, eglErr, iExpectedErrorCode);

		isExpectedError = EFalse;

		}

	else if (eglErr != EGL_SUCCESS)

		{

		VERBOSE_INFO_PRINTF3(_L("thread %d: eglGetError() returned %x, as expected"), iThreadIdx, eglErr);

		}

	// Reset the expected error

	ResetExpectedError();

	return isExpectedError;

	}

EXPORT_C void CTestEglSession::CheckExpectedErrorL(EGLint aExpectedErrorCode)

	{

	EGLint eglErr = eglGetError();	

	// check that we got the expected error

	if (eglErr != aExpectedErrorCode) 

		{

		ERR_PRINTF4(_L("thread %d: eglGetError() returned %x, but expected %x"), iThreadIdx, eglErr, aExpectedErrorCode);

		User::Leave(KErrTEFUnitFail);

		}

	}

void CTestEglSession::QueryExtensionsL(TExtensionsGroups aExtensionBelongsTo)

	{

	// reset the cached extensions

	iExtensionStrings.Reset();

	const char* extensionsString = NULL;

	if(aExtensionBelongsTo == EIsEGL)

		{

		INFO_PRINTF2(_L("thread %d: Calling eglQueryString for EGL_EXTENSIONS)"), iThreadIdx);

		extensionsString = eglQueryString(iDisplay, EGL_EXTENSIONS);

		}

	else if(aExtensionBelongsTo == EIsVG)

		{	

		INFO_PRINTF2(_L("thread %d: Calling vgGetString for VG_EXTENSIONS)"), iThreadIdx);

		// OpenVG needs a current VG context before it will allow the call to vgGetString

		extensionsString = (const char*) vgGetString(VG_EXTENSIONS);

		//cleanup the context & surface

		CleanupSurfaceSgImageL();

		}

	else

		{

		ERR_PRINTF2(_L("CTestEglSession::QueryExtensionsL() - Unknown extension group provided (%d)."), aExtensionBelongsTo);

		User::Leave(KErrArgument);

		}

	CHECK_EXPECTED_ERROR(extensionsString!=NULL);	

	TPtrC8 ptrExtensions((const TUint8 *) extensionsString );

	TBuf16<128> bufExtensions;

	bufExtensions.Copy(ptrExtensions.Left(128));

	INFO_PRINTF3(_L("thread %d: QueryExtensionsL: \"%S\""), iThreadIdx, &bufExtensions);

	TInt posSpace=1;

	while (posSpace > 0 && ptrExtensions.Length() > 0)

		{

		posSpace = ptrExtensions.Locate(' '); // strictly looking for a single space

		ASSERT_FALSE(posSpace==0); // Would imply extension starting with a space or with 2 spaces in a row

		if (posSpace > 0)

			{

			iExtensionStrings.Append(ptrExtensions.Left(posSpace));

			if (posSpace <= ptrExtensions.Length())

				{

				ptrExtensions.Set(ptrExtensions.Mid(posSpace+1));

				}

			}

		else

			{

			iExtensionStrings.Append(ptrExtensions);

			}

		} 

	}

TBool CTestEglSession::FindExtensionStringL(TExtensionsGroups aExtensionBelongsTo, const TDesC8& aExtensionString)

	{

	//Load the extensions for this group if not already cached

	if (iExtensionGroupCached != aExtensionBelongsTo)

		{

		QueryExtensionsL(aExtensionBelongsTo); // Load extension info

		iExtensionGroupCached = aExtensionBelongsTo;

		}

	TInt countExtensionStrings = iExtensionStrings.Count();

	for(TUint i=0; i<countExtensionStrings; i++)

		{

		if (iExtensionStrings[i].Compare(aExtensionString)==0)

			{

			// We have a match!

			return ETrue;

			}

		}

	// No match: copy the extension string into a 16 bit buffer for logging

	const TInt KBufLenMissingExtension=128;

	TBuf16<KBufLenMissingExtension> bufMissingExtension16;

	bufMissingExtension16.Copy(aExtensionString.Left(KBufLenMissingExtension));

	WARN_PRINTF2(_L("EGL extension missing: [%S]"), &bufMissingExtension16);

	return EFalse;

	}

/**

 Converts from TRgb space to Vg floating point colour

 */

EXPORT_C void CTestEglSession::ConvertColor(const TRgb& aSource, VGfloat* aTarget)

//static

	{

	aTarget[0] = (VGfloat)aSource.Red() / 255.f;

	aTarget[1] = (VGfloat)aSource.Green() / 255.f;

	aTarget[2] = (VGfloat)aSource.Blue() / 255.f;

	aTarget[3] = (VGfloat)aSource.Alpha() / 255.f;

	}

/** Breakpoint to manually view available configs while debugging */

EXPORT_C void CTestEglSession::ViewConfigsL()

	{

	EGLConfig configs[KMaxEglConfigs];

	EGLint numConfigs=0;

	// Query number of configs available

	INFO_PRINTF1(_L("Calling eglGetConfigs to get the number of configs available..."));

	CHECK_EXPECTED_ERROR(eglGetConfigs(iDisplay, NULL, KMaxTInt, &numConfigs));

	INFO_PRINTF1(_L("Checking number of configs..."));

	ASSERT_TRUE(numConfigs >= 1);

	INFO_PRINTF2(_L("Found %d configs"), numConfigs);

	// Get the configs

	INFO_PRINTF1(_L("Calling eglGetConfigs to get configs..."));

	CHECK_EXPECTED_ERROR(eglGetConfigs(iDisplay, configs, KMaxEglConfigs, &numConfigs));

	for(TUint index = 0; index < numConfigs; index++)

		{

		EGLint EGL_BUFFER_SIZE_value;

		EGLint EGL_ALPHA_SIZE_value;

		EGLint EGL_BLUE_SIZE_value;

		EGLint EGL_GREEN_SIZE_value;

		EGLint EGL_RED_SIZE_value;

#ifdef PRINT_ALL_CONFIGS_DETAILS

		EGLint EGL_DEPTH_SIZE_value;

		EGLint EGL_STENCIL_SIZE_value;

		EGLint EGL_CONFIG_CAVEAT_value;

		EGLint EGL_CONFIG_ID_value;

		EGLint EGL_LEVEL_value;

		EGLint EGL_MAX_PBUFFER_HEIGHT_value;

		EGLint EGL_MAX_PBUFFER_PIXELS_value;

		EGLint EGL_MAX_PBUFFER_WIDTH_value;

		EGLint EGL_NATIVE_RENDERABLE_value;

		EGLint EGL_NATIVE_VISUAL_ID_value;

		EGLint EGL_NATIVE_VISUAL_TYPE_value;

		EGLint EGL_SAMPLES_value;

		EGLint EGL_SAMPLE_BUFFERS_value;

#endif

		EGLint EGL_SURFACE_TYPE_value;

#ifdef PRINT_ALL_CONFIGS_DETAILS

		EGLint EGL_TRANSPARENT_TYPE_value;

		EGLint EGL_TRANSPARENT_BLUE_VALUE_value;

		EGLint EGL_TRANSPARENT_GREEN_VALUE_value;

		EGLint EGL_TRANSPARENT_RED_VALUE_value;

		EGLint EGL_BIND_TO_TEXTURE_RGB_value;

		EGLint EGL_BIND_TO_TEXTURE_RGBA_value;

		EGLint EGL_MIN_SWAP_INTERVAL_value;

		EGLint EGL_MAX_SWAP_INTERVAL_value;

		EGLint EGL_LUMINANCE_SIZE_value;

		EGLint EGL_ALPHA_MASK_SIZE_value;

		EGLint EGL_COLOR_BUFFER_TYPE_value;

#endif

		EGLint EGL_RENDERABLE_TYPE_value;

		eglGetConfigAttrib(iDisplay, configs[index], EGL_BUFFER_SIZE, &EGL_BUFFER_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_ALPHA_SIZE, &EGL_ALPHA_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_BLUE_SIZE, &EGL_BLUE_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_GREEN_SIZE, &EGL_GREEN_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_RED_SIZE, &EGL_RED_SIZE_value);

#ifdef PRINT_ALL_CONFIGS_DETAILS

		eglGetConfigAttrib(iDisplay, configs[index], EGL_DEPTH_SIZE, &EGL_DEPTH_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_STENCIL_SIZE, &EGL_STENCIL_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_CONFIG_CAVEAT, &EGL_CONFIG_CAVEAT_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_CONFIG_ID, &EGL_CONFIG_ID_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_LEVEL, &EGL_LEVEL_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_PBUFFER_HEIGHT, &EGL_MAX_PBUFFER_HEIGHT_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_PBUFFER_PIXELS, &EGL_MAX_PBUFFER_PIXELS_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_PBUFFER_WIDTH, &EGL_MAX_PBUFFER_WIDTH_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_NATIVE_RENDERABLE, &EGL_NATIVE_RENDERABLE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_NATIVE_VISUAL_ID, &EGL_NATIVE_VISUAL_ID_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_NATIVE_VISUAL_TYPE, &EGL_NATIVE_VISUAL_TYPE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_SAMPLES, &EGL_SAMPLES_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_SAMPLE_BUFFERS, &EGL_SAMPLE_BUFFERS_value);

#endif

		eglGetConfigAttrib(iDisplay, configs[index], EGL_SURFACE_TYPE, &EGL_SURFACE_TYPE_value);

#ifdef PRINT_ALL_CONFIGS_DETAILS

		eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_TYPE, &EGL_TRANSPARENT_TYPE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_BLUE_VALUE, &EGL_TRANSPARENT_BLUE_VALUE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_GREEN_VALUE, &EGL_TRANSPARENT_GREEN_VALUE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_RED_VALUE, &EGL_TRANSPARENT_RED_VALUE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_BIND_TO_TEXTURE_RGB, &EGL_BIND_TO_TEXTURE_RGB_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_BIND_TO_TEXTURE_RGBA, &EGL_BIND_TO_TEXTURE_RGBA_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_MIN_SWAP_INTERVAL, &EGL_MIN_SWAP_INTERVAL_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_SWAP_INTERVAL, &EGL_MAX_SWAP_INTERVAL_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_LUMINANCE_SIZE, &EGL_LUMINANCE_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_ALPHA_MASK_SIZE, &EGL_ALPHA_MASK_SIZE_value);

		eglGetConfigAttrib(iDisplay, configs[index], EGL_COLOR_BUFFER_TYPE, &EGL_COLOR_BUFFER_TYPE_value);

#endif

		eglGetConfigAttrib(iDisplay, configs[index], EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value);

		TBool good = ETrue;

		INFO_PRINTF7(_L("(idx: %3d) RGBA=(%2d) %2d,%2d,%2d,%2d"), index, EGL_BUFFER_SIZE_value, 

				EGL_RED_SIZE_value, EGL_GREEN_SIZE_value, EGL_BLUE_SIZE_value, 

				EGL_ALPHA_SIZE_value);

		if (!(EGL_RED_SIZE_value == 8 && EGL_GREEN_SIZE_value == 8 && EGL_BLUE_SIZE_value == 8 && EGL_ALPHA_SIZE_value == 0))

			{

			continue;

			}

		INFO_PRINTF2(_L("\n\n^^^^^^ CONFIG [%d] VALUES ******"), index);

		if (EGL_SURFACE_TYPE_value & EGL_PIXMAP_BIT)

			{

			INFO_PRINTF2(_L("EGL_SURFACE_TYPE=%d. <<< Has EGL_PIXMAP_BIT"), EGL_SURFACE_TYPE_value);

			}

		else

			{

			INFO_PRINTF2(_L("EGL_SURFACE_TYPE=%d. <<< BAD (not pixmap)"), EGL_SURFACE_TYPE_value);

			good = EFalse;

			}

		if (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)

			{

			INFO_PRINTF2(_L("EGL_RENDERABLE_TYPE=%d. <<< Has EGL_OPENVG_BIT"), EGL_RENDERABLE_TYPE_value);

			}

		else

			{

			INFO_PRINTF2(_L("EGL_RENDERABLE_TYPE=%d. <<< BAD (not open vg)"), EGL_RENDERABLE_TYPE_value);

			good = EFalse;

			}

		if (good)

			{

			INFO_PRINTF1(_L("^^^^^^^ GOOD ^^^^^^^"));

			}

#ifdef PRINT_ALL_CONFIGS_DETAILS

		INFO_PRINTF2(_L("\n\n***** CONFIG [%d] VALUES ******"), index);

		INFO_PRINTF2(_L("EGL_BUFFER_SIZE=%d."), EGL_BUFFER_SIZE_value);

		INFO_PRINTF2(_L("EGL_ALPHA_SIZE=%d."), EGL_ALPHA_SIZE_value);

		INFO_PRINTF2(_L("EGL_BLUE_SIZE=%d."), EGL_BLUE_SIZE_value);

		INFO_PRINTF2(_L("EGL_GREEN_SIZE=%d."), EGL_GREEN_SIZE_value);

		INFO_PRINTF2(_L("EGL_RED_SIZE=%d."), EGL_RED_SIZE_value);

		INFO_PRINTF2(_L("EGL_DEPTH_SIZE=%d."), EGL_DEPTH_SIZE_value);

		INFO_PRINTF2(_L("EGL_STENCIL_SIZE=%d."), EGL_STENCIL_SIZE_value);

		INFO_PRINTF2(_L("EGL_CONFIG_CAVEAT=%d."), EGL_CONFIG_CAVEAT_value);

		INFO_PRINTF2(_L("EGL_CONFIG_ID=%d."), EGL_CONFIG_ID_value);

		INFO_PRINTF2(_L("EGL_LEVEL=%d."), EGL_LEVEL_value);

		INFO_PRINTF2(_L("EGL_MAX_PBUFFER_HEIGHT=%d."), EGL_MAX_PBUFFER_HEIGHT_value);

		INFO_PRINTF2(_L("EGL_MAX_PBUFFER_PIXELS=%d."), EGL_MAX_PBUFFER_PIXELS_value);

		INFO_PRINTF2(_L("EGL_MAX_PBUFFER_WIDTH=%d."), EGL_MAX_PBUFFER_WIDTH_value);

		INFO_PRINTF2(_L("EGL_NATIVE_RENDERABLE=%d."), EGL_NATIVE_RENDERABLE_value);

		INFO_PRINTF2(_L("EGL_NATIVE_VISUAL_ID=%d."), EGL_NATIVE_VISUAL_ID_value);

		INFO_PRINTF2(_L("EGL_NATIVE_VISUAL_TYPE=%d."), EGL_NATIVE_VISUAL_TYPE_value);

		INFO_PRINTF2(_L("EGL_SAMPLES=%d."), EGL_SAMPLES_value);

		INFO_PRINTF2(_L("EGL_SAMPLE_BUFFERS=%d."), EGL_SAMPLE_BUFFERS_value);

		INFO_PRINTF2(_L("EGL_SURFACE_TYPE=%d."), EGL_SURFACE_TYPE_value);

		INFO_PRINTF2(_L("EGL_TRANSPARENT_TYPE=%d."), EGL_TRANSPARENT_TYPE_value);

		INFO_PRINTF2(_L("EGL_TRANSPARENT_BLUE_VALUE=%d."), EGL_TRANSPARENT_BLUE_VALUE_value);

		INFO_PRINTF2(_L("EGL_TRANSPARENT_GREEN_VALUE=%d."), EGL_TRANSPARENT_GREEN_VALUE_value);

		INFO_PRINTF2(_L("EGL_TRANSPARENT_RED_VALUE=%d."), EGL_TRANSPARENT_RED_VALUE_value);

		INFO_PRINTF2(_L("EGL_BIND_TO_TEXTURE_RGB=%d."), EGL_BIND_TO_TEXTURE_RGB_value);

		INFO_PRINTF2(_L("EGL_BIND_TO_TEXTURE_RGBA=%d."), EGL_BIND_TO_TEXTURE_RGBA_value);

		INFO_PRINTF2(_L("EGL_MIN_SWAP_INTERVAL=%d."), EGL_MIN_SWAP_INTERVAL_value);

		INFO_PRINTF2(_L("EGL_MAX_SWAP_INTERVAL=%d."), EGL_MAX_SWAP_INTERVAL_value);

		INFO_PRINTF2(_L("EGL_LUMINANCE_SIZE=%d."), EGL_LUMINANCE_SIZE_value);

		INFO_PRINTF2(_L("EGL_ALPHA_MASK_SIZE=%d."), EGL_ALPHA_MASK_SIZE_value);

		INFO_PRINTF2(_L("EGL_COLOR_BUFFER_TYPE=%d."), EGL_COLOR_BUFFER_TYPE_value);

		INFO_PRINTF2(_L("EGL_RENDERABLE_TYPE=%d."), EGL_RENDERABLE_TYPE_value);

		INFO_PRINTF2(_L("\n*********************************\n\n"), index);

#endif

		}

	}

EXPORT_C static TEglConfigMatchType GetMatchType(EGLint aAttrib, TEglConfigMatchRule aMatchRule)

	{

	const TConfigMatchRuleItem* curMatchRuleItem = KConfigMatchRules[aMatchRule];

	while(curMatchRuleItem->iAttrib != EGL_NONE)

		{

		if (aAttrib == curMatchRuleItem->iAttrib)

			{

			return curMatchRuleItem->iMatchType;

			}

		curMatchRuleItem++;

		}

	RDebug::Printf("Unknown attrib %x", aAttrib);

	return eMatchUnknown;

	}

/**

 Returns the first index of a config that matches the requested config extactly

 */

TInt CTestEglSession::GetFullMatchConfigIndex(EGLDisplay aDisplay, EGLConfig *aConfigs, TInt aNumConfigs, 

											  const EGLint aWantedAttribs[], TEglConfigMatchRule aMatchRule)

	{

	EGLint value=0;

	for(TUint idxConfig=0; idxConfig<aNumConfigs; idxConfig++)

		{

		const EGLint *curAttrib = aWantedAttribs;

		TBool match = ETrue;

		while(*curAttrib != EGL_NONE && match)

			{

			ASSERT_EGL_TRUE(eglGetConfigAttrib(aDisplay, aConfigs[idxConfig], *curAttrib, &value));

			switch(GetMatchType(*curAttrib, aMatchRule))

				{

				case eMatchEqual:

					if (value != curAttrib[1])

						{

						match = EFalse;

						}		

					break;

				case eMatchAtLeast:

					if (value < curAttrib[1])   // Note, we detect "failure to match", hence "<" not ">="!

						{

						match = EFalse;

						}

					break;

				case eMatchBitMask:

					if ((value & curAttrib[1]) != curAttrib[1])

						{

						match = EFalse;

						}

					break;

				case eMatchAlways:

				    break;

				default:

					// We should not get here.

				    ASSERT(FALSE); 

				    break;

				}

			curAttrib += 2;

			}

		// If we get here with match set, we have matched all attributes, and have found a match. 

		if (match) 

			{

			return idxConfig;

			}

		}

	return KErrNotFound;

	}

TInt CTestEglSession::ConfigToPixelFormatTableLength() const

	{

	return sizeof(KMapEglConfigToPixelFormat) / sizeof(TMapEglConfigToPixelFormat);

	}

const TMapEglConfigToPixelFormat& CTestEglSession::ConfigToPixelFormatTable(TInt aIndex) const

	{