// Copyright (c) 2004-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:

 //

 /**

  @file

  @internalTechnology 

 */

 // Epoc Includes

 // For File URI handler API

 #include <uri16.h>

 #include <uri8.h>

 // User Include

 #include "TestGetFileNameFromUriStep.h"

 /**

 Constructor. Sets the test step name

 */

 CTestGetFileNameFromUriStep::CTestGetFileNameFromUriStep()

 	{

 	//Call base class method to set human readable name for test step

 	SetTestStepName(KTestGetFileNameFromUriStep);

 	}

 /**

 Does the main functionality of a test step.

 Here, reads values from INI file and calls DoTestL

 @internalTechnology 

 @see		ExtractFileNameAndCompareL

 @param		None

 @return		EPass or EFail indicating the success or failure of the test step

 */

 TVerdict CTestGetFileNameFromUriStep::doTestStepL()

 	{

 	__UHEAP_MARK;

 	INFO_PRINTF1(_L("\n"));

 	// Get necessary information from INI file

 	TPtrC 	fileUri;

 	TPtrC 	expectedFileName;

 	TPtrC 	fileType;

 	TPtrC 	drive;

 	TInt 	characterSet;

 	if(!GetStringFromConfig(ConfigSection(),	KIniFileUri, 			fileUri			) ||

 	   !GetStringFromConfig(ConfigSection(), 	KIniExpectedFileName, 	expectedFileName) ||

 	   !GetStringFromConfig(ConfigSection(), 	KIniFileType, 			fileType		) ||

 	   !GetIntFromConfig   (ConfigSection(), 	KIniCharacterSet, 		characterSet	) ||

 	   !GetStringFromConfig(ConfigSection(), 	KIniDrive, 				drive			)

 	  )

 		{

 		ERR_PRINTF6(_L("Problem in reading values from ini.			\

 						\nExpected fields are: \n%S\n%S\n%S\n%S\n%S\n"

 					  ),&KIniFileUri, &KIniExpectedFileName, &KIniFileType, &KIniCharacterSet, &KIniDrive

 				   );

 		SetTestStepResult(EFail);

 		}

 	else

 		{

 		TRAPD(err, DoTestL(fileUri, expectedFileName, fileType, drive, characterSet));

 		if(err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Leave occured in CTestGetFileNameFromUriStep::DoTestL: %D"), err);

 			SetTestStepResult(EFail);

 			}

 		}

 	INFO_PRINTF1(_L("\n"));	

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}	// doTestStepL()

 /**

 Constructs fully-qualified filename in case of a private file, checks whether the 

 drive is a removable drive. Populates the <drive> placeholder and calls 

 ExtractFileNameAndCompareL.

 */

 void CTestGetFileNameFromUriStep::DoTestL(const TPtrC& aFileUri, const TPtrC& aExpectedFileName, const TPtrC& aFileType, TPtrC& aDrive, const TInt& aCharacterSet)

 	{

 	TInt err = KErrNone;

 	TFileName fullyQualifiedName(aExpectedFileName);

 	TBool fileNotFound = EFalse;

 	if(aFileType == KFileTypePrivate)

 		{// The file is a private file

 		// In the case of a secure vesrion of the OS

 		// As the INI file contains relative file-name for private files

 		// under the ExpectedFileName field, construct the fully-qualified

 		// expected file-name

 		if((err = CTestFileUriServer::CreateFullyQualifiedName(aExpectedFileName, aDrive, fullyQualifiedName)) != KErrNone)

 			{

 			ERR_PRINTF2(_L("Error returned by CTestFileUriServer::CreateFullyQualifiedName: %D"), err);

 			SetTestStepResult(EFail);

 			return;

 			}

 		}

 	// Check whether drive is removable drive

 	TDriveNumber driveNum;

 	CTestFileUriServer::GetDriveNumber(aDrive, driveNum);

 	TBool aResult;

 	err = CTestFileUriServer::IsRemovableDrive(driveNum, aResult);

 	if(err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Error occured while checking whether drive is removable: %D"), err);

 		SetTestStepResult(EFail);

 		}

 	else

 		{

 		if(aResult)

 			{// The drive is a removable drive

 			INFO_PRINTF1(_L("The drive is a removable drive"));

 			// Check if any other drive contains a file of the same path and name

 			// but comes ahead in the alphabetical order. If yes, that is the correct

 			// expected file name

 			TBuf<1> correctDrive;

 			err = CTestFileUriServer::FirstRemovableDriveWithSameFileName(fullyQualifiedName, correctDrive);

 			if(err != KErrNone)

 				{

 				ERR_PRINTF2(_L("Error occured in FirstRemovableDriveWithSameFileName: %D"), err);

 				SetTestStepResult(EFail);

 				}

 			else if(correctDrive == KNullDesC)

 				{

 				INFO_PRINTF1(_L("File not found on removable drive"));

 				fileNotFound = ETrue;

 				}

 			else

 				{

 				correctDrive.LowerCase();

 				TBuf<1> drive = aDrive;

 				drive.LowerCase();

 				if(correctDrive != drive)

 					{

 					fullyQualifiedName.Replace(0, 1, correctDrive);

 					INFO_PRINTF1(_L("One more removable drive found with the same file name, but is ahead in alphabetical order"));

 					INFO_PRINTF2(_L("Hence the correct expected file name is %S"), fullyQualifiedName);

 					}	

 				}

 			aDrive.Set(KExtMedia());

 			}

 		HBufC16* uriWithDrive = NULL;

 		// Fill the <drive> place holder if it exists

 		TRAPD(err, uriWithDrive = CTestFileUriServer::CheckAndFillDriveNameL(aFileUri, aDrive));

 		if(err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Error occured while filling the drive-placeholder: %D"), err);

 			SetTestStepResult(EFail);

 			}

 		else

 			{

 			CleanupStack::PushL(uriWithDrive);

 			INFO_PRINTF2(_L("Character Set = %D"), aCharacterSet);

 			INFO_PRINTF2(_L("File URI = %S"), uriWithDrive);

 			INFO_PRINTF2(_L("Expected Filename = %S"), &fullyQualifiedName);

 			fullyQualifiedName.LowerCase();	

 			// Call template function based on the characterset.

 			if(aCharacterSet == KCharSet8)

 				{

 				TUriParser16 uriParser8;

 				HBufC16* hBufC8 = NULL;

 				ExtractFileNameAndCompareL(uriParser8, hBufC8, uriWithDrive->Des(), fullyQualifiedName, aFileType, fileNotFound);

 				}

 			else if(aCharacterSet == KCharSet16)

 				{

 				TUriParser16 uriParser16;

 				HBufC16* hBufC16 = NULL;

 				ExtractFileNameAndCompareL(uriParser16, hBufC16, uriWithDrive->Des(), fullyQualifiedName, aFileType, fileNotFound);

 				}

 			else

 				{

 				ERR_PRINTF1(_L("Invalid CharacterSet"));

 				SetTestStepResult(EFail);

 				}

 			CleanupStack::PopAndDestroy(uriWithDrive);	

 			}

 		}

 	}	// DoTestL

 /**

 Template function that calls TUriC::GetFileNameL() after processing 

 an 8-bit or 16-bit version of a URI, verifies the expected and 

 actual results and sets the test step result accordingly.

 */

 template <class TUriParserType, class HBufCType>

 void CTestGetFileNameFromUriStep::ExtractFileNameAndCompareL(TUriParserType& uriParser8Or16, HBufCType*& fileUri8Or16, const TPtrC& aFileUri, const TFileName& aFullyQualifiedName, const TPtrC& aFileType, const TBool& aFileNotFound)

 	{

 	fileUri8Or16 = HBufCType::NewLC(aFileUri.Length());

 	fileUri8Or16->Des().Copy(aFileUri);

 	uriParser8Or16.Parse(*fileUri8Or16);

 	// The actual API being tested

 	HBufC16* fileName16 = NULL;

 	TRAPD(err, fileName16 = uriParser8Or16.GetFileNameL());

 	CleanupStack::PopAndDestroy(fileUri8Or16);

 	if(aFileType == KFileTypePrivate)

 		{

 		}

 	if(aFileNotFound)

 		{// aFileNotFound is true when the file is not found on removable drive

 		if(err == KErrNotFound || err == KErrPathNotFound)

 			{

 			INFO_PRINTF2(_L("Leave occured = %D. This is expected if file is not found on removable drive"), err);

 			}

 		else

 			{

 			ERR_PRINTF2(_L("Unexpected result = %D when file is not found on removable drive"), err);	

 			SetTestStepResult(EFail);

 			if(fileName16 != NULL)

 				{

 				INFO_PRINTF2(_L("File name returned = %S"), fileName16);

 				delete fileName16;

 				}

 			}

 		}

 	else if(err != KErrNone)	

 		{// If it comes here, it means there's some problem. But some tests

 		 // expect an error. So just set the error, and leave the decision 

 		 // to TEF

 		ERR_PRINTF2(_L("Leave occured: %D"), err);	

 		SetTestStepError(err);

 		}

 	else

 		{// Things seem to be OK and a file-name has been returned. 

 		 // Do the checking

 		INFO_PRINTF2(_L("Returned Filename = %S"), fileName16);

 		fileName16->Des().LowerCase();

 		// Compare and set the verdict

 		if((fileName16->Des() != aFullyQualifiedName))

 			{

 			INFO_PRINTF1(_L("The returned filename did not match the expected filename. Result = INCORRECT"));

 			SetTestStepResult(EFail); 

 			}

 		else

 			{

 			INFO_PRINTF1(_L("The returned filename is the same as the expected filename. Result = CORRECT"));

 			}

 		delete fileName16;

 		}

 	}	// ExtractFileNameAndCompareL()