// Copyright (c) 2004-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:

// Unit tests for the CMassStorageFileSystem class

// 

//

/**

 @file

 @internalTechnology

*/

#include <f32file.h>

#include <e32test.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32svr.h>

#include <hal.h>

#include "t_ms_main.h"

#include "t_ms_common.h"

#include "cmassstoragefilesystem.h"

#include "cmassstoragemountcb.h"

// a: Acutally error code;  e: Expected error code

#define LOG_AND_TEST(a, e) {if (a!=e) {test.Printf(_L("%d\n\r"), a); test(EFalse);}}

_LIT(KMsFsyName, "MassStorageFileSystem");

LOCAL_D TChar driveLetter;

LOCAL_D TBusLocalDrive* localDrive=NULL;

LOCAL_C void ParseCommandArguments()

//

// Parses the command line arguments

//

	{

	TBuf<0x100> cmd;

	User::CommandLine(cmd);

	TLex lex(cmd);

	TPtrC token;

	token.Set(lex.NextToken());

	if (token.Length() != 0)

		{

		driveLetter = token[0];

		driveLetter.UpperCase();

		test.Printf(_L("CmdLine Param=%S"),&token);

		}

	else

		{

		test.Printf(_L("Not enough command line arguments"));

		test(EFalse);

		}

	}

LOCAL_C void doMsFsUnitTest()

	{

	__UHEAP_MARK;

	ParseCommandArguments();

	RFs fs;

	TInt err;

	TInt driveNumber;

	err = fs.CharToDrive(driveLetter, driveNumber);

	test(KErrNone == err);

	fs.Close();

	test.Printf(_L("Checking if drive %d is removable\n\r"), driveNumber);

	TBool removable = isDriveRemovable(driveNumber);

	if (!removable)

		{

		test.Printf(_L("This test is not supported on the specified drive\n\t"));

		return;

		}

	CMassStorageFileSystem* msfs = CMassStorageFileSystem::NewL();

	test.Printf(_L("Calling Install\n\r"));

	err = msfs->Install();

	test(err == KErrNone);

	test.Printf(_L("Comparing name\n\r"));

	TName name = msfs->Name();

	test.Printf(_L("Name is %S\n\r"), &name);

	test(name == KMsFsyName);

	test.Printf(_L("Checking version\n\r"));

	TVersion ver(1, 0, 0);

	test(msfs->QueryVersionSupported(ver));

	test.Printf(_L("Checking IsExtensionSupported\n\r"));

	test(msfs->IsExtensionSupported());

	test.Printf(_L("Checking NewMountL\n\r"));

	//In this case new mount should leave because the controller thread is not started

	TRAP(err, msfs->NewMountL());

    LOG_AND_TEST(err, KErrNotReady);

	test.Printf(_L("Calling unsupported functions\n\r"));

	TRAP(err, msfs->NewFileL());

	test(err == KErrNotReady);

	TRAP(err, msfs->NewDirL());

	test(err == KErrNotReady);

	TRAP(err, msfs->NewFormatL());

	test(err == KErrNotReady);

	TBuf<1> buf;

	err = msfs->DefaultPath(buf);

	test(err == KErrNotSupported);

	TDriveList list;

	err = msfs->DriveList(list);

	test(err == KErrNotSupported);

	test.Printf(_L("Deleting file system object\n\r"));

	msfs->Close();

	delete msfs;

	delete localDrive;	

	__UHEAP_MARKEND;

    test.Printf(_L("MSFS unit test ===>PASS\n"));

	}

GLDEF_C void t_ms_fsunit()

//

// Do all tests

//

	{

    doMsFsUnitTest();

    }

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

EXPORT_C TInt CFsObject::SetName(const TDesC *aName)

	{

	User::Free(iName);

	iName=NULL;

	if (aName!=NULL)

		{

		iName=aName->Alloc();

		if (iName==NULL)

			return(KErrNoMemory);

		}

	return(KErrNone);

	}

EXPORT_C TName CFsObject::Name() const

	{

	if (iName)

		return(*iName);

	return(NULL);

	}

EXPORT_C CFsObject::CFsObject()

	{

	iAccessCount=1;

	}

EXPORT_C  CFsObject::~CFsObject()

	{

	if(iName)

		User::Free(iName);

	iName=NULL;

	}	

EXPORT_C TBool CFsObject::IsCorrectThread()

	{

	return(ETrue);

	}

EXPORT_C void CFsObject::Close()	

	{

	if(iName)

		User::Free(iName);

	iName = NULL;

	}

EXPORT_C TInt CFsObject::Open()

	{

	return KErrNone;

	}

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

CFileSystem::CFileSystem(void)

	{

	}

CFileSystem::~CFileSystem(void)

	{

	}

TInt CFileSystem::DefaultPath(TDes& /*aPath*/) const 

	{

	return KErrNone;

	}

EXPORT_C void CFileSystem::DriveInfo(TDriveInfo& aInfo, TInt aDriveNumber) const

	{

	}

EXPORT_C TBool CFileSystem::IsExtensionSupported() const

	{

	return(EFalse);

	}

EXPORT_C TBool CFileSystem::QueryVersionSupported(const TVersion& aVer) const

	{

	return(User::QueryVersionSupported(iVersion,aVer));

	}

EXPORT_C TInt CFileSystem::Remove()

	{

	return(KErrNone);

	}	

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

EXPORT_C TBool IsValidLocalDriveMapping(TInt /*aDrive*/)

//

// Is the drive number to local drive mapping valid?

//

	{

	return(ETrue);

	}

EXPORT_C TBusLocalDrive& GetLocalDrive(TInt aLocalDrive)

	{

	TBusLocalDrive* dd=new(ELeave) TBusLocalDrive;

	TBool mediaCh;

	dd->Connect(aLocalDrive, mediaCh);

	localDrive = dd;

	return *dd;

	}

EXPORT_C TBool DriveNumberToLocalDriveNumber(TInt aDrive)

	{

	return aDrive;

	}

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

EXPORT_C CLocDrvMountCB::CLocDrvMountCB() {}

EXPORT_C CLocDrvMountCB::~CLocDrvMountCB()

	{

	__PRINT1(_L("CLocDrvMountCB::~CLocDrvMountCB() 0x%x"),this);

	if(iProxyDrive)

		delete(iProxyDrive);

	}

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

EXPORT_C CMountCB::CMountCB()

	: iMountQ(_FOFF(CFileCB,iMountLink))

	{

	}

/**

Destructor.

Frees resources before destroying the object.

*/

EXPORT_C CMountCB::~CMountCB()

	{

	delete iVolumeName;

	}	

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

CFsDispatchObject::CFsDispatchObject()

:iDriveNumber(-1) 

{}

CFsDispatchObject::~CFsDispatchObject()

	{

	}

int CFsDispatchObject::IsCorrectThread(void)

	{

	return ETrue;

	}

EXPORT_C void CFsDispatchObject::Close()

	{

	}	

EXPORT_C void CMountCB::IsFileInRom(const TDesC& /*aFileName*/,TUint8*& aFileStart)

	{

	aFileStart=NULL;

	}

int CLocDrvMountCB::CreateLocalDrive(class TBusLocalDrive &) 

	{

	return KErrNone;

	}

void CLocDrvMountCB::DismountedLocalDrive(void) 

	{

	}

EXPORT_C void WriteToDisk(const TDesC& /*aFileName*/, const TDesC8& /*aBuf*/)

	{

	}

// Implement the GetInterface methods here as these are usually 

// exported by EFILE, but these unit tests don't link to it.

TInt CMountCB::GetInterface(TInt /*aInterfaceId*/, TAny*& /*aInterface*/, TAny* /*aInput*/)

	{

	return KErrNotSupported;

	}

TInt CFileSystem::GetInterface(TInt /*aInterfaceId*/, TAny*& /*aInterface*/, TAny* /*aInput*/)

	{

	return KErrNotSupported;

	}