// 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 <e32test.h>

#include <f32file.h>

#include <badesca.h>

#include "srvrepos_noc.h"

#include "srvres.h"

#include "cachemgr.h"

#include "backup.h"

RTest TheTest(_L("Central Repository Backup & Restore Tests"));

enum FileSet

	{

	EOriginals,

	EChanged,

	ERemoved,

	EDEF058823L

	};

_LIT_SECURE_ID( SecureId1, 0x12345 );

TBool oomRunning;

HBufC* iniRomDir=NULL;

CRepositoryBackupClient* backupClient;

CDesC8ArraySeg* originalData1;

CDesC8ArraySeg* changedData1;

CDesC8ArraySeg* originalData2;

CDesC8ArraySeg* changedData2;

CDesC8ArraySeg* changedData3;

CActiveScheduler* globalAS;

const TUid KUidBackupTestRepository 	= { 0xbabababa };

const TUid KUidBackupTestRepository1 	= { 0x00000100 };

const TUint32 KBackupInt1 = 0x02010100;

const TInt KIntOrigValue1 = 10;

const TUint32 KBackupInt2 = 0x03010200;

const TInt KIntChangedValue2 = 200;

const TUint32 KBackupInt3 = 0x04010300;

const TInt KIntOrigValue3 = 30;

const TUint32 KBackupString1 = 0x02010600;

_LIT8(KStringOrigValue, "test original");

_LIT8(KStringChangedValue, "test changed");

const TUint32 KBackupString2 = 0x03010600;

const TUint32 KBackupReal1 = 0x02010700;

const TReal KRealOrigValue = 1.1;

const TUint32 KBackupReal2 = 0x03010700;

const TReal KRealChangedValue = 2.5;

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

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

//Test macroses and functions

LOCAL_C void NextTest(TPtrC aMsg)

	{

	if (!oomRunning)

		{

		TheTest.Next( aMsg );

		}

	}

LOCAL_C void DeleteFilesL()

	{

	_LIT( KOldInstallFiles, "c:\\private\\102081E4\\*.*" );

	_LIT( KOldPersistFiles, "c:\\private\\102081E4\\persists\\*.*" );

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

	CleanupStack::PushL( fm );

	TInt r = KErrNone;

	r = fm->Delete( KOldInstallFiles );

	if (r == KErrAccessDenied)

		{

		// we are not able to delete the files on ARM if their attributes are not set correctly.

		// Only set attributes when got KErrAccessDenied because it's time consuming in OOM test.

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

		User::LeaveIfError(r);

		r = fm->Delete( KOldInstallFiles );

		}

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

		User::Leave(r);

	r = fm->Delete( KOldPersistFiles );

	if (r == KErrAccessDenied)

		{

		// we are not able to delete the files on ARM if their attributes are not set correctly.

		// Only set attributes when got KErrAccessDenied because it's time consuming in OOM test.

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

		User::LeaveIfError(r);

		r = fm->Delete( KOldPersistFiles );

		}

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

		User::Leave(r);

	CleanupStack::PopAndDestroy( fm );

	}

LOCAL_C void CheckL( TInt aValue, TInt aLine )

	{

	if ( !aValue )

		{

		DeleteFilesL();

		TheTest( EFalse, aLine );

		}

	}

LOCAL_C void CheckL( TInt aValue, TInt aExpected, TInt aLine )

	{

	if ( aValue != aExpected )

		{

		DeleteFilesL();

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

		TheTest( EFalse, aLine );

		}

	}

#define TEST(arg) ::CheckL((arg), __LINE__)

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

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

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

LOCAL_C void InitializationL()

    {

    originalData1 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( originalData1 );

	changedData1 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( changedData1 );

	originalData2 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( originalData2 );

	changedData2 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( changedData2 );

	changedData3 = new(ELeave)CDesC8ArraySeg( 128 );

	CleanupStack::PushL( changedData3 );

    }

LOCAL_C void Cleanup()

    {

    CleanupStack::PopAndDestroy( changedData3 );

	CleanupStack::PopAndDestroy( changedData2 );

	CleanupStack::PopAndDestroy( originalData2 );

	CleanupStack::PopAndDestroy( changedData1 );

	CleanupStack::PopAndDestroy( originalData1 );

    }

LOCAL_C void InstallFileSetL( FileSet aFileSet )

	{

	_LIT(KSourceFiles_V1, "z:\\private\\10202BE9\\*.cra");

	_LIT(KSourceFiles_V2, "z:\\private\\10202BE9\\*.crb");

	_LIT(KDestForInstallFiles, "c:\\private\\102081E4\\*.cre");

	_LIT(KDestForPersistFiles, "c:\\private\\102081E4\\persists\\*.cre");

	_LIT(KDEF058823DestFile, "c:\\private\\102081E4\\persists\\*.*");

	_LIT(KDEF058823SrcFile, "z:\\private\\10202BE9\\babababa.cre");

	DeleteFilesL();

	// When the contents of the repository directories change, the cached iOwnerIdLookUpTable becomes invalid

	TServerResources::iOwnerIdLookUpTable.Reset();

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

	CleanupStack::PushL( fm );

	TInt r;

	switch ( aFileSet )

		{

		case EOriginals:

			{		

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

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

				User::Leave( r );

			User::LeaveIfError( fm->Copy( KSourceFiles_V1, KDestForInstallFiles ) );

			User::LeaveIfError( fm->Copy( KSourceFiles_V1, KDestForPersistFiles ) );

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

			if(r == KErrNoMemory)

				User::Leave(r);

			TEST2( r, KErrNone );

			break;

			}

		case EChanged:

			{

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

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

				User::Leave( r );

			User::LeaveIfError( fm->Copy( KSourceFiles_V1, KDestForInstallFiles ) );		

			User::LeaveIfError( fm->Copy( KSourceFiles_V2, KDestForPersistFiles ) );

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

			if(r == KErrNoMemory)

				User::Leave(r);

			TEST2( r, KErrNone );

			break;

			}

		case ERemoved:

			{

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

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

				User::Leave( r );

			User::LeaveIfError( fm->Copy( KSourceFiles_V1, KDestForInstallFiles ) );

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

			if(r == KErrNoMemory)

				User::Leave(r);

			TEST2( r, KErrNone );

			break;

			}

		case EDEF058823L:

		    {

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

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

				User::Leave( r );

			User::LeaveIfError( fm->Copy( KDEF058823SrcFile, KDEF058823DestFile ) );

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

			if(r == KErrNoMemory)

				User::Leave(r);

			TEST2( r, KErrNone );

			break;

		    }

		default:

			RDebug::Print( _L( "Illegal parameter to function: %d\r\n" ), aFileSet );

			TheTest( EFalse, __LINE__ );

		}

	CleanupStack::PopAndDestroy( fm );

	}

LOCAL_C void CleanupActiveScheduler(TAny* aShc)

	{

	CActiveScheduler::Replace( globalAS );

	delete aShc;

	}

LOCAL_C TBool StreamsAreIdenticalL( CDesC8ArraySeg* aDataStream1,  CDesC8ArraySeg* aDataStream2)

	{

	TInt count1 = 0;

	TInt count2 = 0;

	TInt element = 0;

	TInt length = 0;

	TInt total1 = 0;

	TInt total2 = 0;

	TBool retVal = EFalse;

	count1 = aDataStream1->Count();

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

		{

		length = (*aDataStream1)[ element ].Length();

		total1 += length;

		}

	count2 = aDataStream2->Count();

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

		{

		length = (*aDataStream2)[ element ].Length();

		total2 += length;

		}

	if ( total1 != total2 )

		return retVal;

	// Copying each array into a single descriptor before comparison is deliberate

	// to make it easier to inspect the contents in a debugger

	HBufC8* buffer1 = HBufC8::NewLC( total1 );

	TPtr8 tPtr1( buffer1->Des() );

	HBufC8* buffer2 = HBufC8::NewLC( total2 );

	TPtr8 tPtr2( buffer2->Des() );

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

		{

		tPtr1.Append( (*aDataStream1)[ element ] );

		}

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

		{

		tPtr2.Append( (*aDataStream2)[ element ] );

		}

	if ( tPtr1.Compare( tPtr2 ) == 0 )

		retVal = ETrue;

	CleanupStack::PopAndDestroy( buffer2 );

	CleanupStack::PopAndDestroy( buffer1 );

	return retVal;

	}

LOCAL_C void BackupRepositoryL( CDesC8ArraySeg* aDataStream )

	{

	backupClient->CompleteOwnerIdLookupTableL();

	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 );

	CleanupStack::PopAndDestroy( transferBuffer );

	}

LOCAL_C void RestoreRepositoryL( CDesC8ArraySeg* aDataStream )

	{

	backupClient->InitialiseRestoreProxyBaseDataL( SecureId1, EDriveC );

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

	CleanupStack::PushL( transferBuffer );

	TBool finished = EFalse;

	TInt count = aDataStream->Count();

	TInt element = 0;

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

		{

		TPtrC8 ptr = (*aDataStream)[ element ];

		if (ptr.Size()>transferBuffer->Des().MaxSize())

			{

			transferBuffer = transferBuffer->ReAlloc(ptr.Size());

			}

		TPtr8 bufferToSend = transferBuffer->Des();

		bufferToSend.Zero();

		bufferToSend.Append( ptr );

		if ( element + 1 == count )

			finished = ETrue;

		backupClient->RestoreBaseDataSectionL( bufferToSend, finished );

		}

	backupClient->RestoreComplete( EDriveC );

	CleanupStack::PopAndDestroy( transferBuffer );

	}

/**

@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0115

@SYMTestCaseDesc Test Backup functionality.

@SYMTestPriority High

@SYMTestActions  Test Backup functionality.

@SYMTestExpectedResults The test must not fail.

@SYMPREQ PREQ752

         PREQ908

*/

LOCAL_C void BackupTestsL()

	{

	NextTest( _L( " @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0115 Backup repository " ) );

	// create and install the active scheduler we need

	CActiveScheduler* s = new(ELeave) CActiveScheduler;

	TCleanupItem tc(CleanupActiveScheduler, s);

	CleanupStack::PushL(tc);

	CActiveScheduler::Replace( s );

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

	TEST( backupClient != 0 );

	// These tests don't test Backup&Restore functionality over Secure Backup Server so cache management

	// is not possible. For that reason, cache is disabled manually.

	TServerResources::iCacheManager->DisableCache();

	NextTest( _L( "Backup original version" ) );

	// Install known files

	InstallFileSetL( EOriginals );

	BackupRepositoryL( originalData1 );

	NextTest( _L( "Backup changed version" ) );

	InstallFileSetL( EChanged );

	BackupRepositoryL( changedData1 );

	DeleteFilesL();

	NextTest( _L( "Confirm streams different" ) );

	TEST( !StreamsAreIdenticalL( originalData1, changedData1 ) );

	CleanupStack::PopAndDestroy( backupClient );

	// Cleanup the scheduler

	CleanupStack::PopAndDestroy( s );

	}

/**

@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0116

@SYMTestCaseDesc Test Restore functionality.

@SYMTestPriority High

@SYMTestActions  Test Restore functionality.

@SYMTestExpectedResults The test must not fail.

@SYMPREQ PREQ752

         PREQ908

*/

/**

@SYMTestCaseID          SYSLIB-CENTRALREPOSITORY-CIT-1376

@SYMTestCaseDesc        Test for defect

@SYMTestPriority        High

@SYMTestActions         Test that default meta doesn't override individual meta

@SYMTestExpectedResults Test must not fail

@SYMDEF                 INC067080

*/

LOCAL_C void RestoreTestsL()

	{

	NextTest( _L( " @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0116 " ) );

	NextTest( _L( " @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CIT-1376 Restore repository " ) );

	// create and install the active scheduler we need

	CActiveScheduler* s = new(ELeave) CActiveScheduler;

	TCleanupItem tc(CleanupActiveScheduler, s);

	CleanupStack::PushL(tc);

	CActiveScheduler::Replace( s );

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

	TEST( backupClient != 0 );

	CServerRepository* aServerRepo=new (ELeave)CServerRepository();

	CleanupStack::PushL(aServerRepo);

	CSessionNotifier* aSessionNotif=new (ELeave) CSessionNotifier();

	CleanupStack::PushL(aSessionNotif);

	TServerResources::iCacheManager->DisableCache();

	NextTest( _L( "Restore original version over changed version" ) );

	InstallFileSetL( EChanged );

	RestoreRepositoryL( originalData1 );

	NextTest( _L( "Confirm settings restored" ) );

	// Open merged repository to check for values of individual settings

	aServerRepo->OpenL(KUidBackupTestRepository1,*aSessionNotif);

	TInt r, a;

	r = aServerRepo->Get(KBackupInt1, a);

	TEST2(r, KErrNone);

	// This setting is backed up, so it must be restored to original

	TEST(a==KIntOrigValue1);

	r = aServerRepo->Get(KBackupInt2, a);

	TEST2(r, KErrNone);

	// This setting isn't backed up, so it must still have changed value

	TEST(a==KIntChangedValue2);

	r = aServerRepo->Get(KBackupInt3, a);

	TEST2(r, KErrNone);

	// This setting is backed up, so it must be restored to original

	TEST(a==KIntOrigValue3);

	TBuf8<KMaxBinaryLength> str;

	r = aServerRepo->Get(KBackupString1, str);

	TEST(r==KErrNone);

	// This setting is backed up, so it must be restored to original

	TEST(str==KStringOrigValue);

	r = aServerRepo->Get(KBackupString2, str);

	TEST(r==KErrNone);

	// This setting isn't backed up, so it must still have changed value

	TEST(str==KStringChangedValue);

	TReal realval;

	r = aServerRepo->Get(KBackupReal1, realval);

	TEST(r==KErrNone);

	// This setting is backed up, so it must be restored to original

	TEST(realval==KRealOrigValue);

	r = aServerRepo->Get(KBackupReal2, realval);

	TEST(r==KErrNone);

	// This setting isn't backed up, so it must still have changed value

	TEST(realval==KRealChangedValue);

	aServerRepo->Close();

	NextTest( _L( "Restore changed version over original version" ) );

	InstallFileSetL( EOriginals );

	RestoreRepositoryL( changedData1 );

	NextTest( _L( "Confirm settings restored 2" ) );

	// Open merged repository to check for values of individual settings

	aServerRepo->OpenL(KUidBackupTestRepository1,*aSessionNotif);

	r = aServerRepo->Get(KBackupInt1, a);

	TEST2(r, KErrNone);

	// This setting is not backed up, so it must still have original value

	TEST(a==KIntOrigValue1);

	r = aServerRepo->Get(KBackupInt2, a);

	TEST2(r, KErrNone);

	// This setting is backed up, so it must be restored to changed

	TEST(a==KIntChangedValue2);

	r = aServerRepo->Get(KBackupInt3, a);

	TEST2(r, KErrNone);

	// This setting is not backed up, so it must still have original value

	TEST(a==KIntOrigValue3);

	r = aServerRepo->Get(KBackupString1, str);

	TEST(r==KErrNone);