sl@0: // Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "t_sqloom.h"
sl@0: 
sl@0: RTest TheTest(_L("t_sqloom3 test"));
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////         RSqlDatabase OOM tests         ////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1615, SYSLIB-SQL-CT-1639
sl@0: @SYMTestCaseDesc		RSqlDatabase::Create() OOM test - secure and non-secure databases.
sl@0: 						Precondition: the database does not exist.
sl@0: 						The test calls RSqlDatabase::Create() while simulating OOM failures and checks
sl@0: 						that there are no memory and resource leaks.
sl@0: 						Note: It's possible for a database to be created even after memory allocation
sl@0: 						has failed. This is because SQLITE reuses some pages of the page cache which
sl@0: 						have been allocated but are curently not in use. This means it is necessary
sl@0: 						to delete the database and continue checking for memory and resource leaks
sl@0: 						even after a database has been created successfully.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase::Create() OOM test
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0:                         REQ10271
sl@0:                         REQ10273
sl@0:                         REQ10274
sl@0: */
sl@0: void DoCreateDatabaseOomTest(const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError, const TDesC8* aConfigStr = NULL)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1639 RSqlDatabase::Create() - OOM test"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	enum TMethodType {ENonLeavingMethod, ELeavingMethod};
sl@0: 	const TMethodType KMethodType[] = {ENonLeavingMethod, ELeavingMethod};
sl@0: 	for(TInt j=0;j<sizeof(KMethodType)/sizeof(KMethodType[0]);++j)
sl@0: 		{
sl@0: 		for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 			{
sl@0: 			if(aExpectedError != KErrAlreadyExists)
sl@0: 				{
sl@0: 				(void)RSqlDatabase::Delete(aDbFileName);
sl@0: 				}
sl@0: 			TInt err = KErrNone;
sl@0: 			TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set maxAllocationNo times.
sl@0: 			TInt allocationNo = 0;
sl@0: 			TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoCreateDatabaseOomTestAllocLimitServer : KDoCreateDatabaseOomTestAllocLimitClient;
sl@0: 			while(allocationNo < maxAllocationNo)
sl@0: 				{
sl@0: 				MarkHandles();
sl@0: 				MarkAllocatedCells();
sl@0: 
sl@0: 				__UHEAP_MARK;
sl@0: 
sl@0: 				RSqlDatabase db;
sl@0: 
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 
sl@0: 				if(KMethodType[j] == ENonLeavingMethod)
sl@0: 					{
sl@0: 					err =  aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy, aConfigStr) : db.Create(aDbFileName, aConfigStr);
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					TRAP(err, aDbType == ESecureDb ? db.CreateL(aDbFileName, securityPolicy, aConfigStr) : db.CreateL(aDbFileName, aConfigStr));
sl@0: 					}
sl@0: 
sl@0: 				db.Close();
sl@0: 				if(err != KErrNoMemory)
sl@0: 					{
sl@0: 					TEST2(err, aExpectedError);
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					failingAllocationNo = allocationNo;
sl@0: 					}
sl@0: 
sl@0: 				ResetDbHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 				if(err == KErrNone && aExpectedError != KErrAlreadyExists)
sl@0: 					{
sl@0: 					err = db.Delete(aDbFileName);
sl@0: 					TEST2(err, KErrNone);
sl@0: 					}
sl@0: 
sl@0: 				__UHEAP_MARKEND;
sl@0: 
sl@0: 				CheckAllocatedCells();
sl@0: 				CheckHandles();
sl@0: 				}
sl@0: 			TEST2(err, aExpectedError);
sl@0: 			PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);
sl@0: 			}
sl@0: 		}
sl@0: 	RSqlDatabase::Delete(aDbFileName);
sl@0: 	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Open()" OOM test
sl@0: void OpenDatabaseL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	TInt err = aDb.Open(aDbFileName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Exec()" OOM test (8-bit SQL statements), syntax error
sl@0: void ExecBadStatement8L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "CREATE TABL BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT)");
sl@0: 	TInt err = aDb.Exec(KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Exec()" OOM test (16-bit SQL statements), syntax error
sl@0: void ExecBadStatement16L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "CREATE TABLE B!B!B(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT)");
sl@0: 	TInt err = aDb.Exec(KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1813
sl@0: @SYMTestCaseDesc		RSqlDatabase methods - negative OOM test
sl@0: 						Precondition: the database exists.
sl@0: 						The test calls the given as an argument function while simulating OOM failures
sl@0: 						and checks that there are no memory and resource leaks. The calling function is expected to fail
sl@0: 						with aExpectedError error.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase methods - negative OOM tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */
sl@0: void DoDbOomNegativeTest(TDbFuncPtrL aTestFunctionPtrL, const TDesC& aDbFileName, TDbAction aDbAction, TInt aExpectedError)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1813 RSqlDatabase - negative OOM test"));
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		TInt err = KErrNoMemory;
sl@0: 		TInt failingAllocationNo = 0;
sl@0: 		while(err == KErrNoMemory)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 			if(TheOomTestType[i] == EServerSideTest)
sl@0: 				{//If aDbAction is EOpenDb, then we will delay the heap failure simulation, until the database is opened
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++failingAllocationNo, aDbAction == EOpenDb);
sl@0: 				}
sl@0: 
sl@0: 			RSqlDatabase db;
sl@0: 			//if aDbAction is EOpenDb then this is a OOM test different than a test for RSqlDatabase::Open
sl@0: 			if(aDbAction == EOpenDb)
sl@0: 				{
sl@0: 				err = db.Open(aDbFileName);
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 
sl@0: 			if(TheOomTestType[i] == EClientSideTest)
sl@0: 				{
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++failingAllocationNo);
sl@0: 				}
sl@0: 
sl@0: 			TRAP(err, (*aTestFunctionPtrL)(db, aDbFileName, ENonSecureDb));
sl@0: 			db.Close();
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				TEST2(err, aExpectedError);
sl@0: 				}
sl@0: 
sl@0: 			ResetDbHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			}
sl@0: 		TEST2(err, aExpectedError);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
sl@0: 		}
sl@0: 	RSqlDatabase::Delete(aDbFileName);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //RSqlDatabase - negative OOM tests
sl@0: void DbOomNegativeTestsL()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open(), non-existing drive\r\n"));
sl@0: 	_LIT(KDbName1, "A:[1111CCCC]db1.db");
sl@0: 	DoDbOomNegativeTest(&OpenDatabaseL, KDbName1, ENotOpenDb, KErrNotReady);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open(), non-existing file\r\n"));
sl@0: 	_LIT(KDbName2, "c:\\test\\nofile.db");
sl@0: 	DoDbOomNegativeTest(&OpenDatabaseL, KDbName2, ENotOpenDb, KErrNotFound);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open(), zero-length name\r\n"));
sl@0: 	_LIT(KDbName3, "");
sl@0: 	DoDbOomNegativeTest(&OpenDatabaseL, KDbName3, ENotOpenDb, KErrBadName);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open(), directory name\r\n"));
sl@0: 	_LIT(KDbName4, "C:\\TEST\\");
sl@0: 	DoDbOomNegativeTest(&OpenDatabaseL, KDbName4, ENotOpenDb, KErrBadName);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create(), secure database already exists\r\n"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	RSqlDatabase db;
sl@0: 	TInt err = db.Create(KSecureDb2, securityPolicy);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	db.Close();
sl@0: 	securityPolicy.Close();
sl@0: 	DoCreateDatabaseOomTest(KSecureDb2, ESecureDb, KErrAlreadyExists);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create(), database already exists\r\n"));
sl@0: 	err = db.Create(KTestDb2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	db.Close();
sl@0: 	DoCreateDatabaseOomTest(KTestDb2, ENonSecureDb, KErrAlreadyExists);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Exec(), 8-bit SQL, syntax error\r\n"));
sl@0: 	err = db.Create(KTestDb);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	db.Close();
sl@0: 	DoDbOomNegativeTest(&ExecBadStatement8L, KTestDb, EOpenDb, KSqlErrGeneral);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Exec(), 16-bit SQL, syntax error\r\n"));
sl@0: 	err = db.Create(KTestDb);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	db.Close();
sl@0: 	DoDbOomNegativeTest(&ExecBadStatement16L, KTestDb, EOpenDb, KSqlErrGeneral);
sl@0: 	}
sl@0: 
sl@0: void DEF114297PrepareStmtL(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSelectSql, "SELECT e.* FROM edge AS e, node AS n1, node AS n2 WHERE n1.name = 'alice' AND n2.name = 'bob' AND e.orig = n1.id AND e.dest = n2.id ORDER BY n2.name DESC");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSelectSql);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4004
sl@0: @SYMTestCaseDesc		Test for DEF114297 - SqlSrv.EXE::!SQL Server OOM Test for PrepareL.
sl@0: 						The test does an OOM test for RSqlStatement::Prepare() using a specific SELECT SQL statement.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF114297 - SqlSrv.EXE::!SQL Server OOM Test for PrepareL.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF					DEF114297
sl@0: */
sl@0: void DEF114297()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4004  ===DEF114297 - SqlSrv.EXE::!SQL Server OOM Test for PrepareL "));
sl@0: 	(void)RSqlDatabase::Delete(KTestDb);
sl@0: 	RSqlDatabase db;
sl@0: 	TInt err = db.Create(KTestDb);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = db.Exec(_L("CREATE TABLE node(id INTEGER PRIMARY KEY,name TEXT)"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = db.Exec(_L("CREATE INDEX node_idx ON node(name)"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = db.Exec(_L("CREATE TABLE edge(orig INTEGER REFERENCES node,dest INTEGER REFERENCES node,PRIMARY KEY(orig, dest))"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = db.Exec(_L("CREATE INDEX edge_idx ON edge(dest,orig)"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = db.Exec(_L("INSERT INTO node(id,name) VALUES(1,'alice')"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = db.Exec(_L("INSERT INTO node(id,name) VALUES(2,'bob')"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 
sl@0: 		__UHEAP_MARK;
sl@0: 
sl@0: 		SetHeapFailure(EServerSideTest, ++failingAllocationNo);
sl@0: 
sl@0:     	RSqlStatement stmt;
sl@0: 		TRAP(err, DEF114297PrepareStmtL(db, stmt));
sl@0: 		stmt.Close();
sl@0: 		if(err != KErrNoMemory)
sl@0: 			{
sl@0: 			TEST2(err, KErrNone);
sl@0: 			}
sl@0: 
sl@0: 		ResetHeapFailure(EServerSideTest);
sl@0: 
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();
sl@0: 		CheckHandles();
sl@0: 		}
sl@0: 	db.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestDb);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4011
sl@0: @SYMTestCaseDesc		Test for DEF115815 - SELECT random()&1==-1 causes sql server to crash.
sl@0: 						The test does an OOM test for RSqlStatement::Prepare() using a specific SELECT SQL statement.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF115815 - SELECT random()&1==-1 causes sql server to crash.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF					DEF115815
sl@0: */
sl@0: void DEF115815()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4011 ===DEF115815 - SELECT random()&1==-1 causes sql server to crash "));
sl@0: 	(void)RSqlDatabase::Delete(KTestDb);
sl@0: 	RSqlDatabase db;
sl@0: 	TInt err = db.Create(KTestDb);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = db.Exec(_L("CREATE TABLE node(id INTEGER)"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 
sl@0: 		__UHEAP_MARK;
sl@0: 
sl@0: 		SetHeapFailure(EServerSideTest, ++failingAllocationNo);
sl@0: 
sl@0:     	RSqlStatement stmt;
sl@0: 		err = stmt.Prepare(db, _L("SELECT random()&1==-1"));
sl@0: 		stmt.Close();
sl@0: 		if(err != KErrNoMemory)
sl@0: 			{
sl@0: 			TEST2(err, KErrNone);
sl@0: 			}
sl@0: 
sl@0: 		ResetHeapFailure(EServerSideTest);
sl@0: 
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();
sl@0: 		CheckHandles();
sl@0: 		}
sl@0: 	db.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestDb);
sl@0: 	}
sl@0: 
sl@0: void DoTestsL()
sl@0: 	{
sl@0: 	TheTest.Start(_L("SQL OOM-3 tests"));
sl@0: 
sl@0: 	DbOomNegativeTestsL();
sl@0: 
sl@0: 	DEF114297();
sl@0: 
sl@0: 	DEF115815();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	CreateTestDir();
sl@0: 	DeleteTestFiles();
sl@0: 
sl@0: 	TRAPD(err, DoTestsL());
sl@0: 	DeleteTestFiles();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 
sl@0: 	delete tc;
sl@0: 
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}