// Copyright (c) 2002-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:

//

#include <e32test.h>

#include "t_framework.h"

RTest test(RProcess().FileName());

CTestProgram::CTestProgram(const TDesC& aName) : iName(aName) 

	{

	iThreadId = RThread().Id();

	}

void CTestProgram::Panic()

	{

	TPtrC8 fd((TUint8*)iFile);

	TPtrC8 cd((TUint8*)iCond);

	HBufC* fhb = HBufC::NewMax(fd.Length());

	test(fhb != 0);

	HBufC* chb = HBufC::NewMax(cd.Length());

	test(chb != 0);

	fhb->Des().Copy(fd);

	chb->Des().Copy(cd);

	test.Panic(iError, _L("Test '%S' Fails;\nCond: '%S'; File: '%S'; Line %d;\n"), &iName, chb, fhb, iLine);

	}

void CTestProgram::Panic(TInt aError, char* aCond, char* aFile, TInt aLine)

	{

	iError = aError;

	iCond = aCond;

	iFile = aFile;

	iLine = aLine;

	if (iThreadId != RThread().Id())

		{

		RThread thr;

		thr.Panic(_L("FAIL"), aError);

		}

	Panic();

	}

void CTestProgram::Launch(TUint aCount)

	{

	// Remember the number of open handles. Just for a sanity check ....

	TInt start_thc, start_phc;

	RThread().HandleCount(start_phc, start_thc);

	TF_ERROR(RThread().RequestCount(), RThread().RequestCount() == 0);

	test.Next(iName);

	Run(aCount);

	// Sanity check for open handles

	TInt end_thc, end_phc;

	RThread().HandleCount(end_phc, end_thc);

	TF_ERROR(end_thc - start_thc, start_thc == end_thc);

	TF_ERROR(end_phc - start_phc, start_phc == end_phc);

		// and also for pending requests ...

	TF_ERROR(RThread().RequestCount(), RThread().RequestCount() == 0);

	}

void CTestProgram::LaunchGroup(CTestProgram** aGroup, TUint aCount)

	{

	for (CTestProgram** progP = aGroup; *progP; ++progP)

		{

		CTestProgram* prog = *progP;

		prog->Launch(aCount);

		}

	}

TInt CTestProgram::ThreadEntry(TAny* a)

	{

	CTestProgram* prog = (CTestProgram*) a;

	prog->Run(prog->iCount);

	return KErrNone;

	}

void CTestProgram::Spawn(TUint aCount)

	{

	test.Next(iName); 

	iCount = aCount;

	iStatus = KRequestPending;

	RThread thr;

	TInt r = thr.Create(KNullDesC, ThreadEntry, 0x2000, NULL, this);

	TF_ERROR(r, r == KErrNone);

	thr.NotifyDestruction(iDestroyStatus);

	thr.Logon(iStatus);

	thr.Resume();

	thr.Close();

	}

void CTestProgram::Wait()

	{

	User::WaitForRequest(iStatus);

	if (iStatus.Int() != KErrNone)

		{

		Panic();

		}

	User::WaitForRequest(iDestroyStatus);

	if (iDestroyStatus.Int() != KErrNone)

		{

		Panic();

		}

	}

void CTestProgram::SpawnGroup(CTestProgram** aGroup, TUint aCount)

	{

	test.Start(_L("=== Start Parallel Testing ==="));

	CTestProgram** progP;

	for (progP = aGroup; *progP; ++progP)

		{

		CTestProgram* prog = *progP;

		prog->Spawn(aCount);

		}

	for (progP = aGroup; *progP; ++progP)

		{

		CTestProgram* prog = *progP;

		prog->Wait();

		}

	test.Next(_L("=== End Parallel Testing ==="));

	test.End();

	}

void CTestProgram::Exec(const TDesC& aFile, TAny* args, TInt size)

	{

	//

	// Create the child process and pass args as a UNICODE command line.

	// (we suppose that the args size is multiple of sizeof(TUint16))

	//

	RProcess proc;

	TInt r = proc.Create(aFile, TPtrC((TUint16*) args, size/sizeof(TUint16)));

	TF_ERROR(r, r == KErrNone);

	TRequestStatus status;

	proc.Logon(status);

	proc.Resume();

	User::WaitForRequest(status);

	TF_ERROR(status.Int(), status.Int() == KErrNone);

	proc.Close();

	}

void CTestProgram::Start()

	{

	test.Title();

	test.Start(_L("GO!"));

	}

void CTestProgram::End()

	{

	test.End();

	}