// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// msvtestutils.cpp

//

#include "msvtestutils.h"

#include "MSVSERV.H"

#include <e32uid.h>

#include <mtsr.h>

#include <msvruids.h>

#include <txtfmlyr.h>

#include <txtetext.h>

#include <txtrich.h>

#include <miuthdr.h>

#include <mtclbase.h>

#include <flogger.h>

#include <msventryscheduledata.h>

#include <csch_cli.h>

#include <sqldb.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#include "timrfc822datefield.h"

#endif

_LIT(KStoreInitFileName, "\\private\\1000484b\\StoreInit.tmp");

#ifdef SYMBIAN_MESSAGESTORE_UNIT_TESTCODE

_LIT(KDbFileName, "\\messaging.db");

#else

_LIT(KDbFileName, "[1000484B]messaging.db");

#endif

//

//

//	TestMsvOperationTimer

//

//

EXPORT_C TestMsvOperationTimer* TestMsvOperationTimer::NewLC(CConsoleBase* aConsole, CMsvOperation* aMsvOperation, RTest& aRTest)

	{

	TestMsvOperationTimer* self = new(ELeave) TestMsvOperationTimer(aConsole, aMsvOperation, aRTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C TestMsvOperationTimer::TestMsvOperationTimer(CConsoleBase* aConsole, CMsvOperation* aMsvOperation, RTest& aRTest)

	: CTimer(EPriorityStandard+3), iMsvOperation(aMsvOperation), iRTest(aRTest)

	{

	iConsole = aConsole;

	iPeriod = KPeriod;

	iClosing = EFalse;

	iCount = 0;

	}

EXPORT_C void TestMsvOperationTimer::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

EXPORT_C void TestMsvOperationTimer::IssueRequest()

	{

	After(iPeriod);

	}

EXPORT_C void TestMsvOperationTimer::DoCancel()

	{

	CTimer::DoCancel();

	}

EXPORT_C void TestMsvOperationTimer::RunL()

	{

	// display the current progress

	TMsvId temp;	

	TPckgC<TMsvId> paramPack(temp);

	const TDesC8& progBuf = iMsvOperation->ProgressL();	

	paramPack.Set(progBuf);

	TMsvId progress=paramPack();	

	iRTest.Console()->SetPos(0, 10);

	iRTest.Printf(_L("   MessageId %d		\n"),progress);

	IssueRequest();

	};

//

//

//	CMsvTestUtils

//

//

EXPORT_C CMsvTestUtils::CMsvTestUtils(RTest& aRTest)

: CTestUtils(aRTest)

	{

	}

EXPORT_C CMsvTestUtils::~CMsvTestUtils()

	{

	Reset();

	delete iServerMtmDllRegistry;

	delete iMtmRegistryControl;

	}

EXPORT_C void CMsvTestUtils::Reset()

	{

	delete iMsvEntry;

	iMsvEntry = NULL;

	delete iServerEntry;

	iServerEntry = NULL;

	delete iMsvServer;

	iMsvServer = NULL;

	delete iClientMtmRegistry;

	iClientMtmRegistry = NULL;

	if(iMsvSession!=NULL)

		{

		iMsvSession->CloseMessageServer();	

		}

	delete iMsvSession;

	iMsvSession = NULL;

	delete iDummyObserver;

	iDummyObserver = NULL;

	iClientServer = ENeither;

	SpecifyRfc822Dir(KRfc822Files);	

	}

EXPORT_C CBaseMtm* CMsvTestUtils::InstantiateClientMtmL(TUid aMtmType, TMsvId aServiceId)

	{

	// client side

	__ASSERT_ALWAYS(iClientServer == EClientSide, Panic(KErrGeneral));

	if (!iClientMtmRegistry)

		{

		iClientMtmRegistry = CClientMtmRegistry::NewL(*iMsvSession);

		}

	CBaseMtm* newMtm = iClientMtmRegistry->NewMtmL(aMtmType);

	CMsvEntry* entry = iMsvSession->GetEntryL(aServiceId);

	CleanupStack::PushL(entry);

	newMtm->SetCurrentEntryL(entry);

	CleanupStack::Pop(); //entry

	return newMtm;

	}

EXPORT_C CBaseServerMtm* CMsvTestUtils::InstantiateServerMtmL(TUid aMtmType, TMsvId aServiceId)

	{

	// server side

	__ASSERT_ALWAYS(iServerMtmDllRegistry, Panic(KErrGeneral));

	__ASSERT_ALWAYS(iClientServer == EServerSide, Panic(KErrNotSupported));

	User::LeaveIfError(iServerEntry->SetEntry(aServiceId));  	

	CBaseServerMtm* newMtm = iServerMtmDllRegistry->NewServerMtmL(aMtmType, iServerEntry);

	return newMtm;

	}

EXPORT_C void CMsvTestUtils::GoClientSideL()

	{

	Reset();

 	iFs.SetSessionPath(iDriveName);

	iDummyObserver = new (ELeave) TMsvDummyObserver;

	iMsvSession = CMsvSession::OpenSyncL(*iDummyObserver);

	iMsvEntry = CMsvEntry::NewL(*iMsvSession, KMsvRootIndexEntryId, TMsvSelectionOrdering());

	iClientServer = EClientSide;

	}

EXPORT_C void CMsvTestUtils::GoServerSideL()

	{

	Reset();

	_LIT(KMsvServerPattern, "!MsvServer*");

	TFindProcess findprocess(KMsvServerPattern);

	TFullName name;

	// wait for the server to close before trying to start

	// one within this process.

	for(;;)

		{	

		TFindServer find(KMsvServerPattern);

		if (find.Next(name) != KErrNone)

			break;

		User::After(100000);

		}

	iMsvServer = CMsvServer::NewL();

	// wait a couple of seconds

	CTestTimer* timer = CTestTimer::NewL();

	timer->After(5000000);

	CActiveScheduler::Start();

	delete timer;

	iServerEntry = CMsvServerEntry::NewL(*iMsvServer, KMsvRootIndexEntryId);

	iClientServer = EServerSide;

	}

EXPORT_C void CMsvTestUtils::CreateServerMtmRegL(const TUid aMsgType, const TDesC& aHumanReadableName, const TMsvTestDllInfo& aServerMtm, const TMsvTestDllInfo& aClientMtm, const TMsvTestDllInfo& aUiMtm, const TMsvTestDllInfo& aUiDataMtm, const TUid aGroup, const TDesC& aDatFile)

	{

	CMtmDllInfoArray* mtmdllinfoarray=new(ELeave) CMtmDllInfoArray();

	CleanupStack::PushL(mtmdllinfoarray);

	CMtmDllInfo* mtmdllinfo1=CMtmDllInfo::NewL(aHumanReadableName,TUidType(KDynamicLibraryUid,KUidMtmServerComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),aServerMtm.iFileName,aServerMtm.iOrdinal,aServerMtm.iVersion);

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo1);

	CMtmDllInfo* mtmdllinfo2=CMtmDllInfo::NewL(aHumanReadableName,TUidType(KDynamicLibraryUid,KUidMtmClientComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),aClientMtm.iFileName,aClientMtm.iOrdinal,aClientMtm.iVersion);

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo2);

	CMtmDllInfo* mtmdllinfo3=CMtmDllInfo::NewL(aHumanReadableName,TUidType(KDynamicLibraryUid,KUidMtmUiComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),aUiMtm.iFileName,aUiMtm.iOrdinal,aUiMtm.iVersion);

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo3);

	CMtmDllInfo* mtmdllinfo4=CMtmDllInfo::NewL(aHumanReadableName,TUidType(KDynamicLibraryUid,KUidMtmUiDataComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),aUiDataMtm.iFileName,aUiDataMtm.iOrdinal,aUiDataMtm.iVersion);

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo4);

	// Create an empty capability set for creating a new group data object

	TCapabilitySet capSet;

	capSet.SetEmpty();

	CleanupStack::Pop(mtmdllinfoarray); // next line takes ownership

	CMtmGroupData* mtmgroupdata=CMtmGroupData::NewL(aMsgType, aGroup, mtmdllinfoarray, capSet);

	CleanupStack::PushL(mtmgroupdata);

	CFileStore* filestore = CPermanentFileStore::ReplaceLC(FileSession(), aDatFile, EFileShareExclusive|EFileStream|EFileWrite);

	TUidType uidtype(KPermanentFileStoreLayoutUid, KUidMsvDataComponent, aMsgType);

	filestore->SetTypeL(uidtype);

	RStoreWriteStream out;

	TStreamId streamid=out.CreateLC(*filestore);	// Push to stack

	mtmgroupdata->ExternalizeL(out);

	out.CommitL();

	CleanupStack::PopAndDestroy(); // out

	filestore->SetRootL(streamid);

	filestore->CommitL();

	CleanupStack::PopAndDestroy(2, mtmgroupdata); // filestore, mtmgroupdata

	}

EXPORT_C TMsvId CMsvTestUtils::CreateServiceL(const TUid aMtm, TBool aReadOnly, TBool aVisible)

	{

	TMsvId id = 0;

	TMsvEntry entry;

	entry.iMtm = aMtm;

	entry.iType = KUidMsvServiceEntry;

	entry.SetReadOnly(aReadOnly);

	entry.SetVisible(aVisible);

	SetEntryL(KMsvRootIndexEntryId);

	CreateEntryL(entry);

	id = entry.Id();

	SetEntryL(id);

	return id;

	}

EXPORT_C void CMsvTestUtils::CreateRegistryObjectAndControlL()

	{

	//	Create the registry object

	if (!iServerMtmDllRegistry)

		iServerMtmDllRegistry = CServerMtmDllRegistry::NewL(iFs);

	//	Create the registry control..

	if (!iMtmRegistryControl)

		iMtmRegistryControl = CMtmRegistryControl::NewL(iFs, *iServerMtmDllRegistry);

	iRegistryObjectAndControlCreated = ETrue;

	}

EXPORT_C void CMsvTestUtils::InstallMtmGroupL(const TDesC& aDatFile)

	{

	TInt err = KErrNone;

	if (iClientServer == EClientSide)

		{

		err = iMsvSession->InstallMtmGroup(aDatFile);

		}

	else

		{

		User::LeaveIfNull(iServerMtmDllRegistry);

		User::LeaveIfNull(iMtmRegistryControl);

		//	Actually load the group data...

		TUid aUid;

		err = iMtmRegistryControl->InstallMtmGroup(aDatFile, aUid);

		}

	if (err != KErrAlreadyExists)

		User::LeaveIfError(err);

	}

EXPORT_C void CMsvTestUtils::CleanMessageFolderL()

	{

	//Kill the message server if its running

	_LIT(KMsvServerPattern, "!MsvServer*");

	TFindProcess findprocess(KMsvServerPattern);

	TFullName name;

	if(findprocess.Next(name)==KErrNone)

		{

		RProcess process;

    	User::LeaveIfError(process.Open(findprocess));

     	process.Kill(KErrCancel) ;

		process.Close() ;

		}

	// Wait for the server to close before trying to remove

	// the message folder

	TInt loopCount = 0;

	FOREVER

		{

		TFindServer find(KMsvServerPattern);

		if (find.Next(name) != KErrNone)

			break;

		User::After(1000000);

		++loopCount;

		if(loopCount > 5)

			{

			User::Invariant();

			}

		}

	// remove the drive from the system ini 

	CDictionaryFileStore* store = CDictionaryFileStore::SystemLC(iFs);

	if (store->IsPresentL(KUidMsvMessageDriveStream))

		{

		store->RemoveL(KUidMsvMessageDriveStream); 

		store->CommitL();

		}

	CleanupStack::PopAndDestroy(); // store

	CFileMan* fileMan = CFileMan::NewL(iFs); 

	CleanupStack::PushL(fileMan);

	TParse parse;

	TInt error;

	TFileName fileName(KMsvDefaultFolder2); 

	TChar driveChar=FileSession().GetSystemDriveChar();

 	TBuf<2> systemDrive = iDriveName;

	parse.Set(fileName, &systemDrive, NULL);

	error = fileMan->RmDir(parse.DriveAndPath()); 

	error = iFs.RmDir(parse.DriveAndPath()); 

	if (!(error==KErrNotFound||error==KErrNone || error == KErrPathNotFound))

		{

        TPtrC driveAndPath = parse.DriveAndPath();

		Printf(_L("Directory %S cannot be removed. "), &driveAndPath);

		Printf(_L("Please ensure directory is not in use.\n"));

		User::Leave(KErrAccessDenied);

		}

	//delete DBs in C:, D: and E:.

	TPath pathNameTemp(iDriveName);

	pathNameTemp.Append(KDbFileName);

	RSqlDatabase::Delete(pathNameTemp);

	pathNameTemp = _L("D:");

	pathNameTemp.Append(KDbFileName);

	RSqlDatabase::Delete(pathNameTemp);

	pathNameTemp = _L("E:");

	pathNameTemp.Append(KDbFileName);	

	RSqlDatabase::Delete(pathNameTemp);

	// delete "StoreInit.tmp"

 	TPath pathName(iDriveName);

	pathName.Append(KStoreInitFileName);  	

	iFs.Delete(pathName); 

	CleanupStack::PopAndDestroy(fileMan);

	}

EXPORT_C void CMsvTestUtils::FindChildrenL(TMsvId aFolderToTraverse, const TFileName& aFilepath, TBool aReplace, TBool aOtherFiles)

	{

	SpecifyLogsDir(aFilepath);

	FindChildrenL(aFolderToTraverse, aReplace, aOtherFiles);

	}

EXPORT_C void CMsvTestUtils::FindChildrenL(TMsvId aFolderToTraverse, TBool aReplace, TBool aOtherFiles)

	{

	iFileCount=0;

	CDir* rfcFileList;

	// Loads the any test files into an EntryList

	iFs.GetDir(iRfc822Dir, KEntryAttNormal, ESortByName, rfcFileList);

	TMsvSelectionOrdering ordering;

	ordering.SetShowInvisibleEntries(ETrue);

	TMsvId entryId;

	if (iClientServer==EClientSide)

		{

		entryId=iMsvEntry->Entry().Id();

		iMsvEntry->SetEntryL(aFolderToTraverse);

		iMsvEntry->SetSortTypeL(ordering);

		}

	else

		{

		entryId=iServerEntry->Entry().Id();

		iServerEntry->SetEntry(aFolderToTraverse);

		iServerEntry->SetSort(ordering);

		}

	RFile file;

	TFileName filename(iLogsDir);

	filename.Append(KFileNameEntryStructure);

	// Print out Hierarchy - Save to file

	if (aReplace)

		{

		// replace both Entry_Structure.txt and Entry_RichTextBodies.txt

		TInt err1 = file.Replace(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

		if (err1==KErrNotFound) // file does not exist - create it

			err1=file.Create(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

		if (err1 == KErrNone)

			ListChildrenL(aReplace, aOtherFiles, file, *rfcFileList);

		}

	else

		{

		TInt err1 = file.Open(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

		if (err1==KErrNotFound)

			file.Create(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

		else if (err1 != KErrNone)

			User::Leave(err1);

		TInt position=1;

		User::LeaveIfError(file.Seek(ESeekEnd, position));

		ListChildrenL(aReplace, aOtherFiles, file, *rfcFileList);

		}

	file.Close();

	if (iClientServer==EClientSide)

		iMsvEntry->SetEntryL(entryId);

	else

		iServerEntry->SetEntry(entryId);

	delete rfcFileList;

	}

EXPORT_C void CMsvTestUtils::WriteBodyDataL(TMsvId aId, const TFileName& aFilepath, CMsvStore& fileStore, TBool aReplace)

	{

	CParaFormatLayer* paraLayer = CParaFormatLayer::NewL();

	CCharFormatLayer* charLayer = CCharFormatLayer::NewL();

	CRichText* body = CRichText::NewL(paraLayer,charLayer);

	fileStore.RestoreBodyTextL(*body);

	HBufC* pBodyText = HBufC::NewLC(body->DocumentLength()+(body->DocumentLength()/70)+1);

	TPtr pBody = pBodyText->Des();

	body->Extract(pBody, 0);

	RFile file;

	TFileName filename(aFilepath);

	filename.Append(KFileNameBodies);

	TInt err = KErrNone;

	if (aReplace)

		err = file.Replace(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

	else

		err = file.Open(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

	if(err==KErrNotFound) // file does not exist - create it

		err=file.Create(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

	TInt offset=0;

	iRTest(file.Seek(ESeekEnd, offset)==KErrNone);

	TBuf<100> buf;

	buf.Zero();

	buf.AppendFormat(_L("*** %d *************** RichText Data ***************\n"), aId);

	buf.AppendFormat(_L("Size >>> %d\n"), body->DocumentLength());	

	WriteToFileL(file, buf);

	RemoveRichtextFormating(pBody);

	WriteToFileL(file, pBody);

	buf.Zero();

	buf.AppendFormat(_L("\n********************* end of Body ***********************\n"));

	WriteToFileL(file, buf);

	CleanupStack::PopAndDestroy(); // pBodyText

	file.Close();

	delete paraLayer;

	delete charLayer;

	delete body;

	}

EXPORT_C void CMsvTestUtils::WriteFileDataL(TMsvId aId, const TFileName& aFileName, const TFileName& aLogFilepath, TBool aReplace)

	{

	TParse dirPath;

	RFile attach;

	dirPath.Set(aFileName, NULL, NULL);

	TInt err = KErrNone;

	if (attach.Open(iFs, dirPath.FullName(), KEntryAttNormal) != KErrNone)

		return; // failed to find attachment

	TFileName filename(aLogFilepath);

	filename.Append(KFileNameFiles);

	RFile file;

	if (aReplace)

		err = file.Replace(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

	else

		err = file.Open(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

	if(err==KErrNotFound) // file does not exist - create it

		err=file.Create(iFs, filename, EFileShareAny | EFileStreamText | EFileWrite);

	TInt offset=0;

	__ASSERT_ALWAYS(file.Seek(ESeekEnd, offset)==KErrNone, Panic(KErrGeneral));

	TBuf<100> buf;

	buf.Zero();