/**
@SYMTestCaseID SYSLIB-SQL-UT-3440
@SYMTestCaseDesc Test for DEF105928 "SQL server ignores config string parameters".
The test creates a secure database with a configuration string. The test must not fail.
@SYMTestPriority High
@SYMTestActions Test for DEF105928 "SQL server ignores config string parameters".
@SYMTestExpectedResults The test must not fail
@SYMDEF DEF105928
*/
void CfgSecureDbTest()
{
//Create
TSecurityPolicy policy(TSecurityPolicy::EAlwaysPass);
RSqlSecurityPolicy dbPolicy;
TInt err = dbPolicy.Create(policy);
TEST2(err, KErrNone);
_LIT8(KCfgStr1, "cache_size = 80; page_size = 4096; encoding = UTF-8");
err = TheDb.Create(KTestDbName3, dbPolicy, &KCfgStr1);
TEST2(err, KErrNone);
//Since it is a secure database, PRAGMAs cannot be executed (in order to assert the parameter values)
//AssertConfigPrmValues(TheDb, 80, 4096, TSqlSrvConfig::EEncUtf8);
TheDb.Close();
dbPolicy.Close();
//Open
_LIT8(KCfgStr2, "cache_size = 100");
err = TheDb.Open(KTestDbName3, &KCfgStr2);
TEST2(err, KErrNone);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName3);
}
/**
* Method to insert AuthParamsTable
* @param aAuthAppId The ID of the Authentication app
* @param aKey The Key
* @param aSecret The Secret
* @return Returns KErrNone if success. Refer ESqlDbError and system-wide
* error codes for detailed error description.
*/
TInt CSmfCredMgrDbUser::AuthParamsTableInsert(const TDesC& aAuthAppId,
const TDesC& aKey, const TDesC& aSecret)
{
TInt err(KErrNone);
RSqlStatement sqlStatement;
RSqlDatabase db;
TBuf<KMaxBufSize> keyBuf(aKey);
TBuf<KMaxBufSize> secretBuf(aSecret);
err = db.Open(iDbFilePathName);
__ASSERT_DEBUG( (err >= KErrNone), User::Invariant());
err = sqlStatement.Prepare(db, KSmfAuthParamsTableInsert);
TInt paramIndex(KErrNone);
paramIndex = sqlStatement.ParameterIndex(_L(":Val1"));
err = sqlStatement.BindText(paramIndex, aAuthAppId);
paramIndex = sqlStatement.ParameterIndex(_L(":Val2"));
err = sqlStatement.BindText(paramIndex, keyBuf);
paramIndex = sqlStatement.ParameterIndex(_L(":Val3"));
err = sqlStatement.BindText(paramIndex, secretBuf);
err = db.Exec(KBegin);
__ASSERT_DEBUG( (err >= KErrNone), User::Invariant());
err = sqlStatement.Exec();
if (KSqlErrConstraint == err)
{
//Table already present.
}
else if (err < KErrNone)
{
__ASSERT_DEBUG( (err >= KErrNone), User::Invariant());
}
err = db.Exec(KCommit);
__ASSERT_DEBUG( (err >= KErrNone), User::Invariant());
//if commit fails we have to roll back
if (err < KErrNone)
{
err = db.Exec(KRollback);
}
sqlStatement.Close();
db.Close();
if (err >= 0)
{
return KErrNone;
}
return err;
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3441
@SYMTestCaseDesc Test for DEF105928 "SQL server ignores config string parameters".
The test creates a private database with a configuration string. The test must not fail.
@SYMTestPriority High
@SYMTestActions Test for DEF105928 "SQL server ignores config string parameters".
@SYMTestExpectedResults The test must not fail
@SYMDEF DEF105928
*/
void CfgPrivateDbTest()
{
//Create
_LIT8(KCfgStr1, "cache_size = 80; page_size = 4096; encoding = UTF-8");
TInt err = TheDb.Create(KTestDbName4, &KCfgStr1);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 80, 4096, TSqlSrvConfigParams::EEncUtf8);
TheDb.Close();
//Open-1. The cache size can be changed.
_LIT8(KCfgStr2, "cache_size = 100");
err = TheDb.Open(KTestDbName4, &KCfgStr2);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 100, 4096, TSqlSrvConfigParams::EEncUtf8);
TheDb.Close();
//Open-2. The page size cannot be changed if the database does exist already.
_LIT8(KCfgStr3, "page_size = 512");
err = TheDb.Open(KTestDbName4, &KCfgStr3);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, (TSqlSrvConfigParams::KDefaultSoftHeapLimitKb * 1024) / 4096, 4096, TSqlSrvConfigParams::EEncUtf8);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName4);
}
static void CreateTestDatabase()
{
RSqlDatabase::Delete(KTestDbName);
_LIT8(KConfigStr, "encoding=\"UTF-8\"");
TInt err = TheDb.Create(KTestDbName, &KConfigStr);
TEST2(err, KErrNone);
err = TheDb.Exec(_L8("CREATE TABLE Tbl(I INTEGER PRIMARY KEY, I64 BIGINT, D DOUBLE, T TEXT, B BINARY)"));
TEST2(err, 1);
TheDb.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4059
@SYMTestCaseDesc Background compaction - no configuration string test.
The test creates a database without using a configuration string.
The database should be created with default compaction mode - background.
The test reopens the database and verifies that the compaction mode is persistent and is still background.
Then the test reopens the database using different compaction mode in the configuration string and
verifies that the original (background) compaction mode cannot be changed when the database is opened.
@SYMTestPriority Medium
@SYMTestActions Background compaction - no configuration string test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ10273
REQ10274
*/
void CompactConfigTest4L()
{
//Create a test database without configuration string
TInt err = TheDb.Create(KTestDbName1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
TSqlScalarFullSelectQuery scalarQuery(TheDb);
TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
//Delete database
err = RSqlDatabase::Delete(KTestDbName1);
TEST2(err, KErrNone);
//Create a test database with invalid configuration string
_LIT8(KConfigStr1, "encoding=utf-8;compaction=backgrund");
err = TheDb.Create(KTestDbName1, &KConfigStr1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
//Delete database
err = RSqlDatabase::Delete(KTestDbName1);
TEST2(err, KErrNone);
//Create a test database with invalid configuration string
_LIT8(KConfigStr2, "compactin=background");
err = TheDb.Create(KTestDbName1, &KConfigStr2);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
//Delete database
err = RSqlDatabase::Delete(KTestDbName1);
TEST2(err, KErrNone);
}
void CreateDatabaseL(const TDesC& aDbName)
{
// create the database now
RSqlSecurityPolicy securityPolicy;
CleanupClosePushL(securityPolicy);
TSecurityPolicy policy(TSecurityPolicy::EAlwaysPass);
securityPolicy.Create(policy);
TSecurityPolicy schemaPolicy(TSecurityPolicy::EAlwaysPass);
TSecurityPolicy readPolicy(TSecurityPolicy::EAlwaysPass);
TSecurityPolicy writePolicy(TSecurityPolicy::EAlwaysPass);
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, schemaPolicy));
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, readPolicy));
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, writePolicy));
TheTest.Printf(_L("Creating Database %S\n"), &aDbName);
TInt err = TheDbC.Create(aDbName, securityPolicy, &TheSqlConfigString);
if (KErrAlreadyExists == err)
{
// the file already exists
// make sure we delete the file
User::LeaveIfError(TheDbC.Delete(aDbName));
// try again
err = TheDbC.Create(aDbName, securityPolicy, &TheSqlConfigString);
}
User::LeaveIfError(err);
//Create tables
User::LeaveIfError(TheDbC.Exec(KMusicCreateTable));
User::LeaveIfError(TheDbC.Exec(KAuxiliaryCreateTable));
User::LeaveIfError(TheDbC.Exec(KAlbumCreateTable));
User::LeaveIfError(TheDbC.Exec(KArtistCreateTable));
User::LeaveIfError(TheDbC.Exec(KComposerCreateTable));
User::LeaveIfError(TheDbC.Exec(KGenreCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistSongInfoCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistSongsCreateTable));
TheDbC.Close();
CleanupStack::PopAndDestroy(&securityPolicy);
}
TInt UpdateThreadFunc(void*)
{
__UHEAP_MARK;
CTrapCleanup* tc = CTrapCleanup::New();
TTEST(tc != NULL);
RSqlDatabase db;
TInt err = db.Open(KTestDbName1);
TTEST2(err, KErrNone);
RDebug::Print(_L("---:UpdThread: Set the isolation level to \"Read uncommitted\"\r\n"));
err = db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);
TTEST2(err, KErrNone);
RDebug::Print(_L("---:UpdThread: Begin a write transaction\r\n"));
_LIT8(KBeginTransSql, "BEGIN IMMEDIATE TRANSACTION");
err = db.Exec(KBeginTransSql);
TTEST(err >= 0);
RDebug::Print(_L("---:UpdThread: Update the record\r\n"));
_LIT8(KUpdateSql, "UPDATE A SET Id = ");
TBuf8<64> sql(KUpdateSql);
sql.AppendNum((TInt64)KUpdatedValue);
err = db.Exec(sql);
TTEST(err >= 0);
RDebug::Print(_L("---:UpdThread: Notify the main thread about the update\r\n"));
MainThreadCrS.Signal();
RDebug::Print(_L("---:UpdThread: Wait for permisson to continue...\r\n"));
UpdateThreadCrS.Wait();
RDebug::Print(_L("---:UpdThread: Rollback the update\r\n"));
_LIT8(KRollBackTransSql, "ROLLBACK TRANSACTION");
err = db.Exec(KRollBackTransSql);
TTEST(err >= 0);
RDebug::Print(_L("---:UpdThread: Notify the main thread about the rollback\r\n"));
MainThreadCrS.Signal();
db.Close();
delete tc;
__UHEAP_MARKEND;
return KErrNone;
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3438
@SYMTestCaseDesc Test for DEF105928 "SQL server ignores config string parameters".
The test attempts to create a database with configuration string containing:
negative or zero page size and cache size, too small or too big page size,
page size, not power of two. The test expects the SQL server will detect those
invalid page size and cache size values and will refuse to execute the operation.
@SYMTestPriority High
@SYMTestActions Test for DEF105928 "SQL server ignores config string parameters".
@SYMTestExpectedResults The test must not fail
@SYMDEF DEF105928
*/
void CfgInvalidCacheAndPageSizeTest()
{
//Create a database. Page size < 512.
_LIT8(KCfgStr1, "page_size=128;");
TInt err = TheDb.Create(KTestDbName, &KCfgStr1);
TEST2(err, KErrNone);//Invalid page size: KErrNone expected, but the page size will not be set
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Page size > 32768.
_LIT8(KCfgStr2, "page_size=65535;");
err = TheDb.Create(KTestDbName, &KCfgStr2);
TEST2(err, KErrNone);//Invalid page size: KErrNone expected, but the page size will not be set
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Page size is not power of two.
_LIT8(KCfgStr3, "page_size=5000;");
err = TheDb.Create(KTestDbName, &KCfgStr3);
TEST2(err, KErrNone);//Invalid page size: KErrNone expected, but the page size will not be set
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Zero cache size.
_LIT8(KCfgStr4, "cache_size=0");
err = TheDb.Create(KTestDbName, &KCfgStr4);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 0, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Negative cache size.
_LIT8(KCfgStr5, "cache_size=-32");
err = TheDb.Create(KTestDbName, &KCfgStr5);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Zero page size.
_LIT8(KCfgStr6, "page_size=0");
err = TheDb.Create(KTestDbName, &KCfgStr6);
TEST2(err, KErrNone);//Invalid page size: KErrNone expected, but the page size will not be set
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Negative page size.
_LIT8(KCfgStr7, "page_size=-1024");
err = TheDb.Create(KTestDbName, &KCfgStr7);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
}
/**
@SYMTestCaseID PDS-SQLITE3SEC-UT-4038
@SYMTestCaseDesc SQL server single-insert performance test.
The test inserts one record and stores
the execution time for later use (comparison and printing).
@SYMTestPriority High
@SYMTestActions SQL server single-insert performance test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ11320
*/
static void SqlServerSingleInsertTest(const char aSingleInsertSql[], TInt aInsertRecId)
{
TheTest.Next( _L("@SYMTestCaseID:PDS-SQLITE3SEC-UT-4038"));
(void)KillProcess(KSqlSrvName);
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
TheSqlBuf.Format(TPtrC8((const TUint8*)aSingleInsertSql), aInsertRecId);
TUint32 fc = FastCounterValue();
err = TheDb.Exec(TheSqlBuf);
StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleInsert, FastCounterValue() - fc);
TEST2(err, 1);
TheDb.Close();
}
/**
@SYMTestCaseID PDS-SQLITE3SEC-UT-4040
@SYMTestCaseDesc SQL server single-delete performance test.
The test deletes one randomly chosen record and stores
the execution time for later use (comparison and printing).
@SYMTestPriority High
@SYMTestActions SQL server single-delete performance test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ11320
*/
static void SqlServerSingleDeleteTest(const char aSingleDeleteSql[], TInt aDeleteRecId)
{
TheTest.Next( _L("@SYMTestCaseID:PDS-SQLITE3SEC-UT-4040"));
(void)KillProcess(KSqlSrvName);
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
TheSqlBuf.Copy(TPtrC8((const TUint8*)aSingleDeleteSql));
TheSqlBuf.AppendNum((TInt64)aDeleteRecId);
TUint32 fc = FastCounterValue();
err = TheDb.Exec(TheSqlBuf);
StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleDelete, FastCounterValue() - fc);
TEST2(err, 1);
TheDb.Close();
}
/**
@SYMTestCaseID PDS-SQLITE3SEC-UT-4036
@SYMTestCaseDesc SQL server multi-delete performance test.
The test deletes 100 randomly chosen records and stores
the execution time for later use (comparison and printing).
@SYMTestPriority High
@SYMTestActions SQL server multi-delete performance test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ11320
*/
static void SqlServerMultiDeleteTest(const char aDeleteSql[], TInt aDeleteRecIds[], TInt aDeleteRecCnt)
{
TheTest.Next( _L("@SYMTestCaseID:PDS-SQLITE3SEC-UT-4036"));
(void)KillProcess(KSqlSrvName);
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
FormatSqlStmt(TheSqlBuf, aDeleteSql, aDeleteRecIds, aDeleteRecCnt);
TUint32 fc = FastCounterValue();
err = TheDb.Exec(TheSqlBuf);
StorePerfTestResult(EPerfTestSqlMode, EPerfTestMultiDelete, FastCounterValue() - fc);
TEST2(err, aDeleteRecCnt);
TheDb.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4061
@SYMTestCaseDesc Secure shared database and compaction configuration test.
The test verifies that a secure shared database can be created using auto, background or
manual compaction mode and that the compaction mode does not chage after reopening
the database.
@SYMTestPriority Medium
@SYMTestActions Secure shared database and compaction configuration test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ10273
REQ10274
REQ10400
REQ10402
*/
void CompactConfigTest6L()
{
//Create a secure test database with "auto" compaction mode.
RSqlSecurityPolicy securityPolicy = CreateTestSecurityPolicy();
_LIT8(KConfigStr1, "encoding=utf-8;compaction=auto");
TInt err = TheDb.Create(KTestSecureDbName, securityPolicy, &KConfigStr1);
TEST2(err, KErrNone);
securityPolicy.Close();
TheDb.Close();
//Check the vacuum mode. The SQLite vacuum mode should be "auto"
TestCompactMode(KAutoVacuum);
//Close and open the database again. The SQLite vacuum mode should be "auto".
err = TheDb.Open(KTestSecureDbName);
TEST2(err, KErrNone);
TheDb.Close();
TestCompactMode(KAutoVacuum);
//Close and open the database again with a config string with "background" compaction mode.
//The SQLite vacuum mode should stay unchanged.
_LIT8(KConfigStr2, "compaction=background");
err = TheDb.Open(KTestSecureDbName, &KConfigStr2);
TEST2(err, KErrNone);
TheDb.Close();
TestCompactMode(KAutoVacuum);
//Delete database
err = RSqlDatabase::Delete(KTestSecureDbName);
TEST2(err, KErrNone);
//Create a private test database - no config string
securityPolicy = CreateTestSecurityPolicy();
err = TheDb.Create(KTestSecureDbName, securityPolicy);
TEST2(err, KErrNone);
securityPolicy.Close();
TheDb.Close();
//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum.
TestCompactMode(KSqlDefaultVacuum);
//Close and open the database again. The SQLite vacuum mode should be KSqlDefaultVacuum.
err = TheDb.Open(KTestSecureDbName);
TEST2(err, KErrNone);
TheDb.Close();
TestCompactMode(KSqlDefaultVacuum);
//Close and open the database again with a config string with "auto" compaction mode.
//The SQLite vacuum mode should stay unchanged.
err = TheDb.Open(KTestSecureDbName, &KConfigStr1);
TEST2(err, KErrNone);
TheDb.Close();
TestCompactMode(KSqlDefaultVacuum);
//Delete database
err = RSqlDatabase::Delete(KTestSecureDbName);
TEST2(err, KErrNone);
}
void getcontentstatus ( TPtrC aContent , TInt& aBLstatus ,TInt& aINstatus)
{
RSqlDatabase sqlDB;
RFs fssession;
User::LeaveIfError( fssession.Connect() );
TFileName privatePath;
TFileName datafile;
fssession.CreatePrivatePath(EDriveC);
fssession.PrivatePath(privatePath);//data caged path of loading process
fssession.Close();
datafile.Copy(KDriveC);
datafile.Append(privatePath);
datafile.Append( KContentInfoFileName );
TInt err = sqlDB.Open( datafile );
if ( err ==KErrNone )
{
TSqlScalarFullSelectQuery fullSelectQuery(sqlDB);
TBuf<100> sql;
// Query with INS column
_LIT(KgetINstatusSqlFormat, "SELECT INS FROM table1 WHERE NAME = '");
_LIT(Kendtag, "'");
sql.Copy( KgetINstatusSqlFormat);
sql.Append( aContent);
sql.Append( Kendtag );
//sql.Format( KgetINstatusSqlFormat , aContent );
// Read INS as integer.
aINstatus = fullSelectQuery.SelectIntL(sql);
_LIT(KgetBLstatusSqlFormat, "SELECT BLS FROM table1 WHERE NAME = '");
sql.FillZ();
sql.Copy( KgetBLstatusSqlFormat);
sql.Append( aContent);
sql.Append( Kendtag );
//sql.Format( KgetBLstatusSqlFormat , aContent );
// Read BLS as integer.
aBLstatus = fullSelectQuery.SelectIntL(sql);
}
sqlDB.Close();
}
/**
@SYMTestCaseID PDS-SQLITE3SEC-UT-4041
@SYMTestCaseDesc SQL server single-select performance test.
The test selects one randomly chosen record and stores
the execution time for later use (comparison and printing).
@SYMTestPriority High
@SYMTestActions SQL server single-select performance test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ11320
*/
static void SqlServerSingleSelectTest(const char aSingleSelectSql[], TInt aSelectRecId)
{
TheTest.Next( _L("@SYMTestCaseID:PDS-SQLITE3SEC-UT-4041"));
(void)KillProcess(KSqlSrvName);
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
TheSqlBuf.Copy(TPtrC8((const TUint8*)aSingleSelectSql));
TheSqlBuf.AppendNum((TInt64)aSelectRecId);
RSqlStatement stmt;
err = stmt.Prepare(TheDb, TheSqlBuf);
TEST2(err, KErrNone);
TInt recCnt = 0;
TUint32 fc = FastCounterValue();
while((err = stmt.Next()) == KSqlAtRow)
{
TInt64 i64 = stmt.ColumnInt64(0);
UNUSED_VAR(i64);
TReal d = stmt.ColumnReal(1);
UNUSED_VAR(d);
TPtrC t;
err = stmt.ColumnText(2, t);
TEST2(err, KErrNone);
UNUSED_PTR(t);
TPtrC8 b;
err = stmt.ColumnBinary(3, b);
TEST2(err, KErrNone);
UNUSED_PTR(b);
++recCnt;
}
StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleSelect, FastCounterValue() - fc);
TEST2(err, KSqlAtEnd);
TEST2(recCnt, 1);
stmt.Close();
TheDb.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3439
@SYMTestCaseDesc Test for DEF105928 "SQL server ignores config string parameters".
The test creates two databases using configuration strings and checks that database 1
configuration has no impact on database 2 configuration.
@SYMTestPriority High
@SYMTestActions Test for DEF105928 "SQL server ignores config string parameters".
@SYMTestExpectedResults The test must not fail
@SYMDEF DEF105928
*/
void CfgCrossConnectionTest()
{
//Create database 1 with cache size = 40, page size = 2048.
_LIT8(KCfgStr1, "cache_size = 40; page_size = 2048");
TInt err = TheDb.Create(KTestDbName, &KCfgStr1);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 40, 2048, KDefaultEncoding);
//Without closing database 1, create database 2 without a configuration string.
//Check that database 2 uses the default configuration parameters
err = TheDb2.Create(KTestDbName2);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb2, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
//Close database 2. Check the configuration parameters of database 1
TheDb2.Close();
AssertConfigPrmValues(TheDb, 40, 2048, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName2);
(void)RSqlDatabase::Delete(KTestDbName);
//Create 2 databases with different configuration parameters
_LIT8(KCfgStr2_1, "cache_size = 50; page_size = 512; encoding = \"UTF-16\"");
_LIT8(KCfgStr2_2, "cache_size = 80; page_size = 4096; encoding = \"UTF-8\"");
err = TheDb.Create(KTestDbName, &KCfgStr2_1);
TEST2(err, KErrNone);
err = TheDb2.Create(KTestDbName2, &KCfgStr2_2);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 50, 512, TSqlSrvConfigParams::EEncUtf16);
AssertConfigPrmValues(TheDb2, 80, 4096, TSqlSrvConfigParams::EEncUtf8);
TheDb2.Close();
TheDb.Close();
//Reopen the databases and check the configuration parameters
err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
err = TheDb2.Open(KTestDbName2);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, (TSqlSrvConfigParams::KDefaultSoftHeapLimitKb * 1024) / 512, 512, TSqlSrvConfigParams::EEncUtf16);
AssertConfigPrmValues(TheDb2, (TSqlSrvConfigParams::KDefaultSoftHeapLimitKb * 1024) / 4096, 4096, TSqlSrvConfigParams::EEncUtf8);
TheDb2.Close();
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName2);
(void)RSqlDatabase::Delete(KTestDbName);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4062
@SYMTestCaseDesc Compaction configuration test - multiple connections.
The test creates a database with auto or background compaction mode.
Then the test opens more connections to the same database.
The test verifies that the compaction mode of the connections opened later is
the same as the compaction mode of the database that was openen first.
The test also verifies that the compactino mode cannot be changed even if the second
connection is opened with a configuration string with a specified different compaction mode.
@SYMTestPriority Medium
@SYMTestActions Compaction configuration test - multiple connections.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ10273
REQ10274
REQ10400
*/
void CompactConfigTest7L()
{
//Create a test database with "auto" compaction mode.
_LIT8(KConfigStr1, "encoding=utf-8;compaction = auto");
TInt err = TheDb.Create(KTestDbName1, &KConfigStr1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "auto"
TSqlScalarFullSelectQuery scalarQuery(TheDb);
TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
//Open a second connection to the same database - no config string
RSqlDatabase db2;
err = db2.Open(KTestDbName1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "auto"
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
TSqlScalarFullSelectQuery scalarQuery2(db2);
compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
//Open a third connection to the same database - "background" compaction mode config string
_LIT8(KConfigStr2, " encoding = utf-8 ; ; ; compaction = background ");
RSqlDatabase db3;
err = db3.Open(KTestDbName1, &KConfigStr2);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "auto"
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
TSqlScalarFullSelectQuery scalarQuery3(db3);
compact = scalarQuery3.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
//Close & Delete database
db3.Close();
db2.Close();
TheDb.Close();
err = RSqlDatabase::Delete(KTestDbName1);
TEST2(err, KErrNone);
//
//
//Create a test database with "background" compaction mode
_LIT8(KConfigStr3, "compaction = background ;;;;");
err = TheDb.Create(KTestDbName1, &KConfigStr3);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KIncrementalVacuum);
//Open a second connection to the same database - no config string
err = db2.Open(KTestDbName1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KIncrementalVacuum);
scalarQuery2.SetDatabase(db2);
compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KIncrementalVacuum);
//Open a third connection to the same database - "auto" compaction mode config string
_LIT8(KConfigStr4, " encoding = utf-16 ; compaction = auto ; ; ; ");
err = db3.Open(KTestDbName1, &KConfigStr4);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KIncrementalVacuum);
compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KIncrementalVacuum);
scalarQuery3.SetDatabase(db3);
compact = scalarQuery3.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KIncrementalVacuum);
//Close & Delete database
db3.Close();
db2.Close();
TheDb.Close();
err = RSqlDatabase::Delete(KTestDbName1);
TEST2(err, KErrNone);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1646
@SYMTestCaseDesc Testing database operations on a secure database.
The test application's capabilities allow read/write access to the test secure database.
Verify that any other kind of a database operation will fail with KErrPermissionDenied error.
@SYMTestPriority High
@SYMTestActions Testing database operations on a secure database.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
REQ5793
*/
void ReadWriteDatabaseTest()
{
RSqlDatabase db;
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
//Attempt to modify the database schema
err = TheDb.Exec(_L("CREATE TABLE C(FFF TEXT)"));
TEST2(err, KErrPermissionDenied);
err = TheDb.Exec(_L("CREATE TEMP TABLE TBL1(COL1 INTEGER, COL2 INTEGER)"));
TEST(err >= 0);
err = TheDb.Exec(_L("CREATE TEMP TRIGGER del1 AFTER DELETE ON TBL1 BEGIN DELETE FROM A; END;"));
TEST(err >= 0);
err = TheDb.Exec(_L("DROP TRIGGER del1"));
TEST(err >= 0);
err = TheDb.Exec(_L("CREATE TEMP VIEW V1 AS SELECT * FROM TBL1"));
TEST(err >= 0);
err = TheDb.Exec(_L("DROP VIEW V1"));
TEST(err >= 0);
err = TheDb.Exec(_L("CREATE INDEX I1 ON TBL1(COL2)"));
TEST(err >= 0);
err = TheDb.Exec(_L("DROP INDEX I1"));
TEST(err >= 0);
err = TheDb.Exec(_L("DROP TABLE TBL1"));
TEST(err >= 0);
err = TheDb.Exec(_L("ANALYZE A"));
TEST2(err, KErrPermissionDenied);
err = TheDb.Exec(_L("CREATE VIEW V2 AS SELECT * FROM A"));
TEST2(err, KErrPermissionDenied);
//Attempt to update the user data (but it includes a READ operation)
err = TheDb.Exec(_L("UPDATE A SET F1 = 11 WHERE F1 = 1"));
TEST(err >= 0);
//Attempt to update the user data (unconditional UPDATE, no READ operations)
err = TheDb.Exec(_L("UPDATE A SET F1 = 11"));
TEST(err >= 0);
//Attempt to delete the user data (but it includes a READ operation)
err = TheDb.Exec(_L("DELETE FROM B WHERE F2 = 2"));
TEST(err >= 0);
//Attempt to delete the user data (unconditional DELETE, no READ operations)
err = TheDb.Exec(_L("DELETE FROM A"));
TEST(err >= 0);
//Restore the deleted table A
err = TheDb.Exec(_L("INSERT INTO A(F1,B1) VALUES(1,x'41414141414141414141');INSERT INTO A(F1,B1) VALUES(2,x'42424242424242424242');INSERT INTO A(F1,B1) VALUES(3,x'43434343434343434343');INSERT INTO A(F1,B1) VALUES(4,x'44444444444444444444');"));
TEST(err >= 0);
//Restore the deleted record in table B
err = TheDb.Exec(_L("INSERT INTO B(F2, F3, B2) VALUES(2, 'ABC', x'45454545454545454545');"));
TEST2(err, 1);
//Attempt to insert new user data
err = TheDb.Exec(_L("INSERT INTO B(F2, F3, B2) VALUES(6, 'GHI', x'47474747474747474747');"));
TEST2(err, 1);
//Attempt to read the user data
RSqlStatement stmt;
err = stmt.Prepare(TheDb, _L("SELECT A.F1 FROM B,A WHERE A.F1 = B.F2"));
TEST2(err, KErrNone);
//ColumnCount() has no capabilities assigned
TInt colCnt = stmt.ColumnCount();
TEST2(colCnt, 1);
//DeclaredColumnType() has no capabilities assigned
TSqlColumnType colType;
err = stmt.DeclaredColumnType(0, colType);
TEST2(err, KErrNone);
TEST2(colType, ESqlInt);
err = stmt.Next();
TEST2(err, KSqlAtRow);
RDebug::Print(_L("Value=%d\r\n"), stmt.ColumnInt(0));
err = stmt.Next();
TEST2(err, KSqlAtRow);
RDebug::Print(_L("Value=%d\r\n"), stmt.ColumnInt(0));
stmt.Close();
//Attempt to read the system data
err = stmt.Prepare(TheDb, _L("SELECT * FROM SQLITE_MASTER"));
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
TPtrC p;
err = stmt.ColumnText(0, p);
TEST2(err, KErrNone);
RDebug::Print(_L("Value=%S\r\n"), &p);
stmt.Close();
NonSecureDbTest();
TheDb.Close();
}
void CMsvIndexContext::CreateIndexL(TInt aDrive, TBool aSync)
{
__ASSERT_DEBUG(iProgress.iState == TMsvIndexLoadProgress::EIndexNotLoaded, PanicServer(EMsvBadIndexState));
__ASSERT_DEBUG(RFs::IsValidDrive(aDrive), PanicServer(EMsvInvalidDrive));
// Remember stuff
iConfig.iDrive = TDriveUnit(aDrive);
iObserverStatus = NULL;
iRunMailInit = EFalse;
// Set the drive for this index file
TParse parse;
TPtrC drive(iConfig.iDrive.Name());
parse.Set(KMsvDefaultIndexFile2(), &drive, NULL);
// Construct the message folder name etc
iMessageFolder = parse.DriveAndPath();
TFileName indexFileName = parse.FullName();
// Adding the new code
// Now we are creating the new database adapter.
// Find out if the db exists
// Construct the db file name
parse.Set(KDBFileName, &drive, NULL);
TFileName dBFile = parse.FullName();
RSqlDatabase db;
TRAPD(err,db.OpenL(dBFile));
TBool create=EFalse;
// Database may be corrupted, so delete the old database and create a new one.
if(err == KSqlErrCorrupt || err == KSqlErrNotDb )
{
RSqlDatabase::Delete(dBFile);
create = ETrue;
}
// Database is not present. We need to check if the store is an old one.
// If it is, we check if it is corrupt.
// If it is corrupt we can safely delete the store and create a new one
// in its place. If not, then we leave with KErrNotSupported stating that
// the old store is incompatible with this implementation of the message
// store which uses an SQL database for the index.
else if( err == KErrNotFound)
{
// Check if any of the old index files exist in the Mail2 folder.
TParse parse1;
parse1.Set(KMsvDefaultIndexFile, &drive, NULL); //old version of index file
if( BaflUtils::FileExists(iServer.FileSession(), parse1.FullName()) ||
BaflUtils::FileExists(iServer.FileSession(), indexFileName))
{
// Open index store.
RFile file;
TInt error = file.Open(iServer.FileSession(), indexFileName, EFileShareAny|EFileWrite);
// Check if we have an old 'legacy' version of the index file.
CPermanentFileStore* index = NULL;
TRAPD(permError, index = CPermanentFileStore::FromL(file));
CleanupStack::PushL(index);
if (KErrNone == permError)
{
// Check if the store is corrupt. If so then delete it.
if (index->Type() != TUidType(KPermanentFileStoreLayoutUid, KUidMsvIndexFile))
{
create = ETrue;
}
}
// There was an error in getting a permanent filestore object.
// Delete the message store.
else
{
create = ETrue;
}
CleanupStack::PopAndDestroy(); //index
file.Close();
// If the old store is valid, then throw an error.
if(!create)
{
User::Leave(KErrNotSupported);
}
}
//Index file does not exist in Mail2 folder. Go ahead with database creation.
else
{
create = ETrue;
}
}
else
{
db.Close();
User::LeaveIfError(err);
}
db.Close();
if(!create)
{
// Check for database version.
TRAP(err, CMsvDBAdapter::ValidateDatabaseL(dBFile));
User::LeaveIfError(err);
iIndexAdapter = CMsvIndexAdapter::OpenL(iServer, dBFile);
ResetAndCreateNewMailStoreL(EFalse);
}
else
{
iIndexAdapter = CMsvIndexAdapter::NewL(iServer, dBFile);
ResetAndCreateNewMailStoreL();
CreateStoreDeleteFile();
iRunMailInit = ETrue;
TResourceReader reader;
reader.SetBuffer(iBuf);
// Read initial entries from resources
const TInt numberOfEntries = reader.ReadInt16();
for (TInt index=0; index<numberOfEntries; ++index)
{
TMsvEntry newEntry;
// Values from resource file
newEntry.iId = reader.ReadInt32();
newEntry.iParentId = reader.ReadInt32();
newEntry.iServiceId = reader.ReadInt32();
newEntry.iType.iUid = reader.ReadInt32();
newEntry.iMtm.iUid = reader.ReadInt32();
newEntry.iData = reader.ReadInt32();
newEntry.iDescription.Set(reader.ReadTPtrC());
newEntry.iDetails.Set(reader.ReadTPtrC());
newEntry.iDate.UniversalTime();
newEntry.iSize=0;
// Create the new entry
// This is required to create associated service directory.
TInt error = iServer.AddEntry(this, newEntry, KMsvServerId, EFalse);
User::LeaveIfError(error);
}
iIndexAdapter->SetLocalServiceComplete();
}
if(aSync)
{
IndexLoadingCompleted(KErrNone);
}
else
{
iStatus = KRequestPending;
SetActive();
TRequestStatus* st = &iStatus;
User::RequestComplete(st, KErrNone);// do we need to propogate the error from adapter to here
}
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4096
@SYMTestCaseDesc Testing incremental blob writes on a secure database.
The test application's capabilities allow write-only access to the blobs.
Verify that any attempt to read a blob will fail with KErrPermissionDenied.
@SYMTestPriority High
@SYMTestActions Testing incremental blob writes on a secure database.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5794
*/
void WriteOnlyBlobTestL()
{
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
// Attempt to write the blobs in tables A and B
RSqlBlobWriteStream wrStrm;
CleanupClosePushL(wrStrm);
TRAP(err, wrStrm.OpenL(TheDb, _L("A"), _L("B1"), 2));
TEST2(err, KErrNone);
TRAP(err, wrStrm.WriteL(_L8("YYYYYYY")));
TEST2(err, KErrNone);
wrStrm.Close();
TRAP(err, wrStrm.OpenL(TheDb, _L("B"), _L("B2"), 1));
TEST2(err, KErrNone);
TRAP(err, wrStrm.WriteL(_L8("XXXXXXXXX")));
TEST2(err, KErrNone);
CleanupStack::PopAndDestroy(&wrStrm);
TRAP(err, TSqlBlob::SetL(TheDb, _L("A"), _L("B1"), _L8("UUUUUUUU"), 4));
TEST2(err, KErrNone);
TRAP(err, TSqlBlob::SetL(TheDb, _L("B"), _L("B2"), _L8("SSS"), 2));
TEST2(err, KErrNone);
// Attempt to read from the blobs in tables A and B
RSqlBlobReadStream rdStrm;
CleanupClosePushL(rdStrm);
TRAP(err, rdStrm.OpenL(TheDb, _L("A"), _L("B1"), 1));
TEST2(err, KErrPermissionDenied);
rdStrm.Close();
TRAP(err, rdStrm.OpenL(TheDb, _L("B"), _L("B2"), 1));
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&rdStrm);
HBufC8* wholeBuf = NULL;
TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb, _L("A"), _L("B1"), 1));
TEST2(err, KErrPermissionDenied);
TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb, _L("B"), _L("B2"), 1));
TEST2(err, KErrPermissionDenied);
HBufC8* buf = HBufC8::NewLC(10);
TPtr8 bufPtr(buf->Des());
err = TSqlBlob::Get(TheDb, _L("A"), _L("B1"), bufPtr, 2);
TEST2(err, KErrPermissionDenied);
err = TSqlBlob::Get(TheDb, _L("B"), _L("B2"), bufPtr, 1);
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(buf);
// SQLite and system tables
// Attempt to read from and write to the SQLite master table -
// reads should be permitted because write capability is enough for this,
// writes should not be permitted because schema capability is required for this
CleanupClosePushL(rdStrm);
TRAP(err, rdStrm.OpenL(TheDb, _L("sqlite_master"), _L("tbl_name"), 1)); // TEXT column
TEST2(err, KErrNone);
TBuf8<20> data;
TRAP(err, rdStrm.ReadL(data, 1));
TEST2(err, KErrNone);
CleanupStack::PopAndDestroy(&rdStrm);
wholeBuf = TSqlBlob::GetLC(TheDb, _L("sqlite_master"), _L("tbl_name"), 1);
TEST(wholeBuf->Length() > 0);
CleanupStack::PopAndDestroy(wholeBuf);
buf = HBufC8::NewLC(100);
bufPtr.Set(buf->Des());
err = TSqlBlob::Get(TheDb, _L("sqlite_master"), _L("tbl_name"), bufPtr, 1);
TEST2(err, KErrNone);
TEST(bufPtr.Length() > 0);
CleanupStack::PopAndDestroy(buf);
CleanupClosePushL(wrStrm);
TRAP(err, wrStrm.OpenL(TheDb, _L("sqlite_master"), _L("tbl_name"), 1));
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&wrStrm);
TRAP(err, TSqlBlob::SetL(TheDb, _L("sqlite_master"), _L("tbl_name"), _L8("VVVV"), 1));
TEST2(err, KErrPermissionDenied);
// Attempt to read from and write to the system tables - neither reads nor writes should be permitted
CleanupClosePushL(rdStrm);
TRAP(err, rdStrm.OpenL(TheDb, _L("symbian_security"), _L("PolicyData"), 1)); // BLOB column
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&rdStrm);
TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb, _L("symbian_security"), _L("PolicyData"), 1));
TEST2(err, KErrPermissionDenied);
buf = HBufC8::NewLC(100);
bufPtr.Set(buf->Des());
err = TSqlBlob::Get(TheDb, _L("symbian_security"), _L("PolicyData"), bufPtr, 1);
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(buf);
CleanupClosePushL(wrStrm);
TRAP(err, wrStrm.OpenL(TheDb, _L("symbian_security"), _L("PolicyData"), 1));
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&wrStrm);
TRAP(err, TSqlBlob::SetL(TheDb, _L("symbian_security"), _L("PolicyData"), _L8("VVVV"), 1));
TEST2(err, KErrPermissionDenied);
TheDb.Close();
}
static void DeleteTestFiles()
{
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
}
void TestEnvDestroy()
{
TheDbC.Close();
(void)RSqlDatabase::Delete(TheDbFileName);
TheFs.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4097
@SYMTestCaseDesc Testing incremental blob reads and writes on a secure database.
The test application's capabilities allow read and write access to the blobs.
Verify that both reads and writes are allowed.
@SYMTestPriority Medium
@SYMTestActions Testing incremental blob reads and writes on a secure database.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5794
*/
void ReadWriteBlobTestL()
{
// Current database data:
// TABLE A: {1, x'41414141414141414141'}, {2, x'42424242424242424242'}, {3, x'43434343434343434343'}, {4, x'44444444444444444444'}
// TABLE B: {4, "DEF", x'46464646464646464646'} <- ROWID = 2, {2, "ABC", x'45454545454545454545'} <- ROWID = 3, {6, "GHI", x'47474747474747474747'} <- ROWID = 4
RSqlDatabase db;
TInt err = TheDb.Open(KTestDbName);
TEST2(err, KErrNone);
// Attempt to read the blobs in tables A and B
RSqlBlobReadStream rdStrm;
CleanupClosePushL(rdStrm);
TBuf8<20> data;
TRAP(err, rdStrm.OpenL(TheDb, _L("A"), _L("B1"), 1));
TEST2(err, KErrNone);
TRAP(err, rdStrm.ReadL(data, 3));
TEST2(err, KErrNone);
TEST(data.Compare(_L8("AAA")) == 0);
rdStrm.Close();
TRAP(err, rdStrm.OpenL(TheDb, _L("B"), _L("B2"), 3));
TEST2(err, KErrNone);
TRAP(err, rdStrm.ReadL(data, 10));
TEST2(err, KErrNone);
TEST(data.Compare(_L8("EEEEEEEEEE")) == 0);
CleanupStack::PopAndDestroy(&rdStrm);
HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb, _L("A"), _L("B1"), 4);
TEST(wholeBuf->Des().Compare(_L8("DDDDDDDDDD")) == 0);
CleanupStack::PopAndDestroy(wholeBuf);
wholeBuf = TSqlBlob::GetLC(TheDb, _L("B"), _L("B2"), 2);
TEST(wholeBuf->Des().Compare(_L8("FFFFFFFFFF")) == 0);
CleanupStack::PopAndDestroy(wholeBuf);
HBufC8* buf = HBufC8::NewLC(10);
TPtr8 bufPtr(buf->Des());
err = TSqlBlob::Get(TheDb, _L("A"), _L("B1"), bufPtr, 2);
TEST2(err, KErrNone);
TEST(bufPtr.Compare(_L8("BBBBBBBBBB")) == 0);
err = TSqlBlob::Get(TheDb, _L("B"), _L("B2"), bufPtr, 4);
TEST2(err, KErrNone);
TEST(bufPtr.Compare(_L8("GGGGGGGGGG")) == 0);
CleanupStack::PopAndDestroy(buf);
// Attempt to write the blobs in tables A and B
RSqlBlobWriteStream wrStrm;
CleanupClosePushL(wrStrm);
TRAP(err, wrStrm.OpenL(TheDb, _L("A"), _L("B1"), 1));
TEST2(err, KErrNone);
TRAP(err, wrStrm.WriteL(_L8("ZZZ")));
TEST2(err, KErrNone);
wrStrm.Close();
TRAP(err, wrStrm.OpenL(TheDb, _L("B"), _L("B2"), 2));
TEST2(err, KErrNone);
TRAP(err, wrStrm.WriteL(_L8("XXXXXXXXX")));
TEST2(err, KErrNone);
CleanupStack::PopAndDestroy(&wrStrm);
TRAP(err, TSqlBlob::SetL(TheDb, _L("A"), _L("B1"), _L8("UUUUUUUU"), 4));
TEST2(err, KErrNone);
TRAP(err, TSqlBlob::SetL(TheDb, _L("B"), _L("B2"), _L8("TT"), 2));
TEST2(err, KErrNone);
// SQLite and system tables
// Attempt to read from and write to the SQLite master table -
// reads should be permitted because read capability is enough for this,
// writes should not be permitted because schema capability is required for this
CleanupClosePushL(rdStrm);
TRAP(err, rdStrm.OpenL(TheDb, _L("sqlite_master"), _L("tbl_name"), 1)); // TEXT column
TEST2(err, KErrNone);
TRAP(err, rdStrm.ReadL(data, 1));
TEST2(err, KErrNone);
CleanupStack::PopAndDestroy(&rdStrm);
wholeBuf = TSqlBlob::GetLC(TheDb, _L("sqlite_master"), _L("tbl_name"), 1);
TEST(wholeBuf->Length() > 0);
CleanupStack::PopAndDestroy(wholeBuf);
buf = HBufC8::NewLC(100);
bufPtr.Set(buf->Des());
err = TSqlBlob::Get(TheDb, _L("sqlite_master"), _L("tbl_name"), bufPtr, 1);
TEST2(err, KErrNone);
TEST(bufPtr.Length() > 0);
CleanupStack::PopAndDestroy(buf);
CleanupClosePushL(wrStrm);
TRAP(err, wrStrm.OpenL(TheDb, _L("sqlite_master"), _L("tbl_name"), 1));
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&wrStrm);
TRAP(err, TSqlBlob::SetL(TheDb, _L("sqlite_master"), _L("tbl_name"), _L8("VVVV"), 1));
TEST2(err, KErrPermissionDenied);
// Attempt to read from and write to the system tables - neither reads nor writes should be permitted
CleanupClosePushL(rdStrm);
TRAP(err, rdStrm.OpenL(TheDb, _L("symbian_security"), _L("PolicyData"), 1)); // BLOB column
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&rdStrm);
TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb, _L("symbian_security"), _L("PolicyData"), 1));
TEST2(err, KErrPermissionDenied);
buf = HBufC8::NewLC(100);
bufPtr.Set(buf->Des());
err = TSqlBlob::Get(TheDb, _L("symbian_security"), _L("PolicyData"), bufPtr, 1);
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(buf);
CleanupClosePushL(wrStrm);
TRAP(err, wrStrm.OpenL(TheDb, _L("symbian_security"), _L("PolicyData"), 1));
TEST2(err, KErrPermissionDenied);
CleanupStack::PopAndDestroy(&wrStrm);
TRAP(err, TSqlBlob::SetL(TheDb, _L("symbian_security"), _L("PolicyData"), _L8("VVVV"), 1));
TEST2(err, KErrPermissionDenied);
TheDb.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3437
@SYMTestCaseDesc Test for DEF105928 "SQL server ignores config string parameters".
The test attempts to create/open a database using invalid configuration strings,
too long configuration string, string with missing parameter values, string with
invalid database encodings. The test expects the SQL server will report a failure
and will refuse to execute the operation.
@SYMTestPriority High
@SYMTestActions Test for DEF105928 "SQL server ignores config string parameters".
@SYMTestExpectedResults The test must not fail
@SYMDEF DEF105928
*/
void CfgNegativeTest()
{
//Create a database. Spelling problem in the parameter name. This is not reported as an error by the SQL server
//(treated as unknown parameter)
_LIT8(KCfgStr1, "casche_size = 32");
TInt err = TheDb.Create(KTestDbName, &KCfgStr1);
TEST2(err, KErrNone);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Spelling problem in the parameter value.
_LIT8(KCfgStr2, "encoding = UTF-32");
err = TheDb.Create(KTestDbName, &KCfgStr2);
TEST2(err, KErrNone);//Invalid encoding: KErrNone, but the encoding will not be used
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Invalid config string.
_LIT8(KCfgStr3, "dfgjkdfgkdfk; sfkgjhdfgjkdfk; dfgdfetrwer");
err = TheDb.Create(KTestDbName, &KCfgStr3);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Too long and invalid config string.
_LIT8(KCfgStr4, "A123456789B123456789C123456789D123456789E123456789F123456789G123456789H123456789I123456789J123456789K123456789L123456789M123456789N123456789O123456789");
err = TheDb.Create(KTestDbName, &KCfgStr4);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. No parameter value - 1.
_LIT8(KCfgStr5, "page_size=");
err = TheDb.Create(KTestDbName, &KCfgStr5);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. No parameter value - 2.
_LIT8(KCfgStr6, "page_size=;");
err = TheDb.Create(KTestDbName, &KCfgStr6);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Non-number parameter value - 1.
_LIT8(KCfgStr7, "page_size=aaa;");
err = TheDb.Create(KTestDbName, &KCfgStr7);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Non-number parameter value - 2.
_LIT8(KCfgStr8, "cache_size=weyu34;");
err = TheDb.Create(KTestDbName, &KCfgStr8);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. "soft_heap_limit_kb" in the config string.
_LIT8(KCfgStr9, "soft_heap_limit_kb=512;");
err = TheDb.Create(KTestDbName, &KCfgStr9);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. "free_space_threshold_kb" in the config string.
_LIT8(KCfgStr10, "free_space_threshold_kb=256;");
err = TheDb.Create(KTestDbName, &KCfgStr10);
TEST2(err, KErrArgument);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-4060
@SYMTestCaseDesc Private database and compaction configuration test.
The test verifies that a private database can be created using auto, background or
manual compaction mode and that the compaction mode does not chage after reopening
the database.
The test also verifies that if the database is legacy, read-only, then the compaction
mode is auto.
The test also verifies that if the database is legacy, r/w, then the compaction
mode will be changed from auto to background.
@SYMTestPriority Medium
@SYMTestActions Private database and compaction configuration test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ10273
REQ10274
REQ10400
REQ10402
*/
void CompactConfigTest5L()
{
//Create a private test database with "auto" compaction mode
_LIT8(KConfigStr1, "encoding=utf-8;compaction=auto");
TInt err = TheDb.Create(KTestPrivDbName, &KConfigStr1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be "auto"
TSqlScalarFullSelectQuery scalarQuery(TheDb);
TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
TheDb.Close();
//Close and open the database again. The SQLite vacuum mode should be "auto".
err = TheDb.Open(KTestPrivDbName);
TEST2(err, KErrNone);
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
TheDb.Close();
//Close and open the database again with a config string with "background" compaction mode.
//The SQLite vacuum mode should stay unchanged.
_LIT8(KConfigStr2, "compaction=background");
err = TheDb.Open(KTestPrivDbName, &KConfigStr2);
TEST2(err, KErrNone);
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
TheDb.Close();
//Delete database
err = RSqlDatabase::Delete(KTestPrivDbName);
TEST2(err, KErrNone);
//Create a private test database - no config string
err = TheDb.Create(KTestPrivDbName);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
//Close and open the database again. The SQLite vacuum mode should be KSqlDefaultVacuum.
err = TheDb.Open(KTestPrivDbName);
TEST2(err, KErrNone);
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
//Close and open the database again with a config string with "auto" compaction mode.
//The SQLite vacuum mode should stay unchanged.
err = TheDb.Open(KTestPrivDbName, &KConfigStr1);
TEST2(err, KErrNone);
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
//Delete database
err = RSqlDatabase::Delete(KTestPrivDbName);
TEST2(err, KErrNone);
//Open an existing private database that is read-only (on drive Z:)
err = TheDb.Open(KTestPrivDbNameZ, &KConfigStr1);
TEST2(err, KErrNone);
//Check the vacuum mode. The SQLite compact mode should be "auto" (this is an old database (pre-"background compact" era))
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KAutoVacuum);
TheDb.Close();
//Open the same database after copying it to drive C: (r/w private database). The compaction mode should change from auto to background.
RFs fs;
err = fs.Connect();
TEST2(err, KErrNone);
CFileMan* fm = CFileMan::NewL(fs);
TEST(fm != NULL);
err = fm->Copy(KTestPrivDbNameZ, KTestPrivDbNameC);
TEST2(err, KErrNone);
//"Copy" operation executed without errors. Now it is a time to turn off the read-only
//flag of the target file (which may be on if the source file is on a read-only drive)
err = fs.SetAtt(KTestPrivDbNameC, 0, KEntryAttReadOnly);
TEST2(err, KErrNone);
delete fm;
fs.Close();
err = TheDb.Open(KTestPrivDbNameC);
TEST2(err, KErrNone);
scalarQuery.SetDatabase(TheDb);
compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
TEST2(compact, KSqlDefaultVacuum);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestPrivDbNameC);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1613
@SYMTestCaseDesc Multiple connections to the same database from different threads.
Each thread inserts set of record to the same table. Verify that all expected records
and their column values meet the expectations.
@SYMTestPriority High
@SYMTestActions Testing SQL engine behaviour when having mutiple connections to the same database
from different threads.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
REQ5793
*/
void TestMultiConnDiffThread()
{
//Create a test database
RDebug::Print(_L("+++:MainThread: Create test database\r\n"));
RSqlDatabase db;
TInt err = db.Create(KTestDbName1);
TEST2(err, KErrNone);
//Create a test table
RDebug::Print(_L("+++:MainThread: Create a table in the test database\r\n"));
_LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER PRIMARY KEY)");
err = db.Exec(KCreateSql);
TEST(err >= 0);
const TInt KThreadCnt = 4;
const TInt KRange = 100;
const TInt KIsolationLevelCnt = 2;
TPtrC KIsolationLevelName[KIsolationLevelCnt] = {_L("Read Uncommitted"), _L("Serializable")};
const RSqlDatabase::TIsolationLevel KIsolationLevels[KIsolationLevelCnt] = {
RSqlDatabase::EReadUncommitted, RSqlDatabase::ESerializable};
const TInt KTransTypeCnt = 2;
//Do the tests:
// - doing each per thread database operation in a single transaction;
// - doing all per thread database operations in a single transaction;
for(TInt transType=0;transType<KTransTypeCnt;++transType)
{
//For both supported isolation levels: read uncommitted and serializable
for(TInt isolLevel=0;isolLevel<KIsolationLevelCnt;++isolLevel)
{
TInt low = 1;
TInt high = KRange;
RDebug::Print(_L("+++:MainThread: Test: thread count %d, records %d, trans type %d, isolation level: %S\r\n"),
KThreadCnt, KRange, transType, &KIsolationLevelName[isolLevel]);
RThread thread[KThreadCnt];
TRequestStatus status[KThreadCnt];
TThreadData data[KThreadCnt];
//Create the test threads and run them. Each thread establishes a connection with the test database
//and attempts to write set of records in the test table.
TInt j;
for(j=0;j<KThreadCnt;++j,low=high+1,high+=KRange)
{
data[j].iTransType = transType;
data[j].iIsolationLevel = KIsolationLevels[isolLevel];
data[j].iLowRecNo = low;
data[j].iHighRecNo = high;
_LIT(KThreadName,"Thr-");
TBuf<32> threadName(KThreadName);
threadName.AppendNum((TInt64)j + 1);
TEST2(thread[j].Create(threadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&data[j], EOwnerThread), KErrNone);
thread[j].Logon(status[j]);
TEST2(status[j].Int(), KRequestPending);
thread[j].Resume();
}
User::After(2000000);
//Wait until threads finish the database operations and close them.
for(j=0;j<KThreadCnt;++j)
{
User::WaitForRequest(status[j]);
TEST(thread[j].ExitType() != EExitPanic);
thread[j].Close();
}
//Check that all records which are esupposed to be in the database, are there.
RDebug::Print(_L("+++:MainThread: Check that all records have been written\r\n"));
_LIT8(KSelectSql1, "SELECT COUNT(*) FROM A;");
RSqlStatement stmt;
err = stmt.Prepare(db, KSelectSql1);
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
TInt cnt = stmt.ColumnInt(0);
TEST2(cnt, KThreadCnt * KRange);
stmt.Close();
//Check that all records have expected column values.
RDebug::Print(_L("+++:MainThread: Check that all records have expected column values\r\n"));
_LIT8(KSelectSql2, "SELECT * FROM A;");
err = stmt.Prepare(db, KSelectSql2);
TEST2(err, KErrNone);
for(TInt k=0;k<(KThreadCnt*KRange);++k)
{
err = stmt.Next();
TEST2(err, KSqlAtRow);
TInt val = stmt.ColumnInt(0);
TEST(val > 0 && val <= (KThreadCnt * KRange));
}
stmt.Close();
//Prepare for the next test run - delete all records.
RDebug::Print(_L("+++:MainThread: Delete all records\r\n"));
_LIT8(KDeleteSql, "DELETE FROM A");
err = db.Exec(KDeleteSql);
TEST(err >= 0);
}//end of "for(TInt isolLevel=0;isolLevel<KIsolationLevelCnt;++isolLevel)"
}//end of "for(TInt transType=0;transType<KTransTypeCnt;++transType)"
db.Close();
RDebug::Print(_L("+++:MainThread: Delete the test database\r\n"));
(void)RSqlDatabase::Delete(KTestDbName1);
}
/**
@SYMTestCaseID PDS-SQL-UT-4151
@SYMTestCaseDesc Measures the performance of inserting multiple records
into the Music Player MPX database. This test is based on
a real Music Player Harvesting use case
@SYMTestPriority Medium
@SYMTestActions Reads SQL transactions from a file and executes them.
Records the time for executing each statement
@SYMTestExpectedResults All statements should be executed without error and
performance measurements logged
@SYMDEF DEF142306
*/
void RunTest()
{
//Open the file with the sql statements
_LIT(KSqlFileName,"z:\\test\\t_sqlperformance4.sql");
RFile sqlFile;
TInt err = sqlFile.Open(TheFs, KSqlFileName, EFileRead);
TEST2(err, KErrNone);
TInt fileLen = 0;
err = sqlFile.Size(fileLen);
TEST2(err, KErrNone);
HBufC8* sqlBuf = HBufC8::New(fileLen);
TEST(sqlBuf != NULL);
TPtr8 sql = sqlBuf->Des();
err = sqlFile.Read(sql);
sqlFile.Close();
TEST2(err, KErrNone);
TEST2(sql.Length(), fileLen);
//Open main database
err = TheDbC.Open(TheDbFileName, &TheSqlConfigString);
TEST2(err, KErrNone);
TheTest.Printf(_L("Beginning INSERTS...\n"));
const TInt KRecordCount = 6544;
TInt recordCount = 0;
TInt insertCnt = 0;
TInt updateCnt = 0;
TInt selectCnt = 0;
TInt trnCnt = 0;
TInt totalTime = 0;
TInt insertTrnCnt = 0;
TInt updateTrnCnt = 0;
TInt selectTrnCnt = 0;
for(;sql.Length()>0;)
{
TInt eolPos = sql.Locate(TChar('\n'));
if(eolPos < 0)
{
break;//No more SQL statements
}
TInt stmtLength = eolPos;
while (stmtLength > 0 && (sql[stmtLength-1] == '\r'))
{
--stmtLength; //Reduce length to remove carriage return characters from the end of the statement string
}
TPtrC8 sqlStmt8(sql.Ptr(), stmtLength);
TPtrC8 ptr = sql.Mid(eolPos + 1);//"eolPos + 1" - first character after '\n'
sql.Set(const_cast <TUint8*> (ptr.Ptr()), ptr.Length(), ptr.Length());
++recordCount;
//Convert to 16 bit query string
TBuf<1024> query;
query.Copy(sqlStmt8);
//Execute the statement
TInt start = User::FastCounter();
err = TheDbC.Exec(query);
TInt end = User::FastCounter();
TEST(err >= 0);
//Get the execution time for that statement
TInt duration = GetDuration(start, end);
totalTime += duration;
if(query == KBeginTransaction)
{
TheTest.Printf(_L("Execute Statement - BEGIN: %d us\n"), duration);
}
else if(query == KCommitTransaction)
{
++trnCnt;
TheTest.Printf(_L("Execute Statement - COMMIT: %d us, Trn#%d, \"INSERT\" count: %d, \"UPDATE\" count: %d, \"SELECT\" count: %d\n"),
duration, trnCnt, insertTrnCnt, updateTrnCnt, selectTrnCnt);
insertTrnCnt = updateTrnCnt = selectTrnCnt = 0;
}
else
{
TPtrC queryType(query.Ptr(), 6);
TheTest.Printf(_L("Execute Statement - %S: %d us\n"),&queryType, duration);
if(queryType.FindF(_L("INSERT")) >= 0)
{
++insertCnt;
++insertTrnCnt;
}
else if(queryType.FindF(_L("UPDATE")) >= 0)
{
++updateCnt;
++updateTrnCnt;
}
else if(queryType.FindF(_L("SELECT")) >= 0)
{
++selectCnt;
++selectTrnCnt;
}
}
}
delete sqlBuf;
TheDbC.Close();
TheTest.Printf(_L("Total time to process Songs: %d us\n"), totalTime);
TheTest.Printf(_L("Transactions count: %d, \"INSERT\" count: %d, \"UPDATE\" count: %d, \"SELECT\" count: %d\n"),
trnCnt, insertCnt, updateCnt, selectCnt);
TEST2(recordCount, KRecordCount);
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1614
@SYMTestCaseDesc Verifying that when having 2 database connections in different threads, both set
the isolation level to "Read Uncommitted", the reading thread can make "dirty read"
operations (can read the updated but not committed yet record values made by the
writing thread).
@SYMTestPriority High
@SYMTestActions Testing "Read Uncommitted" database isolation level.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
REQ5793
*/
void TestIsolationLevel()
{
RDebug::Print(_L("+++:MainThread: Create critical sections\r\n"));
TEST2(UpdateThreadCrS.CreateLocal(), KErrNone);
UpdateThreadCrS.Wait();
TEST2(MainThreadCrS.CreateLocal(), KErrNone);
MainThreadCrS.Wait();
RDebug::Print(_L("+++:MainThread: Create test database\r\n"));
RSqlDatabase db;
TInt err = db.Create(KTestDbName1);
TEST2(err, KErrNone);
RDebug::Print(_L("+++:MainThread: Set the isolation level to \"Read uncommitted\"\r\n"));
err = db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);
TEST2(err, KErrNone);
RDebug::Print(_L("+++:MainThread: Create a table in the test database\r\n"));
_LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER)");
err = db.Exec(KCreateSql);
TEST(err >= 0);
RDebug::Print(_L("+++:MainThread: Insert one record in the table\r\n"));
_LIT8(KInsertSql, "INSERT INTO A(Id) VALUES(");
TBuf8<64> sql(KInsertSql);
sql.AppendNum((TInt64)KInitialValue);
sql.Append(_L(")"));
err = db.Exec(sql);
TEST2(err, 1);
RDebug::Print(_L("+++:MainThread: Create the \"update\" thread\r\n"));
_LIT(KThreadName, "UpdTh");
RThread thread;
TEST2(thread.Create(KThreadName, &UpdateThreadFunc, 0x2000, 0x1000, 0x10000, NULL, EOwnerThread), KErrNone);
TRequestStatus status;
thread.Logon(status);
TEST2(status.Int(), KRequestPending);
thread.Resume();
RDebug::Print(_L("+++:MainThread: Wait for record update completion...\r\n"));
MainThreadCrS.Wait();
RDebug::Print(_L("+++:MainThread: Read the record and check the data...\r\n"));
_LIT8(KSelectSql, "SELECT * FROM A");
RSqlStatement stmt;
err = stmt.Prepare(db, KSelectSql);
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
TInt val = stmt.ColumnInt(0);
TEST(val == KUpdatedValue);
stmt.Close();
RDebug::Print(_L("+++:MainThread: Notify the update thread that it can rollback\r\n"));
UpdateThreadCrS.Signal();
RDebug::Print(_L("+++:MainThread: Wait for rollback completion...\r\n"));
MainThreadCrS.Wait();
RDebug::Print(_L("+++:MainThread: Read the record and check the data...\r\n"));
err = stmt.Prepare(db, KSelectSql);
TEST2(err, KErrNone);
err = stmt.Next();
TEST2(err, KSqlAtRow);
val = stmt.ColumnInt(0);
TEST2(val, KInitialValue);
stmt.Close();
User::WaitForRequest(status);
thread.Close();
db.Close();
RDebug::Print(_L("+++:MainThread: Delete the test database\r\n"));
(void)RSqlDatabase::Delete(KTestDbName1);
RDebug::Print(_L("+++:MainThread: Close critical sections\r\n"));
MainThreadCrS.Close();
UpdateThreadCrS.Close();
}
/**
@SYMTestCaseID SYSLIB-SQL-UT-3436
@SYMTestCaseDesc Test for DEF105928 "SQL server ignores config string parameters".
The test attempts to create/open a database using different cache size/page size/
database encoding configurations and then checks that the configuration parameters
have been set properly and have the expected values.
@SYMTestPriority High
@SYMTestActions Test for DEF105928 "SQL server ignores config string parameters".
@SYMTestExpectedResults The test must not fail
@SYMDEF DEF105928
*/
void CfgFunctionalTest()
{
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. No config string. The default config parameters will be used.
TInt err = TheDb.Create(KTestDbName);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Cache size set.
_LIT8(KCfgStr1, "cache_size=32");
err = TheDb.Create(KTestDbName, &KCfgStr1);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 32, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Page size set.
_LIT8(KCfgStr2, "page_size=2048");
err = TheDb.Create(KTestDbName, &KCfgStr2);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, (TSqlSrvConfigParams::KDefaultSoftHeapLimitKb * 1024) / 2048, 2048, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Cache & Page size set.
_LIT8(KCfgStr3, "cache_size=256;page_size=4096");
err = TheDb.Create(KTestDbName, &KCfgStr3);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 256, 4096, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Cache size & Page size & db encoding set.
_LIT8(KCfgStr4, "cache_size=512;page_size=512;encoding=UTF-8");
err = TheDb.Create(KTestDbName, &KCfgStr4);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 512, 512, TSqlSrvConfigParams::EEncUtf8);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Cache size & Page size & db encoding set.
_LIT8(KCfgStr5, "cache_size=16;page_size=1024;encoding=UTF-16");
err = TheDb.Create(KTestDbName, &KCfgStr5);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 16, 1024, TSqlSrvConfigParams::EEncUtf16);
TheDb.Close();
//Open the database. Cache size set. The rest of parameter values must be the same as for KCfgStr5.
_LIT8(KCfgStr6, "cache_size=80");
err = TheDb.Open(KTestDbName, &KCfgStr6);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, 80, 1024, TSqlSrvConfigParams::EEncUtf16);
TheDb.Close();
//Open the database. Attempt to set the page size (impossible when opening a database).
_LIT8(KCfgStr7, "page_size=2048");
err = TheDb.Open(KTestDbName, &KCfgStr7);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, KDefaultCacheSize, 1024, TSqlSrvConfigParams::EEncUtf16);
TheDb.Close();
//Open the database. Attempt to set the encoding (impossible when opening a database).
_LIT8(KCfgStr8, "encoding=UTF-8");
err = TheDb.Open(KTestDbName, &KCfgStr8);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, KDefaultCacheSize, 1024, TSqlSrvConfigParams::EEncUtf16);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Empty config string - 1
_LIT8(KCfgStr9, "");
err = TheDb.Create(KTestDbName, &KCfgStr9);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Empty config string - 2
_LIT8(KCfgStr10, " ");
err = TheDb.Create(KTestDbName, &KCfgStr10);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
//Create a database. Empty config string - 3
_LIT8(KCfgStr11, " ; ; ;; ");
err = TheDb.Create(KTestDbName, &KCfgStr11);
TEST2(err, KErrNone);
AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);
TheDb.Close();
(void)RSqlDatabase::Delete(KTestDbName);
}