// Copyright (c) 2006-2010 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:
// NTT DOCOMO, INC - Fix for Bug 1915 "SQL server panics when using long column type strings"
//
// Description:
//
#include <e32test.h>
#include <bautils.h>
#include <s32stor.h>
#include <sqldb.h>
#include "SqlResourceProfiler.h"
#include "SqlResourceTester.h"
///////////////////////////////////////////////////////////////////////////////////////
static RFs TheFs;
RTest TheTest(_L("t_sqldefect test"));
RSqlDatabase TheDb;
_LIT(KTestDir, "c:\\test\\");
_LIT(KTestDatabase1, "c:\\test\\t_sqldefect_1.db");
_LIT(KTestDatabase2, "c:\\test\\t_sqldefect_2.db");
_LIT(KCorruptDb, "c:\\test\\t_SqlShortNonDb.db");
_LIT(KCorruptDbZ, "z:\\test\\t_SqlShortNonDb.db"); //Created outside this test app
_LIT(KSecureTestDb1, "c:[21212122]BBDb2.db"); //Created outside this test app
_LIT(KTestDatabase3, "c:\\test\\t_sqldefect_3.db");
_LIT(KTestDatabase4, "z:\\test\\t_inc095412.db"); //Created outside this test app
_LIT(KTestDatabase5, "c:\\test\\t_sqldefect_5.db");
_LIT(KTestDatabase6, "c:\\test\\t_def120237.db");
_LIT(KTestDatabase7, "c:\\test\\t_def144027.db");
_LIT(KTestDatabase7Journal, "c:\\test\\t_def144027.db-journal");
// This value has been found by performing the OOM test
// with an allocation limit of 2000 and then taking a value
// which is just above the allocation failure rate.
const TInt KDEF115954MaxAllocLimit = 1300;
///////////////////////////////////////////////////////////////////////////////////////
//Deletes all created test files.
void DeleteTestFiles()
{
TheDb.Close();
(void)TheFs.Delete(KTestDatabase7Journal);
(void)RSqlDatabase::Delete(KTestDatabase7);
(void)RSqlDatabase::Delete(KTestDatabase6);
(void)RSqlDatabase::Delete(KTestDatabase5);
(void)RSqlDatabase::Delete(KTestDatabase3);
(void)RSqlDatabase::Delete(KTestDatabase2);
(void)RSqlDatabase::Delete(KTestDatabase1);
(void)RSqlDatabase::Delete(KCorruptDb);
}
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check1(TInt aValue, TInt aLine)
{
if(!aValue)
{
DeleteTestFiles();
RDebug::Print(_L("*** Line %d\r\n"), aLine);
TheTest(EFalse, aLine);
}
}
void Check2(TInt aValue, TInt aExpected, TInt aLine)
{
if(aValue != aExpected)
{
DeleteTestFiles();
RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
TheTest(EFalse, aLine);
}
}
#define TEST(arg) ::Check1((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
///////////////////////////////////////////////////////////////////////////////////////
//Creates file session instance and the test directory
void CreateTestEnv()
{
TInt err = TheFs.Connect();
TEST2(err, KErrNone);
err = TheFs.MkDir(KTestDir);
TEST(err == KErrNone || err == KErrAlreadyExists);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1763
@SYMTestCaseDesc The test creates database 1 and attaches database 2.
Then the test prepares a SELECT sql statement which is supposed to
retrieve records from the attached database 2. Then the test tries to detach
database 2. The expectation is that the detaching operation must fail.
The database can be detached only when there are no alive sql statements prepared on it.
@SYMTestPriority High
@SYMTestActions SQL, "Detach database" test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
REQ5793
*/
void SqlDetachedDbTest()
{
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Exec(_L8("CREATE TABLE A(Id INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L8("INSERT INTO A(Id) VALUES(1)"));
TEST2(err, 1);
TheDb.Close();
err = TheDb.Create(KTestDatabase2);
TEST2(err, KErrNone);
err = TheDb.Exec(_L8("CREATE TABLE B(N INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L8("INSERT INTO B(N) VALUES(10)"));
TEST2(err, 1);
err = TheDb.Exec(_L8("INSERT INTO B(N) VALUES(20)"));
TEST2(err, 1);
TheDb.Close();
err = TheDb.Open(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Attach(KTestDatabase2, _L("Db2"));
TEST2(err, KErrNone);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L8("SELECT * FROM B"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
err = TheDb.Detach(_L("Db2"));
TEST(err != KErrNone);
TPtrC errMsg = TheDb.LastErrorMessage();
RDebug::Print(_L("Detach err: %S\r\n"), &errMsg);
err = stmt.Next();
TEST2(err, KSqlAtRow);
stmt.Close();
err = TheDb.Detach(_L("Db2"));
TEST2(err, KErrNone);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase2);
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4034
@SYMTestCaseDesc Corrupted database test.
The test tries to open a corrupted database file which length is too short.
The 'database open' operation is expected to fail with KSqlErrNotDb error.
@SYMTestPriority High
@SYMTestActions Corrupted database test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
*/
void CorruptDbFileTest()
{
TInt err = TheDb.Open(KCorruptDb);
TEST2(err, KSqlErrNotDb);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4035
@SYMTestCaseDesc Attach database with bad name.
Attempt to attach a file which name cannot be parsed.
The 'attach database' operation is expected to fail with KErrBadName error.
@SYMTestPriority High
@SYMTestActions Attach database with bad name.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
*/
void AttachBadDbFileNameTest()
{
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Attach(_L("\"c:\\test\\d12345678.db\""), _L("Db10"));
TEST2(err, KErrBadName);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4036
@SYMTestCaseDesc Attach secure database. The client cannot pass the security checks.
Attempt to attach a secure database. The client cannot pass the security checks.
The 'attach database' operation is expected to fail with KErrPermissionDenied error.
@SYMTestPriority High
@SYMTestActions Attach secure database. The client cannot pass the security checks.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5794
*/
void AttachSecureDbTest()
{
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Attach(KSecureTestDb1, _L("Db10"));
TEST2(err, KErrPermissionDenied);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4032
@SYMTestCaseDesc Test for defect INC091579 - SQL Panic 7 when streaming BLOB fields.
The test creates a database with a table with a BLOB column. Then inserts
a record. Then the test makes an attempt to read the BLOB column using a stream -
RSqlColumnReadStream. If the defect is not fixed, the code will panic.
@SYMTestPriority High
@SYMTestActions Test for defect INC091579 - SQL Panic 7 when streaming BLOB fields.
@SYMTestExpectedResults Test must not fail
@SYMDEF INC091579
*/
void INC091579L()
{
//Create test database
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
_LIT8(KCreateStmt, "CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)");
err = TheDb.Exec(KCreateStmt);
TEST(err >= 0);
//Insert 1 row, using a binary stream
_LIT8(KInsertStmt, "INSERT INTO A(Fld1,Fld2) VALUES(:p1,:p2)");
RSqlStatement stmt;
err = stmt.Prepare(TheDb, KInsertStmt);
TEST2(err, KErrNone);
err = stmt.BindInt(0, 1);
TEST2(err, KErrNone);
RSqlParamWriteStream out;
err = out.BindBinary(stmt, 1);
TEST2(err, KErrNone);
const TInt KDataSize = 100;
TUint16 columnData[KDataSize];
for(TInt i=0;i<KDataSize;i++)
{
columnData[i] = (TUint16)i;
}
out.WriteL(columnData, KDataSize);
out.CommitL();
err = stmt.Exec();
TEST2(err, 1);
out.Close();
stmt.Close();
//Try to read the inserted row, using a binary stream
_LIT8(KSelectStmt, "SELECT * FROM A WHERE Fld1=1");
err = stmt.Prepare(TheDb, KSelectStmt);
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
RSqlColumnReadStream in;
TInt idx = stmt.ColumnIndex(_L("Fld2"));
TInt type = stmt.ColumnType(idx);
TInt size = stmt.ColumnSize(idx);
err = in.ColumnBinary(stmt,idx); // panic occurs here, if the defect is not fixed
TEST2(err, KErrNone);
in.Close();
//Cleanup
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4033
@SYMTestCaseDesc Test for defect INC091580 - SQL returns bogus pointer when too much text in field.
The test creates a database with a table with 2 TEXT columns. Then inserts
a record using a prepared statement with parameters.
The second text column value is set twice calling RSqlStatement::BindText().
Then the test makes an attempt to read the TEXT columns using a SELECT statement -
RSqlStatement. If the defect is not fixed, the RSqlStatement::ColumnText() returns a
bad value for the first TEXT column.
@SYMTestPriority High
@SYMTestActions Test for defect INC091580 - SQL returns bogus pointer when too much text in field.
@SYMTestExpectedResults Test must not fail
@SYMDEF INC091580
*/
void INC091580L()
{
_LIT8(KCreateStmt, "CREATE TABLE A(Fld1 INTEGER, Fld2 TEXT, Fld3 TEXT)");
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
err = TheDb.Exec(KCreateStmt);
TEST(err >= 0);
_LIT8(KInsertStmt,"INSERT INTO A(Fld1,Fld2,Fld3) VALUES(1,:p1,:p2)");
RSqlStatement stmt;
err = stmt.Prepare(TheDb, KInsertStmt);
TEST2(err, KErrNone);
err = stmt.BindText(0, _L("AAA"));// "AAA" assigned to p1 parameter
TEST2(err, KErrNone);
err = stmt.BindText(1,_L("123456789ABCD"));//"123456789ABCD" assigned to p2 parameter (Fld2 column)
TEST2(err, KErrNone);
err = stmt.BindText(1, _L("123456789ABCDE"));//"123456789ABCDE" assigned to p2 parameter (Fld3 column)
TEST2(err, KErrNone);
err = stmt.Exec();
TEST(err >= 0);
stmt.Close();
_LIT8(KSelectStmt,"SELECT * FROM A WHERE Fld1=1");
err = stmt.Prepare(TheDb, KSelectStmt);
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
TPtrC fld2 = stmt.ColumnTextL(1); // returns bad value if the defect is not fixed
TPtrC fld3 = stmt.ColumnTextL(2);
TEST(fld2 == _L("AAA"));
TEST(fld3 == _L("123456789ABCDE"));
//Cleanup
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1815
@SYMTestCaseDesc KSqlErrFull test.
Create a test database with a table, which first column is declared as
"INTEGER PRIMARY KEY AUTOINCREMENT".
Insert one record into the table, initializing the ROWID with 0x7FFFFFFFFFFFFFFF
(KMaxTInt64). Try to insert one more record into the table. The operation must
fails with KSqlErrDiskFull.
@SYMTestPriority High
@SYMTestActions Verifying that SQL server returns KSqlErrFull when there are no more available row ids.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
REQ5793
*/
void SqlErrFullTest()
{
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Exec(_L8("CREATE TABLE A(Id INTEGER PRIMARY KEY AUTOINCREMENT, T TEXT)"));
TEST(err >= 0);
TBuf8<100> sql;
sql.Copy(_L8("INSERT INTO A(ROWID,T) VALUES("));
sql.AppendNum(KMaxTInt64);
sql.Append(_L8(", 'TTT')"));
err = TheDb.Exec(sql);
TEST(err >= 0);
err = TheDb.Exec(_L8("INSERT INTO A(T) VALUES('UUU')"));
TEST2(err, KSqlErrFull);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L8("SELECT ROWID FROM A"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
TInt64 val = stmt.ColumnInt64(0);
TEST(val == KMaxTInt64);
err = stmt.Next();
TEST2(err, KSqlAtEnd);
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1816-0001
@SYMTestCaseDesc Test for defect INC094870 - Database became corrupted and cannot be opened.
Case 1: Create a test database and set the database encoding to be UTF-8. Create a table.
Close and open again the database. "Database open" operation should not panic.
Case 2: Create a test database and set the database encoding to be UTF-8. Open two
connections to the database and check the encoding. It should be UTF-8.
@SYMTestPriority High
@SYMTestActions Test for defect INC094870 - Database became corrupted and cannot be opened.
@SYMTestExpectedResults Test must not fail
@SYMDEF INC094870
*/
void INC094870L()
{
(void)RSqlDatabase::Delete(KTestDatabase3);
//Test 1 - with a single database
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
err = TheDb.Exec(_L8("PRAGMA cache_size=1000"));
TEST(err >= 0);
err = TheDb.SetIsolationLevel(RSqlDatabase::EReadUncommitted);
TEST(err >= 0);
err = TheDb.Exec(_L8("PRAGMA encoding = \"UTF-8\";"));
TEST(err >= 0);
err = TheDb.Exec(_L8("PRAGMA case_sensitive_like = 0"));
TEST(err >= 0);
err = TheDb.Exec(_L8("CREATE TABLE RDFS_Namespace(NamespaceId INTEGER NOT NULL,Uri TEXT NOT NULL,ReadOnly INTEGER NOT NULL,VID INTEGER NOT NULL,PRIMARY KEY(NamespaceId),UNIQUE(Uri));"));
TEST(err >= 0);
//Close and reopen the database. The Open() call should not fail.
TheDb.Close();
err = TheDb.Open(KTestDatabase3); // This call fails if the defect is not fixed
TEST2(err, KErrNone);
TheDb.Close();
//Test 2 - with two database connections
(void)RSqlDatabase::Delete(KTestDatabase3);
_LIT8(KEncoding, "encoding=UTF-8");
_LIT(KUtf8, "UTF-8");
RSqlDatabase db1, db2;
//Connection 1: Create a database with default encoding UTF-8.
err = db1.Create(KTestDatabase3, &KEncoding);
TEST2(err, KErrNone);
TBuf<100> buf;
//Connection 1: Check the database encoding
TSqlScalarFullSelectQuery query(db1);
err = query.SelectTextL(_L8("PRAGMA encoding"), buf);
TEST2(err, KErrNone);
TEST(buf.Find(KUtf8) >= 0);
//Connection 1: Create a table
err = db1.Exec(_L8("CREATE TABLE Tbl(Id INTEGER, T BLOB)"));
TEST(err >= 0);
//Connection 1: Check the database encoding
err = query.SelectTextL(_L8("PRAGMA encoding"), buf);
TEST2(err, KErrNone);
TEST(buf.Find(KUtf8) >= 0);
//Connection 2: open the same database
err = db2.Open(KTestDatabase3);
TEST2(err, KErrNone);
//Connection 1: Check the database encoding
err = query.SelectTextL(_L8("PRAGMA encoding"), buf);
TEST2(err, KErrNone);
TEST(buf.Find(KUtf8) >= 0);
//Connection 2: Check the database encoding
query.SetDatabase(db2);
err = query.SelectTextL(_L8("PRAGMA encoding"), buf);
TEST2(err, KErrNone);
TEST(buf.Find(KUtf8) >= 0);
//Cleanup
db2.Close();
db1.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1817-0001
@SYMTestCaseDesc Test for defect INC095412 - Retrieving query results may corrupt heap.
Open t_inc095412.db test database and prepare SQL query (the SQL statement is in the test code).
Execute RSqlStatement::Next() and then try to retrieve the text value of column number 1.
If the defect is not fixed RSqlStatement::ColumnText() will panic.
@SYMTestPriority High
@SYMTestActions Test for defect INC095412 - Retrieving query results may corrupt heap.
@SYMTestExpectedResults Test must not fail
@SYMDEF INC095412
*/
void INC095412()
{
TInt err = TheDb.Open(KTestDatabase4);
TEST2(err, KErrNone);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("SELECT ObjId, Uri, InstanceOf, Flags, p1.PropertyId, p1.PropertyTypeId, p1.Value, p1.Source, p1.Confidence FROM Objects JOIN Properties p1 ON ObjId = p1.HostObjId WHERE ( ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? ) ) OR ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? ) ) OR ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? ) ) OR ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN ( ? , ? , ? , ? ) ) );"));
TEST2(err, KErrNone);
const TInt KPrmValues[] = {0, 0, 33, 40, 47, 45, 43, 42, 50, 39, 51, 44, 41, 46, 38, 48, 49, 0, 0, 26, 40, 53, 54, 57, 52, 39, 58, 56, 41, 38, 55, 0, 0, 26, 40, 53, 54, 57, 52, 39, 58, 56, 41, 38, 55, 0, 0, 38, 40, 39, 41};
for(TInt i=0;i<sizeof(KPrmValues)/sizeof(KPrmValues[0]);++i)
{
err = stmt.BindInt(i, KPrmValues[i]);
TEST2(err, KErrNone);
}
err = stmt.Next();
TEST2(err, KSqlAtRow);
TPtrC ptr;
stmt.ColumnText(1, ptr); // May corrupt heap and panic the test application if the defect is not fixed!
stmt.Close();
TheDb.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3427
@SYMTestCaseDesc Test for DEF104242 - The SQL server fails to open database with default security policy only.
The test plays with C:[21212125]T_OneDefPolicy.db secure database, which was created by
an external tool and the database security policy table contains just a single record
with the default security policy. The default security policy is set to be
TSecurityPolicy::EAlwaysPass. The test attempts to read from the database, modify the database
content, modify the database schema.
@SYMTestPriority High
@SYMTestActions Test for DEF104242 - The SQL server fails to open database with default security policy only.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF104242
*/
void DEF104242()
{
TInt err = TheDb.Open(_L("C:[21212125]T_OneDefPolicy.db"));
TEST2(err, KErrNone);
//Read
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("SELECT t1key, data from t1"));
TEST2(err, KErrNone);
while((err = stmt.Next()) == KSqlAtRow)
{
TheTest.Printf(_L("t1key=%d\r\n"), stmt.ColumnInt(0));
}
TEST2(err, KSqlAtEnd);
stmt.Close();
//Write
err = TheDb.Exec(_L("INSERT INTO t1(t1key) VALUES(12)"));
TEST2(err, 1);
//Schema
err = TheDb.Exec(_L("CREATE TABLE AAA(Id INTEGER)"));
TEST(err >= 0);
//Cleanup
TheDb.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3430
@SYMTestCaseDesc Test for DEF104437 - RSqlStatement::Next() panics the SQL server with KERN-EXEC 3.
The test attempts to execute 2 SELECT queries ("IN" and "IN + JOIN"). The table, on
which queries operate, has multi-column primary key. The right-hand side of the
"IN" operator contains NULL.
@SYMTestPriority High
@SYMTestActions Test for DEF104437 - RSqlStatement::Next() panics the SQL server with KERN-EXEC 3.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF104437
*/
void DEF104437()
{
//Test case 1 - "IN" + "JOIN"
(void)RSqlDatabase::Delete(KTestDatabase5);
TInt err = TheDb.Create(KTestDatabase5);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE inmk(cls TEXT,sec INTEGER,inst INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L("INSERT INTO inmk VALUES ('ORD', 2751, 2750)"));
TEST2(err, 1);
err = TheDb.Exec(_L("CREATE TABLE clss(hrar TEXT,cls TEXT,PRIMARY KEY (hrar, cls))"));
TEST(err >= 0);
err = TheDb.Exec(_L("CREATE TABLE rels(prnt_inst INTEGER,chld_inst INTEGER)"));
TEST(err >= 0);
RSqlStatement stmt;
_LIT(KSelectSql,
"SELECT I.sec\
FROM inmk I\
LEFT JOIN\
rels R ON R.prnt_inst = I.inst\
LEFT JOIN\
inmk UI ON UI.inst = R.chld_inst\
LEFT JOIN\
clss C1U ON C1U.cls = UI.cls AND C1U.hrar = 'STH'\
LEFT JOIN\
clss C10U ON C10U.hrar = c1u.hrar AND C10U.cls IN (C1U.cls)\
WHERE I.sec = 2751;");
err = stmt.Prepare(TheDb, KSelectSql);
TEST2(err, KErrNone);
while((err = stmt.Next()) == KSqlAtRow)
{
TInt val = stmt.ColumnInt(0);
TEST2(val, 2751);
TheTest.Printf(_L("column value=%d\r\n"), val);
}
TEST2(err, KSqlAtEnd);
stmt.Close();
TheDb.Close();
//////////////////////////////////////////////////////////////
//Test case 2 - "IN"
(void)RSqlDatabase::Delete(KTestDatabase5);
err = TheDb.Create(KTestDatabase5);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE b(y,z,PRIMARY KEY(y, z))"));
TEST(err >= 0);
err = stmt.Prepare(TheDb, _L("SELECT * FROM b WHERE y = NULL AND z IN ('hello')"));
TEST2(err, KErrNone);
while((err = stmt.Next()) == KSqlAtRow)
{
}
TEST2(err, KSqlAtEnd);
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase5);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3442
@SYMTestCaseDesc Test for DEF105259 - SQL, RSqlColumnReadStream's internal buffer may become invalid.
The test does the following steps:
1) Create a table: CREATE TABLE A(Name TEXT, Data BLOB);
2) Insert only one record in A, such that, the "Name" column length is less than
8 characters, the "Data" column length is 1K bytes.
3) Create RSqlStatement object with the following SQL statement: SELECT * FROM A
4) Call RSqlStatement::Next() to get the record
5) Create RSqlColumnReadStream for column 0 (the "Name" column)
6) Try to access the "Data" column value, without using a stream
7) Try to read the "Name" column using the stream
8) Compare the read "Name" column value vs. the original column value (at the moment
when the table record was stored)
@SYMTestPriority High
@SYMTestActions Test for DEF105259 - SQL, RSqlColumnReadStream's internal buffer may become invalid.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF105259
*/
void DEF105259L()
{
(void)RSqlDatabase::Delete(KTestDatabase3);
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE A(Name TEXT, Data BLOB)"));
TEST(err >= 0);
const TInt KBlobDataSize = 1024;
HBufC* recBuf = HBufC::New(KBlobDataSize * 2 + 100);
TEST(recBuf != NULL);
TPtr sql = recBuf->Des();
sql.Copy(_L("INSERT INTO A(Name,Data) VALUES('A12',x'"));
for(TInt i=0;i<KBlobDataSize;++i)
{
TBuf<2> tmp;
tmp.AppendFormat(_L("%02X"), i % 256);
sql.Append(tmp);
}
sql.Append(_L("')"));
err = TheDb.Exec(sql);
TEST2(err, 1);
delete recBuf;
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("SELECT * FROM A"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
RSqlColumnReadStream strm;
err = strm.ColumnText(stmt, 0);
TEST2(err, KErrNone);
TPtrC8 data;
err = stmt.ColumnBinary(1, data);
TEST2(err, KErrNone);
TBuf<10> name;
strm.ReadL(name, 3);
TEST(name == _L("A12"));
strm.Close();
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3470
@SYMTestCaseDesc Test for DEF105681 - SQL, HReadOnlyBuf::ConstructL() sets a pointer to a local TPtr8 variable.
The test creates a database with a table: A(Name TEXT, Data BLOB). One record is inserted
in the table. Then the test creates a statement object with "SELECT * FROM A" sql statement.
The test moves the statement cursor on the record and attempts to access the BLOB column
using a stream. When the stream object is created, the test attempts to create an embedded
store object from the stream, using CEmbeddedStore::FromLC(strm) call. If the defect
is not fixed, the call will panic.
@SYMTestPriority High
@SYMTestActions Test for DEF105681 - SQL, HReadOnlyBuf::ConstructL() sets a pointer to a local TPtr8 variable.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF105681
*/
void DEF105681L()
{
(void)RSqlDatabase::Delete(KTestDatabase3);
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE A(Name TEXT, Data BLOB)"));
TEST(err >= 0);
err = TheDb.Exec(_L("INSERT INTO A(Name,Data) VALUES('A12',x'0400000000')"));
TEST2(err, 1);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("SELECT * FROM A"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
RSqlColumnReadStream strm;
err = strm.ColumnBinary(stmt, 1);
TEST2(err, KErrNone);
CEmbeddedStore* store = CEmbeddedStore::FromLC(strm);
CleanupStack::PopAndDestroy(store);
strm.Close();
stmt.Close();
//Testing with a NULL binary column value
err = TheDb.Exec(_L("INSERT INTO A(Name,Data) VALUES('BBB',NULL)"));
TEST2(err, 1);
err = stmt.Prepare(TheDb, _L("SELECT * FROM A WHERE Name='BBB'"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
err = strm.ColumnBinary(stmt, 1);
TEST2(err, KErrNone);
store = NULL;
TRAP(err, store = CEmbeddedStore::FromL(strm));
TEST2(err, KErrEof);
delete store;
strm.Close();
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3476
@SYMTestCaseDesc Test for DEF106391 - SQL server does not deallocate the already allocated memory.
The test is executed only on the Emulator, because its execution depends on the amount
of the available memory and the amount of free disk space - factors which cannot be easily
resolved on target hardware.
The test creates a database with a table: T(Id INTEGER, Data BLOB).
One record with a BLOB (either 0.79Mb or 0.9Mb) is inserted using RSqlDatabase::Exec().
Another record with a BLOB (either 1.58 or 1.8Mb) is inserted using RSqlStatement and BLOB parameter.
If the defect is not fixed, after the first INSERT the SQL server will not free occupied by
the statement memory. The available heap memory won't be enough for the execution of the second INSERT statement.
The second INSERT will fail with KErrNoMemory.
@SYMTestPriority High
@SYMTestActions Test for DEF106391 - SQL server does not deallocate the already allocated memory.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF106391
*/
void DEF106391()
{
#if defined __WINS__ || defined __WINSCW__
#ifndef SYMBIAN_USE_SQLITE_VERSION_3_6_4
const TInt KBlobSize = 900 * 1024;
#else
const TInt KBlobSize = 790 * 1024;
#endif
_LIT8(KConfigStr, "encoding=UTF-8");
HBufC8* sqlBuf = HBufC8::New(KBlobSize * 2 + 200);//"+ 200" - for the SQL INSERT statement
TEST(sqlBuf != NULL);
(void)RSqlDatabase::Delete(KTestDatabase5);
//Step 1: insert a record with a very large BLOB column (using RSqlDatabase::Exec())
// (the operation is rolled back because there may not be enough disk space)
TVolumeInfo volInfo;
TInt err = TheFs.Volume(volInfo);
TEST2(err, KErrNone);
TheTest.Printf(_L("INSERT#1, Volume size: %ldK Free space: %ldK\r\n"), volInfo.iSize / 1024, volInfo.iFree / 1024);
TheTest.Printf(_L("Test BLOB size: %dK\r\n"), KBlobSize / 1024);
err = TheDb.Create(KTestDatabase5, &KConfigStr);
TEST2(err, KErrNone);
TSqlResourceProfiler profiler(TheDb);
(void)profiler.Start(TSqlResourceProfiler::ESqlCounterMaxAlloc);
err = TheDb.Exec(_L8("CREATE TABLE T(Id INTEGER, Data BLOB)"));
TEST(err >= 0);
TPtr8 sql = sqlBuf->Des();
sql.Copy(_L8("BEGIN TRANSACTION;INSERT INTO T(Id,Data) VALUES(1, x'"));
for(TInt i=0;i<KBlobSize;++i)
{
sql.Append(_L8("A5"));
}
sql.Append(_L8("');"));
(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterMaxAlloc);
err = TheDb.Exec(sql);
TEST2(err, 1);
err = TheDb.Exec(_L("ROLLBACK TRANSACTION"));
TEST(err >= 0);
TBuf8<32> profilerRes8;
TBuf<32> profilerRes;
if(profiler.Query(TSqlResourceProfiler::ESqlCounterMaxAlloc, profilerRes8) == KErrNone)
{
profilerRes.Copy(profilerRes8);
TheTest.Printf(_L("RSqlDatabase::Exec(): <SQL server max alloc>;<SQLite max alloc>=%S\r\n"), &profilerRes);
}
//Step 2: insert a record with a very large BLOB column (using RSqlStatement::Exec())
// (the operation is rolled back because there may not be enough disk space)
err = TheFs.Volume(volInfo);
TEST2(err, KErrNone);
TheTest.Printf(_L("INSERT#2, Volume size: %ldK Free space: %ldK\r\n"), volInfo.iSize / 1024, volInfo.iFree / 1024);
TheTest.Printf(_L("Test BLOB size: %dK\r\n"), sql.Length() / 1024);
(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterMaxAlloc);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("INSERT INTO T(Id, Data) VALUES(2, :V)"));
TEST2(err, KErrNone);
err = stmt.BindBinary(0, sql);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("BEGIN TRANSACTION"));
TEST(err >= 0);
err = stmt.Exec();
TEST2(err, 1);
err = TheDb.Exec(_L("ROLLBACK TRANSACTION"));
TEST(err >= 0);
stmt.Close();
if(profiler.Query(TSqlResourceProfiler::ESqlCounterMaxAlloc, profilerRes8) == KErrNone)
{
profilerRes.Copy(profilerRes8);
TheTest.Printf(_L("RSqlStatement::Bind/Exec(): <SQL server max alloc>;<SQLite max alloc>=%S\r\n"), &profilerRes);
}
delete sqlBuf;
(void)profiler.Stop(TSqlResourceProfiler::ESqlCounterMaxAlloc);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase5);
#endif// defined __WINS__ || defined __WINSCW__
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3501
@SYMTestCaseDesc Test for DEF109025 - SQL, dangling long binary/text column value pointer
The test does the following steps:
1) Create a table: CREATE TABLE A(Name TEXT, Data BLOB);
2) Insert only one record in A, such that, the "Name" column length is less than
8 characters, the "Data" column length is 1K bytes.
3) Create RSqlStatement object with the following SQL statement: SELECT * FROM A
4) Call RSqlStatement::Next() to get the record
5) Allocate a 1024 bytes buffer (so, when the row buffer has to be reallocated, the system will be forced to
search another block of memory, because the current one is capped by the allocated 1024 bytes)
6) Get a pointer to the "name" column value
7) Get a pointer to the "data" column value
8) Check the "name" column value. If the defect still exists, the "name" pointer will point to a deleted
block of memory.
@SYMTestPriority High
@SYMTestActions Test for DEF109025 - SQL, dangling long binary/text column value pointer.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF109025
*/
void DEF109025()
{
(void)RSqlDatabase::Delete(KTestDatabase3);
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE A(Name TEXT, Data BLOB)"));
TEST(err >= 0);
const TInt KBlobDataSize = 1024;
HBufC* recBuf = HBufC::New(KBlobDataSize * 2 + 100);
TEST(recBuf != NULL);
TPtr sql = recBuf->Des();
sql.Copy(_L("INSERT INTO A(Name,Data) VALUES('A12',x'"));
for(TInt i=0;i<KBlobDataSize;++i)
{
TBuf<2> tmp;
tmp.AppendFormat(_L("%02X"), i % 256);
sql.Append(tmp);
}
sql.Append(_L("')"));
err = TheDb.Exec(sql);
TEST2(err, 1);
delete recBuf;
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("SELECT * FROM A"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
TUint8* mem = new TUint8[1024]; //This memory block will be allocated right after the row buffer,
TEST(mem != NULL); //so the ColumnBinary() call will reallocate the row buffer somewhere else, not at the same address.
TPtrC name;
err = stmt.ColumnText(0, name);
TEST2(err, KErrNone);
TPtrC8 data;
err = stmt.ColumnBinary(1, data);
TEST2(err, KErrNone);
TEST(name == _L("A12"));
delete [] mem;
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3546
@SYMTestCaseDesc Test for DEF109843 - SQL, RSQLStatement::BindBinary() is causing panic if empty descriptor is passed.
The test does the following steps:
1) Create a table: CREATE TABLE A(Id INTEGER, Data BLOB);
2) Create a RSqlStatement object stmt;
3) Prepare stmt with the following SQL statement:
INSERT INTO A(Id,Data) VALUES(:Val1,:Val2);
4) Set the Val2 field with an empty descriptor("") by using RSqlStatement::BindBinary();
5) Execute the statement;
6) If the defect still exist, stmt.BindBinary() will cause a panic;
@SYMTestPriority High
@SYMTestActions Test for DEF109843 - SQL, RSQLStatement::BindBinary() is causing panic if empty descriptor is passed.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF109843
*/
void DEF109843()
{
(void)RSqlDatabase::Delete(KTestDatabase5);
TInt err = TheDb.Create(KTestDatabase5);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, Data BLOB)"));
TEST(err >= 0);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("INSERT INTO A(Id,Data) VALUES(:Val1,:Val2)"));
TEST2(err, KErrNone);
TInt paramIndex;
paramIndex = stmt.ParameterIndex(_L(":Val1"));
TEST(paramIndex >= 0);
err = stmt.BindInt(paramIndex, 1);
TEST2(err, KErrNone);
paramIndex = stmt.ParameterIndex(_L(":Val2"));
TEST(paramIndex >= 0);
TPtrC8 emptyEntry (_L8(""));
err = stmt.BindBinary(paramIndex, emptyEntry);
TEST2(err, KErrNone);
err = stmt.Exec();
TEST(err >= 0);
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase5);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4005
@SYMTestCaseDesc Test for DEF114698 - SqlSrv.EXE::!SQL Server Insert/Update Error.
The test does the following steps:
1) DB3:
CREATE TABLE A(Id INTEGER, Id1 INTEGER)
INSERT INTO A(Id,Id1) VALUES(2,3)
2) DB2:
CREATE TABLE B(Id INTEGER, Id1 INTEGER)
INSERT INTO B(Id,Id1) VALUES(2,3)
3) DB:
CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER)
INSERT INTO MAIN(Id,Id1) VALUES(2,3)
4) Attach DB2 and DB3 to DB.
5) Execute:
INSERT INTO B SELECT * FROM B UNION ALL SELECT * FROM MAIN WHERE exists (select * FROM B WHERE B.Id = MAIN.Id);
UPDATE A SET Id= (SELECT Id1 FROM B WHERE Id=1) WHERE EXISTS ( SELECT MAIN.Id1 FROM MAIN WHERE MAIN.Id = A.Id1);
@SYMTestPriority High
@SYMTestActions Test for DEF114698 - SqlSrv.EXE::!SQL Server Insert/Update Error.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF114698
*/
void DEF114698()
{
(void)RSqlDatabase::Delete(KTestDatabase1);
(void)RSqlDatabase::Delete(KTestDatabase2);
(void)RSqlDatabase::Delete(KTestDatabase5);
TInt err = TheDb.Create(KTestDatabase5);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, Id1 INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L("INSERT INTO A(Id,Id1) VALUES(2,3)"));
TEST2(err, 1);
TheDb.Close();
err = TheDb.Create(KTestDatabase2);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE B(Id INTEGER, Id1 INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L("INSERT INTO B(Id,Id1) VALUES(2,3)"));
TEST2(err, 1);
TheDb.Close();
err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L("INSERT INTO MAIN(Id,Id1) VALUES(2,3)"));
TEST2(err, 1);
err = TheDb.Attach(KTestDatabase2, _L("db2"));
TEST2(err, KErrNone);
err = TheDb.Attach(KTestDatabase5, _L("db3"));
TEST2(err, KErrNone);
err = TheDb.Exec(_L("INSERT INTO B SELECT * FROM B UNION ALL SELECT * FROM MAIN WHERE exists (select * FROM B WHERE B.Id = MAIN.Id)"));
TEST2(err, 2);
err = TheDb.Exec(_L("UPDATE A SET Id= (SELECT Id1 FROM B WHERE Id=1) WHERE EXISTS ( SELECT MAIN.Id1 FROM MAIN WHERE MAIN.Id = A.Id1)"));
TEST2(err, 0);
err = TheDb.Detach(_L("db3"));
TEST2(err, KErrNone);
err = TheDb.Detach(_L("db2"));
TEST2(err, KErrNone);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase5);
(void)RSqlDatabase::Delete(KTestDatabase2);
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4009-0001
@SYMTestCaseDesc Test for DEF115556 SqlSrv.EXE::!SQL Server when preparing complex sql query.
The test does the following steps:
1) Create a database with two tables
CREATE TABLE A(Id INTEGER, Id1 INTEGER, F2 BLOB)
CREATE TABLE B(Id INTEGER, Id1 INTEGER, F2 BLOB)
2) Prepare the following statement
DELETE FROM A WHERE Id1 IN (SELECT Id1 FROM B WHERE Id IN (1,11) UNION SELECT * FROM B WHERE Id1=2 ORDER BY Id ASC LIMIT 1)
If the defect is not fixed, step (2) asserts in SQLITE.
@SYMTestPriority High
@SYMTestActions Test for DEF115556 SqlSrv.EXE::!SQL Server when preparing complex sql query.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF115556
*/
void DEF115556()
{
(void)RSqlDatabase::Delete(KTestDatabase1);
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, Id1 INTEGER, F2 BLOB)"));
TEST(err >= 0);
err = TheDb.Exec(_L("CREATE TABLE B(Id INTEGER, Id1 INTEGER, F2 BLOB)"));
TEST(err >= 0);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("DELETE FROM A WHERE Id1 IN (SELECT Id1 FROM B WHERE Id IN (1,11) UNION SELECT * FROM B WHERE Id1=2 ORDER BY Id ASC LIMIT 1)"));
TEST(err != KErrDied);
TPtrC errDescr = TheDb.LastErrorMessage();
RDebug::Print(_L("\"Stmt prepare\" %d error. Message:\"%S\"\r\n"), err, &errDescr);
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4012
@SYMTestCaseDesc Test for DEF115954: CSession Code = 2 executing SQL stmt in OOM loop.
It is an OOM test. In the loop, the test does the following steps:
1) Create a database.
2) Set heap failure.
3) Open the database
4) Execute the statement which caused the panic before this defect is fixed.
5) Close the database.
If the defect is not fixed, step (5) will panic with CSession Code = 2.
Note: It's possible for database operations to be performed even after memory
allocation has failed. This is because SQLITE reuses some pages of the page
cache which have been allocated but are curently not in use. This means it is
necessary to undo any operations on the database and continue checking for
memory and resource leaks even after an operation has been completed successfully
@SYMTestPriority High
@SYMTestActions Test for DEF115954: CSession Code = 2 executing SQL stmt in OOM loop.
@SYMTestExpectedResults Test program must not panic.
@SYMDEF DEF115954
*/
void DEF115954()
{
TInt err = KErrNone;
TInt failingAllocationNo = 0;
TInt allocationNo = 0;
TheTest.Printf(_L("\r\n"));
while(allocationNo < KDEF115954MaxAllocLimit)
{
TheTest.Printf(_L("%d \r"), allocationNo);
RSqlDatabase::Delete(KTestDatabase1);
err = TheDb.Create(KTestDatabase1);
TEST(err == KErrNone);
TheDb.Close();
const TInt KDelayedDbHeapFailureMask = 0x1000;
TSqlResourceTester::SetDbHeapFailure(KDelayedDbHeapFailureMask, ++allocationNo);
err = TheDb.Open(KTestDatabase1);
TEST(err == KErrNone);
err = TheDb.Exec(_L("CREATE TABLE node(id INTEGER PRIMARY KEY,name TEXT);CREATE INDEX node_idx ON node(name);CREATE TABLE edge(orig INTEGER REFERENCES node,dest INTEGER REFERENCES node,PRIMARY KEY(orig, dest));CREATE INDEX edge_idx ON edge(dest,orig)"));
TheDb.Close();
if(err != KErrNoMemory)
{
TEST2(err, KErrNone);
}
else
{
failingAllocationNo = allocationNo;
}
TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);
}
TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
TEST(err == KErrNone);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4008
@SYMTestCaseDesc Test for DEF115567 - Critical SQLite defect that can cause database corruption during UPDATE/DELETE.
The test creates 2 tables with couple of records and a "BEFORE DELETE" trigger on the first table.
Then the test deletes 1 record from the first table and checks the record count in both tables.
In both cases the record count should not be 0.
@SYMTestPriority Critical
@SYMTestActions Test for DEF115567 - Critical SQLite defect that can cause database corruption during UPDATE/DELETE.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF115567
*/
void DEF115567L()
{
(void)RSqlDatabase::Delete(KTestDatabase1);
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE t3(a INTEGER, b INTEGER);CREATE TABLE t4(a INTEGER, b INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L("CREATE TRIGGER t3_t BEFORE DELETE ON t3 BEGIN DELETE FROM t4 WHERE t4.a = old.a;DELETE FROM t3 WHERE a = 2;END"));
TEST(err >= 0);
err = TheDb.Exec(_L("INSERT INTO t3 VALUES(1,1)"));
TEST2(err, 1);
err = TheDb.Exec(_L("INSERT INTO t3 VALUES(2,2)"));
TEST2(err, 1);
err = TheDb.Exec(_L("INSERT INTO t3 VALUES(3,3)"));
TEST2(err, 1);
err = TheDb.Exec(_L("INSERT INTO t4 VALUES(1,1)"));
TEST2(err, 1);
err = TheDb.Exec(_L("INSERT INTO t4 VALUES(3,3)"));
TEST2(err, 1);
err = TheDb.Exec(_L("DELETE FROM t3 WHERE a=1 OR a=2"));
TEST2(err, 1);
TSqlScalarFullSelectQuery query(TheDb);
TInt rowcnt = query.SelectIntL(_L("SELECT COUNT(*) FROM t3"));
TEST2(rowcnt, 1);
rowcnt = query.SelectIntL(_L("SELECT COUNT(*) FROM t4"));
TEST2(rowcnt, 1);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-4019
@SYMTestCaseDesc Test for DEF116397 Attaching a non-db file should return KSqlErrNotDb rather than KErrEof
@SYMTestPriority Medium
@SYMTestActions Test for DEF116397 - SQL, Attaching database returns KErrEof(-25).
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF116397
*/
void DEF116397()
{
//Test error code opening a corrupt db file
TInt err = TheDb.Open(KCorruptDb);
TEST2(err, KSqlErrNotDb);
TheDb.Close();
//create a sql db file
(void)RSqlDatabase::Delete(KTestDatabase1);
err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE t3(a INTEGER, b INTEGER);CREATE TABLE t4(a INTEGER, b INTEGER)"));
TEST(err >= 0);
TheDb.Close();
//open the db file
err=TheDb.Open(KTestDatabase1);
TEST2(err,KErrNone);
//try to attach a non db file
err=TheDb.Attach(KCorruptDb,_L("db2"));
TEST2(err,KSqlErrNotDb);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4029
@SYMTestCaseDesc Test for DEF119403 - creates a databse, retrieves its Collation Dll Name and makes
sure the Collation Dll Name doesn't contain the path
@SYMTestPriority Medium
@SYMTestActions Test for DEF119403 Database re-index unnecessarily during open operation
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF119403
*/
void DEF119403L()
{
//create a sql db file
(void)RSqlDatabase::Delete(KTestDatabase1);
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
TFileName buf;
TSqlScalarFullSelectQuery query(TheDb);
//Get Collation Dll Name from SYMBIAN_SETTINGS
err = query.SelectTextL(_L8("SELECT CollationDllName FROM SYMBIAN_SETTINGS"), buf);
TEST2(err, KErrNone);
TParse parse;
parse.Set(buf, NULL, NULL);
//Check that the Collation Dll Name doesn't include the path
TEST(!parse.PathPresent());
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
// Helper function for DEF120237L()
TInt ExecuteSelect(RSqlDatabase& aDatabase, const TDesC8& aSelectStatement)
{
RSqlStatement statement;
TInt err = statement.Prepare(aDatabase, aSelectStatement);
TEST2(err, KErrNone);
TInt ret;
TInt count = 0;
TheTest.Printf(_L("Results:\n"));
while((ret = statement.Next()) == KSqlAtRow)
{
TPtrC coltext;
err = statement.ColumnText(0, coltext);
TEST2(err, KErrNone);
RDebug::RawPrint(coltext);
TheTest.Printf(_L("\n"));
count++;
}
TEST2(ret, KSqlAtEnd);
statement.Close();
return count;
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-4031
@SYMTestCaseDesc Test for DEF120237 - Checks that When using SELECT together with
the LIKE operator the right number of results are returned.
@SYMTestPriority Medium
@SYMTestActions 1) Create a database and fill it with test data.
2) Execute a SELECT statement with the LIKE operator and the % wildcard
3) Check that the expected number of results are returned.
@SYMTestExpectedResults The SELECT statements should return the expected number of results.
@SYMDEF DEF120237
*/
void DEF120237L()
{
const TInt KSelectTest1ExpectedResults = 3;
const TInt KSelectTest2ExpectedResults = 3;
_LIT8(KCfgStr, "encoding=UTF-8");
_LIT8(KCreate, "CREATE TABLE A(Id INTEGER,Name TEXT collate nocase)"); //Adding "collate nocase" allows us to see defect
_LIT8(KIndex, "CREATE INDEX name_index on A (name)"); //Adding index allows us to see defect
_LIT8(KRecord1, "INSERT INTO A VALUES(1, '\"AAA')");
_LIT8(KRecord2, "INSERT INTO A VALUES(2, '\"AAB')");
_LIT8(KRecord3, "INSERT INTO A VALUES(3, '\"AAC')");
_LIT8(KRecord4, "INSERT INTO A VALUES(4, '&BAA')");
_LIT8(KRecord5, "INSERT INTO A VALUES(5, '%BAA')");
_LIT8(KRecord6, "INSERT INTO A VALUES(6, '''BAA')");
_LIT8(KRecord7, "INSERT INTO A VALUES(7, '''BAB')");
_LIT8(KRecord8, "INSERT INTO A VALUES(8, '''BAC')");
//Create database
RSqlDatabase database;
CleanupClosePushL(database);
(void*)database.Delete(KTestDatabase6);
User::LeaveIfError(database.Create(KTestDatabase6, &KCfgStr));
TInt err = database.Exec(KCreate);
TEST(err >= KErrNone);
err = database.Exec(KIndex);
TEST(err >= KErrNone);
//Insert Neccessary Data
err = database.Exec(KRecord1);
TEST2(err, 1);
err = database.Exec(KRecord2);
TEST2(err, 1);
err = database.Exec(KRecord3);
TEST2(err, 1);
err = database.Exec(KRecord4);
TEST2(err, 1);
err = database.Exec(KRecord5);
TEST2(err, 1);
err = database.Exec(KRecord6);
TEST2(err, 1);
err = database.Exec(KRecord7);
TEST2(err, 1);
err = database.Exec(KRecord8);
TEST2(err, 1);
//Case 1 when search criteria is "
//Defect: Select does not return result
_LIT8(KSelectTest1, "select name from A where name like '\"%'");
TInt numResults = ExecuteSelect(database, KSelectTest1);
TheTest.Printf(_L("Case 1 Results: %d\n"), numResults);
TEST2(numResults, KSelectTest1ExpectedResults);
//Case 2 when search criteria is '
//Defect: Select returns data beginning with & and % as well
_LIT8(KSelectTest2,"select name from A where name like '''%'");
numResults = ExecuteSelect(database, KSelectTest2);
TheTest.Printf(_L("Case 2 Results: %d\n"), numResults);
TEST2(numResults, KSelectTest2ExpectedResults);
CleanupStack::PopAndDestroy(1);
}
/**
@SYMTestCaseID PDS-SQL-CT-4120
@SYMTestCaseDesc Test for DEF125881 - Checks that when a INSERT statement is executed
under a I/O failure simulation, the correct error code will be returned
@SYMTestPriority Medium
@SYMTestActions 1) Create a database and fill it with test data.
2) Execute a INSERT statement under a I/O failure simulation
3) Check that the expected return error code is retruned
@SYMTestExpectedResults The INSERT statement should return the correct error code under I/O failure
@SYMDEF DEF125881
*/
void DEF125881L()
{
_LIT(KDbPath, "c:\\t_sqldefect-def125881.db");
_LIT(KSchema, "CREATE TABLE test(t TEXT);");
_LIT(KInsert, "INSERT INTO test (t) VALUES (\'mkldfmklmklmkldfmkldfmklm\
klcdmklmkldsdklfjwoierthj\
iofnkjwefniwenfwenfjiowen\
mkldfmklmklmkldfmkldfmklm\
klcdmklmkldsdklfjwoierthj\
mkldfmklmklmkldfmkldfmklm\
klcdmklmkldsdklfjwoierthj\
iofnkjwefniwenfwenfjiowen\
mkldfmklmklmkldfmkldfmklm\
klcdmklmkldsdklfjwoierthj\
iofnkjwefniwenfwenfjiowen\
mkldfmklmklmkldfmkldfmklm\
klcdmklmkldsdklfjwoierthj\
iofnkjwefniwenfwenfjiowen\
iofnkjwefniwenfwenfjiowen\
fiwenfwejnfwinsdf2sdf4sdf\');");
_LIT(KLogFormat, "After %d operations: %d returned\n");
// Create file server session
RFs fsSession;
CleanupClosePushL(fsSession);
User::LeaveIfError(fsSession.Connect());
// Open a SQL DB, setup basic schema
RSqlDatabase sqlDb;
CleanupClosePushL(sqlDb);
TRAPD(createErr, sqlDb.OpenL(KDbPath));
if (createErr != KErrNone)
{
sqlDb.CreateL(KDbPath);
User::LeaveIfError(sqlDb.Exec(KSchema));
}
// Create a SQL statement
RSqlStatement stmnt;
TInt err = stmnt.Prepare(sqlDb, KInsert);
TEST2(err,KErrNone);
// Begin test
TInt fsError = KErrGeneral;
TInt count = 0;
const TInt KMaxOps = 300;
TSqlResourceProfiler pr(sqlDb);
pr.Start(TSqlResourceProfiler::ESqlCounterOsCallDetails);
pr.Reset(TSqlResourceProfiler::ESqlCounterOsCallDetails);
while (fsError != 1 && count <= KMaxOps)
{
// Setup for KErrGeneral failure
fsSession.SetErrorCondition(KErrGeneral, count);
// Database operation
fsError = stmnt.Exec();
stmnt.Reset();
// Test for KErrGeneral
TheTest.Printf(KLogFormat, count, fsError);
TEST( (fsError == KErrGeneral) || (fsError == 1) || (fsError == KSqlErrIO));
// Increment fail-after count
++count;
}
fsSession.SetErrorCondition(KErrNone);
pr.Stop(TSqlResourceProfiler::ESqlCounterOsCallDetails);
stmnt.Close();
CleanupStack::PopAndDestroy(2); // fsSession, sqlDb
(void)RSqlDatabase::Delete(KDbPath);
}
/**
@SYMTestCaseID PDS-SQL-CT-4128
@SYMTestCaseDesc Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
When executing a pragma which deosn't return any results (e.g performing "PRAGMA index_list"
on a table with no index. The client panics when RSqlStatement::Next() is called.
This test checks the client does not panic in this case
@SYMTestPriority High
@SYMTestActions DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF129581
*/
void DEF129581()
{
_LIT8(KPragma, "Pragma index_list(T)");
_LIT8(KCreateTable, "CREATE TABLE T (A INTEGER)");
(void)RSqlDatabase::Delete(KTestDatabase1);
//create a sql db file and make sure no index is added to it
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
//create a table
err = TheDb.Exec(KCreateTable);
TEST(err >= KErrNone);
RSqlStatement stmt;
//Executes a "Pragam index_list.." statement
err = stmt.Prepare(TheDb, KPragma);
TEST2(err, KErrNone);
//Calls RSqlStatement::Next() to make sure the client does not panic.
err = stmt.Next();
TEST2(err, KSqlAtEnd);
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID PDS-SQL-CT-4153
@SYMTestCaseDesc Test for DEF143047: SQL, default "max parameter count" value, compatibility problem.
This test case proves that an SQL statement with more than 1000 parameters can be prepared
successfully. The default value of the SQLITE_MAX_VARIABLE_NUMBER macro is 999.
Changed to 32767 with this defect fix.
@SYMTestPriority High
@SYMTestActions DEF143047: SQL, default "max parameter count" value, compatibility problem
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF143047
*/
void DEF143047()
{
(void)RSqlDatabase::Delete(KTestDatabase1);
TInt err = TheDb.Create(KTestDatabase1);
TEST2(err, KErrNone);
_LIT8(KCreateTable, "CREATE TABLE T(A INTEGER)");
err = TheDb.Exec(KCreateTable);
TEST(err >= KErrNone);
const TInt KPrmCount = 1200;
HBufC8* buf = HBufC8::New(KPrmCount * 2 + 200);
TEST(buf != NULL);
TPtr8 sql = buf->Des();
sql.Copy(_L8("SELECT * FROM T WHERE A IN(?"));
for(TInt i=0;i<KPrmCount;++i)
{
sql.Append(_L8(",?"));
}
sql.Append(_L8(")"));
RSqlStatement stmt;
err = stmt.Prepare(TheDb,sql);
if(err != KErrNone)
{
TPtrC errdes = TheDb.LastErrorMessage();
TheTest.Printf(_L("RSqlStatement::Prepare() failed. Err %d, ErrMsg: \"%S\".\r\n"), err, &errdes);
}
TEST2(err, KErrNone);
stmt.Close();
delete buf;
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase1);
}
/**
@SYMTestCaseID PDS-SQL-UT-4157
@SYMTestCaseDesc Test for PDEF143461 Calling CSqlSrvDatabase::LastErrorMessage() does not panic with the descriptor alignment error
@SYMTestPriority Normal
@SYMTestActions Test for PDEF143461 - CSqlSrvDatabase::LastErrorMessage() alignment problem.
This tests the following SQLite Error messages to make sure it doesn't panic:
1)library routine called out of sequence
2)out of memory
@SYMTestExpectedResults Test must not fail
@SYMDEF PDEF143461
*/
void PDEF143461L()
{
(void) RSqlDatabase::Delete(KTestDatabase6);
//Create and setup the database file
RSqlDatabase db;
TInt err =0;
err = db.Create(KTestDatabase6);
TEST2(err, KErrNone);
err = db.Exec(_L("CREATE TABLE t(num INTEGER)"));
TEST2(err, 1);
err = db.Exec(_L("INSERT INTO t VALUES(1)"));
TEST2(err, 1);
err = db.Exec(_L("INSERT INTO t VALUES(2)"));
TEST2(err, 1);
//Purposely commit an error so LastErrorMessage can be called
RSqlStatement stmt;
err = stmt.Prepare(db, _L("DELETE FROM t WHERE ROWID=?"));
TEST2(err, KErrNone);
err = stmt.BindInt(0, 1);
TEST2(err, KErrNone);
err = stmt.Exec();
TEST2(err, 1);
//Should have reset stmt here
err = stmt.BindInt(0, 2);
TEST2(err, KErrNone);
err = stmt.Exec();
TEST2(err, KSqlErrMisuse);
//Test "library routine called out of sequence" error message
//If the defect is not fixed then it will panic here
TPtrC errMsg = db.LastErrorMessage();
RDebug::Print(_L("errMsg=%S\r\n"), &errMsg);
stmt.Close();
db.Close();
TInt allocationNo = 0;
//The mask allows the out of memory simulation of the SQL Server to be delayed until the database is opened
const TInt KDelayedDbHeapFailureMask = 0x1000;
do
{
TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic |KDelayedDbHeapFailureMask, ++allocationNo);
err = db.Open(KTestDatabase6);
TEST2(err, KErrNone);
err = db.Exec(_L("INSERT INTO t VALUES(3)"));
TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);
TheTest.Printf(_L("%d \r"), allocationNo);
//Test "out of memory" error message, if the defect is not fixed then it will panic here
TPtrC errMsg = db.LastErrorMessage();
RDebug::Print(_L("errMsg=%S\r\n"), &errMsg);
db.Close();
}
while (err == KErrNoMemory);
TEST2(err, 1);
}
/**
@SYMTestCaseID PDS-SQL-CT-4166
@SYMTestCaseDesc Tests for DEF144027: SQL Open returns error if the reported and actual file size are different
@SYMTestPriority Medium
@SYMTestActions 1) Create a simple database and close it (this will automatically delete the journal file
2) Create a 15 bytes garbage journal file which is just less than the minimum file size allowed.
3) Reopen the database and checks that the open operation does not fail even thou we've used a
garbage journal file which is too small
@SYMTestExpectedResults The RSqlDatabase::Open operation should not fail
@SYMDEF DEF144027
DEF144238
*/
void DEF144027()
{
(void) RSqlDatabase::Delete(KTestDatabase7);
(void) TheFs.Delete(KTestDatabase7Journal);
TInt err = TheDb.Create(KTestDatabase7);
TEST2(err, KErrNone);
err = TheDb.Exec(_L("CREATE TABLE t1(NUM INTEGER)"));
TEST2(err, 1);
err = TheDb.Exec(_L("INSERT INTO t1(NUM) VALUES (1)"));
TEST2(err, 1);
TheDb.Close();
//Created a garbage 15 bytes journal file
RFile file;
err = file.Create(TheFs, KTestDatabase7Journal, EFileWrite);
TEST2(err, KErrNone);
_LIT8(KJournalJunkData, "A123456789B1234");//15 bytes
err = file.Write(0, KJournalJunkData);
TEST2(err, KErrNone);
file.Flush();
file.Close();
//Here we check the open operation does not return an error,
//even though there is a journal file less than 16 bytes
err = TheDb.Open(KTestDatabase7);
TEST2(err, KErrNone);
TheDb.Close();
}
/**
Test defect where calling RSQLStatement::DeclaredColumnType() on a table which contains long (> 20 characters) column type
names results in a USER 11 panic.
This test should pass because these are valid SQL column types
*/
void LongColumnTypeTest()
{
(void)RSqlDatabase::Delete(KTestDatabase3);
TInt err = TheDb.Create(KTestDatabase3);
TEST2(err, KErrNone);
_LIT8(KCreateStmt, "CREATE TABLE t(a CHARACTER VARYING(100000), b NCHAR VARYING(100000), c NATIONAL CHARACTER(100000), d NATIONAL CHARACTER VARYING(100000))");
err = TheDb.Exec(KCreateStmt);
TEST(err >= 0);
//Select all columns (SELECT *)
_LIT(KSelectStmt, "SELECT * FROM t");
RSqlStatement stmt;
err = stmt.Prepare(TheDb, KSelectStmt);
TEST2(err, KErrNone);
TSqlColumnType colType;
err = stmt.DeclaredColumnType(0, colType);
TEST2(err,KErrNone);
TEST2(colType, ESqlText);
err = stmt.DeclaredColumnType(1, colType);
TEST2(err,KErrNone);
TEST2(colType, ESqlText);
err = stmt.DeclaredColumnType(2, colType);
TEST2(err,KErrNone);
TEST2(colType, ESqlText);
err = stmt.DeclaredColumnType(3, colType);
TEST2(err,KErrNone);
TEST2(colType, ESqlText);
stmt.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDatabase3);
}
void DoTestsL()
{
TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1763 \"SQL against a detached db\" test "));
SqlDetachedDbTest();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4034 Corrupted db file (file length too short)"));
CorruptDbFileTest();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4035 Attempt to attach a file which name cannot be parsed"));
AttachBadDbFileNameTest();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4036 Attempt to attach a secure database. The client cannot pass the security checks"));
AttachSecureDbTest();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4032 INC091579 - SQL Panic 7 when streaming BLOB fields"));
INC091579L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4033 INC091580 - SQL returns bogus pointer when too much text in field..."));
INC091580L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1815 Testing KSqlErrFull error code "));
SqlErrFullTest();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1816-0001 INC094870 - [SQL] Database became corrupted and cannot be opened "));
INC094870L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1817-0001 INC095412: [SQL] Retrieving query results may corrupt heap "));
INC095412();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3427 DEF104242 - The SQL server fails to open database with default security policy only "));
DEF104242();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3430 DEF104437 - RSqlStatement::Next() panics the SQL server with KERN-EXEC 3 "));
DEF104437();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3442 DEF105259 - SQL, RSqlColumnReadStream's internal buffer may become invalid "));
DEF105259L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3470 DEF105681 - SQL, HReadOnlyBuf::ConstructL() sets a pointer to a local TPtr8 variable "));
DEF105681L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3476 DEF106391 SQL server does not deallocate the already allocated memory "));
DEF106391();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3501 DEF109025 SQL, dangling long binary/text column value pointer "));
DEF109025();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3546 DEF109843 SQL, RSQLStatement::BindBinary() is causing panic if empty descriptor is passed "));
DEF109843();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4005 DEF114698: SqlSrv.EXE::!SQL Server Insert/Update Error "));
DEF114698();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4008 DEF115567 Critical SQLite defect that can cause database corruption during UPDATE/DELETE "));
DEF115567L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4009-0001 DEF115556: SqlSrv.EXE::!SQL Server when preparing complex sql query "));
DEF115556();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4012 DEF115954: CSession Code = 2 executing SQL stmt in OOM loop "));
DEF115954();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4019 DEF116397: SQL, Attaching database returns KErrEof(-25) "));
DEF116397();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4029 DEF119403: Database re-index unnecessarily during open operation"));
DEF119403L();
TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4031 DEF120237: SQL, SQLITE3.3.17, \"collate nocase\", wrong results."));
DEF120237L();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4120 DEF125881: RSqlDatabase::Exec() returns KErrAlreadyExists in I/O failure use cases."));
DEF125881L();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4128 DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases."));
DEF129581();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4153 DEF143047: SQL, default \"max parameter count\" value, compatibility problem."));
DEF143047();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4157 PDEF143461 : CSqlSrvDatabase::LastErrorMessage() alignment problem"));
PDEF143461L();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4166 DEF144027: SQL Open returns error if the reported and actual file size are different"));
DEF144027();
TheTest.Next(_L("RSQLStatement::DeclaredColumnType() causes USER 11 panic when table contains long column type strings"));
LongColumnTypeTest();
}
TInt E32Main()
{
TheTest.Title();
CTrapCleanup* tc = CTrapCleanup::New();
__UHEAP_MARK;
CreateTestEnv();
DeleteTestFiles();
TInt err = RSqlDatabase::Copy(KCorruptDbZ, KCorruptDb);
TEST2(err, KErrNone);
TRAP(err, DoTestsL());
DeleteTestFiles();
TheFs.SetErrorCondition(KErrNone);
TheFs.Close();
TEST2(err, KErrNone);
__UHEAP_MARKEND;
TheTest.End();
TheTest.Close();
delete tc;
User::Heap().Check();
return KErrNone;
}