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

     }