// 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\server\T_Fatcharsetconv_Aux.cpp

 // 

 //

 #include <f32dbg.h>

 #include "T_fatcharsetconv_Aux.h"

 CFileMan* gFileMan = NULL;

 RPointerArray<RFile>* gFileHandles = NULL;

 TTestLogFailureData gLogFailureData;

 RRawDisk TheDisk;

 TFatBootSector gBootSector;

 TBool gIOTesting;

 TBool gAutoTest; // is BTB test

 RFs TheFs;

 RFile TheFile;

 RDir TheDir;

 TFileName gSessionPath;

 TInt gAllocFailOff=KAllocFailureOff;

 TInt gAllocFailOn=KAllocFailureOff;

 TChar gDriveToTest;

 TFileName gFileName;

 TTCType	gTCType;

 TUint	gTCId;

 GLDEF_C void Format(TInt aDrive)

 //

 // Format current drive

 //

 	{

 	test.Next(_L("Format"));

 	TBuf<4> driveBuf=_L("?:\\");

 	driveBuf[0]=(TText)(aDrive+'A');

 	RFormat format;

 	TInt count;

 	TInt r=format.Open(TheFs,driveBuf,EQuickFormat,count);

 	test(r==KErrNone);

 	while(count)

 		{

 		TInt r=format.Next(count);

 		test(r==KErrNone);

 		}

 	format.Close();

 	}

 void MakeDir(const TDesC& aDirName)

 //

 // Make a directory

 //

 	{

 	TInt r=TheFs.MkDirAll(aDirName);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	}

 void ReportCheckDiskFailure(TInt aRet)

 //

 // Report the failure of checkdisk

 //

 	{

 	test.Printf(_L("CHECKDISK FAILED: "));

 	switch(aRet)

 		{

 	case 1:	test.Printf(_L("File cluster chain contains a bad value (<2 or >maxCluster)\n")); break;

 	case 2:	test.Printf(_L("Two files are linked to the same cluster\n")); break;

 	case 3:	test.Printf(_L("Unallocated cluster contains a value != 0\n"));	break;

 	case 4:	test.Printf(_L("Size of file != number of clusters in chain\n")); break;

 	default: test.Printf(_L("Undefined Error value %d\n"),aRet);

 		}

 	test(EFalse);

 	}

 void CreateTestDirectory(const TDesC& aSessionPath)

 //

 // Create directory for test

 //

 	{

 	TParsePtrC path(aSessionPath);

 	test(path.DrivePresent()==EFalse);

 	TInt r=TheFs.SetSessionPath(aSessionPath);

 	test(r==KErrNone);

 	r=TheFs.SessionPath(gSessionPath);

 	test(r==KErrNone);

 	r=TheFs.MkDirAll(gSessionPath);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	}

 TInt CurrentDrive(TChar aDriveChar)

 //

 // Return the current drive number

 //

 	{

 	TInt driveNum;

 	TInt r = TheFs.CharToDrive(aDriveChar,driveNum);

 	test(r==KErrNone);

 	gDriveToTest = gSessionPath[0] = (TText)aDriveChar;

 	return(driveNum);

 	}

 TInt CurrentDrive()

 //

 // Return the current drive number

 //

 	{

 	TInt driveNum;

 	TInt r = TheFs.CharToDrive(gSessionPath[0],driveNum);

 	test(r==KErrNone);

 	return(driveNum);

 	}

 void MakeFile(const TDesC& aFileName,const TUidType& aUidType,const TDesC8& aFileContents)

 //

 // Make a file and write uid and data

 //

 	{

 	RFile file;

 	TInt r=file.Replace(TheFs,aFileName,0);

 	test(r==KErrNone || r==KErrPathNotFound);

 	if (r==KErrPathNotFound)

 		{

 		r=TheFs.MkDirAll(aFileName);

 		test(r==KErrNone);

 		r=file.Replace(TheFs,aFileName,0);

 		test(r==KErrNone);

 		}

 	TCheckedUid checkedUid(aUidType);

 	TPtrC8 uidData((TUint8*)&checkedUid,sizeof(TCheckedUid));

 	r=file.Write(uidData);

 	test(r==KErrNone);

 	r=file.Write(aFileContents);

 	test(r==KErrNone);

 	file.Close();

 	}

 void MakeFile(const TDesC& aFileName,const TDesC8& aFileContents)

 //

 // Make a file and write something in it

 //

 	{

 	RFile file;

 	TInt r=file.Replace(TheFs,aFileName,0);

 	if(r!=KErrNone && r!=KErrPathNotFound)

 		{

 		test.Printf(_L("ERROR: r=%d"),r);

 		test(EFalse);

 		}

 	test(r==KErrNone || r==KErrPathNotFound);

 	if (r==KErrPathNotFound)

 		{

 		r=TheFs.MkDirAll(aFileName);

 		test(r==KErrNone);

 		r=file.Replace(TheFs,aFileName,0);

 		test(r==KErrNone);

 		}

 	r=file.Write(aFileContents);

 	test(r==KErrNone);

 	file.Close();

 	}

 void MakeFile(const TDesC& aFileName,TInt anAttributes)

 //

 // Make a file and write something in it

 //

 	{

 	RFile file;

 	TInt r=file.Replace(TheFs,aFileName,0);

 	test(r==KErrNone || r==KErrPathNotFound);

 	if (r==KErrPathNotFound)

 		{

 		r=TheFs.MkDirAll(aFileName);

 		test(r==KErrNone);

 		r=file.Replace(TheFs,aFileName,0);

 		test(r==KErrNone);

 		}

 	file.Close();

 	r=TheFs.SetAtt(aFileName,anAttributes,0);

 	test(r==KErrNone);

 	}

 void MakeFile(const TDesC& aFileName)

 //

 // Make a file

 //

 	{

 	MakeFile(aFileName,_L8(""));

 	}

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 void QuickFormat()

     {

     FormatFatDrive(TheFs, CurrentDrive(), ETrue);

     }

 void ReadBootSector(TFatBootSector& aBootSector)

 	{

     TInt r = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, aBootSector);

     test(r==KErrNone);

     if(!aBootSector.IsValid())

         {

         test.Printf(_L("Wrong bootsector! Dump:\n"));

         aBootSector.PrintDebugInfo();

         test(0);

         }

 	}

 void GetBootInfo()

 	{

 	QuickFormat();

 	ReadBootSector(gBootSector);

 	}

 #endif

 void CheckIfIOTesting(TTestSwitches& aSwitches)

 	{

 	if( ((aSwitches.iExeOnSymbian || aSwitches.iExeOnWindows) && !(aSwitches.iVerOnSymbian || aSwitches.iVerOnWindows))

 	  ||((aSwitches.iVerOnSymbian || aSwitches.iVerOnWindows) && !(aSwitches.iExeOnSymbian || aSwitches.iExeOnWindows))

 	  )

 		{

 		gIOTesting = ETrue;

 		}

 	}

 void CheckDisk()

 	{

 	TInt r=TheFs.CheckDisk(gSessionPath);

 	if (r!=KErrNone && r!=KErrNotSupported)

 		ReportCheckDiskFailure(r);

 	r = TheFs.ScanDrive(gSessionPath);

 	if (r!=KErrNone && r!=KErrNotSupported && r!=KErrInUse)

 		ReportCheckDiskFailure(r);

 	}

 void InitLogData()

 	{

 	gLogFailureData.iExeOsName = KNone;

 	gLogFailureData.iVerOsName = KNone;

 	gLogFailureData.iExeDrive  = 'A';

 	gLogFailureData.iVerDrive  = 'A';

 	}

 void ClearTCLogData()

 	{

 	gLogFailureData.iTCTypeName.SetLength(0);

 	gLogFailureData.iTCFailureOn.SetLength(0);

 	gLogFailureData.iTCId = 0;

 	gLogFailureData.iTCUniquePath.SetLength(0);

 	gLogFailureData.iAPIName.SetLength(0);

 	gLogFailureData.iLineNum = 0;

 	// gLogFailureData.iFileName.SetLength(0);

 	}

 /*

  * 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, TBool aIsWithDLL=EFalse)

 	{

 	if (aBasicUnitaryTestCaseGroup[aIdx].iBasic.iTestCaseID != 0)

 		{

 		aTestCaseFound.iTestCaseID 	= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iTestCaseID;

 		aTestCaseFound.iAPI 		= aBasicUnitaryTestCaseGroup[aIdx].iBasic.iAPI;

 		aTestCaseFound.iSrcDrvChar	= aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iDrvChar;

 		aTestCaseFound.iSrcCmdPath.Copy(aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmdPath);

 		aTestCaseFound.iSrcPrsPath.Copy(aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsPath);

 		aTestCaseFound.iSrcPrsFiles = aBasicUnitaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsFiles;

 		aTestCaseFound.iIsWithDLL = aIsWithDLL;

 		// To make every test case uniquely indentified for interOP

 		// update the test case id  and its path correspondingly

 		TBuf<15> tempName = _L("_");

 		if(aTestCaseFound.iIsWithDLL)

 			tempName.Append(_L("DLL"));

 		else

 			tempName.Append(_L("NDLL"));

 		TInt idx = aTestCaseFound.iSrcCmdPath.Find(_L("\\Src\\"));

 		aTestCaseFound.iSrcCmdPath.Insert(idx, tempName);

 		aTestCaseFound.iSrcPrsPath.Insert(idx, tempName);

 		}

 	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, TBool aIsWithDLL=EFalse)

 	{

 	if (aBasicBinaryTestCaseGroup[aIdx].iBasic.iTestCaseID != 0)

 		{

 		aTestCaseFound.iTestCaseID 	= aBasicBinaryTestCaseGroup[aIdx].iBasic.iTestCaseID;

 		aTestCaseFound.iAPI 		= aBasicBinaryTestCaseGroup[aIdx].iBasic.iAPI;

 		aTestCaseFound.iSrcDrvChar	= aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iDrvChar;

 		aTestCaseFound.iSrcCmdPath.Copy(aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iCmdPath);

 		aTestCaseFound.iSrcPrsPath.Copy(aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsPath);

 		aTestCaseFound.iSrcPrsFiles = aBasicBinaryTestCaseGroup[aIdx].iSrcPrsBasic.iPrsFiles;

 		aTestCaseFound.iTrgDrvChar	= aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iDrvChar;

 		aTestCaseFound.iTrgCmdPath.Copy(aBasicBinaryTestCaseGroup[aIdx].iTrgPrsBasic.iCmdPath);

 		aTestCaseFound.iIsWithDLL = aIsWithDLL;

 		// To make every test case uniquely indentified for interOP

 		// update the test case id  and its path correspondingly

 		TBuf<15> tempBuf;

 		TInt idx = aTestCaseFound.iSrcCmdPath.Find(_L("\\T_FCSC\\")) + 8 /* Len of \\T_FCSC\\ */;

 		TInt i = 0;

 		while(aTestCaseFound.iSrcCmdPath[idx] != '\\')

 			{

 			tempBuf.SetLength(i+1);

 			tempBuf[i++] = aTestCaseFound.iSrcCmdPath[idx++]; 

 			}

 		tempBuf.Append(_L("_"));

 		if(aTestCaseFound.iIsWithDLL)

 			tempBuf.Append(_L("DLL"));

 		else

 			tempBuf.Append(_L("NDLL"));

 		TInt len = 0;

 		idx = aTestCaseFound.iSrcCmdPath.Find(_L("\\T_FCSC\\")) + 8;

 		while(aTestCaseFound.iSrcCmdPath[idx] != '\\')

 			{

 			len++;

 			aTestCaseFound.iSrcCmdPath[idx++]; 

 			}

 		aTestCaseFound.iSrcCmdPath.Replace(idx-len, len, tempBuf);

 		len =0;

 		idx = aTestCaseFound.iSrcPrsPath.Find(_L("\\T_FCSC\\")) + 8;

 		while(aTestCaseFound.iSrcPrsPath[idx] != '\\')

 			{

 			len++;

 			aTestCaseFound.iSrcCmdPath[idx++]; 

 			}

 		aTestCaseFound.iSrcPrsPath.Replace(idx-len, len, tempBuf);

 		len =0;

 		idx = aTestCaseFound.iTrgCmdPath.Find(_L("\\T_FCSC\\")) + 8;

 		while(aTestCaseFound.iTrgCmdPath[idx] != '\\')

 			{

 			len++;

 			aTestCaseFound.iTrgCmdPath[idx++]; 

 			}

 		aTestCaseFound.iTrgCmdPath.Replace(idx-len, len, tempBuf);

 		}

 	else

 		{

 		return KErrNotFound;

 		}

 	return KErrNone;

 	}

 void Help()

 	{

 	RDebug::Print(_L("t_fatcharsetconv [-x {s,w}] [-d {dt}][-v {sw}]"));

 	RDebug::Print(_L("\t-x :	for executing tests"));

 	RDebug::Print(_L("\t\t	s or S for execution on Symbian"));

 	RDebug::Print(_L("\t\t	w or W for execution on Windows"));

 	RDebug::Print(_L("\t-d:		drive to test for execution/verification"));

 	RDebug::Print(_L("\t\t	This test runs on FAT or Win32 file systems only"));

 	RDebug::Print(_L("\t\t	d or D for test drive on Symbian (FAT file system)"));

 	RDebug::Print(_L("\t\t	Any FAT/Win32 file system drive on emulator i.e. T, X etc"));

 	RDebug::Print(_L("\t-v :	for validating tests"));

 	RDebug::Print(_L("\t\t	s or S for verification on symbian"));

 	RDebug::Print(_L("\t\t	w or W for verification on Windows"));

 	}

 void ClearSwitches(TTestSwitches& aSwitches)

 	{

 	// clear the switches

 	aSwitches.iExeOnSymbian = EFalse;

 	aSwitches.iVerOnSymbian = EFalse;

 	aSwitches.iExeOnWindows = EFalse;

 	aSwitches.iVerOnWindows = EFalse;

 	aSwitches.iExeDriveChar =' ';

 	aSwitches.iVerDriveChar =' ';

 	aSwitches.iExeDriveNum =0;

 	aSwitches.iVerDriveNum =0;

 	aSwitches.iMountedFSName.SetLength(0);

 	}

 void ParseCommandArguments(TTestSwitches& aSwitches)

 	{

 	TBuf<256> cmd;

 	User::CommandLine(cmd);

 	RDebug::Print(_L("Command Line : %S"), &cmd);

 	TChar testDrive = 'C';

 	InitLogData();

 	ClearSwitches(aSwitches);

 	TFileName currentFile=RProcess().FileName();

 	TLex lex(cmd);

 	TPtrC token=lex.NextToken();

 	if (token.MatchF(currentFile)==0)

 		{

 		token.Set(lex.NextToken());

 		}

 	if (token.Length()==0)

 		{

 		testDrive = 'C'; // default drives

 		gAutoTest = ETrue;

 		}

 	else if((token[0] >='A' && token[0]<='Z') || (token[0] >='a' && token[0]<='z'))

 		{

 		testDrive = token[0];

 		gAutoTest = ETrue;

 		}

 	else

 		{

 		while (!lex.Eos())

 			{

 			if (token.Length()==0)

 				{

 				continue;	// ignore trailing whitespace

 				}

 			if (token==_L("-x") || token==_L("-X"))

 				{

 				token.Set(lex.NextToken());

 				if((token==_L("s")) || (token==_L("S")))

 					{

 					aSwitches.iExeOnSymbian = ETrue;

 					gLogFailureData.iExeOsName = KSymbian;

 					}

 				else if((token==_L("w")) || (token==_L("W")))

 					{

 					aSwitches.iExeOnWindows = ETrue;

 					gLogFailureData.iExeOsName = KWindows;

 					}

 				token.Set(lex.NextToken());

 				continue;

 				}

 			if (token==_L("-d") || token==_L("-D"))

 				{

 				token.Set(lex.NextToken());

 				testDrive = token[0];

 				token.Set(lex.NextToken());

 				continue;

 				}

 			if (token==_L("-v") || token==_L("-V"))

 				{

 				token.Set(lex.NextToken());

 				if((token==_L("s")) || (token==_L("S")))

 					{

 					aSwitches.iVerOnSymbian = ETrue;

 					gLogFailureData.iVerOsName = KSymbian;

 					}

 				else if((token==_L("w")) || (token==_L("W")))

 					{

 					aSwitches.iVerOnWindows = ETrue;

 					gLogFailureData.iVerOsName = KWindows;

 					}

 				token.Set(lex.NextToken());

 				continue;

 				}

 			RDebug::Print(_L("Unknown option %S"), &token);

 			Help();

 			return;

 			}

 		}

 	CheckIfIOTesting(aSwitches);

 	if(gIOTesting)

 		{

 		gAutoTest = EFalse;

 		}

 	else

 		{

 		gAutoTest = ETrue;

 		}

 	testDrive.UpperCase();

 	if (gAutoTest)

 		{

 #if defined (__WINS__)

 		//execution phase

 		aSwitches.iExeOnWindows = ETrue;

 		aSwitches.iExeDriveChar = testDrive;

 		aSwitches.iExeDriveNum = CurrentDrive(aSwitches.iExeDriveChar);

 		gLogFailureData.iExeDrive = aSwitches.iExeDriveChar;

 		gLogFailureData.iExeOsName = KWindows;

 		//verification phase

 		aSwitches.iVerOnWindows = ETrue;

 		aSwitches.iVerDriveChar = testDrive;

 		aSwitches.iVerDriveNum = CurrentDrive(aSwitches.iVerDriveChar);

 		gLogFailureData.iVerDrive = aSwitches.iVerDriveChar;

 		gLogFailureData.iVerOsName = KWindows;

 #else	

 		//execution phase

 		aSwitches.iExeOnSymbian = ETrue;

 		aSwitches.iExeDriveChar = testDrive;

 		aSwitches.iExeDriveNum = CurrentDrive(aSwitches.iExeDriveChar);

 		gLogFailureData.iExeDrive = aSwitches.iExeDriveChar;

 		gLogFailureData.iExeOsName = KSymbian;

 		//verification phase	

 		aSwitches.iVerOnSymbian = ETrue;

 		aSwitches.iVerDriveChar = testDrive;

 		aSwitches.iVerDriveNum = CurrentDrive(aSwitches.iVerDriveChar);

 		gLogFailureData.iVerDrive = aSwitches.iVerDriveChar;

 		gLogFailureData.iVerOsName = KSymbian;

 #endif

 		}

 	if(aSwitches.iExeOnWindows || aSwitches.iExeOnSymbian)

 		{

 		aSwitches.iExeDriveChar = testDrive;

 		aSwitches.iExeDriveNum = CurrentDrive(aSwitches.iExeDriveChar);

 		gLogFailureData.iExeDrive = aSwitches.iExeDriveChar;

 		}

 	if(aSwitches.iVerOnWindows || aSwitches.iVerOnSymbian)

 		{

 		aSwitches.iVerDriveChar = testDrive;

 		aSwitches.iVerDriveNum = CurrentDrive(aSwitches.iVerDriveChar);

 		gLogFailureData.iVerDrive = aSwitches.iVerDriveChar;

 		}

 	}

 void InitialiseL()

 	{

 	gFileMan=CFileMan::NewL(TheFs);

 	}

 void RmDir(const TDesC& aDirName)

 	{

 	TFileName filename_dir = aDirName;

 	TInt r = 0;

 	r = TheFs.SetAtt(filename_dir, 0, KEntryAttReadOnly);

 	test(r==KErrNone);

 	r=gFileMan->RmDir(filename_dir);

 	test(r==KErrNone || r==KErrNotFound || r==KErrPathNotFound || r==KErrInUse);

 	}

 // Cleanup test variables

 void Cleanup()

 	{

 	delete gFileMan;

 	}

 /**

     Parsing Dir Data Block

     @param  aDataBlock		data block in TInt[] for parsing	

     @param  aDirDataArray	returning dir data array after parsing

     @panic 					if data setup error

 */

 void ParsingDirDataBlock(const TInt aDataBlock[], RArray<TInt>& aDirDataArray)

 	{

 	TInt err = KErrNone;

 	aDirDataArray.Reset();

 	if (aDataBlock[0] == EOB)

 		{

 		return;

 		}

 	TInt i = 1;

 	FOREVER

 		{

 		TInt lastItem = aDataBlock[i-1];

 		TInt currentItem = aDataBlock[i];

 		// check currentItem

 		if (currentItem == EOB)

 			{

 			if (lastItem == CON || lastItem > LAST)

 			//check last

 				{

 				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 				test(EFalse);

 				}

 			else

 			// passed, insert last, break

 				{

 				err = aDirDataArray.InsertInOrder(lastItem);

 				if (err != KErrNone && err != KErrAlreadyExists)

 					{

 					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 					test(EFalse);

 					}

 				break;

 				}

 			}

 		else if (currentItem == CON)

 		// if current == CON

 			{

 			if (lastItem == CON || lastItem >= LAST)

 			// check last item

 				{

 				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 				test(EFalse);

 				}

 			else // last < LAST, last != CON

 				{

 				// check next item

 				TInt nextItem = aDataBlock[i+1];

 				if (nextItem <= 0 || nextItem > LAST || lastItem >= nextItem)

 					{

 					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 					test(EFalse);

 					}

 				else

 					{

 					// all valid

 					for (TInt j = lastItem; j < nextItem; j++)

 						{

 						err = aDirDataArray.InsertInOrder(j);

 						if (err != KErrNone && err != KErrAlreadyExists)

 							{

 							test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 							test(EFalse);

 							}

 						}

 					}

 				}

 			i++;

 			}

 		else if (0 <= currentItem && currentItem <= LAST)

 		// if current == normal item

 			{

 			if (lastItem == CON)

 				{

 				i++;

 				continue;

 				}

 			else if (lastItem >= LAST)

 			// check last item

 				{

 				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 				test(EFalse);

 				}

 			else

 			// passed, insert last

 				{

 				err = aDirDataArray.InsertInOrder(lastItem);

 				if (err != KErrNone && err != KErrAlreadyExists)

 					{

 					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 					test(EFalse);

 					}

 				}

 			i++;

 			}

 			else	// invalid input

 			{

 			test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

 			test(EFalse);

 			}

 		}

 	}

 /**

     Setup dir structure for testing and verifying functional results

     @param	datastr			data structure to setup directory

     @param  iOperation   	Operation to be performed 

     @param  SrcDrive		Source drive

     @param	Targetdrive		Target drive input

     @panic					if data structure definition is incorrect

 */

 void SetupDirFiles(const TDesC& aPath, const TDirSetupFiles& aDirFiles)

 	{

 	TFileName path = aPath;

 	if (path.Length() == 0)

 		{

 		test.Printf(_L("ERROR<SetupDirFiles()>: Zero length src path!\n"));

 		test(EFalse);

 		}

 	MakeDir(path);

 	RArray<TInt> addBlockDataArray;

 	RArray<TInt> deductBlockDataArray;

 	ParsingDirDataBlock(aDirFiles.iAddingBlock, addBlockDataArray);

 	ParsingDirDataBlock(aDirFiles.iDeductBlock, deductBlockDataArray);

 	if (addBlockDataArray.Count() == 0)

 	// empty dir setup

 		{

 		return;

 		}

 	for (TInt i = 0; i < deductBlockDataArray.Count(); ++i)

 		{

 		TInt idxToDelete = addBlockDataArray.FindInOrder(deductBlockDataArray[i]);

 		if (idxToDelete >= 0)

 			{

 			addBlockDataArray.Remove(idxToDelete);

 			}

 		else if (idxToDelete == KErrNotFound)

 			{

 			continue;

 			}

 		else

 			{

 			test.Printf(_L("ERROR<<SetupDir>>: wrong dir data setup! err=%d\n"), idxToDelete);

 			test(EFalse);

 			}

 		}

 	if (addBlockDataArray.Count() > 0)

 		{

 		for (TInt i = 0; i < addBlockDataArray.Count(); ++i)

 			{

 			TInt idx = addBlockDataArray[i];

 			path = aPath;

 			path += gDirPatterns[idx];

 			if (path[path.Length() - 1] == '\\')

 				{

 				MakeDir(path);

 				}

 			else

 				{

 				MakeFile(path, _L8("blahblah"));

 				}

 			}

 		}

 	addBlockDataArray.Reset();

 	deductBlockDataArray.Reset();

 	}

 void LogTestFailureData(TTCType tcType, TFileName failedOn, 

 					TUint tcId, TFileName tcUniquePath, TInt line)

 	{

 	if(tcType == EUnitaryTest)

 		gLogFailureData.iTCTypeName = KUnitary;

 	else if(tcType == EBinaryTest)

 		gLogFailureData.iTCTypeName = KBinary;

 	gLogFailureData.iTCFailureOn = failedOn;

 	gLogFailureData.iTCId = tcId;

 	gLogFailureData.iTCUniquePath.Copy(tcUniquePath);

 	gLogFailureData.iLineNum = line;

 	gLogFailureData.iFileName.Copy(gFileName);

 	RFile file;

 	TBuf8<256>	tempBuf;

 	TFileName logFileName;

 	if(gIOTesting)

 		{

 		if(failedOn == KExecution)

 			{

 			logFileName.Append(KExeLogFileName);

 			}

 		else

 			{

 			logFileName.Append(KVerLogFileName);

 			}

 		}

 	else

 		{

 		logFileName.Append(KLogFileName);

 		}

 	logFileName.Append(KUnderScore);

 	logFileName.Append(gDriveToTest);

 	logFileName.Append(KExtension);

 	TInt r = file.Create(TheFs, logFileName, EFileRead|EFileWrite);

 	test(r == KErrNone || r == KErrAlreadyExists);

 	if (r == KErrNone)

 		{

 		tempBuf.Append(KLogFileHeader);

 		file.Write(tempBuf);

 		}

 	if (r == KErrAlreadyExists)

 		{

 		r = file.Open(TheFs, logFileName, EFileRead|EFileWrite);

 		test(r == KErrNone);

 		TInt start = 0;

 		r=file.Seek(ESeekEnd,start);

 		test(r == KErrNone);

 		}

 	tempBuf.SetLength(0);

 	tempBuf.Append(KNewLine);

 	if(gIOTesting)

 		tempBuf.Append(KYes);

 	else

 		tempBuf.Append(KNo);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iTCTypeName);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iTCFailureOn);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.AppendNum(gLogFailureData.iTCId);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iTCUniquePath);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iFSName);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iExeOsName);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iExeDrive);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iVerOsName);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iVerDrive);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iAPIName);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.AppendNum(gLogFailureData.iLineNum);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iFuncName);

 	tempBuf.Append(KComma);

 	file.Write(tempBuf);

 	tempBuf.SetLength(0);

 	tempBuf.Append(gLogFailureData.iFileName);

 	file.Write(tempBuf);

 	file.Close();

 	}