diff -r 000000000000 -r 08ec8eefde2f persistentstorage/dbms/tdbms/t_dbalter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/tdbms/t_dbalter.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,697 @@
+// 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>
+
+LOCAL_D RTest test(_L("t_dbalter : 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;
+const TPtrC KTestDir=_L("C:\\DBMS-TST\\");
+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;
+	}
+
+LOCAL_C void DestroyDatabaseL()
+	{
+	TheDatabase.Destroy();
+	TheStore->CommitL();
+	delete TheStore;
+	}
+
+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 TestEmptyTableL()
+	{
+	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 BuildTableL(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 CheckBlobL(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 CheckBlobL(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 CheckTableL()
+	{
+	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])
+			CheckBlobL(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:
+					CheckBlobL(map[ELongNull],KCol8Data);
+					break;
+				case EExtra:
+					CheckBlobL(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 TestFullTableL()
+	{
+	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0576 Create database "));
+	CreateDatabaseL();
+//
+	test.Next(_L("Add non-null column"));
+	BuildTableL();
+	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);
+	CheckTableL();
+//
+	test.Next(_L("Drop columns one by one"));
+	while (set->Count()>1)
+		{
+		set->Remove((*set)[1].iName);
+		test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+		CheckTableL();
+		}
+	delete set;
+	test(TheDatabase.DropTable(KTableName)==KErrNone);
+//
+	test.Next(_L("Extend a text column"));
+	BuildTableL(Set::Extended);
+	set=Set::CreateL(Set::LongerText);
+	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+	delete set;
+	CheckTableL();
+//
+	test.Next(_L("Extend it to a LongText column"));
+	set=Set::CreateL(Set::TextToLongText);
+	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+	delete set;
+	CheckTableL();
+//
+	test.Next(_L("Drop all except one"));
+	set=Set::CreateL(Set::Column3);
+	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+	delete set;
+	CheckTableL();
+	test(TheDatabase.DropTable(KTableName)==KErrNone);
+	test.Next(_L("Drop single column"));
+	for (TInt ii=EBit;ii<=EExtra;++ii)
+		{
+		BuildTableL(Set::Extended);
+		CDbColSet* set=TableDefinitionL(KTableName);
+		set->Remove(KColumns[ii]);
+		test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+		delete set;
+		CheckTableL();
+		test(TheDatabase.DropTable(KTableName)==KErrNone);
+		}
+	test.Next(_L("Drop multiple columns"));
+	BuildTableL();
+	set=Set::CreateL(Set::DropSome);
+	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+	delete set;
+	CheckTableL();
+	test.Next(_L("Drop and add together"));
+	set=Set::CreateL(Set::DropAndAdd);
+	test(TheDatabase.AlterTable(KTableName,*set)==KErrNone);
+	delete set;
+	CheckTableL();
+	test(TheDatabase.DropTable(KTableName)==KErrNone);
+	test.End();
+	DestroyDatabaseL();
+	}
+
+LOCAL_C void Test()
+	{
+	__UHEAP_MARK;
+//
+	test.Start(_L("Alter empty table"));
+	TRAPD(r,TestEmptyTableL();)
+	test(r==KErrNone);
+	__UHEAP_CHECK(0);
+	test.Next(_L("Alter full table"));
+	TRAP(r,TestFullTableL();)
+	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);
+	}
+
+//
+// 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
+	_LIT(KTestDbName, "C:\\DBMS-TST\\T_ALTER.DB");
+	::DeleteDataFile(KTestDbName);
+
+	test.End();
+//
+	__UHEAP_MARKEND;
+	delete TheTrapCleanup;
+
+	TheFs.Close();
+	test.Close();
+	return 0;
+    }