// 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>

 #include <escapeutils.h>

 // User Include

 #include "TestGenerateFileUriStep.h"

 /**

 Constructor. Sets the test step name

 */

 CTestGenerateFileUriStep::CTestGenerateFileUriStep()

 	{

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

 	SetTestStepName(KTestGenerateFileUriStep);

 	}

 /**

 Does the main functionality of a test step.

 Here, reads values from INI file and calls DoTestL

 @internalTechnology 

 @see 		GenerateFileUriAndCompareL

 @param		None

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

 */

 TVerdict CTestGenerateFileUriStep::doTestStepL()

 	{

 	__UHEAP_MARK;

 	INFO_PRINTF1(_L("\n"));

 	// Get necessary information from INI file

 	TPtrC fileName;

 	TPtrC expectedFileUri;

 	TPtrC fileType;

 	TInt characterSet;

 	TPtrC drive;

 	if(!GetStringFromConfig(ConfigSection(), 	KIniFileName, 			fileName		) ||

 	   !GetStringFromConfig(ConfigSection(), 	KIniExpectedFileUri,	expectedFileUri	) ||

 	   !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"

 					  ),&KIniFileName, &KIniExpectedFileUri, &KIniFileType, &KIniCharacterSet, &KIniDrive

 				   );

 		SetTestStepResult(EFail);

 		}

 	else

 		{// No problem in reading values from INI file. Proceed.

 		TRAPD(err, DoTestL(fileName, expectedFileUri, fileType, drive, characterSet));

 		if(err != KErrNone)

 			{

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

 			SetTestStepResult(EFail);

 			}

 		}

 	__UHEAP_MARKEND;

 	INFO_PRINTF1(_L("\n"));	

 	return TestStepResult();

 	}	// doTestStepL()

 /**

 Checks whether the drive is a removable drive. Populates the <drive> placeholder. 

 And calls ExtractFileNameAndCompareL.

 */

 void CTestGenerateFileUriStep::DoTestL(const TPtrC& aFileName, const TPtrC& aExpectedFileUri, const TPtrC& aFileType, const TPtrC& aDrive, const TInt& aCharacterSet)

 	{

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

 	INFO_PRINTF2(_L("File name = %S"), &aFileName);

 	// Eliminate any characters like colon, slash etc.

 	TPtrC drive(aDrive.Left(1));

 	TUint flags = KErrNone;

 	TDriveNumber driveNum;

 	CTestFileUriServer::GetDriveNumber(drive, driveNum);

 	TBool aResult;

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

 			flags = EExtMedia;

 			drive.Set(KExtMedia());

 			}

 		HBufC16* expectedUriWithDrive = NULL;

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

 		TRAPD(err, expectedUriWithDrive = CTestFileUriServer::CheckAndFillDriveNameL(aExpectedFileUri, drive));

 		if(err != KErrNone)

 			{

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

 			SetTestStepResult(EFail);

 			}

 		else

 			{// All preliminary operations OK so far, go ahead and perform the test.

 			CleanupStack::PushL(expectedUriWithDrive);

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

 			if(aCharacterSet == KCharSet8)

 				{

 				CUri16* cUri8 = NULL;

 				GenerateFileUriAndCompareL(cUri8, aFileName, expectedUriWithDrive, flags, driveNum, aFileType);	

 				}

 			else if(aCharacterSet == KCharSet16)

 				{

 				CUri16* cUri16 = NULL;

 				GenerateFileUriAndCompareL(cUri16, aFileName, expectedUriWithDrive, flags, driveNum, aFileType);	

 				}

 			else

 				{

 				ERR_PRINTF1(_L("Invalid CharacterSet"));

 				SetTestStepResult(EFail);

 				}

 			CleanupStack::PopAndDestroy(expectedUriWithDrive);

 			}

 		}

 	}	// DoTestL

 /**	

 Template function that calls the 8 or 16-bit version of 

 CreatePrivateFileUriL() or CreateFileUriL(), verifies the expected and 

 actual results and sets the test step result accordingly.

 */

 template <class CUriType>

 void CTestGenerateFileUriStep::GenerateFileUriAndCompareL(CUriType*& cUri8Or16, const TPtrC& aFileName, HBufC16*& aExpectedFileUri8Or16, const TUint& aFlags, const TInt& aDriveNum, const TPtrC& aFileType)

 	{

 	TInt err = KErrNone;

 	// Get the URI object

 	if(aFileType == KFileTypePrivate)

 		{// Call private version

 		TRAP(err, cUri8Or16 = CUriType::CreatePrivateFileUriL(aFileName, static_cast<TDriveNumber>(aDriveNum), aFlags));

 		// Test it in case of NON-secure version too, but in that case

 		// the expected result is a Leave with KErrNotSupported.

 		} 

 	else

 		{// Call non-private version

 		TRAP(err, cUri8Or16 = CUriType::CreateFileUriL(aFileName, aFlags));	

 		}

 	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 URI has been returned. Do the checking

 		CleanupStack::PushL(cUri8Or16);

 		// Construct a fully lowercase 16-bit version of the returned URI, so that we

 		// can do print, compare etc.

 		HBufC16* lowerCaseUri16 = HBufC16::NewL(cUri8Or16->Uri().UriDes().Length());

 		lowerCaseUri16->Des().Copy(cUri8Or16->Uri().UriDes());

 		CleanupStack::PopAndDestroy(cUri8Or16);

 		INFO_PRINTF2(_L("The returned URI = %S"), lowerCaseUri16);

 		lowerCaseUri16->Des().LowerCase();

 		// Make expected URI too, fully lowercase

 		aExpectedFileUri8Or16->Des().LowerCase();

 		// Compare and set the verdict

 		if (lowerCaseUri16->Des() != aExpectedFileUri8Or16->Des())

 			{

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

 			SetTestStepResult(EFail); 

 			}

 		else

 			{

 			INFO_PRINTF1(_L("The returned and expected URIs matched. Result = CORRECT")); 	

 			}

 		delete lowerCaseUri16;

 		}

 	}		// GenerateFileUriAndCompareL()