/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

* Implementation of test_thread.h

*

*/

#include "test_thread.h"

TInt TTestRemote::iCount=0;

TInt TTestRemote::RunFunctor(TAny* aFunctor)

	{

	TFunctor& functor = *(TFunctor*)aFunctor;

	functor();

	return KErrNone;

	}

TTestThread::TTestThread(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume)

	{

	Init(aName, aFn, aData, aAutoResume);

	}

TTestThread::TTestThread(const TDesC& aName, TFunctor& aFunctor, TBool aAutoResume)

	{

	Init(aName, RunFunctor, &aFunctor, aAutoResume);

	}

TTestThread::~TTestThread()

	{

	//RTest::CloseHandleAndWaitForDestruction(iThread);

	iThread.Close();

	}

void TTestThread::Resume()

	{

	iThread.Resume();

	}

TInt TTestThread::WaitForExitL()

	{

	User::WaitForRequest(iLogonStatus);

	const TInt exitType = iThread.ExitType();

	const TInt exitReason = iThread.ExitReason();

	__ASSERT_ALWAYS(exitType != EExitPending, User::Panic(_L("TTestThread"),0));

	if(exitType != EExitKill)

		User::Leave(exitReason);

	return exitReason;

	}

void TTestThread::Rendezvous(TRequestStatus& aStatus)

	{

	iThread.Rendezvous(aStatus);

	}

void TTestThread::Init(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume)

	{

	TKName name(aName);

	name.AppendFormat(_L("-%d"), iCount++);

	TInt r=iThread.Create(name, aFn, KDefaultStackSize, KHeapSize, KHeapSize, aData);

	if(r!=KErrNone)

		{

		RDebug::Printf("RThread::Create failed, code=%d", r);

		User::Panic(KPanicCat, EThreadCreateFailed);

		}

	iThread.Logon(iLogonStatus);

	__ASSERT_ALWAYS(iLogonStatus == KRequestPending, User::Panic(_L("TTestThread"),0));

	if(aAutoResume)

		iThread.Resume();

	}

CTest::~CTest()

	{

	iName.Close();

	}

void CTest::operator()()

	{

	for(TInt i=0; i<iIterations; i++)

		{

		RunTest();

		}

	}

void CTest::Announce() const

{

	RDebug::RawPrint(_L("Test: "));

	PrintTestInfo();

	RDebug::RawPrint(_L(": "));

	PrintTestType();

	RDebug::RawPrint(_L(": "));

	RDebug::RawPrint(iName);

	RDebug::RawPrint(_L(": "));

	RDebug::Printf("(%d iterations)", iIterations);

}

void CTest::PrintTestInfo() const

	{

	}

const TDesC& CTest::Name() const

	{

	return iName;

	}

CTest::CTest(const TDesC& aName, TInt aIterations)

	:iIterations(aIterations)

	{

	iName.CreateL(aName);

	}

CTest::CTest(const CTest& aOther)

	:iIterations(aOther.iIterations)

	{

	iName.CreateL(aOther.iName);

	}

void MultipleTestRun(RTest& test, const CTest& aTest, TInt aNumberOfThreads)

	{

	RPointerArray<CTest> testArray;

	RPointerArray<TTestThread> threadArray;

	for(TInt i=0; i<aNumberOfThreads; i++)

		{

		//test.Next(_L("Create test thread"));

		CTest* newTest = aTest.Clone();

		test_NotNull(newTest);

		TTestThread* thread = new TTestThread(aTest.Name(), *newTest);

		test_NotNull(thread);

		threadArray.AppendL(thread);

		testArray.AppendL(newTest);

		}

	const TInt count = threadArray.Count();

	for(TInt j=0; j<count; j++)

		{

		TTestThread* thread = threadArray[0];

		TInt r = KErrNone;

		TRAPD(leaveCode, r = thread->WaitForExitL());

		if(leaveCode != KErrNone)

			{

			test.Printf(_L("Thread %d: Panic code:%d\n"), j, leaveCode);

			test_KErrNone(leaveCode);

			}

		if(r!=KErrNone)

			{

			test.Printf(_L("Thread Number %d\n"), j);

			test_KErrNone(r);

			}

		threadArray.Remove(0);

		delete thread;

		}

	threadArray.Close();

	testArray.ResetAndDestroy();

	testArray.Close();

	}

/**

Runs each CTest in aTests in its own thread

Returns once all threads have terminated

*/

void MultipleTestRun(const RPointerArray<CTest>& aTests)

	{

	RTest test(_L("CTest::MultipleTestRun"));

	RPointerArray<TTestThread> threads;

	const TInt count = aTests.Count();

	TInt i;

	for(i=0; i<count; i++)

		{

		_LIT(KDmaTestThread, "DMA-test-thread");

		TTestThread* thread = new TTestThread(KDmaTestThread, *aTests[i], EFalse);

		test_NotNull(thread);

		TInt r = threads.Append(thread);

		test_KErrNone(r);

		}

	for(i=0; i<count; i++)

		{

		threads[i]->Resume();

		}

	for(i=0; i<count; i++)

		{

		TInt r = threads[i]->WaitForExitL();

		test_KErrNone(r);

		}

	threads.ResetAndDestroy();

	test.Close();

	}