// 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, "C:\\private\\10281e17\\");

const TUid KClientUid = {0x21212122}; // the data owner's UID

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

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

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

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

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

static CActiveScheduler* TheScheduler = NULL;

static CSqlBurTestHarness* TheTestHarness = NULL;

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

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

const TInt KTestDbFileCnt = 2;

//Test db files

_LIT(KTestFileName1,"[21212122]AADB2.db");//Created outside this test app

_LIT(KTestFileName2,"[21212122]BBDB2.db");//Created outside this test app

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

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

const TPtrC KTestFileNames[KTestDbFileCnt] = {KTestFileName1(), KTestFileName2()};

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

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

static TUint8 TheBuf[KMaxDbFileSize];

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

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

void TestEnvDestroy()

	{

	delete TheTestHarness;

	TheTestHarness = 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__)

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

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

CSqlBurTestHarness *CSqlBurTestHarness::New()

	{

	CSqlBurTestHarness* self = new CSqlBurTestHarness;

	TEST(self != NULL);

	self->Construct();

	return self;

	}

CSqlBurTestHarness::CSqlBurTestHarness()

	{

	}

void CSqlBurTestHarness::Construct()

	{

	TInt err = iFs.Connect();

	TEST2(err, KErrNone);

	err = iFs.MkDir(KBackupDir);

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

	err = iFs.CreatePrivatePath(EDriveC);

	TEST2(err, KErrNone);

	}

CSqlBurTestHarness::~CSqlBurTestHarness()

	{

	(void)iFs.Delete(KBackupFile);

	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 CSqlBurTestHarness::GetBackUpListL(TSecureId aUid, RArray<TParse>& aFileList)

	{

	if(aUid.iId == 0)

		{//Simulates that there are no databases for backup

		aFileList.Reset();

		return;

		}

	//TheTest.Printf(_L("Getting backup file list for SID=%x\r\n"),aUid);

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

		{

		TParse parse;

		parse.Set(KTestFileNames[i], &KPrivateDir, NULL);

		aFileList.AppendL(parse);

		}

	}

//Notification that a backup is starting

TBool CSqlBurTestHarness::StartBackupL(const RArray<TParse>& /*aFileList*/) 

	{

	//TheTest.Printf(_L("Start \"backup\". %d files in the list.\r\n"), aFileList.Count());

	return ETrue;

	}

//Notification that a backup has ended

void CSqlBurTestHarness::EndBackup(const RArray<TParse>& /*aFileList*/)

	{

	//TheTest.Printf(_L("End \"backup\". %d files in the list.\r\n"), aFileList.Count());

	}

//Notification that a restore is starting

TBool CSqlBurTestHarness::StartRestoreL(TSecureId /*aUid*/) 

	{

	//TheTest.Printf(_L("Start \"restore\" for UID=%X\r\n"), aUid);

	return ETrue;

	}

//Notification that a restore has ended

void CSqlBurTestHarness::EndRestore(TSecureId /*aUid*/) 

	{

	//TheTest.Printf(_L("End \"restore\" for UID=%X\r\n"), aUid);

	}

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

RFs& CSqlBurTestHarness::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);

	TheTestHarness = CSqlBurTestHarness::New();

	TEST(TheTestHarness != NULL);

	}

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

	{

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

		{

		RFile dbFile;

		TInt err = dbFile.Open(aFs, KTestFileNames[i], 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();

		}

	}

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

	{

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

		{

		TEST(TheDbFileSizes[i] > 0);

		RFile dbFile;

		TInt err = dbFile.Open(aFs, KTestFileNames[i], EFileRead);

		TEST2(err, KErrNone);

		TInt fileSize = 0;

		err = dbFile.Size(fileSize);

		TEST2(err, KErrNone);

		TEST(fileSize > 0);

		TEST(TheDbFileSizes[i] == fileSize);

		TPtr8 bufptr(TheBuf, 0, KMaxDbFileSize);

		err = dbFile.Read(bufptr, fileSize);

		TEST2(err, KErrNone);

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

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

		TEST2(err, 0);

		dbFile.Close();

		}

	}

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

//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(CSqlBackupClient &aBackupClient, RFs& aFs, TInt aDataChunkSize = KBufferSize)

	{

	RFile file;

	CleanupClosePushL(file);

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

	User::LeaveIfError(err);

	aBackupClient.InitialiseGetProxyBackupDataL(KClientUid, EDriveC);

	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, KBackupFile))

		{

		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(CSqlBackupClient &aRestoreClient, RFs& aFs, TInt aDataChunkSize = KBufferSize)

	{

	RFile file;

	CleanupClosePushL(file);

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

	User::LeaveIfError(err);

	aRestoreClient.InitialiseRestoreProxyBaseDataL(KClientUid, EDriveC);

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

	if(!finishedFlag)

		{

		User::Leave(KErrEof);

		}

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

		{

		if(!FileExists(aFs, KTestFileNames[i]))

			{

			User::Leave(KErrNotFound);

			}

		}

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

	return count;

	}

//Verifies the integrity of the backup file.

void TestArchiveIntegrityL(CSqlBackupClient &aBackupClient, RFs& aFs)

	{

	RFile bkpFile;

	CleanupClosePushL(bkpFile);

	TInt err = bkpFile.Open(aFs, KBackupFile, 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

		TUint32 dbChecksum = aBackupClient.CheckSumL(dbFile) & 0xFFFFFFFF;

		if(checksum != dbChecksum)

			{

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

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4002 Backup: functional test "));

	CSqlBackupClient* backupClient = NULL;

	TRAPD(err, backupClient = CSqlBackupClient::NewL(TheTestHarness));

	TEST(backupClient != NULL);

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

	const TDriveNumber KDrive = EDriveC;

	//Virtual functions - with default implementation

	(void)backupClient->GetExpectedDataSize(KDrive);

	(void)backupClient->GetDataChecksum(KDrive);

	TBool finished = EFalse;

	TPtr8 ptr(0, 0, 0);

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

	TEST2(err, KErrNotSupported);

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