Symaptic: os/persistentdata/persistentstorage/sql/TEST/t

     1 // Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <f32file.h>

    17 #include <e32test.h>

    18 #include <hal.h>

    19 #include <stdlib.h>

    20 #include <sqldb.h>

    21 #include "sqlite3.h"

    22 #include "SqliteSymbian.h"

    23 #include "SqlSrvStatementUtil.h"

    24 #include "SqlPanic.h"

    25 #include "SqlCompact.h"

    26 #include "SqlCompactConn.h"

    27 #include "SqlCompactEntry.h"

    28 #include "SqlUtil.h"

    30 const TInt KOperationCount = 20;

    31 const TInt KFreePageThresholdKb = 5;

    32 const TInt KFreePageThreshold = 5;

    34 const TInt KCompactStepInterval = 5;//ms

    36 TSqlCompactSettings TheCompactionSettings;

    38 static RTest 			TheTest(_L ("t_sqlcompact2.exe"));

    39 static CTrapCleanup*	TheTrapCleanup = NULL;

    40 static RFs 				TheFs;

    41 static TBuf<KMaxFileName + 1> TheFileNameZ;

    42 static TBuf8<KMaxFileName + 1> TheFileNameZ8;

    44 const TInt KBlobMaxSize = 1024 * 32;

    45 static TBuf8<KBlobMaxSize> TheBlob;

    47 static sqlite3* 		TheDbHandle = NULL;

    49 _LIT8(KFreePageCountPragma, "PRAGMA freelist_count\x0");

    51 TBuf<256>  TheCmd;

    52 TDriveName TheDriveName;

    53 TParse     TheParse;

    54 TFileName  TheDbName;

    56 class CSqlCompactTestActive;

    57 CSqlCompactTestActive* TheTestActive = NULL;

    59 const TTimeIntervalMicroSeconds32 KInterval(200000);

    61 static TInt TheProcessHandleCount = 0;

    62 static TInt TheThreadHandleCount = 0;

    63 static TInt TheAllocatedCellsCount = 0;

    65 #ifdef _DEBUG

    66 const TInt KBurstRate = 100;

    67 #endif

    69 //////////////////////////////////////////////////////////////////////////////////////////////////

    71 void DeleteTestFiles()

    72 	{

    73 	::CloseDbHandle(TheDbHandle);

    74 	(void)TheFs.Delete(TheDbName);

    75 	}

    77 ///////////////////////////////////////////////////////////////////////////////////////

    78 //Test macros and functions

    79 void Check(TInt aValue, TInt aLine)

    80 	{

    81 	if(!aValue)

    82 		{

    83 		DeleteTestFiles();

    84 		TheTest(EFalse, aLine);

    85 		}

    86 	}

    87 void Check(TInt aValue, TInt aExpected, TInt aLine)

    88 	{

    89 	if(aValue != aExpected)

    90 		{

    91 		DeleteTestFiles();

    92 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

    93 		TheTest(EFalse, aLine);

    94 		}

    95 	}

    96 #define TEST(arg) ::Check((arg), __LINE__)

    97 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

    99 //////////////////////////////////////////////////////////////////////////////////////////////////

   101 void TestEnvCreate()

   102 	{

   103 	TInt err = sqlite3SymbianLibInit();

   104 	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

   105 	TheFs = sqlite3SymbianFs();

   106 	for(TInt i=0;i<('Z'-'A');++i)

   107 		{

   108 		TheFs.CreatePrivatePath(i);

   109 		}

   110 	err = TheFs.MkDir(TheDbName);

   111 	TEST(err == KErrNone || err == KErrAlreadyExists);

   112 	DeleteTestFiles();

   113 	}

   115 void TestEnvDestroy()

   116 	{

   117 	DeleteTestFiles();

   118 	sqlite3SymbianLibFinalize();

   119 	CloseSTDLIB();

   120 	}

   122 //////////////////////////////////////////////////////////////////////////////////////////////////

   124 void MarkHandles()

   125 	{

   126 	RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

   127 	}

   129 void MarkAllocatedCells()

   130 	{

   131 	TheAllocatedCellsCount = User::CountAllocCells();

   132 	}

   134 void CheckHandles()

   135 	{

   136 	TInt processHandleCount = 0;

   137 	TInt threadHandleCount = 0;

   139 	RThread().HandleCount(processHandleCount, threadHandleCount);

   141 	TEST(processHandleCount == TheProcessHandleCount);

   142 	TEST(threadHandleCount == TheThreadHandleCount);

   143 	}

   145 void CheckAllocatedCells()

   146 	{

   147 	TInt allocatedCellsCount = User::CountAllocCells();

   148 	TEST(allocatedCellsCount == TheAllocatedCellsCount);

   149 	}

   151 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   153 const TDesC& FileNameZ(const TDesC& aFileName)

   154 	{

   155 	TheFileNameZ.Copy(aFileName);

   156 	TheFileNameZ.ZeroTerminate();

   157 	return TheFileNameZ;

   158 	}

   160 const TDesC8& FileNameZ8(const TDesC& aFileName)

   161 	{

   162 	TheFileNameZ8.Copy(aFileName);

   163 	TheFileNameZ8.ZeroTerminate();

   164 	return TheFileNameZ8;

   165 	}

   167 TInt FreePageCount()

   168 	{

   169 	sqlite3_stmt* stmtHandle = NULL;

   170 	TInt err = ::StmtPrepare8(TheDbHandle, KFreePageCountPragma, stmtHandle);

   171 	TEST2(err, KErrNone);

   172 	TEST(stmtHandle != NULL);

   173 	err = ::StmtNext(stmtHandle);

   174 	TEST2(err, KSqlAtRow);

   175 	TInt pageCount = sqlite3_column_int(stmtHandle, 0);

   176 	TEST(pageCount >= 0);

   177 	::FinalizeStmtHandle(stmtHandle);

   178 	return pageCount;

   179 	}

   181 void PrintInfo(TInt aProcessedPages, const TDesC& aMediaTypeName, TUint32 aStartTicks, TUint32 aEndTicks)

   182 	{

   183 	static TInt freq = 0;

   184 	if(freq == 0)

   185 		{

   186 		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);

   187 		}

   188 	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

   189 	if(diffTicks < 0)

   190 		{

   191 		diffTicks = KMaxTUint32 + diffTicks + 1;

   192 		}

   193 	const TInt KMicroSecIn1Sec = 1000000;

   194 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

   195 	TheTest.Printf(_L("####Media type: %S. Processed pages: %d. Ticks: %ld. Execution time: %d ms\r\n"),

   196 							&aMediaTypeName, aProcessedPages, diffTicks, us / 1000);

   197 	}

   199 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   200 //////////////////////////////        CSqlCompactTestActive declaration              /////////////////////////////////////////////

   201 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   203 class CSqlCompactTestActive : public CActive

   204 	{

   205 private:

   206 	enum TCommand

   207 		{

   208 		ECmdInvalidTest,

   209 		ECmdBeginTest1,

   210 		ECmdEndTest1,

   211 		ECmdBeginTest2,

   212 		ECmdEndTest2,

   213 		ECmdBeginTest3,

   214 		ECmdEndTest3,

   215 		ECmdStopTests

   216 		};

   218 public:

   219 	static void New();

   220 	virtual ~CSqlCompactTestActive();

   221 	void OomTest();

   222 	void FileIoErrTest();

   223 	void PerformanceTest();

   224 	void FreePageUpdateTest();

   226 protected:

   227 	virtual void DoCancel();

   228 	virtual void RunL();

   229 	virtual TInt RunError(TInt aError);

   231 private:

   232 	CSqlCompactTestActive();

   233 	void Complete(TCommand aNextCommand);

   234 	void Schedule(TCommand aNextCommand, TTimeIntervalMicroSeconds32 aInterval);

   236 	void CreateTestDatabase();

   237 	void CreateTestDatabase2();

   238 	void PrepareDb(TBool aNewDb);

   239 	void InsertTestRecords(TInt aOpCount = KOperationCount);

   240 	void UpdateTestRecords(TInt aOpCount = KOperationCount);

   241 	void DeleteTestRecords(TInt aOpCount = KOperationCount);

   242 	void DeleteTestRecords2();

   243 	void TestEnd();

   245 	void UpdateTestBegin();

   246 	void UpdateTestEnd();

   247 	void DeleteTestBegin();

   248 	void DeleteTestEnd();

   249 	void SingleOpCompactTestBegin();

   250 	void SingleOpCompactTestEnd();

   251 	void DoOomTest1();

   252 	void DoOomTest2();

   253 	void DoOomTest3();

   254 	void DoOomTest4();

   255 	void DoOomTest5();

   257 private:

   258 	TInt			iCommand;

   259 	CSqlCompactor*	iCompactor;

   260 	RTimer			iTimer;

   262 	};

   264 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   265 //////////////////////////////        CSqlCompactTestActive implementation             ///////////////////////////////////////////

   266 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   268 void CSqlCompactTestActive::New()

   269 	{

   270 	TheTestActive = new CSqlCompactTestActive;

   271 	TEST(TheTestActive != NULL);

   272 	}

   274 CSqlCompactTestActive::~CSqlCompactTestActive()

   275 	{

   276 	Cancel();

   277 	iTimer.Close();

   278 	delete iCompactor;

   279 	}

   281 void CSqlCompactTestActive::DoCancel()

   282 	{

   283 	iTimer.Cancel();

   284 	TRequestStatus* stat = &iStatus;

   285 	User::RequestComplete(stat, KErrNone);

   286 	}

   288 void CSqlCompactTestActive::RunL()

   289 	{

   290 	switch(iCommand)

   291 		{

   292 		case CSqlCompactTestActive::ECmdBeginTest1:

   293 			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4053 Update test"));

   294 			UpdateTestBegin();

   295 			Schedule(CSqlCompactTestActive::ECmdEndTest1, KInterval);

   296 			break;

   297 		case CSqlCompactTestActive::ECmdEndTest1:

   298 			UpdateTestEnd();

   299 			Complete(CSqlCompactTestActive::ECmdBeginTest2);

   300 			break;

   301 		case CSqlCompactTestActive::ECmdBeginTest2:

   302 			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4054 Delete test"));

   303 			DeleteTestBegin();

   304 			Schedule(CSqlCompactTestActive::ECmdEndTest2, KInterval);

   305 			break;

   306 		case CSqlCompactTestActive::ECmdEndTest2:

   307 			DeleteTestEnd();

   308 			Complete(CSqlCompactTestActive::ECmdBeginTest3);

   309 			break;

   310 		case CSqlCompactTestActive::ECmdBeginTest3:

   311 			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4055 Single operation - compaction test"));

   312 			SingleOpCompactTestBegin();

   313 			Schedule(CSqlCompactTestActive::ECmdEndTest3, KInterval);

   314 			break;

   315 		case CSqlCompactTestActive::ECmdEndTest3:

   316 			SingleOpCompactTestEnd();

   317 			Complete(CSqlCompactTestActive::ECmdStopTests);

   318 			break;

   319 		case CSqlCompactTestActive::ECmdStopTests:

   320 			CActiveScheduler::Stop();

   321 			break;

   322 		case CSqlCompactTestActive::ECmdInvalidTest:

   323 		default:

   324 			TEST(0);

   325 			break;

   326 		}

   327 	}

   329 TInt CSqlCompactTestActive::RunError(TInt aError)

   330 	{

   331 	TEST2(aError, KErrNone);

   332 	return aError;

   333 	}

   335 CSqlCompactTestActive::CSqlCompactTestActive() :

   336 	CActive(CActive::EPriorityStandard),

   337 	iCommand(CSqlCompactTestActive::ECmdInvalidTest),

   338 	iCompactor(NULL)

   339 	{

   340 	TInt err = sqlite3_enable_shared_cache(1);

   341 	TEST2(err, SQLITE_OK);

   342 	TRAP(err, iCompactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   343 	TEST2(err, KErrNone);

   344 	err = iTimer.CreateLocal();

   345 	TEST2(err, KErrNone);

   346 	CActiveScheduler::Add(this);

   347 	Complete(CSqlCompactTestActive::ECmdBeginTest1);

   348 	}

   350 void CSqlCompactTestActive::Complete(CSqlCompactTestActive::TCommand aNextCommand)

   351 	{

   352 	TEST(!IsActive());

   353 	iCommand = aNextCommand;

   354 	TRequestStatus* stat = &iStatus;

   355 	User::RequestComplete(stat, KErrNone);

   356 	SetActive();

   357 	}

   359 void CSqlCompactTestActive::Schedule(TCommand aNextCommand, TTimeIntervalMicroSeconds32 aInterval)

   360 	{

   361 	TEST(!IsActive());

   362 	iCommand = aNextCommand;

   363 	iTimer.After(iStatus, aInterval);

   364 	TEST2(iStatus.Int(), KRequestPending);

   365 	SetActive();

   366 	}

   368 void CSqlCompactTestActive::CreateTestDatabase()

   369 	{

   370 	TInt err = ::CreateDbHandle8(::FileNameZ8(TheDbName), TheDbHandle);

   371 	TEST2(err, KErrNone);

   372 	_LIT8(KCreateTableSql, "CREATE TABLE A(I INTEGRER, B BLOB)\x0");

   373 	err = ::DbExecStmt8(TheDbHandle, KCreateTableSql);

   374 	TEST2(err, KErrNone);

   375 	}

   377 void CSqlCompactTestActive::InsertTestRecords(TInt aOpCount)

   378 	{

   379 	TheBlob.SetLength(SQLITE_DEFAULT_PAGE_SIZE);

   380 	for(TInt i=0;i<aOpCount;++i)

   381 		{

   382 		_LIT8(KInsertSql, "INSERT INTO A VALUES(%d, :Prm)\x0");

   383 		TBuf8<sizeof(KInsertSql) + 10> sqlBuf1;

   384 		sqlBuf1.Format(KInsertSql, i + 1);

   385 		sqlite3_stmt* stmtHandle = NULL;

   386 		TInt err = ::StmtPrepare8(TheDbHandle, sqlBuf1, stmtHandle);

   387 		TEST2(err, KErrNone);

   388 		TEST(stmtHandle != NULL);

   389 		err = sqlite3_bind_blob(stmtHandle, 1, TheBlob.Ptr(), SQLITE_DEFAULT_PAGE_SIZE, SQLITE_STATIC);

   390 		TEST2(err, SQLITE_OK);

   391 		err = ::StmtExec(stmtHandle);

   392 		TEST2(err, KErrNone);

   393 		::FinalizeStmtHandle(stmtHandle);

   394 		}

   395 	}

   397 //Creates a test database (with KDbName name).

   398 void CSqlCompactTestActive::CreateTestDatabase2()

   399     {

   400     //Create the database

   401     const TInt KPageSize = 1024;

   402     _LIT8(KConfigStr, "page_size=");

   403     TBuf8<100> config;

   404     config.Copy(KConfigStr);

   405     config.AppendNum(KPageSize);

   406     TInt err = KErrNone;

   407     err = ::CreateDbHandle8(::FileNameZ8(TheDbName), TheDbHandle);

   408     TEST2(err, KErrNone);

   409     _LIT8(KCreateTableSql, "CREATE TABLE A(I INTEGER, T TEXT)\x0");

   410     err = ::DbExecStmt8(TheDbHandle, KCreateTableSql);

   411     TEST2(err, KErrNone);

   412     }

   414 //Insert 1000 records. The record size is such that there is only two records per page.

   415 void CSqlCompactTestActive::PrepareDb(TBool aDeleteRecords)

   416     {

   417     //Insert records

   418     const TInt KRecordCount = 1000;

   419     const TInt KTextLen = 400;

   420     TBuf<KTextLen> TheText;

   421     TBuf<KTextLen + 100> TheSqlBuf;

   422     TheText.SetLength(TheText.MaxLength());

   423     TheText.Fill(TChar('A'));

   424     for(TInt i=0;i<KRecordCount;++i)

   425         {

   426         TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);

   427         _LIT(KZero, "\x0");

   428         TheSqlBuf.Append(KZero);

   429         TInt err = ::DbExecStmt16(TheDbHandle, TheSqlBuf);

   430         TEST2(err, KErrNone);

   431         }

   432     if(aDeleteRecords)

   433         {

   434         //Delete all records to make a lot of free pages.

   435         _LIT(KDeleteAll, "DELETE FROM A WHERE 1\x0");

   436         TheSqlBuf = KDeleteAll;

   437         TInt err = ::DbExecStmt16(TheDbHandle, TheSqlBuf);

   438         TEST2(err, KErrNone);

   439         }

   440     }

   442 void CSqlCompactTestActive::UpdateTestRecords(TInt aOpCount)

   443 	{

   444 	for(TInt i=0;i<aOpCount;++i)

   445 		{

   446 		_LIT8(KUpdateSql, "UPDATE A SET B=x'1122' WHERE I=%d\x0");

   447 		TBuf8<sizeof(KUpdateSql) + 10> sqlBuf2;

   448 		sqlBuf2.Format(KUpdateSql, i + 1);

   449 		TInt err = ::DbExecStmt8(TheDbHandle, sqlBuf2);

   450 		TEST2(err, KErrNone);

   451 		}

   452 	}

   454 void CSqlCompactTestActive::DeleteTestRecords(TInt aOpCount)

   455 	{

   456 	for(TInt i=0;i<aOpCount;++i)

   457 		{

   458 		_LIT8(KDeleteSql, "DELETE FROM A WHERE I=%d\x0");

   459 		TBuf8<sizeof(KDeleteSql) + 10> sqlBuf2;

   460 		sqlBuf2.Format(KDeleteSql, i + 1);

   461 		TInt err = ::DbExecStmt8(TheDbHandle, sqlBuf2);

   462 		TEST2(err, KErrNone);

   463 		}

   464 	}

   466 void CSqlCompactTestActive::DeleteTestRecords2()

   467 	{

   468 	_LIT8(KDeleteSql, "DELETE FROM A\x0");

   469 	TInt err = ::DbExecStmt8(TheDbHandle, KDeleteSql);

   470 	TEST2(err, KErrNone);

   471 	}

   473 void CSqlCompactTestActive::TestEnd()

   474 	{

   475 	TInt freePageCount = ::FreePageCount();

   476 	TEST2(freePageCount, 0);

   477 	iCompactor->ReleaseEntry(TheDbName);

   478 	::CloseDbHandle(TheDbHandle);

   479 	TheDbHandle = NULL;

   480 	(void)TheFs.Delete(TheDbName);

   481 	}

   483 /**

   484 @SYMTestCaseID			SYSLIB-SQL-UT-4053

   485 @SYMTestCaseDesc		Background compaction scheduled by a set of UPDATE operations.

   486 						The test uses the server background compaction classes directly.

   487 						The test creates a database, inserts records and updates the records.

   488 						The update operations free enough disk space to kick-off the background compaction.

   489 						The test active object, that simulates the SQL server, is activated and the

   490 						background compaction - executed.

   491 						The test checks at the end that the background compaction really happened - in

   492 						CSqlCompactTestActive::UpdateTestEnd().

   493 @SYMTestPriority		Medium

   494 @SYMTestActions			Background compaction scheduled by a set of UPDATE operations.

   495 @SYMTestExpectedResults Test must not fail

   496 @SYMREQ					REQ10271

   497                         REQ10272

   498 */

   499 void CSqlCompactTestActive::UpdateTestBegin()

   500 	{

   501 	CreateTestDatabase();

   502 	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));

   503 	TEST2(err, KErrNone);

   504 	InsertTestRecords();

   505 	UpdateTestRecords();

   506 	TInt freePageCount = ::FreePageCount();

   507 	TEST(freePageCount > KFreePageThreshold);

   508 	}

   510 void CSqlCompactTestActive::UpdateTestEnd()

   511 	{

   512 	TestEnd();

   513 	}

   515 /**

   516 @SYMTestCaseID			SYSLIB-SQL-UT-4054

   517 @SYMTestCaseDesc		Background compaction scheduled by a set of DELETE operations.

   518 						The test uses the server background compaction classes directly.

   519 						The test creates a database, inserts records and deletes the records.

   520 						The delete operations free enough disk space to kick-off the background compaction.

   521 						The test active object, that simulates the SQL server, is activated and the

   522 						background compaction - executed.

   523 						The test checks at the end that the background compaction really happened - in

   524 						CSqlCompactTestActive::DeleteTestEnd().

   525 @SYMTestPriority		Medium

   526 @SYMTestActions			Background compaction scheduled by a set of DELETE operations.

   527 @SYMTestExpectedResults Test must not fail

   528 @SYMREQ					REQ10271

   529                         REQ10272

   530 */

   531 void CSqlCompactTestActive::DeleteTestBegin()

   532 	{

   533 	CreateTestDatabase();

   534 	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));

   535 	TEST2(err, KErrNone);

   536 	InsertTestRecords();

   537 	DeleteTestRecords();

   538 	TInt freePageCount = ::FreePageCount();

   539 	TEST(freePageCount >= KFreePageThreshold);

   540 	}

   542 void CSqlCompactTestActive::DeleteTestEnd()

   543 	{

   544 	TestEnd();

   545 	}

   547 /**

   548 @SYMTestCaseID			SYSLIB-SQL-UT-4055

   549 @SYMTestCaseDesc		Background compaction, initiated by a single operation.

   550 						The test uses the server background compaction classes directly.

   551 						The test creates a database, inserts records and deletes the records using just

   552 						a single DELETE SQL statement.

   553 						The test active object, that simulates the SQL server, schedules

   554 						CSqlCompactTestActive::SingleOpCompactTestEnd() for execution. The code in

   555 						SingleOpCompactTestEnd() checks that the background compaction has been activated and closes the

   556 						database connection. The "database close" operation should start the compaction

   557 						because the total size of free pages is above the "free pages" threshold (in Kb).

   558 @SYMTestPriority		Medium

   559 @SYMTestActions			Background compaction, initiated by a single operation.

   560 @SYMTestExpectedResults Test must not fail

   561 @SYMREQ					REQ10271

   562                         REQ10272

   563 */

   564 void CSqlCompactTestActive::SingleOpCompactTestBegin()

   565 	{

   566 	CreateTestDatabase();

   567 	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));

   568 	TEST2(err, KErrNone);

   569 	InsertTestRecords();

   570 	DeleteTestRecords2();

   571 	TInt freePageCount = ::FreePageCount();

   572 	TEST(freePageCount >= KFreePageThreshold);

   573 	}

   575 void CSqlCompactTestActive::SingleOpCompactTestEnd()

   576 	{

   577 	TestEnd();

   578 	}

   580 //Background compaction - OOM test.

   581 //CSqlCompactor::NewL() is the function tested in an OOM simulation loop.

   582 //The expectation is that if the iteration fails with KErrNoMemory, no memory leak will occur and the compactor object won't be created.

   583 void CSqlCompactTestActive::DoOomTest1()

   584 	{

   585 	TInt err = KErrNoMemory;

   586 	TInt failingAllocationNo = 0;

   587 	while(err == KErrNoMemory)

   588 		{

   589 		MarkHandles();

   590 		MarkAllocatedCells();

   592 		__UHEAP_MARK;

   594 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);

   596 		CSqlCompactor* compactor = NULL;

   597 		TRAP(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   599 		__UHEAP_RESET;

   601 		if(err == KErrNone)

   602 			{

   603 			TEST(compactor != NULL);

   604 			delete compactor;

   605 			}

   606 		else

   607 			{

   608 			TEST(!compactor);

   609 			TEST2(err, KErrNoMemory);

   610 			}

   612 		__UHEAP_MARKEND;

   614 		CheckAllocatedCells();

   615 		CheckHandles();

   616 		}

   617 	TEST2(err, KErrNone);

   618 	TheTest.Printf(_L("=== CSqlCompactor::NewL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   619 	}

   621 //Background compaction - OOM test.

   622 //CSqlCompactor::AddEntryL() is the function tested in an OOM simulation loop.

   623 //The expectation is that no memory leak will occur if OOM iteration fails with KErrNoMemory.

   624 //The expectation also is that if the iteration fails with KErrNoMemory, no entry will be added to the compactor.

   625 void CSqlCompactTestActive::DoOomTest2()

   626 	{

   627 	CSqlCompactor* compactor = NULL;

   628 	TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   629 	TEST2(err, KErrNone);

   630 	TEST(compactor != NULL);

   632 	err = KErrNoMemory;

   633 	TInt failingAllocationNo = 0;

   634 	while(err == KErrNoMemory)

   635 		{

   636 		MarkHandles();

   637 		MarkAllocatedCells();

   639 		__UHEAP_MARK;

   641 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);

   643 		TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));

   645 		__UHEAP_RESET;

   647 		if(err == KErrNone)

   648 			{

   649 			TEST2(compactor->iEntries.Count(), 1);

   650 			compactor->ReleaseEntry(TheDbName);

   651 			compactor->iEntries.Compress();

   652 			}

   653 		else

   654 			{

   655 			TEST2(compactor->iEntries.Count(), 0);

   656 			TEST2(err, KErrNoMemory);

   657 			}

   659 		__UHEAP_MARKEND;

   661 		CheckAllocatedCells();

   662 		CheckHandles();

   663 		}

   664 	delete compactor;

   665 	TEST2(err, KErrNone);

   666 	TheTest.Printf(_L("=== CSqlCompactor::AddEntryL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   667 	}

   669 //Background compaction - OOM test.

   670 //CSqlCompactor::NewL() and CSqlCompactor::AddEntryL() are the functions tested in an OOM simulation loop.

   671 //At the end of the iteration CSqlCompactor::ReleaseEntry() is not called.

   672 //The CSqlCompactor's destructor should properly release the entry if the compactor and the entry have been created successfully.

   673 //The expectation is that no memory leak will occur if OOM iteration fails with KErrNoMemory.

   674 void CSqlCompactTestActive::DoOomTest3()

   675 	{

   676 	TInt err = KErrNoMemory;

   677 	TInt failingAllocationNo = 0;

   678 	while(err == KErrNoMemory)

   679 		{

   680 		MarkHandles();

   681 		MarkAllocatedCells();

   683 		__UHEAP_MARK;

   685 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);

   687 		CSqlCompactor* compactor = NULL;

   688 		TRAP(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   689 		if(err == KErrNone)

   690 			{

   691 			TRAP(err, (void)compactor->AddEntryL(TheDbName, TheCompactionSettings));

   692 			}

   694 		__UHEAP_RESET;

   696 		if(err == KErrNone)

   697 			{

   698 			TEST(compactor != NULL);

   699 			}

   700 		else

   701 			{

   702 			TEST2(err, KErrNoMemory);

   703 			}

   704 		delete compactor;

   706 		__UHEAP_MARKEND;

   708 		CheckAllocatedCells();

   709 		CheckHandles();

   710 		}

   711 	TEST2(err, KErrNone);

   712 	TheTest.Printf(_L("=== CSqlCompactor::NewL()+CSqlCompactor::AddEntryL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   713 	}

   715 //Background compaction - OOM test.

   716 //The test database is created inside the OOM loop, at the beginning of each OOM iteration. The database has enough free space.

   717 //Then the Compact() method is called. The expectation is that if the iteration fails with KErrNoMemory error, no memory leak will occur.

   718 void CSqlCompactTestActive::DoOomTest4()

   719 	{

   720 	TInt err = KErrNoMemory;

   721 	TInt failingAllocationNo = 0;

   722 	while(err == KErrNoMemory)

   723 		{

   724 		MarkHandles();

   725 		MarkAllocatedCells();

   727 		__UHEAP_MARK;

   729 		(void)TheFs.Delete(TheDbName);

   730 		CreateTestDatabase();

   731 		CSqlCompactor* compactor = NULL;

   732 		TRAP(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   733 		TEST2(err, KErrNone);

   734 		TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));

   735 		TEST2(err, KErrNone);

   736 		InsertTestRecords();

   737 		DeleteTestRecords();

   738 		TInt freePageCount = ::FreePageCount();

   739 		TEST(freePageCount >= KFreePageThreshold);

   741 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);

   743 		CSqlCompactEntry* impl = compactor->iEntries[0];

   744 		err = impl->Compact();

   746 		__UHEAP_RESET;

   748 		if(err != KErrNone)

   749 			{

   750 			TEST2(err, KErrNoMemory);

   751 			}

   752 		else

   753 			{

   754 			TInt freePageCount2 = ::FreePageCount();

   755 			TEST(freePageCount2 < freePageCount);

   756 			}

   757 		delete compactor;

   758 		::CloseDbHandle(TheDbHandle);

   759 		TheDbHandle = NULL;

   761 		__UHEAP_MARKEND;

   763 		CheckAllocatedCells();

   764 		CheckHandles();

   765 		}

   766 	TEST2(err, KErrNone);

   767 	TheTest.Printf(_L("=== CSqlCompactEntry::Compact() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   768 	(void)TheFs.Delete(TheDbName);

   769 	}

   771 //Background compaction - OOM test.

   772 //The test database is created outside the OOM loop. The database has enough free space.

   773 //Then the Compact() method is called under OOM simulation.

   774 //The expectation is that if the iteration fails with KErrNoMemory error, no memory leak will occur and the number of

   775 //the free pages is the same as it was at the beginning of the OOM iteration.

   776 void CSqlCompactTestActive::DoOomTest5()

   777 	{

   778 	__UHEAP_MARK;

   780 	CreateTestDatabase();

   781 	CSqlCompactor* compactor = NULL;

   782 	TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   783 	TEST2(err, KErrNone);

   784 	TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));

   785 	TEST2(err, KErrNone);

   786 	InsertTestRecords();

   787 	DeleteTestRecords();

   788 	TInt freePageCount = ::FreePageCount();

   789 	TEST(freePageCount >= KFreePageThreshold);

   790 	err = KErrNoMemory;

   791 	TInt failingAllocationNo = 0;

   792 	while(err == KErrNoMemory)

   793 		{

   794 		TInt freePageCount2 = ::FreePageCount();

   796 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);

   798 		CSqlCompactEntry* impl = compactor->iEntries[0];

   799 		impl->iPageCount = freePageCount2;

   800 		err = impl->Compact();

   802 		__UHEAP_RESET;

   804 		if(err != KErrNone)

   805 			{

   806 			TEST2(err, KErrNoMemory);

   807 			TInt freePageCount3 = ::FreePageCount();

   808 			TEST2(freePageCount2, freePageCount3);

   809 			}

   810 	}

   811 	TEST2(err, KErrNone);

   812 	TInt freePageCount4 = ::FreePageCount();

   813 	TEST(freePageCount4 < freePageCount);

   815 	compactor->ReleaseEntry(TheDbName);

   816 	delete compactor;

   817 	::CloseDbHandle(TheDbHandle);

   818 	TheDbHandle = NULL;

   820 	__UHEAP_MARKEND;

   822 	TheTest.Printf(_L("=== CSqlCompactEntry::Compact()-2 OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   823 	(void)TheFs.Delete(TheDbName);

   824 	}

   826 /**

   827 @SYMTestCaseID			SYSLIB-SQL-UT-4050

   828 @SYMTestCaseDesc		Background compaction - OOM tests.

   829 						The test uses directly the SQL server background compaction classes and does OOM tests for:

   830 						creating the database compaction object (CSqlCompactor), adding a new background database connection,

   831 						calling directly the background compaction method.

   832 @SYMTestPriority		Medium

   833 @SYMTestActions			Background compaction - OOM tests.

   834 @SYMTestExpectedResults Test must not fail

   835 @SYMREQ					REQ10271

   836 */

   837 void CSqlCompactTestActive::OomTest()

   838 	{

   839 	CreateTestDatabase();

   840 	::CloseDbHandle(TheDbHandle);

   841 	TheDbHandle = NULL;

   843 	DoOomTest1();

   844 	DoOomTest2();

   845 	DoOomTest3();

   847 	(void)TheFs.Delete(TheDbName);

   849 	DoOomTest4();

   850 	DoOomTest5();

   851 	}

   853 /**

   854 @SYMTestCaseID			SYSLIB-SQL-UT-4051

   855 @SYMTestCaseDesc		Background compaction - file I/O error simulation test.

   856 						The test calls the background compaction method, CSqlCompactEntry::Compact(),

   857 						in a file I/O error simulation loop.

   858 @SYMTestPriority		Medium

   859 @SYMTestActions			Background compaction - file I/O error simulation test.

   860 @SYMTestExpectedResults Test must not fail

   861 @SYMREQ					REQ10271

   862 */

   863 void CSqlCompactTestActive::FileIoErrTest()

   864 	{

   865 	CreateTestDatabase();

   866 	CSqlCompactor* compactor = NULL;

   867 	TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   868 	TEST2(err, KErrNone);

   869 	TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));

   870 	TEST2(err, KErrNone);

   871 	InsertTestRecords();

   872 	DeleteTestRecords();

   873 	TInt freePageCount = ::FreePageCount();

   874 	TEST(freePageCount >= KFreePageThreshold);

   875 	err = KErrGeneral;

   876 	TInt ioCounter = 0;

   877 	while(err != KErrNone)

   878 		{

   879 		TInt freePageCount2 = ::FreePageCount();

   880 		if(freePageCount2 == 0)

   881 			{

   882 			err = KErrNone;

   883 			break;

   884 			}

   886 		(void)TheFs.SetErrorCondition(err, ioCounter++);

   888 		CSqlCompactEntry* impl = compactor->iEntries[0];

   889 		impl->iPageCount = freePageCount2;

   890 		err = impl->Compact();

   892 		(void)TheFs.SetErrorCondition(KErrNone);

   894 		//check the database free pages count - all bets are off in a case of an I/O error.

   895 		//The free page count may actually have been reduced.

   896 		TInt freePageCount3 = ::FreePageCount();

   897 		TEST(freePageCount3  <= freePageCount2);

   898 		}

   899 	TEST2(err, KErrNone);

   900 	TInt freePageCount4 = ::FreePageCount();

   902 	compactor->ReleaseEntry(TheDbName);

   903 	delete compactor;

   904 	::CloseDbHandle(TheDbHandle);

   905 	TheDbHandle = NULL;

   907 	TheTest.Printf(_L("=== CSqlCompactEntry::Compact() \"file I/O\" error simulation test succeeded at iteration %d, free pages %d ===\r\n"), ioCounter, freePageCount4);

   908 	(void)TheFs.Delete(TheDbName);

   909 	}

   911 /**

   912 @SYMTestCaseID			SYSLIB-SQL-UT-4052

   913 @SYMTestCaseDesc		Compaction - performance test.

   914 						The test creates a test database (the default drive is C:, but different drive

   915 						can be specified as a test argument) and runs a compaction performance test.

   916 						The performance result is printed out.

   917 @SYMTestPriority		Medium

   918 @SYMTestActions			Compaction - performance test.

   919 @SYMTestExpectedResults Test must not fail

   920 @SYMREQ					REQ10271

   921                         REQ10272

   922 */

   923 void CSqlCompactTestActive::PerformanceTest()

   924 	{

   925 	TInt err = TheParse.Set(TheDbName, NULL, NULL);

   926 	TEST2(err, KErrNone);

   927 	TPtrC driveName = TheParse.Drive();

   928 	TEST(driveName.Length() > 0);

   929 	TInt driveNumber = -1;

   930 	err = RFs::CharToDrive(driveName[0], driveNumber);

   931 	TEST2(err, KErrNone);

   932 	TDriveNumber driveNo = static_cast <TDriveNumber> (driveNumber);

   933 	TDriveInfo driveInfo;

   934 	err = TheFs.Drive(driveInfo, driveNo);

   935 	TEST2(err, KErrNone);

   937 	_LIT(KType1, "Not present");

   938 	_LIT(KType2, "Unknown");

   939 	_LIT(KType3, "Floppy");

   940 	_LIT(KType4, "Hard disk");

   941 	_LIT(KType5, "CD ROM");

   942 	_LIT(KType6, "RAM disk");

   943 	_LIT(KType7, "Flash");

   944 	_LIT(KType8, "ROM drive");

   945 	_LIT(KType9, "Remote drive");

   946 	_LIT(KType10,"NAND flash");

   947 	_LIT(KType11,"Rotating media");

   948 	TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};

   949 	TheTest.Printf(_L("Drive: %C: %S. File: \"%S\"\r\n"), 'A' + driveNo, &KMediaTypeNames[driveInfo.iType], &TheDbName);

   951 	(void)TheFs.Delete(TheDbName);

   952 	CreateTestDatabase();

   953 	const TInt KRecCount = 90;

   954 	InsertTestRecords(KRecCount);

   955 	DeleteTestRecords2();

   956 	TInt freePageCount = ::FreePageCount();

   957 	TInt processedPages = 0;

   958 	TheTest.Printf(_L("   Free pages count = %d\r\n"), freePageCount);

   959 	TUint32 start = User::FastCounter();

   960 	err = ::DbCompact(TheDbHandle, KNullDesC, freePageCount, processedPages);

   961 	TUint32 end = User::FastCounter();

   962 	TEST2(err, KErrNone);

   963 	TEST2(processedPages, freePageCount);

   964 	::CloseDbHandle(TheDbHandle);

   965 	TheDbHandle = NULL;

   966 	(void)TheFs.Delete(TheDbName);

   967 	PrintInfo(processedPages, KMediaTypeNames[driveInfo.iType], start, end);

   968 	}

   970 /**

   971 @SYMTestCaseID          PDS-SQL-CT-4239

   972 @SYMTestCaseDesc        Free page update test.

   973                         The test creates a database with some records and deletes them all. The records are inserted such that when

   974                         they get deleted, it leaves a great deal of free pages.

   975                         Then the test refill the pages which ware empty. After that, the test call ::DbCompact(...) with the number of free

   976                         pages previously. The free page count should be updated with "0" since all free pages have been refilled since.

   977 @SYMTestPriority        Medium

   978 @SYMTestExpectedResults Test must not fail

   979 */

   980 void CSqlCompactTestActive::FreePageUpdateTest()

   981     {

   982      (void)TheFs.Delete(TheDbName);

   984     //Create the database with 1000 records and then delete all of them

   985     CreateTestDatabase2();

   987     CSqlCompactor* compactor = NULL;

   988     TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

   989     TEST2(err, KErrNone);

   990     TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));

   991     TEST2(err, KErrNone);

   993     PrepareDb(ETrue);

   994     TInt freePageCount = ::FreePageCount();

   995     TEST(freePageCount > KSqlCompactFreePageThresholdKb);

   996     TheTest.Printf(_L("   Free pages count = %d\r\n"), freePageCount);

   998     //Refill the database

   999     PrepareDb(EFalse);

  1001     CSqlCompactEntry* impl = compactor->iEntries[0];

  1002     impl->iPageCount = freePageCount;

  1003     err = impl->Compact();

  1004     TEST2(err, KErrNone);

  1005     TEST2(impl->iPageCount, 0);

  1007     compactor->ReleaseEntry(TheDbName);

  1008     delete compactor;

  1009     ::CloseDbHandle(TheDbHandle);

  1010     TheDbHandle = NULL;

  1011     (void)TheFs.Delete(TheDbName);

  1012     }

  1014 //////////////////////////////////////////////////////////////////////////////////////////////////

  1016 void DoTests()

  1017 	{

  1018 	CActiveScheduler* scheduler = new CActiveScheduler;

  1019 	TEST(scheduler != NULL);

  1020 	CActiveScheduler::Install(scheduler);

  1022 	CSqlCompactTestActive::New();

  1024 	TheCompactionSettings.iFreePageThresholdKb = KFreePageThresholdKb;

  1026 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4050 \"Out of memory\" test"));

  1027 	TheTestActive->OomTest();

  1029 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4051 \"File I/O\" error simulation test"));

  1030 	TheTestActive->FileIoErrTest();

  1032 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4052 Compaction - performance test"));

  1033 	TheTestActive->PerformanceTest();

  1035 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4239 Free page update test"));

  1036 	TheTestActive->FreePageUpdateTest();

  1038 	CActiveScheduler::Start();

  1040 	delete TheTestActive;

  1041 	TheTestActive = NULL;

  1042 	delete scheduler;

  1043 	}

  1045 //////////////////////////////////////////////////////////////////////////////////////////////////

  1047 //Usage: "t_sqlcompact2 [<drive letter>:]"

  1049 TInt E32Main()

  1050 	{

  1051 	TheTest.Title();

  1053 	TheTrapCleanup = CTrapCleanup::New ();

  1054 	__ASSERT_ALWAYS(TheTrapCleanup != NULL, User::Invariant());

  1056 	__UHEAP_MARK;

  1058 	User::CommandLine(TheCmd);

  1059 	TheCmd.TrimAll();

  1060 	if(TheCmd.Length() > 0)

  1061 		{

  1062 		TheDriveName.Copy(TheCmd);

  1063 		}

  1065 	_LIT(KDbName, "c:\\test\\t_sqlcompact2_1.db");

  1066 	TheParse.Set(TheDriveName, &KDbName, 0);

  1067 	const TDesC& dbFilePath = TheParse.FullName();

  1068 	TheDbName.Copy(dbFilePath);

  1070 	TestEnvCreate();

  1072 	DoTests();

  1074 	TestEnvDestroy();

  1076 	__UHEAP_MARKEND;

  1078 	TheTest.End();

  1079 	TheTest.Close();

  1081 	delete TheTrapCleanup;

  1083 	return KErrNone;

  1084 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--