diff -r 000000000000 -r a41df078684a kerneltest/f32test/cfileman/t_cfileman.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/cfileman/t_cfileman.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,552 @@
+// Copyright (c) 2008-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:
+// f32test\cfileman\t_cfileman.cpp
+// 
+//
+
+#define __E32TEST_EXTENSION__
+#include <f32file.h>
+#include <e32test.h>
+
+#include "t_cfileman_cases.h"
+
+static RArray<TUint> gFailedTestCases;
+
+RTest test(_L("T_CFILEMAN"));
+
+/*
+ * Prints failure notification for failed test cases during test running period
+ */ 
+void DoLogTestCaseFailure(const TTestParamAll& aParam)
+	{
+	const TUint testCaseId = aParam.iTestCaseID; 
+	test.Printf(_L("Test Failure: Case %d !\n"), testCaseId);
+	gFailedTestCases.Append(testCaseId);
+	test.Printf(_L("Print out directory contents:\n"));
+	PrintDir(aParam.iSrcPrsPath, *aParam.iSrcDrvChar);
+	PrintDir(aParam.iSrcCmpPath, *aParam.iSrcDrvChar);
+	if (aParam.iAPI == ECFMMove || aParam.iAPI == ECFMRename || aParam.iAPI == ECFMCopy || aParam.iAPI == ECFMCopyHandle)
+		{
+		PrintDir(aParam.iTrgPrsPath, *aParam.iTrgDrvChar);
+		PrintDir(aParam.iTrgCmpPath, *aParam.iTrgDrvChar);
+		}
+	}
+
+/*
+ * Overall test results logging module, prints out the failing test cases with their ID
+ */
+void DoPrintTestResults()
+	{
+	// if no failure found
+	if (gFailedTestCases.Count() == 0)
+		{
+		test.Printf(_L("All test cases have passed!\n"));
+		return;
+		}
+
+	test.Printf(_L("Test failure(s) found in following case(s):\n"));
+	for (TInt i = 0; i < gFailedTestCases.Count(); i++)
+		{
+		test.Printf(_L("Test Case: %u"), gFailedTestCases[i]);
+		}
+	test(EFalse);
+	}
+
+/*
+ * Presetting module, presets initial source, target and comparing direcotries.
+ * @param	aParam	test param that contains all information about a test case
+ */
+void DoPresettings(const TTestParamAll& aParam)
+	{
+
+	// Setup source files
+	TFileName path = aParam.iSrcPrsPath;
+	path[0] = (TUint16)*aParam.iSrcDrvChar;
+	
+	if(path[0] == (TUint8)gDriveToTest || path[0] == (TUint8)gFixedDriveValid)
+		{
+		SetupDirFiles(path, aParam.iSrcPrsFiles);
+
+		// setup source cmp files
+		path = aParam.iSrcCmpPath;
+		path[0] = (TUint16)*aParam.iSrcDrvChar;
+		SetupDirFiles(path, aParam.iSrcCmpFiles);
+		}
+	
+		if (aParam.iAPI == ECFMMove || aParam.iAPI == ECFMRename || aParam.iAPI == ECFMCopy || aParam.iAPI == ECFMCopyHandle)
+			{
+			// setup trg files
+			path = aParam.iTrgPrsPath;
+			path[0] = (TUint16)*aParam.iTrgDrvChar;
+			
+			if(path[0]== (TUint8)gDriveToTest)
+				{
+				SetupDirFiles(path, aParam.iTrgPrsFiles);
+			
+				// setup trg cmp files
+				path = aParam.iTrgCmpPath;
+				path[0] = (TUint16)*aParam.iTrgDrvChar;
+				SetupDirFiles(path, aParam.iTrgCmpFiles);
+				}
+			}
+	}
+
+/*
+ * Test execution module
+ * @param	aParam	test param that contains all information about a test case
+ * @panic	USER:84	if return codes do not match the expected values. 	
+ */
+
+typedef TBuf<350> TTestFileName; 
+void DoCmdExecution(const TTestParamAll& aParam)
+	{
+	TTestFileName srcCmd = aParam.iSrcCmdPath;
+	if (srcCmd.Length() > 0)
+		{
+		srcCmd[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	else
+		{
+		srcCmd= gSessionPath;
+		srcCmd[0] = (TUint16)*aParam.iSrcDrvChar;
+		}
+	TInt r = KErrNone;
+	switch(aParam.iAPI)
+		{
+		case ECFMDelete:
+			if (!gAsynch)
+				{
+				r = gFileMan->Delete(srcCmd, aParam.iSwitch);
+				test_Equal(r, aParam.iSyncReturn);
+				}
+			else
+				{
+				r = gFileMan->Delete(srcCmd, aParam.iSwitch, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				}
+		break;
+		
+	    case ECFMRmDir:
+			if (!gAsynch)
+				{
+				r = gFileMan->RmDir(srcCmd);
+				test_Equal(r , aParam.iSyncReturn);
+				}
+			else
+				{
+				r = gFileMan->RmDir(srcCmd, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				}
+		break;
+		case ECFMAttribs:
+			if (!gAsynch)
+				{
+				r = gFileMan->Attribs(srcCmd, aParam.iSetAttribs, aParam.iClearAttribs, aParam.iSetModified, aParam.iSwitch);
+				test_Equal(r , aParam.iSyncReturn);
+				}
+			else
+				{
+				r = gFileMan->Attribs(srcCmd, aParam.iSetAttribs, aParam.iClearAttribs, aParam.iSetModified, aParam.iSwitch, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				}
+			break;
+		case ECFMMove:
+			{
+			TTestFileName trgCmd = aParam.iTrgCmdPath;
+			if (trgCmd.Length() > 0)
+				{
+				trgCmd[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				trgCmd= gSessionPath;
+				}
+			if (!gAsynch)
+				{
+				r = gFileMan->Move(srcCmd, trgCmd, aParam.iSwitch);
+				test_Equal(r , aParam.iSyncReturn);
+				}
+			else
+				{
+				r = gFileMan->Move(srcCmd, trgCmd, aParam.iSwitch, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				}
+			break;
+			}
+		case ECFMCopy:
+			{
+			TTestFileName trgCmd = aParam.iTrgCmdPath;
+			if (trgCmd.Length() > 0)
+				{
+				trgCmd[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				trgCmd= gSessionPath;
+				}
+			if (!gAsynch)
+				{
+				r = gFileMan->Copy(srcCmd, trgCmd, aParam.iSwitch);
+				test_Equal(r , aParam.iSyncReturn);
+				}
+			else
+				{
+				r = gFileMan->Copy(srcCmd, trgCmd,aParam.iSwitch, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				}
+			break;
+			}
+		case ECFMRename:
+			{
+			TTestFileName trgCmd = aParam.iTrgCmdPath;
+			if (trgCmd.Length() > 0)
+				{
+				trgCmd[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				trgCmd= gSessionPath;
+				}
+			if (!gAsynch)
+				{
+				r = gFileMan->Rename(srcCmd, trgCmd, aParam.iSwitch);
+				test_Equal(r , aParam.iSyncReturn);
+				}
+			else
+				{
+				r = gFileMan->Rename(srcCmd, trgCmd, aParam.iSwitch, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				}
+			break;
+			}
+		case ECFMCopyHandle:
+		 {
+			TTestFileName trgCmd = aParam.iTrgCmdPath;
+			if (trgCmd.Length() > 0)
+				{
+				trgCmd[0] = (TUint16)*aParam.iTrgDrvChar;
+				}
+			else
+				{
+				trgCmd= gSessionPath;
+				} 
+			
+			if (!gAsynch)
+				{
+				RFile tryfile;
+				TInt ret = 0;
+				ret = tryfile.Open(TheFs, srcCmd, EFileRead|EFileWrite);
+				test_Equal(ret , KErrNone);
+				r = gFileMan->Copy(tryfile, trgCmd, aParam.iSwitch);
+				test_Equal(r , aParam.iSyncReturn);
+				tryfile.Close();
+				}
+			else
+				{
+				RFile tryfile;
+				TInt ret = 0;
+				ret = tryfile.Open(TheFs, srcCmd, EFileRead|EFileWrite);
+				test(ret == KErrNone);
+				r = gFileMan->Copy(tryfile, trgCmd, aParam.iSwitch, gStat);
+				User::WaitForRequest(gStat);
+				test_Equal(r , aParam.iAsyncReturn);
+				test(gStat == aParam.iAsyncStatus);
+				tryfile.Close();
+				}
+		}
+		default:
+		break;
+
+		}
+			
+	}
+
+/*
+ * Result verification module.
+ * @param	aParam	test param that contains all information about a test case
+ * @return	ETrue	if test results in expected behaviour, i.e. test passes
+ * 			EFalse	if test results in unexpected behaviour, i.e. test fails
+ */
+TBool DoResultsVerification(const TTestParamAll& aParam)
+	{
+	TFileName srcPath = aParam.iSrcPrsPath;
+	srcPath[0] = (TUint16)*aParam.iSrcDrvChar;
+	TFileName srcCmpPath = aParam.iSrcCmpPath;
+	srcCmpPath[0] = (TUint16)*aParam.iSrcDrvChar;
+	
+	if ((*aParam.iSrcDrvChar == gDriveToTest))
+		{
+		TBool rel = CompareL(srcPath, srcCmpPath);
+		if(!rel)
+			return EFalse;
+		}
+	
+		if (aParam.iAPI == ECFMMove || aParam.iAPI == ECFMRename || aParam.iAPI == ECFMCopy || aParam.iAPI == ECFMCopyHandle)
+			{
+			TFileName trgPath = aParam.iTrgPrsPath;
+			trgPath[0] = (TUint16)*aParam.iTrgDrvChar;
+			TFileName trgCmpPath = aParam.iTrgCmpPath;
+			trgCmpPath[0] = (TUint16)*aParam.iTrgDrvChar;
+			if ((*aParam.iTrgDrvChar == gDriveToTest))
+				{
+				TBool rel = CompareL(trgPath, trgCmpPath);
+				if(!rel)
+					return rel;
+				}
+			
+			}	
+	return ETrue;
+	}
+
+/*
+ * Search test cases by the index of the array of test case group, overloaded version for basic unitary cases.
+ * @param 	aIdx		the test case index in search
+ * @param	aBasicUnitaryTestCaseGroup		the input test group, should always be gBasicUnitaryTestCases[]
+ * @param	aTestCaseFound		contains params of the test case found by the test case Id.
+ * @return	KErrNone	if only one test case on the id is found
+ * 			KErrNotFound	if no test case is found
+ */
+TInt SearchTestCaseByArrayIdx(TUint aIdx, const TTestCaseUnitaryBasic aBasicUnitaryTestCaseGroup[], TTestParamAll& aTestCaseFound)
+	{
+	if (aBasicUnitaryTestCaseGroup[aIdx].iBasic.iTestCaseID != 0)
+		{
+		aTestCaseFound.iTestCaseID 	= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iTestCaseID;
+		aTestCaseFound.iAPI 		= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iAPI;
+		aTestCaseFound.iSwitch		= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iSwitch;
+		aTestCaseFound.iSyncReturn	= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iSyncReturn;
+		aTestCaseFound.iAsyncReturn	= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iAsyncReturn;
+		aTestCaseFound.iAsyncStatus	= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iAsyncStatus;
+
+		aTestCaseFound.iSrcDrvChar	= aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iDrvChar;
+		aTestCaseFound.iSrcCmdPath.Set(aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmdPath);
+		aTestCaseFound.iSrcPrsPath.Set(aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsPath);
+		aTestCaseFound.iSrcPrsFiles = aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsFiles;
+		aTestCaseFound.iSrcCmpPath.Set(aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmpPath);
+		aTestCaseFound.iSrcCmpFiles = aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmpFiles;
+		}
+	else
+		return KErrNotFound;
+	return KErrNone;
+		
+	}
+
+/*
+ * Search test cases by the index of the array of test case group, overloaded version for basic binary cases.
+ * @param 	aIdx		the test case index in search
+ * @param	aBasicUnitaryTestCaseGroup		the input test group, should always be gBasicBinaryTestCases[]
+ * @param	aTestCaseFound		contains params of the test case found by the test case Id.
+ * @return	KErrNone	if only one test case on the id is found
+ * 			KErrNotFound	if no test case is found
+ */
+TInt SearchTestCaseByArrayIdx(TUint aIdx, const TTestCaseBinaryBasic aBasicBinaryTestCaseGroup[], TTestParamAll& aTestCaseFound)
+	{
+	if (aBasicBinaryTestCaseGroup[aIdx].iBasic.iTestCaseID != 0)
+		{
+		aTestCaseFound.iTestCaseID 	= aBasicBinaryTestCaseGroup[aIdx].iBasic.iTestCaseID;
+		aTestCaseFound.iAPI 		= aBasicBinaryTestCaseGroup[aIdx].iBasic.iAPI;
+		aTestCaseFound.iSwitch		= aBasicBinaryTestCaseGroup[aIdx].iBasic.iSwitch;
+		aTestCaseFound.iSyncReturn	= aBasicBinaryTestCaseGroup[aIdx].iBasic.iSyncReturn;
+		aTestCaseFound.iAsyncReturn	= aBasicBinaryTestCaseGroup[aIdx].iBasic.iAsyncReturn;
+		aTestCaseFound.iAsyncStatus	= aBasicBinaryTestCaseGroup[aIdx].iBasic.iAsyncStatus;
+
+		aTestCaseFound.iSrcDrvChar	= aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iDrvChar;
+		aTestCaseFound.iSrcCmdPath.Set(aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmdPath);
+		aTestCaseFound.iSrcPrsPath.Set(aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsPath);
+		aTestCaseFound.iSrcPrsFiles = aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsFiles;
+		aTestCaseFound.iSrcCmpPath.Set(aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmpPath);
+		aTestCaseFound.iSrcCmpFiles = aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmpFiles;
+
+		aTestCaseFound.iTrgDrvChar	= aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iDrvChar;
+		aTestCaseFound.iTrgCmdPath.Set(aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iCmdPath);
+		aTestCaseFound.iTrgPrsPath.Set(aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iPrsPath);
+		aTestCaseFound.iTrgPrsFiles = aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iPrsFiles;
+		aTestCaseFound.iTrgCmpPath.Set(aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iCmpPath);
+		aTestCaseFound.iTrgCmpFiles = aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iCmpFiles;
+		}
+	else
+		{
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}
+
+/*
+ * Search test cases by test case Id, overloaded version for Basic unitary cases.
+ * @param 	aCaseId		the test case Id in search
+ * @param	aBasicUnitaryTestCaseGroup		the input test group, should always be gBasicUnitaryTestCases[]
+ * @param	aTestCaseFound		contains params of the test case found by the test case Id.
+ * @return	KErrNone	if only one test case on the id is found
+ * 			KErrAlreadyExists	if more than one test cases found by the test case Id
+ * 			KErrNotFound	if no test case is found
+ */
+TInt SearchTestCaseByTestCaseId(TUint aCaseId, const TTestCaseUnitaryBasic aBasicUnitaryTestCaseGroup[], TTestParamAll& aTestCaseFound)
+	{
+	TBool found = EFalse;
+	TInt rel = KErrNone;
+
+	// Scan through the test group by array index
+	for(TInt i = 0; rel == KErrNone; i++)
+		{
+		rel = SearchTestCaseByArrayIdx(i, aBasicUnitaryTestCaseGroup, aTestCaseFound);
+		if(aTestCaseFound.iTestCaseID == aCaseId)
+			{
+			// If more than one test cases found, return error 
+			if(found)
+				{
+				return KErrAlreadyExists;
+				}
+			found = ETrue;
+			}
+		}
+
+	if (!found)
+		{
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}
+
+/*
+ * Do all basic binary test cases defined in gBasicUnitaryTestCases[]
+ */
+void DoAllBasicUnitaryTests(const TTestCaseUnitaryBasic aBasicUnitaryTestCaseGroup[])
+	{
+	TTestParamAll nextTestCase;
+	TInt i = 0;
+	
+	while (SearchTestCaseByArrayIdx(i, aBasicUnitaryTestCaseGroup, nextTestCase) == KErrNone)
+		{
+		TTime startTime;
+		TTime endTime;
+		startTime.HomeTime();
+		DoPresettings(nextTestCase);
+		DoCmdExecution(nextTestCase);
+		if (!DoResultsVerification(nextTestCase))
+			{
+			DoLogTestCaseFailure(nextTestCase);
+			}
+		else
+			{
+			test.Printf(_L("Test ID %d passed \n"),nextTestCase.iTestCaseID);
+			}
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken(0);
+		timeTaken = endTime.MicroSecondsFrom(startTime);
+		TInt time2=0;
+		time2=I64LOW(timeTaken.Int64()/1000);
+		test.Printf(_L("Time Taken by testid %d = %d mS \n"),nextTestCase.iTestCaseID,time2);		
+		++i;
+
+		}
+	}
+
+/*
+ * Do all basic binary test cases defined in gBasicBinaryTestCases[]
+ */
+void DoAllBasicBinaryTests(const TTestCaseBinaryBasic aBasicBinaryTestCaseGroup[])
+	{
+	TTestParamAll nextTestCase;
+	TInt i = 0;
+	while (SearchTestCaseByArrayIdx(i, aBasicBinaryTestCaseGroup, nextTestCase) == KErrNone)
+		{
+		TTime startTime;
+		TTime endTime;
+		startTime.HomeTime();
+		DoPresettings(nextTestCase);
+		DoCmdExecution(nextTestCase);
+		if (!DoResultsVerification(nextTestCase))
+			{
+			DoLogTestCaseFailure(nextTestCase);
+			}
+		else
+			{
+			test.Printf(_L("Test ID %d passed \n"),nextTestCase.iTestCaseID);
+			}
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken(0);
+		timeTaken = endTime.MicroSecondsFrom(startTime);
+
+		TInt time2=0;
+		time2=I64LOW(timeTaken.Int64()/1000);
+		test.Printf(_L("Time Taken by test id %d = %d mS \n"),nextTestCase.iTestCaseID,time2);
+		++i;
+		}
+	}
+
+// Future work: provide command arguement parsing faclity so that users
+//  can choose specific test case(s) in ranges
+//  can choose specific API(s), switches, configurations, etc. for testing
+/*
+ * Main testing control unit
+ */
+void TestMain()
+	{
+//The __PERFTEST__ macro is for future use when a tests are setup to run on a performance machine 
+//which will be enabled to run for both WINSCW and ARMV5
+#ifndef __PERFTEST__
+	//Tests are enabled to run for WINSCW only on the below specified drives due to the time constraint.
+	if((gDriveToTest == 'C') || (gDriveToTest == 'X') || (gDriveToTest == 'Y'))
+		{
+		DoAllBasicUnitaryTests(gBasicUnitaryTestCases);
+		DoAllBasicBinaryTests(gBasicBinaryTestCases);
+		}
+	else
+		{
+		test.Printf(_L("Drive %C: is not supported for this configuration, see test logs for supported configuration details"),gDriveToTest);
+		}
+#endif
+	
+#ifdef __PERFTEST__
+		DoAllBasicUnitaryTests(gBasicUnitaryTestCases);
+		DoAllBasicBinaryTests(gBasicBinaryTestCases);
+#endif	
+	}
+
+
+/*
+ * Initialise test, do all tests in both sync and async mode. 
+*/
+void CallTestsL()
+	{
+	InitialiseL();
+	
+	CreateTestDirectory(_L("\\F32-TST\\T_CFILEMAN\\"));
+
+	gAsynch=EFalse;	
+	test.Next(_L("Synchronous tests ..."));
+	TestMain();
+	
+	DeleteTestDirectory();
+
+	CreateTestDirectory(_L("\\F32-TST\\T_CFILEMAN\\"));
+	gAsynch=ETrue;
+	test.Next(_L("Asynchronous tests ..."));
+	TestMain();
+
+	DoPrintTestResults();
+	Cleanup();
+	DeleteTestDirectory();
+	}