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