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

 //

 #include <d32dbms.h>

 #include <s32file.h>

 #include <e32test.h>

 #include "crccheck.h"

 #undef __UHEAP_MARK

 #define __UHEAP_MARK

 #undef __UHEAP_MARKEND

 #define __UHEAP_MARKEND

 #undef __UHEAP_CHECK

 #define __UHEAP_CHECK(a)

 LOCAL_D TDBMS_CRCChecks TheCrcChecker;

 #ifndef __linux__ //No CRC test on LINUX

 #ifdef __TOOLS2__

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

 #else

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

 #endif

 #endif

 LOCAL_D RTest test(_L("T_ALTER : Test AlterTable"));

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 LOCAL_D CFileStore* TheStore;

 LOCAL_D RDbStoreDatabase TheDatabase;

 LOCAL_D RDbTable TheTable;

 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

 const TPtrC KTestFile=_L("T_ALTER.DB");

 const TPtrC KTableName(_S("Table"));

 const TPtrC KTableName2(_S("Table2"));

 const TPtrC KIndexName(_S("Index"));

 TInt KRecords=100;

 const TUint KCol1Data=0;

 const TInt KCol2Data=2;

 const TPtrC KCol3Data=_L("three");

 const TUint8 _Col4Data[80]={4,4,4,4,0,0xff,2,2,1};

 const TPtrC8 KCol4Data(_Col4Data,sizeof(_Col4Data));

 const TUint KCol5Data=1;

 const TInt KCol6Data=5;

 const TPtrC KCol7Data=_L("six");

 const TPtrC KCol8Data=_L("column number eight = #8");

 const TUint8 _Col9Data[400]={1,2,3,4,5,6,7,8,9,10};

 const TPtrC8 KCol9Data(_Col9Data,sizeof(_Col9Data));

 const TText* const KColumn1=_S("c1");

 const TText* const KColumn2=_S("c2");

 const TText* const KColumn3=_S("c3");

 const TText* const KColumn4=_S("c4");

 const TText* const KColumn5=_S("c5");

 const TText* const KColumn6=_S("c6");

 const TText* const KColumn7=_S("c7");

 const TText* const KColumn8=_S("c8");

 const TText* const KColumn9=_S("c9");

 const TText* const KColumn10=_S("c10");

 const TText* const KColumn11=_S("c11");

 const TPtrC KColumns[]=

 	{

 	KColumn1,

 	KColumn2,

 	KColumn3,

 	KColumn4,

 	KColumn5,

 	KColumn6,

 	KColumn7,

 	KColumn8,

 	KColumn9

 	};

 class Set

 	{

 public:

 	struct SColDef

 		{

 		const TText* iName;

 		TDbColType iType;

 		TInt iAttributes;

 		TInt iMaxLength;

 		};

 	static SColDef const Basic[];

 	static SColDef const Bad[];

 	static SColDef const Incompatible1[];

 	static SColDef const Incompatible2[];

 	static SColDef const Incompatible3[];

 	static SColDef const Different[];

 	static SColDef const Extended[];

 	static SColDef const LongerText[];

 	static SColDef const TextToLongText[];

 	static SColDef const Column3[];

 	static SColDef const DropSome[];

 	static SColDef const DropAndAdd[];

 public:

 	static CDbColSet* CreateL(const SColDef* aDef);

 	};

 // the basic column definition

 enum TCol {EBit,EInt,EText,ELong,EBitNull,EIntNull,ETextNull,ELongNull,EExtra};

 Set::SColDef const Set::Basic[]=

 	{

 	{KColumn1,EDbColBit,TDbCol::ENotNull,-1},

 	{KColumn2,EDbColInt32,TDbCol::ENotNull,-1},

 	{KColumn3,EDbColText,TDbCol::ENotNull,-1},

 	{KColumn4,EDbColLongBinary,TDbCol::ENotNull,-1},

 	{KColumn5,EDbColBit,0,-1},

 	{KColumn6,EDbColInt32,0,-1},

 	{KColumn7,EDbColText,0,-1},

 	{KColumn8,EDbColText,0,50},

 	{0}

 	};

 // a basically invalid set

 Set::SColDef const Set::Bad[]=

 	{

 	{KColumn9,EDbColInt32,0,-1},

 	{KColumn9,EDbColInt32,0,-1},

 	{0}

 	};

 // an incompatible set with Basic

 Set::SColDef const Set::Incompatible1[]=

 	{

 	{KColumn1,EDbColInt32,TDbCol::ENotNull,-1},	// retype a column

 	{0}

 	};

 Set::SColDef const Set::Incompatible2[]=

 	{

 	{KColumn5,EDbColBit,TDbCol::ENotNull,-1},	// change attributes

 	{0}

 	};

 Set::SColDef const Set::Incompatible3[]=

 	{

 	{KColumn8,EDbColText,0,49},	// shrink a text column

 	{0}

 	};

 // a wildly different set

 Set::SColDef const Set::Different[]=

 	{

 	{KColumn11,EDbColInt32,0,-1},

 	{KColumn4,EDbColLongBinary,TDbCol::ENotNull,-1},

 	{KColumn10,EDbColBit,TDbCol::ENotNull,-1},

 	{KColumn3,EDbColText,TDbCol::ENotNull,-1},

 	{0}

 	};

 // basic + 1 column

 Set::SColDef const Set::Extended[]=

 	{

 	{KColumn1,EDbColBit,TDbCol::ENotNull,-1},

 	{KColumn2,EDbColInt32,TDbCol::ENotNull,-1},

 	{KColumn3,EDbColText,TDbCol::ENotNull,-1},

 	{KColumn4,EDbColLongBinary,TDbCol::ENotNull,-1},

 	{KColumn5,EDbColBit,0,-1},

 	{KColumn6,EDbColInt32,0,-1},

 	{KColumn7,EDbColText,0,-1},

 	{KColumn8,EDbColText,0,50},

 	{KColumn9,EDbColLongBinary,0,-1},		// add this column

 	{0}

 	};

 // Extended with a longer text column

 Set::SColDef const Set::LongerText[]=

 	{

 	{KColumn1,EDbColBit,TDbCol::ENotNull,-1},

 	{KColumn2,EDbColInt32,TDbCol::ENotNull,-1},

 	{KColumn3,EDbColText,TDbCol::ENotNull,-1},

 	{KColumn4,EDbColLongBinary,TDbCol::ENotNull,-1},

 	{KColumn5,EDbColBit,0,-1},

 	{KColumn6,EDbColInt32,0,-1},

 	{KColumn7,EDbColText,0,-1},

 	{KColumn8,EDbColText,0,51},			// longer definition

 	{KColumn9,EDbColLongBinary,0,-1},

 	{0}

 	};

 // Extended with a text->LongText column

 Set::SColDef const Set::TextToLongText[]=

 	{

 	{KColumn1,EDbColBit,TDbCol::ENotNull,-1},

 	{KColumn2,EDbColInt32,TDbCol::ENotNull,-1},

 	{KColumn3,EDbColText,TDbCol::ENotNull,-1},

 	{KColumn4,EDbColLongBinary,TDbCol::ENotNull,-1},

 	{KColumn5,EDbColBit,0,-1},

 	{KColumn6,EDbColInt32,0,-1},

 	{KColumn7,EDbColText,0,-1},

 	{KColumn8,EDbColLongText,0,-1},		// longer still

 	{KColumn9,EDbColLongBinary,0,-1},

 	{0}

 	};

 Set::SColDef const Set::Column3[]=

 	{

 	{KColumn3,EDbColText,TDbCol::ENotNull,-1},

 	{0}

 	};

 Set::SColDef const Set::DropSome[]=

 	{

 	{KColumn1,EDbColBit,TDbCol::ENotNull,-1},

 	{KColumn2,EDbColInt32,TDbCol::ENotNull,-1},

 	{KColumn6,EDbColInt32,0,-1},

 	{KColumn7,EDbColText,0,-1},

 	{0}

 	};

 Set::SColDef const Set::DropAndAdd[]=

 	{

 	{KColumn2,EDbColInt32,TDbCol::ENotNull,-1},

 	{KColumn7,EDbColText,0,-1},

 	{KColumn10,EDbColBinary,0,-1},

 	{0}

 	};

 CDbColSet* Set::CreateL(const SColDef* aDef)

 	{

 	CDbColSet *set=CDbColSet::NewLC();

 	for (;aDef->iName;++aDef)

 		{

 		TDbCol col(TPtrC(aDef->iName),aDef->iType);

 		col.iAttributes=aDef->iAttributes;

 		if (aDef->iMaxLength>=0)

 			col.iMaxLength=aDef->iMaxLength;

 		set->AddL(col);

 		}

 	CleanupStack::Pop();

 	return set;

 	}

 //

 // Create the database-in-a-store

 //

 LOCAL_C void CreateDatabaseL()

 	{

 	CFileStore* store=CPermanentFileStore::ReplaceLC(TheFs,KTestFile,EFileRead|EFileWrite);

 	store->SetTypeL(KPermanentFileStoreLayoutUid);

 	TStreamId id;

 	    id=TheDatabase.CreateL(store);

 	store->SetRootL(id);

 	store->CommitL();

 	CleanupStack::Pop();

 	TheStore=store;

 	}

 //

 // Open the database-in-a-store

 //

 LOCAL_C void OpenDatabaseL()

 	{

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

 	TStreamId id=store->Root();

 	    TheDatabase.OpenL(store,id);

 	CleanupStack::Pop();

 	TheStore=store;

 	}

 LOCAL_C void CloseDatabaseL()

 	{

 	TheDatabase.Close();

 	delete TheStore;

 	TInt err = TheCrcChecker.GenerateCrcL(KTestFile);

 	test(err==KErrNone);

 	}

 LOCAL_C void DestroyDatabaseL()

 	{

 	TheDatabase.Destroy();

 	TheStore->CommitL();

 	delete TheStore;

 	TInt err = TheCrcChecker.GenerateCrcL(KTestFile);

 	test(err==KErrNone);

 	}

 LOCAL_C CDbColSet* TableDefinitionL(const TDesC& aTable)

 	{

 	RDbTable table;

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

 	CDbColSet* cs=table.ColSetL();

 	table.Close();

 	return cs;

 	}

 //

 // Compare two column sets

 //

 LOCAL_C void Compare(const CDbColSet& aLeft,const CDbColSet& aRight)

 	{

 	test(aLeft.Count()==aRight.Count());

 	for (TDbColSetIter iter(aLeft);iter;++iter)

 		{

 		const TDbCol* pRight=aRight.Col(iter->iName);

 		test(pRight!=NULL);

 		test(iter->iType==pRight->iType);

 		test(iter->iMaxLength==KDbUndefinedLength || pRight->iMaxLength==KDbUndefinedLength || iter->iMaxLength==pRight->iMaxLength);

 		test((iter->iAttributes&pRight->iAttributes)==iter->iAttributes);

 		}

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0575

 @SYMTestCaseDesc        Store database test 

                         Test for altering the table with different column definitions  

 @SYMTestPriority        Medium

 @SYMTestActions        	Test for RDbStoreDatabase::AlterTable(),RDbStoreDatabase::DropIndex()

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestEmptyTable()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0575 Create table "));

 	CreateDatabaseL();

 	CDbColSet* set=Set::CreateL(Set::Basic);

 	test(TheDatabase.CreateTable(KTableName,*set)==KErrNone);

 	test.Next(_L("Alter non existant table"));

 	test(TheDatabase.AlterTable(KTableName2,*set)==KErrNotFound);

 	delete set;

 //

 	test.Next(_L("Alter to bad definitions"));

 	set=Set::CreateL(Set::Bad);

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 	delete set;

 	set=Set::CreateL(Set::Incompatible1);

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 	delete set;

 	set=Set::CreateL(Set::Incompatible2);

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 	delete set;

 	set=Set::CreateL(Set::Incompatible3);

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 	delete set;

 //

 	test.Next(_L("Drop an indexed column"));

 	CDbKey* key=CDbKey::NewLC();

 	key->AddL(TPtrC(KColumn2));

 	key->MakeUnique();

 	test(TheDatabase.CreateIndex(KIndexName,KTableName,*key)==KErrNone);

 	CleanupStack::PopAndDestroy();

 	set=TableDefinitionL(KTableName);

 	set->Remove(TPtrC(KColumn2));

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 	test(TheDatabase.DropIndex(KIndexName,KTableName)==KErrNone);

 	delete set;

 //

 	test.Next(_L("Extend an indexed text column"));

 	set=Set::CreateL(Set::Extended);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 	key=CDbKey::NewLC();

 	key->AddL(TPtrC(KColumn8));

 	key->MakeUnique();

 	test(TheDatabase.CreateIndex(KIndexName,KTableName,*key)==KErrNone);

 	CleanupStack::PopAndDestroy();

 	set=Set::CreateL(Set::LongerText);

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 	test(TheDatabase.DropIndex(KIndexName,KTableName)==KErrNone);

 //

 	test.Next(_L("Extend a text column"));

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 //

 	test.Next(_L("Extend a text column to a LongText column"));

 	set=Set::CreateL(Set::TextToLongText);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 //

 	test.Next(_L("Alter to a very different set"));

 	set=Set::CreateL(Set::Different);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	CloseDatabaseL();

 	OpenDatabaseL();

 	CDbColSet* def=TableDefinitionL(KTableName);

 	Compare(*set,*def);

 	delete def;

 	delete set;

 	test.End();

 	test(TheDatabase.DropTable(KTableName)==KErrNone);

 	DestroyDatabaseL();

 	}

 class Map

 	{

 public:

 	Map();

 	void Init(RDbRowSet& aSet);

 	inline TDbColNo operator[](TInt aCol) const

 		{return iMap[aCol];}

 private:

 	TDbColNo iMap[EExtra+1];

 	};

 Map::Map()

 	{

 	}

 void Map::Init(RDbRowSet& aSet)

 	{

 	CDbColSet* set=NULL;

 	TRAPD(errCode, set=aSet.ColSetL());

 	if(errCode != KErrNone)

 		{

 		return;

 		}

 	for (TInt ii=EBit;ii<=EExtra;++ii)

 		iMap[ii]=set->ColNo(KColumns[ii]);

 	if(set)

 		delete set;

 	}

 //

 // Build the table for Altering

 //

 LOCAL_C void BuildTable(const Set::SColDef* aDef=Set::Basic)

 	{

 	CDbColSet* set=Set::CreateL(aDef);

 	test(TheDatabase.CreateTable(KTableName,*set)==KErrNone);

 	delete set;

 	TheDatabase.Begin();

 	test(TheTable.Open(TheDatabase,KTableName,TheTable.EInsertOnly)==KErrNone);

 	Map map;

 	map.Init(TheTable);

 	for (TInt ii=0;ii<KRecords;++ii)

 		{

 		TheTable.InsertL();

 		TheTable.SetColL(map[EBit],KCol1Data);

 		TheTable.SetColL(map[EInt],KCol2Data);

 		TheTable.SetColL(map[EText],KCol3Data);

 		TheTable.SetColL(map[ELong],KCol4Data);

 		if ((ii%EBitNull)==0)

 			TheTable.SetColL(map[EBitNull],KCol5Data);

 		if ((ii%EIntNull)==0)

 			TheTable.SetColL(map[EIntNull],KCol6Data);

 		if ((ii%ETextNull)==0)

 			TheTable.SetColL(map[ETextNull],KCol7Data);

 		if ((ii%ELongNull)==0)

 			TheTable.SetColL(map[ELongNull],KCol8Data);

 		if (map[EExtra] && (ii%EExtra)==0)

 			TheTable.SetColL(map[EExtra],KCol9Data);

 		TheTable.PutL();

 		}

 	TheTable.Close();

 	test(TheDatabase.Commit()==KErrNone);

 	}

 LOCAL_C void CheckBlob(TDbColNo aCol,const TDesC8& aData)

 	{

 	test(TheTable.ColSize(aCol)==aData.Size());

 	TBuf8<500> buf;

 	__ASSERT_DEBUG(buf.MaxLength()>=aData.Length(),User::Invariant());

 	RDbColReadStream str;

 	str.OpenLC(TheTable,aCol);

 	str.ReadL(buf,aData.Length());

 	CleanupStack::PopAndDestroy();

 	test(buf==aData);

 	}

 #if defined(UNICODE)

 LOCAL_C void CheckBlob(TDbColNo aCol,const TDesC16& aData)

 	{

 	test(TheTable.ColSize(aCol)==aData.Size());

 	TBuf16<500> buf;

 	__ASSERT_DEBUG(buf.MaxLength()>=aData.Length(),User::Invariant());

 	RDbColReadStream str;

 	str.OpenLC(TheTable,aCol);

 	str.ReadL(buf,aData.Length());

 	CleanupStack::PopAndDestroy();

 	test(buf==aData);

 	}

 #endif

 //

 // Check that the columns which still exist, still contain the same stuff

 // New columns should be Null

 //

 LOCAL_C void CheckTable()

 	{

 	test(TheTable.Open(TheDatabase,KTableName,TheTable.EReadOnly)==KErrNone);

 	Map map;

 	map.Init(TheTable);

 	for (TInt ii=0;ii<KRecords;++ii)

 		{

 		test(TheTable.NextL());

 		TheTable.GetL();

 		if (map[EBit])

 			test(TheTable.ColUint(map[EBit])==KCol1Data);

 		if (map[EInt])

 			test(TheTable.ColInt(map[EInt])==KCol2Data);

 		if (map[EText])

 			test(TheTable.ColDes(map[EText])==KCol3Data);

 		if (map[ELong])

 			CheckBlob(map[ELong],KCol4Data);

 		for (TInt jj=EBitNull;jj<=EExtra;++jj)

 			{

 			if (!map[jj])

 				continue;

 			if (ii%jj)

 				test(TheTable.IsColNull(map[jj]));

 			else

 				{

 				switch (jj)

 					{

 				case EBitNull:

 					test(TheTable.ColUint(map[EBitNull])==KCol5Data);

 					break;

 				case EIntNull:

 					test(TheTable.ColInt(map[EIntNull])==KCol6Data);

 					break;

 				case ETextNull:

 					test(TheTable.ColDes(map[ETextNull])==KCol7Data);

 					break;

 				case ELongNull:

 					CheckBlob(map[ELongNull],KCol8Data);

 					break;

 				case EExtra:

 					CheckBlob(map[EExtra],KCol9Data);

 					break;

 					}

 				}

 			}

 		}

 	TheTable.Close();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0576

 @SYMTestCaseDesc        Test a full table

 @SYMTestPriority        Medium

 @SYMTestActions        	Tests for altering the table 

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestFullTable()

 	{

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

 	CreateDatabaseL();

 //

 	test.Next(_L("Add non-null column"));

 	BuildTable();

 	CDbColSet* set=TableDefinitionL(KTableName);

 	TDbCol col10=TDbCol(TPtrC(KColumn10),EDbColInt32);

 	col10.iAttributes=TDbCol::ENotNull;

 	set->AddL(col10);

 	test(TheDatabase.AlterTable(KTableName,*set)!=KErrNone);

 //

 	test.Next(_L("Add nullable column"));

 	set->Remove(col10.iName);

 	col10.iAttributes=0;

 	set->AddL(col10);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	CheckTable();

 //

 	test.Next(_L("Drop columns one by one"));

 	while (set->Count()>1)

 		{

 		set->Remove((*set)[1].iName);

 		test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 		CheckTable();

 		}

 	delete set;

 	test(TheDatabase.DropTable(KTableName)==KErrNone);

 //

 	test.Next(_L("Extend a text column"));

 	BuildTable(Set::Extended);

 	set=Set::CreateL(Set::LongerText);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 	CheckTable();

 //

 	test.Next(_L("Extend it to a LongText column"));

 	set=Set::CreateL(Set::TextToLongText);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 	CheckTable();

 //

 	test.Next(_L("Drop all except one"));

 	set=Set::CreateL(Set::Column3);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 	CheckTable();

 	test(TheDatabase.DropTable(KTableName)==KErrNone);

 	test.Next(_L("Drop single column"));

 	for (TInt ii=EBit;ii<=EExtra;++ii)

 		{

 		BuildTable(Set::Extended);

 		CDbColSet* set=TableDefinitionL(KTableName);

 		set->Remove(KColumns[ii]);

 		test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 		delete set;

 		CheckTable();

 		test(TheDatabase.DropTable(KTableName)==KErrNone);

 		}

 	test.Next(_L("Drop multiple columns"));

 	BuildTable();

 	set=Set::CreateL(Set::DropSome);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 	CheckTable();

 	test.Next(_L("Drop and add together"));

 	set=Set::CreateL(Set::DropAndAdd);

 	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);

 	delete set;

 	CheckTable();

 	test(TheDatabase.DropTable(KTableName)==KErrNone);

 	test.End();

 	DestroyDatabaseL();

 	}

 LOCAL_C void Test()

 	{

 	__UHEAP_MARK;

 //

 	test.Start(_L("Alter empty table"));

 	TRAPD(r,TestEmptyTable();)

 	test(r==KErrNone);

 	__UHEAP_CHECK(0);

 	test.Next(_L("Alter full table"));

 	TRAP(r,TestFullTable();)

 	test(r==KErrNone);

 	test.End();

 //

 	__UHEAP_MARKEND;

 	}

 //

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

     {

 	test.Title();

 	setupTestDirectory();

 	setupCleanup();

 	__UHEAP_MARK;

 	test.Start(_L("Standard database"));

 	Test();

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

 	Test();

 	// clean up data files used by this test - must be done before call to End() - DEF047652

 #ifndef __TOOLS2__

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

 #else

 	_LIT(KTestDbName, "T_ALTER.DB");

 #endif

 	::DeleteDataFile(KTestDbName);

 #ifndef __linux__

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

 #endif // linux

 	test.End();

 	__UHEAP_MARKEND;

 	delete TheTrapCleanup;

 	TheFs.Close();

 	test.Close();

 	return 0;

     }