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