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