// 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 - Internal Symbian test code 

 */

 #include "tmultiptreventhandlingperf.h"

 #include <hal.h>

 _LIT(KPerformanceTimingChunk, "PerformanceTimingChunk");

 // Number of iterations for eventset

 const TInt KNumOfIterations = 100;

 // Maximum descriptor length for results

 const TInt KMaxDescLength = 528;

 // Static variables used for synchronisation between threads

 GLDEF_D TInt NumOfEventsAdded = 0;

 GLDEF_D RMutex Mutex;

 GLDEF_D RCondVar ConVar;

 void MultiPtrPerfPanic(TInt aPanic)

 	{

 	User::Panic(_L("MultiPterEventHanldingPerformancePanic"), aPanic);

 	}

 // This function opens the chunk and adds the failure description followed by '*'

 TInt CMultiPtrPerfTestControl::Failed(TPoint3D aExp3DPoint, TPoint3D aActual3DPoint, TInt aErrorCode, TInt aExpPtrNum, TInt aActPtrNum)

 	{

 	TInt ret = iChunk.OpenGlobal(KPerformanceTimingChunk, ETrue);

 	if (ret != KErrNone)

 		{

 		return ret;

 		}

 	TUint8* desPtr = iChunk.Base() + iChunkOffset;

 	TPtr8 ptrDes(desPtr, 0, KMaxDescLength);

 	TBuf<80> buf;

 	if (aExpPtrNum != aActPtrNum)

 		{

 		_LIT(KFailedPointerNum, "Failed Expected Pointer Num = %d Actual Pointer Num = %d*");

 		buf.AppendFormat(KFailedPointerNum, aExpPtrNum, aActPtrNum);

 		ptrDes.Append(buf);

 		} 

 	else if (aErrorCode != KErrNone)

 		{

 		_LIT(KFailedErrorCode, "Failed Errorcode = %d*");

 		buf.AppendFormat(KFailedErrorCode, aErrorCode);

 		ptrDes.Append(buf);

 		}

 	else

 		{

 		_LIT(KFailedWrongCoord, "Failed Coordinates Expected = [%d, %d, %d] Actual = [%d, %d, %d]*");

 		buf.AppendFormat(KFailedWrongCoord, aExp3DPoint.iX, aExp3DPoint.iY, aExp3DPoint.iZ, aActual3DPoint.iX, aActual3DPoint.iY, aActual3DPoint.iZ);

 		ptrDes.Append(buf);

 		}

 	iChunk.Close();

 	return ret;

 	}

 // This function opens the chunk and adds a pointer event not supported message followed by '#'

 TInt CMultiPtrPerfTestControl::PointerEventsNotSupported()

     {

     iPointerEventNotSupported = ETrue;

     TInt ret = iChunk.OpenGlobal(KPerformanceTimingChunk, ETrue);

         if (ret != KErrNone)

             {

             return ret;

             }

     TUint8* desPtr = iChunk.Base() + iChunkOffset;

     TPtr8 ptrDes(desPtr, 0, KMaxDescLength);

     TBuf<80> buf;

     _LIT(KPointerEventsNotSupported, "Test Skipped As Pointer Events Are Not Supported By This Configuration#");

     buf.AppendFormat(KPointerEventsNotSupported);

     ptrDes.Append(buf);

     iChunk.Close();

     return ret;

     }

 // This function calulates the average latency, opens the chunk and appends

 // the same in descriptor form. Then close the child thread and calls function 

 // for creating new thread for events. 

 // If all the events have been tested then stops the tests

 // by calling active CActiveScheduler::Stop. 

 TInt CMultiPtrPerfTestControl::CalculateLatencyAndStartThread()

 	{

 	TInt ret = KErrNone;

 	switch (iPtrAppUi->TestCaseNum())

 		{

 		case 1:

 		case 5:

 		case 9:

 		case 13:	

 			iAverageLatency = iLatency/(4*KNumOfIterations);

 			break;

 		case 2:

 		case 6:

 		case 10:

 		case 14:

 			iAverageLatency = iLatency/(8*KNumOfIterations);

 			break;

 		case 3:

 		case 7:

 		case 11:

 		case 15:

 			iAverageLatency = iLatency/(16*KNumOfIterations);

 			break;

 		case 4:

 		case 8:

 		case 12:

 		case 16:

 			iAverageLatency = iLatency/(32*KNumOfIterations);

 			break;

 		default:

 			MultiPtrPerfPanic(EMultiPtrPerfPanicWrongTest);

 		}

 	ret = iChunk.OpenGlobal(KPerformanceTimingChunk, ETrue);

 	if (ret != KErrNone)

 		{

 		return ret;

 		}

 	TUint8* desPtr = iChunk.Base() + iChunkOffset;

 	TPtr8 ptrDes(desPtr, iLatLenInLetters, KMaxDescLength);

 	TBuf<66> buf;

 	buf.Num(iAverageLatency);

 	buf.Append(',');

 	ptrDes.Append(buf);

 	// reset the iLatency for next set of test

 	iLatency = 0;	

 	// For writing the next latency in chunk memory

 	iLatLenInLetters = ptrDes.Length();

 	iChunk.Close();

 	// Before calling the thread Function close the current thread and then call the function

 	// here when we kill the child thread it releases both mutex and condvar that it holds

 	iPtrAppUi->ChildThread().Kill(KErrNone);

 	iPtrAppUi->ChildThread().Close();

 	if (iPtrAppUi->TestCaseNum() == 16)

 		{

 		// It it is the last test case then stop the active scheduler

 		CActiveScheduler::Stop();

 		return ret;

 		}

 	else

 		{

 		return iPtrAppUi->CreateEventSimulatingThreads();

 		}

 	}

 // This function is called by Cone whenever a event is outstanding

 // Here we check if the sent event is same as the expected event in array.

 // Then resumes the thread for next set of events. When all the events are completed

 // calls CalculateLatencyAndStartThread

 void CMultiPtrPerfTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

 	{

     ASSERT(!iPointerEventNotSupported);

 	// The event that is received is (0,0,0) then it is the first event that the test code is sending

 	const TAdvancedPointerEvent* advancedPointerEvent = aPointerEvent.AdvancedPointerEvent();

 	if (iPtrAppUi->TestCaseNum() == 0)

 		{

 		if (advancedPointerEvent->PointerNumber() == 0 && advancedPointerEvent->Position3D() == TPoint3D())

 			{

 			iPtrAppUi->CreateEventSimulatingThreads();

 			return;

 			}

 		else

 			{

 			return;	// ignore other events before starting the tests

 			}

 		}

 	// Get the current time.

 	// Subtract from the test start time.

 	TTime currentTime;

 	currentTime.UniversalTime();

 	TInt64 curTime64 = currentTime.Int64();

 	TInt timeSinceTestStart = curTime64 - iPtrAppUi->TestStartTime();

 	// Get the event, get the time stored in Z corodinate

 	// Then subtract the calculated time from Z coordinate

 	iLatency += timeSinceTestStart - advancedPointerEvent->ProximityAndPressure(); 

 	// Get the current event from buffer and compare it with got event

 	TAdvancedPointerEvent expectedPtrEvent;

 	if(0 == iEventBuffer.Remove(&expectedPtrEvent))

 		{

 		iPtrAppUi->Failed(TPoint3D(), TPoint3D(), KErrNotFound);

 		return;

 		}

 	// Here Z corodinate is not checked.

 	if (expectedPtrEvent.iPosition != advancedPointerEvent->iPosition)

 		{

 		iPtrAppUi->Failed(expectedPtrEvent.Position3D(), advancedPointerEvent->Position3D(), KErrNone);

 		return;

 		}

 	if (expectedPtrEvent.PointerNumber() != advancedPointerEvent->PointerNumber())

 		{

 		iPtrAppUi->Failed(TPoint3D(), TPoint3D(), KErrNone, expectedPtrEvent.PointerNumber(), advancedPointerEvent->PointerNumber());

 		return;

 		}

 	iPtrAppUi->DecrementEventCount();

 	NumOfEventsAdded--;

 	// Event count is zero when all the events have been tested

 	if (iPtrAppUi->EventCount() == 0)

 		{

 		TInt ret = CalculateLatencyAndStartThread(); 

 		if (ret != KErrNone)

 			{

 			iPtrAppUi->Failed(TPoint3D(), TPoint3D(), ret);

 			return;

 			}

 		}

 	else if (NumOfEventsAdded == 0) 

 		{

 		ConVar.Signal();

 		}

 	}

 void CMultiPtrPerfTestControl::AddExpectedEvent(TAdvancedPointerEvent& aExpEvent)

 	{

 	iEventBuffer.Add(&aExpEvent);

 	}

 CMultiPtrPerfTestControl::~CMultiPtrPerfTestControl()

 	{

 	iChunk.Close();

 	}

 void CMultiPtrPerfTestControl::ConstructL()

 	{

     iPointerEventNotSupported = EFalse;

 	ConstructL(TPoint(), ControlEnv()->ScreenDevice()->SizeInPixels());

 	}

 void CMultiPtrPerfTestControl::ConstructL(TPoint aOrigin, TSize aSize)

 	{

     iEventBuffer.SetLengthL(EEventBufferSize);

     iPtrAppUi = static_cast<CMultiPtrPerfTestAppUi*>(ControlEnv()->AppUi());

     CreateWindowL();

     Window().EnableAdvancedPointers();

     EnableDragEvents();

     SetExtent(aOrigin, aSize);

     ActivateL();

  	// Get the cmdline argument of this process in descriptor

  	// convert the descriptor to number and store it in iChunkOffset

  	TBuf<128> buf;

  	User::CommandLine(buf);

  	TLex lex(buf);

  	User::LeaveIfError(lex.Val(iChunkOffset));

 	}

 // This function gets the current time and subtracts it from the time when the whole test was started.

 // Simulates the event and suspends the thread if aWaitAfterEachEvent is ETrue

 // If aWaitAfterEachEvent is EFalse then it suspends the thread after each set of event i,e after 4, 8, 16 and 32 events 

 void SimulatePointerEvents(TInt aCount, CMultiPtrPerfTestAppUi* appUi, TBool aMultiPtrEvent = EFalse, TBool aWaitAfterEachEvent = ETrue)

 	{

 	TRawEvent rawEvent;

 	TPoint ptrPos;

 	TTime currentTime;

 	TInt64 testStartTime = appUi->TestStartTime();

 	TInt ptrNum = 0;

 	TInt ptrMax = 0;

 	// HAL as already been tested at the start of these tests. So no need to test once again

 	HAL::Get(HALData::EPointerNumberOfPointers, ptrMax);

 	appUi->SetNumberOfEvents((KNumOfIterations*aCount)-1);

 	// For testing time taken for each event and for each set of events we make use of RMutex and RConvar.

 	// RMutex is used not to preempt this thread until events has been added

 	// RConVar is used to hold this thread until the events have been tested

 	for (TInt loop = 0; loop < KNumOfIterations; loop++)

 		{

 		ptrNum = 0;

 		ptrPos.iX = ptrPos.iY = 0;

 		Mutex.Wait();

 		for (TInt count = 0; count < aCount/2; count++, ptrNum++)

 			{

 			if (ptrNum >= ptrMax)

 				{

 				ptrNum = 0;

 				}			

 			ptrPos.iX += 2;

 			ptrPos.iY += 1;

 			TWsEvent event;

 			event.InitAdvancedPointerEvent(TPointerEvent::EButton1Down, 0, TPoint3D(ptrPos.iX, ptrPos.iY, 0), (aMultiPtrEvent ? ptrNum : 0));

 			appUi->AddExpectedEvent(*event.Pointer());

 			currentTime.UniversalTime();

 			TInt64 curTime64 = currentTime.Int64();

 			TInt timeSinceTestStart = curTime64 - testStartTime;

 			rawEvent.Set(TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, timeSinceTestStart, (aMultiPtrEvent ? ptrNum : 0));

 			UserSvr::AddEvent(rawEvent);

 			NumOfEventsAdded++;

 			if (aWaitAfterEachEvent)

 				{

 				while(NumOfEventsAdded)

 					ConVar.Wait(Mutex);

 				}

 			event.InitAdvancedPointerEvent(TPointerEvent::EButton1Up, 0, TPoint3D(ptrPos.iX, ptrPos.iY, 0), (aMultiPtrEvent ? ptrNum : 0));

 			appUi->AddExpectedEvent(*event.Pointer());

 			currentTime.UniversalTime();

 			curTime64 = currentTime.Int64();

 			timeSinceTestStart = curTime64 - testStartTime;

 			rawEvent.Set(TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, timeSinceTestStart, (aMultiPtrEvent ? ptrNum : 0));

 			UserSvr::AddEvent(rawEvent);

 			NumOfEventsAdded++;

 			if (aWaitAfterEachEvent)

 				{

 				while(NumOfEventsAdded)

 					ConVar.Wait(Mutex);

 				}

 			}

 		if (!aWaitAfterEachEvent)

 			{

 			while(NumOfEventsAdded)

 				ConVar.Wait(Mutex);

 			}

 		Mutex.Signal();

 		}

 	}

 TInt EventSimulatingThreadStartFunc(TAny* aAny)

 	{

 	CMultiPtrPerfTestAppUi* appUi = static_cast<CMultiPtrPerfTestAppUi*>(aAny);

 	switch(appUi->TestCaseNum()++)

 		{

 		case 0:

 			SimulatePointerEvents(4, appUi);

 			break;

 		case 1:

 			SimulatePointerEvents(8, appUi);

 			break;

 		case 2:

 			SimulatePointerEvents(16, appUi);

 			break;

 		case 3:

 			SimulatePointerEvents(32, appUi);

 			break;

 		case 4:

 			SimulatePointerEvents(4, appUi, ETrue);

 			break;

 		case 5:

 			SimulatePointerEvents(8, appUi, ETrue);

 			break;

 		case 6:

 			SimulatePointerEvents(16, appUi, ETrue);

 			break;

 		case 7:

 			SimulatePointerEvents(32, appUi, ETrue);

 			break;

 		case 8:

 			SimulatePointerEvents(4, appUi, EFalse, EFalse);

 			break;

 		case 9:

 			SimulatePointerEvents(8, appUi, EFalse, EFalse);

 			break;

 		case 10:

 			SimulatePointerEvents(16, appUi, EFalse, EFalse);

 			break;

 		case 11:

 			SimulatePointerEvents(32, appUi, EFalse, EFalse);

 			break;

 		case 12:

 			SimulatePointerEvents(4, appUi, ETrue, EFalse);

 			break;

 		case 13:

 			SimulatePointerEvents(8, appUi, ETrue, EFalse);

 			break;

 		case 14:

 			SimulatePointerEvents(16, appUi, ETrue, EFalse);

 			break;

 		case 15:

 			SimulatePointerEvents(32, appUi, ETrue, EFalse);

 			break;		

 		default:

 			break;

 		}

 	return KErrNone;

 	}

 TInt CMultiPtrPerfTestAppUi::CreateEventSimulatingThreads()

 	{

 	// Depending upon the iTestCase number create thread and simulate events in that thread function

 	TInt ret = KErrNone;

 	_LIT(KSimulateEventsThread, "Events simulating thread");

 	ret = iThread.Create(KSimulateEventsThread, EventSimulatingThreadStartFunc, KDefaultStackSize, 0x4000, 0x4000, this, EOwnerThread);

 	if (ret == KErrNone)

 		{

 		iThread.Resume();

 		}

 	return ret;

 	}

 void CMultiPtrPerfTestAppUi::AddExpectedEvent(TAdvancedPointerEvent& aExpEvent)

 	{

 	iControl->AddExpectedEvent(aExpEvent);

 	}

 void CMultiPtrPerfTestAppUi::Failed(TPoint3D aExp3DPoint, TPoint3D aActual3DPoint, TInt aErrorCode, TInt aExpPtrNum, TInt aActPtrNum)

 	{

 	// Write error description in the memory of shared chunk 

 	// so that the main performance test just stops by saying that it failed

 	// and then stop the active scheduler.

 	iControl->Failed(aExp3DPoint, aActual3DPoint, aErrorCode, aExpPtrNum, aActPtrNum);

 	CActiveScheduler::Stop();

 	}

 void CMultiPtrPerfTestAppUi::PointerEventsNotSupported()

     {

     // Write a pointer events not supported message in the memory of shared chunk 

     // so that the main performance test just skips the pointer test

     iControl->PointerEventsNotSupported();

     }

 CMultiPtrPerfTestAppUi::CMultiPtrPerfTestAppUi()

 	{

 	}

 CMultiPtrPerfTestAppUi::~CMultiPtrPerfTestAppUi()

 	{

 	RemoveFromStack(iControl);

 	delete iControl;

 	}

 void CMultiPtrPerfTestAppUi::ConstructL()

 	{

 	CCoeAppUi::ConstructL();

 	TTime testStartTime;

 	testStartTime.UniversalTime();

 	iTestStartTime = testStartTime.Int64();

 	iControl = new (ELeave) CMultiPtrPerfTestControl();

 	iControl->ConstructL();

 	AddToStackL(iControl);

 	}

 void ConstructControlEnvironmentL(CCoeEnv* aCoe)

 	{

  	aCoe->ConstructL();

  	CMultiPtrPerfTestAppUi* appUi=new(ELeave) CMultiPtrPerfTestAppUi();

  	CleanupStack::PushL(appUi);			// If it leaves after this then there is no way of deleting the appui

  	aCoe->SetAppUi(appUi);				// So pushed it on to cleanup stack

  	aCoe->WsSession().SetAutoFlush(ETrue);

  	appUi->ConstructL();

  	User::LeaveIfError(Mutex.CreateLocal(EOwnerProcess));

  	User::LeaveIfError(ConVar.CreateLocal(EOwnerProcess));

  	CleanupStack::Pop(appUi);

 	}

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

 	CCoeEnv* coe = new CCoeEnv;

 	if (!coe)

 		{

 		return KErrNoMemory; 

 		}

 	TRAPD(err, ConstructControlEnvironmentL(coe));

 	if (err != KErrNone)

 		{

 		delete coe;

 		}

 	else	// If KErrNone then no need to delte coe as it is taken care by ConEnv

 		{

         // Check whether the configuration supports pointer events.

         // If it dosn't support pointer events then the pointer cursor area will be empty,

         // in this case skip the test and inform the test framework that the test has been skipped

         TRect pointerCursorArea = coe->WsSession().PointerCursorArea();

         if(pointerCursorArea.IsEmpty())

             {

             RDebug::Printf("PointerCursorArea is Empty");

             CMultiPtrPerfTestAppUi* appUi = static_cast<CMultiPtrPerfTestAppUi*>(coe->AppUi());

             appUi->PointerEventsNotSupported();

             }

         else

             {

             // First event which starts the test from HandlePointerEventL

             TRawEvent rawEvent;

             rawEvent.Set(TRawEvent::EButton1Down, 0, 0, 0, 0);

             UserSvr::AddEvent(rawEvent);

             coe->ExecuteD();

             }

 		Mutex.Close();

 		ConVar.Close();

 	 	}

 	__UHEAP_MARKEND;

 	return err;

 	}