1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @test

    19 */

    20 

    21 #include "egltest_surfacescaling.h"

    22 

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

    24 #include <test/egltestcommonutils.h>

    25 #include "egltestcommoninisettings.h"

    26 

    27 //We are restricted by the screen comparison utility that requires images to be EColor16MU

    28 const TDisplayMode KTestSourceDisplayMode = EColor16MU;

    29 

    30 CEglTest_SurfaceScalingBase::~CEglTest_SurfaceScalingBase()

    31     {

    32 	CleanAll();

    33 	delete iImageComparison;

    34 	delete iScreenDevice;

    35     CloseWindow();

    36     CloseWsSession();

    37     }

    38 

    39 TVerdict CEglTest_SurfaceScalingBase::doTestStepPreambleL()

    40     {

    41     TVerdict verdict = CEglTestStep::doTestStepPreambleL();

    42 

    43     INFO_PRINTF1(_L("doTestStepPreambleL() - Initialise surface scaling test settings..."));

    44     if(!CheckForExtensionL(KEGL_NOK_surface_scaling))

    45         {

    46 		ERR_PRINTF1(_L("KEGL_NOK_surface_scaling not supported!"));

    47         User::Leave(KErrNotSupported);

    48         }

    49     //retrieve the pointers to the EGL surface scaling extension functions 

    50     iPfnEglQuerySurfaceScalingCapabilityNOK = reinterpret_cast <TFPtrEglQuerySurfaceScalingCapabilityNok> (eglGetProcAddress("eglQuerySurfaceScalingCapabilityNOK"));

    51     iPfnEglSetSurfaceScalingNOK = reinterpret_cast <TFPtrEglSetSurfaceScalingNok> (eglGetProcAddress("eglSetSurfaceScalingNOK"));

    52 	if(!iPfnEglQuerySurfaceScalingCapabilityNOK)

    53 		{

    54 		ERR_PRINTF1(_L("   Cannot retrieve address of the \"eglQuerySurfaceScalingCapabilityNOK\" function"));

    55         User::Leave(KErrNotSupported);

    56 		}

    57 	if(!iPfnEglSetSurfaceScalingNOK)

    58 		{

    59 		ERR_PRINTF1(_L("   Cannot retrieve address of the \"eglSetSurfaceScalingNOK\" function"));

    60         User::Leave(KErrNotSupported);

    61 		}

    62 

    63     //retrieve surface scaling ini settings

    64 	CIniData* iniData = CIniData::NewL(KConfigFileName);

    65     CleanupStack::PushL(iniData);

    66     

    67     _LIT(KSectionSurfaceScaling, "SurfaceScaling");

    68     _LIT(KKeyAllScalable, "AllScalable"); 

    69     

    70     TPtrC scalable;

    71 	if(!iniData->FindVar(KSectionSurfaceScaling,KKeyAllScalable,scalable))

    72         {

    73 		ERR_PRINTF3(_L("   Cannot retrieve section:%S key:%S"), &KSectionSurfaceScaling, &KKeyAllScalable);

    74 		User::Leave(KErrNotSupported);

    75         }

    76 	iAllScalable = (scalable.FindF( _L("true"))==KErrNotFound)? EFalse : ETrue;

    77 	INFO_PRINTF1(_L("  ************************************************************************"));

    78 	INFO_PRINTF1(_L("  ****   The test will be run in following configuration: "));

    79 	INFO_PRINTF2(_L("  ****   All window surfaces scalable: %S"), &scalable);

    80 	INFO_PRINTF1(_L("  ************************************************************************"));

    81 	CleanupStack::PopAndDestroy(iniData);

    82 

    83     //Initiate a window server session and create a window group

    84     OpenWsSessionL(KDefaultWindowGroupId);

    85 

    86     //Create a Screen Device

    87     const TInt screen0 = 0;

    88     iScreenDevice = new(ELeave) CWsScreenDevice(iWsSession);

    89     User::LeaveIfError(iScreenDevice->Construct(screen0));

    90     

    91     // get full screen size

    92     TPixelsAndRotation sizeAndRotation;

    93     iScreenDevice->GetDefaultScreenSizeAndRotation(sizeAndRotation);

    94     iScreenSize = sizeAndRotation.iPixelSize;

    95     		

    96 	//Create the image comparison tool from the screen device as required by most tests 		

    97     iImageComparison = CTGraphicsScreenComparison::NewL(*iScreenDevice);

    98 

    99     return verdict;

   100     }

   101 

   102 TVerdict CEglTest_SurfaceScalingBase::doTestStepPostambleL()

   103     {

   104 	INFO_PRINTF1(_L("doTestStepPostambleL() - Cleaning up"));

   105 	

   106 	// cleanup egltest framework stuff

   107 	CleanAll();

   108 

   109 	// cleanup member variables

   110 	delete iImageComparison;

   111 	iImageComparison = NULL;

   112 	delete iScreenDevice;

   113 	iScreenDevice = NULL;

   114 	

   115 	// close window and wserver session

   116     CloseWindow();

   117     CloseWsSession();

   118 

   119     return CEglTestStep::doTestStepPostambleL();

   120     }

   121 

   122 void CEglTest_SurfaceScalingBase::CreateAndActivateWindowL(const TSize& aWindowSize)

   123     {

   124     ConstructWindowL(iWindow, aWindowSize);

   125     }

   126 

   127 void CEglTest_SurfaceScalingBase::CloseWindow()

   128     {

   129 	iWindow.Close();

   130     }

   131 

   132 //check if border color matches with expected values

   133 void CEglTest_SurfaceScalingBase::CheckBorderColorL(EGLint aExpectedRedChannelColor, EGLint aExpectedBlueChannelColor, EGLint aExpectedGreenChannelColor)

   134     {

   135     EGLint value = 0xffff; //set color channel to some arbitrary number 

   136     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_RED_NOK, &value));

   137     ASSERT_EQUALS(value, aExpectedRedChannelColor);

   138 

   139     value = 0xffff; //set color channel to some arbitrary number

   140     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_GREEN_NOK, &value));

   141     ASSERT_EQUALS(value, aExpectedGreenChannelColor);

   142 

   143     value = 0xffff; //set color channel to some arbitrary number

   144     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, &value));

   145     ASSERT_EQUALS(value, aExpectedBlueChannelColor);

   146     }

   147 

   148 //check if scaling attributes match with expected values

   149 void CEglTest_SurfaceScalingBase::CheckScalingAttributesL(EGLint aExpectedSurfaceWidth, EGLint aExpectedSurfaceHeight, EGLint aExpectedExtentWidth, EGLint aExpectedExtentHeight, EGLint aExpectedOffsetX, EGLint aExpectedOffsetY)

   150     {

   151     EGLint value = 0xffff; //set initial value to some arbitrary number 

   152     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_WIDTH, &value));

   153     ASSERT_EQUALS(value, aExpectedSurfaceWidth);

   154     

   155     value = 0xffff; //set initial value to some arbitrary number 

   156     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_HEIGHT, &value));

   157     ASSERT_EQUALS(value, aExpectedSurfaceHeight);

   158     

   159     value = 0xffff; //set initial value to some arbitrary number 

   160     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_WIDTH_NOK, &value));

   161     ASSERT_EQUALS(value, aExpectedExtentWidth);

   162 

   163     value = 0xffff; //set initial value to some arbitrary number 

   164     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_HEIGHT_NOK, &value));

   165     ASSERT_EQUALS(value, aExpectedExtentHeight);

   166    

   167     value = 0xffff; //set initial value to some arbitrary number 

   168     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_X_NOK, &value));

   169     ASSERT_EQUALS(value, aExpectedOffsetX);

   170    

   171     value = 0xffff; //set initial value to some arbitrary number 

   172     ASSERT_EGL_TRUE(eglQuerySurface(iDisplay, iEglSess->Surface(), EGL_TARGET_EXTENT_OFFSET_Y_NOK, &value));

   173     ASSERT_EQUALS(value, aExpectedOffsetY);

   174     }

   175 

   176 /*

   177  Simple create bitmap function to initialise a rectangular bitmap in four simple colours plus borders

   178      ---------------------------

   179     ¦         borderTop         ¦

   180     ¦     -----------------     ¦

   181     ¦ b. ¦        ¦        ¦ b. ¦

   182     ¦    ¦    1   ¦   2    ¦    ¦

   183     ¦ L  ¦        ¦        ¦ R  ¦

   184     ¦ e  ¦--------¦--------¦ i  ¦

   185     ¦ f  ¦        ¦        ¦ g  ¦

   186     ¦ t  ¦    3   ¦   4    ¦ h  ¦

   187     ¦    ¦        ¦        ¦ t  ¦

   188     ¦     -----------------     ¦

   189     ¦       borderBottom        ¦

   190      --------------------------- 

   191 */

   192 CFbsBitmap* CEglTest_SurfaceScalingBase::CreateBitmapLC(const TSize& aSize, TInt aBorderTop, TInt aBorderBottom, TInt aBorderLeft, TInt aBorderRight, const TRgb& aBorderColor)

   193     {

   194     // create the bitmap to the requested size (DisplayMode set to default value)

   195     CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

   196     CleanupStack::PushL(bitmap);

   197     User::LeaveIfError(bitmap->Create(aSize,KTestSourceDisplayMode));

   198     TEST(bitmap->SizeInPixels().iHeight == aSize.iHeight);

   199     TEST(bitmap->SizeInPixels().iWidth == aSize.iWidth);

   200 

   201     //Create a device and context for the purpose of generating the bitmap which will be the

   202     //master reference used in the test

   203     CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmap);

   204     CleanupStack::PushL(bitmapDevice);

   205     CFbsBitGc* bitmapGc = CFbsBitGc::NewL();

   206     CleanupStack::PushL(bitmapGc);

   207     bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

   208     bitmapGc->Activate(bitmapDevice);

   209 

   210     // First off, set the whole bitmap to the border colour

   211     bitmapGc->SetBrushColor(aBorderColor);

   212     bitmapGc->SetPenColor(aBorderColor);

   213     bitmapGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   214     bitmapGc->DrawRect(aSize);

   215     

   216     // Set each individual quadrant to a different arbitrary colour

   217     const TInt height = aSize.iHeight;

   218     const TInt width  = aSize.iWidth;

   219     const TInt quadrantHeight = (height - aBorderTop - aBorderBottom) / 2;

   220     const TInt quadrantWidth = (width - aBorderLeft - aBorderRight) / 2;

   221 

   222     // quadrant 1 - Colour KRgbMagenta

   223     TRect rect = TRect(TPoint(aBorderLeft, aBorderTop), TSize(quadrantWidth, quadrantHeight));

   224     bitmapGc->SetBrushColor(KRgbMagenta);

   225     bitmapGc->SetPenColor(KRgbMagenta);

   226     bitmapGc->DrawRect(rect);

   227 

   228     // quadrant 2 - Colour KRgbCyan

   229     rect = TRect(TPoint(aBorderLeft+quadrantWidth, aBorderTop), TSize(quadrantWidth, quadrantHeight));

   230     bitmapGc->SetBrushColor(KRgbCyan);

   231     bitmapGc->SetPenColor(KRgbCyan);

   232     bitmapGc->DrawRect(rect);

   233 

   234     // quadrant 3 - Colour KRgbYellow

   235     rect = TRect(TPoint(aBorderLeft, aBorderTop+quadrantHeight), TSize(quadrantWidth, quadrantHeight));

   236     bitmapGc->SetBrushColor(KRgbYellow);

   237     bitmapGc->SetPenColor(KRgbYellow);

   238     bitmapGc->DrawRect(rect);

   239 

   240     // quadrant 4 - Colour KRgbDarkGreen

   241     rect = TRect(TPoint(aBorderLeft+quadrantWidth, aBorderTop+quadrantHeight), TSize(quadrantWidth, quadrantHeight));

   242     bitmapGc->SetBrushColor(KRgbDarkGreen);

   243     bitmapGc->SetPenColor(KRgbDarkGreen);

   244     bitmapGc->DrawRect(rect);

   245 

   246     //clean-up

   247     CleanupStack::PopAndDestroy(2, bitmapDevice);

   248     return bitmap;

   249     }

   250 

   251 void CEglTest_SurfaceScalingBase::WritePixelsToSurfaceL(const CFbsBitmap& aBitmap)

   252 	{

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

   254     const TSize bitmapSize = aBitmap.SizeInPixels();

   255     TUint8* address = reinterpret_cast<TUint8*>(aBitmap.DataAddress());

   256     const TInt stride = aBitmap.DataStride();

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

   258     

   259     // copy pixel data to the drawing surface

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

   261     ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   262     

   263     // force all outstanding requests on the current context to complete

   264     vgFinish();

   265     iWsSession.Finish();

   266 	}

   267 

   268 /**

   269 @SYMTestCaseID GRAPHICS-EGL-0651

   270 

   271 @SYMTestPriority 1

   272 

   273 @SYMPREQ 2676

   274 

   275 @SYMREQ 417-56592

   276 

   277 @SYMTestCaseDesc

   278 Choose a suitable extent to test that specified border colours are correct.

   279 

   280 @SYMTestActions

   281 For a number of different situations, do the following:

   282 1. Create a window of known size

   283 2. Create a fixed size surface, filled in with a predefined bitmap

   284 3. Draw the surface onto the window for a set extent and border colour

   285 4. Compare window content and border against a reference bitmap containing expected values. 

   286 

   287 @SYMTestExpectedResults

   288 The window content matches the independently created reference bitmap in each situation

   289 */

   290 TVerdict CEglTest_SurfaceScaling_Positive::doTestStepL()

   291     {

   292     SetTestStepID(_L("GRAPHICS-EGL-0651"));

   293     SetTestStepName(_L("GRAPHICS-EGL-0651"));

   294     INFO_PRINTF1(_L("CEglTest_SurfaceScaling_Positive::doTestStepL started...."));

   295 

   296     // Create display object

   297     GetDisplayL();

   298     CreateEglSessionL();    // initialise EGL Session so we can make use of its helper objects

   299     iEglSess->InitializeL();

   300     

   301     //  NOTE: Borders depend on what you set as extent, offset, window and surface

   302     //        Care should be taken when choosing size values, better to use even numbers

   303 	//		  (CreateBitmap splits rectangle in four, so we don't want a pixel mismatch there) 

   304     for (TInt index=1; index<=17; index++)

   305     	{

   306 		// Set some default values which are used in most cases

   307 		iWindowWidth = iWindowHeight = 200;

   308 		iBorderColor = TRgb(0,0,0);

   309 	    iBorderTop = iBorderBottom = iBorderLeft = iBorderRight = 0;

   310 

   311 	    switch(index)

   312         {

   313 		case 1:

   314 			// surface scaled to same window size with no border

   315 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   316 		    iExtentWidth = 200; iExtentHeight = 200;

   317 		    iOffsetX = 0; iOffsetY = 0;

   318 			break;

   319 		case 2:

   320 			// surface scaled to half the window size with border top 

   321 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   322 		    iExtentWidth = 200; iExtentHeight = 100;

   323 		    iOffsetX = 0; iOffsetY = 100;

   324 		    iBorderColor = TRgb(0,0,0);         // arbitrary border colour

   325 		    iBorderTop = 100;

   326 			break;

   327 		case 3:

   328 			// surface scaled to half the window size with border bottom

   329 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   330 		    iExtentWidth = 200; iExtentHeight = 100;

   331 		    iOffsetX = 0; iOffsetY = 0;

   332 		    iBorderColor = TRgb(128,0,255);     // arbitrary border colour

   333 		    iBorderBottom = 100;

   334 			break;

   335 		case 4:

   336 			// surface scaled to half the window size with border top and bottom

   337 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   338 		    iExtentWidth = 200; iExtentHeight = 100;

   339 		    iOffsetX = 0; iOffsetY = 50;

   340 		    iBorderColor = TRgb(128,0,0);         // arbitrary border colour

   341 		    iBorderTop = 50; iBorderBottom = 50;

   342 			break;

   343 		case 5:

   344 			// surface scaled to half the window size with border left

   345 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   346 		    iExtentWidth = 100; iExtentHeight = 200;

   347 		    iOffsetX = 100; iOffsetY = 0;

   348 		    iBorderColor = TRgb(96,96,96);         // arbitrary border colour

   349 		    iBorderLeft = 100;

   350 			break;

   351 		case 6:

   352 			// surface scaled to half the window size with border right

   353 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   354 		    iExtentWidth = 100; iExtentHeight = 200;

   355 		    iOffsetX = 0; iOffsetY = 0;

   356 		    iBorderColor = TRgb(192,192,192);       // arbitrary border colour

   357 		    iBorderRight = 100;

   358 			break;

   359 		case 7:

   360 			// surface scaled to half the window size with border left and right

   361 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   362 		    iExtentWidth = 100; iExtentHeight = 200;

   363 		    iOffsetX = 50; iOffsetY = 0;

   364 		    iBorderColor = TRgb(0,0,0);				// arbitrary border colour

   365 		    iBorderLeft = 50; iBorderRight = 50;

   366 			break;

   367 		case 8:

   368 			// surface scaled in different proportions in width and height, with borders 

   369 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   370 		    iExtentWidth = 190; iExtentHeight = 10;

   371 		    iOffsetX = 5; iOffsetY = 95;

   372 		    iBorderColor = TRgb(240,240,240);       // arbitrary border colour

   373 		    iBorderTop = 95; iBorderBottom = 95; iBorderLeft = 5; iBorderRight = 5;

   374 			break;

   375 		case 9:

   376 			// surface scaled to double the window height size, surface cropped with no borders

   377 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   378 		    iExtentWidth = 400; iExtentHeight = 200;

   379 		    iOffsetX = 0; iOffsetY = 0;

   380 			break;

   381 		case 10:

   382 			// surface scaled to double the window width and height size, surface cropped with no borders

   383 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   384 		    iExtentWidth = 400; iExtentHeight = 400;

   385 		    iOffsetX = 0; iOffsetY = 0;

   386 			break;

   387 		case 11:

   388 			// surface scaled to double the window width and height size, surface cropped with borders top and left

   389 		    iSurfaceWidth = 100; iSurfaceHeight = 50;

   390 		    iExtentWidth = 400; iExtentHeight = 400;

   391 		    iOffsetX = 100; iOffsetY = 100;

   392 		    iBorderColor = TRgb(255,128,255);      // arbitrary border colour

   393 		    iBorderTop = 100; iBorderLeft = 100;

   394 			break;

   395 		case 12:

   396 			// QnHD to full screen size

   397 			iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight;

   398 		    iSurfaceWidth = 320; iSurfaceHeight = 180;

   399 		    iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight;

   400 		    iOffsetX = 0; iOffsetY = 0;

   401 			break;

   402 		case 13:

   403 			// QVGA to full screen size

   404 			iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight;

   405 		    iSurfaceWidth = 320; iSurfaceHeight = 240;

   406 		    iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight;

   407 		    iOffsetX = 0; iOffsetY = 0;

   408 			break;

   409 		case 14:

   410 			// HVGA to full screen size

   411 			iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight;

   412 		    iSurfaceWidth = 480; iSurfaceHeight = 320;

   413 		    iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight;

   414 		    iOffsetX = 0; iOffsetY = 0;

   415 			break;

   416 		case 15:

   417 			// 480x270 to full screen size

   418 			iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight;

   419 		    iSurfaceWidth = 480; iSurfaceHeight = 270;

   420 		    iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight;

   421 		    iOffsetX = 0; iOffsetY = 0;

   422 			break;

   423 		case 16:

   424 			// VGA to full screen size

   425 			iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight;

   426 		    iSurfaceWidth = 640; iSurfaceHeight = 480;

   427 		    iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight;

   428 		    iOffsetX = 0; iOffsetY = 0;

   429 			break;

   430 		case 17:

   431 			// WVGA to full screen size

   432 			iWindowWidth = iScreenSize.iWidth; iWindowHeight = iScreenSize.iHeight;

   433 		    iSurfaceWidth = 768; iSurfaceHeight = 480;

   434 		    iExtentWidth = iWindowWidth; iExtentHeight = iWindowHeight;

   435 		    iOffsetX = 0; iOffsetY = 0;

   436 			break;

   437 		default:

   438 		    ERR_PRINTF2(_L("Inconsistency in test code, case does not exist: %d."), index);

   439 		    User::Leave(KErrNotSupported);

   440 		    break;

   441         }

   442 

   443 		// perform the testing

   444 	    doTestPartialStepL();

   445     	}

   446 

   447     // clean-up

   448     CleanAll();

   449 

   450     INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_Positive::doTestStepL completed!"));

   451     RecordTestResultL();

   452     CloseTMSGraphicsStep();

   453     return TestStepResult();

   454     }

   455 

   456 TVerdict CEglTest_SurfaceScaling_Positive::doTestPartialStepL()

   457     {

   458     INFO_PRINTF5(_L("doTestPartialStepL started with (%d,%d) fixed surface scaled to (%d,%d) extent...."), iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight);

   459 

   460     // Establish the connection to the window server and create

   461     // a WindowGroup and a Window object

   462     CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight));

   463 

   464     // Choose EGL config

   465     EGLConfig matchingConfigs[1];

   466     EGLint numConfigs = 0;

   467 

   468     ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs));

   469     TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported

   470 

   471     EGLint attrib_list[] = {

   472               EGL_FIXED_WIDTH_NOK, iSurfaceWidth,

   473               EGL_FIXED_HEIGHT_NOK, iSurfaceHeight,

   474               EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX,

   475               EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY,

   476               EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth,

   477               EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight,

   478               EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(),

   479               EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(),

   480               EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(),

   481               EGL_NONE};

   482     

   483     // Create the window surface and the egl context and make them current

   484     iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list);    

   485 

   486     // Create the test bitmap that will be used in the scaled surface 

   487     //  NOTE: This bitmap generally does not have borders, 

   488     CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0));

   489     

   490     // Copy test bitmap to drawing surface

   491     WritePixelsToSurfaceL(*testBitmap);

   492 

   493     //call eglSwapBuffers

   494     ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface()));

   495     //Wait for the draw operation to complete

   496     eglWaitClient();

   497 

   498     // Create the reference bitmap that should be expected after the scaling 

   499     //  NOTE: This bitmap may have borders

   500     //        Size could exceed that of the window, so check both extent and window

   501     const TInt refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth;

   502     const TInt refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight;

   503     CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor);

   504 

   505     // compare window contents with expected bitmap

   506     TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *refBitmap, TestStepName());

   507     TEST(comparison==KErrNone);

   508     INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone);

   509 

   510     /// Cleanup

   511     CleanupStack::PopAndDestroy(2, testBitmap); // refBitmap, testBitmap

   512     iEglSess->CleanupSurfaceAndContextL();

   513     CloseWindow();

   514     

   515     INFO_PRINTF1(_L("....doTestPartialStepL completed!"));

   516     return TestStepResult();

   517     }

   518 

   519 /**

   520 @SYMTestCaseID GRAPHICS-EGL-0661

   521 

   522 @SYMTestPriority 1

   523 

   524 @SYMPREQ 2676

   525 

   526 @SYMREQ 417-56592

   527 

   528 @SYMTestCaseDesc

   529 Resize native window to verify target extent remains fixed.

   530 

   531 @SYMTestActions

   532 1. Create a window of known size

   533 2. Create a fixed size surface, filled in with a predefined bitmap

   534 3. Draw the surface onto the window for a set extent and border colour

   535 4. Repeat step 3 but increasing native window size by (1,1) pixels.

   536 5. Compare window content and border against a reference bitmap containing expected values. 

   537 

   538 @SYMTestExpectedResults

   539 The window content matches the independently created reference bitmap in each situation

   540 */

   541 TVerdict CEglTest_SurfaceScaling_WindowResize::doTestStepL()

   542     {

   543     SetTestStepID(_L("GRAPHICS-EGL-0661"));

   544     SetTestStepName(_L("GRAPHICS-EGL-0661"));

   545     INFO_PRINTF1(_L("CEglTest_SurfaceScaling_WindowResize::doTestStepL started...."));

   546 

   547     // set the initial value of a square window

   548     const TInt KWindowSize = 100;

   549     

   550     // surface with size and extent that matches the window size and no offset

   551     iWindowWidth = iWindowHeight = KWindowSize;

   552     iSurfaceWidth = iSurfaceHeight = KWindowSize;

   553     iExtentWidth = iExtentHeight = KWindowSize;

   554     iOffsetX = 0; iOffsetY = 0;

   555     iBorderColor = TRgb(0x99,0xcc,0xff);	// set some arbitrary colour

   556     iBorderTop = 0; iBorderBottom = 0; iBorderLeft = 0; iBorderRight = 0;

   557 

   558     // Establish the connection to the window server and create

   559     // a WindowGroup and a Window object

   560     CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight));

   561 

   562     // Create display object

   563     GetDisplayL();

   564     CreateEglSessionL();    // initialise EGL Session so we can make use of its helper objects

   565     iEglSess->InitializeL();

   566 

   567     // Choose EGL config

   568     EGLConfig matchingConfigs[1];

   569     EGLint numConfigs = 0;

   570 

   571     ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs));

   572     TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported

   573 

   574     EGLint attrib_list[] = {

   575               EGL_FIXED_WIDTH_NOK, iSurfaceWidth,

   576               EGL_FIXED_HEIGHT_NOK, iSurfaceHeight,

   577               EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX,

   578               EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY,

   579               EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth,

   580               EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight,

   581               EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(),

   582               EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(),

   583               EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(),

   584               EGL_NONE};

   585     

   586     // Create the window surface and the egl context and make them current

   587     iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list);    

   588     

   589     // Create the test bitmap that will be used in the scaled surface 

   590     //  NOTE: This bitmap generally does not have borders, 

   591     CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0));

   592     

   593     // Copy test bitmap to drawing surface

   594     WritePixelsToSurfaceL(*testBitmap);

   595 

   596     // Start doing iterations by increasing native window size.

   597     INFO_PRINTF1(_L("Start increasing native window size by (1,1)..."));

   598     iWindowWidth=1;

   599     iWindowHeight=1;

   600     while(iWindowWidth<=(KWindowSize*2) && iWindowHeight<=(KWindowSize*2))

   601     	{

   602 		// Note that borders will appear while window size is bigger than extent

   603 		//  - iSurfaceWidth/iSurfaceHeight - unmodified

   604 		//  - iExtentWidth/iExtentHeight - unmodified

   605 		//  - iOffsetX/iOffsetY - unmodified 

   606 		// Set up expected values for the border

   607 		iBorderTop = 0; iBorderLeft = 0; 

   608 		iBorderBottom = iExtentHeight<iWindowHeight ? iWindowHeight-iExtentHeight : 0; 

   609 		iBorderRight = iExtentWidth<iWindowWidth ? iWindowWidth-iExtentWidth : 0; 

   610 

   611 		// resize window to new given size

   612 	    iWindow.Invalidate();

   613 		iWindow.BeginRedraw();

   614 		iWindow.SetSize(TSize(iWindowWidth, iWindowHeight));

   615 		iWindow.EndRedraw();

   616 

   617 		// re-populate buffers with the unmodified fixed size surface content

   618 	    WritePixelsToSurfaceL(*testBitmap);

   619 		

   620 		// perform the testing

   621 		doTestPartialStepL();

   622 		++iWindowWidth;

   623 		++iWindowHeight;

   624     	}

   625 

   626     /// Cleanup

   627     CleanupStack::PopAndDestroy(testBitmap);

   628     iEglSess->CleanupSurfaceAndContextL();

   629     CleanAll();

   630     CloseWindow();

   631     

   632     INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_WindowResize::doTestStepL completed!"));

   633     RecordTestResultL();

   634     CloseTMSGraphicsStep();

   635     return TestStepResult();

   636     }

   637 

   638 TVerdict CEglTest_SurfaceScaling_WindowResize::doTestPartialStepL()

   639     {

   640     INFO_PRINTF3(_L("doTestPartialStepL started for native window size of (%d, %d)...."), iWindowWidth, iWindowHeight);

   641 

   642 	// resize may be effective only after swapbuffers 

   643 	ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface()));

   644 	ASSERT_EGL_TRUE(eglWaitClient());

   645 	

   646 	//check all expected values

   647     CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); 

   648     CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); 

   649 

   650     // Create the reference bitmap that should be expected after the window resize 

   651     //  NOTE: This bitmap may have borders

   652     //        Size could exceed that of the window, so check both extent and window

   653     const TInt refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth;

   654     const TInt refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight;

   655     CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor);

   656     

   657     // compare window contents with expected bitmap

   658     TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *refBitmap, TestStepName());

   659     TEST(comparison==KErrNone);

   660     INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone);

   661 

   662     /// Cleanup

   663     CleanupStack::PopAndDestroy(refBitmap);

   664 

   665     return TestStepResult();

   666     }

   667 

   668 /**

   669 @SYMTestCaseID GRAPHICS-EGL-0668

   670 

   671 @SYMTestPriority 1

   672 

   673 @SYMPREQ 2676

   674 

   675 @SYMREQ 417-56592

   676 

   677 @SYMTestCaseDesc

   678 Create a fixed size surface and vary the extent position for a range of values.

   679 

   680 @SYMTestActions

   681 1. Create a window of known size

   682 2. Create a fixed size surface, filled in with a predefined bitmap

   683 3. Draw the surface onto the window for a set extent and border colour

   684 4. Repeat step 3 but increasing target extent offset by (1,1) pixels.

   685 5. Compare window content and border against a reference bitmap containing expected values. 

   686 

   687 @SYMTestExpectedResults

   688 The window content matches the independently created reference bitmap in each situation

   689 */

   690 TVerdict CEglTest_SurfaceScaling_ExtentPositionChange::doTestStepL()

   691     {

   692     SetTestStepID(_L("GRAPHICS-EGL-0668"));

   693     SetTestStepName(_L("GRAPHICS-EGL-0668"));

   694     INFO_PRINTF1(_L("CEglTest_SurfaceScaling_ExtentPositionChange::doTestStepL started...."));

   695 

   696     // surface with size and extent that matches the window size and no offset

   697     iWindowWidth = iWindowHeight = 100;

   698     iSurfaceWidth = iExtentWidth = iWindowWidth;

   699     iSurfaceHeight = iExtentHeight = iWindowHeight;

   700     iOffsetX = 0; iOffsetY = 0;

   701     iBorderColor = TRgb(0x11,0x22,0x33);	// set some arbitrary colour

   702     iBorderTop = 0; iBorderBottom = 0; iBorderLeft = 0; iBorderRight = 0;

   703 

   704     // Establish the connection to the window server and create

   705     // a WindowGroup and a Window object

   706     CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight));

   707 

   708     // Create display object

   709     GetDisplayL();

   710     CreateEglSessionL();    // initialise EGL Session so we can make use of its helper objects

   711     iEglSess->InitializeL();

   712 

   713     // Choose EGL config

   714     EGLConfig matchingConfigs[1];

   715     EGLint numConfigs = 0;

   716 

   717     ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs));

   718     TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported

   719 

   720     EGLint attrib_list[] = {

   721               EGL_FIXED_WIDTH_NOK, iSurfaceWidth,

   722               EGL_FIXED_HEIGHT_NOK, iSurfaceHeight,

   723               EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX,

   724               EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY,

   725               EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth,

   726               EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight,

   727               EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(),

   728               EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(),

   729               EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(),

   730               EGL_NONE};

   731     

   732     // Create the window surface and the egl context and make them current

   733     iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list);    

   734     

   735     // Create the test bitmap that will be used in the scaled surface 

   736     //  NOTE: This bitmap generally does not have borders, 

   737     CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0));

   738     

   739     // Copy test bitmap to drawing surface

   740     WritePixelsToSurfaceL(*testBitmap);

   741 

   742 	// This test is a bit different. Since the extent remains the same, and we only change

   743     //  the offset, we create an oversized reference bitmap and compare the screen with a

   744     //  region contained within the reference bitmap 

   745     // Size is three times the extent so that it has extent size borders all around

   746     const TInt refWidth = 3*iExtentWidth;

   747     const TInt refHeight = 3*iExtentHeight;

   748     iBorderTop=iBorderBottom=iBorderLeft=iBorderRight=iExtentWidth;	

   749     CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor);

   750 

   751     // Start doing iterations by increasing target extent offset

   752     INFO_PRINTF1(_L("Start increasing target extent offset size by (1,1)..."));

   753     for (iOffsetX=-iExtentWidth,iOffsetY=-iExtentHeight; iOffsetX<=iExtentWidth&&iOffsetY<=iExtentHeight; ++iOffsetX,++iOffsetY)

   754     	{

   755 		// Note that borders will appear other than when offset is (0,0)

   756 		//  - iSurfaceWidth/iSurfaceHeight - unmodified

   757 		//  - iExtentWidth/iExtentHeight - unmodified

   758 	

   759 	    // set new offset values

   760 	    ASSERT_EGL_TRUE(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), iOffsetX, iOffsetY, iExtentWidth, iExtentHeight));

   761 

   762 		// re-populate buffers with the unmodified fixed size surface content

   763 	    WritePixelsToSurfaceL(*testBitmap);

   764 

   765 		// perform the testing

   766 		doTestPartialStepL(*refBitmap);

   767     	}

   768     

   769     /// Cleanup

   770     CleanupStack::PopAndDestroy(2, testBitmap); //testBitmap, refBitmap

   771     iEglSess->CleanupSurfaceAndContextL();

   772     CleanAll();

   773     CloseWindow();

   774     

   775     INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_ExtentPositionChange::doTestStepL completed!"));

   776     RecordTestResultL();

   777     CloseTMSGraphicsStep();

   778     return TestStepResult();

   779     }

   780 

   781 TVerdict CEglTest_SurfaceScaling_ExtentPositionChange::doTestPartialStepL(const CFbsBitmap& aRefBitmap)

   782     {

   783     INFO_PRINTF3(_L("doTestPartialStepL started for offset of (%d, %d)...."), iOffsetX, iOffsetY);

   784 

   785     // offset change may be effective only after swapbuffers 

   786 	ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface()));

   787 	ASSERT_EGL_TRUE(eglWaitClient());

   788 	// Finish() to ensure all native window operations related to the surface complete before image comparision.

   789 	iWsSession.Finish();

   790 	

   791 	//check all expected values

   792     CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); 

   793     CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); 

   794 

   795     // Prepare the offset of the reference bitmap to know what sub-region should be compared

   796     const TInt refWidth = 3*iExtentWidth;

   797     const TInt refHeight = 3*iExtentHeight;

   798     TPoint bitmapOffset(refWidth-iExtentWidth-iRefBitmapOffset, refHeight-iExtentHeight-iRefBitmapOffset);

   799     iRefBitmapOffset++;		// increase offset for next iteration

   800     

   801     // Comparision takes into account specific region within the reference bitmap

   802     TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), bitmapOffset, aRefBitmap, TestStepName());

   803     TEST(comparison==KErrNone);

   804     INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone);

   805 

   806     return TestStepResult();

   807     }

   808 

   809 /**

   810 @SYMTestCaseID GRAPHICS-EGL-0669

   811 

   812 @SYMTestPriority 1

   813 

   814 @SYMPREQ 2676

   815 

   816 @SYMREQ 417-56592

   817 

   818 @SYMTestCaseDesc

   819 Create a fixed size surface and vary the extent size for a range of values

   820 

   821 @SYMTestActions

   822 1. Create a window of known size

   823 2. Create a fixed size surface, filled in with a predefined bitmap

   824 3. Draw the surface onto the window for a set extent and border colour

   825 4. Repeat step 3 but increasing target extent size by (2,2) pixels.

   826 5. Compare window content and border against a reference bitmap containing expected values. 

   827 

   828 @SYMTestExpectedResults

   829 The window content matches the independently created reference bitmap in each situation

   830 */

   831 TVerdict CEglTest_SurfaceScaling_ExtentSizeChange::doTestStepL()

   832     {

   833     SetTestStepID(_L("GRAPHICS-EGL-0669"));

   834     SetTestStepName(_L("GRAPHICS-EGL-0669"));

   835     INFO_PRINTF1(_L("CEglTest_SurfaceScaling_ExtentSizeChange::doTestStepL started...."));

   836 

   837     // set the initial value of a square window

   838     const TInt KWindowSize = 100;

   839     

   840     // surface with size and extent that matches the window size and no offset

   841     iWindowWidth = iWindowHeight = KWindowSize;

   842     iSurfaceWidth = iSurfaceHeight = KWindowSize;

   843     iExtentWidth = iExtentHeight = KWindowSize; 	

   844     iOffsetX = 0; iOffsetY = 0;

   845     iBorderColor = TRgb(0x80,0x40,0xF0);	// set some arbitrary colour

   846     iBorderTop = 0; iBorderBottom = 0; iBorderLeft = 0; iBorderRight = 0;

   847 

   848     // Establish the connection to the window server and create

   849     // a WindowGroup and a Window object

   850     CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight));

   851 

   852     // Create display object

   853     GetDisplayL();

   854     CreateEglSessionL();    // initialise EGL Session so we can make use of its helper objects

   855     iEglSess->InitializeL();

   856 

   857     // Choose EGL config

   858     EGLConfig matchingConfigs[1];

   859     EGLint numConfigs = 0;

   860 

   861     ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs));

   862     TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported

   863 

   864     EGLint attrib_list[] = {

   865               EGL_FIXED_WIDTH_NOK, iSurfaceWidth,

   866               EGL_FIXED_HEIGHT_NOK, iSurfaceHeight,

   867               EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX,

   868               EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY,

   869               EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth,

   870               EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight,

   871               EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(),

   872               EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(),

   873               EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(),

   874               EGL_NONE};

   875     

   876     // Create the window surface and the egl context and make them current

   877     iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list);    

   878     

   879     // Create the test bitmap that will be used in the scaled surface 

   880     //  NOTE: This bitmap generally does not have borders, 

   881     CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0));

   882     

   883     // Copy test bitmap to drawing surface

   884     WritePixelsToSurfaceL(*testBitmap);

   885 

   886     // Start doing iterations by increasing target extent size 

   887     //  We do increments of (2,2) because the reference bitmap is simetrically split into 4 areas, so size

   888     //  of this reference bitmap should be an even number of pixels

   889     INFO_PRINTF1(_L("Start increasing target extent size by (2,2)..."));

   890     iExtentWidth=2;

   891     iExtentHeight=2;

   892 	while(iExtentWidth <= (KWindowSize*2) && iExtentHeight <= (KWindowSize*2))

   893     	{

   894 		// Note that borders will appear while extent is smaller than window

   895 		//  - iSurfaceWidth/iSurfaceHeight - unmodified

   896 		//  - iOffsetX/iOffsetY - unmodified 

   897 		// Set up expected values for the border

   898 		iBorderTop = 0; iBorderLeft = 0; 

   899 		iBorderBottom = iExtentHeight<iWindowHeight ? iWindowHeight-iExtentHeight : 0; 

   900 		iBorderRight = iExtentWidth<iWindowWidth ? iWindowWidth-iExtentWidth : 0; 

   901 

   902 	    // set new target extent values

   903 	    ASSERT_EGL_TRUE(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), iOffsetX, iOffsetY, iExtentWidth, iExtentHeight));

   904 

   905 		// re-populate buffers with the unmodified fixed size surface content

   906 	    WritePixelsToSurfaceL(*testBitmap);

   907 		

   908 		// perform the testing

   909 		doTestPartialStepL();

   910 		iExtentWidth+=2;

   911 		iExtentHeight+=2;

   912 		}

   913 

   914     /// Cleanup

   915     CleanupStack::PopAndDestroy(testBitmap);

   916     iEglSess->CleanupSurfaceAndContextL();

   917     CleanAll();

   918     CloseWindow();

   919     

   920     INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_ExtentSizeChange::doTestStepL completed!"));

   921     RecordTestResultL();

   922     CloseTMSGraphicsStep();

   923     return TestStepResult();

   924     }

   925 

   926 TVerdict CEglTest_SurfaceScaling_ExtentSizeChange::doTestPartialStepL()

   927     {

   928     INFO_PRINTF3(_L("doTestPartialStepL started for extent size of (%d, %d)...."), iExtentWidth, iExtentHeight);

   929 

   930     // extent change may be effective only after swapbuffers 

   931 	ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface()));

   932 	ASSERT_EGL_TRUE(eglWaitClient());

   933 	// Finish() to ensure all native window operations related to the surface complete before image comparision.

   934 	iWsSession.Finish();

   935 	

   936 	//check all expected values

   937     CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); 

   938     CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); 

   939 

   940     // Create the reference bitmap that should be expected after the window resize 

   941     //  NOTE: This bitmap may have borders

   942     //        Size could exceed that of the window, so check both extent and window

   943     const TInt refWidth = iExtentWidth>iWindowWidth ? iExtentWidth : iWindowWidth;

   944     const TInt refHeight = iExtentHeight>iWindowHeight ? iExtentHeight : iWindowHeight;

   945     CFbsBitmap* refBitmap = CreateBitmapLC(TSize(refWidth, refHeight), iBorderTop, iBorderBottom, iBorderLeft, iBorderRight, iBorderColor);

   946     

   947     // compare window contents with expected bitmap

   948     TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *refBitmap, TestStepName());

   949     TEST(comparison==KErrNone);

   950     INFO_PRINTF3(_L("CompareScreenImageL returns %d (expected is %d)"), comparison, KErrNone);

   951 

   952     /// Cleanup

   953     CleanupStack::PopAndDestroy(refBitmap);

   954 

   955     return TestStepResult();

   956     }

   957 

   958 /**

   959 @SYMTestCaseID GRAPHICS-EGL-0670

   960 

   961 @SYMTestPriority 1

   962 

   963 @SYMPREQ 2676

   964 

   965 @SYMREQ 417-56592

   966 

   967 @SYMTestCaseDesc

   968 Check that updating surface scaling attributes is visible only after calling eglSwapBuffers

   969 

   970 @SYMTestActions

   971 1. Create a window of known size

   972 2. Create a fixed size surface, filled in with a predefined bitmap

   973 3. Draw the surface onto the window for a set extent and border colour

   974 4. Repeat step 3 but increasing target extent size and changing border colours

   975 5. Compare window content and border against a reference bitmap containing expected values

   976   5a. Before calling eglSwapBuffers

   977   5b. After callnig eglSwapBuffers  

   978 

   979 @SYMTestExpectedResults

   980 5a. The window content matches the independently created reference with old values

   981 5b. The window content matches the independently created reference with new values

   982 */

   983 TVerdict CEglTest_SurfaceScaling_SwapBuffers::doTestStepL()

   984     {

   985     SetTestStepID(_L("GRAPHICS-EGL-0670"));

   986     SetTestStepName(_L("GRAPHICS-EGL-0670"));

   987     INFO_PRINTF1(_L("CEglTest_SurfaceScaling_SwapBuffers::doTestStepL started...."));

   988 

   989     // set the initial value of a square window

   990     const TInt KWindowSize = 200;

   991     

   992     // surface with size that matches the window size and no offset and extent a quarter 

   993     // of that originally positioned in the middle (so borders should be seen)

   994     iWindowWidth = iWindowHeight = KWindowSize;

   995     iSurfaceWidth = iSurfaceHeight = KWindowSize;

   996     iExtentWidth = iExtentHeight = KWindowSize/4; 	

   997     iOffsetX = (iWindowWidth-iExtentWidth)/2; iOffsetY = (iWindowHeight-iExtentHeight)/2;	// to center the surface at the middle of the window

   998     iBorderColor = TRgb(0xFF,0xFF,0x00);	// set some arbitrary colour with blue channel to 0x00

   999 	iBorderTop = iBorderBottom = iExtentHeight<iWindowHeight ? (iWindowHeight-iExtentHeight)/2 : 0; 

  1000 	iBorderLeft = iBorderRight = iExtentWidth<iWindowWidth ? (iWindowWidth-iExtentWidth)/2 : 0; 

  1001 

  1002     // Establish the connection to the window server and create

  1003     // a WindowGroup and a Window object

  1004     CreateAndActivateWindowL(TSize(iWindowWidth, iWindowHeight));

  1005 

  1006     // Create display object

  1007     GetDisplayL();

  1008     CreateEglSessionL();    // initialise EGL Session so we can make use of its helper objects

  1009     iEglSess->InitializeL();

  1010 

  1011     // Choose EGL config

  1012     EGLConfig matchingConfigs[1];

  1013     EGLint numConfigs = 0;

  1014 

  1015     ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KScalingConfigAttribs[EWindowAttribsColor16MU_Scaling], matchingConfigs, 1, &numConfigs));

  1016     TESTL(numConfigs == 1); // Abort the test if the EGL config is not supported

  1017 

  1018     EGLint attrib_list[] = {

  1019               EGL_FIXED_WIDTH_NOK, iSurfaceWidth,

  1020               EGL_FIXED_HEIGHT_NOK, iSurfaceHeight,

  1021               EGL_TARGET_EXTENT_OFFSET_X_NOK, iOffsetX,

  1022               EGL_TARGET_EXTENT_OFFSET_Y_NOK, iOffsetY,

  1023               EGL_TARGET_EXTENT_WIDTH_NOK, iExtentWidth,

  1024               EGL_TARGET_EXTENT_HEIGHT_NOK, iExtentHeight,

  1025               EGL_BORDER_COLOR_RED_NOK, iBorderColor.Red(),

  1026               EGL_BORDER_COLOR_GREEN_NOK, iBorderColor.Green(),

  1027               EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue(),

  1028               EGL_NONE};

  1029     

  1030     // Create the window surface and the egl context and make them current

  1031     iEglSess->CreateWindowSurfaceAndMakeCurrentL(matchingConfigs[0], iWindow, EFalse, EGL_OPENVG_API, 1, attrib_list);    

  1032     

  1033     // Create the test bitmap that will be used in the scaled surface 

  1034     //  NOTE: This bitmap generally does not have borders, 

  1035     CFbsBitmap* testBitmap = CreateBitmapLC(TSize(iSurfaceWidth, iSurfaceHeight),0,0,0,0,TRgb(0,0,0));

  1036     

  1037     // Copy test bitmap to drawing surface

  1038     WritePixelsToSurfaceL(*testBitmap);

  1039 

  1040     // we need to update the window content for the first frame comparison inside the loop further down 

  1041 	ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface()));

  1042 	ASSERT_EGL_TRUE(eglWaitClient());

  1043 

  1044 	// Start doing iterations changing border colours and increasing target extent size 

  1045     //  We do increments of (2,2) because the reference bitmap is simetrically split into 4 areas, so size

  1046     //  of this reference bitmap should be an even number of pixels

  1047     INFO_PRINTF1(_L("Start changing border colours and increasing target extent size by (2,2)..."));

  1048     for (;;)

  1049     	{

  1050 		// re-populate buffers with the unmodified fixed size surface content

  1051 		WritePixelsToSurfaceL(*testBitmap);

  1052 

  1053 		// perform the testing

  1054 		doTestPartialStepL();

  1055 		

  1056 		// break the loop when necessary

  1057 		if (iBorderColor.Blue()>=255)

  1058 			break;

  1059 		}

  1060 

  1061     /// Cleanup

  1062     CleanupStack::PopAndDestroy(testBitmap);

  1063     iEglSess->CleanupSurfaceAndContextL();

  1064     CleanAll();

  1065     CloseWindow();

  1066     

  1067     INFO_PRINTF1(_L("....CEglTest_SurfaceScaling_SwapBuffers::doTestStepL completed!"));

  1068     RecordTestResultL();

  1069     CloseTMSGraphicsStep();

  1070     return TestStepResult();

  1071     }

  1072 

  1073 TVerdict CEglTest_SurfaceScaling_SwapBuffers::doTestPartialStepL()

  1074     {

  1075     INFO_PRINTF4(_L("doTestPartialStepL started for border colour (%d,%d,%d)...."), iBorderColor.Red(), iBorderColor.Green(), iBorderColor.Blue());

  1076 

  1077 	// Note that borders will appear while extent is smaller than window

  1078 	//  - iSurfaceWidth/iSurfaceHeight - unmodified

  1079 	//  - iExtentWidth/iExtentHeight - modified 

  1080 	//  - iOffsetX/iOffsetY - modified

  1081 	

  1082     // Set up new value for border blue channel, storing old ones

  1083 	TRgb oldBorderColor(iBorderColor);

  1084 	TInt newColorBlue = oldBorderColor.Blue() + 5;

  1085 	TESTL(newColorBlue>=0 && newColorBlue<=255);

  1086 	iBorderColor.SetBlue(newColorBlue);

  1087 	

  1088     // Set up new values for extent/offset, storing old ones

  1089 	TInt oldExtentWidth = iExtentWidth;

  1090 	TInt oldExtentHeight = iExtentHeight;

  1091 	iExtentWidth+=2;

  1092 	iExtentHeight+=2;

  1093 	iOffsetX = (iWindowWidth-iExtentWidth)/2; 

  1094 	iOffsetY = (iWindowHeight-iExtentHeight)/2;

  1095 	

  1096 	// Set up expected values for the border, storing old ones

  1097 	TInt oldBorderTop = iBorderTop;

  1098 	TInt oldBorderBottom = iBorderBottom;

  1099 	TInt oldBorderLeft = iBorderLeft;

  1100 	TInt oldBorderRight = iBorderRight;

  1101 	iBorderTop = iBorderBottom = iExtentHeight<iWindowHeight ? (iWindowHeight-iExtentHeight)/2 : 0; 

  1102 	iBorderLeft = iBorderRight = iExtentWidth<iWindowWidth ? (iWindowWidth-iExtentWidth)/2 : 0; 

  1103 

  1104     // set new extent/offset values

  1105     ASSERT_EGL_TRUE(iPfnEglSetSurfaceScalingNOK(iDisplay, iEglSess->Surface(), iOffsetX, iOffsetY, iExtentWidth, iExtentHeight));

  1106     // set new border colour values

  1107     ASSERT_EGL_TRUE(eglSurfaceAttrib(iDisplay, iEglSess->Surface(), EGL_BORDER_COLOR_BLUE_NOK, iBorderColor.Blue()));

  1108     

  1109     // Check that values have been updated as expected

  1110     CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); 

  1111     CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); 

  1112 

  1113     // Check that the screen has NOT BEEN UPDATED just yet

  1114 

  1115     // Create the reference bitmap that should be expected before the extent/border changes 

  1116     TInt refWidth = oldExtentWidth>iWindowWidth ? oldExtentWidth : iWindowWidth;

  1117     TInt refHeight = oldExtentHeight>iWindowHeight ? oldExtentHeight : iWindowHeight;

  1118     CFbsBitmap* oldRefBitmap = CreateBitmapLC(TSize(refWidth, refHeight), oldBorderTop, oldBorderBottom, oldBorderLeft, oldBorderRight, oldBorderColor);

  1119 

  1120     // compare screen with old reference bitmap

  1121     TInt comparison = iImageComparison->CompareScreenImageL(TSize(iWindowWidth, iWindowHeight), TPoint(0,0), TPoint(0,0), *oldRefBitmap, TestStepName());

  1122     TEST(comparison==KErrNone);

  1123     INFO_PRINTF3(_L("CompareScreenImageL before eglSwapBuffers returns %d (expected is %d)"), comparison, KErrNone);

  1124 

  1125     // extent/offset changes MUST be effective only after swapbuffers 

  1126 	ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSess->Surface()));

  1127 	ASSERT_EGL_TRUE(eglWaitClient());

  1128 	// Finish() to ensure all native window operations related to the surface complete before image comparision.

  1129 	iWsSession.Finish();

  1130 	

  1131 	//check values still are as expected

  1132     CheckScalingAttributesL(iSurfaceWidth, iSurfaceHeight, iExtentWidth, iExtentHeight, iOffsetX, iOffsetY); 

  1133     CheckBorderColorL(iBorderColor.Red(), iBorderColor.Blue(), iBorderColor.Green()); 

  1134 

  1135     // Create the reference bitmap that should be expected after the extent/border changes