// Copyright (c) 2006-2010 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 <e32test.h>

#include <bautils.h>

#include <sqldb.h>

#include <e32math.h>

#include "SqlBur.h"

#include "t_sqlbur.h"

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

RTest TheTest(_L("SQL Backup and Restore Test"));

_LIT(KPrivateDir, "\\private\\10281e17\\");

//Don't forget to update DeleteBackupFiles() implementation if a new uid is added

const TSecureId KClientUid = 0x21212122; // the data owner's UID

const TSecureId KZeroFileSizeUid = 0xFFFF4321;

const TSecureId KTestClientUid1 = 0xFFFF4322;

const TSecureId KTestClientUid2 = 0xFFFF4323;

const TSecureId KTestClientUid3 = 0xFFFF4324;

_LIT(KBackupDir, "C:\\TEST\\");

_LIT(KBackupFileTemplate, "C:\\TEST\\Backup.bak");

_LIT(KBackupCopy, "C:\\TEST\\Backup2.bak");

_LIT(KBackupFile2Z, "Z:\\TEST\\t_sqlbur_backup_ver0.bak");

_LIT(KBackupFile2, "C:\\TEST\\t_sqlbur_backup_ver0.bak");

_LIT(KZeroSizeFile, "C:\\private\\10281e17\\[FFFF4321]t_sqlbur_zero.db");

_LIT(KTestFile1, "C:\\private\\10281e17\\[FFFF4322]t_sqlbur_test1.db");

_LIT(KTestFile1NameOnly, "[FFFF4322]t_sqlbur_test1.db");

_LIT(KTestFile1Bak, "C:\\private\\10281e17\\bak[FFFF4322]t_sqlbur_test1.db.bak");

_LIT(KTestDeleteMask1, "C:\\private\\10281e17\\[FFFF4322]*");

_LIT(KTestDeleteMask2, "*bur_test1.db");

_LIT(KTestFile2, "\\private\\10281e17\\[FFFF4323]t_sqlbur_test2.db");

_LIT(KTestFile3, "c:\\private\\10281e17\\[FFFF4324]t_sqlbur_test3.db");

_LIT(KTestFile4, "c:\\private\\10281e17\\[FFFF4324]t_sqlbur_test4.db");

const TDriveNumber KTestDrive = EDriveC;

const TUint KBufferSize = 2048; // used for reading backup files for validation

static CActiveScheduler* TheScheduler = NULL;

static CSqlSrvTestBurInterface* TheSqlSrvTestBurInterface = NULL;

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

//Test db files

_LIT(KTestDbFileName1,"C:[21212122]AADB2.db");

_LIT(KTestDbFileName2,"C:[21212122]BBDB2.db");

//Temp buffers for storing files content, to be compared with what is received after the restore operation. 10 files max.

TInt TheFileCount = 0;

const TInt KMaxDbFileSize = 10 * 1024;//The max test db file size - 10 Kb max.

static TUint8 TheDbFileData[10][KMaxDbFileSize];//An array where the original db file content will be stored

static TInt TheDbFileSizes[10];//An array where the real db file size will be stored

static TUint8 TheBuf[KMaxDbFileSize];

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

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

void DeleteBackupFiles()

	{

	TFileName fname;

	fname.Copy(KBackupFileTemplate);

	fname.Append((static_cast <TUid> (KClientUid)).Name());

	(void)TheSqlSrvTestBurInterface->Fs().Delete(fname);

	fname.Copy(KBackupFileTemplate);

	fname.Append((static_cast <TUid> (KZeroFileSizeUid)).Name());

	(void)TheSqlSrvTestBurInterface->Fs().Delete(fname);

	fname.Copy(KBackupFileTemplate);

	fname.Append((static_cast <TUid> (KTestClientUid1)).Name());

	(void)TheSqlSrvTestBurInterface->Fs().Delete(fname);

	fname.Copy(KBackupFileTemplate);

	fname.Append((static_cast <TUid> (KTestClientUid2)).Name());

	(void)TheSqlSrvTestBurInterface->Fs().Delete(fname);

	fname.Copy(KBackupFileTemplate);

	fname.Append((static_cast <TUid> (KTestClientUid3)).Name());

	(void)TheSqlSrvTestBurInterface->Fs().Delete(fname);

	}

void TestEnvDestroy()

	{

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy);

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak);

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3);

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile);

	DeleteBackupFiles();

	delete TheSqlSrvTestBurInterface;

	TheSqlSrvTestBurInterface = NULL;		

	delete TheScheduler;

	TheScheduler = NULL;

	}

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

// Test macros and functions

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

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TestEnvDestroy();

		TheTest(EFalse, aLine);

		}

	}

void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		TestEnvDestroy();

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

		TheTest(EFalse, aLine);

		}

	}

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

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

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

static void DestroyFileList(RArray<HBufC*>& aFileList)

	{

	for(TInt i=0;i<aFileList.Count();++i)

		{

		delete aFileList[i];

		}

	aFileList.Close();

	}

//CSqlSrvTestBurInterface - test implementation of the MSqlSrvBurInterface, implemented in the production code by the SQL server.

CSqlSrvTestBurInterface *CSqlSrvTestBurInterface::New()

	{

	CSqlSrvTestBurInterface* self = new CSqlSrvTestBurInterface;

	TEST(self != NULL);

	self->Construct();

	return self;

	}

CSqlSrvTestBurInterface::CSqlSrvTestBurInterface()

	{

	}

void CSqlSrvTestBurInterface::Construct()

	{

	TInt err = iFs.Connect();

	TEST2(err, KErrNone);

	err = iFs.MkDir(KBackupDir);

	TEST(err == KErrNone || err == KErrAlreadyExists);

	err = iFs.CreatePrivatePath(KTestDrive);

	TEST2(err, KErrNone);

	}

CSqlSrvTestBurInterface::~CSqlSrvTestBurInterface()

	{

	iFs.Close();

	}

//Called by the backup client ot get a list of database files to backup

//The array is owned by the caller

//The SQL server would have the job to get a list of databases owned by

//the given SID and to determine whether the backup flag is set

//All databases that satisfy this requirement will be added to the array.

void CSqlSrvTestBurInterface::GetBackUpListL(TSecureId aUid, TDriveNumber aDrive, RArray<HBufC*>& aFileList)

	{

	if(aUid.iId == 0)

		{//Simulates that there are no databases for backup

		DestroyFileList(aFileList);

		return;

		}

	TDriveUnit driveUnit(aDrive);

	TDriveName driveName = driveUnit.Name();

	TFileName path;

	path.Copy(driveName);

	path.Append(KPrivateDir);

	//Include the aUid and the "*" mask

	TUidName uidName = (static_cast <TUid> (aUid)).Name();

	_LIT(KMatchAllDbFiles, "*");

	TBuf<KMaxUidName + sizeof(KMatchAllDbFiles)> fileNameMask(uidName);

	fileNameMask.Append(KMatchAllDbFiles);

	TParse parse;

	TInt err = parse.Set(path, &fileNameMask, NULL);

	User::LeaveIfError(err);

	//Do the search

	TPtrC fullPath(parse.FullName());

	CDir* fileNameCol = NULL;

	err = TheSqlSrvTestBurInterface->Fs().GetDir(fullPath, KEntryAttNormal, ESortNone, fileNameCol);

	if(err == KErrNotFound)

		{

		return;

		}

	User::LeaveIfError(err);

	CleanupStack::PushL(fileNameCol);

	TInt fileCount = fileNameCol->Count();

	err = aFileList.Reserve(fileCount);

	User::LeaveIfError(err);

	//Append the full database file paths to the file names list.

	for(TInt i=0;i<fileCount;++i)

		{

		const ::TEntry& entry = (*fileNameCol)[i];

		err = parse.Set(path, &entry.iName, NULL);

		User::LeaveIfError(err);

		TPtrC fname(parse.FullName());

		HBufC* fnameBuf = fname.AllocL();

		err = aFileList.Append(fnameBuf);

		User::LeaveIfError(err);

		}

	CleanupStack::PopAndDestroy(fileNameCol);

	}

//Returns the file system resource handle to the caller.

RFs& CSqlSrvTestBurInterface::Fs()

	{

	return iFs;

	}

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

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

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

TBool FileExists(RFs& aFs, const TDesC& aFileName)

	{

	TEntry entry;

	return aFs.Entry(aFileName, entry) == KErrNone;

	}

void TestEnvCreate()

	{

	TheScheduler = new CActiveScheduler;

	TEST(TheScheduler != NULL);

	CActiveScheduler::Install(TheScheduler);

	TheSqlSrvTestBurInterface = CSqlSrvTestBurInterface::New();

	TEST(TheSqlSrvTestBurInterface != NULL);

	}

void PrepareSearchPath(TDriveNumber aDrive, TDes& aPath)

	{

	TDriveUnit driveUnit(aDrive);

	TDriveName driveName = driveUnit.Name();

	aPath.Copy(driveName);

	aPath.Append(KPrivateDir);

	}

void PrepareSearchPattern(const TDesC& aPath, TSecureId aUid, TParse& aParse)

	{

	TUidName uidName = (static_cast <TUid> (aUid)).Name();

	_LIT(KMatchAllDbFiles, "*");

	TBuf<KMaxUidName + sizeof(KMatchAllDbFiles)> fileNameMask(uidName);

	fileNameMask.Append(KMatchAllDbFiles);

	TInt err = aParse.Set(aPath, &fileNameMask, NULL);

	TEST2(err, KErrNone);

	}

//Reads the content of the db files and stores the content to a global memory buffer.

//That buffer content will be used later for verification of the restore process.

void StoreDbContentToBuf(RFs& aFs, TDriveNumber aDrive, TSecureId aUid)

	{

	TFileName path;

	PrepareSearchPath(aDrive, path);

	TParse parse;

	PrepareSearchPattern(path, aUid, parse);

	TheFileCount = -1;

	Mem::FillZ(TheDbFileData, sizeof(TheDbFileData));

	Mem::FillZ(TheDbFileSizes, sizeof(TheDbFileSizes));

	CDir* dir = NULL;

	TInt err = aFs.GetDir(parse.FullName(), KEntryAttNormal, ESortByName, dir);

	TEST2(err, KErrNone);

	TheFileCount = dir->Count();

	for(TInt i=0;i<TheFileCount;++i)

		{

		const ::TEntry& entry = (*dir)[i];

		err = parse.Set(path, &entry.iName, NULL);

		TEST2(err, KErrNone);

		TPtrC fname(parse.FullName());

		RFile dbFile;

		err = dbFile.Open(aFs, fname, EFileRead);

		TEST2(err, KErrNone);

		TInt fileSize = 0;

		err = dbFile.Size(fileSize);

		TEST2(err, KErrNone);

		TEST(fileSize > 0);

		TPtr8 bufptr(TheDbFileData[i], 0, KMaxDbFileSize);

		err = dbFile.Read(bufptr, fileSize);

		TEST2(err, KErrNone);

		TEST(fileSize == bufptr.Length());

		TheDbFileSizes[i] = fileSize;

		dbFile.Close();

		}

	delete dir;

	}

//At the moment when this function is called, the db files content is already restored.

//The function will open the restored db files and compare their content against the content

//of the original db files (kept in a global memory buffer).

void CompareDbContentWithBuf(RFs& aFs, TDriveNumber aDrive, TSecureId aUid)

	{

	TFileName path;

	PrepareSearchPath(aDrive, path);

	TParse parse;

	PrepareSearchPattern(path, aUid, parse);

	CDir* dir = NULL;

	TInt err = aFs.GetDir(parse.FullName(), KEntryAttNormal, ESortByName, dir);

	TEST2(err, KErrNone);

	TEST2(TheFileCount, dir->Count());

	for(TInt i=0;i<TheFileCount;++i)

		{

		TEST(TheDbFileSizes[i] > 0);

		const ::TEntry& entry = (*dir)[i];

		err = parse.Set(path, &entry.iName, NULL);

		TEST2(err, KErrNone);

		TPtrC fname(parse.FullName());

		RFile dbFile;

		TInt err = dbFile.Open(aFs, fname, EFileRead);

		TEST2(err, KErrNone);

		TInt fileSize = 0;

		err = dbFile.Size(fileSize);

		TEST2(err, KErrNone);

		TEST(fileSize > 0);

		TEST2(TheDbFileSizes[i], fileSize);

		TPtr8 bufptr(TheBuf, 0, KMaxDbFileSize);

		err = dbFile.Read(bufptr, fileSize);

		TEST2(err, KErrNone);

		TEST2(fileSize, bufptr.Length());

		err = Mem::Compare(TheBuf, fileSize, TheDbFileData[i], TheDbFileSizes[i]);

		TEST2(err, 0);

		dbFile.Close();

		}

	delete dir;

	}

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

//The backup client will return a series of data chunks representing

//one of more databases for the uid of the data owner.

//This data is stored in a file on the C drive for the purposes of the test

TInt TestBackupL(CSqlBurCallback &aBackupClient, RFs& aFs, TSecureId aUid, TDriveNumber aDrive, TInt aDataChunkSize = KBufferSize)

	{

	TFileName backupFileName;

	backupFileName.Copy(KBackupFileTemplate);

	backupFileName.Append((static_cast <TUid> (aUid)).Name());

	RFile file;

	CleanupClosePushL(file);

	TInt err = file.Replace(aFs, backupFileName, EFileWrite | EFileStream | EFileShareExclusive);

	User::LeaveIfError(err);

	aBackupClient.InitialiseGetProxyBackupDataL(aUid, aDrive);

	TBuf8<KBufferSize> buf;

	TPtr8 ptr((TUint8*)buf.Ptr(), aDataChunkSize);

	TBool finishedFlag = EFalse;

	TInt count = 0;

	do

		{

		aBackupClient.GetBackupDataSectionL(ptr, finishedFlag);

		count += ptr.Length();

		err = file.Write(ptr);

		User::LeaveIfError(err);

		ptr.SetLength(0);

		}

	while(!finishedFlag);

	CleanupStack::PopAndDestroy(&file);

	if(count == 0)

		{

		User::Leave(KErrEof);

		}

	if(!FileExists(aFs, backupFileName))

		{

		User::Leave(KErrNotFound);

		}

	TheTest.Printf(_L("Backup complete. %d bytes processed.\r\n"), count);

	return count;

	}

//This sends the data in chunks form back to the BUR client

//for nupacking and restoration of the original databases files

TInt TestRestoreL(CSqlBurCallback &aRestoreClient, RFs& aFs, TSecureId aUid, TDriveNumber aDrive, TInt aDataChunkSize = KBufferSize)

	{

	TFileName backupFileName;

	backupFileName.Copy(KBackupFileTemplate);

	backupFileName.Append((static_cast <TUid> (aUid)).Name());

	RFile file;

	CleanupClosePushL(file);

	TInt err = file.Open(aFs, backupFileName, EFileRead | EFileShareExclusive);

	User::LeaveIfError(err);

	aRestoreClient.InitialiseRestoreProxyBaseDataL(aUid, aDrive);

	TBuf8<KBufferSize> buf;

	TPtr8 ptr((TUint8*)buf.Ptr(), aDataChunkSize);

	TBool finishedFlag = EFalse;

	TInt fileSize = 0;

	err = file.Size(fileSize);

	User::LeaveIfError(err);

	TInt count = fileSize;

	do

		{

		err = file.Read(ptr, aDataChunkSize);

		User::LeaveIfError(err);

		fileSize -= ptr.Length();

		finishedFlag = fileSize == 0;

		aRestoreClient.RestoreBaseDataSectionL(ptr, finishedFlag);

		ptr.SetLength(0);

		} 

	while(fileSize > 0);

	CleanupStack::PopAndDestroy(&file);

	aRestoreClient.RestoreComplete(aDrive);

	if(!finishedFlag)

		{

		User::Leave(KErrEof);

		}

	TheTest.Printf(_L("Restore complete. %d bytes processed.\r\n"), count);

	return count;

	}

//Verifies the integrity of the backup file.

void TestArchiveIntegrityL(CSqlBurCallback &aBackupClient, RFs& aFs, TSecureId aUid)

	{

	RFile bkpFile;

	CleanupClosePushL(bkpFile);

	TFileName backupFileName;

	backupFileName.Copy(KBackupFileTemplate);

	backupFileName.Append((static_cast <TUid> (aUid)).Name());

	TInt err = bkpFile.Open(aFs, backupFileName, EFileRead | EFileShareExclusive);

	User::LeaveIfError(err);

	TBuf8<KBufferSize> buf;

	TPtr8 ptr((TUint8*)buf.Ptr(), buf.MaxLength());

	TInt bkpFileSize = 0;

	err = bkpFile.Size(bkpFileSize);

	User::LeaveIfError(err);

	while(bkpFileSize > 0)

		{

		// get the checksum

		err = bkpFile.Read(ptr, 16); // 8 UTF-16 characters

		User::LeaveIfError(err);

		if(ptr.Length() != 16)

			{

			User::Leave(KErrCorrupt);

			}

		TPtr ptr16((TUint16*) ptr.Ptr(), 8, 8);

		TLex lex(ptr16);

		TUint32 checksum;

		lex.SkipSpace();

		err = lex.Val(checksum, EHex);

		User::LeaveIfError(err);

		bkpFileSize -= 16;

		// get the old file size

		err = bkpFile.Read(ptr, 16); // 8 UTF-16 characters

		User::LeaveIfError(err);

		if(ptr.Length() != 16)

			{

			User::Leave(KErrCorrupt);

			}

		ptr16.Set((TUint16*) ptr.Ptr(), 8, 8);

		lex.Assign(ptr16);

		TUint32 oldFileSize;

		lex.SkipSpace();

		err = lex.Val(oldFileSize, EHex);

		User::LeaveIfError(err);

		bkpFileSize -= 16;

		// get the backup file header version

		err = bkpFile.Read(ptr, 8); // 4 UTF-16 characters

		User::LeaveIfError(err);

		ptr16.Set((TUint16*)ptr.Ptr(), 4, 4);

		lex.Assign(ptr16);

		TUint32 hdrVer;

		lex.SkipSpace();

		err = lex.Val(hdrVer, EHex);

		User::LeaveIfError(err);

		bkpFileSize -= 8;

		// get the file size

		err = bkpFile.Read(ptr, 32); // 16 UTF-16 characters

		User::LeaveIfError(err);

		if(ptr.Length() != 32)

			{

			User::Leave(KErrCorrupt);

			}

		ptr16.Set((TUint16*) ptr.Ptr(), 16, 16);

		lex.Assign(ptr16);

		TInt64 fileSize;

		lex.SkipSpace();

		err = lex.Val(fileSize, EHex);

		User::LeaveIfError(err);

		bkpFileSize -= 32;

		// get the filename size

		err = bkpFile.Read(ptr, 16); // 8 UTF-16 characters

		User::LeaveIfError(err);

		ptr16.Set((TUint16*)ptr.Ptr(), 8, 8);

		lex.Assign(ptr16);

		TUint32 fileNameSize;

		lex.SkipSpace();

		err = lex.Val(fileNameSize, EHex);

		User::LeaveIfError(err);

		bkpFileSize -= 16;

		// get the filename

		err = bkpFile.Read(ptr, fileNameSize * 2); // fileName UTF-16 characters

		User::LeaveIfError(err);

		if(ptr.Length() != (fileNameSize * 2))

			{

			User::Leave(KErrCorrupt);

			}

		ptr16.Set((TUint16*) ptr.Ptr(), fileNameSize, fileNameSize);

		lex.Assign(ptr16);

		TParse tp;

		tp.Set(ptr16, NULL, NULL);

		TPtrC dbFileName = tp.Name();

		bkpFileSize -= fileNameSize * 2;

		// open a local file - replaces any previous one

		RFile64 dbFile;

		CleanupClosePushL(dbFile);

		err = dbFile.Replace(aFs, dbFileName, EFileWrite | EFileShareExclusive);

		User::LeaveIfError(err);

		// copy all the data (file size bytes)

		TInt bytesLeftToRead = fileSize;

		while(bytesLeftToRead > 0)

			{

			TInt readSize = bytesLeftToRead > KBufferSize ? KBufferSize : bytesLeftToRead;

			err = bkpFile.Read(ptr, readSize);

			User::LeaveIfError(err);

			if(ptr.Length() != readSize)

				{

				User::Leave(KErrCorrupt);	

				}

			bytesLeftToRead -= readSize;

			err = dbFile.Write(ptr, readSize);

			User::LeaveIfError(err);

			}

		bkpFileSize -= fileSize;

		// checksum the file

		TUint64 checkSum64 = 0;

		User::LeaveIfError(aBackupClient.CheckSum(dbFile, checkSum64));

		TUint32 checksum32 = checkSum64 & 0xFFFFFFFF; 

		if(checksum != checksum32)

			{

			User::Leave(KErrCorrupt);

			}

		// all done with this file

		CleanupStack::PopAndDestroy(&dbFile);

		err = aFs.Delete(dbFileName);

		User::LeaveIfError(err);

		}

	CleanupStack::PopAndDestroy(&bkpFile);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4002

@SYMTestCaseDesc		Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"

						The test backups 2 test db files, then verifies the backup file integrity,

						then restores the test db files content from the backup file.

						At the end, the test checks that the restored test db files content is the

						same as the content of the original test db file.

@SYMTestPriority		High

@SYMTestActions			Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"

@SYMTestExpectedResults Test must not fail

@SYMDEF					DEF113598

*/	

void FunctionalTest()

	{

	CSqlBurCallback* backupClient = NULL;

	TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));

	TEST(backupClient != NULL);

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

	//Virtual functions - with default implementation

	(void)backupClient->GetExpectedDataSize(KTestDrive);

	(void)backupClient->GetDataChecksum(KTestDrive);

	TBool finished = EFalse;

	TPtr8 ptr(0, 0, 0);

	TRAP(err, backupClient->GetSnapshotDataL(KTestDrive, ptr, finished));

	TEST2(err, KErrNotSupported);

	TRAP(err, backupClient->InitialiseGetBackupDataL(KTestDrive));

	TEST2(err, KErrNotSupported);

	TRAP(err, backupClient->InitialiseRestoreBaseDataL(KTestDrive));

	TEST2(err, KErrNotSupported);

	TRAP(err, backupClient->InitialiseRestoreIncrementDataL(KTestDrive));

	TEST2(err, KErrNotSupported);

	TPtrC8 ptr2(KNullDesC8);

	TRAP(err, backupClient->RestoreIncrementDataSectionL(ptr2, finished));

	TEST2(err, KErrNotSupported);

	TRAP(err, backupClient->AllSnapshotsSuppliedL());

	TEST2(err, KErrNone);

	TRAP(err, backupClient->ReceiveSnapshotDataL(KTestDrive, ptr2, finished));

	TEST2(err, KErrNotSupported);

	backupClient->TerminateMultiStageOperation();

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

	TInt bytesStored = 0;

	TRAP(err, bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive));

	TEST2(err, KErrNone);

	TheTest.Next(_L("Archive integrity test"));

	TRAP(err, TestArchiveIntegrityL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid));

	TEST2(err, KErrNone);

	delete backupClient;

	TheTest.Next(_L("Restore: functional test"));

	CSqlBurCallback* restoreClient = NULL;

	TRAP(err, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));

	TEST(restoreClient != NULL);

	TInt bytesRestored = 0;

	TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive));

	TEST2(err, KErrNone);

	TEST(bytesRestored == bytesStored);

	delete restoreClient;

	CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);

	}

TInt DoBackupL(TDriveNumber aDrive, TSecureId aUid)

	{

	CSqlBurCallback* backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface);

	CleanupStack::PushL(backupClient);

	TInt bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), aUid, aDrive);

	CleanupStack::PopAndDestroy(backupClient);

	return bytesStored;

	}

TInt DoRestoreL(TDriveNumber aDrive, TSecureId aUid)

	{

	CSqlBurCallback* restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface);

	CleanupStack::PushL(restoreClient);

	TInt bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), aUid, aDrive);

	CleanupStack::PopAndDestroy(restoreClient);

	return bytesRestored;

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4003

@SYMTestCaseDesc		Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"

						Under simulated OOM condition, the test backups 2 test db files, 

						then restores the test db files content from the backup file.

						At the end, the test checks that the restored test db files content is the

						same as the content of the original test db file.

@SYMTestPriority		High

@SYMTestActions			Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"

@SYMTestExpectedResults Test must not fail

@SYMDEF					DEF113598

*/	

void OomTest()

	{

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

	TInt err = KErrNoMemory;

	TInt bytesStored = 0;

	TInt count = 0;

	for(count=1;err==KErrNoMemory;++count)

		{

		TInt startProcessHandleCount;

		TInt startThreadHandleCount;

		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

		User::__DbgMarkStart(RHeap::EUser);

		User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext, count);

		TRAP(err, bytesStored = DoBackupL(KTestDrive, KClientUid));

		User::__DbgMarkEnd(RHeap::EUser, 0);

		TInt endProcessHandleCount;

		TInt endThreadHandleCount;

		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

		TEST(startProcessHandleCount == endProcessHandleCount);

		TEST(startThreadHandleCount == endThreadHandleCount);

		}

	TEST2(err, KErrNone);

	TheTest.Printf(_L("OOM backup test succeeded at heap failure rate of %d\r\n"), count);

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

	TheTest.Next(_L("Restore: OOM test"));

	err = KErrNoMemory;

	TInt bytesRestored = 0;

	for(count=1;err==KErrNoMemory;++count)

		{

		TInt startProcessHandleCount;

		TInt startThreadHandleCount;

		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

		User::__DbgMarkStart(RHeap::EUser);

		User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext, count);

		TRAP(err, bytesRestored = DoRestoreL(KTestDrive, KClientUid));

		User::__DbgMarkEnd(RHeap::EUser, 0);

		TInt endProcessHandleCount;

		TInt endThreadHandleCount;

		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

		TEST(startProcessHandleCount == endProcessHandleCount);

		TEST(startThreadHandleCount == endThreadHandleCount);

		}

	TEST2(err, KErrNone);

	User::__DbgSetAllocFail(RHeap::EUser, RAllocator::ENone, 0);

	TheTest.Printf(_L("OOM restore test succeeded at heap failure rate of %d\r\n"), count);

	TEST2(bytesStored, bytesRestored);

	CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4143

@SYMTestCaseDesc		SQL Backup&Restore - data chunk size test.

						The test uses an integer array of 10 elements with randomly generated data chunk sizes.

						Then the test runs 10 backup iterations using each time different data chunk size.

						After each backup iteration the test performs a restore operation and checks that the 

						data has been backup&restored without errors.

@SYMTestActions			SQL Backup&Restore - data chunk size test.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		Medium

@SYMREQ					REQ12104

*/

void FunctionalTest2()

	{

	TTime now;

	now.UniversalTime();

	TInt64 seed = now.Int64();

	const TInt KArraySize = 10;

	TInt  dataChunks[10] = {2, 6, 0, 0, 0, 0, 0, 0, 0, 0};

	const TInt KMaxDataChunkSize = 50;

	for(TInt i=2;i<KArraySize;)

		{

		TInt dataChunkSize = Math::Rand(seed) % KMaxDataChunkSize;

		if((dataChunkSize % 2) == 0 && dataChunkSize != 0)	//The code works only with data chunks with even sizes!!!

			{

			dataChunks[i++] = dataChunkSize;

			}

		}

	for(TInt i=0;i<KArraySize;++i)

		{

		TheTest.Printf(_L(" === Iteration %d, chunk size %d\r\n"), i + 1, dataChunks[i]);

		CSqlBurCallback* backupClient = NULL;

		TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));

		TEST(backupClient != NULL);

		TInt bytesStored = 0;

		TRAP(err, bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive, dataChunks[i]));

		TEST2(err, KErrNone);

		TRAP(err, TestArchiveIntegrityL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid));

		TEST2(err, KErrNone);

		delete backupClient;

		CSqlBurCallback* restoreClient = NULL;

		TRAP(err, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));

		TEST(restoreClient != NULL);

		TInt bytesRestored = 0;

		TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive, dataChunks[i]));

		TEST2(err, KErrNone);

		TEST(bytesRestored == bytesStored);

		delete restoreClient;

		CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);

		}

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4144

@SYMTestCaseDesc		SQL Backup&Restore - legacy backup file format header test.

						The 64-bit file system related changes made in the SQL server required some 

						changes to be made in the format of the backup file header.

						The test checks that a backup file created with the previous format of the file header

						can be restored without errors by the updated Backup&Restore implementation.

@SYMTestActions			SQL Backup&Restore - legacy backup file format header test.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		Medium

@SYMREQ					REQ12104

*/

void LegacyFileFormatTest()

	{

	//KBackupFile2 is a database backup file with header version 0.

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupFile2);

	TInt rc = BaflUtils::CopyFile(TheSqlSrvTestBurInterface->Fs(), KBackupFile2Z, KBackupFile2);

	TEST2(rc, KErrNone);

	(void)TheSqlSrvTestBurInterface->Fs().SetAtt(KBackupFile2, 0, KEntryAttReadOnly);

	//Restore the databases from KBackupFile2.

	CSqlBurCallback* restoreClient = NULL;

	TRAP(rc, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));

	TEST(restoreClient != NULL);

	RFile file;

	rc = file.Open(TheSqlSrvTestBurInterface->Fs(), KBackupFile2, EFileRead | EFileShareExclusive);

	TEST2(rc, KErrNone);

	TRAP(rc, restoreClient->InitialiseRestoreProxyBaseDataL(KClientUid, KTestDrive));

	TEST2(rc, KErrNone);

	TBuf8<KBufferSize> buf;

	TPtr8 ptr((TUint8*)buf.Ptr(), buf.MaxSize());

	TBool finishedFlag = EFalse;

	TInt fileSize = 0;

	rc = file.Size(fileSize);

	TEST2(rc, KErrNone);

	do

		{

		rc = file.Read(ptr);

		TEST2(rc, KErrNone);

		fileSize -= ptr.Size();

		finishedFlag = fileSize == 0;

		TRAP(rc, restoreClient->RestoreBaseDataSectionL(ptr, finishedFlag));

		ptr.SetLength(0);

		} 

	while(fileSize > 0);

	file.Close();	

	restoreClient->RestoreComplete(KTestDrive);

	TEST(finishedFlag);

	delete restoreClient;

	//At this point we have two restored databases: KTestDbFileName1 and KTestDbFileName2.

	//The content of the restored file cannot be compared directly, because t_sqlattach uses the same test databases

	//and modifies them. The original database content was stored without executing t_sqlattach.

	//Hence a simple test is made: open the restored database, check if the database content can be accessed.

	RSqlDatabase db;

	rc = db.Open(KTestDbFileName1);

	TEST2(rc, KErrNone);

	//The database contains this table: "TABLE C(A1 INTEGER, B2 BLOB)". 

	rc = db.Exec(_L("INSERT INTO C VALUES(100, 200)"));

	TEST2(rc, 1);

	RSqlStatement stmt;

	rc = stmt.Prepare(db, _L("SELECT * FROM C"));

	TEST2(rc, KErrNone);

	while((rc = stmt.Next()) == KSqlAtRow)

		{

		}

	stmt.Close();

	TEST2(rc, KSqlAtEnd);

	db.Close();

	rc = db.Open(KTestDbFileName2);

	TEST2(rc, KErrNone);

	//The database contains this table: "TABLE A1(F1 INTEGER , F2 INTEGER, B1 BLOB)"

	rc = db.Exec(_L("INSERT INTO A1 VALUES(100, 200, NULL)"));

	TEST2(rc, 1);

	rc = stmt.Prepare(db, _L("SELECT * FROM A1"));

	TEST2(rc, KErrNone);

	while((rc = stmt.Next()) == KSqlAtRow)

		{

		}

	stmt.Close();

	TEST2(rc, KSqlAtEnd);

	db.Close();

	(void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupFile2);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4192

@SYMTestCaseDesc		SQL Backup&Restore - empty backup file list test.

						The test checks what will happen if the list with the files for backup is empty.

						The GetBackupDataSectionL() should immediatelly set the flag parameter to true and do nothing.

@SYMTestActions			SQL Backup&Restore - empty backup file list test.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMDEF					DEF145198

*/

void EmptyBackupFileListTest()

	{

	CSqlBurCallback* backupClient = NULL;

	TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));

	TEST(backupClient != NULL);

	TRAP(err, backupClient->InitialiseGetProxyBackupDataL(KNullUid, KTestDrive));

	TEST2(err, KErrNone);

	TBuf8<100> buf;

	TPtr8 ptr((TUint8*)buf.Ptr(), 0, buf.MaxLength());

	TBool finishedFlag = EFalse;

	TRAP(err, backupClient->GetBackupDataSectionL(ptr, finishedFlag));

	delete backupClient;

	TEST2(err, KErrNone);

	TEST(finishedFlag);

	TEST2(buf.Length(), 0);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4193

@SYMTestCaseDesc		SQL Backup&Restore - file I/O error simulation test.

						The test executes a backup, followed by a restore operation 

						in a file I/O error simulation loop.

@SYMTestActions			SQL Backup&Restore - file I/O error simulation test.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMDEF					DEF145198

*/

void BackupRestoreFileIoErrTest()

	{

	//Make sure that the database content, just before the backup, will be copied to the test biffers.

	//The buffers will be used during the restore testing for verification of the database content.

	StoreDbContentToBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);

	for(TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)

		{

		TheTest.Printf(_L("===Backup&Restore, simulated file system error=%d\r\n"), fsError);