1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlcompact1.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,610 @@
1.4 +// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <bautils.h>
1.21 +#include <sqldb.h>
1.22 +#include <hal.h>
1.23 +#include "SqlUtil.h"
1.24 +
1.25 +///////////////////////////////////////////////////////////////////////////////////////
1.26 +
1.27 +RTest TheTest(_L("t_sqlcompact1 test"));
1.28 +
1.29 +RSqlDatabase TheDb;
1.30 +
1.31 +const TInt KTextLen = 400;
1.32 +TBuf<KTextLen> TheText;
1.33 +TBuf<KTextLen + 100> TheSqlBuf;
1.34 +
1.35 +_LIT(KTestDir, "c:\\test\\");
1.36 +_LIT(KDbName1, "c:\\test\\t_sqlcompact1_1.db");
1.37 +_LIT(KDbName2, "c:\\test\\t_sqlcompact1_2.db");
1.38 +_LIT(KDbName3, "c:\\test\\t_sqlcompact1_3.db");
1.39 +_LIT(KDbName4, "c:\\test\\t_sqlcompact1_4.db");
1.40 +
1.41 +_LIT(KAttachName1, "UOOO");
1.42 +_LIT(KAttachName2, "FOOO");
1.43 +_LIT(KAttachName3, "AOOO");
1.44 +_LIT(KAttachName4, "EOOO");
1.45 +
1.46 +///////////////////////////////////////////////////////////////////////////////////////
1.47 +
1.48 +void DestroyTestEnv()
1.49 + {
1.50 + TheDb.Close();
1.51 + (void)RSqlDatabase::Delete(KDbName4);
1.52 + (void)RSqlDatabase::Delete(KDbName3);
1.53 + (void)RSqlDatabase::Delete(KDbName2);
1.54 + (void)RSqlDatabase::Delete(KDbName1);
1.55 + }
1.56 +
1.57 +///////////////////////////////////////////////////////////////////////////////////////
1.58 +///////////////////////////////////////////////////////////////////////////////////////
1.59 +//Test macros and functions
1.60 +void Check(TInt aValue, TInt aLine)
1.61 + {
1.62 + if(!aValue)
1.63 + {
1.64 + DestroyTestEnv();
1.65 + RDebug::Print(_L("*** Test failure. Boolean expression evaluates to false.\r\n"));
1.66 + TheTest(EFalse, aLine);
1.67 + }
1.68 + }
1.69 +void Check2(TInt aValue, TInt aExpected, TInt aLine)
1.70 + {
1.71 + if(aValue != aExpected)
1.72 + {
1.73 + DestroyTestEnv();
1.74 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.75 + TheTest(EFalse, aLine);
1.76 + }
1.77 + }
1.78 +#define TEST(arg) ::Check((arg), __LINE__)
1.79 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.80 +
1.81 +///////////////////////////////////////////////////////////////////////////////////////
1.82 +
1.83 +//t_sqlcompact1 timeouts in WDP builds.
1.84 +//This function is used to check whether the time limit is reaqched or not.
1.85 +TBool IsTimeLimitReached()
1.86 + {
1.87 + struct TStartTime
1.88 + {
1.89 + TStartTime()
1.90 + {
1.91 + iTime.HomeTime();
1.92 + }
1.93 + TTime iTime;
1.94 + };
1.95 +
1.96 + static TStartTime startTime;
1.97 + const TInt KTestTimeLimit = 100;//seconds
1.98 +
1.99 + TTime currTime;
1.100 + currTime.HomeTime();
1.101 +
1.102 + TTimeIntervalSeconds s;
1.103 + TInt err = currTime.SecondsFrom(startTime.iTime, s);
1.104 + TEST2(err, KErrNone);
1.105 + return s.Int() > KTestTimeLimit;
1.106 + }
1.107 +
1.108 +void GetHomeTimeAsString(TDes& aStr)
1.109 + {
1.110 + TTime time;
1.111 + time.HomeTime();
1.112 + TDateTime dt = time.DateTime();
1.113 + aStr.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());
1.114 + }
1.115 +
1.116 +void CreateTestEnv()
1.117 + {
1.118 + RFs fs;
1.119 + TInt err = fs.Connect();
1.120 + TEST2(err, KErrNone);
1.121 +
1.122 + err = fs.MkDir(KTestDir);
1.123 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.124 +
1.125 + fs.Close();
1.126 + }
1.127 +
1.128 +///////////////////////////////////////////////////////////////////////////////////////
1.129 +
1.130 +void ReplaceDb(const TDesC& aDbName, TInt aPageSize)
1.131 + {
1.132 + (void)RSqlDatabase::Delete(aDbName);
1.133 + _LIT8(KConfigStr, "compaction=manual;page_size=");
1.134 + TBuf8<50> config;
1.135 + config.Copy(KConfigStr);
1.136 + config.AppendNum(aPageSize);
1.137 + TInt err = TheDb.Create(aDbName, &config);
1.138 + TEST2(err, KErrNone);
1.139 + TheDb.Close();
1.140 + }
1.141 +
1.142 +void CreateTable(const TDesC& aDbName)
1.143 + {
1.144 + TInt err = TheDb.Open(aDbName);
1.145 + TEST2(err, KErrNone);
1.146 + err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));
1.147 + TEST(err >= 0);
1.148 + TheDb.Close();
1.149 + }
1.150 +
1.151 +void InsertRecords(const TDesC& aDbName)
1.152 + {
1.153 + TInt err = TheDb.Open(aDbName);
1.154 + TEST2(err, KErrNone);
1.155 + err = TheDb.Exec(_L("BEGIN TRANSACTION"));
1.156 + TEST(err >= 0);
1.157 + TheText.SetLength(TheText.MaxLength());
1.158 + TheText.Fill(TChar('A'));
1.159 + for(TInt i=0;i<100;++i)
1.160 + {
1.161 + TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
1.162 + err = TheDb.Exec(TheSqlBuf);
1.163 + TEST2(err, 1);
1.164 + }
1.165 + err = TheDb.Exec(_L("COMMIT TRANSACTION"));
1.166 + TEST(err >= 0);
1.167 + TheDb.Close();
1.168 + }
1.169 +
1.170 +TInt DeleteRecords(const TDesC& aDbName, TInt aPageCount, TInt aPageSize)
1.171 + {
1.172 + TInt freePageCount = -1;
1.173 + TInt err = TheDb.Open(aDbName);
1.174 + TEST2(err, KErrNone);
1.175 + err = TheDb.Exec(_L("BEGIN TRANSACTION"));
1.176 + TEST(err >= 0);
1.177 + for(TInt i=0;;++i)
1.178 + {
1.179 + TheSqlBuf.Format(_L("DELETE FROM A WHERE I=%d"), i + 1);
1.180 + err = TheDb.Exec(TheSqlBuf);
1.181 + TEST2(err, 1);
1.182 + RSqlDatabase::TSize s;
1.183 + err = TheDb.Size(s);
1.184 + TEST2(err, KErrNone);
1.185 + freePageCount = s.iFree / aPageSize;
1.186 + if(freePageCount >= aPageCount)
1.187 + {
1.188 + break;
1.189 + }
1.190 + }
1.191 + err = TheDb.Exec(_L("COMMIT TRANSACTION"));
1.192 + TEST(err >= 0);
1.193 + TheDb.Close();
1.194 + return freePageCount;
1.195 + }
1.196 +
1.197 +/**
1.198 +@SYMTestCaseID SYSLIB-SQL-UT-4072
1.199 +@SYMTestCaseDesc Manual compaction on attached databases with different page size.
1.200 + The test creates couple of databases with manual compaction and
1.201 + different page sizes, then inserts some records and deletes part of
1.202 + the just inserted records thus making some free pages.
1.203 + The test opens the first database and attaches all other databases the the first one.
1.204 + Then the test checks that RSqlDatabase::Size() returns correct information
1.205 + about the free database space. The test runs the manual compaction on the
1.206 + databases and checks again that the free database space is reported correctly.
1.207 +@SYMTestPriority Medium
1.208 +@SYMTestActions Manual compaction on attached databases with different page size.
1.209 +@SYMTestExpectedResults Test must not fail
1.210 +@SYMREQ REQ10405
1.211 + REQ10407
1.212 +*/
1.213 +void CompactDbTest1()
1.214 + {
1.215 + const TPtrC KDbName[] = {KDbName1(), KDbName2(), KDbName3(), KDbName4()};
1.216 + const TPtrC KDbAttachName[]={KAttachName1(),KAttachName2(), KAttachName3(), KAttachName4()};
1.217 + const TInt KDbPageSize[] = {8192, 1024, 4096, 2048};
1.218 + const TInt KFreePageCount[]={9, 30, 17, 7};
1.219 + TInt freePageCount[] ={0, 0, 0, 0};
1.220 + const TInt KSize = sizeof(KDbName) / sizeof(KDbName[0]);
1.221 +
1.222 + TInt i;
1.223 +
1.224 + TBuf<50> timeBuf;
1.225 + GetHomeTimeAsString(timeBuf);
1.226 + TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
1.227 +
1.228 + //Create databases, tables, insert records, delete part of the just inserted records.
1.229 + for(i=0;i<KSize;++i)
1.230 + {
1.231 + ReplaceDb(KDbName[i], KDbPageSize[i]);
1.232 + CreateTable(KDbName[i]);
1.233 + InsertRecords(KDbName[i]);
1.234 + freePageCount[i] = DeleteRecords(KDbName[i], KFreePageCount[i], KDbPageSize[i]);
1.235 + }
1.236 +
1.237 + GetHomeTimeAsString(timeBuf);
1.238 + TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
1.239 +
1.240 + //Open the first database, attach all others.
1.241 + TInt err = TheDb.Open(KDbName1());
1.242 + TEST2(err, KErrNone);
1.243 + for(i=0;i<KSize;++i)
1.244 + {
1.245 + err = TheDb.Attach(KDbName[i], KDbAttachName[i]);
1.246 + TEST2(err, KErrNone);
1.247 + }
1.248 +
1.249 + GetHomeTimeAsString(timeBuf);
1.250 + TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
1.251 +
1.252 + //Check the size of the main database.
1.253 + RSqlDatabase::TSize size;
1.254 + err = TheDb.Size(size);
1.255 + TEST2(err, KErrNone);
1.256 + TEST2((size.iFree / KDbPageSize[0]), freePageCount[0]);
1.257 +
1.258 + //For all attached database: check the size of the database, compact, check the size again.
1.259 + for(i=0;i<KSize;++i)
1.260 + {
1.261 + err = TheDb.Size(size, KDbAttachName[i]);
1.262 + TEST2(err, KErrNone);
1.263 + TEST2((size.iFree / KDbPageSize[i]), freePageCount[i]);
1.264 +
1.265 + const TInt KCompactPageCount = 3;
1.266 + TInt rc = TheDb.Compact(KCompactPageCount * KDbPageSize[i], KDbAttachName[i]);
1.267 + TInt expected = KCompactPageCount * KDbPageSize[i];
1.268 + TEST2(rc, expected);
1.269 + err = TheDb.Size(size, KDbAttachName[i]);
1.270 + TEST2(err, KErrNone);
1.271 + TInt count = size.iFree / KDbPageSize[i];
1.272 + expected = freePageCount[i] - KCompactPageCount;
1.273 + TEST2(count, expected);
1.274 + }
1.275 +
1.276 + GetHomeTimeAsString(timeBuf);
1.277 + TheTest.Printf(_L("===Time4: %S\r\n"), &timeBuf);
1.278 +
1.279 + //Detach databases and close the main database.
1.280 + for(i=0;i<KSize;++i)
1.281 + {
1.282 + err = TheDb.Detach(KDbAttachName[i]);
1.283 + TEST2(err, KErrNone);
1.284 + }
1.285 + TheDb.Close();
1.286 +
1.287 + GetHomeTimeAsString(timeBuf);
1.288 + TheTest.Printf(_L("===Time5: %S\r\n"), &timeBuf);
1.289 +
1.290 + //Cleanup.
1.291 + for(i=0;i<KSize;++i)
1.292 + {
1.293 + (void)RSqlDatabase::Delete(KDbName[i]);
1.294 + }
1.295 + }
1.296 +
1.297 +//Creates a test database (with KDbName1 name). Inserts aRecordCount records.
1.298 +//The page size is specified in aPageSize parameter. But practically the page size is always 1024 bytes.
1.299 +//The record size is such that there is only one record per page.
1.300 +void PrepareDb(TInt aPageSize, TInt aRecordCount, TBool aManualCompaction = EFalse)
1.301 + {
1.302 + //Create the database
1.303 + (void)RSqlDatabase::Delete(KDbName1);
1.304 + _LIT8(KConfigStr, "page_size=");
1.305 + TBuf8<100> config;
1.306 + config.Copy(KConfigStr);
1.307 + config.AppendNum(aPageSize);
1.308 + if(aManualCompaction)
1.309 + {
1.310 + config.Append(_L(";compaction=manual;"));
1.311 + }
1.312 + TInt err = TheDb.Create(KDbName1, &config);
1.313 + TEST2(err, KErrNone);
1.314 +
1.315 + err = TheDb.Exec(_L("BEGIN TRANSACTION"));
1.316 + TEST(err >= 0);
1.317 + err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));
1.318 + TEST(err >= 0);
1.319 + //Insert records
1.320 + TheText.SetLength(TheText.MaxLength());
1.321 + TheText.Fill(TChar('A'));
1.322 + for(TInt i=0;i<aRecordCount;++i)
1.323 + {
1.324 + TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
1.325 + err = TheDb.Exec(TheSqlBuf);
1.326 + TEST2(err, 1);
1.327 + }
1.328 + err = TheDb.Exec(_L("COMMIT TRANSACTION"));
1.329 + TEST(err >= 0);
1.330 + //Delete all records making a lot of free pages. This operation should kick-off the background compaction
1.331 + err = TheDb.Exec(_L("DELETE FROM A WHERE 1"));
1.332 + TEST2(err, aRecordCount);
1.333 + }
1.334 +
1.335 +/**
1.336 +@SYMTestCaseID SYSLIB-SQL-UT-4073
1.337 +@SYMTestCaseDesc Background compaction steps test.
1.338 + The test creates a database with background compaction mode,
1.339 + then inserts records and deletes all of them. The count of records is such that when
1.340 + the records get deleted, the number of the free pages is very big and all free pages cannot
1.341 + be removed for just one compaction step.
1.342 + The test waits for ("compaction interval"/10 ms) time and checks that no compaction
1.343 + step has been run by the server during the pause and the free space size is the same as before the
1.344 + pause. Then the test waits for ("compaction interval" + "compaction step") time and checks that
1.345 + the background compaction step really happened and removed only part of the free pages.
1.346 + The same test is repeated again and the same check is performed again.
1.347 +@SYMTestPriority Medium
1.348 +@SYMTestActions Background compaction steps test.
1.349 +@SYMTestExpectedResults Test must not fail
1.350 +@SYMREQ REQ10271
1.351 + REQ10272
1.352 +*/
1.353 +void CompactDbTest2()
1.354 + {
1.355 + TBuf<50> timeBuf;
1.356 + GetHomeTimeAsString(timeBuf);
1.357 + TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
1.358 +
1.359 + const TInt KPageSize = 1024;
1.360 + //Number of records to be added and removed from database. Need to be increased when testing on a faster
1.361 + // hardware, otherwise at fastest case the background compaction could be finished in just 1 step.
1.362 + const TInt KRecordCount = 2000;
1.363 + PrepareDb(KPageSize, KRecordCount);
1.364 +
1.365 + GetHomeTimeAsString(timeBuf);
1.366 + TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
1.367 +
1.368 + //Check the free space-1
1.369 + RSqlDatabase::TSize size1;
1.370 + TInt err = TheDb.Size(size1);
1.371 + TEST2(err, KErrNone);
1.372 + TheTest.Printf(_L("===Free space before compaction, pages=%d\r\n"), size1.iFree / KPageSize);
1.373 + TEST(size1.iSize >= (KRecordCount * KPageSize));
1.374 +
1.375 + //Wait KSqlCompactStepIntervalMs/10 ms. The background compaction should not be kicked-off.
1.376 + TTime time1;
1.377 + time1.HomeTime();
1.378 + User::After((KSqlCompactStepIntervalMs / 10) * 1000);
1.379 + TTime time2;
1.380 + time2.HomeTime();
1.381 + TTimeIntervalMicroSeconds intervalUs = time2.MicroSecondsFrom(time1);
1.382 + //Check the free space-2
1.383 + RSqlDatabase::TSize size2;
1.384 + err = TheDb.Size(size2);
1.385 + TEST2(err, KErrNone);
1.386 + TheTest.Printf(_L("=== Wait time: %ld ms. Free space after compaction-1, pages=%d\r\n"), intervalUs.Int64() / 1000 ,size2.iFree / KPageSize);
1.387 + if(intervalUs > KSqlCompactStepIntervalMs * 1000)
1.388 + {
1.389 + TEST(size2.iFree <= size1.iFree);
1.390 + }
1.391 + else
1.392 + {
1.393 + TEST(size2.iFree == size1.iFree);
1.394 + }
1.395 +
1.396 + GetHomeTimeAsString(timeBuf);
1.397 + TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
1.398 +
1.399 + //Wait (KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) ms. During the pause only part of the free pages
1.400 + //should be removed (whatever can be completed for KSqlCompactStepLengthMs ms).
1.401 + User::After((KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) * 1000);
1.402 + //Check the free space-3
1.403 + RSqlDatabase::TSize size3;
1.404 + err = TheDb.Size(size3);
1.405 + TEST2(err, KErrNone);
1.406 + TheTest.Printf(_L("===Free space after compaction-2, pages=%d\r\n"), size3.iFree / KPageSize);
1.407 + if(size3.iFree == 0)
1.408 + {
1.409 + TheTest.Printf(_L("WARNING: Background compaction finished in 1 step. Initial number of records need to be increased.\r\n"));
1.410 + }
1.411 + TEST(size3.iFree > 0 && size3.iFree < size2.iFree);
1.412 +
1.413 + GetHomeTimeAsString(timeBuf);
1.414 + TheTest.Printf(_L("===Time4: %S\r\n"), &timeBuf);
1.415 +
1.416 + //Wait another (KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) ms. During the pause only part of the free pages
1.417 + //should be removed (whatever can be completed for KSqlCompactStepLengthMs ms).
1.418 + User::After((KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) * 1000);
1.419 + //Check the free space-4
1.420 + RSqlDatabase::TSize size4;
1.421 + err = TheDb.Size(size4);
1.422 + TEST2(err, KErrNone);
1.423 + TheTest.Printf(_L("===Free space after compaction-3, pages=%d\r\n"), size4.iFree / KPageSize);
1.424 + TEST((size4.iFree > 0 && size4.iFree < size3.iFree) || (size4.iFree == 0));
1.425 +
1.426 + GetHomeTimeAsString(timeBuf);
1.427 + TheTest.Printf(_L("===Time5: %S\r\n"), &timeBuf);
1.428 +
1.429 + //Cleanup
1.430 + TheDb.Close();
1.431 + (void)RSqlDatabase::Delete(KDbName1);
1.432 + }
1.433 +
1.434 +/**
1.435 +@SYMTestCaseID SYSLIB-SQL-UT-4074
1.436 +@SYMTestCaseDesc Background compaction timer test.
1.437 + The test creates a database with background compaction mode,
1.438 + then inserts records and deletes all of them. The count of records is such that when
1.439 + the records get deleted, the number of the free pages is very big and all free pages cannot
1.440 + be removed for just one compaction step.
1.441 + Then the test executes a set of operations with the server. The amount of time needed for the
1.442 + operations to be executed is bigger than the ("compaction interval" + "compaction step") time.
1.443 + No compaction step should be executed during that time, because every operation resets the background
1.444 + compaction timer.
1.445 +@SYMTestPriority Medium
1.446 +@SYMTestActions Background compaction timer test.
1.447 +@SYMTestExpectedResults Test must not fail
1.448 +@SYMREQ REQ10271
1.449 + REQ10272
1.450 +*/
1.451 +void CompactDbTest3()
1.452 + {
1.453 + TBuf<50> timeBuf;
1.454 + GetHomeTimeAsString(timeBuf);
1.455 + TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
1.456 +
1.457 + const TInt KPageSize = 1024;
1.458 + const TInt KRecordCount = 1000;
1.459 + PrepareDb(KPageSize, KRecordCount);
1.460 +
1.461 + GetHomeTimeAsString(timeBuf);
1.462 + TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
1.463 +
1.464 + //Check the free space-1
1.465 + RSqlDatabase::TSize size1;
1.466 + TInt err = TheDb.Size(size1);
1.467 + TEST2(err, KErrNone);
1.468 + TheTest.Printf(_L("===Free space before operations, pages=%d. Db.Size=%d, Db.Free=%d\r\n"), size1.iFree / KPageSize, size1.iSize, size1.iFree);
1.469 + TEST(size1.iSize >= (KRecordCount * KPageSize));
1.470 +
1.471 + //Execute a set of operations. The time needed for the operations to complete is bigger than
1.472 + //(KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) ms
1.473 + TInt freq = 0;
1.474 + TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);
1.475 + TUint32 begin = User::FastCounter();
1.476 + TInt count = 0;
1.477 + TInt time = -1;
1.478 + for(;;++count)
1.479 + {
1.480 + err = TheDb.Exec(_L("SELECT COUNT(*) FROM A"));
1.481 + TEST(err >= 0);
1.482 + TUint32 current = User::FastCounter();
1.483 + TInt64 diffTicks = (TInt64)current - (TInt64)begin;
1.484 + if(diffTicks < 0)
1.485 + {
1.486 + diffTicks = KMaxTUint32 + diffTicks + 1;
1.487 + }
1.488 + const TInt KMicroSecIn1Sec = 1000000;
1.489 + TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
1.490 + time = us / 1000;
1.491 + if(time > ((KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs)))
1.492 + {
1.493 + break;
1.494 + }
1.495 + }
1.496 +
1.497 + GetHomeTimeAsString(timeBuf);
1.498 + TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
1.499 +
1.500 + //Check the free space-2
1.501 + RSqlDatabase::TSize size2;
1.502 + err = TheDb.Size(size2);
1.503 + TEST2(err, KErrNone);
1.504 + TheTest.Printf(_L("===%d operations completed for %d ms\r\n"), count, time);
1.505 + TheTest.Printf(_L("===Free space after operations, pages=%d\r\n"), size2.iFree / KPageSize);
1.506 + TEST(size1.iFree == size2.iFree);
1.507 +
1.508 + //Cleanup
1.509 + TheDb.Close();
1.510 + (void)RSqlDatabase::Delete(KDbName1);
1.511 + }
1.512 +
1.513 +/**
1.514 +@SYMTestCaseID SYSLIB-SQL-UT-4103
1.515 +@SYMTestCaseDesc Big manual compaction test.
1.516 + The test creates a database with 1000 free pages, then calls
1.517 + RSqlDatabase::Compact(RSqlDatabase::EMaxCompaction).
1.518 +@SYMTestPriority Medium
1.519 +@SYMTestActions Big manual compaction test.
1.520 +@SYMTestExpectedResults Test must not fail
1.521 +@SYMREQ REQ10271
1.522 + REQ10272
1.523 +*/
1.524 +void ManualCompactTest()
1.525 + {
1.526 + TBuf<50> timeBuf;
1.527 + GetHomeTimeAsString(timeBuf);
1.528 + TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
1.529 +
1.530 + //Create a database with 1000 free pages
1.531 + const TInt KPageSize = 1024;
1.532 + const TInt KRecordCount = 1000;
1.533 + PrepareDb(KPageSize, KRecordCount, ETrue);//create the database with manual compaction mode
1.534 +
1.535 + GetHomeTimeAsString(timeBuf);
1.536 + TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
1.537 +
1.538 + //Check the free space-1
1.539 + RSqlDatabase::TSize size1;
1.540 + TInt err = TheDb.Size(size1);
1.541 + TEST2(err, KErrNone);
1.542 + const TInt KFreePageCount = size1.iFree / KPageSize;
1.543 + TheTest.Printf(_L("===Free space before operations, pages=%d\r\n"), KFreePageCount);
1.544 + TEST(size1.iSize >= (KRecordCount * KPageSize));
1.545 + //Compact
1.546 + err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
1.547 + TEST2(err, size1.iFree);
1.548 +
1.549 + GetHomeTimeAsString(timeBuf);
1.550 + TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
1.551 +
1.552 + //Cleanup
1.553 + TheDb.Close();
1.554 + (void)RSqlDatabase::Delete(KDbName1);
1.555 + }
1.556 +
1.557 +void DoTestsL()
1.558 + {
1.559 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4072 Manual Compact() - attached databases, different page sizes"));
1.560 + CompactDbTest1();
1.561 +
1.562 + if(IsTimeLimitReached())
1.563 + {
1.564 + TheTest.Printf(_L("===Test timeout!\r\n"));
1.565 + return;
1.566 + }
1.567 +
1.568 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4073 Background compaction steps test"));
1.569 + CompactDbTest2();
1.570 +
1.571 + if(IsTimeLimitReached())
1.572 + {
1.573 + TheTest.Printf(_L("===Test timeout!\r\n"));
1.574 + return;
1.575 + }
1.576 +
1.577 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4074 Background compaction timer test"));
1.578 + CompactDbTest3();
1.579 +
1.580 + if(IsTimeLimitReached())
1.581 + {
1.582 + TheTest.Printf(_L("===Test timeout!\r\n"));
1.583 + return;
1.584 + }
1.585 +
1.586 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4103 Big manual compaction test"));
1.587 + ManualCompactTest();
1.588 + }
1.589 +
1.590 +TInt E32Main()
1.591 + {
1.592 + TheTest.Title();
1.593 +
1.594 + CTrapCleanup* tc = CTrapCleanup::New();
1.595 + TheTest(tc != NULL);
1.596 +
1.597 + __UHEAP_MARK;
1.598 +
1.599 + CreateTestEnv();
1.600 + TRAPD(err, DoTestsL());
1.601 + DestroyTestEnv();
1.602 + TEST2(err, KErrNone);
1.603 +
1.604 + __UHEAP_MARKEND;
1.605 +
1.606 + TheTest.End();
1.607 + TheTest.Close();
1.608 +
1.609 + delete tc;
1.610 +
1.611 + User::Heap().Check();
1.612 + return KErrNone;
1.613 + }