// 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 <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();

	}