// 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_fsys.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <f32file_private.h>

#include <e32test.h>

#include <e32math.h>

#include "t_server.h"

#include "fat_utils.h"

#include "filesystem_fat.h"

using namespace Fat_Test_Utils;

RTest test(_L("T_FSYS"));

static TInt64   gRndSeed;

_LIT(KTestFsy,  "T_TFSYS");

_LIT(KTestFsy2, "T_TFSYS2");

_LIT(KTestFsy3, "T_TFSYS3");

_LIT(KTestFsName,  "Test");

_LIT(KTestFsName2, "Test2");

_LIT(KTestFsName3, "Test3");

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

void InitGlobals()

{

    //-- initialise random generator 

    gRndSeed = 0xf73c1ab;

    Math::Rand(gRndSeed);

}

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

void DestroyGlobals()

{

}

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

/**

    Test CFsMountHelper class functionality

*/

void TestFsMountHelper()

{

    test.Next(_L("Test CFsMountHelper class functionality\n"));

    if(Is_SimulatedSystemDrive(TheFs, CurrentDrive()))

    {

        test.Printf(_L("Can't test on a simulated drive, skipping!\n"));

        return;

    }

    TInt    nRes;

    TFSName fsName;

    TFSName fsName1;

    CFsMountHelper* pHelper1 = CFsMountHelper::New(TheFs, CurrentDrive());

    test(pHelper1 !=0);

    CFsMountHelper* pHelper2 = CFsMountHelper::New(TheFs, CurrentDrive());

    test(pHelper2 !=0);

    //-- 1. store the original file system state

    nRes = pHelper1->GetMountProperties();

    test_KErrNone(nRes);

    //-- 1.1 simple case. dismount the file system and mount it back

    nRes = TheFs.FileSystemName(fsName, CurrentDrive());

    test_KErrNone(nRes);

    nRes = pHelper1->DismountFileSystem();

    test_KErrNone(nRes);

    nRes = pHelper1->MountFileSystem();

    test_KErrNone(nRes);

    nRes = TheFs.FileSystemName(fsName1, CurrentDrive());

    test_KErrNone(nRes);

    test(fsName1 == fsName);

    //-- 1.2 attempts to dismount FS that has files opened

    _LIT(KFileName, "\\myfile");

    _LIT8(KFileData, "\\this is the file data");

    RFile file;

    nRes = file.Replace(TheFs, KFileName, EFileWrite);

    test_KErrNone(nRes);

    //-- 1.2.1 simplistic API

    nRes = pHelper1->DismountFileSystem();

    test_Value(nRes, nRes == KErrInUse);

    //-- 1.2.1 more advanced asynchronous API

    TRequestStatus stat;

    //-- 1.2.1.1 simple normal dismounting, Rfs::DismountFileSystem() analog

    pHelper1->DismountFileSystem(stat, CFsMountHelper::ENormal);

    User::WaitForRequest(stat);

    test_Value(stat.Int(), stat.Int() == KErrInUse);

    //-- 1.2.1.2 dismount with notifying clients (no clients, so it should succeed)

    //-- this will be a kind of forced dismounting

    pHelper1->DismountFileSystem(stat, CFsMountHelper::ENotifyClients);

    User::WaitForRequest(stat);

    test_KErrNone(stat.Int());

    nRes = file.Write(KFileData);

    test_Value(nRes, nRes == KErrNotReady); //-- no file system on the drive

    //-- mount the file system back

    nRes = pHelper1->MountFileSystem();

    test_KErrNone(nRes);

    nRes = file.Write(KFileData);

    test_Value(nRes, nRes == KErrDisMounted);

    file.Close();

    //-- 1.2.1.3 forced dismounting

    nRes = file.Replace(TheFs, KFileName, EFileWrite);

    test_KErrNone(nRes);

    pHelper1->DismountFileSystem(stat, CFsMountHelper::ENormal);

    User::WaitForRequest(stat);

    test_Value(stat.Int(), stat.Int() == KErrInUse);

    pHelper1->DismountFileSystem(stat, CFsMountHelper::EForceImmediate);

    User::WaitForRequest(stat);

    test_KErrNone(stat.Int());

    nRes = file.Write(KFileData);

    test_Value(nRes, nRes == KErrNotReady); //-- no file system on the drive

    file.Close();

    //-- there is no file system on the drive. 

    //-- test weird use cases 

    nRes = pHelper2->GetMountProperties();

    test_Value(nRes, nRes == KErrNotFound)

    //nRes = pHelper2->MountFileSystem(); //-- this will trigger an assert in debug mode

    //-- 2. test extensions

    //-- 2.1 mount the file system back

    nRes = pHelper1->MountFileSystem();

    test_KErrNone(nRes);

    //-- 2.2 install secondary extension

    _LIT(KExtensionLog,"T_LOGEXT");     //-- test secondary extension module name *.fxt

    _LIT(KExtensionLogName,"Logger");   //-- extension name

    nRes = TheFs.AddExtension(KExtensionLog);

    test_KErrNone(nRes);

    nRes = TheFs.MountExtension(KExtensionLogName, CurrentDrive());

    test_KErrNone(nRes);

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 0); //-- extension slot 0

    test(nRes == KErrNone);

    test(fsName1 == KExtensionLogName);

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 1); //-- extension slot 1

    test_Value(nRes, nRes == KErrNotFound)

    //-- 2.3 dismount the file system, it has now different set of properties comparing to ones stored in the pHelper1

    nRes = pHelper2->GetMountProperties();

    test(nRes == KErrNone);

    nRes = pHelper2->DismountFileSystem();

    test_KErrNone(nRes);

    //-- 2.3.1 mount the original FS (without extension)

    nRes = pHelper1->MountFileSystem();

    test_KErrNone(nRes);

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 0); //-- extension slot 0

    test_Value(nRes, nRes == KErrNotFound)

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 1); //-- extension slot 1

    test_Value(nRes, nRes == KErrNotFound)

    nRes = pHelper1->DismountFileSystem();

    test_KErrNone(nRes);

    //-- 2.3.2 mount back the FS with extension

    nRes = pHelper2->MountFileSystem();

    test_KErrNone(nRes);

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 0); //-- extension slot 0

    test(nRes == KErrNone);

    test(fsName1 == KExtensionLogName);

    //-- 2.4 remove the extensions and dismount the file system with properties stored in pHelper2

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 1); //-- extension slot 1

    test_Value(nRes, nRes == KErrNotFound)

    nRes = pHelper2->DismountFileSystem();

    test_KErrNone(nRes);

    nRes = TheFs.RemoveExtension(KExtensionLogName);

    test_KErrNone(nRes);

    //-- 2.4 restore the original file system

    nRes = pHelper1->MountFileSystem();

    test_KErrNone(nRes);

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 0); //-- extension slot 0

    test_Value(nRes, nRes == KErrNotFound)

    nRes = TheFs.ExtensionName(fsName1, CurrentDrive(), 1); //-- extension slot 1

    test_Value(nRes, nRes == KErrNotFound)

    nRes = TheFs.FileSystemName(fsName1, CurrentDrive());

    test_KErrNone(nRes);

    test(fsName1 == fsName);

    delete pHelper1;

    delete pHelper2;

}

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

/**

    The maximum length for the file system and extension names is KMaxFSNameLength

    test how the file server supports this

*/

void TestFileSystemNameLength()

{

    test.Next(_L("Test file system name length limits\n"));

    if(Is_SimulatedSystemDrive(TheFs, CurrentDrive()))

    {

        test.Printf(_L("Can't test on a simulated drive, skipping!\n"));

        return;

    }

    TInt nRes;

    TBuf<1024> name;

    TInt i;

    _LIT(KEmptyName, "");                //-- invalid length == 0

    _LIT(KDoesNotExist,  "RubbishName"); //-- valid length == 11

    _LIT(KDoesNotExist1, "RubbishName123456789012345678901"); //-- valid length == 32 (KMaxFSNameLength)

    _LIT(KNameTooLong1,  "RubbishName123456789012345678901_"); //-- invalid length == 33 (KMaxFSNameLength+1)

    test(KDoesNotExist1().Length() == KMaxFSNameLength);

    //-- generate a very long name

    name.Zero();

    for(i=0; i<(name.MaxLength()/KDoesNotExist1().Length()); ++i)

    {

        name.Append(KDoesNotExist1);

    }

    //-- 1. try to dismount the existing FS/extension specifying invalid name

    //-- 1.1 try empty names

    nRes = TheFs.DismountFileSystem(KEmptyName, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    nRes = TheFs.DismountExtension(KEmptyName, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    //-- 1.2 valid length, but non-existing name

    nRes = TheFs.DismountFileSystem(KDoesNotExist, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    nRes = TheFs.DismountExtension(KDoesNotExist, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    //-- 1.2 valid length == KMaxFSNameLength, but non-existing name

    nRes = TheFs.DismountFileSystem(KDoesNotExist1, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    nRes = TheFs.DismountExtension(KDoesNotExist1, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    //-- 1.3 too long name == KMaxFSNameLength+1, 

    nRes = TheFs.DismountFileSystem(KNameTooLong1, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    nRes = TheFs.DismountExtension(KNameTooLong1, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    //-- 1.4 a very long name ~ 1024 characters, 

    nRes = TheFs.DismountFileSystem(name, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    nRes = TheFs.DismountExtension(name, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    //-- try mounting extensions with valid, bu non-existing names

    nRes = TheFs.MountExtension(KDoesNotExist, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    nRes = TheFs.MountExtension(KDoesNotExist1, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

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

    //-- dismount original file system from the drive

    CFsMountHelper* pHelper = CFsMountHelper::New(TheFs, CurrentDrive());

    test(pHelper !=0);

    nRes = pHelper->GetMountProperties();

    test_KErrNone(nRes);

    nRes = pHelper->DismountFileSystem();

    test_KErrNone(nRes);

    //-- 2. try to mount a FS/extension with the invalid name

    //-- 2.1 try empty names

    nRes = TheFs.MountFileSystem(KEmptyName, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    nRes = TheFs.MountExtension(KEmptyName, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    //-- 1.2 valid length, but non-existing name

    nRes = TheFs.MountFileSystem(KDoesNotExist, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    //-- 1.2 valid length == KMaxFSNameLength, but non-existing name

    nRes = TheFs.MountFileSystem(KDoesNotExist1, CurrentDrive());

    test_Value(nRes, nRes == KErrNotFound);

    //-- 1.3 too long name == KMaxFSNameLength+1, 

    nRes = TheFs.MountFileSystem(KNameTooLong1, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    nRes = TheFs.MountExtension(KNameTooLong1, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    //-- 1.4 a very long name ~ 1024 characters, 

    nRes = TheFs.MountFileSystem(name, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    nRes = TheFs.MountExtension(name, CurrentDrive());

    test_Value(nRes, nRes == KErrArgument);

    //-- mount original file system back to the drive

    nRes = pHelper->MountFileSystem();

    test_KErrNone(nRes);

    delete pHelper;

}

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

static void TestFileSystemNames()

    {

    test.Next(_L("TestFileSystemNames(). Read file system names for all drives\n"));

    TFullName name;

    TBuf<60>  buf;

    TInt nRes;

    TDriveList drvList;

    nRes = TheFs.DriveList(drvList);

    test_KErrNone(nRes);

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

        {

        buf.Format(_L("drv %C: att:0x%02x"), 'A'+i, drvList[i]);

        nRes = TheFs.FileSystemName(name, i);

        test_Value(nRes, nRes == KErrNone || nRes==KErrNotFound);

        if(nRes == KErrNone)

            {

            buf.AppendFormat(_L(" Mounted FS:%S"), &name);

            }

        else

            {

            buf.Append(_L(" Mounted FS:"));

            }

        buf.Append(_L("\n"));

        test.Printf(buf);

        }

    }

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

static void CheckDismount(TDesC& aFs,TInt aDrive)

    {

    if (aDrive==EDriveC) // ??? Can't test on C: - see below

        return;

    TInt r;

    TFullName oldSess, newSess;

    r=TheFs.SessionPath(oldSess);

    test_KErrNone(r);

    TChar c;

    r=TheFs.DriveToChar(aDrive,c);

    test_KErrNone(r);

    newSess.Append(c);

    newSess.Append(':');

    newSess.Append('\\');

    TBuf<128> b;

    TDriveInfo di;

    r=TheFs.Drive(di,aDrive);

    test_KErrNone(r);

    b.Format(_L("Test dismounting of test file system on %c: (DrvAtt:%x MedAtt:%x)\n"),(TUint)c,di.iDriveAtt,di.iMediaAtt);

    test.Next(b);

    // Test cannot dismount on rom drive

    test.Next(_L("Test cannot dismount on Rom drive\n"));

    TFullName zName;

    r=TheFs.FileSystemName(zName,EDriveZ);

    test_KErrNone(r);

    r=TheFs.DismountFileSystem(zName,EDriveZ);

    test.Printf(_L("r=%d\n"),r);

    // NB if paging is enabled on a ROFS partition which is part of the composite file system then the 

    // likelihood is that there will be a at least one file clamped: in this case there error will be KErrInUse

    test_Value(r, r == KErrAccessDenied || r==KErrInUse);

    // Test cannot dismount on wrong drive

    test.Next(_L("Test cannot dismount on wrong drive\n"));

    r=TheFs.DismountFileSystem(aFs,EDriveA);

    test_Value(r, r == KErrNotReady);

    // Test cannot dismount with wrong name

    test.Next(_L("Test cannot dismount with wrong file system name\n"));

    r=TheFs.DismountFileSystem(_L("abc"),aDrive);

    test_Value(r, r == KErrNotFound);

    // Test cannot dismount with a file open

    test.Next(_L("Test cannot dismount with a file open\n"));

    r=TheFs.SetSessionPath(newSess);

    RFile file;

    r=file.Replace(TheFs,_L("abc"),EFileShareAny);

    test_KErrNone(r);

    r=TheFs.SessionPath(newSess);

    TBool open;

    r=TheFs.IsFileOpen(_L("abc"),open);

    test_KErrNone(r);

    test(open);

    r=TheFs.DismountFileSystem(aFs,aDrive);

    test_Value(r, r == KErrInUse);

    file.Close();

    // Now test dismount works

    test.Next(_L("Test dismounts OK\n"));

    r=TheFs.DismountFileSystem(aFs,aDrive);

    if(r!=KErrNone)

        {

        test.Printf(_L("Error = %d\n"),r);    

        test(EFalse);

        }

    TFullName n;

    r=TheFs.FileSystemName(n,aDrive);

    test_Value(r, r == KErrNone || r==KErrNotFound);

    test(!n.Length());

    r=file.Replace(TheFs,_L("abc"),EFileShareAny);

    test_Value(r, r == KErrNotReady);

    file.Close();