// Copyright (c) 1998-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\server\t_hungfs.cpp

 // this test will either run with a secure mmc or will simulate a

 // mmc card.

 // 

 //

 #include <f32file.h>

 #include <e32test.h>

 #include "t_server.h"

 GLDEF_D RTest test(_L("T_HUNGFS"));

 GLREF_D RFs TheFs;

 LOCAL_D RFile SubFile1;

 LOCAL_D TInt HungReturnCodeC;

 LOCAL_D RSemaphore HungSemaphoreC;

 LOCAL_D TInt HungReturnCodeNC;

 LOCAL_D RSemaphore HungSemaphoreNC;

 GLREF_C void Format(TInt aDrive);

 LOCAL_D const TInt KControlIoLockMount=5;

 LOCAL_D const TInt KControlIoClearLockMount=6;

 LOCAL_D const TInt KControlIoCNotifier=7;

 LOCAL_D const TInt KControlIoClearCNotifier=8;

 LOCAL_D const TInt KControlIoCancelNCNotifier=KMaxTInt-1;

 LOCAL_D TBool isSecureMmc;

 LOCAL_D TFileName gLockedPath;

 LOCAL_D TFileName gLockedBase;

 LOCAL_D TInt gLockedDrive;

 GLREF_D TFileName gSessionPath;

 LOCAL_D TInt gSessionDrive;

 TBuf8<16> KPassword8=_L8("abc");

 TBuf16<8> KPassword=_L("abc");

 _LIT(File1,"file1");

 _LIT(File2,"file2");

 _LIT(Dir1,"\\dir1\\");

 _LIT(NotifyDir,"\\not\\");

 _LIT(NotifyDir2,"\\abc\\");

 _LIT(HungDirNC,"\\hungnc\\");

 _LIT(HungDirC,"\\hungc\\");

 LOCAL_D const TInt KHeapSize=0x2000;

 struct SNonCriticalInfo

 	{

 	TBool iSameSession;

 	TBool iUseRFile;

 	};

 LOCAL_C TInt ThreadFunctionNC(TAny* aInfo)

 //

 // Thread entry point to put up non-critical notifier

 //

 	{

 	RFs fs;

 	TInt r;

 	TBuf8<8> mmcBuf;

 	// pad out password if using lockable mmc

 	if(isSecureMmc)

 		{

 		TUint8 pBuf[]={0x61,0x00,0x62,0x00,0x63,00};

 		mmcBuf.SetLength(6);

 		for(TInt i=0;i<6;++i)

 			mmcBuf[i]=pBuf[i];

 		}

 	SNonCriticalInfo* info=NULL;

 	if(aInfo!=NULL)

 		info=(SNonCriticalInfo*)aInfo;

 	r=fs.Connect();

 	if(isSecureMmc)

 		{

 		if(info && info->iSameSession)

 			r=TheFs.LockDrive(gLockedDrive,NULL,mmcBuf,EFalse);

 		else

 			{

 			r=fs.LockDrive(gLockedDrive,NULL,mmcBuf,EFalse);

 			RDebug::Print(_L("l=%d"),r);

 			}

 		}

 	else

 		{

 		if(info && info->iSameSession)

 			r=TheFs.ControlIo(gLockedDrive,KControlIoLockMount,KPassword8);

 		else

 			r=fs.ControlIo(gLockedDrive,KControlIoLockMount,KPassword8);

 		}

 //	UserSvr::ForceRemountMedia(ERemovableMedia0);

 	User::After(300000);

 	HungSemaphoreNC.Signal();

 	TFileName hungDir=gLockedBase;

 	hungDir+=HungDirNC;

 	if(info && info->iSameSession)

 		r=TheFs.RmDir(hungDir);

 	else if(info && info->iSameSession && info->iUseRFile)

 		{

 		TBuf8<16> buf=_L8("abc");

 		r=SubFile1.Write(buf);

 		}

 	else

 		{

 		r=fs.RmDir(hungDir);

 		RDebug::Print(_L("rd=%d"),r);

 		}

 	HungReturnCodeNC=r;

 	if(isSecureMmc)

 		{

 		r=fs.UnlockDrive(gLockedDrive,mmcBuf,EFalse);

 		r=fs.ClearPassword(gLockedDrive,mmcBuf);

 		}

 	else

 		r=fs.ControlIo(gLockedDrive,KControlIoClearLockMount,KPassword8);

 	HungSemaphoreNC.Signal();

 	fs.Close();

 	return(KErrNone);

 	}

 LOCAL_C TInt ThreadFunctionC(TAny* aDrive)

 //

 // Thread entry point to put up a critical notifier

 //

 	{

 	RFs fs;

 	TInt r=fs.Connect();

 	test(r==KErrNone);

 	TInt drive;

 #if defined(__WINS__)

 	drive=EDriveY;

 #else	

 	drive=EDriveC;

 #endif

 	// can only get critcal notifer up using ControIo

 	// assumes fat file system running on one of the drives named below

 	r=fs.ControlIo(drive,KControlIoCNotifier);

 	TBool isRemovable=*(TBool*)aDrive;

 	TFileName hungDir=(_L("?:"));

 #if defined(__WINS__)

 	if(isRemovable)

 		hungDir[0]=(TText)('A'+EDriveX);

 	else

 		hungDir[0]=(TText)('A'+EDriveY);

 #else

 	if(isRemovable)

 		hungDir[0]=(TText)('A'+EDriveD);

 	else

 		hungDir[0]=(TText)('A'+EDriveC);

 #endif

 	hungDir+=HungDirC;

 	r=fs.RmDir(hungDir);

 	r=fs.MkDir(hungDir);

 	HungReturnCodeC=r;

 	r=fs.ControlIo(drive,KControlIoClearCNotifier);

 	HungSemaphoreC.Signal();

 	r=fs.RmDir(hungDir);

 	fs.Close();

 	return(KErrNone);

 	}

 LOCAL_C void PutNonCriticalNotifier(TAny* aInfo,RThread& aThread)

 //

 // put up a non-critical notifier on a removable media

 //

 	{

 	TInt r=aThread.Create(_L("ThreadNC"),ThreadFunctionNC,KDefaultStackSize,KMinHeapSize,KMinHeapSize,aInfo);

 	test(r==KErrNone);	

 	aThread.SetPriority(EPriorityMore);

 	aThread.Resume();

 	HungSemaphoreNC.Wait();

 	User::After(1000000);

 	}

 LOCAL_C void PutCriticalNotifier(TBool aBool,RThread& aThread)

 //

 // put up a critical notifier on the specified drive

 //

 	{

 	TInt r=aThread.Create(_L("ThreadC"),ThreadFunctionC,KDefaultStackSize,KMinHeapSize,KMinHeapSize,&aBool);

 	test(r==KErrNone);

 	aThread.SetPriority(EPriorityMore);

 	aThread.Resume();

 	User::After(1000000);

 	}

 void TestNotifiers()

 //

 // Test non-critical notifier is cancelled when the critical notifier is put up

 // Needs to be carried out on platform with password notifier which handles requests

 // asynchronously and uses CAtaDisk in fat file system on c: drive ie. not internal ram

 // drive

 //

 	{

 	test.Next(_L("TestNotifiers"));

 	if(isSecureMmc)

 		return;

 	RThread threadNC,threadC;

 	PutNonCriticalNotifier(NULL,threadNC);

 	PutCriticalNotifier(EFalse,threadC);

 	// get rid of critical notifier

 	test.Printf(_L("Press cancel on for critcal notifier\n"));

 	test.Printf(_L("Press any character\n"));

 	test.Getch();

 	TRequestStatus deathStat;

 	threadNC.Logon( deathStat );

 	HungSemaphoreC.Wait();

 	// test(HungReturnCodeNC==KErrAbort);

 	TRequestStatus deathStat2;

 	threadC.Logon(deathStat2);

 	HungSemaphoreNC.Wait();

 	//test(HungReturnCodeNC==KErrLocked);

 	User::WaitForRequest(deathStat2);

 	threadNC.Close();

 	threadC.Close();

 	}

 void TestCriticalFunctions() 

 //

 // test that only a subset of functions are supported when the critical notifier is up

 //

 	{

 	test.Next(_L("test functions supported with critical notifier"));

 	// used for EFsSubClose

 	RFile file;

 	TInt r=file.Create(TheFs,File1,EFileShareAny|EFileWrite);

 	test(r==KErrNone||KErrAlreadyExists);

 	if(r==KErrAlreadyExists)

 		{

 		r=file.Open(TheFs,File1,EFileShareAny|EFileWrite);

 		test(r==KErrNone);

 		}

 	TBuf8<16> buf=_L8("abcdefghijklmnop");

 	r=file.Write(buf);

 	test(r==KErrNone);

 	r=TheFs.MkDir(NotifyDir);

 	test(r==KErrNone);

 	RThread thread;

 	PutCriticalNotifier(ETrue,thread);

 	// test functions that are supported with critical notifier

 	// EFsNotifyChange

 	test.Next(_L("test functions that are supported with critical notifier"));

 	TRequestStatus status;

 	TheFs.NotifyChange(ENotifyAll,status);

 	test(status==KRequestPending);

 	// EFsNotifyChangeCancel

 	TheFs.NotifyChangeCancel();

 	test(status==KErrCancel);

 	// EFsNotifyChangeEx

 	TheFs.NotifyChange(ENotifyAll,status,gSessionPath);

 	test(status==KRequestPending);

 	// EFsNotifyChangeCancelEx

 	TheFs.NotifyChangeCancel(status);

 	test(status==KErrCancel);

 	// EFsSubClose

 	// difficult  to test properly because this does not return an error value

 	file.Close();

 	// test that notifications are not completed when a critical notifier completes

 	test.Next(_L("test notifications not completed"));

 	TheFs.NotifyChange(ENotifyDisk,status);

 	test(status==KRequestPending);

 	TRequestStatus status2;

 	TheFs.NotifyChange(ENotifyDir,status2,NotifyDir);

 	test(status2==KRequestPending);

 	// test some functions that are not supported when critcical notifier up

 	// EFsFileOpen

 	test.Next(_L("test functions that are not supported with critical notifier"));

 	r=file.Open(TheFs,File2,EFileShareAny);

 	test(r==KErrInUse);

 	// EFsFileCreate

 	r=file.Create(TheFs,File2,EFileShareAny);

 	test(r==KErrInUse);

 	// EFsMkDir

 	r=TheFs.MkDir(Dir1);

 	test(r==KErrInUse);

 	// EFsVolume

 	TVolumeInfo info;

 	r=TheFs.Volume(info,gSessionDrive);

 	test(r==KErrInUse);

 	// get rid of critical notifier

 	test.Printf(_L("Press escape on the critical notifier\n"));

 	TRequestStatus deathStat;

 	thread.Logon(deathStat);

 	HungSemaphoreC.Wait();

 	test(HungReturnCodeC==KErrAbort);

 	User::WaitForRequest(deathStat);

 	thread.Close();

 	// test notifiers have not gone off

 	test(status==KRequestPending&&status2==KRequestPending);

 	// test that notification setup on  default drive has had the drive changed

 	// to * since the critical notifier was up

 	TFileName notDir=gLockedBase;

 	notDir+=NotifyDir;

 	r=TheFs.MkDir(notDir);

 	test(r==KErrNone);

 	test(status==KRequestPending&&status2==KErrNone);

 	TheFs.NotifyChangeCancel();

 	test(status==KErrCancel);

 	r=TheFs.Delete(File1);

 	test(r==KErrNone);

 	r=TheFs.RmDir(notDir);

 	test(r==KErrNone);

 	r=TheFs.RmDir(NotifyDir);

 	test(r==KErrNone);

 	}

 void TestParsingFunctions()	

 //

 // Test functions that use Parse* and Validate* functions with 

 // non-critical notifier up

 // 

 	{

 	test.Next(_L("TestParsingFunctions"));

 	RThread thread;

 	PutNonCriticalNotifier(NULL,thread);

 	// test on same drive as notifier

 	test.Next(_L("test parsing functions on same drive"));

 	// Using ParseSubst

 	TFileName dir=gLockedBase;

 	dir+=Dir1;

 	TInt r=TheFs.MkDir(dir);

 	test(r==KErrInUse);

 	TFileName file=gLockedPath;

 	file+=File1;

 	RFile f;

 	r=f.Create(TheFs,file,EFileShareAny);

 	test(r==KErrInUse);

 	// Using ParsePathPtr0

 	r=TheFs.SetSubst(gLockedPath,EDriveO);

 	test(r==KErrInUse);

 	// ValidateDrive

 	TVolumeInfo info;

 	r=TheFs.Volume(info,gLockedDrive);

 	test(r==KErrInUse);

 	TFileName origSessPath;

 	r=TheFs.SessionPath(origSessPath);

 	test(r==KErrNone);

 	// test these work ok

 	r=TheFs.SetSessionPath(gLockedPath);

 	test(r==KErrNone);

 	r=TheFs.SetSessionPath(origSessPath);

 	test(r==KErrNone);

 	// test on different drive from notifier - the session path

 	test.Next(_L("test parsing functions on a different drive"));

 	// Using ParseSubst

 	r=TheFs.MkDir(Dir1);

 	test(r==KErrNone);

 	r=TheFs.RmDir(Dir1);

 	test(r==KErrNone);

 	r=f.Create(TheFs,File1,EFileShareAny);

 	test(r==KErrNone);

 	f.Close();

 	r=TheFs.Delete(File1);

 	test(r==KErrNone);

 	// Using ParsePathPtr0

 	r=TheFs.SetSubst(gSessionPath,EDriveO);

 	test(r==KErrNone);

 	r=TheFs.SetSubst(_L(""),EDriveO);

 	test(r==KErrNone);

 	// ValidateDrive

 	r=TheFs.Volume(info,gSessionDrive);

 	test(r==KErrNone);

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	TRequestStatus deathStat;

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 //	test.End();

 	}

 void TestTFsFunctions()	

 //

 // test functions that do not use the Parse* and Validate* functions

 //

 	{

 	test.Next(_L("TestTFsFunctions"));

 	TFileName sessName,lockedName;

 	TInt r=TheFs.FileSystemName(sessName,gSessionDrive);

 	test(r==KErrNone);

 	r=TheFs.FileSystemName(lockedName,gLockedDrive);

 	test(r==KErrNone);

 	RThread thread;

 	PutNonCriticalNotifier(NULL,thread);

 	// test functions on hung drive - should return KErrInUse

 	test.Next(_L("test TFs functions on hung drive"));

 	// TFsDismountFileSystem

 	r=TheFs.DismountFileSystem(lockedName,gLockedDrive);

 	test(r==KErrInUse);

 	// TFsMountFileSystem

 	r=TheFs.MountFileSystem(lockedName,gLockedDrive);

 	test(r==KErrInUse);

 	// TFsFileSystemName

 	r=TheFs.FileSystemName(lockedName,gLockedDrive);

 	test(r==KErrInUse);

 	// test functions on drive other than hung drive

 	test.Next(_L("test TFs functions on drive that is not hung"));

 	// TFsDismountFileSystem

 #if defined(__WINS__)

 	// bug in TFsMountFileSystem which needs to be fixed before running on EDriveC on WINS

 	if(gSessionDrive!=EDriveC)

 		{

 #endif

 	r=TheFs.DismountFileSystem(sessName,gSessionDrive);

 	test(r==KErrNone);

 	// TFsMountFileSystem

 	r=TheFs.MountFileSystem(sessName,gSessionDrive);

 	test(r==KErrNone);

 #if defined(__WINS__)

 		}

 #endif

 	// TFsFileSystemName

 	TFileName fsName;

 	r=TheFs.FileSystemName(fsName,gSessionDrive);

 	test(r==KErrNone);

 	test(fsName==sessName);

 	// test functions that fail on all drives

 	test.Next(_L("test TFs functions that fail on all drives"));

 	// TFsListOpenFiles

 	CFileList* list=NULL;

 	TOpenFileScan fileScan(TheFs);

 	TRAP(r,fileScan.NextL(list));

 	test(r==KErrInUse);

 	// test functions that should pass on any drive

 	test.Next(_L("test TFs functions that pass on all drives"));

 	// TFsSetDefaultPath

 	// TFsSetSessionPath

 	r=TheFs.SetSessionPath(gLockedPath);

 	test(r==KErrNone);

 	r=TheFs.SetSessionPath(gSessionPath);

 	test(r==KErrNone);

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	TRequestStatus deathStat;

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 //	test.End();

 	}

 void TestSubsessions()	

 //

 // test subsession functions

 //

 	{

 	test.Next(_L("TestSubsessions"));

 	RThread thread;

 	PutNonCriticalNotifier(NULL,thread);

 	// test that subsessions cannot be opened on a hung drive

 	test.Next(_L("test subsessions cannot be opened on a hung drive"));

 	// EFsFileCreate

 	RFile file;

 	TFileName fileName=gLockedPath;

 	fileName+=File1;

 	TInt r=file.Create(TheFs,fileName,EFileShareAny);

 	test(r==KErrInUse);

 	// EFsFormatOpen

 	RFormat format;

 	TInt count;

 	r=format.Open(TheFs,gLockedPath,EHighDensity,count);

 	test(r==KErrInUse);

 	// EFsDirOpen

 	RDir dir;

 	r=dir.Open(TheFs,gLockedPath,KEntryAttMaskSupported);

 	test(r==KErrInUse);

 	// EFsRawDiskOpen

 	RRawDisk raw;

 	r=raw.Open(TheFs,gLockedDrive);

 	test(r==KErrInUse);

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	TRequestStatus deathStat;

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 	// now open the subsessions

 	r=file.Create(TheFs,fileName,EFileShareAny);

 	test(r==KErrNone||KErrAlreadyExists);

 	if(r==KErrAlreadyExists)

 		{

 		r=file.Open(TheFs,fileName,EFileShareAny);

 		test(r==KErrNone);

 		}

 	r=dir.Open(TheFs,gLockedPath,KEntryAttMaskSupported);

 	test(r==KErrNone);

 	// put notifier back up

 	PutNonCriticalNotifier(NULL,thread);

 	// test subsession operations fail on a hung drive

 	test.Next(_L("test subsession operations fail on a hung drive"));

 	// EFsFileRead

 	TBuf8<16> readBuf;

 	r=file.Read(readBuf);

 	test(r==KErrInUse);

 	// subsession should be able to be closed ok

 	file.Close();

 	// EFsDelete

 	r=TheFs.Delete(fileName);

 	test(r==KErrInUse);

 	// EFsDirRead

 	TEntry entry;

 	r=dir.Read(entry);

 	test(r==KErrInUse);

 	// subsession should be able to be closed ok

 	dir.Close();

 	// not going to test operations on a drive the is not hung

 	// since this will be tested on other tests

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 	r=TheFs.Delete(fileName);

 	test(r==KErrNone);

 //	test.End();

 	}

 void TestSameSession()

 //

 // Test functions that can and cannot be handled from same session when notifier is up

 //

 	{

 	test.Next(_L("TestSameSession"));

 	RFile file;

 	TInt r=file.Create(TheFs,File1,EFileWrite);

 	test(r==KErrNone);

 	// put notifier up using TheFs session

 	SNonCriticalInfo info={ETrue,0};

 	RThread thread;

 	PutNonCriticalNotifier(&info,thread);

 	// test critical functions can be handled

 	test.Next(_L("test critical functions can be handled"));

 	// EFsNotifyChange

 	TRequestStatus status;

 	TheFs.NotifyChange(ENotifyAll,status);

 	test(status==KRequestPending);

 	// EFsNotifyChangeCancel

 	TheFs.NotifyChangeCancel();

 	test(status==KErrCancel);

 	// EFsNotifyChange again

 	TheFs.NotifyChange(ENotifyAll,status);

 	test(status==KRequestPending);

 	// EFsNotifyChangeCancelEx

 	TheFs.NotifyChangeCancel(status);

 	test(status==KErrCancel);

 	// not going to test EFsSubClose

 	// test other functions are not handled

 	test.Next(_L("test other functions cannot be handled"));

 	// EFsNotifyChangeEx

 	TheFs.NotifyChange(ENotifyAll,status,gSessionPath);

 	test(status==KErrInUse);

 	TFileName defPath;

 	// EFsCheckDisk

 	r=TheFs.CheckDisk(gSessionPath);

 	test(r==KErrInUse);

 	// EFsFileWrite

 	_LIT8(buffer,"abc");

 	TBuf8<8> buf(buffer);

 	r=file.Write(buf);

 	test(r==KErrInUse);

 	// this file should be able to be closed

 	file.Close();

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	TRequestStatus deathStat;

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 	r=TheFs.Delete(File1);

 	test(r==KErrNone);

 //	test.End();

 	}

 void TestSameSubSession()

 // 

 // test hung file server with same subsession

 //

 	{

 	_LIT(file1Name,"\\SubFile1");

 	_LIT(file2Name,"\\SubFile2");

 	_LIT(file3Name,"\\SubFile3");

 	_LIT(file4Name,"\\SubFile4");

 	TFileName origSession;

 	TInt r=TheFs.SessionPath(origSession);

 	test(r==KErrNone);

 	TFileName file1Path(gLockedBase);

 	file1Path+=file1Name;

 	TFileName file2Path(file2Name);

 	TFileName file3Path(gLockedBase);

 	file3Path+=file3Name;

 	TFileName file4Path(file4Name);

 	// create file that will be used to hang file server

 	r=SubFile1.Create(TheFs,file1Path,EFileWrite);

 	test(r==KErrNone);

 	// create file with same session but on different drive

 	RFile subfile2;

 	r=subfile2.Create(TheFs,file2Path,EFileWrite);

 	test(r==KErrNone);

 	// create file on unhung drive and with different session

 	RFs fs2;

 	r=fs2.Connect();

 	test(r==KErrNone);

 	r=fs2.SetSessionPath(origSession);

 	test(r==KErrNone);

 	RFile subfile3;

 	r=subfile3.Create(fs2,file3Path,EFileWrite);

 	test(r==KErrNone);

 	// create file on unhung drive and with different session

 	RFile subfile4;

 	r=subfile4.Create(fs2,file4Path,EFileWrite);

 	test(r==KErrNone);

 	// in a different thread cause the server to hang using one of the File1 subsession

 	// put notifier up using TheFs session

 	SNonCriticalInfo info={ETrue,ETrue};

 	RThread thread;

 	PutNonCriticalNotifier(&info,thread);

 	test.Next(_L("test writing to files with hung file server"));

 	// check only file4 can be written to

 	_LIT8(buffer,"abc");

 	TBuf8<8> buf(buffer);

 	// File1 caused hung file server

 	r=SubFile1.Write(buf);

 	test(r==KErrInUse);

 	// file2 is same session as subsession that caused hung file server

 	r=subfile2.Write(buf);

 	test(r==KErrInUse);

 	// file3 is opened on hung drive

 	r=subfile3.Write(buf);

 	test(r==KErrInUse);

 	// file4 should be ok

 	r=subfile4.Write(buf);

 	test(r==KErrNone);

 	// hard to test EFsSubClose since does not return an error value

 	test.Next(_L("test closing down the subsessions"));

 	subfile4.Close();

 	// calling close on the same subsession as is hung will cause this subsession

 	// to be closed once the original request is completed

 	SubFile1.Close();

 	subfile2.Close();

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	TRequestStatus deathStat;

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 	// close remaining files

 	subfile3.Close();

 	// clean up

 	fs2.Close();

 	r=TheFs.Delete(file1Path);

 	test(r==KErrNone);

 	r=TheFs.Delete(file2Path);

 	test(r==KErrNone);

 	r=TheFs.Delete(file3Path);

 	test(r==KErrNone);

 	r=TheFs.Delete(file4Path);

 	test(r==KErrNone);

 	}

 void TestExtendedNotifier()

 //

 //

 //

 	{

 	test.Next(_L("TestExtendedNotifier"));

 	// setup a notification on a removable media

 	test.Next(_L("test with drive specified"));

 	TFileName notDir=gLockedBase;

 	notDir+=NotifyDir;

 	TRequestStatus status;

 	TheFs.NotifyChange(ENotifyAll,status,notDir);

 	test(status==KRequestPending);

 	// now do an operation on c: and test no notification

 	TInt r=TheFs.MkDir(NotifyDir);

 	test(r==KErrNone);

 	r=TheFs.RmDir(NotifyDir);

 	test(r==KErrNone);

 	User::After(1000000);

 	test(status==KRequestPending);

 	TheFs.NotifyChangeCancel(status);

 	test(status==KErrCancel);

 	// now put up the notifier

 	RThread thread;

 	PutNonCriticalNotifier(NULL,thread);

 	// repeat the above notification

 	// setup a notification on a removable media - the drive should be changed

 	// to * since notifier is up

 	test.Next(_L("test with wildcard for drive"));

 	TheFs.NotifyChange(ENotifyAll,status,notDir);

 	test(status==KRequestPending);

 	// test notification does not go off with wrong path

 	r=TheFs.MkDir(NotifyDir2);

 	test(r==KErrNone);

 	r=TheFs.RmDir(NotifyDir2);

 	test(r==KErrNone);

 	test(status==KRequestPending);

 	// now do an operation on c: and test there has been a notification

 	r=TheFs.MkDir(NotifyDir);

 	test(r==KErrNone);

 	r=TheFs.RmDir(NotifyDir);

 	test(r==KErrNone);

 	User::After(1000000);

 	// request should be completed this time

 	test(status==KErrNone);

 	// set up a notification on drive that is not removable

 	// the path should not be changed

 	test.Next(_L("test with non-removable drive"));

 	TheFs.NotifyChange(ENotifyAll,status,notDir);

 	test(status==KRequestPending);

 	TRequestStatus status2;

 	TFileName origSession;

 	r=TheFs.SessionPath(origSession);

 	test(r==KErrNone);

 	RFs fs2;

 	r=fs2.Connect();

 	test(r==KErrNone);

 	r=fs2.SetSessionPath(origSession);

 	test(r==KErrNone);

 	_LIT(notifyDirZ,"z:\\test\\");

 	_LIT(notifyDirSess,"\\test\\");

 	// notifyDirZ already exists, create test dir in session path

 	r=fs2.MkDir(notifyDirSess);

 	test(r==KErrNone);

 	fs2.NotifyChange(ENotifyDir,status2,notifyDirZ);

 	test(status2==KRequestPending);

 	TRequestStatus status3;

 	fs2.NotifyChange(ENotifyDir,status3,notifyDirSess);

 	test(status3==KRequestPending);

 	// now delete session dir and test no notification

 	r=TheFs.RmDir(notifyDirSess);

 	test(r==KErrNone);

 	test(status2==KRequestPending && status3==KErrNone);

 	// get rid of non-critical notifier

 	test.Printf(_L("Enter %S on the notifier\n"),&KPassword);

 	TRequestStatus deathStat;

 	thread.Logon( deathStat );

 	HungSemaphoreNC.Wait();

 	test(HungReturnCodeNC==KErrNotFound);

 	User::WaitForRequest( deathStat );

 	thread.Close();

 	test(status==KErrNone&&status2==KErrNone);

 	fs2.Close();

 	test.Next(_L("test extended notification with critical notifier"));

 	RThread threadC;

 	// put a a critical notifier

 	PutCriticalNotifier(ETrue,threadC);

 	// setup extended change notification on session path, drive should be changed to *

 	TheFs.NotifyChange(ENotifyAll,status,NotifyDir);

 	test(status==KRequestPending);

 	// get rid of notifier

 	test.Printf(_L("Press cancel on for critcal notifier\n"));

 	threadC.Logon(deathStat);

 	HungSemaphoreC.Wait();

 	User::WaitForRequest(deathStat);

 	threadC.Close();

 	// test that notification has not gone off

 	test(status==KRequestPending);

 	// create directory on locked drive

 	r=TheFs.MkDir(notDir);

 	test(r==KErrNone);

 	// test notifier goes off

 	test(status==KErrNone);

 	r=TheFs.RmDir(notDir);

 	test(r==KErrNone);

 	// get rid of critical notifier

 	}	

 LOCAL_C TBool TestSessionPath()

 //

 // 

 //

 	{

 #if defined(__WINS__)

 	TInt r=TheFs.CharToDrive(gSessionPath[0],gSessionDrive);

 	test(r==KErrNone);

 	if(gSessionDrive==EDriveX)

 		return(EFalse);

 #else

 	TInt r=TheFs.CharToDrive(gSessionPath[0],gSessionDrive);

 	test(r==KErrNone);

 	TDriveList list;

 	r=TheFs.DriveList(list);

 	test(r==KErrNone);

 	if((list[gSessionDrive])&KDriveAttRemovable)

 		return(EFalse);

 #endif

 	return(ETrue);

 	}

 GLDEF_C void CallTestsL()

 //

 // Test a hung file server

 //

 	{

 	if(!IsTestTypeStandard())

 		return;

 	if(!TestSessionPath())

 		{

 		test.Printf(_L("Not testing on %S\n"),&gSessionPath);

 		return;

 		}

 #if defined(__WINS__)

 	gLockedDrive=EDriveX;

 	gLockedPath=_L("?:\\");

 	gLockedBase=_L("?:");

 	gLockedPath[0]=gLockedBase[0]=(TText)('A'+gLockedDrive);

 #else

 	gLockedDrive=EDriveD;

 	gLockedPath=_L("?:\\");

 	gLockedBase=_L("?:");

 	gLockedPath[0]=gLockedBase[0]=(TText)('A'+gLockedDrive);

 #endif

 	test.Printf(_L("Is a secure mmc present? Press y for yes\n"));

 	TChar c=test.Getch();

 	if(c=='y'||c=='Y')

 		isSecureMmc=ETrue;

 	else

 		isSecureMmc=EFalse;

 	TInt r=HungSemaphoreC.CreateLocal(0);

 	test(r==KErrNone);

 	r=HungSemaphoreNC.CreateLocal(0);

 	test(r==KErrNone);

 	// create sharable session

 	TheFs.ShareAuto();

 	TestParsingFunctions();

 	TestTFsFunctions();

 	TestExtendedNotifier();

 	TestSubsessions();

 //	TestNotifiers();

 	TestCriticalFunctions();

 	TestSameSession();

 	TestSameSubSession();

 	HungSemaphoreC.Close();

 	HungSemaphoreNC.Close();

 }