--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/src/egltest_image.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,501 @@
+// 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_image.h"
+
+#ifndef __INIPARSER_H__
+#include <cinidata.h>
+#endif // __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);
+   	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();
+	}
+