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

//

//

#define __E32TEST_EXTENSION__

#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_KErrNone(r);

	return(v.iFree);

	}

LOCAL_C TInt64 DiskSize(TInt aDrive)

//

//

//

	{

	TVolumeInfo v;

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

	test_KErrNone(r);

	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_Value(r, r == KErrNone || r==KErrNotFound);

	TInt64 freeSpace = FreeDiskSpace(aDrive);

	RFile file;

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

	test_KErrNone(r);

	r = file.Write(TheBuffer,1);

	test_KErrNone(r);

	file.Close();

	TInt64 newSpace = FreeDiskSpace(aDrive);

	r = TheFs.Delete(KTestFile1);

	test_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

#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_Value(r, r == KErrNone || r==KErrAlreadyExists);

	r=TheFs.Delete(KFileFiller);

	test_Value(r, r == KErrNone || r==KErrNotFound);

	r=TheFs.Delete(KTestFile1);

	test_Value(r, r == KErrNone || r==KErrNotFound);

	r=TheFs.Delete(KTestFile2);

	test_Value(r, r == KErrNone || r==KErrNotFound);

	r=TheFs.RmDir(KTestDir1);

	test_Value(r, r == KErrNone || r==KErrNotFound);

	r=TheFs.RmDir(KTestDir2);

	test_Value(r, 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_KErrNone(r);

			}

		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_KErrNone(r);

			}

		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_KErrNone(r);

			break;

		case ETaskRmDir: break;

		case ETaskDelete: break;

		case ETaskReplace:

			r=TheFs.Delete(KTestFile2);

			test_KErrNone(r);

			break;

		case ETaskFileReplace:

			r=TheFs.Delete(KTestFile1);

			test_KErrNone(r);

			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_KErrNone(r);

			break;

		case ETaskDelete:

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

			test_KErrNone(r);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize1);

				test_KErrNone(r);

				}

			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_KErrNone(r);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize1);

				test_KErrNone(r);

				}

			else

				{

				WriteToFile( file, KFileSize2 );

				}

			file.Close();

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

			test_KErrNone(r);

			if( !LffsDrive )

				{

				r=file2.SetSize(KFileSize3);

				test_KErrNone(r);

				}

			else

				{

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

				}

			file2.Close();

			break;

		case ETaskFileReplace:

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

			test_KErrNone(r);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize3*2);

				}

			else

				{

				WriteToFile( file, KFileSize3 );

				}

			test_KErrNone(r);

			file.Close();

			break;

		case ETaskFileWrite:

		case ETaskFileWrite4KB:

		case ETaskFileWrite64KB:

		case ETaskFileSetSize:

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

			test_KErrNone(r);

			file.Close();

			break;

		case ETaskNoChange1:

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

			test_KErrNone(r);

			if( !LffsDrive )

				{

				r=file.SetSize(KFileSize1);

				test_KErrNone(r);

				}

			else

				{

				WriteToFile( file, KFileSize1 );

				}

			file.Close();

			break;

		case ETaskNoChange2:

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

			test_KErrNone(r);

			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_KErrNone(r);

	r=fs.SetSessionPath(gSessionPath);

	test_KErrNone(r);

	TThreadTask task=*(TThreadTask*)&aThreadTask;

	RFile file;

	switch(task)

		{

		case ETaskMkDir:

			r=fs.MkDir(KTestDir1);

			test_KErrNone(r);

			break;

		case ETaskRmDir:

			r=fs.RmDir(KTestDir1);

			test_KErrNone(r);

			break;

		case ETaskDelete:

			r=fs.Delete(KTestFile1);

			test_KErrNone(r);