// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include <e32test.h>
#include <bautils.h>
#include "SqlSrvMain.h"
#include "SqlSrvStartup.h"
#include "SqlSrvUtil.h"
#include "SqlSrvDatabase.h"
#include "SqlSrvFileData.h"
///////////////////////////////////////////////////////////////////////////////////////
RTest TheTest(_L("t_sqloom5 test"));
RFs TheFs;
_LIT(KTestDir, "c:\\test\\");
_LIT(KDbFile, "c:\\test\\t_sqloom5.db");
_LIT(KDbFile2, "c:[10281E17]t_sqloom5.db");
_LIT(KDbFile3, "c:[10281E17]t_sqloom5_2.db");
_LIT(KDbFile4, "c:[10281E17]t_sqloom5_3.db");
_LIT8(KConfig, "encoding=UTF-8");
extern CSqlServer* TheServer;
static TInt TheProcessHandleCount = 0;
static TInt TheThreadHandleCount = 0;
static TInt TheAllocatedCellsCount = 0;
#ifdef _DEBUG
static const TInt KBurstRate = 20;
#endif
enum TSqlDbEncoding
{
ESqlDbUtf16,
ESqlDbUtf8
};
///////////////////////////////////////////////////////////////////////////////////////
void DestroyTestEnv()
{
(void)TheFs.Delete(KDbFile4);
(void)TheFs.Delete(KDbFile3);
(void)TheFs.Delete(KDbFile2);
(void)TheFs.Delete(KDbFile);
TheFs.Close();
}
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check(TInt aValue, TInt aLine)
{
if(!aValue)
{
DestroyTestEnv();
RDebug::Print(_L("*** Expresssion evaluated to false\r\n"));
TheTest(EFalse, aLine);
}
}
void Check(TInt aValue, TInt aExpected, TInt aLine)
{
if(aValue != aExpected)
{
DestroyTestEnv();
RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
TheTest(EFalse, aLine);
}
}
#define TEST(arg) ::Check((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void MarkHandles()
{
RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
}
static void MarkAllocatedCells()
{
TheAllocatedCellsCount = User::CountAllocCells();
}
static void CheckAllocatedCells()
{
TInt allocatedCellsCount = User::CountAllocCells();
TEST2(allocatedCellsCount, TheAllocatedCellsCount);
}
static void CheckHandles()
{
TInt endProcessHandleCount;
TInt endThreadHandleCount;
RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
TEST2(TheProcessHandleCount, endProcessHandleCount);
TEST2(TheThreadHandleCount, endThreadHandleCount);
}
static void OomPreStep(TInt
#ifdef _DEBUG
aFailingAllocationNo
#endif
)
{
MarkHandles();
MarkAllocatedCells();
__UHEAP_MARK;
__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, aFailingAllocationNo, KBurstRate);
}
static void OomPostStep()
{
__UHEAP_RESET;
__UHEAP_MARKEND;
CheckAllocatedCells();
CheckHandles();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CreateTestEnv()
{
TInt err = TheFs.Connect();
TEST2(err, KErrNone);
err = TheFs.MkDir(KTestDir);
TEST(err == KErrNone || err == KErrAlreadyExists);
err = TheFs.CreatePrivatePath(EDriveC);
TEST(err == KErrNone || err == KErrAlreadyExists);
}
static CSqlServer* CreateSqlServerL()
{
CSqlServer* server = CSqlServer::NewLC();
CleanupStack::Pop(server);
return server;
}
void CreateDatabaseOomTest(TSqlDbEncoding aEncoding)
{
(void)TheFs.Delete(KDbFile);
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
TSqlSrvFileData& fdata = TheServer->FileData();
RMessage2 msg;
TRAP(err, fdata.SetL(msg, KDbFile().Length(), 0, KDbFile, aEncoding == ESqlDbUtf8 ? &KConfig : NULL));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::CreateL(fdata));
delete db;
}
OomPostStep();
}
delete TheServer;
TheServer = NULL;
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::CreateL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
}
/**
@SYMTestCaseID PDS-SQL-UT-4167
@SYMTestCaseDesc CSqlSrvDatabase::CreateL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::CreateL() in an OOM loop.
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577
*/
void Utf16CreateDatabaseOomTest()
{
CreateDatabaseOomTest(ESqlDbUtf16);
}
/**
@SYMTestCaseID PDS-SQL-UT-4182
@SYMTestCaseDesc CSqlSrvDatabase::CreateL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::CreateL() in an OOM loop.
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF145047
*/
void Utf8CreateDatabaseOomTest()
{
CreateDatabaseOomTest(ESqlDbUtf8);
}
void OpenDatabaseOomTest()
{
//The database is created by the previous test: CreateDatabaseOomTest().
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
TSqlSrvFileData& fdata = TheServer->FileData();
RMessage2 msg;
TRAP(err, fdata.SetL(msg, KDbFile().Length(), 0, KDbFile));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::OpenL(fdata));
delete db;
}
OomPostStep();
}
delete TheServer;
TheServer = NULL;
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::OpenL() [non-secure db] OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
}
/**
@SYMTestCaseID PDS-SQL-UT-4168
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() OOM test - non-secure database.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() in an OOM loop.
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577
*/
void Utf16OpenDatabaseOomTest()
{
OpenDatabaseOomTest();
}
/**
@SYMTestCaseID PDS-SQL-UT-4183
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() OOM test - non-secure database.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() in an OOM loop.
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF145047
*/
void Utf8OpenDatabaseOomTest()
{
OpenDatabaseOomTest();
}
void CreateSecureDatabaseOomTest(TSqlDbEncoding aEncoding)
{
(void)TheFs.Delete(KDbFile2);
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
TSqlSrvFileData& fdata = TheServer->FileData();
RMessage2 msg;
TRAP(err, fdata.SetL(msg, KDbFile2().Length(), 0, KDbFile2, aEncoding == ESqlDbUtf8 ? &KConfig : NULL));
if(err == KErrNone)
{
TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
CSqlSecurityPolicy* policy = NULL;
TRAP(err, policy = CSqlSecurityPolicy::NewL(defaultPolicy));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::CreateSecureL(fdata, policy));
delete db;
}
}
OomPostStep();
}
delete TheServer;
TheServer = NULL;
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::CreateSecureL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
}
/**
@SYMTestCaseID PDS-SQL-UT-4169
@SYMTestCaseDesc CSqlSrvDatabase::CreateSecureL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::CreateSecureL() in an OOM loop.
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577
*/
void Utf16CreateSecureDatabaseOomTest()
{
CreateSecureDatabaseOomTest(ESqlDbUtf16);
}
/**
@SYMTestCaseID PDS-SQL-UT-4184
@SYMTestCaseDesc CSqlSrvDatabase::CreateSecureL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::CreateSecureL() in an OOM loop.
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF145047
*/
void Utf8CreateSecureDatabaseOomTest()
{
CreateSecureDatabaseOomTest(ESqlDbUtf8);
}
void OpenSecureDatabaseOomTest()
{
//The database is created by the previous test: CreateSecureDatabaseOomTest().
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
TSqlSrvFileData& fdata = TheServer->FileData();
RMessage2 msg;
TRAP(err, fdata.SetL(msg, KDbFile2().Length(), 0, KDbFile2));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::OpenL(fdata));
delete db;
}
OomPostStep();
}
delete TheServer;
TheServer = NULL;
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::OpenL() [secure db] OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
}
/**
@SYMTestCaseID PDS-SQL-UT-4170
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() OOM test - secure database.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() in an OOM loop.
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577, PDEF44845
*/
void Utf16OpenSecureDatabaseOomTest()
{
OpenSecureDatabaseOomTest();
}
/**
@SYMTestCaseID PDS-SQL-UT-4185
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() OOM test - secure database.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() in an OOM loop.
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF145047
*/
void Utf8OpenSecureDatabaseOomTest()
{
OpenSecureDatabaseOomTest();
}
/////////////////////////////////////////////////////////////
const TInt KDbConnCount = 7;
#ifdef _DEBUG
const TInt KDbAttachedCount = 10;
#endif
TBuf<10> TheAttachedDbName;
//Declares KDbConnCount "CSqlSrvDatabase*" variables.
#define TEST_DECLARE_DB_VARS() \
CSqlSrvDatabase* db[KDbConnCount]; \
Mem::FillZ(db, sizeof(db));
//Declares all KDbConnCount "CSqlSrvDatabase*" objects.
#define TEST_DELETE_DB() \
for(TInt i=0;i<KDbConnCount;++i) \
{ \
delete db[i]; \
}
//Creates CSqlSrvDatabase object where the database file is dbFile (the second macro parameter).
//The CSqlSrvDatabase pointer db[N - 1] (N is the first macro parameter) will be set to point to
//the created CSqlSrvDatabase object.
//N is the number of the database to be opened, between 1 and KDbConnCount.
#define TEST_OPEN_DB(N, dbFile) \
__ASSERT_DEBUG(N > 0 && N <= KDbConnCount, User::Invariant()); \
TRAP(err, fdata.SetL(msg, dbFile.Length(), 0, dbFile)); \
if(err != KErrNone) \
{ \
goto Cleanup; \
} \
db[N - 1] = NULL; \
TRAP(err, db[N - 1] = CSqlSrvDatabase::OpenL(fdata)); \
if(err != KErrNone) \
{ \
goto Cleanup; \
}
//Attaches the "dbFile" database to the database number specified by the first macro parameter.
//The attached database name is "A<M>", where M is the third macro parameter.
//N is the number of the database connection, between 1 and KDbConnCount.
//M is the number of the database to be attached, between 1 and KDbAttachedCount.
#define TEST_ATTACH_DB(N, dbFile, M) \
__ASSERT_DEBUG(N > 0 && N <= KDbConnCount, User::Invariant()); \
__ASSERT_DEBUG(M > 0 && M <= KDbAttachedCount, User::Invariant()); \
TRAP(err, fdata.SetL(msg, dbFile.Length(), 0, dbFile)); \
if(err != KErrNone) \
{ \
goto Cleanup; \
} \
TheAttachedDbName.Copy(_L("A")); \
TheAttachedDbName.AppendNum(M); \
TRAP(err, db[N - 1]->AttachDbL(fdata, TheAttachedDbName)); \
if(err != KErrNone) \
{ \
goto Cleanup; \
}
//Detaches database "A<M>" (M is the second macro parameter) from the database identified
//by the number N - the first macro parameter.
//N is the number of the database connection, between 1 and KDbConnCount.
//M is the number of the database to be detached, between 1 and KDbAttachedCount.
#define TEST_DETACH_DB(N, M) \
__ASSERT_DEBUG(N > 0 && N <= KDbConnCount, User::Invariant()); \
__ASSERT_DEBUG(M > 0 && M <= KDbAttachedCount, User::Invariant()); \
if(db[N - 1]) \
{ \
TheAttachedDbName.Copy(_L("A")); \
TheAttachedDbName.AppendNum(M); \
TRAP_IGNORE(db[N - 1]->DetachDbL(TheAttachedDbName)); \
}
/////////////////////////////////////////////////////////////
void CreateSecureTestDb(const TDesC& aDbFile, TSqlDbEncoding aEncoding)
{
(void)TheFs.Delete(aDbFile);
TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
CSqlSecurityPolicy* policy = NULL;
TRAPD(err, policy = CSqlSecurityPolicy::NewL(defaultPolicy));
TEST2(err, KErrNone);
TSqlSrvFileData& fdata = TheServer->FileData();
RMessage2 msg;
TRAP(err, fdata.SetL(msg, aDbFile.Length(), 0, aDbFile, aEncoding == ESqlDbUtf8 ? &KConfig : NULL));
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::CreateSecureL(fdata, policy));
delete db;
TEST2(err, KErrNone);
}
void OpenAttachDatabaseOomTest(TSqlDbEncoding aEncoding)
{
//Part of the databases are created by the previous tests.
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
CreateSecureTestDb(KDbFile3, aEncoding);
CreateSecureTestDb(KDbFile4, aEncoding);
//The following 2 declarations are used by the macros in the OOM loop
RMessage2 msg;
TSqlSrvFileData& fdata = TheServer->FileData();
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
//Declare KDbConnCount "CSqlSrvDatabase*" variables.
TEST_DECLARE_DB_VARS();
//Create CSqlSrvDatabase object, the database name is the second parameter of the macro.
//The related db[N - 1] variable will be set to point to the created object.
TEST_OPEN_DB(1, KDbFile2());
TEST_OPEN_DB(2, KDbFile2());
TEST_OPEN_DB(3, KDbFile3());
TEST_OPEN_DB(4, KDbFile3());
TEST_OPEN_DB(5, KDbFile3());
TEST_OPEN_DB(6, KDbFile());
TEST_OPEN_DB(7, KDbFile());
//Attach to the database with the number specified as first macro parameter, the database file, specified
//as second macro parameter. The logical name of the attached database is "A<M>", where M is the third macro parameter.
TEST_ATTACH_DB(1, KDbFile(), 1);
TEST_ATTACH_DB(2, KDbFile(), 2);
TEST_ATTACH_DB(2, KDbFile(), 3);
TEST_ATTACH_DB(5, KDbFile4(), 4);
TEST_ATTACH_DB(2, KDbFile4(), 5);
TEST_ATTACH_DB(2, KDbFile4(), 6);
TEST_ATTACH_DB(5, KDbFile4(), 7);
TEST_ATTACH_DB(5, KDbFile4(), 8);
TEST_ATTACH_DB(1, KDbFile4(), 9);
TEST_ATTACH_DB(1, KDbFile(), 10);
Cleanup:
__UHEAP_SETBURSTFAIL(RAllocator::ENone, 0, 0);
//Detach from the database with the number specified as first macro parameter, the database
//with name "A<M>", where M is the second macro parameter.
TEST_DETACH_DB(1, 9);
TEST_DETACH_DB(1, 1);
TEST_DETACH_DB(1, 10);
TEST_DETACH_DB(2, 2);
TEST_DETACH_DB(2, 3);
TEST_DETACH_DB(2, 5);
TEST_DETACH_DB(2, 6);
TEST_DETACH_DB(5, 4);
TEST_DETACH_DB(5, 7);
TEST_DETACH_DB(5, 8);
//Delete all created CSqlSrvDatabase objects.
TEST_DELETE_DB();
OomPostStep();
}
delete TheServer;
TheServer = NULL;
(void)TheFs.Delete(KDbFile4);
(void)TheFs.Delete(KDbFile3);
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
}
/**
@SYMTestCaseID PDS-SQL-UT-4171
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() and CSqlSrvDatabase::AttachDbL() in an OOM test.
The test is a complex one - 7 (KDbConnCount constant) databases opened
(secure and non-secure), 10 (KDbAttachedCount constant) databases
attached (secure and non-secure).
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577, DEF144603
*/
void Utf16OpenAttachDatabaseOomTest()
{
OpenAttachDatabaseOomTest(ESqlDbUtf16);
}
/**
@SYMTestCaseID PDS-SQL-UT-4186
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() and CSqlSrvDatabase::AttachDbL() in an OOM test.
The test is a complex one - 7 (KDbConnCount constant) databases opened
(secure and non-secure), 10 (KDbAttachedCount constant) databases
attached (secure and non-secure).
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144603
*/
void Utf8OpenAttachDatabaseOomTest()
{
OpenAttachDatabaseOomTest(ESqlDbUtf8);
}
void OpenAttachDatabaseOomTest2(TSqlDbEncoding aEncoding)
{
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
CreateSecureTestDb(KDbFile3, aEncoding);
CreateSecureTestDb(KDbFile4, aEncoding);
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
RMessage2 msg;
TSqlSrvFileData& fdata = TheServer->FileData();
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
TRAP(err, fdata.SetL(msg, KDbFile3().Length(), 0, KDbFile3));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::OpenL(fdata));
if(err == KErrNone)
{
TRAP(err, fdata.SetL(msg, KDbFile4().Length(), 0, KDbFile4));
if(err == KErrNone)
{
TRAP(err, db->AttachDbL(fdata, _L("db2")));
if(err == KErrNone)
{
TRAP(err, db->DetachDbL(_L("db2")));
}
}
delete db;
}
}
OomPostStep();
}
(void)TheFs.Delete(KDbFile4);
(void)TheFs.Delete(KDbFile3);
delete TheServer;
TheServer = NULL;
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM test 2 succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
}
/**
@SYMTestCaseID PDS-SQL-UT-4172
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() and CSqlSrvDatabase::AttachDbL() in an OOM test.
Two secure databases are created and then, in an OOM loop, the test executes this sequence of
commands: open first database, attach the second database, detach the attached database,
close the first database.
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577, PDEF44845
*/
void Utf16OpenAttachDatabaseOomTest2()
{
OpenAttachDatabaseOomTest2(ESqlDbUtf16);
}
/**
@SYMTestCaseID PDS-SQL-UT-4187
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() and CSqlSrvDatabase::AttachDbL() in an OOM test.
Two secure databases are created and then, in an OOM loop, the test executes this sequence of
commands: open first database, attach the second database, detach the attached database,
close the first database.
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF145047
*/
void Utf8OpenAttachDatabaseOomTest2()
{
OpenAttachDatabaseOomTest2(ESqlDbUtf8);
}
void OpenCreateDatabaseOomTest(TSqlDbEncoding aEncoding)
{
TheServer = NULL;
TRAPD(err, TheServer = CreateSqlServerL());
TEST2(err, KErrNone);
(void)TheFs.Delete(KDbFile2);
CreateSecureTestDb(KDbFile2, aEncoding);
TheTest.Printf(_L("Iteration:\r\n"));
//Open the database
TInt failingAllocationNo = 0;
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
OomPreStep(failingAllocationNo);
RMessage2 msg;
TSqlSrvFileData& fdata = TheServer->FileData();
TRAP(err, fdata.SetL(msg, KDbFile2().Length(), 0, KDbFile2));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::OpenL(fdata));
if(err == KErrNone)
{
delete db;
}
else
{
TEST(!db);
}
}
OomPostStep();
}
TEST2(err, KErrNone);
err = TheFs.Delete(KDbFile2);
TEST2(err, KErrNone);
//Create the database
TInt failingAllocationNo2 = 0;
err = KErrNoMemory;
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo2);
OomPreStep(failingAllocationNo2);
RMessage2 msg;
TSqlSrvFileData& fdata = TheServer->FileData();
TRAP(err, fdata.SetL(msg, KDbFile2().Length(), 0, KDbFile2, aEncoding == ESqlDbUtf8 ? &KConfig : NULL));
if(err == KErrNone)
{
TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
CSqlSecurityPolicy* policy = NULL;
TRAP(err, policy = CSqlSecurityPolicy::NewL(defaultPolicy));
if(err == KErrNone)
{
CSqlSrvDatabase* db = NULL;
TRAP(err, db = CSqlSrvDatabase::CreateSecureL(fdata, policy));
if(err == KErrNone)
{
delete db;
}
else
{
TEST(!db);
}
}
}
OomPostStep();
}
(void)TheFs.Delete(KDbFile2);
delete TheServer;
TheServer = NULL;
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::CreateSecureL() OOM test succeeded at heap failure rate of %d ===\r\n"),
failingAllocationNo + failingAllocationNo2);
}
/**
@SYMTestCaseID PDS-SQL-UT-4173
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::CreateSecureL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() and CSqlSrvDatabase::CreateSecureL() in an OOM test.
The test creates a secure database then executes CSqlSrvDatabase::OpenL() in an OOM loop.
After that the database is deleted and the test executes CSqlSrvDatabase::CreateSecureL() in an OOM loop.
The purpose of the test is to check that the CSqlSrver maps are properly updated when
the database is closed.
UTF16 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144577, PDEF44845
*/
void Utf16OpenCreateDatabaseOomTest()
{
OpenCreateDatabaseOomTest(ESqlDbUtf16);
}
/**
@SYMTestCaseID PDS-SQL-UT-4188
@SYMTestCaseDesc CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::CreateSecureL() OOM test.
@SYMTestPriority High
@SYMTestActions The test runs CSqlSrvDatabase::OpenL() and CSqlSrvDatabase::CreateSecureL() in an OOM test.
The test creates a secure database then executes CSqlSrvDatabase::OpenL() in an OOM loop.
After that the database is deleted and the test executes CSqlSrvDatabase::CreateSecureL() in an OOM loop.
The purpose of the test is to check that the CSqlSrver maps are properly updated when
the database is closed.
UTF8 encoded database is used.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF145047
*/
void Utf8OpenCreateDatabaseOomTest()
{
OpenCreateDatabaseOomTest(ESqlDbUtf8);
}
void DoTests()
{
#ifndef _DEBUG
TheTest.Start(_L("This test can be run only in debug mode!"));
#else
CActiveScheduler* scheduler = new CActiveScheduler;
TEST(scheduler != NULL);
CActiveScheduler::Install(scheduler);
TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-UT-4167 CSqlSrvDatabase::CreateL() OOM unit test"));
Utf16CreateDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4168 CSqlSrvDatabase::OpenL() OOM unit test - non-secure database"));
Utf16OpenDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4169 CSqlSrvDatabase::CreateSecureL() OOM unit test"));
Utf16CreateSecureDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4170 CSqlSrvDatabase::OpenL() OOM unit test - secure database"));
Utf16OpenSecureDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4171 CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM unit test"));
Utf16OpenAttachDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4172 CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM unit test - 2"));
Utf16OpenAttachDatabaseOomTest2();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4173 CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::CreateL() OOM unit test"));
Utf16OpenCreateDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4182 CSqlSrvDatabase::CreateL() OOM unit test, UTF8 database"));
Utf8CreateDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4183 CSqlSrvDatabase::OpenL() OOM unit test - non-secure UTF8 database"));
Utf8OpenDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4184 CSqlSrvDatabase::CreateSecureL() OOM unit test, UTF8 database"));
Utf8CreateSecureDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4185 CSqlSrvDatabase::OpenL() OOM unit test - secure UTF8 database"));
Utf8OpenSecureDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4186 CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM unit test, UTF8 database"));
Utf8OpenAttachDatabaseOomTest();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4187 CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::AttachDbL() OOM unit test 2, UTF8 database"));
Utf8OpenAttachDatabaseOomTest2();
TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4188 CSqlSrvDatabase::OpenL() & CSqlSrvDatabase::CreateL() OOM unit test, UTF8 database"));
Utf8OpenCreateDatabaseOomTest();
delete scheduler;
#endif //_DEBUG
}
TInt E32Main()
{
TheTest.Title();
CTrapCleanup* tc = CTrapCleanup::New();
TheTest(tc != NULL);
__UHEAP_MARK;
CreateTestEnv();
DoTests();
DestroyTestEnv();
__UHEAP_MARKEND;
TheTest.End();
TheTest.Close();
delete tc;
User::Heap().Check();
return KErrNone;
}