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

    }