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