// Copyright (c) 1999-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\fsstress\t_soak1.cpp

// Suggestions for future improvements: The createVerifyFileX method uses local 

// RBufs for writing and reading. By making these buffers global (at least the 

// write buffers), the overhead of allocating and filling memory can be avoided.

// 

//

#include <f32file.h>

#include <e32test.h>

#include "t_chlffs.h"

#include "t_server.h"

#define __TESTING_LFFS__

LOCAL_D TInt gDriveNumber;

const TInt KMaxNumberThreads     = 4;

const TInt KHeapSize             = 0x600000;

const TInt KDiskUnitThreshold    = 0x1000000; // if disk metrics are above threshold, display in MB rather than KB

const TInt KNotificationInterval = 10 * 1000000;

const TInt KMaxSizeArray         = 3;

const TInt KMaxFilesPerDirectory = 100;

struct TTestMetrics

	{

	TInt SizeArray[KMaxSizeArray][5];

	TInt KSpaceRequiredForMakeAndDelete;

	TInt KFillDiskFileSize;

	};

///#define SINGLE__THREAD

// 256 sectors, 17 sectors+1, 3 bytes, 254 sectors+4, 100 sectors

//  50 sectors, 113 sectors+25, 10 sectors, 103 bytes, 199 sectors+44

// 24 sectors+166, 189 bytes, 225 sectors, 4 sectors+221, 117 sectors+40

LOCAL_D const TTestMetrics DefMetrics =

				{

				{{65536,4353,3,65028,25600},	// Sizearray[0]

				{12800,28953,2560,103,50988},	// Sizearray[1]

				{6310,189,57600,1245,29992}},	// Sizearray[2]

				655360,							// KSpaceRequiredForMakeAndDelete

				65536							// KFillDiskFileSize

				};

// 16 sectors, 1 sectors+1, 3 bytes, 15 sectors+4, 6 sectors

//  3 sectors, 7 sectors+25, 1 sector, 103 bytes, 12 sectors+44

// 2 sectors+166, 189 bytes, 15 sectors, 4 sectors+221, 7 sectors+40

LOCAL_D const TTestMetrics LffsMetrics = 

				{

				{{4096,257,3,3844,1536},		// Sizearray[0]

				{768,1817,256,103,3116},		// Sizearray[1]

				{678,189,3840,1245,1832}},		// Sizearray[2]

				36864,							// KSpaceRequiredForMakeAndDelete

				4096							// KFillDiskFileSize

				};

// 1600 sectors, 100 sectors+100, 1 sector+44, 1501 sectors+144, 600 sectors

// 300 sectors, 709 sectors+196, 100 sectors, 40 sectors+60, 1217 sectors+48

// 264 sectors+216, 73 sectors+212, 486 sectors+84, 715 sectors+160

LOCAL_D const TTestMetrics FAT32Metrics =

				{

				{{409600,25700,300,384400,153600},		// Sizearray[0]

				{76800,181700,25600,10300,311600},		// Sizearray[1]

				{67800,18900,384000,124500,183200}},	// Sizearray[2]

				3686400,								// KSpaceRequiredForMakeAndDelete

				409600									// KFillDiskFileSize

				};

// 8 sectors, 1 sectors+1, 3 bytes, 7 sectors+4, 3 sectors

//  1 sectors, 3 sectors+25, 1 sector, 103 bytes, 6 sectors+44

// 1 sector+166 bytes, 189 bytes, 7 sectors, 2 sectors+221, 3 sectors+40

LOCAL_D const TTestMetrics NandMetrics = 

				{

				{{2048,257,3,1796,768},			// Sizearray[0]

				{256,793,256,103,1580},			// Sizearray[1]

				{422,189,1792,833,808}},		// Sizearray[2]

				20480,							// KSpaceRequiredForMakeAndDelete

				2048							// KFillDiskFileSize

				};

LOCAL_D const TTestMetrics* TheMetrics = 0;

#if defined(__WINS__)

#define WIN32_LEAN_AND_MEAN

#pragma warning (disable:4201) // warning C4201: nonstandard extension used : nameless struct/union

#pragma warning (default:4201) // warning C4201: nonstandard extension used : nameless struct/union

#endif

#if defined(_UNICODE)

	#if !defined(UNICODE)

		#define UNICODE

	#endif

#endif

#ifndef SINGLE__THREAD

	#define REUSE_THREAD

#endif

#ifdef REUSE_THREAD

	LOCAL_D TBool gRequestEnd;

#endif

class TThreadTestInfo

	{

public:

	TInt iCycles;

	TInt iErrors;

	TInt iSizeArrayPos;

	TInt iErrorInfo;

	};

GLDEF_D RTest test(_L("T_SOAK1"));

LOCAL_D TThreadTestInfo ThreadTestInfo[KMaxNumberThreads];

LOCAL_D TBool CurrentlyFillingDisk;

LOCAL_D TInt FillDiskCount;

LOCAL_D TInt FillDiskCycle;

LOCAL_C TInt MakeAndDeleteFilesThread(TAny* anId);

LOCAL_C TInt FillAndEmptyDiskThread(TAny* anId);

LOCAL_C TInt CreateVerifyFileX(const TDesC& aBaseName,TInt aSize,RFs &aFs,TInt aPattern);

LOCAL_C TInt MakeFileName(TInt aThreadId, TInt aFileNumber, RFs & aFs, TFileName& aName, TBool aMakeDir = ETrue);

LOCAL_C TInt AppendPath(TFileName& aPath, TInt aNumber, TInt aLevel);

_LIT( KConnect, "Connect" );

_LIT( KDelete, "Delete" );

_LIT( KDriveToChar, "DriveToChar" );

_LIT( KAppendPath, "AppendPath" );

_LIT( KSetSessPath, "SetSessPath" );

_LIT( KMdAll, "MkdirAll" );

_LIT( KVolInfo, "VolInfo" );

_LIT( KReplace, "Replace" );

_LIT( KRead, "Read" );

_LIT( KWrite, "Write" );

_LIT( KFlush, "Flush" );

_LIT( KDataCompare, "DataCompare" );

_LIT( KMemory, "Memory" );

_LIT( KFilePrefix, "FILE_" );

_LIT(KPath, "?:\\SOAK_TEST\\SESSION%d\\");

LOCAL_C void LogError( TInt aError, const TDesC& aAction, const TDesC& aFileName, TUint a1, TUint a2, TInt line = -1 )

	{

	if(line >= 0)

		{

		_LIT(KFmt, "TSOAK1 ERROR (line %d): %d, file [%S], %S, (0x%x, 0x%x)");

		RDebug::Print(KFmt, line, aError, &aFileName, &aAction, a1, a2);

		}

	else 

		{

		_LIT(KFmt, "TSOAK1 ERROR: %d, file [%S], %S, (0x%x, 0x%x)");

		RDebug::Print(KFmt, aError, &aFileName, &aAction, a1, a2);

		}

	}

LOCAL_C TInt MakeFileName(TInt aThreadId, TInt aFileNumber, RFs & aFs, TFileName& aName, TBool aMakeDir)

//

// creates a file name and makes all the directory components, if required

//

	{

	TFileName path;

	path.Format(KPath, aThreadId);

	TChar driveLetter;

	TInt  r;

	r = aFs.DriveToChar(gDriveNumber, driveLetter);

	if (r != KErrNone)

		{

		LogError(r, KDriveToChar, KNullDesC, driveLetter, 0);

		aFs.Close();

		return(r);

		}

	path[0] = (TText) driveLetter;

	r = aFs.SetSessionPath(path);

	if (r != KErrNone)

		{

		LogError(r, KSetSessPath, path, 0, 0);

		aFs.Close();

		return(r);

		}

	// add additional directories

	TInt fileNumber;

	fileNumber = aFileNumber;

	r = AppendPath(path, fileNumber, 0);

	if(r != KErrNone)

		{

		LogError(r, KAppendPath, path, fileNumber, 0);

		aFs.Close();

		return(r);

		}

	if(aMakeDir)

		{

		r = aFs.MkDirAll(path);

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

			{

			LogError(r, KMdAll, path, 0, 0);

			aFs.Close();

			return(r);

			}

		}

	// and finally add file name

	path.Append(KFilePrefix);

	path.AppendNum(aFileNumber);

	aName = path;

	return(KErrNone);

	}

LOCAL_C TInt AppendPath(TFileName& aPath, TInt aNumber, TInt aLevel)

//

// helper function for MakeFileName()

//

	{

	if(aNumber > KMaxFilesPerDirectory)

		{

		aNumber /= KMaxFilesPerDirectory;

		AppendPath(aPath, aNumber, aLevel + 1);

		}

	if(aLevel)

		{	

		aPath.AppendNum(aNumber % KMaxFilesPerDirectory);	

		aPath.Append('\\');	

		}

	return(KErrNone);

	}

LOCAL_C TInt MakeAndDeleteFilesThread(TAny* anId)

//

// The entry point for the 'MakeAndDeleteFiles' thread.

//

	{

	TInt thrdId=(TInt)anId;

	TInt pattern=(ThreadTestInfo[thrdId].iCycles)%2;

    TInt r;

	RFs f;

	r=f.Connect();

	if (r!=KErrNone)

		{

		LogError( r, KConnect, KNullDesC, 0, 0 );

		ThreadTestInfo[thrdId].iErrorInfo=1;

		return(r);

		}

	TFileName fileName;

	TInt sizeArrayPos = ThreadTestInfo[thrdId].iSizeArrayPos;

#ifdef REUSE_THREAD

	while(!gRequestEnd)

		{

#endif	

		for(TInt i = 0; i < 5; i++)

			{

			// create files

			r = MakeFileName(thrdId, i, f, fileName);

			if(r != KErrNone)

				{

				ThreadTestInfo[thrdId].iErrorInfo=2;

				f.Close();

				return(r);

				}

			r = CreateVerifyFileX(fileName, TheMetrics->SizeArray[sizeArrayPos][0], f, pattern);

			if (r!=KErrNone)

				{

				ThreadTestInfo[thrdId].iErrorInfo=3;

				f.Close();

				return(r);

				}

			// delete selected files at certain points in the cycle

			TInt deleteFile = EFalse;

			switch(i)

				{

				default:

					// nothing to be done

				break;

				case 2:

					// delete file 0

					deleteFile = ETrue;

					r = MakeFileName(thrdId, 0, f, fileName, EFalse);

				break;

				case 3:

					// delete file 1

					deleteFile = ETrue;

					r = MakeFileName(thrdId, 1, f, fileName, EFalse);

				break;

				}

				if(deleteFile)

					{

					// check MakeFileName() error code

					if(r != KErrNone)

						{

						ThreadTestInfo[thrdId].iErrorInfo = 4;

						f.Close();

						return(r);

						}

					// and delete file

					r = f.Delete(fileName);

					if(r != KErrNone)

						{

						ThreadTestInfo[thrdId].iErrorInfo = 5;

						f.Close();

						return(r);

						}

					}

			}

		sizeArrayPos++;

		if(sizeArrayPos >= KMaxSizeArray)

			{

			sizeArrayPos = 0;

			}

		ThreadTestInfo[thrdId].iSizeArrayPos=sizeArrayPos;

#ifdef REUSE_THREAD

	ThreadTestInfo[thrdId].iCycles++;

	pattern = (ThreadTestInfo[thrdId].iCycles) % 2;

	}

#endif

	f.Close();

	return(KErrNone);

	}

LOCAL_C TInt FillAndEmptyDiskThread(TAny* anId)

//

// The entry point for the 'FillAndEmptyDisk' thread.

//

	{

	TInt thrdId=(TInt)anId;

	TInt pattern=(ThreadTestInfo[thrdId].iCycles)%2;

    TInt r;

	RFs f;

	r=f.Connect();

	if (r!=KErrNone)

		{

		LogError( r, KConnect, KNullDesC, 0, 0 );

		ThreadTestInfo[thrdId].iErrorInfo=6;

		return(r);

		}

	TInt i;

#ifdef REUSE_THREAD

	while(!gRequestEnd)

		{

#endif	

		for (i=0;i<5;i++) // Create/Delete 5 files each time

			{

			if (CurrentlyFillingDisk)

				{

				TVolumeInfo v;

				r=f.Volume(v,gDriveNumber);

				if (r!=KErrNone)

					{

					ThreadTestInfo[thrdId].iErrorInfo=7;

					LogError( r, KVolInfo, KNullDesC, gDriveNumber, 0);

					f.Close();

					return(r);

					}

				if (v.iFree<=(TheMetrics->KSpaceRequiredForMakeAndDelete+TheMetrics->KFillDiskFileSize))

					CurrentlyFillingDisk=EFalse;

				else

					{

					TFileName fileName;

					r = MakeFileName(thrdId, FillDiskCount, f, fileName);

					if(r != KErrNone)

						{

						ThreadTestInfo[thrdId].iErrorInfo = 8;

						f.Close();

						return(r);

						}			

					r = CreateVerifyFileX(fileName, TheMetrics->KFillDiskFileSize, f, pattern);

					if (r!=KErrNone)

						{

						ThreadTestInfo[thrdId].iErrorInfo=9;

						f.Close();

						return(r);

						}

					FillDiskCount++;

					}

				}

			else

				{

				if (FillDiskCount<=0)

					{

					CurrentlyFillingDisk=ETrue;

					FillDiskCount=0;

					FillDiskCycle++;

					}

				else

					{

					FillDiskCount--;

					TFileName fileName;

					r = MakeFileName(thrdId, FillDiskCount, f, fileName, EFalse);

					if(r != KErrNone)

						{

						ThreadTestInfo[thrdId].iErrorInfo = 10;

						f.Close();

						return(r);

						}

					r = f.Delete(fileName);				

					if (r!=KErrNone)

						{

						ThreadTestInfo[thrdId].iErrorInfo=11;

						LogError(r, KDelete, fileName,FillDiskCount, 0);

						f.Close();

						return(r);

						}

					}

				}

			}

#ifdef REUSE_THREAD

		ThreadTestInfo[thrdId].iCycles++;

		pattern = (ThreadTestInfo[thrdId].iCycles) % 2;

		}			

#endif

	f.Close();

	return(KErrNone);

	}

const TInt KCreateFileBufSize = 0x80000; 

LOCAL_C TInt CreateVerifyFileX(const TDesC& aFileName, TInt aSize, RFs& aFs, TInt aPattern)

//

// Create and verify a file.

//

	{

	// Note, the directory structure is provided by MakeFileName(). Hence it 

	// is assumed at this point that the path to the file exists already.

	RFile file;

	TInt r;

	r = file.Replace(aFs, aFileName, EFileWrite);

	if (r!=KErrNone)

		{

		LogError( r, KReplace, aFileName, EFileWrite, 0 );

		return(r);

		}

	// Grow it to the specified size by writing a pattern buffer to it

	// Alternate the pattern buffer each time

	RBuf8 wBuf;

	r = wBuf.CreateMax(KCreateFileBufSize);

	if(r != KErrNone)

		{

		LogError(r, KMemory, aFileName, 0, 0, __LINE__);

		wBuf.Close();

		file.Close();

		return(r);

		}

	TInt i;

	if (aPattern)

		{

		// ascending pattern

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

			{			

			wBuf[i] = (TUint8) i;			

			}

		}

	else

		{

		// descending pattern

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

			{

			wBuf[i] = (TUint8) ((KCreateFileBufSize - 1) - i);

			}

		}

	TInt pos;

	TInt chunkSize;

	TInt sectorCount = 0;

	for (pos = 0; pos < aSize; pos += chunkSize)

		{

		wBuf[0]=(TUint8)i;	// Insert sector count

		chunkSize = Min((aSize-pos), KCreateFileBufSize);

		r = file.Write(pos, wBuf, chunkSize);

		if (r != KErrNone)

			{

			LogError(r, KWrite, aFileName, pos, chunkSize, __LINE__);

			file.Close();

			wBuf.Close();

			return(r);

			}

		sectorCount++;

		}

	// Flush it

	r=file.Flush();

	if (r!=KErrNone)

		{

		LogError( r, KFlush, aFileName, 0, 0, __LINE__);

		file.Close();

		wBuf.Close();

		return(r);

		}

//	Test still works if this is commented out just doesn't verify

	// Read back and verify it

	RBuf8 rBuf;

	r = rBuf.CreateMax(KCreateFileBufSize);

	if(r != KErrNone)

		{

		LogError( r, KMemory, aFileName, 0, 0, __LINE__);

		file.Close();

		wBuf.Close();

		rBuf.Close();

		return(KErrGeneral);

		}

	for (pos = 0;pos < aSize; pos += chunkSize)

		{

		chunkSize = Min((aSize-pos), KCreateFileBufSize);

		r = file.Read(pos, rBuf, chunkSize);

		if (r != KErrNone)

			{

			LogError(r, KRead, aFileName, pos, 0, __LINE__);

			file.Close();

			wBuf.Close();

			rBuf.Close();

			return(r);

			}

		wBuf[0] = (TUint8) i; // Insert sector count

		wBuf.SetLength(chunkSize);

		r = rBuf.Compare(wBuf);

		if (r != 0)

			{

			LogError(r, KDataCompare, aFileName, 0, 0, __LINE__);

			file.Close();

			wBuf.Close();

			rBuf.Close();

			return(KErrGeneral);

			}

		}

//

	file.Close();

	wBuf.Close();

	rBuf.Close();

	return(KErrNone);

	}

#ifdef SINGLE__THREAD

LOCAL_C void DoTests()

//

//  single thread

//

    {

	TInt r=KErrNone;

	test.Next(_L("Start continuous file Write/Read/Verify operation"));

	RThread t[KMaxNumberThreads];

	TRequestStatus tStat[KMaxNumberThreads];

	TInt i=0;

	TName threadName;

	TRequestStatus kStat=KRequestPending;

	test.Console()->Read(kStat);

	ThreadTestInfo[i].iCycles=0;

	ThreadTestInfo[i].iErrors=0;

	ThreadTestInfo[i].iSizeArrayPos=(i%KMaxSizeArray);

	ThreadTestInfo[i].iErrorInfo=0;

	if (i<(KMaxNumberThreads-1))

		{

		threadName.Format(_L("MakeAndDeleteFiles%d"),i);

    	r=t[i].Create(threadName,MakeAndDeleteFilesThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

		}

	else

		{

		// Last thread fills/empties disk

		threadName.Format(_L("FillAndEmptyDisk%d"),i);

    	r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

		}

	if (r!=KErrNone)

		test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);

	test(r==KErrNone);

	t[i].Logon(tStat[i]);

	t[i].Resume();

	CurrentlyFillingDisk=ETrue;

	FillDiskCount=0;

    TInt totalTime=0;

    TTime startTime;

    TTime time;

    startTime.UniversalTime();

	TInt ypos=test.Console()->WhereY();

	FOREVER

		{

		User::WaitForAnyRequest();

		if (kStat!=KRequestPending)

			{

    		t[i].LogonCancel(tStat[i]);

			User::WaitForRequest(tStat[i]);

			break;

			}

		else

			{

			TBool threadFinished=EFalse;

			if (tStat[i]!=KRequestPending && !threadFinished)

				{

				t[i].Close();

				(ThreadTestInfo[i].iCycles)++;

				if (tStat[i]!=KErrNone)

					(ThreadTestInfo[i].iErrors)++;

				threadFinished=ETrue;

				// Launch another thread

				TInt threadNameId=((ThreadTestInfo[i].iCycles)%2)?(i+KMaxNumberThreads):i; // Alternate thread name

				threadName.Format(_L("FillAndEmptyDisk%d"),threadNameId);

   				r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

				if (r!=KErrNone)

					test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);

    			test(r==KErrNone);

    			t[i].Logon(tStat[i]);

				t[i].Resume();

				}

			test.Console()->SetPos(0,(ypos+i));

			test.Printf(_L("Thread(%d): % 4d errors in % 4d cycles (%d)\r\n"),i,ThreadTestInfo[i].iErrors,ThreadTestInfo[i].iCycles,ThreadTestInfo[i].iErrorInfo);

			if (!threadFinished)

				{

				test.Printf(_L("Semaphore death"));

				break;

				}

			TVolumeInfo v;

			r=TheFs.Volume(v,gDriveNumber);

			test(r==KErrNone);

			test.Console()->SetPos(0,(ypos+KMaxNumberThreads));

			test.Printf(_L("Free space on disk: %u K(of %u K)\r\n"),(v.iFree/1024).Low(),(v.iSize/1024).Low());

            TTimeIntervalSeconds timeTaken;

            time.UniversalTime();

            r=time.SecondsFrom(startTime,timeTaken);

            test(r==KErrNone);

            totalTime=timeTaken.Int();

            TInt seconds = totalTime % 60;

            TInt minutes = (totalTime / 60) % 60;

            TInt hours   = (totalTime / 3600) % 24;

            TInt days    = totalTime / (60 * 60 * 24);

            test.Printf(_L("Elapsed Time: %d d %02d:%02d:%02d\r\n"), days, hours, minutes, seconds);

			}

		}

    }

#else 

LOCAL_C void DoTests()

//

//  multiple threads

//

    {

	TInt r=KErrNone;

	test.Next(_L("Start continuous file Write/Read/Verify operation"));

	RThread t[KMaxNumberThreads];

	TRequestStatus tStat[KMaxNumberThreads];

	TInt i=0;

	TName threadName;

	TRequestStatus kStat=KRequestPending;

	test.Console()->Read(kStat);

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

		{

		ThreadTestInfo[i].iCycles=0;

		ThreadTestInfo[i].iErrors=0;

		ThreadTestInfo[i].iSizeArrayPos=(i%KMaxSizeArray);

		ThreadTestInfo[i].iErrorInfo=0;

		if (i<(KMaxNumberThreads-1))

			{

			threadName.Format(_L("MakeAndDeleteFiles%d"),i);

	    	r=t[i].Create(threadName,MakeAndDeleteFilesThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

			}

		else

			{

			// Last thread fills/empties disk

			threadName.Format(_L("FillAndEmptyDisk%d"),i);

	    	r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

			}

		if (r!=KErrNone)

   			test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);

	    test(r==KErrNone);

	    t[i].Logon(tStat[i]);

		t[i].Resume();

		}

	CurrentlyFillingDisk=ETrue;

	FillDiskCount=0;

    TInt totalTime = 0;

    TTime cycleTime;

    TTime startTime;

    TTime time;

    startTime.UniversalTime();

    cycleTime.UniversalTime();

	TVolumeInfo v;

	r=TheFs.Volume(v,gDriveNumber);

	test(r==KErrNone);

//	TInt initialFreeSpace = I64LOW(v.iFree / 1024);

#ifdef __LIMIT_EXECUTION_TIME__

	RTimer timer;

	timer.CreateLocal();

	TRequestStatus reqStat;

	timer.After(reqStat,60000000); // After 60 secs

#endif

#ifdef REUSE_THREAD

	RTimer displayTimer;

	displayTimer.CreateLocal();

	TRequestStatus displayStat;

	displayTimer.After(displayStat, KNotificationInterval); // after 10 secs

#endif

	TInt ypos=test.Console()->WhereY();

	FOREVER

		{

		User::WaitForAnyRequest();

		if (kStat!=KRequestPending)

			{

			// user requested to end - let threads die

#ifdef REUSE_THREAD				

			gRequestEnd = ETrue;

#endif			

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

				{

				User::WaitForRequest(tStat[i]);

				}

			break;

			}

#ifdef __LIMIT_EXECUTION_TIME__

		else if (reqStat != KRequestPending)

			{

			// max execution exceeded - wait for threads to die

			TInt totalCycles = 0;

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

				{

				totalCycles+= ThreadTestInfo[i].iCycles;

				}

			test.Printf(_L("Total cycles = %d\r\n"), totalCycles);

			test.Printf(_L("Waiting for thread death...\r\n"));

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

				{

				User::WaitForRequest(tStat[i]);

				}

			break;

			}

#endif

		else

			{

			// other notification

			TBool threadFinished=EFalse;

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

				{

				if (tStat[i]!=KRequestPending && !threadFinished)

					{

					t[i].Close();

					(ThreadTestInfo[i].iCycles)++;

					if (tStat[i]!=KErrNone)

						(ThreadTestInfo[i].iErrors)++;

					threadFinished=ETrue;

					// Launch another thread

					TInt threadNameId=((ThreadTestInfo[i].iCycles)%2)?(i+KMaxNumberThreads):i; // Alternate thread name

					if (i<(KMaxNumberThreads-1))

						{

						threadName.Format(_L("MakeAndDeleteFiles%d"),threadNameId);

	    				r=t[i].Create(threadName,MakeAndDeleteFilesThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

						}

					else

						{

						// Last thread fills/empties disk

						threadName.Format(_L("FillAndEmptyDisk%d"),threadNameId);

	    				r=t[i].Create(threadName,FillAndEmptyDiskThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)i);

						}

					if (r!=KErrNone)

   						test.Printf(_L("Error(%d) creating thread(%d)\r\n"),r,i);

	    			test(r==KErrNone);

	    			t[i].Logon(tStat[i]);

					t[i].Resume();

					}

				test.Console()->SetPos(0,(ypos+i));

   				test.Printf(_L("Thread(%d): % 4d errors in % 4d cycles (%d)\r\n"),i,ThreadTestInfo[i].iErrors,ThreadTestInfo[i].iCycles,ThreadTestInfo[i].iErrorInfo);

				}

#ifdef REUSE_THREAD

			if(displayStat != KRequestPending)

				{

				// re-request notification

				displayTimer.After(displayStat, KNotificationInterval);

				}

			else if (!threadFinished)

				{

				test.Printf(_L("Semaphore death"));

				break;

				}

#else 

			if (!threadFinished)

				{

				test.Printf(_L("Semaphore death"));

				break;

				}

#endif					

			r=TheFs.Volume(v,gDriveNumber);

			test(r==KErrNone);

			test.Console()->SetPos(0,(ypos+KMaxNumberThreads));

			TInt  freeSpace;

			TInt8 freeSpaceUnit;

			TInt  totalSpace;

			TInt8 totalSpaceUnit;

			// switch t

			if(v.iFree > KDiskUnitThreshold)

				{

				// display in MB

				freeSpace = I64LOW(v.iFree / (1024 * 1024));

				freeSpaceUnit = 'M';

				}

			else

				{

				// display in KB

				freeSpace = I64LOW(v.iFree/1024);

				freeSpaceUnit = 'K';

				}

			if(v.iSize > KDiskUnitThreshold)

				{

				// display in MB

				totalSpace = I64LOW(v.iSize / (1024 * 1024));

				totalSpaceUnit = 'M';

				}

			else

				{

				// display in KB

				totalSpace = I64LOW(v.iSize/1024);

				totalSpaceUnit = 'K';

				}

			test.Printf(_L("Free space on disk: %u %cB (of %u %cB)\r\n"), 

						freeSpace, freeSpaceUnit, totalSpace, totalSpaceUnit);

            TTimeIntervalSeconds timeTaken;

            time.UniversalTime();            

            r=time.SecondsFrom(startTime,timeTaken);

            test(r==KErrNone);

            totalTime=timeTaken.Int();

            TInt seconds = totalTime % 60;

            TInt minutes = (totalTime / 60) % 60;

            TInt hours   = (totalTime / 3600) % 24;

            TInt days    = totalTime / (60 * 60 * 24);

            test.Printf(_L("Elapsed Time (%d): %d d %02d:%02d:%02d\r\n"), FillDiskCycle, days, hours, minutes, seconds);

            if(CurrentlyFillingDisk)

            	{

            	// work out ETA to full disk

	            r = time.SecondsFrom(cycleTime, timeTaken);

    	        if((r == KErrNone) && (v.iSize > v.iFree))

    	        	{

		            	totalTime = (TInt) ((v.iFree/1024 * (TInt64) timeTaken.Int()) / (v.iSize/1024 - v.iFree/1024));

		    	        seconds = totalTime % 60;

    		    	    minutes = (totalTime / 60) % 60;

        		    	hours   = (totalTime / 3600) % 24;

	            		days    = totalTime / (60 * 60 * 24);

    	        		test.Printf(_L("ETA to full disk: %d d %02d:%02d:%02d\r\n"), days, hours, minutes, seconds);

        	    	}

            	}

            else 

            	{

            	// currently emptying disk, update time metrics

            	cycleTime.UniversalTime();

            	}            	

			}

			test.Printf(_L("\n"));

		}

    }

#endif

GLDEF_C void CallTestsL()

//

// Call all tests

//

    {

	TInt r = TheFs.CharToDrive( gSessionPath[0], gDriveNumber );

	test( KErrNone == r );

	// select appropriate metrics table

	if(IsFileSystemFAT32(TheFs, gDriveNumber)) 

		{

		TheMetrics = &FAT32Metrics;

		RDebug::Printf("Using FAT32 metrics\r\n");

		}

	else if(IsTestingLFFS())

		{

		TheMetrics = &LffsMetrics;

		RDebug::Printf("Using LFFS metrics\r\n");

		}

	else

		{

		TDriveInfo driveInfo;

		r=TheFs.Drive(driveInfo, gDriveNumber);

		test(r==KErrNone);

		if((driveInfo.iType==EMediaNANDFlash) && !(driveInfo.iMediaAtt & KMediaAttWriteProtected))

			{

			TheMetrics = &NandMetrics;

			RDebug::Printf("Using NAND metrics\r\n");

			}

		else 

			{

			TheMetrics = &DefMetrics;

			RDebug::Printf("Using default metrics\r\n");

			}

		}

	FillDiskCycle = 1;

#ifdef REUSE_THREAD

	gRequestEnd = EFalse;

#endif

	DoTests();

    }