diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/baseapitest/basesvs/validation/f32/sfsrv/src/T_DirScanData.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/kernelhwsrv/baseapitest/basesvs/validation/f32/sfsrv/src/T_DirScanData.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,480 @@
+/*
+* 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: 
+*
+*/
+
+
+/**
+@test
+@internalComponent
+v
+This contains CT_DirScanData
+*/
+
+//	User includes
+#include "T_DirScanData.h"
+#include "T_SfSrvServer.h"
+
+/*@{*/
+///	Parameters
+_LIT(KAttMask,							"attmask" );
+_LIT(KRfsObject,						"rfsObject");
+_LIT(KDirObject,						"dirObject");
+_LIT(KExpected,							"expected");
+_LIT(KPath,								"path");
+_LIT(KEntrySortKey,						"sortkey");
+_LIT(KScanDirection,					"scandirection");
+
+///Commands
+_LIT(KCmdNewL,							"NewL");
+_LIT(KCmdNewLC,							"NewLC");
+_LIT(KCmdSetScanDataL,					"SetScanDataL");
+_LIT(KCmdFullPath,						"FullPath");
+_LIT(KCmdAbbreviatedPath,				"AbbreviatedPath");
+_LIT(KCmdNextL,							"NextL");
+_LIT(KCmdDestructor,					"~");
+
+//	Sort key
+_LIT(KESortNone,						"ESortNone");
+_LIT(KESortByName,						"ESortByName");
+_LIT(KESortByExt,						"ESortByExt");
+_LIT(KESortBySize,						"ESortBySize");
+_LIT(KESortByDate,						"ESortByDate");
+_LIT(KESortByUid,						"ESortByUid");
+_LIT(KEDirsAnyOrder,					"EDirsAnyOrder");
+_LIT(KEDirsFirst,						"EDirsFirst");
+_LIT(KEDirsLast,						"EDirsLast");
+_LIT(KEAscending,						"EAscending");
+_LIT(KEDescending,						"EDescending");
+_LIT(KEDirDescending,					"EDirDescending");
+
+// Scan directions
+_LIT(KEScanUpTree,	 					"EScanUpTree");
+_LIT(KEScanDownTree,	 				"EScanDownTree");
+
+
+CT_DirScanData* CT_DirScanData::NewL()
+/**
+* Two phase constructor
+*/
+	{
+	CT_DirScanData* ret = new (ELeave) CT_DirScanData();
+	CleanupStack::PushL(ret);
+	ret->ConstructL();
+	CleanupStack::Pop(ret);
+	return ret;
+	}
+	
+
+CT_DirScanData::CT_DirScanData()
+:	iDirScan(NULL)
+/**
+* Protected constructor. First phase construction
+*/
+	{
+	}
+
+
+void CT_DirScanData::ConstructL()
+/**
+* Protected constructor. Second phase construction
+*/
+	{
+	}
+
+
+CT_DirScanData::~CT_DirScanData()
+/**
+* Destructor.
+*/
+	{
+	DoCleanup();
+	}
+
+
+TAny* CT_DirScanData::GetObject()
+	{
+	return iDirScan;
+	}
+
+
+TBool	CT_DirScanData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)
+/**
+* Process a command read from the ini file
+*
+* @param aCommand	the command to process
+* @param aSection	the section in the ini file requiring the command to be processed
+*
+* @return ETrue if the command is processed
+*/
+	{
+	TBool	retVal = ETrue;
+
+	if (aCommand == KCmdNewL)
+		{
+		DoCmdNewL(aSection);
+		}
+	else if (aCommand == KCmdDestructor)
+		{
+		DoCleanup();
+		}
+	else if (aCommand == KCmdNewLC)
+		{
+		DoCmdNewLC(aSection);
+		}
+	else if (aCommand == KCmdSetScanDataL)
+		{
+		DoCmdSetScanDataL(aSection);
+		}
+	else if (aCommand == KCmdNextL)
+		{
+		DoCmdNextL(aSection);
+		}
+	else if (aCommand == KCmdAbbreviatedPath)
+		{
+		DoCmdAbbreviatedPath(aSection);
+		}
+	else if (aCommand == KCmdFullPath)
+		{
+		DoCmdFullPath(aSection);
+		}
+	else
+		{
+		retVal = EFalse;
+		}
+	return retVal;
+	}
+
+void CT_DirScanData::DoCleanup()
+	{
+	INFO_PRINTF1(_L("Doing cleanup!"));
+	
+	if (iDirScan)
+		{
+		delete iDirScan;
+		iDirScan = NULL;
+		}
+	}
+		
+void CT_DirScanData::DoCmdNewL(const TDesC& aSection)
+	{
+	INFO_PRINTF1(_L("Constructing CDirScan object!"));
+	
+	RFs*	rfsObject = NULL;
+	TPtrC	rfsObjectName;
+	if (GET_MANDATORY_STRING_PARAMETER(KRfsObject, aSection, rfsObjectName))
+		{
+		rfsObject = (RFs*)GetDataObjectL(rfsObjectName);
+		}
+	
+	DoCleanup();
+	TRAPD (error, iDirScan = CDirScan::NewL(*rfsObject));
+	if (error == KErrNone)
+		{
+		INFO_PRINTF1(_L("CDirScan object has been created with NewL constructor!"));			
+		}
+	else
+		{
+		ERR_PRINTF2(_L("CDirScan object is not created with NewL constructor! Error code: %d"), error);
+		SetError(error);
+		}
+	}
+	
+void CT_DirScanData::DoCmdNewLC(const TDesC& aSection)
+	{
+	INFO_PRINTF1(_L("Constructing CDirScan object!"));
+	
+	RFs*	rfsObject = NULL;
+	TPtrC	rfsObjectName;
+	if (GET_MANDATORY_STRING_PARAMETER(KRfsObject, aSection, rfsObjectName))
+		{
+		rfsObject = (RFs*)GetDataObjectL(rfsObjectName);
+		}
+	
+	DoCleanup();
+	TRAPD (error, iDirScan = CDirScan::NewLC(*rfsObject); CleanupStack::Pop(iDirScan) );
+	if (error == KErrNone)
+		{
+		INFO_PRINTF1(_L("CDirScan object has been created with NewLC constructor!"));
+		}
+	else
+		{
+		ERR_PRINTF2(_L("CDirScan object is not created with NewLC constructor! Error code: %d"), error);
+		SetError(error);
+		}
+	}
+
+void CT_DirScanData::DoCmdSetScanDataL(const TDesC& aSection)
+	{
+	INFO_PRINTF1(_L("Setting data scanning!"));
+	
+	TBool	dataOk = ETrue;
+	
+	TPtrC	path;
+	if (!GET_MANDATORY_STRING_PARAMETER(KPath(), aSection, path))
+		{
+		dataOk = EFalse;
+		}
+
+	TUint	attMask = KEntryAttHidden;
+	if ( !FileserverUtil::GetAttMask(*this, aSection, KAttMask(), attMask))
+        {
+       	dataOk = EFalse;
+       	}
+
+	TPtrC	entrySortKey;
+	TUint	sortKey = ESortNone;
+	
+	if (GET_OPTIONAL_STRING_PARAMETER(KEntrySortKey(), aSection, entrySortKey))
+		{
+		if ( !ConvertToSortKey(entrySortKey, sortKey) )
+			{
+			TInt	intTemp;
+			if ( GET_MANDATORY_INT_PARAMETER(KEntrySortKey(), aSection, intTemp) )
+				{
+				sortKey=intTemp;
+				}
+			else
+				{
+				dataOk = EFalse;
+				}
+			}
+		}
+		
+	TPtrC						entryScanDirection;
+	CDirScan::TScanDirection	scanDirection = CDirScan::EScanDownTree;
+	
+	if (GET_OPTIONAL_STRING_PARAMETER(KScanDirection(), aSection, entryScanDirection))
+		{
+		if ( !ConvertToScanDirection(entryScanDirection, scanDirection))
+            {
+           	dataOk = EFalse;
+           	}
+		}
+		
+	
+	if (dataOk)
+		{
+		TRAPD (err, iDirScan->SetScanDataL(path, attMask, sortKey, scanDirection));
+		if(err == KErrNone)
+			{
+			INFO_PRINTF1(_L("SetScanDataL complete!"));
+			}
+		else
+			{
+			ERR_PRINTF2(_L("SetScanDataL() Error: %d"), err);
+			SetError(err);
+			}
+		}
+	}	
+
+void CT_DirScanData::DoCmdNextL(const TDesC& aSection)
+	{
+	INFO_PRINTF1(_L("Scanning next directory entries!"));
+	
+	CDir*		dirObject = NULL;
+	CT_DirData* dirWrapperObject = NULL;
+	TPtrC		dirObjectName;
+	
+	if (GET_MANDATORY_STRING_PARAMETER(KDirObject, aSection, dirObjectName))
+		{
+		dirWrapperObject = static_cast<CT_DirData*>(GetDataWrapperL(dirObjectName));
+		}
+	TRAPD (err, iDirScan->NextL(dirObject));
+	if (err == KErrNone)
+		{
+		if (dirObject == NULL)
+			{
+			INFO_PRINTF1(_L("CDir instance is NULL, there is no directory left to go."));
+			}
+		else
+			{
+			INFO_PRINTF1(_L("Scanning the next directory entry completed successfully!"));
+			}
+		}
+	else
+		{
+		ERR_PRINTF2(_L("Can't scan the next directory entry in the structure Error code: %d"), err);
+		SetError(err);
+		}
+		
+	if (dirObject)
+		{
+		if(dirWrapperObject)
+			{
+			dirWrapperObject->SetObjectL(dirObject);
+			}
+		else
+		    {
+		    delete dirObject;
+		    dirObject = NULL;			        
+		    }
+		}	
+	}
+	
+void CT_DirScanData::DoCmdAbbreviatedPath(const TDesC& aSection)
+	{
+	INFO_PRINTF1(_L("Getting directory abbreviated path!"));
+	
+	TPtrC	expected;
+	if (GET_MANDATORY_STRING_PARAMETER(KExpected(), aSection, expected))
+		{
+		TPtrC	abbPath;
+		abbPath.Set(iDirScan->AbbreviatedPath());
+		
+		if (abbPath != expected)
+			{
+			ERR_PRINTF3(_L("Result (%S) didn't match with expected result (%S)!"), &abbPath, &expected);
+			SetBlockResult(EFail);
+			}
+		else 
+			{
+			INFO_PRINTF2(_L("Result (%S) match with expected result!"), &abbPath);
+			}
+		}
+	}
+
+void CT_DirScanData::DoCmdFullPath(const TDesC& aSection)
+	{
+	INFO_PRINTF1(_L("Getting directory full path!"));
+	
+	TPtrC	expected;
+	if (GET_MANDATORY_STRING_PARAMETER(KExpected(), aSection, expected))
+		{
+		TPtrC	fullPath;
+		fullPath.Set(iDirScan->FullPath());
+		
+		if (fullPath != expected)
+			{
+			ERR_PRINTF3(_L("Result (%S) didn't match with expected result (%S)!"), &fullPath, &expected);
+			SetBlockResult(EFail);
+			}
+		else 
+			{
+			INFO_PRINTF2(_L("Result (%S) match with expected result!"), &fullPath);
+			}
+		}
+	}
+	
+	
+TBool CT_DirScanData::ConvertToSortKey(const TDesC& aSortKeyStr, TUint& aSortKey)
+	{
+	TBool ret = ETrue;
+
+	if (aSortKeyStr == KESortNone)
+		{
+		aSortKey = ESortNone;
+		}
+	else if (aSortKeyStr == KESortByName)
+		{
+		aSortKey = ESortByName;
+		}
+	else if (aSortKeyStr == KESortByExt)
+		{
+		aSortKey = ESortByExt;
+		}
+	else if (aSortKeyStr == KESortBySize)
+		{
+		aSortKey = ESortBySize;
+		}
+	else if (aSortKeyStr == KESortByDate)
+		{
+		aSortKey = ESortByDate;
+		}
+	else if (aSortKeyStr == KESortByUid)
+		{
+		aSortKey = ESortByUid;
+		}
+	else if (aSortKeyStr == KEDirsAnyOrder)
+		{
+		aSortKey = EDirsAnyOrder;
+		}
+	else if (aSortKeyStr == KEDirsFirst)
+		{
+		aSortKey = EDirsFirst;
+		}
+	else if (aSortKeyStr == KEDirsLast)
+		{
+		aSortKey = EDirsLast;
+		}
+	else if (aSortKeyStr == KEAscending)
+		{
+		aSortKey = EAscending;
+		}
+	else if (aSortKeyStr == KEDescending)
+		{
+		aSortKey = EDescending;
+		}
+	else if (aSortKeyStr == KEDirDescending)
+		{
+		aSortKey = EDirDescending;
+		}
+	else if (aSortKeyStr.Match((_L("*|*"))) != KErrNotFound)
+		{
+		TUint tmpSortKey;
+
+		TInt location = aSortKeyStr.Match(_L("*|*"));
+		//Converting Left part of the data
+		TPtrC left = aSortKeyStr.Left(location);
+		if (ConvertToSortKey(left, tmpSortKey))
+			{
+			aSortKey = tmpSortKey;
+			}
+		else
+			{
+			ret = EFalse;
+			}
+
+		//Converting right data can be with another "|"
+		TPtrC right = aSortKeyStr.Mid(location + 1);
+
+		if (ConvertToSortKey(right, tmpSortKey))
+			{
+			aSortKey = aSortKey | tmpSortKey;
+			}
+		else
+			{
+			ret = EFalse;
+			}
+		}
+	else
+		{
+		ret = EFalse;
+		}
+
+	return ret;
+	}
+
+
+	
+TBool CT_DirScanData::ConvertToScanDirection(const TDesC& aScanDirectionStr, CDirScan::TScanDirection& aScanDirection)
+	{
+	TBool ret = ETrue;
+
+	if (aScanDirectionStr == KEScanUpTree)
+		{
+		aScanDirection = CDirScan::EScanUpTree;
+		}
+	else if (aScanDirectionStr == KEScanDownTree)
+		{
+		aScanDirection = CDirScan::EScanDownTree;
+		}
+	else
+		{
+		ret = EFalse;
+		}
+
+	return ret;
+	}