// Copyright (c) 2007-2010 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_image.h"

 #include <iniparser.h>

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

 #include <test/egltestcommonconversion.h>

 #include <test/egltestcommoninisettings.h>

 #include <test/egltestcommonsgimageinfo.h>

 /**

 @SYMTestCaseID GRAPHICS-EGL-0107

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Tests the use of an EglImageKHR object with OpenVG, using the “EGL_IMAGE_PRESERVED” attribute.

 This means we can draw to the source RSgImage as soon as it is created.

 @SYMTestActions

 This test will check for the “VG_KHR_EGL_image” extension, if it is not supported on this platform then the test will return immediately without failure.

 Create a reference Bitmap

 Create and fully construct an RSgImage object having the same content as the reference bitmap

 •	Set the iUsage bit to ESgUsageBitOpenVgImage

 Pass the RSgImage object into eglCreateImageKHR() with

 •	The target parameter set to EGL_NATIVE_PIXMAP_KHR

 •	Use the current display and EGL_NO_CONTEXT

 •	Use the “EGL_IMAGE_PRESERVED” attribute

 Check that eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR

 Create and make current and EGL context bound to OVG APIs and linked to a pixmap surface.

 •	Set the iUsage bit of the underlying RSgImage to ESgUsageBitOpenVgSurface 

 Use vgCreateEGLImageTargetKHR() to construct a VGImage object from the EGLImage.

 •	Check for errors

 Use OpenVG to copy  the VGImage created from the EGLImage to the new pixmap surface currently linked to the context.

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

 Destroy the original image data

 •	Pass the VGImage into vgDestroyImage()

 •	Pass the EGLImage into eglDestroyImageKHR()

 •	Close the RSgImage

 Check that the pixmap contains expected pixel values.

 Destroy the pixmap

 Check for memory and handle leaks

 @SYMTestExpectedResults

 eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR

 After each call to an OpenVG method, check that vgGetError() returns VG_NO_ERROR

 The pixmap contains expected pixel values after the original image data has been destroyed

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_RSgImage_UseOpenVG_PersistImageData::doTestStepL()

 	{

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

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

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

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// This test is performed for default pixel format

 	PrintUsedPixelConfiguration();

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	// Create RSgImage's attributes.

 	//This image will become a VGImage. It will be Cleared via vgClear

 	TSgImageInfoTest imageInfo = TSgImageInfoTest(iSourceFormat, KPixmapSize);

 #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

 	imageInfo.iUsage = 	ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface;

 #else

 	imageInfo.iUsage =  ESgUsageOpenVgImage | ESgUsageOpenVgTarget;	

 #endif	

 	INFO_PRINTF1(_L("Creating an RSgImage"));

 	RSgImage sgImage;

 	CleanupClosePushL(sgImage);

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

 	ASSERT_EQUALS(ret, KErrNone);

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

 	ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));

     EGLint numConfigsWithPre = 0;       

     EGLConfig configWithPre;

     const EGLint KAttribImagePre[] = { EGL_MATCH_NATIVE_PIXMAP,  reinterpret_cast<EGLint>(&sgImage),

                                        EGL_RENDERABLE_TYPE,      EGL_OPENVG_BIT,

                                        EGL_SURFACE_TYPE,         EGL_PIXMAP_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT,

                                        EGL_NONE };

     ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KAttribImagePre, &configWithPre, 1, &numConfigsWithPre));

 	// Create a pixmap surface from the native image

 	INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));

 	EGLSurface surface = eglCreatePixmapSurface(iDisplay, configWithPre, &sgImage, KPixmapAttribsVgAlphaFormatPre );

 	ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE);

 	// Create a context for drawing to/reading from the pixmap surface and make it current

 	INFO_PRINTF1(_L("Calling eglCreateContext"));

 	EGLContext context = eglCreateContext(iDisplay, configWithPre, EGL_NO_CONTEXT, NULL);

 	ASSERT_EGL_TRUE(context != EGL_NO_CONTEXT);

 	INFO_PRINTF1(_L("Calling eglMakeCurrent"));

 	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, surface, surface, context));

 	//Drawing to the current surface (and hence to the RSgImage) to test that the contents are preserved

 	//create a reference bitmap to use the values (we use index=1) 

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

 	CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 1);

 	CleanupStack::PushL(bitmap);

     // Mind the fact that CFbsBitmap and VGImages use different coordinates origin!

 	TSize bitmapSize = bitmap->SizeInPixels();

 	TUint8* address = reinterpret_cast<TUint8*>(bitmap->DataAddress());

 	TInt stride = bitmap->DataStride();

 	address += (bitmapSize.iHeight - 1) * stride;

 	vgWritePixels(address, -stride, KDefaultSurfaceFormat,0,0, bitmapSize.iWidth, bitmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();   // wait for writing to finish

    	ASSERT_EGL_TRUE(eglDestroySurface(iDisplay, surface));				//Destroying Surface handle

 	INFO_PRINTF1(_L("Create a EGLImage out of the SgImage"));

 	EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR);

 	INFO_PRINTF1(_L("Create a VGImage out of the EGLImage"));

 	VGImage vgImageTarget = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR);

 	ASSERT_VG_TRUE(vgImageTarget != VG_INVALID_HANDLE);

 	//Create an OffScreen Pixmap to be used as an OpenVg target using the same config of the previous RSgImage

 	//except for Usage

 	imageInfo.iSizeInPixels = KPixmapSize;

 #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

 	imageInfo.iUsage = ESgUsageBitOpenVgSurface;

 #else

 	imageInfo.iUsage = ESgUsageOpenVgTarget;

 #endif

 	RSgImage sgImageTarget;

 	CleanupClosePushL(sgImageTarget);

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

 	ASSERT_EQUALS(ret, KErrNone);

 	surface = eglCreatePixmapSurface(iDisplay, configWithPre, &sgImageTarget, KPixmapAttribsVgAlphaFormatPre);

 	ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE);

 	INFO_PRINTF1(_L("Calling eglMakeCurrent"));

 	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, surface, surface, context));

     //Copy the source VGImage to the surface

 	vgSetPixels(0, 0, vgImageTarget, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();

 	vgDestroyImage(vgImageTarget);										//Destroying VGImage handle

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR));		//Destroying EGLImage handle

 	sgImage.Close();													//Destroying SgImage and so the actual data

 	// we can now compare the VgImage to the one we would expect for this particular process

 	iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 	ASSERT_EGL_TRUE(eglDestroyContext(iDisplay, context));				//Closing eglContext

 	ASSERT_EGL_TRUE(eglDestroySurface(iDisplay,surface));				//Destroying Target Surface handle

 	sgImageTarget.Close();												//Destroying 2nd RSgImage handle

 	//cleanup

 	CleanupStack::PopAndDestroy(3,&sgImage); // sgImage, bitmap, sgImageTarget 

 	CleanAll();

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0108

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Ensure that if there are more than one EGLImage and some of them are destroyed,

 the other images remain workable

 @SYMTestActions

 Create a reference Bitmap

 Create and fully construct 4 RSgImage objects having the same content as the reference bitmap

 •	Set the iUsage bit to ESgUsageBitOpenVgImage

 Pass the 4 RSgImage objects into eglCreateImageKHR() with

 •	The target parameter set to EGL_NATIVE_PIXMAP_KHR

 •	Use the current display and EGL_NO_CONTEXT

 •	Use a NULL attr_list

 Check that those calls to eglCreateImageKHR() do NOT return EGL_NO_IMAGE_KHR

 Create and make current and EGL context bound to OVG APIs and linked to a pixmap surface.

 •	Set the iUsage bit of the underlying RSgImage to ESgUsageBitOpenVgSurface

 Use vgCreateEGLImageTargetKHR() to construct VGImage objects from the just created EGLImages.

 •	Check for errors

 Destroy all the RSgImages.

 Pass the 2nd and the 3rd EGLImeges to eglDestroyImageKHR().

 Call vgDestroyImage on the 2nd VGImage too.

 Use OpenVG to draw the VGImage created from the 4th EGLImage to the new pixmap surface currently linked to the context.

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

 Check that the pixmap contains expected pixel values.

 Clear the destination surface to the default background color

 Use OpenVG to draw the VGImage created from the 3rd EGLImage to the new pixmap surface currently linked to the context.

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

 Check that the pixmap contains expected pixel values.

 Clear the destination surface to the default background color

 Destroy and restore the 4th VGImage and copy it to the pixmap surface.

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

 Check that the pixmap contains expected pixel values.

 Pass all the VGImages left into vgDestroyImage()

 Pass the EGLImage left into eglDestroyImageKHR()

 Destroy the pixmap

 Check for memory and handle leaks

 @SYMTestExpectedResults

 Pixmap surface has the expected contents

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_Consistent_Linked_List::doTestStepL()

 	{

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

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

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

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// This test is performed for default pixel format

 	PrintUsedPixelConfiguration();

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	// Create a reference bitmap which we use to init the SgImage (we use index=6)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

 	CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 6);

 	CleanupStack::PushL(bitmap);

 	INFO_PRINTF1(_L("Creating 4 RSgImages"));

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize);

 	RSgImage sgImage1;

 	CleanupClosePushL(sgImage1);

 	ASSERT_EQUALS(sgImage1.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

 	RSgImage sgImage2;

 	CleanupClosePushL(sgImage2);

 	ASSERT_EQUALS(sgImage2.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

 	RSgImage sgImage3;

 	CleanupClosePushL(sgImage3);

 	ASSERT_EQUALS(sgImage3.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

 	RSgImage sgImage4;

 	CleanupClosePushL(sgImage4);

 	ASSERT_EQUALS(sgImage4.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

 	INFO_PRINTF1(_L("Creating 4 EGLImages"));

 	EGLImageKHR imageKHR1 = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage1, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR1 != EGL_NO_IMAGE_KHR);

 	EGLImageKHR imageKHR2 = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage2, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR2 != EGL_NO_IMAGE_KHR);

 	EGLImageKHR imageKHR3 = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage3, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR3 != EGL_NO_IMAGE_KHR);

 	EGLImageKHR imageKHR4 = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage4, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR4 != EGL_NO_IMAGE_KHR);

 	//Create a Surface and Link it to a Context bound to OpenVG

 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

 	TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

 	iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo2, CTestEglSession::EResourceCloseSgImageEarly);

     INFO_PRINTF1(_L("Creating 4 VGImages from the four EGLImages"));

 	VGImage vgImage1 = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR1);

 	ASSERT_VG_TRUE(vgImage1 != VG_INVALID_HANDLE);

 	VGImage vgImage2 = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR2);

 	ASSERT_VG_TRUE(vgImage2 != VG_INVALID_HANDLE);

 	VGImage vgImage3 = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR3);

 	ASSERT_VG_TRUE(vgImage3 != VG_INVALID_HANDLE);

 	VGImage vgImage4 = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR4);

 	ASSERT_VG_TRUE(vgImage4 != VG_INVALID_HANDLE);

 	INFO_PRINTF1(_L("Destroying all RSgImage, the 2nd and the 3rd EGLImage, the 2nd VGImage"));

 	CleanupStack::PopAndDestroy(4, &sgImage1); 							// closes the 4 RSgImages

 	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR2));	//Destroying 2nd EGLImage handle

 	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR3));	//Destroying 3rd EGLImage handle

 	vgDestroyImage(vgImage2);											//Destroying 2nd VGImage handle

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	//Copy the source VGImage to the surface

 	INFO_PRINTF1(_L("Drawing the 4th VGImage content to the surface"));

 	vgSetPixels(0, 0, vgImage4, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();

     iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 	INFO_PRINTF1(_L("Content is as expected"));

 	INFO_PRINTF1(_L("Clear the surface and draw the 3rd VGImage content to the surface"));

 	VGfloat bgColor[] = {0.25, 0.50, 0.75, 1.0}; // random opaque colour

 	vgSetfv(VG_CLEAR_COLOR, 4, bgColor);

 	vgClear(0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

 	vgSetPixels(0, 0, vgImage3, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();

     iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 	INFO_PRINTF1(_L("Content is as expected"));

 	INFO_PRINTF1(_L("Clear the surface, destroy the 4th VGImage and, after having it set up again, copy its content to the surface"));

 	vgSetfv(VG_CLEAR_COLOR, 4, bgColor);

 	vgClear(0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

 	vgDestroyImage(vgImage4);													//Destroying 4th VGImage handle

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	vgImage4 = VG_INVALID_HANDLE;

 	vgImage4 = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR4);		//Creating 4th image again

 	ASSERT_VG_TRUE(vgImage4 != VG_INVALID_HANDLE);

 	vgSetPixels(0, 0, vgImage4, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();

     iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 	INFO_PRINTF1(_L("Content is as expected"));

 	INFO_PRINTF1(_L("Destroying remaining images"));

 	vgDestroyImage(vgImage1);											//Destroying 1st VGImage handle

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	vgDestroyImage(vgImage3);											//Destroying 3rd VGImage handle

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	vgDestroyImage(vgImage4);											//Destroying 4th VGImage handle

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR1));	//Destroying 1st EGLImage handle

 	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR4));	//Destroying 4th EGLImage handle

 	//cleanup

 	CleanupStack::PopAndDestroy(bitmap);

 	CleanAll();

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0112

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Ensure that the EGL implementation holds a handle to the SgDriver.

 In this way all the resource may be used even though a call to SgDriver::Close() has been made.

 @SYMTestActions

 Create a RSgImage with the same content as the reference bitmap.

 Create a EGLImage from the RSgImage.

 Close the SgDriver.

 Create a pbuffer surface, a context and make them current.

 Create a VGImage from the eglImage.

 Copy the VGImage to the surface.

 Check the contents

 Release all resources.

 @SYMTestExpectedResults

 If creation of pbuffer fails, silently terminate the test without failing, as it is not mandatory to support

 a pbuffer format.

 The surface contains the expected contents. 

 No memory or handle leaks.

 */

 TVerdict CEglTest_EGL_Image_SgDriverHandle::doTestStepL()

 	{

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

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

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

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// This test is performed for default pixel format

 	PrintUsedPixelConfiguration();

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	RSgImage sgImage;

 	CleanupClosePushL(sgImage);

 	// Create a reference bitmap which we use to init the SgImage (we use index=6)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

 	CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 6);

 	CleanupStack::PushL(bitmap);

 	INFO_PRINTF1(_L("Creating 1 RSgImage"));

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize);

 	ASSERT_EQUALS(sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

 	CleanupStack::PopAndDestroy(bitmap);

 	INFO_PRINTF1(_L("Creating 1 EGLImage from the RSgImage"));

 	EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR);

 	//close SgImage before closing the SgDriver

 	CleanupStack::PopAndDestroy(&sgImage);

 	INFO_PRINTF1(_L("Closing the SgDriver now should cause no difference"));

 	iEglSess->CloseSgDriver();

 	// If create pbuffer surface fails, don't fail if there's no matching config (but fail in any other situation):

     //		Support for a pbuffer surface is not mandated for any pixel format

     //		We should not enforce it in the tests

     //		Silently terminate the test without failing.

 	TEglTestConfig pbufferFormat = EglTestConversion::VgFormatToPBufferSurfaceFormat(iSurfaceFormat);

 	EGLConfig currentConfig = 0;

 	TRAPD(res, currentConfig = iEglSess->GetConfigExactMatchL( pbufferFormat ));

 	if(res == KTestNoMatchingConfig)

 	    {

 		WARN_PRINTF2(_L("Can't create pbuffer, format %d. Terminating the test without failing"), pbufferFormat);

 		ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR));

 		CleanAll();

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 	    }

     User::LeaveIfError(res); // leave here if any other error was raised other than the one above.

 	iEglSess->CreatePbufferSurfaceAndMakeCurrentL(currentConfig, KPixmapSizeBigger, EGL_OPENVG_API);

 	INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage"));

 	VGImage vgImage = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR);

 	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

     INFO_PRINTF1(_L("Copying the VGImage to the surface"));

 	vgSetPixels(0, 0, vgImage, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();

 	// Re-create a reference bitmap which we use to init the SgImage (we use index=6)

 	CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 6);

 	CleanupStack::PushL(refBitmap);

 	iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

 	CleanupStack::PopAndDestroy(refBitmap);

 	INFO_PRINTF1(_L("Content is as expected"));

 	// destroy eglimage and vgimage

 	vgDestroyImage(vgImage);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR));

 	//cleanup

 	CleanAll();

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}