diff -r 000000000000 -r 08ec8eefde2f persistentstorage/sql/TEST/testexecute/SQLite/config/Robustness.ini.DEVBOARD
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sql/TEST/testexecute/SQLite/config/Robustness.ini.DEVBOARD	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,387 @@
+
+// ///////////////////////////////////////////////////////////////////////////
+//
+// Used by Robustness.script, SYSLIB-SQL-CIT-1705.
+//
+// This config file defines operations to test robustness of the SQLite
+// system, under low disk conditions.
+//
+[Top]
+Delete0=E:\Robustness0.db
+ExpectedError0=KErrNotFound
+Create1=E:\Robustness0.db
+Exec2=Create Table Sometable(Someint int primary key, Somereal real, Sometext text);
+// Add a small amount of data and check it.
+NewBlock3=AddBlock10-1
+NewBlock4=CheckBlock10-1
+// Fill the disk to within 100K of full. First fill to within 150k so we have
+// an easy way of quickly getting 50K of disk back - by deleting 'fillfile'.
+NewBlock5=FillDisk150K
+NewBlock6=FillDisk100K
+
+Exec7=Begin Transaction;
+// Fill the disk until an out of disk error occurs. Then close the
+// database because once it's reported a disk full error all bets are off..
+NewBlock8=FillDisk1
+Close9=
+
+// This will return things to 50K of disk free (because we filled to 150K,
+// then to 100K with this file).
+Delete10=E:\fillfile.txt
+
+// Re-open the database. This is the point of the test - the database should
+// still be usable.
+Open11=E:\Robustness0.db
+
+// Check the original block is still ok...
+NewBlock12=CheckBlock10-1
+
+// Delete the data that we used to fill the disk. This is easy, our 'AddBlock'
+// data has 'Someint' values that are negative, the filldisk data is positive.
+Exec13=Delete From Sometable where Someint >= 0;
+
+NewBlock14=AddBlock10-2
+NewBlock15=CheckBlock10-2
+
+Close16=
+Delete17=E:\Robustness0.db
+Delete18=E:\fillfile2.txt
+EndBlock19=
+
+// Add two records to the table.
+[AddBlock2-1]
+Prepare0=Insert into Sometable(Someint, Somereal, Sometext) values(:FInt, :FReal, :FText);
+Function1=WriteBigTable
+LowCount=-30
+HighCount=-29
+CountStep=1
+Multiplier=-1.859785
+Text=Z:\TEF_SQL\TestData\reference1.txt
+EventuallyExpectedError=KErrNone
+St_Close2=
+EndBlock3=
+
+// Add ten records to the table.
+[AddBlock10-1]
+Prepare0=Insert into Sometable(Someint, Somereal, Sometext) values(:FInt, :FReal, :FText);
+Function1=WriteBigTable
+LowCount=-20
+HighCount=-11
+CountStep=1
+Multiplier=-1.859785
+Text=Z:\TEF_SQL\TestData\reference1.txt
+EventuallyExpectedError=KErrNone
+St_Close2=
+EndBlock3=
+
+// Add ten different records to the table.
+[AddBlock10-2]
+Prepare0=Insert into Sometable(Someint, Somereal, Sometext) values(:FInt, :FReal, :FText);
+Function1=WriteBigTable
+LowCount=-10
+HighCount=-1
+CountStep=1
+Multiplier=-1.859785
+Text=Z:\TEF_SQL\TestData\reference1.txt
+EventuallyExpectedError=KErrNone
+St_Close2=
+EndBlock3=
+
+// Check the records added by AddBlock10-1
+[CheckBlock10-1]
+Prepare0=Select * from Sometable;
+Next1=KSqlAtRow
+Function2=ReadBigTable
+LowCount=-20
+HighCount=-11
+CountStep=1
+Multiplier=-1.859785
+Text=Z:\TEF_SQL\TestData\reference1.txt
+EventuallyExpectedError=KErrNone
+St_Close3=
+EndBlock4=
+// Check both blocks.
+[CheckBlock10-2]
+Prepare0=Select * from Sometable;
+Next1=KSqlAtRow
+Function2=ReadBigTable
+LowCount=-20
+HighCount=-1
+CountStep=1
+Multiplier=-1.859785
+Text=Z:\TEF_SQL\TestData\reference1.txt
+EventuallyExpectedError=KErrNone
+St_Close3=
+EndBlock4=
+
+
+// /////////////////////////////////////////////////////////////////////////// 
+
+// Fill the disk to within 4M of full.
+[FillDisk4M]
+Function0=NearFillDisk
+FillFile=E:\fillfile4M.txt
+DiskFree=4194304
+EndBlock1=
+
+// Fill the disk to within 150K of full.
+[FillDisk150K]
+Function0=NearFillDisk
+FillFile=E:\fillfile2.txt
+DiskFree=153600
+EndBlock1=
+
+// Fill the disk to within 100K of full.
+[FillDisk100K]
+Function0=NearFillDisk
+FillFile=E:\fillfile.txt
+DiskFree=102400
+EndBlock1=
+
+// Use 8k text chunks to fill the disk up not so quickly.
+[FillDisk1]
+Prepare0=Insert into Sometable(Someint, Somereal, Sometext) values(:FInt, :FReal, :FText);
+Function1=WriteBigTable
+LowCount=0
+HighCount=999999
+CountStep=1
+Multiplier=299792458
+Text=Z:\TEF_SQL\TestData\reference1.txt
+EventuallyExpectedError=KErrDiskFull
+St_Close2=
+EndBlock3=
+
+// Fill the disk with small records, slow. We should close the database once the
+// i/o error has been seen - unless we have space reserved.
+[FillDisk2]
+Prepare0=Insert into Sometable(Someint, Somereal, Sometext) values(:FInt, :FReal, :FText);
+Function1=WriteBigTable
+LowCount=1000000
+HighCount=1999999
+CountStep=1
+Multiplier=299792458
+Text=S
+EventuallyExpectedError=KErrDiskFull
+St_Close2=
+EndBlock3=
+
+// ///////////////////////////////////////////////////////////////////////////
+//
+// Used by SYSLIB-SQL-CIT-1741
+// 
+// This block has two concurrent, synchronized threads. It checks that
+// a database can be modified when the disk is utterly full if disk space
+// has been reserved, looks for appropriate errors and so forth.
+//
+// This block is initially triggered by 'FillTest' which is working
+// on a separate db on the same disk at the same time.
+[DeleteTest]
+WaitA0=1
+Delete1=E:\Robustness5.db
+ExpectedError1=KErrNotFound
+
+Create2=E:\Robustness5.db
+// Reserve 100K of space.
+ReserveDriveSpace3=102400
+Exec4=Create Table Sometable(Someint int primary key, Somereal real, Sometext text);
+NoOperation5=
+
+// Fill the disk to within 100K of full.
+NewBlock6=FillDisk100K
+
+// Fill the remaining 100K with db writes. Do NOT close - we have reserved space.
+NewBlock7=FillDisk1
+
+// Get the reserved space.
+GetReserveAccess8=
+
+// And add two more records. No error should occur, we have reserved space now.
+// Two of these records is <15K.
+NewBlock9=AddBlock2-1
+NoOperation10=
+
+// Wake up 'FillTest'. There is very little disk space left (<8k?) at this
+// point but it will be using very small records so it'll manage some.
+SignalB11=1
+// Goes to FillTest Step 7.
+WaitA12=1
+
+// FillTest has filled the disk remaining with small records.
+// Our reserved disk space is actually shared so the following delete will
+// fail - the reserve has gone. Two records, about 15k.
+Exec13=delete from Sometable where Someint>=0 and Someint<2;
+ExpectedError13=KErrDiskFull
+ReleaseReserveAccess14=
+LastErrorMessage15=
+SignalB16=1
+WaitA17=1
+// Goes to FillTest Step 13.
+
+// Right, we're done. Clean up. Try releasing the reserve again, just to
+// see if it will break anything.. Naturally we must do this before the
+// RSqlDatabase::Close, we must have a valid object to do anything.
+ReleaseReserveAccess18=
+FreeReservedSpace19=
+Close20=
+Delete21=E:\Robustness5.db
+Delete22=E:\fillfile.txt
+EndBlock23=
+
+// Runs concurrently with DeleteTest.
+[FillTest]
+Delete0=E:\Robustness4.db
+ExpectedError0=KErrNotFound
+Create1=E:\Robustness4.db
+Exec2=Create Table Sometable(Someint int primary key, Somereal real, Sometext text);
+// Add some data to the database.
+NewBlock3=AddBlock10-1
+NewBlock4=CheckBlock10-1
+// Now trigger the 'DeleteTest' block - this fills the whole disk with a
+// separate database and signals us back when it's done.
+SignalA5=1
+// Goes to DeleteTest step 1.
+WaitB6=1
+// Attempt to add more data to our database.  Some will work, especially as
+// our records are small. The 'FillTest-1' block is expecting an error.
+Prepare7=Insert into Sometable(Someint, Somereal, Sometext) values(:FInt, :FReal, :FText);
+NewBlock8=FillTest-1
+St_Close9=
+
+// Wake up 'DeleteTest' again. It's going to delete a record or two.
+// Goes to DeleteTest Step 13.
+SignalA10=1
+WaitB11=1
+NoOperation12=
+
+// We can't do any db operations now - this thread never had reserved disk space
+// so all we can do is close down.
+
+Close13=
+Delete14=E:\Robustness4.db
+NoOperation15=
+// Goes to DeleteTest step 18.
+SignalA16=1
+EndBlock17=
+
+// Called by FillTest. Fills the (small) amount of remaining disk.
+[FillTest-1]
+Function0=WriteBigTable
+LowCount=12000000
+HighCount=12999999
+CountStep=1
+Multiplier=299792458
+Text=Shine On You Crazy Diamond
+EventuallyExpectedError=KErrDiskFull
+EndBlock1=
+
+// ///////////////////////////////////////////////////////////////////////////
+//
+// Used by SYSLIB-SQL-CIT-1704
+//
+// Here we create a database and add some data to it. Then we ATTACH another
+// database (creating it in the process) on a completely different partition.
+// We fill that partition with 'FillDisk' and then try to add one more record,
+// which should fail. Then we attempt to delete the attached database,
+// expecting 'KErrInUse', then we DETACH it and once more try to write to it,
+// which of course fails. Then we delete it.
+[Attach]
+Delete0=C:\Robustness2.db
+ExpectedError0=KErrNotFound
+Delete1=E:\Robustness3.db
+ExpectedError1=KErrNotFound
+Create2=C:\Robustness2.db
+NoOperation3=
+Exec4=Create Table Maintable(MyInt int primary key, MyReal real, MyText text);
+NewBlock5=AttachAddBlock
+
+Exec6=Attach "E:\Robustness3.db" as TheAttached;
+Exec7=Create Table TheAttached.Sometable(Someint int, Somereal real, Sometext text);
+
+// Fill the disk to within 100K of full (with a file..)
+NewBlock8=FillDisk150K
+NewBlock9=FillDisk100K
+
+// Fill up the drive with the attached database, first with big records,
+// then small.
+NewBlock10=FillDisk1
+Close11=
+
+// Re-open and re-attach.. Fill right to the limit with small records.
+Open12=C:\Robustness2.db
+Exec13=Attach "E:\Robustness3.db" as TheAttached;
+NewBlock14=FillDisk2
+Close15=
+
+// Re-open and re-attach...
+Open16=C:\Robustness2.db
+Exec17=Attach "E:\Robustness3.db" as TheAttached;
+
+// Verify we can add no more.
+Exec18=Insert into Sometable values(-90009, 2.718281828, "Hovercraft");
+ExpectedError18=KErrDiskFull
+
+// Close, re-open and re-attach, bets are off once we have a disk error.
+Close19=
+Open20=C:\Robustness2.db
+Exec21=Attach "E:\Robustness3.db" as TheAttached;
+
+// Verify the attached db is locked.
+Delete22=E:\Robustness3.db
+ExpectedError22=KErrInUse
+
+// Beyond this point we can't expect anything to work (necessarily) because
+// there isn't any disk space left. So grab free off 50K to make sure
+// (the fill to within 100K of full file which was created after filling
+// to within 150K of full).
+Delete23=E:\fillfile.txt
+NoOperation24=
+NoOperation25=
+
+// The number of lines common to both tables is highly dependent on exactly
+// how much space was left when the disk was filled. We really can't know
+// how many lines there will be so lets just check there are some.. Even
+// this might fail if the amount of space was very small..
+Prepare26=Select * from Maintable, Sometable where(MyInt = Someint);
+Next27=KSqlAtRow
+Next28=KSqlAtRow
+// Keep the reserve for the moment or we can't be sure things will run.
+
+// We're in the middle of an RSqlStatement operation so this detach will
+// fail.
+Exec29=Detach TheAttached;
+ExpectedError29=KSqlErrGeneral
+LastErrorMessage30=database TheAttached is locked
+// Statement has NOT expired, because DETACH should have failed..
+Next31=KSqlAtRow
+St_Close32=
+Exec33=Detach TheAttached;
+Exec34=Select * from Sometable;
+ExpectedError34=KSqlErrGeneral
+LastErrorMessage35=no such table: Sometable
+
+// Now try to delete it again. This attempt should be successful.
+Delete36=E:\Robustness3.db
+// This test has been done before..
+Delete37=C:\Robustness2.db
+ExpectedError37=KErrInUse
+ReleaseReserveAccess38=
+FreeReservedSpace39=
+Close40=
+Delete41=C:\Robustness2.db
+Delete42=E:\fillfile2.txt
+EndBlock43=
+
+// Just add a little to the database..
+[AttachAddBlock]
+Prepare0=Insert into Maintable(MyInt, MyReal, MyText) values(:FInt, :FReal, :FText);
+Function1=WriteBigTable
+LowCount=0
+HighCount=49
+CountStep=1
+Multiplier=9.869604401
+Text=Hey, here's some text.
+EventuallyExpectedError=KErrNone
+St_Close2=
+EndBlock3=
+
+