// Copyright (c) 1996-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_mount.cpp
// Testing FAT cache performance
//
//
/**
@file
*/
#define __E32TEST_EXTENSION__
#include <f32file.h>
#include <e32test.h>
#include <e32math.h>
#include <e32property.h>
#include "t_server.h"
//#include "t_std.h"
#include "fat_utils.h"
using namespace Fat_Test_Utils;
#ifdef __VC32__
// Solve compilation problem caused by non-English locale
#pragma setlocale("english")
#endif
RTest test(_L("T_FAT_Cache_BM"));
//-- note that this test disables all FAT mount enhancements, like asynchronous mounting and using FSInfo sector.
static void WaitForFatBkGndActivityEnd();
//-------------------------------------------------------------------
//-- debug bit flags that may be set in the property which controls FAT volume mounting
const TUid KThisTestSID={0x10210EB3}; ///< this EXE SID
//const TUint32 KMntProp_EnableALL = 0x00000000; //-- enable all operations
const TUint32 KMntProp_DisableALL = 0xFFFFFFFF; //-- disable all operations
//const TUint32 KMntProp_Disable_FsInfo = 0x00000001; //-- mask for disabling/enabling FSInfo information
//const TUint32 KMntProp_Disable_FatBkGndScan = 0x00000002; //-- mask for disabling/enabling FAT background scanner
//-------------------------------------------------------------------
static TInt gDriveNum=-1; ///< drive number we are dealing with
static TInt64 gRndSeed;
static TFatBootSector gBootSector;
static void DoRemountFS(TInt aDrive);
//-- Array of integer file tars. Tags are used to identify files (the file name is generated by KFnTemplate template)
typedef CArrayFixFlat<TInt> CFileTagsArray;
static CFileTagsArray *pFTagArray = NULL;
//-------------------------------------------------------------------
const TInt KMaxFiles = 1000; //-- maximal number of files to create
//-- number of unfragmented files that will be left, other files will be merged to bigger ones.
const TInt KUnfragmentedFilesLeave = KMaxFiles/10;
_LIT(KDirName, "\\DIR1\\"); //-- directory name we a working with (FAT12/16 won't allow KMaxFiles in the root dir.)
_LIT(KFirstFileName, "\\First_file_1.nul"); //-- the name of the first file on the volume
//-------------------------------------------------------------------
/**
Make a file name by its numeric tag
@param aDes here will be a file name
@param aFileNameTag numeric tag for the file name generation
*/
void MakeFileName(TDes& aDes, TInt aFileNameTag)
{
_LIT(KFnTemplate, "F%d.NUL");//-- file name template, use 8.3 names here in order not to stress dir. cache much.
aDes.Copy(KDirName);
aDes.AppendFormat(KFnTemplate, aFileNameTag);
}
//-------------------------------------------------------------------
/**
format the volume and read the boot sector
*/
static void FormatVolume(TBool aQuickFormat)
{
(void)aQuickFormat;
#ifndef __EPOC32__
test.Printf(_L("This is emulator configuration!!!!\n"));
//-- FAT32 SPC:1; for the FAT32 testing on the emulator
//TFatFormatParam fp;
//fp.iFatType = EFat32;
//fp.iSecPerCluster = 1;
//FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fp); //-- always quick; doesn't matter for the emulator
aQuickFormat = ETrue;
#endif
FormatFatDrive(TheFs, CurrentDrive(), aQuickFormat);
TInt nRes = ReadBootSector(TheFs, gDriveNum, 0x00, gBootSector);
test_KErrNone(nRes);
}
//-------------------------------------------------------------------
/**
Helper method. Does one iteration of merging test files into one fragmented one.
See DoMergeFiles()
@param aFTagArray reference to the file tags array
@param aBigFileNo a sequential number of the result file to be merged from random number of smaller ones (names are taken from the tag array)
@param aTimeTaken_us on return will contain time taken to this operation, in microseconds
@return number of files merged into one.
*/
TInt DoMergeTestFiles(CFileTagsArray& aFTagArray, TInt aBigFileNo, TInt64& aTimeTaken_us)
{
aTimeTaken_us = 0;
TTime timeStart;
TTime timeEnd;
//-- merged files' names start with this number
const TInt KMergedFileFnThreshold = 20000;
const TInt KMaxMergedFiles = 20;
const TInt nFilesToMerge = Max((Math::Rand(gRndSeed) % KMaxMergedFiles), 2); //-- how many files to merge into one
test(aFTagArray.Count() > KMaxMergedFiles);
TInt selectedFTags[KMaxMergedFiles]; //-- here we will store file tags to be merged to one large fragmented file
TInt i;
TInt nRes;
i=0;
do
{
//-- randomly select a file tag from the global array
const TInt index = (TUint)Math::Rand(gRndSeed) % aFTagArray.Count();
const TInt fnTag = aFTagArray[index];
if(fnTag < 0 || //-- no such file, already deleted
fnTag >= KMergedFileFnThreshold) //-- this is a big, already merged file
continue;
selectedFTags[i] = fnTag;
aFTagArray.Delete(index);
++i;
}while(i<nFilesToMerge);
//-- here we have file tags in selectedFNumbers array. delete these files and create one big file
//-- with the equal size. This file will be perfectly fragmented.
//-- search for FAT entries had priority to the right, so delete files in reverse order.
TUint32 newFileSize = 0;
TBuf<128> buf;
RFile file;
timeStart.UniversalTime(); //-- take start time
for(i=0; i<nFilesToMerge; ++i)
{
MakeFileName(buf, selectedFTags[nFilesToMerge-1-i]);
nRes=file.Open(TheFs, buf, EFileRead);
test_KErrNone(nRes);
TInt nSize;
nRes = file.Size(nSize);
test_KErrNone(nRes);
file.Close();
newFileSize+=(TUint32)nSize; //-- this will be the size of the new file
//-- delete small file
nRes = TheFs.Delete(buf);
test_KErrNone(nRes);
}
//-- create a large file taking the place of few smaller. It will be framented.
const TInt bigFileTag = aBigFileNo+KMergedFileFnThreshold;
MakeFileName(buf, bigFileTag);
nRes = CreateEmptyFile(TheFs, buf, newFileSize);
test_KErrNone(nRes);
timeEnd.UniversalTime(); //-- take end time
aTimeTaken_us = (timeEnd.MicroSecondsFrom(timeStart)).Int64();
//-- put new big file name tag to the global array in order not to forget it for later use.
aFTagArray.AppendL(bigFileTag);
return nFilesToMerge;
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0689
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc randomly deletes small files and creates larger. Measures time taken by this FAT fragmentation
//!
//! @SYMTestActions
//! 0 delete a random number of small files
//! 1 create a random number of larger files, measure time taken
//!
//! @SYMTestExpectedResults successful files deletion/creation
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
/**
precondition: We have a lot of (KMaxFiles) files of the same size on the volume. They occupy almost all FAT.
This method randomly selects several files on the volume, deletes them and creates a bigger file that occupies space from the
deleted files. So that we got a fragmented big file. Repeat this until we have KUnfragmentedFilesLeave initial files left on the
volume.
*/
void DoMergeFiles(CFileTagsArray& aFTagArray)
{
test.Next(_L("Merging small files to larger creating FAT fragmentation...\n"));
TInt64 usTotalTime=0;
TInt64 usCurrTime;
TInt nUnfragmentedLeft = aFTagArray.Count();
for(TInt i=0; nUnfragmentedLeft > KUnfragmentedFilesLeave; ++i)
{
nUnfragmentedLeft -= DoMergeTestFiles(aFTagArray, i, usCurrTime);
usTotalTime += usCurrTime;
}
test.Printf(_L("#--> Merging files :%d ms\n"), (TUint32)usTotalTime/K1mSec);
}
//-------------------------------------------------------------------
/**
Randomly shuffles entries in file name tags array.
*/
void ShuffleArray(CFileTagsArray& aFTagArray)
{
const TInt KSwapIterations = 500;
const TInt arrSize = aFTagArray.Count();
for(TInt i = 0; i<KSwapIterations; ++i)
{//-- randomly swap 2 elements in the array
const TInt idx1 = (TUint)Math::Rand(gRndSeed) % arrSize;
const TInt idx2 = (TUint)Math::Rand(gRndSeed) % arrSize;
TInt tmp = aFTagArray[idx1];
aFTagArray[idx1] = aFTagArray[idx2];;
aFTagArray[idx2] = tmp;
}
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0690
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc Measure open and seek time for all files that have tags in aFTagArray.
//!
//! @SYMTestActions
//! 0 remount FS
//! 1 open all files, that have tags in aFTagArray, measure time taken
//! 2 seek to the each file end, measure time taken
//!
//! @SYMTestExpectedResults successful files open/seek
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void MeasureSeekTime(CFileTagsArray& aFTagArray)
{
test.Next(_L("Measuring seek time...\n"));
TInt nRes;
RFile file;
TBuf<128> buf;
TTime timeStart;
TTime timeEnd;
TInt64 usTotalTimeSeek=0;
TInt64 usTotalTimeOpen=0;
const TInt KNumRepetitions = 10;
for(TInt repCnt=0; repCnt<KNumRepetitions; ++repCnt)
{
//-- remount file system, reset caches
DoRemountFS(gDriveNum);
for(TInt i = 0; i<aFTagArray.Count(); ++i)
{
MakeFileName(buf, aFTagArray[i]);
//-- 1. open the file
timeStart.UniversalTime(); //-- take start time
nRes = file.Open(TheFs, buf, EFileRead);
timeEnd.UniversalTime(); //-- take end time
usTotalTimeOpen += (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test_KErrNone(nRes);
//-- 2. goto the end of the file. This operation shall traverse whole file's cluster chain in FAT
timeStart.UniversalTime(); //-- take start time
TInt seekPos = 0;
nRes = file.Seek(ESeekEnd, seekPos);
timeEnd.UniversalTime(); //-- take end time
usTotalTimeSeek += (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test_KErrNone(nRes);
file.Close();
}
}
test.Printf(_L("#--> Total open time for %d files is %d ms\n"), aFTagArray.Count(), (TUint32)usTotalTimeOpen/(K1mSec*KNumRepetitions));
test.Printf(_L("#--> Total seek time for %d files is %d ms\n"), aFTagArray.Count(), (TUint32)usTotalTimeSeek/(K1mSec*KNumRepetitions));
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0692
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc Detetes all files that have name tags in name tags array and measures time taken.
//!
//! @SYMTestActions
//! 0 remount the FS
//! 1 delete files and measure time taken.
//!
//! @SYMTestExpectedResults successful creating files
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void DeleteAllFiles(CFileTagsArray& aFTagArray)
{
TInt nRes;
TBuf<128> buf;
TTime timeStart;
TTime timeEnd;
TInt64 usTotalTime=0;
test.Next(_L("Deleting all files...\n"));
//-- remount file system, reset caches
DoRemountFS(gDriveNum);
for(TInt i = 0; i<aFTagArray.Count(); ++i)
{
MakeFileName(buf, aFTagArray[i]);
timeStart.UniversalTime(); //-- take start time
nRes = TheFs.Delete(buf);
timeEnd.UniversalTime(); //-- take end time
usTotalTime += (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test_KErrNone(nRes);
}
test.Printf(_L("#--> Deleted %d files in %d ms\n"), aFTagArray.Count(), (TUint32)usTotalTime/K1mSec);
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0687
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc Create KMaxFiles files to fill in space in FAT table and measure time taken.
//!
//! @SYMTestActions
//! 0 Create KMaxFiles files and measure time taken.
//!
//! @SYMTestExpectedResults successful creating files
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
/**
Create KMaxFiles files to fill in space in FAT table and measure time taken.
@return EFalse if it is impossible to create test files
*/
TBool DoCreateFiles(CFileTagsArray& aFTagArray)
{
TInt nRes;
TBuf<128> buf;
TTime timeStart;
TTime timeEnd;
TInt64 usTotalTime=0;
test.Next(_L("Creating many files\n"));
test.Printf(_L("Number of files:%d\n"), KMaxFiles);
aFTagArray.Reset();
TVolumeInfo volInfo;
nRes = TheFs.Volume(volInfo, gDriveNum);
test_KErrNone(nRes);
test(gBootSector.IsValid());
const TUint32 clustSz = gBootSector.SectorsPerCluster() * gBootSector.BytesPerSector();
const TUint32 maxClusters = (TUint32)(volInfo.iFree / clustSz);
if(KMaxFiles > 0.8 * maxClusters)
{
test.Printf(_L("Can't create %d files; skipping the test!\n"), KMaxFiles);
return EFalse;
}
//-- adjust file size for very small volumes
TUint32 fillFileSz = (maxClusters/KMaxFiles)*clustSz;
if(fillFileSz*KMaxFiles >= 0.8*volInfo.iFree) //-- take into account the size of the directory with 1000 files.
{
if(fillFileSz <= clustSz)
{
test.Printf(_L("Can't create %d files; skipping the test!\n"), KMaxFiles);
return EFalse;
}
fillFileSz -= clustSz;
}
//-- create the first file on the volume. It will be deleted then in order to create 1 free FAT entry
//-- in the very beginnng of the FAT. So, the size of this file shan't be more that 1 sector/cluster.
nRes = CreateEmptyFile(TheFs, KFirstFileName, 100);
test_KErrNone(nRes);
//-- to avoid affected timings in UREL mode.
WaitForFatBkGndActivityEnd();
//-- disable FAT test utils print out, it affects measured time when we create empty files
EnablePrintOutput(EFalse);
//-- create KMaxFiles files on the volume
for(TInt i=0; i<KMaxFiles; ++i)
{
//-- create empty file
MakeFileName(buf, i);
timeStart.UniversalTime(); //-- take start time
nRes = CreateEmptyFile(TheFs, buf, fillFileSz);
timeEnd.UniversalTime(); //-- take end time
usTotalTime += (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test_KErrNone(nRes);
//-- put its id number to the array.
aFTagArray.AppendL(i);
if((i % 100) == 0)
test.Printf(_L("*"));
}
EnablePrintOutput(ETrue); //-- Enable FAT test utils print out
test.Printf(_L("\n#--> Created %d files in %d ms\n"), KMaxFiles, (TUint32)usTotalTime/K1mSec);
return ETrue;
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0691
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc Check that all FAT copies are the same.
//!
//! @SYMTestActions
//! 0 read all available FAT copies and compare them
//!
//! @SYMTestExpectedResults all FAT copies on the vollume must be the same.
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void CheckFatCopies()
{
test.Next(_L("Comparing FATs...\n"));
TFatBootSector bootSec;
TInt nRes = ReadBootSector(TheFs, gDriveNum, 0x00, bootSec);
test_KErrNone(nRes);
const TInt numFATs = bootSec.NumberOfFats();
if(numFATs < 2)
{//-- only one FAT, nothing to compare with.
test.Printf(_L("The volume has only 1 FAT. Nothing to do.\n"));
return;
}
const TUint32 bytesPerSec = bootSec.BytesPerSector();
const TUint32 posFat1Start = bootSec.FirstFatSector() * bytesPerSec;
const TUint32 fatSize = bootSec.TotalFatSectors() * bytesPerSec;
RBuf8 fatBuf1;
RBuf8 fatBuf2;
nRes = fatBuf1.CreateMax(bytesPerSec);
test_KErrNone(nRes);
nRes = fatBuf2.CreateMax(bytesPerSec);
test_KErrNone(nRes);
//-- read FAT sector by sector comparing all copies
TUint32 currPos = posFat1Start;
for(TUint cntSectors=0; cntSectors<bootSec.TotalFatSectors(); ++cntSectors)
{
//-- read a sector of FAT#0
nRes = MediaRawRead(TheFs, gDriveNum, currPos, bytesPerSec, fatBuf1);
test_KErrNone(nRes);
//-- read the same sector from other copies of FAT and compare with FAT#0
for(TInt currFat=1; currFat<numFATs; ++currFat)
{
nRes = MediaRawRead(TheFs, gDriveNum, (currFat*fatSize + currPos), bytesPerSec, fatBuf2);
test_KErrNone(nRes);
//-- compare the buffer to FAT#0
if(fatBuf1.CompareF(fatBuf2) !=0)
{//-- current FAT is different from FAT0
test.Printf(_L("FAT#%d differs from FAT#0! FAT sector:%d, media Sector:%d\n"), currFat, cntSectors, cntSectors+bootSec.FirstFatSector());
test(0);
}
}
currPos+=bytesPerSec;
}
fatBuf1.Close();
fatBuf2.Close();
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0688
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc Create the file whose FAT entries will go to the end of the FAT table and measure the time taken.
//!
//! @SYMTestActions
//! 0 delete a file in the very beginning of the FAT
//! 1 remount file system
//! 2 create a larger file finishing at the end of FAT, measure time taken
//!
//! @SYMTestExpectedResults successful files creation
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
/**
Create the file whose FAT entries will go to the end of the FAT table and measure the time taken.
preconditions:
1. The FAT table must be almost full already. This is done previously in DoCreateFiles().
2. There shall be a small file in the very beginning of the FAT which this test deletes and remounts the FS.
this will cause "the last known free cluster" in the FAT to be set to the beginning of the FAT.
Then when we create a larger file, whole occupied FAT region will be scanned for the free cluster.
*/
void CreateLastFile()
{
test.Next(_L("Create a file in the end of FAT\n"));
TTime timeStart;
TTime timeEnd;
TInt64 usTotalTime=0;
TInt nRes;
//-- 1. delete the first file on the volume (see KFirstFileName & DoCreateFiles()
//-- it will create free FAT entry in the very beginning.
nRes = TheFs.Delete(KFirstFileName);
test_KErrNone(nRes);
//-- 2. remount file system, reset caches etc. The first known free cluster will be number 2 or 3, because of the point 1.
//-- the rest of the FAT is filled, because we've created plenty of files in the DoCreateFiles()
DoRemountFS(gDriveNum);
//-- 3. create a file that will occupy more that 2 clusters; the 1st cluster of it will be in the very beginning of the FAT,
//-- and the rest will be in the very end of the FAT. Measure the time taken to walk all FAT when searching free entry.
_LIT(KLastFn, "\\last-last.file");
test(gBootSector.IsValid());
const TUint32 clustSz = gBootSector.SectorsPerCluster() * gBootSector.BytesPerSector();
//-- disable FAT test utils print out, it affects measured time
EnablePrintOutput(EFalse);
timeStart.UniversalTime(); //-- take start time
//-- create an empty file, it is supposed to be placed in the very end of FAT (FAT table is almost full because of the
//-- previous test)
nRes = CreateEmptyFile(TheFs, KLastFn, 7*clustSz);
timeEnd.UniversalTime(); //-- take end time
usTotalTime = (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test_KErrNone(nRes);
test.Printf(_L("#--> file at the end of FAT created in %d ms\n"), (TUint32)usTotalTime/K1mSec);
//-- delete the file
nRes = TheFs.Delete(KLastFn);
test_KErrNone(nRes);
EnablePrintOutput(ETrue); //-- Enable FAT test utils print out
}
//-------------------------------------------------------------------
/**
Create 100 directories in the root and measure time
*/
void DoCreateDirsInRoot()
{
test.Next(_L("Measure time to create many directories in the Root.\n"));
if(!Is_Fat32(TheFs, gDriveNum))
{
test.Printf(_L("This test requires FAT32, skipping\n"));
return;
}
TTime timeStart;
TTime timeEnd;
TInt64 usTotalTime=0;
TFileName dirName;
//-- remount file system, reset caches etc. The first known free cluster will be number 2 or 3
DoRemountFS(gDriveNum);
//-- disable FAT test utils print out, it affects measured time
EnablePrintOutput(EFalse);
timeStart.UniversalTime(); //-- take start time
//-- create some subdirectories in the root dir and measure time
const TInt KMaxDirs = 100;
for(TInt i=0; i<KMaxDirs; ++i)
{
dirName.Format(_L("\\directory%04d\\"), i);
TInt nRes = TheFs.MkDir(dirName);
test_KErrNone(nRes);
}
timeEnd.UniversalTime(); //-- take end time
usTotalTime = (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test.Printf(_L("#--> %d Dirs. created in %d ms\n"), KMaxDirs, (TUint32)usTotalTime/K1mSec);
EnablePrintOutput(ETrue); //-- Enable FAT test utils print out
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-T_FATCACHE_BM-0693
//! @SYMTestType PT
//! @SYMPREQ PREQ1721
//! @SYMTestCaseDesc Create a large file (2G max) and measure the time. Then delete this file and measure time taken
//!
//! @SYMTestActions
//! 0 quick format the volume
//! 1 create emply file that takes either 80% of the volume of 2G max, masure time taken
//! 2 remount FS
//! 3 delete this file and measure time taken
//!
//! @SYMTestExpectedResults successful files creation/deletion
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
static void CreateLargeFile()
{
test.Next(_L("Create a large file and measure time\n"));
FormatVolume(ETrue); //-- quick format the volume.
_LIT(KBigFileName, "\\BigFile.big");
test(gBootSector.IsValid());
//-- calculate the size of the file, it shall be max 2G or take almost all volume
TVolumeInfo volInfo;
TInt nRes;
nRes = TheFs.Volume(volInfo, gDriveNum);
test_KErrNone(nRes);
const TUint32 clustSz = gBootSector.SectorsPerCluster() * gBootSector.BytesPerSector();
const TUint32 maxClusters = (TUint32)(volInfo.iFree / clustSz);
const TUint32 clustersPer1G = K1GigaByte / clustSz;
const TUint32 clustersPer2G = 2*clustersPer1G;
TUint32 fileClusters=0;
if(maxClusters*0.8 < clustersPer2G)
fileClusters = (TUint32)(maxClusters*0.8);
else
fileClusters = (TUint32)(clustersPer2G*0.8);
const TUint32 fileSize = fileClusters*clustSz;
//-- create empty file and measure time
TTime timeStart;
TTime timeEnd;
TInt64 usTimeCreate=0;
TInt64 usTimeDelete=0;
timeStart.UniversalTime(); //-- take start time
nRes = CreateEmptyFile(TheFs, KBigFileName, fileSize);
timeEnd.UniversalTime(); //-- take end time
test_KErrNone(nRes);
usTimeCreate = (timeEnd.MicroSecondsFrom(timeStart)).Int64();
//-- remount file system, reset caches etc.
DoRemountFS(gDriveNum);
//-- delete the file
timeStart.UniversalTime(); //-- take start time
nRes = TheFs.Delete(KBigFileName);
timeEnd.UniversalTime(); //-- take end time
test_KErrNone(nRes);
usTimeDelete = (timeEnd.MicroSecondsFrom(timeStart)).Int64();
test.Printf(_L("#--> Big file sz:%u created:%d ms, deleted:%d ms\n"), fileSize, (TUint32)(usTimeCreate/K1mSec) , (TUint32)(usTimeDelete/K1mSec));
}
//-------------------------------------------------------------------
/**
Start tests.
*/
void RunTest()
{
test.Printf(_L("Prepare the volume for BM testing...\n"));
test(pFTagArray != NULL);
CFileTagsArray &fTagArray = *pFTagArray;
fTagArray.Reset();
//-- full format the drive
FormatVolume(EFalse);
test.Printf(_L("\n#--> t_fatcache_bm\n"));
//-- create test directory.
MakeDir(KDirName);
//-- 1. create KMaxFiles files to fill in space in FAT table.
if(!DoCreateFiles(fTagArray))
return; //-- test is inconsistent
//-- 1.1 create a file in the very end of the full volume (FAT table is almost full). Measure time taken
CreateLastFile();
//-- 1.2 create multiple directories in the root and measure time
// DoCreateDirsInRoot();
//-- 2. randomly merge some small files to bigger ones that will be fragmented
DoMergeFiles(fTagArray);
//-- 3. randomly shuffle file tags in the array
ShuffleArray(fTagArray);
//-- 4. measure file open and seek time
MeasureSeekTime(fTagArray);
//-- 4.5 Check that all copies of FAT are the same.
CheckFatCopies();
//-- 5. delete all files and print out time taken
DeleteAllFiles(fTagArray);
//-- 6. Create a large file (2G max) and measure the time
//!!!!
CreateLargeFile();
}
//-------------------------------------------------------------------
static void WaitForFatBkGndActivityEnd()
{
//-- if we work in release mode, we need to use a hardcore solution to wait until possible FAT background activity finishes
//-- because transient FAT threads can affect timings (e.g. creating a file may need waiting to FAT background thread to
//-- parse some portion of FAT) etc.
//-- for debug mode background FAT activity is disabled in InitGlobals() and timings are not precise anyway
//-- for release mode we just need to wait some time
#ifndef _DEBUG
const TInt KWaitTimeSec = 10;
test.Printf(_L("waiting %d sec...\n"), KWaitTimeSec);
User::After(KWaitTimeSec*K1Sec);
#endif
}
//-------------------------------------------------------------------
/**
Dismounts and mounts the FS on a drive aDrive
This will cause resetting "last known free cluster number" value in the FAT table implementation in FSY.
(Mounting enhancements are disabled.) Empty the caches etc.
*/
static void DoRemountFS(TInt aDrive)
{
TInt nRes = RemountFS(TheFs, aDrive);
test_KErrNone(nRes);
//-- get volume info, this is a trick that can help avoiding asynchronous FAT mount in UREL mode
//TVolumeInfo v;
//nRes = TheFs.Volume(v);
//-- to avoid affected timings in UREL mode.
WaitForFatBkGndActivityEnd();
}
//-------------------------------------------------------------------
/** initialise test global objects */
static void InitGlobals()
{
//-- initialise random generator
gRndSeed = 0x67fc1a9;
//-- construct file numbers array
pFTagArray = new CFileTagsArray(KMaxFiles);
test(pFTagArray != NULL);
pFTagArray->SetReserveL(KMaxFiles);
//-- define a propery which will control mount process in the fsy.
//-- The property key is a drive number being tested
_LIT_SECURITY_POLICY_PASS(KTestPropPolicy);
TInt nRes = RProperty::Define(KThisTestSID, gDriveNum, RProperty::EInt, KTestPropPolicy, KTestPropPolicy);
test(nRes == KErrNone || nRes == KErrAlreadyExists);
//-- disable all volume mount enhancements, like asynch mount and FSInfo.
//-- this works only in debug mode.
nRes = RProperty::Set(KThisTestSID, gDriveNum, (TInt)KMntProp_DisableALL);
test_KErrNone(nRes);
}
/** destroy test global objects */
static void DestroyGlobals()
{
delete pFTagArray;
//-- delete test property
RProperty::Delete(KThisTestSID, gDriveNum);
}
//-------------------------------------------------------------------
void CallTestsL()
{
//-- set up console output
Fat_Test_Utils::SetConsole(test.Console());
TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
test(nRes==KErrNone);
//-- check if this is FAT
if(!Is_Fat(TheFs, gDriveNum))
{
test.Printf(_L("Skipping. This test requires FAT drive.\n"));
return;
}
//-- check this is not the internal ram drive
TVolumeInfo v;
nRes = TheFs.Volume(v);
test(nRes==KErrNone);
if(v.iDrive.iMediaAtt & KMediaAttVariableSize)
{
test.Printf(_L("Skipping. Internal ram drive not tested.\n"));
return;
}
//-------------------------------------
PrintDrvInfo(TheFs, gDriveNum);
InitGlobals();
RunTest();
//-------------------------------------
DestroyGlobals();
}