// Copyright (c) 1996-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\bench\t_proc1.cpp

// One half of the process relative type test stuff

// Overview:

// Tests the RProcess class, including tests on the heap, process naming, 

// process resumption, process creation and shared chunks. 

// API Information:

// RProcess

// Details:

// - Open a nonexistent process by a process Id and checks for the failure 

// of finding this process.

// - Open a process with invalid name and verify failure results are as expected.

// - Test the closing of processes by calling Kill, Terminate, and Panic methods.

// Verify results are as expected.

// - Create a process and verify the full path name of the loaded executable on 

// which this process is based.

// - Open a process by name, rename the process in a variety of ways and verify 

// the results are as expected.

// - Open a process, assign high, low, and bad priorities, verify the results

// are as expected.

// - Open a process, kill it and verify the results are as expected.

// - Open a process by name based on the file name, verify the results are as 

// expected.

// - Retrieve the process Id and open a handle on it. Create a duplicate process.

// Verify the results are as expected.

// - Find a process using TFindProcess() and open a handle on it. Verify the

// results are as expected.

// - Check chunk sharing between threads and verify results are as expected.

// - Perform a "speed" test where a new thread is created and the thread increments

// a count until stopped. Calculate and display counts per second. Verify results

// are as expected.

// - Verify the ExitReason, ExitType and ExitCatagory when the thread dies.

// - Verify that stopping the process completes existing pending requests with 

// KErrServerTerminated.

// - Verify that the heap was not corrupted by the tests.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include "../mmu/mmudetect.h"

#include "t_proc.h"

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

const TBufC<67> tooLong=_L("This should return KErrBadName and not crash.......0123456789ABCDEF");

const TBufC<66> notQuiteTooLong=_L("This should return KErrNone and be completely OK..0123456789ABCDEF");

const TBufC<26> bond=_L("Bond, James Bond[00000000]");

const TBufC<16> jamesBond=_L("Bond, James Bond");

RProcess proc;

RProcess proc2;

RProcess proc3;

RProcess proc4;

TName command;

TRequestStatus stat,notStat;

const TInt KKillReason=2563453;

const TInt KTerminateReason=8034255;

const TInt KPanicReason=39365235;

LOCAL_D RSemaphore client;

LOCAL_D TInt speedCount;

class RDisplay : public RSessionBase

	{

public:

	TInt Open();

	TInt Display(const TDesC& aMessage);

	TInt Read();

	TInt Write();

	TInt Stop();

	TInt Test();

	TVersion Version();

	};

TInt RDisplay::Open()

//

// Open the server.

//

	{

	return(CreateSession(_L("Display"),Version(),1));

	}

TInt RDisplay::Display(const TDesC& aMessage)

//

// Display a message.

//

	{

	TBuf<0x10> b(aMessage);

	return(SendReceive(CMyServer::EDisplay,TIpcArgs(&b)));

	}

TInt RDisplay::Read()

//

// Get session to test CSession2::ReadL.

//

	{

	TBuf<0x10> b(_L("Testing read"));

	return(SendReceive(CMyServer::ERead,TIpcArgs(&b)));

	}

TInt RDisplay::Write()

//

// Get session to test CSession2::WriteL.

//

	{

	TBuf<0x10> b;

    TBufC<0x10> c; // Bad descriptor - read only

	TInt r=SendReceive(CMyServer::EWrite,TIpcArgs(&b,&c));

	if (r==KErrNone && b!=_L("It worked!"))

		r=KErrGeneral;

	return r;

	}

TInt RDisplay::Test()

//

// Send a message and wait for completion.

//

	{

	TInt i[4];

	return(SendReceive(CMyServer::ETest,TIpcArgs(&i[0])));

	}

TInt RDisplay::Stop()

//

// Stop the server.

//

	{

	TInt i[4];

	return(SendReceive(CMyServer::EStop,TIpcArgs(&i[0])));

	}

TVersion RDisplay::Version()

//

// Return the current version.

//

	{

	TVersion v(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	return(v);

	}

LOCAL_C TInt RunPanicThread(RThread& aThread)

	{

	TRequestStatus s;

	aThread.Logon(s);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	aThread.Resume();

	User::WaitForRequest(s);

	User::SetJustInTime(jit);

	return s.Int();

	}

TInt KillProtectedEntry(TAny*)

	{

	proc.Kill(KErrGeneral);

	return KErrGeneral;

	}

TInt createProc2(RProcess& aProcess)

	{

	TFileName filename(RProcess().FileName());

	TInt pos=filename.LocateReverse(TChar('\\'));

	filename.SetLength(pos+1);

	filename+=_L("T_PROC2.EXE");

	TInt r=aProcess.Create(filename, command);

	if (r==KErrNone)

		{

		TFullName fn(aProcess.FullName());

		test.Printf(_L("Created %S\n"),&fn);

		}

	return r;

	}

void simpleTests1()

	{

	test.Next(_L("Open by name"));

	RProcess me;

	TInt r=proc2.Open(me.Name());

	test(r==KErrNone);

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

	TName initName(me.Name());

	r=User::RenameProcess(jamesBond);

	test(r==KErrNone);

	test(me.Name().Left(26)==bond);

	test(proc2.Name().Left(26)==bond);

	r=User::RenameProcess(tooLong);

	test(r==KErrBadName);

	test(me.Name().Left(26)==bond);

	test(proc2.Name().Left(26)==bond);

	TName* work=new TName(notQuiteTooLong);

	r=User::RenameProcess(*work);

	test(r==KErrNone);

	work->Append(_L("[00000000]"));

	test(me.Name().Length()==KMaxKernelName);

	test(me.Name().Left(KMaxKernelName-4)==*work);

	test(proc2.Name().Length()==KMaxKernelName);

	test(proc2.Name().Left(KMaxKernelName-4)==*work);

	delete work;

	r=User::RenameProcess(_L("T_PROC1"));

	test(r==KErrNone);

	TFullName fn(_L("T_PROC1["));

	TUidType uidType(me.Type());

	TUint32 uid3 = uidType[2].iUid;

	fn.AppendNumFixedWidth(uid3,EHex,8);

	fn.Append(']');

	test(proc2.Name().Left(17)==fn);

	test(me.Name().Left(17)==fn);

	TInt l = initName.Locate('[');

	r=User::RenameProcess(initName.Left(l));

	test(r==KErrNone);

	test(proc2.Name()==initName);

	proc2.Close();

	}

TInt BadPriority(TAny* proc2)

	{

	((RProcess*)proc2)->SetPriority(EPriorityWindowServer);

	return KErrNone; 

	}

void simpleTests2()

	{

	TInt r=proc2.Open(proc.Name());

	test.Next(_L("Mess with Priority"));

	proc.SetPriority(EPriorityHigh);

	test.Printf(_L("%d %d\n"),proc.Priority(),proc2.Priority());

	test(proc.Priority()==EPriorityHigh);

	test(proc2.Priority()==EPriorityHigh);

	proc2.SetPriority(EPriorityLow);

	test(proc.Priority()==EPriorityLow);

	test(proc2.Priority()==EPriorityLow);

	RThread thread;

	r=thread.Create(_L("Bad Priority"),BadPriority,KDefaultStackSize,NULL,&proc2);

	test(r==KErrNone);

	r=RunPanicThread(thread);

	test(r==EBadPriority);

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

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

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	CLOSE_AND_WAIT(thread);

	test(proc.Priority()==EPriorityLow);

	test(proc2.Priority()==EPriorityLow);

	proc2.Close();

	}

void procTests1()

	{

	test.Next(_L("Test functions"));

    TFileName fileName(proc.FileName());

    test.Printf(fileName);

#ifndef __WINS__

	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		test(fileName.Mid(1).CompareF(_L(":\\Sys\\Bin\\T_PROC2.EXE"))==0);

	else

		test(fileName.Mid(1).CompareF(_L(":\\System\\Bin\\T_PROC2.EXE"))==0);

#else

	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		test(fileName.CompareF(_L("Z:\\Sys\\Bin\\T_PROC2.EXE"))==0);

	else

		test(fileName.CompareF(_L("Z:\\System\\Bin\\T_PROC2.EXE"))==0);

#endif

	test(proc.Name().Left(21).CompareF(_L("T_PROC2.EXE[00000000]"))==0);

	test(proc.Priority()==EPriorityForeground);

	test(proc.ExitType()==EExitPending);

	test(proc.ExitReason()==0);

	test(proc.ExitCategory()==KNullDesC);

	}

void procTests2()

	{

	test.Next(_L("Kill and recreate"));

	RProcess proc2;

	TInt r=proc2.Open(proc.Id());

	test(r==KErrNone);

	test(proc2.Handle()!=0);

	proc.Logon(stat);

	proc.Logon(notStat);

	r=proc.LogonCancel(notStat);

	test(r==KErrNone);

	test(notStat==KErrNone);

	proc.Kill(KKillReason);

	User::WaitForRequest(stat);

	test(stat==KKillReason);

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

	test(proc.ExitReason()==KKillReason);

	test(proc.ExitCategory()==_L("Kill"));

	proc.Close();

	test(proc.Handle()==0);

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

	test(proc2.ExitReason()==KKillReason);

	test(proc2.ExitCategory()==_L("Kill"));

	CLOSE_AND_WAIT(proc2);

	test(proc2.Handle()==0);

	}

void procTests3()

	{

	TFileName filename(RProcess().FileName());

	TInt pos=filename.LocateReverse(TChar('\\'));

	filename.SetLength(pos+1);

	filename+=_L("T_PROC2.EXE");

	TInt r=proc.Create(filename, command);

	test(r==KErrNone);

	TFullName fn(proc.FullName());

	test.Printf(_L("Created %S\n"),&fn);

	test(proc.FileName().CompareF(filename)==0);

	test(proc.Name().Left(21).CompareF(_L("T_PROC2.EXE[00000000]"))==0);

	test(proc.Priority()==EPriorityForeground);

	test(proc.ExitType()==EExitPending);

	test(proc.ExitReason()==0);

	test(proc.ExitCategory()==KNullDesC);

	}

void procTests4()

	{

	test.Next(_L("Get and open by Id"));

	TProcessId id=proc.Id();

	TProcessId id2=proc.Id();

	test(id==id2);

	TInt r=proc2.Open(proc.Name());

	test(r==KErrNone);

	id2=proc2.Id();

	test(id==id2);

	r=proc3.Open(id);

	test(r==KErrNone);

	id2=proc3.Id();

	test(id==id2);

	proc3.Close();

	if (HaveVirtMem())

		{

		test.Next(_L("Create duplicate"));

		r=createProc2(proc3);

		test(r==KErrNone);

		id2=proc3.Id();

		test(id!=id2);

		test(*(TUint*)&id<*(TUint*)&id2);

		}

	}

void procTests5()

	{

	test.Next(_L("Try to find processes"));

	TFindProcess* findProc=new TFindProcess(_L("T_PROC2*"));

	test(findProc!=NULL);

	TFullName* result=new TFullName;

	test(result!=NULL);

	TInt r=findProc->Next(*result);

	test(r==KErrNone);

	TFullName temp = proc.FullName();

	test(result->CompareF(temp)==0);

	r=findProc->Next(*result);

	test(r==KErrNone);

	test(result->CompareF(proc3.FullName())==0);

	r=findProc->Next(*result);

	test(r==KErrNotFound);

	findProc->Find(_L("T?PROC2*]*"));

	r=findProc->Next(*result);

	test(r==KErrNone);

	test(result->CompareF(temp)==0);

	r=findProc->Next(*result);

	test(r==KErrNone);

	test(result->CompareF(proc3.FullName())==0);

	delete result;

	test.Next(_L("Open by find handle"));

	r=proc4.Open(*findProc);

	test(r==KErrNone);

	TProcessId id=proc3.Id();

	TProcessId id2=proc4.Id();

	test(id==id2);

	delete findProc;

	}

void procTests6()

	{

	test.Next(_L("Kill duplicate"));

	proc3.Logon(stat);

	test(stat==KRequestPending);

	proc4.Kill(12345);

	User::WaitForRequest(stat);

	test(stat==12345);

	}

void createProcess()

//

// Create T_PROC2 and, on the way, do lots of basic tests

//

	{

	test.Start(_L("Create"));

	TInt r=globSem1.CreateGlobal(_L("GlobSem1"), 0);

	test(r==KErrNone);

	r=globSem2.CreateGlobal(_L("GlobSem2"), 0);

	test(r==KErrNone);

	r=createProc2(proc);

	test(r==KErrNone);

	procTests1();

	simpleTests1();

	simpleTests2();

	procTests2();

	procTests3();

	procTests4();

	if (HaveVirtMem())

		{

		procTests5();

		procTests6();

		}

	proc2.Close();

	proc3.Close();

	if (proc4.Handle())

		CLOSE_AND_WAIT(proc4);

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

	proc.Logon(stat); // logon to process

	proc.Logon(notStat);

	r=proc.LogonCancel(notStat);

	test(r==KErrNone);

	test(notStat==KErrNone);

	test(proc.ExitType()==EExitPending);

	proc.Resume();

	globSem1.Wait(); // wait for T_PROC2 to get started

	test.End();

	}

void murderProcess()

	{

	test.Start(_L("Kill"));

	RProcess process;

	TInt r=createProc2(process);

	test(r==KErrNone);

	TProcessId id=process.Id();

	TProcessId id2=process.Id();

	test(id==id2);

 	TRequestStatus stat;

	process.Logon(stat);

	test(process.ExitType()==EExitPending);

	process.Kill(KKillReason);

	User::WaitForRequest(stat);

	test(stat==KKillReason);

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

	test(process.ExitReason()==KKillReason);

	test(process.ExitCategory()==_L("Kill"));

	CLOSE_AND_WAIT(process);

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

	r=createProc2(process);

	test(r==KErrNone);

	id2=process.Id();

	test(*(TUint*)&id+2==*(TUint*)&id2);	// use 2 ID's each time, one for process, one for thread

	process.Logon(stat);

	test(process.ExitType()==EExitPending);

	process.Terminate(KTerminateReason);

	User::WaitForRequest(stat);

	test(stat==KTerminateReason);

	test(process.ExitType()==EExitTerminate);

	test(process.ExitReason()==KTerminateReason);

	test(process.ExitCategory()==_L("Terminate"));

	CLOSE_AND_WAIT(process);

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

	r=createProc2(process);

	test(r==KErrNone);

	id2=process.Id();

	test(*(TUint*)&id+4==*(TUint*)&id2);

 	test(process.ExitType()==EExitPending);

	process.Logon(stat);

	process.SetJustInTime(EFalse);	// prevent the process panic from starting the debugger

	process.Panic(_L("BOO!"),KPanicReason);

	User::WaitForRequest(stat);

	test(stat==KPanicReason);

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

	test(process.ExitReason()==KPanicReason);

	test(process.ExitCategory()==_L("BOO!"));

	CLOSE_AND_WAIT(process);

	test.End();

	}

void sharedChunks()

	{

	test.Start(_L("Test chunk sharing between threads"));

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

	TInt r=0;

	RChunk chunk;

	TInt size=0x1000;

	TInt maxSize=0x5000;

	r=chunk.CreateGlobal(_L("Marmalade"),size,maxSize);

	test(r==KErrNone);

	test.Next(_L("Write 0-9 to it"));

	TUint8* base=chunk.Base();

	for (TInt8 j=0;j<10;j++)

		*base++=j; // write 0 - 9 to the chunk

  	globSem2.Signal(); // T_PROC2 can check the chunk now

	globSem1.Wait();

	chunk.Close(); // now it's ok to kill the chunk

	test.End();

	}

TInt sharedChunks2(TAny* /*aDummy*/)

	{

    RTest test(_L("Shared Chunks 2"));

	test.Title();	

	test.Start(_L("Test chunk sharing between threads"));

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

	TInt r=0;

	RChunk chunk;

	TInt size=0x1000;

	TInt maxSize=0x5000;

	r=chunk.CreateGlobal(_L("Marmalade"),size,maxSize);

	test(r==KErrNone);

	test.Next(_L("Write 0-9 to it"));

	TUint8* base=chunk.Base();

	for (TInt8 j=0;j<10;j++)

		*base++=j; // write 0 - 9 to the chunk

  	globSem2.Signal(); // T_PROC2 can check the chunk now

	globSem1.Wait();

	chunk.Close(); // now it's ok to kill the chunk

	test.End();

    return(KErrNone);

	}

TInt speedyThreadEntryPoint(TAny*)

//

// The entry point for the speed test thread.

//

	{

	RDisplay t;

	TInt r=t.Open();

	test(r==KErrNone);

	speedCount=0;

	client.Signal();

	while ((r=t.Test())==KErrNone)

		speedCount++;

	t.Close();

	return r;

	}

TInt BadName(TAny*)

	{

	proc.Open(_L("*"));

	return KErrNone;

	}

TInt sharedHeap(TAny*)

	{

	RTest test2(_L("sharedHeap"));

	test2.Title();

	test2.Start(_L("Shared heap tests"));

	RAllocator* allocator = &User::Allocator();

	test2.Printf(_L("sharedHeap's heap is at %08x\n"), allocator);

	TInt size;

	allocator->AllocSize(size);

	test2.Printf(_L("sharedHeap's heap allocsize is %08x\n"),size);

// Press a key only if running the test in manual mode. We will be

// able to ascertain this when RTest has been enhanced.

//	test.Next(_L("Press a key to continue"));

//	test2.Getch();

	test2.End();

	return(KErrNone);

	}

_LIT(KTestProcessNewName,"T_PROC1_NEW.EXE");

TInt DupRenameProcTest(TInt aCall)

	{

	test.Printf(_L("DupRenameProcTest: call %d\n"),aCall);

	TInt r;

	switch(aCall)

		{

	case 1:

		{

		r = User::RenameProcess(KTestProcessNewName);

		test(r==KErrNone);

		TFullName fn(RProcess().FullName());

		test.Printf(_L("Renamed to %S\n"),&fn);

		TInt li = fn.Locate('[');

		TInt ri = fn.Locate(']');

		test(fn.Left(li)==KTestProcessNewName);

		test(fn.Mid(ri+1)==_L("0001"));

		}

	case 0:

		{

		TFileName filename(RProcess().FileName());

		TInt pos=filename.LocateReverse(TChar('\\'));

		filename.SetLength(pos+1);

		filename+=_L("T_PROC1.EXE");

		RProcess pr;

		TBuf16<10> call;

		call.Num(aCall+1);

		r = pr.Create(filename, call);

		TFullName fn(pr.FullName());

		test.Printf(_L("Created %S\n"),&fn);

		TRequestStatus st;

		pr.Logon(st);

		pr.Resume();

		User::WaitForRequest(st);

		CLOSE_AND_WAIT(pr);

		}

		return KErrNone;

	case 2:

		{

		r = User::RenameProcess(KTestProcessNewName);

		test(r==KErrNone);

		TFullName fn(RProcess().FullName());

		test.Printf(_L("Renamed to %S\n"),&fn);

		TInt li = fn.Locate('[');

		TInt ri = fn.Locate(']');

		test(fn.Left(li)==KTestProcessNewName);

		test(fn.Mid(ri+1)==_L("0002"));

		}

		return KErrNone;

	default:

		return KErrArgument;

		}

	}

_LIT(KTestProcessName,"TestName");

void TestProcessRename()

	{

	// Rename the current process with test name

    TInt r = User::RenameProcess(KTestProcessName);

    test(r==KErrNone);

    TName name1 = RProcess().Name();

    // Check new name is correct

    TName name2 = name1;

    name2.SetLength(KTestProcessName().Length());

    test(name2.CompareF(KTestProcessName)==0);

    // Rename the process with same test name

    r = User::RenameProcess(KTestProcessName);

    test(r==KErrNone);

    name2 = RProcess().Name();

    test(name1.Compare(name2)==0);  // name should be unchanged

	}

TInt E32Main()

	{

	__KHEAP_MARK;

	// Turn off lazy dll unloading

	RLoader l;

	test(l.Connect()==KErrNone);

	test(l.CancelLazyDllUnload()==KErrNone);

	l.Close();

	TBuf16<512> cmd;

	User::CommandLine(cmd);

	if(cmd.Length() && TChar(cmd[0]).IsDigit())

		{

		TInt r = DupRenameProcTest(TUint(TChar(cmd[0])) - '0');

		test(r==KErrNone);

		return 0;

		}

	test.Title();

	test.Start(_L("Testing process stuff 1"));

	TInt r;

	TRequestStatus s;

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

	r=client.CreateLocal(0);

	test(r==KErrNone);

	test.Next(_L("Try to open nonexistant process by ID"));

	r=proc.Open(*(TProcessId*)&KMaxTUint);

	test(r==KErrNotFound);

	test.Next(_L("Try to open process with invalid name"));

	RThread thread;

	r=thread.Create(_L("Bad Name"),BadName,KDefaultStackSize,NULL,NULL);

	test(r==KErrNone);

	TRequestStatus threadStat;

	thread.Logon(threadStat);

	TBool justInTime=User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(threadStat);

	User::SetJustInTime(justInTime);

	test(threadStat==EBadName);

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

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

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	CLOSE_AND_WAIT(thread);

	test.Next(_L("Murder processes in different ways"));

	murderProcess();

	test.Next(_L("Create second process"));

	createProcess();

	test.Next(_L("Shared Chunks from main thread"));

	sharedChunks();

	test.Next(_L("Shared chunks from secondary thread"));

	RThread t;

	r=t.Create(_L("Shared chunks 2"),sharedChunks2,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

    test(r==KErrNone);

	t.Logon(s);

	t.Resume();

	User::WaitForRequest(s);

	test(s==KErrNone);

	CLOSE_AND_WAIT(t);

	test.Next(_L("Starting speedy client"));

	RThread speedy;

	r=speedy.Create(_L("Speedy"),speedyThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

	test(r==KErrNone);

	RThread().SetPriority(EPriorityMuchMore);

    speedy.SetPriority(EPriorityNormal);

	TRequestStatus speedyStatus;

	speedy.Logon(speedyStatus);

	speedy.Resume();

	test.Next(_L("Wait for speedy to start"));

	client.Wait();

	globSem1.Wait(); // wait for proc2 to be nice & quiet

	test.Printf(_L("Starting speed test...\n"));

    User::After(300000);

    TInt b=speedCount;

    User::After(3000000);

    TInt n=speedCount;

    test.Printf(_L("Count = %d in 1 second\n"),(n-b)/3);

	test.Next(_L("Tell second process speed tests are done"));

	globSem2.Signal();

	test.Next(_L("Process Logon"));

	User::WaitForRequest(stat);

	const TDesC& cat=proc.ExitCategory();

	test.Printf(_L("Exit category = %S\n"),&cat);

	test.Printf(_L("Exit reason = %x\n"),proc.ExitReason());

	test.Printf(_L("Exit type = %x\n"),proc.ExitType());

	test(stat==KErrNone);

	test(proc.ExitCategory()==_L("Kill"));

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

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

	test(notStat==KErrNone);

	test.Next(_L("Test LogonCancel to dead process is ok"));

	r=proc.LogonCancel(stat);

	test(r==KErrGeneral);

	globSem1.Close();

	globSem2.Close();

	client.Close();

	User::WaitForRequest(speedyStatus);

	test(speedyStatus==KErrServerTerminated);

	test(speedy.ExitReason()==KErrServerTerminated);

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

	CLOSE_AND_WAIT(speedy);

	CLOSE_AND_WAIT(proc);

	User::After(5000000);	// wait for MMC session to disappear

	test.Next(_L("Test rename of the processes with duplicate names"));

	r = DupRenameProcTest(0);

	test(r==KErrNone);

    TestProcessRename();

	test.Next(_L("Check for kernel alloc heaven"));

	__KHEAP_MARKEND; 

	test.End();

	return(KErrNone);

	}