// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Tests EikFileUtils APIs.

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include <eikfutil.h>

#include <ecom/ecom.h>

#include "tfileutils.h"

#include <tfileutils.rsg>

_LIT(KTFileUtilesResourceFilePath, "z:\\system\\test\\fileutils\\tfileutils.rsc");

// globals 

TBufC<128> KOriginalFileName = _L("c:\\home\\letters\\azxcvmbcdef");

//

// class CTFileUtilsAppUi

//

CTFileUtilsAppUi::CTFileUtilsAppUi(CTmsTestStep* aStep) :

	CTestAppUi(aStep, KTFileUtilesResourceFilePath)

	{

	}

void CTFileUtilsAppUi::ConstructL()

    {

    CTestAppUi::ConstructL();

	AutoTestManager().StartAutoTest();

    }

CTFileUtilsAppUi::~CTFileUtilsAppUi()

    {

    }

/**

   The method is an override from CTestAppUi. The method initiates tests on

   EikFileUtils APIs.

 */

void CTFileUtilsAppUi::RunTestStepL(TInt aNumStep)

 	{

	User::After(TTimeIntervalMicroSeconds32(500000));

 	switch(aNumStep)

 		{

 	case 1:

 		SetTestStepID(_L("UIF-fileutils-TestFileOperations"));

		TestFileOperations();

		RecordTestResultL();

		break;

 	case 2:

 		SetTestStepID(_L("UIF-fileutils-TestFileOperations2"));

		TestFileOperations2();

		RecordTestResultL();

		break;

	case 3:

		SetTestStepID(_L("UIF-fileutils-TestFileOperations3"));

		TestFileOperations3();

		RecordTestResultL();

		break;

	case 4:

		SetTestStepID(_L("UIF-fileutils-TestFileOperations4"));

		TestFileOperations4();

		RecordTestResultL();

		break;

	case 5:

		SetTestStepID(_L("UIF-fileutils-TestAbbreviateFileName"));

		TestAbbreviateFileName();

		RecordTestResultL();

		break;

	case 6:

		SetTestStepID(_L("UIF-fileutils-TestUidTypeMatches"));

		TestUidTypeMatches();

		RecordTestResultL();

		break;

	case 7:

		SetTestStepID(_L("UIF-fileutils-TestValidFolderName"));

		TestValidFolderName();

		RecordTestResultL();

		break;

	case 8:

		{

		SetTestStepID(_L("UIF-fileutils-TestDiskListL"));

		TRAPD(err, TestDiskListL());

		TEST(err == KErrNone);

		RecordTestResultL();

		break;

		}

	case 9:

		{

		SetTestStepID(_L("UIF-fileutils-TestSortByTableL"));

		TRAPD(err, TestSortByTableL());

		TEST(err == KErrNone);

		RecordTestResultL();

		CloseTMSGraphicsStep();

		break;

		}

	case 10:

 		INFO_PRINTF1(_L("Tests completed.\n"));

 		AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);

		break;	

	default:

 		break;

 		}

 	}

/**

   This method creates & sets the application's user interface object.

 */

void CFileUtilsStep::ConstructAppL(CEikonEnv* aEikEnv)

     { // runs inside a TRAP harness

	aEikEnv->ConstructL();

 	CTFileUtilsAppUi* appUi=new(ELeave) CTFileUtilsAppUi(this);

	CleanupStack::PushL(appUi);

 	aEikEnv->SetAppUi(appUi);

	appUi->ConstructL();

	CleanupStack::Pop(appUi);

	// goes out of scope when function leaves and private members are destroyed. App Architecture handles 

	// CEikAppUI destruction

     }

CFileUtilsStep::~CFileUtilsStep()

	{

	}

CFileUtilsStep::CFileUtilsStep()

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KFileUtilsStep);

	}

/**

   The method creates & sets the test step's user interface object and

   launches the test step.

 */

TVerdict CFileUtilsStep::doTestStepL()

	{

	INFO_PRINTF1(_L("Test Started"));

	PreallocateHALBuffer();

	__UHEAP_MARK;

 	CEikonEnv* eikEnv=new CEikonEnv;

 	if (eikEnv==NULL)

		{

		INFO_PRINTF1(_L("Failed to create Eikon Environment due to lack of Memory"));

		SetTestStepResult(EFail);

 		return TestStepResult();

		}

 	TRAPD(err,ConstructAppL(eikEnv));

 	if (err!=KErrNone)

		{

 		SetTestStepResult(EFail);

		delete eikEnv;

		INFO_PRINTF2(_L("Failed to construct Eikon Environment, error %d"), err);

		}

 	else

 		eikEnv->ExecuteD();

	REComSession::FinalClose();	

 	__UHEAP_MARKEND;

	INFO_PRINTF1(_L("Test Finished"));

	return TestStepResult();

    }

/**

   @SYMTestCaseID UIF-fileutils-TestFileOperations

   @SYMPREQ

   @SYMTestCaseDesc Test folder information,file copy, renaming & deletion APIs of

   EikFileUtils.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The method tests the following APIs:\n

   1.EikFileUtils::IsFolder() : IsFolder() API is tested to verify whether 

   folder path exists by passing invalid & valid folder paths. It also tests the

   API by passing valid path including filename of a file.\n

   2.EikFileUtils::PathExists() : PathExists() API is tested to verify whether

   the specifed path exists by passing valid path including filename.\n

   3.EikFileUtils::FolderExists() : FolderExists() API is tested to verify

   whether folder exists by passing a valid folder path.\n

   4.EikFileUtils::CheckFolder() : CheckFolder() API is tested by passing a

   non-existent folder path.\n

   5.EikFileUtils::CheckWhetherFullNameRefersToFolder() : 

   CheckWhetherFullNameRefersToFolder() API is tested to verify whether the

   fullname passed refers to a folder. This is done by passing a fullname 

   with filename and by passing fullname without a filename.\n

   6.EikFileUtils::CopyFile() : CopyFile() API is tested to verify copying of

   an existing & non-existent file.\n

   7.EikFileUtils::RenameFile() : RenameFile() API is tested to verify renaming

   of a file.\n

   8.EikFileUtils::DeleteFile() : DeleteFile() API is tested to verify deletion

   of a valid and invalid file.\n

   @SYMTestExpectedResults The test validates results against expected values.

 */

void CTFileUtilsAppUi::TestFileOperations()

	{

	_LIT(KSourceFileName, "z:\\uiktest\\uiktest_t_fileutils.script");

	_LIT(KSourceFileNameNotExist, "z:\\system\\test\\uiktest\\notexist.txt");

	_LIT(KDestDir, "c:\\uiktest\\");

	RFs	fs;

	TInt theRes = fs.Connect();

	TEST(theRes == KErrNone);

	if(theRes != KErrNone)

		{

		return;

		}

	fs.RmDir(KDestDir);

	INFO_PRINTF2(_L("Tests whether \"%S\" is a folder"), &KDestDir);

	TBool theBoolRetVal = EFalse;

	theRes = EikFileUtils::IsFolder(KDestDir, theBoolRetVal);

	TEST(theRes == KErrNotFound && (!theBoolRetVal));

	fs.MkDirAll(KDestDir);

	theRes = EikFileUtils::IsFolder(KDestDir, theBoolRetVal);

	//

	TEST(theRes == KErrNone);

	TEST(theBoolRetVal);

	//should be fail as consists filename

	INFO_PRINTF2(_L("Test whether path \"%S\" exist"), &KSourceFileName);

	theBoolRetVal = EikFileUtils::PathExists(KSourceFileName);

	TEST(!theBoolRetVal);

	theRes = EikFileUtils::IsFolder(KSourceFileName, theBoolRetVal);

	TEST(theRes == KErrNone);

	TEST(!theBoolRetVal);

	//Tests whether a specified folder exists.

	INFO_PRINTF2(_L("Tests whether a specified folder \"%S\" exist"), &KDestDir);

	theBoolRetVal = EikFileUtils::FolderExists(KDestDir);

	TEST(theBoolRetVal);

	//exercising CheckFolder

	//non-existant path

	theRes = EikFileUtils::CheckFolder(_L("c:\\kkkk\\"));

	TEST(theRes);

	theRes = EikFileUtils::CheckFolder(KDestDir);

	TEST(theRes == KErrNone);

	INFO_PRINTF2(_L("Passing full path, including filename \"%S\" and check whether full name refers to folder"), &KSourceFileName);

	theRes = EikFileUtils::CheckWhetherFullNameRefersToFolder(KSourceFileName, theBoolRetVal);

	TEST(theRes == (TInt)KErrNone);

	TEST(!theBoolRetVal);

	INFO_PRINTF2(_L("Passing full path, excluding filename \"%S\" and check whether full name refers to folder"), &KDestDir);

	theRes = EikFileUtils::CheckWhetherFullNameRefersToFolder(KDestDir, theBoolRetVal);

	TEST(theRes == (TInt)KErrNone);

	TEST(theBoolRetVal);

	_LIT(KDestFileName, "fileutils.txt");

	_LIT(KDestNewFileName, "fileutilsnew.txt");

	TFileName	destFileName(KDestDir);

	destFileName += KDestFileName;

	TFileName	destFileNameNew(KDestDir);

	destFileNameNew += KDestNewFileName; 

	// When trying to copy an Non-Existant File , the expected Return code is KErrNotFound

	INFO_PRINTF1(_L("Try to copy non-existent file"));

	theRes = EikFileUtils::CopyFile(KSourceFileNameNotExist, KDestFileName, CFileMan::EOverWrite);

	TEST(theRes == KErrNotFound);

	INFO_PRINTF3(_L("Try to copy a file from %S to %S "), &KSourceFileName, &destFileName);

	theRes = EikFileUtils::CopyFile(KSourceFileName, destFileName, CFileMan::EOverWrite);

	TEST(theRes == KErrNone);	

	// When the Source and Destination Filenames are the same

	INFO_PRINTF2(_L("Try to copy with src and dest filenames being same (\"%S\") with aSwitch = EOverWrite"), &destFileName);

	theRes = EikFileUtils::CopyFile(destFileName, destFileName, CFileMan::EOverWrite);

	TEST(theRes == KErrNone);

	INFO_PRINTF3(_L("Expected Return Code is KErrNone %d obtained return code is %d"),KErrNone,theRes);

	INFO_PRINTF2(_L("Try to copy with src and dest filenames being same (\"%S\") with aSwitch = 0"), &destFileName);

	theRes = EikFileUtils::CopyFile(destFileName, destFileName, 0);

	TEST(theRes == KErrAlreadyExists);

	INFO_PRINTF3(_L("Expected Return Code is KErrAlreadyExists %d obtained return code is %d"),KErrAlreadyExists,theRes);

	INFO_PRINTF3(_L("Rename the file from %S to %S"), &destFileName, &destFileNameNew);

	theRes = EikFileUtils::RenameFile(destFileName, destFileNameNew, CFileMan::EOverWrite);

	TEST(theRes == KErrNone);	

	// Copy usually keeps the same attributes on target, so we need to fix them

	fs.SetAtt(destFileNameNew,0,KEntryAttReadOnly);	

	INFO_PRINTF2(_L("Delete the file : \"%S\""), &destFileNameNew);

	theRes = EikFileUtils::DeleteFile(destFileNameNew);

	TEST(theRes == KErrNone);	

	if(theRes != KErrNone)

		{

		INFO_PRINTF2(_L("Error during deleting the file %d"), theRes);

		}

	//try to delete twice

	INFO_PRINTF1(_L("Delete the file twice"));

	theRes = EikFileUtils::DeleteFile(destFileNameNew);

	TEST(theRes == KErrNotFound);	

	INFO_PRINTF2(_L("Tests whether a specified folder %S exists"), &KDestDir);

	theBoolRetVal = EikFileUtils::FolderExists(KDestDir);

	TEST(theBoolRetVal);

	fs.RmDir(KDestDir);

	//test has to return false as we have deleted the directory

	theBoolRetVal = EikFileUtils::FolderExists(KDestDir);

	TEST(!theBoolRetVal);

	fs.Close();

	}

/**

   @SYMTestCaseID UIF-fileutils-TestAbbreviateFileName

   @SYMPREQ

   @SYMTestCaseDesc Tests EikFileUtils::AbbreviatePath() 

   & EikFileUtils::AbbreviateFileName() APIs.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The tests performs the following:\n

   1.EikFileUtils::AbbreviateFileName() : AbbreviateFileName() API is tested to

   display the filename when the space to display the entire filename is

   sufficient and in-sufficient.

   2.EikFileUtils::AbbreviatePath() : AbbreviatePath() API is tested to display

   path when the space to display the entire path is sufficient and

   in-sufficient.

   @SYMTestExpectedResults The test validates results against expected values.

 */

void CTFileUtilsAppUi::TestAbbreviateFileName()

	{

	//exercising AbbreviateFileName function

	TBuf<256>	buf;

	TBuf<1>	buf1;

	TFileName fileName(KOriginalFileName);

	TFileName fileName1(KOriginalFileName);

	EikFileUtils::AbbreviateFileName(fileName, buf);

	TEST(buf == KOriginalFileName);

	const TInt theLenghtBuffer = 8;

	TBuf<theLenghtBuffer> bufLen8;

	EikFileUtils::AbbreviateFileName(fileName, bufLen8);

	TChar ellipsis(0x2026);

	buf = KOriginalFileName.Right(theLenghtBuffer);

	buf[0] = (TUint16)ellipsis;

	TEST(buf == bufLen8);

	//exercising AbbreviatePath function

	buf1.Zero();

	buf1.Append(ellipsis);

	const CFont* theFont = CEikonEnv::Static()->LegendFont();

	fileName = KOriginalFileName;

	TInt theMaxWidthInPixels = 0;

	INFO_PRINTF1(_L("exercising AbbreviatePath function"));

	buf = EikFileUtils::AbbreviatePath(fileName, *theFont, theMaxWidthInPixels);

	TEST(buf == buf1);

	//--------

	buf.Zero();

	buf.Append(ellipsis);

	fileName = KOriginalFileName.Right(KOriginalFileName.Length() / 2);

	fileName.Insert(0, buf);

	theMaxWidthInPixels = theFont->TextWidthInPixels(fileName);	

	fileName1 = KOriginalFileName;

	buf = EikFileUtils::AbbreviatePath(fileName1, *theFont, theMaxWidthInPixels);

	TEST(buf == fileName);

	//--------

	buf = EikFileUtils::AbbreviatePath(fileName1, *theFont, theMaxWidthInPixels + 1);

	TEST(buf == fileName);	

	}

/**

   @SYMTestCaseID UIF-fileutils-TestFileOperations2

   @SYMPREQ

   @SYMTestCaseDesc Tests drive information APIs and Parse() API.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The method tests the following APIs:

   1.EikFileUtils::RootFolderPath() : RootFolderPath() API is tested to verify

   whether the root folder for the specified drive is returned.\n

   2.EikFileUtils::Parse() : Parse() API is tested to verify whether a specifed

   filename can be parsed. The test is carried out for valid & invalid file

   paths.\n

   3.EikFileUtils::DiskIsReadOnly() : DiskIsReadOnly() API is tested to verify

   whether the specified disk is read only. This is done by specifying the drive

   root folder, drive letter & invalid drives.

   4.EikFileUtils::MostSignificantPartOfFullName() : MostSignificantPartOfFullName()

   API is tested to verify whether it retreives the most significant part of

   specified drive, path and file name.

   5.EikFileUtils::DriveAndPathFromFullName() : DriveAndPathFromFullName()

   API is tested to verify whether it parses the specified full path to obtain 

   the drive and path.

   @SYMTestExpectedResults The test validates results against expected values.

 */

void CTFileUtilsAppUi::TestFileOperations2()

	{

	TBool theBoolRetVal;

	TBuf<1> buf1 = _L("d");

	_LIT(KRootFolderPath, "d:\\");

	TBuf<256> buf;

	buf = EikFileUtils::RootFolderPath(buf1);

	TEST(buf == KRootFolderPath);

	//exercising parse function

	buf.Copy(KOriginalFileName);

	INFO_PRINTF1(_L("Tests whether a specified file name can be parsed"));

	TInt theRes = EikFileUtils::Parse(buf);

	TEST(theRes == KErrNone);

	buf.Delete(0, 1);

	theRes = EikFileUtils::Parse(buf);

	TEST(theRes == KErrBadName);

	//exercising 	function TInt DiskIsReadOnly(const TDesC& aFullName, TBool& aIsReadOnly);

	buf = _L("c:\\");

	INFO_PRINTF2(_L("Tests whether the specified drive %S is read-only"), &buf);

	theRes = EikFileUtils::DiskIsReadOnly(buf, theBoolRetVal);

	INFO_PRINTF1(_L("Tests whether the specified drive is read-only"));

	TEST(theRes == KErrNone && (!theBoolRetVal));

	buf = _L("z:");

	theRes = EikFileUtils::DiskIsReadOnly(buf, theBoolRetVal);

	TEST(theRes == KErrNone && theBoolRetVal);

	buf = _L("c~\\");

	theRes = EikFileUtils::DiskIsReadOnly(buf, theBoolRetVal);

	TEST(theRes == KErrBadName && theBoolRetVal);

	buf = _L("c");

	theRes = EikFileUtils::DiskIsReadOnly(buf, theBoolRetVal);

	TEST(theRes == KErrBadName);

	//exercising 	function MostSignificantPartOfFullName

	TFileName fileName(KOriginalFileName);

	INFO_PRINTF1(_L("Gets the folder/file name"));

	theRes = EikFileUtils::MostSignificantPartOfFullName(fileName, buf);

	TEST(theRes == KErrNone);

	TEST(buf.Compare(_L("azxcvmbcdef")) == 0);

	theRes = fileName.LocateReverseF('\\'); 

	fileName = fileName.Mid(theRes + 1);

	TEST(fileName == buf);

	//exercising 	function DriveAndPathFromFullName

	fileName = KOriginalFileName;

	INFO_PRINTF1(_L("Parses the specified full path and file name to obtain the drive and path"));

	fileName = EikFileUtils::DriveAndPathFromFullName(fileName);

	buf = KOriginalFileName;

	theRes = buf.LocateReverseF('\\'); 

	buf = buf.Left(theRes + 1);

	TEST(buf == fileName);

	}

/**

   @SYMTestCaseID UIF-fileutils-TestFileOperations4

   @SYMPREQ

   @SYMTestCaseDesc Tests EikFileUtils::FolderNameFromFullName() API.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The method tests FolderNameFromFullName() API to verify whether

   it retreives folder name from a path and file name. The test is carried out