// ///////////////////////////////////////////////////////////////////////////

//

// 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=T:\Robustness0.db

ExpectedError0=KErrNotFound

Create1=T:\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

// 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=T:\fillfile.txt

// Re-open the database. This is the point of the test - the database should

// still be usable.

Open11=T:\Robustness0.db

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

NewBlock14=AddBlock10-2

NewBlock15=CheckBlock10-2

Close16=

Delete17=T:\Robustness0.db

Delete18=T:\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. Unnecessary on the emulator.

[FillDisk4M]

EndBlock0=

// Fill the disk to within 150K of full.

[FillDisk150K]

Function0=NearFillDisk

FillFile=T:\fillfile2.txt

DiskFree=153600

EndBlock1=

// Fill the disk to within 100K of full.

[FillDisk100K]

Function0=NearFillDisk

FillFile=T:\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=T:\Robustness5.db

ExpectedError1=KErrNotFound

Create2=T:\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=T:\Robustness5.db

Delete22=T:\fillfile.txt

EndBlock23=

// Runs concurrently with DeleteTest.

[FillTest]

Delete0=T:\Robustness4.db

ExpectedError0=KErrNotFound

Create1=T:\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=T:\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=T:\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 "T:\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 "T:\Robustness3.db" as TheAttached;

NewBlock14=FillDisk2

Close15=

// Re-open and re-attach...

Open16=C:\Robustness2.db

Exec17=Attach "T:\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 "T:\Robustness3.db" as TheAttached;

// Verify the attached db is locked.

Delete22=T:\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=T:\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=T:\Robustness3.db

// This test has been done before..

Delete37=C:\Robustness2.db

ExpectedError37=KErrInUse

ReleaseReserveAccess38=

FreeReservedSpace39=

Close40=

Delete41=C:\Robustness2.db

Delete42=T:\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=