diff -r 000000000000 -r bde4ae8d615e os/graphics/egl/egltest/src/egltest_surfacescaling.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/egl/egltest/src/egltest_surfacescaling.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,3103 @@ +// Copyright (c) 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_surfacescaling.h" + +#include // for ASSERT macros +#include +#include "egltestcommoninisettings.h" + +//We are restricted by the screen comparison utility that requires images to be EColor16MU +const TDisplayMode KTestSourceDisplayMode = EColor16MU; + +CEglTest_SurfaceScalingBase::~CEglTest_SurfaceScalingBase() + { + CleanAll(); + delete iImageComparison; + delete iScreenDevice; + CloseWindow(); + CloseWsSession(); + } + +TVerdict CEglTest_SurfaceScalingBase::doTestStepPreambleL() + { + TVerdict verdict = CEglTestStep::doTestStepPreambleL(); + + INFO_PRINTF1(_L("doTestStepPreambleL() - Initialise surface scaling test settings...")); + if(!CheckForExtensionL(KEGL_NOK_surface_scaling)) + { + ERR_PRINTF1(_L("KEGL_NOK_surface_scaling not supported!")); + User::Leave(KErrNotSupported); + } + //retrieve the pointers to the EGL surface scaling extension functions + iPfnEglQuerySurfaceScalingCapabilityNOK = reinterpret_cast (eglGetProcAddress("eglQuerySurfaceScalingCapabilityNOK")); + iPfnEglSetSurfaceScalingNOK = reinterpret_cast (eglGetProcAddress("eglSetSurfaceScalingNOK")); + if(!iPfnEglQuerySurfaceScalingCapabilityNOK) + { + ERR_PRINTF1(_L(" Cannot retrieve address of the \"eglQuerySurfaceScalingCapabilityNOK\" function")); + User::Leave(KErrNotSupported); + } + if(!iPfnEglSetSurfaceScalingNOK) + { + ERR_PRINTF1(_L(" Cannot retrieve address of the \"eglSetSurfaceScalingNOK\" function")); + User::Leave(KErrNotSupported); + } + + //retrieve surface scaling ini settings + CIniData* iniData = CIniData::NewL(KConfigFileName); + CleanupStack::PushL(iniData); + + _LIT(KSectionSurfaceScaling, "SurfaceScaling"); + _LIT(KKeyAllScalable, "AllScalable"); + + TPtrC scalable; + if(!iniData->FindVar(KSectionSurfaceScaling,KKeyAllScalable,scalable)) + { + ERR_PRINTF3(_L(" Cannot retrieve section:%S key:%S"), &KSectionSurfaceScaling, &KKeyAllScalable); + User::Leave(KErrNotSupported); + } + iAllScalable = (scalable.FindF( _L("true"))==KErrNotFound)? EFalse : ETrue; + INFO_PRINTF1(_L(" ************************************************************************")); + INFO_PRINTF1(_L(" **** The test will be run in following configuration: ")); + INFO_PRINTF2(_L(" **** All window surfaces scalable: %S"), &scalable); + INFO_PRINTF1(_L(" ************************************************************************")); + CleanupStack::PopAndDestroy(iniData); + + //Initiate a window server session and create a window group + OpenWsSessionL(KDefaultWindowGroupId); + + //Create a Screen Device + const TInt screen0 = 0; + iScreenDevice = new(ELeave) CWsScreenDevice(iWsSession); + User::LeaveIfError(iScreenDevice->Construct(screen0)); + + // get full screen size + TPixelsAndRotation sizeAndRotation; + iScreenDevice->GetDefaultScreenSizeAndRotation(sizeAndRotation); + iScreenSize = sizeAndRotation.iPixelSize; + + //Create the image comparison tool from the screen device as required by most tests + iImageComparison = CTGraphicsScreenComparison::NewL(*iScreenDevice); + + return verdict; + } + +TVerdict CEglTest_SurfaceScalingBase::doTestStepPostambleL() + { + INFO_PRINTF1(_L("doTestStepPostambleL() - Cleaning up")); + + // cleanup egltest framework stuff + CleanAll(); + + // cleanup member variables + delete iImageComparison; + iImageComparison = NULL; + delete iScreenDevice; + iScreenDevice = NULL; + + // close window and wserver session + CloseWindow(); + CloseWsSession(); + + return CEglTestStep::doTestStepPostambleL(); + } + +void CEglTest_SurfaceScalingBase::CreateAndActivateWindowL(const TSize& aWindowSize) + { + ConstructWindowL(iWindow, aWindowSize); + } + +void CEglTest_SurfaceScalingBase::CloseWindow() + { + iWindow.Close(); + } + +//check if border color matches with expected values +void CEglTest_SurfaceScalingBase::CheckBorderColorL(EGLint aExpectedRedChannelColor, EGLint aExpectedBlueChannelColor, EGLint aExpectedGreenChannelColor) + { + EGLint value = 0xffff; //set color channel to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, &value)); + ASSERT_EQUALS(value, aExpectedRedChannelColor); + + value = 0xffff; //set color channel to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, &value)); + ASSERT_EQUALS(value, aExpectedGreenChannelColor); + + value = 0xffff; //set color channel to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, &value)); + ASSERT_EQUALS(value, aExpectedBlueChannelColor); + } + +//check if scaling attributes match with expected values +void CEglTest_SurfaceScalingBase::CheckScalingAttributesL(EGLint aExpectedSurfaceWidth, EGLint aExpectedSurfaceHeight, EGLint aExpectedExtentWidth, EGLint aExpectedExtentHeight, EGLint aExpectedOffsetX, EGLint aExpectedOffsetY) + { + EGLint value = 0xffff; //set initial value to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_WIDTH, &value)); + ASSERT_EQUALS(value, aExpectedSurfaceWidth); + + value = 0xffff; //set initial value to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_HEIGHT, &value)); + ASSERT_EQUALS(value, aExpectedSurfaceHeight); + + value = 0xffff; //set initial value to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, &value)); + ASSERT_EQUALS(value, aExpectedExtentWidth); + + value = 0xffff; //set initial value to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, &value)); + ASSERT_EQUALS(value, aExpectedExtentHeight); + + value = 0xffff; //set initial value to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, &value)); + ASSERT_EQUALS(value, aExpectedOffsetX); + + value = 0xffff; //set initial value to some arbitrary number + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, &value)); + ASSERT_EQUALS(value, aExpectedOffsetY); + } + +/* + Simple create bitmap function to initialise a rectangular bitmap in four simple colours plus borders + --------------------------- + ¦ borderTop ¦ + ¦ ----------------- ¦ + ¦ b. ¦ ¦ ¦ b. ¦ + ¦ ¦ 1 ¦ 2 ¦ ¦ + ¦ L ¦ ¦ ¦ R ¦ + ¦ e ¦--------¦--------¦ i ¦ + ¦ f ¦ ¦ ¦ g ¦ + ¦ t ¦ 3 ¦ 4 ¦ h ¦ + ¦ ¦ ¦ ¦ t ¦ + ¦ ----------------- ¦ + ¦ borderBottom ¦ + --------------------------- +*/ +CFbsBitmap* CEglTest_SurfaceScalingBase::CreateBitmapLC(const TSize& aSize, TInt aBorderTop, TInt aBorderBottom, TInt aBorderLeft, TInt aBorderRight, const TRgb& aBorderColor) + { + // create the bitmap to the requested size (DisplayMode set to default value) + CFbsBitmap* bitmap = new(ELeave) CFbsBitmap(); + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Create(aSize,KTestSourceDisplayMode)); + TEST(bitmap->SizeInPixels().iHeight == aSize.iHeight); + TEST(bitmap->SizeInPixels().iWidth == aSize.iWidth); + + //Create a device and context for the purpose of generating the bitmap which will be the + //master reference used in the test + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmap); + CleanupStack::PushL(bitmapDevice); + CFbsBitGc* bitmapGc = CFbsBitGc::NewL(); + CleanupStack::PushL(bitmapGc); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + bitmapGc->Activate(bitmapDevice); + + // First off, set the whole bitmap to the border colour + bitmapGc->SetBrushColor(aBorderColor); + bitmapGc->SetPenColor(aBorderColor); + bitmapGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + bitmapGc->DrawRect(aSize); + + // Set each individual quadrant to a different arbitrary colour + const TInt height = aSize.iHeight; + const TInt width = aSize.iWidth; + const TInt quadrantHeight = (height - aBorderTop - aBorderBottom) / 2; + const TInt quadrantWidth = (width - aBorderLeft - aBorderRight) / 2; + + // quadrant 1 - Colour KRgbMagenta + TRect rect = TRect(TPoint(aBorderLeft, aBorderTop), TSize(quadrantWidth, quadrantHeight)); + bitmapGc->SetBrushColor(KRgbMagenta); + bitmapGc->SetPenColor(KRgbMagenta); + bitmapGc->DrawRect(rect); + + // quadrant 2 - Colour KRgbCyan + rect = TRect(TPoint(aBorderLeft+quadrantWidth, aBorderTop), TSize(quadrantWidth, quadrantHeight)); + bitmapGc->SetBrushColor(KRgbCyan); + bitmapGc->SetPenColor(KRgbCyan); + bitmapGc->DrawRect(rect); + + // quadrant 3 - Colour KRgbYellow + rect = TRect(TPoint(aBorderLeft, aBorderTop+quadrantHeight), TSize(quadrantWidth, quadrantHeight)); + bitmapGc->SetBrushColor(KRgbYellow); + bitmapGc->SetPenColor(KRgbYellow); + bitmapGc->DrawRect(rect); + + // quadrant 4 - Colour KRgbDarkGreen + rect = TRect(TPoint(aBorderLeft+quadrantWidth, aBorderTop+quadrantHeight), TSize(quadrantWidth, quadrantHeight)); + bitmapGc->SetBrushColor(KRgbDarkGreen); + bitmapGc->SetPenColor(KRgbDarkGreen); + bitmapGc->DrawRect(rect); + + //clean-up + CleanupStack::PopAndDestroy(2, bitmapDevice); + return bitmap; + } + +void CEglTest_SurfaceScalingBase::WritePixelsToSurfaceL(const CFbsBitmap& aBitmap) + { + // Mind the fact that CFbsBitmap and VGImages use different coordinates origin + const TSize bitmapSize = aBitmap.SizeInPixels(); + TUint8* address = reinterpret_cast(aBitmap.DataAddress()); + const TInt stride = aBitmap.DataStride(); + address += (bitmapSize.iHeight - 1) * stride; + + // copy pixel data to the drawing surface + vgWritePixels(address, -stride, KDefaultSurfaceFormat,0,0, bitmapSize.iWidth, bitmapSize.iHeight); + ASSERT_TRUE(vgGetError()==VG_NO_ERROR); + + // force all outstanding requests on the current context to complete + vgFinish(); + iWsSession.Finish(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0651 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Choose a suitable extent to test that specified border colours are correct. + +@SYMTestActions +For a number of different situations, do the following: +1. Create a window of known size +2. Create a fixed size surface, filled in with a predefined bitmap +3. Draw the surface onto the window for a set extent and border colour +4. Compare window content and border against a reference bitmap containing expected values. + +@SYMTestExpectedResults +The window content matches the independently created reference bitmap in each situation +*/ +TVerdict CEglTest_SurfaceScaling_Positive::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0651")); + SetTestStepName(_L("GRAPHICS-EGL-0651")); + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_Positive::doTestStepL started....")); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // NOTE: Borders depend on what you set as extent, offset, window and surface + // Care should be taken when choosing size values, better to use even numbers + // (CreateBitmap splits rectangle in four, so we don't want a pixel mismatch there) + for (TInt index=1; index<=17; index++) + { + // Set some default values which are used in most cases + iWindowWidth = iWindowHeight = 200; + iBorderColor = TRgb(0,0,0); + iBorderTop = iBorderBottom = iBorderLeft = iBorderRight = 0; + + switch(index) + { + case 1: + // surface scaled to same window size with no border + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 200; iExtentHeight = 200; + iOffsetX = 0; iOffsetY = 0; + break; + case 2: + // surface scaled to half the window size with border top + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 200; iExtentHeight = 100; + iOffsetX = 0; iOffsetY = 100; + iBorderColor = TRgb(0,0,0); // arbitrary border colour + iBorderTop = 100; + break; + case 3: + // surface scaled to half the window size with border bottom + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 200; iExtentHeight = 100; + iOffsetX = 0; iOffsetY = 0; + iBorderColor = TRgb(128,0,255); // arbitrary border colour + iBorderBottom = 100; + break; + case 4: + // surface scaled to half the window size with border top and bottom + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 200; iExtentHeight = 100; + iOffsetX = 0; iOffsetY = 50; + iBorderColor = TRgb(128,0,0); // arbitrary border colour + iBorderTop = 50; iBorderBottom = 50; + break; + case 5: + // surface scaled to half the window size with border left + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 100; iExtentHeight = 200; + iOffsetX = 100; iOffsetY = 0; + iBorderColor = TRgb(96,96,96); // arbitrary border colour + iBorderLeft = 100; + break; + case 6: + // surface scaled to half the window size with border right + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 100; iExtentHeight = 200; + iOffsetX = 0; iOffsetY = 0; + iBorderColor = TRgb(192,192,192); // arbitrary border colour + iBorderRight = 100; + break; + case 7: + // surface scaled to half the window size with border left and right + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 100; iExtentHeight = 200; + iOffsetX = 50; iOffsetY = 0; + iBorderColor = TRgb(0,0,0); // arbitrary border colour + iBorderLeft = 50; iBorderRight = 50; + break; + case 8: + // surface scaled in different proportions in width and height, with borders + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 190; iExtentHeight = 10; + iOffsetX = 5; iOffsetY = 95; + iBorderColor = TRgb(240,240,240); // arbitrary border colour + iBorderTop = 95; iBorderBottom = 95; iBorderLeft = 5; iBorderRight = 5; + break; + case 9: + // surface scaled to double the window height size, surface cropped with no borders + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 400; iExtentHeight = 200; + iOffsetX = 0; iOffsetY = 0; + break; + case 10: + // surface scaled to double the window width and height size, surface cropped with no borders + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 400; iExtentHeight = 400; + iOffsetX = 0; iOffsetY = 0; + break; + case 11: + // surface scaled to double the window width and height size, surface cropped with borders top and left + iSurfaceWidth = 100; iSurfaceHeight = 50; + iExtentWidth = 400; iExtentHeight = 400; + iOffsetX = 100; iOffsetY = 100; + iBorderColor = TRgb(255,128,255); // arbitrary border colour + iBorderTop = 100; iBorderLeft = 100; + break; + case 12: + // QnHD to full screen size + iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight; + iSurfaceWidth = 320; iSurfaceHeight = 180; + iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + break; + case 13: + // QVGA to full screen size + iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight; + iSurfaceWidth = 320; iSurfaceHeight = 240; + iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + break; + case 14: + // HVGA to full screen size + iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight; + iSurfaceWidth = 480; iSurfaceHeight = 320; + iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + break; + case 15: + // 480x270 to full screen size + iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight; + iSurfaceWidth = 480; iSurfaceHeight = 270; + iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + break; + case 16: + // VGA to full screen size + iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight; + iSurfaceWidth = 640; iSurfaceHeight = 480; + iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + break; + case 17: + // WVGA to full screen size + iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight; + iSurfaceWidth = 768; iSurfaceHeight = 480; + iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + break; + default: + ERR_PRINTF2(_L("Inconsistency in test code, case does not exist: %d."), index); + User::Leave(KErrNotSupported); + break; + } + + // perform the testing + doTestPartialStepL(); + } + + // clean-up + CleanAll(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_Positive::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +TVerdict CEglTest_SurfaceScaling_Positive::doTestPartialStepL() + { + INFO_PRINTF5(_L("doTestPartialStepL started with (%d,%d) fixed surface scaled to (%d,%d) extent...."), iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight)); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, iSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, iSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight, + EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(), + EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(), + EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(), + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Create the test bitmap that will be used in the scaled surface + // NOTE: This bitmap generally does not have borders, + CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0)); + + // Copy test bitmap to drawing surface + WritePixelsToSurfaceL(*testBitmap); + + //call eglSwapBuffers + ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface())); + //Wait for the draw operation to complete + eglWaitClient(); + + // Create the reference bitmap that should be expected after the scaling + // NOTE: This bitmap may have borders + // Size could exceed that of the window, so check both extent and window + const TInt refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth; + const TInt refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight; + CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor); + + // compare window contents with expected bitmap + TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *refBitmap, TestStepName()); + TEST(comparison==KErrNone); + INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone); + + /// Cleanup + CleanupStack::PopAndDestroy(2, testBitmap); // refBitmap, testBitmap + iEglSess->CleanupSurfaceAndContextL(); + CloseWindow(); + + INFO_PRINTF1(_L("....doTestPartialStepL completed!")); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0661 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Resize native window to verify target extent remains fixed. + +@SYMTestActions +1. Create a window of known size +2. Create a fixed size surface, filled in with a predefined bitmap +3. Draw the surface onto the window for a set extent and border colour +4. Repeat step 3 but increasing native window size by (1,1) pixels. +5. Compare window content and border against a reference bitmap containing expected values. + +@SYMTestExpectedResults +The window content matches the independently created reference bitmap in each situation +*/ +TVerdict CEglTest_SurfaceScaling_WindowResize::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0661")); + SetTestStepName(_L("GRAPHICS-EGL-0661")); + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_WindowResize::doTestStepL started....")); + + // set the initial value of a square window + const TInt KWindowSize = 100; + + // surface with size and extent that matches the window size and no offset + iWindowWidth = iWindowHeight = KWindowSize; + iSurfaceWidth = iSurfaceHeight = KWindowSize; + iExtentWidth = iExtentHeight = KWindowSize; + iOffsetX = 0; iOffsetY = 0; + iBorderColor = TRgb(0x99,0xcc,0xff); // set some arbitrary colour + iBorderTop = 0; iBorderBottom = 0; iBorderLeft = 0; iBorderRight = 0; + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, iSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, iSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight, + EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(), + EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(), + EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(), + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Create the test bitmap that will be used in the scaled surface + // NOTE: This bitmap generally does not have borders, + CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0)); + + // Copy test bitmap to drawing surface + WritePixelsToSurfaceL(*testBitmap); + + // Start doing iterations by increasing native window size. + INFO_PRINTF1(_L("Start increasing native window size by (1,1)...")); + iWindowWidth=1; + iWindowHeight=1; + while(iWindowWidth<=(KWindowSize*2) && iWindowHeight<=(KWindowSize*2)) + { + // Note that borders will appear while window size is bigger than extent + // - iSurfaceWidth/iSurfaceHeight - unmodified + // - iExtentWidth/iExtentHeight - unmodified + // - iOffsetX/iOffsetY - unmodified + // Set up expected values for the border + iBorderTop = 0; iBorderLeft = 0; + iBorderBottom = iExtentHeightCleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_WindowResize::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +TVerdict CEglTest_SurfaceScaling_WindowResize::doTestPartialStepL() + { + INFO_PRINTF3(_L("doTestPartialStepL started for native window size of (%d, %d)...."), iWindowWidth, iWindowHeight); + + // resize may be effective only after swapbuffers + ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface())); + ASSERT_EGL_TRUE(eglWaitClient()); + + //check all expected values + CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); + CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); + + // Create the reference bitmap that should be expected after the window resize + // NOTE: This bitmap may have borders + // Size could exceed that of the window, so check both extent and window + const TInt refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth; + const TInt refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight; + CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor); + + // compare window contents with expected bitmap + TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *refBitmap, TestStepName()); + TEST(comparison==KErrNone); + INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone); + + /// Cleanup + CleanupStack::PopAndDestroy(refBitmap); + + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0668 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Create a fixed size surface and vary the extent position for a range of values. + +@SYMTestActions +1. Create a window of known size +2. Create a fixed size surface, filled in with a predefined bitmap +3. Draw the surface onto the window for a set extent and border colour +4. Repeat step 3 but increasing target extent offset by (1,1) pixels. +5. Compare window content and border against a reference bitmap containing expected values. + +@SYMTestExpectedResults +The window content matches the independently created reference bitmap in each situation +*/ +TVerdict CEglTest_SurfaceScaling_ExtentPositionChange::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0668")); + SetTestStepName(_L("GRAPHICS-EGL-0668")); + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_ExtentPositionChange::doTestStepL started....")); + + // surface with size and extent that matches the window size and no offset + iWindowWidth = iWindowHeight = 100; + iSurfaceWidth = iExtentWidth = iWindowWidth; + iSurfaceHeight = iExtentHeight = iWindowHeight; + iOffsetX = 0; iOffsetY = 0; + iBorderColor = TRgb(0x11,0x22,0x33); // set some arbitrary colour + iBorderTop = 0; iBorderBottom = 0; iBorderLeft = 0; iBorderRight = 0; + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, iSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, iSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight, + EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(), + EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(), + EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(), + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Create the test bitmap that will be used in the scaled surface + // NOTE: This bitmap generally does not have borders, + CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0)); + + // Copy test bitmap to drawing surface + WritePixelsToSurfaceL(*testBitmap); + + // This test is a bit different. Since the extent remains the same, and we only change + // the offset, we create an oversized reference bitmap and compare the screen with a + // region contained within the reference bitmap + // Size is three times the extent so that it has extent size borders all around + const TInt refWidth = 3*iExtentWidth; + const TInt refHeight = 3*iExtentHeight; + iBorderTop=iBorderBottom=iBorderLeft=iBorderRight=iExtentWidth; + CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor); + + // Start doing iterations by increasing target extent offset + INFO_PRINTF1(_L("Start increasing target extent offset size by (1,1)...")); + for (iOffsetX=-iExtentWidth,iOffsetY=-iExtentHeight; iOffsetX<=iExtentWidth&&iOffsetY<=iExtentHeight; ++iOffsetX,++iOffsetY) + { + // Note that borders will appear other than when offset is (0,0) + // - iSurfaceWidth/iSurfaceHeight - unmodified + // - iExtentWidth/iExtentHeight - unmodified + + // set new offset values + ASSERT_EGL_TRUE(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), iOffsetX, iOffsetY, iExtentWidth, iExtentHeight)); + + // re-populate buffers with the unmodified fixed size surface content + WritePixelsToSurfaceL(*testBitmap); + + // perform the testing + doTestPartialStepL(*refBitmap); + } + + /// Cleanup + CleanupStack::PopAndDestroy(2, testBitmap); //testBitmap, refBitmap + iEglSess->CleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_ExtentPositionChange::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +TVerdict CEglTest_SurfaceScaling_ExtentPositionChange::doTestPartialStepL(const CFbsBitmap& aRefBitmap) + { + INFO_PRINTF3(_L("doTestPartialStepL started for offset of (%d, %d)...."), iOffsetX, iOffsetY); + + // offset change may be effective only after swapbuffers + ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface())); + ASSERT_EGL_TRUE(eglWaitClient()); + // Finish() to ensure all native window operations related to the surface complete before image comparision. + iWsSession.Finish(); + + //check all expected values + CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); + CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); + + // Prepare the offset of the reference bitmap to know what sub-region should be compared + const TInt refWidth = 3*iExtentWidth; + const TInt refHeight = 3*iExtentHeight; + TPoint bitmapOffset(refWidth-iExtentWidth-iRefBitmapOffset, refHeight-iExtentHeight-iRefBitmapOffset); + iRefBitmapOffset++; // increase offset for next iteration + + // Comparision takes into account specific region within the reference bitmap + TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), bitmapOffset, aRefBitmap, TestStepName()); + TEST(comparison==KErrNone); + INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone); + + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0669 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Create a fixed size surface and vary the extent size for a range of values + +@SYMTestActions +1. Create a window of known size +2. Create a fixed size surface, filled in with a predefined bitmap +3. Draw the surface onto the window for a set extent and border colour +4. Repeat step 3 but increasing target extent size by (2,2) pixels. +5. Compare window content and border against a reference bitmap containing expected values. + +@SYMTestExpectedResults +The window content matches the independently created reference bitmap in each situation +*/ +TVerdict CEglTest_SurfaceScaling_ExtentSizeChange::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0669")); + SetTestStepName(_L("GRAPHICS-EGL-0669")); + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_ExtentSizeChange::doTestStepL started....")); + + // set the initial value of a square window + const TInt KWindowSize = 100; + + // surface with size and extent that matches the window size and no offset + iWindowWidth = iWindowHeight = KWindowSize; + iSurfaceWidth = iSurfaceHeight = KWindowSize; + iExtentWidth = iExtentHeight = KWindowSize; + iOffsetX = 0; iOffsetY = 0; + iBorderColor = TRgb(0x80,0x40,0xF0); // set some arbitrary colour + iBorderTop = 0; iBorderBottom = 0; iBorderLeft = 0; iBorderRight = 0; + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, iSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, iSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight, + EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(), + EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(), + EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(), + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Create the test bitmap that will be used in the scaled surface + // NOTE: This bitmap generally does not have borders, + CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0)); + + // Copy test bitmap to drawing surface + WritePixelsToSurfaceL(*testBitmap); + + // Start doing iterations by increasing target extent size + // We do increments of (2,2) because the reference bitmap is simetrically split into 4 areas, so size + // of this reference bitmap should be an even number of pixels + INFO_PRINTF1(_L("Start increasing target extent size by (2,2)...")); + iExtentWidth=2; + iExtentHeight=2; + while(iExtentWidth <= (KWindowSize*2) && iExtentHeight <= (KWindowSize*2)) + { + // Note that borders will appear while extent is smaller than window + // - iSurfaceWidth/iSurfaceHeight - unmodified + // - iOffsetX/iOffsetY - unmodified + // Set up expected values for the border + iBorderTop = 0; iBorderLeft = 0; + iBorderBottom = iExtentHeightSurface(), iOffsetX, iOffsetY, iExtentWidth, iExtentHeight)); + + // re-populate buffers with the unmodified fixed size surface content + WritePixelsToSurfaceL(*testBitmap); + + // perform the testing + doTestPartialStepL(); + iExtentWidth+=2; + iExtentHeight+=2; + } + + /// Cleanup + CleanupStack::PopAndDestroy(testBitmap); + iEglSess->CleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_ExtentSizeChange::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +TVerdict CEglTest_SurfaceScaling_ExtentSizeChange::doTestPartialStepL() + { + INFO_PRINTF3(_L("doTestPartialStepL started for extent size of (%d, %d)...."), iExtentWidth, iExtentHeight); + + // extent change may be effective only after swapbuffers + ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface())); + ASSERT_EGL_TRUE(eglWaitClient()); + // Finish() to ensure all native window operations related to the surface complete before image comparision. + iWsSession.Finish(); + + //check all expected values + CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); + CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); + + // Create the reference bitmap that should be expected after the window resize + // NOTE: This bitmap may have borders + // Size could exceed that of the window, so check both extent and window + const TInt refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth; + const TInt refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight; + CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor); + + // compare window contents with expected bitmap + TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *refBitmap, TestStepName()); + TEST(comparison==KErrNone); + INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone); + + /// Cleanup + CleanupStack::PopAndDestroy(refBitmap); + + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0670 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Check that updating surface scaling attributes is visible only after calling eglSwapBuffers + +@SYMTestActions +1. Create a window of known size +2. Create a fixed size surface, filled in with a predefined bitmap +3. Draw the surface onto the window for a set extent and border colour +4. Repeat step 3 but increasing target extent size and changing border colours +5. Compare window content and border against a reference bitmap containing expected values + 5a. Before calling eglSwapBuffers + 5b. After callnig eglSwapBuffers + +@SYMTestExpectedResults +5a. The window content matches the independently created reference with old values +5b. The window content matches the independently created reference with new values +*/ +TVerdict CEglTest_SurfaceScaling_SwapBuffers::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-EGL-0670")); + SetTestStepName(_L("GRAPHICS-EGL-0670")); + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_SwapBuffers::doTestStepL started....")); + + // set the initial value of a square window + const TInt KWindowSize = 200; + + // surface with size that matches the window size and no offset and extent a quarter + // of that originally positioned in the middle (so borders should be seen) + iWindowWidth = iWindowHeight = KWindowSize; + iSurfaceWidth = iSurfaceHeight = KWindowSize; + iExtentWidth = iExtentHeight = KWindowSize/4; + iOffsetX = (iWindowWidth-iExtentWidth)/2; iOffsetY = (iWindowHeight-iExtentHeight)/2; // to center the surface at the middle of the window + iBorderColor = TRgb(0xFF,0xFF,0x00); // set some arbitrary colour with blue channel to 0x00 + iBorderTop = iBorderBottom = iExtentHeightInitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, iSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, iSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight, + EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(), + EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(), + EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(), + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Create the test bitmap that will be used in the scaled surface + // NOTE: This bitmap generally does not have borders, + CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0)); + + // Copy test bitmap to drawing surface + WritePixelsToSurfaceL(*testBitmap); + + // we need to update the window content for the first frame comparison inside the loop further down + ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface())); + ASSERT_EGL_TRUE(eglWaitClient()); + + // Start doing iterations changing border colours and increasing target extent size + // We do increments of (2,2) because the reference bitmap is simetrically split into 4 areas, so size + // of this reference bitmap should be an even number of pixels + INFO_PRINTF1(_L("Start changing border colours and increasing target extent size by (2,2)...")); + for (;;) + { + // re-populate buffers with the unmodified fixed size surface content + WritePixelsToSurfaceL(*testBitmap); + + // perform the testing + doTestPartialStepL(); + + // break the loop when necessary + if (iBorderColor.Blue()>=255) + break; + } + + /// Cleanup + CleanupStack::PopAndDestroy(testBitmap); + iEglSess->CleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_SwapBuffers::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +TVerdict CEglTest_SurfaceScaling_SwapBuffers::doTestPartialStepL() + { + INFO_PRINTF4(_L("doTestPartialStepL started for border colour (%d,%d,%d)...."), iBorderColor.Red(), iBorderColor.Green(), iBorderColor.Blue()); + + // Note that borders will appear while extent is smaller than window + // - iSurfaceWidth/iSurfaceHeight - unmodified + // - iExtentWidth/iExtentHeight - modified + // - iOffsetX/iOffsetY - modified + + // Set up new value for border blue channel, storing old ones + TRgb oldBorderColor(iBorderColor); + TInt newColorBlue = oldBorderColor.Blue() + 5; + TESTL(newColorBlue>=0 && newColorBlue<=255); + iBorderColor.SetBlue(newColorBlue); + + // Set up new values for extent/offset, storing old ones + TInt oldExtentWidth = iExtentWidth; + TInt oldExtentHeight = iExtentHeight; + iExtentWidth+=2; + iExtentHeight+=2; + iOffsetX = (iWindowWidth-iExtentWidth)/2; + iOffsetY = (iWindowHeight-iExtentHeight)/2; + + // Set up expected values for the border, storing old ones + TInt oldBorderTop = iBorderTop; + TInt oldBorderBottom = iBorderBottom; + TInt oldBorderLeft = iBorderLeft; + TInt oldBorderRight = iBorderRight; + iBorderTop = iBorderBottom = iExtentHeightSurface(), iOffsetX, iOffsetY, iExtentWidth, iExtentHeight)); + // set new border colour values + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue())); + + // Check that values have been updated as expected + CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); + CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); + + // Check that the screen has NOT BEEN UPDATED just yet + + // Create the reference bitmap that should be expected before the extent/border changes + TInt refWidth = oldExtentWidth>iWindowWidth ? oldExtentWidth : iWindowWidth; + TInt refHeight = oldExtentHeight>iWindowHeight ? oldExtentHeight : iWindowHeight; + CFbsBitmap* oldRefBitmap = CreateBitmapLC(TSize(refWidth, refHeight), oldBorderTop, oldBorderBottom, oldBorderLeft, oldBorderRight, oldBorderColor); + + // compare screen with old reference bitmap + TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *oldRefBitmap, TestStepName()); + TEST(comparison==KErrNone); + INFO_PRINTF3(_L("CompareScreenImageL before eglSwapBuffers returns %d (expected is %d)"), comparison, KErrNone); + + // extent/offset changes MUST be effective only after swapbuffers + ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface())); + ASSERT_EGL_TRUE(eglWaitClient()); + // Finish() to ensure all native window operations related to the surface complete before image comparision. + iWsSession.Finish(); + + //check values still are as expected + CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); + CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); + + // Create the reference bitmap that should be expected after the extent/border changes + refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth; + refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight; + CFbsBitmap* newRefBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor); + + // compare screen with new reference bitmap + comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *newRefBitmap, TestStepName()); + TEST(comparison==KErrNone); + INFO_PRINTF3(_L("CompareScreenImageL after eglSwapBuffers returns %d (expected is %d)"), comparison, KErrNone); + + /// Cleanup + CleanupStack::PopAndDestroy(2, oldRefBitmap); // oldRefBitmap, newRefBitmap + + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0652 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Check that all configs that support surface scaling also support window surfaces. + +@SYMTestActions +1. Query number of configs +2. Iterate through all configs and check if surface scaling is supported +3. If surface scaling is supported, chech that it supports window surfaces and + attempt to create a fixed size window surface +4. If surface scaling is not supported, check eglGetConfigAttrib return value and + attempt to create a fixed size window surface + +@SYMTestExpectedResults +3. All configs that support surface scaling support window surfaces and window surface creation succeeds. +4. If surface scaling is not supported, eglGetConfigAttrib sets value to EGL_FALSE and window surface creation fails. +*/ +TVerdict CEglTest_SurfaceScaling_WindowSurface_Check::doTestStepL() + { + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_WindowSurface_Check::doTestStepL")); + SetTestStepName(_L("GRAPHICS-EGL-0652")); + SetTestStepID(_L("GRAPHICS-EGL-0652")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100, 100)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + EGLConfig matchingConfigs[KMaxEglConfigs]; + EGLint numConfigs = 0; + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, 50, + EGL_FIXED_HEIGHT_NOK, 50, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, 100, + EGL_TARGET_EXTENT_HEIGHT_NOK, 100, + EGL_NONE}; + + // Query total number of configs + ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, NULL, KMaxTInt, &numConfigs)); + TESTL(numConfigs >= 1 && numConfigs <= KMaxEglConfigs); + INFO_PRINTF2(_L("Found %d configs in total"), numConfigs); + + // Get all configs + ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, matchingConfigs, KMaxEglConfigs, &numConfigs)); + + // Check that if surface scaling is supported in the config, then window surfaces are supported too + for(TInt i=0; iInitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + // Make the fixed size surface half width and height of the window + TInt surfaceWidth = iWindow.Size().iWidth / 2; + TInt surfaceHeight = iWindow.Size().iHeight / 2; + + TInt invalidCombinationAttrNum = 6; + EGLint invalid_combination_attrib_list[][11] = { + { + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_NONE} + }; + + TInt illegalValAttrNum = 14; + EGLint illegal_value_attrib_list[][19] = { + { + EGL_FIXED_WIDTH_NOK, -1, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, 0, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, -1, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, -1, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, 0, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, -1, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, 0, + EGL_BORDER_COLOR_RED_NOK, 0xfc, + EGL_BORDER_COLOR_GREEN_NOK, 0xfd, + EGL_BORDER_COLOR_BLUE_NOK, 0xfe, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, -1, + EGL_BORDER_COLOR_GREEN_NOK, 0, + EGL_BORDER_COLOR_BLUE_NOK, 0, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0, + EGL_BORDER_COLOR_GREEN_NOK, -1, + EGL_BORDER_COLOR_BLUE_NOK, 0, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0, + EGL_BORDER_COLOR_GREEN_NOK, 0, + EGL_BORDER_COLOR_BLUE_NOK, -1, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 256, + EGL_BORDER_COLOR_GREEN_NOK, 0, + EGL_BORDER_COLOR_BLUE_NOK, 0, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0, + EGL_BORDER_COLOR_GREEN_NOK, 256, + EGL_BORDER_COLOR_BLUE_NOK, 0, + EGL_NONE}, + { + EGL_FIXED_WIDTH_NOK, surfaceWidth, + EGL_FIXED_HEIGHT_NOK, surfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, iWindow.Size().iWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, iWindow.Size().iHeight, + EGL_BORDER_COLOR_RED_NOK, 0, + EGL_BORDER_COLOR_GREEN_NOK, 0, + EGL_BORDER_COLOR_BLUE_NOK, 256, + EGL_NONE} + }; + + INFO_PRINTF1(_L("Calling eglCreateWindowSurface with invalid combination of Surface Scaling attributes... - only five out of six compulsary attributes specified")); + for(TInt i = 0;i < invalidCombinationAttrNum;i++) + { + EGLSurface surface = eglCreateWindowSurface(iDisplay, matchingConfigs[0], &iWindow, invalid_combination_attrib_list[i]); + TEST_EGL_ERROR(surface == EGL_NO_SURFACE, EGL_BAD_ATTRIBUTE); + } + + INFO_PRINTF1(_L("Calling eglCreateWindowSurface with illegal values for each attribute...")); + for(TInt i = 0;i < illegalValAttrNum;i++) + { + EGLSurface surface = eglCreateWindowSurface(iDisplay, matchingConfigs[0], &iWindow, illegal_value_attrib_list[i]); + TEST_EGL_ERROR(surface == EGL_NO_SURFACE, EGL_BAD_ATTRIBUTE); + } + + // clean-up + CloseWindow(); + CleanAll(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_Negative_CreateWindowSurface::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0654 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative test. This test is to check the return value and error code when creating +a fixed size non window surface. + +@SYMTestActions +1. Attempt to create a pixmap with scaling attributes specified +2. Attempt to create a pbuffer surface with scaling attributes specified +3. Attempt to create a window surface with scaling attributes specified but + config doesn't support surface scaling + +@SYMTestExpectedResults +1. EGL_NO_SURFACE is returned with error set to EGL_BAD_ATTRIBUTE +2. EGL_NO_SURFACE is returned with error set to EGL_BAD_ATTRIBUTE +3. EGL_NO_SURFACE is returned with error set to EGL_BAD_MATCH +*/ +TVerdict CEglTest_SurfaceScaling_Negative_FixedSize_NonWindowSurface::doTestStepL() + { + INFO_PRINTF1(_L("CEglTest_SurfaceScaling_Negative_FixedSize_NonWindowSurface::doTestStepL")); + SetTestStepName(_L("GRAPHICS-EGL-0654")); + SetTestStepID(_L("GRAPHICS-EGL-0654")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100, 100)); + + // Create bitmap + User::LeaveIfError(RFbsSession::Connect()); + CFbsBitmap* bitmap = new(ELeave) CFbsBitmap(); + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Create(TSize(20, 20), EColor16MU)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); + iEglSess->InitializeL(); + + EGLConfig config; + EGLSurface surface = EGL_NO_SURFACE; + EGLint numConfigs = 0; + + // Use OpenVG to draw + ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API)); + + const EGLint KFixedSize_surface_attrib_list[] = { + EGL_FIXED_WIDTH_NOK, 100, + EGL_FIXED_HEIGHT_NOK, 100, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, 150, + EGL_TARGET_EXTENT_HEIGHT_NOK, 150, + EGL_NONE}; + + // If all window surfaces in EGL are scalable, first case must be skipped. Others still valid + TInt index = iAllScalable ? 1 : 0; + for(; index < 3; index++) + { + switch(index) + { + case 0: + INFO_PRINTF1(_L("Calling eglCreateWindowSurface with surface scaling attribute specified in a config that does not support scaling...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribs_NoScaling], &config, 1, &numConfigs)); + TEST(numConfigs==1); + surface = eglCreateWindowSurface(iDisplay, config, &iWindow, KFixedSize_surface_attrib_list); + TEST_EGL_ERROR(surface == EGL_NO_SURFACE, EGL_BAD_MATCH); + break; + case 1: + INFO_PRINTF1(_L("Calling eglCreatePixmapSurface with surface scaling attribute specified...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPixmapAttribsColor16MU], &config, 1, &numConfigs)); + TEST(numConfigs==1); + surface = eglCreatePixmapSurface(iDisplay, config, (NativePixmapType)bitmap, KFixedSize_surface_attrib_list); + TEST_EGL_ERROR(surface == EGL_NO_SURFACE, EGL_BAD_ATTRIBUTE); + break; + case 2: + INFO_PRINTF1(_L("Calling eglCreatePbufferSurface with surface scaling attribute specified...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPBufferAttribsColor64K], &config, 1, &numConfigs)); + TEST(numConfigs==1); + surface = eglCreatePbufferSurface(iDisplay, config, KFixedSize_surface_attrib_list); + TEST_EGL_ERROR(surface == EGL_NO_SURFACE, EGL_BAD_ATTRIBUTE); + break; + } + } + + // cleanup + CleanupStack::PopAndDestroy(bitmap); + CloseWindow(); + CleanAll(); + RFbsSession::Disconnect(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_Negative_FixedSize_NonWindowSurface::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0655 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Exercising border color set by default. + +@SYMTestActions +1. Create a fixed size EGL Window Surface without border color specified. +2. Create a fixed size EGL Window Surface with border color specified for one channel. +3. Create a fixed size EGL Window Surface with border color specified for two channels. + +@SYMTestExpectedResults +Retrieved border color matches to the value it has been set at surface creation, +if during the surface creation border color has not been specified it is set to black (0x0). +*/ +TVerdict CEglTest_SurfaceScalingDefaultBorderColor::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0655")); + SetTestStepID(_L("GRAPHICS-EGL-0655")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingDefaultBorderColor::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL (numConfigs == 1); // Abort the test if the EGL config is not supported + + // Make the fixed size surface half width and height of the window + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + + EGLint attrib_list1[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, KWindowWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KWindowHeight, + EGL_NONE}; + + EGLint attrib_list2[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, KWindowWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KWindowHeight, + EGL_BORDER_COLOR_RED_NOK, 0xf0, + EGL_NONE}; + + EGLint attrib_list3[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, KWindowWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KWindowHeight, + EGL_BORDER_COLOR_BLUE_NOK, 0xf8, + EGL_BORDER_COLOR_GREEN_NOK, 0xfc, + EGL_NONE}; + + for(TInt index = 0; index < 3; index++) + { + EGLint* attrib_list = NULL; + EGLint expectedRedChannelColor = 0; + EGLint expectedGreenChannelColor = 0; + EGLint expectedBlueChannelColor = 0; + + switch(index) + { + case 0: + attrib_list = attrib_list1; + break; + case 1: + expectedRedChannelColor = 0xf0; + attrib_list = attrib_list2; + break; + case 2: + expectedBlueChannelColor = 0xf8; + expectedGreenChannelColor = 0xfc; + attrib_list = attrib_list3; + break; + } + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Check expected border colours + CheckBorderColorL(expectedRedChannelColor, expectedBlueChannelColor, expectedGreenChannelColor); + + // Cleanup + iEglSess->CleanupSurfaceAndContextL(); + } + + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingDefaultBorderColor::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + + +/** +@SYMTestCaseID GRAPHICS-EGL-0656 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Modifying an existing fixed size surface border color. + +@SYMTestActions +1. Create a fixed size EGL Window Surface with border color specified. +2. Modify border color with the new values. + +@SYMTestExpectedResults +New color will take place only after setting new values. +*/ + +TVerdict CEglTest_SurfaceScalingModifyingBorderColor::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0656")); + SetTestStepID(_L("GRAPHICS-EGL-0656")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingModifyingBorderColor::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL (numConfigs == 1); // Abort the test if the EGL config is not supported + + // Make the fixed size surface half width and height of the window + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const TInt KExtentWidth = KSurfaceWidth; + const TInt KExtentHeight = KSurfaceHeight; + const EGLint KRedChannelColor = 0x20; + const EGLint KGreenChannelColor = 0x40; + const EGLint KBlueChannelColor = 0x60; + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight, + EGL_BORDER_COLOR_RED_NOK, KRedChannelColor, + EGL_BORDER_COLOR_BLUE_NOK, KBlueChannelColor, + EGL_BORDER_COLOR_GREEN_NOK, KGreenChannelColor, + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + CheckBorderColorL(KRedChannelColor, KBlueChannelColor, KGreenChannelColor); + + //modify existing attributes + const EGLint KOffsetColor = 100; + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, KRedChannelColor + KOffsetColor)); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, KBlueChannelColor + KOffsetColor)); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, KGreenChannelColor + KOffsetColor)); + + //check that border color has been modified now + CheckBorderColorL(KRedChannelColor+KOffsetColor, KBlueChannelColor+KOffsetColor, KGreenChannelColor+KOffsetColor); + + // Cleanup + iEglSess->CleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingModifyingBorderColor::doTestStepL completed!")); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0657 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Modifying an existing non-fixed size surface border color. + +@SYMTestActions +1. Create a non-fixed size EGL Window Surface. +2. Try to set border color after surface creation. +3. Repeat steps 1-2 for pixmap and pbuffer surface + +@SYMTestExpectedResults +Setting border color has no effect. +*/ +TVerdict CEglTest_SurfaceScalingModifyingBorderColorNonFixed::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0657")); + SetTestStepID(_L("GRAPHICS-EGL-0657")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingModifyingBorderColorNonFixed::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth; + const TInt KSurfaceHeight = KWindowHeight; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + // If all window surfaces in EGL are scalable, first case must be skipped. Others still valid + TInt index = iAllScalable ? 1 : 0; + for(; index < 3; index++) + { + switch(index) + { + case 0: + // Create the non-fixed size window surface and the egl context and make them current + INFO_PRINTF1(_L("Create the non-fixed size window surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribs_NoScaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow); + break; + case 1: + // Create the pbuffer surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pbuffer surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPBufferAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePbufferSurfaceAndMakeCurrentL(matchingConfigs[0], TSize(KSurfaceWidth, KSurfaceHeight)); + break; + case 2: + // Create the pixmap surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pixmap surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPixmapAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(TSize(KSurfaceWidth, KSurfaceHeight), EColor16MU); + break; + } + + // Set border color values to a non fixed size window (nothing should happen) + const EGLint KRedChannelColor = 0x20; + const EGLint KGreenChannelColor = 0x40; + const EGLint KBlueChannelColor = 0x60; + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, KRedChannelColor)); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, KBlueChannelColor)); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, KGreenChannelColor)); + + // Check all attributes (this is a non-fixed size window) + // Note that we cannot use CheckBorderColorL because values are not updated + EGLint redChannelColor = -1; + EGLint greenChannelColor = -2; + EGLint blueChannelColor = -3; + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, &redChannelColor)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, &blueChannelColor)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, &greenChannelColor)); + TEST(redChannelColor == -1); + TEST(greenChannelColor == -2); + TEST(blueChannelColor == -3); + + // Set invalid border color values to a non fixed size window (nothing should happen) + INFO_PRINTF1(_L("Attempt to set invalid border color values to a non fixed size window...")); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, KRedChannelColor+256)); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, KBlueChannelColor+256)); + ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, KGreenChannelColor+256)); + + // Check all attributes (this is a non-fixed size window) + // Note that we cannot use CheckBorderColorL because values are not updated + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, &redChannelColor)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, &blueChannelColor)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, &greenChannelColor)); + TEST(redChannelColor == -1); + TEST(greenChannelColor == -2); + TEST(blueChannelColor == -3); + + // destroy surface and context + iEglSess->CleanupSurfaceAndContextL(); + } + + // Cleanup + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingModifyingBorderColorNonFixed::doTestStepL completed!")); + + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0658 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Attempt to modify an existing fixed size surface border color with invalid values. + +@SYMTestActions +1. Create a fixed size EGL Window Surface with border color specified. +2. Try to modify border color with the negative values. +3. Try to modify border color with the positive values greater than 255. + +@SYMTestExpectedResults +Attempt to modify the border color with the new values will fail with error code EGL_BAD_ATTRIBUTE. +*/ +TVerdict CEglTest_SurfaceScalingModifyingInvalidBorderColor::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0658")); + SetTestStepID(_L("GRAPHICS-EGL-0658")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingModifyingInvalidBorderColor::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL (numConfigs == 1); // Abort the test if the EGL config is not supported + + // Make the fixed size surface half width and height of the window + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const EGLint KRedChannelColor = 0x20; + const EGLint KGreenChannelColor = 0x40; + const EGLint KBlueChannelColor = 0x60; + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, 0, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, 0, + EGL_TARGET_EXTENT_WIDTH_NOK, KWindowWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KWindowHeight, + EGL_BORDER_COLOR_RED_NOK, KRedChannelColor, + EGL_BORDER_COLOR_BLUE_NOK, KBlueChannelColor, + EGL_BORDER_COLOR_GREEN_NOK, KGreenChannelColor, + EGL_NONE}; + + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // check initial values match + CheckBorderColorL(KRedChannelColor, KBlueChannelColor, KGreenChannelColor); + + //modify existing attributes with negative value + INFO_PRINTF1(_L("Attempt to set negative border color values...")); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, -KRedChannelColor) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, -KBlueChannelColor) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, -KGreenChannelColor) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + //check that border color has not been modified + CheckBorderColorL(KRedChannelColor, KBlueChannelColor, KGreenChannelColor); + + //modify existing attributes with very big positive value + INFO_PRINTF1(_L("Attempt to set border color values that are too big...")); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, KRedChannelColor + 256) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, KBlueChannelColor + 256) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, KGreenChannelColor + 256) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + //check that border color has not been modified + CheckBorderColorL(KRedChannelColor, KBlueChannelColor, KGreenChannelColor); + + /// Cleanup + iEglSess->CleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingModifyingInvalidBorderColor::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0659 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Attempt to modify an extent with eglSurfaceAttrib() after surface has been created. + +@SYMTestActions +1. Create a fixed size EGL Window Surface. +2. Try to modify a surface extent parameters with arbitrary values via eglSurfaceAttrib(). + +@SYMTestExpectedResults +Attempt to modify the extent will fail with error code EGL_BAD_ATTRIBUTE. +*/ +TVerdict CEglTest_SurfaceScalingModifyingExtent::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0659")); + SetTestStepID(_L("GRAPHICS-EGL-0659")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingModifyingExtent::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + INFO_PRINTF1(_L("Attempt to modify surface extent for fixed size surfaces...")); + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL (numConfigs == 1); // Abort the test if the EGL config is not supported + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const TInt KExtentWidth = KWindowWidth; + const TInt KExtentHeight = KWindowHeight; + const TInt KOffsetX = 10; + const TInt KOffsetY = 20; + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, KOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, KOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight, + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Invalid update - modify existing attributes with any value + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_FIXED_WIDTH_NOK, KSurfaceWidth/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_FIXED_HEIGHT_NOK, KSurfaceHeight/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, KOffsetX/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, KOffsetY/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + + // check that attributes have not been modified + CheckScalingAttributesL(KSurfaceWidth, KSurfaceHeight, KExtentWidth, KExtentHeight, KOffsetX, KOffsetY); + + /// Cleanup + iEglSess->CleanupSurfaceAndContextL(); + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingModifyingExtent::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0671 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Attempt to modify an extent with eglSurfaceAttrib() after surface has been created. + +@SYMTestActions +1. Create a non fixed size EGL Window Surface. +2. Try to modify a surface extent parameters with arbitrary values via eglSurfaceAttrib(). +3. Repeat steps 2-3 for pixmap and pbuffer surface + +@SYMTestExpectedResults +Attempt to modify the extent will fail with error code EGL_BAD_ATTRIBUTE. +*/ +TVerdict CEglTest_SurfaceScalingModifyingExtentNonFixed::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0671")); + SetTestStepID(_L("GRAPHICS-EGL-0671")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingModifyingExtentNonFixed::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth; + const TInt KSurfaceHeight = KWindowHeight; + const TInt KExtentWidth = KWindowWidth; + const TInt KExtentHeight = KWindowHeight; + const TInt KOffsetX = 11; + const TInt KOffsetY = 22; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + // If all window surfaces in EGL are scalable, first case must be skipped. Others still valid + TInt index = iAllScalable ? 1 : 0; + for(; index < 3; index++) + { + switch(index) + { + case 0: + // Create the non-fixed size window surface and the egl context and make them current + INFO_PRINTF1(_L("Create the non-fixed size window surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribs_NoScaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow); + break; + case 1: + // Create the pbuffer surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pbuffer surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPBufferAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePbufferSurfaceAndMakeCurrentL(matchingConfigs[0], TSize(KSurfaceWidth, KSurfaceHeight)); + break; + case 2: + // Create the pixmap surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pixmap surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPixmapAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(TSize(KSurfaceWidth, KSurfaceHeight), EColor16MU); + break; + } + + // Invalid update - modify existing attributes with any value + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_FIXED_WIDTH_NOK, KSurfaceWidth/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_FIXED_HEIGHT_NOK, KSurfaceHeight/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, KOffsetX/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, KOffsetY/2) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + + // destroy surface and context + iEglSess->CleanupSurfaceAndContextL(); + } + + /// Cleanup + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingModifyingExtentNonFixed::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0660 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Query surface attrubutes related to scaling. + +@SYMTestActions +1. Create a non-fixed size EGL Window Surface. +2. Query surface attributes. + +@SYMTestExpectedResults +2. Query surface attributes succeeds and all atributes matches to the expected values. +*/ +TVerdict CEglTest_SurfaceScalingQuerySurface::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0660")); + SetTestStepID(_L("GRAPHICS-EGL-0660")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingQuerySurface::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL (numConfigs == 1); // Abort the test if the EGL config is not supported + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const TInt KExtentWidth = KWindowWidth; + const TInt KExtentHeight = KWindowHeight; + const EGLint KXOffset = 10; + const EGLint KYOffset = 20; + const EGLint KBorderColorRed = 0xa0; + const EGLint KBorderColorBlue = 0xf0; + const EGLint KBorderColorGreen = 0xfc; + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, KXOffset, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, KYOffset, + EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight, + EGL_BORDER_COLOR_BLUE_NOK, KBorderColorBlue, + EGL_BORDER_COLOR_GREEN_NOK, KBorderColorGreen, + EGL_BORDER_COLOR_RED_NOK, KBorderColorRed, + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + INFO_PRINTF1(_L("Query surface attributes and border colour back and check expected values...")); + CheckBorderColorL(KBorderColorRed, KBorderColorBlue, KBorderColorGreen); + CheckScalingAttributesL(KSurfaceWidth, KSurfaceHeight, KExtentWidth, KExtentHeight, KXOffset, KYOffset); + + INFO_PRINTF1(_L("Check EGL_FIXED_WIDTH_NOK and EGL_FIXED_HEIGHT_NOK cannot be queried...")); + EGLint surfaceFixedWidth = -1; + EGLint surfaceFixedHeight = -2; + TEST(EGL_FALSE == eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_FIXED_WIDTH_NOK, &surfaceFixedWidth)); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(EGL_FALSE == eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_FIXED_HEIGHT_NOK, &surfaceFixedHeight)); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(surfaceFixedWidth == -1); + TEST(surfaceFixedHeight == -2); + + // clean-up + iEglSess->CleanupSurfaceAndContextL(); + CloseWindow(); + CleanAll(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingQuerySurface::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0662 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Query surface attributes which are not supported by this API. + +@SYMTestActions +1. Create a non-fixed size EGL window surface. +2. Query surface attributes. +3. Repeat step 2 for EGL window surface, pixmap and pbuffer surface + +@SYMTestExpectedResults +Query surface attributes will fail with error code EGL_BAD_ATTRIBUTE. +*/ +TVerdict CEglTest_SurfaceScalingQuerySurfaceNonFixed::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0662")); + SetTestStepID(_L("GRAPHICS-EGL-0662")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingQuerySurfaceNonFixed::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100,100)); + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth; + const TInt KSurfaceHeight = KWindowHeight; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + // If all window surfaces in EGL are scalable, first case must be skipped. Others still valid + TInt index = iAllScalable ? 1 : 0; + for(; index < 3; index++) + { + switch(index) + { + case 0: + // Create the non-fixed size window surface and the egl context and make them current + INFO_PRINTF1(_L("Create the non-fixed size window surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribs_NoScaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow); + break; + case 1: + // Create the pbuffer surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pbuffer surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPBufferAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePbufferSurfaceAndMakeCurrentL(matchingConfigs[0], TSize(KSurfaceWidth, KSurfaceHeight)); + break; + case 2: + // Create the pixmap surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pixmap surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPixmapAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(TSize(KSurfaceWidth, KSurfaceHeight), EColor16MU); + break; + } + + INFO_PRINTF1(_L("Check EGL_FIXED_WIDTH_NOK and EGL_FIXED_HEIGHT_NOK cannot be queried...")); + EGLint surfaceFixedWidth = -1; + EGLint surfaceFixedHeight = -2; + TEST(EGL_FALSE == eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_FIXED_WIDTH_NOK, &surfaceFixedWidth)); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(EGL_FALSE == eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_FIXED_HEIGHT_NOK, &surfaceFixedHeight)); + ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE); + TEST(surfaceFixedWidth == -1); + TEST(surfaceFixedHeight == -2); + + INFO_PRINTF1(_L("Check surface size is as we would expect...")); + EGLint surfaceWidth = 0; + EGLint surfaceHeight = 0; + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_WIDTH, &surfaceWidth)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_HEIGHT, &surfaceHeight)); + TEST(surfaceWidth == KWindowWidth); // non-fixed size surface + TEST(surfaceHeight == KWindowHeight); // non-fixed size surface + + INFO_PRINTF1(_L("Check scaling attributes cannot be queried...")); + EGLint extentOffsetX = -1; + EGLint extentOffsetY = -2; + EGLint extentWidth = -3; + EGLint extentHeight = -4; + EGLint borderColorBlue = -5; + EGLint borderColorRed = -6; + EGLint borderColorGreen = -7; + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, &extentOffsetX)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, &extentOffsetY)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, &extentWidth)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, &extentHeight)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, &borderColorBlue)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, &borderColorGreen)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, &borderColorRed)); + TEST(extentOffsetX == -1); + TEST(extentOffsetY == -2); + TEST(extentWidth == -3); + TEST(extentHeight == -4); + TEST(borderColorBlue == -5); + TEST(borderColorRed == -6); + TEST(borderColorGreen == -7); + + // destroy surface and context + iEglSess->CleanupSurfaceAndContextL(); + } + + // clean-up + CloseWindow(); + CleanAll(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingQuerySurfaceNonFixed::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0663 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Query surface scaling capability with invalid parameters. + +@SYMTestActions +1. Query surface scaling capability for the different configs. +2. Query surface scaling capability with invalid display. +3. Query surface scaling capability with negative surface width. +4. Query surface scaling capability with negative surface height. +5. Query surface scaling capability with negative target width. +6. Query surface scaling capability with negative target height. +7. Query surface scaling capability with zero surface width. +8. Query surface scaling capability with zero surface height. +9. Query surface scaling capability with zero target width. +10. Query surface scaling capability with zero target height. + +@SYMTestExpectedResults +1. Query surface capability will fail with error code EGL_BAD_MATCH if config doesn't support scaling and succeed otherwise. +2. Query surface capability will fail with error code EGL_BAD_DISPLAY. +3. Query surface capability will fail with error code EGL_BAD_PARAMETER. +4. Query surface capability will fail with error code EGL_BAD_PARAMETER. +5. Query surface capability will fail with error code EGL_BAD_PARAMETER. +6. Query surface capability will fail with error code EGL_BAD_PARAMETER. +7. Query surface capability will fail with error code EGL_BAD_PARAMETER. +8. Query surface capability will fail with error code EGL_BAD_PARAMETER. +9. Query surface capability will fail with error code EGL_BAD_PARAMETER. +10. Query surface capability will fail with error code EGL_BAD_PARAMETER. +*/ +TVerdict CEglTest_SurfaceScalingCapability::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0663")); + SetTestStepID(_L("GRAPHICS-EGL-0663")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingCapability::doTestStepL")); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[KMaxEglConfigs]; + EGLint numConfigs = 0; + + CreateAndActivateWindowL(TSize(100,100)); + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const EGLDisplay KInvalidDisplay = iDisplay - 100; + EGLint capability = -1; //arbitrary number beyond the existing range + EGLConfig config = -1; + + INFO_PRINTF1(_L("Calling eglGetConfigs to get configs...")); + ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, matchingConfigs, KMaxEglConfigs, &numConfigs)); + for(TInt index = 0; index < numConfigs; index++) + { + EGLint value = EGL_FALSE; + ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, matchingConfigs[index], EGL_SURFACE_SCALING_NOK, &value)); + if(value == EGL_FALSE) + { + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, matchingConfigs[index], KSurfaceWidth, KSurfaceHeight, KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_MATCH); + } + else + { + if(config == -1) + {//memorize the first config that supports scaling + config = matchingConfigs[index]; + } + ASSERT_EGL_TRUE(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, matchingConfigs[index], KSurfaceWidth, KSurfaceHeight, KWindowWidth, KWindowHeight, &capability)); + TEST((capability == EGL_SUPPORTED_NOK) || (capability == EGL_SLOW_NOK)); + capability = -1; + } + } + capability = -1; + TEST(config != -1); // make sure that at least one config supports scaling + + //invalid display + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(KInvalidDisplay, config, KSurfaceWidth, KSurfaceHeight, KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_DISPLAY); + + //negative width + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, -KSurfaceWidth, KSurfaceHeight, KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, KSurfaceWidth, KSurfaceHeight, -KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + //negative height + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, KSurfaceWidth, -KSurfaceHeight, KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, KSurfaceWidth, KSurfaceHeight, KWindowWidth, -KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + //zero width + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, -0, KSurfaceHeight, KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, KSurfaceWidth, KSurfaceHeight, -0, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + //zero height + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, KSurfaceWidth, -0, KWindowWidth, KWindowHeight, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + TEST(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, config, KSurfaceWidth, KSurfaceHeight, KWindowWidth, -0, &capability) == EGL_FALSE); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_BAD_PARAMETER); + + // Cleanup + CloseWindow(); + CleanAll(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingCapability::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0664 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Call eglSetSurfaceScalingNOK with fixed size surface and a target extent that can be set. + +@SYMTestActions +Retrieve all available EGL configs and for those that support surface scaling +1. Create a window surface with surface scaling attributes and make it current +2. Query these attributes and check they correspond with what is expected +3. Query if surface supports scaling to a different extent +4. Set the new extent and new offset to the surface +5. Query these attributes + +@SYMTestExpectedResults +5. Surface scaling attributes have been updated +*/ +TVerdict CEglTest_SurfaceScalingSet::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0664")); + SetTestStepID(_L("GRAPHICS-EGL-0664")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingSet::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100, 100)); + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const TInt KExtentWidth = KWindowWidth; + const TInt KExtentHeight = KWindowHeight; + const EGLint KOffsetX = 3; + const EGLint KOffsetY = 7; + + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, KOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, KOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight, + EGL_NONE}; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[KMaxEglConfigs]; + EGLint numConfigs = 0; + + // Query total number of configs + ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, NULL, KMaxTInt, &numConfigs)); + TESTL(numConfigs >= 1 && numConfigs <= KMaxEglConfigs); + INFO_PRINTF2(_L("Found %d configs"), numConfigs); + + // Get the configs + ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, matchingConfigs, KMaxEglConfigs, &numConfigs)); + + // Check if surface scaling is supported in the config, if so, create surface + for(TInt i=0; iCreateWindowSurfaceAndMakeCurrentL(matchingConfigs[i], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + } + else if (renderableType&EGL_OPENGL_ES_BIT) + { + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[i], iWindow, EFalse, EGL_OPENGL_ES_API, 1, attrib_list); + } + else + { + WARN_PRINTF2(_L("Config %d does not support either OPENVG or OPENGL_ES. Skip!"), i); + continue; + } + + // Check values are as expected + CheckScalingAttributesL(KSurfaceWidth, KSurfaceHeight, KExtentWidth, KExtentHeight, KOffsetX, KOffsetY); + + // modify target extent atttributes + // 1 - first check that this new extent is supported, should do as we're reducing it + EGLint capability = -1; //arbitrary number beyond the existing range + EGLint newExtentWidth = KExtentWidth / 2; + EGLint newExtentHeight = KExtentHeight / 2; + EGLint newOffsetX = KOffsetX * 2; + EGLint newOffsetY = KOffsetY * 2; + ASSERT_EGL_TRUE(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, matchingConfigs[i], KSurfaceWidth, KSurfaceHeight, newExtentWidth, newExtentHeight, &capability)); + TEST((capability == EGL_SUPPORTED_NOK) || (capability == EGL_SLOW_NOK)); + // 2 - set new extent + ASSERT_EGL_TRUE(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), newOffsetX, newOffsetY, newExtentWidth, newExtentHeight)); + + // Check attributes have changed + CheckScalingAttributesL(KSurfaceWidth, KSurfaceHeight, newExtentWidth, newExtentHeight, newOffsetX, newOffsetY); + + // Cleanup + iEglSess->CleanupSurfaceAndContextL(); + } + } + + // Cleanup + CloseWindow(); + CleanAll(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingSet::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0665 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Call eglSetSurfaceScalingNOK with invalid parameters + +@SYMTestActions +1. Set surface scaling with invalid display. +2. Set surface scaling with negative target width. +3. Set surface scaling with negative target height. +3. Set surface scaling with zero target width. +3. Set surface scaling with zero target height. +@SYMTestExpectedResults +1. Set surface scaling will fail with error code EGL_BAD_DISPLAY. +2. Set surface scaling will fail with error code EGL_BAD_PARAMETER. +3. Set surface scaling will fail with error code EGL_BAD_PARAMETER. +4. Set surface scaling will fail with error code EGL_BAD_PARAMETER. +5. Set surface scaling will fail with error code EGL_BAD_PARAMETER. +*/ +TVerdict CEglTest_SurfaceScalingSetInvalidAttributes::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0665")); + SetTestStepID(_L("GRAPHICS-EGL-0665")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingSetInvalidAttributes::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100, 100)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const TInt KExtentWidth = KWindowWidth; + const TInt KExtentHeight = KWindowHeight; + const EGLint KOffsetX = 11; + const EGLint KOffsetY = 13; + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, KOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, KOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight, + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // Check all attributes + CheckScalingAttributesL(KSurfaceWidth, KSurfaceHeight, KExtentWidth, KExtentHeight, KOffsetX, KOffsetY); + + for(TInt index = 0; index < 5; index++) + { + // new attribute values + EGLDisplay newDisplay = iDisplay; + EGLint newExtentWidth = KExtentWidth; + EGLint newExtentHeight = KExtentHeight; + EGLint newOffsetX = KOffsetX; + EGLint newOffsetY = KOffsetY; + // expected error value + EGLint error = EGL_BAD_PARAMETER; + + switch(index) + { + case 0: + // Invalid display - valid extent + newDisplay = newDisplay - 100; + error = EGL_BAD_DISPLAY; + break; + case 1: + // Valid display - Negative extent width + newExtentWidth = -newExtentHeight; + break; + case 2: + // Valid display - Negative extent height + newExtentHeight = -newExtentHeight; + break; + case 3: + // Valid display - zero extent width + newExtentWidth = 0; + break; + case 4: + // Valid display - zero extent height + newExtentHeight = 0; + break; + } + + TEST(EGL_FALSE == iPfnEglSetSurfaceScalingNOK(newDisplay, iEglSess->Surface(), newOffsetX, newOffsetY, newExtentWidth, newExtentHeight)); + ASSERT_EGL_ERROR(error); + + // attributes haven't changed + CheckScalingAttributesL(KSurfaceWidth, KSurfaceHeight, KWindowWidth, KWindowHeight, KOffsetX, KOffsetY); + } + + // Cleanup + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingSetInvalidAttributes::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0666 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Query scaling attributes in non-fixed size surfaces + +@SYMTestActions +1. Create a window surface from a non-fixed size surface +2. Set surface scaling with valid target extent. +3. Query scaling attributes +4. Repeat step 2-3 for EGL window surface, pixmap and pbuffer surface + +@SYMTestExpectedResults +2. Set surface scaling will fail with error code EGL_BAD_MATCH. +3. Query scaling attributes does not fail, but values not updated +*/ +TVerdict CEglTest_SurfaceScalingSetNonFixed::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0666")); + SetTestStepID(_L("GRAPHICS-EGL-0666")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingSetNonFixed::doTestStepL")); + + // Establish the connection to the window server and create + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100, 100)); + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth; + const TInt KSurfaceHeight = KWindowHeight; + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config - Make sure it DOES NOT support surface scaling + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + + // If all window surfaces in EGL are scalable, first case must be skipped. Others still valid + TInt index = iAllScalable ? 1 : 0; + for(; index < 3; index++) + { + switch(index) + { + case 0: + // Create the non-fixed size window surface and the egl context and make them current + INFO_PRINTF1(_L("Create the non-fixed size window surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribs_NoScaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow); + break; + case 1: + // Create the pbuffer surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pbuffer surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPBufferAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePbufferSurfaceAndMakeCurrentL(matchingConfigs[0], TSize(KSurfaceWidth, KSurfaceHeight)); + break; + case 2: + // Create the pixmap surface and the egl context and make them current + INFO_PRINTF1(_L("Create the pixmap surface and the egl context and make them current...")); + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[EPixmapAttribsColor16MU], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); + iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(TSize(KSurfaceWidth, KSurfaceHeight), EColor16MU); + break; + } + + // Check all attributes (this is a non-fixed size surface) - + // Note that we cannot use CheckScalingAttributesL because values are not updated + EGLint surfaceWidth = 0; + EGLint surfaceHeight = 0; + EGLint extentWidth = -1; + EGLint extentHeight = -2; + EGLint offsetX = -3; + EGLint offsetY = -4; + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_WIDTH, &surfaceWidth)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_HEIGHT, &surfaceHeight)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, &extentWidth)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, &extentHeight)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, &offsetX)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, &offsetY)); + TEST((surfaceWidth == KWindowWidth) && (surfaceHeight == KWindowHeight)); + // following values should not be modified (non fixed size window) + TEST((extentWidth == -1) && (extentHeight == -2)); + TEST((offsetX == -3) && (offsetY == -4)); + + // new attribute values + EGLint newExtentWidth = extentWidth / 2; + EGLint newExtentHeight = extentHeight / 2; + EGLint newOffsetX = offsetX * 2; + EGLint newOffsetY = offsetY * 2; + + // Valid parameters - But non fixed size surface + TEST(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), newOffsetX, newOffsetY, newExtentWidth, newExtentHeight) == EGL_FALSE); + ASSERT_EGL_ERROR(EGL_BAD_MATCH); + + // attributes haven't changed + // Note that we cannot use CheckScalingAttributesL because values are not updated + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_WIDTH, &surfaceWidth)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_HEIGHT, &surfaceHeight)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, &extentWidth)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, &extentHeight)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, &offsetX)); + ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, &offsetY)); + TEST((surfaceWidth == KWindowWidth) && (surfaceHeight == KWindowHeight)); + TEST((extentWidth == -1) && (extentHeight == -2)); + TEST((offsetX == -3) && (offsetY == -4)); + + // destroy surface and context + iEglSess->CleanupSurfaceAndContextL(); + } + + // Cleanup + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingSetNonFixed::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +/** +@SYMTestCaseID GRAPHICS-EGL-0667 + +@SYMTestPriority 1 + +@SYMPREQ 2676 + +@SYMREQ 417-56592 + +@SYMTestCaseDesc +Negative testing. Calling extensions without initialising EGL + +@SYMTestActions +Without initialising EGL +1. Call query surface scaling capability +2. Call set surface scaling + +@SYMTestExpectedResults +1. Query scaling capability will fail with error code EGL_NOT_INITIALIZED. +2. Set surface scaling will fail with error code EGL_NOT_INITIALIZED. +*/ +TVerdict CEglTest_SurfaceScalingNotInitialized::doTestStepL() + { + SetTestStepName(_L("GRAPHICS-EGL-0667")); + SetTestStepID(_L("GRAPHICS-EGL-0667")); + INFO_PRINTF1(_L("CEglTest_SurfaceScalingNotInitialized::doTestStepL")); + + // a WindowGroup and a Window object + CreateAndActivateWindowL(TSize(100, 100)); + + // Create display object + GetDisplayL(); + CreateEglSessionL(); // initialise EGL Session so we can make use of its helper objects + iEglSess->InitializeL(); + + // Choose EGL config + EGLConfig matchingConfigs[1]; + EGLint numConfigs = 0; + ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs)); + TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported + + const TInt KWindowWidth = iWindow.Size().iWidth; + const TInt KWindowHeight = iWindow.Size().iHeight; + const TInt KSurfaceWidth = KWindowWidth/2; + const TInt KSurfaceHeight = KWindowHeight/2; + const TInt KExtentWidth = KWindowWidth; + const TInt KExtentHeight = KWindowHeight; + const EGLint KOffsetX = 11; + const EGLint KOffsetY = 13; + EGLint attrib_list[] = { + EGL_FIXED_WIDTH_NOK, KSurfaceWidth, + EGL_FIXED_HEIGHT_NOK, KSurfaceHeight, + EGL_TARGET_EXTENT_OFFSET_X_NOK, KOffsetX, + EGL_TARGET_EXTENT_OFFSET_Y_NOK, KOffsetY, + EGL_TARGET_EXTENT_WIDTH_NOK, KExtentWidth, + EGL_TARGET_EXTENT_HEIGHT_NOK, KExtentHeight, + EGL_NONE}; + + // Create the window surface and the egl context and make them current + iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list); + + // First set new offset attributes (fairly simple, so should be supported) + INFO_PRINTF1(_L("Set new offset attributes - should succeed...")); + EGLint capability = -1; //arbitrary number beyond the existing range + ASSERT_EGL_TRUE(iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, matchingConfigs[0], KSurfaceWidth, KSurfaceHeight, KExtentWidth, KExtentHeight, &capability)); + TEST((capability == EGL_SUPPORTED_NOK) || (capability == EGL_SLOW_NOK)); + ASSERT_EGL_TRUE(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), KOffsetX+1, KOffsetY+1, KExtentWidth, KExtentHeight)); + + // Terminate display and try again + INFO_PRINTF1(_L("Terminate display and try again, should fail now...")); + eglTerminate(iDisplay); + + capability = -1; //arbitrary number beyond the existing range + TEST(EGL_FALSE == iPfnEglQuerySurfaceScalingCapabilityNOK(iDisplay, matchingConfigs[0], KSurfaceWidth, KSurfaceHeight, KExtentWidth, KExtentHeight, &capability)); + TEST(capability == -1); //make sure that value has not been modified + ASSERT_EGL_ERROR(EGL_NOT_INITIALIZED); + + TEST(EGL_FALSE == iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), KOffsetX, KOffsetY, KExtentWidth, KExtentHeight)); + ASSERT_EGL_ERROR(EGL_NOT_INITIALIZED); + + // Cleanup + CleanAll(); + CloseWindow(); + + INFO_PRINTF1(_L("....CEglTest_SurfaceScalingNotInitialized::doTestStepL completed!")); + RecordTestResultL(); + CloseTMSGraphicsStep(); + return TestStepResult(); + } +