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

//

#include <bookmarkdatabase.h>

#include "testutils.h"

#include "tbookmarktests.h"

#include <e32test.h>

#include <f32file.h>

#include <badesca.h>

#include <connect/sbdefs.h>

#include <connect/sbeclient.h>

#include "srvrepos.h"

#include "srvres.h"

#include "cachemgr.h"

#include "backup.h"

#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected)

_LIT ( KMyFolder, "BackupFolder" );

_LIT(KTxtBookmark1, "Bookmark 1");

_LIT8(KBookmarkUri, "www.ft.com");

_LIT(KTitle, "Bookmark Backup Restore Test");

LOCAL_D RTest gTest(KTitle());

LOCAL_D CTestWrapper* gTestWrapper;

CActiveScheduler* globalAS;

CRepositoryBackupClient* backupClient;

CDesC8ArraySeg* originalData1;

CDesC8ArraySeg* originalData2;

_LIT_SECURE_ID( SecureId1, 0x102078CB );

_LIT( K10205af8, "10205AF8.txt" );

_LIT( K10205af9, "10205AF9.txt" );

_LIT( K10205afa, "10205AFA.txt" );

_LIT( K10205afb, "10205AFB.txt" );

const TUid KUidBookmarkDatabaseRepository   = { 0x10205AF8 };

const TUid KUidFolderRepository             = { 0x10205AF9 };

const TUid KUidBookmarkRepository           = { 0x10205AFA };

const TUid KUidIconRepository               = { 0x10205AFB };

LOCAL_C	void ResetRepositoryL ( TUid aUid )

	{

	CRepository* repository = CRepository::NewL ( aUid );

	CleanupStack::PushL ( repository );

	User::LeaveIfError ( repository->Reset() );	

	CleanupStack::PopAndDestroy ( repository );

	}

/**

Creates a database.

Creates a folder.

Creates a bookmark.

*/

LOCAL_C void CreateBookmarkInFolderL()

	{

	//This will ensure that the old repositories are deleted

	ResetRepositoryL ( KUidBookmarkDatabaseRepository );

	ResetRepositoryL ( KUidFolderRepository );

	ResetRepositoryL ( KUidBookmarkRepository );

	ResetRepositoryL ( KUidIconRepository );

	// Open the database

	RBkDatabase database;

	database.OpenL();

	CleanupClosePushL(database);

	//Create a folder

	RBkFolder folder = database.CreateFolderL(KMyFolder);

	CleanupClosePushL(folder);

	// Create a bookmark in the new folder

	RBkBookmark bmrk = database.CreateBookmarkL(&folder);

	CleanupClosePushL(bmrk);

	// Set some bookmark properties

	bmrk.SetTitleL(KTxtBookmark1);

	bmrk.SetUriL(KBookmarkUri);

	// Close the bookmark

	CleanupStack::PopAndDestroy(&bmrk);

	// Close the folder

	CleanupStack::PopAndDestroy(&folder);

	// Commit the changes to the database and close it

	database.CommitL();

	CleanupStack::PopAndDestroy(&database);

	gTest.Printf(_L("\n*** Created database, folder, bookmark ***\n"));		

	}

/**

Deletes all the files in the temporary repository folder.

The temporary repository folder used is 10281FE5.

*/

LOCAL_C void DeleteFilesL()

	{

	_LIT( KOldInstallFiles, "c:\\private\\10281FE5\\*.*" );

	_LIT( KOldPersistFiles, "c:\\private\\10281FE5\\persists\\*.*" );

	CFileMan* fm = CFileMan::NewL( TServerResources::iFs );

	CleanupStack::PushL( fm );

	TInt r = fm->Delete( KOldInstallFiles );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

		User::Leave(r);

	r = fm->Delete( KOldPersistFiles );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

		User::Leave(r);

	gTest.Printf(_L("\n*** Deleted files from temporary repository ***\n"));

	CleanupStack::PopAndDestroy( fm );

	}

/**

Deletes all the files in the original bookmarks repository folder.

The bookmarks repository folder is 10202be9

*/

LOCAL_C void DeleteRepositoryFilesL()

	{

	_LIT( KOldInstallFiles, "c:\\private\\10202be9\\*.cre" );

	_LIT( KOldPersistFiles, "c:\\private\\10202be9\\persists\\*.cre" );

	CFileMan* fm = CFileMan::NewL( TServerResources::iFs );

	CleanupStack::PushL( fm );

	TInt r = fm->Delete( KOldInstallFiles );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

		User::Leave(r);

	r = fm->Delete( KOldPersistFiles );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

		User::Leave(r);

	gTest.Printf(_L("\n*** Deleted files from original repository ***\n"));

	CleanupStack::PopAndDestroy( fm );

	}

LOCAL_C void CheckL( TInt aValue, TInt aExpected)

	{

	if ( aValue != aExpected )

		{

		DeleteFilesL();

		RDebug::Print( _L( "*** Expected error: %d, got: %d\r\n"), aExpected, aValue );

		}

	}

/**

Does a copy of the config files from the ROM area to the temporary repository folder.

The bookmark component has 4 config files 10205AF8.txt, 10205AF9.txt, 10205AFA.txt and

10205AFB.txt.

*/	

LOCAL_C void InstallFileSetL(const TDesC& afilename)

	{

	_LIT( KFileSrcPath, "\\private\\10202be9\\" );

	_LIT( KInstallFileDestPath, "\\private\\10281FE5\\" );

	_LIT( KPersistFileDestPath, "\\private\\10281FE5\\persists\\" );

	_LIT( KDriveC, "c:" );

	_LIT( KDriveZ, "z:" );

	TBuf<KMaxFileName> dest;

	TBuf<KMaxFileName> src;

	TBuf<KMaxFileName> src2;

	TBuf<KMaxFileName> dest2;

	TInt r;

	CFileMan* fm = CFileMan::NewL( TServerResources::iFs );

	CleanupStack::PushL( fm );

	dest.Copy( KDriveC );

	dest.Append( KInstallFileDestPath );

	dest.Append( afilename );

	r = fm->Delete( dest );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

	User::Leave( r );

	r = TServerResources::iFs.MkDirAll( dest );

	if ( r != KErrNone && r != KErrAlreadyExists )

	User::Leave( r );

	src.Copy( KDriveZ );

	src.Append( KFileSrcPath );

	src.Append( afilename );

	User::LeaveIfError( fm->Copy( src, dest ) );

	r = fm->Attribs( dest, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse );

	TEST2( r, KErrNone );

	dest2.Copy( KDriveC );

	dest2.Append( KPersistFileDestPath );

	dest2.Append( afilename  );

	r = fm->Delete( dest2 );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

	User::Leave( r );

	r = TServerResources::iFs.MkDirAll( dest2 );

	if ( r != KErrNone && r != KErrAlreadyExists )

	User::Leave( r );

	src2.Copy( KDriveZ );

	src2.Append( KFileSrcPath );

	src2.Append( afilename );

	User::LeaveIfError( fm->Copy( src2, dest2 ) );

	r = fm->Attribs( dest2, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse );

	TEST2( r, KErrNone );

	CleanupStack::PopAndDestroy( fm );

	}

/**

Does the backup of the repository.

*/

LOCAL_C void BackupRepositoryL( CDesC8ArraySeg* aDataStream )

	{

	backupClient->CompleteOwnerIdLookupTableL();

	//The SecureId1 has to be the same as the value for [owner] tag in each of the

	//config files

	backupClient->InitialiseGetProxyBackupDataL( SecureId1, EDriveC );

	HBufC8* transferBuffer = HBufC8::NewL( 128 );

	CleanupStack::PushL( transferBuffer );

	TPtr8 bufferToSend = transferBuffer->Des();

	TBool finished = EFalse;

	aDataStream->Reset();

	do 

		{

		bufferToSend.Zero();

		backupClient->GetBackupDataSectionL( bufferToSend, finished );

		aDataStream->AppendL( bufferToSend );

		} while ( !finished );

	gTest.Printf(_L("\n*** Backup process completed successfully ***\n"));	

	CleanupStack::PopAndDestroy( transferBuffer );

	}

/**

Does a restore of the backed up data.

@param aDataStream

	Carries the backed up data.	

*/

LOCAL_C void RestoreRepositoryL( CDesC8ArraySeg* aDataStream )

	{

	backupClient->InitialiseRestoreProxyBaseDataL( SecureId1, EDriveC );

	HBufC8* transferBuffer = HBufC8::NewL( 128 );

	CleanupStack::PushL( transferBuffer );

	TPtr8 bufferToSend = transferBuffer->Des();

	TBool finished = EFalse;

	TInt count = aDataStream->Count();

	TInt element = 0;

	for ( element = 0; element < count; element++ ) 

		{

		bufferToSend.Zero();

		bufferToSend.Append( (*aDataStream)[ element ] );

		if ( element + 1 == count )

			finished = ETrue;

		backupClient->RestoreBaseDataSectionL( bufferToSend, finished );

		}

	backupClient->RestoreComplete( EDriveC );

	gTest.Printf(_L("\n*** Restoration completed successfully ***\n"));

	CleanupStack::PopAndDestroy( transferBuffer );

	}

/**

Initializes the descriptors required for the backup and restore process

*/

LOCAL_C void InitializationLC()    

    {

    originalData1 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( originalData1 );

	originalData2 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( originalData2 );

	}

/**

Cleans up the used resources

*/

LOCAL_C void CleanupL()

    {

    CleanupStack::PopAndDestroy( originalData2 );

    CleanupStack::PopAndDestroy( originalData1 );

    }

/**

Move the restored (.cre) files from the temporary repository folder to the original repository 

folder.

*/

LOCAL_C void MoveFilesToOriginalRepositoryL()

{

	_LIT( KFileSrcPath, "\\private\\10281FE5\\persists\\" );

	_LIT( KFileDestPath, "\\private\\10202be9\\persists\\" );

	_LIT( KDriveC, "c:" );

	_LIT( KAllFiles, "*.*");

	TBuf<KMaxFileName> dest;

	TBuf<KMaxFileName> src;

	TInt r;

	CFileMan* fm = CFileMan::NewL( TServerResources::iFs );

						CleanupStack::PushL( fm );

	dest.Copy( KDriveC );

	dest.Append( KFileDestPath );

	dest.Append( KAllFiles );

	r = TServerResources::iFs.MkDirAll( dest );

	if ( r != KErrNone && r != KErrAlreadyExists )

	User::Leave( r );

	src.Copy( KDriveC );

	src.Append( KFileSrcPath );

	src.Append( KAllFiles );

	User::LeaveIfError( fm->Copy( src, dest ) );

	r = fm->Attribs( dest, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse );

	TEST2( r, KErrNone );

	gTest.Printf(_L("\n*** Restored files to original repository ***\n"));

	CleanupStack::PopAndDestroy( fm );

}

LOCAL_D TBool IsItemInFolderL(const TDesC& aName, RBkFolder& aFolder)	

	{

	RBkNode item;

	TBool found = EFalse;

	TInt index = aFolder.Count() - 1;

	for (;index >= 0; --index)

		{

		item = aFolder.OpenItemL(index);

		CleanupClosePushL(item);

		const TDesC& title = item.Title();

		if (title.Compare(aName) == 0)

			{

			found = ETrue;

			}

		CleanupStack::PopAndDestroy(&item);

		if (found)

			{

			break;

			}

		}

	return found;

	}

/**

Checks if the Repository is restored along with the foleder and the bookmark created

previously

*/

LOCAL_C void CheckRepositoryL()

{

	RBkDatabase database1;

	database1.OpenL();

	CleanupClosePushL(database1);

	RBkFolder folder;

	TRAPD(err1, folder = database1.OpenFolderL(KMyFolder));

	gTestWrapper->TEST(err1 == KErrNone);

	CleanupClosePushL(folder);

	gTestWrapper->TEST(IsItemInFolderL(KTxtBookmark1, folder));

	CleanupStack::PopAndDestroy(&folder);

	CleanupStack::PopAndDestroy(&database1);

}

/**

Creates a bookmark database. Cretes a temporary repository folder with the repositories in it. 

Does a backup and a restore to the temporary repository and then to the original repository and 

deletes the temporary repository.

*/

LOCAL_C void INC081573L()

	{

	// create and install the active scheduler we need

	CActiveScheduler* s = new(ELeave) CActiveScheduler;

	CleanupStack::PushL( s );

	CActiveScheduler::Replace( s );

	//Create folder and bookmark

	CreateBookmarkInFolderL();

	backupClient = CRepositoryBackupClient::NewLC(TServerResources::iFs);

	TServerResources::iCacheManager->DisableCache();

	gTest.Printf(_L("\n*** File installation started ***\n"));

	// Install known files

	InstallFileSetL(K10205af8);

	InstallFileSetL(K10205af9);

	InstallFileSetL(K10205afa);

	InstallFileSetL(K10205afb);

	gTest.Printf(_L("\n*** File installation completed successfully ***\n"));

	// backup known files, 

	BackupRepositoryL( originalData1 );

	// delete files

	DeleteFilesL();

	//delete repository files

	DeleteRepositoryFilesL();

	// restore when other files do not exist

	RestoreRepositoryL( originalData1 );

	//move files back to repository

	MoveFilesToOriginalRepositoryL();

	//delete the temporary repository

	DeleteFilesL();

	CleanupStack::PopAndDestroy( backupClient );

	// Cleanup the scheduler

	CActiveScheduler::Replace( globalAS );

	CleanupStack::PopAndDestroy( s );

	CheckRepositoryL();

	}

/**

Starts the backup and restore tests

*/

void DoBackupTestL()

	{

	InitializationLC();

	INC081573L();

	TServerResources::iOwnerIdLookUpTable.Reset();

	CleanupL();

	}

LOCAL_C void MainL()

	{

	__UHEAP_MARK;

	gTest.Start( _L( "\n*** Backup and restore tests ***\n" ) );

	gTest.Printf(_L("@SYMTestCaseID IWS-APPPROTOCOLS-BOOKMARKS-TBACKUPTEST-0001 "));	

	// create and install the active scheduler we need for the cache manager in TServerResources::InitialiseL

	globalAS=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(globalAS);

	CActiveScheduler::Install(globalAS);

	TServerResources::InitialiseL();

	gTestWrapper = CTestWrapper::NewLC(gTest);

	gTestWrapper->Start(_L("\n*** Bookmark Test ***\n"));

	DoBackupTestL();

	gTestWrapper->End();

	CleanupStack::PopAndDestroy(gTestWrapper);

	TServerResources::Close();

	CleanupStack::PopAndDestroy(globalAS);

	gTest.End();

	gTest.Close();

	__UHEAP_MARKEND;

	}

TInt E32Main()

	{	

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if ( !cleanup )

		return KErrNoMemory;

	TRAPD( err, MainL()  );

	if ( err != KErrNone )

		User::Panic( _L( "Testing failed: " ), err );

	delete cleanup;

	__UHEAP_MARKEND;

	return 0;	

	}