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

// @internalComponent

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <u32std.h> 	// unicode builds

#include <e32base.h>

#include <e32base_private.h>

#include <e32cons.h>

#include <e32Test.h>	// RTest headder

#include <e32def.h>

#include <e32def_private.h>

#include "TestCaseFactory.h"

#include "debugmacros.h"

RTestFactory& RTestFactory::Instance()

	{

	static RTestFactory singleton;

	return singleton;

	}

RTestFactory::~RTestFactory()

	{

	}

RTestFactory::RTestFactory()

:	iTestCases(TStringIdentity::Hash,TStringIdentity::Id)

	{

	}

void RTestFactory::RegisterTestCase(const TDesC& aTestCaseId,TCreationMethod aCreationMethod)

	{

	//LOG_FUNC

	TStringIdentity key(aTestCaseId);

	TInt err(Instance().iTestCases.Insert(key,aCreationMethod));

	if (err != KErrNone)

		{

		// Log that a test case could not be registered due to err

		RDebug::Print(_L("Test case '%S' could not be registered with test case factory"),&aTestCaseId);

		}

	else

		{

		RTestFactory::TCreationMethod* creatorFunction = Instance().iTestCases.Find(key);

		if (creatorFunction == NULL)

			{

			RDebug::Print(_L("<Error> Test case '%S' did not register"),&aTestCaseId);

			ListRegisteredTestCases();

			}

		else

			{

			RDebug::Print(_L("Test case '%S' registered in factory"),&aTestCaseId);

			}

		}

	}

TBool RTestFactory::TestCaseExists(const TDesC& aTestCaseId)

	{

	RTestFactory::TCreationMethod creatorFunction;

	TStringIdentity key(aTestCaseId);

	creatorFunction = REINTERPRET_CAST(RTestFactory::TCreationMethod, Instance().iTestCases.Find(key));

	return (NULL != creatorFunction);

	}

/* Returns the test ID (name) of test at offset aIndex in the MAP

 */

void RTestFactory::GetTestID(TInt aIndex, TBuf<KTestCaseIdLength> &aTestID)

	{

	LOG_FUNC

	RFactoryMap::TIter it(Instance().iTestCases);

	TInt count(0);

	for (count=0; count<Instance().iTestCases.Count(); count++)

		{

		it.NextKey();

		if (count == aIndex)

			{

			TStringIdentity k(*it.CurrentKey());

			TBuf<64> *p = REINTERPRET_CAST(TBuf<64>*, &k);

			aTestID.Copy( *p);	

			return;

			}

		}

	// Error: Case not found!

	User::Leave(-2);

	}

/* Return the ordinal value of the Test ID (numeric portion)

 */

TInt TestIDValue(const TDesC & aTestID)

	{

	TUint16 value;

	TBuf<KTestCaseIdLength> id;

	id = aTestID.Right(4);

	TLex  lex(id);

	if (KErrNone == lex.Val(value, EDecimal))

		return(value);

	return(-1);	

	}

/* Print the test IDs in numerical order

 * Returns a sorted array of strings containing all of the test IDs

 */	

void RTestFactory::ListRegisteredTestCases(RPointerArray<HBufC> & aTestCaseNameArr)

	{

	LOG_FUNC

	RFactoryMap::TIter it(Instance().iTestCases);

	TInt count(0);

	TInt cases(Instance().iTestCases.Count());

	test.Printf(_L("------ F A C T O R Y -------\n"));

	it.Reset();

	for (count=0; count<Instance().iTestCases.Count(); count++)

		{

		TStringIdentity k(*it.NextKey());

		TBuf<KTestCaseIdLength> *p = REINTERPRET_CAST(TBuf<KTestCaseIdLength>*, &k); // pointer to the test ID

		TBool placed(EFalse);

		TInt  pos(0);

		TInt  val(0);

		// build the sorted list

		while (!placed)

			{

			val = TestIDValue(*p);

			if (aTestCaseNameArr.Count()==pos) 

				{ //array empty or reached end

				HBufC* testIdentity = HBufC::NewLC(KTestCaseIdLength);

				*testIdentity = *p;

				aTestCaseNameArr.Append(testIdentity);

				CleanupStack::Pop(testIdentity);

				placed = ETrue;

				}

			else

				{

				if ( val < TestIDValue(*aTestCaseNameArr[pos]) )

					{

					HBufC* testIdentity = HBufC::NewLC(KTestCaseIdLength);

					*testIdentity = *p;

					aTestCaseNameArr.Insert(testIdentity, pos);

					placed = ETrue;

					CleanupStack::Pop(testIdentity);

					}

				else

					{

					pos++;

					}

				}

			}

		}

	// print it

	for (count=0; count<aTestCaseNameArr.Count(); count++)

		{

		test.Printf(_L("% 2d: %S\n"), count, aTestCaseNameArr[count]);

		}

	test.Printf(_L("----------------------------\n"));

	}

CTestCaseRoot* RTestFactory::CreateTestCaseL(const TDesC& aTestCaseId)

	{

	LOG_FUNC

	RTestFactory::TCreationMethod creatorFunction = NULL;

	TInt err(KErrNone);

	TStringIdentity key(aTestCaseId);

	TRAP(err,creatorFunction = Instance().iTestCases.FindL(key));

	if (err != KErrNone)

		{

		// Test case is not present in the factory therefore test cannot support specified test case

		RDebug::Print(_L("<Error %d> Test case '%S' not supported"),err,&aTestCaseId);

		ListRegisteredTestCases();

		User::Leave(err);

		}

	RDebug::Print(_L("Creating test case '%S'"),&aTestCaseId);

	// Call the creator function to create the test case object

	return creatorFunction(gSemiAutomated);

	}