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