// 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();

	}