// 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()

{

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

}

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

/**

    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

    {

        _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);

        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