--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sql/TEST/t_sqloom2.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1605 @@
+// Copyright (c) 2005-2009 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 "t_sqloom.h"
+
+RTest TheTest(_L("t_sqloom2 test"));
+
+const TInt KSqlBufMaxLen = 16 * 1024;
+const TInt KBlobStrLen = KSqlBufMaxLen / 2 - 100;
+const TInt KBlobLen = KBlobStrLen;
+
+TBuf8<KSqlBufMaxLen> TheSqlBuf;
+TBuf8<KBlobStrLen> TheSqlBuf2;
+
+///////////////////////////////////////////////////////////////////////////////////////
+/////////////// RSqlStatement OOM tests ///////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
+
+_LIT8(KSqlDbString, "BEGIN;\
+ CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB);\
+ INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\
+ COMMIT;");
+_LIT8(KSqlDbString2,"INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(1, 34, 10.9897, 'data2');");
+
+const TInt KLongColumnSize = 3013;
+const TInt KLongParameterSize = 4501;
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+static TUint16 TheTextColumnData[MAX(KLongColumnSize, KLongParameterSize)];
+static TUint8 TheBinaryColumnData[MAX(KLongColumnSize, KLongParameterSize) * sizeof(TUint16)];
+
+//"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement)
+void PrepareStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString, "SELECT * FROM BBB");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::PrepareL()" OOM test (8-bit SELECT SQL statement)
+void PrepareStmt8_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString, "SELECT * FROM BBB");
+ aStmt.PrepareL(aDb, KSqlString);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement), syntax error
+void PrepareBadStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString, "SELECT123 * FROM BBB");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement, move next)
+void PrepareMoveStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString, "SELECT * FROM BBB");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ if(err == KErrNone)
+ {
+ err = aStmt.Next();
+ if(err == KSqlAtRow)
+ {
+ err = KErrNone;
+ }
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement)
+void PrepareInsertStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (8-bit INSERT SQL statement, long column)
+void ExecInsertNextStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");
+ _LIT8(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");
+ TInt err = aStmt.Prepare(aDb, KSqlString1);
+ if(err == KErrNone)
+ {
+ for(TInt i=0;i<KLongColumnSize;++i)
+ {
+ TheTextColumnData[i] = (TUint16)i;
+ }
+ const TPtrC textVal(TheTextColumnData, KLongColumnSize);
+ const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
+ TInt err = aStmt.BindText(0, textVal);
+ if(err == KErrNone)
+ {
+ err = aStmt.BindBinary(1, binVal);
+ }
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ }
+ if(err >= 0)
+ {
+ aStmt.Close();
+ err = aStmt.Prepare(aDb, KSqlString2);
+ if(err == KErrNone)
+ {
+ err = aStmt.Next();
+ }
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement with parameters)
+void PrepareInsertPrmStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement)
+void PrepareStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString, "SELECT * FROM BBB");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::PrepareL()" OOM test (16-bit SELECT SQL statement)
+void PrepareStmt16_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString, "SELECT * FROM BBB");
+ aStmt.PrepareL(aDb, KSqlString);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement), syntax error
+void PrepareBadStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString, "23478SELECT * FROM BBB");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement, move next)
+void PrepareMoveStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString, "SELECT * FROM BBB");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ if(err == KErrNone)
+ {
+ err = aStmt.Next();
+ if(err == KSqlAtRow)
+ {
+ err = KErrNone;
+ }
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement)
+void PrepareInsertStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (16-bit INSERT SQL statement, long column)
+void ExecInsertNextStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");
+ _LIT(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");
+ TInt err = aStmt.Prepare(aDb, KSqlString1);
+ if(err == KErrNone)
+ {
+ for(TInt i=0;i<KLongColumnSize;++i)
+ {
+ TheTextColumnData[i] = (TUint16)i;
+ }
+ const TPtrC textVal(TheTextColumnData, KLongColumnSize);
+ const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
+ TInt err = aStmt.BindText(0, textVal);
+ if(err == KErrNone)
+ {
+ err = aStmt.BindBinary(1, binVal);
+ }
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ }
+ if(err >= 0)
+ {
+ aStmt.Close();
+ err = aStmt.Prepare(aDb, KSqlString2);
+ if(err == KErrNone)
+ {
+ err = aStmt.Next();
+ }
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement with parameters)
+void PrepareInsertPrmStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
+ {
+ _LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");
+ TInt err = aStmt.Prepare(aDb, KSqlString);
+ User::LeaveIfError(err);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SQL-CT-1617
+@SYMTestCaseDesc RSqlStatement::Prepare() OOM test
+ Precondition: the database exists, opened, some record(s) inserted.
+ The test calls the given as an argument function while simulating OOM failures
+ and checks that there are no memory and resource leaks.
+@SYMTestPriority High
+@SYMTestActions RSqlStatement::Prepare() OOM test
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ5792
+ REQ5793
+*/
+void DoStmtPrepareOomTestL(TStmtFuncPtrL aStmtFuncPtrL, const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError = KErrNone)
+ {
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1617 RSqlStatement::Prepare() - OOM test"));
+ RSqlSecurityPolicy securityPolicy;
+ CreateTestSecurityPolicy(securityPolicy);
+ for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
+ {
+ RSqlDatabase::Delete(aDbFileName);
+ RSqlDatabase db;
+ TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
+ TEST2(err, KErrNone);
+ err = db.Exec(KSqlDbString);
+ TEST(err >= 0);
+ //The next operation is executed to force the SQL server side session to make one memory allocation
+ //for the statement handle in its RDbObjContainer contrainer data member. Otherwise the OOM test will fail,
+ //because the server side session will do one additional allocation, which stays alive untill the
+ //session gets closed.
+ RSqlStatement dummyStmt;
+ err = dummyStmt.Prepare(db, _L("SELECT * FROM BBB"));
+ TEST2(err, KErrNone);
+ dummyStmt.Close();
+
+ err = KErrNoMemory;
+ const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
+ TInt allocationNo = 0;
+ TInt failingAllocationNo = 0;
+ while(allocationNo < KMaxAllocation)
+ {
+ MarkHandles();
+ MarkAllocatedCells();
+
+ __UHEAP_MARK;
+
+ SetHeapFailure(TheOomTestType[i], ++allocationNo);
+
+ RSqlStatement stmt;
+ TRAP(err, (*aStmtFuncPtrL)(db, stmt));
+ stmt.Close();
+ if(err != KErrNoMemory)
+ {
+ TEST2(err, aExpectedError);
+ }
+ else
+ {
+ failingAllocationNo = allocationNo;
+ }
+
+ ResetHeapFailure(TheOomTestType[i]);
+
+ __UHEAP_MARKEND;
+
+ CheckAllocatedCells();
+ CheckHandles();
+ }
+
+ db.Close();
+ TEST2(err, aExpectedError);
+ PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
+ }
+ //Delete the database file
+ RSqlDatabase::Delete(aDbFileName);
+ securityPolicy.Close();
+ }
+
+//"RSqlStatement::Reset()" OOM test
+void ResetStmtL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.Next();
+ if(err == KErrNone)
+ {
+ err = aStmt.Reset();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Exec()" OOM test
+void ExecStmtL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.Exec();
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::Next()" OOM test
+void NextStmtL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.Next();
+ if(err == KErrNone)
+ {
+ err = aStmt.Next();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::ParameterIndex()" OOM test
+void StmtParameterIndexL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.ParameterIndex(_L(":Prm2"));
+ if(err == 1) //":Prm2" index is 1
+ {
+ err = KErrNone;
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::ParameterName()" OOM test
+void StmtParameterNameL(RSqlStatement& aStmt)
+ {
+ // _LIT(KExcpected, ":Prm2");
+ TPtrC paramName;
+ TInt err = aStmt.ParameterName(1, paramName);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::ParamName()" OOM test
+void StmtParamNameL(RSqlStatement& aStmt)
+ {
+ TPtrC paramName;
+ TInt err = aStmt.ParamName(1, paramName);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::ColumnIndex()" OOM test
+void StmtColumnIndexL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.ColumnIndex(_L("fLd3"));
+ if(err == 2) //"fLd3" index is 2
+ {
+ err = KErrNone;
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::ColumnName()" OOM test
+void StmtColumnNameL(RSqlStatement& aStmt)
+ {
+ //_LIT(KExpected, "fLd3");
+ TPtrC colName;
+ TInt err = aStmt.ColumnName(2, colName);
+ User::LeaveIfError(err);
+ }
+
+
+//"RSqlStatement::ColumnType()" OOM test
+void StmtColumnTypeL(RSqlStatement& aStmt)
+ {
+ TSqlColumnType coltype = aStmt.ColumnType(2);
+ TEST(coltype == ESqlReal);
+ }
+
+//"RSqlStatement::ColumnSize()" OOM test
+void StmtColumnSizeL(RSqlStatement& aStmt)
+ {
+ TInt colsize = aStmt.ColumnSize(2);
+ TEST(colsize == sizeof(TReal));
+ }
+
+//"RSqlStatement::BindNull()" OOM test
+void StmtBindNullL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.BindNull(1);
+ //The bindings will be transferred on the server side right before Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::BindInt()" OOM test
+void StmtBindIntL(RSqlStatement& aStmt)
+ {
+ TInt val = 184;
+ TInt err = aStmt.BindInt(0, val);
+ //The bindings will be transferred on the server side right before Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::BindInt64()" OOM test
+void StmtBindInt64L(RSqlStatement& aStmt)
+ {
+ TInt64 val = MAKE_TINT64(0x00FF00FF, 0x12345678);
+ TInt err = aStmt.BindInt64(1, val);
+ //The bindings will be transferred on the server side right before Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::BindReal()" OOM test
+void StmtBindRealL(RSqlStatement& aStmt)
+ {
+ TReal val = 25.2423;
+ TInt err = aStmt.BindReal(2, val);
+ //The bindings will be transferred on the server side right before Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::BindText()" OOM test
+void StmtBindTextL(RSqlStatement& aStmt)
+ {
+ for(TInt i=0;i<KLongParameterSize;++i)
+ {
+ TheTextColumnData[i] = (TUint16)i;
+ }
+ const TPtrC val(TheTextColumnData, KLongParameterSize);
+ TInt err = aStmt.BindText(3, val);
+ //The bindings will be transferred on the server side right before a Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::BindBinary()" OOM test
+void StmtBindBinaryL(RSqlStatement& aStmt)
+ {
+ for(TInt i=0;i<KLongParameterSize;++i)
+ {
+ TheBinaryColumnData[i] = (TUint8)i;
+ }
+ const TPtrC8 val(TheBinaryColumnData, KLongParameterSize);
+ TInt err = aStmt.BindBinary(3, val);
+ //The bindings will be transferred on the server side right before a Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::BindZeroBlob()" OOM test
+void StmtBindZeroBlobL(RSqlStatement& aStmt)
+ {
+ TInt err = aStmt.BindZeroBlob(3, KLongParameterSize);
+ //The bindings will be transferred on the server side right before a Next() or Exec() call
+ if(err == KErrNone)
+ {
+ err = aStmt.Exec();
+ }
+ User::LeaveIfError(err);
+ }
+
+//"RSqlStatement::IsNull()" OOM test
+void StmtIsNullColumnL(RSqlStatement& aStmt)
+ {
+ TBool rc = aStmt.IsNull(0);
+ TEST(!rc);
+ }
+
+//"RSqlStatement::ColumnInt()" OOM test
+void StmtColumnIntL(RSqlStatement& aStmt)
+ {
+ TInt val = aStmt.ColumnInt(0);
+ TEST(val == 10);
+ }
+
+//"RSqlStatement::ColumnInt64()" OOM test
+void StmtColumnInt64L(RSqlStatement& aStmt)
+ {
+ TInt64 val = aStmt.ColumnInt64(1);
+ TEST(val == 100);
+ }
+
+//"RSqlStatement::ColumnReal()" OOM test
+void StmtColumnRealL(RSqlStatement& aStmt)
+ {
+ TReal val = aStmt.ColumnReal(2);
+ TEST(Abs(val - 100.001) < 0.000001);
+ }
+
+//"RSqlStatement::ColumnTextL()" OOM test
+void StmtColumnText1L(RSqlStatement& aStmt)
+ {
+ TPtrC val = aStmt.ColumnTextL(3);
+ TEST(val.Length() == KLongColumnSize);
+ for(TInt i=0;i<KLongColumnSize;++i)
+ {
+ TEST(val[i] == (TUint16)i);
+ }
+ }
+
+//"RSqlStatement::ColumnText()" OOM test
+void StmtColumnText2L(RSqlStatement& aStmt)
+ {
+ TPtrC val;
+ TInt err = aStmt.ColumnText(3, val);
+ User::LeaveIfError(err);
+ TEST(val.Length() == KLongColumnSize);
+ for(TInt i=0;i<KLongColumnSize;++i)
+ {
+ TEST(val[i] == (TUint16)i);
+ }
+ }
+
+//"RSqlStatement::ColumnText()" OOM test
+void StmtColumnText3L(RSqlStatement& aStmt)
+ {
+ TPtr val(TheTextColumnData, KLongColumnSize);
+ TInt err = aStmt.ColumnText(3, val);
+ User::LeaveIfError(err);
+ TEST(val.Length() == KLongColumnSize);
+ for(TInt i=0;i<KLongColumnSize;++i)
+ {
+ TEST(val[i] == (TUint16)i);
+ }
+ }
+
+//"RSqlStatement::ColumnBinaryL()" OOM test
+void StmtColumnBinary1L(RSqlStatement& aStmt)
+ {
+ TPtrC8 val = aStmt.ColumnBinaryL(4);
+ TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
+ for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
+ {
+ TUint8 valLow = val[j];
+ TUint8 valHigh = val[j + 1];
+ TEST(valLow == (TUint8)(i & 0xFF));
+ TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
+ }
+ }
+
+//"RSqlStatement::ColumnBinary()" OOM test
+void StmtColumnBinary2L(RSqlStatement& aStmt)
+ {
+ TPtrC8 val;
+ TInt err = aStmt.ColumnBinary(4, val);
+ User::LeaveIfError(err);
+ TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
+ for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
+ {
+ TUint8 valLow = val[j];
+ TUint8 valHigh = val[j + 1];
+ TEST(valLow == (TUint8)(i & 0xFF));
+ TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
+ }
+ }
+
+//"RSqlStatement::ColumnBinary()" OOM test
+void StmtColumnBinary3L(RSqlStatement& aStmt)
+ {
+ TPtr8 val(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));
+ TInt err = aStmt.ColumnBinary(4, val);
+ User::LeaveIfError(err);
+ TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
+ for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
+ {
+ TUint8 valLow = val[j];
+ TUint8 valHigh = val[j + 1];
+ TEST(valLow == (TUint8)(i & 0xFF));
+ TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
+ }
+ }
+
+//"RSqlStatement::ColumnCount()" OOM test
+void StmtColumnCount(RSqlStatement& aStmt)
+ {
+ TInt cnt = aStmt.ColumnCount();
+ TEST2(cnt, 5);
+ }
+
+//"RSqlStatement::DeclaredColumnType()" OOM test
+void StmtDeclaredColumnTypeL(RSqlStatement& aStmt)
+ {
+ TInt cnt = aStmt.ColumnCount();
+ TEST2(cnt, 5);
+ const TSqlColumnType KColTypes[] = {ESqlInt, ESqlInt, ESqlReal, ESqlText, ESqlBinary};
+ for(TInt i=0;i<cnt;++i)
+ {
+ TSqlColumnType colType;
+ TInt err = aStmt.DeclaredColumnType(i, colType);
+ User::LeaveIfError(err);
+ TEST2(colType, KColTypes[i]);
+ }
+ }
+
+//"RSqlColumnReadStream::ColumnBinary()" OOM test
+void StmtColumnBinaryStreamL(RSqlStatement& aStmt)
+ {
+ RSqlColumnReadStream strm;
+ CleanupClosePushL(strm);
+ TInt err = strm.ColumnBinary(aStmt, 4);
+ User::LeaveIfError(err);
+ strm.ReadL(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));
+ CleanupStack::PopAndDestroy(&strm);
+ for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
+ {
+ TUint8 valLow = TheBinaryColumnData[j];
+ TUint8 valHigh = TheBinaryColumnData[j + 1];
+ TEST(valLow == (TUint8)(i & 0xFF));
+ TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
+ }
+ }
+
+//"RSqlColumnReadStream::ColumnText()" OOM test
+void StmtColumnTextStreamL(RSqlStatement& aStmt)
+ {
+ RSqlColumnReadStream strm;
+ CleanupClosePushL(strm);
+ TInt err = strm.ColumnText(aStmt, 3);
+ User::LeaveIfError(err);
+ strm.ReadL(TheTextColumnData, KLongColumnSize);
+ CleanupStack::PopAndDestroy(&strm);
+ for(TInt i=0;i<KLongColumnSize;++i)
+ {
+ TEST(TheTextColumnData[i] == (TUint16)i);
+ }
+ }
+
+//"RSqlParamWriteStream::BindBinary()" OOM test
+void StmtParamBinaryStreamL(RSqlStatement& aStmt)
+ {
+ for(TInt i=0;i<KLongParameterSize;++i)
+ {
+ TheTextColumnData[i] = (TUint16)i;
+ }
+
+ RSqlParamWriteStream strm;
+ CleanupClosePushL(strm);
+ TInt err = strm.BindBinary(aStmt, 3);
+ User::LeaveIfError(err);
+ strm.WriteL((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
+ CleanupStack::PopAndDestroy(&strm);
+ }
+
+//"RSqlParamWriteStream::BindText()" OOM test
+void StmtParamTextStreamL(RSqlStatement& aStmt)
+ {
+ for(TInt i=0;i<KLongParameterSize;++i)
+ {
+ TheTextColumnData[i] = (TUint16)i;
+ }
+
+ RSqlParamWriteStream strm;
+ CleanupClosePushL(strm);
+ TInt err = strm.BindText(aStmt, 3);
+ User::LeaveIfError(err);
+ strm.WriteL(TheTextColumnData, KLongColumnSize);
+ CleanupStack::PopAndDestroy(&strm);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SQL-CT-1618
+@SYMTestCaseDesc RSqlStatement methods OOM tests
+ Precondition: the database exists, opened, some record(s) inserted.
+ The test calls the given as an argument function while simulating OOM failures
+ and checks that there are no memory and resource leaks.
+@SYMTestPriority High
+@SYMTestActions RSqlStatement methods OOM tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ5792
+ REQ5793
+*/
+void DoStmtOomTestL(TStmtFuncPtrL aStmtPrepareFuncPtrL, TStmtFuncPtr2L aStmtTestFuncPtrL, const TDesC& aDbFileName, TDbType aDbType)
+ {
+ //This is not really an OOM test, because:
+ //(A) The test forces the server to simulate heap failure on determied allocation step
+ //(B) SQL server counts only the number of active statement and stream objects, the allocated memory cells
+ // are not counted.
+ // The reason that the allocated memory cells are not counted and in case of OOM failure - checked is
+ // because the SQL server may make some per-connection persistent memory allocations (cache pages, etc.)
+ // which will not be deallocated when the statement object is closed.
+
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1618 RSqlStatement - OOM test"));
+ RSqlSecurityPolicy securityPolicy;
+ CreateTestSecurityPolicy(securityPolicy);
+ for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
+ {
+ RSqlDatabase::Delete(aDbFileName);
+ RSqlDatabase db;
+ TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
+ TEST2(err, KErrNone);
+ err = db.Exec(KSqlDbString);
+ TEST(err >= 0);
+ err = db.Exec(KSqlDbString2);
+ TEST(err >= 0);
+
+ err = KErrNoMemory;
+ const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
+ TInt allocationNo = 0;
+ TInt failingAllocationNo = 0;
+ while(allocationNo < KMaxAllocation)
+ {
+ MarkHandles();
+ MarkAllocatedCells();
+
+ __UHEAP_MARK;
+
+ RSqlStatement stmt;
+ TRAP(err, (*aStmtPrepareFuncPtrL)(db, stmt));
+ TEST2(err, KErrNone);
+
+ SetHeapFailure(TheOomTestType[i], ++allocationNo);
+
+ TRAP(err, (*aStmtTestFuncPtrL)(stmt));
+
+ //ResetHeapFailure() has to be called before stmt.Close() because,
+ //otherwise it will panic the server (the server resource count, marked by
+ //SetHeapFailure() call, is 1 (there is one prepared statement))
+ ResetHeapFailure(TheOomTestType[i]);
+
+ stmt.Close();
+
+ if(err != KErrNoMemory)
+ {
+ TEST2(err, KErrNone);
+ }
+ else
+ {
+ failingAllocationNo = allocationNo;
+ }
+
+ __UHEAP_MARKEND;
+
+ CheckAllocatedCells();
+ CheckHandles();
+ }
+
+ db.Close();
+ TEST2(err, KErrNone);
+ PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
+ }
+ //Delete the database file
+ RSqlDatabase::Delete(aDbFileName);
+ securityPolicy.Close();
+ }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////// RSqlBlobReadStream, RSqlBlobWriteStream - OOM tests /////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//RSqlBlobReadStream, RSqlBlobWriteStream - OOM test preparation.
+void ExecInsertBlobL(RSqlDatabase& aDb)
+ {
+ _LIT8(KSqlString1, "CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB)");
+ TInt err = aDb.Exec(KSqlString1);
+ User::LeaveIfError(err);
+ _LIT8(KSqlString2, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, 'AAA', x'");
+ TheSqlBuf.Copy(KSqlString2);
+ for(TInt i=0;i<KBlobStrLen;++i)
+ {
+ TheSqlBuf.Append(_L8("A5"));
+ }
+ TheSqlBuf.Append(_L8("')"));
+ err = aDb.Exec(TheSqlBuf);
+ User::LeaveIfError(err);
+ }
+
+//"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()" OOM test
+void BlobReadStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ RSqlBlobReadStream strm;
+ CleanupClosePushL(strm);
+ if(aAttachDbName.Length() > 0)
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
+ }
+ else
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
+ }
+ const TInt KReadOpCnt = 8;
+ for(TInt j=0;j<KReadOpCnt;++j)
+ {
+ strm.ReadL(TheSqlBuf, KBlobLen / KReadOpCnt);
+ TEST2(TheSqlBuf.Length(), (KBlobLen / KReadOpCnt));
+ for(TInt i=0;i<(KBlobLen / KReadOpCnt);++i)
+ {
+ TUint8 val = TheSqlBuf[i];
+ TEST2(val, 0xA5);
+ }
+ }
+ CleanupStack::PopAndDestroy(&strm);
+ }
+
+//"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()" OOM test
+void BlobReadStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ RSqlBlobReadStream strm;
+ CleanupClosePushL(strm);
+ if(aAttachDbName.Length() > 0)
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
+ }
+ else
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
+ }
+ TInt size = strm.SizeL();
+ TEST2(size, KBlobLen);
+ CleanupStack::PopAndDestroy(&strm);
+ }
+
+//"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()" OOM test
+void BlobWriteStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ RSqlBlobWriteStream strm;
+ CleanupClosePushL(strm);
+ if(aAttachDbName.Length() > 0)
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
+ }
+ else
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
+ }
+ const TInt KWriteOpCnt = 8;
+ TheSqlBuf.SetLength(KBlobLen / KWriteOpCnt);
+ TheSqlBuf.Fill(TChar('Z'));
+ for(TInt j=0;j<KWriteOpCnt;++j)
+ {
+ strm.WriteL(TheSqlBuf, KBlobLen / KWriteOpCnt);
+ }
+ strm.CommitL();
+ CleanupStack::PopAndDestroy(&strm);
+ }
+
+//"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()" OOM test
+void BlobWriteStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ RSqlBlobWriteStream strm;
+ CleanupClosePushL(strm);
+ if(aAttachDbName.Length() > 0)
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
+ }
+ else
+ {
+ strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
+ }
+ TInt size = strm.SizeL();
+ TEST2(size, KBlobLen);
+ CleanupStack::PopAndDestroy(&strm);
+ }
+
+//"TSqlBlob::GetLC()" OOM test
+void BlobWholeGet1L(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ HBufC8* buf = NULL;
+ if(aAttachDbName.Length() > 0)
+ {
+ buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
+ }
+ else
+ {
+ buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1);
+ }
+ TEST(buf->Length() == KBlobStrLen);
+ CleanupStack::PopAndDestroy(buf);
+ }
+
+//"TSqlBlob::Get()" OOM test
+void BlobWholeGet2L(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ if(aAttachDbName.Length() > 0)
+ {
+ TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1, aAttachDbName);
+ }
+ else
+ {
+ TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1);
+ }
+ }
+
+//"TSqlBlob::SetL()" OOM test
+void BlobWholeSetL(RSqlDatabase& aDb, const TDesC& aAttachDbName = KNullDesC)
+ {
+ if(aAttachDbName.Length() > 0)
+ {
+ TSqlBlob::SetL(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1, aAttachDbName);
+ }
+ else
+ {
+ TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1);
+ }
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SQL-UT-4091
+@SYMTestCaseDesc RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests
+ Precondition: the database exists, opened, some record(s) inserted.
+ The test calls the given as an argument function while simulating OOM failures
+ and checks that there are no memory and resource leaks.
+@SYMTestPriority High
+@SYMTestActions RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ5792
+ REQ10410
+ REQ10411
+ REQ10418
+*/
+void DoBlobOomTestL(TBlobPrepareFuncPtrL aBlobPrepareFuncPtrL, TBlobTestFuncPtrL aBlobTestFuncPtrL,
+ const TDesC& aDbFileName, TDbType aDbType, TBool aAttachDb = EFalse)
+ {
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4091 RSqlBlobReadStream, RSqlBlobWriteStream - OOM test"));
+ RSqlSecurityPolicy securityPolicy;
+ CreateTestSecurityPolicy(securityPolicy);
+ for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
+ {
+ RSqlDatabase::Delete(aDbFileName);
+ RSqlDatabase db;
+ TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
+ TEST2(err, KErrNone);
+ TRAP(err, (*aBlobPrepareFuncPtrL)(db));
+ TEST2(err, KErrNone);
+ _LIT(KAttachDbName, "AttachDb");
+ if(aAttachDb)
+ {
+ err = db.Attach(aDbFileName, KAttachDbName);
+ TEST2(err, KErrNone);
+ }
+
+ err = KErrNoMemory;
+ const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KBlobOomTestAllocLimitServer : KBlobOomTestAllocLimitClient;
+ TInt allocationNo = 0;
+ TInt failingAllocationNo = 0;
+ while(allocationNo < KMaxAllocation)
+ {
+ MarkHandles();
+ MarkAllocatedCells();
+
+ __UHEAP_MARK;
+
+ SetHeapFailure(TheOomTestType[i], ++allocationNo);
+ if(aAttachDb)
+ {
+ TRAP(err, (*aBlobTestFuncPtrL)(db, KAttachDbName));
+ }
+ else
+ {
+ TRAP(err, (*aBlobTestFuncPtrL)(db));
+ }
+
+ ResetHeapFailure(TheOomTestType[i]);
+
+ if(err != KErrNoMemory)
+ {
+ if(err != KErrNone)
+ {
+ TPtrC errmsg = db.LastErrorMessage();
+ if(errmsg.Length() > 0)
+ {
+ TheTest.Printf(_L("\r\n@@@ error %d, error message: %S\r\n"), err, &errmsg);
+ }
+ }
+ TEST2(err, KErrNone);
+ }
+ else
+ {
+ failingAllocationNo = allocationNo;
+ }
+
+ __UHEAP_MARKEND;
+
+ CheckAllocatedCells();
+ CheckHandles();
+ }
+ TEST2(err, KErrNone);
+
+ if(aAttachDb)
+ {
+ (void)db.Detach(KAttachDbName);
+ }
+
+ db.Close();
+ err = RSqlDatabase::Delete(aDbFileName);
+ TEST2(err, KErrNone);
+ PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
+ }
+ securityPolicy.Close();
+ }
+
+void ScalarFullSelectInt_8L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TInt val = query.SelectIntL(_L8("SELECT F1 FROM A WHERE F3 < 0"));
+ TEST2(val, 2);
+ }
+
+void ScalarFullSelectInt64_8L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TInt64 val = query.SelectInt64L(_L8("SELECT F2 FROM A WHERE F1 = 1"));
+ TEST2(val, 10000000000LL);
+ }
+
+void ScalarFullSelectReal_8L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TReal val = query.SelectRealL(_L8("SELECT F3 FROM A WHERE F1 = 1"));
+ TEST(val > 2.0 && val < 3.0);
+ }
+
+void ScalarFullSelectText_8L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TBuf<20> buf;
+ TInt err = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), buf);
+ TEST2(err, KErrNone);
+ _LIT(KText, "NAME1234567890");
+ TEST(buf == KText);
+ }
+
+void ScalarFullSelectBinary_8L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TBuf8<20> buf;
+ TInt err = query.SelectBinaryL(_L8("SELECT F5 FROM A WHERE F1 = 1"), buf);
+ TEST2(err, KErrNone);
+ TEST(buf.Length() == 0);
+ }
+
+void ScalarFullSelectInt_16L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TInt val = query.SelectIntL(_L16("SELECT F1 FROM A WHERE F3 < 0"));
+ TEST2(val, 2);
+ }
+
+void ScalarFullSelectInt64_16L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TInt64 val = query.SelectInt64L(_L16("SELECT F2 FROM A WHERE F1 = 1"));
+ TEST2(val, 10000000000LL);
+ }
+
+void ScalarFullSelectReal_16L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TReal val = query.SelectRealL(_L16("SELECT F3 FROM A WHERE F1 = 1"));
+ TEST(val > 2.0 && val < 3.0);
+ }
+
+void ScalarFullSelectText_16L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TBuf<20> buf;
+ TInt err = query.SelectTextL(_L16("SELECT F4 FROM A WHERE F1 = 1"), buf);
+ TEST2(err, KErrNone);
+ _LIT(KText, "NAME1234567890");
+ TEST(buf == KText);
+ }
+
+void ScalarFullSelectBinary_16L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ TBuf8<20> buf;
+ TInt err = query.SelectBinaryL(_L16("SELECT F5 FROM A WHERE F1 = 1"), buf);
+ TEST2(err, KErrNone);
+ TEST(buf.Length() == 0);
+ }
+
+void ScalarFullSelectText2_8L(RSqlDatabase& aDb)
+ {
+ TSqlScalarFullSelectQuery query(aDb);
+ HBufC* buf = HBufC::NewLC(8);
+ TPtr name = buf->Des();
+ TInt rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);
+ TEST(rc >= 0); //the function may return only non-negative values
+ if(rc > 0)
+ {
+ buf = buf->ReAllocL(rc);
+ CleanupStack::Pop();
+ CleanupStack::PushL(buf);
+ name.Set(buf->Des());
+ rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);
+ TEST(rc == 0);
+ _LIT(KText, "NAME1234567890");
+ TEST(name == KText);
+ }
+ CleanupStack::PopAndDestroy(buf);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SQL-CT-1811
+@SYMTestCaseDesc TSqlScalarFullSelectQuery functions OOM test
+ Precondition: the database exists.
+ The test simulates OOM failures while calling TSqlScalarFullSelectQuery functions
+ and checks that there are no memory and resource leaks.
+@SYMTestPriority High
+@SYMTestActions TSqlScalarFullSelectQuery methods OOM tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ5792
+ REQ5793
+*/
+void DoFullSelectOomTest(TScalarFullSelectFuncPtrL aTestFunctionPtrL)
+ {
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1811 TSqlScalarFullSelectQuery - OOM test"));
+ //Create test database
+ RSqlDatabase db;
+ TInt err = db.Create(KTestDb);
+ TEST2(err, KErrNone);
+ err = db.Exec(_L("CREATE TABLE A(F1 INTEGER, F2 INTEGER, F3 FLOAT, F4 TEXT, F5 BLOB)"));
+ TEST(err >= 0);
+ err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4, F5) VALUES(1, 10000000000, 2.54, 'NAME1234567890', NULL)"));
+ TEST2(err, 1);
+ err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4) VALUES(2, 200, -1.11, 'ADDRESS')"));
+ TEST2(err, 1);
+ db.Close();
+ //OOM test loop
+ for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
+ {
+ err = KErrNoMemory;
+ const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
+ TInt allocationNo = 0;
+ TInt failingAllocationNo = 0;
+ while(allocationNo < KMaxAllocation)
+ {
+ MarkHandles();
+ MarkAllocatedCells();
+
+ __UHEAP_MARK;
+
+ if(TheOomTestType[i] == EServerSideTest)
+ {//We will delay the heap failure simulation, until the database is opened
+ SetDbHeapFailure(TheOomTestType[i], ++allocationNo, ETrue);
+ }
+
+ err = db.Open(KTestDb);
+ TEST2(err, KErrNone);
+
+ if(TheOomTestType[i] == EClientSideTest)
+ {
+ SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
+ }
+
+ TRAP(err, (*aTestFunctionPtrL)(db));
+ db.Close();
+ if(err != KErrNoMemory)
+ {
+ TEST2(err, KErrNone);
+ }
+ else
+ {
+ failingAllocationNo = allocationNo;
+ }
+
+ ResetDbHeapFailure(TheOomTestType[i]);
+
+ __UHEAP_MARKEND;
+
+ CheckAllocatedCells();
+ CheckHandles();
+ }
+ TEST2(err, KErrNone);
+ PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
+ }
+ //Delete the database file
+ RSqlDatabase::Delete(KTestDb);
+ }
+
+//RSqlStatement OOM tests
+void StmtOomTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));
+ DoStmtPrepareOomTestL(&PrepareStmt8L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::PrepareL(), 8-bit SQL\r\n"));
+ DoStmtPrepareOomTestL(&PrepareStmt8_2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));
+ DoStmtPrepareOomTestL(&PrepareStmt16L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::PrepareL(), 16-bit SQL\r\n"));
+ DoStmtPrepareOomTestL(&PrepareStmt16_2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Reset(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareStmt8L, &ResetStmtL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Reset(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareStmt16L, &ResetStmtL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Exec(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertStmt8L, &ExecStmtL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Exec(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertStmt16L, &ExecStmtL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Next(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareStmt8L, &NextStmtL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::Next(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareStmt16L, &NextStmtL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterIndexL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterIndexL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ParameterName(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterNameL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ParameterName(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterNameL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ParamName(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamNameL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ParamName(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamNameL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareStmt8L, &StmtColumnIndexL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareStmt16L, &StmtColumnIndexL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnType(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnTypeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnType(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnTypeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnSizeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnSizeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnName(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnNameL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnName(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnNameL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindNull(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindNullL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindNull(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindNullL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindInt(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindIntL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindInt(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindIntL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindInt64(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindInt64L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindInt64(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindInt64L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindReal(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindRealL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindReal(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindRealL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindText(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindTextL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindText(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindTextL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindBinary(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindBinaryL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindBinary(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindBinaryL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::IsNull(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::IsNull(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnIntL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnIntL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnInt64L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnInt64L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnRealL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnRealL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText1L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText1L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText3L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText3L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnCount, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnCount, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);
+ }
+ }
+
+//RSqlStatement - negative OOM tests
+void StmtOomNegativeTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));
+ DoStmtPrepareOomTestL(&PrepareBadStmt8L, dbFileName[i], dbType[i], KSqlErrGeneral);
+
+ TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));
+ DoStmtPrepareOomTestL(&PrepareBadStmt16L, dbFileName[i], dbType[i], KSqlErrGeneral);
+ }
+ }
+
+//RSqlColumnReadStream OOM tests
+void ColumnReadStreamOomTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);
+ }
+ }
+
+//RSqlParamWriteStream OOM tests
+void ParamWriteStreamOomTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 8-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 16-bit SQL\r\n"));
+ DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);
+ }
+ }
+
+//TSqlScalarFullSelectQuery OOM tests
+void ScalarFullSelectQueryOomTestsL()
+ {
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 8-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectInt_8L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 8-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectInt64_8L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 8-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectReal_8L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectText_8L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 8-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectBinary_8L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 16-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectInt_16L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 16-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectInt64_16L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 16-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectReal_16L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 16-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectText_16L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 16-bit SQL\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectBinary_16L);
+
+ TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL, small buffer\r\n"));
+ DoFullSelectOomTest(&ScalarFullSelectText2_8L);
+ }
+
+void BlobReadStreamOomTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL() + attached database\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i], ETrue);
+
+ TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL() + attached database\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i], ETrue);
+ }
+ }
+
+void BlobWriteStreamOomTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL() + attached database\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i], ETrue);
+
+ TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL() + attached database\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i], ETrue);
+ }
+ }
+
+void BlobWholeOomTestsL()
+ {
+ const TInt KTestCnt = 2;
+ const TPtrC dbFileName[KTestCnt] = {KTestDb(), KSecureTestDb()};
+ TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
+
+ for(TInt i=0;i<KTestCnt;++i)
+ {
+ TheTest.Printf(_L("===TSqlBlob::GetLC()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet1L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===TSqlBlob::Get()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet2L, dbFileName[i], dbType[i]);
+
+ TheTest.Printf(_L("===TSqlBlob::SetL()\r\n"));
+ DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeSetL, dbFileName[i], dbType[i]);
+ }
+ }
+
+void DoTestsL()
+ {
+ TheTest.Start(_L("SQL OOM tests - 2"));
+
+ StmtOomTestsL();
+
+ StmtOomNegativeTestsL();
+
+ ColumnReadStreamOomTestsL();
+
+ ParamWriteStreamOomTestsL();
+
+ ScalarFullSelectQueryOomTestsL();
+
+ BlobReadStreamOomTestsL();
+
+ BlobWriteStreamOomTestsL();
+
+ BlobWholeOomTestsL();
+ }
+
+TInt E32Main()
+ {
+ TheTest.Title();
+
+ CTrapCleanup* tc = CTrapCleanup::New();
+
+ __UHEAP_MARK;
+
+ CreateTestDir();
+ DeleteTestFiles();
+
+ TRAPD(err, DoTestsL());
+ DeleteTestFiles();
+ TEST2(err, KErrNone);
+
+ __UHEAP_MARKEND;
+
+ TheTest.End();
+ TheTest.Close();
+
+ delete tc;
+
+ User::Heap().Check();
+ return KErrNone;
+ }