diff -r 000000000000 -r a41df078684a kerneltest/e32test/system/t_env.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/system/t_env.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,414 @@
+// 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;
+    }