// Copyright (c) 1997-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:

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include <e32math.h>

#include "fat_utils.h"

#include "t_server.h"

#include "t_chlffs.h"

using namespace Fat_Test_Utils;

RTest test(_L("t_falsespace"));

const TInt KNumberThreads=2;

const TInt KHeapSize=0x2000;

//-- this is taken from the file server. Hardcoded constant that specifies session limits on reserving the drive space

const TInt KMaxSessionDriveReserved	=0x10000; 

static TInt RsrvSpaceThread(TAny* aArg);

static TInt SessCloseThread(TAny* aArg);

static void GetFreeDiskSpace(TInt64 &aFree);

TInt gCount;		//count of files used to fill up the disk

TInt gTestDrive;	//drive number of the drive currently being tested

TChar gCh;

_LIT(KBasePath,"\\F32-TST\\FILLDIR\\");

_LIT(KBaseName,"\\F32-TST\\FILLDIR\\FILE");

_LIT(KTestFile,"?:\\test.txt");

_LIT8(KTestData, "12345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678");

_LIT(KDir, "?:\\adodgydir\\");

_LIT(KDrv,"?:\\");	

_LIT(KNewName,"?:\\newname.txt");

void FormatDrive()

{

    TInt nRes;

    #if 0

    //-- FAT32 SPC:1; for the FAT32 testing on the emulator 

    TFatFormatParam fp;

    fp.iFatType = EFat32;

    fp.iSecPerCluster = 1;

	nRes = FormatFatDrive(TheFs, gTestDrive, ETrue, &fp);	

    #else

    nRes = FormatFatDrive(TheFs, gTestDrive, ETrue);	

    #endif

    test_KErrNone(nRes);

}

void SynchronousClose(RFs &aSession)

	{

	TRequestStatus s;

	aSession.NotifyDestruction(s);

	test(s.Int()==KRequestPending);

	aSession.Close();

	User::WaitForRequest(s);

	}

//-----------------------------------------------------------------------------

/**

    Get a cluster size for the currently mounted FS (if it supports clusters). 

    @return 0 if there was an error (e.g. cluster size query is not supported), otherwise a cluster size

*/

static TUint32 FsClusterSize()

{

    TVolumeIOParamInfo volIop;

    TInt nRes = TheFs.VolumeIOParam(gTestDrive, volIop);

    if(nRes != KErrNone || volIop.iClusterSize < 512 || !IsPowerOf2(volIop.iClusterSize))

        {

        test.Printf(_L("FsClusterSize() The FS hasn't reported a cluster size\n"));

        return 0;

        }

    return volIop.iClusterSize;

}

static TInt CreateFileX(const TDesC& aBaseName,TInt aX, TInt aFileSize)

//

// Create a large file. Return KErrEof or KErrNone

//

	{

	TBuf<128> fileName=aBaseName;

	fileName.AppendNum(aX);

	RFile file;

	TInt r=file.Replace(TheFs,fileName,EFileWrite);

	if (r==KErrDiskFull)

		return(r);

	if (r!=KErrNone)

		{

		test.Printf(_L("ERROR:: Replace returned %d\n"),r);

		test(0);

		return(KErrDiskFull);

		}

	if (!IsTestingLFFS())

		r=file.SetSize(aFileSize);

	else

		{

    	TBuf8<1024> testdata(1024);

    	TInt count=(aFileSize/testdata.Length());

    	r=KErrNone;

    	while (count-- && r==KErrNone) 

        	r=file.Write(testdata);

		}

	if (r==KErrDiskFull)

		{

		file.Close();

		return(r);

		}

	if (r!=KErrNone)

		{

		test.Printf(_L("ERROR:: SetSize/Write returned %d\n"),r);

		test(0);

		//test.Getch();

		file.Close();

		return(KErrDiskFull);

		}

	file.Close();

	test.Printf(_L("Created file %d size %d\n"),aX,aFileSize);

	return(KErrNone);

	}

LOCAL_C TInt DeleteFileX(const TDesC& aBaseName,TInt aX)

//

// Delete a large file

//

	{

	TBuf<128> fileName=aBaseName;

	fileName.AppendNum(aX);

	return TheFs.Delete(fileName);

	}

static void FillUpDisk()

//

// Test that a full disk is ok

//

	{

	test.Next(_L("Fill disk to capacity\n"));

	TInt r=TheFs.MkDirAll(KBasePath);

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

	gCount=0;

	TFileName sessionPath;

	r=TheFs.SessionPath(sessionPath);

	test_KErrNone(r);

	TBuf<128> fileName=KBaseName();

	TInt64 freespace=0;

	TInt64 freespaceBeforeScanDrive = 0;

	TInt64 freespaceAfterScanDrive = 0;

	do

		{

		GetFreeDiskSpace(freespace);

		TInt fillfilesize=0;

		if (I64HIGH(freespace))

			fillfilesize=KMaxTInt;

		else

			fillfilesize=I64LOW(freespace)* 7/8;

		FOREVER

			{

			TInt r=CreateFileX(fileName,gCount,fillfilesize);

			if (r==KErrDiskFull)

				{

				if(fillfilesize <= 2)

					break;

				else

					fillfilesize=fillfilesize/2;

				}

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

			if(r==KErrNone)

				gCount++;

			}

		r=TheFs.CheckDisk(fileName);

		if (r!=KErrNone && r!=KErrNotSupported)

			{

			test.Printf(_L("ERROR:: CheckDisk returned %d\n"),r);

			test(0);

			}

		// Test that scan drive passes on a full disk

		// DEF071696 - KErrCorrupt on Scan Drive 

		GetFreeDiskSpace(freespaceBeforeScanDrive);

		test.Printf(_L("Before ScanDrive freeSpace = %08X:%08X\n"),

			I64HIGH(freespaceBeforeScanDrive), I64LOW(freespaceBeforeScanDrive));

		r = TheFs.ScanDrive(fileName);

		if (r!=KErrNone && r!=KErrNotSupported)

			{

			test.Printf(_L("ScanDrive returned %d\n"), r);

			test(0);

			}

		GetFreeDiskSpace(freespaceAfterScanDrive);

		test.Printf(_L("After ScanDrive freeSpace = %08X:%08X\n"),

			I64HIGH(freespaceAfterScanDrive), I64LOW(freespaceAfterScanDrive));

		}

		while (freespaceBeforeScanDrive != freespaceAfterScanDrive );

	gCount--;

	}

static void GetFreeDiskSpace(TInt64 &aFree)

//

//	Get free disk space

//

	{

	TVolumeInfo v;

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

	test_KErrNone(r);

	aFree=v.iFree;

	}

static void Test1()

//

//	Test the API fundamentaly works for one session

//

	{

	test.Next(_L("Test Disk Space reserve APIs\n"));

	TInt r=0;

    FormatDrive();

	TInt64 free2;

	TInt64 free1; 

	TInt64 diff;

	r=TheFs.GetReserveAccess(gTestDrive);

	test_Value(r, r == KErrPermissionDenied);

	//make sure nothing odd happens if we didnt already have access

	r=TheFs.ReleaseReserveAccess(gTestDrive);

	test_KErrNone(r);

	GetFreeDiskSpace(free2);

	r=TheFs.ReserveDriveSpace(gTestDrive,0x1000);

	test_KErrNone(r);

	GetFreeDiskSpace(free1);

	diff = free2 - free1;

	test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100); 

	r=TheFs.GetReserveAccess(gTestDrive);

	test_KErrNone(r);

	GetFreeDiskSpace(free1);

	TInt64 temp = free2-free1;

	test(I64INT(temp)>(-0x90) && I64INT(temp)<0x90);

	r=TheFs.ReleaseReserveAccess(gTestDrive);

	test_KErrNone(r);

	GetFreeDiskSpace(free1);

	diff = free2 - free1;

	test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100);

	//test reallocation of reserved space is possible

	r=TheFs.ReserveDriveSpace(gTestDrive,0x2000);

	test_KErrNone(r);

	//test upper limit of reserved space 

	r=TheFs.ReserveDriveSpace(gTestDrive,0x2000000);

	test_Value(r, r == KErrArgument);

	r=TheFs.ReserveDriveSpace(gTestDrive,0);

	test_KErrNone(r);

	r=TheFs.GetReserveAccess(gTestDrive);

	test_Value(r, r == KErrPermissionDenied);

	//make sure nothing odd happens if we didnt already have access

	r=TheFs.ReleaseReserveAccess(gTestDrive);

	test_KErrNone(r);

	r=TheFs.ReserveDriveSpace(gTestDrive,-45);

	test_Value(r, r == KErrArgument);

	}

static void Test2()

//

//	Test multiple sessions, ensure the drive limit is not exceeded

//	

	{

	test.Next(_L("Test Session and total reserve limits\n"));

    FormatDrive();

	TInt i=0;

	TInt r=0;

	RFs sessions[17];

	TVolumeInfo v;

	//Connect Sessions

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

		{

		r = sessions[i].Connect();

		test_KErrNone(r);

		}

	test.Next(_L("Test breaching sesson reserve limit\n"));

	r=sessions[0].ReserveDriveSpace(gTestDrive,0x10001);

	test_Value(r, r == KErrArgument);

	//Get Volume Free Space

	r = sessions[0].Volume(v, gTestDrive);

	if(v.iFree > 0x100000)

		{

		test.Next(_L("Test breaching drive reserve limit\n"));

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

			{

			r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);

			test_KErrNone(r);

			}

		//The straw

		r=sessions[16].ReserveDriveSpace(gTestDrive,0x10);

		test_Value(r, r == KErrTooBig);

		}

	else

		{

		test.Printf(_L("Drive too small: breaching drive reserve limit test skipped\n"));

		test.Next(_L("Testing exhausting available drive free space instead\n"));

		for(i=0; (v.iFree -= 0x10000) >= 0; i++)

			{

			r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);

			test_KErrNone(r);

			}

		//The straw

		r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);

		test_Value(r, r == KErrDiskFull);

		}

	//Close Sessions

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

		{

		SynchronousClose(sessions[i]);

		}

	}

static void Test3()

//

//	Test session cleanup

//		

	{

	test.Next(_L("Test session close and clean up of resrved space\n"));

	FormatDrive();

	RFs fs1;

	RFs fs2;

	TInt64 free2(0);

	TInt64 free1(0); 

	TInt64 diff(0);

	TInt r=0;

	r = fs1.Connect();

	test_KErrNone(r);

	r = fs2.Connect();

	test_KErrNone(r);

	GetFreeDiskSpace(free1);

	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);

	test_KErrNone(r);

	r=fs2.ReserveDriveSpace(gTestDrive,0x10000);

	test_KErrNone(r);

	GetFreeDiskSpace(free2);

	diff = free1 - free2;

	test(I64INT(diff)>0x1FBD0 && I64INT(diff)<0x21000); 

	SynchronousClose(fs1);

	GetFreeDiskSpace(free2);

	diff = free1-free2;

	test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4); 

	r = fs1.Connect();

	test_KErrNone(r);

	GetFreeDiskSpace(free1);

	diff= free1-free2;

	test(I64INT(diff)== 0 || I64INT(diff)<0xFA0 ); 

	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);

	test_KErrNone(r);

	GetFreeDiskSpace(free2);

	diff = free1 - free2;

	test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4); 

	// Make sure no reserve space is allocated

	r=fs1.ReserveDriveSpace(gTestDrive,0);

	test_KErrNone(r);

	r=fs2.ReserveDriveSpace(gTestDrive,0);

	test_KErrNone(r);

	// Now fill up the disk

	FillUpDisk();

	// Should fail as there is no space

	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);

	test_Value(r, r == KErrDiskFull);

	SynchronousClose(fs1);

	SynchronousClose(fs2);

	}

static void Test4()

//

//	Test real out of disk space conditions i.e. properly run out of disk space and try to 

//	reserve an area etc

//	

	{

	test.Next(_L("Test Filling disk and using APIs\n"));

	if(IsTestingLFFS())

		{

		//-- This test is not valid for LFFS, because free space on this FS can change itself because of some internal FS activities

		test.Printf(_L("This test is inconsistent on LFFS\n"));

		return;

		}

    const TInt KThreshold = 0x10000;

    //-- check that the cluster size doesn't exceed the max. limit

    const TInt KClusterSz = FsClusterSize();

    if(KClusterSz > KThreshold)

        {

        test.Printf(_L("The cluster size(%d) is bigger than threshold to test (%d)! Skipping the test!\n"), KClusterSz, KThreshold);

		return;

		}

    FormatDrive();

	RFs fs;

	TInt r=fs.Connect();

	test_KErrNone(r);

	TInt64 freeA(0);

	TInt64 freeB(0);

	RFile file;

									//start with known amount of space

	//create a single file to use for futher tests

	TBuf<20> buf;

	buf=KTestFile;

	buf[0]=(TUint16)gCh;

	r=file.Replace(fs, buf, EFileWrite);

	test_KErrNone(r);

	r=file.Write(KTestData());

	test_KErrNone(r);

	file.Close();

	r=fs.ReserveDriveSpace(gTestDrive,KThreshold);		//reserve some disk space

	test_KErrNone(r);

	FillUpDisk();									//fill up the disk

	TVolumeInfo v;									//get disk space

	r=fs.Volume(v,gTestDrive);

	test_KErrNone(r);

	freeA=v.iFree;

	r=fs.GetReserveAccess(gTestDrive);				//get access to reserve space

	test_KErrNone(r);