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 <e32test.h>

    17 #include <bautils.h>

    18 #include <sqldb.h>

    19 #include <stdlib.h>

    20 #include "sqlite3.h"

    21 #include "SqliteSymbian.h"

    22 #include "SqlResourceTester.h"

    24 ///////////////////////////////////////////////////////////////////////////////////////

    26 RTest TheTest(_L("t_sqlcompact4 test"));

    27 TParse TheParse;

    28 TDriveName TheDrive;

    30 RSqlDatabase TheDb;

    31 sqlite3* TheSqliteDb = NULL;

    32 TBuf<256> TheCmd;

    34 const TInt KTextLen = 1000;

    35 const TInt KRecLen = 2000;

    37 TBuf<KTextLen> TheText;

    38 TBuf8<KRecLen> TheSqlQuery;

    39 TBuf8<KRecLen> TheSqlFmt;

    40 TBuf<KTextLen + 50> TheSqlTexLen;

    42 _LIT(KDefaultDriveName, "c:");

    43 _LIT(KTestDir, "c:\\test\\");

    44 _LIT(KTestDbTemplate8, "c:\\test\\t_sqlcompact4_tmpl8.dat");

    45 _LIT(KTestDbTemplate16, "c:\\test\\t_sqlcompact4_tmpl16.dat");

    46 _LIT(KDbName, "c:\\test\\t_sqlcompact4_1.db");

    47 _LIT(KDbName2, "c:\\test\\t_sqlcompact4_2.db");

    48 _LIT(KRoDbName, "z:\\test\\testdb1.db");//Created outside the test app

    49 TFileName TheTestDbName;

    51 const TInt KMaxThreadCount = 100;

    52 TInt32 TheTestThreadCount = 8;

    54 const TInt KTestDbPageSize = 1024;

    56 TInt TheOriginalDbSize8 = -1;

    57 TInt TheCompactedDbSize8 = -1;

    59 TInt TheOriginalDbSize16 = -1;

    60 TInt TheCompactedDbSize16 = -1;

    62 //In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, when _SQLPROFILER macro is defined)

    63 #ifdef _SQLPROFILER

    64 TInt TheSqlSrvProfilerFileRead = 0;

    65 TInt TheSqlSrvProfilerFileWrite = 0;

    66 TInt TheSqlSrvProfilerFileSync = 0;

    67 TInt TheSqlSrvProfilerFileSetSize = 0;

    68 #endif

    70 ///////////////////////////////////////////////////////////////////////////////////////

    72 void DestroyTestEnv()

    73 	{

    74 	if(TheSqliteDb)

    75 		{

    76 		sqlite3_close(TheSqliteDb);

    77 		TheSqliteDb = NULL;

    78 		}

    79 	TheDb.Close();

    80 	(void)RSqlDatabase::Delete(KDbName2);

    81 	(void)RSqlDatabase::Delete(TheTestDbName);

    82 	(void)RSqlDatabase::Delete(KTestDbTemplate16);

    83 	(void)RSqlDatabase::Delete(KTestDbTemplate8);

    84 	sqlite3SymbianLibFinalize();

    85 	CloseSTDLIB();

    86 	}

    88 ///////////////////////////////////////////////////////////////////////////////////////

    89 ///////////////////////////////////////////////////////////////////////////////////////

    90 //Test macros and functions

    91 void Check(TInt aValue, TInt aLine)

    92 	{

    93 	if(!aValue)

    94 		{

    95 		DestroyTestEnv();

    96 		RDebug::Print(_L("*** Test failure. Boolean expression evaluates to false.\r\n"));

    97 		TheTest(EFalse, aLine);

    98 		}

    99 	}

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

   101 	{

   102 	if(aValue != aExpected)

   103 		{

   104 		DestroyTestEnv();

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

   106 		TheTest(EFalse, aLine);

   107 		}

   108 	}

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

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

   112 ///////////////////////////////////////////////////////////////////////////////////////

   114 void CreateTestEnv()

   115     {

   116     RFs fs;

   117 	TInt err = fs.Connect();

   118 	TEST2(err, KErrNone);

   120 	err = fs.MkDir(KTestDir);

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

   123 	TheParse.Set(TheDrive, &KTestDir, 0);

   125 	err = fs.MkDir(TheParse.DriveAndPath());

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

   128 	fs.Close();

   130 	sqlite3SymbianLibInit();

   131 	}

   133 ///////////////////////////////////////////////////////////////////////////////////////

   135 void CreateTestDatabase8()

   136 	{

   137 	TheTest.Printf(_L("Create UTF8 test database: %S\r\n"), &KTestDbTemplate8);

   138 	(void)RSqlDatabase::Delete(KTestDbTemplate8);

   139 	TBuf8<KMaxFileName> fname;

   140 	fname.Copy(KTestDbTemplate8);

   141 	TheSqliteDb = NULL;

   142 	TInt rc = sqlite3_open((const char*)fname.PtrZ(), &TheSqliteDb);

   143 	TEST2(rc, SQLITE_OK);

   144 	TBuf8<100> sql;

   145 	_LIT8(KSql, "PRAGMA page_size=%d\x0");

   146 	sql.Format(KSql, KTestDbPageSize);

   147 	rc = sqlite3_exec(TheSqliteDb, (const char*)sql.Ptr(), 0, 0, 0);

   148 	TEST2(rc, SQLITE_OK);

   149 	rc = sqlite3_exec(TheSqliteDb, "CREATE TABLE A(Id INTEGER,Data BLOB)", 0, 0, 0);

   150 	TEST2(rc, SQLITE_OK);

   151 	//Insert records

   152 	rc = sqlite3_exec(TheSqliteDb, "BEGIN", 0, 0, 0);

   153 	TEST2(rc, SQLITE_OK);

   154 	TheSqlQuery.Copy(_L8("INSERT INTO A VALUES(%d,x'"));

   155 	for(TInt j=0;j<(KRecLen-50);++j)

   156 		{

   157 		TheSqlQuery.Append(_L8("A"));

   158 		}

   159 	TheSqlQuery.Append(_L8("')"));

   160 	const TInt KRecCount = 100;

   161 	for(TInt i=0;i<KRecCount;++i)

   162 		{

   163 		TheSqlFmt.Format(TheSqlQuery, i + 1);

   164 		rc = sqlite3_exec(TheSqliteDb, (const char*)TheSqlFmt.PtrZ(), 0, 0, 0);

   165 		TEST2(rc, SQLITE_OK);

   166 		}

   167 	rc = sqlite3_exec(TheSqliteDb, "COMMIT", 0, 0, 0);

   168 	TEST2(rc, SQLITE_OK);

   169 	//Free some space

   170 	rc = sqlite3_exec(TheSqliteDb, "DELETE FROM A WHERE Id > 10", 0, 0, 0);

   171 	TEST2(rc, SQLITE_OK);

   172 	sqlite3_close(TheSqliteDb);

   173 	TheSqliteDb = NULL;

   174 	}

   176 void CreateTestDatabase16()

   177 	{

   178 	TheTest.Printf(_L("Create UTF16 test database: %S\r\n"), &KTestDbTemplate16);

   179 	(void)RSqlDatabase::Delete(KTestDbTemplate16);

   180 	TBuf<KMaxFileName> fname;

   181 	fname.Copy(KTestDbTemplate16);

   182 	TheSqliteDb = NULL;

   183 	TInt rc = sqlite3_open16(fname.PtrZ(), &TheSqliteDb);

   184 	TEST2(rc, SQLITE_OK);

   185 	TBuf8<100> sql;

   186 	_LIT8(KSql, "PRAGMA page_size=%d\x0");

   187 	sql.Format(KSql, KTestDbPageSize);

   188 	rc = sqlite3_exec(TheSqliteDb, (const char*)sql.Ptr(), 0, 0, 0);

   189 	TEST2(rc, SQLITE_OK);

   190 	rc = sqlite3_exec(TheSqliteDb, "CREATE TABLE A(Id INTEGER,Data BLOB)", 0, 0, 0);

   191 	TEST2(rc, SQLITE_OK);

   192 	//Insert records

   193 	rc = sqlite3_exec(TheSqliteDb, "BEGIN", 0, 0, 0);

   194 	TEST2(rc, SQLITE_OK);

   195 	TheSqlQuery.Copy(_L8("INSERT INTO A VALUES(%d,x'"));

   196 	for(TInt j=0;j<(KRecLen-50);++j)

   197 		{

   198 		TheSqlQuery.Append(_L8("A"));

   199 		}

   200 	TheSqlQuery.Append(_L8("')"));

   201 	const TInt KRecCount = 100;

   202 	for(TInt i=0;i<KRecCount;++i)

   203 		{

   204 		TheSqlFmt.Format(TheSqlQuery, i + 1);

   205 		rc = sqlite3_exec(TheSqliteDb, (const char*)TheSqlFmt.PtrZ(), 0, 0, 0);

   206 		TEST2(rc, SQLITE_OK);

   207 		}

   208 	rc = sqlite3_exec(TheSqliteDb, "COMMIT", 0, 0, 0);

   209 	TEST2(rc, SQLITE_OK);

   210 	//Free some space

   211 	rc = sqlite3_exec(TheSqliteDb, "DELETE FROM A WHERE Id > 10", 0, 0, 0);

   212 	TEST2(rc, SQLITE_OK);

   213 	sqlite3_close(TheSqliteDb);

   214 	TheSqliteDb = NULL;

   215 	}

   217 void CreateDatabase8(const TDesC& aTargetDbName)

   218 	{

   219 	RFs fs;

   220 	TInt err = fs.Connect();

   221 	TEST2(err, KErrNone);

   222 	CFileMan* fm = NULL;

   223 	TRAP(err, fm = CFileMan::NewL(fs));

   224 	TEST2(err, KErrNone);

   225 	err = fm->Copy(KTestDbTemplate8, aTargetDbName);

   226 	delete fm;

   227 	fs.Close();

   228 	TEST2(err, KErrNone);

   229 	}

   231 void CreateDatabase16(const TDesC& aTargetDbName)

   232 	{

   233 	RFs fs;

   234 	TInt err = fs.Connect();

   235 	TEST2(err, KErrNone);

   236 	CFileMan* fm = NULL;

   237 	TRAP(err, fm = CFileMan::NewL(fs));

   238 	TEST2(err, KErrNone);

   239 	err = fm->Copy(KTestDbTemplate16, aTargetDbName);

   240 	delete fm;

   241 	fs.Close();

   242 	TEST2(err, KErrNone);

   243 	}

   245 void CalculateMaxCompaction8()

   246 	{

   247 	TheTest.Printf(_L("UTF8 test database - calculate max compaction\r\n"));

   248 	(void)RSqlDatabase::Delete(TheTestDbName);

   249 	CreateDatabase8(TheTestDbName);

   250 	TInt err = TheDb.Open(TheTestDbName);

   251 	TEST2(err, KErrNone);

   252 	RSqlDatabase::TSize size1;

   253 	err = TheDb.Size(size1);

   254 	TEST2(err, KErrNone);

   255 	TheTest.Printf(_L("UTF8.Database before compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);

   256 	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);

   257 	TEST2(err, size1.iFree);

   258 	RSqlDatabase::TSize size2;

   259 	err = TheDb.Size(size2);

   260 	TEST2(err, KErrNone);

   261 	TheTest.Printf(_L("UTF8.Database after compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);

   262 	TheDb.Close();

   263 	(void)RSqlDatabase::Delete(TheTestDbName);

   264 	TheOriginalDbSize8 = size1.iSize;

   265 	TheCompactedDbSize8 = size2.iSize;

   266 	TEST(TheOriginalDbSize8 > 0);

   267 	TEST(TheCompactedDbSize8 > 0 && TheCompactedDbSize8 < TheOriginalDbSize8);

   268 	}

   270 void CalculateMaxCompaction16()

   271 	{

   272 	TheTest.Printf(_L("UTF16 test database - calculate max compaction\r\n"));

   273 	(void)RSqlDatabase::Delete(TheTestDbName);

   274 	CreateDatabase16(TheTestDbName);

   275 	TInt err = TheDb.Open(TheTestDbName);

   276 	TEST2(err, KErrNone);

   277 	RSqlDatabase::TSize size1;

   278 	err = TheDb.Size(size1);

   279 	TEST2(err, KErrNone);

   280 	TheTest.Printf(_L("UTF16.Database before compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);

   281 	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);

   282 	TEST2(err, size1.iFree);

   283 	RSqlDatabase::TSize size2;

   284 	err = TheDb.Size(size2);

   285 	TEST2(err, KErrNone);

   286 	TheTest.Printf(_L("UTF16.Database after compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);

   287 	TheDb.Close();

   288 	(void)RSqlDatabase::Delete(TheTestDbName);

   289 	TheOriginalDbSize16 = size1.iSize;

   290 	TheCompactedDbSize16 = size2.iSize;

   291 	TEST(TheOriginalDbSize16 > 0);

   292 	TEST(TheCompactedDbSize16 > 0 && TheCompactedDbSize16 < TheOriginalDbSize16);

   293 	}

   295 ///////////////////////////////////////////////////////////////////////////////////////

   298 enum TCompactionType {ESyncCompaction, EAsyncCompaction, EMaxCompactionType};

   300 TInt DoCompact(TCompactionType aType, TInt aSize, const TDesC& aAttachDbName = KNullDesC)

   301 	{

   302 	TInt err = KErrGeneral;

   303 	switch(aType)

   304 		{

   305 		case ESyncCompaction:

   306 			err = TheDb.Compact(aSize, aAttachDbName);

   307 			break;

   308 		case EAsyncCompaction:

   309 			{

   310 			TRequestStatus stat;

   311 			TheDb.Compact(aSize, stat, aAttachDbName);

   312 			User::WaitForRequest(stat);

   313 			TEST(stat != KRequestPending);

   314 			err = stat.Int();

   315 			break;

   316 			}

   317 		default:

   318 			TEST(0);

   319 			break;

   320 		}

   321 	return err;

   322 	}

   324 TInt DoManualCompaction(TCompactionType aType, const TDesC& aMainDb, TInt aSize, TBool aRoFlag = EFalse)

   325 	{

   326 	if(!aRoFlag)

   327 		{

   328 		(void)RSqlDatabase::Delete(aMainDb);

   329 		CreateDatabase8(aMainDb);

   330 		}

   332 	TInt err = TheDb.Open(aMainDb);

   333 	TEST2(err, KErrNone);

   335 	err = DoCompact(aType, aSize);

   337 	TheDb.Close();

   338 	if(!aRoFlag)

   339 		{

   340 		(void)RSqlDatabase::Delete(aMainDb);

   341 		}

   342 	return err;

   343 	}

   345 TInt DoManualCompaction(TCompactionType aType, TInt aSize, const TDesC& aAttachDbName)

   346 	{

   347 	return DoCompact(aType, aSize, aAttachDbName);

   348 	}

   350 void DoManualCompaction(TCompactionType aType, TInt aSize, TInt aCompactedSize)

   351 	{

   352 	(void)RSqlDatabase::Delete(TheTestDbName);

   353 	CreateDatabase8(TheTestDbName);

   355 	TInt err = TheDb.Open(TheTestDbName);

   356 	TEST2(err, KErrNone);

   358 	err = DoCompact(aType, aSize);

   359 	TEST(err >= 0);

   361 	RSqlDatabase::TSize size;

   362 	err = TheDb.Size(size);

   363 	TEST2(err, KErrNone);

   364 	TEST2(size.iSize, aCompactedSize);

   366 	TheDb.Close();

   367 	(void)RSqlDatabase::Delete(TheTestDbName);

   368 	}

   370 void DoManualCompaction(TCompactionType aType, TInt aSize, TInt aCompactedSize, const TDesC& aAttachDbName)

   371 	{

   372 	TInt err = DoCompact(aType, aSize, aAttachDbName);

   373 	TEST(err >= 0);

   375 	RSqlDatabase::TSize size;

   376 	err = TheDb.Size(size, aAttachDbName);

   377 	TEST2(err, KErrNone);

   378 	TEST2(size.iSize, aCompactedSize);

   379 	}

   381 /**

   382 @SYMTestCaseID			SYSLIB-SQL-UT-4064

   383 @SYMTestCaseDesc		Manual compaction - negative tests.

   384 						The test creates a database with a manual compaction mode.

   385 						Then the test executes the following negative tests using both synchronous and

   386 						asynchronous Compact() methods:

   387 							- RSqlDatabase::Compact() called with aSize parameter value = KMinTInt;

   388 							- RSqlDatabase::Compact() called with negative aSize parameter value;

   389 							- RSqlDatabase::Compact() called on a read-only database;

   390 							- RSqlDatabase::Compact() called on an attached read-only database;

   391 							- RSqlDatabase::Compact() called on a nonexisting attached database with very long name;

   392 							- RSqlDatabase::Compact() called with aSize = 0;

   393 							- RSqlDatabase::Compact() called on a read-only database where the version number of symbian_settings table is 3;

   394 @SYMTestPriority		Medium

   395 @SYMTestActions			Manual compaction - negative tests.

   396 @SYMTestExpectedResults Test must not fail

   397 @SYMREQ					REQ10273

   398                         REQ10274

   399                         REQ10402

   400 */

   401 void ManualCompactionNegativeTest()

   402 	{

   403 	for(TInt i=0;i<EMaxCompactionType;++i)

   404 		{

   405 		//Specifying KMaxTInt as aSize argument value.

   406 		TInt err = DoManualCompaction((TCompactionType)i, TheTestDbName, KMaxTInt);

   407 		TEST(err > 0);

   408 		//Specifying KMinTInt as aSize argument value.

   409 		err = DoManualCompaction((TCompactionType)i, TheTestDbName, KMinTInt);

   410 		TEST2(err, KErrArgument);

   411 		//Specifying another negative value as aSize argument value.

   412 		err = DoManualCompaction((TCompactionType)i, TheTestDbName, -357);

   413 		TEST2(err, KErrArgument);

   414 		//Specifying zero as aSize argument value.

   415 		err = DoManualCompaction((TCompactionType)i, TheTestDbName, 0);

   416 		TEST2(err, 0);

   417 		//Read-only database - old format (version 3 of symbian_settings table)

   418 		err = DoManualCompaction((TCompactionType)i, KRoDbName, RSqlDatabase::EMaxCompaction, ETrue);

   419 		TEST2(err, KSqlErrReadOnly);

   420 		//

   421 		(void)RSqlDatabase::Delete(TheTestDbName);

   422 		CreateDatabase16(TheTestDbName);

   423 		err = TheDb.Open(TheTestDbName);

   424 		TEST2(err, KErrNone);

   425 		_LIT(KAttachDbName, "Db");

   426 		//Attached read-only database

   427 		err = TheDb.Attach(KRoDbName, KAttachDbName);

   428 		TEST2(err, KErrNone);

   429 		err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, KAttachDbName);

   430 		TEST2(err, KSqlErrReadOnly);

   431 		err = TheDb.Detach(KAttachDbName);

   432 		TEST2(err, KErrNone);

   433 		//Nonexisting attached database

   434 		err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, _L("aaa"));

   435 		TEST2(err, KSqlErrGeneral);

   436         //Very long name of a  nonexisting attached database

   437         TBuf<KMaxFileName + 10> fname;

   438         fname.SetLength(fname.MaxLength());

   439         fname.Fill(0xDD);

   440         err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, fname);

   441         TEST2(err, KErrBadName);

   442         //Invalid attached database name

   443         fname.Copy(_L("c:\\|aaa|.db"));

   444         err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, fname);

   445         TEST2(err, KSqlErrGeneral);

   446         //

   447 		TheDb.Close();

   448 		(void)RSqlDatabase::Delete(TheTestDbName);

   449 		}

   450 	}

   452 /**

   453 @SYMTestCaseID			SYSLIB-SQL-UT-4065

   454 @SYMTestCaseDesc		Manual compaction - functional tests.

   455 						The test creates a database with a manual compaction mode.

   456 						Then the test executes the following functional tests using both synchronous and

   457 						asynchronous Compact() methods:

   458 							- RSqlDatabase::Compact() called with aSize parameter value = RSqlDatabase::EMaxCompaction;

   459 							- RSqlDatabase::Compact() called with aSize parameter value = 0. No pages should be removed;

   460 							- RSqlDatabase::Compact() called with aSize parameter value = 1. 1 page should be removed;

   461 							- RSqlDatabase::Compact() called with aSize parameter value = "db page size - 1". 1 page should be removed;

   462 							- RSqlDatabase::Compact() called with aSize parameter value = "db page size * <cnt>". <cnt> pages should be removed;

   463 							- RSqlDatabase::Compact() called with aSize parameter value > the free db space. All free pages should be removed;

   464 						The same functional tests are repeated with an attached database.

   465 @SYMTestPriority		Medium

   466 @SYMTestActions			Manual compaction - functional tests.

   467 @SYMTestExpectedResults Test must not fail

   468 @SYMREQ					REQ10273

   469                         REQ10274

   470                         REQ10402

   471 */

   472 void ManualCompactionTest()

   473 	{

   474 	for(TInt i=0;i<EMaxCompactionType;++i)

   475 		{

   476 		//Calling Compact() with aSize = RSqlDatabase::EMaxCompaction

   477 		DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, TheCompactedDbSize8);

   478 		//Calling Compact() with aSize = 0. 0 pages expected to be removed

   479 		DoManualCompaction((TCompactionType)i, 0, TheOriginalDbSize8);

   480 		//Calling Compact() with aSize = 1. 1 page expected to be removed

   481 		DoManualCompaction((TCompactionType)i, 1, TheOriginalDbSize8 - KTestDbPageSize);

   482 		//Calling Compact() with aSize = KTestDbPageSize - 1. 1 page expected to be removed

   483 		DoManualCompaction((TCompactionType)i, KTestDbPageSize - 1, TheOriginalDbSize8 - KTestDbPageSize);

   484 		//Calling Compact() with aSize = KTestDbPageSize. 1 page expected to be removed

   485 		DoManualCompaction((TCompactionType)i, KTestDbPageSize, TheOriginalDbSize8 - KTestDbPageSize);

   486 		const TInt KPagesCnt1 = 17;

   487 		//Calling Compact() with aSize = KTestDbPageSize * KPagesCnt1. KPagesCnt1 pages expected to be removed

   488 		DoManualCompaction((TCompactionType)i, KTestDbPageSize * KPagesCnt1, TheOriginalDbSize8 - KTestDbPageSize * KPagesCnt1);

   489 		//Calling Compact() with aSize > TheOriginalDbSize8. All free pages expected to be removed

   490 		DoManualCompaction((TCompactionType)i, TheOriginalDbSize8 + 2000, TheCompactedDbSize8);

   491 		//Attached database

   492 		(void)RSqlDatabase::Delete(KDbName2);

   493 		TInt err = TheDb.Create(KDbName2);

   494 		TEST2(err, KErrNone);

   495 		(void)RSqlDatabase::Delete(TheTestDbName);

   496 		CreateDatabase16(TheTestDbName);

   497 		_LIT(KAttachDbName, "Db");

   498 		err = TheDb.Attach(TheTestDbName, KAttachDbName);

   499 		TEST2(err, KErrNone);

   500 		TInt newDatabaseSize = TheOriginalDbSize16;

   501 		//Calling Compact() with aSize = 0. 0 pages expected to be removed

   502 		DoManualCompaction((TCompactionType)i, 0, newDatabaseSize, KAttachDbName);

   503 		//Calling Compact() with aSize = 1. 1 page expected to be removed

   504 		DoManualCompaction((TCompactionType)i, 1, TheOriginalDbSize16 - KTestDbPageSize, KAttachDbName);

   505 		newDatabaseSize -= KTestDbPageSize;

   506 		//Calling Compact() with aSize = KTestDbPageSize - 1. 1 page expected to be removed

   507 		DoManualCompaction((TCompactionType)i, KTestDbPageSize - 1, newDatabaseSize - KTestDbPageSize, KAttachDbName);

   508 		newDatabaseSize -= KTestDbPageSize;

   509 		//Calling Compact() with aSize = KTestDbPageSize. 1 page expected to be removed

   510 		DoManualCompaction((TCompactionType)i, KTestDbPageSize, newDatabaseSize - KTestDbPageSize, KAttachDbName);

   511 		newDatabaseSize -= KTestDbPageSize;

   512 		//Calling Compact() with aSize = KTestDbPageSize * KPagesCnt1. KPagesCnt1 pages expected to be removed

   513 		DoManualCompaction((TCompactionType)i, KTestDbPageSize * KPagesCnt1, newDatabaseSize - KTestDbPageSize * KPagesCnt1, KAttachDbName);

   514 		newDatabaseSize -= KTestDbPageSize * KPagesCnt1;

   515 		//Calling Compact() with aSize > newDatabaseSize. All free pages expected to be removed

   516 		DoManualCompaction((TCompactionType)i, newDatabaseSize + 2000, TheCompactedDbSize16, KAttachDbName);

   517 		//

   518 		err = TheDb.Detach(KAttachDbName);

   519 		TEST2(err, KErrNone);

   520 		TheDb.Close();

   521 		(void)RSqlDatabase::Delete(KDbName2);

   522 		}

   523 	}

   526 enum TSizeTestType {EManualSizeTest, EAutoSizeTest};

   528 void DoCompactionDbSizeTest(TSizeTestType aType)

   529 	{

   530 	(void)RSqlDatabase::Delete(TheTestDbName);

   531 	_LIT8(KConfig1, "compaction=manual");

   532 	_LIT8(KConfig2, "compaction=auto");

   533 	TInt err = TheDb.Create(TheTestDbName, aType == EManualSizeTest ? &KConfig1 : &KConfig2);

   534 	TEST2(err, KErrNone);

   535 	err = TheDb.Exec(_L("CREATE TABLE A(T TEXT)"));

   536 	TEST2(err, 1);

   537 	//

   538 	RSqlDatabase::TSize size;

   539 	err = TheDb.Size(size);

   540 	TEST2(err, KErrNone);

   541 	TEST2(size.iFree, 0);

   542 	//

   543 	const TInt KRecCnt = 50;

   544 	for(TInt i=0;i<KRecCnt;++i)

   545 		{

   546 		err = TheDb.Exec(_L("INSERT INTO A VALUES('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaa')"));

   547 		TEST2(err, 1);

   548 		}

   549 	//

   550 	err = TheDb.Size(size);

   551 	TEST2(err, KErrNone);

   552 	TEST2(size.iFree, 0);

   553 	//

   554 	err = TheDb.Exec(_L("DELETE FROM A WHERE 1"));

   555 	TEST2(err, KRecCnt);

   556 	//

   557 	err = TheDb.Size(size);

   558 	TEST2(err, KErrNone);

   559 	if(aType == EManualSizeTest)

   560 		{

   561 		TEST(size.iFree > 0);

   562 		}

   563 	else

   564 		{

   565 		TEST2(size.iFree, 0);

   566 		}

   567 	//

   568 	TheDb.Close();

   569 	(void)RSqlDatabase::Delete(TheTestDbName);

   570 	}

   572 /**

   573 @SYMTestCaseID			SYSLIB-SQL-UT-4066

   574 @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) called on a database with manual compaction mode.

   575 						The test creates a database with a manual compaction mode.

   576 						Then the test inserts some records and deletes the records making some free database pages.

   577 						The test calls RSqlDatabase::Size(TSize&) before and after the delete operation and verifies

   578 						that the database file size stays unchanged.

   579 @SYMTestPriority		Medium

   580 @SYMTestActions			RSqlDatabase::Size(TSize&) called on a database with manual compaction mode.

   581 @SYMTestExpectedResults Test must not fail

   582 @SYMREQ					REQ10407

   583 */

   584 void ManualCompactionSizeTest()

   585 	{

   586 	DoCompactionDbSizeTest(EManualSizeTest);

   587 	}

   589 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   590 //////////////////////////////////         OOM testing        ////////////////////////////////////////////////////////////

   591 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   593 void PrintEndOfOomTest(TInt aFailingAllocationNo)

   594 	{

   595 	TheTest.Printf(_L("=== OOM Test succeeded at heap failure rate of %d ===\r\n"), aFailingAllocationNo);

   596 	}

   598 void SetDbHeapFailure(TInt aFailingAllocationNo)

   599 	{

   600 	const TInt KDelayedDbHeapFailureMask = 0x1000;

   601 	TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic | KDelayedDbHeapFailureMask, aFailingAllocationNo);

   602 	}

   604 void ResetDbHeapFailure()

   605 	{

   606 	TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);

   607 	}

   609 static TInt TheHandleCount1B;

   610 static TInt TheHandleCount2B;

   611 static TInt TheAllocatedCellsCountB;

   613 void MarkHandles()

   614 	{

   615 	RThread().HandleCount(TheHandleCount1B, TheHandleCount2B);

   616 	}

   618 void CheckHandles()

   619 	{

   620 	TInt endHandleCount1E;

   621 	TInt endHandleCount2E;

   623 	RThread().HandleCount(endHandleCount1E, endHandleCount2E);

   625 	TEST(TheHandleCount1B == endHandleCount1E);

   626 	TEST(TheHandleCount2B == endHandleCount2E);

   627 	}

   629 void MarkAllocatedCells()

   630 	{

   631 	TheAllocatedCellsCountB = User::CountAllocCells();

   632 	}

   634 void CheckAllocatedCells()

   635 	{

   636 	TInt allocatedCellsCountE = User::CountAllocCells();

   637 	TEST(allocatedCellsCountE == TheAllocatedCellsCountB);

   638 	}

   640 typedef void (*TDbFuncPtrL)(const TDesC& aDbName);

   642 void DoManualCompactionOomTest(TDbFuncPtrL aTestFunctionPtrL, const TDesC& aDbFileName, const TDesC& aAttachDbFileName, const TDesC& aDbName)

   643 	{

   644 	const TInt KDoDbOomTestAllocLimitServer = 1000;

   645 	TInt failingAllocation = 0;

   646 	TInt allocation = 0;

   647 	TInt err = KErrNoMemory;

   648 	while(allocation < KDoDbOomTestAllocLimitServer)

   649 		{

   650 		MarkHandles();

   651 		MarkAllocatedCells();

   653 		__UHEAP_MARK;

   655 		SetDbHeapFailure(++allocation);

   657 		err = TheDb.Open(aDbFileName);

   658 		TEST2(err, KErrNone);

   659 		if(aAttachDbFileName != KNullDesC)

   660 			{

   661 			TEST(aDbName != KNullDesC);

   662 			err = TheDb.Attach(aAttachDbFileName, aDbName);

   663 			TEST(err == KErrNone || err == KErrNoMemory);

   664 			}

   665 		if(err == KErrNone)

   666 			{

   667 			TRAP(err, (*aTestFunctionPtrL)(aDbName));

   668 			if(err != KErrNoMemory)

   669 				{

   670 				TEST2(err, KErrNone);

   671 				}

   672 			else

   673 				{

   674 				failingAllocation = allocation;

   675 				}

   676 			}

   678 		ResetDbHeapFailure();

   680 		if(aAttachDbFileName != KNullDesC)

   681 			{

   682 			(void)TheDb.Detach(aDbName);

   683 			}

   684 		TheDb.Close();

   686 		__UHEAP_MARKEND;

   688 		CheckAllocatedCells();

   689 		CheckHandles();

   690 		}

   691 	TEST2(err, KErrNone);

   692 	PrintEndOfOomTest(failingAllocation + 1);

   693 	}

   695 void OomTest1L(const TDesC&)

   696 	{

   697 	User::LeaveIfError(TheDb.Compact(RSqlDatabase::EMaxCompaction));

   698 	}

   700 void OomTest2L(const TDesC& aDbName)

   701 	{

   702 	TEST(aDbName != KNullDesC);

   703 	User::LeaveIfError(TheDb.Compact(RSqlDatabase::EMaxCompaction, aDbName));

   704 	}

   706 /**

   707 @SYMTestCaseID			SYSLIB-SQL-UT-4068

   708 @SYMTestCaseDesc		RSqlDatabase::Compact() - OOM test.

   709 						The test creates a database with a manual compaction mode.

   710 						Then the test calls Compact() in an OOM loop.

   711 						The same OOM test is repeated for Compact() called an attached database.

   712 @SYMTestPriority		Medium

   713 @SYMTestActions			RSqlDatabase::Compact() - OOM test.

   714 @SYMTestExpectedResults Test must not fail

   715 @SYMREQ					REQ10405

   716 */

   717 void ManualCompactionOomTest()

   718 	{

   719 	TheTest.Printf(_L("Main database - manual compaction - OOM test\r\n"));

   720 	(void)RSqlDatabase::Delete(TheTestDbName);

   721 	CreateDatabase8(TheTestDbName);

   722 	DoManualCompactionOomTest(&OomTest1L, TheTestDbName, KNullDesC, KNullDesC);

   723 	TInt err = TheDb.Open(TheTestDbName);

   724 	TEST2(err, KErrNone);

   725 	RSqlDatabase::TSize size;

   726 	err = TheDb.Size(size);

   727 	TEST2(err, KErrNone);

   728 	TEST2(size.iSize, TheCompactedDbSize8);

   729 	TheDb.Close();

   731 	TheTest.Printf(_L("Attached database - manual compaction - OOM test\r\n"));

   732 	(void)RSqlDatabase::Delete(KDbName2);

   733 	err = TheDb.Create(KDbName2);

   734 	TEST2(err, KErrNone);

   735 	TheDb.Close();

   736 	(void)RSqlDatabase::Delete(TheTestDbName);

   737 	CreateDatabase16(TheTestDbName);

   738 	DoManualCompactionOomTest(&OomTest2L, KDbName2, TheTestDbName, _L("Db"));

   739 	err = TheDb.Open(TheTestDbName);

   740 	TEST2(err, KErrNone);

   741 	err = TheDb.Size(size);

   742 	TEST2(err, KErrNone);

   743 	TEST2(size.iSize, TheCompactedDbSize16);

   744 	TheDb.Close();

   746 	(void)RSqlDatabase::Delete(KDbName2);

   747 	(void)RSqlDatabase::Delete(TheTestDbName);

   748 	}

   750 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   752 /**

   753 @SYMTestCaseID			SYSLIB-SQL-UT-4067

   754 @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) called on a database with auto compaction mode.

   755 						The test creates a database with an auto compaction mode.

   756 						Then the test inserts some records and deletes the records.

   757 						The test calls RSqlDatabase::Size(TSize&) after the delete operation and verifies

   758 						that the database file does not contain any free pages.

   759 @SYMTestPriority		Medium

   760 @SYMTestActions			RSqlDatabase::Size(TSize&) called on a database with auto compaction mode.

   761 @SYMTestExpectedResults Test must not fail

   762 @SYMREQ					REQ10407

   763                         REQ10400

   764 */

   765 void AutoCompactionSizeTest()

   766 	{

   767 	DoCompactionDbSizeTest(EAutoSizeTest);

   768 	}

   770 /**

   771 @SYMTestCaseID			SYSLIB-SQL-UT-4069

   772 @SYMTestCaseDesc		Background compaction functional test.

   773 						The test executes a 10 iterations loop with a "sleep" time 1000000 us at the beginning.

   774 						The "sleep" time is divided by 2 on each iteration.

   775 						In each iteration the test creates a database with free pages count big enough to kick-off the

   776 						background compaction. Then the test executes enough Exec()s in order to kick-off the background compaction.

   777 						Then the test "sleeps" the calculated "sleep" time and checks after that the database size and free pages

   778 						count and prints them out. After the last iteration the same test is repeated with no "sleep" time.

   779 						The test verifies how the client connection activity affects the possibility of the server to run the

   780 						background compaction.

   781 @SYMTestPriority		Medium

   782 @SYMTestActions			Background compaction functional test.

   783 @SYMTestExpectedResults Test must not fail

   784 @SYMREQ					REQ10271

   785                         REQ10407

   786 */

   787 void BackgroundCompactionTest()

   788 	{

   789 	TInt interval = 1000000;//us

   790 	const TInt KIterationCnt = 10;

   791 	TheTest.Printf(_L("===Sleep after Exec()\r\n"));

   792 	for(TInt i=0;i<KIterationCnt;++i)

   793 		{

   794 		(void)RSqlDatabase::Delete(TheTestDbName);

   795 		CreateDatabase8(TheTestDbName);

   796 		TInt err = TheDb.Open(TheTestDbName);

   797 		TEST2(err, KErrNone);

   798 		RSqlDatabase::TSize size1;

   799 		err = TheDb.Size(size1);

   800 		TEST2(err, KErrNone);

   801 		TheTest.Printf(_L("---------------------------------\r\n"));

   802 		TheTest.Printf(_L("===Sleep time %d ms. Database before background compaction: size %ld, free space %ld\r\n"), interval / 1000, size1.iSize, size1.iFree);

   803 		//Simulate Exec() activities

   804 		for(TInt j=0;j<100;++j)

   805 			{

   806 			err = TheDb.Exec(_L8("SELECT Id FROM A LIMIT 1"));

   807 			TEST(err >= 0);

   808 			}

   809 		User::After(interval);

   810 		RSqlDatabase::TSize size2;

   811 		err = TheDb.Size(size2);

   812 		TEST2(err, KErrNone);

   813 		TheTest.Printf(_L("===Database after background compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);

   814 		TEST(size2.iSize <= size1.iSize);

   815 		TEST(size2.iFree <= size1.iFree);

   816 		interval /= 2;

   817 		TheDb.Close();

   818 		}

   819 	TheTest.Printf(_L("===No sleep\r\n"));

   820 	(void)RSqlDatabase::Delete(TheTestDbName);

   821 	CreateDatabase8(TheTestDbName);

   822 	TInt err = TheDb.Open(TheTestDbName);

   823 	TEST2(err, KErrNone);

   824 	RSqlDatabase::TSize size1;

   825 	err = TheDb.Size(size1);

   826 	TEST2(err, KErrNone);

   827 	TheTest.Printf(_L("===Database before background compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);

   828 	//Simulate Exec() activities

   829 	for(TInt j=0;j<100;++j)

   830 		{

   831 		err = TheDb.Exec(_L8("SELECT Id FROM A LIMIT 1"));

   832 		TEST(err >= 0);

   833 		}

   834 	RSqlDatabase::TSize size2;

   835 	err = TheDb.Size(size2);

   836 	TEST2(err, KErrNone);

   837 	TheTest.Printf(_L("===Database after background compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);

   838 	TEST(size2.iSize <= size1.iSize);

   839 	TEST(size2.iFree <= size1.iFree);

   840 	TheDb.Close();

   841 	(void)RSqlDatabase::Delete(TheTestDbName);

   842 	}

   844 struct TThreadData

   845 	{

   846 	TThreadData(const TDesC& aFileName, TInt aSleepInterval) :

   847 		iDbName(aFileName),

   848 		iSleepInterval(aSleepInterval)

   849 		{

   850 		TInt err = iCritSection.CreateLocal();

   851 		TEST2(err, KErrNone);

   852 		iCritSection.Wait();

   853 		Mem::FillZ(&iSize1, sizeof(iSize1));

   854 		Mem::FillZ(&iSize2, sizeof(iSize2));

   855 		}

   856 	TFileName iDbName;

   857 	RCriticalSection iCritSection;

   858 	RSqlDatabase::TSize iSize1;

   859 	RSqlDatabase::TSize iSize2;

   860 	TInt	iSleepInterval;

   861 	};

   863 TInt ThreadFunc(void* aPrm)

   864 	{

   865 	TEST(aPrm != NULL);

   867 	__UHEAP_MARK;

   868 	CTrapCleanup* tc = CTrapCleanup::New();

   869 	TheTest(tc != NULL);

   871 	//Wait for a signal from the main thread

   872 	TThreadData* thrdat = (TThreadData*)aPrm;

   873 	thrdat->iCritSection.Wait();

   875 	RSqlDatabase db;

   876 	TInt err = db.Open(thrdat->iDbName);

   877 	TEST2(err, KErrNone);

   878 	err = db.Size(thrdat->iSize1);

   879 	TEST2(err, KErrNone);

   880 	//Simulate Exec() activities

   881 	for(TInt j=0;j<100;++j)

   882 		{

   883 		err = db.Exec(_L8("SELECT Id FROM A LIMIT 1"));

   884 		TEST(err >= 0);

   885 		if((j % 10) == 0 && thrdat->iSleepInterval > 0)

   886 			{

   887 			User::After(thrdat->iSleepInterval);

   888 			}

   889 		}

   890 	err = db.Size(thrdat->iSize2);

   891 	TEST2(err, KErrNone);

   892 	db.Close();

   894 	delete tc;

   895 	__UHEAP_MARKEND;

   896 	return KErrNone;

   897 	}

   899 /**

   900 @SYMTestCaseID			SYSLIB-SQL-UT-4070

   901 @SYMTestCaseDesc		Background compaction load test.

   902 						The test runs 8 threads. Each thread connects to a different database.

   903 						Each database has space in the free pages above the "free pages" threshold -

   904 						the background compaction will be scheduled at the moment when the database is opened.

   905 						Every thread executes some operations on the opened database - that will delay the background compaction.

   906 						After every 10 operations the thread sleeps for a specified interval of a time.

   907 						After all threads complete, the test checks the database size and free pages count and

   908 						prints them out.

   909 						The test verifies the ability of the SQL server to run the background compaction under a load.

   910 @SYMTestPriority		Medium

   911 @SYMTestActions			Background compaction load test.

   912 @SYMTestExpectedResults Test must not fail

   913 @SYMREQ					REQ10271

   914                         REQ10407

   915 */

   916 void BackgroundCompactionLoadTest()

   917 	{

   918 	RThread threads[KMaxThreadCount];

   919 	TThreadData* thrdata[KMaxThreadCount] = {NULL};

   920 	TRequestStatus thrstat[KMaxThreadCount];

   922 	const TInt KSleepInterval[] = {0, 50000, 100000, 300000, 500000, 800000};//us

   923 	const TInt KTestCnt = sizeof(KSleepInterval) / sizeof(KSleepInterval[0]);

   925 	for(TInt k=0;k<KTestCnt;++k)

   926 		{

   927 		TheTest.Printf(_L("=================================================\r\n"));

   928 		TheTest.Printf(_L("===Sleep interval %d ms\r\n"), KSleepInterval[k] / 1000);

   929 		TheTest.Printf(_L("=================================================\r\n"));

   930 		//Create test databases and threads

   931 		for(TInt i=0;i<TheTestThreadCount;++i)

   932 			{

   933 			//Database

   934 			TBuf<16> fname;

   935 			fname.Copy(_L("\\test\\a"));

   936 			fname.AppendNum(i + 1);

   937 			fname.Append(_L(".db"));

   938 			TheParse.Set(TheDrive, &fname, 0);

   939 			(void)RSqlDatabase::Delete(TheParse.FullName());

   940 			CreateDatabase8(TheParse.FullName());

   941 			//Thread data

   942 			thrdata[i] = new TThreadData(TheParse.FullName(), KSleepInterval[k]);

   943 			TEST(thrdata[i] != NULL);

   944 			//Thread

   945 			TBuf<16> thrname;

   946 			thrname.Copy(_L("Thread"));

   947 			thrname.AppendNum(i + 1);

   948 			TInt err = threads[i].Create(thrname, &ThreadFunc, 0x2000, 0x1000, 0x10000, thrdata[i], EOwnerProcess);

   949 			TEST2(err, KErrNone);

   950 			threads[i].Logon(thrstat[i]);

   951 			TEST2(thrstat[i].Int(), KRequestPending);

   952 			threads[i].Resume();

   953 			}

   954 		//Enable the threads

   955 		for(TInt i=0;i<TheTestThreadCount;++i)

   956 			{

   957 			thrdata[i]->iCritSection.Signal();

   958 			}

   959 		//Wait for cmpletion

   960 		for(TInt i=0;i<TheTestThreadCount;++i)

   961 			{

   962 			User::WaitForRequest(thrstat[i]);

   963 			}

   964 		//Report

   965 		for(TInt i=0;i<TheTestThreadCount;++i)

   966 			{

   967 			TheTest.Printf(_L("===Thread %d, database %S\r\n"), i + 1, &(thrdata[i]->iDbName));

   968 			TheTest.Printf(_L("===Before background compaction: size %6ld, free space %6ld\r\n"), thrdata[i]->iSize1.iSize, thrdata[i]->iSize1.iFree);

   969 			TheTest.Printf(_L("===After background compaction:  size %6ld, free space %6ld\r\n"), thrdata[i]->iSize2.iSize, thrdata[i]->iSize2.iFree);

   970 			TEST(thrdata[i]->iSize2.iSize <= thrdata[i]->iSize1.iSize);

   971 			TEST(thrdata[i]->iSize2.iFree <= thrdata[i]->iSize1.iFree);

   972 			}

   973 		//Destroy

   974 		for(TInt i=0;i<TheTestThreadCount;++i)

   975 			{

   976 			(void)RSqlDatabase::Delete(thrdata[i]->iDbName);

   977 			thrdata[i]->iCritSection.Close();

   978 			delete thrdata[i];

   979 			thrdata[i] = NULL;

   980 			CLOSE_AND_WAIT(threads[i]);

   981 			}

   982 		}

   983 	}

   985 /**

   986 @SYMTestCaseID			SYSLIB-SQL-UT-4071

   987 @SYMTestCaseDesc		Background compaction in a DDL transaction test.

   988 						The test creates a database, begins a transaction that modifies the database structure

   989 						and executes enough operations in order free enough space to kick-off the background compaction.

   990 						The test should not report any failures caused by the fact that the main database connection is

   991 						in a DML transaction and at the same time the background connection may try to execute

   992 						a "PRAGMA freelist_count" statement.

   993 @SYMTestPriority		Medium

   994 @SYMTestActions			Background compaction in a DDL transaction test.

   995 @SYMTestExpectedResults Test must not fail

   996 @SYMREQ					REQ10271

   997 */

   998 void BackgroundCompactionInDDLTransactionTest()

   999 	{

  1000 	const TInt KOperationCount = 100;

  1001 	(void)RSqlDatabase::Delete(KDbName);

  1002 	TInt err = TheDb.Create(KDbName);

  1003 	TEST2(err, KErrNone);

  1004 	err = TheDb.Exec(_L("BEGIN"));

  1005 	TEST(err >= 0);

  1006 	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));

  1007 	TEST2(err, 1);

  1008 	TheText.SetLength(KTextLen);

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

  1010 	for(TInt i=0;i<=KOperationCount;++i)

  1011 		{

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

  1013 		err = TheDb.Exec(TheSqlTexLen);

  1014 		TEST2(err, 1);

  1015 		}

  1016 	err = TheDb.Exec(_L("COMMIT"));

  1017 	TEST(err >= 0);

  1018 	TheDb.Close();

  1019 	(void)RSqlDatabase::Delete(KDbName);

  1020 	}

  1022 /**

  1023 @SYMTestCaseID			PDS-SQL-CT-4209

  1024 @SYMTestCaseDesc		Corrupted database background compaction test.

  1025 						The test creates a database, inserts records, then deletes part of the records.

  1026 						The free pages count should be big enough to kick off the background compaction.

  1027 						But the database is closed immediatelly and then the db file is corrupted in a such

  1028 						way that during the "database open" operation the corruption is not detected.

  1029 						But the corruption is detected during the background compaction. The SQL server

  1030 						should detect during the compaction that the databas eis corrupted and should

  1031 						stop compacting the database (and draining the battery). Unfortunatelly, this

  1032 						cannot be tested automatically, so a breakpoint should be set at the User::After()

  1033 						call, and then the SQL server side should be debugged in order to berify that the

  1034 						background compaction is really stopped for that database.

  1035 @SYMTestPriority		High

  1036 @SYMTestActions			Corrupted database background compaction test.

  1037 @SYMTestExpectedResults Test must not fail

  1038 @SYMDEF					ou1cimx1#406830

  1039 */

  1040 void CorruptedDbBckgCompactionTest()

  1041 	{

  1042 	//Step 1: Create a database with some records

  1043 	const TInt KOperationCount = 100;

  1044 	(void)RSqlDatabase::Delete(KDbName);

  1045 	TInt err = TheDb.Create(KDbName);

  1046 	TEST2(err, KErrNone);

  1047 	err = TheDb.Exec(_L("BEGIN"));

  1048 	TEST(err >= 0);

  1049 	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));

  1050 	TEST2(err, 1);

  1051 	TheText.SetLength(KTextLen);

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

  1053 	for(TInt i=0;i<=KOperationCount;++i)

  1054 		{

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

  1056 		err = TheDb.Exec(TheSqlTexLen);

  1057 		TEST2(err, 1);

  1058 		}

  1059 	err = TheDb.Exec(_L("COMMIT"));

  1060 	TEST(err >= 0);

  1061 	//Step 2: Delete some records to free some space

  1062 	err = TheDb.Exec(_L("DELETE FROM A WHERE (I % 2) = 0"));

  1063 	TEST(err > 0);

  1064 	//Step 3: Close the database

  1065 	TheDb.Close();

  1066 	//Step 4: Corrupt the database

  1067     RFs fs;

  1068 	err = fs.Connect();

  1069 	TEST2(err, KErrNone);

  1070 	RFile file;

  1071 	err = file.Open(fs, KDbName, EFileRead | EFileWrite);

  1072 	TEST2(err, KErrNone);

  1073 	TInt pos = 5000;

  1074 	err = file.Seek(ESeekStart, pos);

  1075 	TEST2(err, KErrNone);

  1076 	TheSqlQuery.SetLength(1000);

  1077 	for(TInt i=0;i<30;++i)

  1078 		{

  1079 		err = file.Write(TheSqlQuery);

  1080 		TEST2(err, KErrNone);

  1081 		}

  1082 	file.Close();

  1083 	//Step 5: Check the background compaction. Wait 10 seconds allowing the SQL server to try to compact the

  1084 	//        database. The SQL server should detect that the SQL database is corrupted and should stop trying to

  1085 	//        compact the database.

  1086 	err = TheDb.Open(KDbName);

  1087 	TEST2(err, KErrNone);

  1088 	User::After(10000000);

  1089 	//

  1090 	TheDb.Close();

  1091 	(void)RSqlDatabase::Delete(KDbName);

  1092 	}

  1094 void DoTestsL()

  1095 	{

  1096 	CreateTestDatabase8();

  1097 	CalculateMaxCompaction8();

  1098 	CreateTestDatabase16();

  1099 	CalculateMaxCompaction16();

  1101 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4064 Manual Compact() - negative tests"));

  1102 	ManualCompactionNegativeTest();

  1104 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4065 Manual Compact() tests"));

  1105 	ManualCompactionTest();

  1107 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4066 Manual compaction db size test"));

  1108 	ManualCompactionSizeTest();

  1110 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4068 Manual compaction - OOM test"));

  1111 	ManualCompactionOomTest();

  1113 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4067 Auto compaction db size test"));

  1114 	AutoCompactionSizeTest();

  1116 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4069 Background compaction test"));

  1117 	BackgroundCompactionTest();

  1119 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4070 Background compaction - load test"));

  1120 	BackgroundCompactionLoadTest();

  1122 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4071 Background compaction activated inside a DDL transaction - test"));

  1123 	BackgroundCompactionInDDLTransactionTest();

  1125 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4209 Corrupted database background compaction test"));

  1126 	CorruptedDbBckgCompactionTest();

  1127 	}

  1129 TInt E32Main()

  1130 	{

  1131 	TheTest.Title();

  1133 	CTrapCleanup* tc = CTrapCleanup::New();

  1134 	TheTest(tc != NULL);

  1136 	TheTest.Printf(_L("Usage:\r\n  t_sqlcompact4 [[drive:] [test thread count]]\r\n"));

  1137 	TheDrive.Copy(KDefaultDriveName);

  1138 	User::CommandLine(TheCmd);

  1139 	TheCmd.TrimAll();

  1140 	if(TheCmd.Length() > 0)

  1141 		{

  1142 		TInt pos = TheCmd.Locate(TChar(' '));

  1143 		TheTest(pos > 0);

  1144 		TPtrC prm1(TheCmd.Left(pos));

  1145 		TPtrC prm2(TheCmd.Mid(pos + 1));

  1147 		TheDrive.Copy(prm1);

  1149 		TLex lex(prm2);

  1150 		lex.Val(TheTestThreadCount);

  1151 		}

  1152 	TheParse.Set(TheDrive, &KDbName, 0);

  1153 	TheTestDbName.Copy(TheParse.FullName());

  1154 	TheTest.Printf(_L("Test database: %S\r\n"), &TheTestDbName);

  1156 	__UHEAP_MARK;

  1158 	CreateTestEnv();

  1159 	TRAPD(err, DoTestsL());

  1160 	DestroyTestEnv();

  1161 	TEST2(err, KErrNone);

  1163 	__UHEAP_MARKEND;

  1165 	TheTest.End();

  1166 	TheTest.Close();

  1168 	delete tc;

  1170 	User::Heap().Check();

  1171 	return KErrNone;

  1172 	}

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