1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqloom2.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1607 @@
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_sqloom2 test"));
1.22 +
1.23 +const TInt KSqlBufMaxLen = 16 * 1024;
1.24 +const TInt KBlobStrLen = KSqlBufMaxLen / 2 - 100;
1.25 +const TInt KBlobLen = KBlobStrLen;
1.26 +
1.27 +TBuf8<KSqlBufMaxLen> TheSqlBuf;
1.28 +TBuf8<KBlobStrLen> TheSqlBuf2;
1.29 +
1.30 +///////////////////////////////////////////////////////////////////////////////////////
1.31 +/////////////// RSqlStatement OOM tests ///////////////////////////////
1.32 +///////////////////////////////////////////////////////////////////////////////////////
1.33 +
1.34 +_LIT8(KSqlDbString, "BEGIN;\
1.35 + CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB);\
1.36 + INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\
1.37 + COMMIT;");
1.38 +_LIT8(KSqlDbString2,"INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(1, 34, 10.9897, 'data2');");
1.39 +
1.40 +const TInt KLongColumnSize = 3013;
1.41 +const TInt KLongParameterSize = 4501;
1.42 +
1.43 +#define MAX(a, b) ((a) > (b) ? (a) : (b))
1.44 +
1.45 +static TUint16 TheTextColumnData[MAX(KLongColumnSize, KLongParameterSize)];
1.46 +static TUint8 TheBinaryColumnData[MAX(KLongColumnSize, KLongParameterSize) * sizeof(TUint16)];
1.47 +
1.48 +//"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement)
1.49 +void PrepareStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.50 + {
1.51 + _LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");
1.52 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.53 + User::LeaveIfError(err);
1.54 + }
1.55 +
1.56 +//"RSqlStatement::PrepareL()" OOM test (8-bit SELECT SQL statement)
1.57 +void PrepareStmt8_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.58 + {
1.59 + _LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");
1.60 + aStmt.PrepareL(aDb, KSqlString);
1.61 + }
1.62 +
1.63 +//"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement), syntax error
1.64 +void PrepareBadStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.65 + {
1.66 + _LIT8(KSqlString, "SELECT123 * FROM BBB WHERE Fld1=? AND Fld4<>?");
1.67 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.68 + User::LeaveIfError(err);
1.69 + }
1.70 +
1.71 +//"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement, move next)
1.72 +void PrepareMoveStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.73 + {
1.74 + _LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");
1.75 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.76 + User::LeaveIfError(err);
1.77 + err = aStmt.BindInt(0, 1);
1.78 + User::LeaveIfError(err);
1.79 + err = aStmt.BindText(1, _L("data244weewfn43wr83224iu23ewkjfbrektug4i433b3k45b"));
1.80 + User::LeaveIfError(err);
1.81 + err = aStmt.Next();
1.82 + if(err == KSqlAtRow)
1.83 + {
1.84 + err = KErrNone;
1.85 + }
1.86 + User::LeaveIfError(err);
1.87 + }
1.88 +
1.89 +//"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement)
1.90 +void PrepareInsertStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.91 + {
1.92 + _LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");
1.93 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.94 + User::LeaveIfError(err);
1.95 + }
1.96 +
1.97 +//"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (8-bit INSERT SQL statement, long column)
1.98 +void ExecInsertNextStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.99 + {
1.100 + _LIT8(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");
1.101 + _LIT8(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");
1.102 + TInt err = aStmt.Prepare(aDb, KSqlString1);
1.103 + if(err == KErrNone)
1.104 + {
1.105 + for(TInt i=0;i<KLongColumnSize;++i)
1.106 + {
1.107 + TheTextColumnData[i] = (TUint16)i;
1.108 + }
1.109 + const TPtrC textVal(TheTextColumnData, KLongColumnSize);
1.110 + const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
1.111 + TInt err = aStmt.BindText(0, textVal);
1.112 + if(err == KErrNone)
1.113 + {
1.114 + err = aStmt.BindBinary(1, binVal);
1.115 + }
1.116 + if(err == KErrNone)
1.117 + {
1.118 + err = aStmt.Exec();
1.119 + }
1.120 + }
1.121 + if(err >= 0)
1.122 + {
1.123 + aStmt.Close();
1.124 + err = aStmt.Prepare(aDb, KSqlString2);
1.125 + if(err == KErrNone)
1.126 + {
1.127 + err = aStmt.Next();
1.128 + }
1.129 + }
1.130 + User::LeaveIfError(err);
1.131 + }
1.132 +
1.133 +//"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement with parameters)
1.134 +void PrepareInsertPrmStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.135 + {
1.136 + _LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");
1.137 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.138 + User::LeaveIfError(err);
1.139 + }
1.140 +
1.141 +//"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement)
1.142 +void PrepareStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.143 + {
1.144 + _LIT(KSqlString, "SELECT * FROM BBB");
1.145 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.146 + User::LeaveIfError(err);
1.147 + }
1.148 +
1.149 +//"RSqlStatement::PrepareL()" OOM test (16-bit SELECT SQL statement)
1.150 +void PrepareStmt16_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.151 + {
1.152 + _LIT(KSqlString, "SELECT * FROM BBB");
1.153 + aStmt.PrepareL(aDb, KSqlString);
1.154 + }
1.155 +
1.156 +//"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement), syntax error
1.157 +void PrepareBadStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.158 + {
1.159 + _LIT(KSqlString, "23478SELECT * FROM BBB");
1.160 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.161 + User::LeaveIfError(err);
1.162 + }
1.163 +
1.164 +//"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement, move next)
1.165 +void PrepareMoveStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.166 + {
1.167 + _LIT(KSqlString, "SELECT * FROM BBB");
1.168 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.169 + if(err == KErrNone)
1.170 + {
1.171 + err = aStmt.Next();
1.172 + if(err == KSqlAtRow)
1.173 + {
1.174 + err = KErrNone;
1.175 + }
1.176 + }
1.177 + User::LeaveIfError(err);
1.178 + }
1.179 +
1.180 +//"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement)
1.181 +void PrepareInsertStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.182 + {
1.183 + _LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");
1.184 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.185 + User::LeaveIfError(err);
1.186 + }
1.187 +
1.188 +//"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (16-bit INSERT SQL statement, long column)
1.189 +void ExecInsertNextStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.190 + {
1.191 + _LIT(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");
1.192 + _LIT(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");
1.193 + TInt err = aStmt.Prepare(aDb, KSqlString1);
1.194 + if(err == KErrNone)
1.195 + {
1.196 + for(TInt i=0;i<KLongColumnSize;++i)
1.197 + {
1.198 + TheTextColumnData[i] = (TUint16)i;
1.199 + }
1.200 + const TPtrC textVal(TheTextColumnData, KLongColumnSize);
1.201 + const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
1.202 + TInt err = aStmt.BindText(0, textVal);
1.203 + if(err == KErrNone)
1.204 + {
1.205 + err = aStmt.BindBinary(1, binVal);
1.206 + }
1.207 + if(err == KErrNone)
1.208 + {
1.209 + err = aStmt.Exec();
1.210 + }
1.211 + }
1.212 + if(err >= 0)
1.213 + {
1.214 + aStmt.Close();
1.215 + err = aStmt.Prepare(aDb, KSqlString2);
1.216 + if(err == KErrNone)
1.217 + {
1.218 + err = aStmt.Next();
1.219 + }
1.220 + }
1.221 + User::LeaveIfError(err);
1.222 + }
1.223 +
1.224 +//"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement with parameters)
1.225 +void PrepareInsertPrmStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
1.226 + {
1.227 + _LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");
1.228 + TInt err = aStmt.Prepare(aDb, KSqlString);
1.229 + User::LeaveIfError(err);
1.230 + }
1.231 +
1.232 +/**
1.233 +@SYMTestCaseID SYSLIB-SQL-CT-1617
1.234 +@SYMTestCaseDesc RSqlStatement::Prepare() OOM test
1.235 + Precondition: the database exists, opened, some record(s) inserted.
1.236 + The test calls the given as an argument function while simulating OOM failures
1.237 + and checks that there are no memory and resource leaks.
1.238 +@SYMTestPriority High
1.239 +@SYMTestActions RSqlStatement::Prepare() OOM test
1.240 +@SYMTestExpectedResults Test must not fail
1.241 +@SYMREQ REQ5792
1.242 + REQ5793
1.243 +*/
1.244 +void DoStmtPrepareOomTestL(TStmtFuncPtrL aStmtFuncPtrL, const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError = KErrNone)
1.245 + {
1.246 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1617 RSqlStatement::Prepare() - OOM test"));
1.247 + RSqlSecurityPolicy securityPolicy;
1.248 + CreateTestSecurityPolicy(securityPolicy);
1.249 + for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
1.250 + {
1.251 + RSqlDatabase::Delete(aDbFileName);
1.252 + RSqlDatabase db;
1.253 + TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
1.254 + TEST2(err, KErrNone);
1.255 + err = db.Exec(KSqlDbString);
1.256 + TEST(err >= 0);
1.257 + //The next operation is executed to force the SQL server side session to make one memory allocation
1.258 + //for the statement handle in its RDbObjContainer contrainer data member. Otherwise the OOM test will fail,
1.259 + //because the server side session will do one additional allocation, which stays alive untill the
1.260 + //session gets closed.
1.261 + RSqlStatement dummyStmt;
1.262 + err = dummyStmt.Prepare(db, _L("SELECT * FROM BBB"));
1.263 + TEST2(err, KErrNone);
1.264 + dummyStmt.Close();
1.265 +
1.266 + err = KErrNoMemory;
1.267 + const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
1.268 + TInt allocationNo = 0;
1.269 + TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
1.270 + while(allocationNo < KMaxAllocation)
1.271 + {
1.272 + MarkHandles();
1.273 + MarkAllocatedCells();
1.274 +
1.275 + __UHEAP_MARK;
1.276 +
1.277 + SetHeapFailure(TheOomTestType[i], ++allocationNo);
1.278 +
1.279 + RSqlStatement stmt;
1.280 + TRAP(err, (*aStmtFuncPtrL)(db, stmt));
1.281 + stmt.Close();
1.282 + if(err != KErrNoMemory)
1.283 + {
1.284 + TEST2(err, aExpectedError);
1.285 + }
1.286 + else
1.287 + {
1.288 + failingAllocationNo = allocationNo;
1.289 + }
1.290 +
1.291 + ResetHeapFailure(TheOomTestType[i]);
1.292 +
1.293 + __UHEAP_MARKEND;
1.294 +
1.295 + CheckAllocatedCells();
1.296 + CheckHandles();
1.297 + }
1.298 +
1.299 + db.Close();
1.300 + TEST2(err, aExpectedError);
1.301 + PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
1.302 + }
1.303 + //Delete the database file
1.304 + RSqlDatabase::Delete(aDbFileName);
1.305 + securityPolicy.Close();
1.306 + }
1.307 +
1.308 +//"RSqlStatement::Reset()" OOM test
1.309 +void ResetStmtL(RSqlStatement& aStmt)
1.310 + {
1.311 + TInt err = aStmt.Next();
1.312 + if(err == KErrNone)
1.313 + {
1.314 + err = aStmt.Reset();
1.315 + }
1.316 + User::LeaveIfError(err);
1.317 + }
1.318 +
1.319 +//"RSqlStatement::Exec()" OOM test
1.320 +void ExecStmtL(RSqlStatement& aStmt)
1.321 + {
1.322 + TInt err = aStmt.Exec();
1.323 + User::LeaveIfError(err);
1.324 + }
1.325 +
1.326 +//"RSqlStatement::Next()" OOM test
1.327 +void NextStmtL(RSqlStatement& aStmt)
1.328 + {
1.329 + TInt err = aStmt.Next();
1.330 + if(err == KErrNone)
1.331 + {
1.332 + err = aStmt.Next();
1.333 + }
1.334 + User::LeaveIfError(err);
1.335 + }
1.336 +
1.337 +//"RSqlStatement::ParameterIndex()" OOM test
1.338 +void StmtParameterIndexL(RSqlStatement& aStmt)
1.339 + {
1.340 + TInt err = aStmt.ParameterIndex(_L(":Prm2"));
1.341 + if(err == 1) //":Prm2" index is 1
1.342 + {
1.343 + err = KErrNone;
1.344 + }
1.345 + User::LeaveIfError(err);
1.346 + }
1.347 +
1.348 +//"RSqlStatement::ParameterName()" OOM test
1.349 +void StmtParameterNameL(RSqlStatement& aStmt)
1.350 + {
1.351 + // _LIT(KExcpected, ":Prm2");
1.352 + TPtrC paramName;
1.353 + TInt err = aStmt.ParameterName(1, paramName);
1.354 + User::LeaveIfError(err);
1.355 + }
1.356 +
1.357 +//"RSqlStatement::ParamName()" OOM test
1.358 +void StmtParamNameL(RSqlStatement& aStmt)
1.359 + {
1.360 + TPtrC paramName;
1.361 + TInt err = aStmt.ParamName(1, paramName);
1.362 + User::LeaveIfError(err);
1.363 + }
1.364 +
1.365 +//"RSqlStatement::ColumnIndex()" OOM test
1.366 +void StmtColumnIndexL(RSqlStatement& aStmt)
1.367 + {
1.368 + TInt err = aStmt.ColumnIndex(_L("fLd3"));
1.369 + if(err == 2) //"fLd3" index is 2
1.370 + {
1.371 + err = KErrNone;
1.372 + }
1.373 + User::LeaveIfError(err);
1.374 + }
1.375 +
1.376 +//"RSqlStatement::ColumnName()" OOM test
1.377 +void StmtColumnNameL(RSqlStatement& aStmt)
1.378 + {
1.379 + //_LIT(KExpected, "fLd3");
1.380 + TPtrC colName;
1.381 + TInt err = aStmt.ColumnName(2, colName);
1.382 + User::LeaveIfError(err);
1.383 + }
1.384 +
1.385 +
1.386 +//"RSqlStatement::ColumnType()" OOM test
1.387 +void StmtColumnTypeL(RSqlStatement& aStmt)
1.388 + {
1.389 + TSqlColumnType coltype = aStmt.ColumnType(2);
1.390 + TEST(coltype == ESqlReal);
1.391 + }
1.392 +
1.393 +//"RSqlStatement::ColumnSize()" OOM test
1.394 +void StmtColumnSizeL(RSqlStatement& aStmt)
1.395 + {
1.396 + TInt colsize = aStmt.ColumnSize(2);
1.397 + TEST(colsize == sizeof(TReal));
1.398 + }
1.399 +
1.400 +//"RSqlStatement::BindNull()" OOM test
1.401 +void StmtBindNullL(RSqlStatement& aStmt)
1.402 + {
1.403 + TInt err = aStmt.BindNull(1);
1.404 + //The bindings will be transferred on the server side right before Next() or Exec() call
1.405 + if(err == KErrNone)
1.406 + {
1.407 + err = aStmt.Exec();
1.408 + }
1.409 + User::LeaveIfError(err);
1.410 + }
1.411 +
1.412 +//"RSqlStatement::BindInt()" OOM test
1.413 +void StmtBindIntL(RSqlStatement& aStmt)
1.414 + {
1.415 + TInt val = 184;
1.416 + TInt err = aStmt.BindInt(0, val);
1.417 + //The bindings will be transferred on the server side right before Next() or Exec() call
1.418 + if(err == KErrNone)
1.419 + {
1.420 + err = aStmt.Exec();
1.421 + }
1.422 + User::LeaveIfError(err);
1.423 + }
1.424 +
1.425 +//"RSqlStatement::BindInt64()" OOM test
1.426 +void StmtBindInt64L(RSqlStatement& aStmt)
1.427 + {
1.428 + TInt64 val = MAKE_TINT64(0x00FF00FF, 0x12345678);
1.429 + TInt err = aStmt.BindInt64(1, val);
1.430 + //The bindings will be transferred on the server side right before Next() or Exec() call
1.431 + if(err == KErrNone)
1.432 + {
1.433 + err = aStmt.Exec();
1.434 + }
1.435 + User::LeaveIfError(err);
1.436 + }
1.437 +
1.438 +//"RSqlStatement::BindReal()" OOM test
1.439 +void StmtBindRealL(RSqlStatement& aStmt)
1.440 + {
1.441 + TReal val = 25.2423;
1.442 + TInt err = aStmt.BindReal(2, val);
1.443 + //The bindings will be transferred on the server side right before Next() or Exec() call
1.444 + if(err == KErrNone)
1.445 + {
1.446 + err = aStmt.Exec();
1.447 + }
1.448 + User::LeaveIfError(err);
1.449 + }
1.450 +
1.451 +//"RSqlStatement::BindText()" OOM test
1.452 +void StmtBindTextL(RSqlStatement& aStmt)
1.453 + {
1.454 + for(TInt i=0;i<KLongParameterSize;++i)
1.455 + {
1.456 + TheTextColumnData[i] = (TUint16)i;
1.457 + }
1.458 + const TPtrC val(TheTextColumnData, KLongParameterSize);
1.459 + TInt err = aStmt.BindText(3, val);
1.460 + //The bindings will be transferred on the server side right before a Next() or Exec() call
1.461 + if(err == KErrNone)
1.462 + {
1.463 + err = aStmt.Exec();
1.464 + }
1.465 + User::LeaveIfError(err);
1.466 + }
1.467 +
1.468 +//"RSqlStatement::BindBinary()" OOM test
1.469 +void StmtBindBinaryL(RSqlStatement& aStmt)
1.470 + {
1.471 + for(TInt i=0;i<KLongParameterSize;++i)
1.472 + {
1.473 + TheBinaryColumnData[i] = (TUint8)i;
1.474 + }
1.475 + const TPtrC8 val(TheBinaryColumnData, KLongParameterSize);
1.476 + TInt err = aStmt.BindBinary(3, val);
1.477 + //The bindings will be transferred on the server side right before a Next() or Exec() call
1.478 + if(err == KErrNone)
1.479 + {
1.480 + err = aStmt.Exec();
1.481 + }
1.482 + User::LeaveIfError(err);
1.483 + }
1.484 +
1.485 +//"RSqlStatement::BindZeroBlob()" OOM test
1.486 +void StmtBindZeroBlobL(RSqlStatement& aStmt)
1.487 + {
1.488 + TInt err = aStmt.BindZeroBlob(3, KLongParameterSize);
1.489 + //The bindings will be transferred on the server side right before a Next() or Exec() call
1.490 + if(err == KErrNone)
1.491 + {
1.492 + err = aStmt.Exec();
1.493 + }
1.494 + User::LeaveIfError(err);
1.495 + }
1.496 +
1.497 +//"RSqlStatement::IsNull()" OOM test
1.498 +void StmtIsNullColumnL(RSqlStatement& aStmt)
1.499 + {
1.500 + TBool rc = aStmt.IsNull(0);
1.501 + TEST(!rc);
1.502 + }
1.503 +
1.504 +//"RSqlStatement::ColumnInt()" OOM test
1.505 +void StmtColumnIntL(RSqlStatement& aStmt)
1.506 + {
1.507 + TInt val = aStmt.ColumnInt(0);
1.508 + TEST(val == 10);
1.509 + }
1.510 +
1.511 +//"RSqlStatement::ColumnInt64()" OOM test
1.512 +void StmtColumnInt64L(RSqlStatement& aStmt)
1.513 + {
1.514 + TInt64 val = aStmt.ColumnInt64(1);
1.515 + TEST(val == 100);
1.516 + }
1.517 +
1.518 +//"RSqlStatement::ColumnReal()" OOM test
1.519 +void StmtColumnRealL(RSqlStatement& aStmt)
1.520 + {
1.521 + TReal val = aStmt.ColumnReal(2);
1.522 + TEST(Abs(val - 100.001) < 0.000001);
1.523 + }
1.524 +
1.525 +//"RSqlStatement::ColumnTextL()" OOM test
1.526 +void StmtColumnText1L(RSqlStatement& aStmt)
1.527 + {
1.528 + TPtrC val = aStmt.ColumnTextL(3);
1.529 + TEST(val.Length() == KLongColumnSize);
1.530 + for(TInt i=0;i<KLongColumnSize;++i)
1.531 + {
1.532 + TEST(val[i] == (TUint16)i);
1.533 + }
1.534 + }
1.535 +
1.536 +//"RSqlStatement::ColumnText()" OOM test
1.537 +void StmtColumnText2L(RSqlStatement& aStmt)
1.538 + {
1.539 + TPtrC val;
1.540 + TInt err = aStmt.ColumnText(3, val);
1.541 + User::LeaveIfError(err);
1.542 + TEST(val.Length() == KLongColumnSize);
1.543 + for(TInt i=0;i<KLongColumnSize;++i)
1.544 + {
1.545 + TEST(val[i] == (TUint16)i);
1.546 + }
1.547 + }
1.548 +
1.549 +//"RSqlStatement::ColumnText()" OOM test
1.550 +void StmtColumnText3L(RSqlStatement& aStmt)
1.551 + {
1.552 + TPtr val(TheTextColumnData, KLongColumnSize);
1.553 + TInt err = aStmt.ColumnText(3, val);
1.554 + User::LeaveIfError(err);
1.555 + TEST(val.Length() == KLongColumnSize);
1.556 + for(TInt i=0;i<KLongColumnSize;++i)
1.557 + {
1.558 + TEST(val[i] == (TUint16)i);
1.559 + }
1.560 + }
1.561 +
1.562 +//"RSqlStatement::ColumnBinaryL()" OOM test
1.563 +void StmtColumnBinary1L(RSqlStatement& aStmt)
1.564 + {
1.565 + TPtrC8 val = aStmt.ColumnBinaryL(4);
1.566 + TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
1.567 + for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
1.568 + {
1.569 + TUint8 valLow = val[j];
1.570 + TUint8 valHigh = val[j + 1];
1.571 + TEST(valLow == (TUint8)(i & 0xFF));
1.572 + TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
1.573 + }
1.574 + }
1.575 +
1.576 +//"RSqlStatement::ColumnBinary()" OOM test
1.577 +void StmtColumnBinary2L(RSqlStatement& aStmt)
1.578 + {
1.579 + TPtrC8 val;
1.580 + TInt err = aStmt.ColumnBinary(4, val);
1.581 + User::LeaveIfError(err);
1.582 + TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
1.583 + for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
1.584 + {
1.585 + TUint8 valLow = val[j];
1.586 + TUint8 valHigh = val[j + 1];
1.587 + TEST(valLow == (TUint8)(i & 0xFF));
1.588 + TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
1.589 + }
1.590 + }
1.591 +
1.592 +//"RSqlStatement::ColumnBinary()" OOM test
1.593 +void StmtColumnBinary3L(RSqlStatement& aStmt)
1.594 + {
1.595 + TPtr8 val(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));
1.596 + TInt err = aStmt.ColumnBinary(4, val);
1.597 + User::LeaveIfError(err);
1.598 + TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
1.599 + for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
1.600 + {
1.601 + TUint8 valLow = val[j];
1.602 + TUint8 valHigh = val[j + 1];
1.603 + TEST(valLow == (TUint8)(i & 0xFF));
1.604 + TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
1.605 + }
1.606 + }
1.607 +
1.608 +//"RSqlStatement::ColumnCount()" OOM test
1.609 +void StmtColumnCount(RSqlStatement& aStmt)
1.610 + {
1.611 + TInt cnt = aStmt.ColumnCount();
1.612 + TEST2(cnt, 5);
1.613 + }
1.614 +
1.615 +//"RSqlStatement::DeclaredColumnType()" OOM test
1.616 +void StmtDeclaredColumnTypeL(RSqlStatement& aStmt)
1.617 + {
1.618 + TInt cnt = aStmt.ColumnCount();
1.619 + TEST2(cnt, 5);
1.620 + const TSqlColumnType KColTypes[] = {ESqlInt, ESqlInt, ESqlReal, ESqlText, ESqlBinary};
1.621 + for(TInt i=0;i<cnt;++i)
1.622 + {
1.623 + TSqlColumnType colType;
1.624 + TInt err = aStmt.DeclaredColumnType(i, colType);
1.625 + User::LeaveIfError(err);
1.626 + TEST2(colType, KColTypes[i]);
1.627 + }
1.628 + }
1.629 +
1.630 +//"RSqlColumnReadStream::ColumnBinary()" OOM test
1.631 +void StmtColumnBinaryStreamL(RSqlStatement& aStmt)
1.632 + {
1.633 + RSqlColumnReadStream strm;
1.634 + CleanupClosePushL(strm);
1.635 + TInt err = strm.ColumnBinary(aStmt, 4);
1.636 + User::LeaveIfError(err);
1.637 + strm.ReadL(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));
1.638 + CleanupStack::PopAndDestroy(&strm);
1.639 + for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
1.640 + {
1.641 + TUint8 valLow = TheBinaryColumnData[j];
1.642 + TUint8 valHigh = TheBinaryColumnData[j + 1];
1.643 + TEST(valLow == (TUint8)(i & 0xFF));
1.644 + TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
1.645 + }
1.646 + }
1.647 +
1.648 +//"RSqlColumnReadStream::ColumnText()" OOM test
1.649 +void StmtColumnTextStreamL(RSqlStatement& aStmt)
1.650 + {
1.651 + RSqlColumnReadStream strm;
1.652 + CleanupClosePushL(strm);
1.653 + TInt err = strm.ColumnText(aStmt, 3);
1.654 + User::LeaveIfError(err);
1.655 + strm.ReadL(TheTextColumnData, KLongColumnSize);
1.656 + CleanupStack::PopAndDestroy(&strm);
1.657 + for(TInt i=0;i<KLongColumnSize;++i)
1.658 + {
1.659 + TEST(TheTextColumnData[i] == (TUint16)i);
1.660 + }
1.661 + }
1.662 +
1.663 +//"RSqlParamWriteStream::BindBinary()" OOM test
1.664 +void StmtParamBinaryStreamL(RSqlStatement& aStmt)
1.665 + {
1.666 + for(TInt i=0;i<KLongParameterSize;++i)
1.667 + {
1.668 + TheTextColumnData[i] = (TUint16)i;
1.669 + }
1.670 +
1.671 + RSqlParamWriteStream strm;
1.672 + CleanupClosePushL(strm);
1.673 + TInt err = strm.BindBinary(aStmt, 3);
1.674 + User::LeaveIfError(err);
1.675 + strm.WriteL((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
1.676 + CleanupStack::PopAndDestroy(&strm);
1.677 + }
1.678 +
1.679 +//"RSqlParamWriteStream::BindText()" OOM test
1.680 +void StmtParamTextStreamL(RSqlStatement& aStmt)
1.681 + {
1.682 + for(TInt i=0;i<KLongParameterSize;++i)
1.683 + {
1.684 + TheTextColumnData[i] = (TUint16)i;
1.685 + }
1.686 +
1.687 + RSqlParamWriteStream strm;
1.688 + CleanupClosePushL(strm);
1.689 + TInt err = strm.BindText(aStmt, 3);
1.690 + User::LeaveIfError(err);
1.691 + strm.WriteL(TheTextColumnData, KLongColumnSize);
1.692 + CleanupStack::PopAndDestroy(&strm);
1.693 + }
1.694 +
1.695 +/**
1.696 +@SYMTestCaseID SYSLIB-SQL-CT-1618
1.697 +@SYMTestCaseDesc RSqlStatement methods OOM tests
1.698 + Precondition: the database exists, opened, some record(s) inserted.
1.699 + The test calls the given as an argument function while simulating OOM failures
1.700 + and checks that there are no memory and resource leaks.
1.701 +@SYMTestPriority High
1.702 +@SYMTestActions RSqlStatement methods OOM tests
1.703 +@SYMTestExpectedResults Test must not fail
1.704 +@SYMREQ REQ5792
1.705 + REQ5793
1.706 +*/
1.707 +void DoStmtOomTestL(TStmtFuncPtrL aStmtPrepareFuncPtrL, TStmtFuncPtr2L aStmtTestFuncPtrL, const TDesC& aDbFileName, TDbType aDbType)
1.708 + {
1.709 + //This is not really an OOM test, because:
1.710 + //(A) The test forces the server to simulate heap failure on determied allocation step
1.711 + //(B) SQL server counts only the number of active statement and stream objects, the allocated memory cells
1.712 + // are not counted.
1.713 + // The reason that the allocated memory cells are not counted and in case of OOM failure - checked is
1.714 + // because the SQL server may make some per-connection persistent memory allocations (cache pages, etc.)
1.715 + // which will not be deallocated when the statement object is closed.
1.716 +
1.717 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1618 RSqlStatement - OOM test"));
1.718 + RSqlSecurityPolicy securityPolicy;
1.719 + CreateTestSecurityPolicy(securityPolicy);
1.720 + for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
1.721 + {
1.722 + RSqlDatabase::Delete(aDbFileName);
1.723 + RSqlDatabase db;
1.724 + TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
1.725 + TEST2(err, KErrNone);
1.726 + err = db.Exec(KSqlDbString);
1.727 + TEST(err >= 0);
1.728 + err = db.Exec(KSqlDbString2);
1.729 + TEST(err >= 0);
1.730 +
1.731 + err = KErrNoMemory;
1.732 + const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
1.733 + TInt allocationNo = 0;
1.734 + TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
1.735 + while(allocationNo < KMaxAllocation)
1.736 + {
1.737 + MarkHandles();
1.738 + MarkAllocatedCells();
1.739 +
1.740 + __UHEAP_MARK;
1.741 +
1.742 + RSqlStatement stmt;
1.743 + TRAP(err, (*aStmtPrepareFuncPtrL)(db, stmt));
1.744 + TEST2(err, KErrNone);
1.745 +
1.746 + SetHeapFailure(TheOomTestType[i], ++allocationNo);
1.747 +
1.748 + TRAP(err, (*aStmtTestFuncPtrL)(stmt));
1.749 +
1.750 + //ResetHeapFailure() has to be called before stmt.Close() because,
1.751 + //otherwise it will panic the server (the server resource count, marked by
1.752 + //SetHeapFailure() call, is 1 (there is one prepared statement))
1.753 + ResetHeapFailure(TheOomTestType[i]);
1.754 +
1.755 + stmt.Close();
1.756 +
1.757 + if(err != KErrNoMemory)
1.758 + {
1.759 + TEST2(err, KErrNone);
1.760 + }
1.761 + else
1.762 + {
1.763 + failingAllocationNo = allocationNo;
1.764 + }
1.765 +
1.766 + __UHEAP_MARKEND;
1.767 +
1.768 + CheckAllocatedCells();
1.769 + CheckHandles();
1.770 + }
1.771 +
1.772 + db.Close();
1.773 + TEST2(err, KErrNone);
1.774 + PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
1.775 + }
1.776 + //Delete the database file
1.777 + RSqlDatabase::Delete(aDbFileName);
1.778 + securityPolicy.Close();
1.779 + }
1.780 +
1.781 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.782 +////////////////// RSqlBlobReadStream, RSqlBlobWriteStream - OOM tests /////////////////////
1.783 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.784 +
1.785 +//RSqlBlobReadStream, RSqlBlobWriteStream - OOM test preparation.
1.786 +void ExecInsertBlobL(RSqlDatabase& aDb)
1.787 + {
1.788 + _LIT8(KSqlString1, "CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB)");
1.789 + TInt err = aDb.Exec(KSqlString1);
1.790 + User::LeaveIfError(err);
1.791 + _LIT8(KSqlString2, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, 'AAA', x'");
1.792 + TheSqlBuf.Copy(KSqlString2);
1.793 + for(TInt i=0;i<KBlobStrLen;++i)
1.794 + {
1.795 + TheSqlBuf.Append(_L8("A5"));
1.796 + }
1.797 + TheSqlBuf.Append(_L8("')"));
1.798 + err = aDb.Exec(TheSqlBuf);
1.799 + User::LeaveIfError(err);
1.800 + }
1.801 +
1.802 +//"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()" OOM test
1.803 +void BlobReadStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.804 + {
1.805 + RSqlBlobReadStream strm;
1.806 + CleanupClosePushL(strm);
1.807 + if(aAttachDbName.Length() > 0)
1.808 + {
1.809 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
1.810 + }
1.811 + else
1.812 + {
1.813 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
1.814 + }
1.815 + const TInt KReadOpCnt = 8;
1.816 + for(TInt j=0;j<KReadOpCnt;++j)
1.817 + {
1.818 + strm.ReadL(TheSqlBuf, KBlobLen / KReadOpCnt);
1.819 + TEST2(TheSqlBuf.Length(), (KBlobLen / KReadOpCnt));
1.820 + for(TInt i=0;i<(KBlobLen / KReadOpCnt);++i)
1.821 + {
1.822 + TUint8 val = TheSqlBuf[i];
1.823 + TEST2(val, 0xA5);
1.824 + }
1.825 + }
1.826 + CleanupStack::PopAndDestroy(&strm);
1.827 + }
1.828 +
1.829 +//"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()" OOM test
1.830 +void BlobReadStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.831 + {
1.832 + RSqlBlobReadStream strm;
1.833 + CleanupClosePushL(strm);
1.834 + if(aAttachDbName.Length() > 0)
1.835 + {
1.836 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
1.837 + }
1.838 + else
1.839 + {
1.840 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
1.841 + }
1.842 + TInt size = strm.SizeL();
1.843 + TEST2(size, KBlobLen);
1.844 + CleanupStack::PopAndDestroy(&strm);
1.845 + }
1.846 +
1.847 +//"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()" OOM test
1.848 +void BlobWriteStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.849 + {
1.850 + RSqlBlobWriteStream strm;
1.851 + CleanupClosePushL(strm);
1.852 + if(aAttachDbName.Length() > 0)
1.853 + {
1.854 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
1.855 + }
1.856 + else
1.857 + {
1.858 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
1.859 + }
1.860 + const TInt KWriteOpCnt = 8;
1.861 + TheSqlBuf.SetLength(KBlobLen / KWriteOpCnt);
1.862 + TheSqlBuf.Fill(TChar('Z'));
1.863 + for(TInt j=0;j<KWriteOpCnt;++j)
1.864 + {
1.865 + strm.WriteL(TheSqlBuf, KBlobLen / KWriteOpCnt);
1.866 + }
1.867 + strm.CommitL();
1.868 + CleanupStack::PopAndDestroy(&strm);
1.869 + }
1.870 +
1.871 +//"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()" OOM test
1.872 +void BlobWriteStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.873 + {
1.874 + RSqlBlobWriteStream strm;
1.875 + CleanupClosePushL(strm);
1.876 + if(aAttachDbName.Length() > 0)
1.877 + {
1.878 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
1.879 + }
1.880 + else
1.881 + {
1.882 + strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
1.883 + }
1.884 + TInt size = strm.SizeL();
1.885 + TEST2(size, KBlobLen);
1.886 + CleanupStack::PopAndDestroy(&strm);
1.887 + }
1.888 +
1.889 +//"TSqlBlob::GetLC()" OOM test
1.890 +void BlobWholeGet1L(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.891 + {
1.892 + HBufC8* buf = NULL;
1.893 + if(aAttachDbName.Length() > 0)
1.894 + {
1.895 + buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
1.896 + }
1.897 + else
1.898 + {
1.899 + buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1);
1.900 + }
1.901 + TEST(buf->Length() == KBlobStrLen);
1.902 + CleanupStack::PopAndDestroy(buf);
1.903 + }
1.904 +
1.905 +//"TSqlBlob::Get()" OOM test
1.906 +void BlobWholeGet2L(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.907 + {
1.908 + if(aAttachDbName.Length() > 0)
1.909 + {
1.910 + TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1, aAttachDbName);
1.911 + }
1.912 + else
1.913 + {
1.914 + TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1);
1.915 + }
1.916 + }
1.917 +
1.918 +//"TSqlBlob::SetL()" OOM test
1.919 +void BlobWholeSetL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
1.920 + {
1.921 + if(aAttachDbName.Length() > 0)
1.922 + {
1.923 + TSqlBlob::SetL(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1, aAttachDbName);
1.924 + }
1.925 + else
1.926 + {
1.927 + TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1);
1.928 + }
1.929 + }
1.930 +
1.931 +/**
1.932 +@SYMTestCaseID SYSLIB-SQL-UT-4091
1.933 +@SYMTestCaseDesc RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests
1.934 + Precondition: the database exists, opened, some record(s) inserted.
1.935 + The test calls the given as an argument function while simulating OOM failures
1.936 + and checks that there are no memory and resource leaks.
1.937 +@SYMTestPriority High
1.938 +@SYMTestActions RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests
1.939 +@SYMTestExpectedResults Test must not fail
1.940 +@SYMREQ REQ5792
1.941 + REQ10410
1.942 + REQ10411
1.943 + REQ10418
1.944 +*/
1.945 +void DoBlobOomTestL(TBlobPrepareFuncPtrL aBlobPrepareFuncPtrL, TBlobTestFuncPtrL aBlobTestFuncPtrL,
1.946 + const TDesC& aDbFileName, TDbType aDbType, TBool aAttachDb = EFalse)
1.947 + {
1.948 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4091 RSqlBlobReadStream, RSqlBlobWriteStream - OOM test"));
1.949 + RSqlSecurityPolicy securityPolicy;
1.950 + CreateTestSecurityPolicy(securityPolicy);
1.951 + for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
1.952 + {
1.953 + RSqlDatabase::Delete(aDbFileName);
1.954 + RSqlDatabase db;
1.955 + TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
1.956 + TEST2(err, KErrNone);
1.957 + TRAP(err, (*aBlobPrepareFuncPtrL)(db));
1.958 + TEST2(err, KErrNone);
1.959 + _LIT(KAttachDbName, "AttachDb");
1.960 + if(aAttachDb)
1.961 + {
1.962 + err = db.Attach(aDbFileName, KAttachDbName);
1.963 + TEST2(err, KErrNone);
1.964 + }
1.965 +
1.966 + err = KErrNoMemory;
1.967 + const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KBlobOomTestAllocLimitServer : KBlobOomTestAllocLimitClient;
1.968 + TInt allocationNo = 0;
1.969 + TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
1.970 + while(allocationNo < KMaxAllocation)
1.971 + {
1.972 + MarkHandles();
1.973 + MarkAllocatedCells();
1.974 +
1.975 + __UHEAP_MARK;
1.976 +
1.977 + SetHeapFailure(TheOomTestType[i], ++allocationNo);
1.978 + if(aAttachDb)
1.979 + {
1.980 + TRAP(err, (*aBlobTestFuncPtrL)(db, KAttachDbName));
1.981 + }
1.982 + else
1.983 + {
1.984 + TRAP(err, (*aBlobTestFuncPtrL)(db, KNullDesC));
1.985 + }
1.986 +
1.987 + ResetHeapFailure(TheOomTestType[i]);
1.988 +
1.989 + if(err != KErrNoMemory)
1.990 + {
1.991 + if(err != KErrNone)
1.992 + {
1.993 + TPtrC errmsg = db.LastErrorMessage();
1.994 + if(errmsg.Length() > 0)
1.995 + {
1.996 + TheTest.Printf(_L("\r\n@@@ error %d, error message: %S\r\n"), err, &errmsg);
1.997 + }
1.998 + }
1.999 + TEST2(err, KErrNone);
1.1000 + }
1.1001 + else
1.1002 + {
1.1003 + failingAllocationNo = allocationNo;
1.1004 + }
1.1005 +
1.1006 + __UHEAP_MARKEND;
1.1007 +
1.1008 + CheckAllocatedCells();
1.1009 + CheckHandles();
1.1010 + }
1.1011 + TEST2(err, KErrNone);
1.1012 +
1.1013 + if(aAttachDb)
1.1014 + {
1.1015 + (void)db.Detach(KAttachDbName);
1.1016 + }
1.1017 +
1.1018 + db.Close();
1.1019 + err = RSqlDatabase::Delete(aDbFileName);
1.1020 + TEST2(err, KErrNone);
1.1021 + PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
1.1022 + }
1.1023 + securityPolicy.Close();
1.1024 + }
1.1025 +
1.1026 +void ScalarFullSelectInt_8L(RSqlDatabase& aDb)
1.1027 + {
1.1028 + TSqlScalarFullSelectQuery query(aDb);
1.1029 + TInt val = query.SelectIntL(_L8("SELECT F1 FROM A WHERE F3 < 0"));
1.1030 + TEST2(val, 2);
1.1031 + }
1.1032 +
1.1033 +void ScalarFullSelectInt64_8L(RSqlDatabase& aDb)
1.1034 + {
1.1035 + TSqlScalarFullSelectQuery query(aDb);
1.1036 + TInt64 val = query.SelectInt64L(_L8("SELECT F2 FROM A WHERE F1 = 1"));
1.1037 + TEST2(val, 10000000000LL);
1.1038 + }
1.1039 +
1.1040 +void ScalarFullSelectReal_8L(RSqlDatabase& aDb)
1.1041 + {
1.1042 + TSqlScalarFullSelectQuery query(aDb);
1.1043 + TReal val = query.SelectRealL(_L8("SELECT F3 FROM A WHERE F1 = 1"));
1.1044 + TEST(val > 2.0 && val < 3.0);
1.1045 + }
1.1046 +
1.1047 +void ScalarFullSelectText_8L(RSqlDatabase& aDb)
1.1048 + {
1.1049 + TSqlScalarFullSelectQuery query(aDb);
1.1050 + TBuf<20> buf;
1.1051 + TInt err = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), buf);
1.1052 + TEST2(err, KErrNone);
1.1053 + _LIT(KText, "NAME1234567890");
1.1054 + TEST(buf == KText);
1.1055 + }
1.1056 +
1.1057 +void ScalarFullSelectBinary_8L(RSqlDatabase& aDb)
1.1058 + {
1.1059 + TSqlScalarFullSelectQuery query(aDb);
1.1060 + TBuf8<20> buf;
1.1061 + TInt err = query.SelectBinaryL(_L8("SELECT F5 FROM A WHERE F1 = 1"), buf);
1.1062 + TEST2(err, KErrNone);
1.1063 + TEST(buf.Length() == 0);
1.1064 + }
1.1065 +
1.1066 +void ScalarFullSelectInt_16L(RSqlDatabase& aDb)
1.1067 + {
1.1068 + TSqlScalarFullSelectQuery query(aDb);
1.1069 + TInt val = query.SelectIntL(_L16("SELECT F1 FROM A WHERE F3 < 0"));
1.1070 + TEST2(val, 2);
1.1071 + }
1.1072 +
1.1073 +void ScalarFullSelectInt64_16L(RSqlDatabase& aDb)
1.1074 + {
1.1075 + TSqlScalarFullSelectQuery query(aDb);
1.1076 + TInt64 val = query.SelectInt64L(_L16("SELECT F2 FROM A WHERE F1 = 1"));
1.1077 + TEST2(val, 10000000000LL);
1.1078 + }
1.1079 +
1.1080 +void ScalarFullSelectReal_16L(RSqlDatabase& aDb)
1.1081 + {
1.1082 + TSqlScalarFullSelectQuery query(aDb);
1.1083 + TReal val = query.SelectRealL(_L16("SELECT F3 FROM A WHERE F1 = 1"));
1.1084 + TEST(val > 2.0 && val < 3.0);
1.1085 + }
1.1086 +
1.1087 +void ScalarFullSelectText_16L(RSqlDatabase& aDb)
1.1088 + {
1.1089 + TSqlScalarFullSelectQuery query(aDb);
1.1090 + TBuf<20> buf;
1.1091 + TInt err = query.SelectTextL(_L16("SELECT F4 FROM A WHERE F1 = 1"), buf);
1.1092 + TEST2(err, KErrNone);
1.1093 + _LIT(KText, "NAME1234567890");
1.1094 + TEST(buf == KText);
1.1095 + }
1.1096 +
1.1097 +void ScalarFullSelectBinary_16L(RSqlDatabase& aDb)
1.1098 + {
1.1099 + TSqlScalarFullSelectQuery query(aDb);
1.1100 + TBuf8<20> buf;
1.1101 + TInt err = query.SelectBinaryL(_L16("SELECT F5 FROM A WHERE F1 = 1"), buf);
1.1102 + TEST2(err, KErrNone);
1.1103 + TEST(buf.Length() == 0);
1.1104 + }
1.1105 +
1.1106 +void ScalarFullSelectText2_8L(RSqlDatabase& aDb)
1.1107 + {
1.1108 + TSqlScalarFullSelectQuery query(aDb);
1.1109 + HBufC* buf = HBufC::NewLC(8);
1.1110 + TPtr name = buf->Des();
1.1111 + TInt rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);
1.1112 + TEST(rc >= 0); //the function may return only non-negative values
1.1113 + if(rc > 0)
1.1114 + {
1.1115 + buf = buf->ReAllocL(rc);
1.1116 + CleanupStack::Pop();
1.1117 + CleanupStack::PushL(buf);
1.1118 + name.Set(buf->Des());
1.1119 + rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);
1.1120 + TEST(rc == 0);
1.1121 + _LIT(KText, "NAME1234567890");
1.1122 + TEST(name == KText);
1.1123 + }
1.1124 + CleanupStack::PopAndDestroy(buf);
1.1125 + }
1.1126 +
1.1127 +/**
1.1128 +@SYMTestCaseID SYSLIB-SQL-CT-1811
1.1129 +@SYMTestCaseDesc TSqlScalarFullSelectQuery functions OOM test
1.1130 + Precondition: the database exists.
1.1131 + The test simulates OOM failures while calling TSqlScalarFullSelectQuery functions
1.1132 + and checks that there are no memory and resource leaks.
1.1133 +@SYMTestPriority High
1.1134 +@SYMTestActions TSqlScalarFullSelectQuery methods OOM tests
1.1135 +@SYMTestExpectedResults Test must not fail
1.1136 +@SYMREQ REQ5792
1.1137 + REQ5793
1.1138 +*/
1.1139 +void DoFullSelectOomTest(TScalarFullSelectFuncPtrL aTestFunctionPtrL)
1.1140 + {
1.1141 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1811 TSqlScalarFullSelectQuery - OOM test"));
1.1142 + //Create test database
1.1143 + RSqlDatabase db;
1.1144 + TInt err = db.Create(KTestDb);
1.1145 + TEST2(err, KErrNone);
1.1146 + err = db.Exec(_L("CREATE TABLE A(F1 INTEGER, F2 INTEGER, F3 FLOAT, F4 TEXT, F5 BLOB)"));
1.1147 + TEST(err >= 0);
1.1148 + err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4, F5) VALUES(1, 10000000000, 2.54, 'NAME1234567890', NULL)"));
1.1149 + TEST2(err, 1);
1.1150 + err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4) VALUES(2, 200, -1.11, 'ADDRESS')"));
1.1151 + TEST2(err, 1);
1.1152 + db.Close();
1.1153 + //OOM test loop
1.1154 + for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
1.1155 + {
1.1156 + err = KErrNoMemory;
1.1157 + const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
1.1158 + TInt allocationNo = 0;
1.1159 + TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
1.1160 + while(allocationNo < KMaxAllocation)
1.1161 + {
1.1162 + MarkHandles();
1.1163 + MarkAllocatedCells();
1.1164 +
1.1165 + __UHEAP_MARK;
1.1166 +
1.1167 + if(TheOomTestType[i] == EServerSideTest)
1.1168 + {//We will delay the heap failure simulation, until the database is opened
1.1169 + SetDbHeapFailure(TheOomTestType[i], ++allocationNo, ETrue);
1.1170 + }
1.1171 +
1.1172 + err = db.Open(KTestDb);
1.1173 + TEST2(err, KErrNone);
1.1174 +
1.1175 + if(TheOomTestType[i] == EClientSideTest)
1.1176 + {
1.1177 + SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
1.1178 + }
1.1179 +
1.1180 + TRAP(err, (*aTestFunctionPtrL)(db));
1.1181 + db.Close();
1.1182 + if(err != KErrNoMemory)
1.1183 + {
1.1184 + TEST2(err, KErrNone);
1.1185 + }
1.1186 + else
1.1187 + {
1.1188 + failingAllocationNo = allocationNo;
1.1189 + }
1.1190 +
1.1191 + ResetDbHeapFailure(TheOomTestType[i]);
1.1192 +
1.1193 + __UHEAP_MARKEND;
1.1194 +
1.1195 + CheckAllocatedCells();
1.1196 + CheckHandles();
1.1197 + }
1.1198 + TEST2(err, KErrNone);
1.1199 + PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
1.1200 + }
1.1201 + //Delete the database file
1.1202 + RSqlDatabase::Delete(KTestDb);
1.1203 + }
1.1204 +
1.1205 +//RSqlStatement OOM tests
1.1206 +void StmtOomTestsL()
1.1207 + {
1.1208 + const TInt KTestCnt = 2;
1.1209 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1210 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1211 +
1.1212 + for(TInt i=0;i<KTestCnt;++i)
1.1213 + {
1.1214 + TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));
1.1215 + DoStmtPrepareOomTestL(&PrepareStmt8L, dbFileName[i], dbType[i]);
1.1216 +
1.1217 + TheTest.Printf(_L("===RSqlStatement::PrepareL(), 8-bit SQL\r\n"));
1.1218 + DoStmtPrepareOomTestL(&PrepareStmt8_2L, dbFileName[i], dbType[i]);
1.1219 +
1.1220 + TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));
1.1221 + DoStmtPrepareOomTestL(&PrepareStmt16L, dbFileName[i], dbType[i]);
1.1222 +
1.1223 + TheTest.Printf(_L("===RSqlStatement::PrepareL(), 16-bit SQL\r\n"));
1.1224 + DoStmtPrepareOomTestL(&PrepareStmt16_2L, dbFileName[i], dbType[i]);
1.1225 +
1.1226 + TheTest.Printf(_L("===RSqlStatement::Reset(), 8-bit SQL\r\n"));
1.1227 + DoStmtOomTestL(&PrepareStmt8L, &ResetStmtL, dbFileName[i], dbType[i]);
1.1228 +
1.1229 + TheTest.Printf(_L("===RSqlStatement::Reset(), 16-bit SQL\r\n"));
1.1230 + DoStmtOomTestL(&PrepareStmt16L, &ResetStmtL, dbFileName[i], dbType[i]);
1.1231 +
1.1232 + TheTest.Printf(_L("===RSqlStatement::Exec(), 8-bit SQL\r\n"));
1.1233 + DoStmtOomTestL(&PrepareInsertStmt8L, &ExecStmtL, dbFileName[i], dbType[i]);
1.1234 +
1.1235 + TheTest.Printf(_L("===RSqlStatement::Exec(), 16-bit SQL\r\n"));
1.1236 + DoStmtOomTestL(&PrepareInsertStmt16L, &ExecStmtL, dbFileName[i], dbType[i]);
1.1237 +
1.1238 + TheTest.Printf(_L("===RSqlStatement::Next(), 8-bit SQL\r\n"));
1.1239 + DoStmtOomTestL(&PrepareStmt8L, &NextStmtL, dbFileName[i], dbType[i]);
1.1240 +
1.1241 + TheTest.Printf(_L("===RSqlStatement::Next(), 16-bit SQL\r\n"));
1.1242 + DoStmtOomTestL(&PrepareStmt16L, &NextStmtL, dbFileName[i], dbType[i]);
1.1243 +
1.1244 + TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 8-bit SQL\r\n"));
1.1245 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterIndexL, dbFileName[i], dbType[i]);
1.1246 +
1.1247 + TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 16-bit SQL\r\n"));
1.1248 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterIndexL, dbFileName[i], dbType[i]);
1.1249 +
1.1250 + TheTest.Printf(_L("===RSqlStatement::ParameterName(), 8-bit SQL\r\n"));
1.1251 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterNameL, dbFileName[i], dbType[i]);
1.1252 +
1.1253 + TheTest.Printf(_L("===RSqlStatement::ParameterName(), 16-bit SQL\r\n"));
1.1254 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterNameL, dbFileName[i], dbType[i]);
1.1255 +
1.1256 + TheTest.Printf(_L("===RSqlStatement::ParamName(), 8-bit SQL\r\n"));
1.1257 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamNameL, dbFileName[i], dbType[i]);
1.1258 +
1.1259 + TheTest.Printf(_L("===RSqlStatement::ParamName(), 16-bit SQL\r\n"));
1.1260 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamNameL, dbFileName[i], dbType[i]);
1.1261 +
1.1262 + TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 8-bit SQL\r\n"));
1.1263 + DoStmtOomTestL(&PrepareStmt8L, &StmtColumnIndexL, dbFileName[i], dbType[i]);
1.1264 +
1.1265 + TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 16-bit SQL\r\n"));
1.1266 + DoStmtOomTestL(&PrepareStmt16L, &StmtColumnIndexL, dbFileName[i], dbType[i]);
1.1267 +
1.1268 + TheTest.Printf(_L("===RSqlStatement::ColumnType(), 8-bit SQL\r\n"));
1.1269 + DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnTypeL, dbFileName[i], dbType[i]);
1.1270 +
1.1271 + TheTest.Printf(_L("===RSqlStatement::ColumnType(), 16-bit SQL\r\n"));
1.1272 + DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnTypeL, dbFileName[i], dbType[i]);
1.1273 +
1.1274 + TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 8-bit SQL\r\n"));
1.1275 + DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnSizeL, dbFileName[i], dbType[i]);
1.1276 +
1.1277 + TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 16-bit SQL\r\n"));
1.1278 + DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnSizeL, dbFileName[i], dbType[i]);
1.1279 +
1.1280 + TheTest.Printf(_L("===RSqlStatement::ColumnName(), 8-bit SQL\r\n"));
1.1281 + DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnNameL, dbFileName[i], dbType[i]);
1.1282 +
1.1283 + TheTest.Printf(_L("===RSqlStatement::ColumnName(), 16-bit SQL\r\n"));
1.1284 + DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnNameL, dbFileName[i], dbType[i]);
1.1285 +
1.1286 + TheTest.Printf(_L("===RSqlStatement::BindNull(), 8-bit SQL\r\n"));
1.1287 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindNullL, dbFileName[i], dbType[i]);
1.1288 +
1.1289 + TheTest.Printf(_L("===RSqlStatement::BindNull(), 16-bit SQL\r\n"));
1.1290 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindNullL, dbFileName[i], dbType[i]);
1.1291 +
1.1292 + TheTest.Printf(_L("===RSqlStatement::BindInt(), 8-bit SQL\r\n"));
1.1293 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindIntL, dbFileName[i], dbType[i]);
1.1294 +
1.1295 + TheTest.Printf(_L("===RSqlStatement::BindInt(), 16-bit SQL\r\n"));
1.1296 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindIntL, dbFileName[i], dbType[i]);
1.1297 +
1.1298 + TheTest.Printf(_L("===RSqlStatement::BindInt64(), 8-bit SQL\r\n"));
1.1299 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindInt64L, dbFileName[i], dbType[i]);
1.1300 +
1.1301 + TheTest.Printf(_L("===RSqlStatement::BindInt64(), 16-bit SQL\r\n"));
1.1302 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindInt64L, dbFileName[i], dbType[i]);
1.1303 +
1.1304 + TheTest.Printf(_L("===RSqlStatement::BindReal(), 8-bit SQL\r\n"));
1.1305 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindRealL, dbFileName[i], dbType[i]);
1.1306 +
1.1307 + TheTest.Printf(_L("===RSqlStatement::BindReal(), 16-bit SQL\r\n"));
1.1308 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindRealL, dbFileName[i], dbType[i]);
1.1309 +
1.1310 + TheTest.Printf(_L("===RSqlStatement::BindText(), 8-bit SQL\r\n"));
1.1311 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindTextL, dbFileName[i], dbType[i]);
1.1312 +
1.1313 + TheTest.Printf(_L("===RSqlStatement::BindText(), 16-bit SQL\r\n"));
1.1314 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindTextL, dbFileName[i], dbType[i]);
1.1315 +
1.1316 + TheTest.Printf(_L("===RSqlStatement::BindBinary(), 8-bit SQL\r\n"));
1.1317 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindBinaryL, dbFileName[i], dbType[i]);
1.1318 +
1.1319 + TheTest.Printf(_L("===RSqlStatement::BindBinary(), 16-bit SQL\r\n"));
1.1320 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindBinaryL, dbFileName[i], dbType[i]);
1.1321 +
1.1322 + TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 8-bit SQL\r\n"));
1.1323 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);
1.1324 +
1.1325 + TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 16-bit SQL\r\n"));
1.1326 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);
1.1327 +
1.1328 + TheTest.Printf(_L("===RSqlStatement::IsNull(), 8-bit SQL\r\n"));
1.1329 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);
1.1330 +
1.1331 + TheTest.Printf(_L("===RSqlStatement::IsNull(), 16-bit SQL\r\n"));
1.1332 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);
1.1333 +
1.1334 + TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 8-bit SQL\r\n"));
1.1335 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnIntL, dbFileName[i], dbType[i]);
1.1336 +
1.1337 + TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 16-bit SQL\r\n"));
1.1338 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnIntL, dbFileName[i], dbType[i]);
1.1339 +
1.1340 + TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 8-bit SQL\r\n"));
1.1341 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnInt64L, dbFileName[i], dbType[i]);
1.1342 +
1.1343 + TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 16-bit SQL\r\n"));
1.1344 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnInt64L, dbFileName[i], dbType[i]);
1.1345 +
1.1346 + TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 8-bit SQL\r\n"));
1.1347 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnRealL, dbFileName[i], dbType[i]);
1.1348 +
1.1349 + TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 16-bit SQL\r\n"));
1.1350 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnRealL, dbFileName[i], dbType[i]);
1.1351 +
1.1352 + TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 8-bit SQL\r\n"));
1.1353 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText1L, dbFileName[i], dbType[i]);
1.1354 +
1.1355 + TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 16-bit SQL\r\n"));
1.1356 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText1L, dbFileName[i], dbType[i]);
1.1357 +
1.1358 + TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 8-bit SQL\r\n"));
1.1359 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText2L, dbFileName[i], dbType[i]);
1.1360 +
1.1361 + TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 16-bit SQL\r\n"));
1.1362 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText2L, dbFileName[i], dbType[i]);
1.1363 +
1.1364 + TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 8-bit SQL\r\n"));
1.1365 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText3L, dbFileName[i], dbType[i]);
1.1366 +
1.1367 + TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 16-bit SQL\r\n"));
1.1368 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText3L, dbFileName[i], dbType[i]);
1.1369 +
1.1370 + TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 8-bit SQL\r\n"));
1.1371 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);
1.1372 +
1.1373 + TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 16-bit SQL\r\n"));
1.1374 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);
1.1375 +
1.1376 + TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 8-bit SQL\r\n"));
1.1377 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);
1.1378 +
1.1379 + TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 16-bit SQL\r\n"));
1.1380 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);
1.1381 +
1.1382 + TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 8-bit SQL\r\n"));
1.1383 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);
1.1384 +
1.1385 + TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 16-bit SQL\r\n"));
1.1386 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);
1.1387 +
1.1388 + TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 8-bit SQL\r\n"));
1.1389 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnCount, dbFileName[i], dbType[i]);
1.1390 +
1.1391 + TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 16-bit SQL\r\n"));
1.1392 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnCount, dbFileName[i], dbType[i]);
1.1393 +
1.1394 + TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 8-bit SQL\r\n"));
1.1395 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);
1.1396 +
1.1397 + TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 16-bit SQL\r\n"));
1.1398 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);
1.1399 + }
1.1400 + }
1.1401 +
1.1402 +//RSqlStatement - negative OOM tests
1.1403 +void StmtOomNegativeTestsL()
1.1404 + {
1.1405 + const TInt KTestCnt = 2;
1.1406 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1407 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1408 +
1.1409 + for(TInt i=0;i<KTestCnt;++i)
1.1410 + {
1.1411 + TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));
1.1412 + DoStmtPrepareOomTestL(&PrepareBadStmt8L, dbFileName[i], dbType[i], KSqlErrGeneral);
1.1413 +
1.1414 + TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));
1.1415 + DoStmtPrepareOomTestL(&PrepareBadStmt16L, dbFileName[i], dbType[i], KSqlErrGeneral);
1.1416 + }
1.1417 + }
1.1418 +
1.1419 +//RSqlColumnReadStream OOM tests
1.1420 +void ColumnReadStreamOomTestsL()
1.1421 + {
1.1422 + const TInt KTestCnt = 2;
1.1423 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1424 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1425 +
1.1426 + for(TInt i=0;i<KTestCnt;++i)
1.1427 + {
1.1428 + TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 8-bit SQL\r\n"));
1.1429 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);
1.1430 +
1.1431 + TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 16-bit SQL\r\n"));
1.1432 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);
1.1433 +
1.1434 + TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 8-bit SQL\r\n"));
1.1435 + DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);
1.1436 +
1.1437 + TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 16-bit SQL\r\n"));
1.1438 + DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);
1.1439 + }
1.1440 + }
1.1441 +
1.1442 +//RSqlParamWriteStream OOM tests
1.1443 +void ParamWriteStreamOomTestsL()
1.1444 + {
1.1445 + const TInt KTestCnt = 2;
1.1446 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1447 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1448 +
1.1449 + for(TInt i=0;i<KTestCnt;++i)
1.1450 + {
1.1451 + TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 8-bit SQL\r\n"));
1.1452 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);
1.1453 +
1.1454 + TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 16-bit SQL\r\n"));
1.1455 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);
1.1456 +
1.1457 + TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 8-bit SQL\r\n"));
1.1458 + DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);
1.1459 +
1.1460 + TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 16-bit SQL\r\n"));
1.1461 + DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);
1.1462 + }
1.1463 + }
1.1464 +
1.1465 +//TSqlScalarFullSelectQuery OOM tests
1.1466 +void ScalarFullSelectQueryOomTestsL()
1.1467 + {
1.1468 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 8-bit SQL\r\n"));
1.1469 + DoFullSelectOomTest(&ScalarFullSelectInt_8L);
1.1470 +
1.1471 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 8-bit SQL\r\n"));
1.1472 + DoFullSelectOomTest(&ScalarFullSelectInt64_8L);
1.1473 +
1.1474 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 8-bit SQL\r\n"));
1.1475 + DoFullSelectOomTest(&ScalarFullSelectReal_8L);
1.1476 +
1.1477 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL\r\n"));
1.1478 + DoFullSelectOomTest(&ScalarFullSelectText_8L);
1.1479 +
1.1480 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 8-bit SQL\r\n"));
1.1481 + DoFullSelectOomTest(&ScalarFullSelectBinary_8L);
1.1482 +
1.1483 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 16-bit SQL\r\n"));
1.1484 + DoFullSelectOomTest(&ScalarFullSelectInt_16L);
1.1485 +
1.1486 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 16-bit SQL\r\n"));
1.1487 + DoFullSelectOomTest(&ScalarFullSelectInt64_16L);
1.1488 +
1.1489 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 16-bit SQL\r\n"));
1.1490 + DoFullSelectOomTest(&ScalarFullSelectReal_16L);
1.1491 +
1.1492 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 16-bit SQL\r\n"));
1.1493 + DoFullSelectOomTest(&ScalarFullSelectText_16L);
1.1494 +
1.1495 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 16-bit SQL\r\n"));
1.1496 + DoFullSelectOomTest(&ScalarFullSelectBinary_16L);
1.1497 +
1.1498 + TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL, small buffer\r\n"));
1.1499 + DoFullSelectOomTest(&ScalarFullSelectText2_8L);
1.1500 + }
1.1501 +
1.1502 +void BlobReadStreamOomTestsL()
1.1503 + {
1.1504 + const TInt KTestCnt = 2;
1.1505 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1506 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1507 +
1.1508 + for(TInt i=0;i<KTestCnt;++i)
1.1509 + {
1.1510 + TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()\r\n"));
1.1511 + DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i]);
1.1512 +
1.1513 + TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL() + attached database\r\n"));
1.1514 + DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i], ETrue);
1.1515 +
1.1516 + TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()\r\n"));
1.1517 + DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i]);
1.1518 +
1.1519 + TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL() + attached database\r\n"));
1.1520 + DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i], ETrue);
1.1521 + }
1.1522 + }
1.1523 +
1.1524 +void BlobWriteStreamOomTestsL()
1.1525 + {
1.1526 + const TInt KTestCnt = 2;
1.1527 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1528 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1529 +
1.1530 + for(TInt i=0;i<KTestCnt;++i)
1.1531 + {
1.1532 + TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()\r\n"));
1.1533 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i]);
1.1534 +
1.1535 + TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL() + attached database\r\n"));
1.1536 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i], ETrue);
1.1537 +
1.1538 + TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()\r\n"));
1.1539 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i]);
1.1540 +
1.1541 + TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL() + attached database\r\n"));
1.1542 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i], ETrue);
1.1543 + }
1.1544 + }
1.1545 +
1.1546 +void BlobWholeOomTestsL()
1.1547 + {
1.1548 + const TInt KTestCnt = 2;
1.1549 + const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
1.1550 + TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
1.1551 +
1.1552 + for(TInt i=0;i<KTestCnt;++i)
1.1553 + {
1.1554 + TheTest.Printf(_L("===TSqlBlob::GetLC()\r\n"));
1.1555 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet1L, dbFileName[i], dbType[i]);
1.1556 +
1.1557 + TheTest.Printf(_L("===TSqlBlob::Get()\r\n"));
1.1558 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet2L, dbFileName[i], dbType[i]);
1.1559 +
1.1560 + TheTest.Printf(_L("===TSqlBlob::SetL()\r\n"));
1.1561 + DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeSetL, dbFileName[i], dbType[i]);
1.1562 + }
1.1563 + }
1.1564 +
1.1565 +void DoTestsL()
1.1566 + {
1.1567 + TheTest.Start(_L("SQL OOM tests - 2"));
1.1568 +
1.1569 + StmtOomTestsL();
1.1570 +
1.1571 + StmtOomNegativeTestsL();
1.1572 +
1.1573 + ColumnReadStreamOomTestsL();
1.1574 +
1.1575 + ParamWriteStreamOomTestsL();
1.1576 +
1.1577 + ScalarFullSelectQueryOomTestsL();
1.1578 +
1.1579 + BlobReadStreamOomTestsL();
1.1580 +
1.1581 + BlobWriteStreamOomTestsL();
1.1582 +
1.1583 + BlobWholeOomTestsL();
1.1584 + }
1.1585 +
1.1586 +TInt E32Main()
1.1587 + {
1.1588 + TheTest.Title();
1.1589 +
1.1590 + CTrapCleanup* tc = CTrapCleanup::New();
1.1591 +
1.1592 + __UHEAP_MARK;
1.1593 +
1.1594 + CreateTestDir();
1.1595 + DeleteTestFiles();
1.1596 +
1.1597 + TRAPD(err, DoTestsL());
1.1598 + DeleteTestFiles();
1.1599 + TEST2(err, KErrNone);
1.1600 +
1.1601 + __UHEAP_MARKEND;
1.1602 +
1.1603 + TheTest.End();
1.1604 + TheTest.Close();
1.1605 +
1.1606 + delete tc;
1.1607 +
1.1608 + User::Heap().Check();
1.1609 + return KErrNone;
1.1610 + }