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

		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)

			{