diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/sql/TEST/t_sqlload.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlload.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,985 @@
+// Copyright (c) 2006-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 <e32math.h>
+#include <bautils.h>
+#include <sqldb.h>
+#include "SqlResourceTester.h"
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+#define UNUSED_VAR(a) (a) = (a)
+
+RTest TheTest(_L("t_sqlload test"));
+
+TDriveNumber KTestDrive = EDriveC;
+
+_LIT(KTestDir, "c:\\test\\");
+_LIT(KTestDbName1, "c:\\test\\t_sqlload_1.db");
+_LIT(KTestDbName2, "c:\\test\\t_sqlload_2.db");
+_LIT(KTestDbName3, "c:\\test\\t_sqlload_3.db");
+_LIT(KTestDbName4, "c:\\test\\t_sqlload_4.db");
+_LIT(KTestDbName5, "c:\\test\\t_sqlload_5.db");
+
+//Test thread count
+const TInt KTestThreadCnt = 4;
+
+//Test database names
+const TPtrC KTestDbNames[] =
+	{
+	KTestDbName1(),
+	KTestDbName2(),
+	KTestDbName3()
+	};
+
+//Test database count
+const TInt KTestDbCnt = sizeof(KTestDbNames) / sizeof(KTestDbNames[0]);
+
+//Test duration
+const TInt KTestDuration = 120;//seconds
+
+//Test record count
+const TInt KRecordCnt = 100;
+//Record count which will be used in the test SQL queries
+const TInt KQueriedRecordCnt = 40;
+//Every SQL query will be processed (stepped) in KTestStepCnt steps.
+const TInt KTestStepCnt = 4;
+//RSqlStatement object count which will be used in the tests
+const TInt KStatementCnt = 10;
+//Max allowed alive RSqlStatement objects per thread
+const TInt KMaxStatementPerThread = 30;
+//Binary data length
+const TInt KBinDataLen = 2003;
+
+//StatementMaxNumberTest() time limit in seconds.
+const TInt KTestTimeLimit = 60;//seconds
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void DeleteTestFiles()
+	{
+	RSqlDatabase::Delete(KTestDbName5);
+	RSqlDatabase::Delete(KTestDbName4);
+	RSqlDatabase::Delete(KTestDbName3);
+	RSqlDatabase::Delete(KTestDbName2);
+	RSqlDatabase::Delete(KTestDbName1);
+	}
+
+void GetHomeTimeAsString(TDes& aStr)
+	{
+	TTime time;
+	time.HomeTime();
+	TDateTime dt = time.DateTime();
+	aStr.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
+//Test macros and functions
+void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)
+	{
+	if(!aValue)
+		{
+		DeleteTestFiles();
+		if(aPrintThreadName)
+			{
+			RThread th;
+			TName name = th.Name();
+			RDebug::Print(_L("*** Thread %S, Line %d\r\n"), &name, aLine);
+			}
+		else
+			{
+			RDebug::Print(_L("*** Line %d\r\n"), aLine);
+			}
+		TheTest(EFalse, aLine);
+		}
+	}
+void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)
+	{
+	if(aValue != aExpected)
+		{
+		DeleteTestFiles();
+		if(aPrintThreadName)
+			{
+			RThread th;
+			TName name = th.Name();
+			RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);
+			}
+		else
+			{
+			RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
+			}
+		TheTest(EFalse, aLine);
+		}
+	}
+#define TEST(arg) ::Check1((arg), __LINE__)
+#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
+#define TTEST(arg) ::Check1((arg), __LINE__, ETrue)
+#define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+//StatementMaxNumberTest() timeouts in WDP builds.
+//This function is used to return the seconds passed from the start of the test case.
+TTimeIntervalSeconds ExecutionTimeSeconds(TTime& aStartTime)
+	{
+	TTime currTime;
+	currTime.HomeTime();
+	
+	TTimeIntervalSeconds s;
+	TInt err = currTime.SecondsFrom(aStartTime, s);
+	TEST2(err, KErrNone);
+	return s;
+	}
+
+void CreateTestDir()
+    {
+    RFs fs;
+	TInt err = fs.Connect();
+	TEST2(err, KErrNone);
+
+	err = fs.MkDir(KTestDir);
+	TEST(err == KErrNone || err == KErrAlreadyExists);
+
+	err = fs.CreatePrivatePath(KTestDrive);
+	TEST(err == KErrNone || err == KErrAlreadyExists);
+	
+	fs.Close();
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void CreateTestDatabases()
+	{
+	HBufC8* recData = HBufC8::New(KBinDataLen * 2 + 50);//"* 2" - hex values for the INSERT SQL statement
+	TEST(recData != NULL);
+	TPtr8 sql = recData->Des();
+
+	for(TInt dbIdx=0;dbIdx<KTestDbCnt;++dbIdx)
+		{
+		//Create test database
+		RSqlDatabase db;
+		TInt err = db.Create(KTestDbNames[dbIdx]);
+		TEST2(err, KErrNone);
+
+		//Create test table
+		_LIT8(KCreateSql, "CREATE TABLE A(F1 INTEGER, F2 BLOB)");
+		err = db.Exec(KCreateSql);
+		TEST(err >= 0);
+
+		//Insert records in the test table
+		for(TInt recIdx=1;recIdx<=KRecordCnt;++recIdx)
+			{
+			_LIT8(KInsertSql, "INSERT INTO A(F1, F2) VALUES(");
+			sql.Copy(KInsertSql);
+			sql.AppendNum((TInt64)recIdx);
+			sql.Append(_L(", X'"));
+			for(TInt k=0;k<KBinDataLen;++k)
+				{
+				sql.AppendFormat(_L8("%02X"), recIdx);
+				}
+			sql.Append(_L("')"));
+			err = db.Exec(sql);
+			TEST2(err, 1);
+			}
+
+		db.Close();
+		}
+
+	delete recData;
+	}
+
+//Structure used by the test thread function for orginizing its set of test data.
+struct TSqlStatement
+	{
+	RSqlStatement	iObj;
+	TBool 			iAlive;			//Non-zero if iObj is alive
+	TInt			iCurIndex;		//The number of the current record in the set controlled by iObj statement
+	TInt			iEndIndex;		//The last record number in the set controlled by iObj statement
+	TInt			iCount;			//Records count in the set controlled by iObj statement
+	};
+	
+typedef RArray<TSqlStatement> RSqlStatementArray;	
+
+//Inits the random numbers generator.
+//Opens one of the test databases.
+void PreTest(RSqlDatabase& aDb, TInt64& aSeed, TName& aThreadName)
+	{
+	RThread currThread;
+	
+	//Init the random numbers generator
+	TTime now;
+	now.UniversalTime();
+	aSeed = now.Int64() + currThread.Id();
+
+	//Open one of the test databases
+	const TInt KDbIndex = Math::Rand(aSeed) % KTestDbCnt;
+
+	aThreadName = currThread.Name();
+	RDebug::Print(_L("=== Thread %S, database %S\r\n"), &aThreadName, &KTestDbNames[KDbIndex]);
+
+	TInt err = aDb.Open(KTestDbNames[KDbIndex]);
+	TTEST2(err, KErrNone);
+	}
+
+//Creates N statements, where 0 < N < KStatementCnt
+TInt CreateStatements(RSqlDatabase& aDb, TInt64& aSeed, RSqlStatementArray& aStmtArray)
+	{
+	TInt stmtCount = Math::Rand(aSeed) % KStatementCnt;
+	if(stmtCount == 0)
+		{
+		stmtCount = 1;
+		}
+	for(TInt i=0;i<stmtCount;++i)
+		{
+		TSqlStatement stmt;
+		stmt.iAlive = EFalse;
+		stmt.iCount = KQueriedRecordCnt;
+		stmt.iCurIndex = Math::Rand(aSeed) % KRecordCnt;
+		if(stmt.iCurIndex == 0)
+			{
+			stmt.iCurIndex = 1;
+			}
+		if(stmt.iCurIndex > (KRecordCnt - KQueriedRecordCnt))
+			{
+			stmt.iCurIndex = KRecordCnt - KQueriedRecordCnt;
+			}
+		stmt.iEndIndex = stmt.iCurIndex + KQueriedRecordCnt;
+		TBuf8<100> sql;
+		sql.Copy(_L8("SELECT * FROM A WHERE F1 >= "));
+		sql.AppendNum(stmt.iCurIndex);
+		sql.Append(_L8(" AND F1 < "));
+		sql.AppendNum(stmt.iEndIndex);
+		TInt err = stmt.iObj.Prepare(aDb, sql);
+		TTEST2(err, KErrNone);
+		stmt.iAlive = ETrue;
+		err = aStmtArray.Append(stmt);
+		TTEST2(err, KErrNone);
+		}
+	return stmtCount;		
+	}
+	
+//For each alive statement object - do (TSqlStatement::iCount / KTestStepCnt)
+//RSqlStatement::Next() calls. If the Next() call reaches the end - close the statement object.
+TInt ProcessStatements(RSqlStatementArray& aStmtArray)
+	{
+	const TInt KTotalStmtCount = aStmtArray.Count();
+	TInt alive = 0;
+	TInt completed = 0;
+	for(TInt k=0;k<KTotalStmtCount;++k)
+		{
+		TSqlStatement& stmt = aStmtArray[k];
+		if(stmt.iAlive)
+			{
+			++alive;
+			TInt endIndex = stmt.iCurIndex + stmt.iCount / KTestStepCnt;
+			if(endIndex <= stmt.iEndIndex)
+				{
+				while(stmt.iCurIndex < endIndex)
+					{
+					TInt err = stmt.iObj.Next();
+					TTEST2(err, KSqlAtRow);
+					//test column values
+					TInt val1 = stmt.iObj.ColumnInt(0);
+					TTEST(val1 == stmt.iCurIndex);
+					RSqlColumnReadStream strm;
+					err = strm.ColumnBinary(stmt.iObj, 1);
+					TTEST2(err, KErrNone);
+					for(TInt ii=0;ii<KBinDataLen;++ii)
+						{
+						TUint8 byte = 0;
+						TRAP(err, byte = strm.ReadUint8L());
+						TTEST2(err, KErrNone);
+						TTEST(byte == (TUint8)val1);
+						}
+					strm.Close();
+					++stmt.iCurIndex;
+					}
+				}
+			if(stmt.iCurIndex >= stmt.iEndIndex)
+				{
+				stmt.iObj.Close();
+				stmt.iAlive = EFalse;
+				++completed;
+				}
+			}
+		}
+	return completed;
+	}
+
+//Close up to N statements, where 0 < N < KStatementCnt
+TInt CloseStatements(RSqlStatementArray& aStmtArray, TInt64& aSeed)
+	{
+	TInt stmtCount = Math::Rand(aSeed) % KStatementCnt;
+	if(stmtCount == 0)
+		{
+		stmtCount = 1;
+		}
+	const TInt KTotalStmtCount = aStmtArray.Count();
+	TInt closed = 0;
+	for(TInt j=0;j<stmtCount;++j)
+		{
+		const TInt KIdx = Math::Rand(aSeed) % KTotalStmtCount;
+		TInt idx = KIdx;
+		while((idx = (++idx % KTotalStmtCount)) != KIdx)
+			{
+			if(aStmtArray[idx].iAlive)
+				{
+				aStmtArray[idx].iObj.Close();
+				aStmtArray[idx].iAlive = EFalse;
+				++closed;
+				break;
+				}
+			}
+		}
+	return closed;
+	}
+
+//Counts the alive statements
+TInt AliveStatementsCount(RSqlStatementArray& aStmtArray)
+	{
+	TInt aliveCnt = 0;
+	const TInt KTotalStmtCount = aStmtArray.Count();
+	for(TInt l=0;l<KTotalStmtCount;++l)
+		{
+		if(aStmtArray[l].iAlive)
+			{
+			++aliveCnt;
+			}
+		}
+	return aliveCnt;
+	}
+	
+//Close all alive statements
+void CloseAllStatements(RSqlStatementArray& aStmtArray)
+	{
+	const TInt KTotalStmtCount = aStmtArray.Count();
+	for(TInt i=0;i<KTotalStmtCount;++i)
+		{
+		if(aStmtArray[i].iAlive)
+			{
+			aStmtArray[i].iObj.Close();
+			}
+		}
+	TTEST2(TSqlResourceTester::Count(), 0);
+	}
+
+//Removes the already closed statements and compresses the array
+void RemoveDeadStatements(RSqlStatementArray& aStmtArray)
+	{
+	for(TInt i=aStmtArray.Count()-1;i>=0;--i)
+		{
+		if(!aStmtArray[i].iAlive)
+			{
+			aStmtArray.Remove(i);
+			}
+		}
+	aStmtArray.Compress();		
+	}
+
+//Close statement objects, statements array and the database object
+TInt PostTest(RSqlDatabase& aDb, RSqlStatementArray& aStmtArray)
+	{
+	TInt statementsAlive = AliveStatementsCount(aStmtArray);
+	CloseAllStatements(aStmtArray);
+	aStmtArray.Close();
+	aDb.Close();
+	return statementsAlive;
+	}
+
+//Test thread function
+//The thread function works with a set of TSqlStatement objects
+//The test consists of 4 steps:
+//Step 1: the test thread creates m TSqlStatement objects, 0 < m < KStatementCnt.
+//		  With each of the created TSqlStatement objects the test thread prepares SELECT SQL query
+//        "SELECT * FROM A WHERE F1 >= K1 AND F1 < K2", where K1 is random generated number, such that:
+//        0 < K1 < (KRecordCnt - KQueriedRecordCnt)
+//        K2 = K1 + KQueriedRecordCnt
+//		  All just created TSqlStatement objects are marked as alive.
+//Step 2: For each alive TSqlStatement object the test thread calls iObj.Next() method KTestStepCnt times,
+//        KTestStepCnt < KQueriedRecordCnt.
+//        The column values are retrieved and checked.
+//Step 3: the test thread closes n TSqlStatement objects, 0 < n < KStatementCnt.
+//Step 4: the test thread counts how many alive TSqlStatement objects are there.
+//        If this count > KMaxStatementPerThread then the test thread closes all alive TSqlStatement objects
+//		  to avoid OOM errors during the test.
+//
+//		  Each test thread does steps 1..4 for a period of KTestDuration seconds.
+//		  At the end all TSqlStatement objects are closed.
+//
+//		  The idea of the test is to load the SQL server creating several amount of statement and stream objects
+//		  and see that it is working stable and without problems.
+TInt ThreadFunc(void*)
+	{
+	__UHEAP_MARK;
+
+	CTrapCleanup* tc = CTrapCleanup::New();
+	TTEST(tc != NULL);
+
+	TInt64 seed = 0;
+	RSqlDatabase db;
+	TName threadName;
+	RSqlStatementArray statements;
+	
+	//Init the random numbers generator, opens the database
+	PreTest(db, seed, threadName);
+
+	//Main test loop
+	TInt iteration = 0;
+	TTime currTime;
+	currTime.UniversalTime();
+	TTime endTime = currTime + TTimeIntervalSeconds(KTestDuration);
+	while(currTime < endTime)
+		{
+		++iteration;
+		///////////////////////////////////////////////////////////////////////
+		TInt statementsAliveBegin = statements.Count();
+		//Step 1: Create N statements, where 0 < N < KStatementCnt
+		TInt statementsCreated = CreateStatements(db, seed, statements);
+		///////////////////////////////////////////////////////////////////////
+		//Step 2: For each alive statement object - do (TSqlStatement::iCount / KTestStepCnt)
+		//        RSqlStatement::Next() calls. If the Next() call reaches the end - close the statement object.
+		TInt statementsCompleted = ProcessStatements(statements);
+		///////////////////////////////////////////////////////////////////////
+		//Step 3: Close up to N statements, where 0 < N < KStatementCnt
+		TInt statementsClosed = CloseStatements(statements, seed);
+		///////////////////////////////////////////////////////////////////////
+		//Step 4: If the alive statement count is more than KMaxStatementPerThread, then close them all
+		TInt statementsAliveEnd = AliveStatementsCount(statements);
+		if(statementsAliveEnd > KMaxStatementPerThread)
+			{
+			RDebug::Print(_L("!!! Thread %S, iteration %d, alive %d, close all\r\n"), &threadName, iteration, statementsAliveEnd);
+			CloseAllStatements(statements);
+			statementsAliveEnd = 0;
+			}
+		///////////////////////////////////////////////////////////////////////
+		RemoveDeadStatements(statements);
+		RDebug::Print(_L("=== Thread %S, iteration % 4d, begin: % 3d, created % 2d, closed % 2d, completed % 2d, end % 3d, \r\n"),
+							&threadName, iteration, statementsAliveBegin, 
+													statementsCreated, statementsClosed, statementsCompleted, 
+													statementsAliveEnd);
+		currTime.UniversalTime();
+		}
+
+	//Close statement objects and the database object
+	TInt statementsAlive = PostTest(db, statements);
+
+	delete tc;
+
+	__UHEAP_MARKEND;
+
+	RDebug::Print(_L("=== Thread %S exit, still alive %d\r\n"), &threadName, statementsAlive);
+
+	return KErrNone;
+	}
+
+void CreateTestThreads(RThread aThreads[], TRequestStatus aStatuses[], TInt aMaxCount)
+	{
+	_LIT(KThreadName, "TstThr");
+	for(TInt i=0;i<aMaxCount;++i)
+		{
+		TBuf<20> threadName(KThreadName);
+		threadName.AppendNum((TInt64)(i + 1));
+		TEST2(aThreads[i].Create(threadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, NULL, EOwnerProcess), KErrNone);
+		aThreads[i].Logon(aStatuses[i]);
+		TEST2(aStatuses[i].Int(), KRequestPending);
+		}
+	}
+
+void ResumeTestThreads(RThread aThreads[], TInt aMaxCount)
+	{
+	for(TInt i=0;i<aMaxCount;++i)
+		{
+		aThreads[i].Resume();
+		}
+	}
+
+
+void CloseTestThreads(RThread aThreads[], TRequestStatus aStatuses[], TInt aMaxCount)
+	{
+	for(TInt i=0;i<aMaxCount;++i)
+		{
+		User::WaitForRequest(aStatuses[i]);
+		TEST(aThreads[i].ExitType() != EExitPanic);
+		aThreads[i].Close();
+		}
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1627-0001
+@SYMTestCaseDesc		SQL server load test. The test creates KTestThreadCnt threads, KTestDbCnt test databases and
+						inserts in each of them KRecordCnt test records.
+						Pre-test step: each test thread randomly chooses and opens one of the test databases.
+						Then, each of the test threads is doing the following 4 test steps:
+						Step 1: the test thread creates m TSqlStatement objects, 0 < m < KStatementCnt.
+						With each of the created TSqlStatement objects the test thread prepares SELECT SQL query
+						"SELECT * FROM A WHERE F1 >= K1 AND F1 < K2", where K1 is random generated number, such that:
+						0 < K1 < (KRecordCnt - KQueriedRecordCnt)
+						K2 = K1 + KQueriedRecordCnt
+						All just created TSqlStatement objects are marked as alive.
+						Step 2: For each alive TSqlStatement object the test thread calls iObj.Next() method KTestStepCnt times,
+						KTestStepCnt < KQueriedRecordCnt.
+						The column values are retrieved and checked.
+						Step 3: the test thread closes n TSqlStatement objects, 0 < n < KStatementCnt.
+						Step 4: the test thread counts how many alive TSqlStatement objects are there.
+						If this count > KMaxStatementPerThread then the test thread closes all alive TSqlStatement objects
+						to avoid OOM errors during the test.
+
+						Each test thread does steps 1..4 for a period of KTestDuration seconds.
+						At the end all TSqlStatement objects are closed.
+
+						The idea of the test is to load the SQL server creating several amount of statement and stream objects
+						and see that it is working stable and without problems.
+@SYMTestPriority		High
+@SYMTestActions			SQL server load test
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/
+void SqlLoadTest()
+	{
+	CreateTestDatabases();
+
+	RThread threads[KTestThreadCnt];
+	TRequestStatus statuses[KTestThreadCnt];
+
+	CreateTestThreads(threads, statuses, KTestThreadCnt);
+
+	ResumeTestThreads(threads, KTestThreadCnt);
+
+	User::After(2000000);
+
+	CloseTestThreads(threads, statuses, KTestThreadCnt);
+	}
+
+/**
+@SYMTestCaseID          PDS-SQL-CT-4201
+@SYMTestCaseDesc        Max number of SQL statements test.
+@SYMTestPriority        High
+@SYMTestActions         The test creates a table with couple of records and then
+						creates as many as possible SQL statements. The expected result is
+						that either the statement creation process will fail with KErrNoMemory or
+						the max number of statements to be created is reached (100000).
+						Then the test deletes 1/2 of the created statements objects and
+						after that attempts to execute Next() on the rest of them.
+						Note that the test has a time limit of 120 seconds. Otherwise on some platforms
+						with WDP feature switched on the test may timeout.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF                 DEF145236
+*/  
+void StatementMaxNumberTest()
+	{
+	TBuf<30> time;
+	GetHomeTimeAsString(time);
+	TheTest.Printf(_L("=== %S: Create database\r\n"), &time);
+	
+	(void)RSqlDatabase::Delete(KTestDbName1);
+	RSqlDatabase db;
+	TInt err = db.Create(KTestDbName1);
+	TEST2(err, KErrNone);
+	err = db.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A(I) VALUES(1); INSERT INTO A(I) VALUES(2);"));
+	TEST(err >= 0);
+
+	GetHomeTimeAsString(time);
+	TheTest.Printf(_L("=== %S: Create statements array\r\n"), &time);
+	
+	//Reserve memory for the statement objects
+	const TInt KMaxStmtCount = 100000;
+	RSqlStatement* stmt = new RSqlStatement[KMaxStmtCount];
+	TEST(stmt != NULL);
+
+	TTime startTime;
+	startTime.HomeTime();
+	
+	//Create as many statement objects as possible
+	TInt idx = 0;
+	err = KErrNone;
+	for(;idx<KMaxStmtCount;++idx)
+		{
+		err = stmt[idx].Prepare(db, _L("SELECT * FROM A WHERE I>=0 AND I<10"));
+		if(err != KErrNone)
+			{
+			break;
+			}
+		TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
+		if((idx % 100) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: Create % 5d statements. %d seconds.\r\n"), &time, idx + 1, s.Int());
+			}
+		if(s.Int() > KTestTimeLimit)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
+			++idx;//The idx-th statement is valid, the statement count is idx + 1.
+			break;
+			}
+		}
+	
+	TInt stmtCnt = idx;
+	TheTest.Printf(_L("%d created statement objects. Last error: %d.\r\n"), stmtCnt, err);
+	TEST(err == KErrNone || err == KErrNoMemory);
+
+	//Close 1/2 of the statements to free some memory
+	idx = 0;
+	for(;idx<(stmtCnt/2);++idx)
+		{
+		stmt[idx].Close();
+		if((idx % 100) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: % 5d statements closed\r\n"), &time, idx + 1);
+			}
+		}
+	
+	//Now, there should be enough memory to be able to execute Next() on the rest of the statements
+	for(TInt j=0;idx<stmtCnt;++idx,++j)
+		{
+		err = stmt[idx].Next();
+		TEST2(err, KSqlAtRow);
+		err = stmt[idx].Next();
+		TEST2(err, KSqlAtRow);
+		err = stmt[idx].Next();
+		TEST2(err, KSqlAtEnd);
+		GetHomeTimeAsString(time);
+		TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
+		if((j % 100) == 0)
+			{
+			TheTest.Printf(_L("=== %S: % 5d statements processed. %d seconds.\r\n"), &time, j + 1, s.Int());
+			}
+		if(s.Int() > KTestTimeLimit)
+			{
+			TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
+			break;
+			}
+		}
+
+	//Cleanup
+	for(idx=0;idx<stmtCnt;++idx)
+		{
+		stmt[idx].Close();
+		if((idx % 100) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: % 5d statements closed\r\n"), &time, idx + 1);
+			}
+		}
+	delete [] stmt;
+	db.Close();
+	(void)RSqlDatabase::Delete(KTestDbName1);
+	GetHomeTimeAsString(time);
+	TheTest.Printf(_L("=== %S: Test case end\r\n"), &time);
+	}
+
+TInt CreateFileSessions(TInt& aIdx, RFs aFs[], TInt aMaxFsSessCount)
+	{
+	TBuf<30> time;
+	TTime startTime;
+	startTime.HomeTime();
+	//Create as many file session objects as possible
+	TInt err = KErrNone;
+	for(;aIdx<aMaxFsSessCount;++aIdx)
+		{
+		err = aFs[aIdx].Connect();
+		if(err != KErrNone)
+			{
+			break;
+			}
+		TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
+		if((aIdx % 500) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: Create % 5d file sessions. %d seconds.\r\n"), &time, aIdx + 1, s.Int());
+			}
+		if(s.Int() > KTestTimeLimit)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
+			++aIdx;//The idx-th file session object is valid, the file session count is idx + 1.
+			break;
+			}
+		}
+	return err;
+	}
+
+/**
+@SYMTestCaseID          PDS-SQL-CT-4237
+@SYMTestCaseDesc        Max file session number test.
+@SYMTestPriority        High
+@SYMTestActions         The test creates as many as possible file session objects. The expected result is
+						that either the file session creation process will fail with KErrNoMemory or
+						the max number of file sessions to be created is reached (100000).
+						Then the test attempts to create a database. If there is no memory, the test
+						closes some of the file session objects. The test also attempts to copy
+						the created database and to delete it after that, both operations performed
+						with all file session objects still open. The expectation is that the test
+						will not crash the SQL server or the client side SQL dll.
+						Note that the test has a time limit of 120 seconds. Otherwise on some platforms
+						with WDP feature switched on the test may timeout.
+@SYMTestExpectedResults Test must not fail
+*/  
+void FileSessionMaxNumberTest()
+	{
+	TBuf<30> time;
+	GetHomeTimeAsString(time);
+	TheTest.Printf(_L("=== %S: Create file sessions\r\n"), &time);
+
+	const TInt KMaxFsCount = 100000;
+	RFs* fs = new RFs[KMaxFsCount];
+	TEST(fs != NULL);
+
+	//Create as many file session objects as possible
+	TInt idx = 0;
+	TInt err = CreateFileSessions(idx, fs, KMaxFsCount);
+	TheTest.Printf(_L("%d created file session objects. Last error: %d.\r\n"), idx, err);
+	TEST(err == KErrNone || err == KErrNoMemory);
+	
+	TBool dbCreated = EFalse;
+	RSqlDatabase db;
+	
+	//An attempt to create a database
+	while(idx > 0 && err == KErrNoMemory)
+		{
+		(void)RSqlDatabase::Delete(KTestDbName1);
+		err = db.Create(KTestDbName1);
+		if(err == KErrNone)
+			{
+			err = db.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A(I) VALUES(1); INSERT INTO A(I) VALUES(2);"));
+			}
+		TheTest.Printf(_L("Database creation. Last error: %d.\r\n"), err);
+		TEST(err == KErrNoMemory || err >= 0);
+		if(err == KErrNoMemory)
+			{
+			fs[--idx].Close();
+			}
+		else
+			{
+			dbCreated = ETrue;
+			}
+		db.Close();
+		}
+
+	if(dbCreated)
+		{
+		//Create again file session objects - as many as possible
+		err = CreateFileSessions(idx, fs, KMaxFsCount);
+		TEST(err == KErrNone || err == KErrNoMemory);
+		//Try to copy the database
+		err = RSqlDatabase::Copy(KTestDbName1, KTestDbName4);
+		TheTest.Printf(_L("Copy database. Last error: %d.\r\n"), err);
+		TEST(err == KErrNone || err == KErrNoMemory);
+		//Try to delete the databases
+		if(err == KErrNone)
+			{
+			err = RSqlDatabase::Delete(KTestDbName4);
+			TheTest.Printf(_L("Delete database copy. Last error: %d.\r\n"), err);
+			TEST(err == KErrNone || err == KErrNoMemory);
+			}
+		err = RSqlDatabase::Delete(KTestDbName1);
+		TheTest.Printf(_L("Delete database. Last error: %d.\r\n"), err);
+		TEST(err == KErrNone || err == KErrNoMemory);
+		}
+	
+	//Cleanup
+	for(TInt i=0;i<idx;++i)
+		{
+		fs[i].Close();
+		if((i % 500) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: % 5d file sessions closed\r\n"), &time, i + 1);
+			}
+		}
+	delete [] fs;
+	err = RSqlDatabase::Delete(KTestDbName4);
+	TEST(err == KErrNone || err == KErrNotFound);
+	err = RSqlDatabase::Delete(KTestDbName1);
+	TEST(err == KErrNone || err == KErrNotFound);
+	}
+
+TInt CreateSqlConnections(TInt& aIdx, RSqlDatabase aDb[], TInt aMaxSqlConnCount)
+	{
+	TBuf<30> time;
+	TTime startTime;
+	startTime.HomeTime();
+	//Create as many file session objects as possible
+	TInt err = KErrNone;
+	for(;aIdx<aMaxSqlConnCount;++aIdx)
+		{
+		err = aDb[aIdx].Open(KTestDbName1);
+		if(err != KErrNone)
+			{
+			break;
+			}
+		TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
+		if((aIdx % 100) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: Create % 5d sql connections. %d seconds.\r\n"), &time, aIdx + 1, s.Int());
+			}
+		if(s.Int() > KTestTimeLimit)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
+			++aIdx;//The idx-th sql connection is valid, the sql connection count is idx + 1.
+			break;
+			}
+		}
+	return err;
+	}
+
+/**
+@SYMTestCaseID          PDS-SQL-CT-4238
+@SYMTestCaseDesc        Max sql connection number test.
+@SYMTestPriority        High
+@SYMTestActions         The test creates as many as possible sql connection objects. The expected result is
+						that either the sql connection creation process will fail with KErrNoMemory or
+						the max number of sql connection to be created is reached (100000).
+						Then the test attempts to create a database. If there is no memory, the test
+						closes some of the sql connection objects. The test also attempts to copy
+						the created database and to delete it after that, both operations performed
+						with all sql connection objects still open. The expectation is that the test
+						will not crash the SQL server or the client side SQL dll.
+						Note that the test has a time limit of 120 seconds. Otherwise on some platforms
+						with WDP feature switched on the test may timeout.
+@SYMTestExpectedResults Test must not fail
+*/  
+void SqlConnectionMaxNumberTest()
+	{
+	TBuf<30> time;
+	GetHomeTimeAsString(time);
+	TheTest.Printf(_L("=== %S: Create sql connections\r\n"), &time);
+
+	(void)RSqlDatabase::Delete(KTestDbName1);
+	RSqlDatabase db1;
+	TInt err = db1.Create(KTestDbName1);//CreateSqlConnections() opens the already existing KTestDbName1 database
+	TEST2(err, KErrNone);
+	
+	const TInt KMaxConnCount = 100000;
+	RSqlDatabase* db = new RSqlDatabase[KMaxConnCount];
+	TEST(db != NULL);
+
+	//Create as many sql connection objects as possible
+	TInt idx = 0;
+	err = CreateSqlConnections(idx, db, KMaxConnCount);
+	TheTest.Printf(_L("%d created sql connection objects. Last error: %d.\r\n"), idx, err);
+	TEST(err == KErrNone || err == KErrNoMemory);
+	
+	TBool dbCreated = EFalse;
+	RSqlDatabase db2;
+	
+	//An attempt to create a database
+	while(idx > 0 && err == KErrNoMemory)
+		{
+		(void)RSqlDatabase::Delete(KTestDbName4);
+		err = db2.Create(KTestDbName4);
+		if(err == KErrNone)
+			{
+			err = db2.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A(I) VALUES(1); INSERT INTO A(I) VALUES(2);"));
+			}
+		TheTest.Printf(_L("Database creation. Last error: %d.\r\n"), err);
+		TEST(err == KErrNoMemory || err >= 0);
+		if(err == KErrNoMemory)
+			{
+			db[--idx].Close();
+			}
+		else
+			{
+			dbCreated = ETrue;
+			}
+		db2.Close();
+		}
+	
+	if(dbCreated)
+		{
+		//Create again sql connection objects - as many as possible
+		err = CreateSqlConnections(idx, db, KMaxConnCount);
+		TEST(err == KErrNone || err == KErrNoMemory);
+		//Try to copy the database
+		err = RSqlDatabase::Copy(KTestDbName4, KTestDbName5);
+		TheTest.Printf(_L("Copy database. Last error: %d.\r\n"), err);
+		TEST(err == KErrNone || err == KErrNoMemory);
+		//Try to delete the databases
+		if(err == KErrNone)
+			{
+			err = RSqlDatabase::Delete(KTestDbName5);
+			TheTest.Printf(_L("Delete database copy. Last error: %d.\r\n"), err);
+			TEST(err == KErrNone || err == KErrNoMemory);
+			}
+		err = RSqlDatabase::Delete(KTestDbName4);
+		TheTest.Printf(_L("Delete database. Last error: %d.\r\n"), err);
+		TEST(err == KErrNone || err == KErrNoMemory);
+		}
+	
+	//Cleanup
+	for(TInt i=0;i<idx;++i)
+		{
+		db[i].Close();
+		if((i % 100) == 0)
+			{
+			GetHomeTimeAsString(time);
+			TheTest.Printf(_L("=== %S: % 5d sql connections closed\r\n"), &time, i + 1);
+			}
+		}
+	delete [] db;
+	db1.Close();
+	err = RSqlDatabase::Delete(KTestDbName5);
+	TEST(err == KErrNone || err == KErrNotFound);
+	err = RSqlDatabase::Delete(KTestDbName4);
+	TEST(err == KErrNone || err == KErrNotFound);
+	err = RSqlDatabase::Delete(KTestDbName1);
+	TEST(err == KErrNone || err == KErrNotFound);
+	}
+
+void DoTests()
+	{
+	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1627-0001 SQL server load test "));
+	SqlLoadTest();
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4201 Statement max number test"));
+	StatementMaxNumberTest();
+#if defined __WINS__ ||	defined __WINSCW__
+	//The next two tests are likely to timeout on hardware because they create a lot of file sessions and sql connections.
+	//The SQL server heap is 32Mb on hardware but only 6Mb on the Emulator. 
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4237 File session max number test"));
+	FileSessionMaxNumberTest();
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4238 Sql connection max number test"));
+	SqlConnectionMaxNumberTest();
+#endif	
+	}
+
+TInt E32Main()
+	{
+	TheTest.Title();
+
+	CTrapCleanup* tc = CTrapCleanup::New();
+
+	__UHEAP_MARK;
+
+	CreateTestDir();
+	DeleteTestFiles();
+	DoTests();
+	DeleteTestFiles();
+
+	__UHEAP_MARKEND;
+
+	TheTest.End();
+	TheTest.Close();
+
+	delete tc;
+
+	User::Heap().Check();
+	return KErrNone;
+	}