--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/fsstress/t_soak1.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,971 @@
+// 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();
+
+ }
+