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

	}