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

 // TESTGENERATEFILEURIFORALLFILESSTEP.CPP

 // 

 //

 /**

  @file

  @internalTechnology 

 */

 // Epoc Includes

 // For File URI handler API

 #include <uri16.h>

 #include <uri8.h>

 #include <escapeutils.h>

 // User Include

 #include "TestForAllFilesStep.h"

 /**

 Constructor. Sets the test step name

 */

 CTestForAllFilesStep::CTestForAllFilesStep()

 	{

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

 	SetTestStepName(KTestForAllFilesStep);

 	}

 /**

 Does the main functionality of a test step. Here just calls DoTestL.

 @internalTechnology 

 @param		None

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

 */

 TVerdict CTestForAllFilesStep::doTestStepL()

 	{

 	__UHEAP_MARK;

 	INFO_PRINTF1(_L("\n"));

 	TRAPD(err, DoTestL());

 	if(err != KErrNone)

 		{

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

 		SetTestStepResult(EFail);

 		}

 	INFO_PRINTF1(_L("\n"));	

 	__UHEAP_MARKEND;

 	return TestStepResult();	

 	}		// doTestStepL()

 /**

 Scans all the directories and calls TestBothWaysL that tests the

 creation of URI from a filename and vice versa for all the files.

 */

 void CTestForAllFilesStep::DoTestL()

 	{

 	RFs fs;

 	TInt err = fs.Connect();

 	if(err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Error occured while connecting to file server: %D"), err);

 		SetTestStepResult(EFail);

 		}

 	else

 		{

 		TBuf<4> rootDir;

 		CDirScan *dirScan = CDirScan::NewLC(fs);

 		TInt drive;

 		for(drive = EDriveA; drive <= EDriveZ; ++drive)

 			{

 			rootDir.Format(_L("%c:\\"), static_cast<char>(KLetterA + drive));

 			dirScan->SetScanDataL(rootDir, KEntryAttNormal, ESortNone);

 			CDir* entryList = NULL;

 			FOREVER

 				{

 				TRAPD(err, dirScan->NextL(entryList));

 				if(err == KErrNotReady)

 					{

 					INFO_PRINTF2(_L("Drive %S not ready"), &rootDir);

 					break;

 					}

 				if (entryList==NULL)

 					{

 					break;

 					}

 				CleanupStack::PushL(entryList);

 				TFileName filename;

 				TInt index;

 				for(index = 0; index < entryList->Count(); ++index)

 					{

 					const TEntry& entry = (*entryList)[index];

 					filename = dirScan->FullPath();

 					filename.Append(entry.iName);

 					INFO_PRINTF1(_L("\n"));

 					INFO_PRINTF2(_L("The next file name in the dir-scan = %S"), &filename);

 					INFO_PRINTF1(_L("Calling 8-bit versions"));

 					// To keep VC compiler happy as it does not support

 					// explicit template calls.Hence passing empty variables 

 					// cUri8 and tUriParser8

 					CUri8* cUri8 = NULL;

 					TUriParser8 tUriParser8;

 					TestBothWaysL(cUri8, tUriParser8, filename);

 					INFO_PRINTF1(_L("\n"));

 					INFO_PRINTF1(_L("Calling 16-bit versions"));

 					CUri16* cUri16 = NULL;

 					TUriParser16 tUriParser16;

 					TestBothWaysL(cUri16, tUriParser16, filename);

 					}

 				CleanupStack::PopAndDestroy(entryList);	

 				}	// FOREVER

 			}

 		fs.Close();

 		CleanupStack::PopAndDestroy(dirScan);	

 		}

 	}	// DoTestL

 /**

 Template function that calls CUri::CreateFileUriL to generate a URI and 

 calls TUriC::GetFileNameL() with this URI, to verify that the filename so got

 is the same as the original one.

 */

 template <class CUriType, class TUriParserType>

 void CTestForAllFilesStep::TestBothWaysL(CUriType*& cUri8Or16, TUriParserType& tUriParser8Or16, TFileName& aFileName)

 	{

 	TUint flags = KErrNone;

 	TDriveNumber driveNum;

 	TParse parser;

 	parser.Set(aFileName, 0, 0);

 	TBuf<1> drive = parser.Drive().Left(1);

 	drive.LowerCase();

 	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;

 			}

 		// Generate the URI	

 		TRAPD(err, cUri8Or16 = CUriType::CreateFileUriL(aFileName, flags));

 		if(err != KErrNone)

 			{

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

 			SetTestStepResult(EFail);

 			}

 		else

 			{

 			CleanupStack::PushL(cUri8Or16);

 			// Just in case, create a 16-bit heap desc and print.

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

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

 			INFO_PRINTF2(_L("File URI returned by CreateFileUriL = %S"), tempBuf);

 			delete tempBuf;

 			if(aResult)

 				{

 				TBuf<1> correctDrive;

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

 				if(err != KErrNone)

 					{

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

 					SetTestStepResult(EFail);

 					}

 				else

 					{

 					correctDrive.LowerCase();

 					if(correctDrive != drive)

 						{

 						aFileName.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"), aFileName);

 						}	

 					}

 				}

 			// Convert the URI to filename back again

 			HBufC16* returnedFileName = NULL;

 			tUriParser8Or16.Parse(cUri8Or16->Uri().UriDes());

 			TRAPD(err, returnedFileName = tUriParser8Or16.GetFileNameL());

 			CleanupStack::PopAndDestroy(cUri8Or16);

 			if(err != KErrNone)

 				{

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

 				SetTestStepResult(EFail);

 				}

 			else

 				{

 				INFO_PRINTF2(_L("The filename returned by GetFileNameL = %S"), returnedFileName);

 				// Verify the result

 				aFileName.LowerCase();

 				returnedFileName->Des().LowerCase();

 				if(returnedFileName->Compare(aFileName) != KErrNone)

 					{

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

 					SetTestStepResult(EFail);

 					}

 				else

 					{

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

 					}	

 				delete returnedFileName;

 				}	

 			}

 		}

 	}	// TestBothWaysL