// 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 <test/tefunit.h> // for ASSERT macros

#include <test/egltestcommonutils.h>

#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 <TFPtrEglQuerySurfaceScalingCapabilityNok> (eglGetProcAddress("eglQuerySurfaceScalingCapabilityNOK"));

    iPfnEglSetSurfaceScalingNOK = reinterpret_cast <TFPtrEglSetSurfaceScalingNok> (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<TUint8*>(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.