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

// @file f32test\concur\cfafsdly.cpp

//

#include "cfafsdly.h"

#include "cfafsdlyif.h"

#include "cfafshmem.h"

IMPORT_C TUint32 DebugRegister();

const TInt KMajorVersionNumber=1;

const TInt KMinorVersionNumber=0;

class TTestDebug

/// Class containing debugging functions.

    {

public:

    static void Printf(TRefByValue<const TDesC> aFmt, ...)

        {

        if (DebugRegister() & KDLYTRC)

            {

            VA_LIST list;

            VA_START(list, aFmt);

            TBuf<256>buf;

            buf.FormatList(aFmt, list);

            RDebug::Print(_L("%S"), &buf);

            }

        }

	static void After(TInt usec)

		{

		RTimer timer;

		timer.CreateLocal();

		TRequestStatus stat;

		timer.After(stat, usec);

		User::WaitForRequest(stat);

		timer.Close();

		}

private:

    };

TTestFile::TTestFile()

/// Initialise a file (clear the size).

	{

	iSize = 0;

	}

void TTestFile::Entry(TEntry& aEntry) const

/// Set up a standard entry item for the file.  Note that it strips off any

/// path from the name of the file.

/// @param aEntry Item to receive data about the file.

	{

	TInt i = iName.LocateReverse('\\');

	if (i == KErrNotFound)

		i = 0;

	else

		++i;

	aEntry.iName     = iName.Mid(i);

	aEntry.iAtt      = KEntryAttNormal;

	aEntry.iSize     = iSize;

	aEntry.iModified = iTime;

	}

TTestDir::TTestDir()

	{

	}

TTestFile* TTestDir::Create(const TDesC& aName)

/// Create a new file, if there is any space left.

/// @param aName Name of the file to be created.

/// @return Pointer to the file structure if it there is space, NULL if not.

	{

	TInt i;

	for (i = 0; i < KMaxFiles; i++)

		{

		if (iFile[i].iName.Length() == 0)

			{

			iFile[i].iName = aName;

			iFile[i].iSize = 0;

			return &iFile[i];

			}

		}

	return NULL;

	}

const TTestFile* TTestDir::Find(const TDesC& aName) const

/// Find a file by name.

/// @param aName Name of file to find (no wildcards).

/// @return Pointer to the file structure if it is found, NULL if not.

	{

	TInt i;

	for (i = 0; i < KMaxFiles; i++)

		{

		if (aName == iFile[i].iName)

			{

			return &iFile[i];

			}

		}

	return NULL;

	}

TTestFile* TTestDir::Find(const TDesC& aName)

/// Find a file by name.

/// @param aName Name of file to find (no wildcards).

/// @return Pointer to the file structure if it is found, NULL if not.

	{

	TInt i;

	for (i = 0; i < KMaxFiles; i++)

		{

		if (aName == iFile[i].iName)

			{

			return &iFile[i];

			}

		}

	return NULL;

	}

void TTestDir::Delete(const TDesC& aName)

/// Delete a file by name (no wildcards) by setting its name to zero length.

/// No error is returned if it doesn't exist.

/// @param aName Name of file to delete (no wildcards).

	{

	TInt i;

	for (i = 0; i < KMaxFiles; i++)

		{

		if (aName == iFile[i].iName)

			{

			iFile[i].iName.SetLength(0);

			iFile[i].iSize = 0;

			}

		}

	}

TTestFile* TTestDir::Entry(TInt aIndex)

/// Return a pointer to the specified file by number, or NULL if the index

/// is out of range.

	{

	return (aIndex >= 0 && aIndex < KMaxFiles ? &iFile[aIndex] : NULL);

	}

CTestFileSystem::CTestFileSystem()

///

/// Constructor

///

	{

	__DECLARE_NAME(_S("CTestFileSystem"));

	TTestDebug::Printf(_L("CTestFileSystem::CTestFileSystem()\n"));

	}

CTestFileSystem::~CTestFileSystem()

///

/// Destructor

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::~CTestFileSystem()\n"));

	}

TInt CTestFileSystem::Install()

///

/// Install the file system

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::Install()\n"));

	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KF32BuildVersionNumber);

	TPtrC name=_L("DelayFS");

	return(SetName(&name));

	}

CMountCB* CTestFileSystem::NewMountL() const

///

/// Create a new mount control block

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::NewMountL()\n"));

	return (new(ELeave) CTestMountCB);

	}

CFileCB* CTestFileSystem::NewFileL() const

///

/// Create a new file

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::NewFileL()\n"));

	return (new(ELeave) CTestFileCB);

	}

CDirCB* CTestFileSystem::NewDirL() const

///

/// create a new directory lister

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::NewDirL()\n"));

	return (new(ELeave) CTestDirCB);

	}

CFormatCB* CTestFileSystem::NewFormatL() const

///

/// Create a new media formatter

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::NewFormatL()\n"));

	return (new(ELeave) CTestFormatCB);

	}

TInt CTestFileSystem::DefaultPath(TDes& aPath) const

///

/// Return the intial default path

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::DefaultPath(%S)\n"), aPath.Ptr());

	aPath=_L("C:\\");

	return (KErrNone);

	}

void CTestFileSystem::DriveInfo(TDriveInfo& anInfo,TInt aDriveNumber) const

///

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::DriveInfo(%d)\n"), aDriveNumber);

	anInfo.iMediaAtt = KMediaAttFormattable;

	anInfo.iType     = EMediaHardDisk;

//	anInfo.iDriveAtt = KDriveAttRemote | KDriveAttRemovable;

	anInfo.iDriveAtt = KDriveAttRemote;

	}

TBusLocalDrive& CTestFileSystem::DriveNumberToLocalDrive(TInt aDriveNumber)

///

/// Return the local drive associated with aDriveNumber

///

	{

	TTestDebug::Printf(_L("CTestFileSystem::DriveNumberToLocalDrive()\n"));

	return(GetLocalDrive(aDriveNumber));

	}

/**

Reports whether the specified interface is supported - if it is,

the supplied interface object is modified to it

@param aInterfaceId     The interface of interest

@param aInterface       The interface object

@return                 KErrNone if the interface is supported, otherwise KErrNotFound 

@see CFileSystem::GetInterface()

*/

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

    {

    switch(aInterfaceId)

        {

        case CFileSystem::EProxyDriveSupport: // The Filesystem supports proxy drives

			return KErrNone;

        default:

            return(CFileSystem::GetInterface(aInterfaceId, aInterface, aInput));

        }

    }

CFileSystem* CTestFileSystem::NewL()

///

/// Create a new filesystem and return the pointer to its structure.

///

	{

	CFileSystem* testFSys = new(ELeave) CTestFileSystem;

	return testFSys;

	}

/////////////////////////////////////////////////////////////////////////////

static void cvtbuff(TBuf<64>& aOut, const TDesC8& aIn)

/// Copy an 8-bit buffer to a generic one.

/// @param aOut Generic text buffer.

/// @param aIn  8-bit buffer to be copied.

    {

    TInt i;

    TInt n = aIn.Length();

    if (n > 64)

        n = 64;

    aOut.SetLength(n);

    for (i = 0; i < n; i++)

        aOut[i] = TText(aIn[i]);

    }

CTestFileCB::CTestFileCB() : CFileCB(), iFile(NULL), iData(NULL)

	{

	TTestDebug::Printf(_L("CTestFileCB::CTestFileCB()\n"));

	};

CTestFileCB::~CTestFileCB()

	{

	CTestFileCB* file = (CTestFileCB*)this;

	if (file->iFile)

		TTestDebug::Printf(_L("CTestFileCB::~CTestFileCB(%S)\n"), &file->iFile->iName);

	else

		TTestDebug::Printf(_L("CTestFileCB::~CTestFileCB()\n"));

	};

void CTestFileCB::RenameL(const TDesC& aNewName)

/// Rename a file (not supported).

	{

	TTestDebug::Printf(_L("CTestFileCB::RenameL(%S)\n"), aNewName.Ptr());

	}

void CTestFileCB::ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)

/// Read from a file.  This introduces a fixed delay of 1 second (by default;

/// 10mS if KDLYFAST bit is set in the debug register), gets the data from the

/// file area and optionally traces it.

	{

	// set up lengths

	TInt max = (aPos > iSize ? 0 : iSize - aPos);

	TInt len = (aLength > max ? max : aLength);

	// set up return data

	THMem  dataBuffer(aDes, aMessage);

	dataBuffer.Write(iData+aPos, len, 0);

	aLength = len;

	/// now output traces

	TTestDebug::Printf(_L("CTestFileCB::ReadL(%4d, %4d, %.8X)\n"), aPos, aLength, aDes);

	TPtr8    pbuf(iData+aPos, len, max);

	TBuf<64> buf;

	cvtbuff(buf, pbuf);

	TTestDebug::After(DebugRegister() & KDLYFAST ? 10000 : 1000000);

	TTestDebug::Printf(_L("CTestFileCB::ReadL(%4d, %4d, %.8X=%.32S) exit\n"), aPos, aLength, aDes, &buf);

	}

void CTestFileCB::WriteL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)

/// Write to a file.  This introduces a fixed delay of 1 second (by default;

/// 10mS if KDLYFAST bit is set in the debug register), puts the data into the

/// file area if there is room and optionally traces it.

	{

	// Set the modified attribute (so Flush() makes its way through)

	iAtt |= KEntryAttModified;

	// set up maximum length

	TInt max = (aPos > KMaxFileLen ? 0 : KMaxFileLen - aPos);

	TInt len = (aLength > max ? max : aLength);

	TInt pos = aPos + len;

	// copy the data

	THMem  dataBuffer(aDes, aMessage);

	dataBuffer.Read(iData+aPos, len, 0);

	if (pos > iSize)

		iSize = pos;

	iFile->iSize = iSize;

	aLength = len;

	// trace it

	TPtr8    pbuf(iData+aPos, len, max);

	TBuf<64> buf;

	cvtbuff(buf, pbuf);

	TTestDebug::Printf(_L("CTestFileCB::WriteL(%4d, %4d, %.8X=%.32S)\n"), aPos, aLength, aDes, &buf);

	TTestDebug::After(DebugRegister() & KDLYFAST ? 10000 : 1000000);

	TTestDebug::Printf(_L("CTestFileCB::WriteL(%4d, %4d, %.8X) exit\n"), aPos, aLength, aDes);

	}

TInt CTestFileCB::Address(TInt& aPos) const

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestFileCB::Address(%d)\n"), aPos);

	return 0;

	}

void CTestFileCB::SetSizeL(TInt aSize)

/// Does nothing

	{

	TTestDebug::Printf(_L("CTestFileCB::SetSizeL(%d)\n"), aSize);

	}

void CTestFileCB::SetEntryL(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)

/// Does nothing

	{

	TTestDebug::Printf(_L("CTestFileCB::SetEntryL(%.8X, %.8X, %.8X)\n"), aTime.Int64(), aSetAttMask, aClearAttMask);

	}

void CTestFileCB::FlushDataL()

/// Flushes the file (well, actually does nothing other than introduce a fixed delay 

//	of 2.5 seconds (by default; 10mS if KDLYFAST bit is set in the debug register).

	{

	TTestDebug::Printf(_L("CTestFileCB::FlushDataL()\n"));

	if(iAtt & KEntryAttModified)

		{

		iAtt &= ~KEntryAttModified;

		TTestDebug::After(3500000);

		}

	}

void CTestFileCB::FlushAllL()

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestFileCB::FlushAllL()\n"));

	}

void CTestFileCB::CheckPos(TInt aPos)

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestFileCB::CheckPos(%d)\n"), aPos);

	}

/////////////////////////////////////////////////////////////////////////////

CTestMountCB::CTestMountCB() : CMountCB()

	{

	TTestDebug::Printf(_L("CTestMountCB::CTestMountCB()\n"));

	iSize = KMaxFileLen;

	SetVolumeName(HBufC::NewL(0));

	};

CTestMountCB::~CTestMountCB()

	{

	TTestDebug::Printf(_L("CTestMountCB::~CTestMountCB()\n"));

	};

void CTestMountCB::MountL(TBool aForceMount)

/// Does nothing.

	{

	if (aForceMount)

		TTestDebug::Printf(_L("CTestMountCB::MountL(forced)\n"));

	else

		TTestDebug::Printf(_L("CTestMountCB::MountL()\n"));

	}

TInt CTestMountCB::ReMount()

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::ReMount()\n"));

	return KErrNone;

	}

void CTestMountCB::Dismounted()

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::Dismounted()\n"));

	}

void CTestMountCB::VolumeL(TVolumeInfo& aVolume) const

/// Gets data about the volume -- the name is fixed and the size and free

/// space remaining are constant.

	{

	TTestDebug::Printf(_L("CTestMountCB::VolumeL()\n"));

	aVolume.iName = _L("DelayTest");

	aVolume.iSize = KMaxFileLen;

	aVolume.iFree = KMaxFileLen;

	}

void CTestMountCB::SetVolumeL(TDes& aName)

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::SetVolumeL(%S)\n"), &aName);

	}

void CTestMountCB::MkDirL(const TDesC& aName)

	{

	TTestDebug::Printf(_L("CTestMountCB::MkDirL(%S)\n"), &aName);

	User::Leave(KErrNotSupported);

	}

void CTestMountCB::RmDirL(const TDesC& aName)

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::RmDirL(%S)\n"), &aName);

	}

void CTestMountCB::DeleteL(const TDesC& aName)

	{

	TTestDebug::Printf(_L("CTestMountCB::DeleteL(%S)\n"), &aName);

	iDir.Delete(aName);

	}

void CTestMountCB::RenameL(const TDesC& anOldName,const TDesC& anNewName)

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::RenameL(%S, %S)\n"), &anOldName, &anNewName);

	}

void CTestMountCB::ReplaceL(const TDesC& /*anOldName*/,const TDesC& /*anNewName*/)

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::ReplaceL()\n"));

	}

void CTestMountCB::EntryL(const TDesC& aName, TEntry& aEntry) const

/// Gets the data associated with the specified file.

	{

	const TTestFile* e = iDir.Find(aName);

	if (e)

		{

		e->Entry(aEntry);

		}

	else

		{

		aEntry.iName = _L("");

		aEntry.iAtt  = 0;

		aEntry.iSize = 0;

		aEntry.iType = TUidType();

		TTestDebug::Printf(_L("CTestMountCB::EntryL(%S) leave KErrNotFound\n"), &aName);

		User::Leave(KErrNone);

		}

	TTestDebug::Printf(_L("CTestMountCB::EntryL(%S, %S)\n"), &aName, &aEntry.iName);

	}

void CTestMountCB::SetEntryL(const TDesC& aName, const TTime& aTime, TUint aSetAttMask, TUint aClearAttMask)

/// Does nothing.

	{

	TTestDebug::Printf(_L("CTestMountCB::SetEntryL(%S, %.8X, %.8X, %.8X)\n"),

					   &aName, aTime.Int64(), aSetAttMask, aClearAttMask);

	}

void CTestMountCB::FileOpenL(const TDesC& aName, TUint aMode, TFileOpen aOpen, CFileCB* aFile)

/// Opens a file in the specified mode (the mode is ignored after this,

/// both read and write will work with any open file).  If a file is opened

/// for writing then it will be overwritten without comment.  The timestamp

/// of the file will be set when it is opened for writing.

/// @param aName Name of the file.

/// @param aMode Read, write etc.

/// @param aOpen ???

/// @param aFile Pointer to the already allocated file descriptor area.

	{

	TTestDebug::Printf(_L("CTestMountCB::FileOpenL(%S, %.8X, %.8X, %.8X)\n"),

				  &aName, aMode, aOpen, aFile);