1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlmulti.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,546 @@
1.4 +// Copyright (c) 2006-2009 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 <bautils.h>
1.21 +#include <sqldb.h>
1.22 +
1.23 +///////////////////////////////////////////////////////////////////////////////////////
1.24 +
1.25 +RTest TheTest(_L("t_sqlmulti test"));
1.26 +
1.27 +_LIT(KTestDir, "c:\\test\\");
1.28 +_LIT(KTestDbName1, "c:\\test\\t_sqlmulti.db");
1.29 +
1.30 +///////////////////////////////////////////////////////////////////////////////////////
1.31 +
1.32 +void DeleteTestFiles()
1.33 + {
1.34 + RSqlDatabase::Delete(KTestDbName1);
1.35 + }
1.36 +
1.37 +///////////////////////////////////////////////////////////////////////////////////////
1.38 +///////////////////////////////////////////////////////////////////////////////////////
1.39 +//Test macros and functions
1.40 +void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)
1.41 + {
1.42 + if(!aValue)
1.43 + {
1.44 + DeleteTestFiles();
1.45 + if(aPrintThreadName)
1.46 + {
1.47 + RThread th;
1.48 + TName name = th.Name();
1.49 + RDebug::Print(_L("*** Thread %S, Line %d\r\n"), &name, aLine);
1.50 + }
1.51 + else
1.52 + {
1.53 + RDebug::Print(_L("*** Line %d\r\n"), aLine);
1.54 + }
1.55 + TheTest(EFalse, aLine);
1.56 + }
1.57 + }
1.58 +void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)
1.59 + {
1.60 + if(aValue != aExpected)
1.61 + {
1.62 + DeleteTestFiles();
1.63 + if(aPrintThreadName)
1.64 + {
1.65 + RThread th;
1.66 + TName name = th.Name();
1.67 + RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);
1.68 + }
1.69 + else
1.70 + {
1.71 + RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
1.72 + }
1.73 + TheTest(EFalse, aLine);
1.74 + }
1.75 + }
1.76 +#define TEST(arg) ::Check1((arg), __LINE__)
1.77 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.78 +#define TTEST(arg) ::Check1((arg), __LINE__, ETrue)
1.79 +#define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)
1.80 +
1.81 +///////////////////////////////////////////////////////////////////////////////////////
1.82 +
1.83 +void CreateTestDir()
1.84 + {
1.85 + RFs fs;
1.86 + TInt err = fs.Connect();
1.87 + TEST2(err, KErrNone);
1.88 +
1.89 + err = fs.MkDir(KTestDir);
1.90 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.91 +
1.92 + fs.Close();
1.93 + }
1.94 +
1.95 +///////////////////////////////////////////////////////////////////////////////////////
1.96 +
1.97 +/**
1.98 +@SYMTestCaseID SYSLIB-SQL-CT-1612
1.99 +@SYMTestCaseDesc Two connections to the same database in the same thread. Create a test database
1.100 + and insert some records from both connections. Verify that all records were inserted
1.101 + successfully.
1.102 +@SYMTestPriority High
1.103 +@SYMTestActions Testing SQL engine behaviour when having mutiple connections to the same database
1.104 + in the same thread.
1.105 +@SYMTestExpectedResults Test must not fail
1.106 +@SYMREQ REQ5792
1.107 + REQ5793
1.108 +*/
1.109 +void TestMultiConnSameThread()
1.110 + {
1.111 + //Connection 1
1.112 + RSqlDatabase db1;
1.113 + TInt err = db1.Create(KTestDbName1);
1.114 + TEST2(err, KErrNone);
1.115 +
1.116 + //Create test database
1.117 + RDebug::Print(_L("###Create test database\r\n"));
1.118 + _LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER PRIMARY KEY AUTOINCREMENT, Data INTEGER)");
1.119 + err = db1.Exec(KCreateSql);
1.120 + TEST(err >= 0);
1.121 +
1.122 + //Connection 2
1.123 + RSqlDatabase db2;
1.124 + err = db2.Open(KTestDbName1);
1.125 + TEST2(err, KErrNone);
1.126 +
1.127 + //Insert some records using both connections
1.128 + RDebug::Print(_L("###Insert some records\r\n"));
1.129 + const TInt KRecNum = 100;
1.130 + _LIT8(KInsertSql, "INSERT INTO A(Data) VALUES(");
1.131 + for(TInt i=0;i<KRecNum;++i)
1.132 + {
1.133 + TBuf8<100> sql(KInsertSql);
1.134 + sql.AppendNum((TInt64)i + 1);
1.135 + sql.Append(_L(");"));
1.136 + err = (i%2) ? db1.Exec(sql) : db2.Exec(sql);
1.137 + if(err < 0)
1.138 + {
1.139 + TPtrC msg = (i%2) ? db1.LastErrorMessage() : db2.LastErrorMessage();
1.140 + RDebug::Print(_L("##Db Error msg: \"%S\"\n\r"), &msg);
1.141 + }
1.142 + TEST2(err, 1);
1.143 + }
1.144 +
1.145 + //Check the database content
1.146 + RDebug::Print(_L("###Check the database content\r\n"));
1.147 + _LIT8(KSelectSql, "SELECT * FROM A");
1.148 + RSqlStatement stmt;
1.149 + err = stmt.Prepare(db1, KSelectSql);
1.150 + TEST2(err, KErrNone);
1.151 +
1.152 + for(TInt j=0;j<KRecNum;++j)
1.153 + {
1.154 + err = stmt.Next();
1.155 + TEST2(err, KSqlAtRow);
1.156 + TEST(stmt.AtRow());
1.157 + TInt id = stmt.ColumnInt(0);
1.158 + TInt data = stmt.ColumnInt(1);
1.159 + TEST(id == data);
1.160 + }
1.161 +
1.162 + stmt.Close();
1.163 +
1.164 + //Cleanup
1.165 + db2.Close();
1.166 + db1.Close();
1.167 + RDebug::Print(_L("###Delete the test database\r\n"));
1.168 + (void)RSqlDatabase::Delete(KTestDbName1);
1.169 + }
1.170 +
1.171 +///////////////////////////////////////////////////////////////////////////////////////
1.172 +
1.173 +struct TThreadData
1.174 + {
1.175 + TInt iTransType;
1.176 + RSqlDatabase::TIsolationLevel iIsolationLevel;
1.177 + TInt iLowRecNo;
1.178 + TInt iHighRecNo;
1.179 + };
1.180 +
1.181 +TInt ThreadFunc(void* aData)
1.182 + {
1.183 + __UHEAP_MARK;
1.184 +
1.185 + CTrapCleanup* tc = CTrapCleanup::New();
1.186 + TTEST(tc != NULL);
1.187 +
1.188 + TThreadData* data = static_cast<TThreadData*> (aData);
1.189 + TTEST(data != NULL);
1.190 +
1.191 + RSqlDatabase db;
1.192 + TInt err = db.Open(KTestDbName1);
1.193 + TTEST2(err, KErrNone);
1.194 +
1.195 + err = db.SetIsolationLevel(data->iIsolationLevel);
1.196 + TTEST2(err, KErrNone);
1.197 +
1.198 + if(data->iTransType == 1)
1.199 + {
1.200 + _LIT8(KBeginTrans, "BEGIN");
1.201 + err = db.Exec(KBeginTrans);
1.202 + TTEST(err >= 0);
1.203 + }
1.204 +
1.205 + _LIT8(KInsertSql, "INSERT INTO A(Id) VALUES(");
1.206 + for(TInt id=data->iLowRecNo;id<=data->iHighRecNo;++id)
1.207 + {
1.208 + TBuf8<128> sql(KInsertSql);
1.209 + sql.AppendNum((TInt64)id);
1.210 + sql.Append(_L(")"));
1.211 + err = KSqlErrBusy;
1.212 + const TInt KAttempts = 20;
1.213 + for(TInt i=0;i<KAttempts&&err==KSqlErrBusy;++i)
1.214 + {
1.215 + err = db.Exec(sql);
1.216 + if(err == KSqlErrBusy)
1.217 + {
1.218 + RThread th;
1.219 + TName name = th.Name();
1.220 + RDebug::Print(_L("!!!Database locked, Thread: %S, Attempt %d, column value %d\r\n"), &name, i + 1, id);
1.221 + User::After(1000000);
1.222 + }
1.223 + }
1.224 + TTEST2(err, 1);
1.225 + }
1.226 +
1.227 + if(data->iTransType == 1)
1.228 + {
1.229 + _LIT8(KCommitTrans, "COMMIT");
1.230 + err = db.Exec(KCommitTrans);
1.231 + TTEST(err >= 0);
1.232 + }
1.233 +
1.234 + db.Close();
1.235 + delete tc;
1.236 +
1.237 + __UHEAP_MARKEND;
1.238 +
1.239 + return KErrNone;
1.240 + }
1.241 +
1.242 +/**
1.243 +@SYMTestCaseID SYSLIB-SQL-CT-1613
1.244 +@SYMTestCaseDesc Multiple connections to the same database from different threads.
1.245 + Each thread inserts set of record to the same table. Verify that all expected records
1.246 + and their column values meet the expectations.
1.247 +@SYMTestPriority High
1.248 +@SYMTestActions Testing SQL engine behaviour when having mutiple connections to the same database
1.249 + from different threads.
1.250 +@SYMTestExpectedResults Test must not fail
1.251 +@SYMREQ REQ5792
1.252 + REQ5793
1.253 +*/
1.254 +void TestMultiConnDiffThread()
1.255 + {
1.256 + //Create a test database
1.257 + RDebug::Print(_L("+++:MainThread: Create test database\r\n"));
1.258 + RSqlDatabase db;
1.259 + TInt err = db.Create(KTestDbName1);
1.260 + TEST2(err, KErrNone);
1.261 +
1.262 + //Create a test table
1.263 + RDebug::Print(_L("+++:MainThread: Create a table in the test database\r\n"));
1.264 + _LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER PRIMARY KEY)");
1.265 + err = db.Exec(KCreateSql);
1.266 + TEST(err >= 0);
1.267 +
1.268 + const TInt KThreadCnt = 4;
1.269 + const TInt KRange = 100;
1.270 +
1.271 + const TInt KIsolationLevelCnt = 2;
1.272 + TPtrC KIsolationLevelName[KIsolationLevelCnt] = {_L("Read Uncommitted"), _L("Serializable")};
1.273 + const RSqlDatabase::TIsolationLevel KIsolationLevels[KIsolationLevelCnt] = {
1.274 + RSqlDatabase::EReadUncommitted, RSqlDatabase::ESerializable};
1.275 +
1.276 + const TInt KTransTypeCnt = 2;
1.277 +
1.278 + //Do the tests:
1.279 + // - doing each per thread database operation in a single transaction;
1.280 + // - doing all per thread database operations in a single transaction;
1.281 + for(TInt transType=0;transType<KTransTypeCnt;++transType)
1.282 + {
1.283 + //For both supported isolation levels: read uncommitted and serializable
1.284 + for(TInt isolLevel=0;isolLevel<KIsolationLevelCnt;++isolLevel)
1.285 + {
1.286 + TInt low = 1;
1.287 + TInt high = KRange;
1.288 +
1.289 + RDebug::Print(_L("+++:MainThread: Test: thread count %d, records %d, trans type %d, isolation level: %S\r\n"),
1.290 + KThreadCnt, KRange, transType, &KIsolationLevelName[isolLevel]);
1.291 +
1.292 + RThread thread[KThreadCnt];
1.293 + TRequestStatus status[KThreadCnt];
1.294 + TThreadData data[KThreadCnt];
1.295 +
1.296 + //Create the test threads and run them. Each thread establishes a connection with the test database
1.297 + //and attempts to write set of records in the test table.
1.298 + TInt j;
1.299 + for(j=0;j<KThreadCnt;++j,low=high+1,high+=KRange)
1.300 + {
1.301 + data[j].iTransType = transType;
1.302 + data[j].iIsolationLevel = KIsolationLevels[isolLevel];
1.303 + data[j].iLowRecNo = low;
1.304 + data[j].iHighRecNo = high;
1.305 +
1.306 + _LIT(KThreadName,"Thr-");
1.307 + TBuf<32> threadName(KThreadName);
1.308 + threadName.AppendNum((TInt64)j + 1);
1.309 +
1.310 + TEST2(thread[j].Create(threadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&data[j], EOwnerThread), KErrNone);
1.311 + thread[j].Logon(status[j]);
1.312 + TEST2(status[j].Int(), KRequestPending);
1.313 + thread[j].Resume();
1.314 + }
1.315 +
1.316 + User::After(2000000);
1.317 + //Wait until threads finish the database operations and close them.
1.318 + for(j=0;j<KThreadCnt;++j)
1.319 + {
1.320 + User::WaitForRequest(status[j]);
1.321 + TEST(thread[j].ExitType() != EExitPanic);
1.322 + thread[j].Close();
1.323 + }
1.324 +
1.325 + //Check that all records which are esupposed to be in the database, are there.
1.326 + RDebug::Print(_L("+++:MainThread: Check that all records have been written\r\n"));
1.327 + _LIT8(KSelectSql1, "SELECT COUNT(*) FROM A;");
1.328 + RSqlStatement stmt;
1.329 + err = stmt.Prepare(db, KSelectSql1);
1.330 + TEST2(err, KErrNone);
1.331 + err = stmt.Next();
1.332 + TEST2(err, KSqlAtRow);
1.333 + TInt cnt = stmt.ColumnInt(0);
1.334 + TEST2(cnt, KThreadCnt * KRange);
1.335 + stmt.Close();
1.336 +
1.337 + //Check that all records have expected column values.
1.338 + RDebug::Print(_L("+++:MainThread: Check that all records have expected column values\r\n"));
1.339 + _LIT8(KSelectSql2, "SELECT * FROM A;");
1.340 + err = stmt.Prepare(db, KSelectSql2);
1.341 + TEST2(err, KErrNone);
1.342 + for(TInt k=0;k<(KThreadCnt*KRange);++k)
1.343 + {
1.344 + err = stmt.Next();
1.345 + TEST2(err, KSqlAtRow);
1.346 + TInt val = stmt.ColumnInt(0);
1.347 + TEST(val > 0 && val <= (KThreadCnt * KRange));
1.348 + }
1.349 + stmt.Close();
1.350 +
1.351 + //Prepare for the next test run - delete all records.
1.352 + RDebug::Print(_L("+++:MainThread: Delete all records\r\n"));
1.353 + _LIT8(KDeleteSql, "DELETE FROM A");
1.354 + err = db.Exec(KDeleteSql);
1.355 + TEST(err >= 0);
1.356 + }//end of "for(TInt isolLevel=0;isolLevel<KIsolationLevelCnt;++isolLevel)"
1.357 + }//end of "for(TInt transType=0;transType<KTransTypeCnt;++transType)"
1.358 +
1.359 + db.Close();
1.360 + RDebug::Print(_L("+++:MainThread: Delete the test database\r\n"));
1.361 + (void)RSqlDatabase::Delete(KTestDbName1);
1.362 + }
1.363 +
1.364 +///////////////////////////////////////////////////////////////////////////////////////
1.365 +
1.366 +static RCriticalSection UpdateThreadCrS;
1.367 +static RCriticalSection MainThreadCrS;
1.368 +const TInt KInitialValue = 10;
1.369 +const TInt KUpdatedValue = 20;
1.370 +
1.371 +TInt UpdateThreadFunc(void*)
1.372 + {
1.373 + __UHEAP_MARK;
1.374 +
1.375 + CTrapCleanup* tc = CTrapCleanup::New();
1.376 + TTEST(tc != NULL);
1.377 +
1.378 + RSqlDatabase db;
1.379 + TInt err = db.Open(KTestDbName1);
1.380 + TTEST2(err, KErrNone);
1.381 +
1.382 + RDebug::Print(_L("---:UpdThread: Set the isolation level to \"Read uncommitted\"\r\n"));
1.383 + err = db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);
1.384 + TTEST2(err, KErrNone);
1.385 +
1.386 + RDebug::Print(_L("---:UpdThread: Begin a write transaction\r\n"));
1.387 + _LIT8(KBeginTransSql, "BEGIN IMMEDIATE TRANSACTION");
1.388 + err = db.Exec(KBeginTransSql);
1.389 + TTEST(err >= 0);
1.390 +
1.391 + RDebug::Print(_L("---:UpdThread: Update the record\r\n"));
1.392 + _LIT8(KUpdateSql, "UPDATE A SET Id = ");
1.393 + TBuf8<64> sql(KUpdateSql);
1.394 + sql.AppendNum((TInt64)KUpdatedValue);
1.395 + err = db.Exec(sql);
1.396 + TTEST(err >= 0);
1.397 +
1.398 + RDebug::Print(_L("---:UpdThread: Notify the main thread about the update\r\n"));
1.399 + MainThreadCrS.Signal();
1.400 +
1.401 + RDebug::Print(_L("---:UpdThread: Wait for permisson to continue...\r\n"));
1.402 + UpdateThreadCrS.Wait();
1.403 +
1.404 + RDebug::Print(_L("---:UpdThread: Rollback the update\r\n"));
1.405 + _LIT8(KRollBackTransSql, "ROLLBACK TRANSACTION");
1.406 + err = db.Exec(KRollBackTransSql);
1.407 + TTEST(err >= 0);
1.408 +
1.409 + RDebug::Print(_L("---:UpdThread: Notify the main thread about the rollback\r\n"));
1.410 + MainThreadCrS.Signal();
1.411 +
1.412 + db.Close();
1.413 + delete tc;
1.414 +
1.415 + __UHEAP_MARKEND;
1.416 +
1.417 + return KErrNone;
1.418 + }
1.419 +
1.420 +/**
1.421 +@SYMTestCaseID SYSLIB-SQL-CT-1614
1.422 +@SYMTestCaseDesc Verifying that when having 2 database connections in different threads, both set
1.423 + the isolation level to "Read Uncommitted", the reading thread can make "dirty read"
1.424 + operations (can read the updated but not committed yet record values made by the
1.425 + writing thread).
1.426 +@SYMTestPriority High
1.427 +@SYMTestActions Testing "Read Uncommitted" database isolation level.
1.428 +@SYMTestExpectedResults Test must not fail
1.429 +@SYMREQ REQ5792
1.430 + REQ5793
1.431 +*/
1.432 +void TestIsolationLevel()
1.433 + {
1.434 + RDebug::Print(_L("+++:MainThread: Create critical sections\r\n"));
1.435 + TEST2(UpdateThreadCrS.CreateLocal(), KErrNone);
1.436 + UpdateThreadCrS.Wait();
1.437 + TEST2(MainThreadCrS.CreateLocal(), KErrNone);
1.438 + MainThreadCrS.Wait();
1.439 +
1.440 + RDebug::Print(_L("+++:MainThread: Create test database\r\n"));
1.441 + RSqlDatabase db;
1.442 + TInt err = db.Create(KTestDbName1);
1.443 + TEST2(err, KErrNone);
1.444 +
1.445 + RDebug::Print(_L("+++:MainThread: Set the isolation level to \"Read uncommitted\"\r\n"));
1.446 + err = db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);
1.447 + TEST2(err, KErrNone);
1.448 +
1.449 + RDebug::Print(_L("+++:MainThread: Create a table in the test database\r\n"));
1.450 + _LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER)");
1.451 + err = db.Exec(KCreateSql);
1.452 + TEST(err >= 0);
1.453 +
1.454 + RDebug::Print(_L("+++:MainThread: Insert one record in the table\r\n"));
1.455 + _LIT8(KInsertSql, "INSERT INTO A(Id) VALUES(");
1.456 + TBuf8<64> sql(KInsertSql);
1.457 + sql.AppendNum((TInt64)KInitialValue);
1.458 + sql.Append(_L(")"));
1.459 + err = db.Exec(sql);
1.460 + TEST2(err, 1);
1.461 +
1.462 + RDebug::Print(_L("+++:MainThread: Create the \"update\" thread\r\n"));
1.463 + _LIT(KThreadName, "UpdTh");
1.464 + RThread thread;
1.465 + TEST2(thread.Create(KThreadName, &UpdateThreadFunc, 0x2000, 0x1000, 0x10000, NULL, EOwnerThread), KErrNone);
1.466 + TRequestStatus status;
1.467 + thread.Logon(status);
1.468 + TEST2(status.Int(), KRequestPending);
1.469 + thread.Resume();
1.470 +
1.471 + RDebug::Print(_L("+++:MainThread: Wait for record update completion...\r\n"));
1.472 + MainThreadCrS.Wait();
1.473 +
1.474 + RDebug::Print(_L("+++:MainThread: Read the record and check the data...\r\n"));
1.475 + _LIT8(KSelectSql, "SELECT * FROM A");
1.476 + RSqlStatement stmt;
1.477 + err = stmt.Prepare(db, KSelectSql);
1.478 + TEST2(err, KErrNone);
1.479 + err = stmt.Next();
1.480 + TEST2(err, KSqlAtRow);
1.481 + TInt val = stmt.ColumnInt(0);
1.482 + TEST(val == KUpdatedValue);
1.483 + stmt.Close();
1.484 +
1.485 + RDebug::Print(_L("+++:MainThread: Notify the update thread that it can rollback\r\n"));
1.486 + UpdateThreadCrS.Signal();
1.487 +
1.488 + RDebug::Print(_L("+++:MainThread: Wait for rollback completion...\r\n"));
1.489 + MainThreadCrS.Wait();
1.490 +
1.491 + RDebug::Print(_L("+++:MainThread: Read the record and check the data...\r\n"));
1.492 + err = stmt.Prepare(db, KSelectSql);
1.493 + TEST2(err, KErrNone);
1.494 + err = stmt.Next();
1.495 + TEST2(err, KSqlAtRow);
1.496 + val = stmt.ColumnInt(0);
1.497 + TEST2(val, KInitialValue);
1.498 + stmt.Close();
1.499 +
1.500 + User::WaitForRequest(status);
1.501 + thread.Close();
1.502 +
1.503 + db.Close();
1.504 + RDebug::Print(_L("+++:MainThread: Delete the test database\r\n"));
1.505 + (void)RSqlDatabase::Delete(KTestDbName1);
1.506 +
1.507 + RDebug::Print(_L("+++:MainThread: Close critical sections\r\n"));
1.508 + MainThreadCrS.Close();
1.509 + UpdateThreadCrS.Close();
1.510 + }
1.511 +
1.512 +///////////////////////////////////////////////////////////////////////////////////////
1.513 +
1.514 +void DoTestsL()
1.515 + {
1.516 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1612 Multiple connections, the same thread "));
1.517 + TestMultiConnSameThread();
1.518 +
1.519 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1613 Multiple connections, different threads "));
1.520 + TestMultiConnDiffThread();
1.521 +
1.522 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1614 Isolation level "));
1.523 + TestIsolationLevel();
1.524 + }
1.525 +
1.526 +TInt E32Main()
1.527 + {
1.528 + TheTest.Title();
1.529 +
1.530 + CTrapCleanup* tc = CTrapCleanup::New();
1.531 +
1.532 + __UHEAP_MARK;
1.533 +
1.534 + CreateTestDir();
1.535 + DeleteTestFiles();
1.536 + TRAPD(err, DoTestsL());
1.537 + DeleteTestFiles();
1.538 + TEST2(err, KErrNone);
1.539 +
1.540 + __UHEAP_MARKEND;
1.541 +
1.542 + TheTest.End();
1.543 + TheTest.Close();
1.544 +
1.545 + delete tc;
1.546 +
1.547 + User::Heap().Check();
1.548 + return KErrNone;
1.549 + }