// Copyright (c) 1995-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\manager\t_romg.cpp
// 
//

#include <f32file.h>
#include <e32test.h>
#include <e32rom.h>
#include "..\server\t_server.h"

const TInt KBufSize=0x10000;
const TInt KFillerSize=0x100;
const TInt KRomFileHeaderSize=0x100;
const TInt KRomFileHeaderNameSize=0x10;

class TRomFileHeaderBase
	{
public:
	TText8 iName[KRomFileHeaderNameSize];
	TText8 iVersionStr[4];
	TText8 iBuildNumStr[4];
	TInt iRomSize;
	TInt iHeaderSize;
	};

class TRomFileHeader : public TRomFileHeaderBase
	{
public:
	TUint8 iFiller[KRomFileHeaderSize-sizeof(TRomFileHeaderBase)];
	};

class CMemDir;
class CMemEntry : public CBase
	{
public:
	static CMemEntry* New(const TEntry& anEntry);
	~CMemEntry();
	TInt EntrySize();
	void Write();
	void WriteFile();
	inline TBool IsDir() {return(iEntry.iAtt&KEntryAttDir);}
	inline CMemDir& Dir() {return(*iDir);}
	inline void SetDir(CMemDir& aDir) {iDir=(&aDir);}
	inline TInt Size() {return(iSize);}
	inline TLinAddr Base() {return(iBase);}
	inline void SetBase();
	inline const TDesC& Name() {return(*iName);}
	inline static TInt LinkOffset() {return(_FOFF(CMemEntry,iLink));}
protected:
	CMemEntry(const TEntry& anEntry);
private:
	TLinAddr iBase;
	TInt iSize;
	TRomEntry iEntry;
	HBufC* iName;
	CMemDir* iDir;
	TDblQueLink iLink;
	};

class CMemDir : public CBase
	{
public:
	static CMemDir* NewL();
	~CMemDir();
	void LoadDirL(const TDesC& aPath);
	void SetBaseDirs();
	void SetBaseFiles();
	void WriteDirs();
	void WriteFiles();
	void Write();
	TFileName Name(const TDesC& aName);
	inline TLinAddr Base() {return(iBase);}
protected:
	CMemDir();
private:
	TInt iSize;
	TInt iCount;
	TLinAddr iBase;
	HBufC* iPath;
	TDblQue<CMemEntry> iEntryQ;
	};

class RFileX : public RFile
	{
public:
	RFileX() : RFile() {}
	TInt Write(const TDesC8& aDes);
	TInt Write(const TDesC8& aDes,TInt aLength);
	};

GLDEF_D RTest test(_L("T_ROMG"));
LOCAL_D RFileX TheFile;
LOCAL_D TRomHeader TheRomHeader;
LOCAL_D TLinAddr TheCurrentBase;
LOCAL_D CMemDir* TheRootDir;
LOCAL_D TInt TheLevel;
LOCAL_D TBuf8<KBufSize> TheBuf;
LOCAL_D TBuf8<KFillerSize> TheFiller;
#if defined(_UNICODE)
LOCAL_D const TPtrC TheFileName=_L("ROMFILEU.BIN");
#else
LOCAL_D const TPtrC TheFileName=_L("ROMFILE.BIN");
#endif

TInt RFileX::Write(const TDesC8& aDes)
//
// Write and update the file pos
//
	{

	TheCurrentBase+=aDes.Size();
	return(RFile::Write(aDes));
	}

TInt RFileX::Write(const TDesC8& aDes,TInt aLength)
//
// Write and update the file pos
//
	{

	TheCurrentBase+=aLength;
	return(RFile::Write(aDes,aLength));
	}

CMemEntry* CMemEntry::New(const TEntry& anEntry)
//
// Create a new entry.
//
	{

	CMemEntry* pE=new(ELeave) CMemEntry(anEntry);
	pE->iName=anEntry.iName.Alloc();
	test(pE->iName!=NULL);
	return(pE);
	}

#pragma warning( disable : 4705 )	// statement has no effect
CMemEntry::CMemEntry(const TEntry& anEntry)
//
// Constructor.
//
	{

	iEntry.iAtt=(TUint8)(anEntry.iAtt|KEntryAttReadOnly); // All rom files are read only
	iEntry.iSize=anEntry.iSize;
	iEntry.iNameLength=(TUint8)anEntry.iName.Size();
	iSize=Align4(anEntry.iSize);
	__DECLARE_NAME(_S("CMemEntry"));
	}
#pragma warning( default : 4705 )

CMemEntry::~CMemEntry()
//
// Destruct.
//
	{

	if (iLink.iNext!=NULL)
		iLink.Deque();
	delete iName;
	if (IsDir())
		delete iDir;
	}

void CMemEntry::SetBase()
//
// Set the entries base address.
//
	{

	iBase=TheCurrentBase;
	iEntry.iAddressLin=TheCurrentBase;
	}

TInt CMemEntry::EntrySize()
//
// Calculate the entries size.
//
	{

	return(Align4(KRomEntrySize+iEntry.iNameLength));
	}

void CMemEntry::Write()
//
// Write the current entry.
//
	{

	test(TheFile.Write(TPtrC8((TUint8*)&iEntry,KRomEntrySize))==KErrNone);
	test(TheFile.Write(TPtrC8((TUint8*)iName->Ptr(),iName->Size()))==KErrNone);
	TInt rem=EntrySize()-iName->Size()-KRomEntrySize;
	if (rem)
		test(TheFile.Write(TheFiller,rem)==KErrNone);
	}

void CMemEntry::WriteFile()
//
// Write the current entries file.
//
	{

	test(iBase==TheCurrentBase);
	TAutoClose<RFile> f;
	TFileName n=Dir().Name(*iName);
	test(f.iObj.Open(TheFs,n,EFileStream|EFileRead)==KErrNone);
	TInt size=0;
	do
		{
		test(f.iObj.Read(TheBuf)==KErrNone);
		test(TheFile.Write(TheBuf)==KErrNone);
		size+=TheBuf.Length();
		} while (TheBuf.Length()==TheBuf.MaxLength());
	test(iEntry.iSize==size);
	TInt rem=iSize-size;
	if (rem)
		test(TheFile.Write(TheFiller,rem)==KErrNone);
	}

CMemDir* CMemDir::NewL()
//
// Create a new directory.
//
	{

	return(new(ELeave) CMemDir);
	}

CMemDir::CMemDir()
//
// Constructor.
//
	: iEntryQ(CMemEntry::LinkOffset())
	{

	__DECLARE_NAME(_S("CMemDir"));
	}

CMemDir::~CMemDir()
//
// Destruct.
//
	{

	while (!iEntryQ.IsEmpty())
		{
		CMemEntry* pE=iEntryQ.First();
		delete pE;
		}
	delete iPath;
	}

void CMemDir::SetBaseDirs()
//
// Set the base address of the directory and any sub-directories.
//
	{

	iBase=TheCurrentBase;
	iSize=sizeof(TInt);
	TDblQueIter<CMemEntry> q(iEntryQ);
	CMemEntry* pE;
	while ((pE=q++)!=NULL)
		{
		iCount++;
		iSize+=pE->EntrySize();
		}
	TheCurrentBase+=iSize;
	q.SetToFirst();
	while ((pE=q++)!=NULL)
		{
		if (pE->IsDir())
			{
			pE->SetBase();
			pE->Dir().SetBaseDirs();
			}
		}
	}

void CMemDir::SetBaseFiles()
//
// Set the base address of each file.
//
	{

	TDblQueIter<CMemEntry> q(iEntryQ);
	CMemEntry* pE;
	while ((pE=q++)!=NULL)
		{
		if (!pE->IsDir())
			{
			pE->SetBase();
			TheCurrentBase+=pE->Size();
			}
		}
	q.SetToFirst();
	while ((pE=q++)!=NULL)
		{
		if (pE->IsDir())
			pE->Dir().SetBaseFiles();
		}
	}

void CMemDir::WriteDirs()
//
// Write the directory and any sub-directories.
//
	{

	TheLevel++;
	TFileName name=Name(_L(""));
	test.Printf(_L("%*p%S\n"),TheLevel<<1,&name);
	Write();
	TDblQueIter<CMemEntry> q(iEntryQ);
	CMemEntry* pE;
	while ((pE=q++)!=NULL)
		{
		if (pE->IsDir())
			pE->Dir().WriteDirs();
		}
	TheLevel--;
	}

void CMemDir::WriteFiles()
//
// Set the base address of each file.
//
	{

	TheLevel++;
	TFileName name=Name(_L(""));
	test.Printf(_L("%*p%S\n"),TheLevel<<1,&name);
	TDblQueIter<CMemEntry> q(iEntryQ);
	CMemEntry* pE;
	while ((pE=q++)!=NULL)
		{
		if (!pE->IsDir())
			{
			test.Printf(_L("%*p%S\n"),(TheLevel<<1)+2,&pE->Name()),
			pE->WriteFile();
			}
		}
	q.SetToFirst();
	while ((pE=q++)!=NULL)
		{
		if (pE->IsDir())
			pE->Dir().WriteFiles();
		}
	TheLevel--;
	}

void CMemDir::Write()
//
// Write the current directory.
//
	{

	test(iBase==TheCurrentBase);
	TInt size=iSize-sizeof(TInt);
	test(TheFile.Write(TPtrC8((TUint8*)&size,sizeof(TInt)))==KErrNone);
	TDblQueIter<CMemEntry> q(iEntryQ);
	CMemEntry* pE;
	while ((pE=q++)!=NULL)
		pE->Write();
	TInt sz=(TheCurrentBase-iBase);
	test(sz==iSize);
	}

TFileName CMemDir::Name(const TDesC& aName)
//
// Make a full path name from aName.
//
	{

	TFileName n(*iPath);
	n+=_L("\\");
	n+=aName;
	return(n);
	}

void CMemDir::LoadDirL(const TDesC& aPath)
//
// Load a directory.
//
	{

	TheLevel++;
	iPath=aPath.AllocL();
	TFileName name=Name(_L("*.*"));
	test.Printf(_L("%*p%S\n"),TheLevel<<1,&name);
	CDir* pD;
	test(TheFs.GetDir(Name(_L("*.*")),KEntryAttMatchMask,EDirsFirst|ESortByName,pD)==KErrNone);
	TInt count=pD->Count();
	TInt i=0;
	while (i<count)
		{
		const TEntry& e=(*pD)[i++];
		TParse parse;
		parse.Set(e.iName,NULL,NULL);
		if (!parse.Ext().CompareF(_L(".NCB")))
			continue; // Ignore .ncb files - cannot open/read them.
		CMemEntry* pE=CMemEntry::New(e);
		iEntryQ.AddLast(*pE);
		}
	delete pD;
	TDblQueIter<CMemEntry> q(iEntryQ);
	CMemEntry* pE;
	while ((pE=q++)!=NULL)
		{
		if (pE->IsDir())
			{
			CMemDir* pM=CMemDir::NewL();
			pE->SetDir(*pM);
			pM->LoadDirL(Name(pE->Name()));
			}
		else
			pE->SetDir(*this);
		}
	TheLevel--;
	}

LOCAL_C void buildRomImageL()
//
// Build the ROM image.
//
	{

	test.Start(_L("Parse command line"));
	HBufC* buf=HBufC::New(RProcess().CommandLineLength());
   	test(buf!=NULL);
 	TPtr cmd = buf->Des();
 	RProcess().CommandLine(cmd);
	TLex lex(*buf);
	TFileName n=lex.NextToken();
	if (n.Length()==0)
		n=_L("\\F32");
	test(n.Length()!=0);
	if (n.Right(1)==_L("\\"))
		n.SetLength(n.Length()-1);
//
	test.Next(_L("Create root mem dir"));
	TRAPD(r,TheRootDir=CMemDir::NewL());
	test(r==KErrNone);
//
	test.Next(_L("Load directory structure"));
	TheLevel=(-1);
	TRAP(r,TheRootDir->LoadDirL(n));
	test(r==KErrNone);
	test(TheLevel==(-1));
//
	delete buf;
	test.End();
	}

LOCAL_C void baseRomImage()
//
// Set base addresses for the ROM image.
//
	{

	test.Start(_L("Setting up the header"));
	Mem::FillZ(&TheRomHeader,sizeof(TRomHeader));
	test.Printf(_L("1"));
	TheRomHeader.iVersion=TVersion(1,0,1);
	test.Printf(_L("2"));
	TTime t;
	t.HomeTime();
	test.Printf(_L("3"));
	TheRomHeader.iTime=t.Int64();
	test.Printf(_L("4"));
	TheRomHeader.iRomBase=UserSvr::RomHeaderAddress();
	test.Printf(_L("5"));
	TheRomHeader.iRomRootDirectoryList=TheCurrentBase=UserSvr::RomHeaderAddress()+sizeof(TRomHeader);
	test.Printf(_L("6"));
//
	test.Next(_L("Set dirs base"));
	TheRootDir->SetBaseDirs();
//
	test.Next(_L("Set files base"));
	TheRootDir->SetBaseFiles();
	TheRomHeader.iRomSize=TheCurrentBase-UserSvr::RomHeaderAddress();
//
	test.End();
	}

LOCAL_C void writeRomImage()
//
// Write the ROM image.
//
	{

	test.Start(_L("Write rom file header"));
//
	TPckgBuf<TRomFileHeader> fileHeadB;
	fileHeadB.FillZ(fileHeadB.MaxLength());
	TRomFileHeader& fileHead=fileHeadB();
	Mem::Copy(&fileHead.iName[0],"EPOC468 ROM     ",KRomFileHeaderNameSize);
	Mem::Copy(&fileHead.iVersionStr[0],"0.01",4);
	Mem::Copy(&fileHead.iBuildNumStr[0],"   1",4);
	fileHead.iRomSize=TheRomHeader.iRomSize;
	fileHead.iHeaderSize=KRomFileHeaderSize;
	test(TheFile.Write(fileHeadB)==KErrNone);
//
	test.Next(_L("Write rom header"));
	TheFiller.FillZ(TheFiller.MaxLength());
	TPckgC<TRomHeader> head(TheRomHeader);
	test(TheFile.Write(head)==KErrNone);
	TheCurrentBase=UserSvr::RomHeaderAddress()+sizeof(TheRomHeader);
//
	test.Next(_L("Write directories"));
	TheLevel=(-1);
	TheRootDir->WriteDirs();
	test(TheLevel==(-1));
//
	test.Next(_L("Write files"));
	TheLevel=(-1);
	TheRootDir->WriteFiles();
	test(TheLevel==(-1));
//
	test.End();
	}

GLDEF_C void CallTestsL(void)
//
// Test the file server.
//
    { 	
	test.Title();

#if defined(__WINS__) 
	test.Printf(_L("Running on WINS.  Skipping ROM test"));
	return;
#endif
//
	test.Start(_L("Testing rom"));

	TInt r=TheFs.Delete(TheFileName);
	if (r==KErrAccessDenied)
		{
		test.Printf(_L("Error: Cannot access %S"),&TheFileName);
		test.End();
		return;
		}
	test(r==KErrNone || r==KErrNotFound);
//
	test.Next(_L("Generating ROM image"));
	TRAP(r,buildRomImageL());
	test(r==KErrNone);
//
	test.Next(_L("Basing the rom image"));
	baseRomImage();
//
	TBuf<0x80> b=_L("Writing ROM file ");
	b+=TheFileName;
	test.Next(b);
	r=TheFile.Replace(TheFs,TheFileName,EFileStream|EFileWrite);
	test(r==KErrNone);
	writeRomImage();
	TheFile.Close();
	delete TheRootDir;

	test.End();
	return;
    }