// 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());

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