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

 //

 #include "t_cenrep_helper.h"

 #include "srvdefs.h"

 #include <f32file.h> // RFs

 #include <e32test.h> // RTest

 #include <hal.h>

 #include "cachemgr.h"

 #include "clirep.h"

 #if defined(__CENTREP_SERVER_PERFTEST__) || defined(__CENTREP_SERVER_MEMTEST__) || defined(__CENTREP_SERVER_CACHETEST__)

 	#include "srvreqs.h"

 	#define CONDITIONAL_PARAM(x) x

 #else

 	#define CONDITIONAL_PARAM(x)

 #endif

 void PatchDrive(TDes& aPath)

 	{

 	TDriveNumber sysdrive = RFs::GetSystemDrive();

 	aPath[0] = 'a' + sysdrive-EDriveA; // Replace drive letter only.

 	}

 EXPORT_C void printDirL(const TDesC& aDirName)

 	{

 	CDir* fileList=NULL;

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	TInt r = fs.GetDir(aDirName,KEntryAttNormal, ESortByDate, fileList);

 	if (r==KErrPathNotFound)

 		{

 		RDebug::Print(_L("No directory %S"), &aDirName);

 		}

 	else if (r==KErrNone)

 		{

 		TInt fileCount=fileList->Count();

 		RDebug::Print( _L("%02d files in %S\n"),fileCount, &aDirName);

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

 			{

 			TEntry entry=(*fileList)[i];

 			RDebug::Print( _L("File[%02d] - %S \n"),

 							i,

 							&(entry.iName)

 							);

 			}

 		}

 	else

 		{

 		RDebug::Print(_L("Error getting contents of directory %S"), &aDirName);

 		}

 	delete fileList;

 	CleanupStack::PopAndDestroy();	//fs

 	}

 EXPORT_C TInt KillProcess(const TDesC& aProcessName)

 	{

 	TFullName name;

 	RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);

 	TBuf<64> pattern(aProcessName);

 	TInt length = pattern.Length();

 	pattern += _L("*");

 	TFindProcess procFinder(pattern);

 	while (procFinder.Next(name) == KErrNone)

 		{

 		if (name.Length() > length)

 			{//If found name is a string containing aProcessName string.

 			TChar c(name[length]);

 			if (c.IsAlphaDigit() ||

 				c == TChar('_') ||

 				c == TChar('-'))

 				{

 				// If the found name is other valid application name

 				// starting with aProcessName string.

 				RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);

 				continue;

 				}

 			}

 		RProcess proc;

 		if (proc.Open(name) == KErrNone)

 			{

 			proc.Kill(0);

 			RDebug::Print(_L("\"%S\" process killed.\n"), &name);

 			}

 		proc.Close();

 		}

 	return KErrNone;

 	}

 const TInt KSmallDelay = 2*1000;

 //File cleanup function

 EXPORT_C void CleanupCDriveL(TBool aRemoveRomCache)

 	{

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	CFileMan* fm = CFileMan::NewL(fs);

 	CleanupStack::PushL(fm);

 	HBufC* file_buf = HBufC::NewLC(KMaxFileName);

 	TPtr file(file_buf->Des());

 	file.Copy(KCPersistsFiles);

 	PatchDrive(file);

 	TInt r = fm->Delete(file);

 	if (r != KErrNone &&

 		r != KErrNotFound &&

 		r != KErrPathNotFound)

 		{

 		User::Leave(r);

 		}

 	if(aRemoveRomCache)

 		{

 		//Delete cached rom version file

 		file.Copy(KCRomVersionFiles);

 		PatchDrive(file);

 		fm->Attribs(file, 0, KEntryAttReadOnly, TTime(0), 0);

 		r = fm->Delete(file);

 		if (r != KErrNone &&

 			r != KErrNotFound &&

 			r != KErrPathNotFound &&

 			r != KErrPermissionDenied)

 			{

 			User::Leave(r);

 			}

 		// Delete all install files

 		file.Copy(KCInstallFiles);

 		PatchDrive(file);	

 		r = fm->Delete(file);

 		if (r != KErrNone &&

 			r != KErrNotFound &&

 			r != KErrPathNotFound)

 			{

 			User::Leave(r);

 			}

 		// Give SW time to handle uninstall.

 		User::After(KSmallDelay);

 		}

 	CleanupStack::PopAndDestroy(3);

 	}

 //Function to remove all repositories from repository cache

 //Try not to use this function because it is time consuming (129.5 seconds)

 EXPORT_C void CleanupRepositoryCache()

 	{

 	// So we wait here until the cache is empty to correct the behaviour.

 	User::After(KDefaultEvictionTimeout+950000);

     }

 //Function to clean specific repository files

 EXPORT_C void CleanupFileFromCDriveL(const TUid aRepository)

 	{

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	CFileMan* fm = CFileMan::NewL(fs);

 	CleanupStack::PushL(fm);

 	HBufC* file_buf = HBufC::NewLC(KMaxFileName);

 	TPtr filename(file_buf->Des());

 	filename = KCPersistsDir;

 	filename.AppendNumFixedWidth(aRepository.iUid,EHex,8);

 	filename.Append(KTxtFileExt);

 	PatchDrive(filename);

 	// Delete txt file from persists dir

 	TInt r = fm->Delete(filename);

 	if (r != KErrNone &&

 		r != KErrNotFound &&

 		r != KErrPathNotFound)

 		{

 		User::Leave(r);

 		}

 	filename = KCPersistsDir;

 	filename.AppendNumFixedWidth(aRepository.iUid,EHex,8);

 	filename.Append(KCreFileExt);

 	PatchDrive(filename);

 	// Delete cre file from persists dir

 	r = fm->Delete(filename);

 	if (r != KErrNone &&

 		r != KErrNotFound &&

 		r != KErrPathNotFound)

 		{

 		User::Leave(r);

 		}

 	filename = KCInstallDir;

 	filename.AppendNumFixedWidth(aRepository.iUid,EHex,8);

 	filename.Append(KTxtFileExt);	

 	PatchDrive(filename);

 	// Delete txt file from install dir	

 	r = fm->Delete(filename);

 	if (r != KErrNone &&

 		r != KErrNotFound &&

 		r != KErrPathNotFound)

 		{

 		User::Leave(r);

 		}

 	filename = KCInstallDir;

 	filename.AppendNumFixedWidth(aRepository.iUid,EHex,8);

 	filename.Append(KCreFileExt);	

 	PatchDrive(filename);	

 	// Delete cre file from install dir	

 	r = fm->Delete(filename);

 	if (r != KErrNone &&

 		r != KErrNotFound &&

 		r != KErrPathNotFound)

 		{

 		User::Leave(r);

 		}

 	// Give SW time to handle uninstall.

 	User::After(KSmallDelay);

 	CleanupStack::PopAndDestroy(3);

 	}	

 //This function copies files from a source folder to a target folder

 //and sets the file attributes to archive and read only

 EXPORT_C void CopyTestFilesL(CFileMan& aFm, const TDesC& aSrc, const TDesC& aDest)

 	{

 	TBuf<KMaxFileName> src, dest;	

 	src.Copy(aSrc);	

 	dest.Copy(aDest);

 	PatchDrive(dest);

 	//copy test files

 	User::LeaveIfError(aFm.Copy(src, dest,CFileMan::ERecurse));

 	aFm.Attribs(dest,

 					KEntryAttArchive,

 					KEntryAttReadOnly,

 					TTime(0),

 					CFileMan::ERecurse);		

 	}

 //This function prints out the recorded time in milliseconds of aTime.

 EXPORT_C void RecordPerformanceTimingL(TUint32 aTime)

 	{

 	TInt freq = 0;

 	TInt Err = HAL::Get(HAL::EFastCounterFrequency, freq);

 	if(Err != KErrNone)

 	{

 		RDebug::Print(_L("HAL error <%d>\r\n"), Err);

 	}

 	const TInt KMicroSecIn1Sec = 1000000;

 	const TInt KMsIn1Sec = 1000;

 	double v = ((double)aTime * KMicroSecIn1Sec) / (double)freq; TInt v2 = (TInt)v;

 	RDebug::Print(_L("####Execution time: %d ms\r\n"), v2 / KMsIn1Sec);

 	}

 ///////////////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////////////

 //Test macroes and functions

 EXPORT_C void CheckL(RTest& aTest, TInt aValue, TInt aLine)

 	{

 	if (!aValue)

 		{

 		CleanupCDriveL();

 		aTest(EFalse, aLine);

 		}

 	}

 EXPORT_C void CheckL(RTest& aTest, TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if (aValue != aExpected)

 		{

 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"),

 					  aExpected, aValue);

 		CleanupCDriveL();

 		aTest(EFalse, aLine);

 		}

 	}

 /**

  *Retrieves transaction state of the session.

 */

 EXPORT_C TInt TransactionState(CRepository* aRep)

 	{

 	return (static_cast<CClientRepository*>(aRep))->TransactionState();

 	}

 /**

  *Sends EGetSetParameters to server.

 */

 EXPORT_C TInt SetGetParameters(const TIpcArgs& CONDITIONAL_PARAM(aArgs))

 	{

 #if defined(__CENTREP_SERVER_PERFTEST__) || defined(__CENTREP_SERVER_MEMTEST__) || defined(__CENTREP_SERVER_CACHETEST__)

 	RRepositorySession session;

 	TInt ret = session.Connect();

 	if (ret == KErrNone)

 		{

 		ret = session.SendReceive(EGetSetParameters, aArgs);

 		session.Close();

 		}

 	return ret;

 #else

 	return KErrNotSupported;

 #endif

 	}