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

// 

// Testing "automounter" filesystem plugin functionality. 

//

//

/**

 @file

*/

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <e32property.h>

#include <f32dbg.h>

#include "filesystem_fat.h"

#include "filesystem_automounter.h" 

#include "t_server.h"

#include "fat_utils.h"

using namespace Fat_Test_Utils;

RTest test(_L("T_Automounter"));

static TInt     gDriveNum=-1; ///< drive number we are dealing with

//-------------------------------------------------------------------

//-- the debug test property string can be used to control automounter in debug mode.

const TUid KThisTestSID={0x10210EB3}; ///< this EXE SID

//-------------------------------------------------------------------

//-- Actually, for testing autoounter, it is neccessary to have at least 3 filesystems:

//-- automounter itself and any 2 dirrerent filesystems that can be used as child ones. 

//-- Let's use FAT as a 1st child, and exFAT as 2nd. All these 3  *.fsy shall be present.

/** automounter filesystem name */

#define KAutoMounterFSName KFileSystemName_AutoMounter

_LIT(KAutoMounterFsy,    "automounter.fsy");    ///< automounter *.fsy module name

//-- FAT is used as a child filesystem #0

/**  filesystem #1 name */

#define KFSName1 KFileSystemName_FAT

#if defined(__WINS__) //-- FAT fsy name is a mess.

_LIT(KFsy1, "efat32.fsy");

#else

_LIT(KFsy1, "elocal.fsy");

#endif    

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//-- exFAT is used as a child filesystem #1. The problem here: some poor guys might not have the exFAT at all including the header file

//-- "filesystem_exfat.h" that defines exFAT volume formatting structure. Fortunately for them the exFAT formatting parameters like "sectors per cluster" and

//-- "number of FATs" have the same layout in the data container as FAT ones. So FAT formatting structure can be used for formatting exFAT.

//-- The macro defines if exFAT might not be available.

#define EXFAT_MIGHT_NOT_BE_PRESENT

/** filesystem #2 name */

#ifdef EXFAT_MIGHT_NOT_BE_PRESENT

    _LIT(KFSName2, "exFAT");

#else

    #define KFSName2 KFileSystemName_exFAT

    #include "filesystem_exfat.h" 

    using namespace FileSystem_EXFAT;

#endif

_LIT(KFsy2, "exfat.fsy"); ///< filesystem #2 *.fsy module name

TBool automounter_Loaded  = EFalse; ///< ETrue if automounter.fsy is loaded; used for correct cleanup

TBool childFs1_Loaded     = EFalse; ///< ETrue if child #0 *.fsy is loaded; used for correct cleanup

TBool childFs2_Loaded     = EFalse; ///< ETrue if child #1 *.fsy is loaded; used for correct cleanup

TFSDescriptor   orgFsDescriptor; //-- keeps parameters of the original FS

//-------------------------------------------------------------------

/**

    perform some operations to see if the file system works at all

*/

void CheckFsOperations()

{

    TInt nRes;

    TVolumeInfo v;

    nRes = TheFs.Volume(v);

    test_KErrNone(nRes);

    _LIT(KTestDir, "\\directory1\\DIR2\\another directory\\");

    MakeDir(KTestDir);

    _LIT(KTestFile, "\\this is a file to test.bin");

    nRes = CreateCheckableStuffedFile(TheFs, KTestFile, 20376);

    test_KErrNone(nRes);

    nRes = VerifyCheckableFile(TheFs, KTestFile);

    test_KErrNone(nRes);

    nRes = TheFs.Delete(KTestFile);

    test_KErrNone(nRes);

}

//-------------------------------------------------------------------

/**

    Check that FileSystem1 subtype matches one of the expected

*/

void CheckSubtype_FS1(const TDesC& aFsSubtype)

{

    _LIT(KFatSubType12, "fat12");

    _LIT(KFatSubType16, "fat16");

    _LIT(KFatSubType32, "fat32");

    test(aFsSubtype.CompareF(KFatSubType12) == 0 || aFsSubtype.CompareF(KFatSubType16) == 0 || aFsSubtype.CompareF(KFatSubType32) == 0 );

}

//-------------------------------------------------------------------

/**

    Check that FileSystem2 subtype matches expected

*/

void CheckSubtype_FS2(const TDesC& aFsSubtype)

{

    _LIT(KExFatSubType, "exFAT");

    test(aFsSubtype.CompareF(KExFatSubType) == 0);

}

//-------------------------------------------------------------------

/**

    Dismounts Currently mounted file system.

*/

static TInt DoDismountFS()

{

    TBuf<40> fsName(0);

    TInt nRes;

    nRes = TheFs.FileSystemName(fsName, gDriveNum);

    if(nRes == KErrNone)

    {

        test.Printf(_L("--- Dismounting FS:%S\n"), &fsName);

        nRes = TheFs.DismountFileSystem(fsName, gDriveNum);

        return nRes;

    }

    return KErrNone; //-- no file system mounted

}

//-------------------------------------------------------------------

/**

    Dismounts Currently mounted file system.

*/

static void DismountFS()

{

    test(DoDismountFS() == KErrNone);

}

//-------------------------------------------------------------------

/**

    Dismounts Currently mounted file system.

*/

static void ForceDismountFS()

{

    test.Printf(_L("--- Force dismounting current FS\n"));

    TRequestStatus stat;

    TheFs.NotifyDismount(gDriveNum, stat, EFsDismountForceDismount); 

    User::WaitForRequest(stat);         

    test(stat.Int() == KErrNone);

}

//-------------------------------------------------------------------

/**

    Mount the given file system. Mounting file system doesn't mean that it will be usable.

    For example, KErrCorrupt can be the result if FS doesn't recognise bootsectors etc. 

    @param  aFsName file system name

    @return error code

*/

static TInt DoMountFS(const TDesC& aFsName)

{

    TInt nRes;

    test.Printf(_L("+++ Mounting FS:%S\n"), &aFsName);

    TFSDescriptor   newFsDescriptor = orgFsDescriptor;

    newFsDescriptor.iFsName = aFsName;

    test(!newFsDescriptor.iDriveSynch); //-- mount the given FS as asynchronous one, the automounter can't be used on a synchronous drive anyway.

    nRes = MountFileSystem(TheFs, gDriveNum, newFsDescriptor);

    if(nRes != KErrNone)

    {

        test.Printf(_L("++> Error Mounting FS! code:%d\n"), nRes);

    }

    else

    {

        PrintDrvInfo(TheFs, gDriveNum);

    }

    return nRes;

}

//-------------------------------------------------------------------

/**

    Explicitly mount the "automounter" FS

*/

static void Mount_AutomounterFS()

{

    DismountFS();

    DoMountFS(KAutoMounterFSName);

}

//-------------------------------------------------------------------

/**

    Explicitly mount the FileSystem1

*/

static void Mount_FileSystem1()

{

    DismountFS();

    DoMountFS(KFSName1);

}

//-------------------------------------------------------------------

/**

    Explicitly mount the FileSystem2

*/

static void Mount_FileSystem2()

{

    DismountFS();

    DoMountFS(KFSName2);

}

//-------------------------------------------------------------------

/**

    Just fill first 32 sectors with zeroes.

    The volume will require formatting after this.

*/

static void CorruptDrive()

{

    TInt nRes;

    test.Printf(_L("!!! corrupting the drive...\n"));

    RRawDisk  rawDisk;

    nRes = rawDisk.Open(TheFs, gDriveNum);

    test(nRes == KErrNone);

    TBuf8<512>  sectorBuf(512);

    sectorBuf.FillZ();

    const TInt  KSectors = 32;

    TInt64      mediaPos = 0;

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

    {

        nRes = rawDisk.Write(mediaPos, sectorBuf);

        test(nRes == KErrNone);

        mediaPos += sectorBuf.Size();

    }

    rawDisk.Close();

}

//-------------------------------------------------------------------

/**

    quick format the volume using all parameter by default

*/

static void FormatVolume(TBool aQuickFormat = ETrue)

{

    TInt nRes;

    nRes = FormatDrive(TheFs, CurrentDrive(), aQuickFormat);

    test_KErrNone(nRes);

}

//-------------------------------------------------------------------

TInt DoFormatSteps(RFormat& aFormat, TInt& aFmtCnt)

{

    TInt nRes = KErrNone;

    while(aFmtCnt)

    {

        nRes = aFormat.Next(aFmtCnt);

        if(nRes != KErrNone)

        {

            test.Printf(_L("RFormat::Next() failed! code:%d\n"), nRes);

            break;

        }

    }

    return nRes;

}

//-------------------------------------------------------------------

/** 

    initialise test global objects 

    @return EFalse if something goes wrong

*/

TBool InitGlobals()

{

#ifndef _DEBUG

    test.Printf(_L("This test can't be performed in RELEASE mode! Skipping.\n"));

    test(0);

#endif

    TInt nRes;

    //-- store original file system parameters

    nRes = GetFileSystemDescriptor(TheFs, gDriveNum, orgFsDescriptor);

    test_KErrNone(nRes);

    //=======================================

    //-- define a text propery that will override automounter config string in estart.txt

    //-- automounter must be able to parse this string.

    //-- The property key is a drive number being tested

    {

        const TUint KPropKey = 0; //-- property key

        _LIT_SECURITY_POLICY_PASS(KTestPropPolicy);

        nRes = RProperty::Define(KThisTestSID, KPropKey, RProperty::EText, KTestPropPolicy, KTestPropPolicy);

        test(nRes == KErrNone || nRes == KErrAlreadyExists);

        //-- set the propery, it will override automounter config from estart.txt. 

        //-- the config string has following format: "<fs_name1>,<fsname2>"

        TBuf8<50> cfgBuf(0);

        cfgBuf.Append(KFSName1);

        cfgBuf.Append(_L(" , "));

        cfgBuf.Append(KFSName2);

        nRes = RProperty::Set(KThisTestSID, KPropKey, cfgBuf);

        test_KErrNone(nRes);

    }

    //=======================================

    //-- we must ensure that all 3 required *.fsy are present and load them.

    //-- the automounter must have child filesystems loaded before its initialisation. 

    {

        _LIT(KFsyFailure, "can't load '%S', code:%d, the test can't be performed!\n");

        //-- child FS #0

        nRes = TheFs.AddFileSystem(KFsy1);

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

        {

            test.Printf(KFsyFailure, &KFsy1, nRes);    

            return EFalse;

        }

        childFs1_Loaded = ETrue;

        //-- child FS #1

        nRes = TheFs.AddFileSystem(KFsy2);

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

        {

            test.Printf(KFsyFailure, &KFsy2, nRes);    

            return EFalse;

        }

        childFs2_Loaded = ETrue;

        //-- automounter

        nRes = TheFs.AddFileSystem(KAutoMounterFsy);

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

        {

            test.Printf(KFsyFailure, &KAutoMounterFsy, nRes);    

            return EFalse;

        }

        automounter_Loaded = ETrue;

    }

    //=======================================

    //-- dismount original file system and optional primary extension. Secondary extensions are not supported.

    test.Printf(_L("Dismounting the original FS:%S, PExt:%S \n"), &orgFsDescriptor.iFsName, &orgFsDescriptor.iPExtName);

    nRes = TheFs.DismountFileSystem(orgFsDescriptor.iFsName, gDriveNum);

    test_KErrNone(nRes);

    return ETrue;

}

//-------------------------------------------------------------------

/** destroy test global objects */

void DestroyGlobals()

{

    test.Printf(_L("Restoring the environment....\n"));

    TInt nRes;

    //=======================================

    //-- dismount current filesystem that was used for testing and mount the original filesystem

    if(orgFsDescriptor.iFsName.Length())

    {//-- the original file system had been dismounted during test initialisation; dismount whatever we have now

        test.Printf(_L("Mounting back the original FS:%S, PExt:%S \n"), &orgFsDescriptor.iFsName, &orgFsDescriptor.iPExtName);

        TBuf<40> fsName;

        nRes = TheFs.FileSystemName(fsName, gDriveNum);

        if(nRes == KErrNone && fsName.CompareF(orgFsDescriptor.iFsName) != KErrNone)

        {

            nRes = TheFs.DismountFileSystem(fsName, gDriveNum);

            test_KErrNone(nRes);

            //-- mount original FS as asynchronous one, the automounter can't be used on a synchronous drive anyway.

            MountFileSystem(TheFs, gDriveNum, orgFsDescriptor);

            FormatVolume();

        }

    }

    //=======================================

    //-- delete test property

    RProperty::Delete(KThisTestSID, gDriveNum);

    //=======================================

    //-- if the original FS wasn't automounter, unload child file systems

    if(orgFsDescriptor.iFsName.CompareF(KFileSystemName_AutoMounter) != 0)

    { 

        if(childFs1_Loaded)

        {

            nRes = TheFs.RemoveFileSystem(KFSName1);

            test(nRes == KErrNone ||  nRes == KErrInUse); //-- if the FS was used on some drive before test started, It will be KErrInUse

            childFs1_Loaded = EFalse;

        }

        if(childFs2_Loaded)

        {

            nRes = TheFs.RemoveFileSystem(KFSName2);

            test(nRes == KErrNone ||  nRes == KErrInUse); //-- if the FS was used on some drive before test started, It will be KErrInUse

            childFs2_Loaded = EFalse;

        }

        //-- unload test filesystem modules

        if(automounter_Loaded)

        {

            nRes = TheFs.RemoveFileSystem(KAutoMounterFSName); //-- if the FS was used on some drive before test started, It will be KErrInUse

            test(nRes == KErrNone ||  nRes == KErrInUse);

            automounter_Loaded = EFalse;

        }

     }

     else

     {

        nRes = RemountFS(TheFs, gDriveNum);

        test(nRes == KErrNone);

     }

    TVolumeInfo v;

    TheFs.Volume(v);

}

//-------------------------------------------------------------------

/*

    Testing basic automounter functionality. Format media with different file systems FS1/FS2, mount automounter and 

    ensure that it recognised and successfully mounts appropriate child file system.

    1.1 mount "filesystem1" / format volume 

    1.2 check file system name / subtype / functionality

    1.3 corrupt "filesystem1"

    1.4 check  file system name / subtype

    2.1 mount "automounter"

    2.2 check file system name / subtype / functionality (this must correspond to the filesystem1) The "filesystem1" must be recognised

    3.1 mount "filesystem2" / format volume

    3.2 check file system name / subtype / functionality

    3.3 corrupt "filesystem2"

    3.4 check  file system name / subtype

    3.5 format volume (it will be filesystem2)

    4.1 mount "automounter"

    4.2 check file system name / subtype / functionality (this must correspond to the filesystem2) The "filesystem2" must be recognised

    5.  check the list of supported file systems on the drive

    6.1 corrupt the volume 

    6.2 check that automounter can't recognise it

    7.  restore "filesystem1" / format volume 

*/

void TestAutomounterBasics()

{

    test.Next(_L("Testing automounter basic functionality \n"));