// 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_pipe4.cpp
// This is very similar to User::WaitForRequest() but allows the User
// to specify multiple TRequestStatus objects to wait on. The function
// will return when the first TRequestStatus object completes.
// / Header Files////////
// 
//

/**
 @STMTestCaseID			KBASE-T_PIPE4-0218
 @SYMPREQ				PREQ1460
 @SYMREQ					REQ6142
 @SYMCR					CR0923
 @SYMTestCaseDesc		User::WaitForNRequests functional test
 @SYMTestPriority		High
 @SYMTestActions			Tests the operation of the API User::WaitForNRequests().
 @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 <e32std.h>
#include <e32std_private.h>

#include "rpipe.h"

//// Test Objects for All threads////

LOCAL_D RTest test(_L("t_pipe4"));
LOCAL_D RTest test2(_L("t_pipe_t2"));
LOCAL_D RTest test3(_L("t_pipe_t3"));
LOCAL_D RTest test4(_L("t_pipe_t4"));
LOCAL_D RTest test5(_L("t_pipe_t5"));

//// Thread Name Constants //////
_LIT(KThread2Name, "WaitThread");
_LIT(KThread3Name, "NotifyDataThread");
_LIT(KThread4Name, "NotifySpaceThread");
_LIT(KThread5Name, "CancelNotifyThread");

_LIT(KPipe1Name,"TestPipeP");
_LIT(KPipe2Name,"TestPipeQ");
_LIT(KPipe3Name,"TestPipeR");
_LIT(KPipe4Name,"TestPipeS");
_LIT(KPipe5Name,"TestPipeT");


_LIT8(KTestDataNum,"1234567890");



const TInt KHeapSize=0x2000;


// Following class is used to pass thread handle information to different threads.
class TData
	{
public:
	TData(RPipe* aPipe, RPipe *bPipe, TInt aSize);
	RPipe* rPipe;								// Pipe Read handle
	RPipe* wPipe;								// Pipe Write handle
	TInt iSize;


	};

TData::TData(RPipe * aPipe , RPipe *bPipe, TInt aSize) {
	rPipe = aPipe;
	wPipe = bPipe;
	iSize = aSize;

}

////////////////////////////////////////////////////
//// WaitThread : Function opens the Read handle
////			for the pipe passed to it.
////
////			CPipeName --> Pipe Name
////			aData 	  --> Read Write Handle
////
////////////////////////////////////////////////////
TBufC<100> 		cPipeName;

TInt WaitThread(TAny* aData) {

	test2.Start(_L("PIPE TEST:WaitThread Entry"));
	TInt 		ret;

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

	ret = data.rPipe->Open(cPipeName,RPipe::EOpenToRead);
	test2 (ret == KErrNone);

	test2.Printf(_L("PIPE TEST:WaitThread Exit\n"));
	test2.End();
	test2.Close();
	return KErrNone;
}

////////////////////////////////////////////////////
//// NotifyDataThread :
////			Function writes data into the pipe.
////
////			aData 	  --> Read Write Handle
////
////////////////////////////////////////////////////

TInt NotifyDataThread(TAny* aData) {

	TBufC8<50> 			cTestData(KTestDataNum); 	// Test Data
	TInt 				ret;

	test3.Start(_L("PIPE TEST:NotifyDataThread Entry"));

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

	User::After(10000);

	ret = data.wPipe->Write(cTestData,cTestData.Length());
	test3(ret == cTestData.Length());

	test3.Printf(_L("PIPE TEST:NotifyDataThread Exit\n"));
	test3.End();
	test3.Close();
	return KErrNone;
}

////////////////////////////////////////////////////
//// NotifySpaceThread :
////			Function flush the pipe and makes
////			it free.
////
////			aData 	  --> Read Write Handle
////
////////////////////////////////////////////////////

TInt NotifySpaceThread(TAny* aData) {


	test4.Start(_L("PIPE TEST:NotifySpaceThread Entry"));

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

//	User::After(10000000);

	data.rPipe->Flush();

	test4.Printf(_L("PIPE TEST:NotifySpaceThread Exit\n"));
	test4.End();
	test4.Close();
	return KErrNone;
}


////////////////////////////////////////////////////
//// CancelNotifyThread :
////			Function cancels Space available request
////			or Cancels Data available request.
////
////			CancelFlag  --> 1 CancelSpaceAvailable
////							0 for CancelDataAvailable
////
////			aData 	  --> Read Write Handle
////
////////////////////////////////////////////////////

TInt		CancelFlag; // 1 CancelSpaceAvailable ; 0 for CancelDataAvailable
TInt CancelNotifyThread(TAny* aData) {

	test5.Start(_L("PIPE TEST:CancelNotifyThread Entry"));

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

	if ( CancelFlag == 1)
		data.wPipe->CancelSpaceAvailable();
	else if ( CancelFlag == 0)
		data.rPipe->CancelDataAvailable();
	else
		test5.Printf(_L("PIPE TEST: *** Illegal Cancel\n"));

	test5.Printf(_L("PIPE TEST:CancelNotifyThread Exit\n"));
	test5.End();
	test5.Close();
	return KErrNone;
}

////////////////////////////////////////////////////
//// Main Thread
////
////
////////////////////////////////////////////////////
/*


1. Create 5 (UN)Pipes.
2. Register NotifyData AVailable on 5 pipes.
3. Create Thread 1
4. Wait for n request.
5. In thread 1 write data into any one pipe. Exit
6. Main should show 1 stat variable updated.

7. Again call Wait for n request.
8. It shall come out as one stat is Available.

9. Close all the pipes. Repeat same for NotifySpace available.

10. Define 5 N-Pipes
11. Open write end and call wait till read end open.
12. Create thread 2
12. Wait for n request
13. In thread 2 , open read end of one of the pipe.
14. Main should show 1 stat variable updated.

15. Again call Wait for n request.
16. It shall come out as one stat is Available.

17. Close all the pipes. Destroy pipes.

18. Create 3 N pipe and 2 UN pipes.
19. Register 2 NDA , 2 NSA , 2 Read end wait.
20. Create thread 3 make any request successful.


*/

LOCAL_C void test_MainThread()
{

		RPipe			aReader1,aWriter1;			// Used to pass to thread.
		RPipe			aReader2,aWriter2;			// Used to pass to thread.
		RPipe			aReader3,aWriter3;			// Used to pass to thread.
		RPipe			aReader4,aWriter4;			// Used to pass to thread.
		RPipe			aReader5,aWriter5;			// Used to pass to thread.

		TInt			ret,aSize;
		RThread			thread2;
		RThread			thread3;
		RThread			thread4;
		RThread			thread5;

		TRequestStatus	stat1;
		TRequestStatus	stat2;
		TRequestStatus	stat3;
		TRequestStatus	stat4;
		TRequestStatus	stat5;

		TRequestStatus	s;

		TRequestStatus	*ReqArray[] =
		{
			&stat1,&stat2,&stat3,&stat4,&stat5
		};
		const TBufC<100> 		cPipeName1(KPipe1Name);
		TBufC8<50> 				cTestData(KTestDataNum); 	// Test Data



		test.Printf(_L("PIPE TEST:Main Thread Entry\n"));

//Test	1:

		aSize = 10;
		// Create 5 Pipes.
		ret = RPipe::Create( aSize,	aReader1,aWriter1,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		ret = RPipe::Create( aSize,	aReader2,aWriter2,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		ret = RPipe::Create( aSize,	aReader3,aWriter3,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		ret = RPipe::Create( aSize,	aReader4,aWriter4,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		ret = RPipe::Create( aSize,	aReader5,aWriter5,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		// Register Notification for Data Available for all 5 pipes.
		aReader1.NotifyDataAvailable(stat1);
		aReader2.NotifyDataAvailable(stat2);
		aReader3.NotifyDataAvailable(stat3);
		aReader4.NotifyDataAvailable(stat4);
		aReader5.NotifyDataAvailable(stat5);


		// Pass handles for Pipe# 3
		TData data1(&aReader3,&aWriter3,aSize);

		// Create thread for Writing data into pipe.
		// This will make status variable of respective pipe as AVAILABLE
		ret = thread3.Create(
								KThread3Name, 		// Thread name
								NotifyDataThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data1		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread3.Logon(s);
		test_Equal(KRequestPending, s.Int());

		// Start the Thread
		thread3.Resume();

		// Wait till any of the request status is Avaialble
		User::WaitForNRequest(ReqArray,5);

		// As WaitForNRequest returned. This proves test pass.
		test.Printf(_L("PIPE TEST:Test 1: Pass\n"));

		// Cancel all pending requests for other tests.
		aReader1.CancelDataAvailable();
		aReader2.CancelDataAvailable();
		aReader3.CancelDataAvailable();
		aReader4.CancelDataAvailable();
		aReader5.CancelDataAvailable();

		// Close thread.
		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread3);


//Test	2:

		// Pipes created in Test 1.
		// Write data into all the pipes and Fill it.
		aWriter1.Write(cTestData,cTestData.Length());
		aWriter2.Write(cTestData,cTestData.Length());
		aWriter3.Write(cTestData,cTestData.Length());
		aWriter4.Write(cTestData,cTestData.Length());
		aWriter5.Write(cTestData,cTestData.Length());

		// Register notification for Space availability for all pipes.
			
		aWriter1.NotifySpaceAvailable(aSize,stat1);
		aWriter2.NotifySpaceAvailable(aSize,stat2);
		aWriter3.NotifySpaceAvailable(aSize,stat3);
		aWriter4.NotifySpaceAvailable(aSize,stat4);
		aWriter5.NotifySpaceAvailable(aSize,stat5);


		// Create data object for Pipe# 5.
		TData data2(&aReader5,&aWriter5,aSize);

		// Create thread which will make space available in Pipe.
		//
		ret = thread4.Create(
								KThread4Name, 		// Thread name
								NotifySpaceThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data2		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread4.Logon(s);
		test_Equal(KRequestPending, s.Int());

		// Start the thread.
		thread4.Resume();

		// Wait till any of the status variable status change to Avaialble
		User::WaitForNRequest(ReqArray,5);

		test.Printf(_L("PIPE TEST:Test 2: Pass\n"));

		// Cancel all pending requests.
		aWriter1.CancelSpaceAvailable();
		aWriter2.CancelSpaceAvailable();
		aWriter3.CancelSpaceAvailable();
		aWriter4.CancelSpaceAvailable();
		aWriter5.CancelSpaceAvailable();

		// Close the thread.
		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread4);

//Test	3:
		// Flush all the Pipes.
		// This is needed for NotifyDataAvailable request.
		aReader1.Flush();
		aReader2.Flush();
		aReader3.Flush();
		aReader4.Flush();
		aReader5.Flush();

		// Register NotifyDataAvailable request for all the pipes.
		
		CancelFlag = 0;	// 0 = CanceldataAvailable()
		aReader1.NotifyDataAvailable(stat1);
		aReader2.NotifyDataAvailable(stat2);
		aReader3.NotifyDataAvailable(stat3);
		aReader4.NotifyDataAvailable(stat4);
		aReader5.NotifyDataAvailable(stat5);

		TData data3(&aReader2,&aWriter2,aSize);

		ret = thread5.Create(
								KThread5Name, 		// Thread name
								CancelNotifyThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data3		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread5.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread5.Resume();

		User::WaitForNRequest(ReqArray,5);

		test.Printf(_L("PIPE TEST:Test 3: Pass\n"));
		aReader1.CancelDataAvailable();
		aReader2.CancelDataAvailable();
		aReader3.CancelDataAvailable();
		aReader4.CancelDataAvailable();
		aReader5.CancelDataAvailable();
		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread5);


//Test	4:
		aReader1.Close();
		aWriter1.Close();
		aReader2.Close();
		aWriter2.Close();
		aReader3.Close();
		aWriter3.Close();
		aReader4.Close();
		aWriter4.Close();
		aReader5.Close();
		aWriter5.Close();

		ret = RPipe::Define(KPipe1Name,aSize);
		test_KErrNone(ret);
		ret = RPipe::Define(KPipe2Name,aSize);
		test_KErrNone(ret);
		ret = RPipe::Define(KPipe3Name,aSize);
		test_KErrNone(ret);
		ret = RPipe::Define(KPipe4Name,aSize);
		test_KErrNone(ret);
		ret = RPipe::Define(KPipe5Name,aSize);
		test_KErrNone(ret);

		aWriter1.Open(KPipe1Name,RPipe::EOpenToWrite);
		aWriter2.Open(KPipe2Name,RPipe::EOpenToWrite);
		aWriter3.Open(KPipe3Name,RPipe::EOpenToWrite);
		aWriter4.Open(KPipe4Name,RPipe::EOpenToWrite);
		aWriter5.Open(KPipe5Name,RPipe::EOpenToWrite);

		aWriter1.Wait(KPipe1Name,stat1);
		aWriter2.Wait(KPipe2Name,stat2);
		aWriter3.Wait(KPipe3Name,stat3);
		aWriter4.Wait(KPipe4Name,stat4);
		aWriter5.Wait(KPipe5Name,stat5);

		const TBufC<100> 		cPipeName2(KPipe2Name);

		TData data4(&aReader2,&aWriter2,aSize);
		cPipeName = cPipeName2;

		ret = thread2.Create(
								KThread2Name, 		// Thread name
								WaitThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data4		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread2.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread2.Resume();
		User::WaitForNRequest(ReqArray,5);
		test.Printf(_L("PIPE TEST:Test 4: Pass\n"));
		aWriter1.CancelWait();
		aWriter2.CancelWait();
		aWriter3.CancelWait();
		aWriter4.CancelWait();
		aWriter5.CancelWait();

		aReader1.Close();		aWriter1.Close();
		aReader2.Close();		aWriter2.Close();
		aReader3.Close();		aWriter3.Close();
		aReader4.Close();		aWriter4.Close();
		aReader5.Close();		aWriter5.Close();

		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread2);

//Test	5:

		ret =aWriter1.Open(KPipe1Name,RPipe::EOpenToWrite);
		test_KErrNone(ret);
		aReader1.Close();
		//ret =aWriter1.Wait(KPipe1Name,stat1);
		aWriter1.Wait(KPipe1Name,stat1);

		ret =aWriter2.Open(KPipe2Name,RPipe::EOpenToWrite);
		test_KErrNone(ret);
		ret =aReader2.Open(KPipe2Name,RPipe::EOpenToRead);
		test_KErrNone(ret);
		ret =aWriter2.Write(cTestData,cTestData.Length());
		//ret =aWriter2.NotifySpaceAvailable(aSize,stat2);
		aWriter2.NotifySpaceAvailable(aSize,stat2);

		ret = RPipe::Create( aSize,	aReader3,aWriter3,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		aReader3.Flush();
		//ret =aReader3.NotifyDataAvailable(stat3);
		aReader3.NotifyDataAvailable(stat3);

		ret = RPipe::Create( aSize,	aReader4,aWriter4,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		ret =aWriter4.Write(cTestData,cTestData.Length());
		//ret =aWriter4.NotifySpaceAvailable(aSize,stat4);
		aWriter4.NotifySpaceAvailable(aSize,stat4);

		ret = RPipe::Create( aSize,	aReader5,aWriter5,EOwnerProcess, EOwnerProcess);
		test_KErrNone(ret);
		aReader5.Flush();
		//ret =aReader5.NotifyDataAvailable(stat5);
		aReader5.NotifyDataAvailable(stat5);

		TData data5(&aReader3,&aWriter3,aSize);
		cPipeName = cPipeName2;

		RThread thread6;

		ret = thread6.Create(
								KThread3Name, 		// Thread name
								NotifyDataThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data5		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread6.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread6.Resume();
		User::WaitForNRequest(ReqArray,5);
		test.Printf(_L("PIPE TEST:Test 5: Pass\n"));

		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread6);
//Test	6:

		TData data6(&aReader2,&aWriter2,aSize);
		cPipeName = cPipeName2;

		RThread thread7;

		ret = thread7.Create(
								KThread3Name, 		// Thread name
								NotifySpaceThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data6		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread7.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread7.Resume();

		User::WaitForNRequest(ReqArray,5);
		test.Printf(_L("PIPE TEST:Test 6: Pass\n"));


		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread7);

//Test	7:
		TData data7(&aReader1,&aWriter1,aSize);
		cPipeName = cPipeName1;

		RThread thread8;

		ret = thread8.Create(
								KThread2Name, 		// Thread name
								WaitThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data7		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread8.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread8.Resume();

		User::WaitForNRequest(ReqArray,5);
		test.Printf(_L("PIPE TEST:Test 7: Pass\n"));


		User::WaitForRequest(s);
//		CLOSE_AND_WAIT(thread8);	DOESN'T WORK SINCE PIPE DRIVER KEEPS THE THREAD OPEN
		thread8.Close();

//Test	8:
		TData data8(&aReader4,&aWriter4,aSize);

		RThread thread9;
		
		CancelFlag = 1;	// 1 = CancelSpaceAvailable()

		ret = thread9.Create(
								KThread4Name, 		// Thread name
								CancelNotifyThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data8		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread9.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread9.Resume();

		User::WaitForNRequest(ReqArray,5);
		test.Printf(_L("PIPE TEST:Test 8: Pass\n"));

		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread9);

//Test	9:
		TData data9(&aReader5,&aWriter5,aSize);

		RThread thread10;

		CancelFlag = 0;	// 0 = CancelDataAvailable()

		ret = thread10.Create(
								KThread5Name, 		// Thread name
								CancelNotifyThread,			// Function to be called
								KDefaultStackSize,
								KHeapSize,
								KHeapSize,
								(TAny *)&data9		// Data object containing Pipe information.
							);
		test_KErrNone(ret);
		thread10.Logon(s);
		test_Equal(KRequestPending, s.Int());
		thread10.Resume();

		
		User::WaitForNRequest(ReqArray,5);
		test.Printf(_L("PIPE TEST:Test 9: Pass\n"));

		User::WaitForRequest(s);
		CLOSE_AND_WAIT(thread10);


		aReader1.Close();		aWriter1.Close();
		aReader2.Close();		aWriter2.Close();
		aReader3.Close();		aWriter3.Close();
		aReader4.Close();		aWriter4.Close();
		aReader5.Close();		aWriter5.Close();
		ret = RPipe::Destroy(KPipe1Name);
		test_KErrNone(ret);
		ret = RPipe::Destroy(KPipe2Name);
		test_KErrNone(ret);
		ret = RPipe::Destroy(KPipe3Name);
		test_KErrNone(ret);
		ret = RPipe::Destroy(KPipe4Name);
		test_KErrNone(ret);
		ret = RPipe::Destroy(KPipe5Name);
		test_KErrNone(ret);
		
		
		test.Printf(_L("PIPE TEST:Main Thread Exit\n"));
		return;



}

////////////////////////////////////////////////////
//// RunTests:
////
////
////////////////////////////////////////////////////
LOCAL_C void RunTests(void)
{

	test.Start(_L("PIPE TEST: Testing WaitForNRequest"));

	test_MainThread();

	test.Printf(_L("PIPE TEST: Ending test.\n"));

	test.End();
	test.Close();
	return;
}


////////////////////////////////////////////////////
//// E32Main : Main entry point to test.
////
////
////////////////////////////////////////////////////


GLDEF_C TInt E32Main()

{
	TInt		ret = 0;

	ret = RPipe::Init();
	
	if (ret != KErrNone && ret != KErrAlreadyExists)
	{
	test.Printf(_L(" t_pipe4.exe PIPE TEST: Error loading driver %d\n"),ret);
	test.Printf(_L(" Exiting t_pipe4.exe\n"));

	return KErrNone;

	}
	RunTests();

	TName pddName1(RPipe::Name());
	
	ret= User::FreeLogicalDevice(pddName1);
	
	return KErrNone;
	
}