// 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\pipe\t_pipe.cpp

// Overview:

// Test pipe mechanism

// API Information:

// RPipe

// Details:

// - Create various leagal and illegal pipe and verify that pipe

// functionality works as stated in requirements.

// - Create Named and UnNamed Pipes and verify.

// - Test Pipes communication in multiprocess , multithreaded , single process

// single threaded environment.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Refer Pipes design and requirement document.

// 1. SGL.GT0314.202 PREQ1460 Design Doc

// 2. SGL.GT0314.203 PREQ1460 Pipe Functional Specification

// Refer Pipe test specification document.

// 1. SGL.GT0314.601 Pipes_Test_Specifications

// Failures and causes:

// Base Port information:

// MMP File:

// t_pipe.mmp

// 

//

/**

 @STMTestCaseID			KBASE-T_PIPE-0217

 @SYMPREQ				PREQ1460

 @SYMREQ					REQ6141

 @SYMCR					CR0923

 @SYMTestCaseDesc		Pipe functional tests

 @SYMTestPriority		High

 @SYMTestActions			Tests the functionality of the pipe. Success and failure tests are performed.

 @SYMTestExpectedResults	Test should pass

*/

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32svr.h>

#include <e32des8.h>

#include <e32des8_private.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <e32math.h>

#include <hal.h>

#include "rpipe.h"

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

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

const TInt KHeapSize=0x2000;

// Test Data

_LIT8(KTestData,"Pipe Data To Be Passed");

_LIT8(KTestData1,"P");

_LIT8(KTestData2,"Pipe Data To Be Passed");

_LIT8(KTestData3,"ipe Data To Be Passed");

// Test Pipe Names

_LIT(KPipe1Name,"TestPipe1");

_LIT(KPipe3Name,"TestPipe3");

//Global semaphore name

_LIT(KSemaphoreName,"Semaphore1");

// Pipename of max pipe length 80 Charecters.

_LIT(KMaxPipeName,"abcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrst");

// PipeName of max pipe length plus one ,81 charecters

_LIT(KMaxPipeNamePlusOne,"abcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrst1");

// Thread Name Constants

_LIT(KThread2Name, "thread2");

_LIT(KThread3Name, "thread3");

_LIT(KThread4Name, "thread4");

_LIT(KThread5Name, "thread5");

_LIT(KReaderThread, "ReaderThread");

_LIT(KWriterThread, "WriterThread");

_LIT(KThread8Name, "thread8");

_LIT(KThread9Name, "thread9");

_LIT(KThread11Name, "thread11");

// Test Process Name Constants

_LIT(KProcessName, "t_pipe2.exe");

// Following class is used to pass thread handle information to different threads.

class TData

	{

public:

	TData(RPipe* aReadEnd, RPipe *aWriteEnd); 

	TData(RPipe* aReadEnd, RPipe *aWriteEnd, const TDesC8* aPipeData, TInt aIterations=1);

	RPipe* iReadEnd;

	RPipe* iWriteEnd;

	const TDesC8* iPipeData;

	TInt iIterations;

	};

TData::TData(RPipe* aReadEnd , RPipe *aWriteEnd)

	:iReadEnd(aReadEnd),iWriteEnd(aWriteEnd), iPipeData(NULL), iIterations(NULL)

	{}

TData::TData(RPipe* aReadEnd , RPipe *aWriteEnd, const TDesC8* aPipeData, TInt aIterations)

	:iReadEnd(aReadEnd),iWriteEnd(aWriteEnd), iPipeData(aPipeData), iIterations(aIterations)

	{}

/**

A utility class for running functions in other threads/processes

*/

class TTestRemote

	{

public:

	virtual TInt WaitForExitL()=0;

	virtual ~TTestRemote()

		{}

	virtual void Rendezvous(TRequestStatus& aStatus) =0;

protected:

	TTestRemote()

		{}

	static TInt RunFunctor(TAny* aFunctor)

		{

		TFunctor& functor = *(TFunctor*)aFunctor;

		functor();

		return KErrNone;

		}

	TRequestStatus iLogonStatus;

	static TInt iCount;

	};

TInt TTestRemote::iCount=0;

class TTestThread : public TTestRemote

	{

public:

	TTestThread(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume=ETrue)

		{

		Init(aName, aFn, aData, aAutoResume);

		}

	/**

	Run aFunctor in another thread

	*/

	TTestThread(const TDesC& aName, TFunctor& aFunctor, TBool aAutoResume=ETrue)

		{

		Init(aName, RunFunctor, &aFunctor, aAutoResume);

		}

	~TTestThread()

		{

		//RTest::CloseHandleAndWaitForDestruction(iThread);

		iThread.Close();

		}

	void Resume()

		{

		iThread.Resume();

		}

	/**

	If thread exited normally, return its return code

	Otherwise, leave with exit reason

	*/

	virtual TInt WaitForExitL()

		{

		User::WaitForRequest(iLogonStatus);

		const TInt exitType = iThread.ExitType();

		const TInt exitReason = iThread.ExitReason();

		__ASSERT_ALWAYS(exitType != EExitPending, User::Panic(_L("TTestThread"),0));

		if(exitType != EExitKill)

			User::Leave(exitReason);

		return exitReason;

		}

	virtual void Rendezvous(TRequestStatus& aStatus)

		{

		iThread.Rendezvous(aStatus);

		}

private:

	void Init(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume)

		{

		TKName name(aName);

		name.AppendFormat(_L("-%d"), iCount++);	

		TInt r=iThread.Create(name, aFn, KDefaultStackSize, KHeapSize, KHeapSize, aData);

		User::LeaveIfError(r);

		iThread.Logon(iLogonStatus);

		__ASSERT_ALWAYS(iLogonStatus == KRequestPending, User::Panic(_L("TTestThread"),0));

		if(aAutoResume)

			iThread.Resume();

		}

	RThread iThread;

	};

/**

Non blocking reads, verifying data as expected

*/

TInt TestThread2(TAny* aData)

	{

	RTest test(_L("t_pipe_t2"));

	test.Start(_L("Thread 2"));

	test.Printf(_L("THREAD 2 called by TestMultiThreadNamedPipes And TestMultiThreadUnNamedPipes\n"));

	TBuf8<50>		cPipeReadData;

	TInt 			ret,readsize;

	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.

	test.Next(_L("PIPE TEST:Thread 2-1 Read 1 byte of data from the pipe : Test for success\n"));

	readsize = 1;

	ret = data.iReadEnd->Read(cPipeReadData ,readsize);

	test_Equal(readsize, ret);

	test.Next(_L("PIPE TEST:Thread 2-2 Validate 1 byte received is correct\n"));

	ret = cPipeReadData.Compare(KTestData1);

	test_KErrNone(ret);

	test.Next(_L("PIPE TEST:Thread 2-3 Read remaining data from the pipe\n"));

	readsize = 21;

	ret = data.iReadEnd->Read(cPipeReadData , readsize);

	test_Equal(readsize, ret);

	test.Next(_L("PIPE TEST:Thread 2-4 Validate received data\n"));

	ret = cPipeReadData.Compare(KTestData3);

	test_KErrNone(ret);

	test.End();

	test.Close();

	return KErrNone;

}

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

	This function is used as thread to test Unnamed pipes.

	TestMultiThreadUnNamedPipes() will use this function.

	TestMultiThreadNamedPipes() will use this function.

	@aData 			: Used to pass the pipe and handle its size information.

	Return Value	: TInt

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

TInt TestThread3(TAny* aData) {

	TInt 				ret, aWriteSize;

	TBufC8<50> 			cTestData3(KTestData2); 	// Test Data

	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.

	RTest test(_L("t_pipe_t3"));

	test.Start(_L("Thread 3"));

	test.Printf(_L(" THREAD 3 called by TestMultiThreadNamedPipes And TestMultiThreadUnNamedPipes\n"));

	test.Next(_L("PIPE TEST:Thread 3-1 Call Write blocking and write data\n"));

	// Call Writeblocking function. Write one byte of data.

	aWriteSize = cTestData3.Length();

	ret = data.iWriteEnd->WriteBlocking(cTestData3,aWriteSize);

	test_Equal(aWriteSize, ret);

	// Call Writeblocking function. Write aSize bye data.

	// Write data so that pipe get filled.

	test.Next(_L("PIPE TEST:Thread 3-2 Write data till pipe is filled up \n"));

	ret = data.iWriteEnd->WriteBlocking(cTestData3,aWriteSize);

	test_Equal(aWriteSize, ret);

	test.End();

	test.Close();

	return KErrNone;

}

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

	This function is used as thread to test Unnamed pipes.

	TestMultiThreadUnNamedPipes() will use this function.

	@aData 			: Used to pass the pipe and handle its size information.

	Return Value	: TInt

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

//TRequestStatus			stat1;

TInt TestThread4(TAny* aData) {

	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.

	TRequestStatus			stat1;

	TBuf8<150>				cPipeReadData;

	TInt					ret;

	RTest test(_L("t_pipe_t4"));

	test.Start(_L("Thread 4"));

	RSemaphore				sem;					//	Handle to the global semaphore

	ret = sem.OpenGlobal(KSemaphoreName);					// Access to the global semaphore identified by its name.

	test(ret == KErrNone);

	test.Printf(_L("Thread 4:Created by TestNotifyMechanismPipes.\n"));

	test.Next(_L("PIPE TEST:Thread 4-1 Register Notify Data available request.\n"));

	data.iReadEnd->NotifyDataAvailable(stat1);

	test_Equal(KRequestPending, stat1.Int());

	sem.Signal(); //signal to say that we have issued notification request

	test.Next(_L("PIPE TEST:Thread 4-2 Wait till notified for data. Check for Available.\n"));

	User::WaitForRequest(stat1);

	test ( stat1.Int() == KErrNone);

	test.Next(_L("PIPE TEST:Thread 4-3 Read One byte of data from the pipe.\n"));

	sem.Wait();	//wait for signal that 1 byte should be read

	ret = data.iReadEnd->Read(cPipeReadData,1);

	test (ret == 1);

	test.Next(_L("PIPE TEST:Thread 4-4 Verify data is correct ?.\n"));

	test (KErrNone == cPipeReadData.Compare(KTestData1));

	test.Next(_L("PIPE TEST:Thread 4-5 Read remaining data from the pipe.\n"));

	ret = data.iReadEnd->Read(cPipeReadData,21);

	test (ret == 21);

	test.Next(_L("PIPE TEST:Thread 4-6 Verify data is correct ?.\n"));

	test (KErrNone == cPipeReadData.Compare(KTestData3));

	sem.Signal();	//signalling to the main thread to continue its operation

	sem.Close();	//closing the handle to the semaphore

	test.End();

	test.Close();

	return KErrNone;

}

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

	This function is used as thread to test Unnamed pipes.

	TestWaitMechanismPipes() will use this function.

	@aData 			: Used to pass the pipe and handle its size information.

	Return Value	: TInt

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

TInt TestThread5(TAny* aData) {

	TData& data = *(TData *)aData; 							// aData will have pipe handles and size.

	TRequestStatus			stat1;

	TInt					ret;

	RTest test(_L("t_pipe_t5"));

	test.Start(_L("Thread 5"));

	test.Printf(_L("PIPE TEST:Thread 5:Created by TestWaitMechanismPipes.\n"));

	test.Next(_L("PIPE TEST:Thread 5-1:Register one more request to wait till open to read. It shall not allow\n"));

	data.iWriteEnd->Wait(KPipe3Name, stat1);

	test (stat1.Int() == KErrInUse);

	data.iWriteEnd->WaitForReader(KPipe3Name, stat1);

	test (stat1.Int() == KErrInUse);

	test.Next(_L("PIPE TEST:Thread 5-2:Open Pipe handle to Read.\n"));

	ret = data.iReadEnd->Open(KPipe3Name,RPipe::EOpenToRead);

	test(ret == KErrNone);

	test.End();

	test.Close();

	return KErrNone;

}

/**

The reader thread will wait till there is data in the pipe

and then continuously read till it has read the total length

of the pipe.

*/

TInt ReaderThread(TAny* aData) {

// Read data from Pipe

	RTest test(KReaderThread);

	test.Title();

	test.Start(_L("Reader Thread"));

	TData& data = *(TData *)aData;

	TBuf8<10> pipeReadData;

	const TInt sizeToRead = data.iReadEnd->MaxSize(); //attempt to read everything from pipe

	TRequestStatus status(KErrGeneral);

	//do read in loop in case thread is notified before pipe is full

	TInt totalDataRead=0;

	do

		{

		data.iReadEnd->NotifyDataAvailable(status);

		test.Printf(_L("notify data request status is %d\n"), status.Int());

		if(status==KRequestPending)

			User::WaitForRequest(status);

		test(status==KErrNone);

		test.Printf(_L("ready to read data\n"), status.Int());

		const TInt sizeRead = data.iReadEnd->Read(pipeReadData, sizeToRead);

		test.Printf(_L("Read %d bytes from pipe\n"), sizeRead);

		test(sizeRead>0);

		totalDataRead+=sizeRead;

		} 

	while(totalDataRead<sizeToRead);

	test(totalDataRead==sizeToRead);

	test.End();

	test.Close();

	return KErrNone;

}

_LIT8(KTestDataNum1 , "12345");

_LIT8(KTestDataNum , "1234567890");

/**

Write into pipe to completely fill it.

*/

TInt WriterThread(TAny* aData)

	{

// Write data to pipe

	RPipe* writeEnd = static_cast<TData*>(aData)->iWriteEnd;

	RTest test(_L("WriterThread"));

	test.Start(_L("WriterThread"));

	writeEnd->Flush(); //make sure pipe is empty

	const TInt sizeToWrite = writeEnd->MaxSize();

	test.Printf(_L("Writing %d bytes in to pipe\n"), sizeToWrite);

	TInt length=writeEnd->WriteBlocking(KTestDataNum1,sizeToWrite);

	test(length==sizeToWrite);

	test.End();

	test.Close();

	return KErrNone;

	}

/**

The FlusherThread waits till the supplied pipe

is full before flushing it. 

*/

TInt FlusherThread(TAny* aData)

	{

	TData& data = *(TData *)aData; 							// aData will have pipe handles and size.

	//wait for pipe to fill, then flush

	TRequestStatus status;

	const TInt maxSize=data.iReadEnd->MaxSize();

	do

		{	

		data.iReadEnd->NotifyDataAvailable(status);

		if(status==KRequestPending)

			User::WaitForRequest(status);

		if(status!=KErrNone)

			return status.Int();

		} while(data.iReadEnd->Size()<maxSize);

	data.iReadEnd->Flush();

	return KErrNone;

	}

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

	This function is used as thread to test Unnamed pipes.

	TestWaitMechanismPipes() will use this function.

	@aData 			: Used to pass the pipe and handle its size information.

	Return Value	: TInt

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

TInt	CloseFlag;

TInt TestThread9(TAny* aData) {

	TData& data = *(TData *)aData; 							// aData will have pipe handles and size.

	if (CloseFlag == 1)

	data.iReadEnd->Close();

	if (CloseFlag == 0)

	data.iWriteEnd->Close();

	return 0;

	}

/**

The test will create 2 threads running this function. They will

race to placing the blocking read request. The first