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