// 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_aux.cpp

// 

//

#include "t_cfileman_aux.h"

CFileMan* gFileMan = NULL;

RPointerArray<RFile>* gFileHandles = NULL;

TBool gAsynch = EFalse;

TRequestStatus gStat;

TBool testingInvalidPathLengths;

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

	r=gFileMan->RmDir(filename_dir);

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

	}

// Cleanup test variables

void Cleanup()

	{

	delete gFileMan;

	}

//Test that the contents of two directories are identical

TBool CompareL(const TDesC& aDir1,const TDesC& aDir2)

	{

	TBool rel = ETrue;

	CDirScan* scanDir1=CDirScan::NewL(TheFs);

	scanDir1->SetScanDataL(aDir1,KEntryAttMaskSupported,ESortByName);

	CDirScan* scanDir2=CDirScan::NewL(TheFs);

	scanDir2->SetScanDataL(aDir2,KEntryAttMaskSupported,ESortByName);

	FOREVER

		{

		CDir* entryList1;

		CDir* entryList2;

		scanDir1->NextL(entryList1);

		scanDir2->NextL(entryList2);

		if (entryList1==NULL || entryList2==NULL)

			{

			if (!(entryList1==NULL && entryList2==NULL))

				{

				delete entryList1, 

				delete entryList2, 

				delete scanDir1, 

				delete scanDir2;

				return(EFalse);

				}

			break;

			}

		TFileName abbPath1=scanDir1->AbbreviatedPath();

		TFileName abbPath2=scanDir2->AbbreviatedPath();

		if (!(abbPath1==abbPath2))

			{

			delete entryList1, 

			delete entryList2, 

			delete scanDir1, 

			delete scanDir2;

			return(EFalse);

			}

		TInt count1=entryList1->Count();

		TInt count2=entryList2->Count();

		if (!(count1==count2))

			{

			delete entryList1, 

			delete entryList2, 

			delete scanDir1, 

			delete scanDir2;

			return(EFalse);

			}

		while(count1--)

			{

			TEntry entry1=(*entryList1)[count1];

			TEntry entry2=(*entryList2)[count1];

			if (!(entry1.iName==entry2.iName))

				{

				delete entryList1, 

				delete entryList2, 

				delete scanDir1, 

				delete scanDir2;

				return(EFalse);

				}

			if (!(entry1.iAtt==entry2.iAtt))

				{

				delete entryList1, 

				delete entryList2, 

				delete scanDir1, 

				delete scanDir2;

				return(EFalse);

				}

			}

		delete entryList1;

		delete entryList2;

		}

	delete scanDir1;

	delete scanDir2;

	return rel;

	}

/**

    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 attribs:

	@param  filenamedir   		root path of dir data or a file data

	@param  mode			    value of an mode to be set(Normal/Open/Shared..)

*/

void OpenFile(TDesC& aFile, TFileMode aFileMode)

	{

	RFile* file = new (ELeave) RFile;

	gFileHandles->Append(file);

	TInt ret = 0;

	ret = file->Open(TheFs, aFile, aFileMode);

	test(ret==KErrNone);

	}

/**

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

		}

	RmDir(path);

	MakeDir(path);

	RArray<TInt> addBlockDataArray;

	RArray<TInt> deductBlockDataArray;

	ParsingDirDataBlock(aDirFiles.iAddingBlock, addBlockDataArray);

	ParsingDirDataBlock(aDirFiles.iDeductBlock, deductBlockDataArray);

	if (addBlockDataArray.Count() == 0)

	// empty dir setup

		{

		return;

		}

	else

		{

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

	}

/**

    Print out all items in aPath

    @param  aPath 		root path for scanning

    @panic				SetScanData error

*/

void PrintDir(const TDesC& aPath, const TChar& aDrv)

	{

	TFileName fn;

	if (aPath.Length() == 0)

		{

		return;

		}

	else

		{

		fn = aPath;

		fn[0] = (TUint16)aDrv;

		test.Printf(_L("==============================\n"));

		test.Printf(_L("<<PrintDir>>: root = \"%S\"\n"), &fn);

		}

	CDirScan* scan = CDirScan::NewL(TheFs);

	TUint entryAttMask = KEntryAttMaskSupported;

	TUint entrySortMask = EDirsLast|EAscending;

	CDirScan::TScanDirection scanDirection = CDirScan::EScanDownTree;

	TRAPD(err, scan->SetScanDataL(fn, entryAttMask, entrySortMask, scanDirection));

	test(err == KErrNone);

	CDir* dir = NULL;

	TInt i = 0;

	TBool temp_val = ETrue;

	while (temp_val)

		{

		scan->NextL(dir);

		if (dir != NULL)

			{

			for (TInt j = 0; j < dir->Count(); ++j)

				{

				TFileName item(fn.Left(aPath.Length() - 1));

				item.Append(scan->AbbreviatedPath());

				TEntry dummy = (*dir)[j];

				item.Append(dummy.iName);

				if (dummy.iAtt & KEntryAttDir)

					{

					item.Append('\\');

					}

				test.Printf(_L("<<PrintDir>>: item %d: \"%S\"\n"), i, &item);

				++i;

				}

			delete dir;

			dir = NULL;

			}

		else

			{

			break;

			}

		}

	delete scan;

	}