// Copyright (c) 1994-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\system\t_env.cpp

 // Overview:

 // Test RProcess parameters

 // API Information:

 // RProcess

 // Details:

 // - Create a thread that causes a variety of panics. Verify that the exit

 // reason is as expected.

 // - Create a process that causes a variety of panics. Verify that the results

 // are as expected.

 // - Test passing 16 bit and 8 bit descriptors to another process. Verify the 

 // text and other results are as expected.

 // - Verify that an invalid read of a descriptor by a process causes a panic.

 // - Test passing zero length data to a separate process works as expected.

 // - Test that passing each of a mutex, semaphore, file handle and chunk to a 

 // separate process works as expected.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32test.h>

 #include <e32panic.h>

 #include <e32msgqueue.h>

 #include <d32comm.h>

 #include <f32file.h>

 #if defined (__WINS__)

 #define PDD_NAME _L("ECDRV.PDD")

 #define LDD_NAME _L("ECOMM.LDD")

 #else

 #define PDD_NAME _L("EUART")

 #define LDD_NAME _L("ECOMM")

 #endif

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

 _LIT(KProcName, "t_env_child.exe");

 _LIT(KThreadName, "t_env_panic_thread");

 _LIT(KQueueName, "testqueue");

 _LIT(KMutexName, "testmutex");

 _LIT(KSemName, "testsemaphore");

 _LIT(KChunkName, "testchunk");

 _LIT(KFileName, "c:\\testfile");

 const TInt KHeapSize=0x2000;

 class TData 

 	{

 public:

 	TData(TInt aTest, RProcess& aProcess);

 	TInt iTest;

 	RProcess& iProcess;

 	};

 TData::TData(TInt aTest, RProcess&  aProcess) :	iTest(aTest), iProcess(aProcess)

 	{

 	//empty

 	};

 class Handles

 	{

 	public:

 	void SetupParameters(RProcess& aNewProcess);

 	Handles();

 	~Handles();

 	void Command(TInt aCommand);

 	public:

 	RMsgQueue<TInt> iCommandQueue;

 	RMsgQueue<TInt> iIntQueue;

 	RMutex iMutex;

 	RSemaphore iSem;

 	RChunk iChunk;

 	RFile iFile;

 	RFs iSession;

 	};

 void Handles::Command(TInt aC)

 	{

 	iCommandQueue.SendBlocking(aC);

 	}

 void Handles::SetupParameters(RProcess& aNewProcess)

 	{

 	aNewProcess.SetParameter(1, iCommandQueue);

 	aNewProcess.SetParameter(2, iIntQueue);

 	aNewProcess.SetParameter(3, iMutex);

 	aNewProcess.SetParameter(4, iSem);

 	aNewProcess.SetParameter(5, iChunk);

 	aNewProcess.SetParameter(7, iSession);

 	aNewProcess.SetParameter(8, iFile);

 	}

 _LIT8(KTestData,"test data");

 Handles::Handles()

 	{

 	TInt ret = iCommandQueue.CreateGlobal(KNullDesC, 10, EOwnerProcess);

 	test(ret == KErrNone);

 	ret = iIntQueue.CreateGlobal(KQueueName,1);

 	test(ret == KErrNone);

 	ret = iMutex.CreateGlobal(KMutexName);

 	test(ret == KErrNone);

 	ret = iSem.CreateGlobal(KSemName,0);

 	test(ret == KErrNone);

 	ret = iChunk.CreateGlobal(KChunkName, 1024, 2048);

 	test(ret == KErrNone);

 	ret = iSession.Connect();

 	test(ret == KErrNone);

 	ret = iSession.ShareProtected();

 	test(ret == KErrNone);

 	ret = iFile.Open(iSession, KFileName, EFileStreamText|EFileWrite|EFileShareAny); 

 	if (ret == KErrNotFound) // file does not exist - create it 

 		ret = iFile.Create(iSession, KFileName, EFileStreamText|EFileWrite|EFileShareAny);

 	test(ret == KErrNone);

 	ret = iFile.Write(0, KTestData);

 	test(ret == KErrNone);

 	}

 Handles::~Handles()

 	{

 	iCommandQueue.Close();

 	iIntQueue.Close();

 	iMutex.Close();

 	iSem.Close();

 	iChunk.Close();

 	iSession.Close();

 	}

 LOCAL_C TInt testSetParameterPanics(TAny* aData)

 	{

 	const TData* data = (const TData*)aData;

 	switch (data->iTest)

 		{

 		case 0:	//try and pass a non local handle

 			{

 			RMsgQueue<TInt> localMsgQueue;

 			localMsgQueue.CreateLocal(1);

 			data->iProcess.SetParameter(1, localMsgQueue);	//should panic with plat security panic

 			break;

 			}

 		case 1:	//out of range slot

 			{

 			RMsgQueue<TInt> globalMsgQueue;

 			globalMsgQueue.CreateGlobal(KNullDesC, 1);

 			data->iProcess.SetParameter(-1, globalMsgQueue);	//should panic with range error

 			break;

 			}

 		case 2:

 			{

 			RMsgQueue<TInt> globalMsgQueue;

 			globalMsgQueue.CreateGlobal(KNullDesC, 1);

 			data->iProcess.SetParameter(1234, globalMsgQueue);	//should panic with range error

 			break;

 			}

 		case 3:	//in use 

 			{

 			RMsgQueue<TInt> globalMsgQueue;

 			globalMsgQueue.CreateGlobal(KNullDesC, 1);

 			data->iProcess.SetParameter(1, globalMsgQueue);

 			data->iProcess.SetParameter(1, globalMsgQueue);	//panic, in use

 			break;

 			}

 		case 4:

 			{

 			TPtrC8 bad((const TUint8*)0xfeed,4);

 			data->iProcess.SetParameter(1, bad);

 			break;

 			}

 		case 5:	//slot 0 is for the command line

 			{

 			RMsgQueue<TInt> globalMsgQueue;

 			globalMsgQueue.CreateGlobal(KNullDesC, 1);

 			data->iProcess.SetParameter(0, globalMsgQueue);	//panic, in use

 			break;

 			}

 		}

 	return KErrNone;

 	}

 GLDEF_C TInt E32Main()

     {

 	test.Title();

 	test.Start(_L("Process Parameters"));

 	test.Next(_L("Test Panics on a set"));

 	TBool jit = User::JustInTime();

 	User::SetJustInTime(EFalse);

 	TInt i;

 	RProcess p;

 	TInt ret = p.Create(KProcName, KProcName);

 	test(ret == KErrNone);

 	for (i = 0; i < 6; i++)

 		{

 		test.Printf(_L("panic test number %d\n"), i);

 		TData data(i, p);

 		RThread thread;

 		ret = thread.Create(KThreadName, testSetParameterPanics, KDefaultStackSize, KHeapSize, KHeapSize, &data);

 		test(KErrNone == ret);

 		TRequestStatus stat;

 		thread.Logon(stat);

 		thread.Resume();

 		User::WaitForRequest(stat);

 		test.Printf(_L("exit type is %d, stat is %d"), thread.ExitType(), stat.Int());

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

 		switch (i)

 			{

 			case 0:

 			test (thread.ExitReason() == EPlatformSecurityTrap);

 			break;

 			case 1:

 			case 2:

 			test (thread.ExitReason() == EParameterSlotRange);

 			break;

 			case 3:

 			case 5:

 			test (thread.ExitReason() == EParameterSlotInUse);

 			break;

 			case 4:

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

 			break;

 			}

 		CLOSE_AND_WAIT(thread);

 		}

 	p.Kill(0);	

 	CLOSE_AND_WAIT(p);

 	test.Next(_L("launch panicing process"));

 	Handles h;	

 	TRequestStatus stat;

 	for (i = 0; i < 1; i++)

 		{

 		h.Command(i);

 		ret = p.Create(KProcName, KNullDesC);

 		test(ret == KErrNone);

 		p.Logon(stat);

 		h.SetupParameters(p);

 		p.Resume();

 		User::WaitForRequest(stat);

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

 		test(p.ExitReason()==EParameterSlotRange);

 		CLOSE_AND_WAIT(p);

 		}

 	User::SetJustInTime(jit);

 	test.Next(_L("test 16 bit descriptor"));

 	h.Command(8);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.SetParameter(15, _L("16 bit text"));

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

 	test.Next(_L("test 8 bit descriptor"));

 	h.Command(9);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.SetParameter(15, _L8("8 bit text"));

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

 	test.Next(_L("test bad read of descriptor"));

 	h.Command(10);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.SetParameter(15, _L8("aa"));

 	p.Resume();

 	User::WaitForRequest(stat);

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

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

 	CLOSE_AND_WAIT(p);

 	test.Next(_L("test zero length data"));

 	h.Command(11);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.SetParameter(15, KNullDesC);

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

 	test.Next(_L("test reserved command line"));

 	h.Command(12);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

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

 	h.Command(4);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

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

 	h.Command(5);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

 	test.Next(_L("test file handle"));

 	h.Command(6);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

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

 	h.Command(7);

 	ret = p.Create(KProcName, KNullDesC);

 	test(ret == KErrNone);

 	p.Logon(stat);

 	h.SetupParameters(p);

 	p.Resume();

 	User::WaitForRequest(stat);

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

 	test(p.ExitReason()==KErrNone);

 	CLOSE_AND_WAIT(p);

 	test.End();

 	return 0;

     }