// 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 "egltest_createpixmapsurface.h"

 #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

 #include <sgresource/sgimage.h>

 #else

 #include <graphics/sgimage.h>

 #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

 #include <test/tefunit.h> // for ASSERT macros

 #include <test/egltestcommonconversion.h>

 #include <test/egltestcommoninisettings.h>

 #include <test/egltestcommonsgimageinfo.h>

 /**

 @SYMTestCaseID GRAPHICS-EGL-0063

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 This test ensures the matching algorithm between EGLConfig and RSgImages when the RSgImage format is EUidPixelFormatARGB_8888_PRE.

 The algorithm is tested in both eglChooseConfig and eglCreatePixmap.

 @SYMTestActions

 Create an RSgImage format with the following parameters:

 * format: EUidPixelFormatARGB_8888_PRE

 * usage: ESgUsageBitOpenVgSurface

 Create second RSgImage format with the following parameters:

 * format: EUidPixelFormatXRGB_8888

 * usage: ESgUsageBitOpenVgSurface

 Query a compatible config via eglChooseConfig.

 If we get one compatible config check that is accepted by eglCreatePixmapSurface.

 1) call eglCreatePixmap with the just queried config and as attribute:

 	* EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_NONPRE

 	* as native pixmap format supply RSgImage with premultiply alpha   

 This call has to fail and give back a EGL_BAD_MATCH error.

 2) call eglCreatePixmapSurface with the just queried config and as attribute:

     * EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE

     * as native pixmap format supply RSgImage with non-premultiply alpha   

 This call has to fail and give back a EGL_BAD_MATCH error.

 3) call eglCreatePixmapSurface with the just queried config and as attribute:

 	* EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE

 This call has to succed.

 No memory or handle leaks.

 @SYMTestExpectedResults

 The first and second calls to eglCreatePixmapSurface have to fail and give back a EGL_BAD_MATCH error.

 The third call has to succed.

 No memory or handle leaks.

 */

 TVerdict CEglTest_CreatePixmapSurface_Alpha_bit_RSgImage::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0063"));

 	INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_Alpha_bit_RSgImage::doTestPartialStepL"));	

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// Create display object

 	GetDisplayL();

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

 	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(EUidPixelFormatARGB_8888_PRE);

     RSgImage sgImageWithPre;

     // Create a SgImage ARGB_8888_PRE

 	CleanupClosePushL(sgImageWithPre);

     ret = sgImageWithPre.Create(imageInfo, NULL, NULL);

     ASSERT_EQUALS(ret, KErrNone);

 	EGLint numConfigsWithPre = 0;		

 	EGLConfig configWithPre[KMaxEglConfigs];

 	const EGLint KAttrib_list_ImageWithPre[] = { EGL_MATCH_NATIVE_PIXMAP,	(TInt)&sgImageWithPre,

 												 EGL_RENDERABLE_TYPE, 		EGL_OPENVG_BIT,

 												 EGL_SURFACE_TYPE, 			EGL_PIXMAP_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT,

 												 EGL_NONE };

 	INFO_PRINTF1(_L("Calling eglChooseConfig with the EGL_MATCH_NATIVE_PIXMAP flag set"));

 	eglChooseConfig(iDisplay,KAttrib_list_ImageWithPre,configWithPre,KMaxEglConfigs,&numConfigsWithPre);

     if(!numConfigsWithPre)

         {

         ERR_PRINTF1(_L("No EGL Config with EGL_VG_ALPHA_FORMAT_PRE available for EUidPixelFormatARGB_8888_PRE"));

         SetTestStepResult(EFail);           

         }

 	for(TInt index = 0; index < numConfigsWithPre; index++)

 	    {

 	    INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENVG_API)"));

 	    ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));

 	    INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));

 		eglSess->SetExpectedError(EGL_BAD_MATCH);

 		EGLSurface surface = eglCreatePixmapSurface(iDisplay, configWithPre[index],&sgImageWithPre, KPixmapAttribsVgAlphaFormatNonPre);

 		if ( !eglSess->CheckExpectedError(EGL_FALSE) )

 			{

 			ERR_PRINTF1(_L("eglCreatePixmapSurface didn't fail as expected."));

 			SetTestStepResult(EFail);			

 			if(surface != EGL_NO_SURFACE)

 				{

 				eglDestroySurface(iDisplay,surface);

 				eglSess->CheckExpectedError(EGL_SUCCESS);

 				surface = EGL_NO_SURFACE;

 				}

 			}		

 		surface = eglCreatePixmapSurface(iDisplay, configWithPre[index],&sgImageWithPre, KPixmapAttribsVgAlphaFormatPre);

 		if ( !eglSess->CheckExpectedError(EGL_TRUE) )

 			{

 			ERR_PRINTF1(_L("eglCreatePixmapSurface failed."));

 			SetTestStepResult(EFail);			

 			}

 		if(surface != EGL_NO_SURFACE)

 			{

 			eglDestroySurface(iDisplay,surface);

 			eglSess->CheckExpectedError(EGL_SUCCESS);

 			surface = EGL_NO_SURFACE;

 			}		

 		}

 	CleanupStack::PopAndDestroy(2,eglSess);

 	TerminateDisplayL();

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0066

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Test passing a non-initialised RSgImage into eglCreatePixmapSurface()

 @SYMTestActions

 Initialise the thread to use RSgImage as the native pixmap type

 For each config returned from eglGetConfig() that supports OpenGLES or OpenVG rendering to pixmaps

 	*	Create an empty RSgImage object but do not initialize it

 	*	Use eglCreatePixmapSurface() to construct a surface from the RSgImage object.

 		o	Use a NULL attrib_list

 	*	Close the RSgImage object

 @SYMTestExpectedResults

 Check that eglCreatePixmapSurface() returns EGL_NO_SURFACE

 Check that eglGetError() returns EGL_BAD_NATIVE_PIXMAP

 Check for memory and handle leaks.

 */

 TVerdict CEglTest_CreatePixmapSurface_RSgImage_Negative_RSgImage_NotInitialised::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0066"));

 	INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_RSgImage_Negative_RSgImage_NotInitialised::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();

 	EGLConfig configs[KMaxEglConfigs];

 	EGLint numConfigs=0;

 	// Query number of configs available

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

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

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

 	ASSERT_TRUE(numConfigs >= 1);

 	ASSERT_TRUE(numConfigs <= KMaxEglConfigs);

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

 	// Get the configs

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

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

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

 		{

 		INFO_PRINTF2(_L("Getting Config Attributes for index %d"), index);

 		EGLint surfaceType=0;

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

 		if (!(surfaceType & EGL_PIXMAP_BIT))

 			{

 			// This is just an info print because we don't want to test surfaces that do not support pixmaps.

 			VERBOSE_INFO_PRINTF1(_L("Skipping config: Does not support pixmaps"));

 			continue;

 			}

 		EGLint renderableType=0;

 		RSgImage sgImage; // Deliberately don't initialise it

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

 		if (renderableType & EGL_OPENVG_BIT)

 			{

 			VERBOSE_INFO_PRINTF1(_L("...is OpenVg renderable"));

 			eglSess->OpenSgDriverL();

 			// Need to set the API type before creating the context (H/W requires this to be done before the surface is created, rather than the context)

 			VERBOSE_INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENVG_API)"));

 			ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));

 			// Create a pixmap surface from the native image

 			VERBOSE_INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));

 			EGLSurface surface = eglCreatePixmapSurface(iDisplay, configs[index], &sgImage, KPixmapAttribsNone);

 			// Expect this to fail

 			ASSERT_EQUALS(surface, EGL_NO_SURFACE);

 	 		ASSERT_EGL_ERROR(EGL_BAD_NATIVE_PIXMAP);

 			eglSess->CloseSgDriver();

 			}

 		if ((renderableType & EGL_OPENGL_ES_BIT) || (renderableType & EGL_OPENGL_ES2_BIT))

 			{

 			VERBOSE_INFO_PRINTF1(_L("...is OpenGles renderable"));

 			eglSess->OpenSgDriverL();

 			// Need to set the API type before creating the context (H/W requires this to be done before the surface is created, rather than the context)

 			VERBOSE_INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENGL_ES_API)"));

 			ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENGL_ES_API));

 			// Create a pixmap surface from the native image

 			VERBOSE_INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));

 			EGLSurface surface = eglCreatePixmapSurface(iDisplay, configs[index], &sgImage, KPixmapAttribsNone);

 			// Expect this to fail

 			ASSERT_EQUALS(surface, EGL_NO_SURFACE);

 	 		ASSERT_EGL_ERROR(EGL_BAD_NATIVE_PIXMAP);

 			eglSess->CloseSgDriver();

 			}

 		}	

 	CleanupStack::PopAndDestroy(eglSess);

 	TerminateDisplayL();

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0075

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Test that the system can detect obviously invalid pixmap objects 

 @SYMTestActions

 Try to create a pixmap surface from an odd integer

 @SYMTestExpectedResults

 This should fail with EGL_BAD_NATIVE_PIXMAP

 Check that all memory and handles have been deallocated.

 */

 TVerdict CEglTest_CreatePixmapSurface_Negative_Invalid_Pixmap_Type::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0075"));

 	INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_Negative_Invalid_Pixmap_Type::doTestStepL"));

 	// Create display object

 	GetDisplayL();

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	// Initialise the display object

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

     EGLConfig configs[KMaxEglConfigs];

 	EGLint numConfigs=0;

 	const EGLint KConfigAttribPixmapSurface[] = 

 		{

 		EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,

 		EGL_SURFACE_TYPE, EGL_PIXMAP_BIT,

 		EGL_NONE

 		};

 	// Query number of configs available

     INFO_PRINTF1(_L("Calling eglChooseConfig to get the number of configs available for pixmap surfaces..."));

 	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribPixmapSurface, NULL, KMaxTInt, &numConfigs));

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

 	ASSERT_TRUE(numConfigs >= 1);

 	ASSERT_TRUE(numConfigs <= KMaxEglConfigs);

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

 	// Get the configs

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

 	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribPixmapSurface, configs, KMaxEglConfigs, &numConfigs));

 	EGLint badPixmap=12345;

 	EGLSurface surface = eglCreatePixmapSurface(iDisplay, configs[0], &badPixmap, NULL);	

 	eglSess->SetExpectedError(EGL_BAD_NATIVE_PIXMAP);	

 	ASSERT_TRUE(eglSess->CheckExpectedError(surface));

 	CleanupStack::PopAndDestroy(eglSess);

 	TerminateDisplayL();

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0420

 @SYMTestPriority 1

 @SYMPREQ 2637

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Test the successful creation and use of a pixmap surface for all supporting configs.

 @SYMTestActions

 Initialize the thread to use RSgImage as the native pixmap type.

 For each supported combination of pixel mode and usage bits (see Graphics Resource documentation for detail)

 •   Create an SgImage

 •   Choose EGL config, supplying in attribute list as EGL_MATCH_NATIVE_PIXMAP the SgImage created on the previous step

 •   For each configuration obtained on the previous step and for three possible resource close rules (close SgImage late, close SgImage early, close SgDriver and SgImage early):

 o   Use eglCreatePixmapSurface() to construct a surface from the RSgImage object and make it current

 o   Make some basic drawing to the surface (fill the area with pre-defined  colour)

 o   Call eglWaitClient() to finish the above drawing instructions synchronously.

 o   Deallocate the surface and the pixmap

 @SYMTestExpectedResults

 There is at least one configuration available for all mandatory combinations of pixel formats and usage bits.

 Use EGL client API to check that the surface with underlying SgImage has the expected pixel data.

 */

 TVerdict CEglTest_CreatePixmapSurface_RSgImage_Positive_MantadoryFormatUsageSupport::doTestStepL()

     {

     SetTestStepID(_L("GRAPHICS-EGL-0420"));

     INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_RSgImage_Positive_MantadoryFormatUsageSupport::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// Create display object

 	GetDisplayL();

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

     // Initialise ini parser

     CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();

     CleanupStack::PushL(iniParser);

     TInt numPixmapSgSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);

 #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

     const EGLint KSgPixmapUsageSupport[] =

         {

         ESgUsageBitOpenVgSurface,         

         ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface,

         ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Texture2D,

         ESgUsageBitOpenVgSurface | ESgUsageBitOpenVgImage| ESgUsageBitOpenGles2Texture2D,

         ESgUsageBitOpenGles2Surface,

         ESgUsageBitOpenGles2Surface | ESgUsageBitOpenVgImage,

         ESgUsageBitOpenGles2Texture2D |ESgUsageBitOpenGles2Surface,

         ESgUsageBitOpenVgImage | ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface

         };

     for(TInt i = 0; i < numPixmapSgSurfaceFormats; i++)

         {

         VGImageFormat surfaceFormat = iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,i);

         TSgImageInfoTest imageInfo = TSgImageInfoTest();

         imageInfo.iPixelFormat = EglTestConversion::VgFormatToSgPixelFormat(surfaceFormat);;

         EGLint alphaPreBit = (imageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE) ? EGL_VG_ALPHA_FORMAT_PRE_BIT : 0;

         TInt numUsageCombinations = sizeof(KSgPixmapUsageSupport) / sizeof(KSgPixmapUsageSupport[0]);

         for(TUint32 j = 0; j < numUsageCombinations; j++)

             {

             if(KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface))

                 {

                 if(!eglSess->IsOpenGLES2Supported())

                     continue;

                 }

             if(KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGlesTexture2D | ESgUsageBitOpenGlesSurface))

                 {

                 if(!eglSess->IsOpenGLESSupported())

                     continue;

                 }

             imageInfo.iUsage = KSgPixmapUsageSupport[j]; 

             RSgImage image;

             ASSERT_EQUALS(image.Create(imageInfo, NULL, NULL), KErrNone);

             CleanupClosePushL(image);

             TSgImageInfoTest imageInfoSupported; 

             ASSERT_EQUALS(image.GetInfo(imageInfoSupported), KErrNone);//returned info may include more usage bits than we actually requested

             if(((imageInfoSupported.iUsage & (ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface)) && 

                                (!eglSess->IsOpenGLES2Supported()) ||

                 ((imageInfoSupported.iUsage & (ESgUsageBitOpenGlesTexture2D | ESgUsageBitOpenGlesSurface)) && 

                                (!eglSess->IsOpenGLESSupported()))))

                 {

                 CleanupStack::PopAndDestroy(&image);

                 continue;

                 }	

             EGLint eglRenderableTypeValue = 0;

             if(imageInfoSupported.iUsage & ESgUsageBitOpenVgSurface)

                 {

                 eglRenderableTypeValue = EGL_OPENVG_BIT;

                 }

             else if(imageInfoSupported.iUsage & ESgUsageBitOpenGles2Surface)

                 {

                 eglRenderableTypeValue = EGL_OPENGL_ES2_BIT;

                 }

             else if(imageInfoSupported.iUsage & ESgUsageBitOpenGlesSurface)

                 {

                 eglRenderableTypeValue = EGL_OPENGL_ES_BIT;

                 }

             else if(imageInfoSupported.iUsage & ESgUsageBitOpenGlSurface)

                 {

                 eglRenderableTypeValue = EGL_OPENGL_BIT;

                 }

             TEST(eglRenderableTypeValue != 0);

             // only minimum amount of renderable type matching to Native pixmap will be passed into attribute list.

             // And egl will decide whatever configs include at least given renderable type.

             const EGLint KAttrib_list[] = { EGL_MATCH_NATIVE_PIXMAP, reinterpret_cast<EGLint>(&image),

 											EGL_RENDERABLE_TYPE, eglRenderableTypeValue,

 											EGL_SURFACE_TYPE, EGL_PIXMAP_BIT | alphaPreBit,

 											EGL_NONE };     

             EGLConfig configs[KMaxEglConfigs];

             EGLint numConfigs=0;

             ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttrib_list,configs, KMaxEglConfigs,&numConfigs));

             CleanupStack::PopAndDestroy(&image);

             TEST(numConfigs > 0);

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

                 {

                 const TInt numCloseRules = 3; 

                 for(TInt closeRule = 0; closeRule < numCloseRules; closeRule++)

                     {

                     CTestEglSession::TResourceCloseRule resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;

                     switch(closeRule)

                         {

                     case 0:

                         VERBOSE_INFO_PRINTF1(_L("Close Image Late"));

                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;

                         break;

                     case 1:

                         VERBOSE_INFO_PRINTF1(_L("Close Image Early"));

                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageEarly;

                         break;

                     case 2:

                         VERBOSE_INFO_PRINTF1(_L("Close Sg Driver and Image Early"));

                         resourceCloseRule = CTestEglSession::EResourceCloseSgDriverAndImageEarly;

                         break;

                     default:

                         break;

                         }

                     if (KSgPixmapUsageSupport[j] & ESgUsageBitOpenVgSurface)

                         {

                         VERBOSE_INFO_PRINTF1(_L("...is OpenVG renderable"));

                         eglSess->TryUsePixmapRSgImageOpenVgL(configs[index], imageInfo, resourceCloseRule); // we can't fail to create an image as we have already tried it 

                         }

                     if (KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGlesSurface | ESgUsageBitOpenGlesTexture2D))

                         {

                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES renderable"));

                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 1); // we can't fail to create an image as we have already tried it

                         }

                     if (KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGles2Surface | ESgUsageBitOpenGles2Texture2D))

                         {

                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES2 renderable"));

                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 2); // we can't fail to create an image as we have already tried it

                         }

                     }//for(TInt closeRule; closeRule < numCloseRules; closeRule++)

                 }//for(TInt index = 0; index < numConfigs; index++)

             }//for(TUint32 j = 0; j < numUsageCombinations; j++)

         }//for(TInt i = 0; i < numSgImagePixelFormatSupport; i++)

 #else

     const EGLint KSgPixmapUsageSupport[] =

         {

         ESgUsageOpenVgTarget,         

         ESgUsageOpenVgImage | ESgUsageOpenVgTarget,

         ESgUsageOpenVgTarget | ESgUsageOpenGles2Texture2D,

         ESgUsageOpenVgTarget | ESgUsageOpenVgImage| ESgUsageOpenGles2Texture2D,

         ESgUsageOpenGles2Target,

         ESgUsageOpenGles2Target | ESgUsageOpenVgImage,

         ESgUsageOpenGles2Texture2D |ESgUsageOpenGles2Target,

         ESgUsageOpenVgImage | ESgUsageOpenGles2Texture2D | ESgUsageOpenGles2Target

         };

     for(TInt i = 0; i < numPixmapSgSurfaceFormats; i++)

         {

         VGImageFormat surfaceFormat = iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,i);

         TSgImageInfoTest imageInfo = TSgImageInfoTest();

         imageInfo.iPixelFormat = EglTestConversion::VgFormatToSgPixelFormat(surfaceFormat);;

         EGLint alphaPreBit = (imageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE) ? EGL_VG_ALPHA_FORMAT_PRE_BIT : 0;

         TInt numUsageCombinations = sizeof(KSgPixmapUsageSupport) / sizeof(KSgPixmapUsageSupport[0]);

         for(TUint32 j = 0; j < numUsageCombinations; j++)

             {

             if(KSgPixmapUsageSupport[j] & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGles2Target))

                 {

                 if(!eglSess->IsOpenGLES2Supported())

                     continue;

                 }

             if(KSgPixmapUsageSupport[j] & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGlesTarget))

                 {

                 if(!eglSess->IsOpenGLESSupported())

                     continue;

                 }

             imageInfo.iUsage = KSgPixmapUsageSupport[j]; 

             RSgImage image;

             ASSERT_EQUALS(image.Create(imageInfo, NULL, NULL), KErrNone);

             CleanupClosePushL(image);

             TSgImageInfoTest imageInfoSupported; 

             ASSERT_EQUALS(image.GetInfo(imageInfoSupported), KErrNone);//returned info may include more usage bits than we actually requested

             if(((imageInfoSupported.iUsage & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGles2Target)) && 

                                (!eglSess->IsOpenGLES2Supported()) ||

                 ((imageInfoSupported.iUsage & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGlesTarget)) && 

                                (!eglSess->IsOpenGLESSupported()))))

                 {

                 CleanupStack::PopAndDestroy(&image);

                 continue;

                 }   

             EGLint eglRenderableTypeValue = 0;

             if(imageInfoSupported.iUsage & ESgUsageOpenVgTarget)

                 {

                 eglRenderableTypeValue = EGL_OPENVG_BIT;

                 }

             else if(imageInfoSupported.iUsage & ESgUsageOpenGles2Target)

                 {

                 eglRenderableTypeValue = EGL_OPENGL_ES2_BIT;

                 }

             else if(imageInfoSupported.iUsage & ESgUsageOpenGlesTarget)

                 {

                 eglRenderableTypeValue = EGL_OPENGL_ES_BIT;

                 }

             TEST(eglRenderableTypeValue != 0);

             // only minimum amount of renderable type matching to Native pixmap will be passed into attribute list.

             // And egl will decide whatever configs include at least given renderable type.

             const EGLint KAttrib_list[] = { EGL_MATCH_NATIVE_PIXMAP, reinterpret_cast<EGLint>(&image),

                                             EGL_RENDERABLE_TYPE, eglRenderableTypeValue,

                                             EGL_SURFACE_TYPE, EGL_PIXMAP_BIT | alphaPreBit,

                                             EGL_NONE };     

             EGLConfig configs[KMaxEglConfigs];

             EGLint numConfigs=0;

             ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttrib_list,configs, KMaxEglConfigs,&numConfigs));

             CleanupStack::PopAndDestroy(&image);

             TEST(numConfigs > 0);

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

                 {

                 const TInt numCloseRules = 3; 

                 for(TInt closeRule = 0; closeRule < numCloseRules; closeRule++)

                     {

                     CTestEglSession::TResourceCloseRule resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;

                     switch(closeRule)

                         {

                     case 0:

                         VERBOSE_INFO_PRINTF1(_L("Close Image Late"));

                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;

                         break;

                     case 1:

                         VERBOSE_INFO_PRINTF1(_L("Close Image Early"));

                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageEarly;

                         break;

                     case 2:

                         VERBOSE_INFO_PRINTF1(_L("Close Sg Driver and Image Early"));

                         resourceCloseRule = CTestEglSession::EResourceCloseSgDriverAndImageEarly;

                         break;

                     default:

                         break;

                         }

                     if (KSgPixmapUsageSupport[j] & ESgUsageOpenVgTarget)

                         {

                         VERBOSE_INFO_PRINTF1(_L("...is OpenVG renderable"));

                         eglSess->TryUsePixmapRSgImageOpenVgL(configs[index], imageInfo, resourceCloseRule); // we can't fail to create an image as we have already tried it 

                         }

                     if (KSgPixmapUsageSupport[j] & (ESgUsageOpenGlesTarget | ESgUsageOpenGles2Texture2D))

                         {

                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES renderable"));

                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 1); // we can't fail to create an image as we have already tried it

                         }

                     if (KSgPixmapUsageSupport[j] & (ESgUsageOpenGles2Target | ESgUsageOpenGles2Texture2D))

                         {

                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES2 renderable"));

                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 2); // we can't fail to create an image as we have already tried it

                         }

                     }//for(TInt closeRule; closeRule < numCloseRules; closeRule++)

                 }//for(TInt index = 0; index < numConfigs; index++)

             }//for(TUint32 j = 0; j < numUsageCombinations; j++)

         }//for(TInt i = 0; i < numSgImagePixelFormatSupport; i++)

  #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

     CleanupStack::PopAndDestroy(2, eglSess);//iniParser, eglSess

     TerminateDisplayL();

     RecordTestResultL();

     CloseTMSGraphicsStep();

     return TestStepResult();

     }