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

//

/**

 @file

 @released

*/

#include "t_burteststepbase.h"

namespace bur_ts

	{

	_LIT(KTabText, "\t|");

	_LIT(KFormatText2, "%S%S");

	_LIT(KFormatText3, "%S%S%S");

	_LIT(KFormatText4, "%S%S%d");

	_LIT(KFormatText5, "%S%S%X");

	_LIT(KFormatText6, "%S%S%s");

	const TUint8 KMaxHexLength = 8;

	CBURTestStepBase::CBURTestStepBase(CBURTestServer& aParent) 

		/**

		C++ Constructor

		@internalComponent

		@released

		@param aParent - The parent CBURTestServer of this child test step.

		*/

		:iParentTestServer(aParent),

		iBackupClient(NULL),

		iBackupIncType(EBackupBase),

	 	iIsPartial(EFalse),

	 	iExpectStatus(1),

	 	iExpectStatus2(1),

		iFailures(KErrNone),

		iStorageManager(NULL),

		iMode(EBackupMode),

		iWaitedForActive(EFalse)

		{}

	CBURTestStepBase::~CBURTestStepBase()

		/**

		C++ Destructor

		@internalComponent

		@released

		*/

		{

		iDataOwners.ResetAndDestroy();

		iDataOwners.Close();

		iSidArray.Close();

		iJidArray.Close();

		iPublicFileNames.Close();

		iPrivateFileNames.Close();

		iPrivateFileSizes.Close();

		iFs.Close();

		iTransferTypes.ResetAndDestroy();

		iTransferTypes.Close();

		delete iStorageManager;

		delete iActiveScheduler;

		delete iBackupClient;

		}

	// LOGGING METHODS

	void CBURTestStepBase::Log(TUint aIndentationLevel, const TDesC& aLog)

		/**

		Logs the data inside the string as text string at aIndentationLevel.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF3(KFormatText2, &ptr, &aLog);

		delete indentation;

		}

	void CBURTestStepBase::LogWithText(TUint aIndentationLevel, const TDesC& aLog, const TDesC& aText)

		/**

		Writes the message with a text string.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aText - Textual data to be logged with the main message.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText3, &ptr, &aLog, &aText);

		delete indentation;

		}

	void CBURTestStepBase::LogWithText8(TUint aIndentationLevel, const TDesC& aLog, const TDesC8& aText)

		/**

		8-bit variant of the above

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aText - 8-bit textual data to be logged with the main message.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText3, &ptr, &aLog, &aText);

		delete indentation;

		}

	void CBURTestStepBase::LogWithNum(TUint aIndentationLevel, const TDesC& aLog, TInt aNum)

		/**

		Writes to the report a number along with a message.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aNum - Number to be printed with the log.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText4, &ptr, &aLog, aNum);

		delete indentation;

		}

	void CBURTestStepBase::LogWithSID(TUint aIndentationLevel, const TDesC& aLog, TSecureId aSecureId)

		/**

		Writes out a TSecureId as a hexadecimal number along with a message.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aSecureId - A TSecureId to be printed as a hexadecimal number.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText5, &ptr, &aLog, aSecureId.iId);

		delete indentation;

		}

	void CBURTestStepBase::LogWithChar(TUint aIndentationLevel, const TDesC& aLog, TChar aChar)

		/**

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aChar - A single char, appended at the end of the message.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText6, &ptr, &aLog, &aChar);

		delete indentation;

		}

	HBufC* CBURTestStepBase::GetIndentation(TInt aLevel)

		/**

		Generates a string of indentation markers (based on KIndentationMarker) the 

		level of depth specified by aLevel

		@internalComponent

		@released

		@param aLevel - Level of depth required for indentation.

		*/

		{

		HBufC* hbuf = NULL;

		// Indentation level times the length of the indentation marker, 

		// plus room for a tab and a '|'

		TInt indentationLength = aLevel * KIndentationMarker().Length() + 10;

		hbuf = HBufC::NewL(indentationLength);

		hbuf->Des().Append(KTabText);

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

			{

			hbuf->Des().Append(KIndentationMarker);

			}

		return hbuf;

		}

	void CBURTestStepBase::CreateStorageManagerL()

		/**

		Must only be called after the user input has been processed.

		@internalComponent

		@released

		*/

		{

		iStorageManager = CStorageManager::NewL(iBackupDirName, iDriveList, this);

		}

	void CBURTestStepBase::ProcessUserOptionsL()

		/**

		This function uses TestExecute config file parsers to read in the user preferences

		from ini files

		@internalComponent

		@released

		 */

		{

		TPtrC backupDir;

		TInt isPartial = 0;

		TInt isBase = 0;

		TPtrC driveListText;

		// directory for archiving backup data

		_LIT(KBackupDirText1, "BackupDir");

		GetStringFromConfig(ConfigSection(), KBackupDirText1, backupDir);

		_LIT(KBackupDirText2, "Backup directory: ");

		LogWithText(LOG_LEVEL3, KBackupDirText2, backupDir);

		iBackupDirName.Copy(backupDir);

		// affected drives

		_LIT(KDriveListText1, "DriveList");

		GetStringFromConfig(ConfigSection(), KDriveListText1, driveListText);

		_LIT(KDriveListText2, "Drives: ");

		LogWithText(LOG_LEVEL3, KDriveListText2, driveListText);

		// extract all drives from the user input

		iDriveList = CBURTestStepBase::StringToDriveListL(driveListText);

		// create the storage handler based on the drives and backup directory

		CreateStorageManagerL();

		_LIT(KExpectStatusText1, "ExpectStatus");

		GetIntFromConfig(ConfigSection(), KExpectStatusText1, iExpectStatus);

		_LIT(KExpectStatusText2, "ExpectStatus: ");

		LogWithNum(LOG_LEVEL3, KExpectStatusText2, iExpectStatus);		

		_LIT(KExpectStatusText3, "ExpectStatus2");

		GetIntFromConfig(ConfigSection(), KExpectStatusText3, iExpectStatus2);

		_LIT(KExpectStatusText4, "ExpectStatus2: ");

		LogWithNum(LOG_LEVEL3, KExpectStatusText4, iExpectStatus2);			

		// full/partial backup

		_LIT(KPartialText1, "IsPartial");

		GetIntFromConfig(ConfigSection(), KPartialText1, isPartial);

		if (isPartial == 0)

			{

			iIsPartial = EFalse;

			_LIT(KPartialText2, "Full/Partial Type: Full");

			Log(LOG_LEVEL3, KPartialText2);

			} //if

		else if (isPartial == 1)

			{

			iIsPartial = ETrue;

			TSecureId sid;

			TChar ch;

			TPtrC list;

			// PARSING ID LIST //

			_LIT(KSIDList, "IDs");

			GetStringFromConfig(ConfigSection(), KSIDList, list);

			TLex sidLex(list);

			while (!sidLex.Eos())

				{

        		sidLex.Mark();

	        	ch=sidLex.Peek();

    	    	while(!sidLex.Eos() && ( ch=sidLex.Peek() ) != TChar(','))

        			sidLex.Inc();

        		if(!sidLex.TokenLength())

        			continue;

        		TPtrC pToken = sidLex.MarkedToken();

        		TLex token(pToken);

        		if (pToken.Length() <= KMaxHexLength && token.Val(sid.iId, EHex) == KErrNone)

        			{

        			iSidArray.Append(sid);

					_LIT(KFound, "ID Found in ini file: ");

					LogWithSID(LOG_LEVEL4, KFound, sid);		

        			} //if

        		else // must be a Java suite hash

        			{

        			iJidArray.Append(pToken);

        			_LIT(KJFound, "Java ID Found in ini file: ");

        			LogWithText(LOG_LEVEL4, KJFound, pToken);

        			}

        		if(ch==TChar(','))

        			sidLex.Inc();

        		sidLex.SkipSpace();

				} //while

			_LIT(KPartialText3, "Full/Partial Type: Partial");

			Log(LOG_LEVEL3, KPartialText3);

			} //if

		else

			{

			_LIT(KPartialText4, "Full/Partial Type: UNKNOWN");

			_LIT(KPartialText5, "** PLEASE USE 0 OR 1 ONLY **");

			_LIT(KPartialText6, "** Using FULL as default  **");

			Log(LOG_LEVEL4, KPartialText4);

			Log(LOG_LEVEL4, KPartialText5);

			Log(LOG_LEVEL4, KPartialText6);

			}

		// base/incremental

		_LIT(KIncrText1, "BaseOnly");

		GetIntFromConfig(ConfigSection(), KIncrText1, isBase);

		if (isBase == 1)

			{

			iBackupIncType = EBackupBase;

			_LIT(KIncrText2, "Base/Incremental Type: Base Only");

			Log(LOG_LEVEL3, KIncrText2);

			}

		else if (isBase == 0)

			{

			iBackupIncType = EBackupIncrement;

			_LIT(KIncrText3, "Base/Incremental Type: Incremental by Default");

			Log(LOG_LEVEL3, KIncrText3);

			}

		else

			{

			_LIT(KIncrText4, "Base/Incremental Type: UNKNOWN");

			_LIT(KIncrText5, "** PLEASE USE 0 OR 1 ONLY **");

			_LIT(KIncrText6, "** Using BASE as default  **");

			Log(LOG_LEVEL4, KIncrText4);

			Log(LOG_LEVEL4, KIncrText5);

			Log(LOG_LEVEL4, KIncrText6);

			}

		TChar delimiter(',');

		/** Read public files into array */

		_LIT(KExpectPublicFiles, "ExpectPublicFiles");

		ReadListIntoStringArray(KExpectPublicFiles, delimiter, iPublicFileNames);

		/** Read private files into array */

		_LIT(KExpectPrivateFiles, "ExpectPrivateFiles");

		ReadListIntoStringArray(KExpectPrivateFiles, delimiter, iPrivateFileNames);		

		/** Read private file sizes into array */

		_LIT(KExpectPrivateFileSizes, "ExpectPrivateFileSizes");

		ReadListIntoIntArray(KExpectPrivateFileSizes, delimiter, iPrivateFileSizes);

		}

	void CBURTestStepBase::ReadListIntoStringArray(const TDesC& aSectionName, const TChar& aDelimiter, RArray<TPtrC>& aResultList)

		{

		TChar ch;

		TPtrC list;

		GetStringFromConfig(ConfigSection(), aSectionName, list);

		TLex strLex(list);

		while (!strLex.Eos())

			{

			strLex.Mark();

        	ch=strLex.Peek();

	    	while( ( !strLex.Eos() ) && 

	    		   ((ch=strLex.Peek()) != aDelimiter) )

	    		{

	    		strLex.Inc();

	    		}

    		if(!strLex.TokenLength())

    			continue;

    		TPtrC pToken = strLex.MarkedToken();

    		aResultList.Append(pToken);

    		if(ch == aDelimiter)

    			strLex.Inc();

    		strLex.SkipSpace();    

			} //while		

		}

	void CBURTestStepBase::ReadListIntoIntArray(const TDesC& aSectionName, const TChar& aDelimiter, RArray<TInt>& aResultList)

		{

		RArray<TPtrC> strList;

		CleanupClosePushL(strList);

		ReadListIntoStringArray(aSectionName, aDelimiter, strList);

		TInt count = strList.Count();

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

			{

			TInt num = 0;

			TLex token(strList[i]);

			if (token.Val(num) == KErrNone)

				{

				aResultList.Append(num);

				}

			}

		CleanupStack::PopAndDestroy(&strList); // strList

		}	

	void CBURTestStepBase::PopulateListOfDataOwnersL()

		/**

		Uses CSBEClient::ListOfDataOwnersL() to extract a list of data owners that have 

		registred for backup and restore. Populates iDataOwners.

		@internalComponent

		@released

		*/

		{

		_LIT(KTempText1, "Getting list of data owners from device");

		Log(LOG_LEVEL2,KTempText1);

		TRAPD(err, iBackupClient->ListOfDataOwnersL(iDataOwners));

		if (err != KErrNone)

			{

			_LIT(KTempText1, "Error getting list of data owners: ");

			LogWithNum(LOG_LEVEL2,KTempText1, err);

			iFailures++;

			}

		// Log

		if (iDataOwners.Count() == 0)

			{

			_LIT(KTempText3, "No data owners found.");

			Log(LOG_LEVEL3, KTempText3);

			}

		else

			{

			_LIT(KTempText4, "Number of data owners found on device: ");

			LogWithNum(LOG_LEVEL3, KTempText4, iDataOwners.Count());

			}

		}

	void CBURTestStepBase::PopulateListOfDataOwnersAsyncL()

		/**

		Uses CSBEClient::ListOfDataOwnersL() to extract a list of data owners that have 

		registred for backup and restore. Populates iDataOwners.

		@internalComponent

		@released

		*/

		{

		_LIT(KTempText1, "Getting list of data owners from device");

		Log(LOG_LEVEL2,KTempText1);

		CBURActiveObject* active = CBURActiveObject::NewL();

		CleanupStack::PushL(active);

		TRAPD(err, iBackupClient->ListOfDataOwnersL(iDataOwners, active->iStatus));

		if (err == KErrNone)

			{

			active->StartL();

			}

		if (err != KErrNone || active->Error() != KErrNone)

			{

			_LIT(KTempText1, "Error getting list of data owners: ");

			LogWithNum(LOG_LEVEL2,KTempText1, err);

			iFailures++;

			}

		CleanupStack::PopAndDestroy(active);

		// Log

		if (iDataOwners.Count() == 0)

			{

			_LIT(KTempText3, "No data owners found.");

			Log(LOG_LEVEL3, KTempText3);

			}

		else

			{

			_LIT(KTempText4, "Number of data owners found on device: ");

			LogWithNum(LOG_LEVEL3, KTempText4, iDataOwners.Count());

			}

		}

	void CBURTestStepBase::SetBURModeL(TBURPartType aBURPartType, TBackupIncType aBackupIncType)

		/**

		Uses CSBEClient::SetBURModeL() to set backup and restore settings

		@internalComponent

		@released

		@param aBURPartType - Full/Partial backup/restore.

		@param aBackupIncType - Base/Incremental backup/restore.

		*/

		{

		iBackupClient->SetBURModeL(iDriveList, aBURPartType, aBackupIncType);

		}