// 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();

	}