1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlload.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,985 @@
1.4 +// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <e32math.h>
1.21 +#include <bautils.h>
1.22 +#include <sqldb.h>
1.23 +#include "SqlResourceTester.h"
1.24 +
1.25 +///////////////////////////////////////////////////////////////////////////////////////
1.26 +
1.27 +#define UNUSED_VAR(a) (a) = (a)
1.28 +
1.29 +RTest TheTest(_L("t_sqlload test"));
1.30 +
1.31 +TDriveNumber KTestDrive = EDriveC;
1.32 +
1.33 +_LIT(KTestDir, "c:\\test\\");
1.34 +_LIT(KTestDbName1, "c:\\test\\t_sqlload_1.db");
1.35 +_LIT(KTestDbName2, "c:\\test\\t_sqlload_2.db");
1.36 +_LIT(KTestDbName3, "c:\\test\\t_sqlload_3.db");
1.37 +_LIT(KTestDbName4, "c:\\test\\t_sqlload_4.db");
1.38 +_LIT(KTestDbName5, "c:\\test\\t_sqlload_5.db");
1.39 +
1.40 +//Test thread count
1.41 +const TInt KTestThreadCnt = 4;
1.42 +
1.43 +//Test database names
1.44 +const TPtrC KTestDbNames[] =
1.45 + {
1.46 + KTestDbName1(),
1.47 + KTestDbName2(),
1.48 + KTestDbName3()
1.49 + };
1.50 +
1.51 +//Test database count
1.52 +const TInt KTestDbCnt = sizeof(KTestDbNames) / sizeof(KTestDbNames[0]);
1.53 +
1.54 +//Test duration
1.55 +const TInt KTestDuration = 120;//seconds
1.56 +
1.57 +//Test record count
1.58 +const TInt KRecordCnt = 100;
1.59 +//Record count which will be used in the test SQL queries
1.60 +const TInt KQueriedRecordCnt = 40;
1.61 +//Every SQL query will be processed (stepped) in KTestStepCnt steps.
1.62 +const TInt KTestStepCnt = 4;
1.63 +//RSqlStatement object count which will be used in the tests
1.64 +const TInt KStatementCnt = 10;
1.65 +//Max allowed alive RSqlStatement objects per thread
1.66 +const TInt KMaxStatementPerThread = 30;
1.67 +//Binary data length
1.68 +const TInt KBinDataLen = 2003;
1.69 +
1.70 +//StatementMaxNumberTest() time limit in seconds.
1.71 +const TInt KTestTimeLimit = 60;//seconds
1.72 +
1.73 +///////////////////////////////////////////////////////////////////////////////////////
1.74 +
1.75 +void DeleteTestFiles()
1.76 + {
1.77 + RSqlDatabase::Delete(KTestDbName5);
1.78 + RSqlDatabase::Delete(KTestDbName4);
1.79 + RSqlDatabase::Delete(KTestDbName3);
1.80 + RSqlDatabase::Delete(KTestDbName2);
1.81 + RSqlDatabase::Delete(KTestDbName1);
1.82 + }
1.83 +
1.84 +void GetHomeTimeAsString(TDes& aStr)
1.85 + {
1.86 + TTime time;
1.87 + time.HomeTime();
1.88 + TDateTime dt = time.DateTime();
1.89 + aStr.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());
1.90 + }
1.91 +
1.92 +///////////////////////////////////////////////////////////////////////////////////////
1.93 +///////////////////////////////////////////////////////////////////////////////////////
1.94 +//Test macros and functions
1.95 +void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)
1.96 + {
1.97 + if(!aValue)
1.98 + {
1.99 + DeleteTestFiles();
1.100 + if(aPrintThreadName)
1.101 + {
1.102 + RThread th;
1.103 + TName name = th.Name();
1.104 + RDebug::Print(_L("*** Thread %S, Line %d\r\n"), &name, aLine);
1.105 + }
1.106 + else
1.107 + {
1.108 + RDebug::Print(_L("*** Line %d\r\n"), aLine);
1.109 + }
1.110 + TheTest(EFalse, aLine);
1.111 + }
1.112 + }
1.113 +void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)
1.114 + {
1.115 + if(aValue != aExpected)
1.116 + {
1.117 + DeleteTestFiles();
1.118 + if(aPrintThreadName)
1.119 + {
1.120 + RThread th;
1.121 + TName name = th.Name();
1.122 + RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);
1.123 + }
1.124 + else
1.125 + {
1.126 + RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
1.127 + }
1.128 + TheTest(EFalse, aLine);
1.129 + }
1.130 + }
1.131 +#define TEST(arg) ::Check1((arg), __LINE__)
1.132 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.133 +#define TTEST(arg) ::Check1((arg), __LINE__, ETrue)
1.134 +#define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)
1.135 +
1.136 +///////////////////////////////////////////////////////////////////////////////////////
1.137 +
1.138 +//StatementMaxNumberTest() timeouts in WDP builds.
1.139 +//This function is used to return the seconds passed from the start of the test case.
1.140 +TTimeIntervalSeconds ExecutionTimeSeconds(TTime& aStartTime)
1.141 + {
1.142 + TTime currTime;
1.143 + currTime.HomeTime();
1.144 +
1.145 + TTimeIntervalSeconds s;
1.146 + TInt err = currTime.SecondsFrom(aStartTime, s);
1.147 + TEST2(err, KErrNone);
1.148 + return s;
1.149 + }
1.150 +
1.151 +void CreateTestDir()
1.152 + {
1.153 + RFs fs;
1.154 + TInt err = fs.Connect();
1.155 + TEST2(err, KErrNone);
1.156 +
1.157 + err = fs.MkDir(KTestDir);
1.158 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.159 +
1.160 + err = fs.CreatePrivatePath(KTestDrive);
1.161 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.162 +
1.163 + fs.Close();
1.164 + }
1.165 +
1.166 +///////////////////////////////////////////////////////////////////////////////////////
1.167 +
1.168 +void CreateTestDatabases()
1.169 + {
1.170 + HBufC8* recData = HBufC8::New(KBinDataLen * 2 + 50);//"* 2" - hex values for the INSERT SQL statement
1.171 + TEST(recData != NULL);
1.172 + TPtr8 sql = recData->Des();
1.173 +
1.174 + for(TInt dbIdx=0;dbIdx<KTestDbCnt;++dbIdx)
1.175 + {
1.176 + //Create test database
1.177 + RSqlDatabase db;
1.178 + TInt err = db.Create(KTestDbNames[dbIdx]);
1.179 + TEST2(err, KErrNone);
1.180 +
1.181 + //Create test table
1.182 + _LIT8(KCreateSql, "CREATE TABLE A(F1 INTEGER, F2 BLOB)");
1.183 + err = db.Exec(KCreateSql);
1.184 + TEST(err >= 0);
1.185 +
1.186 + //Insert records in the test table
1.187 + for(TInt recIdx=1;recIdx<=KRecordCnt;++recIdx)
1.188 + {
1.189 + _LIT8(KInsertSql, "INSERT INTO A(F1, F2) VALUES(");
1.190 + sql.Copy(KInsertSql);
1.191 + sql.AppendNum((TInt64)recIdx);
1.192 + sql.Append(_L(", X'"));
1.193 + for(TInt k=0;k<KBinDataLen;++k)
1.194 + {
1.195 + sql.AppendFormat(_L8("%02X"), recIdx);
1.196 + }
1.197 + sql.Append(_L("')"));
1.198 + err = db.Exec(sql);
1.199 + TEST2(err, 1);
1.200 + }
1.201 +
1.202 + db.Close();
1.203 + }
1.204 +
1.205 + delete recData;
1.206 + }
1.207 +
1.208 +//Structure used by the test thread function for orginizing its set of test data.
1.209 +struct TSqlStatement
1.210 + {
1.211 + RSqlStatement iObj;
1.212 + TBool iAlive; //Non-zero if iObj is alive
1.213 + TInt iCurIndex; //The number of the current record in the set controlled by iObj statement
1.214 + TInt iEndIndex; //The last record number in the set controlled by iObj statement
1.215 + TInt iCount; //Records count in the set controlled by iObj statement
1.216 + };
1.217 +
1.218 +typedef RArray<TSqlStatement> RSqlStatementArray;
1.219 +
1.220 +//Inits the random numbers generator.
1.221 +//Opens one of the test databases.
1.222 +void PreTest(RSqlDatabase& aDb, TInt64& aSeed, TName& aThreadName)
1.223 + {
1.224 + RThread currThread;
1.225 +
1.226 + //Init the random numbers generator
1.227 + TTime now;
1.228 + now.UniversalTime();
1.229 + aSeed = now.Int64() + currThread.Id();
1.230 +
1.231 + //Open one of the test databases
1.232 + const TInt KDbIndex = Math::Rand(aSeed) % KTestDbCnt;
1.233 +
1.234 + aThreadName = currThread.Name();
1.235 + RDebug::Print(_L("=== Thread %S, database %S\r\n"), &aThreadName, &KTestDbNames[KDbIndex]);
1.236 +
1.237 + TInt err = aDb.Open(KTestDbNames[KDbIndex]);
1.238 + TTEST2(err, KErrNone);
1.239 + }
1.240 +
1.241 +//Creates N statements, where 0 < N < KStatementCnt
1.242 +TInt CreateStatements(RSqlDatabase& aDb, TInt64& aSeed, RSqlStatementArray& aStmtArray)
1.243 + {
1.244 + TInt stmtCount = Math::Rand(aSeed) % KStatementCnt;
1.245 + if(stmtCount == 0)
1.246 + {
1.247 + stmtCount = 1;
1.248 + }
1.249 + for(TInt i=0;i<stmtCount;++i)
1.250 + {
1.251 + TSqlStatement stmt;
1.252 + stmt.iAlive = EFalse;
1.253 + stmt.iCount = KQueriedRecordCnt;
1.254 + stmt.iCurIndex = Math::Rand(aSeed) % KRecordCnt;
1.255 + if(stmt.iCurIndex == 0)
1.256 + {
1.257 + stmt.iCurIndex = 1;
1.258 + }
1.259 + if(stmt.iCurIndex > (KRecordCnt - KQueriedRecordCnt))
1.260 + {
1.261 + stmt.iCurIndex = KRecordCnt - KQueriedRecordCnt;
1.262 + }
1.263 + stmt.iEndIndex = stmt.iCurIndex + KQueriedRecordCnt;
1.264 + TBuf8<100> sql;
1.265 + sql.Copy(_L8("SELECT * FROM A WHERE F1 >= "));
1.266 + sql.AppendNum(stmt.iCurIndex);
1.267 + sql.Append(_L8(" AND F1 < "));
1.268 + sql.AppendNum(stmt.iEndIndex);
1.269 + TInt err = stmt.iObj.Prepare(aDb, sql);
1.270 + TTEST2(err, KErrNone);
1.271 + stmt.iAlive = ETrue;
1.272 + err = aStmtArray.Append(stmt);
1.273 + TTEST2(err, KErrNone);
1.274 + }
1.275 + return stmtCount;
1.276 + }
1.277 +
1.278 +//For each alive statement object - do (TSqlStatement::iCount / KTestStepCnt)
1.279 +//RSqlStatement::Next() calls. If the Next() call reaches the end - close the statement object.
1.280 +TInt ProcessStatements(RSqlStatementArray& aStmtArray)
1.281 + {
1.282 + const TInt KTotalStmtCount = aStmtArray.Count();
1.283 + TInt alive = 0;
1.284 + TInt completed = 0;
1.285 + for(TInt k=0;k<KTotalStmtCount;++k)
1.286 + {
1.287 + TSqlStatement& stmt = aStmtArray[k];
1.288 + if(stmt.iAlive)
1.289 + {
1.290 + ++alive;
1.291 + TInt endIndex = stmt.iCurIndex + stmt.iCount / KTestStepCnt;
1.292 + if(endIndex <= stmt.iEndIndex)
1.293 + {
1.294 + while(stmt.iCurIndex < endIndex)
1.295 + {
1.296 + TInt err = stmt.iObj.Next();
1.297 + TTEST2(err, KSqlAtRow);
1.298 + //test column values
1.299 + TInt val1 = stmt.iObj.ColumnInt(0);
1.300 + TTEST(val1 == stmt.iCurIndex);
1.301 + RSqlColumnReadStream strm;
1.302 + err = strm.ColumnBinary(stmt.iObj, 1);
1.303 + TTEST2(err, KErrNone);
1.304 + for(TInt ii=0;ii<KBinDataLen;++ii)
1.305 + {
1.306 + TUint8 byte = 0;
1.307 + TRAP(err, byte = strm.ReadUint8L());
1.308 + TTEST2(err, KErrNone);
1.309 + TTEST(byte == (TUint8)val1);
1.310 + }
1.311 + strm.Close();
1.312 + ++stmt.iCurIndex;
1.313 + }
1.314 + }
1.315 + if(stmt.iCurIndex >= stmt.iEndIndex)
1.316 + {
1.317 + stmt.iObj.Close();
1.318 + stmt.iAlive = EFalse;
1.319 + ++completed;
1.320 + }
1.321 + }
1.322 + }
1.323 + return completed;
1.324 + }
1.325 +
1.326 +//Close up to N statements, where 0 < N < KStatementCnt
1.327 +TInt CloseStatements(RSqlStatementArray& aStmtArray, TInt64& aSeed)
1.328 + {
1.329 + TInt stmtCount = Math::Rand(aSeed) % KStatementCnt;
1.330 + if(stmtCount == 0)
1.331 + {
1.332 + stmtCount = 1;
1.333 + }
1.334 + const TInt KTotalStmtCount = aStmtArray.Count();
1.335 + TInt closed = 0;
1.336 + for(TInt j=0;j<stmtCount;++j)
1.337 + {
1.338 + const TInt KIdx = Math::Rand(aSeed) % KTotalStmtCount;
1.339 + TInt idx = KIdx;
1.340 + while((idx = (++idx % KTotalStmtCount)) != KIdx)
1.341 + {
1.342 + if(aStmtArray[idx].iAlive)
1.343 + {
1.344 + aStmtArray[idx].iObj.Close();
1.345 + aStmtArray[idx].iAlive = EFalse;
1.346 + ++closed;
1.347 + break;
1.348 + }
1.349 + }
1.350 + }
1.351 + return closed;
1.352 + }
1.353 +
1.354 +//Counts the alive statements
1.355 +TInt AliveStatementsCount(RSqlStatementArray& aStmtArray)
1.356 + {
1.357 + TInt aliveCnt = 0;
1.358 + const TInt KTotalStmtCount = aStmtArray.Count();
1.359 + for(TInt l=0;l<KTotalStmtCount;++l)
1.360 + {
1.361 + if(aStmtArray[l].iAlive)
1.362 + {
1.363 + ++aliveCnt;
1.364 + }
1.365 + }
1.366 + return aliveCnt;
1.367 + }
1.368 +
1.369 +//Close all alive statements
1.370 +void CloseAllStatements(RSqlStatementArray& aStmtArray)
1.371 + {
1.372 + const TInt KTotalStmtCount = aStmtArray.Count();
1.373 + for(TInt i=0;i<KTotalStmtCount;++i)
1.374 + {
1.375 + if(aStmtArray[i].iAlive)
1.376 + {
1.377 + aStmtArray[i].iObj.Close();
1.378 + }
1.379 + }
1.380 + TTEST2(TSqlResourceTester::Count(), 0);
1.381 + }
1.382 +
1.383 +//Removes the already closed statements and compresses the array
1.384 +void RemoveDeadStatements(RSqlStatementArray& aStmtArray)
1.385 + {
1.386 + for(TInt i=aStmtArray.Count()-1;i>=0;--i)
1.387 + {
1.388 + if(!aStmtArray[i].iAlive)
1.389 + {
1.390 + aStmtArray.Remove(i);
1.391 + }
1.392 + }
1.393 + aStmtArray.Compress();
1.394 + }
1.395 +
1.396 +//Close statement objects, statements array and the database object
1.397 +TInt PostTest(RSqlDatabase& aDb, RSqlStatementArray& aStmtArray)
1.398 + {
1.399 + TInt statementsAlive = AliveStatementsCount(aStmtArray);
1.400 + CloseAllStatements(aStmtArray);
1.401 + aStmtArray.Close();
1.402 + aDb.Close();
1.403 + return statementsAlive;
1.404 + }
1.405 +
1.406 +//Test thread function
1.407 +//The thread function works with a set of TSqlStatement objects
1.408 +//The test consists of 4 steps:
1.409 +//Step 1: the test thread creates m TSqlStatement objects, 0 < m < KStatementCnt.
1.410 +// With each of the created TSqlStatement objects the test thread prepares SELECT SQL query
1.411 +// "SELECT * FROM A WHERE F1 >= K1 AND F1 < K2", where K1 is random generated number, such that:
1.412 +// 0 < K1 < (KRecordCnt - KQueriedRecordCnt)
1.413 +// K2 = K1 + KQueriedRecordCnt
1.414 +// All just created TSqlStatement objects are marked as alive.
1.415 +//Step 2: For each alive TSqlStatement object the test thread calls iObj.Next() method KTestStepCnt times,
1.416 +// KTestStepCnt < KQueriedRecordCnt.
1.417 +// The column values are retrieved and checked.
1.418 +//Step 3: the test thread closes n TSqlStatement objects, 0 < n < KStatementCnt.
1.419 +//Step 4: the test thread counts how many alive TSqlStatement objects are there.
1.420 +// If this count > KMaxStatementPerThread then the test thread closes all alive TSqlStatement objects
1.421 +// to avoid OOM errors during the test.
1.422 +//
1.423 +// Each test thread does steps 1..4 for a period of KTestDuration seconds.
1.424 +// At the end all TSqlStatement objects are closed.
1.425 +//
1.426 +// The idea of the test is to load the SQL server creating several amount of statement and stream objects
1.427 +// and see that it is working stable and without problems.
1.428 +TInt ThreadFunc(void*)
1.429 + {
1.430 + __UHEAP_MARK;
1.431 +
1.432 + CTrapCleanup* tc = CTrapCleanup::New();
1.433 + TTEST(tc != NULL);
1.434 +
1.435 + TInt64 seed = 0;
1.436 + RSqlDatabase db;
1.437 + TName threadName;
1.438 + RSqlStatementArray statements;
1.439 +
1.440 + //Init the random numbers generator, opens the database
1.441 + PreTest(db, seed, threadName);
1.442 +
1.443 + //Main test loop
1.444 + TInt iteration = 0;
1.445 + TTime currTime;
1.446 + currTime.UniversalTime();
1.447 + TTime endTime = currTime + TTimeIntervalSeconds(KTestDuration);
1.448 + while(currTime < endTime)
1.449 + {
1.450 + ++iteration;
1.451 + ///////////////////////////////////////////////////////////////////////
1.452 + TInt statementsAliveBegin = statements.Count();
1.453 + //Step 1: Create N statements, where 0 < N < KStatementCnt
1.454 + TInt statementsCreated = CreateStatements(db, seed, statements);
1.455 + ///////////////////////////////////////////////////////////////////////
1.456 + //Step 2: For each alive statement object - do (TSqlStatement::iCount / KTestStepCnt)
1.457 + // RSqlStatement::Next() calls. If the Next() call reaches the end - close the statement object.
1.458 + TInt statementsCompleted = ProcessStatements(statements);
1.459 + ///////////////////////////////////////////////////////////////////////
1.460 + //Step 3: Close up to N statements, where 0 < N < KStatementCnt
1.461 + TInt statementsClosed = CloseStatements(statements, seed);
1.462 + ///////////////////////////////////////////////////////////////////////
1.463 + //Step 4: If the alive statement count is more than KMaxStatementPerThread, then close them all
1.464 + TInt statementsAliveEnd = AliveStatementsCount(statements);
1.465 + if(statementsAliveEnd > KMaxStatementPerThread)
1.466 + {
1.467 + RDebug::Print(_L("!!! Thread %S, iteration %d, alive %d, close all\r\n"), &threadName, iteration, statementsAliveEnd);
1.468 + CloseAllStatements(statements);
1.469 + statementsAliveEnd = 0;
1.470 + }
1.471 + ///////////////////////////////////////////////////////////////////////
1.472 + RemoveDeadStatements(statements);
1.473 + RDebug::Print(_L("=== Thread %S, iteration % 4d, begin: % 3d, created % 2d, closed % 2d, completed % 2d, end % 3d, \r\n"),
1.474 + &threadName, iteration, statementsAliveBegin,
1.475 + statementsCreated, statementsClosed, statementsCompleted,
1.476 + statementsAliveEnd);
1.477 + currTime.UniversalTime();
1.478 + }
1.479 +
1.480 + //Close statement objects and the database object
1.481 + TInt statementsAlive = PostTest(db, statements);
1.482 +
1.483 + delete tc;
1.484 +
1.485 + __UHEAP_MARKEND;
1.486 +
1.487 + RDebug::Print(_L("=== Thread %S exit, still alive %d\r\n"), &threadName, statementsAlive);
1.488 +
1.489 + return KErrNone;
1.490 + }
1.491 +
1.492 +void CreateTestThreads(RThread aThreads[], TRequestStatus aStatuses[], TInt aMaxCount)
1.493 + {
1.494 + _LIT(KThreadName, "TstThr");
1.495 + for(TInt i=0;i<aMaxCount;++i)
1.496 + {
1.497 + TBuf<20> threadName(KThreadName);
1.498 + threadName.AppendNum((TInt64)(i + 1));
1.499 + TEST2(aThreads[i].Create(threadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, NULL, EOwnerProcess), KErrNone);
1.500 + aThreads[i].Logon(aStatuses[i]);
1.501 + TEST2(aStatuses[i].Int(), KRequestPending);
1.502 + }
1.503 + }
1.504 +
1.505 +void ResumeTestThreads(RThread aThreads[], TInt aMaxCount)
1.506 + {
1.507 + for(TInt i=0;i<aMaxCount;++i)
1.508 + {
1.509 + aThreads[i].Resume();
1.510 + }
1.511 + }
1.512 +
1.513 +
1.514 +void CloseTestThreads(RThread aThreads[], TRequestStatus aStatuses[], TInt aMaxCount)
1.515 + {
1.516 + for(TInt i=0;i<aMaxCount;++i)
1.517 + {
1.518 + User::WaitForRequest(aStatuses[i]);
1.519 + TEST(aThreads[i].ExitType() != EExitPanic);
1.520 + aThreads[i].Close();
1.521 + }
1.522 + }
1.523 +
1.524 +/**
1.525 +@SYMTestCaseID SYSLIB-SQL-CT-1627-0001
1.526 +@SYMTestCaseDesc SQL server load test. The test creates KTestThreadCnt threads, KTestDbCnt test databases and
1.527 + inserts in each of them KRecordCnt test records.
1.528 + Pre-test step: each test thread randomly chooses and opens one of the test databases.
1.529 + Then, each of the test threads is doing the following 4 test steps:
1.530 + Step 1: the test thread creates m TSqlStatement objects, 0 < m < KStatementCnt.
1.531 + With each of the created TSqlStatement objects the test thread prepares SELECT SQL query
1.532 + "SELECT * FROM A WHERE F1 >= K1 AND F1 < K2", where K1 is random generated number, such that:
1.533 + 0 < K1 < (KRecordCnt - KQueriedRecordCnt)
1.534 + K2 = K1 + KQueriedRecordCnt
1.535 + All just created TSqlStatement objects are marked as alive.
1.536 + Step 2: For each alive TSqlStatement object the test thread calls iObj.Next() method KTestStepCnt times,
1.537 + KTestStepCnt < KQueriedRecordCnt.
1.538 + The column values are retrieved and checked.
1.539 + Step 3: the test thread closes n TSqlStatement objects, 0 < n < KStatementCnt.
1.540 + Step 4: the test thread counts how many alive TSqlStatement objects are there.
1.541 + If this count > KMaxStatementPerThread then the test thread closes all alive TSqlStatement objects
1.542 + to avoid OOM errors during the test.
1.543 +
1.544 + Each test thread does steps 1..4 for a period of KTestDuration seconds.
1.545 + At the end all TSqlStatement objects are closed.
1.546 +
1.547 + The idea of the test is to load the SQL server creating several amount of statement and stream objects
1.548 + and see that it is working stable and without problems.
1.549 +@SYMTestPriority High
1.550 +@SYMTestActions SQL server load test
1.551 +@SYMTestExpectedResults Test must not fail
1.552 +@SYMREQ REQ5792
1.553 + REQ5793
1.554 +*/
1.555 +void SqlLoadTest()
1.556 + {
1.557 + CreateTestDatabases();
1.558 +
1.559 + RThread threads[KTestThreadCnt];
1.560 + TRequestStatus statuses[KTestThreadCnt];
1.561 +
1.562 + CreateTestThreads(threads, statuses, KTestThreadCnt);
1.563 +
1.564 + ResumeTestThreads(threads, KTestThreadCnt);
1.565 +
1.566 + User::After(2000000);
1.567 +
1.568 + CloseTestThreads(threads, statuses, KTestThreadCnt);
1.569 + }
1.570 +
1.571 +/**
1.572 +@SYMTestCaseID PDS-SQL-CT-4201
1.573 +@SYMTestCaseDesc Max number of SQL statements test.
1.574 +@SYMTestPriority High
1.575 +@SYMTestActions The test creates a table with couple of records and then
1.576 + creates as many as possible SQL statements. The expected result is
1.577 + that either the statement creation process will fail with KErrNoMemory or
1.578 + the max number of statements to be created is reached (100000).
1.579 + Then the test deletes 1/2 of the created statements objects and
1.580 + after that attempts to execute Next() on the rest of them.
1.581 + Note that the test has a time limit of 120 seconds. Otherwise on some platforms
1.582 + with WDP feature switched on the test may timeout.
1.583 +@SYMTestExpectedResults Test must not fail
1.584 +@SYMDEF DEF145236
1.585 +*/
1.586 +void StatementMaxNumberTest()
1.587 + {
1.588 + TBuf<30> time;
1.589 + GetHomeTimeAsString(time);
1.590 + TheTest.Printf(_L("=== %S: Create database\r\n"), &time);
1.591 +
1.592 + (void)RSqlDatabase::Delete(KTestDbName1);
1.593 + RSqlDatabase db;
1.594 + TInt err = db.Create(KTestDbName1);
1.595 + TEST2(err, KErrNone);
1.596 + err = db.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A(I) VALUES(1); INSERT INTO A(I) VALUES(2);"));
1.597 + TEST(err >= 0);
1.598 +
1.599 + GetHomeTimeAsString(time);
1.600 + TheTest.Printf(_L("=== %S: Create statements array\r\n"), &time);
1.601 +
1.602 + //Reserve memory for the statement objects
1.603 + const TInt KMaxStmtCount = 100000;
1.604 + RSqlStatement* stmt = new RSqlStatement[KMaxStmtCount];
1.605 + TEST(stmt != NULL);
1.606 +
1.607 + TTime startTime;
1.608 + startTime.HomeTime();
1.609 +
1.610 + //Create as many statement objects as possible
1.611 + TInt idx = 0;
1.612 + err = KErrNone;
1.613 + for(;idx<KMaxStmtCount;++idx)
1.614 + {
1.615 + err = stmt[idx].Prepare(db, _L("SELECT * FROM A WHERE I>=0 AND I<10"));
1.616 + if(err != KErrNone)
1.617 + {
1.618 + break;
1.619 + }
1.620 + TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
1.621 + if((idx % 100) == 0)
1.622 + {
1.623 + GetHomeTimeAsString(time);
1.624 + TheTest.Printf(_L("=== %S: Create % 5d statements. %d seconds.\r\n"), &time, idx + 1, s.Int());
1.625 + }
1.626 + if(s.Int() > KTestTimeLimit)
1.627 + {
1.628 + GetHomeTimeAsString(time);
1.629 + TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
1.630 + ++idx;//The idx-th statement is valid, the statement count is idx + 1.
1.631 + break;
1.632 + }
1.633 + }
1.634 +
1.635 + TInt stmtCnt = idx;
1.636 + TheTest.Printf(_L("%d created statement objects. Last error: %d.\r\n"), stmtCnt, err);
1.637 + TEST(err == KErrNone || err == KErrNoMemory);
1.638 +
1.639 + //Close 1/2 of the statements to free some memory
1.640 + idx = 0;
1.641 + for(;idx<(stmtCnt/2);++idx)
1.642 + {
1.643 + stmt[idx].Close();
1.644 + if((idx % 100) == 0)
1.645 + {
1.646 + GetHomeTimeAsString(time);
1.647 + TheTest.Printf(_L("=== %S: % 5d statements closed\r\n"), &time, idx + 1);
1.648 + }
1.649 + }
1.650 +
1.651 + //Now, there should be enough memory to be able to execute Next() on the rest of the statements
1.652 + for(TInt j=0;idx<stmtCnt;++idx,++j)
1.653 + {
1.654 + err = stmt[idx].Next();
1.655 + TEST2(err, KSqlAtRow);
1.656 + err = stmt[idx].Next();
1.657 + TEST2(err, KSqlAtRow);
1.658 + err = stmt[idx].Next();
1.659 + TEST2(err, KSqlAtEnd);
1.660 + GetHomeTimeAsString(time);
1.661 + TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
1.662 + if((j % 100) == 0)
1.663 + {
1.664 + TheTest.Printf(_L("=== %S: % 5d statements processed. %d seconds.\r\n"), &time, j + 1, s.Int());
1.665 + }
1.666 + if(s.Int() > KTestTimeLimit)
1.667 + {
1.668 + TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
1.669 + break;
1.670 + }
1.671 + }
1.672 +
1.673 + //Cleanup
1.674 + for(idx=0;idx<stmtCnt;++idx)
1.675 + {
1.676 + stmt[idx].Close();
1.677 + if((idx % 100) == 0)
1.678 + {
1.679 + GetHomeTimeAsString(time);
1.680 + TheTest.Printf(_L("=== %S: % 5d statements closed\r\n"), &time, idx + 1);
1.681 + }
1.682 + }
1.683 + delete [] stmt;
1.684 + db.Close();
1.685 + (void)RSqlDatabase::Delete(KTestDbName1);
1.686 + GetHomeTimeAsString(time);
1.687 + TheTest.Printf(_L("=== %S: Test case end\r\n"), &time);
1.688 + }
1.689 +
1.690 +TInt CreateFileSessions(TInt& aIdx, RFs aFs[], TInt aMaxFsSessCount)
1.691 + {
1.692 + TBuf<30> time;
1.693 + TTime startTime;
1.694 + startTime.HomeTime();
1.695 + //Create as many file session objects as possible
1.696 + TInt err = KErrNone;
1.697 + for(;aIdx<aMaxFsSessCount;++aIdx)
1.698 + {
1.699 + err = aFs[aIdx].Connect();
1.700 + if(err != KErrNone)
1.701 + {
1.702 + break;
1.703 + }
1.704 + TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
1.705 + if((aIdx % 500) == 0)
1.706 + {
1.707 + GetHomeTimeAsString(time);
1.708 + TheTest.Printf(_L("=== %S: Create % 5d file sessions. %d seconds.\r\n"), &time, aIdx + 1, s.Int());
1.709 + }
1.710 + if(s.Int() > KTestTimeLimit)
1.711 + {
1.712 + GetHomeTimeAsString(time);
1.713 + TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
1.714 + ++aIdx;//The idx-th file session object is valid, the file session count is idx + 1.
1.715 + break;
1.716 + }
1.717 + }
1.718 + return err;
1.719 + }
1.720 +
1.721 +/**
1.722 +@SYMTestCaseID PDS-SQL-CT-4237
1.723 +@SYMTestCaseDesc Max file session number test.
1.724 +@SYMTestPriority High
1.725 +@SYMTestActions The test creates as many as possible file session objects. The expected result is
1.726 + that either the file session creation process will fail with KErrNoMemory or
1.727 + the max number of file sessions to be created is reached (100000).
1.728 + Then the test attempts to create a database. If there is no memory, the test
1.729 + closes some of the file session objects. The test also attempts to copy
1.730 + the created database and to delete it after that, both operations performed
1.731 + with all file session objects still open. The expectation is that the test
1.732 + will not crash the SQL server or the client side SQL dll.
1.733 + Note that the test has a time limit of 120 seconds. Otherwise on some platforms
1.734 + with WDP feature switched on the test may timeout.
1.735 +@SYMTestExpectedResults Test must not fail
1.736 +*/
1.737 +void FileSessionMaxNumberTest()
1.738 + {
1.739 + TBuf<30> time;
1.740 + GetHomeTimeAsString(time);
1.741 + TheTest.Printf(_L("=== %S: Create file sessions\r\n"), &time);
1.742 +
1.743 + const TInt KMaxFsCount = 100000;
1.744 + RFs* fs = new RFs[KMaxFsCount];
1.745 + TEST(fs != NULL);
1.746 +
1.747 + //Create as many file session objects as possible
1.748 + TInt idx = 0;
1.749 + TInt err = CreateFileSessions(idx, fs, KMaxFsCount);
1.750 + TheTest.Printf(_L("%d created file session objects. Last error: %d.\r\n"), idx, err);
1.751 + TEST(err == KErrNone || err == KErrNoMemory);
1.752 +
1.753 + TBool dbCreated = EFalse;
1.754 + RSqlDatabase db;
1.755 +
1.756 + //An attempt to create a database
1.757 + while(idx > 0 && err == KErrNoMemory)
1.758 + {
1.759 + (void)RSqlDatabase::Delete(KTestDbName1);
1.760 + err = db.Create(KTestDbName1);
1.761 + if(err == KErrNone)
1.762 + {
1.763 + err = db.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A(I) VALUES(1); INSERT INTO A(I) VALUES(2);"));
1.764 + }
1.765 + TheTest.Printf(_L("Database creation. Last error: %d.\r\n"), err);
1.766 + TEST(err == KErrNoMemory || err >= 0);
1.767 + if(err == KErrNoMemory)
1.768 + {
1.769 + fs[--idx].Close();
1.770 + }
1.771 + else
1.772 + {
1.773 + dbCreated = ETrue;
1.774 + }
1.775 + db.Close();
1.776 + }
1.777 +
1.778 + if(dbCreated)
1.779 + {
1.780 + //Create again file session objects - as many as possible
1.781 + err = CreateFileSessions(idx, fs, KMaxFsCount);
1.782 + TEST(err == KErrNone || err == KErrNoMemory);
1.783 + //Try to copy the database
1.784 + err = RSqlDatabase::Copy(KTestDbName1, KTestDbName4);
1.785 + TheTest.Printf(_L("Copy database. Last error: %d.\r\n"), err);
1.786 + TEST(err == KErrNone || err == KErrNoMemory);
1.787 + //Try to delete the databases
1.788 + if(err == KErrNone)
1.789 + {
1.790 + err = RSqlDatabase::Delete(KTestDbName4);
1.791 + TheTest.Printf(_L("Delete database copy. Last error: %d.\r\n"), err);
1.792 + TEST(err == KErrNone || err == KErrNoMemory);
1.793 + }
1.794 + err = RSqlDatabase::Delete(KTestDbName1);
1.795 + TheTest.Printf(_L("Delete database. Last error: %d.\r\n"), err);
1.796 + TEST(err == KErrNone || err == KErrNoMemory);
1.797 + }
1.798 +
1.799 + //Cleanup
1.800 + for(TInt i=0;i<idx;++i)
1.801 + {
1.802 + fs[i].Close();
1.803 + if((i % 500) == 0)
1.804 + {
1.805 + GetHomeTimeAsString(time);
1.806 + TheTest.Printf(_L("=== %S: % 5d file sessions closed\r\n"), &time, i + 1);
1.807 + }
1.808 + }
1.809 + delete [] fs;
1.810 + err = RSqlDatabase::Delete(KTestDbName4);
1.811 + TEST(err == KErrNone || err == KErrNotFound);
1.812 + err = RSqlDatabase::Delete(KTestDbName1);
1.813 + TEST(err == KErrNone || err == KErrNotFound);
1.814 + }
1.815 +
1.816 +TInt CreateSqlConnections(TInt& aIdx, RSqlDatabase aDb[], TInt aMaxSqlConnCount)
1.817 + {
1.818 + TBuf<30> time;
1.819 + TTime startTime;
1.820 + startTime.HomeTime();
1.821 + //Create as many file session objects as possible
1.822 + TInt err = KErrNone;
1.823 + for(;aIdx<aMaxSqlConnCount;++aIdx)
1.824 + {
1.825 + err = aDb[aIdx].Open(KTestDbName1);
1.826 + if(err != KErrNone)
1.827 + {
1.828 + break;
1.829 + }
1.830 + TTimeIntervalSeconds s = ExecutionTimeSeconds(startTime);
1.831 + if((aIdx % 100) == 0)
1.832 + {
1.833 + GetHomeTimeAsString(time);
1.834 + TheTest.Printf(_L("=== %S: Create % 5d sql connections. %d seconds.\r\n"), &time, aIdx + 1, s.Int());
1.835 + }
1.836 + if(s.Int() > KTestTimeLimit)
1.837 + {
1.838 + GetHomeTimeAsString(time);
1.839 + TheTest.Printf(_L("=== %S: The time limit reached.\r\n"), &time);
1.840 + ++aIdx;//The idx-th sql connection is valid, the sql connection count is idx + 1.
1.841 + break;
1.842 + }
1.843 + }
1.844 + return err;
1.845 + }
1.846 +
1.847 +/**
1.848 +@SYMTestCaseID PDS-SQL-CT-4238
1.849 +@SYMTestCaseDesc Max sql connection number test.
1.850 +@SYMTestPriority High
1.851 +@SYMTestActions The test creates as many as possible sql connection objects. The expected result is
1.852 + that either the sql connection creation process will fail with KErrNoMemory or
1.853 + the max number of sql connection to be created is reached (100000).
1.854 + Then the test attempts to create a database. If there is no memory, the test
1.855 + closes some of the sql connection objects. The test also attempts to copy
1.856 + the created database and to delete it after that, both operations performed
1.857 + with all sql connection objects still open. The expectation is that the test
1.858 + will not crash the SQL server or the client side SQL dll.
1.859 + Note that the test has a time limit of 120 seconds. Otherwise on some platforms
1.860 + with WDP feature switched on the test may timeout.
1.861 +@SYMTestExpectedResults Test must not fail
1.862 +*/
1.863 +void SqlConnectionMaxNumberTest()
1.864 + {
1.865 + TBuf<30> time;
1.866 + GetHomeTimeAsString(time);
1.867 + TheTest.Printf(_L("=== %S: Create sql connections\r\n"), &time);
1.868 +
1.869 + (void)RSqlDatabase::Delete(KTestDbName1);
1.870 + RSqlDatabase db1;
1.871 + TInt err = db1.Create(KTestDbName1);//CreateSqlConnections() opens the already existing KTestDbName1 database
1.872 + TEST2(err, KErrNone);
1.873 +
1.874 + const TInt KMaxConnCount = 100000;
1.875 + RSqlDatabase* db = new RSqlDatabase[KMaxConnCount];
1.876 + TEST(db != NULL);
1.877 +
1.878 + //Create as many sql connection objects as possible
1.879 + TInt idx = 0;
1.880 + err = CreateSqlConnections(idx, db, KMaxConnCount);
1.881 + TheTest.Printf(_L("%d created sql connection objects. Last error: %d.\r\n"), idx, err);
1.882 + TEST(err == KErrNone || err == KErrNoMemory);
1.883 +
1.884 + TBool dbCreated = EFalse;
1.885 + RSqlDatabase db2;
1.886 +
1.887 + //An attempt to create a database
1.888 + while(idx > 0 && err == KErrNoMemory)
1.889 + {
1.890 + (void)RSqlDatabase::Delete(KTestDbName4);
1.891 + err = db2.Create(KTestDbName4);
1.892 + if(err == KErrNone)
1.893 + {
1.894 + err = db2.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A(I) VALUES(1); INSERT INTO A(I) VALUES(2);"));
1.895 + }
1.896 + TheTest.Printf(_L("Database creation. Last error: %d.\r\n"), err);
1.897 + TEST(err == KErrNoMemory || err >= 0);
1.898 + if(err == KErrNoMemory)
1.899 + {
1.900 + db[--idx].Close();
1.901 + }
1.902 + else
1.903 + {
1.904 + dbCreated = ETrue;
1.905 + }
1.906 + db2.Close();
1.907 + }
1.908 +
1.909 + if(dbCreated)
1.910 + {
1.911 + //Create again sql connection objects - as many as possible
1.912 + err = CreateSqlConnections(idx, db, KMaxConnCount);
1.913 + TEST(err == KErrNone || err == KErrNoMemory);
1.914 + //Try to copy the database
1.915 + err = RSqlDatabase::Copy(KTestDbName4, KTestDbName5);
1.916 + TheTest.Printf(_L("Copy database. Last error: %d.\r\n"), err);
1.917 + TEST(err == KErrNone || err == KErrNoMemory);
1.918 + //Try to delete the databases
1.919 + if(err == KErrNone)
1.920 + {
1.921 + err = RSqlDatabase::Delete(KTestDbName5);
1.922 + TheTest.Printf(_L("Delete database copy. Last error: %d.\r\n"), err);
1.923 + TEST(err == KErrNone || err == KErrNoMemory);
1.924 + }
1.925 + err = RSqlDatabase::Delete(KTestDbName4);
1.926 + TheTest.Printf(_L("Delete database. Last error: %d.\r\n"), err);
1.927 + TEST(err == KErrNone || err == KErrNoMemory);
1.928 + }
1.929 +
1.930 + //Cleanup
1.931 + for(TInt i=0;i<idx;++i)
1.932 + {
1.933 + db[i].Close();
1.934 + if((i % 100) == 0)
1.935 + {
1.936 + GetHomeTimeAsString(time);
1.937 + TheTest.Printf(_L("=== %S: % 5d sql connections closed\r\n"), &time, i + 1);
1.938 + }
1.939 + }
1.940 + delete [] db;
1.941 + db1.Close();
1.942 + err = RSqlDatabase::Delete(KTestDbName5);
1.943 + TEST(err == KErrNone || err == KErrNotFound);
1.944 + err = RSqlDatabase::Delete(KTestDbName4);
1.945 + TEST(err == KErrNone || err == KErrNotFound);
1.946 + err = RSqlDatabase::Delete(KTestDbName1);
1.947 + TEST(err == KErrNone || err == KErrNotFound);
1.948 + }
1.949 +
1.950 +void DoTests()
1.951 + {
1.952 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1627-0001 SQL server load test "));
1.953 + SqlLoadTest();
1.954 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4201 Statement max number test"));
1.955 + StatementMaxNumberTest();
1.956 +#if defined __WINS__ || defined __WINSCW__
1.957 + //The next two tests are likely to timeout on hardware because they create a lot of file sessions and sql connections.
1.958 + //The SQL server heap is 32Mb on hardware but only 6Mb on the Emulator.
1.959 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4237 File session max number test"));
1.960 + FileSessionMaxNumberTest();
1.961 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4238 Sql connection max number test"));
1.962 + SqlConnectionMaxNumberTest();
1.963 +#endif
1.964 + }
1.965 +
1.966 +TInt E32Main()
1.967 + {
1.968 + TheTest.Title();
1.969 +
1.970 + CTrapCleanup* tc = CTrapCleanup::New();
1.971 +
1.972 + __UHEAP_MARK;
1.973 +
1.974 + CreateTestDir();
1.975 + DeleteTestFiles();
1.976 + DoTests();
1.977 + DeleteTestFiles();
1.978 +
1.979 + __UHEAP_MARKEND;
1.980 +
1.981 + TheTest.End();
1.982 + TheTest.Close();
1.983 +
1.984 + delete tc;
1.985 +
1.986 + User::Heap().Check();
1.987 + return KErrNone;
1.988 + }