// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\mqueue\t_mqueue.cpp

// Overview:

// Test message queuing

// API Information:

// RMsgQueue, RMsgQueueBase

// Details:

// - Create various illegal and legal private message queues and verify 

// results are as expected. Test private message queue functionality in

// both single threaded tests and multi-threaded tests.

// - Create various illegal and legal global named message queues and verify 

// results are as expected. Test global named message queue functionality

// in both single threaded tests and multi-threaded tests.

// - Test multi-process queues and template based queues, verify results are 

// as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32svr.h>

#include <e32msgqueue.h>

#include <f32file.h>

LOCAL_D RTest test(_L("t_mqueue"));

//if the test is to run under the debugger, uncomment the following line

//#define _DEBUGGER_BUILD

const TInt KHeapSize=0x2000;

const TInt KTestValue = 42;

_LIT8(KFillPattern, "1234567890");

_LIT(KGLobalName1, "GlobalMessageQueue1");

LOCAL_C void SingleThreadedTests(RMsgQueueBase& aQueue, TInt aSlots, TInt aSize)

	{

	test.Printf(_L("Single Threaded Tests"));

	TRequestStatus stat;

	test.Next(_L("test CancelDataAvailable"));

	aQueue.NotifyDataAvailable(stat);

	test (stat == KRequestPending);

	aQueue.CancelDataAvailable();

	User::WaitForRequest(stat);

	test (stat == KErrCancel);

	TUint8 * pSourceData = (TUint8*)User::Alloc(aSize*2);

	test(pSourceData != NULL);	

	TPtr8 pS(pSourceData, aSize*2, aSize*2);

	pS.Repeat(KFillPattern);

	TUint8 * pDestinationData = (TUint8*)User::Alloc(aSize*2);

	test(pDestinationData != NULL);

	TPtr8 pD(pDestinationData, aSize*2, aSize*2);

	pD.FillZ();

	test.Next(_L("test MessageSize"));

	test(aQueue.MessageSize() == aSize);

	test.Next(_L("Send a legal message through"));

	TInt ret = aQueue.Send(pSourceData, aSize);

	test(ret == KErrNone);

	test.Next(_L("Receive legal message"));

	ret = aQueue.Receive(pDestinationData, aSize);

	test(ret == KErrNone);

	TPtr8 p(pS);

	p.SetLength(aSize);

	pD.SetLength(aSize);

	test(p == pD);

	pD.FillZ();

	test.Next(_L("Send a short message through"));

	ret = aQueue.Send(pSourceData, aSize/2);

	test(ret == KErrNone);

	test.Next(_L("Receive legal message"));

	ret = aQueue.Receive(pDestinationData, aSize);

	test(ret == KErrNone);

	p.SetLength(aSize/2);

	pD.SetLength(aSize/2);

	test(p == pD);

	pD.FillZ();

	test.Next(_L("Test Receive with no message"));

	ret = aQueue.Receive(pDestinationData, aSize);

	test(ret == KErrUnderflow);

	if (aSlots >= 2)

		{	

		test.Next(_L("Send two legal messages through"));

		pS[0] = 0;

		ret = aQueue.Send(pSourceData, aSize);

		test(ret == KErrNone);

		pS[0] = 1;

		ret = aQueue.Send(pSourceData, aSize);

		test(ret == KErrNone);

		test.Next(_L("Receive two legal messages in tx order"));

		ret = aQueue.Receive(pDestinationData, aSize);

		test(ret == KErrNone);

		test(pD[0] == 0);

		pD.FillZ();

		ret = aQueue.Receive(pDestinationData, aSize);

		test(ret == KErrNone);

		test(pD[0] == 1);

		pD.FillZ();

		}

	test.Next(_L("Test filling the queue to the max"));

	TInt x;

	for (x = 0; x < aSlots; x++)

		{

		pS[0] = (TUint8)x;

		ret = aQueue.Send(pSourceData, aSize);

		test(ret == KErrNone);

		}

	test.Next(_L("Test one too many sends"));

	ret = aQueue.Send(pSourceData, aSize);

	test(ret == KErrOverflow);

	test.Next(_L("test cancel SpaceAvailable"));

	aQueue.NotifySpaceAvailable(stat);

	test (stat == KRequestPending);

	aQueue.CancelSpaceAvailable();

	User::WaitForRequest(stat);

	test (stat == KErrCancel);

	test.Next(_L("Test emptying the queue"));

	for (x = 0; x < aSlots; x++)

		{

		ret = aQueue.Receive(pDestinationData, aSize);

		test(ret == KErrNone);

		test(pD[0] == (TUint8)x );

		pD.FillZ();

		}

	test.Next(_L("test cancel DataAvailable"));

	aQueue.NotifyDataAvailable(stat);

	test (stat == KRequestPending);

	aQueue.CancelDataAvailable();

	User::WaitForRequest(stat);

	test (stat == KErrCancel);

	test.Next(_L("Test one too many receives"));

	ret = aQueue.Receive(pDestinationData, aSize);

	test(ret == KErrUnderflow);

	test.Next(_L("Test wrap around"));

	test.Printf(_L("fill queue to max\n"));

	for (x = 0; x < aSlots; x++)

		{

		pS[0] = (TUint8)x;

		ret = aQueue.Send(pSourceData, aSize);

		test(ret == KErrNone);

		}

	test.Printf(_L("half empty the queue\n"));

	for (x = 0; x < aSlots/2; x++)

		{

		ret = aQueue.Receive(pDestinationData, aSize);

		test(ret == KErrNone);

		test(pD[0] == (TUint8)x);

		pD.FillZ();

		}

	test.Printf(_L("fill queue to max\n"));

	for (x = 0; x < aSlots/2; x++)

		{

		pS[0] = (TUint8)x;

		ret = aQueue.Send(pSourceData, aSize);

		test (ret == KErrNone);

		}

		ret = aQueue.Send(pSourceData, aSize);

		test (ret == KErrOverflow);

	test.Printf(_L("empty the queue\n"));

	for (x = aSlots/2; x < aSlots; x++)

		{

		ret = aQueue.Receive(pDestinationData, aSize);

		test(ret == KErrNone);

		test(pD[0] == (TUint8)x);

		}

	for (x = 0; x < aSlots/2; x++)

		{

		ret = aQueue.Receive(pDestinationData, aSize);

		test(ret == KErrNone);

		test(pD[0] == (TUint8)x);

		}

	test.Next(_L("Test queue is empty"));

	ret = aQueue.Receive(pDestinationData, aSize);

	test(ret == KErrUnderflow);

	User::Free(pSourceData);

	User::Free(pDestinationData);

	}

_LIT(KThread2Name, "thread2");

_LIT(KThread3Name, "thread3");

_LIT(KThread4Name, "thread4");

class TData 

	{

public:

	TData(RMsgQueueBase* aQ, TInt aSize, TInt aSlots,TInt aTest=0, TAny* aData=NULL);

	RMsgQueueBase* iQueue;

	TInt iSize;

	TInt iSlots;

	TInt iTest;

	TAny* iData;

	};

TData::TData(RMsgQueueBase* aQ, TInt aSize, TInt aSlots, TInt aTest, TAny* aData) :	iQueue(aQ), iSize(aSize),

																		iSlots(aSlots), iTest(aTest), iData(aData)

	{

	//empty

	};

LOCAL_C TInt illegalSendEntryPoint(TAny* aData)

	{

	TData& data = *(TData *)aData;

	switch (data.iTest)

		{

	case 0:

		data.iQueue->Send(data.iData, data.iSize*2);	//should panic, message size incorrect

		break;

	case 1:

#ifdef _DEBUGGER_BUILD

		#pragma message ("BUILT FOR DEBUGGER")

		User::Panic(_L("test"),ECausedException);

#else

		data.iQueue->Send((TAny*)0xfeed, data.iSize);	//should panic

#endif

	break;

	case 2:

#ifdef _DEBUGGER_BUILD

		#pragma message ("BUILT FOR DEBUGGER")

		User::Panic(_L("test"),ECausedException);

#else

		data.iQueue->Send((TAny*)0xDEDEDEDE, data.iSize);	//dodgy address

#endif	

		break;

		}

	test(0);	//should never get here.  This'll make a Kern Exec 0! as tries to use console from different thread

	return 0;

	}

LOCAL_C TInt illegalReceiveEntryPoint(TAny* aData)

	{

	TData& data = *(TData *)aData;

	TUint8 buf[256];

	switch (data.iTest)

		{

	case 0:

		data.iQueue->Receive(buf, data.iSize*2);	//should panic, message size incorrect

		break;

	case 1:

#ifdef _DEBUGGER_BUILD

		#pragma message ("BUILT FOR DEBUGGER")

		User::Panic(_L("test"),ECausedException);

#else

		data.iQueue->Receive((TAny*)0xfeed, data.iSize);	//should panic

#endif

		break;

	case 2:

#ifdef _DEBUGGER_BUILD

		#pragma message ("BUILT FOR DEBUGGER")

		User::Panic(_L("test"),ECausedException);

#else

		data.iQueue->Receive((TAny*)0xDEDEDEDE, data.iSize);	//dodgy address

#endif

		break;

		}

	test(0);	//should never get here.  This'll make a Kern Exec 0!

	return 0;

	}

LOCAL_C TInt sendBlockingEntryPoint(TAny* aData)

	{

	TData& data = *(TData *)aData;

	TInt d = KTestValue;

	data.iQueue->SendBlocking(&d, 4);

	return KErrNone;

	}

LOCAL_C TInt receiveBlockingEntryPoint(TAny* aData)

	{

	TData& data = *(TData *)aData;

	TUint8  pData[256];

	TPtr8 pD(pData, data.iSize, data.iSize);

	pD.FillZ();

	data.iQueue->ReceiveBlocking(pData, data.iSize);

	test (*(TInt*)pData == KTestValue);

	return KErrNone;

	}

LOCAL_C TInt notifyDataAvailableEntryPoint(TAny* aData)

	{

	TData& data = *(TData *)aData;

	//check size as well

	test(data.iQueue->MessageSize() == data.iSize);

	TRequestStatus stat;

	data.iQueue->NotifyDataAvailable(stat);

	User::WaitForRequest(stat);

	return KErrNone;

	}

LOCAL_C TInt notifySpaceAvailableEntryPoint(TAny* aData)

	{

	TData& data = *(TData *)aData;

	TRequestStatus stat;

	data.iQueue->NotifySpaceAvailable(stat);

	User::WaitForRequest(stat);

	return KErrNone;

	}

LOCAL_C void MultiThreadedTests(RMsgQueueBase& aQueue, TInt aSlots, TInt aSize)

	{

	test.Next(_L("multi threaded tests"));

	RThread thread2;

	TInt ret = KErrNone;

	TAny* ptr = User::Alloc(aSize);

	test.Next(_L("test Send with illegal parameters"));

	TInt testnum;

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	for (testnum = 0; testnum < 3; testnum++)	//testnum range is determined by the number of tests in illegalSendEntryPoint

		{

		TData data(&aQueue, aSize, aSlots, testnum, ptr);

		ret = thread2.Create(KThread2Name, illegalSendEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

		test(KErrNone == ret);

		TRequestStatus thread2stat;

		thread2.Logon(thread2stat);

		thread2.Resume();

		User::WaitForRequest(thread2stat);

		test (thread2.ExitType() == EExitPanic);

		switch (testnum)

		{

		case 0:

		test (thread2.ExitReason() == EMsgQueueInvalidLength);

		break;

		case 1:

		test (thread2.ExitReason() == ECausedException);

		break;

		case 2:

		test (thread2.ExitReason() == ECausedException);

		break;

		}

		CLOSE_AND_WAIT(thread2);

		}

	User::SetJustInTime(jit);

	test.Next(_L("test Receive with illegal parameters"));

	jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	for (testnum = 0; testnum < 3; testnum++)	//testnum range is determined by the number of tests in illegalReceiveEntryPoint

		{

	//put something in the queue

		aQueue.Send(&testnum, 4);

		TData data(&aQueue, aSize, aSlots, testnum, ptr);

		ret = thread2.Create(KThread2Name, illegalReceiveEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

		test(KErrNone == ret);

		TRequestStatus thread2stat;

		thread2.Logon(thread2stat);

		thread2.Resume();

		User::WaitForRequest(thread2stat);

		test (thread2.ExitType() == EExitPanic);

		switch (testnum)

		{

		case 0:

		test (thread2.ExitReason() == EMsgQueueInvalidLength);

		break;

		case 1:

		test (thread2.ExitReason() == ECausedException);

		break;

		case 2:

		test (thread2.ExitReason() == ECausedException);

		break;

		}

		CLOSE_AND_WAIT(thread2);

		}

	User::SetJustInTime(jit);

	while(KErrNone == aQueue.Receive(ptr, aSize))	//empty the queue

		{

		//empty,

		}

	test.Next(_L("multi threaded NotifySpaceAvailable"));

	TInt dummydata = KTestValue;

	//fill the queue

	while (KErrNone == aQueue.Send(&dummydata, sizeof (TInt)))

		{

		//empty

		}

	TData data(&aQueue, aSize, aSlots);

	ret = thread2.Create(KThread2Name, notifySpaceAvailableEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

	test(KErrNone == ret);

	TRequestStatus thread2stat;

	thread2.Logon(thread2stat);

	thread2.Resume();

	//thread2 should be waiting for space available

	test (thread2stat == KRequestPending);

	aQueue.ReceiveBlocking(ptr, aSize);

	User::WaitForRequest(thread2stat);

	test (thread2stat == KErrNone);

	test (thread2.ExitType() == EExitKill);

	CLOSE_AND_WAIT(thread2);

	//thread 2 has exited OK

	//empty the queue

	while (KErrNone == aQueue.Receive(ptr, aSize))

		{

		//empty

		}

	test.Next(_L("multi threaded SendBlocking, ReceiveBlocking"));

	ret = thread2.Create(KThread2Name, receiveBlockingEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

	test(KErrNone == ret);

	thread2.Logon(thread2stat);

	thread2.Resume();

	aQueue.SendBlocking(&dummydata, sizeof (TInt));

	User::WaitForRequest(thread2stat);

	test (thread2.ExitType() == EExitKill);

	CLOSE_AND_WAIT(thread2);

	test.Next(_L("multiple ReceiveBlocking"));

	ret = thread2.Create(KThread2Name, receiveBlockingEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

	test(KErrNone == ret);

	RThread thread3;

	ret = thread3.Create(KThread3Name, receiveBlockingEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

	test(KErrNone == ret);

	RThread thread4;

	ret = thread4.Create(KThread4Name, receiveBlockingEntryPoint, KDefaultStackSize, KHeapSize, KHeapSize, &data);

	test(KErrNone == ret);

	thread2.Logon(thread2stat);

	TRequestStatus thread3stat;

	thread3.Logon(thread3stat);

	TRequestStatus thread4stat;

	thread4.Logon(thread4stat);

	thread2.Resume();

	User::After(500000);

	jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	thread3.Resume();

	thread4.Resume();