1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqloom3.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,401 @@
1.4 +// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "t_sqloom.h"
1.20 +
1.21 +RTest TheTest(_L("t_sqloom3 test"));
1.22 +
1.23 +///////////////////////////////////////////////////////////////////////////////////////
1.24 +/////////////// RSqlDatabase OOM tests ////////////////////////////////
1.25 +///////////////////////////////////////////////////////////////////////////////////////
1.26 +
1.27 +/**
1.28 +@SYMTestCaseID SYSLIB-SQL-CT-1615, SYSLIB-SQL-CT-1639
1.29 +@SYMTestCaseDesc RSqlDatabase::Create() OOM test - secure and non-secure databases.
1.30 + Precondition: the database does not exist.
1.31 + The test calls RSqlDatabase::Create() while simulating OOM failures and checks
1.32 + that there are no memory and resource leaks.
1.33 + Note: It's possible for a database to be created even after memory allocation
1.34 + has failed. This is because SQLITE reuses some pages of the page cache which
1.35 + have been allocated but are curently not in use. This means it is necessary
1.36 + to delete the database and continue checking for memory and resource leaks
1.37 + even after a database has been created successfully.
1.38 +@SYMTestPriority High
1.39 +@SYMTestActions RSqlDatabase::Create() OOM test
1.40 +@SYMTestExpectedResults Test must not fail
1.41 +@SYMREQ REQ5792
1.42 + REQ5793
1.43 + REQ10271
1.44 + REQ10273
1.45 + REQ10274
1.46 +*/
1.47 +void DoCreateDatabaseOomTest(const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError, const TDesC8* aConfigStr = NULL)
1.48 + {
1.49 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1639 RSqlDatabase::Create() - OOM test"));
1.50 + RSqlSecurityPolicy securityPolicy;
1.51 + CreateTestSecurityPolicy(securityPolicy);
1.52 + enum TMethodType {ENonLeavingMethod, ELeavingMethod};
1.53 + const TMethodType KMethodType[] = {ENonLeavingMethod, ELeavingMethod};
1.54 + for(TInt j=0;j<sizeof(KMethodType)/sizeof(KMethodType[0]);++j)
1.55 + {
1.56 + for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
1.57 + {
1.58 + if(aExpectedError != KErrAlreadyExists)
1.59 + {
1.60 + (void)RSqlDatabase::Delete(aDbFileName);
1.61 + }
1.62 + TInt err = KErrNone;
1.63 + TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set maxAllocationNo times.
1.64 + TInt allocationNo = 0;
1.65 + TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoCreateDatabaseOomTestAllocLimitServer : KDoCreateDatabaseOomTestAllocLimitClient;
1.66 + while(allocationNo < maxAllocationNo)
1.67 + {
1.68 + MarkHandles();
1.69 + MarkAllocatedCells();
1.70 +
1.71 + __UHEAP_MARK;
1.72 +
1.73 + RSqlDatabase db;
1.74 +
1.75 + SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
1.76 +
1.77 + if(KMethodType[j] == ENonLeavingMethod)
1.78 + {
1.79 + err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy, aConfigStr) : db.Create(aDbFileName, aConfigStr);
1.80 + }
1.81 + else
1.82 + {
1.83 + TRAP(err, aDbType == ESecureDb ? db.CreateL(aDbFileName, securityPolicy, aConfigStr) : db.CreateL(aDbFileName, aConfigStr));
1.84 + }
1.85 +
1.86 + db.Close();
1.87 + if(err != KErrNoMemory)
1.88 + {
1.89 + TEST2(err, aExpectedError);
1.90 + }
1.91 + else
1.92 + {
1.93 + failingAllocationNo = allocationNo;
1.94 + }
1.95 +
1.96 + ResetDbHeapFailure(TheOomTestType[i]);
1.97 +
1.98 + if(err == KErrNone && aExpectedError != KErrAlreadyExists)
1.99 + {
1.100 + err = db.Delete(aDbFileName);
1.101 + TEST2(err, KErrNone);
1.102 + }
1.103 +
1.104 + __UHEAP_MARKEND;
1.105 +
1.106 + CheckAllocatedCells();
1.107 + CheckHandles();
1.108 + }
1.109 + TEST2(err, aExpectedError);
1.110 + PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);
1.111 + }
1.112 + }
1.113 + RSqlDatabase::Delete(aDbFileName);
1.114 + securityPolicy.Close();
1.115 + }
1.116 +
1.117 +//"RSqlDatabase::Open()" OOM test
1.118 +void OpenDatabaseL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
1.119 + {
1.120 + TInt err = aDb.Open(aDbFileName);
1.121 + User::LeaveIfError(err);
1.122 + }
1.123 +
1.124 +//"RSqlDatabase::Exec()" OOM test (8-bit SQL statements), syntax error
1.125 +void ExecBadStatement8L(RSqlDatabase& aDb, const TDesC&, TDbType)
1.126 + {
1.127 + _LIT8(KSqlString, "CREATE TABL BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT)");
1.128 + TInt err = aDb.Exec(KSqlString);
1.129 + User::LeaveIfError(err);
1.130 + }
1.131 +
1.132 +//"RSqlDatabase::Exec()" OOM test (16-bit SQL statements), syntax error
1.133 +void ExecBadStatement16L(RSqlDatabase& aDb, const TDesC&, TDbType)
1.134 + {
1.135 + _LIT(KSqlString, "CREATE TABLE B!B!B(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT)");
1.136 + TInt err = aDb.Exec(KSqlString);
1.137 + User::LeaveIfError(err);
1.138 + }
1.139 +
1.140 +/**
1.141 +@SYMTestCaseID SYSLIB-SQL-CT-1813
1.142 +@SYMTestCaseDesc RSqlDatabase methods - negative OOM test
1.143 + Precondition: the database exists.
1.144 + The test calls the given as an argument function while simulating OOM failures
1.145 + and checks that there are no memory and resource leaks. The calling function is expected to fail
1.146 + with aExpectedError error.
1.147 +@SYMTestPriority High
1.148 +@SYMTestActions RSqlDatabase methods - negative OOM tests
1.149 +@SYMTestExpectedResults Test must not fail
1.150 +@SYMREQ REQ5792
1.151 + REQ5793
1.152 +*/
1.153 +void DoDbOomNegativeTest(TDbFuncPtrL aTestFunctionPtrL, const TDesC& aDbFileName, TDbAction aDbAction, TInt aExpectedError)
1.154 + {
1.155 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1813 RSqlDatabase - negative OOM test"));
1.156 + for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
1.157 + {
1.158 + TInt err = KErrNoMemory;
1.159 + TInt failingAllocationNo = 0;
1.160 + while(err == KErrNoMemory)
1.161 + {
1.162 + MarkHandles();
1.163 + MarkAllocatedCells();
1.164 +
1.165 + __UHEAP_MARK;
1.166 +
1.167 + if(TheOomTestType[i] == EServerSideTest)
1.168 + {//If aDbAction is EOpenDb, then we will delay the heap failure simulation, until the database is opened
1.169 + SetDbHeapFailure(TheOomTestType[i], ++failingAllocationNo, aDbAction == EOpenDb);
1.170 + }
1.171 +
1.172 + RSqlDatabase db;
1.173 + //if aDbAction is EOpenDb then this is a OOM test different than a test for RSqlDatabase::Open
1.174 + if(aDbAction == EOpenDb)
1.175 + {
1.176 + err = db.Open(aDbFileName);
1.177 + TEST2(err, KErrNone);
1.178 + }
1.179 +
1.180 + if(TheOomTestType[i] == EClientSideTest)
1.181 + {
1.182 + SetDbHeapFailure(TheOomTestType[i], ++failingAllocationNo);
1.183 + }
1.184 +
1.185 + TRAP(err, (*aTestFunctionPtrL)(db, aDbFileName, ENonSecureDb));
1.186 + db.Close();
1.187 + if(err != KErrNoMemory)
1.188 + {
1.189 + TEST2(err, aExpectedError);
1.190 + }
1.191 +
1.192 + ResetDbHeapFailure(TheOomTestType[i]);
1.193 +
1.194 + __UHEAP_MARKEND;
1.195 +
1.196 + CheckAllocatedCells();
1.197 + CheckHandles();
1.198 + }
1.199 + TEST2(err, aExpectedError);
1.200 + PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
1.201 + }
1.202 + RSqlDatabase::Delete(aDbFileName);
1.203 + }
1.204 +
1.205 +///////////////////////////////////////////////////////////////////////////////////////
1.206 +///////////////////////////////////////////////////////////////////////////////////////
1.207 +
1.208 +//RSqlDatabase - negative OOM tests
1.209 +void DbOomNegativeTestsL()
1.210 + {
1.211 + TheTest.Printf(_L("===RSqlDatabase::Open(), non-existing drive\r\n"));
1.212 + _LIT(KDbName1, "A:[1111CCCC]db1.db");
1.213 + DoDbOomNegativeTest(&OpenDatabaseL, KDbName1, ENotOpenDb, KErrNotReady);
1.214 +
1.215 + TheTest.Printf(_L("===RSqlDatabase::Open(), non-existing file\r\n"));
1.216 + _LIT(KDbName2, "c:\\test\\nofile.db");
1.217 + DoDbOomNegativeTest(&OpenDatabaseL, KDbName2, ENotOpenDb, KErrNotFound);
1.218 +
1.219 + TheTest.Printf(_L("===RSqlDatabase::Open(), zero-length name\r\n"));
1.220 + _LIT(KDbName3, "");
1.221 + DoDbOomNegativeTest(&OpenDatabaseL, KDbName3, ENotOpenDb, KErrBadName);
1.222 +
1.223 + TheTest.Printf(_L("===RSqlDatabase::Open(), directory name\r\n"));
1.224 + _LIT(KDbName4, "C:\\TEST\\");
1.225 + DoDbOomNegativeTest(&OpenDatabaseL, KDbName4, ENotOpenDb, KErrBadName);
1.226 +
1.227 + TheTest.Printf(_L("===RSqlDatabase::Create(), secure database already exists\r\n"));
1.228 + RSqlSecurityPolicy securityPolicy;
1.229 + CreateTestSecurityPolicy(securityPolicy);
1.230 + RSqlDatabase db;
1.231 + TInt err = db.Create(KSecureDb2, securityPolicy);
1.232 + TEST2(err, KErrNone);
1.233 + db.Close();
1.234 + securityPolicy.Close();
1.235 + DoCreateDatabaseOomTest(KSecureDb2, ESecureDb, KErrAlreadyExists);
1.236 +
1.237 + TheTest.Printf(_L("===RSqlDatabase::Create(), database already exists\r\n"));
1.238 + err = db.Create(KTestDb2);
1.239 + TEST2(err, KErrNone);
1.240 + db.Close();
1.241 + DoCreateDatabaseOomTest(KTestDb2, ENonSecureDb, KErrAlreadyExists);
1.242 +
1.243 + TheTest.Printf(_L("===RSqlDatabase::Exec(), 8-bit SQL, syntax error\r\n"));
1.244 + err = db.Create(KTestDb);
1.245 + TEST2(err, KErrNone);
1.246 + db.Close();
1.247 + DoDbOomNegativeTest(&ExecBadStatement8L, KTestDb, EOpenDb, KSqlErrGeneral);
1.248 +
1.249 + TheTest.Printf(_L("===RSqlDatabase::Exec(), 16-bit SQL, syntax error\r\n"));
1.250 + err = db.Create(KTestDb);
1.251 + TEST2(err, KErrNone);
1.252 + db.Close();
1.253 + DoDbOomNegativeTest(&ExecBadStatement16L, KTestDb, EOpenDb, KSqlErrGeneral);
1.254 + }
1.255 +
1.256 +void DEF114297PrepareStmtL(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.257 + {
1.258 + _LIT(KSelectSql, "SELECT e.* FROM edge AS e, node AS n1, node AS n2 WHERE n1.name = 'alice' AND n2.name = 'bob' AND e.orig = n1.id AND e.dest = n2.id ORDER BY n2.name DESC");
1.259 + TInt err = aStmt.Prepare(aDb, KSelectSql);
1.260 + User::LeaveIfError(err);
1.261 + }
1.262 +
1.263 +/**
1.264 +@SYMTestCaseID SYSLIB-SQL-UT-4004
1.265 +@SYMTestCaseDesc Test for DEF114297 - SqlSrv.EXE::!SQL Server OOM Test for PrepareL.
1.266 + The test does an OOM test for RSqlStatement::Prepare() using a specific SELECT SQL statement.
1.267 +@SYMTestPriority High
1.268 +@SYMTestActions Test for DEF114297 - SqlSrv.EXE::!SQL Server OOM Test for PrepareL.
1.269 +@SYMTestExpectedResults Test must not fail
1.270 +@SYMDEF DEF114297
1.271 +*/
1.272 +void DEF114297()
1.273 + {
1.274 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4004 ===DEF114297 - SqlSrv.EXE::!SQL Server OOM Test for PrepareL "));
1.275 + (void)RSqlDatabase::Delete(KTestDb);
1.276 + RSqlDatabase db;
1.277 + TInt err = db.Create(KTestDb);
1.278 + TEST2(err, KErrNone);
1.279 + err = db.Exec(_L("CREATE TABLE node(id INTEGER PRIMARY KEY,name TEXT)"));
1.280 + TEST2(err, 1);
1.281 + err = db.Exec(_L("CREATE INDEX node_idx ON node(name)"));
1.282 + TEST2(err, 1);
1.283 + err = db.Exec(_L("CREATE TABLE edge(orig INTEGER REFERENCES node,dest INTEGER REFERENCES node,PRIMARY KEY(orig, dest))"));
1.284 + TEST2(err, 1);
1.285 + err = db.Exec(_L("CREATE INDEX edge_idx ON edge(dest,orig)"));
1.286 + TEST2(err, 1);
1.287 + err = db.Exec(_L("INSERT INTO node(id,name) VALUES(1,'alice')"));
1.288 + TEST2(err, 1);
1.289 + err = db.Exec(_L("INSERT INTO node(id,name) VALUES(2,'bob')"));
1.290 + TEST2(err, 1);
1.291 + err = KErrNoMemory;
1.292 + TInt failingAllocationNo = 0;
1.293 + while(err == KErrNoMemory)
1.294 + {
1.295 + MarkHandles();
1.296 + MarkAllocatedCells();
1.297 +
1.298 + __UHEAP_MARK;
1.299 +
1.300 + SetHeapFailure(EServerSideTest, ++failingAllocationNo);
1.301 +
1.302 + RSqlStatement stmt;
1.303 + TRAP(err, DEF114297PrepareStmtL(db, stmt));
1.304 + stmt.Close();
1.305 + if(err != KErrNoMemory)
1.306 + {
1.307 + TEST2(err, KErrNone);
1.308 + }
1.309 +
1.310 + ResetHeapFailure(EServerSideTest);
1.311 +
1.312 + __UHEAP_MARKEND;
1.313 +
1.314 + CheckAllocatedCells();
1.315 + CheckHandles();
1.316 + }
1.317 + db.Close();
1.318 + (void)RSqlDatabase::Delete(KTestDb);
1.319 + }
1.320 +
1.321 +/**
1.322 +@SYMTestCaseID SYSLIB-SQL-UT-4011
1.323 +@SYMTestCaseDesc Test for DEF115815 - SELECT random()&1==-1 causes sql server to crash.
1.324 + The test does an OOM test for RSqlStatement::Prepare() using a specific SELECT SQL statement.
1.325 +@SYMTestPriority High
1.326 +@SYMTestActions Test for DEF115815 - SELECT random()&1==-1 causes sql server to crash.
1.327 +@SYMTestExpectedResults Test must not fail
1.328 +@SYMDEF DEF115815
1.329 +*/
1.330 +void DEF115815()
1.331 + {
1.332 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4011 ===DEF115815 - SELECT random()&1==-1 causes sql server to crash "));
1.333 + (void)RSqlDatabase::Delete(KTestDb);
1.334 + RSqlDatabase db;
1.335 + TInt err = db.Create(KTestDb);
1.336 + TEST2(err, KErrNone);
1.337 + err = db.Exec(_L("CREATE TABLE node(id INTEGER)"));
1.338 + TEST2(err, 1);
1.339 + err = KErrNoMemory;
1.340 + TInt failingAllocationNo = 0;
1.341 + while(err == KErrNoMemory)
1.342 + {
1.343 + MarkHandles();
1.344 + MarkAllocatedCells();
1.345 +
1.346 + __UHEAP_MARK;
1.347 +
1.348 + SetHeapFailure(EServerSideTest, ++failingAllocationNo);
1.349 +
1.350 + RSqlStatement stmt;
1.351 + err = stmt.Prepare(db, _L("SELECT random()&1==-1"));
1.352 + stmt.Close();
1.353 + if(err != KErrNoMemory)
1.354 + {
1.355 + TEST2(err, KErrNone);
1.356 + }
1.357 +
1.358 + ResetHeapFailure(EServerSideTest);
1.359 +
1.360 + __UHEAP_MARKEND;
1.361 +
1.362 + CheckAllocatedCells();
1.363 + CheckHandles();
1.364 + }
1.365 + db.Close();
1.366 + (void)RSqlDatabase::Delete(KTestDb);
1.367 + }
1.368 +
1.369 +void DoTestsL()
1.370 + {
1.371 + TheTest.Start(_L("SQL OOM-3 tests"));
1.372 +
1.373 + DbOomNegativeTestsL();
1.374 +
1.375 + DEF114297();
1.376 +
1.377 + DEF115815();
1.378 + }
1.379 +
1.380 +TInt E32Main()
1.381 + {
1.382 + TheTest.Title();
1.383 +
1.384 + CTrapCleanup* tc = CTrapCleanup::New();
1.385 +
1.386 + __UHEAP_MARK;
1.387 +
1.388 + CreateTestDir();
1.389 + DeleteTestFiles();
1.390 +
1.391 + TRAPD(err, DoTestsL());
1.392 + DeleteTestFiles();
1.393 + TEST2(err, KErrNone);
1.394 +
1.395 + __UHEAP_MARKEND;
1.396 +
1.397 + TheTest.End();
1.398 + TheTest.Close();
1.399 +
1.400 + delete tc;
1.401 +
1.402 + User::Heap().Check();
1.403 + return KErrNone;
1.404 + }