sl@0: // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: /**
sl@0:  @file
sl@0:  @test
sl@0:  @internalComponent
sl@0: */
sl@0:  
sl@0: 
sl@0: #include <e32std.h>
sl@0: #include <fbs.h>
sl@0: 
sl@0: #include "test_step_logger.h"
sl@0: #include "comparison.h"
sl@0: #include "utils.h"
sl@0: #include "compwin.h"
sl@0: #include "crpwin.h"
sl@0: #include "edgedwin.h"
sl@0: #include "coordinatewin.h"
sl@0: #include "backedupwin.h"
sl@0: #include "enormouswin.h"
sl@0: #include "animatedwin.h"
sl@0: #include "spritewin.h"
sl@0: #include "panic.h"
sl@0: 
sl@0: 
sl@0: const TInt KSteps = 10;
sl@0: 
sl@0: CComparison::COperationTimer::COperationTimer(CComparison* aComp):CTimer(0), iComp(aComp)
sl@0: {}
sl@0: 
sl@0: void CComparison::COperationTimer::ConstructL()
sl@0: 	{
sl@0: 	CTimer::ConstructL();
sl@0: 	}
sl@0: 
sl@0: void CComparison::COperationTimer::DoCancel()
sl@0: 	{}
sl@0: 
sl@0: void CComparison::COperationTimer::RunL()
sl@0: 	{
sl@0: 	iComp->Tick();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /*-------------------------------------------------------------------------*/
sl@0: // COneShotCompare
sl@0: CComparison::COneShotCompare* CComparison::COneShotCompare::NewL(TInt aPriority, CComparison& aComparison)
sl@0: 	{
sl@0: 	return new(ELeave)CComparison::COneShotCompare(aPriority, aComparison);
sl@0: 	}
sl@0: 
sl@0: CComparison::COneShotCompare::COneShotCompare(TInt aPriority, CComparison& aComparison)
sl@0: 	:CAsyncOneShot(aPriority), iComparison(aComparison)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: void CComparison::COneShotCompare::RunL()
sl@0: 	{
sl@0: 	iComparison.iScreen->CopyScreenToBitmap(iComparison.iScreenBitmap);
sl@0: 	iComparison.SetVerifyTick(User::NTickCount());
sl@0: 	iComparison.Verify(iComparison.iScreenBitmap);
sl@0: 	}
sl@0: /*-------------------------------------------------------------------------*/
sl@0: 
sl@0: _LIT(KConfigurationWindowSuffix, "-Window");
sl@0: 
sl@0: /*******************************************************************************
sl@0: This is the stresslet itself
sl@0: *******************************************************************************/
sl@0: CComparison * CComparison::NewLC(MTestStepReporter& aReporter)
sl@0: 	{
sl@0: 	CComparison * self = new (ELeave) CComparison(aReporter);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: void CComparison::ConstructL()
sl@0: 	{
sl@0: 	iWatchCat = CTestExecWatchCat::NewL( CExecutionContext::ECtxRandomAndRecord );
sl@0: 	}
sl@0: 
sl@0: CComparison::CComparison (MTestStepReporter& aReporter):
sl@0: 	CStresslet(aReporter), iDifferenceBitmap(NULL), iDifferenceDevice(NULL), iOneShotCompare(NULL)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Sets stress-test configuration (read from ini file).
sl@0:  @param aRunData configuration data
sl@0:  @param aConfFactory a factory interface for creating "section" readers. These
sl@0:  are used to supply configuration data for each window type.
sl@0:  */
sl@0: void CComparison::SetRunDataL(const TRunData& aRunData, MTestStepConfigurationContextFactory* aConfFactory)
sl@0: 	{
sl@0: 	iData = aRunData;
sl@0: 	User::LeaveIfError(iFs.Connect());
sl@0: 	iFs.MkDirAll(iData.loggingPath);
sl@0: 	iWatchCat->SetLoggingPathL(iData.loggingPath);
sl@0: 
sl@0: 	//each window type can have its own configuration
sl@0: 	MTestStepConfigurationContext* context; //context created by the factory argument
sl@0: 	RBuf section; //section name (window-type + "-window"
sl@0: 	section.Create(32);
sl@0: 	CleanupStack::PushL(&section);
sl@0: 
sl@0: 	struct STestStepConfEntry
sl@0: 		{
sl@0: 		const TPtrC8 iType;	//section name
sl@0: 		void (*iFunc)(const MTestStepConfigurationContext*); //configuration loader
sl@0: 		} confLoaders[] = 
sl@0: 		{
sl@0: 			{KCommonWindowType(),    CCompWin::LoadConfiguration},
sl@0: 			{KAnimatedWindowType(),   CAnimatedWin::LoadConfiguration},
sl@0: 			{KBackedupWindowType(),   CBackedupWin::LoadConfiguration},
sl@0: 			{KCoordinateWindowType(), CCoordinateWin::LoadConfiguration},
sl@0: 			{KCrpWindowType(),        CCrpWin::LoadConfiguration},
sl@0: 			{KEdgedWindowType(),      CEdgedWin::LoadConfiguration},
sl@0: 			{KEnormousWindowType(),   CEnormousWin::LoadConfiguration},
sl@0: 			{KSpritedWindowType(),    CSpritedWin::LoadConfiguration}
sl@0: 		};
sl@0: 
sl@0: 	for (int i=0; i<sizeof(confLoaders)/sizeof(STestStepConfEntry); i++)
sl@0: 		{
sl@0: 		section.Copy(confLoaders[i].iType);
sl@0: 		section.Append(KConfigurationWindowSuffix);
sl@0: 		context = aConfFactory->GetConfigurationContextLC(section);
sl@0: 		confLoaders[i].iFunc(context);
sl@0: 		CleanupStack::PopAndDestroy(context);
sl@0: 		}
sl@0: 	
sl@0: 	CleanupStack::Pop(&section);
sl@0: 	}
sl@0: 
sl@0: void CComparison::StartL()
sl@0: 	{
sl@0: 	iStartTime.UniversalTime();
sl@0: 	if (iData.randomSeed > -1)
sl@0: 		{
sl@0: 		//use seed from ini file
sl@0: 		iFirstSeed = iData.randomSeed;
sl@0: 		}
sl@0: 	else 
sl@0: 		{
sl@0: 		// randomize seed by time
sl@0: 		iFirstSeed = iStartTime.Int64();
sl@0: 		}
sl@0: 	TRnd::SetSeed(iFirstSeed);
sl@0: 	
sl@0: 	iWasOk = ETrue;
sl@0: 	iMode = EAct;
sl@0: 	iErrorNum = 0;
sl@0: 	iWinGroup=new(ELeave) RWindowGroup(Session());
sl@0: 	User::LeaveIfError(iWinGroup->Construct( (TUint32)(iWinGroup) ));
sl@0: 	iWinGroup->SetOrdinalPosition(0,0);
sl@0: 
sl@0: 	//make sure at least minNumWindows are created, or if it's zero no limit
sl@0: 	iNumWindowsLeft = iData.minNumWindows;
sl@0: 
sl@0: 	iScreen = new (ELeave) CWsScreenDevice(Session());	
sl@0: 	User::LeaveIfError(iScreen->Construct(0));
sl@0: 	TDisplayMode screenMode = iScreen->DisplayMode();
sl@0: 	
sl@0: 	iScreenBitmap = new (ELeave) CFbsBitmap;
sl@0: 	iScreenBitmap->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode);
sl@0: 	
sl@0: 	iBackground = new(ELeave) RBlankWindow(Session());
sl@0: 	iBackground->Construct(*iWinGroup,reinterpret_cast<TUint32>(iBackground));
sl@0: 	iBackground->SetColor(KRgbBlack);
sl@0: 	iBackground->SetExtent(TPoint(0,0), TSize(iData.windowWidth, iData.windowHeight));
sl@0: 	iBackground->SetOrdinalPosition(0);
sl@0: 	iBackground->Activate();
sl@0: 
sl@0: 	iCurrentBmp = 0;
sl@0: 	iLastBmp = 1;
sl@0: 	iBmpGc = CFbsBitGc::NewL();
sl@0: 	for (TInt bmp = 0; bmp < 2; ++bmp)
sl@0: 		{
sl@0: 		iBitmap[bmp] = new (ELeave) CFbsBitmap;
sl@0: 		iBitmap[bmp]->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode); //EColor16MU); //
sl@0: 		iDevice[bmp] = CFbsBitmapDevice::NewL(iBitmap[bmp]);
sl@0: 		//clear bitmap background
sl@0: 		iBmpGc->Activate(iDevice[bmp]);
sl@0: 		iBmpGc->Reset();
sl@0: 		iBmpGc->SetPenStyle(CGraphicsContext::ENullPen);
sl@0: 		iBmpGc->SetBrushColor(KRgbBlack);
sl@0: 		iBmpGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
sl@0: 		TPoint origin(0,0);
sl@0: 		TRect rect(origin, TSize(iData.windowWidth, iData.windowHeight));
sl@0: 		iBmpGc->DrawRect(rect);
sl@0: 		}
sl@0: 
sl@0: 	iDifferenceBitmap = new (ELeave) CFbsBitmap;
sl@0: 	iDifferenceBitmap->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode); //EColor16MU); //
sl@0: 	iDifferenceDevice = CFbsBitmapDevice::NewL(iDifferenceBitmap);
sl@0: 
sl@0: 	iTimer = new(ELeave) COperationTimer(this);
sl@0: 	iTimer->ConstructL();
sl@0: 	CActiveScheduler::Add (iTimer);
sl@0: 	iTimer->After(iData.initPeriod);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Simulate a Left key stroke
sl@0:  */
sl@0: void CComparison::Touch()
sl@0: 	{
sl@0: 	User::ResetInactivityTime();
sl@0: 
sl@0: 	TRawEvent keyDown;  
sl@0: 	keyDown.Set(TRawEvent::EKeyDown,EStdKeyLeftArrow);
sl@0: 	Session().SimulateRawEvent(keyDown);
sl@0: 	
sl@0: 	TRawEvent keyUp;
sl@0: 	keyUp.Set(TRawEvent::EKeyUp,EStdKeyLeftArrow);
sl@0: 	Session().SimulateRawEvent(keyUp);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Non leaving version of TickL that reports failures
sl@0:  */
sl@0: TInt CComparison::Tick()
sl@0: 	{
sl@0: 	TRAPD(err, TickL());
sl@0: 	if (err)
sl@0: 		{
sl@0: 		REPORT_EVENT( EFalse );
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Called periodically 
sl@0:  */
sl@0: void CComparison::TickL()
sl@0: 	{
sl@0: 	if (iMustConclude)
sl@0: 		{
sl@0: 		WriteLog();
sl@0: 		ConcludeNow();
sl@0: 		return;
sl@0: 		}
sl@0: 	if (0 == iTestNum % 100)
sl@0: 		{
sl@0: 		Touch();
sl@0: 		}
sl@0: 	DoStuffL();
sl@0: 	if (iStuffDone)
sl@0: 		{
sl@0: 		++iTestNum;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Dispatch work to selected operation by mode
sl@0:  */
sl@0: void CComparison::DoStuffL()
sl@0: 	{
sl@0: 	iStuffDone = EFalse;
sl@0: 	switch (iMode)
sl@0: 		{
sl@0: 		case EAct:
sl@0: 			ActL();
sl@0: 			break;
sl@0: 		case EMove:
sl@0: 			MoveL();
sl@0: 			break;
sl@0: 		case EResize:
sl@0: 			ResizeL();
sl@0: 			break;
sl@0: 		};
sl@0: 	if (iWasOk && iData.compareBitmaps && iStuffDone)
sl@0: 		{
sl@0: 		Session().Flush();
sl@0: 		// schedule a delayed compare, will take place after all updates to windows
sl@0: 		if (iOneShotCompare == NULL)
sl@0: 			{
sl@0: 			iOneShotCompare = CComparison::COneShotCompare::NewL(EPriorityMuchLess, *this);
sl@0: 			}
sl@0: 		iOneShotCompare->Call();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if (iTestNum > iData.maxRunCycles && iNumWindowsLeft == 0)
sl@0: 			{
sl@0: 			iMustConclude = ETrue;
sl@0: 			}
sl@0: 		iTimer->After(iData.period);
sl@0: 		}
sl@0: 	Session().Flush();
sl@0: 
sl@0: 	Session().Finish(); 
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0:  Performs a random operation on a random window
sl@0:  Operation can be one of create, destroy, move, bring to front/back,
sl@0:  resize, tick, toggle-visibility
sl@0:  */
sl@0: void CComparison::ActL()
sl@0: 	{
sl@0: 	TInt action = TRnd::rnd(EACount);
sl@0: 	if (iWindows.Count() == 0)
sl@0: 		{
sl@0: 		action = 0;
sl@0: 		}
sl@0: 	
sl@0: 	iBehaviour.iWin = RandomWindow();
sl@0: 	iAct = static_cast<TAct>(action);
sl@0: 	switch(iAct)
sl@0: 		{
sl@0: 		case EACreate:
sl@0: 			CreateWindowL();
sl@0: 			break;
sl@0: 		case EADestroy:
sl@0: 			DestroyWindow();
sl@0: 			break;
sl@0: 		case EAMove:
sl@0: 			MoveWindow();
sl@0: 			break;
sl@0: 		case EAFront:
sl@0: 			BringWindowToFrontL();
sl@0: 			break;
sl@0: 		case EABack:
sl@0: 			SendWindowToBackL();
sl@0: 			break;
sl@0: 		case EAResize:
sl@0: 			ResizeWindow();
sl@0: 			break;
sl@0: 		case EATick:
sl@0: 			TickWindowL();
sl@0: 			break;
sl@0: 		case EAToggleVisible:
sl@0: 			ToggleVisible();
sl@0: 			break;
sl@0: 		} //lint !e787 enum constant TAct::EACount not used within switch
sl@0: 	}
sl@0: 
sl@0: void CComparison::MoveL()
sl@0: 	{
sl@0: 	if (iBehaviour.iCount < 1)
sl@0: 		{
sl@0: 		iMode = EAct;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TPoint pos = iBehaviour.iWin->Pos() + iBehaviour.iPos;
sl@0: 		iBehaviour.iWin->SetPos(pos);
sl@0: 		--iBehaviour.iCount;
sl@0: 		iStuffDone = ETrue;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CComparison::ResizeL()
sl@0: 	{
sl@0: 	if (iBehaviour.iCount < 1)
sl@0: 		{
sl@0: 		iMode = EAct;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TSize size = iBehaviour.iWin->Size();
sl@0: 		size.iWidth += iBehaviour.iPos.iX;
sl@0: 		size.iHeight += iBehaviour.iPos.iY;
sl@0: 		iBehaviour.iWin->SetSize(size);
sl@0: 		--iBehaviour.iCount;
sl@0: 		iStuffDone = ETrue;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Sets the position for a future window-move command, the actual move will be 
sl@0:  done in the next step 
sl@0:  */
sl@0: void CComparison::MoveWindow()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	if (iBehaviour.iWin)
sl@0: 		{
sl@0: 		TPoint pos = TPoint(TRnd::rnd(KPosLimit), TRnd::rnd(KPosLimit));
sl@0: 		pos.iX -= iBehaviour.iWin->Size().iWidth / 2;
sl@0: 		pos.iY -= iBehaviour.iWin->Size().iHeight / 2;
sl@0: 		iBehaviour.iPos = pos - iBehaviour.iWin->Pos();
sl@0: 		iBehaviour.iCount = KSteps;
sl@0: 		iBehaviour.iPos.iX /= iBehaviour.iCount;
sl@0: 		iBehaviour.iPos.iY /= iBehaviour.iCount;
sl@0: 		iMode = EMove;
sl@0: 		}
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Sets the size for a future window-resize command, the actual resize will be 
sl@0:  done in the next step 
sl@0:  */
sl@0: void CComparison::ResizeWindow()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	if (iBehaviour.iWin)
sl@0: 		{
sl@0: 		TPoint newsize = TPoint(TRnd::rnd(KPosLimit), TRnd::rnd(KPosLimit));
sl@0: 		TPoint oldsize;
sl@0: 		oldsize.iX = iBehaviour.iWin->Size().iWidth;
sl@0: 		oldsize.iY = iBehaviour.iWin->Size().iHeight;
sl@0: 		iBehaviour.iPos = newsize - oldsize;
sl@0: 		iBehaviour.iCount = KSteps;
sl@0: 		iBehaviour.iPos.iX /= iBehaviour.iCount;
sl@0: 		iBehaviour.iPos.iY /= iBehaviour.iCount;
sl@0: 		iMode = EResize;
sl@0: 		}
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: void CComparison::BringWindowToFrontL()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	CCompWin* win = iBehaviour.iWin;
sl@0: 	if (win)
sl@0: 		{
sl@0: 		win->BringToFrontL();
sl@0: 		TInt pos = FindTopWindow(win);
sl@0: 		if (pos >= 0)
sl@0: 			{
sl@0: 			iWindows.Remove(pos);
sl@0: 			iWindows.Append(win);
sl@0: 			}
sl@0: 		iStuffDone = ETrue;
sl@0: 		}
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 	
sl@0: void CComparison::SendWindowToBackL()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	TInt ord = iBackground->OrdinalPosition();
sl@0: 	if (ord > 0)
sl@0: 		{
sl@0: 		CCompWin* win = iBehaviour.iWin;
sl@0: 		if (win)
sl@0: 			{
sl@0: 			TInt pos = FindTopWindow(win);
sl@0: 			if (pos >= 0)
sl@0: 				{
sl@0: 				iWindows.Remove(pos);
sl@0: 				iWindows.Insert(win, 0);
sl@0: 				win->Window()->SetOrdinalPosition(ord - 1);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				win->SendToBackL();
sl@0: 				}
sl@0: 			iStuffDone = ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: TInt CComparison::FindTopWindow(CCompWin* win)
sl@0: 	{
sl@0: 	return iWindows.Find(win);
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0:  Returns a random window (which may be a NULL window)
sl@0: */
sl@0: CCompWin * CComparison::RandomWindow()
sl@0: 	{
sl@0: 	if (iWindows.Count() == 0)
sl@0: 		{
sl@0: 		return 0;
sl@0: 		}
sl@0: 	
sl@0: 	TInt num = TRnd::rnd(iWindows.Count() + 1);
sl@0: 	
sl@0: 	if (num == iWindows.Count())
sl@0: 		{
sl@0: 		return 0;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		return iWindows[num]->RandomWindow();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CComparison::CreateWindowL()
sl@0: 	{
sl@0: 	CCompWin* parent = iBehaviour.iWin;
sl@0: 	CCompWin* win = CCompWin::NewLC(Session(), iWinGroup, parent, WindowGc());
sl@0: 	iBehaviour.iWin = win;
sl@0: 	if (!parent)
sl@0: 		{
sl@0: 		iWindows.AppendL(win);
sl@0: 		}
sl@0: 	CleanupStack::Pop(win);
sl@0: 	if (iNumWindowsLeft > 0)	//decrement window count
sl@0: 		{
sl@0: 		--iNumWindowsLeft;
sl@0: 		}
sl@0: 	iStuffDone = ETrue;
sl@0: 	}	
sl@0: 
sl@0: void CComparison::DestroyWindow()
sl@0: 	{
sl@0: 	CCompWin* win = iBehaviour.iWin;
sl@0: 	if (win)
sl@0: 		{
sl@0: 		TInt num = iWindows.Find(win);
sl@0: 		if (num != KErrNotFound)
sl@0: 			{
sl@0: 			iWindows.Remove(num);
sl@0: 			}
sl@0: 		delete win;
sl@0: 		iBehaviour.iWin = 0; // rby added
sl@0: 		iStuffDone = ETrue;
sl@0: 		}
sl@0: 	}	
sl@0: 
sl@0: void CComparison::TickWindowL()
sl@0: 	{
sl@0: 	CCompWin* win = iBehaviour.iWin;
sl@0: 	if (win)
sl@0: 		{
sl@0: 		if (win->TickL())
sl@0: 			{
sl@0: 			iStuffDone = ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: void CComparison::ToggleVisible()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	CCompWin* win = iBehaviour.iWin;
sl@0: 	if (win)
sl@0: 		{
sl@0: 		win->ToggleVisible();
sl@0: 		iStuffDone = ETrue;
sl@0: 		}
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: void CComparison::HandleRedraw(TWsRedrawEvent &aEvent)
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	if (aEvent.Handle() != reinterpret_cast<TUint32>(iBackground))
sl@0: 		{
sl@0: 		reinterpret_cast<CCompWin*>(aEvent.Handle())->HandleRedraw(aEvent);
sl@0: 		}
sl@0: 	Session().Flush();
sl@0: 	__UHEAP_MARKEND;
sl@0: 	}
sl@0: 
sl@0: void CComparison::HandleEvent(TWsEvent &/*aEvent*/)
sl@0: 	{	
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Compares two bitmaps. Comparison is done on a pixel-by-pixel basis.
sl@0:  If the bitmaps are of different sizes, the smaller axis of each is used for
sl@0:  comparison (top-left subregions).
sl@0:  First different pixel is stored in internally.
sl@0:  @return ETrue if bitmaps match, EFalse otherwise.
sl@0: */
sl@0: TBool CComparison::BitmapsMatch(const CFbsBitmap * aBitmap1, const CFbsBitmap * aBitmap2)
sl@0: 	{
sl@0: 	TDisplayMode mode1 = aBitmap1->DisplayMode();
sl@0: 	TDisplayMode mode2 = aBitmap2->DisplayMode();
sl@0: 	
sl@0: 	TSize bmpSize = aBitmap1->SizeInPixels();
sl@0: 	TSize bmpSize2 = aBitmap2->SizeInPixels();
sl@0: 	if (bmpSize2.iWidth < bmpSize.iWidth)
sl@0: 		{
sl@0: 		bmpSize.iWidth = bmpSize2.iWidth;
sl@0: 		}
sl@0: 	if (bmpSize2.iHeight < bmpSize.iHeight)
sl@0: 		{
sl@0: 		bmpSize.iHeight = bmpSize2.iHeight;
sl@0: 		}
sl@0: 	
sl@0: 	TRgb c1;
sl@0: 	TRgb c2;
sl@0: 	for (TInt y=0; y < bmpSize.iHeight; y++)
sl@0: 		{
sl@0: 		for (TInt x=0; x < bmpSize.iWidth; x++)
sl@0: 			{
sl@0: 			TPoint point(x, y);
sl@0: 			aBitmap1->GetPixel(c1, point);
sl@0: 			aBitmap2->GetPixel(c2, point);
sl@0: 			if (c1 != c2)
sl@0:        			{
sl@0:        			iPixel1 = c1.Value();
sl@0:        			iPixel2 = c2.Value();
sl@0:        			iPixelPos = point;
sl@0: 				return EFalse;
sl@0: 				}
sl@0: 			}		
sl@0: 		}
sl@0: 	return ETrue;		
sl@0: 	}
sl@0: void CComparison::Verify(CFbsBitmap * aServerBmp)
sl@0: 	{	
sl@0: 	//Copy the currentBmp to lastBmp
sl@0: 	TInt dataStride = iBitmap[iCurrentBmp]->DataStride();
sl@0: 	TInt sizeInByte = dataStride * iBitmap[iCurrentBmp]->SizeInPixels().iHeight;
sl@0: 	TUint32* bitmapAddressSource = iBitmap[iCurrentBmp]->DataAddress();
sl@0: 	TUint32* bitmapAddressTarget = iBitmap[iLastBmp]->DataAddress();
sl@0: 	memcpy(bitmapAddressTarget, bitmapAddressSource, sizeInByte);
sl@0: 	// This method is only used by the animation and sprite windows; ignores 
sl@0: 	// comparisons for times that are too close to the sprite change. But as the 
sl@0: 	// difference error drifts, there is no point relying on it.
sl@0: 	if (!WindowsReadyForVerification())
sl@0: 		{
sl@0: 		Tick();
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	if (iWasOk)
sl@0: 		{
sl@0: 		DrawBitmap();
sl@0: 		
sl@0: 		const TBool bmpMatch = BitmapsMatch(aServerBmp, iBitmap[iCurrentBmp]);
sl@0: 		REPORT_EVENT( bmpMatch );
sl@0: 		
sl@0: #ifdef __WINSCW__		
sl@0: 		if ( !bmpMatch )
sl@0: 			{
sl@0: 			__DEBUGGER();
sl@0: 			}
sl@0: #endif
sl@0: 		
sl@0: 		if (!iData.saveOnlyDifferent || !bmpMatch)
sl@0: 			{
sl@0: 			TBuf<128> fileName;
sl@0: 			fileName.Append(iData.loggingPath);
sl@0: 			fileName.Append(_L("Stresslet_Comparison_"));
sl@0: 			if (iData.saveOnlyDifferent)
sl@0: 				{
sl@0: 				fileName.AppendNumFixedWidthUC((TUint)iErrorNum, EDecimal, 3);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				fileName.AppendNumFixedWidthUC((TUint)iTestNum, EDecimal, 3);
sl@0: 				}
sl@0: 			TInt baseLength = fileName.Length();
sl@0: 			
sl@0: 			//previous is saved only when saving different bitmaps 
sl@0: 			//otherwise it is always the same as the previous expected
sl@0: 			if (iData.saveOnlyDifferent)
sl@0: 				{
sl@0: 				fileName.Append(_L("_Previous.mbm"));
sl@0: 				__ASSERT_ALWAYS(KErrNone == iBitmap[iLastBmp]->Save(fileName), Panic(EPanic6));
sl@0: 				}
sl@0: 			
sl@0: 			fileName.SetLength(baseLength);
sl@0: 			fileName.Append(_L("_Expected.mbm"));
sl@0: 			__ASSERT_ALWAYS(KErrNone == iBitmap[iCurrentBmp]->Save(fileName), Panic(EPanic7));
sl@0: 			
sl@0: 			fileName.SetLength(baseLength);
sl@0: 			fileName.Append(_L("_Screen.mbm"));
sl@0: 			__ASSERT_ALWAYS(KErrNone == aServerBmp->Save(fileName), Panic(EPanic8));
sl@0: 
sl@0: 			//store difference between expected and screen bitmaps (XOR image)
sl@0: 			if (iData.saveDifferenceBitmap)
sl@0: 				{
sl@0: 				iBmpGc->Activate(iDifferenceDevice);
sl@0: 				iBmpGc->Reset();
sl@0: 				iBmpGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
sl@0: 				iBmpGc->BitBlt(TPoint(0,0), iBitmap[iCurrentBmp]);
sl@0: 				iBmpGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);
sl@0: 				iBmpGc->BitBlt(TPoint(0,0), aServerBmp);
sl@0: 				iBmpGc->Reset();
sl@0: 				fileName.SetLength(baseLength);
sl@0: 				fileName.Append(_L("_Difference.mbm"));
sl@0: 				__ASSERT_ALWAYS(KErrNone == iDifferenceBitmap->Save(fileName), Panic(EPanic19));
sl@0: 				}
sl@0: 			
sl@0: 			fileName.SetLength(baseLength);
sl@0: 			fileName.Append(_L("_info.txt"));
sl@0: 			RFile file;
sl@0: 			TInt err = file.Create(iFs, fileName, EFileWrite);
sl@0: 			if (err != KErrNone)
sl@0: 				err = file.Replace(iFs, fileName, EFileWrite);
sl@0: 			if (err == KErrNone)
sl@0: 				{
sl@0: 				TBuf8<128> info;
sl@0: 				info.Append(_L8("Seed = "));
sl@0: 				info.AppendNum(iFirstSeed);
sl@0: 				info.Append(_L8("\n"));
sl@0: 				file.Write(info);
sl@0: 				info.SetLength(0);
sl@0: 				TTime now;
sl@0: 				now.UniversalTime();
sl@0: 				info.Append(_L8(" Runtime = "));
sl@0: 				info.AppendNum(now.MicroSecondsFrom(iStartTime).Int64() / 1000);
sl@0: 				info.Append(_L8(" ms\r\n"));
sl@0: 				file.Write(info);
sl@0: 				info.SetLength(0);
sl@0: 				info.Append(_L8("Action = ["));
sl@0: 				info.AppendNum((TInt64)iAct);
sl@0: 				info.Append(_L8("]   Mode = ["));
sl@0: 				info.AppendNum((TInt64)iMode);
sl@0: 				info.Append(_L8("]   Test = ["));
sl@0: 				info.AppendNum((TInt64)iTestNum);
sl@0: 				info.Append(_L8("]\r\n"));
sl@0: 				file.Write(info);
sl@0: 				info.SetLength(0);
sl@0: 				info.Append(_L8("Pixel at ["));
sl@0: 				info.AppendNum((TInt64)iPixelPos.iX);
sl@0: 				info.Append(_L8(","));
sl@0: 				info.AppendNum((TInt64)iPixelPos.iY);
sl@0: 				info.Append(_L8("] mismatch screen 0x"));
sl@0: 				info.AppendNum((TInt64)iPixel1, EHex);
sl@0: 				info.Append(_L8(" != bitmap 0x"));
sl@0: 				info.AppendNum((TInt64)iPixel2, EHex);
sl@0: 				info.Append(_L8("\r\n\r\n"));
sl@0: 				file.Write(info);
sl@0: 				
sl@0: 				TPoint zero(0,0);
sl@0: 				for (TInt num = 0; num < iWindows.Count(); ++num)
sl@0: 					{
sl@0: 					iWindows[num]->Dump(file, zero, 0, iBehaviour.iWin);
sl@0: 					info.SetLength(0);
sl@0: 					info.Append(_L8("\r\n"));
sl@0: 					file.Write(info);
sl@0: 					}				
sl@0: 				file.Close();
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				//failed create logfile
sl@0: 				__ASSERT_ALWAYS(EFalse, Panic(EPanic9));
sl@0: 				}
sl@0: 			
sl@0: 			if (!bmpMatch)
sl@0: 				{
sl@0: 				++iErrorNum;
sl@0: 				}
sl@0: 			}
sl@0: 		}	
sl@0: 	if ((iTestNum > iData.maxRunCycles && iNumWindowsLeft == 0) || !iWasOk)
sl@0: 		{
sl@0: 		iMustConclude = ETrue;
sl@0: 		}
sl@0: 	iTimer->After(iData.period);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Write information(eg. seed, starttime, endtime and time elapse) to Stresslet_Log.txt file 
sl@0: */
sl@0: void CComparison::WriteLog()
sl@0: 	{
sl@0: 	TBuf<128> fileName;
sl@0: 	fileName.Append(iData.loggingPath);
sl@0: 	fileName.Append(_L("Stresslet_Log.txt"));
sl@0: 	RFile file;
sl@0: 	TInt err = file.Create(iFs, fileName, EFileWrite);
sl@0: 	if (err != KErrNone)
sl@0: 		{
sl@0: 		err = file.Replace(iFs, fileName, EFileWrite);
sl@0: 		}
sl@0: 	if (err == KErrNone)
sl@0: 		{
sl@0: 		TBuf8<128> info;
sl@0: 		info.Append(_L8("Seed = "));
sl@0: 		info.AppendNum(iFirstSeed);
sl@0: 		info.Append(_L8("\r\n"));
sl@0: 		file.Write(info);
sl@0: 		info.SetLength(0);
sl@0: 		TBuf<40> dateTimeString;
sl@0: 	    _LIT(KFormat2,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S.%C%:3");
sl@0: 	    iStartTime.FormatL(dateTimeString,KFormat2);
sl@0: 		info.Append(_L8("StartTime = "));
sl@0: 		info.Append(dateTimeString);
sl@0: 		info.Append(_L8("\r\n"));
sl@0: 		TTime now;
sl@0: 		now.UniversalTime();
sl@0: 		now.FormatL(dateTimeString,KFormat2);
sl@0: 		info.Append(_L8("Endtime = "));
sl@0: 		info.Append(dateTimeString);
sl@0: 		info.Append(_L8("\r\n"));
sl@0: 		info.Append(_L8("Elapse = "));
sl@0: 		info.AppendNum(now.MicroSecondsFrom(iStartTime).Int64() / 1000);
sl@0: 		info.Append(_L8(" ms\r\n"));
sl@0: 		file.Write(info);
sl@0: 		file.Close();
sl@0: 		}
sl@0: 	}
sl@0: /**
sl@0:  Returns true if all visible windows are ready for verification
sl@0:  */
sl@0: TBool CComparison::WindowsReadyForVerification() const
sl@0: 	{
sl@0: 	TBool res = ETrue;
sl@0: 	TInt idx = 0;
sl@0: 	while ( idx < iWindows.Count() && res )
sl@0: 		{
sl@0: 		if ( iWindows[ idx ]->IsVisible() )
sl@0: 			{
sl@0: 			res = iWindows[ idx ]->QueryReadyForVerification();
sl@0: 			}
sl@0: 		idx++;
sl@0: 		}
sl@0: 	return res;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Calls all windows to draw themselves on a bitmap
sl@0:  */
sl@0: void CComparison::DrawBitmap()
sl@0: 	{
sl@0: 	iBmpGc->Activate(iDevice[iCurrentBmp]);
sl@0: 	iBmpGc->Reset();
sl@0: 
sl@0: 	// clear background area
sl@0: 	iBmpGc->SetPenStyle(CGraphicsContext::ENullPen);
sl@0: 	iBmpGc->SetBrushColor(KRgbBlack);
sl@0: 	iBmpGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
sl@0: 
sl@0: 	TPoint origin(0,0);
sl@0: 	TRect rect(origin, TSize(iData.windowWidth, iData.windowHeight));
sl@0: 
sl@0: 	//create a region containing all screen, subtract all visible windows
sl@0: 	RRegion backClipping(rect);
sl@0: 	if (!iData.clearAllBackground)
sl@0: 		{
sl@0: 		for (TInt num = 0; num < iWindows.Count(); ++num)
sl@0: 			{
sl@0: 			if (iWindows[num]->IsVisible())
sl@0: 				iWindows[num]->SubSelfFromRegion(backClipping, rect, origin);
sl@0: 			}
sl@0: 		}
sl@0: 	
sl@0: 	//clip drawing to background only & clear
sl@0: 	iBmpGc->SetClippingRegion(backClipping);
sl@0: 	iBmpGc->DrawRect(rect);
sl@0: 	//go back to no clipping
sl@0: 	iBmpGc->CancelClipping();
sl@0: 	backClipping.Close();
sl@0: 
sl@0: 	for (TInt num = 0; num < iWindows.Count(); ++num)
sl@0: 		{
sl@0: 		if (iWindows[num]->IsVisible())
sl@0: 			{
sl@0: 			iWindows[num]->ClearBitmapBackground(iBmpGc, rect, origin);
sl@0: 			iWindows[num]->DrawBitmap(iBmpGc, rect, origin);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: void CComparison::SetVerifyTick(TUint32 aTick)
sl@0: 	{
sl@0: 	for (TInt num = 0; num < iWindows.Count(); ++num)
sl@0: 		{
sl@0: 		if (iWindows[num]->IsVisible())
sl@0: 			iWindows[num]->SetVerifyTick(aTick);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: CComparison::~CComparison()
sl@0: 	{
sl@0: 	iFs.Close();
sl@0: 	
sl@0: 	if (iBackground)
sl@0: 		{
sl@0: 		iBackground->Close();
sl@0: 		delete iBackground;
sl@0: 		}	
sl@0: 	
sl@0: 	iWindows.ResetAndDestroy();
sl@0: 	if (iWinGroup)
sl@0: 		{
sl@0: 		iWinGroup->Close();
sl@0: 		delete iWinGroup;
sl@0: 		}
sl@0: 
sl@0: 	delete iOneShotCompare; //delayed compare
sl@0: 
sl@0: 	delete iDifferenceDevice;
sl@0: 	delete iDifferenceBitmap;
sl@0: 	
sl@0: 	for (TInt bmp = 0; bmp < 2; ++bmp)
sl@0: 		{
sl@0: 		delete iDevice[bmp];
sl@0: 		delete iBitmap[bmp];
sl@0: 		}
sl@0: 	
sl@0: 	delete iBmpGc;
sl@0: 	delete iTimer;
sl@0: 
sl@0: 	delete iScreenBitmap;
sl@0: 	delete iScreen;
sl@0: 	}