diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/sql/TEST/t_sqldbconfigfile.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqldbconfigfile.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1340 @@ +// Copyright (c) 2008-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: +// +// Description: +// + +#include +#include +#include +#include +#include +#include "sqlite3.h" +#include "SqliteSymbian.h" +#include "SqlResourceTester.h" + +//In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, +//when _SQLPROFILER macro is defined) +#ifdef _SQLPROFILER +TInt TheSqlSrvProfilerFileRead = 0; +TInt TheSqlSrvProfilerFileWrite = 0; +TInt TheSqlSrvProfilerFileSync = 0; +TInt TheSqlSrvProfilerFileSetSize = 0; +#endif + +///////////////////////////////////////////////////////////////////////////////////////////////// +/// This test works only if the whole SQL component is built with SYSLIBS_TEST macro defined! /// +///////////////////////////////////////////////////////////////////////////////////////////////// + +RTest TheTest(_L("t_sqldbconfigfile test")); + +#ifdef SYSLIBS_TEST + +extern TBool IsStatementSupported(const TDesC& aStatementIn, const TDesC& aDbName, TDes& aStatementOut); + +RFs TheFs; +RSqlDatabase TheDb; +sqlite3 *TheDbHandle = NULL; + +_LIT(KCfgDb1, "c:[1111C1C1]a.db"); // shared, secure db +_LIT(KCfgDb2, "c:[1111C1C1]b.db"); // shared, secure db (no config file for it) +_LIT(KCfgDb3, "c:\\private\\1111C1C1\\c.db"); // private, secure db +_LIT(KCfgDb4, "c:\\test\\d.db"); // public db +_LIT(KCfgDb5, "c:[1111C1C1]e.db"); // shared, secure db (config file created before db is created) + +_LIT(KCfgDb1ConfigFilePath, "c:\\private\\10281e17\\cfg[1111C1C1]a.db.0%d"); // config file version %d for a.db +_LIT(KCfgDb3ConfigFileV01Path, "c:\\private\\10281e17\\cfgc.db.01"); // config file v01 for c.db (unsupported) +_LIT(KCfgDb4ConfigFileV01Path, "c:\\private\\10281e17\\cfgd.db.01"); // config file v01 for d.db (unsupported) +_LIT(KCfgDb5ConfigFileV01Path, "c:\\private\\10281e17\\cfg[1111C1C1]e.db.01"); // config file v01 for e.db +_LIT(KCfgDb1CorruptConfigFilePath, "c:\\private\\10281e17\\cfg[1111C1C1]a.db.invalidextension"); // invalid config file name syntax + +// config file valid contents (used for v02 and others) +_LIT8(KCfgConfigFileValidStmt, "CREATE INDEX newIdx ON table1(i3) ;"); +// config file v03 empty contents +_LIT8(KCfgDb1ConfigFileV03EmptyStmt, ""); +// config file v04 unsupported contents +_LIT8(KCfgDb1ConfigFileV04UnsupportedStmt, "DELETE FROM table1"); +// config file v05 only whitespace contents +_LIT8(KCfgDb1ConfigFileV05OnlyWhitespaceStmt, " \r\n \r\n"); +// config file v06 invalid schema contents +_LIT8(KCfgDb1ConfigFileV06InvalidSchemaStmt, "CREATE INDEX thisIdx ON table999(i3)"); +// config file v07 unsupported comment style +_LIT8(KCfgDb1ConfigFileV07InvalidCommentedStmt, "CREATE INDEX ind1 ON table1(i2) // create an index"); +// config file v08 sequence of different statements +_LIT8(KCfgDb1ConfigFileV08SeqStmt, "; CREATE INDEX IdxFirst ON table1(i3)\r\n; DELETE FROM table1;INSERT INTO table1 (i1,i2,i3) values(6,7,8);;CREATE INDEX IdxSecond ON table1(i1);"); +// config file v09 whitespace before and after statement +_LIT8(KCfgDb1ConfigFileV09WhitespacePreAndPostStmt, " CREATE INDEX intIdx ON table1(i1) "); +// config file v10 valid contents +_LIT8(KCfgDb1ConfigFileV10ValidStmt, "CREATE INDEX i3Index ON table1(i3)\n"); +// config file v11 valid contents (also tests that any amount spaces and tabs are allowed between 'CREATE' and 'INDEX') +_LIT8(KCfgDb1ConfigFileV11ValidStmt, "CREATE INDEX i1Index ON table1(i1);\nCREATE INDEX i2Index ON table1(i2)"); +// config file v12 invalid stmt plus valid stmt +_LIT8(KCfgDb1ConfigFileV12InvalidPlusValidStmt, "CREATE UNIQUE INDEX uniqueIdx ON table1(i1);CREATE INDEX v12Idx ON table1(i2)"); +// config file v13 supported SQL comment style +_LIT8(KCfgDb1ConfigFileV13SQLCommentStmt, "CREATE INDEX v13Idx ON table1(i1) -- this is an SQL comment"); +// config file v14 supported 'C' comment style +_LIT8(KCfgDb1ConfigFileV14CCommentStmt, "CREATE INDEX v14Idx ON table1(i3) /* this is a C comment */;"); + +//KLongDbName1 is "long" enough to allow "-journal" to be added at the end. +//Also, on simulators/emulators the file names have a prefix with length of about 30 characters +//(something like \epoc\winscw\c\....) +_LIT(KLongDbName1, "c:[1111C1C1]a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a.db"); +_LIT(KLongCfgName1, "c:\\private\\10281e17\\cfg[1111C1C1]a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a.db.01"); + +_LIT(KSqlSrvPrivatePath, "\\private\\10281e17\\"); +_LIT(KResetCollationDllSql, "UPDATE symbian_settings SET CollationDllName='hjagafsff'"); + +_LIT(KAttachDb1, "Db1"); +_LIT(KAttachDb2, "Db2"); +_LIT(KAttachDb5, "Db5"); + +/////////////////////////////////////////////////////////////////////////////////////// +// Destroy functions + +void KillSqlServer() + { + _LIT(KSqlSrvName, "sqlsrv.exe"); + TFullName name; + //RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName); + TBuf<64> pattern(KSqlSrvName); + TInt length = pattern.Length(); + pattern += _L("*"); + TFindProcess procFinder(pattern); + + while (procFinder.Next(name) == KErrNone) + { + if (name.Length() > length) + {//If found name is a string containing aProcessName string. + TChar c(name[length]); + if (c.IsAlphaDigit() || + c == TChar('_') || + c == TChar('-')) + { + // If the found name is other valid application name + // starting with aProcessName string. + //RDebug::Print(_L(":: Process name: \"%S\".\n"), &name); + continue; + } + } + RProcess proc; + if (proc.Open(name) == KErrNone) + { + proc.Kill(0); + //RDebug::Print(_L("\"%S\" process killed.\n"), &name); + } + proc.Close(); + } + } + +void DeleteCfgFilesAndDbs() + { + (void)RSqlDatabase::Delete(KLongDbName1); + (void)RSqlDatabase::Delete(KCfgDb1); + (void)RSqlDatabase::Delete(KCfgDb2); + (void)RSqlDatabase::Delete(KCfgDb3); + (void)RSqlDatabase::Delete(KCfgDb4); + (void)RSqlDatabase::Delete(KCfgDb5); + (void)TheFs.Delete(KLongCfgName1); + (void)TheFs.Delete(KCfgDb3ConfigFileV01Path); + (void)TheFs.Delete(KCfgDb4ConfigFileV01Path); + (void)TheFs.Delete(KCfgDb5ConfigFileV01Path); + CFileMan* fileMan = 0; + TRAPD(err, fileMan = CFileMan::NewL(TheFs)); + if(KErrNone == err) + { + (void)fileMan->Delete(_L("c:\\private\\10281e17\\cfg[1111C1C1]a.db.*")); + delete fileMan; + } + } + +void DestroyTestEnv() + { + if(TheDbHandle) + { + sqlite3_close(TheDbHandle); + TheDbHandle = NULL; + } + TheDb.Close(); + KillSqlServer(); + DeleteCfgFilesAndDbs(); + TheFs.Close(); + } + +/////////////////////////////////////////////////////////////////////////////////////// +// Test macros and functions + +void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + DestroyTestEnv(); + TheTest(EFalse, aLine); + } + } +void Check(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + DestroyTestEnv(); + TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + TheTest(EFalse, aLine); + } + } +#define TEST(arg) ::Check((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) + +// OOM test functions + +static TInt TheHandleCount1; +static TInt TheHandleCount2; +static TInt TheAllocatedCellsCount; + +void MarkHandles() + { + RThread().HandleCount(TheHandleCount1, TheHandleCount2); + } + +void CheckHandles() + { + TInt endHandleCount1; + TInt endHandleCount2; + + RThread().HandleCount(endHandleCount1, endHandleCount2); + + TEST2(TheHandleCount1, endHandleCount1); + TEST2(TheHandleCount2, endHandleCount2); + } + +void MarkAllocatedCells() + { + TheAllocatedCellsCount = User::CountAllocCells(); + } + +void CheckAllocatedCells() + { + TInt allocatedCellsCount = User::CountAllocCells(); + TEST2(allocatedCellsCount, TheAllocatedCellsCount); + } + +/////////////////////////////////////////////////////////////////////////////////////// +// Set up functions + +RSqlSecurityPolicy CreateSecurityPolicy() + { + const TSecurityPolicy KDefaultPolicy(TSecurityPolicy::EAlwaysPass); + RSqlSecurityPolicy policy; + TInt err = policy.Create(KDefaultPolicy); + TEST2(err, KErrNone); + err = policy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KDefaultPolicy); + TEST2(err, KErrNone); + err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KDefaultPolicy); + TEST2(err, KErrNone); + err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, KDefaultPolicy); + TEST2(err, KErrNone); + return policy; + } + +void DoCreateCfgFile(const TDesC& aFileName, const TDesC8& aData) + { + RFile file; + TInt err = file.Create(TheFs, aFileName, EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Write(aData); + file.Close(); + TEST2(err, KErrNone); + } + +// Create v01 of the test config files +void CreateCfgFiles() + { + TFileName fileName; + TInt v1 = 1; + fileName.Format(KCfgDb1ConfigFilePath, v1); + + // config file v01 contents for db1 (also tests that upper and lower case statements are both supported) + _LIT8(KCfgDb1ConfigFile01Stmts, "CREATE INDEX idx ON table1(i1);CREATE INDEX idx2 ON table1(i2);INSERT INTO table1 (i1,i2,i3) values(5,8,9);DELETE FROM table1;create index multiidx ON TABLE1(i2,i3)"); + DoCreateCfgFile(fileName, KCfgDb1ConfigFile01Stmts); + + // config file v01 contents for db3 (will not be processed as db3 is not a shared, secure db) + _LIT8(KCfgDb3ConfigFile01Stmts, "CREATE INDEX idx ON table3(i1)"); + DoCreateCfgFile(KCfgDb3ConfigFileV01Path, KCfgDb3ConfigFile01Stmts); + + // config file v01 contents for db4 (will not be processed as db4 is not a shared, secure db) + _LIT8(KCfgDb4ConfigFile01Stmts, "CREATE INDEX idx ON table4(i1)"); + DoCreateCfgFile(KCfgDb4ConfigFileV01Path, KCfgDb4ConfigFile01Stmts); + + // create the config file for Db5 before the database has been created + // config file v01 contents for db5 (will eventually be processed after db5 itself is created) + _LIT8(KCfgDb5ConfigFile01Stmts, "CREATE INDEX idx ON table5(i1);\r\n"); + DoCreateCfgFile(KCfgDb5ConfigFileV01Path, KCfgDb5ConfigFile01Stmts); + } + +void DoCreateCfgDb(const TDesC& aFileName, const TDesC& aCreateTblSql, const TDesC& aInsertSql, + RSqlSecurityPolicy* aPolicy = NULL) + { + TInt err = aPolicy ? TheDb.Create(aFileName, *aPolicy) : TheDb.Create(aFileName); + TEST2(err, KErrNone); + err = TheDb.Exec(aCreateTblSql); + TEST(err >= 0); + err = TheDb.Exec(aInsertSql); + TEST(err == 1); + TheDb.Close(); + } + +// Create the test databases +void CreateCfgDbs() + { + RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy(); + DoCreateCfgDb(KCfgDb1, _L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)"), + _L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)"), &securityPolicy); + DoCreateCfgDb(KCfgDb2, _L("CREATE TABLE table2(i1 INTEGER, i2 INTEGER, i3 INTEGER)"), + _L("INSERT INTO table2 (i1,i2,i3) values(4,5,6)"), &securityPolicy); + securityPolicy.Close(); + DoCreateCfgDb(KCfgDb3, _L("CREATE TABLE table3(i1 INTEGER, i2 INTEGER)"), + _L("INSERT INTO table3 (i1,i2) values(7,8)")); + DoCreateCfgDb(KCfgDb4, _L("CREATE TABLE table4(i1 INTEGER, i2 INTEGER, i3 INTEGER)"), + _L("INSERT INTO table4 (i1,i2,i3) values(9,10,11)")); + } + +void CreateCfgFilesAndDbs() + { + CreateCfgFiles(); + CreateCfgDbs(); + + // Must now kill the SQL Server so that the config files + // created above are found and processed when it restarts + KillSqlServer(); + } + +// Create the Db5 test database (a config file for it already exists) + void CreateDb5() + { + RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy(); + DoCreateCfgDb(KCfgDb5, _L("CREATE TABLE table5(i1 INTEGER, i2 INTEGER, i3 INTEGER)"), + _L("INSERT INTO table5 (i1,i2,i3) values(1,2,3)"), &securityPolicy); + securityPolicy.Close(); + } + +void SetupTestEnv() + { + TInt err = TheFs.Connect(); + TEST2(err, KErrNone); + + _LIT(KTestDir, "c:\\test\\"); + err = TheFs.MkDir(KTestDir); + TEST(err == KErrNone || err == KErrAlreadyExists); + + err = TheFs.CreatePrivatePath(EDriveC); + TEST(err == KErrNone || err == KErrAlreadyExists); + + // Create the cfg dbs and config files + DeleteCfgFilesAndDbs(); // just incase any previous files are lingering + CreateCfgFilesAndDbs(); + } + +/////////////////////////////////////////////////////////////////////////////////////// +// +TInt CalcTimeMs(TUint32 aStartTicks, TUint32 aEndTicks) + { + static TInt freq = 0; + if(freq == 0) + { + TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone); + } + TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks; + if(diffTicks < 0) + { + diffTicks = KMaxTUint32 + diffTicks + 1; + } + const TInt KMicroSecIn1Sec = 1000000; + TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq; + return us / 1000; + } + +/////////////////////////////////////////////////////////////////////////////////////// +// Config file replacement functions + +void UpgradeDbConfigFile(TInt aCurrentVersion) + { + TInt newVersion = aCurrentVersion + 1; + TEST(newVersion != 0 && newVersion != 1 && newVersion != 10 && newVersion != 11 && newVersion < 15); + + KillSqlServer(); + + TFileName fname; + fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion); + TInt err = TheFs.Delete(fname); + TEST2(err, KErrNone); + + if(newVersion == 12) + { + // also delete version 10 of file + fname.Format(KCfgDb1ConfigFilePath, 10); + err = TheFs.Delete(fname); + TEST2(err, KErrNone); + } + + const TPtrC8 stmts[] = {KNullDesC8(), KNullDesC8(), + KCfgConfigFileValidStmt(), + KCfgDb1ConfigFileV03EmptyStmt(), + KCfgDb1ConfigFileV04UnsupportedStmt(), + KCfgDb1ConfigFileV05OnlyWhitespaceStmt(), + KCfgDb1ConfigFileV06InvalidSchemaStmt(), + KCfgDb1ConfigFileV07InvalidCommentedStmt(), + KCfgDb1ConfigFileV08SeqStmt(), + KCfgDb1ConfigFileV09WhitespacePreAndPostStmt(), + KNullDesC8(), KNullDesC8(), + KCfgDb1ConfigFileV12InvalidPlusValidStmt(), + KCfgDb1ConfigFileV13SQLCommentStmt(), + KCfgDb1ConfigFileV14CCommentStmt()}; + + fname.Format(KCfgDb1ConfigFilePath, newVersion); + DoCreateCfgFile(fname, stmts[newVersion]); + } + +void DowngradeDbConfigFile(TInt aCurrentVersion) + { + TEST(aCurrentVersion > 1); + + KillSqlServer(); + + TFileName fname; + fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion); + TInt err = TheFs.Delete(fname); + TEST2(err, KErrNone); + + fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion - 1); + DoCreateCfgFile(fname, KCfgConfigFileValidStmt); + } + +void CreateCorruptDbConfigFile(TInt aCurrentVersion) + { + KillSqlServer(); + + TFileName fname; + fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion); + TInt err = TheFs.Delete(fname); + TEST2(err, KErrNone); + + DoCreateCfgFile(KCfgDb1CorruptConfigFilePath, KCfgConfigFileValidStmt); + } + +void CreateTwoVersionsOfConfigFile() + { + KillSqlServer(); + + TInt err = TheFs.Delete(KCfgDb1CorruptConfigFilePath); + TEST2(err, KErrNone); + + TInt nextVersion = 10; + TFileName fname; + fname.Format(KCfgDb1ConfigFilePath, nextVersion); + DoCreateCfgFile(fname, KCfgDb1ConfigFileV10ValidStmt); + + ++nextVersion; + fname.Format(KCfgDb1ConfigFilePath, nextVersion); + DoCreateCfgFile(fname, KCfgDb1ConfigFileV11ValidStmt); + } + +/////////////////////////////////////////////////////////////////////////////////////// +// DoDbCfgTests() functions + +TInt GetDbCfgVersion(const TDesC& aDbName) + { + // Note: We have to use SQLite directly to access the settings + // table as the SQL Server denies permission to access this table + // as it is in a shared, secure database + + TParse parse; + TInt err = parse.Set(aDbName, &KSqlSrvPrivatePath, 0); + TEST2(err, KErrNone); + + TBuf8 dbFileName; + dbFileName.Copy(parse.FullName()); + + sqlite3 *dbHandle = NULL; + TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle); + TEST2(rc, SQLITE_OK); + + _LIT(KGetDbCfgVersionSql, "SELECT Reserved AS DbCfgVersion FROM symbian_settings"); + TBuf<100> queryBuf; + queryBuf.Copy(KGetDbCfgVersionSql); + + sqlite3_stmt* stmtHandle = NULL; + const void* stmtTailZ = NULL; + rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ); + TEST2(rc, SQLITE_OK); + + rc = sqlite3_step(stmtHandle); + TEST2(rc, SQLITE_ROW); + + TInt version = sqlite3_column_int(stmtHandle, 0); + + rc = sqlite3_step(stmtHandle); + TEST2(rc, SQLITE_DONE); + + sqlite3_finalize(stmtHandle); + sqlite3_close(dbHandle); + + return version; + } + +TBool GuessSystemSettingsTable(const TDesC& aDbName, TInt aVersion) + { + TInt dbCfgVersion = GetDbCfgVersion(aDbName); + return dbCfgVersion == aVersion; + } + +void CheckSystemSettingsTable(const TDesC& aDbName, TInt aVersion) + { + TInt dbCfgVersion = GetDbCfgVersion(aDbName); + TEST2(dbCfgVersion, aVersion); + } + +void CheckRecordCount(const TDesC& aTable) + { + // There should always be only 1 record in the table + // in each database as INSERT and DELETE statements are + // not supported in the config files + TBuf<50> sql; + sql.Format(_L("SELECT COUNT(*) FROM %S"), &aTable); + TSqlScalarFullSelectQuery q(TheDb); + TInt count = 0; + TRAPD(err, count = q.SelectIntL(sql)); + TEST2(err, KErrNone); + TEST2(count, 1); + } + +TInt ExpectedDb1IndexCount(TInt aExpectedStoredVersion) + { + TEST(aExpectedStoredVersion >= 0 && aExpectedStoredVersion < 15); + const TInt KIdxCnt[] = { + -1, + 3, // Only files 01 - 04, 09 and 11 will be successfully processed and so stored in the settings table + 4, // 1 more index should be added to db1 based on config file 02 + 4, 4, 4, 4, 4, // no more indices should be added to db1 based on config file 03 - 07 + 6, // 2 more indices should be added to db1 based on config file 08 + 7, // 1 more index should be added to db1 based on config file 09 + -1, + 9, // 2 more indices should be added to db1 based on config file 11 + 10, // 1 more index should be added to db1 based on config file 12 + 11, // 1 more index should be added to db1 based on config file 13 + 12}; // 1 more index should be added to db1 based on config file 14 + return KIdxCnt[aExpectedStoredVersion]; + } + +void CheckIndexCount(TInt aExpectedIndexCount) + { + _LIT(KDbCheckNumIndices, "SELECT COUNT(*) FROM sqlite_master WHERE type = 'index'"); + TSqlScalarFullSelectQuery q(TheDb); + TInt count = 0; + TRAPD(err, count = q.SelectIntL(KDbCheckNumIndices)); + TEST2(err, KErrNone); + TEST2(count, aExpectedIndexCount); + } + +void DoCfgOpenTest(TInt aExpectedStoredVersion, const TDesC& aDbFileName, const TDesC& aTblName, TInt aExpectedIndexCnt) + { + TInt err = TheDb.Open(aDbFileName); + TEST2(err, KErrNone); + CheckRecordCount(aTblName); + CheckIndexCount(aExpectedIndexCnt); + TheDb.Close(); + // Check that the ops in the specified config file have been applied. + CheckSystemSettingsTable(aDbFileName, aExpectedStoredVersion); + } + +void DoCfgOpenTests(TInt aExpectedStoredVersion) + { + // Open a shared, secure database - config ops should be applied on it. + // There should still be only 1 record and 3 indices in the table. + TheTest.Printf(_L("===CfgOpen: Open shared, secure database\r\n")); + DoCfgOpenTest(aExpectedStoredVersion, KCfgDb1, _L("table1"), ExpectedDb1IndexCount(aExpectedStoredVersion)); + + // Open again the same shared, secure database - no config should occur (it has already been done). + TheTest.Printf(_L("===CfgOpen: Open shared, secure database again\r\n")); + DoCfgOpenTest(aExpectedStoredVersion, KCfgDb1, _L("table1"), ExpectedDb1IndexCount(aExpectedStoredVersion)); + + // Open a shared, secure database - no config should occur (there is no config file for this database) + TheTest.Printf(_L("===CfgOpen: Open shared, secure database (that has no config file)\r\n")); + DoCfgOpenTest(0, KCfgDb2, _L("table2"), 0); + + // Open a private, secure database - no config should occur + TheTest.Printf(_L("===CfgOpen: Open private, secure database\r\n")); + DoCfgOpenTest(0, KCfgDb3, _L("table3"), 0); + + // Open a public database - no config should occur + TheTest.Printf(_L("===CfgOpen: Open public database\r\n")); + DoCfgOpenTest(0, KCfgDb4, _L("table4"), 0); + } + +void DoUpgradedCfgOpenTest() + { + // Upgrade the config file for KCfgDb1, i.e. replace v1 file with v2 file + UpgradeDbConfigFile(1); + DoCfgOpenTests(2); + } + +void DoBadCfgOpenTests() + { + // Test an empty config file + UpgradeDbConfigFile(2); // the current file version is 02, replace it with 03 + DoCfgOpenTests(3); // version 03 will be successfully processed and stored in the settings table + + // Test a config file with unsupported operations (these will be ignored) + UpgradeDbConfigFile(3); // the current file version is 03, replace it with 04 + DoCfgOpenTests(4); // version 04 will be successfully processed (the unsupported operations are ignored) and stored in the settings table + + // Test a config file with only whitespace in it + UpgradeDbConfigFile(4); // the current file version is 04, replace it with 05 + DoCfgOpenTests(5); // version 05 will be successfully processed (the whitespace is ignored) and stored in the settings table + + // Test a config file with operations on an invalid table + UpgradeDbConfigFile(5); // the current file version is 05, replace it with 06 + DoCfgOpenTests(6); // version 06 will be successfully processed (the failed-to-execute operation will be ignored) and stored in the settings table + + // Test a config file that contains an invalid comment style + UpgradeDbConfigFile(6); // the current file version is 06, replace it with 07 + DoCfgOpenTests(7); // version 07 will be successfully processed (the line with invalid comment syntax will be ignored) and stored in the settings table + + // Test a config file that contains a sequence of statements as one statement (this is currently unsupported) + UpgradeDbConfigFile(7); // the current file version is 07, replace it with 08 + DoCfgOpenTests(8); // version 08 will be successfully processed (the line with a sequence of statements is ignored) and stored in the settings table + + // Test a config file that contains whitespace before and after the SQL statement + UpgradeDbConfigFile(8); // the current file version is 08, replace it with 09 + DoCfgOpenTests(9); // version 09 will be successfully processed and stored in the settings table + + // Test a config file that has a lower extension number + DowngradeDbConfigFile(9); // the current file version is 09, replace it with 08 + DoCfgOpenTests(9); // version 08 will NOT be processed (as it is a lower version than that stored), and 09 will remain stored in the settings table + + // Test a config file that has an invalid extension + CreateCorruptDbConfigFile(8); // the current file version is 08, replace it with a file with an invalid extension + DoCfgOpenTests(9); // the invalid file will NOT be processed, and 09 will remain stored in the settings table + + // Test two versions of the config file (two versions should not be present at the same time) + CreateTwoVersionsOfConfigFile(); // the current file has an invalid extension, delete it and create version 10 and version 11 + DoCfgOpenTests(11); // only version 11 will be processed (as it is the highest version), and 11 will be stored in the settings table + + // Test a config file that contains an invalid statement and a valid statement + UpgradeDbConfigFile(11); // the current file versions are 10 and 11, replace them with 12 + DoCfgOpenTests(12); // version 12 will be successfully processed (the invalid statement will be ignored and the valid statement executed) and stored in the settings table + + // Test a config file that contains a SQL style comment + UpgradeDbConfigFile(12); // the current file version is 12, replace it with 13 + DoCfgOpenTests(13); // version 13 will be successfully processed (the SQL style comment will be ignored) and stored in the settings table + + // Test a config file that contains a 'C' style comment + UpgradeDbConfigFile(13); // the current file version is 13, replace it with 14 + DoCfgOpenTests(14); // version 14 will be successfully processed (the 'C' style comment will be ignored) and stored in the settings table + } + +void DoNewDbCfgOpenTest() + { + // Create Db5 - a config file already exists for this database + CreateDb5(); + + // Open the shared, secure database Db5 - config ops should be applied on it. + // There should now be 1 index in the table. + TheTest.Printf(_L("===NewDbCfg: Open shared, secure database\r\n")); + DoCfgOpenTest(1, KCfgDb5, _L("table5"), 1); + + // Open again the same shared, secure database - no config should occur (it has already been done) + TheTest.Printf(_L("===NewDbCfg: Open shared, secure database again\r\n")); + DoCfgOpenTest(1, KCfgDb5, _L("table5"), 1); + } + +void DoCfgAttachTests(TInt aExpectedStoredVersion = 0) + { + // Open a private, secure database - no config should occur + TheTest.Printf(_L("===CfgAttach: Open private, secure database\r\n")); + TInt err = TheDb.Open(KCfgDb3); + TEST2(err, KErrNone); + // Attach a shared, secure database - the db1 config file should not be processed + TheTest.Printf(_L("===CfgAttach: Attach shared, secure database\r\n")); + err = TheDb.Attach(KCfgDb1, KAttachDb1); + TEST2(err, KErrNone); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb1, aExpectedStoredVersion); // check that the config file has not been processed for db1 + CheckSystemSettingsTable(KCfgDb3, 0); + + // Open a public database - no config should occur + TheTest.Printf(_L("===CfgAttach: Open public database\r\n")); + err = TheDb.Open(KCfgDb4); + TEST2(err, KErrNone); + // Attach a shared, secure database - no config should occur (there is no config file for this database) + TheTest.Printf(_L("===CfgAttach: Attach shared, secure database (that has no config file)\r\n")); + err = TheDb.Attach(KCfgDb2, KAttachDb2); + TEST2(err, KErrNone); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb2, 0); + CheckSystemSettingsTable(KCfgDb4, 0); + } + +void DoUpgradedCfgAttachTest() + { + // Upgrade the config file for KCfgDb1, i.e. replace v1 file with v2 file + UpgradeDbConfigFile(1); + DoCfgAttachTests(2); + } + +void DoBadCfgAttachTests() + { + // Test an empty config file + UpgradeDbConfigFile(2); // the current file version is 02, replace it with 03 + DoCfgAttachTests(3); // version 03 will not be processed so no update to settings table + + // Test a config file with unsupported operations + UpgradeDbConfigFile(3); // the current file version is 03, replace it with 04 + DoCfgAttachTests(4); // version 04 will not be processed so no update to settings table + + // Test a config file with only whitespace in it + UpgradeDbConfigFile(4); // the current file version is 04, replace it with 05 + DoCfgAttachTests(5); // version 05 will not be processed so no update to settings table + + // Test a config file with operations on an invalid table + UpgradeDbConfigFile(5); // the current file version is 05, replace it with 06 + DoCfgAttachTests(6); // version 06 will not be processed so no update to settings table + + // Test a config file that contains an invalid comment style + UpgradeDbConfigFile(6); // the current file version is 06, replace it with 07 + DoCfgAttachTests(7); // version 07 will not be processed so no update to settings table + + // Test a config file that contains a sequence of statements as one statement (this is currently unsupported) + UpgradeDbConfigFile(7); // the current file version is 07, replace it with 08 + DoCfgAttachTests(8); // version 08 will not be processed so no update to settings table + + // Test a config file that contains whitespace before and after the SQL statement + UpgradeDbConfigFile(8); // the current file version is 08, replace it with 09 + DoCfgAttachTests(9); // version 09 will not be processed so no update to settings table + + // Test a config file that has a lower extension number + DowngradeDbConfigFile(9); // the current file version is 09, replace it with 08 + DoCfgAttachTests(9); // version 08 will not be processed so no update to settings table + + // Test a config file that has an invalid extension + CreateCorruptDbConfigFile(8); // the current file version is 08, replace it with a file with an invalid extension + DoCfgAttachTests(9); // the invalid file will not be processed so no update to settings table + + // Test two versions of the config file (two versions should not be present at the same time) + CreateTwoVersionsOfConfigFile(); // the current file has an invalid extension, delete it and create version 10 and version 11 + DoCfgAttachTests(11); // neither version 10 or 11 will be processed so no update to settings table + + // Test a config file that contains an invalid statement and a valid statement + UpgradeDbConfigFile(11); // the current file versions are 10 and 11, replace them with 12 + DoCfgAttachTests(12); // version 12 will not be processed so no update to settings table + + // Test a config file that contains a SQL style comment + UpgradeDbConfigFile(12); // the current file version is 12, replace it with 13 + DoCfgAttachTests(13); // version 13 will not be processed so no update to settings table + + // Test a config file that contains a 'C' style comment + UpgradeDbConfigFile(13); // the current file version is 13, replace it with 14 + DoCfgAttachTests(14); // version 14 will not be processed so no update to settings table + } + +void DoNewDbCfgAttachTest() + { + // Create Db5 - a config file already exists for this + CreateDb5(); + + // Open a private, secure database - no config should occur + TheTest.Printf(_L("===NewDbCfgAttach: Open private, secure database\r\n")); + TInt err = TheDb.Open(KCfgDb3); + TEST2(err, KErrNone); + CheckRecordCount(_L("table3")); + CheckIndexCount(0); + + // Attach a shared, secure database - the db5 config file should not be processed + TheTest.Printf(_L("===NewDbCfgAttach: Attach shared, secure database\r\n")); + err = TheDb.Attach(KCfgDb5, KAttachDb5); + TEST2(err, KErrNone); + CheckRecordCount(_L("table5")); + CheckIndexCount(0); // there should still be no indices in the table + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb5, 1); // check that the config file has been processed for db1 + CheckSystemSettingsTable(KCfgDb3, 0); + } + +void ResetStoredCollationDll() + { + // Note: We have to use SQLite directly to access the settings + // table as the SQL Server denies permission to access this table + // as it is in a shared, secure database + + TParse parse; + parse.Set(KCfgDb1, &KSqlSrvPrivatePath, 0); + + TBuf8 dbFileName; + dbFileName.Copy(parse.FullName()); + + sqlite3 *dbHandle = NULL; + TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle); + TEST2(rc, SQLITE_OK); + + TBuf<100> queryBuf; + queryBuf.Append(KResetCollationDllSql()); + + sqlite3_stmt* stmtHandle = NULL; + const void* stmtTailZ = NULL; + rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ); + TEST2(rc, SQLITE_OK); + + rc = sqlite3_step(stmtHandle); + TEST2(rc, SQLITE_DONE); + + sqlite3_finalize(stmtHandle); + sqlite3_close(dbHandle); + } + +void CheckCollationDllUpdated() + { + // Note: We have to use SQLite directly to access the settings + // table as the SQL Server denies permission to access this table + // as it is in a shared, secure database + + TParse parse; + parse.Set(KCfgDb1, &KSqlSrvPrivatePath, 0); + + TBuf8 dbFileName; + dbFileName.Copy(parse.FullName()); + + sqlite3 *dbHandle = NULL; + TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle); + TEST2(rc, SQLITE_OK); + + _LIT(KGetCollationDllSql, "SELECT CollationDllName FROM symbian_settings"); + TBuf<100> queryBuf; + queryBuf.Append(KGetCollationDllSql()); + + sqlite3_stmt* stmtHandle = NULL; + const void* stmtTailZ = NULL; + rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ); + TEST2(rc, SQLITE_OK); + + rc = sqlite3_step(stmtHandle); + TEST2(rc, SQLITE_ROW); + + const TUint16* collationDllName = (const TUint16*)sqlite3_column_text16(stmtHandle, 0); + TInt collationDllNameLen = sqlite3_column_bytes(stmtHandle, 0) / sizeof(TUint16); + TPtrC ptr(collationDllName, collationDllNameLen); + + rc = sqlite3_step(stmtHandle); + TEST2(rc, SQLITE_DONE); + + sqlite3_finalize(stmtHandle); + sqlite3_close(dbHandle); + + _LIT(KTestCollationDllName, "hjagafsff");//The same as the used in KResetCollationDllSql statement + TEST(ptr != KTestCollationDllName); + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-4010 +@SYMTestCaseDesc New database configuration files feature - unit test. + The test opens several test databases, and the database configuration + file for one of the shared, secure databases is processed. This is + repeated for a variety of versions of the database configuration file, + both valid and invalid. The same tests are repeated for when attaching, + rather than opening, the test databases. The test also verifies that + reindexing occurs if necessary when a database is opened or attached, + regardless of whether or not database configuration is also required. + Finally, the test also verifies that a config file that exists before + the database itself is created will be processed when the database is + opened for the first time. +@SYMTestPriority High +@SYMTestActions New database configuration files feature - unit test. +@SYMTestExpectedResults The test must not fail +@SYMCR LMAN-79SJ7L +*/ +void DoDbCfgTests() + { + // Do 'open' tests for new db config file feature + DoCfgOpenTests(1); // open the test databases + DoUpgradedCfgOpenTest(); // upgrade the config file for db1 and reopen the test databases + DoBadCfgOpenTests(); // corrupt the config file for db1 (in a variety of ways) and reopen the test databases + DoNewDbCfgOpenTest(); // create a db for which a config file already exists and then open the db + + // Recreate the original dbs and config files + DeleteCfgFilesAndDbs(); + CreateCfgFilesAndDbs(); + + // Do 'attach' tests for new db config file feature + DoCfgAttachTests(1); // attach the test databases + DoUpgradedCfgAttachTest(); // upgrade the config file for db1 and reattach the test databases + DoBadCfgAttachTests(); // corrupt the config file for db1 (in a variety of ways) and reattach the test databases + DoNewDbCfgAttachTest(); // create a db for which a config file already exists and then attach the db + + // Recreate the original dbs and config files + DeleteCfgFilesAndDbs(); + CreateCfgFilesAndDbs(); + + // Do the test that causes both reindexing and db configuration to occur when db1 is opened + ResetStoredCollationDll(); + DoCfgOpenTests(1); + CheckCollationDllUpdated(); + + // Recreate the original dbs and config files + DeleteCfgFilesAndDbs(); + CreateCfgFilesAndDbs(); + + // Do the test that causes reindexing to occur when db1 is attached (no db configuration occurs for attach) + ResetStoredCollationDll(); + DoCfgAttachTests(1); + CheckCollationDllUpdated(); // db1's stored collation dll name should now match db3's (to which Db1 is attached) stored collation name + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-4013 +@SYMTestCaseDesc New database configuration files feature - OOM test. + The test opens a shared secure database for which there + exists a database configuration file that is to be processed. + The open call is executed within an OOM loop, which causes + an OOM error to occur at different stages of the open call. + The test verifies that OOM errors are handled correctly and + that on the final loop - when no OOM errors occur - the database is + successfully opened and the database configuration file is processed. +@SYMTestPriority High +@SYMTestActions New database configuration files feature - OOM test. +@SYMTestExpectedResults The test must not fail +@SYMCR LMAN-79SJ7L +*/ +void DoDbCfgOOMTests() + { + // Recreate the original dbs and config files + DeleteCfgFilesAndDbs(); + CreateCfgFilesAndDbs(); + + // The server is stopped at the end of CreateCfgFilesAndDbs(). + // Before the test loop below begins we attach Db1 so that the + // server starts up again and stores Db1's security policy in + // CSqlServer::iSecurityMap. Otherwise there will be unmatching + // allocated cells in the test below. Do not call Detach() before + // Close(). We 'attach' Db1 here rather than 'open' it because + // open is the API that we want to test in the while loop + TInt err = TheDb.Open(KCfgDb3); + TEST2(err, KErrNone); + err = TheDb.Attach(KCfgDb1, KAttachDb1); + TEST2(err, KErrNone); + TheDb.Close(); + + err = KErrNoMemory; + TInt failingAllocationNo = 0; + while(err == KErrNoMemory) + { + MarkHandles(); + MarkAllocatedCells(); + + __UHEAP_MARK; + + TheTest.Printf(_L("%d\r"), failingAllocationNo + 1); + + // Set failure rate + TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic, ++failingAllocationNo); + err = TheDb.Open(KCfgDb1); + if(err != KErrNoMemory) + { + TEST2(err, KErrNone); + TheDb.Close(); + if(GuessSystemSettingsTable(KCfgDb1, 0)) + { + err = KErrNoMemory; + } + } + + // Reset failure rate + TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0); + + TheDb.Close(); + + __UHEAP_MARKEND; + + CheckAllocatedCells(); + CheckHandles(); + } + TEST2(err, KErrNone); + TheTest.Printf(_L("\r\n")); + CheckSystemSettingsTable(KCfgDb1, 1); // check that the settings table has been updated with v01 of the config file + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-4014 +@SYMTestCaseDesc New database configuration files feature - File I/O failures test. + The test opens a shared secure database for which there + exists a database configuration file that is to be processed. + The open call is executed within a file I/O failure loop, which + causes a selection of file I/O errors to occur at different stages + of the open call. + The test verifies that file I/O errors are handled correctly and + that on the final loop - when no file I/O errors occur - the database + is successfully opened and the database configuration file is processed. + NOTE: This test also acts as the test case for defect DEF116688. +@SYMTestPriority High +@SYMTestActions New database configuration files feature - File I/O failures test. +@SYMTestExpectedResults The test must not fail +@SYMCR LMAN-79SJ7L +*/ +void DoDbCfgFileIOFailuresTests() + { + // Recreate the original dbs and config files + DeleteCfgFilesAndDbs(); + CreateCfgFilesAndDbs(); + + // The server is stopped at the end of CreateCfgFilesAndDbs(). + // Before the test loop below begins we start the server again + // by opening Db3) so that any server start up file i/o ops will + // succeed. We don't open Db1 here because opening Db1 is what + // we want to test in the while loop + TInt err = TheDb.Open(KCfgDb3); + TEST2(err, KErrNone); + TheDb.Close(); + + TBool isFinished = EFalse; + err = KErrNotFound; + TInt iter = 0; + TheTest.Printf(_L("Iteration\r\n")); + for(TInt cnt = 0; !isFinished; ++cnt) + { + for(TInt fsError = KErrNotFound; fsError >= KErrUnderflow; --fsError) // errors -1 to -10 will be generated + { + TheTest.Printf(_L("%d/%d \r"), ++iter, fsError); + (void)TheFs.SetErrorCondition(fsError, cnt); // set error code and how soon it is to occur + err = TheDb.Open(KCfgDb1); + (void)TheFs.SetErrorCondition(KErrNone); + TheDb.Close(); + if(err != KErrNone) + { + // An error has occured. We know that this means that the database + // configuration part of the open call wasn't reached (because the + // database configuration part returns KErrNone even if it fails). + // But check anyway that the database content is still the same as + // before, i.e. the settings table has not been updated + CheckSystemSettingsTable(KCfgDb1, 0); + } + else + { + // Either the database configuration file for Db1 has been successfully + // processed or it failed part-way through being processed (KErrNone is + // returned in this case too). + // If it was the former then the the settings table will have + // been updated to store v01 of the config file + if(GuessSystemSettingsTable(KCfgDb1, 1)) + { + isFinished = ETrue; + break; + } + } + } + } + TheTest.Printf(_L("\r\n")); + TEST2(err, KErrNone); + // Check that the database configuration was allowed to be successfully applied in one of the loops + CheckSystemSettingsTable(KCfgDb1, 1); // check that the settings table has been updated with v01 of the config file + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-4015 +@SYMTestCaseDesc New database configuration files feature - Performance test. + The test measures: + - the startup time of the SQL Server when 0 and 4 database + configuration files exist + - the time taken to open a shared, secure database when a + database configuration file does and does not exist for it + - the time taken to open a shared, secure database when a + database configuration file exists for it but it has already + been processed + - the time taken to attach a shared, secure database when a + database configuration file does and does not exist for it +@SYMTestPriority High +@SYMTestActions New database configuration files feature - Performance test. +@SYMTestExpectedResults The test must not fail +@SYMCR LMAN-79SJ7L +*/ +void DoDbCfgPerfTests() + { + // Recreate the original dbs + DeleteCfgFilesAndDbs(); + CreateCfgDbs(); + KillSqlServer(); + + // Measure the start up time of the server when + // there are no database configuration files to be cached. + // Open Db4 (public db): + // No reindexing required + // Database configuration is not considered + TUint32 start = User::FastCounter(); + TInt err = TheDb.Open(KCfgDb4); + TUint32 end = User::FastCounter(); + TEST2(err, KErrNone); + CheckRecordCount(_L("table4")); + CheckIndexCount(0); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb4, 0); + TInt ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Server startup (via Open call) - no database config files to cache: %d ms\r\n"), ms); + + // Measure the time to open Db1 when no database + // configuration file exists for it. + // Open Db1 (shared, secure db): + // No reindexing required + // Database configuration is considered but no config file is found + start = User::FastCounter(); + err = TheDb.Open(KCfgDb1); + end = User::FastCounter(); + TEST2(err, KErrNone); + CheckRecordCount(_L("table1")); + CheckIndexCount(0); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb1, 0); + ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Open shared, secure Db1 - no config file is found: %d ms\r\n"), ms); + + // Measure the time to attach Db1 (database configuration will not be considered). + // Attach Db1 (shared, secure db): + // No reindexing required + // Database configuration is not considered + TheDb.Open(KCfgDb3); + TEST2(err, KErrNone); + start = User::FastCounter(); + err = TheDb.Attach(KCfgDb1, KAttachDb1); + end = User::FastCounter(); + TEST2(err, KErrNone); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb3, 0); + CheckSystemSettingsTable(KCfgDb1, 0); + ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Attach shared, secure Db1 - database config is not considered: %d ms\r\n"), ms); + + // Create the 4 version 01 config files now + CreateCfgFiles(); + KillSqlServer(); // stop the server so that the files are found when it is restarted + + // Measure the start up time of the server when + // there are 4 database configuration files to be cached. + // Open Db4 (public db): + // No reindexing required + // Database configuration is not considered + start = User::FastCounter(); + err = TheDb.Open(KCfgDb4); + end = User::FastCounter(); + TEST2(err, KErrNone); + CheckRecordCount(_L("table4")); + CheckIndexCount(0); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb4, 0); + ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Server startup (via Open call) - 4 database config files to cache: %d ms\r\n"), ms); + + // Measure the time to open Db1 when a database + // configuration file exists for it. + // Open Db1 (shared, secure db): + // No reindexing required + // Database configuration is considered, a file is found and config is applied (3 indices are created) + start = User::FastCounter(); + err = TheDb.Open(KCfgDb1); + end = User::FastCounter(); + TEST2(err, KErrNone); + CheckRecordCount(_L("table1")); + CheckIndexCount(3); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb1, 1); + ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Open shared, secure Db1 - config file is found and applied: %d ms\r\n"), ms); + + // Measure the time to open Db1 when a database + // configuration file exists for it but is has already been processed. + // Open Db1 (shared, secure db): + // No reindexing required + // Database configuration is considered, a file is found but it has already been processed + start = User::FastCounter(); + err = TheDb.Open(KCfgDb1); + end = User::FastCounter(); + TEST2(err, KErrNone); + CheckRecordCount(_L("table1")); + CheckIndexCount(3); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb1, 1); + ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Open shared, secure Db1 - config file is found but already processed: %d ms\r\n"), ms); + + // Measure the time to attach Db1 (database configuration will not be considered). + // Attach Db1 (shared, secure db): + // No reindexing required + // Database configuration is not considered + TheDb.Open(KCfgDb3); + TEST2(err, KErrNone); + start = User::FastCounter(); + err = TheDb.Attach(KCfgDb1, KAttachDb1); + end = User::FastCounter(); + TEST2(err, KErrNone); + TheDb.Close(); + CheckSystemSettingsTable(KCfgDb3, 0); + CheckSystemSettingsTable(KCfgDb1, 1); + ms = CalcTimeMs(start, end); + TheTest.Printf(_L("Execution time: Attach shared, secure Db1 - database config is not considered: %d ms\r\n"), ms); + } + +void TestStatements() + { + _LIT(KDbName, "attachDb"); + TBuf<200> buf; + + // supported statements + TBool rc = IsStatementSupported(_L("CREATE INDEX idx ON tbl(ColA)"), KDbName, buf); + TEST(rc); + rc = IsStatementSupported(_L("CREATE INDEX IF NOT EXISTS idx ON tbl(ColA)"), KDbName, buf); + TEST(rc); + + // unsupported statements + rc = IsStatementSupported(_L("CREATE UNIQUE INDEX idx ON tbl(ColA)"), KDbName, buf); + TEST(!rc); + rc = IsStatementSupported(_L("CREATE idx ON tbl(ColA)"), KDbName, buf); + TEST(!rc); + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-4030 +@SYMTestCaseDesc Test IsStatementSupportedLC function. + This function checks either SQL statement from DB configuration file is supported or not. + In the case of supported statement, function allocates buffer and copies statement into that buffer. + Call IsStatementSupportedLC on several supported and unsupported SQL statements. +@SYMTestPriority High +@SYMTestActions Test IsStatementSupportedLC function. +@SYMTestExpectedResults The test must not fail +@SYMDEF DEF118058 +*/ +void DoIsStatementSupportedTests() + { + TestStatements(); + } + +void DoLongDbNameTest() + { + //Create the database + RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy(); + + TInt err = TheDb.Create(KLongDbName1, securityPolicy); + TEST2(err, KErrNone); + err = TheDb.Exec(_L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)")); + TEST(err >= 0); + err = TheDb.Exec(_L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)")); + TEST(err == 1); + TheDb.Close(); + //Kill the server (to reload config file names at the server startup) + KillSqlServer(); + /////////////////////////////////////////////////////////////////////// + TheTest.Printf(_L("Open a database with a long name\r\n")); + //Create cfg file + RFile file; + TFileName fileName; + err = file.Create(TheFs, KLongCfgName1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TPtrC8 pDb1((const TUint8*)KCfgConfigFileValidStmt().Ptr(), KCfgConfigFileValidStmt().Length()); + err = file.Write(pDb1); + file.Close(); + TEST2(err, KErrNone); + //Open the database + err = TheDb.Open(KLongDbName1); + TEST2(err, KErrNone); + CheckRecordCount(_L("table1")); + CheckIndexCount(1); // there should now be 1 index in the table + TheDb.Close(); + const TInt KVersion = 1; + CheckSystemSettingsTable(KLongDbName1, KVersion); // check that the ops in the specified config file have been applied + /////////////////////////////////////////////////////////////////////// + TheTest.Printf(_L("Attach a database with a long logical name\r\n")); + //Attached database test + //Recreate the database + (void)RSqlDatabase::Delete(KLongDbName1); + err = TheDb.Create(KLongDbName1, securityPolicy); + TEST2(err, KErrNone); + err = TheDb.Exec(_L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)")); + TEST(err >= 0); + err = TheDb.Exec(_L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)")); + TEST(err == 1); + TheDb.Close(); + //Kill the server (to reload config file names at the server startup) + KillSqlServer(); + //Open the main database + err = TheDb.Open(KCfgDb1); + securityPolicy.Close(); + TEST2(err, KErrNone); + //Attach a database with a very long logical name + TFileName attachDbName; + attachDbName.SetLength(KMaxFileName); + attachDbName.Fill(TChar('A')); + err = TheDb.Attach(KLongDbName1, attachDbName); + TEST2(err, KErrNone); + err = TheDb.Detach(attachDbName); + TEST2(err, KErrNone); + TheDb.Close(); + CheckSystemSettingsTable(KLongDbName1, KVersion); // check that the ops in the specified config file have been applied + //Cleanup + (void)RSqlDatabase::Delete(KLongDbName1); + } + +void DoTests() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4010 Database config files test")); + DoDbCfgTests(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4013 Database config files OOM test")); + DoDbCfgOOMTests(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4014 Database config files file I/O error simulation test")); + DoDbCfgFileIOFailuresTests(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4015 Database config files performance test")); + DoDbCfgPerfTests(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4030 Database config files - supported SQl statements test")); + DoIsStatementSupportedTests(); + + TheTest.Next(_L("'Long database name' tests")); + DoLongDbNameTest(); + } + +#endif //SYSLIBS_TEST + +TInt E32Main() + { + TheTest.Title(); + + CTrapCleanup* tc = CTrapCleanup::New(); + TheTest(tc != NULL); + + __UHEAP_MARK; + +#ifdef SYSLIBS_TEST + TheTest.Start(_L("Setting up the test environment")); + SetupTestEnv(); + sqlite3SymbianLibInit(); + DoTests(); + DestroyTestEnv(); + sqlite3SymbianLibFinalize(); + CloseSTDLIB(); + TheTest.End(); +#else + TheTest.Start(_L("This test works only if the whole SQL component is built with SYSLIBS_TEST macro defined!")); + TheTest.End(); +#endif + + __UHEAP_MARKEND; + + TheTest.Close(); + + delete tc; + + User::Heap().Check(); + return KErrNone; + }