--- /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;
+ }