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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // f32test\demandpaging\t_reaper.cpp

 //

 // Suite of tests for the Reaper, the reaper is used to clean up files

 // which were deleted whilst in use, the delete is delayed until the 

 // files are no longer in use and then completed by the reaper.

 //

 // 001 Loader Reaper/Clamp Tests

 // 002 Try deleteing file while Open

 // 003 Try deleteing file while Clamped and Open

 // 004 Try deleteing while Clamped

 // 005 Check moved in sys/del

 // 006 Check Can't delete

 // 007 Unclamp and Delete

 // 008 Copy DLL to drive and delete

 // 009 Copy DLL, Load, close and RFs::delete

 // 010 Copy DLL, Load, close and Loader::delete

 // 011 Copy DLL to drive, load and delete

 // 012 Check file deleted on close

 // 013 Try deleting something of the same name twice while loaded.

 // 

 //! @SYMTestCaseID			KBASE-T_REAPER-0330

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1110

 //! @SYMTestCaseDesc		Demand Paging Reaper.

 //! @SYMTestActions			001 Loader Reaper/Clamp Tests

 //! @SYMTestExpectedResults All tests should pass.

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <e32svr.h>

 #include <f32file.h>

 #include <e32ldr.h>

 #include <u32hal.h>

 #include "u32std.h"

 TBool Verbose = EFalse;

 RFs TheFs;

 RLoader Loader;

 TInt DriveNumber=-1;

 class TPagingDriveInfo

 	{

 public:

 	TChar iDriveLetter;

 	TDriveInfo iDriveInfo;

 	};

 RArray<TPagingDriveInfo> SupportedDrives;

 TInt gNumSupportedDrives = 0;

 LOCAL_D RTest test(_L("T_reaper"));

 _LIT(KFilePath,":\\sys\\bin\\test.txt");

 _LIT(KSysPath,"z:\\sys\\bin\\");

 _LIT(KPathDel,":\\sys\\del\\");

 _LIT(KDllFile,"t_reaper_test_dll.dll");

 const TInt KLibNameLength = 50;

 void CopyDll(const TDesC& aSourceName, const TDesC& aDestName)

 	{

 	const TInt KBufferSize = 3333;

 	TBuf8<KBufferSize> buffer;

 	RFile in, out;

 	test.Printf(_L("  copying %S to %S\n"), &aSourceName, &aDestName);

 	TInt r = TheFs.MkDirAll(aDestName);

 	test_Assert(r == KErrNone || r == KErrAlreadyExists, test.Printf(_L("MkDirAll returned %d\n"),r));

 	test_KErrNone(in.Open(TheFs, aSourceName, EFileRead));

 	test_KErrNone(out.Replace(TheFs, aDestName, EFileWrite));

 	TInt size;

 	test_KErrNone(in.Size(size));

 	TInt pos = 0;

 	while (pos < size)

 		{

 		test_KErrNone(in.Read(buffer));

 		test_KErrNone(out.Write(buffer));

 		pos += buffer.Length();

 		}

 	in.Close();

 	out.Close();

 	}

 void CopyDllToDrive(const TDesC& aSourceName, TUint8 aDrive, TBuf<KLibNameLength>& aDestName)

 	{

 		TBuf<KLibNameLength> sourceName;

 		sourceName=KSysPath;

 		sourceName.Append(aSourceName);

 		aDestName=KSysPath;

 		aDestName.Append(aSourceName);

 		aDestName[0] = aDrive;

 		CopyDll(sourceName, aDestName);

 	}

 static void CreateTestFile(const TDesC& aTestFile)

 /**

 	Create an empty file with the supplied name.  This function is used

 	to create file which can be deleted with RLoader::Delete.

 	@param	aFs				Open file server session.

 	@param	aTestFile		The test file's name.

  */

 	{

 	TInt r;

 	TheFs.MkDirAll(aTestFile);

 	RFile f;

 	r = f.Replace(TheFs, aTestFile, EFileWrite | EFileStream | EFileShareExclusive);

 	test_KErrNone(r);

 	TBuf<256> buf(_L("Space is big, I mean its really big.\n"));

 	TPtrC8 pBuf((TUint8*)&buf);

 	f.Write(pBuf);

 	f.Flush();

 	f.Close();

 	}

 // Get the list of pageable drives

 void GetSupportedDrives()

 	{

 	TChar ch;

 	TBuf<256> fileSystemName;

 	TDriveList driveList;

 	TDriveInfo driveInfo;

 	TInt r = TheFs.DriveList(driveList);

     test_KErrNone(r);

 	TBool NandPageableMediaFound = EFalse;

 	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)

 		{

 	    if(!driveList[drvNum])

 	        continue;   //-- skip unexisting drive

 	    test_KErrNone( TheFs.Drive(driveInfo, drvNum) );

 		test_KErrNone( TheFs.DriveToChar(drvNum, ch) );

 		test_KErrNone( TheFs.FileSystemName(fileSystemName, drvNum) );

 		if (Verbose)

 			test.Printf(_L("GetSupportedDrives, Drive %c iType %d iDriveAtt %08x iMediaAtt %08X, fileSystemName %S\n"), 

 				(TInt) ch, driveInfo.iType, driveInfo.iDriveAtt, driveInfo.iMediaAtt, &fileSystemName);

 		if ((driveInfo.iDriveAtt & KDriveAttPageable) && (driveInfo.iType == EMediaNANDFlash))

 			NandPageableMediaFound = ETrue;

 		TBool pageable = EFalse;

 		if (driveInfo.iDriveAtt & KDriveAttPageable)

 			pageable = ETrue;

 		// If we've already found a pageable NAND drive, then assume the Z: drive is pageable too 

 		// if it's got a composite file system (fudge)

 		_LIT(KCompositeName,"Composite");

 		if (fileSystemName == KCompositeName())

 			{

 			if (NandPageableMediaFound)

 				pageable = ETrue;

 			driveInfo.iMediaAtt|=KMediaAttWriteProtected;

 			}

 		if (pageable)

 			{

 			TPagingDriveInfo pagingDriveInfo;

 			pagingDriveInfo.iDriveLetter = ch;

 			pagingDriveInfo.iDriveInfo = driveInfo;

 			test_KErrNone( SupportedDrives.Append(pagingDriveInfo) );

 			if (Verbose)

 				test.Printf(_L("Drive %c supports paging\n"), (TInt) pagingDriveInfo.iDriveLetter);

 			gNumSupportedDrives++;

 			}

 		}

 	}

 TInt FindDeletedFile(TUint8 aDrive, TDes& aFile, const TDesC& aExcludedFile=KNullDesC)

 	{

 	aFile.Zero();

 	_LIT(KSearchPathDel,"?:\\sys\\del\\*");

 	TBuf<13> delPath;

 	delPath = KSearchPathDel;

 	delPath[0] = aDrive;

 	CDir* dir=NULL;

 	CTrapCleanup* c = CTrapCleanup::New();

 	TInt r = TheFs.GetDir(delPath,KEntryAttMatchExclude | KEntryAttDir ,ESortNone,dir);

 	delete c;

 	if(r==KErrPathNotFound)

 		return 0; // no files

 	test_KErrNone(r);

 	test.Printf(_L("Files: %d\n"),dir->Count() );

 	TInt count = dir->Count();

 	TBool found = false;

 	for (TInt i=count-1;i>=0;i--)

 		{

 		TBuf<KLibNameLength> tempPath;

 		tempPath.Append(aDrive);

 		tempPath.Append(KPathDel);

 		tempPath.Append((*dir)[i].iName);

 		test.Printf(_L("%S\n"), &tempPath);

 		if(!found && tempPath.CompareF(aExcludedFile)!=0)

 			{

 			found = true;

 			aFile = tempPath;

 			}

 		}

 	delete dir;

 	return count;

 	}

 void TestDlls(TUint8 aDrive)

 	{

 	TEntry e;

 	TBuf<KLibNameLength> libName;

 	TBuf<KLibNameLength> delName;

 	TBuf<KLibNameLength> delName2;

 	TBuf<KLibNameLength> libName2;

 	RLibrary library;

 	RLibrary library2;

 	test.Next(_L("Copy DLL to drive and delete"));

 	CopyDllToDrive(KDllFile,aDrive,libName);

 	test_Equal(0, FindDeletedFile(aDrive,delName)); // check no files in sys/del

 	test_KErrNone(Loader.Delete(libName));

 	test_Equal(KErrNotFound, TheFs.Entry(libName,e));

 	test_Equal(0, FindDeletedFile(aDrive,delName)); // check no files in sys/del

 	test.Next(_L("Copy DLL, Load, close and RFs::delete"));

 	CopyDllToDrive(KDllFile,aDrive,libName);

 	test_KErrNone( library.Load(libName));

 	test_Equal(KErrInUse, TheFs.Delete(libName));

 	CLOSE_AND_WAIT(library);

 	test_KErrNone( TheFs.Delete(libName));

 	test_Equal(KErrNotFound, TheFs.Entry(libName,e));

 	test.Next(_L("Copy DLL, Load, close and Loader::delete"));

 	CopyDllToDrive(KDllFile,aDrive,libName);

 	test_KErrNone( library.Load(libName));

 	CLOSE_AND_WAIT(library);

 	test_KErrNone( Loader.Delete(libName));

 	test_Equal(KErrNotFound, TheFs.Entry(libName,e));

 	test_Equal(0, FindDeletedFile(aDrive,delName)); // check no files in sys/del

 	test.Next(_L("Copy DLL to drive, load and delete"));

 	CopyDllToDrive(KDllFile,aDrive,libName);

 	test_KErrNone( library.Load(libName));

 	test_Equal(KErrInUse, TheFs.Delete(libName));

 	test_KErrNone( Loader.Delete(libName));

 	test_Equal(KErrNotFound, TheFs.Entry(libName,e));

 	test_Equal(1, FindDeletedFile(aDrive,delName)); // get name of 'deleted' file

 	test_Equal(KErrInUse, TheFs.Delete(delName));

 	test.Next(_L("Check file deleted on close"));

 	CLOSE_AND_WAIT(library);

 	test_Equal(KErrNotFound, TheFs.Entry(delName,e));	

 	test.Next(_L("Try deleting something of the same name twice while loaded."));

 	CopyDllToDrive(KDllFile,aDrive,libName);

 	test_KErrNone( library.Load(libName));

 	test_KErrNone( Loader.Delete(libName));

 	test_Equal(KErrNotFound, TheFs.Entry(libName,e));

 	test_Equal(1, FindDeletedFile(aDrive,delName)); // get name of 'deleted' file

 	test.Printf(_L("Load a Secord Copy\n"));

 	CopyDllToDrive(KDllFile,aDrive,libName);

 	libName2=libName;

 	libName2[27]='2';

 	test_KErrNone( TheFs.Rename(libName,libName2));

 	test_KErrNone( library2.Load(libName2));

 	test_KErrNone( TheFs.Rename(libName2,libName));

 	test.Printf(_L("Try and delete second copy\n"));

 	test_KErrNone( Loader.Delete(libName));

 	test_Equal(2, FindDeletedFile(aDrive,delName2,delName)); // get name of second 'deleted' file

 	test.Printf(_L("Now close and watch deletions\n"));

 	CLOSE_AND_WAIT(library);

 	test_Equal(KErrNotFound, TheFs.Entry(delName,e));

 		test_KErrNone( TheFs.Entry(delName2,e));

 	CLOSE_AND_WAIT(library2);

 	test_Equal(KErrNotFound, TheFs.Entry(delName2,e));

 	}

 void BasicTest(TUint8 aDrive)

 	{

 	TBuf<256> startFileName;	

 	TBuf<256> endFileName;

 	RFile file;

 	RFileClamp fileClamp;

 	startFileName.Append((TChar) aDrive);

 	startFileName+=KFilePath;

 	CreateTestFile(startFileName);

 	test.Next(_L("Try deleteing file while Open"));

 	test_KErrNone( file.Open(TheFs,startFileName,EFileShareExclusive|EFileWrite));

 	test_Equal(KErrInUse, Loader.Delete(startFileName));

 	test.Next(_L("Try deleteing file while Clamped and Open"));

 	test_KErrNone( fileClamp.Clamp(file));

 	test_Equal(KErrInUse, Loader.Delete(startFileName));

 	test.Next(_L("Try deleteing while Clamped"));

 	file.Close(); 

 	test_Equal(0, FindDeletedFile(aDrive,endFileName)); // check no files in sys/del

 	test_KErrNone( Loader.Delete(startFileName));

 	test.Next(_L("Check moved in sys/del"));

 	test_Equal(1, FindDeletedFile(aDrive,endFileName)); // check one file in sys/del

 	test.Next(_L("Check Can't delete"));

 	test_Equal(KErrInUse, TheFs.Delete(endFileName));

 	test.Next(_L("Unclamp and Delete"));

 	test_KErrNone( fileClamp.Close(TheFs));

 	test_KErrNone( TheFs.Delete(endFileName));

 	}

 //

 // ParseCommandLine reads the arguments and sets globals accordingly.

 //

 TInt ParseCommandLine()

 	{

 	TBuf<32> args;

 	User::CommandLine(args);

 	TLex lex(args);

 	TInt err=KErrNone;

 	FOREVER

 		{

 		TPtrC token=lex.NextToken();

 		if(token.Length()!=0)

 			{

 			if ((token.Length()==1) || ((token.Length()==2) && (token[1]==':')))

 				{

 				TChar driveLetter = User::UpperCase(token[0]); 

 				if ((driveLetter>='A') && (driveLetter<='Z'))

 					DriveNumber=driveLetter - (TChar) 'A';

 				else 

 					err=KErrArgument;

 				}

 			else if ((token==_L("help")) || (token==_L("-h")) || (token==_L("-?")))

 				{

 				test.Printf(_L("\nThis tests the loader's reaper, which is used in code paging to postpone deletions of paged code from disk.\n")); 

 				test.Printf(_L("\nIf no drive letter is supplied, then all suitable drives are checked.\n\n"));

 				err=KErrCancel;

 				}

 			else

 				err=KErrArgument;

 			}

 		else

 			break;

 		if (err!=KErrNone)

 			{

 			if (err==KErrArgument)

 				test.Printf(_L("\nUnknown argument '%S'\n"), &token);

 			test.Printf(_L("\nUsage:  t_reaper [-h] [<driveletter>]\n\n"));

 			test.Getch();

 			return err;

 			}

 		}

 	return KErrNone;

 	}

 GLDEF_C TInt E32Main()

 	{

 	TInt i;

 	test.Title();

 	if (ParseCommandLine())

 		return KErrNone;

 	TheFs.Connect();

 	TUint32 memModelAttributes=UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);

 	TUint32 pagingPolicy = E32Loader::PagingPolicy();

 	if((memModelAttributes&EMemModelAttrCodePaging)==0 || pagingPolicy==EKernelConfigCodePagingPolicyNoPaging)

 		{

 		test.Start(_L("TESTS NOT RUN - Code paging not enabled on system."));

 		test.End();

 		return KErrNone;

 		}

 	test.Start(_L("Loader Reaper/Clamp Tests"));

 	// Turn off evil lazy dll unloading

 	RLoader l;

 	test(l.Connect()==KErrNone);

 	test(l.CancelLazyDllUnload()==KErrNone);

 	l.Close();

 	GetSupportedDrives();

 	test_Compare(gNumSupportedDrives,>,0);

 	test_KErrNone( Loader.Connect());

 	test_KErrNone( Loader.CancelLazyDllUnload());

 	for (i=0;i<gNumSupportedDrives;i++)

 		{

 		if ((DriveNumber==-1) || (DriveNumber== (TInt) (SupportedDrives[i].iDriveLetter - (TChar) 'A')))

 			{

 			test.Printf(_L("Testing drive: %c\n"),(TInt) SupportedDrives[i].iDriveLetter);

 			if (!(SupportedDrives[i].iDriveInfo.iMediaAtt&KMediaAttWriteProtected))

 				{

 				TUint8 drive = SupportedDrives[i].iDriveLetter;

 				BasicTest(drive);

 				TestDlls(drive);

 				}

 			}

 		}

 	Loader.Close();

 	TheFs.Close();

 	test.End();

 	return KErrNone;

 	}