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

 //

 // MSVC++ up to 5.0 has problems with expanding inline functions

 // This disables the mad warnings for the whole project

 #if defined(NDEBUG) && defined(__VC32__) && _MSC_VER<=1100

 #pragma warning(disable : 4710)			// function not expanded. MSVC 5.0 is stupid

 #endif

 #include <d32dbms.h>

 #include <s32file.h>

 #include <e32test.h>

 #include <e32math.h>

 #include "crccheck.h"

 #undef __UHEAP_MARK

 #define __UHEAP_MARK

 #undef __UHEAP_MARKEND

 #define __UHEAP_MARKEND

 LOCAL_D TDBMS_CRCChecks TheCrcChecker;

 #ifndef __linux__ //No CRC test on LINUX

 #ifdef __TOOLS2__

 const TPtrC	KCrcRecord=_L("\\epoc32\\winscw\\c\\dbms-tst\\T_COMP.CRC");

 #else

 const TPtrC	KCrcRecord=_L("C:\\dbms-tst\\T_COMP.CRC");

 #endif

 #endif

 LOCAL_D RTest test(_L("T_COMP"));

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 LOCAL_D RFs TheFs;

 const TInt KTestCleanupStack=0x20;

 #ifdef __TOOLS2__

 const TPtrC KTestDir=_L(".\\dbms-tst\\");

 #else

 const TPtrC KTestDir=_L("C:\\dbms-tst\\");

 #endif

 //T_BENCH.DB file is created by T_BENCH test and is used by the current test (T_COMP).

 //T_COMP test will delete T_BENCH.DB at the end as it is no more needed. 

 //If you want to rerun T_COMP test again, you have to ensure that T_BENCH.DB file exists - 

 //run T_BENCH test again.

 _LIT(KTestFile,"T_BENCH.DB");

 _LIT(KRomTestFile,"Z:\\TEST\\T_COMP.DAT");

 _LIT(KCompressedFile,"T_COMP.DB1");

 _LIT(KDecompressedFile,"T_COMP.DB2");

 const TStreamId KHelpId=2;

 //

 // Compress the database

 //

 LOCAL_C void CompressL(const TDesC& aSource,const TDesC& aTarget,TBool aCompress)

 	{

 #ifndef __TOOLS2__

 	CFileMan* man=CFileMan::NewL(TheFs);

 	TInt r=man->Copy(aSource,aTarget);

 	delete man;

 	User::LeaveIfError(r);

 #else

 	TInt r;

     RFile f1;

     r = f1.Open(TheFs, aSource, EFileStreamText|EFileShareReadersOnly);

     test(r==KErrNone);

     RFile f2;

     r=f2.Replace(TheFs, aTarget, EFileWrite);

     test(r==KErrNone);

     TBuf8<512> copyBuf;

 	TInt rem;

 	r=f1.Size(rem);

 	test(r==KErrNone);

 	TInt pos=0;

 	while (rem)

 		{

 		TInt s=Min(rem,copyBuf.MaxSize());

 		r=f1.Read(pos,copyBuf,s);

 		test(r==KErrNone);

 		test(copyBuf.Length()==s);

 		r=f2.Write(pos,copyBuf,s);

 		test(r==KErrNone);

 		pos+=s;

 		rem-=s;

 		}

 	f1.Close();

 	f2.Close();	

 #endif

 #ifndef __TOOLS2__

 	User::LeaveIfError(TheFs.SetAtt(aTarget,0,KEntryAttReadOnly));

 #endif

 	CFileStore* store=CFileStore::OpenLC(TheFs,aTarget,EFileRead|EFileWrite);

 	TUint t=User::TickCount();

 	if (aCompress)

 		RDbStoreDatabase::CompressL(*store,store->Root());

 	else

 		RDbStoreDatabase::DecompressL(*store,store->Root());

 	t=User::TickCount()-t;

 	test.Printf(_L("%d ticks\r\n"),t);

 	store->CompactL();

 	store->CommitL();

 	CleanupStack::PopAndDestroy();	// store

 	TInt err;

 	TRAPD(lc, err = TheCrcChecker.GenerateCrcL(aTarget));

 	test(err == KErrNone);

 	test(lc == KErrNone);

 	}

 LOCAL_C void CheckTableL(RDbDatabase& aDatabase,RDbDatabase& aCopy,const TDesC& aTable)

 	{

 	test.Printf(_L("Processing table %S\n"),&aTable);

 	RDbTable table;

 	test (table.Open(aDatabase,aTable,table.EReadOnly)==KErrNone);

 	RDbTable copy;

 	test (copy.Open(aCopy,aTable,table.EReadOnly)==KErrNone);

 	TInt columns=table.ColCount();

 	while (table.NextL())

 		{

 		table.GetL();

 		test (copy.NextL());

 		copy.GetL();

 		for (TInt ii=1;ii<=columns;++ii)

 			{

 			if (TDbCol::IsLong(table.ColType(ii)))

 				{

 				TInt len=table.ColSize(ii);

 				test (len==copy.ColSize(ii));

 				RDbColReadStream strm1;

 				strm1.OpenLC(table,ii);

 				RDbColReadStream strm2;

 				strm2.OpenLC(copy,ii);

 				TBuf8<512> buf1;

 				TBuf8<512> buf2;

 				while (len)

 					{

 					TInt block=Min(512,len);

 					strm1.ReadL(buf1,block);

 					strm2.ReadL(buf2,block);

 					test (buf1==buf2);

 					len-=block;

 					}

 				CleanupStack::PopAndDestroy(2);

 				}

 			else

 				{

 				test (table.ColDes8(ii)==copy.ColDes8(ii));

 				}

 			}

 		}

 	table.Close();

 	copy.Close();

 	}

 LOCAL_C void CheckL(const TDesC& aSource,const TDesC& aTarget)

 	{

 	RDbNamedDatabase comp;

 	RDbNamedDatabase copy;

 	test (comp.Open(TheFs,aSource,TPtrC(),comp.EReadOnly)==KErrNone);

 	test (copy.Open(TheFs,aTarget,TPtrC(),copy.EReadOnly)==KErrNone);

 	CDbTableNames* tables=comp.TableNamesL();

 	for (TInt ii=0;ii<tables->Count();++ii)

 		CheckTableL(comp,copy,(*tables)[ii]);

 	delete tables;

 	copy.Close();

 	comp.Close();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0593

 @SYMTestCaseDesc        Database compression tests.

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for RDbStoreDatabase::CompressL(),RDbStoreDatabase::DecompressL() functions 

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void Test(const TDesC& aSource,const TDesC& aTarget,TBool aCompress)

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0593 Converting database "));

 	TRAPD(r,CompressL(aSource,aTarget,aCompress));

 	test (r==KErrNone);

 	test.Next(_L("Checking database"));

 	TRAP(r,CheckL(aSource,aTarget));

 	test (r==KErrNone);

 	test.End();

 	}

 //

 // Prepare the test directory.

 //

 LOCAL_C void setupTestDirectory()

     {

 	TInt r=TheFs.Connect();

 	test(r==KErrNone);

 //

 	r=TheFs.MkDir(KTestDir);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	r=TheFs.SetSessionPath(KTestDir);

 	test(r==KErrNone);

 // On TOOLS2 - RFs::SetSessionPath() will affect all RFs Sessions, 

 // the two RFs need same session path anyway

 #ifdef __WINSCW__ 

 	r=TheCrcChecker.SetSessionPath(KTestDir);

 	test(r==KErrNone);

 #endif

 	}

 //

 // Initialise the cleanup stack.

 //

 LOCAL_C void setupCleanup()

     {

 	TheTrapCleanup=CTrapCleanup::New();

 	test(TheTrapCleanup!=NULL);

 	TRAPD(r,\

 		{\

 		for (TInt i=KTestCleanupStack;i>0;i--)\

 			CleanupStack::PushL((TAny*)0);\

 		CleanupStack::Pop(KTestCleanupStack);\

 		});

 	test(r==KErrNone);

 	}

 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

 	{

 	RFs fsSession;

 	TInt err = fsSession.Connect();

 	if(err == KErrNone)

 		{

 		TEntry entry;

 		if(fsSession.Entry(aFullName, entry) == KErrNone)

 			{

 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

 			if(err != KErrNone) 

 				{

 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

 				}

 			err = fsSession.Delete(aFullName);

 			if(err != KErrNone) 

 				{

 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

 				}

 			}

 		fsSession.Close();

 		}

 	else

 		{

 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

 		}

 	}

 //

 // Test streaming conversions.

 //

 GLDEF_C TInt E32Main()

     {

 	__UHEAP_MARK;

 	test.Title();

 	setupTestDirectory();

 	setupCleanup();

 //

 	test.Start(_L("Compressing..."));

 // Don't use the rom test file.

 /*

 	TUint dummy;

     TInt err = TheFs.Att(KRomTestFile,dummy);

 	if (err==KErrNone)

 		Test(KRomTestFile,KCompressedFile,ETrue);

 	else

 		Test(KTestFile,KCompressedFile,ETrue);

 */

 	Test(KTestFile,KCompressedFile,ETrue);

 	test.Next(_L("Decompressing..."));

 	Test(KCompressedFile,KDecompressedFile,EFalse);

 //

 #ifndef __TOOLS2__

 	_LIT(KTestDbName,"C:\\dbms-tst\\T_BENCH.DB");

 	::DeleteDataFile(KTestDbName);

 	_LIT(KTestDbName1,"C:\\dbms-tst\\T_COMP.DB1");

 	::DeleteDataFile(KTestDbName1);

 	_LIT(KTestDbName2,"C:\\dbms-tst\\T_COMP.DB2");

 	::DeleteDataFile(KTestDbName2);

 #else

 	_LIT(KTestDbName,"T_BENCH.DB");

 	::DeleteDataFile(KTestDbName);

 	_LIT(KTestDbName1,"T_COMP.DB1");

 	::DeleteDataFile(KTestDbName1);

 	_LIT(KTestDbName2,"T_COMP.DB2");

 	::DeleteDataFile(KTestDbName2);

 #endif

 #ifndef __linux__

 #ifdef CRC_COMP  // Exclude Crc checking for this test. It's out of scope.

 	TInt err;

 #ifndef __TOOLS2__

 	TRAPD(lc, err = TheCrcChecker.DumpCrcRecordsL(KCrcRecord));

 	test(err==KErrNone);

 	test(lc==KErrNone);

 #else

 	TRAPD(lc, err = TheCrcChecker.ValidateCrcRecordsL(KCrcRecord));

 	TPtrC errmsg;

 	TheCrcChecker.ErrorReportL(err, errmsg);

 	RDebug::Print(errmsg);

 	test(err==KErrNone || err==TDBMS_CRCChecks::ECrcCheckOk);

 #endif

 #endif

 #endif

 	delete TheTrapCleanup;

 	test.End(); //call to end must be after deletion of files - DEF047652

 	TheFs.Close();

 	test.Close();

 	__UHEAP_MARKEND;

 	return 0;

     }