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

#ifndef __INIPARSER_H__
#include <cinidata.h>
#endif // __INIPARSER_H__
#include <test/tefunit.h> // for ASSERT macros

#include "egltest_nativepixmaptype.h"
#include <test/egltestcommonconversion.h>
#include <test/egltestcommoninisettings.h>


/**
@SYMTestCaseID GRAPHICS-EGL-0015

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc
Checks the single threaded usage of a Pixmap<RSgImage>

@SYMTestActions
Call eglInitialize()
Use a Pixmap<RSgImage>

@SYMTestExpectedResults
Use of Pixmap<RSgImage> succeeds
*/
TVerdict CEglTest_NativePixmapType_SingleThread_Positive_RSgImage::doTestStepL()
	{
	SetTestStepID(_L("GRAPHICS-EGL-0015"));
	INFO_PRINTF1(_L("CEglTest_NativePixmapType_SingleThread_Positive_RSgImage::doTestStepL"));
	
	TBool ret = CheckForExtensionL(KEGL_RSgimage);
	if(!ret)
		{
		// The extension is not supported
		RecordTestResultL();
		CloseTMSGraphicsStep();
		return TestStepResult();
		}

	// Create display object
	GetDisplayL();
	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);
	eglSess->InitializeL();

	// Try to create and use an RSgImage pixmap
	eglSess->TryUsePixmapRSgImageL();
	
	CleanupStack::PopAndDestroy(eglSess);
	TerminateDisplayL();
	RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

/**
@SYMTestCaseID GRAPHICS-EGL-0028

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc
These tests check usage of a Pixmap<RSgImage> within two threads.

@SYMTestActions
Execute threads A and B in the following order
A: Call eglInitialize()
B: Call eglInitialize()
-----
A: Use Pixmap<RSgImage>
B: Use Pixmap<RSgImage>

@SYMTestExpectedResults
Use_Pixmap<RSgImage> succeeds for both threads
*/
TVerdict CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doTestStepL()
	{
	SetTestStepID(_L("GRAPHICS-EGL-0028"));
	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doTestStepL"));
	
	TBool ret = CheckForExtensionL(KEGL_RSgimage);
	
	if(ret)
		{
		Test_MultiThreadL(2, ETrue);
		TerminateDisplayL();
		}
	
	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doTestStepL"));
	RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

void CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doThreadFunctionL(TInt aIdx)
	{
	INFO_PRINTF2(_L("thread %d: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doThreadFunctionL"), aIdx);
	
	GetDisplayL();
	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);
	
	eglSess->InitializeL();
	
	Rendezvous(aIdx);
	
	eglSess->TryUsePixmapRSgImageL();
	
	CleanupStack::PopAndDestroy(eglSess);
	
	INFO_PRINTF2(_L("thread %d: Exit CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doThreadFunctionL"), aIdx);
	}

/**
@SYMTestCaseID GRAPHICS-EGL-0029

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc
These tests check usage of a Pixmap<RSgImage> within two threads.
Threads are indipendent (no rendezvous).

@SYMTestActions
Execute threads A and B in the following order
A: Call eglInitialize()
B: Call eglInitialize()
-----
A: Use Pixmap<RSgImage>
B: Use Pixmap<RSgImage>

@SYMTestExpectedResults
Use_Pixmap<RSgImage> succeeds for both threads
*/
TVerdict CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doTestStepL()
	{
	SetTestStepID(_L("GRAPHICS-EGL-0029"));
	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doTestStepL"));
	
	TBool ret = CheckForExtensionL(KEGL_RSgimage);
		
	if(ret)
		{
		Test_MultiThreadL(2, ETrue);
		TerminateDisplayL();
		}
	
	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doTestStepL"));
	RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

void CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doThreadFunctionL(TInt aIdx)
	{
	INFO_PRINTF2(_L("thread %d: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doThreadFunctionL"), aIdx);
	GetDisplayL();
	//first check if the extension is present
	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);	
	eglSess->InitializeL();
		
	eglSess->TryUsePixmapRSgImageL();
	
	CleanupStack::PopAndDestroy(eglSess);
	
	INFO_PRINTF2(_L("thread %d: Exit CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doThreadFunctionL"), aIdx);
	}


/**
@SYMTestCaseID GRAPHICS-EGL-0030

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc
These test checks that one call to eglInitialize per process is sufficient.
Both threads use a Pixmap<RSgImage> 

@SYMTestActions
Execute threads A and B in the following order
A: Call eglInitialize()
B: <no initialisation>
-----
A: Use Pixmap<RSgImage>
B: Use Pixmap<RSgImage>

@SYMTestExpectedResults
Use_Pixmap<RSgImage> succeeds for both threads
*/
TVerdict CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doTestStepL()
	{
	SetTestStepID(_L("GRAPHICS-EGL-0030"));
	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);
		
	if(ret)
		{
		Test_MultiThreadL(2, ETrue);
		TerminateDisplayL();
		}
	
	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doTestStepL"));
	RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

void CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doThreadFunctionL(TInt aIdx)
	{
	INFO_PRINTF2(_L("thread %d: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doThreadFunctionL"), aIdx);
	
	GetDisplayL();
	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);
	
	if (aIdx == 0)
		{
		eglSess->InitializeL();
		}
	Rendezvous(aIdx);
	if (aIdx == 1)
		{
		INFO_PRINTF2(_L("thread %d: skipping initialisation"), aIdx);
		}
	
	Rendezvous(aIdx);
	
	eglSess->TryUsePixmapRSgImageL();
	
	CleanupStack::PopAndDestroy(eglSess);

	INFO_PRINTF2(_L("thread %d: Exit CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doThreadFunctionL"), aIdx);
	}

// MultiProcess tests

/**
@SYMTestCaseID GRAPHICS-EGL-0041

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc
These tests check usage of a Pixmap<RSgImage> within two processes.

@SYMTestActions
Execute processes A and B in the following order

A: Call eglInitialize()
B: Call eglInitialize()
-----
A: Use_Pixmap<RSgImage>
B: Use_Pixmap<RSgImage>

@SYMTestExpectedResults
Use_Pixmap<RSgImage> should succeed for both processes
*/
TVerdict CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doTestStepL()
	{
    SetTestStepID(_L("GRAPHICS-EGL-0041"));
	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doTestStepL"));

	// First check whether RSgImage is supported
	TBool ret = CheckForExtensionL(KEGL_RSgimage);
		
	if(ret)
		{
		// Now run the multiprocess test - each process can safely assume that RSgImage support is available.
		Test_MultiProcessL(KEglTestStepDllName, 2, KNativePixmapType_MultiProcess_Both_RSgImage);
		}
	
	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doTestStepL"));
	RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

void CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doProcessFunctionL(TInt aIdx)
	{
	INFO_PRINTF2(_L("process %d: CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doProcessFunctionL"), aIdx);

	// Create display object
	GetDisplayL();
	
	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);
	
	// Initialize the thread
	eglSess->InitializeL();
	
	// Rendezvous: ensure that both threads get to this point before continuing
	Rendezvous(aIdx);	

	// Try to create and use an RSgImage pixmap
	INFO_PRINTF2(_L("process %d: Calling TryUsePixmapRSgImageL..."), aIdx);
	eglSess->TryUsePixmapRSgImageL();
	
	CleanupStack::PopAndDestroy(eglSess);
	TerminateDisplayL();
	
	INFO_PRINTF2(_L("process %d: Exit CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doThreadFunctionL"), aIdx);
	}

/**
@SYMTestCaseID GRAPHICS-EGL-0044

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc
Ensure that when asking for an EGLconfig via eglChooseConfig
passing an RSgImage with given iUsage and iPixelFormat attributes,
just the matching configs are returned.

@SYMTestActions
Fully construct an RSgImage setting iUsage and/or iPixelFormat
Loop through different values of iUsage and iPixelFormat and change RSgImage attributes accordingly
•	Query all the configs available on the display calling eglGetConfigs.
•	Loop through the possible configs and manually check how many they are and save their index.
•	Call eglChooseConfig() having in the attrib_list the attribute EGL MATCH NATIVE PIXMAP set as the handle to the RSgImage previously created.
•	Check if the number of the returned matching config is equal to the one manually checked earlier. Check if the returned configs are actually the same.
End Loop
Destroy the RSgImage object

@SYMTestExpectedResults
Returned Configs have to be the ones expected.
The values that iPixelFormat have to assume are:
•	EUidPixelFormatRGB_565
•	EUidPixelFormatXRGB_8888
•	EUidPixelFormatARGB_8888_PRE
It’s not possible to test any other pixel formats (such as 
EUidPixelFormatARGB_8888) because it is not allowed to create an RSgImage 
with that pixel format and iUsage bit saying that it is going to be used 
as a target.
The values that iUsage have to assume are:
•   ESgUsageBitOpenVgSurface
•   ESgUsageBitOpenGles2Surface
•	ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Surface
•	ESgUsageBitOpenVgImage
If OpenGLES2 is not supported creation of the SgImage is expected to fail 
with KErrNotSupported error code.
*/
TVerdict CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestStepL()
	{
	SetTestStepID(_L("GRAPHICS-EGL-0044"));
	INFO_PRINTF1(_L("CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);
	if(!ret)
		{
		// The extension is not supported
		RecordTestResultL();
		CloseTMSGraphicsStep();
		return TestStepResult();
		}

	// Create display object
	GetDisplayL();
	CreateEglSessionL();
	iEglSess->InitializeL();
	iEglSess->OpenSgDriverL();
	
	CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();
	CleanupStack::PushL(iniParser);
				
	TInt numRSgImageTargetFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);
	if(!numRSgImageTargetFormats)
		{
		ERR_PRINTF1(_L("No formats to iterate through!"));
		User::Leave(KErrArgument);		
		}
	
	TBool isGles2Supported = iEglSess->IsOpenGLES2Supported();
	for(TUint i=0; i < numRSgImageTargetFormats; i++)
		{
		//We are running thorugh all the possible "target" configurations because
		//they have one allowed pixel format less than the source has
		//so this test is expected to fail for EUidPixelFormatARGB_8888
		iSurfaceFormat			= iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,i);
		iSourceFormat 			= EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);
		
#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
		INFO_PRINTF1(_L("Trying usage bit ESgUsageBitOpenVgSurface"));
		iSgImageSurfaceUsage 	= ESgUsageBitOpenVgSurface;
#else
		INFO_PRINTF1(_L("Trying usage bit ESgUsageOpenVgTarget"));
		iSgImageSurfaceUsage 	= ESgUsageOpenVgTarget;
#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
		doTestPartialStepL();

		//if OpenGLES2 is not supported we must not succeed in creating SgImage
#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
		INFO_PRINTF1(_L("Trying usage bit ESgUsageVitOpenGles2Surface"));
		iSgImageSurfaceUsage    = ESgUsageBitOpenGles2Surface; 
		TRAPD(res, doTestPartialStepL());
		TESTL(res == (isGles2Supported ? KErrNone : KErrTEFUnitFail));
#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		//if OpenGLES2 is not supported we must not succeed in creating SgImage
#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
		INFO_PRINTF1(_L("Trying usage bit ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Surface"));
		iSgImageSurfaceUsage 	= ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Surface; 
		TRAP(res, doTestPartialStepL());
		TESTL(res == (isGles2Supported ? KErrNone : KErrTEFUnitFail));
#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
		INFO_PRINTF1(_L("Trying usage bit ESgUsageBitOpenVgImage"));
		iSgImageSurfaceUsage 	= ESgUsageBitOpenVgImage;
#else
		INFO_PRINTF1(_L("Trying usage bit ESgUsageOpenVgImage"));
		iSgImageSurfaceUsage 	= ESgUsageOpenVgImage;
#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
		doTestPartialStepL();
		}
	
	CleanupStack::PopAndDestroy(iniParser);
	CleanAll();
	
    RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

TVerdict CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestPartialStepL()
	{
	INFO_PRINTF1(_L("CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestPartialStepL"));
	PrintUsedPixelConfiguration();
		
	//Creating one RSgImage containing reference bitmap's contents
	INFO_PRINTF1(_L("Creating one RSgImage"));
	RSgImage sgImage;
	CleanupClosePushL(sgImage);
	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);
	TSgImageInfo imageInfo;
	imageInfo.iSizeInPixels = KPixmapSize;
	imageInfo.iPixelFormat = pixelFormat;
	imageInfo.iUsage = iSgImageSurfaceUsage;

	// Create a reference bitmap which we use to init the SgImage (we use index=4)
	TDisplayMode bitmapMode = EglTestConversion::VgFormatToDisplayMode(iSurfaceFormat);
	CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, 4);
	CleanupStack::PushL(bitmap);	
	ASSERT_EQUALS(sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);
	CleanupStack::PopAndDestroy(bitmap);
	bitmap = NULL;

	//create bitmap for further use
    bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    TSgImageInfo requestedImageInfo;
    sgImage.GetInfo(requestedImageInfo);

    TDisplayMode displayMode = EglTestConversion::PixelFormatToDisplayMode((TUidPixelFormat) (requestedImageInfo.iPixelFormat));
    TESTL(bitmap->Create(requestedImageInfo.iSizeInPixels, displayMode) == KErrNone);
	
	//Query all the config available on the display
	INFO_PRINTF1(_L("Calling eglGetConfigs, querying for the configs' number available on this display"));
	EGLint numConfigs;
	eglGetConfigs(iDisplay,NULL,0,&numConfigs);
	if(!numConfigs)
		{
		ERR_PRINTF1(_L("No available configs!"));
		CleanAll();
		User::Leave(KErrTEFUnitFail);
		}	
	
	//allocate a array to store all these configs and retrieve all the IDs	
	INFO_PRINTF2(_L("There are %d configs available on this display"),numConfigs);
	EGLConfig* configs = new(ELeave) EGLConfig[numConfigs];
	CleanupStack::PushL(configs);
	INFO_PRINTF1(_L("Calling eglGetConfigs, querying for all configs available on this display"));
	ASSERT_EGL_TRUE(eglGetConfigs(iDisplay,configs,KMaxEglConfigs,&numConfigs));		
	
	//"manually check" if a config is compatible with this RSgImage
    RArray<EGLint> compatibleConfigsIdsArray;
    CleanupClosePushL(compatibleConfigsIdsArray);
    RArray<EGLConfig> compatibleConfigsHandleArray;
    CleanupClosePushL(compatibleConfigsHandleArray);
  	for(TUint i=0;i<numConfigs;i++)
		{
		if(GetEglSess()->IsACompatibleConfig(configs[i],sgImage,EFalse))
			{
			compatibleConfigsHandleArray.AppendL(configs[i]);
			EGLint configID = 0;
			eglGetConfigAttrib(iDisplay, configs[i], EGL_CONFIG_ID, &configID);
			compatibleConfigsIdsArray.Append(configID);
            VERBOSE_INFO_PRINTF2(_L("Config %d is compatible"), configs[i]);
			}
		}
    const TInt numCompatibleConfigs = compatibleConfigsIdsArray.Count();  
	INFO_PRINTF2(_L("Of which %d are compatible with this RSgImage"),numCompatibleConfigs);

	//Setting the attributes list to EGL_MATCH_NATIVE_PIXMAP with value the handle to the RSgImage	
	const EGLint KAttrib_listFail[] = { EGL_MATCH_NATIVE_PIXMAP,NULL,EGL_NONE };
	const EGLint KAttrib_list[] = { EGL_MATCH_NATIVE_PIXMAP,(TInt)&sgImage,EGL_NONE };

	Mem::FillZ(configs, sizeof(EGLConfig)*numConfigs);
	
	//Ask all the configs eglChooseConfig thinks are compatible with this RSgImage
	//just a negative test
	INFO_PRINTF1(_L("Calling eglChooseConfig with the EGL_MATCH_NATIVE_PIXMAP flag set, but null pointer"));	
	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttrib_listFail,configs,numConfigs,&numConfigs) == EGL_FALSE);
	GetEglSess()->CheckExpectedErrorL(EGL_BAD_ATTRIBUTE);
	
	//actually retrieve those config
	INFO_PRINTF1(_L("Calling eglChooseConfig with the EGL_MATCH_NATIVE_PIXMAP flag set"));
	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttrib_list,configs,numConfigs,&numConfigs) == EGL_TRUE);

    RArray<EGLint> configsIdsArray;
    CleanupClosePushL(configsIdsArray);
    RArray<EGLConfig> configsHandleArray;
    CleanupClosePushL(configsHandleArray);
 	for(TUint i=0;i<numConfigs;i++)
        {
        configsHandleArray.Append(configs[i]);
        EGLint configID = 0;
        eglGetConfigAttrib(iDisplay, configs[i], EGL_CONFIG_ID, &configID);
        configsIdsArray.Append(configID);
        }

    INFO_PRINTF3(_L("Checking number of configs returned by eglChooseConfig: %d, number configs, calculated mannually: %d"), numConfigs, numCompatibleConfigs);
    ASSERT_EGL_TRUE(numConfigs <= numCompatibleConfigs);
    
	//Check if the config "manually checked" match with the ones eglChooseConfig returned
	TInt numFoundInConfig = 0; //signify, how many IDs from compatible configs matches 
	//to the IDs from config retreived by eglChooseConfig, where image is supplied as a native pixmap

	//check that all configs we checked previously mannually, have corresponding config retrieved via EGL API
	for(TUint i=0;i<numCompatibleConfigs;i++)
		{
		TBool found = EFalse;
	    if (configsIdsArray.Find(compatibleConfigsIdsArray[i]) != KErrNotFound)
            {
            found = ETrue;
            VERBOSE_INFO_PRINTF2(_L("Config %d It's compatible as expected!"),compatibleConfigsHandleArray[i]);
            numFoundInConfig++;
            }
		if(!found)
			{
			//Check whether we can create pixmap surface based on CFbsBitmap. 
			//If this succeeds the config was not intended to be used 
			//for RSgImage but CFbsBitmap, which is legitimate and we 
			//shall exclude this config from our consideration.
            EGLint EGL_RENDERABLE_TYPE_value = 0;
            eglGetConfigAttrib(iDisplay, compatibleConfigsHandleArray[i], EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value);
            const EGLint* KAttribs = ((pixelFormat == EUidPixelFormatARGB_8888_PRE) && (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
            EGLSurface surface = eglCreatePixmapSurface(iDisplay,compatibleConfigsHandleArray[i],bitmap,KAttribs);
            ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE);
            ASSERT_EGL_TRUE(eglDestroySurface(iDisplay,surface));
			}
		}
	TEST(numFoundInConfig==numConfigs);

	//now checking that eglCreatePixmapSurface returns a surface just with the proper configs
	//just the configs seen as compatible should allow to create a pixmap surface
	memset(configs,0,sizeof(EGLConfig)*numConfigs);
	
	INFO_PRINTF1(_L("Now testing eglCreatePixmapSurface"));	
	INFO_PRINTF1(_L("Calling eglGetConfigs, querying for all configs available on this display"));
	ASSERT_EGL_TRUE(eglGetConfigs(iDisplay,configs,KMaxEglConfigs,&numConfigs));

	configsHandleArray.Reset();
	configsIdsArray.Reset();
    for(TUint i=0;i<numConfigs;i++)
        {
        configsHandleArray.Append(configs[i]);
        EGLint configID = 0;
        eglGetConfigAttrib(iDisplay, configs[i], EGL_CONFIG_ID, &configID);
        configsIdsArray.Append(configID);
        }

	for(TUint i=0;i<numConfigs;i++)//iterates through all the configs available on this display
		{		
		EGLint EGL_SURFACE_TYPE_value = 0;
		EGLint EGL_RENDERABLE_TYPE_value = 0;
		eglGetConfigAttrib(iDisplay, configsHandleArray[i], EGL_SURFACE_TYPE, &EGL_SURFACE_TYPE_value);
		eglGetConfigAttrib(iDisplay, configsHandleArray[i], EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value);
		
		//bind the API to the renderable type of the config
		if (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)
			{
			eglBindAPI(EGL_OPENVG_API);
			}
		else
			{
			eglBindAPI(EGL_OPENGL_ES_API);
			}

		TBool found = EFalse;
	    if (compatibleConfigsIdsArray.Find(configsIdsArray[i]) != KErrNotFound)
            {
            found = ETrue;
            VERBOSE_INFO_PRINTF2(_L("Config %d It's compatible as expected!"),configsHandleArray[i]);
            numFoundInConfig++;
            }

	    if(EGL_SURFACE_TYPE_value & EGL_PIXMAP_BIT)	//we are interested just on pixmap surfaces
			{
			//we need to set the alpha bit value if we are using 16MAP sgImages and vgtarget
			const EGLint* KAttribs = ((pixelFormat == EUidPixelFormatARGB_8888_PRE) && (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
			EGLSurface surface = eglCreatePixmapSurface(iDisplay,configsHandleArray[i],&sgImage,KAttribs);
			if(surface != EGL_NO_SURFACE)
				{
				ASSERT_EGL_ERROR(EGL_SUCCESS);
				}
			else if (found)
				{
				//if EGL_NO_SURFACE and found,
				//we have to eliminate the case when it is possible to create pixmap surface based on CFbsBitmap. 
				//If this succeeds the config was not intended to be used 
				//for RSgImage but CFbsBitmap, which is legitimate and we 
				//shall exclude this config from our consideration.
				surface = eglCreatePixmapSurface(iDisplay,configsHandleArray[i],bitmap,KAttribs);
				ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE);
				ASSERT_EGL_ERROR(EGL_SUCCESS);
				}
			else 
				{
				// if EGL_NO_SURFACE and !found, then the error raised by eglCreatePixmapSurface must be EGL_BAD_MATCH
				ASSERT_EGL_ERROR(EGL_BAD_MATCH);
				}
			if(surface != EGL_NO_SURFACE)
				{
				ASSERT_EGL_TRUE(eglDestroySurface(iDisplay,surface));
				}
			}
		}
	
	// clean-up everything
	CleanupStack::PopAndDestroy(7, &sgImage); // the 4 arrays, config, bitmap, sgimage
	return TestStepResult();
	}


/**
@SYMTestCaseID GRAPHICS-EGL-0420

@SYMTestPriority 1

@SYMPREQ 2637

@SYMTestCaseDesc
Ensure that the system can tell the difference between an RSgImage and a CFbsBitmap.

@SYMTestActions
Cycling through 64K, 16MU and 16MAP.
 - For each pixel format, create a CFbsBitmap and pass it into eglChooseConfig() via EGL_MATCH_NATIVE_PIXMAP.
 - If eglChooseConfig() returns no results for any pixel format then that’s OK, as we are not mandating that 
   the EGL implementation supports CFbsBitmaps 
	- call eglCreatePixmapSurface() with the bitmap to check it returns a suitable error and doesn’t crash. 
	- If it doesn’t crash then we have started to demonstrate it recognises this is not an RSgImage.
	- This also ensures that we are not mandating any of the above pixel formats, just trying them out.
 - If eglChooseConfig() does return some results, then use each config to create a pixmap surface and draw something. 
	- This will check that eglCreatePixmapSurface() can tell the difference, as well as some very basic sanity checking.

@SYMTestExpectedResults
If eglChooseConfig() returns no results, that's ok as long as it doesn’t crash.
If eglChooseConfig() returns some results, eglCreatePixmapSurface(), a surface can be successfully created and used.
*/
TVerdict CEglTest_CFbsBitmap_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestStepL()
	{
	SetTestStepID(_L("GRAPHICS-EGL-0420"));
	INFO_PRINTF1(_L("CEglTest_CFbsBitmap_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);
	if(!ret)
		{
		// The extension is not supported
		RecordTestResultL();
		CloseTMSGraphicsStep();
		return TestStepResult();
		}

	// Create display object
	GetDisplayL();
	CreateEglSessionL();
	iEglSess->InitializeL();
    iEglSess->OpenSgDriverL();

	CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();
	CleanupStack::PushL(iniParser);
	TInt numPixmapFbsSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapFbsSurfaceFormats);
	if(!numPixmapFbsSurfaceFormats)
		{
		ERR_PRINTF1(_L("No formats to iterate through!"));
		User::Leave(KErrArgument);		
		}

	for(TUint i=0; i < numPixmapFbsSurfaceFormats; i++)
		{
		//We are running thorugh all the possible CFbsBitmap format configurations
		iSurfaceFormat = iniParser->GetVgFormat(KSectionPixmapFbsSurfaceFormats,i);
		iSourceFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);
		doTestPartialStepL();
		}

	CleanupStack::PopAndDestroy(iniParser);
	CleanAll();
	
    RecordTestResultL();
	CloseTMSGraphicsStep();
	return TestStepResult();
	}

TVerdict CEglTest_CFbsBitmap_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestPartialStepL()
	{
	INFO_PRINTF1(_L("CEglTest_CFbsBitmap_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestPartialStepL"));
	PrintUsedPixelConfiguration();

	//Creating one reference CFbsBitmap in the specified format
	INFO_PRINTF1(_L("Creating a CFbsBitmap..."));
    TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);
	CFbsBitmap* bitmap = GetEglSess()->CreateReferenceBitmapL(bitmapMode);
	CleanupStack::PushL(bitmap);	
	
	//Calling eglBindAPI
    ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));

	const EGLint KAttribList[] = {EGL_MATCH_NATIVE_PIXMAP, reinterpret_cast<EGLint>(bitmap), 
							 	  EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
							 	  EGL_SURFACE_TYPE, EGL_PIXMAP_BIT,
							 	  EGL_NONE };
	const EGLint* KPixmapAttribs = (iSourceFormat == EUidPixelFormatARGB_8888_PRE) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;

  	//Calling eglChooseConfig with the reference CFbsBitmap
	INFO_PRINTF1(_L("Calling eglChooseConfig with EGL_MATCH_NATIVE_PIXMAP to check if the system understands CFbsBitmaps..."));
	EGLConfig currentConfig;
	EGLint numconfigs=0;
    ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttribList,&currentConfig,1,&numconfigs))
    if (numconfigs==0)
    	{
    	//If eglChooseConfig() returns no results for any pixel format then that’s OK.
    	//This also ensures that we are not mandating any of the above pixel formats, just trying them out.
    	INFO_PRINTF1(_L("eglChooseConfig() returns no results for this pixel format. Continue the test"));
    	}
    else
    	{
    	//If eglChooseConfig() does return some results, then use config to create a pixmap surface and draw something
    	INFO_PRINTF1(_L("eglChooseConfig() returns a config for this pixel format. Do some sanity"));
    	EGLSurface surface = eglCreatePixmapSurface(iDisplay,currentConfig,bitmap,KPixmapAttribs);
    	ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE);
	    EGLContext context = eglCreateContext(iDisplay, currentConfig, EGL_NO_CONTEXT, NULL);
	    ASSERT_EGL_TRUE(context != EGL_NO_CONTEXT);
	    ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, surface, surface, context));

	    // Draw something to the surface
		VGfloat color[4] = { 1.0f, 0.f, 1.0f, 0.f };
		vgSetfv(VG_CLEAR_COLOR, 4, color);
		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);
		vgClear(0, 0, bitmap->SizeInPixels().iWidth, bitmap->SizeInPixels().iHeight);
		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);
    	INFO_PRINTF1(_L("Pixmap successfully created and drawn onto. Sanity check completed!"));

	    //destroy surface-context
	    ASSERT_EGL_TRUE(eglDestroySurface(iDisplay,surface));
    	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
    	}

	// clean-up everything
	CleanupStack::PopAndDestroy(bitmap);
	return TestStepResult();
	}