// Copyright (c) 2008-2009 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

 @internalComponent

*/

#include <e32std.h>

#include <fbs.h>

#include "test_step_logger.h"

#include "comparison.h"

#include "utils.h"

#include "compwin.h"

#include "crpwin.h"

#include "edgedwin.h"

#include "coordinatewin.h"

#include "backedupwin.h"

#include "enormouswin.h"

#include "animatedwin.h"

#include "spritewin.h"

#include "panic.h"

const TInt KSteps = 10;

CComparison::COperationTimer::COperationTimer(CComparison* aComp):CTimer(0), iComp(aComp)

{}

void CComparison::COperationTimer::ConstructL()

	{

	CTimer::ConstructL();

	}

void CComparison::COperationTimer::DoCancel()

	{}

void CComparison::COperationTimer::RunL()

	{

	iComp->Tick();

	}

/*-------------------------------------------------------------------------*/

// COneShotCompare

CComparison::COneShotCompare* CComparison::COneShotCompare::NewL(TInt aPriority, CComparison& aComparison)

	{

	return new(ELeave)CComparison::COneShotCompare(aPriority, aComparison);

	}

CComparison::COneShotCompare::COneShotCompare(TInt aPriority, CComparison& aComparison)

	:CAsyncOneShot(aPriority), iComparison(aComparison)

	{

	}

void CComparison::COneShotCompare::RunL()

	{

	iComparison.iScreen->CopyScreenToBitmap(iComparison.iScreenBitmap);

	iComparison.SetVerifyTick(User::NTickCount());

	iComparison.Verify(iComparison.iScreenBitmap);

	}

/*-------------------------------------------------------------------------*/

_LIT(KConfigurationWindowSuffix, "-Window");

/*******************************************************************************

This is the stresslet itself

*******************************************************************************/

CComparison * CComparison::NewLC(MTestStepReporter& aReporter)

	{

	CComparison * self = new (ELeave) CComparison(aReporter);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CComparison::ConstructL()

	{

	iWatchCat = CTestExecWatchCat::NewL( CExecutionContext::ECtxRandomAndRecord );

	}

CComparison::CComparison (MTestStepReporter& aReporter):

	CStresslet(aReporter), iDifferenceBitmap(NULL), iDifferenceDevice(NULL), iOneShotCompare(NULL)

	{

	}

/**

 Sets stress-test configuration (read from ini file).

 @param aRunData configuration data

 @param aConfFactory a factory interface for creating "section" readers. These

 are used to supply configuration data for each window type.

 */

void CComparison::SetRunDataL(const TRunData& aRunData, MTestStepConfigurationContextFactory* aConfFactory)

	{

	iData = aRunData;

	User::LeaveIfError(iFs.Connect());

	iFs.MkDirAll(iData.loggingPath);

	iWatchCat->SetLoggingPathL(iData.loggingPath);

	//each window type can have its own configuration

	MTestStepConfigurationContext* context; //context created by the factory argument

	RBuf section; //section name (window-type + "-window"

	section.Create(32);

	CleanupStack::PushL(&section);

	struct STestStepConfEntry

		{

		const TPtrC8 iType;	//section name

		void (*iFunc)(const MTestStepConfigurationContext*); //configuration loader

		} confLoaders[] = 

		{

			{KCommonWindowType(),    CCompWin::LoadConfiguration},

			{KAnimatedWindowType(),   CAnimatedWin::LoadConfiguration},

			{KBackedupWindowType(),   CBackedupWin::LoadConfiguration},

			{KCoordinateWindowType(), CCoordinateWin::LoadConfiguration},

			{KCrpWindowType(),        CCrpWin::LoadConfiguration},

			{KEdgedWindowType(),      CEdgedWin::LoadConfiguration},

			{KEnormousWindowType(),   CEnormousWin::LoadConfiguration},

			{KSpritedWindowType(),    CSpritedWin::LoadConfiguration}

		};

	for (int i=0; i<sizeof(confLoaders)/sizeof(STestStepConfEntry); i++)

		{

		section.Copy(confLoaders[i].iType);

		section.Append(KConfigurationWindowSuffix);

		context = aConfFactory->GetConfigurationContextLC(section);

		confLoaders[i].iFunc(context);

		CleanupStack::PopAndDestroy(context);

		}

	CleanupStack::Pop(&section);

	}

void CComparison::StartL()

	{

	iStartTime.UniversalTime();

	if (iData.randomSeed > -1)

		{

		//use seed from ini file

		iFirstSeed = iData.randomSeed;

		}

	else 

		{

		// randomize seed by time

		iFirstSeed = iStartTime.Int64();

		}

	TRnd::SetSeed(iFirstSeed);

	iWasOk = ETrue;

	iMode = EAct;

	iErrorNum = 0;

	iWinGroup=new(ELeave) RWindowGroup(Session());

	User::LeaveIfError(iWinGroup->Construct( (TUint32)(iWinGroup) ));

	iWinGroup->SetOrdinalPosition(0,0);

	//make sure at least minNumWindows are created, or if it's zero no limit

	iNumWindowsLeft = iData.minNumWindows;

	iScreen = new (ELeave) CWsScreenDevice(Session());	

	User::LeaveIfError(iScreen->Construct(0));

	TDisplayMode screenMode = iScreen->DisplayMode();

	iScreenBitmap = new (ELeave) CFbsBitmap;

	iScreenBitmap->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode);

	iBackground = new(ELeave) RBlankWindow(Session());

	iBackground->Construct(*iWinGroup,reinterpret_cast<TUint32>(iBackground));

	iBackground->SetColor(KRgbBlack);

	iBackground->SetExtent(TPoint(0,0), TSize(iData.windowWidth, iData.windowHeight));

	iBackground->SetOrdinalPosition(0);

	iBackground->Activate();

	iCurrentBmp = 0;

	iLastBmp = 1;

	iBmpGc = CFbsBitGc::NewL();

	for (TInt bmp = 0; bmp < 2; ++bmp)

		{

		iBitmap[bmp] = new (ELeave) CFbsBitmap;

		iBitmap[bmp]->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode); //EColor16MU); //

		iDevice[bmp] = CFbsBitmapDevice::NewL(iBitmap[bmp]);

		//clear bitmap background

		iBmpGc->Activate(iDevice[bmp]);

		iBmpGc->Reset();

		iBmpGc->SetPenStyle(CGraphicsContext::ENullPen);

		iBmpGc->SetBrushColor(KRgbBlack);

		iBmpGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		TPoint origin(0,0);

		TRect rect(origin, TSize(iData.windowWidth, iData.windowHeight));

		iBmpGc->DrawRect(rect);

		}

	iDifferenceBitmap = new (ELeave) CFbsBitmap;

	iDifferenceBitmap->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode); //EColor16MU); //

	iDifferenceDevice = CFbsBitmapDevice::NewL(iDifferenceBitmap);

	iTimer = new(ELeave) COperationTimer(this);

	iTimer->ConstructL();

	CActiveScheduler::Add (iTimer);

	iTimer->After(iData.initPeriod);

	}

/**

 Simulate a Left key stroke

 */

void CComparison::Touch()

	{

	User::ResetInactivityTime();

	TRawEvent keyDown;  

	keyDown.Set(TRawEvent::EKeyDown,EStdKeyLeftArrow);

	Session().SimulateRawEvent(keyDown);

	TRawEvent keyUp;

	keyUp.Set(TRawEvent::EKeyUp,EStdKeyLeftArrow);

	Session().SimulateRawEvent(keyUp);

	}

/**

 Non leaving version of TickL that reports failures

 */

TInt CComparison::Tick()

	{

	TRAPD(err, TickL());

	if (err)

		{

		REPORT_EVENT( EFalse );

		}

	return err;

	}

/**

 Called periodically 

 */

void CComparison::TickL()

	{

	if (iMustConclude)

		{

		WriteLog();

		ConcludeNow();

		return;

		}

	if (0 == iTestNum % 100)

		{

		Touch();

		}

	DoStuffL();

	if (iStuffDone)

		{

		++iTestNum;

		}

	}

/**

 Dispatch work to selected operation by mode

 */

void CComparison::DoStuffL()

	{

	iStuffDone = EFalse;

	switch (iMode)

		{

		case EAct:

			ActL();

			break;

		case EMove:

			MoveL();

			break;

		case EResize:

			ResizeL();

			break;

		};

	if (iWasOk && iData.compareBitmaps && iStuffDone)

		{

		Session().Flush();

		// schedule a delayed compare, will take place after all updates to windows

		if (iOneShotCompare == NULL)

			{

			iOneShotCompare = CComparison::COneShotCompare::NewL(EPriorityMuchLess, *this);

			}

		iOneShotCompare->Call();

		}

	else

		{

		if (iTestNum > iData.maxRunCycles && iNumWindowsLeft == 0)

			{

			iMustConclude = ETrue;

			}

		iTimer->After(iData.period);

		}

	Session().Flush();

	Session().Finish(); 

	}

/**

 Performs a random operation on a random window

 Operation can be one of create, destroy, move, bring to front/back,

 resize, tick, toggle-visibility

 */

void CComparison::ActL()

	{

	TInt action = TRnd::rnd(EACount);

	if (iWindows.Count() == 0)

		{

		action = 0;

		}

	iBehaviour.iWin = RandomWindow();

	iAct = static_cast<TAct>(action);

	switch(iAct)

		{

		case EACreate:

			CreateWindowL();

			break;

		case EADestroy:

			DestroyWindow();

			break;

		case EAMove:

			MoveWindow();

			break;

		case EAFront:

			BringWindowToFrontL();

			break;

		case EABack:

			SendWindowToBackL();

			break;

		case EAResize:

			ResizeWindow();

			break;

		case EATick:

			TickWindowL();

			break;

		case EAToggleVisible:

			ToggleVisible();

			break;

		} //lint !e787 enum constant TAct::EACount not used within switch

	}

void CComparison::MoveL()

	{

	if (iBehaviour.iCount < 1)

		{

		iMode = EAct;

		}

	else

		{

		TPoint pos = iBehaviour.iWin->Pos() + iBehaviour.iPos;

		iBehaviour.iWin->SetPos(pos);

		--iBehaviour.iCount;

		iStuffDone = ETrue;

		}

	}

void CComparison::ResizeL()

	{

	if (iBehaviour.iCount < 1)

		{

		iMode = EAct;

		}

	else

		{

		TSize size = iBehaviour.iWin->Size();

		size.iWidth += iBehaviour.iPos.iX;

		size.iHeight += iBehaviour.iPos.iY;

		iBehaviour.iWin->SetSize(size);

		--iBehaviour.iCount;

		iStuffDone = ETrue;

		}

	}

/**

 Sets the position for a future window-move command, the actual move will be 

 done in the next step 

 */

void CComparison::MoveWindow()

	{

	__UHEAP_MARK;

	if (iBehaviour.iWin)

		{

		TPoint pos = TPoint(TRnd::rnd(KPosLimit), TRnd::rnd(KPosLimit));

		pos.iX -= iBehaviour.iWin->Size().iWidth / 2;

		pos.iY -= iBehaviour.iWin->Size().iHeight / 2;

		iBehaviour.iPos = pos - iBehaviour.iWin->Pos();

		iBehaviour.iCount = KSteps;

		iBehaviour.iPos.iX /= iBehaviour.iCount;

		iBehaviour.iPos.iY /= iBehaviour.iCount;

		iMode = EMove;

		}

	__UHEAP_MARKEND;

	}

/**

 Sets the size for a future window-resize command, the actual resize will be 

 done in the next step 

 */

void CComparison::ResizeWindow()

	{

	__UHEAP_MARK;

	if (iBehaviour.iWin)

		{

		TPoint newsize = TPoint(TRnd::rnd(KPosLimit), TRnd::rnd(KPosLimit));

		TPoint oldsize;

		oldsize.iX = iBehaviour.iWin->Size().iWidth;

		oldsize.iY = iBehaviour.iWin->Size().iHeight;

		iBehaviour.iPos = newsize - oldsize;

		iBehaviour.iCount = KSteps;

		iBehaviour.iPos.iX /= iBehaviour.iCount;

		iBehaviour.iPos.iY /= iBehaviour.iCount;

		iMode = EResize;

		}

	__UHEAP_MARKEND;

	}

void CComparison::BringWindowToFrontL()

	{

	__UHEAP_MARK;

	CCompWin* win = iBehaviour.iWin;

	if (win)

		{

		win->BringToFrontL();

		TInt pos = FindTopWindow(win);

		if (pos >= 0)

			{

			iWindows.Remove(pos);

			iWindows.Append(win);

			}

		iStuffDone = ETrue;

		}

	__UHEAP_MARKEND;

	}

void CComparison::SendWindowToBackL()

	{

	__UHEAP_MARK;

	TInt ord = iBackground->OrdinalPosition();

	if (ord > 0)

		{

		CCompWin* win = iBehaviour.iWin;

		if (win)

			{

			TInt pos = FindTopWindow(win);

			if (pos >= 0)

				{

				iWindows.Remove(pos);

				iWindows.Insert(win, 0);

				win->Window()->SetOrdinalPosition(ord - 1);

				}

			else

				{

				win->SendToBackL();

				}

			iStuffDone = ETrue;

			}

		}

	__UHEAP_MARKEND;

	}

TInt CComparison::FindTopWindow(CCompWin* win)

	{

	return iWindows.Find(win);

	}

/**

 Returns a random window (which may be a NULL window)

*/

CCompWin * CComparison::RandomWindow()

	{

	if (iWindows.Count() == 0)

		{

		return 0;

		}

	TInt num = TRnd::rnd(iWindows.Count() + 1);

	if (num == iWindows.Count())

		{

		return 0;

		}

	else

		{

		return iWindows[num]->RandomWindow();

		}

	}

void CComparison::CreateWindowL()

	{

	CCompWin* parent = iBehaviour.iWin;

	CCompWin* win = CCompWin::NewLC(Session(), iWinGroup, parent, WindowGc());

	iBehaviour.iWin = win;

	if (!parent)

		{

		iWindows.AppendL(win);

		}

	CleanupStack::Pop(win);

	if (iNumWindowsLeft > 0)	//decrement window count

		{

		--iNumWindowsLeft;

		}

	iStuffDone = ETrue;

	}	

void CComparison::DestroyWindow()

	{

	CCompWin* win = iBehaviour.iWin;

	if (win)

		{

		TInt num = iWindows.Find(win);

		if (num != KErrNotFound)

			{

			iWindows.Remove(num);

			}

		delete win;

		iBehaviour.iWin = 0; // rby added

		iStuffDone = ETrue;