/*

 * Copyright (c) 2001-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: 

 * Defines methods common to all test classes

 *

 */

 #include <e32cons.h>

 #include "testbase.h"

 #include "t_input.h"

 _LIT(KParametersStart, "<parameters>");

 _LIT(KValuesStart, "<values>");

 _LIT(KRandomStart, "<random>");

 const TInt KMaxValuesSize = 1024;

 CTestBase::CTestBase(CASN1NormalTest &aASN1Action)

 : iASN1Action(aASN1Action)

 	{

 	}

 CTestBase::~CTestBase()

 	{

 	iParameters->Close();

 	delete iParameters;

 	iValues->ResetAndDestroy();

 	delete iValues;

 	};

 CTestAction::TScriptError CTestBase::ConstructL(const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction::TScriptError syntaxError;

 	iParameters = new (ELeave)RArray<CTestParameter::TType>;

 	iValues = new (ELeave)RPointerArray<CTestParameter>;

 	FillParameterArray();

 	HBufC* aBody = HBufC::NewLC(aTestActionSpec.iActionBody.Length());

 	aBody->Des().Copy(aTestActionSpec.iActionBody);

 	TPtrC parameters(Input::ParseElement(*aBody, KParametersStart));

 	syntaxError = CheckValueParametersL(parameters);

 	if(syntaxError==CTestAction::ENone)

 		syntaxError = CheckRandomParametersL(parameters);

 	CleanupStack::PopAndDestroy();

 	return(syntaxError);

 	}

 CTestAction::TScriptError CTestBase::CheckValueParametersL(const TDesC& aParameters)

 	{

 	TInt dummyPos = 0, valuePos = 0, lastDummy = 0;

 	TBuf<KMaxValueSize> singleValue;

 	CTestParameter *testParameter=0;

 	TBuf<KMaxValuesSize> values;

 	// finds values to run test with

 	do

 		{

 		lastDummy = dummyPos;

 		values = Input::ParseElement(aParameters, KValuesStart, dummyPos);

 		// finds the next group of value

 		if(lastDummy != dummyPos)

 			{

 			// parses each value in group with its expeced type

 			for(TInt parameter = 0; parameter < iParameters->Count(); parameter++)

 				{

 				testParameter = NULL;

 				// checks if its last parameter

 				if(parameter < iParameters->Count() - 1)

 					{

 					// finds it position

 					valuePos = values.Find((_L(",")));

 					if(valuePos > 0)

 						{

 						// fills singleValue with value

 						if(valuePos > KMaxValueSize)

 							{

 							iSyntaxErrorDescription.Copy(_L("value too long"));

 							return(CTestAction::ESyntax);

 							}

 						singleValue.Copy(values.Left(valuePos));

 						values = values.Mid(valuePos + 1);

 						}

 					else

 						{

 						// couldnt find it there is a problem

 						iSyntaxErrorDescription.Copy(_L("Invalid number of parameters"));

 						return(CTestAction::ESyntax);

 						};

 					}

 				else

 					{

 					// its the last value fill singleValue with it

 					if(values.Length() > KMaxValueSize)

 						{

 						iSyntaxErrorDescription.Copy(_L("value too long"));

 						return(CTestAction::ESyntax);

 						}

 					singleValue.Copy(values);

 					};

 				// trims any white space

 				singleValue.Trim();

 				// checks what type its supposed to be

 				switch((*iParameters)[parameter])

 					{

 					case CTestParameter::EInt:

 						{

 							// its an int, check to see if its a range

 							if(singleValue.Find(_L("..")) == KErrNotFound)

 								testParameter = CIntTestParameter::NewL(singleValue);

 							else

 								testParameter = CIntRangeTestParameter::NewL(singleValue);

 							break;

 						}

 					case CTestParameter::EString:

 						{

 							// its a string

 							testParameter = CStringTestParameter::NewL(singleValue);

 							break;

 						}

 					case CTestParameter::EIntRange:

 					case CTestParameter::ERandom:

 						break;	//	Nothing to do

 					};

 				// if testparamer is found add it to the list

 				if(testParameter)

 					{	

 					if(testParameter->iValid)

 						iValues->Append(testParameter);

 					else

 						{

 						delete testParameter;

 						iSyntaxErrorDescription.Copy(_L("Invalid value "));

 						iSyntaxErrorDescription.Append(singleValue);

 						return(CTestAction::ESyntax);

 						}

 					}

 				};

 			}

 		}

 	while(lastDummy != dummyPos);

 	return(CTestAction::ENone);

 	};

 CTestAction::TScriptError CTestBase::CheckRandomParametersL(const TDesC& aParameters)

 	{

 	TInt dummyPos = 0, lastDummy = 0;

 	TBuf<KMaxValueSize> singleValue;

 	CTestParameter *testParameter=0;

 	TBuf<KMaxValuesSize> values;

 	// finds any random tests

 	do

 		{

 		lastDummy = dummyPos;

 		values = Input::ParseElement(aParameters, KRandomStart, dummyPos);

 		if(lastDummy != dummyPos)

 			{

 			if(values.Length() > KMaxValueSize)

 				{

 				iSyntaxErrorDescription.Copy(_L("value too long"));

 				return(CTestAction::ESyntax);

 				}

 			singleValue.Copy(values);

 			// found one create a random parameter with its interators

 			testParameter = CRandomTestParameter::NewL(singleValue);

 			// adds it to list

 			if(testParameter)

 				{	

 				if(testParameter->iValid)

 					iValues->Append(testParameter);

 				else

 					{

 					delete testParameter;

 					iSyntaxErrorDescription.Copy(_L("Invalid value "));

 					iSyntaxErrorDescription.Append(singleValue);

 					return(CTestAction::ESyntax);

 					}

 				}

 			}

 		}

 	while(lastDummy != dummyPos);

 	return(CTestAction::ENone);

 	};

 void CTestBase::OutputEncodingL(CConsoleBase& aConsole, TDesC8& aData)

 	{

 	aConsole.Printf(_L("Encoding: Length = "));

 	TBuf<20> bits;

 	bits.AppendNum(aData.Length());

 	bits.Append(_L(", data = "));

 	aConsole.Printf(bits);

 	TInt size = aData.Length();

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

 		{

 		TBuf<10> tbuf;

 		tbuf.AppendNumFixedWidth(aData[i], EHex, 2);

 		aConsole.Printf(tbuf);

 		}

 	aConsole.Printf(_L("\n"));

 	}

 TBool CTestBase::CountTests(TInt &totalTests)

 	{

 	CTestParameter* test;

 	TInt totalRandomTests = 0;

 	TInt totalParameters = 0;

 	TInt totalRangeTests = 0;

 	totalTests=0;

 	// counts number of tests to do for type

 	for(TInt pos = 0; pos < iValues->Count(); pos++)

 		{

 		test = (*iValues)[pos];

 		switch(test->GetType())

 			{

 			case CTestParameter::EInt :

 			case CTestParameter::EString :

 				{

 				totalTests++;

 				totalParameters++;

 				break;

 				}

 			case CTestParameter::EIntRange :

 				{

 				CIntRangeTestParameter *rangeInt = REINTERPRET_CAST(CIntRangeTestParameter*, test);

 				totalRangeTests += rangeInt->Range();

 				totalParameters++;

 				break;

 				}

 			case CTestParameter::ERandom :

 				{

 				CRandomTestParameter *randomInt = REINTERPRET_CAST(CRandomTestParameter*, test);

 				totalRandomTests+= randomInt->Interations();

 				break;

 				}

 			};

 		};

 	// only count each test once, remember each test can only have one parameter field of 

 	// range or random

 	totalTests = totalRandomTests + totalRangeTests + (totalParameters / iParameters->Count());

 	// checks if tests correct number of parameters for type

 	return((totalParameters %  iParameters->Count()) == 0);

 	};