// 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:

// OpenWF tests

//

#include <test/extendtef.h>

#include <hal.h>

#include "openwftest.h"

#define KCompositorVersion	0x01023456

#define KGrowCleanupStack	12

#define KMaxNotificationDelay   5000000 //5 seconds

#define KNotificationWarning    100000  //100 ms

_LIT(KTestSectionName, "TestInfo");

_LIT(KImageSectionName, "ImageInfo");

_LIT(KContiguousFlag, "ContiguousFlag");

_LIT(KTolerance, "Tolerance");

_LIT(KTestMode, "TestMode");

_LIT(KSaveImage, "SaveImage");

_LIT(KDir, "Dir");

_LIT(KDefaultDir, "c:\\openwftest\\img\\");

_LIT(KCompositionPause, "CompositionPause");

_LIT(KManualPause, "ManualPause");

//Uncomment this and rebuild if you wish to test if fastpath is enabled using breakpoints

//#define BREAKPOINT_FASTPATH

/*

 * COpenwfTest implementation

 */

COpenwfTest::COpenwfTest()

:iFastpathablePixelFormat(EUidPixelFormatXRGB_8888),

 iNonFastpathablePixelFormat(EUidPixelFormatRGB_565),

 iMappable(ETrue),

 iMaxBuffers(2),

 iMinBuffers(1),

 iCacheAttrib(ECacheNotlisted),

 iDeviceId(WFC_INVALID_HANDLE),

 iSync(EGL_NO_SYNC_KHR),

 iDevice(WFC_INVALID_HANDLE),

 iContext(WFC_INVALID_HANDLE)

	{

	}

COpenwfTest::~COpenwfTest()

	{

    TearDown();

	}

void COpenwfTest::SetupL()

    {    

    iScheduler = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(iScheduler);

    ReadIniData();

    iEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    ASSERT_FALSE(iEGLDisplay == EGL_NO_DISPLAY);

    ASSERT_FALSE(iEGLDisplay == EGL_BAD_ALLOC);

    ASSERT_EQUALS(eglGetError(),EGL_SUCCESS);

    eglInitialize(iEGLDisplay, NULL, NULL);

    ASSERT_EQUALS(eglGetError(),EGL_SUCCESS);

    WFCint filterList[] = { WFC_DEVICE_FILTER_SCREEN_NUMBER, WFC_DEFAULT_SCREEN_NUMBER, WFC_NONE};

    ASSERT_TRUE(wfcEnumerateDevices(&iDeviceId, 1, filterList) == 1);

    ASSERT_TRUE(iDeviceId != WFC_INVALID_HANDLE);    

    iDevice = wfcCreateDevice(iDeviceId, NULL);

    ASSERT_TRUE(iDevice != WFC_INVALID_HANDLE);  

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    iContext = wfcCreateOnScreenContext(iDevice, WFC_DEFAULT_SCREEN_NUMBER, NULL);

    ASSERT_TRUE(iContext != WFC_INVALID_HANDLE);  

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    iFastpathableHeight = wfcGetContextAttribi(iDevice, iContext, WFC_CONTEXT_TARGET_HEIGHT);

    iFastpathableWidth = wfcGetContextAttribi(iDevice, iContext, WFC_CONTEXT_TARGET_WIDTH);

    iStride = iFastpathableWidth * 4;

    iFullScreenTRect = TRect(0,0,iFastpathableWidth,iFastpathableHeight);

    iFullScreenRect[0] = 0;

    iFullScreenRect[1] = 0;

    iFullScreenRect[2] = iFullScreenTRect.Width();

    iFullScreenRect[3] = iFullScreenTRect.Height();

    iCenterTRect = TRect(iFastpathableWidth/4,iFastpathableHeight/4,

            3*iFastpathableWidth/4,3*iFastpathableHeight/4);

    iCenterRect[0] = iCenterTRect.iTl.iX;

    iCenterRect[1] = iCenterTRect.iTl.iY;

    iCenterRect[2] = iCenterTRect.Width();

    iCenterRect[3] = iCenterTRect.Height();

    iHalfSizeRect[0] = 0;

    iHalfSizeRect[1] = 0;

    iHalfSizeRect[2] = iFastpathableWidth/2;

    iHalfSizeRect[3] = iFastpathableHeight/2;

    iUtility = CSurfaceUtility::NewL();

    if((iTestMode == EAutomatic) || iSaveImage)

        {

        // Need to initialise the on screen stream before composition

        // to ensure the content is available later 

        iUtility->GetOnScreenStream(iDevice, iContext);

        }

    if (iSaveImage)

        {   // Create a directory to save images

        iUtility->CreateImagePath(iImageDirectory);                

        }

    iAllowManualPause = ETrue; //tests can stop it (eg dispXtimes tests) 

    EGLint attrib_list[1] = {EGL_NONE};

    iSync = eglCreateSyncKHR(iEGLDisplay,EGL_SYNC_REUSABLE_KHR, attrib_list);

    ASSERT_NOT_EQUALS(iSync,EGL_NO_SYNC_KHR);

    ASSERT_EQUALS(eglGetError(),EGL_SUCCESS);

    }

/**

 * test Suite furniture 

 **/

void COpenwfTest::TearDownL()

    {

    // Nothing leaves in this function, 

    // but TearDownL() is needed for the CTestFixture (TEF) interface

    TearDown();

    }

void COpenwfTest::TearDown()

    {

    WFCErrorCode wfcError;

    if (iDevice != WFC_INVALID_HANDLE)

        {

        wfcError = wfcGetError(iDevice);

        if (wfcError != WFC_ERROR_NONE)

            {

            INFO_PRINTF2(_L("TearDown: There was a failure in the test. error=%d"),wfcError);

            }

        }

    if (iOnScreenStream != WFC_INVALID_HANDLE)

        {

        (void)SymbianStreamReleaseReadBuffer(iOnScreenStream, iOnScreenBuffer); //ignore the error

        iOnScreenStream = WFC_INVALID_HANDLE;

        }

    delete iUtility;

    iUtility = NULL;

    if (iContext != WFC_INVALID_HANDLE)

        {

        wfcDestroyContext(iDevice, iContext);

        iContext = WFC_INVALID_HANDLE;

        WFCErrorCode wfcError = wfcGetError(iDevice);

        if (wfcError != WFC_ERROR_NONE)

            {

            INFO_PRINTF2(_L("TearDown: wfcDestroyContext error=%d"),wfcError);

            }

        }

    if (iDevice != WFC_INVALID_HANDLE)

        {

        WFCErrorCode deviceError = wfcDestroyDevice(iDevice);

        iDevice = WFC_INVALID_HANDLE;

        if (deviceError != WFC_ERROR_NONE)

            {

            INFO_PRINTF2(_L("TearDown: wfcDestroyDevice error=%d"),deviceError);

            }

        }

    if (iSync != EGL_NO_SYNC_KHR)

        {

        EGLBoolean eglSyncError = eglDestroySyncKHR(iEGLDisplay, iSync);

        iSync = EGL_NO_SYNC_KHR;

        if (eglSyncError != EGL_TRUE)

            {

            INFO_PRINTF2(_L("TearDown: eglSyncError line %d"),__LINE__);

            }

        }

    if (iEGLDisplay != EGL_NO_DISPLAY)

        {

        EGLBoolean eglTerminateError = eglTerminate(iEGLDisplay);

        iEGLDisplay = EGL_NO_DISPLAY;

        if (eglTerminateError != EGL_TRUE)

            {

            INFO_PRINTF2(_L("TearDown: eglTerminateError line %d"),__LINE__);

            }

        }

    delete iScheduler;

    iScheduler = NULL;

    }

/**

 * To be called at the beginning of tests

 * aActivate default is ON

 */

void COpenwfTest::SetupEmptySceneL(TBool aActivate)

    {

#ifdef BREAKPOINT_FASTPATH

    __BREAKPOINT();

#endif

    wfcSetContextAttribi(iDevice, iContext, WFC_CONTEXT_ROTATION, WFC_ROTATION_0);

    wfcSetContextAttribi(iDevice, iContext, WFC_CONTEXT_BG_COLOR, 0xFFFFFFFF);

    if (aActivate)

        {

        LOG(("OpenWFTest: Running in autonomous composition mode"));

        wfcActivate(iDevice,iContext);

        }

    else

        {

        LOG(("OpenWFTest: Running in non autonomous composition mode"));

        wfcDeactivate(iDevice,iContext);

        }

    LOG(("OpenWFTest: Expecting COMPOSITION after next commit"));

    wfcCommit(iDevice, iContext, WFC_TRUE);   // Compose the scene

    wfcFence(iDevice, iContext, iEGLDisplay, iSync);

    ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    LOG(("OpenWFTest: Fastpath - setting up scene - fastpath now off"));

    }

void COpenwfTest::ReadIniData()

    {

	//test mode

    TBool returnValue = iConfig.GetInt(KTestSectionName, KTestMode, iTestMode);

    ASSERT_TRUE(returnValue);

    //save images

	iSaveImage=EFalse;

    if (iTestMode == EAutomatic)

        {

        returnValue = iConfig.GetBool(KTestSectionName, KSaveImage, iSaveImage);

        }

    // Get path for the images to be saved to

    TPtrC dir;

    returnValue = iConfig.GetString(KTestSectionName, KDir, dir);

    if (returnValue)

        {

		iImageDirectory.Set(dir);

        }

    else

        {

		iImageDirectory.Set(KDefaultDir);

        }

    // Composition pause in microseconds

    TInt compositionPause;

    returnValue = iConfig.GetInt(KTestSectionName, KCompositionPause, compositionPause);

    ASSERT_TRUE(returnValue);

    iCompositionPause = compositionPause;

    // Manual pause in microseconds

    iManualPause = 0;

    if (iTestMode != EAutomatic)

        {

		TInt manualPause;

		returnValue = iConfig.GetInt(KTestSectionName, KManualPause, manualPause);

		ASSERT_TRUE(returnValue);

		iManualPause = manualPause;

        }

    // Force contiguous

    TBool contiguousFlag;

    returnValue = iConfig.GetBool(KImageSectionName, KContiguousFlag, contiguousFlag);

    if (returnValue && contiguousFlag)

        {

        iContiguous = EContiguous;

        }

    // Test tolerance

    TInt tolerance;

    returnValue = iConfig.GetInt(KImageSectionName, KTolerance, tolerance);

    if (returnValue)

        {

        iTolerance = tolerance;

        }

    }

/**

 * Acquires the on screen stream and buffer number

 * NOTE: this function should be paired with a ReleaseOnScreenStream call

 * Returns ETrue on success

 */

TBool COpenwfTest::AcquireOnScreenStream()

	{

	TInt error = KErrNone;

	ASSERT_TRUE(iOnScreenStream == WFC_INVALID_HANDLE);

    if(iTestMode == EAutomatic)

    	{	//need to get the on screen stream

		iOnScreenStream = iUtility->GetOnScreenStream(iDevice, iContext);

		if(iOnScreenStream == WFC_INVALID_HANDLE)

			{

			INFO_PRINTF1(_L("Failed getting on screen stream"));

			LOG(("OpenWFTest: *** Failed getting on screen stream"));

			return EFalse;

			}

		error = SymbianStreamAcquireReadBuffer(iOnScreenStream, &iOnScreenBuffer);

		if (error != KErrNone)

			{

			LOG(("OpenWFTest: *** Unable to acquire read buffer. error = %d",error));

			INFO_PRINTF2(_L("Unable to acquire read buffer. error = %d"),error);

			}

		return (error == KErrNone);

    	}

	else

		{

		INFO_PRINTF1(_L("No need to get the on screen stream, probably manual checking mode"));

		LOG(("OpenWFTest: *** No need to get the on screen stream, probably manual checking mode"));

		return ETrue;

		}

	}

/**

 * Releases the on screen stream

 */

void COpenwfTest::ReleaseOnScreenStream()

	{

	if (iOnScreenStream != WFC_INVALID_HANDLE)

		{

		(void)SymbianStreamReleaseReadBuffer(iOnScreenStream, iOnScreenBuffer);	//ignore the error

		iOnScreenStream = WFC_INVALID_HANDLE;

		}

	if(iTestMode != EAutomatic && iAllowManualPause)

		{

		INFO_PRINTF1(_L("Performing manual wait"));

		LOG(("OpenWFTest: *** Performing manual wait"));

		TRAP_IGNORE(WaitL(iManualPause));

		}

	if(iTestMode != EAutomatic && !iAllowManualPause)

	    {

        INFO_PRINTF1(_L("Test not allowing a manual wait"));

        LOG(("OpenWFTest: *** Test not allowing a manual wait"));

	    }

	}

/**

 * Checks the rect of the on screen stream

 * Returns ETrue on success

 */

TBool COpenwfTest::CheckOnScreenStreamRect(TRect aRect, const TRgb& aExpectedColor, TInt aTolerance)

	{

    if(iTestMode == EAutomatic)

    	{

		if (iOnScreenStream == WFC_INVALID_HANDLE)

			{

			LOG(("OpenWFTest: *** We don't have access to the on screen stream"));

			INFO_PRINTF1(_L("We don't have access to the on screen stream"));

			return EFalse;

			}

		const TSurfaceId* surfaceId = NULL;

		long bufferIndex;

		TInt error = SymbianStreamGetBufferId(iOnScreenStream,iOnScreenBuffer,&bufferIndex,&surfaceId);

		if (error == KErrNone)

			{

			return CheckRect(*surfaceId,bufferIndex,aRect,aExpectedColor,aTolerance);

			}

		else

			{

			LOG(("OpenWFTest: *** Unable to get stream buffer id. error = %d",error));

			INFO_PRINTF2(_L("Unable to get stream buffer id. error = %d"),error);

			return EFalse;

			}

    	}

    else

    	{	//print out what we're hoping to see for manual testing

		LOG(("OpenWFTest: For rect %d %d %d %d",aRect.iTl.iX,aRect.iTl.iY,aRect.iBr.iX,aRect.iBr.iY));

		LOG(("OpenWFTest: The expected color is r=%d g=%d b=%d",aExpectedColor.Red(),aExpectedColor.Green(),

				aExpectedColor.Blue()));

		INFO_PRINTF5(_L("For rect %d %d %d %d"),aRect.iTl.iX,aRect.iTl.iY,aRect.iBr.iX,aRect.iBr.iY);

		INFO_PRINTF4(_L("The expected color is r=%d g=%d b=%d"),aExpectedColor.Red(),aExpectedColor.Green(),

				aExpectedColor.Blue());

		return ETrue;

    	}

	}

/**

 * checks the color within the given rectangle of the given surface

 * returns ETrue on success

 */

TBool COpenwfTest::CheckRect(const TSurfaceId& aSurface, TInt aBuffer,  TRect aRect,

		const TRgb& aExpectedColor, TInt aTolerance)

	{

	INFO_PRINTF1(_L("Starting pixel checking"));

	LOG(("OpenWFTest: *** Starting pixel checking"));

	// Check pixel data

	TBool success = iUtility->CheckRectColor(aSurface, aRect, aBuffer, aExpectedColor, aTolerance);

	if (success)

		{

		INFO_PRINTF1(_L("Finished pixel checking - pass"));

		LOG(("OpenWFTest: *** Finished pixel checking - pass"));

		}

	else

		{

		INFO_PRINTF1(_L("Finished pixel checking - fail"));

		LOG(("OpenWFTest: *** Finished pixel checking - fail"));

		}

    return success;

	}

/**

 * If in automatic mode it will save a TGA image of the on screen stream.

 * It will also print the name of the reference image.

 * Returns ETrue on success

 */

TBool COpenwfTest::CheckOnScreenReferenceImage()

	{

	TInt error = KErrNone;

	//Create image file name

	_LIT(KSeparator, "_");

	_LIT(KTGAImgFormat, ".tga");

	iImageAddress.Zero();

	iImageAddress.Append(iTestName);

	iImageAddress.Append(KSeparator);

	iImageAddress.AppendNum(iImageCounter);

	iImageAddress.Append(KTGAImgFormat);

	LOGL((_L("Reference Image:%S"),&iImageAddress));

	INFO_PRINTF2(_L("Reference Image:%S"),&iImageAddress);

	//Add file path

	iImageAddress.Insert(0,iImageDirectory);

	iImageCounter++;

    if(iTestMode == EAutomatic && iSaveImage)

    	{

		if (iOnScreenStream == WFC_INVALID_HANDLE)

			{

			LOG(("OpenWFTest: *** We don't have access to the on screen stream",error));

			INFO_PRINTF1(_L("We don't have access to the on screen stream"));

			return EFalse;

			}

		const TSurfaceId* surfaceId = NULL;

		long bufferIndex;

		error = SymbianStreamGetBufferId(iOnScreenStream,iOnScreenBuffer,&bufferIndex,&surfaceId);

		if (error == KErrNone)

			{

			return SaveImage(*surfaceId,bufferIndex);

			}

		else

			{

			LOG(("OpenWFTest: *** Unable to get stream buffer id. error = %d",error));

			INFO_PRINTF2(_L("Unable to get stream buffer id. error = %d"),error);

			return EFalse;

			}

    	}

    return ETrue;

	}

/**

 *  helper function for saving images to files

 *  returns ETrue on success

 */

TBool COpenwfTest::SaveImage(const TSurfaceId& aSurface, TInt aNumOfBuffer)

    {

	if(iTestMode == EAutomatic && iSaveImage)

		{

		INFO_PRINTF1(_L("Start to save image"));

		LOG(("OpenWFTest: *** Start to save image"));

		TBool success = EFalse;

		TRAPD(error, success = iUtility->SaveResultImageTGAL(aSurface, aNumOfBuffer, iImageAddress));

		if(error != KErrNone || !success)

			{

			INFO_PRINTF1(_L("Failed saving image"));

			LOG(("OpenWFTest: *** Failed saving image"));

			return EFalse;

			}

		INFO_PRINTF1(_L("Saved image"));

		LOG(("OpenWFTest: *** Saved image"));

		}

    return ETrue;

    }

/**

 * Basic wait function call. Return amount of other active objects that stopped the scheduler

*/

TInt COpenwfTest::WaitL(TTimeIntervalMicroSeconds32 aDelay)	//aDelay in microseconds

	{

	CActiveWaiter* waiter = NULL;

	waiter = CActiveWaiter::NewL();

    TInt counter = waiter->Wait(aDelay);

	delete waiter;

	return counter;

	}

/**

 * aMaxDelay    The maximum time we are willing to wait in microseconds

 * aNotifications   The amount of notifications we expect to complete, must be >0

 * Returns ETrue on success

*/

TBool COpenwfTest::WaitForNotifications(TTimeIntervalMicroSeconds32 aMaxDelay,TInt aNotificatons)

    {

    if (aNotificatons == 0)

        {   //use WaitL if no notifications are expected

        return EFalse;

        }

    TTime before;

    TTime after;

    before.UniversalTime();

    TTimeIntervalMicroSeconds diff;

    TInt counter = aNotificatons;

    CActiveWaiter* waiter = NULL;

    TRAP_IGNORE(waiter = CActiveWaiter::NewL());

    if (!waiter)

        {

        INFO_PRINTF1(_L("Failed creating CActiveWaiter"));

        LOG(("OpenWFTest: *** Failed creating CActiveWaiter"));

        return EFalse;

        }

    waiter->StartWait(aMaxDelay);

    CActiveScheduler::Start();

    while(!waiter->iRun)

        {

        after.UniversalTime();

        diff = after.MicroSecondsFrom(before);

        if (diff > KNotificationWarning)

            {

            INFO_PRINTF2(_L("note: Notification took a long time to complete: %ld microseconds"),diff.Int64());

            LOG(("OpenWFTest: *** note: Notification took a long time to complete: %ld microseconds",diff.Int64()));

            }

        counter--;

        if (counter == 0)

            {   //all expected notifications were completed

            delete waiter;

            return ETrue;

            }

        CActiveScheduler::Start();

        }

    INFO_PRINTF2(_L("Not all notifications completed, counter=%d"),counter);

    LOG(("OpenWFTest: *** Not all notifications completed, counter=%d",counter));

    delete waiter;

    //the notifications didn't complete in time

    return EFalse;

    }

// Create a suite of all the tests

CTestSuite* COpenwfTest::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE_OPT(COpenwfTest,NULL);

		//positive fastpath tests

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0000L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0001L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0002L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0003L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0004L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0005L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0006L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0007L);

        //fastpath with notification tests

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0010L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0011L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0012L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0013L);

        //negative fastpath tests

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0020L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0021L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0022L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0023L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0024L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0025L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0026L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_FASTPATH_0027L);

	END_SUITE;

	}

void TefUnitFailLeaveL()

	{

	User::Leave(KErrTEFUnitFail);

	}

CActiveNotification* CActiveNotification::NewL(RSurfaceUpdateSession& aSurfaceUpdateSession,TBool aActivate)

	{

	CActiveNotification* self = new (ELeave) CActiveNotification;

	CleanupStack::PushL(self);

	self->ConstructL(aSurfaceUpdateSession);

	CleanupStack::Pop(self);

	if (aActivate)

		{

		self->SetActive();

		}

	return self;

	}

void CActiveNotification::ConstructL(RSurfaceUpdateSession& aSurfaceUpdateSession)

	{

	CActiveScheduler::Add(this);

	iSurfaceUpdateSession = aSurfaceUpdateSession;

	}

CActiveNotification::CActiveNotification() : CActive(EPriorityNormal)

	{}

CActiveNotification::~CActiveNotification()

	{

	Cancel();

	}

void CActiveNotification::DoCancel()

	{  //we need to cancel all notifications - this will impact other notifications in this sus session!

    iSurfaceUpdateSession.CancelAllUpdateNotifications();

	}

void CActiveNotification::RunL()

	{

	CActiveScheduler::Stop();

	}

TInt CActiveNotification::RunError(TInt aError)

	{

	return aError; // exists so a break point can be placed on it.

	}

void CActiveNotification::Activate()

	{

	SetActive();

	}

CActiveWaiter* CActiveWaiter::NewL()

    {

	CActiveWaiter* self = new (ELeave) CActiveWaiter;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CActiveWaiter::ConstructL()

    {

    User::LeaveIfError(iTimer.CreateLocal());

    CActiveScheduler::Add(this);

    }

CActiveWaiter::CActiveWaiter() : CActive(CActive::EPriorityStandard)

    {}

CActiveWaiter::~CActiveWaiter()

    {

    Cancel();

    iTimer.Close();

    }

void CActiveWaiter::DoCancel()

    {

    iTimer.Cancel();

    }

void CActiveWaiter::RunL()

    {

	iRun = ETrue;

    CActiveScheduler::Stop();

    }

TInt CActiveWaiter::RunError(TInt aError)

    {

    return aError; // exists so a break point can be placed on it.

    }

/**

 * Waits the set amount of time. Returns the amount of times the active scheduler 

 * was stopped (not including its own active scheduler stop)

 */

TInt CActiveWaiter::Wait(TTimeIntervalMicroSeconds32 aDelay)   //microseconds

    {

	TInt counter = 0;

    SetActive();

    iTimer.After(iStatus, aDelay);

    iRun = EFalse;

    CActiveScheduler::Start();

    while (!iRun)

    	{//may be another object that stops the scheduler running in these tests.

		counter++;

		CActiveScheduler::Start();

    	}

    return counter;

    }

/**

 * Starts an AO with the given delay. Remember the RunL will stop the active scheduler.

 */

void CActiveWaiter::StartWait(TTimeIntervalMicroSeconds32 aDelay)   //microseconds

    {

    SetActive();

    iTimer.After(iStatus, aDelay);

    }

/*

@SYMTestCaseID          GRAPHICS-OPENWFC-FASTPATH-0000

@SYMTestCaseDesc        Positive testing - Fastpath one-element scene

@SYMREQ                 

@SYMPREQ                PREQ417-54885

@SYMTestType            Unit Test

@SYMTestPriority        High

@SYMTestPurpose         Check a scene meeting fastpath criteria can be fastpathed

@SYMTestActions         

    All compositions are autonomous:

    Compose an empty scene

    Create a scene containing a screen sized element with no scaling, no alpha, no mask, no rotation

    Compose the scene

@SYMTestExpectedResults

    The final scene should be fastpathed    

*/

void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0000L()

	{

    iTestName = _L("FASTPATH_0000");

    INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

    LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

    SetupEmptySceneL();

    TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

                                                iFastpathablePixelFormat,

                                                iStride, iContiguous, iMaxBuffers);

    ASSERT_FALSE(surface.IsNull());

    WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

    TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

    wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

#ifdef BREAKPOINT_FASTPATH

    __BREAKPOINT();

#endif

    wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

    LOG(("OpenWFTest: Expecting FASTPATH after next commit"));

    wfcCommit(iDevice, iContext, WFC_TRUE);

    wfcFence(iDevice, iContext, iEGLDisplay, iSync);

    ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

    LOG(("OpenWFTest: Fastpath - Now ON"));

    iUtility->FillSurfaceL(surface, 0, KGreen);

    err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WaitL(iCompositionPause);

    ASSERT_TRUE(AcquireOnScreenStream());

    ASSERT_TRUE(CheckOnScreenReferenceImage());

    ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

    ReleaseOnScreenStream();

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    wfcDestroySource(iDevice, fpSource);

	}

/*

@SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0001

@SYMTestCaseDesc		Positive testing - Fastpath one-element scene  

@SYMREQ					

@SYMPREQ						PREQ417-54885

@SYMTestType				Unit Test

@SYMTestPriority		High	

@SYMTestPurpose			Check a scene including a full screen element with global alpha at opaque level 

										can be fastpathed

@SYMTestActions			

	All compositions are autonomous:

	Compose an empty scene

	Create a scene containing a screen sized element with 2 buffers

	Enable WFC_TRANPARENCY_GLOBAL_ALPHA 

	Set WFC_ELEMENT_GLOBAL_ALPHA to be 255 (opaque)

	Compose the scene

@SYMTestExpectedResults

	The final scene should be fastpathed

*/

void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0001L()

	{

    iTestName = _L("FASTPATH_0001");

    INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

    LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

    SetupEmptySceneL();

    TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

                                                iFastpathablePixelFormat,

                                                iStride, iContiguous, iMaxBuffers);

    ASSERT_FALSE(surface.IsNull());

    WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

    TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

    wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

    //set element global alpha

    wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_TRANSPARENCY_TYPES, WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA);

    wfcSetElementAttribf(iDevice, fpElement, WFC_ELEMENT_GLOBAL_ALPHA, 1.0f);

#ifdef BREAKPOINT_FASTPATH

    __BREAKPOINT();

#endif

    wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

    LOG(("OpenWFTest: Expecting FASTPATH after next commit - using element alpha"));

    wfcCommit(iDevice, iContext, WFC_TRUE);

    wfcFence(iDevice, iContext, iEGLDisplay, iSync);

    ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

    LOG(("OpenWFTest: Fastpath - now ON - using element alpha"));

    iUtility->FillSurfaceL(surface, 0, KGreen);

    err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WaitL(iCompositionPause);	

    ASSERT_TRUE(AcquireOnScreenStream());

    ASSERT_TRUE(CheckOnScreenReferenceImage());

    ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

    ReleaseOnScreenStream();

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    wfcDestroySource(iDevice, fpSource);  

	}

/*

@SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0002

@SYMTestCaseDesc		Positive testing - Fastpath one-element scene  

@SYMREQ					

@SYMPREQ						PREQ417-54885

@SYMTestType				Unit Test

@SYMTestPriority		High

@SYMTestPurpose			Check a scene including a full screen element with source alpha flagged but an 

										opaque data format can be fastpathed

@SYMTestActions			

	All compositions are autonomous:

	Compose an empty scene

	Create a scene containing a screen sized element 

	Enable WFC_TRANSPARENCY_SOURCE, but the source format has no alpha value 

	Compose the scene

@SYMTestExpectedResults

	The final scene should be fastpathed

*/	

void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0002L()

	{

    iTestName = _L("FASTPATH_0002");

    INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

    LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

    SetupEmptySceneL();

    TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

												EUidPixelFormatXRGB_8888,

                                                iStride, iContiguous, iMaxBuffers);

    ASSERT_FALSE(surface.IsNull());

    WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

    TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

    wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

    //set pixel alpha on XRGB element

    wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_TRANSPARENCY_TYPES, WFC_TRANSPARENCY_SOURCE);

#ifdef BREAKPOINT_FASTPATH

    __BREAKPOINT();

#endif

    wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

    LOG(("OpenWFTest: Expecting FASTPATH after next commit - using pixel alpha"));

    wfcCommit(iDevice, iContext, WFC_TRUE);

    wfcFence(iDevice, iContext, iEGLDisplay, iSync);

    ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

    LOG(("OpenWFTest: Fastpath - now ON - using pixel alpha"));

    iUtility->FillSurfaceL(surface, 0, KGreen);

    err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WaitL(iCompositionPause);

    ASSERT_TRUE(AcquireOnScreenStream());

    ASSERT_TRUE(CheckOnScreenReferenceImage());

    ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

    ReleaseOnScreenStream();

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    wfcDestroySource(iDevice, fpSource);  

	}

/*

@SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0003

@SYMTestCaseDesc		Positive testing - Fastpath scene with a double buffered element

@SYMREQ					

@SYMPREQ						PREQ417-54885

@SYMTestType				Unit Test

@SYMTestPriority		High

@SYMTestPurpose			Check if a scene is fastpathed using the second buffer

@SYMTestActions			

	All compositions are autonomous:

	Compose an empty scene

	A) Create a scene containing an element with 2 buffers

	Set the element screen size

	Set destination and source rectangle to screen size

	Compose the scene

	B) Send an update to buffer 1 with change of colour

	Wait for notification

@SYMTestExpectedResults

	The scene should be fastpathed for A and B

	Screen colour should change after B

*/

void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0003L()

	{

    iTestName = _L("FASTPATH_0003");

    INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

    LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

    SetupEmptySceneL();

    TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

                                                iFastpathablePixelFormat,

                                                iStride, iContiguous, iMaxBuffers);

    ASSERT_FALSE(surface.IsNull());

    WFCSource fpSource = wfcCreateSourceFromStream(iDevice, iContext,reinterpret_cast<WFCNativeStreamType>(&surface), NULL);

    TInt err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WFCElement fpElement = wfcCreateElement(iDevice, iContext, NULL);

    wfcSetElementAttribi(iDevice, fpElement, WFC_ELEMENT_SOURCE, fpSource);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_SOURCE_RECTANGLE, 4, iFullScreenRect);

    wfcSetElementAttribiv(iDevice, fpElement, WFC_ELEMENT_DESTINATION_RECTANGLE, 4, iFullScreenRect);

#ifdef BREAKPOINT_FASTPATH

    __BREAKPOINT();

#endif

    wfcInsertElement(iDevice, fpElement, WFC_INVALID_HANDLE);

    LOG(("OpenWFTest: Expecting FASTPATH after next commit"));

    wfcCommit(iDevice, iContext, WFC_TRUE);

    wfcFence(iDevice, iContext, iEGLDisplay, iSync);

    ASSERT_EQUALS(eglClientWaitSyncKHR(iEGLDisplay,iSync,0,(EGLTimeKHR)EGL_FOREVER_KHR),EGL_CONDITION_SATISFIED_KHR);

    LOG(("OpenWFTest: Fastpath - now ON"));

    iUtility->FillSurfaceL(surface, 0, KGreen);

    err = iUtility->SubmitUpdate(surface, 0, NULL);

    ASSERT_EQUALS(err,KErrNone);

    WaitL(iCompositionPause);	

    ASSERT_TRUE(AcquireOnScreenStream());

    ASSERT_TRUE(CheckOnScreenReferenceImage());

    ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KGreen,iTolerance));

    ReleaseOnScreenStream();

    //Fill surface is blue

    iUtility->FillSurfaceL(surface, 1, KBlue);

	//Do content update for surface buff1

    CActiveNotification* buff1disp = CActiveNotification::NewL(iUtility->Session(),ETrue);

    CleanupStack::PushL(buff1disp);

    TTimeStamp buff1time;

    iUtility->NotifyWhenDisplayed(buff1disp->iStatus,buff1time);

    LOG(("OpenWFTest: Fastpath - staying ON..."));

    err = iUtility->SubmitUpdate(surface, 1, NULL);

	ASSERT_EQUALS(err,KErrNone);

    ASSERT_TRUE(WaitForNotifications(KMaxNotificationDelay,1));	//1 AO should have completed

    //create ref image/check on screen content

    ASSERT_TRUE(AcquireOnScreenStream());

    ASSERT_TRUE(CheckOnScreenReferenceImage());

    ASSERT_TRUE(CheckOnScreenStreamRect(iFullScreenTRect,KBlue,iTolerance));

    ReleaseOnScreenStream();

    ASSERT_EQUALS(wfcGetError(iDevice),WFC_ERROR_NONE);

    wfcDestroySource(iDevice, fpSource);

    CleanupStack::PopAndDestroy(buff1disp);

	}

/*

@SYMTestCaseID			GRAPHICS-OPENWFC-FASTPATH-0004

@SYMTestCaseDesc		Positive testing - Fastpath two-element scene 

@SYMREQ					

@SYMPREQ						PREQ417-54885

@SYMTestType				Unit Test

@SYMTestPriority		Medium

@SYMTestPurpose			Check a scene including a full screen opaque element as the top layer can be 

										fastpathed

@SYMTestActions			

	All compositions are autonomous:

	Compose an empty scene

	A) Create a scene containing a screen sized element with WFC_TRANSPARENCY_NONE enabled

	Compose the scene

  B) Create a small rectangle behind the first element

	Compose the scene

*/

void COpenwfTest::GRAPHICS_OPENWFC_FASTPATH_0004L()

	{

    iTestName = _L("FASTPATH_0004");

    INFO_PRINTF2(_L("GRAPHICS_OPENWFC_%SL()"),&iTestName);

    LOGL((_L("OpenWFTest: GRAPHICS_OPENWFC_%SL()"),&iTestName));

    SetupEmptySceneL();

	TSurfaceId surface=iUtility->CreateSurfaceL(TSize(iFastpathableWidth,iFastpathableHeight),

												iFastpathablePixelFormat,