--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/stack/t_stacksize.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,335 @@
+// Copyright (c) 2003-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\stack\t_stacksize.cpp
+// Overview:
+// Verifies the correct implementation of CreateStackOverride method of RProcess.
+// Meanings of constants:
+// KDefaultStackSize:
+// - System wide default stack size in actual version;
+// KNumberOfFitIteration:
+// - Number of DummyRecursion which can fit in KDefaultStackSize.
+// Value = KDefaultStackSize / 2KB - 1
+// KNumberOfUnfitIteration:
+// - Number of DummyRecursion which is raised a Panic based on stack overflow.
+// Value = KDefaultStackSize / 2KB rounded up to nearest integer
+// Details:
+// ETestProcess1: Create a process with original RProcess::Create() and start it
+// - it passes with KNumberOfFitIteration DummyRecursion .
+// ETestProcess2: Create a process with RProcess::CreateWithStackOverride(), default
+// stack size and start it
+// - it passes with KNumberOfFitIteration DummyRecursion.
+// ETestProcess3: Create a process with original RProcess::Create() and start it
+// - it raised Panic on Stack overflow with KNumberOfUnfitIteration DummyRecursion.
+// ETestProcess4: Create a process with RProcess::CreateWithStackOverride(), default
+// stack size and start it
+// - it raised Panic on Stack overflow with KNumberOfUnfitIteration DummyRecursion.
+// ETestProcess5: Create a process with RProcess::CreateWithStackOverride(), 2*KDefaultStackSize
+// stack and start it
+// - it passes with KNumberOfUnfitIteration DummyRecursion.
+// ETestProcess6: Create a process with RProcess::CreateWithStackOverride(), -2*KDefaultStackSize
+// stack.
+// - the process creation interrupted with KErrArgument error code
+// ETestProcess7: Create a process with RProcess::CreateWithStackOverride(), KDefaultStackSize/2
+// stack and start it
+// - it passes with KNumberOfFitIteration DummyRecursion, because the process will be
+// create with (App. image) default stack size.
+// Platforms/Drives/Compatibility:
+// It is won't work on emulator, because the unlimited stack size.
+// Assumptions/Requirement/Pre-requisites:
+// No
+// Failures and causes:
+// Failures of this test will indicate defects in the implementation of CreateWithStackOverride().
+// Base Port information:
+// No?
+//
+//
+
+#include <e32test.h>
+#include "u32std.h"
+#include <u32hal.h>
+#include <e32svr.h>
+
+LOCAL_D RTest test(_L("T_STACKSIZE"));
+LOCAL_D RTest test2(_L("*** T_STACKSIZE SLAVE ***"));
+
+const TInt KNumberOfFitIteration = KDefaultStackSize / 2048 - 1;
+const TInt KNumberOfUnfitIteration = (KDefaultStackSize + 2047) / 2048;
+
+enum TTestProcessFunctions
+ {
+ ETestProcess1,
+ ETestProcess2,
+ ETestProcess3,
+ ETestProcess4,
+ ETestProcess5,
+ ETestProcess6,
+ ETestProcess7,
+ };
+
+class RTestProcess : public RProcess
+ {
+public:
+ TInt Create(TTestProcessFunctions aFunction, TInt aStackSize=0, TInt aArg1=-1,TInt aArg2=-1);
+ };
+
+TInt RTestProcess::Create(TTestProcessFunctions aFunction, TInt aStackSize, TInt aArg1,TInt aArg2)
+ {
+
+ test.Printf(_L("RTestProcess::Create started with stack size:%d bytes\n")
+ , (0 == aStackSize ? KDefaultStackSize : aStackSize )
+ );
+ if(aArg1==-1)
+ aArg1 = RProcess().Id();
+ TBuf<512> commandLine;
+ commandLine.Num((TInt)aFunction);
+ commandLine.Append(_L(" "));
+ commandLine.AppendNum(aArg1);
+ commandLine.Append(_L(" "));
+ commandLine.AppendNum(aArg2);
+
+ TFileName filename(RProcess().FileName());
+ TInt pos=filename.LocateReverse(TChar('\\'));
+ filename.SetLength(pos+1);
+ filename+=_L("T_STACKSIZE.EXE");
+
+ TInt r=KErrNone;
+ switch (aFunction)
+ {
+ case ETestProcess1:
+ test.Printf(_L("Call original Create.\n"));
+ r = RProcess::Create(filename,commandLine);
+ break;
+
+ case ETestProcess2:
+ test.Printf(_L("Call CreateWithStackOverride\n"));
+ r = RProcess::CreateWithStackOverride(filename, commandLine, TUidType(), aStackSize, EOwnerProcess);
+ break;
+
+ case ETestProcess3:
+ test.Printf(_L("Call original Create.\n"));
+ r = RProcess::Create(filename,commandLine);
+ break;
+
+ case ETestProcess4:
+ test.Printf(_L("Call CreateWithStackOverride\n"));
+ r = RProcess::CreateWithStackOverride(filename, commandLine, TUidType(), aStackSize, EOwnerProcess);
+ break;
+
+ case ETestProcess5:
+ test.Printf(_L("Call CreateWithStackOverride\n"));
+ r = RProcess::CreateWithStackOverride(filename, commandLine, TUidType(), aStackSize, EOwnerProcess);
+ break;
+
+ case ETestProcess6:
+ test.Printf(_L("Call CreateWithStackOverride\n"));
+ r = RProcess::CreateWithStackOverride(filename, commandLine, TUidType(), aStackSize, EOwnerProcess);
+ break;
+
+ case ETestProcess7:
+ test.Printf(_L("Call CreateWithStackOverride\n"));
+ r = RProcess::CreateWithStackOverride(filename, commandLine, TUidType(), aStackSize, EOwnerProcess);
+ break;
+
+ default:
+ User::Panic(_L("T_STACKSIZE"),1);
+
+ }
+
+ test.Printf(_L("RTestProcess::Create end.\n"));
+ return r;
+ }
+
+
+TInt DummyRecursion(TInt aA)
+ {
+ TBuf8<2040> gobble; // gobble 2K of stack
+ gobble.Append(TChar(aA)); // stop compiler optimising out gobble buffer
+ if (aA <= 1)
+ return aA;
+ return 1 + DummyRecursion(aA-1);
+ }
+
+TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)
+ {
+ (void)aArg1;
+ (void)aArg2;
+
+
+ switch(aTestNum)
+ {
+ case ETestProcess1:
+ {
+ test2.Printf(_L("ETestProcess1 started with %d recursion...\n"), KNumberOfFitIteration);
+ test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
+ break;
+ }
+
+ case ETestProcess2:
+ {
+ test2.Printf(_L("ETestProcess2 started with %d recursion...\n"), KNumberOfFitIteration);
+ test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
+ break;
+ }
+
+ case ETestProcess3:
+ {
+ test2.Printf(_L("ETestProcess3 started with %d recusion...\n"), KNumberOfUnfitIteration);
+ test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
+ break;
+ }
+
+ case ETestProcess4:
+ {
+ test2.Printf(_L("ETestProcess4 started with %d recursion...\n"), KNumberOfUnfitIteration);
+ test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
+ break;
+ }
+
+ case ETestProcess5:
+ {
+ test2.Printf(_L("ETestProcess5 started with %d recursion...\n"), KNumberOfUnfitIteration);
+ test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
+ break;
+ }
+
+ case ETestProcess6:
+ {
+ test2.Printf(_L("ETestProcess6 started with %d recursion...\n"), KNumberOfFitIteration);
+ test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
+ break;
+ }
+
+ case ETestProcess7:
+ {
+
+ test2.Printf(_L("ETestProcess7 started with %d recursion\n"), KNumberOfFitIteration);
+ test2.Printf(_L("(it is raised a Panic with %d bytes stack)...\n"), KDefaultStackSize/2);
+ test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
+ break;
+ }
+
+ default:
+ User::Panic(_L("T_STACKSIZE"),1);
+ }
+
+ test2.Printf(_L("\n\t finished.\n"));
+
+ return KErrNone;
+ }
+
+GLDEF_C TInt E32Main()
+ {
+
+
+ TBuf16<512> cmd;
+ User::CommandLine(cmd);
+ if(cmd.Length() && TChar(cmd[0]).IsDigit())
+ {
+ test2.Title();
+ test2.Start(_L("Slave process started..."));
+ TInt function = -1;
+ TInt arg1 = -1;
+ TInt arg2 = -1;
+ TLex lex(cmd);
+ lex.Val(function);
+ lex.SkipSpace();
+ lex.Val(arg1);
+ lex.SkipSpace();
+ lex.Val(arg2);
+ int r = DoTestProcess(function,arg1,arg2);
+ test2.End();
+ return r;
+ }
+
+ test.Title();
+
+ RTestProcess rogueP;
+ TRequestStatus rendezvous;
+
+ test.Start(_L("Create process with original Create and default stack size"));
+ TInt r = rogueP.Create(ETestProcess1, 0 );
+ test(r==KErrNone);
+ rogueP.Rendezvous(rendezvous);
+ rogueP.Resume();
+ User::WaitForRequest(rendezvous);
+ test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
+ test(rogueP.ExitType()==EExitKill);
+
+ test.Next(_L("Create process with CreateWithStackOverride and default stack size"));
+ r = rogueP.Create(ETestProcess2, 0 );
+ test(r==KErrNone);
+ rogueP.Rendezvous(rendezvous);
+ rogueP.Resume();
+ User::WaitForRequest(rendezvous);
+ test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
+ test(rogueP.ExitType()==EExitKill);
+
+ test.Next(_L("Create process with original Create and default stack size"));
+ r = rogueP.Create(ETestProcess3, 0 );
+ test(r==KErrNone);
+ rogueP.Rendezvous(rendezvous);
+ rogueP.Resume();
+ User::WaitForRequest(rendezvous);
+ test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
+#if !defined(__WINS__)
+ test(rogueP.ExitType()==EExitPanic);
+#else
+ test(rogueP.ExitType()==EExitKill);
+#endif
+
+ test.Next(_L("Create process with CreateWithStackOverride and default stack size"));
+ r = rogueP.Create(ETestProcess4, 0 );
+ test(r==KErrNone);
+ rogueP.Rendezvous(rendezvous);
+ rogueP.Resume();
+ User::WaitForRequest(rendezvous);
+ test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
+
+#if !defined(__WINS__)
+ test(rogueP.ExitType()==EExitPanic);
+#else
+ test(rogueP.ExitType()==EExitKill);
+#endif
+
+
+ test.Next(_L("Create process with CreateWithStackOverride and 2 * KDefaultStackSize stack size"));
+ r = rogueP.Create(ETestProcess5, 2 * KDefaultStackSize );
+ test(r==KErrNone);
+ rogueP.Rendezvous(rendezvous);
+ rogueP.Resume();
+ User::WaitForRequest(rendezvous);
+ test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
+ test(rogueP.ExitType()==EExitKill);
+
+#if !defined(__WINS__)
+ test.Next(_L("Create process with CreateWithStackOverride and negative stack size"));
+ r = rogueP.Create(ETestProcess6, - 2 * KDefaultStackSize );
+ test(r==KErrArgument);
+#endif
+
+ test.Next(_L("Create process with CreateWithStackOverride and KDefaultStackSize/2 stack size"));
+ r = rogueP.Create(ETestProcess7, KDefaultStackSize / 2 );
+ test(r==KErrNone);
+ rogueP.Rendezvous(rendezvous);
+ rogueP.Resume();
+ User::WaitForRequest(rendezvous);
+ test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
+ test(rogueP.ExitType()==EExitKill);
+
+ test.Printf(_L("Test finished.\n"));
+ test.End();
+
+ return(0);
+ }
+