// Copyright (c) 1996-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 "TMESSAGE.H"

 const TInt KTotalNumberOfTestMessages=5;

 const TInt KMaxNumOfMessagesInActiveQueue=21;

 const TInt KMaxNumOfSyncMessages=25;

 const TInt KNumOfTestCases=7;

 TInt MsgCountCheck=0;

 TInt SyncSendReceiveCount=0;

 TUid UidAtFirstLocation;

 TUid UidAtLastLocation;

 TBool TestNeedsExtraCheck=EFalse;

 CTMessage::CTMessage(CTestStep* aStep) : CTWsGraphicsBase(aStep), iSyncSendReceiveFlag(EFalse), iCounter(-1), iState(0)

 	{

 	}

 TInt CTMessage::CreateAndSendMessages(TInt aCount,TInt aNoOfMessages)

 	{

 	CMessageReceiver* msgReceiver=(*iMessageReceiver)[iState];

 	TInt identifer=msgReceiver->GroupWin()->Identifier();

 	TInt length=aCount*2;

 	TUint8 modificationFactor=(TUint8 )(aCount*3+1);

 	TUint8 msgValue=0;

 	if(!iSyncSendReceiveFlag && TestNeedsExtraCheck)

 		{

 		if(aCount==0)

 			{

 			UidAtFirstLocation=TUid::Uid(length+(modificationFactor<<24));

 			}

 		else if(aCount==(aNoOfMessages-1))

 			{

 			UidAtLastLocation=TUid::Uid(length+(modificationFactor<<24));

 			}

 		}

 	iMsg->Des().Zero();

 	for(TInt index=0;index<length;index++)

 		{

 		msgValue=(TUint8)(msgValue+modificationFactor);

 		iMsg->Des().Append(msgValue);

 		}

 	return TheClient->iWs.SendMessageToWindowGroup(identifer, TUid::Uid(length+(modificationFactor<<24)), *iMsg);

 	}

 TInt CTMessage::CallbackLowPriority(TAny* aMessageTest)

 	{

 	return static_cast<CTMessage*>(aMessageTest)->SendSyncMessages();

 	}

 TInt CTMessage::SendSyncMessages()

 	{

 	if(iSyncSendReceiveFlag && iCounter++<SyncSendReceiveCount)

 		{

 		TEST(CreateAndSendMessages(iCounter,SyncSendReceiveCount)==KErrNone);

 		return ETrue;

 		}

 	TheClient->iWs.NumWindowGroups();		//Make sure all asyncronus calls have been processed

 	CTEventBase& eventHandler=*TheClient->EventHandler();

 	if (eventHandler.iStatus.Int()==KRequestPending)

 		CActiveScheduler::Stop();

 	else

 		return ETrue;

 	return EFalse;

 	}

 CTMessage::~CTMessage()

 	{

 	iMessageReceiver->ResetAndDestroy();

 	iMessageReceiver->Close();

 	delete iMessageReceiver;

  	iLowPriorityObject->Cancel();

 	delete iLowPriorityObject;

 	iLowPriorityObject=NULL;

 	delete iMsg;

 	}

 void CTMessage::ConstructL()

 	{

 	iLowPriorityObject= new(ELeave) CLowPriorityIdle();

 	iMessageReceiver=new(ELeave) RPointerArray<CMessageReceiver>(KNumOfTestCases);

 	iMsg=HBufC8::NewL(KMaxNumOfSyncMessages*2);

 	for(TInt index=0;index<KNumOfTestCases;index++)

 		{

 		CMessageReceiver* messageReceiver=new(ELeave) CMessageReceiver(TheClient, this);

 		messageReceiver->ConstructL();

 		iMessageReceiver->AppendL(messageReceiver);

 		}

 	}

 CLowPriorityIdle::CLowPriorityIdle() : CIdle(EPriorityIdle)

 	{

 	CActiveScheduler::Add(this);

 	}

 TInt CLowPriorityIdle::RunError(TInt /*aError*/)

 	{

 	CActiveScheduler::Stop();

 	return KErrNone;

 	}

 LOCAL_C TInt DoPanicTest(TInt aInt, TAny *)

 	{

 	switch(aInt)

 		{

 		case 1:

 			User::Panic(KWSERV,EWservPanicGcActive);

 			break;

 		}

 	return(EWsExitReasonBad);

 	}

 CMessageReceiver::CMessageReceiver(CTClient *aClient, CTMessage *aTMessage) : CTWindowGroup(aClient), iMsgCount(0)

 	{

 	iTMessage = aTMessage;

 	}

 #define MESSAGES_READ 1		//Change to 2 to test the 16-bit functions too.

 void CMessageReceiver::MessageReady(const TWsEvent& aEvent)

 	{

 	iTMessage->OnMessageReceived(aEvent, iMsgCount);

 	}

 void CTMessage::OnMessageReceived(const TWsEvent& aEvent, TInt& aMsgCount)

 	{

 	aMsgCount++;

 	if(aMsgCount>MsgCountCheck)

 		{

 		return;

 		}

 	if (MESSAGES_READ*(aMsgCount/MESSAGES_READ)<aMsgCount)

 		{

 		return;

 		}

 	TPtr8 msgPtr(NULL,0);

 	//TPtr16 msgPtr2(NULL,0);

 	TUid uid;

 	TInt retValue=TheClient->iWs.FetchMessage(uid, msgPtr, aEvent);

 	TEST(retValue==KErrNone);

 	//GroupWin()->FetchMessage(uid, msgPtr2);

 	if(TestNeedsExtraCheck)

 		{

 		TEST(uid==(aMsgCount==1?UidAtFirstLocation:UidAtLastLocation));

 		}

 	TInt msgLength=(uid.iUid)&0xFFFFFF;

 	TUint8 uidFactor=(TUint8)((uid.iUid&0xFF000000)>>24);

 	TBool retVal = msgPtr.Length()==msgLength;

 	TEST(retVal);

 	if (!retVal)

 		INFO_PRINTF3(_L("msgPtr.Length()==msgLength  - Expected: %d, Actual: %d"), msgLength, msgPtr.Length());

 	TUint8 check=0;

 	for(TInt index=0;index<msgLength;index++)

 		{

 		check=(TUint8)(check+uidFactor);

 		retVal = msgPtr[index]==check;

 		TEST(retVal);

 		if (!retVal)

 			INFO_PRINTF3(_L("msgPtr[index]==check  - Expected: %d, Actual: %d"), check, msgPtr[index]);

 		}

 	/*CTestBase::Test(msgPtr.Length()/2==msgPtr2.Length());

 	TPtrC8 data2((const TUint8*) msgPtr2.Ptr(),msgPtr2.Size());

 	CTestBase::Test(data2==msgPtr.Left(msgPtr2.Size()));*/

 	User::Free((TAny *)msgPtr.Ptr());

 	//User::Free((TAny *)msgPtr2.Ptr());

 	}

 void CTMessage::TestPanicsL()

 	{	

 	TEST(iTest->TestWsPanicL(&DoPanicTest,EWservPanicGcActive,1));

 	iTest->CloseAllPanicWindows();

 	}

 void CTMessage::MessageTests(TInt aNoOfMessages,TInt aMsgCountCheck,TBool aSyncSendReceiveFlag,TBool aTestNeedsExtraCheck)

 	{

 	iSyncSendReceiveFlag=aSyncSendReceiveFlag;

 	TestNeedsExtraCheck=aTestNeedsExtraCheck;

 	MsgCountCheck=aMsgCountCheck;

 	iLowPriorityObject->Start(TCallBack(CallbackLowPriority,this));

 	if(iSyncSendReceiveFlag)

 		{

 		//Messages will be sent and received one by one using the function SendSyncMessages().

 		CActiveScheduler::Start();

 		}

 	else

 		{

 		for(TInt count=0;count<aNoOfMessages;count++)

 			{

 			TInt err=CreateAndSendMessages(count,aNoOfMessages);

 			TEST(err==KErrNone);

 			if (err!=KErrNone)

 				{

 				_LIT(KLog,"Error %d when trying to send Messages");

 				LOG_MESSAGE2(KLog,err);

 				}

 			}

 		CActiveScheduler::Start();

 		TInt msgCount=(*iMessageReceiver)[iState]->MessageCount();

 		TEST(msgCount==MsgCountCheck);

 		if (msgCount!=MsgCountCheck)

 			{

 			_LIT(KLog,"Number of messages recieved=%d expected=%d");

 			LOG_MESSAGE3(KLog,msgCount,MsgCountCheck);

 			}

 		}

 	}

 /**

  Test delivery group messages in case when event queue is overflow

  */

 void CTMessage::TestMessageQueueOverflowL()

 	{

 	const TInt numMaxMessages = 60;

 	TInt numWasteMessages = 0;

 	TInt numWgMessages = 5;

 	TInt gotRealWasteMessages = 0;

 	TInt gotRealWgMessages = 0;

 	const TInt oneSecond = 1000000;

 	const TInt allPossibleMessages = 500;

 	RWsSession senderWsSession;

 	RWindowGroup senderGroupWin;

 	TInt sndrHanGrpWin = 7777;

 	RWsSession receiverWsSession;

 	RWindowGroup receiverGroupWin;

 	TInt rcvrHanGrpWin = 8888;

 	TRequestStatus testStatus;

 	TRequestStatus timerStatus;

 	TWsEvent wasteEvent;

 	TWsEvent event;

 	RTimer timer;

 	timer.CreateLocal();

 	CleanupClosePushL(timer);

 	// Create sender WsSession and the window group

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

 	CleanupClosePushL(senderWsSession);

 	senderGroupWin = RWindowGroup(senderWsSession);

 	User::LeaveIfError(senderGroupWin.Construct(sndrHanGrpWin));

 	CleanupClosePushL(senderGroupWin);

 	// Create reciever WsSession and the window group

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

 	CleanupClosePushL(receiverWsSession);

 	receiverGroupWin = RWindowGroup(receiverWsSession);

 	User::LeaveIfError(receiverGroupWin.Construct(rcvrHanGrpWin));

 	CleanupClosePushL(receiverGroupWin);

 	TInt err = KErrNone;

 	// Send waste events to the receiver and overflow the event queue

 	for (TInt ind = 0; ind < numMaxMessages; ind++)

 		{

 		wasteEvent.SetType(sndrHanGrpWin);

 		err = senderWsSession.SendEventToWindowGroup(receiverGroupWin.Identifier(), wasteEvent);

 		if (err != KErrNone)

 			{

 			numWasteMessages = ind; // Real number waste messages that was sent

 			break;

 			}

 		}

 	// Send messages to the receiver

 	for (TInt ind = 0; ind < numWgMessages; ind++)

 		{

 		TInt uidData = ind + sndrHanGrpWin;

 		TPtr8 msg((unsigned char*) &uidData, sizeof(uidData));

 		err = senderWsSession.SendMessageToWindowGroup(receiverGroupWin.Identifier(), TUid::Uid(uidData), msg);

 		if (err != KErrNone)

 			{

 			LOG_MESSAGE2(_L("UnExpected Error Code = %d"),err);

 			numWgMessages = ind; // Real number window group messages that was sent

 			}

 		}

 	// Check and count sent messages 

 	for (TInt ind = 0; ind < allPossibleMessages; ind++)

 		{

 		receiverWsSession.EventReady(&testStatus);

 		timer.After(timerStatus, oneSecond);

 		User::WaitForRequest(testStatus, timerStatus);

 		if (testStatus == 0)

 			{

 			// Test incoming events

 			receiverWsSession.GetEvent(event);

 			if (event.Type() == sndrHanGrpWin)

 				{

 				++gotRealWasteMessages;

 				}

 			else if (event.Type() == EEventMessageReady)

 				{

 				if (gotRealWgMessages == 0)

 					{

 					for (TInt ind = 0; ind < numMaxMessages; ind++)

 						{

 						wasteEvent.SetType(sndrHanGrpWin);

 						err = senderWsSession.SendEventToWindowGroup(receiverGroupWin.Identifier(), wasteEvent);

 						if (err == KErrNone)

 							{

 							++numWasteMessages;

 							}

 						else

 							{

 							break;

 							}

 						}

 					}

 				++gotRealWgMessages;

 				TUid uid;

 				TPtr8 msgPtr(NULL,0);

 				err = receiverWsSession.FetchMessage(uid, msgPtr, event);

 				User::Free((TAny *) msgPtr.Ptr());

 				}

 			// testStatus has been completed. Hence, Cancel the timer.

 			timer.Cancel();

 			User::WaitForRequest(timerStatus);

 			}

 		else

 			{

 			// Times out, cancel the event notification

 			receiverWsSession.EventReadyCancel();

 			User::WaitForRequest(testStatus);

 			// All events were recieved

 			break;

 			}

 		}

 	LOG_MESSAGE3(_L("Got Waste message = %d expected =%d"),gotRealWasteMessages,numWasteMessages);

 	LOG_MESSAGE3(_L("Got Group message = %d expected =%d"),gotRealWgMessages,numWgMessages);

 	TEST(gotRealWasteMessages == numWasteMessages);

 	TEST(gotRealWgMessages == numWgMessages);

 	CleanupStack::PopAndDestroy(&receiverGroupWin);

 	CleanupStack::PopAndDestroy(&receiverWsSession);

 	CleanupStack::PopAndDestroy(&senderGroupWin);

 	CleanupStack::PopAndDestroy(&senderWsSession);

 	CleanupStack::PopAndDestroy(&timer);

 	TheClient->iWs.Flush();

 	}

 void CTMessage::RunTestCaseL(TInt /*aCurTestCase*/)

 	{

 	_LIT(KMsgTest0,"Message test 1");

 	_LIT(KMsgTest1,"Message test 2");

 	_LIT(KMsgTest2,"Message test 3");

 	_LIT(KMsgTest3,"Message test 4");

 	_LIT(KMsgTest4,"Message test 5");

 	_LIT(KMsgTest5,"Message test 6");

 	_LIT(KMsgTest6,"Message test 7");

 	_LIT(KMsgTest7,"Message test 8 - when event queue is overflow");

 	iState=iTest->iState; // used by iMessageReceiver array 

 	((CTMessageStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

 	switch(++iTest->iState)

 		{

 /**

 @SYMTestCaseID		GRAPHICS-WSERV-0084

 @SYMDEF             DEF081259

 @SYMTestCaseDesc    Test message sending and receiving

 @SYMTestPriority    High

 @SYMTestStatus      Implemented

 @SYMTestActions     Generates 5 short messages and sends them to window group, window group receives them

 @SYMTestExpectedResults Expects that received messages have the same length and the same content as those sent

 */		

 		case 1:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0084"));

 			iTest->LogSubTest(KMsgTest0);

 			MessageTests(KTotalNumberOfTestMessages,KTotalNumberOfTestMessages,EFalse,EFalse);

 			break;

 /**

 @SYMTestCaseID		GRAPHICS-WSERV-0406

 @SYMDEF             DEF102201,DEF141447

 @SYMTestCaseDesc    Test message sending and receiving

 @SYMTestPriority    High

 @SYMTestStatus      Implemented

 @SYMTestActions     Generates some diffrent size of messages and sends them to window group, window group receives them

 @SYMTestExpectedResults Expects that received messages have the same length and the same content as those sent

 */		

 		case 2:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest1);

 			MessageTests(KMaxNumOfMessagesInActiveQueue-1,KMaxNumOfMessagesInActiveQueue-1,EFalse,EFalse);

 			break;

 		case 3:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest2);

 			MessageTests(KMaxNumOfMessagesInActiveQueue,2,EFalse,ETrue);

 			break;

 		case 4:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest3);

 			MessageTests(KMaxNumOfMessagesInActiveQueue+1,2,EFalse,ETrue);

 			break;

 		case 5:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest4);

 			MessageTests(KMaxNumOfMessagesInActiveQueue+2,2,EFalse,ETrue);

 			break;

 		case 6:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest5);

 			SyncSendReceiveCount=KMaxNumOfSyncMessages;

 			MessageTests(KMaxNumOfSyncMessages,KMaxNumOfSyncMessages,ETrue,EFalse);

 			break;

 		case 7:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest6);

 			MessageTests(KMaxNumOfMessagesInActiveQueue+1,2,EFalse,ETrue);

 			((*iMessageReceiver)[iState])->ResetMessageCount();

 			SyncSendReceiveCount=KTotalNumberOfTestMessages;

 			MessageTests(KTotalNumberOfTestMessages,KTotalNumberOfTestMessages,ETrue,EFalse);

 			break;

 		case 8:

 			((CTMessageStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0406"));

 			iTest->LogSubTest(KMsgTest7);

 			TestMessageQueueOverflowL();

 			((CTMessageStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

 			((CTMessageStep*)iStep)->CloseTMSGraphicsStep();

 			TestComplete();

 			return;

 		}

 	((*iMessageReceiver)[iState])->ResetMessageCount();

 	((CTMessageStep*)iStep)->RecordTestResultL();

 	}

 __WS_CONSTRUCT_STEP__(Message)