// 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\server\t_CHECKDISK.cpp
//
//
#define __E32TEST_EXTENSION__
#include <f32file.h>
#include <e32test.h>
//#include <e32svr.h>
//#include <f32dbg.h>
#include "t_server.h"
//#include <e32twin.h>

RTest test(_L("T_CHECKDISK"));

RFs TheFs;
TInt gDrive;
TFileName gSessionPath;
TChar gDriveToTest;


HBufC8* gBuf = NULL;
TPtr8 gBufReadPtr(NULL, 0);
HBufC8* gBufSec = NULL;
TPtr8 gBufWritePtr(NULL, 0);

const TInt KOneK = 1024;
const TInt KOneMeg = KOneK * 1024;
const TInt KBlockSize = KOneK * 129 ;
const TInt KWaitRequestsTableSize = 70;

TInt gBigFileSize = 0;
TInt gSmallFileSize = 0;
TInt64 gMediaSize = 0;
TBool gSkip=EFalse;
TInt writeSize = KBlockSize;
TInt seekSize = 0;
TSeek seekType = ESeekAddress;
TInt reduceSize = 0;

TTimeIntervalMicroSeconds32 gTimeTakenBigFile(0);
TBuf16<45> gSmallFile, gBigFile;
LOCAL_D TInt gNextFile=0;
TTime gTime1;
TTime gTime2;

LOCAL_D RSemaphore gSync;

// Concurrent Threads
RThread gBig;
RThread gSmall;
LOCAL_D RSemaphore client;
LOCAL_D const TInt KHeapSize=0x4000;
LOCAL_D const TInt KMaxHeapSize=0x100000;
TRequestStatus gStatus[KWaitRequestsTableSize];

enum TTestState
	{
	EThreadWait,
	EThreadSignal,
	ENoThreads
	};

//
// Generates a name of the form FFFFF*<aPos>.TXT (aLong.3)
//
GLDEF_C void FileNameGen(TDes16& aBuffer, TInt aLong, TInt aPos)
	{
	TInt padding;
	TInt i=0;
	TBuf16<10> tempbuf;

	_LIT(KNumber,"%d");
	tempbuf.Format(KNumber,aPos);
	padding=aLong-tempbuf.Size()/2;
	aBuffer=_L("");
	while(i<padding)
		{
		aBuffer.Append('F');
		i++;
		}
	aBuffer.Append(tempbuf);

	_LIT(KExtension1, ".TXT");
	aBuffer.Append(KExtension1);
	}




//
// Expects a drive letter as a parameter
//
LOCAL_C void parseCommandLine()
	{
	TBuf<0x100> cmd;
	User::CommandLine(cmd);
	TLex lex(cmd);
	TPtrC token=lex.NextToken();
	TInt r=0;

	if(token.Length()!=0)
		{
		gDriveToTest=token[0];
		gDriveToTest.UpperCase();
		}
	else
		{
		gDriveToTest='C';
		}

		r=TheFs.CharToDrive(gDriveToTest,gDrive);
		test_KErrNone(r);
		gSessionPath=_L("?:\\F32-TST\\");
		gSessionPath[0]=(TText)gDriveToTest;
		test.Printf(_L("\nCLP=%S\n"),&token);
	}

//
// Fills a buffer with character aC
//
LOCAL_C void FillBuffer(TDes8& aBuffer, TInt aLength, TChar aC)
	{
	test (aBuffer.MaxLength() >= aLength);
	for(TInt i=0; i<aLength; i++)
		{
		aBuffer.Append(aC);
		}
	}

//
// Waits for all the TRequestStatus in status[] to complete
//
LOCAL_C void WaitForAll(TRequestStatus status[], TInt aSize)
	{
	TInt i=0;

	while(i<aSize)
		{
		User::WaitForRequest(status[i++]);
		}
	}


//
// Writes a file synchronously in blocks of aBlockSize size
// this function can be called from another thread, therefore requires its own RTest instance
LOCAL_C TInt WriteFile(RFs& fs, TDes16& aFile, TInt aSize, TInt aBlockSize, TTestState aState)
	{
	RTest test(_L(""));

	TInt r=0;
	RFile fileWrite;

	test(aBlockSize>0);				// Block size must be greater than 0

	if(aState==EThreadWait)
		{
		gSync.Wait();
		}
	r=fileWrite.Replace(fs,aFile,EFileShareAny|EFileWrite);
	test_KErrNone(r);

	TInt j=0;
	while(j<aSize)
		{
		r=fileWrite.Write(gBufWritePtr, writeSize);
		test_KErrNone(r);
		if(seekType)
			{
			r=fileWrite.Seek(seekType, seekSize);
			test_KErrNone(r);

			if (writeSize + reduceSize >= 0)
				writeSize += reduceSize;

			writeSize = Min(writeSize, gBufWritePtr.Length());

			}
		if((j==0)&&(aState==EThreadSignal))
			{
			gSync.Signal();
			}
		j+=aBlockSize;
		}

	fileWrite.Close();

	return KErrNone;
	}

LOCAL_C void IniStatus(TRequestStatus aStatus[], TInt aSize)
	{
	TInt i=0;

	while(i<aSize)
		{
		aStatus[i++]=KRequestPending;
		}
	}

//
// Write big file
// This is a thread function, therefore requires its own RTest instance
LOCAL_C TInt WriteBigFile(TAny* )
	{
	RTest test(_L(""));
	RFs fs;
	TInt r=fs.Connect(gDriveToTest);
	test_KErrNone(r);

	r=fs.SetSessionPath(gSessionPath);
	test_KErrNone(r);

	WriteFile(fs, gBigFile, gBigFileSize, KBlockSize, EThreadSignal);
	gTime1.HomeTime();

	client.Signal();
	return ETrue;
	}

//
// Writes a file asynchronously in blocks of aBlockSize size
// this function can be called from another thread, therefore requires its own RTest instance
LOCAL_C void WriteFileAsync(RFs& fs, RFile& aFileWrite, TDes16& aFile, TInt aSize, TInt aBlockSize, TRequestStatus aStatus[])
	{
	RTest test(_L(""));

	TInt r=0;

	test(aBlockSize>0);				// Block size must be greater than 0
	test((aSize%aBlockSize)==0); 	// Ensure the size of the file is a multiple of the block size

	r=aFileWrite.Replace(fs,aFile,EFileShareAny|EFileWrite);
	test_KErrNone(r);

	TInt j=0,i=0;
	while(j<aSize)
		{
		aFileWrite.Write(gBufWritePtr,aStatus[i++]);
		j+=aBlockSize;
		}
	}



//
// Write big file async
// This is a thread function, therefore requires its own RTest instance
LOCAL_C TInt WriteBigFileAsync(TAny* )
	{
	RTest test(_L(""));
	RFs fs;
	TInt r=fs.Connect(gDriveToTest);
	test_KErrNone(r);

	r=fs.SetSessionPath(gSessionPath);
	test_KErrNone(r);


	RFile bigFile;

	IniStatus(gStatus,KWaitRequestsTableSize);
	WriteFileAsync(fs, bigFile, gSmallFile, gBigFileSize, KBlockSize,gStatus);
	gSync.Signal();
	WaitForAll(gStatus, gBigFileSize/KBlockSize);

	return ETrue;
	}

static void TestClientDies()
	{
	test.Next(_L("Client dying unexpectedly"));

	TInt r=0;
	TBuf<20> unit=_L("?:\\");
	unit[0]=(TText)gDriveToTest;

	//-------------------------------------------
	test.Printf(_L("Sync test\n"));

	r=gBig.Create(_L("TEST1"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);

	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Async test\n"));
	r=gSmall.Create(_L("TEST2"),WriteBigFileAsync,KDefaultStackSize*2,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);

	gSmall.Resume();
	gSync.Wait();

	gSmall.Kill(-2);
	gSmall.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing for size not multiple of blocksize\n"));

	writeSize = 5000;
	r=gBig.Create(_L("TEST3"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing with seek current and write inside the file boundary\n"));

	writeSize = 5000;
	seekType = ESeekCurrent;
	seekSize = -5000;
	reduceSize = -3000;
	r=gBig.Create(_L("TEST4"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing with seek current and overwrite entire file\n"));
	writeSize = 5000;
	seekType = ESeekCurrent;
	seekSize = -5000;
	reduceSize = 0;
	r=gBig.Create(_L("TEST5"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing with seek current and write outside the file boundary\n"));

	writeSize = 5000;
	seekType = ESeekCurrent;
	seekSize = -5000;
	reduceSize = 5000;
	r=gBig.Create(_L("TEST6"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing with seek current and write within the file boundary\n"));
	writeSize = 5000;
	seekType = ESeekCurrent;
	seekSize = -3000;
	reduceSize = -4000;
	r=gBig.Create(_L("TEST7"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing with seek current and write exactly to file size\n"));
	writeSize = 5000;
	seekType = ESeekCurrent;
	seekSize = -3000;
	reduceSize = -3000;
	r=gBig.Create(_L("TEST8"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	//-------------------------------------------
	test.Printf(_L("Testing with seek current and write greater than file size\n"));
	writeSize = 5000;
	seekType = ESeekCurrent;
	seekSize = -3000;
	reduceSize = 10000;
	r=gBig.Create(_L("TEST9"),WriteBigFile,KDefaultStackSize,KHeapSize,KMaxHeapSize,NULL);
	test_KErrNone(r);
	gBig.Resume();
	gSync.Wait();

	gBig.Kill(-2);
	gBig.Close();
	User::After(500000);

	r=TheFs.CheckDisk(unit);
	test_Value(r, r == KErrNone || r == KErrNotSupported);

	TInt retries = 0;

	do
		{
		r=TheFs.ScanDrive(unit);
		if (r != KErrNone)
			test.Printf(_L("ScanDrive() returned %d\n"), r);
		if (r == KErrInUse)
			User::After(500000);
		}
	while (r == KErrInUse && ++retries < 5);

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

	}


//---------------------------------------------------------------------
/**
    Test that CheckDisk will not cause stack overflow on very deep directory structure.
*/
void TestCheckDisk_VeryDeepDirectory()
	{
	test.Next(_L("Testing deep dir structure check"));

	TInt nRes;
	TBuf<20> unit=_L("?:\\");
	unit[0]=(TText)gDriveToTest;

	//-- 1. create deep dir structure, like \\0\\1\\2\\...... 90 levels deep
	const TInt KMaxDirDepth = 90;

	test.Printf(_L("Creating directory with %d subdirs.\n"),KMaxDirDepth);

	TFileName fn;
	for(TInt i=0; i<KMaxDirDepth; ++i)
		{
		fn.AppendFormat(_L("\\%d"), i%10);
		}
	fn.Append(_L("\\"));

	nRes = TheFs.MkDirAll(fn);
	test_Value(nRes, nRes == KErrNone || nRes == KErrAlreadyExists);

	//-- 2. invoke Check Disk and ensure that target doesn't die from stack overflow.
	test.Printf(_L("Running Check Disk...\n"));
	nRes = TheFs.CheckDisk(unit);

	test_Value(nRes, nRes == KErrNone || nRes == KErrTooBig);
	}


//---------------------------------------------------------------------
//
// This test tries to read a small file while writing a big one
//
GLDEF_C void CallTestsL()
	{
	TBuf16<45> dir;

	test.Next(_L("Preparing the environmnet\n"));

	FileNameGen(gSmallFile, 8, gNextFile++);
	FileNameGen(gBigFile, 8, gNextFile++);
	dir=gSessionPath;
	dir.Append(gSmallFile);
	gSmallFile=dir;
	dir=gSessionPath;
	dir.Append(gBigFile);
	gBigFile=dir;

	TRAPD(res,gBuf = HBufC8::NewL(KBlockSize+1));
	test(res == KErrNone && gBuf != NULL);

	gBufWritePtr.Set(gBuf->Des());
	FillBuffer(gBufWritePtr, KBlockSize, 'B');

	TRAPD(res2,gBufSec = HBufC8::NewL(KBlockSize+1));
	test(res2 == KErrNone && gBufSec != NULL);
	gBufReadPtr.Set(gBufSec->Des());

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

	TestClientDies();
	TestCheckDisk_VeryDeepDirectory();

	delete gBuf;
	delete gBufSec;
	}

LOCAL_C void DoTests()
	{
 	TInt r=0;

 	r=client.CreateLocal(0);
	test_KErrNone(r);

  	r=gSync.CreateLocal(0);
	test_KErrNone(r);

	r=TheFs.SetSessionPath(gSessionPath);
	test_KErrNone(r);

	r=TheFs.MkDirAll(gSessionPath);
	test_Value(r, r == KErrNone || r == KErrAlreadyExists);

	TheFs.ResourceCountMarkStart();
	TRAP(r,CallTestsL());
	test_KErrNone(r);
	TheFs.ResourceCountMarkEnd();
	}

TBool CheckForDiskSize()
	{
	TVolumeInfo volInfo;
	TInt r = TheFs.Volume(volInfo, gDrive);
	test_KErrNone(r);

	gMediaSize = volInfo.iSize;
	gSmallFileSize = KBlockSize;
	gBigFileSize = KBlockSize*20;
	while(((2*gBigFileSize)+KOneMeg) > gMediaSize )
		{
			gBigFileSize -= (2*KBlockSize);
		}

	if(gBigFileSize< (3*gSmallFileSize))
		return EFalse;
	else
		return ETrue;
	}

void Format(TInt aDrive)
	{

	test.Next(_L("Format"));
	TBuf<4> driveBuf=_L("?:\\");
	driveBuf[0]=(TText)(aDrive+'A');
	RFormat format;
	TInt count;
	TInt r=format.Open(TheFs,driveBuf,EQuickFormat,count);
	test_KErrNone(r);

	while(count)
		{
		TInt r=format.Next(count);
		test_KErrNone(r);
		}
	format.Close();
	}


static TBool IsFAT(RFs &aFsSession, TInt aDrive)
{
	_LIT(KFatName, "Fat");

	TFileName f;
	TInt r = aFsSession.FileSystemName(f, aDrive);
	test_Value(r, r == KErrNone || r == KErrNotFound);
	return (f.CompareF(KFatName) == 0);
}


GLDEF_C TInt E32Main()
	{

	CTrapCleanup* cleanup;
	cleanup=CTrapCleanup::New();

	__UHEAP_MARK;
	test.Title();
	test.Start(_L("Starting tests..."));
	parseCommandLine();

	TInt r = TheFs.Connect();
	test_KErrNone(r);

	TDriveInfo info;
	TVolumeInfo volInfo;
	r=TheFs.Drive(info,gDrive);
	test_KErrNone(r);

	if(info.iMediaAtt&KMediaAttVariableSize)
		{// Not testing in RAM Drives
		test.Printf(_L("Tests skipped in RAM drive\n"));
		goto out;
        }

	r = TheFs.Volume(volInfo, gDrive);
	if (r == KErrNotReady)
		{
		if (info.iType == EMediaNotPresent)
			test.Printf(_L("%c: Medium not present - cannot perform test.\n"), (TUint)gDriveToTest);
		else
			test.Printf(_L("%c: medium found (type %d) but drive not ready\nPrevious test may have hung; else, check hardware.\n"), (TUint)gDriveToTest, (TInt)info.iType);
		}
	else if (r == KErrCorrupt)
		{
		test.Printf(_L("%c: Media corruption; previous test may have aborted; else, check hardware\n"), (TUint)gDriveToTest);
		}
	test_KErrNone(r);

	if(!IsFAT(TheFs, gDrive))
        {
		test.Printf(_L("Tests skipped on non-FAT drive\n"));
		goto out;
        }

	if ((volInfo.iDrive.iMediaAtt & KMediaAttFormattable))
		Format(gDrive);

	if(CheckForDiskSize())
		{
		DoTests();
		if ((volInfo.iDrive.iMediaAtt & KMediaAttFormattable))
		   Format(gDrive);
		}
	else
		{
		test.Printf(_L("Skipping tests due to lack of space to perform them in this unit\n"));
		}
out:
	test.End();

	TheFs.Close();
	test.Close();

	__UHEAP_MARKEND;
	delete cleanup;
	return(KErrNone);
    }