// 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_dspace.cpp

//

//

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "t_chlffs.h"

/* This tests disk space notification. Using RFs::NotifyDiskSpace a client can request

to be notified if the free disk space crosses a specified threshold. This test requires

a card to be present in d: */

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

const TInt KMaxBufSize=512;

#if defined(__WINS__)

TInt KFileSize1=2048;

TInt KFileSize2=4096;

TInt KFileSize3=8192;

#else

TInt KFileSize1=512;

TInt KFileSize2=1024;

TInt KFileSize3=4096;

#endif

const TInt KHeapSize=0x2000;

const TInt KStackSize=0x4000;

TInt gMinFileSize;

TBool LffsDrive = EFalse;

TBuf8<KMaxBufSize> TheBuffer;

TInt64 TheDiskSize;

TInt RemovableDrive;

TBuf<4> RemovableDriveBuf=_L("?:\\");

_LIT(KTestFile1, "\\F32-TST\\testfile1");

_LIT(KTestFile2, "\\F32-TST\\testFile2");

_LIT(KTestDir1, "\\F32-TST\\testDir1\\");

_LIT(KTestDir2, "\\F32-TST\\testDir2\\");

_LIT(KFileFiller, "\\F32-TST\\fileFiller");

// functions that may cause change in free disk space

// not all of them of tested since some require knowledge of file system

// to ensure change in free disk space

enum TThreadTask

	{

	ETaskSetVolume,

	ETaskMkDir,

	ETaskRmDir,

	ETaskDelete,		// test

	ETaskRename,

	ETaskReplace,		// test

	ETaskFileCreate,

	ETaskFileReplace,	// test

	ETaskFileTemp,

	ETaskFileWrite,		// test

	ETaskFileWrite4KB,

	ETaskFileWrite64KB,

	ETaskFileSetSize,	// test

	ETaskFileRename,

	ETaskNoChange1,

	ETaskNoChange2,

	ETaskFileCreateLffs,// test

	ETaskSpin

	};

LOCAL_C TBool IsWinsCDrive(TInt aDrive)

//

//

//

	{

#if defined(__WINS__)

	if(aDrive==KDefaultDrive)

		return(gSessionPath[0]==(TText)'C');

	else

		return(aDrive==EDriveC);

#else

	return(EFalse);

#endif

	}

LOCAL_C TInt64 FreeDiskSpace(TInt aDrive)

//

//

//

	{

	TVolumeInfo v;

	TInt r=TheFs.Volume(v,aDrive);

	test(r==KErrNone);

	return(v.iFree);

	}

LOCAL_C TInt64 DiskSize(TInt aDrive)

//

//

//

	{

	TVolumeInfo v;

	TInt r=TheFs.Volume(v,aDrive);

	test(r==KErrNone);

	return(v.iSize);

	}

// MinimumFileSize() -

// Deduces the minimum space occupied by a file by creating a file of one byte

// in length. This should equal the cluster size on FAT volumes.

//

LOCAL_C TInt MinimumFileSize(TInt aDrive)

	{

	TInt r = TheFs.Delete(KTestFile1);

	test(r==KErrNone || r==KErrNotFound);

	TInt64 freeSpace = FreeDiskSpace(aDrive);

	RFile file;

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

	test(r==KErrNone);

	r = file.Write(TheBuffer,1);

	test(r==KErrNone);

	file.Close();

	TInt64 newSpace = FreeDiskSpace(aDrive);

	r = TheFs.Delete(KTestFile1);

	test(r==KErrNone);

	TInt64 minFileSize = freeSpace - newSpace;

	test (minFileSize >= 0);

	minFileSize = Max(minFileSize, 512);

	test (minFileSize < KMaxTInt);

	TInt minFileSizeLow = I64LOW(minFileSize);

	RDebug::Print(_L("minFileSize %u"), minFileSizeLow);

#if defined(__WINS__)

	KFileSize1 = minFileSizeLow << 2;	// 512 * 2^2 = 512 * 4 = 2048;

	KFileSize2 = minFileSizeLow << 3;	// 512 * 2^3 = 512 * 8 = 4096;

	KFileSize3 = minFileSizeLow << 4;	// 512 * 2^4 = 512 * 16 = 8192;

#else

	KFileSize1 = minFileSizeLow;		// 512;

	KFileSize2 = minFileSizeLow << 1;	// 512 * 2^1 = 512 * 2 = 1024;

	KFileSize3 = minFileSizeLow << 3;	// 512 * 2^3 = 512 * 8 = 4096;

#endif

	return (TInt) minFileSizeLow;

	}

LOCAL_C void Initialise()

//

// do any initialisation before starting tests

//

	{

	if(TheBuffer.Length()!=KMaxBufSize)

		{

		TheBuffer.SetLength(KMaxBufSize);

		Mem::Fill((void*)TheBuffer.Ptr(),KMaxBufSize,0xab);

		}

#if defined(__WINS__)

	RemovableDrive=EDriveX;

#else

	TDriveList drvList;

	if(KErrNone == TheFs.DriveList(drvList))

		{

		TInt i;

		//should be successful, otherwise it means a system w/o any drive!!!

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

			{

			TDriveInfo driveInfo;

			if((drvList[i] != 0)

				&& (KErrNone == TheFs.Drive(driveInfo, i))

				&& (driveInfo.iType == EMediaHardDisk))

				{

				RemovableDrive = i;

				test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive);

				break;

				}

			}

		if(i == KMaxDrives)

			{

			test.Printf(_L("No Removable media found! Testing discontinued.\n"));

			User::Exit(KErrNone);

			}

		}

	else

		{

		test.Printf(_L("No Drive found! Testing discontinued.\n"));

		User::Exit(KErrNone);

		}

#endif

	test.Printf(_L("inside init++++++++++++++++++++++++++>\n\n\n"));

	test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive);

	// initialise removable drive descriptor

	TChar c;

	TInt r=RFs::DriveToChar(RemovableDrive,c);

	test(r==KErrNone);

	RemovableDriveBuf[0]=(TText)c;

	if( !LffsDrive )

		{

		// and create the default directory

		TFileName d=gSessionPath;

		d[0]=RemovableDriveBuf[0];

		MakeDir(d);

		}

	// better format the default drive as long as not WINS c drive

	TInt drive;

	r= RFs::CharToDrive(gSessionPath[0],drive);

	test(r==KErrNone);

#if defined(__WINS__)

	if(drive!=EDriveC)

		Format(drive);

#else

	Format(drive);

	// test not run on c: drive but does use it

	Format(EDriveC);

#endif

	TheDiskSize=DiskSize(KDefaultDrive);

	// and set the default directory

	r=TheFs.MkDirAll(gSessionPath);

	test(r==KErrNone || r==KErrAlreadyExists);

	r=TheFs.Delete(KFileFiller);

	test(r==KErrNone || r==KErrNotFound);

	r=TheFs.Delete(KTestFile1);

	test(r==KErrNone || r==KErrNotFound);

	r=TheFs.Delete(KTestFile2);

	test(r==KErrNone || r==KErrNotFound);

	r=TheFs.RmDir(KTestDir1);

	test(r==KErrNone || r==KErrNotFound);

	r=TheFs.RmDir(KTestDir2);

	test(r==KErrNone || r==KErrNotFound);

	gMinFileSize = MinimumFileSize(drive);

	}

LOCAL_C TInt64 FillDisk(RFile& aFile,TInt64 aNewSpace,TInt aDrive)

//

// fill a file until free disk space equals aFreeSpace

//

	{

	TInt64 space=FreeDiskSpace(aDrive);

	test(space>aNewSpace);

	while(space>aNewSpace)

		{

		TInt s=Min(KMaxBufSize, I64INT(space-aNewSpace));

		TInt r=aFile.Write(TheBuffer,s);

		if( !LffsDrive )

			{

			test(r==KErrNone);

			}

		else

			{

			//

			// LFFS is less predictable than a normal drive because of the logging

			// and metadata arrangement

			//

			test( (KErrNone==r) || (KErrDiskFull==r) );

			if( KErrDiskFull == r )

				{

				// shrink the file back down again to give the requested free space

				TInt fileSize;

				r=aFile.Size( fileSize );

				test( KErrNone == r );

				test( TInt64(fileSize) > aNewSpace );

				fileSize -= I64LOW(aNewSpace);

				r=aFile.SetSize( fileSize );

				test( KErrNone == r );

				space=FreeDiskSpace(aDrive);

				while( space < aNewSpace )

					{

					fileSize -= I64LOW(aNewSpace - space);

					test( fileSize > 0 );

					r=aFile.SetSize( fileSize );

					test( KErrNone == r );

					space=FreeDiskSpace(aDrive);

					}

				break;

				}

			}

		space=FreeDiskSpace(aDrive);

		}

	return(space);

	}

LOCAL_C void WriteToFile(RFile& aFile,TInt aSize)

//

//

//

	{

	while(aSize>0)

		{

		TInt s=Min(KMaxBufSize,aSize);

		TInt r=aFile.Write(TheBuffer,s);

		aSize-=s;

		// Flush if write caching enabled to ensure we get disk space notifications

		if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))

			r = aFile.Flush();

		if( !LffsDrive )

			{

			test(r==KErrNone);

			}

		else

			{

			// we can't accurately predict the amount of data we can actually get

			// on an LFFS drive, so it's posible we could exceed the available

			// space even though we are writing less that the reported free space

			test( (KErrNone==r) || (KErrDiskFull==r) );

			if( KErrDiskFull == r )

				{

				break;	// just stop

				}

			}

		}

	}

LOCAL_C void CleanupForThread(TInt aTask)

//

//

//

	{

	TInt r;

	switch(aTask)

		{

		case ETaskMkDir:

			r=TheFs.RmDir(KTestDir1);

			test(r==KErrNone);

			break;

		case ETaskRmDir: break;

		case ETaskDelete: break;

		case ETaskReplace:

			r=TheFs.Delete(KTestFile2);

			test(r==KErrNone);

			break;

		case ETaskFileReplace:

			r=TheFs.Delete(KTestFile1);

			test(r==KErrNone);

			break;

		case ETaskFileWrite:

		case ETaskFileWrite4KB:

		case ETaskFileWrite64KB:

		case ETaskFileSetSize:

		case ETaskFileCreateLffs:

		case ETaskNoChange1:

		case ETaskNoChange2:

			r=TheFs.Delete(KTestFile1);

			if(r!=KErrNone)

				{

				test.Printf(_L("r=%d"),r);

				test(EFalse);

				}

			break;

		case ETaskSpin:

		default:break;

		}

	}

LOCAL_C void InitialiseForThread(TInt aTask)

//

//

//

	{

	TInt r;

	RFile file,file2;

	switch(aTask)

		{

		case ETaskMkDir:	break;

		case ETaskRmDir:

			r=TheFs.MkDir(KTestDir1);

			test(r==KErrNone);

			break;

		case ETaskDelete:

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

			test(r==KErrNone);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize1);

				test(r==KErrNone);

				}

			else

				{

				// LFFS supports sparse files, so we have to write real data

				// into the file to ensure that it uses up disk space

				WriteToFile( file, KFileSize1 );

				}

			file.Close();

			break;

		case ETaskReplace:

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

			test(r==KErrNone);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize1);

				test(r==KErrNone);

				}

			else

				{

				WriteToFile( file, KFileSize2 );

				}

			file.Close();

			r=file2.Create(TheFs,KTestFile2,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			if( !LffsDrive )

				{

				r=file2.SetSize(KFileSize3);

				test(r==KErrNone);

				}

			else

				{

				WriteToFile( file2, gMinFileSize << 4);	// 512 * 16 = 8K

				}

			file2.Close();

			break;

		case ETaskFileReplace:

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

			test(r==KErrNone);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize3*2);

				}

			else

				{

				WriteToFile( file, KFileSize3 );

				}

			test(r==KErrNone);

			file.Close();

			break;

		case ETaskFileWrite:

		case ETaskFileWrite4KB:

		case ETaskFileWrite64KB:

		case ETaskFileSetSize:

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

			test(r==KErrNone);

			file.Close();

			break;

		case ETaskNoChange1:

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

			test(r==KErrNone);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize1);

				test(r==KErrNone);

				}

			else

				{

				WriteToFile( file, KFileSize1 );

				}

			file.Close();

			break;

		case ETaskNoChange2:

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

			test(r==KErrNone);

			file.Close();

			break;

		case ETaskFileCreateLffs:

			r = TheFs.Delete(KTestFile1);

			break;

		case ETaskSpin:

		default:break;

		}

	}

LOCAL_C TInt ThreadFunction(TAny* aThreadTask)

//

//

//

	{

	RTest test(_L("T_DSPACE_ThreadFunction"));

	RFs fs;

	TInt r=fs.Connect();

	test(r==KErrNone);

	r=fs.SetSessionPath(gSessionPath);

	test(r==KErrNone);

	TThreadTask task=*(TThreadTask*)&aThreadTask;

	RFile file;

	switch(task)

		{

		case ETaskMkDir:

			r=fs.MkDir(KTestDir1);

			test(r==KErrNone);

			break;

		case ETaskRmDir:

			r=fs.RmDir(KTestDir1);

			test(r==KErrNone);

			break;

		case ETaskDelete:

			r=fs.Delete(KTestFile1);

			test(r==KErrNone);

			break;

		case ETaskReplace:

			r=fs.Replace(KTestFile1,KTestFile2);

			test(r==KErrNone);

			break;

		case ETaskFileReplace:

			r=file.Replace(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			file.Close();

			break;

		case ETaskFileWrite:

			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

#if defined(__WINS__)

			WriteToFile( file, gMinFileSize << 4);	// 512 * 16 = 8K

#else

			WriteToFile( file, gMinFileSize << 1);	// 512 * 2 = 1K

#endif

			file.Close();

			break;

		case ETaskFileWrite4KB:

			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			WriteToFile(file,gMinFileSize << 3);	// 512 * 2^3 = 512 * 8 = 4K

			file.Close();

			break;

		case ETaskFileWrite64KB:

			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			WriteToFile(file,gMinFileSize<<7);	// 512 * 2^7 = 512 * 128 = 64K

			file.Close();

			break;

		case ETaskFileSetSize:

			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			r=file.SetSize(KFileSize3);

			file.Close();

			break;

		case ETaskFileCreateLffs:

			r=file.Create(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			file.Close();

			break;

		case ETaskNoChange1:

			{

			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);

			test(r==KErrNone);

			TTime time;

			time.HomeTime();

			r=file.SetModified(time);

			test(r==KErrNone);

			file.Close();

			break;

			}

		case ETaskNoChange2:

			{

			TEntry e;

			r=fs.Entry(KTestFile1,e);

			test(r==KErrNone);

			break;

			}

		case ETaskSpin:

			for(;;) {};

		default:break;

		}

	fs.Close();

	return(KErrNone);

	}

void TestCancellation()

//

// test error disk space notification requests can be cancelled

//

	{

	test.Next(_L("test disk space cancellation"));

	const TInt ThresholdSize=500;

	// test a cancellation

	// Up the priority of this thread so that we can cancel the request before the drive thread

	// runs, to test whether cancelling still works.

	RThread().SetPriority(EPriorityRealTime);

	TRequestStatus stat1;

	TheFs.NotifyDiskSpace(ThresholdSize,KDefaultDrive,stat1);

	test(stat1==KRequestPending);

	TheFs.NotifyDiskSpaceCancel(stat1);

	test(stat1==KErrCancel);

	RThread().SetPriority(EPriorityNormal);

	// test no affect if already cancelled

	stat1=KErrNone;

	TheFs.NotifyDiskSpaceCancel(stat1);

	test(stat1==KErrNone);

	// set up two requests, cancel 1

	TRequestStatus stat2;

	TheFs.NotifyDiskSpace(ThresholdSize,KDefaultDrive,stat1);

	TheFs.NotifyDiskSpace(ThresholdSize,KDefaultDrive,stat2);

	test(stat1==KRequestPending && stat2==KRequestPending);

	TheFs.NotifyDiskSpaceCancel(stat2);

	test(stat1==KRequestPending && stat2==KErrCancel);

	TheFs.NotifyDiskSpaceCancel(stat1);

	test(stat1==KErrCancel);

	if( !LffsDrive)

		{

		// now repeat with c: and removable drive

		TheFs.NotifyDiskSpace(ThresholdSize,EDriveC,stat1);

		TheFs.NotifyDiskSpace(ThresholdSize,RemovableDrive,stat2);

		test(stat1==KRequestPending && stat2==KRequestPending);

		TheFs.NotifyDiskSpaceCancel(stat1);

		test(stat2==KRequestPending && stat1==KErrCancel);

		TheFs.NotifyDiskSpaceCancel(stat2);

		test(stat2==KErrCancel);

		}

	}

void TestErrorConditions()

//

// test disk space notification requests return correct error value

//

	{

	test.Next(_L("test error conditions"));

	// attempt to set up disk space notification with a threshold of zero

	TRequestStatus status;

	TheFs.NotifyDiskSpace(0,KDefaultDrive,status);

	test(status==KErrArgument);

	// test on an empty drive

	TheFs.NotifyDiskSpace(100,EDriveO,status);

	test(status==KErrNotReady);

	// test on a drive out of rance

	TheFs.NotifyDiskSpace(100,27,status);

	test(status==KErrBadName);

	// new setup with threshold of one

	TheFs.NotifyDiskSpace(1,KDefaultDrive,status);

	test(status==KRequestPending);

	TheFs.NotifyDiskSpaceCancel(status);

	test(status==KErrCancel);

	// and with a threshold > disk size

	TheFs.NotifyDiskSpace(TheDiskSize+10,KDefaultDrive,status);

	test(status==KErrArgument);

	// now with a size of max size -1

	TheFs.NotifyDiskSpace(TheDiskSize-1,KDefaultDrive,status);

	test(status==KRequestPending);

	TheFs.NotifyDiskSpaceCancel(status);

	test(status==KErrCancel);

	// set up mutiple requests and cancel one

	TRequestStatus status2,status3;

	TheFs.NotifyDiskSpace(TheDiskSize-10,KDefaultDrive,status);

	TheFs.NotifyDiskSpace(TheDiskSize-10,KDefaultDrive,status2);

	TheFs.NotifyDiskSpace(TheDiskSize-10,KDefaultDrive,status3);

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

	TheFs.NotifyDiskSpaceCancel(status3);

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

	// cancel the remaining ones

	TheFs.NotifyDiskSpaceCancel();

	test(status==KErrCancel&&status2==KErrCancel&&status3==KErrCancel);

	}

TInt GenerateMediaChange()

	{

	RLocalDrive d;

	TBool flag=EFalse;

	//Find the local drive number corresponding to removabledrive

	TMediaSerialNumber serialNum;

	TInt r = TheFs.GetMediaSerialNumber(serialNum, RemovableDrive);

	if(r!= KErrNone)

		return r;

	TInt len = serialNum.Length();

	test.Printf(_L("Serial number (len %d) :"), len);

	TInt localDriveNum = -1;

	for (TInt n=0; n<KMaxLocalDrives; n++)

		{

		r = d.Connect(n, flag);

		if(r != KErrNone)

			{

			test.Printf(_L("drive %d: TBusLocalDrive::Connect() failed %d\n"), n, r);

			continue;

			}

	    TLocalDriveCapsV5Buf capsBuf;

	    TLocalDriveCapsV5& caps = capsBuf();

		r = d.Caps(capsBuf);

		if(r != KErrNone)

			{

			test.Printf(_L("drive %d: TBusLocalDrive::Caps() failed %d\n"), n, r);

			continue;

			}

		TPtrC8 localSerialNum(caps.iSerialNum, caps.iSerialNumLength);

		if (serialNum.Compare(localSerialNum) == 0)

			{

				localDriveNum = n;

				d.Close();

				break;

			}

		d.Close();

		}

	r =d.Connect(localDriveNum,flag);

	if (r!=KErrNone)

		return r;

	d.ForceMediaChange();

	d.Close();

	return KErrNone;

	}

void TestDiskNotify()

//

// test functions that can result in disk change notification

// format,scandrive, media change

//

	{

	// make default directory

	_LIT(defaultDir,"C:\\F32-TST\\");

	TInt r=TheFs.MkDirAll(defaultDir);

	test(r==KErrNone||r==KErrAlreadyExists);

	// create the filler file

	RFile file;

	TFileName fileName=_L("C:");

	fileName+=KFileFiller;

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

	test(r==KErrNone);

	TInt64 free=FreeDiskSpace(EDriveC);

	// use up 16KB

	FillDisk(file,free-16384,EDriveC);

	// test formatting notifies clients on only specific drive

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

	TRequestStatus stat1, stat2;

	TInt64 freeC=FreeDiskSpace(EDriveC);

	TInt64 freeD=FreeDiskSpace(RemovableDrive);

	TheFs.NotifyDiskSpace(freeC+1024,EDriveC,stat1);

	TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2);

	test(stat1==KRequestPending && stat2==KRequestPending);

	RFormat f;

	TInt count;

	r=f.Open(TheFs,RemovableDriveBuf,EQuickFormat,count);

	test(r==KErrNone);

	while(count)

		{

		r=f.Next(count);

		test(r==KErrNone);

		}

	f.Close();

	User::After(1000000);

	User::WaitForRequest(stat2);

	test(stat1==KRequestPending && stat2==KErrNone);

	TheFs.NotifyDiskSpaceCancel(stat1);

	test(stat1==KErrCancel);

	// and create the test directory for the removable drive

	TFileName fName=_L("");

	fName+=RemovableDriveBuf;

	fName+=_L("F32-TST\\");

	r=TheFs.MkDirAll(fName);

	test(r==KErrNone);

	// test that a media change notifies clients on all drives

	test.Next(_L("media change"));

	freeC=FreeDiskSpace(EDriveC);

	freeD=FreeDiskSpace(RemovableDrive);

	test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC);

	test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD);

	TheFs.NotifyDiskSpace(freeC+1024,EDriveC,stat1);

	TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2);

	test(stat1==KRequestPending && stat2==KRequestPending);

//	UserSvr::ForceRemountMedia(ERemovableMedia0);

	r = GenerateMediaChange();

	if(r == KErrNone)

		{

		User::After(1000000);

		User::WaitForRequest(stat2);

		test(stat1==KRequestPending && stat2==KErrNone);

		TheFs.NotifyDiskSpaceCancel(stat1);

		test(stat1==KErrCancel);

		}

	else

		{

		test.Printf(_L("media change not supported, skipping this step\n"));

		TheFs.NotifyDiskSpaceCancel(stat1);

		test(stat1 == KErrCancel);

		TheFs.NotifyDiskSpaceCancel(stat2);

		test(stat2 == KErrCancel);

		}

	// test that scandrive notifies clients on only specific drives

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

	// first test that scandrive does not find any problems on the removable media

	r=TheFs.ScanDrive(RemovableDriveBuf);

	test(r==KErrNone);

	// now set up disk space notification

	freeC=FreeDiskSpace(EDriveC);

	freeD=FreeDiskSpace(RemovableDrive);

	test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC);

	test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD);

	TheFs.NotifyDiskSpace(freeC+8192,EDriveC,stat1);

	TheFs.NotifyDiskSpace(freeD-8192,RemovableDrive,stat2);

	test(stat1==KRequestPending && stat2==KRequestPending);

	r=TheFs.ScanDrive(RemovableDriveBuf);

	test(r==KErrNone);

	User::After(1000000);

	User::WaitForRequest(stat2);

	test(stat1==KRequestPending && stat2==KErrNone);

	TheFs.NotifyDiskSpaceCancel(stat1);

	test(stat1==KErrCancel);

	file.Close();

	r=TheFs.Delete(fileName);

	test(r==KErrNone);

	if(gSessionPath[0]!=(TText)'C')

		{

		r=TheFs.RmDir(defaultDir);

		test(r==KErrNone||r==KErrInUse);

		}

	}

void TestFunctions()

//

// test some of the functions that may result in a change in free disk space

// not testing all functions that may result in free disk space change since

// change is dependent on the file system

//

	{

	test.Next(_L("test disk space functions"));

	// create the filler file

	RFile file;

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

	test(r==KErrNone);

	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;

	FillDisk(file,newSpace,KDefaultDrive);

	// check file write

	test.Next(_L("check RFile:Write"));

	TThreadTask task=ETaskFileWrite;

	InitialiseForThread(task);

	TInt64 free=FreeDiskSpace(KDefaultDrive);

	TRequestStatus stat1;

	TInt64 threshold=free-200;

	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);

	test(stat1==KRequestPending);

	RThread thread;

	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);

	test(r==KErrNone);

	thread.Resume();

	User::WaitForRequest(stat1);

	test(stat1==KErrNone);

	free=FreeDiskSpace(KDefaultDrive);

	test(free<threshold);

	TRequestStatus deathStat;

	thread.Logon( deathStat );

	User::WaitForRequest( deathStat );

	thread.Close();

	CleanupForThread(task);

	// check file set size

	// setting file size on LFFS only uses a small amount of disk space for metadata

	// so we skip this test for an LFFS drive

	if( !LffsDrive )

		{

		test.Next(_L("check RFile:SetSize"));

		task=ETaskFileSetSize;

		InitialiseForThread(task);

		free=FreeDiskSpace(KDefaultDrive);

		threshold=free-100;

		TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);

		test(stat1==KRequestPending);

		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);

		test(r==KErrNone);

		TRequestStatus deathStat;

		thread.Logon( deathStat );

		thread.Resume();

		User::WaitForRequest(stat1);

		test(stat1==KErrNone);

		free=FreeDiskSpace(KDefaultDrive);

		test(free<threshold);

		User::WaitForRequest( deathStat );

		thread.Close();

		CleanupForThread(task);

		}

	// check disk space notification does not occur when threshold not crossed

	TInt64 newFree;

	test.Next(_L("check RFile:SetSize with wrong threshold"));

	User::After(1000000);	//put in due to thread latency

	task=ETaskFileSetSize;

	InitialiseForThread(task);

	free=FreeDiskSpace(KDefaultDrive);

	threshold=free+100;

	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);

	test(stat1==KRequestPending);

	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);

	test(r==KErrNone);

	thread.Logon( deathStat );

	thread.Resume();

	User::After(1000000);

	test(stat1==KRequestPending);

	newFree=FreeDiskSpace(KDefaultDrive);

/*

	test.Printf(_L("threshold = %d and %d"),threshold.High(), threshold.Low());

	test.Printf(_L("free = %d and %d"),free.High(), free.Low());

	test.Printf(_L("newFree = %d and %d"),newFree.High(), newFree.Low());

*/

	if(!LffsDrive)

		test(free<threshold && newFree<free);

	else

		test(free<threshold);		//changing file size on lffs does not do anything

	User::WaitForRequest( deathStat );

	thread.Close();

	CleanupForThread(task);

	TheFs.NotifyDiskSpaceCancel(stat1);

	test(stat1==KErrCancel);

	// check for file delete

	test.Next(_L("check RFs::Delete"));

	task=ETaskDelete;

	InitialiseForThread(task);

	free=FreeDiskSpace(KDefaultDrive);

	threshold=free+300;

	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);

	test(stat1==KRequestPending);

	r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);

	test(r==KErrNone);

	thread.Logon( deathStat );

	thread.Resume();

	User::WaitForRequest(stat1);

	test(stat1==KErrNone);

	free=FreeDiskSpace(KDefaultDrive);

	test(free>threshold);

	User::WaitForRequest( deathStat );

	thread.Close();

	CleanupForThread(task);

	// check for replace with threshold too high

	test.Next(_L("check RFs::Replace with threshold too high"));

    if( LffsDrive )

	{

	    test.Printf( _L("Skipped.... test isn't consistent on LFFS drive\n") );

	}

    else

	{

        task=ETaskReplace;

	    InitialiseForThread(task);

	    free=FreeDiskSpace(KDefaultDrive);

    #if defined(__WINS__)

	    threshold=free + gMinFileSize * 16 + 2048;		// 512 * 16 + 2K = 10K

    #else

	    if(LffsDrive )

		    threshold=free + (gMinFileSize << 4) + 2048;	// 512 * 16 + 2K = 10K

	    else

		    threshold=free + gMinFileSize * 9 + 392;	// 512 * 9 + 392 = 5000;

    #endif

	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);

	    test(stat1==KRequestPending);

	    r=thread.Create(_L("thread5"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);

	    test(r==KErrNone);

	    thread.Logon( deathStat );

	    thread.Resume();

	    User::After(1000000);

	    test(stat1==KRequestPending);

	    newFree=FreeDiskSpace(KDefaultDrive);

	    test(newFree<threshold && free<newFree);

	    TheFs.NotifyDiskSpaceCancel();

	    test(stat1==KErrCancel);

	    User::WaitForRequest( deathStat );

	    thread.Close();