diff -r 000000000000 -r 5d03bc08d59c egl/egltest/src/egltest_image_negative.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/egl/egltest/src/egltest_image_negative.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,639 @@ +// 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 // for ASSERT macros + +#include "egltest_image_negative.h" + +#include +#include + +/** +@SYMTestCaseID GRAPHICS-EGL-0126 + +@SYMTestPriority 1 + +@SYMPREQ 39 + +@SYMREQ See SGL.GT0386.401 document + +@SYMTestCaseDesc +Test that eglCreateImageKHR() fails and returns the correct error +when one of the parameters other than “Target” has an invalid value. +The value of the “Target” parameter must always be EGL_NATIVE_PIXMAP_KHR + +@SYMTestActions +• Call eglCreateImageKHR() with NULL instead of a valid RSgImage handle +• Create a not fully constructed RSgImage object (i.e. do not call RSgImage::Create() )and pass its handle when calling eglCreateImageKHR(). +• Fully construct an RSgImage and call eglCreateImageKHR() with a valid egl context +• Call eglCreateImageKHR() with a non valid target (meaningless number instead of EGL_NATIVE_PIXMAP_KHR) +• Call eglCreateImageKHR() with diplay = EGL_NO_DISPLAY +• Call eglCreateImageKHR() with a meaningless number in place of iDisplay +Destroy the RSgImage object + + +@SYMTestExpectedResults +eglCreateImageKHR() returns EGL_NO_IMAGE_KHR in all cases +• And an EGL_BAD_PARAMETER error is generated in all cases but the last +• The last case should generate EGL_BAD_DISPLAY error +No memory or handle leaks +*/ +TVerdict CEglTest_EGL_Image_eglCreateImage_Bad_Parameter::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0126")); + INFO_PRINTF1(_L("CEglTest_EGL_Image_eglCreateImage_Bad_Parameter::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(); + + INFO_PRINTF1(_L("Creating one EGLImage from a NULL RSgImage")); + EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, NULL, KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + INFO_PRINTF1(_L("Creating one EGLImage from a not fully constructed RSgImage")); + RSgImage sgImage; + CleanupClosePushL(sgImage); + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + // Create an RSgImage with proper attributes + TSgImageInfo imageInfo; + imageInfo.iSizeInPixels = KPixmapSize; + imageInfo.iPixelFormat = iSourceFormat; +#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo.iUsage = ESgUsageBitOpenVgImage; +#else + imageInfo.iUsage = ESgUsageOpenVgImage; + imageInfo.iShareable = EFalse; + imageInfo.iCpuAccess = ESgCpuAccessReadWrite; + //imageInfo.iMutable = ETrue; + imageInfo.iScreenId = KSgScreenIdMain; + imageInfo.iUserAttributes = NULL; + imageInfo.iUserAttributeCount=0; +#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + + ASSERT_EQUALS(sgImage.Create(imageInfo, NULL, NULL), KErrNone); + + //Creating a Valid Context + INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENVG_API)")); + ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API)); + + INFO_PRINTF1(_L("Calling eglCreateContext")); + TEglTestConfig pixmapFormat = EglTestConversion::VgFormatToPixmapSgSurfaceFormat(iSurfaceFormat); + EGLConfig currentConfig = iEglSess->GetConfigExactMatchL(pixmapFormat); + EGLContext context = eglCreateContext(iDisplay, currentConfig, EGL_NO_CONTEXT, NULL); + ASSERT_EGL_TRUE(context != EGL_NO_CONTEXT); + + INFO_PRINTF1(_L("Calling with a valid context instead of EGL_NO_CONTEXT")); + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,context,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + INFO_PRINTF1(_L("Calling with a non valid target, using registered by meaningless in this context number - EGL_RENDERABLE_TYPE")); + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT, EGL_RENDERABLE_TYPE,&sgImage,KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + INFO_PRINTF1(_L("Calling with a non valid target, using registered by meaningless in this context number - EGL_RENDERABLE_TYPE, and a valid context too")); + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,context,EGL_RENDERABLE_TYPE,&sgImage,KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + INFO_PRINTF1(_L("Calling with a display set to EGL_NO_DISPLAY")); + imageKHR = iEglSess->eglCreateImageKhrL(EGL_NO_DISPLAY,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_DISPLAY); + + INFO_PRINTF1(_L("Calling with a a \"random\" value instead of a Display")); + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay+3,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_DISPLAY); + + INFO_PRINTF1(_L("Calling with an invalid attribute list")); + EGLint KEglImageAttribsInvalid[] = + { + EGL_SURFACE_TYPE, EGL_PIXMAP_BIT, + EGL_NONE + }; + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsInvalid); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + INFO_PRINTF1(_L("Calling with a corrupt attribute list (fail to provide an EGL_NONE attribute at the end of the list)")); + EGLint KEglImageAttribsCorrupt[] = + { + EGL_IMAGE_PRESERVED_KHR, EGL_TRUE + }; + imageKHR = iEglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&sgImage,KEglImageAttribsCorrupt); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + //cleanup + ASSERT_EGL_TRUE(eglDestroyContext(iDisplay, context)); + CleanupStack::PopAndDestroy(&sgImage); + CleanAll(); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0127 + +@SYMTestPriority 1 + +@SYMPREQ 39 + +@SYMREQ See SGL.GT0386.401 document + +@SYMTestCaseDesc +Check that iUsage bits are enforced. +It’s not possible to create a VGImage from an RSgImage can’t be used as a VGImage source. + +@SYMTestActions +Create a reference Bitmap +Create and fully construct an RSgImage object having the same content as the reference bitmap +• Set the iUsage bits to ESgUsageBitOpenGlesSurface +Pass the 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() returns EGL_NO_IMAGE_KHR +The following will only be exercised if OpenGL_ES2 is supported +• Set the iUsage bits to ESgUsageBitOpenGles2Texture2D +Pass the 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 a VGImage object from the just created EGLImage. +This call should return VG_UNSUPPORTED_IMAGE_FORMAT_ERROR since the underlying RSgImage needs iUsage of ESgOpenVgImage to make this call succeed. +Pass the EGLImage into eglDestroyImageKHR() +Close the RSgImage +Destroy the pixmap +Check for memory and handle leaks + +@SYMTestExpectedResults +eglCreateImageKHR() does return EGL_BAD_PARAMETER +No memory or handle leaks +*/ +TVerdict CEglTest_EGL_Image_UsageBits_Enforcement::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0127")); + INFO_PRINTF1(_L("CEglTest_EGL_Image_UsageBits_Enforcement::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=8) + TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat); + CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8); + CleanupStack::PushL(bitmap); + + // Create RSgImage's attributes. + TSgImageInfoTest imageInfo; + imageInfo.iSizeInPixels = KPixmapSize; + imageInfo.iPixelFormat = iSourceFormat; +#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo.iUsage = ESgUsageBitOpenGlesSurface; +#else + imageInfo.iUsage = ESgUsageDirectGdiSource; + imageInfo.iShareable = EFalse; + imageInfo.iCpuAccess = ESgCpuAccessNone; + imageInfo.iScreenId = KSgScreenIdMain; + imageInfo.iUserAttributes = NULL; + imageInfo.iUserAttributeCount = 0; +#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + + RSgImage sgImage; + CleanupClosePushL(sgImage); + ASSERT_EQUALS(sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone); + + //First Subtest: creation of an EGLImageKhr with wrong Usage will fail + INFO_PRINTF1(_L("Trying to create an EGLImage from a RSgImage that doesn't have correct iUsage, ESgUsageBitOpenVgImage|ESgUsageOpenGlesTexture2D|ESgUsageOpenGles2Texture2D")); + EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR == EGL_NO_IMAGE_KHR); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + CleanupStack::PopAndDestroy(&sgImage); + + if(iEglSess->IsOpenGLES2Supported()) + { + TSgImageInfoTest imageInfo2; + imageInfo2.iSizeInPixels = KPixmapSize; + imageInfo2.iPixelFormat = iSourceFormat; +#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo2.iUsage = ESgUsageBitOpenGles2Texture2D; +#else + imageInfo2.iUsage = ESgUsageOpenGlesTexture2D; +#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + + // Create a SgImage + RSgImage sgImage2; + CleanupClosePushL(sgImage2); + ASSERT_EQUALS(sgImage2.Create(imageInfo2, bitmap->DataAddress(), bitmap->DataStride()), KErrNone); + + // Create a EGLImage from the RSgImage + EGLImageKHR imageKHR2 = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage2, KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR2 == EGL_NO_IMAGE_KHR); + + //Create an OffScreen Pixmap, we need it to make a Context current + imageInfo2.iSizeInPixels = KPixmapSize; + imageInfo2.iPixelFormat = iSourceFormat; +#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo2.iUsage = ESgUsageBitOpenVgSurface; +#else + imageInfo2.iUsage = ESgUsageOpenVgTarget; +#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo2,CTestEglSession::EResourceCloseSgImageEarly); + + // Create a VGImage from the EGLImage + //Second Subtest: creation of an VGImage from an EGLImage whose RSgImage has NOT ESgUsageBitOpenVgImage as usage will fail + VGImage vgImageTarget = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR2); + ASSERT_VG_TRUE(vgImageTarget == VG_INVALID_HANDLE); + ASSERT_TRUE(vgGetError()==VG_UNSUPPORTED_IMAGE_FORMAT_ERROR); + + CleanupStack::PopAndDestroy(&sgImage2); + ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR2)); + } + + //cleanup + CleanupStack::PopAndDestroy(bitmap); + CleanAll(); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0128 + +@SYMTestPriority 1 + +@SYMPREQ 39 + +@SYMREQ See SGL.GT0386.401 document + +@SYMTestCaseDesc +eglDestroyImageKHR handles correctly errors when given wrong input parameters. + +@SYMTestActions +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 a NULL attr_list +Check that eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR +Call eglDestroyImageKHR() sequentially with the following parameters: +1. Display equal to EGL_NO_DISPLAY +2. The EGLImageKHR is not a valid EGLImage handle +Destroy the image data +• Pass the EGLImage into eglDestroyImageKHR() +• Close RSgImage +Check for memory and handle leaks + +@SYMTestExpectedResults +eglDestroyImageKHR generates the correct error code: +• EGL_BAD_DISPLAY in the both case +*/ +TVerdict CEglTest_EGL_Image_DestroyImageKHR::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0128")); + INFO_PRINTF1(_L("CEglTest_EGL_Image_DestroyImageKHR::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(); + + INFO_PRINTF1(_L("Creating one RSgImage")); + TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize); +#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo.iCpuAccess = ESgCpuAccessReadWrite; +#endif + RSgImage sgImage; + CleanupClosePushL(sgImage); + ASSERT_EQUALS(sgImage.Create(imageInfo, NULL, NULL), KErrNone); + + INFO_PRINTF1(_L("Creating one EGLImage from it")); + 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("Calling eglDestroyImageKHR with EGL_NO_DISPLAY")); + ASSERT_EGL_TRUE(!iEglSess->DestroyEGLImage(EGL_NO_DISPLAY, imageKHR)); + ASSERT_EGL_ERROR(EGL_BAD_DISPLAY); + + INFO_PRINTF1(_L("Calling eglDestroyImageKHR with a random number (but not 1) as Display")); + ASSERT_EGL_TRUE(!iEglSess->DestroyEGLImage(7, imageKHR)); + ASSERT_EGL_ERROR(EGL_BAD_DISPLAY); + + INFO_PRINTF1(_L("Calling eglDestroyImageKHR with valid EGLImage handle (so, that should succeed)")); + ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR)); + + INFO_PRINTF1(_L("Calling eglDestroyImageKHR with invalid handle")); + ASSERT_EGL_TRUE(!iEglSess->DestroyEGLImage(iDisplay, imageKHR)); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + //cleanup + CleanupStack::PopAndDestroy(&sgImage); + CleanAll(); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0129 + +@SYMTestPriority 1 + +@SYMPREQ 39 + +@SYMREQ See SGL.GT0386.401 document + +@SYMTestCaseDesc +Any attemp to create a VGImage from a bad EGLImage handle has to fail. + +@SYMTestActions +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 a NULL attr_list +Check that eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR. +Create a surface and a current context. +Destroy the EGLImage but retain the handle value. +Try to create a VGImage from this invalid handle. +Check that the error VG_ILLEGAL_ARGUMENT_ERROR is raised. +Check for memory and handle leaks. + +@SYMTestExpectedResults +vgCreateImageTargetKHR raises a VG_ILLEGAL_ARGUMENT_ERROR error. +Check for memory and handle leaks. +*/ +TVerdict CEglTest_EGL_Image_VGImage_From_Invalid_EGLHandle::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0129")); + INFO_PRINTF1(_L("CEglTest_VGImage_From_Invalid_EGLHandle::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(); + + INFO_PRINTF1(_L("Creating one RSgImage")); + TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize); +#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo.iCpuAccess = ESgCpuAccessReadWrite; +#endif + RSgImage sgImage; + CleanupClosePushL(sgImage); + ASSERT_EQUALS(sgImage.Create(imageInfo, NULL, NULL), KErrNone); + + INFO_PRINTF1(_L("Creating one EGLImage from it")); + EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue); + ASSERT_EGL_TRUE(imageKHR != 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("Destroying the EGLImage but retain the handle value")); + ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR)); + + INFO_PRINTF1(_L("Attemptimg to create a VGImage from an invalid handle")); + VGImage vgImage = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR); + ASSERT_VG_TRUE(vgImage == VG_INVALID_HANDLE); + ASSERT_TRUE(vgGetError()==VG_ILLEGAL_ARGUMENT_ERROR); + + vgDestroyImage(vgImage); + ASSERT_TRUE(vgGetError()==VG_BAD_HANDLE_ERROR); + + //cleanup + CleanupStack::PopAndDestroy(&sgImage); + CleanAll(); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0130 + +@SYMTestPriority 1 + +@SYMPREQ 39 + +@SYMREQ See SGL.GT0386.401 document + +@SYMTestCaseDesc +When a RSgImage is used as both the source and target of a draw operation, then the operation should not panic. +However the outcome is undefined. + +@SYMTestActions +Create and fully construct an RSgImage object +Pass the 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 +Use vgCreateEGLImageTargetKHR() to construct a VGImage object from the just created EGLImage. +• Check for errors +Create Pixmap Surface from the previous RSgImage and make it current in a way that is compatible as a target for the VGImage to be drawn to. +• Set the iUsage bit to ESgUsageBitOpenVgSurface and ESgUsageBitOpenGlesSurface +Use OpenVG to draw a single patern to the left half of the VGImage created from the EGLImage. +Try to draw this VGImage to the right half of the pixmap surface currently linked to the context. +Call eglWaitClient() to finish the above drawing instructions synchronously. +Check that the pixmap contains expected pixel values. +Pass the VGImage into vgDestroyImage() +Pass the EGLImage into eglDestroyImageKHR() +Close the RSgImage +Destroy the pixmap +Check for memory and handle leaks + +@SYMTestExpectedResults +This test is not supposed to panic. +The contents, though, are undefined since we are reading from and writing to the same memory +No memory or handle leaks. +*/ +TVerdict CEglTest_EGL_Image_Self_Drawing::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0130")); + INFO_PRINTF1(_L("CEglTest_EGL_Image_Self_Drawing::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=8) + TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat); + CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8); + CleanupStack::PushL(bitmap); + + INFO_PRINTF1(_L("Creating one RSgImage")); + TSgImageInfoTest imageInfo; + imageInfo.iSizeInPixels = KPixmapSize; + imageInfo.iPixelFormat = iSourceFormat; +#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + imageInfo.iUsage = ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface; +#else + imageInfo.iUsage = ESgUsageOpenVgImage | ESgUsageOpenVgTarget; +#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE + RSgImage sgImage; + CleanupClosePushL(sgImage); + ASSERT_EQUALS(sgImage.Create(imageInfo, bitmap->DataAddress(),bitmap->DataStride()), KErrNone); + + INFO_PRINTF1(_L("Creating one EGLImage from it")); + 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("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(&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)); + + // Create a VGImage from the EGLImage + INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage")); + VGImage vgImage = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)imageKHR); + ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE); + + //Copy the source VGImage to the surface + vgSetPixels(0, 0, vgImage, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight); + ASSERT_TRUE(vgGetError()==VG_NO_ERROR); + eglWaitClient(); + + //cleanup + vgDestroyImage(vgImage); + ASSERT_TRUE(vgGetError()==VG_NO_ERROR); + ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, imageKHR)); + CleanupStack::PopAndDestroy(2, bitmap); // bitmap, sgImage + //This test doesn't check the drawing because the content of the image are undefined + //since we are using the same buffer both as target and as source + //The main purpose of this test is to ensure we don't get a panic + ASSERT_EGL_TRUE(eglDestroyContext(iDisplay, context)); //Closing eglContext + context = EGL_NO_CONTEXT; + ASSERT_EGL_TRUE(eglDestroySurface(iDisplay,surface)); //Destroying Target Surface handle + CleanAll(); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + }