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 "t_sqlcmdlineutil.h"

    21 ///////////////////////////////////////////////////////////////////////////////////////

    23 RTest			TheTest(_L("t_sqlperformance2 test"));

    24 RSqlDatabase 	TheDb;

    25 TFileName		TheDbFileName;

    26 RFs				TheFs;

    28 TBuf<200> 		TheTestTitle;

    29 TCmdLineParams 	TheCmdLineParams;

    30 TBuf8<200> 		TheSqlConfigString;

    32 _LIT(KUtf8,  "UTF8 ");

    33 _LIT(KUtf16, "UTF16");

    35 TInt TheBlobSize = 1024 * 256;

    37 ///////////////////////////////////////////////////////////////////////////////////////

    39 void TestEnvDestroy()

    40 	{

    41 	TheDb.Close();

    42 	(void)RSqlDatabase::Delete(TheDbFileName);

    43 	TheFs.Close();

    44 	}

    46 ///////////////////////////////////////////////////////////////////////////////////////

    47 ///////////////////////////////////////////////////////////////////////////////////////

    48 //Test macros and functions

    49 void Check1(TInt aValue, TInt aLine)

    50 	{

    51 	if(!aValue)

    52 		{

    53 		TestEnvDestroy();

    54 		TheTest.Printf(_L("*** Line %d\r\n"), aLine);

    55 		TheTest(EFalse, aLine);

    56 		}

    57 	}

    58 void Check2(TInt aValue, TInt aExpected, TInt aLine)

    59 	{

    60 	if(aValue != aExpected)

    61 		{

    62 		TestEnvDestroy();

    63 		TheTest.Printf(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

    64 		TheTest(EFalse, aLine);

    65 		}

    66 	}

    67 #define TEST(arg) ::Check1((arg), __LINE__)

    68 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

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

    72 void TestEnvInit()

    73     {

    74     TInt err = TheFs.Connect();

    75     TEST2(err, KErrNone);

    76     //

    77     TInt driveNumber = -1;

    78 	err = RFs::CharToDrive(TheCmdLineParams.iDriveName[0], driveNumber);

    79 	TEST2(err, KErrNone);

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

    81 	TDriveInfo driveInfo;

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

    83 	TEST2(err, KErrNone);

    84     //Create the test directory

    85 	err = TheFs.MkDirAll(TheDbFileName);

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

    87     //Print drive info and the database name

    88 	_LIT(KType1, "Not present");

    89 	_LIT(KType2, "Unknown");

    90 	_LIT(KType3, "Floppy");

    91 	_LIT(KType4, "Hard disk");

    92 	_LIT(KType5, "CD ROM");

    93 	_LIT(KType6, "RAM disk");

    94 	_LIT(KType7, "Flash");

    95 	_LIT(KType8, "ROM drive");

    96 	_LIT(KType9, "Remote drive");

    97 	_LIT(KType10,"NAND flash");

    98 	_LIT(KType11,"Rotating media");

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

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

   101 	}

   103 void PrintWriteTime(TTimeIntervalMicroSeconds aTime, TTimeIntervalMicroSeconds aWriteTime, TTimeIntervalMicroSeconds aCommitTime)

   104 	{

   105 	TheTest.Printf(_L("####Execution time: %d ms, Write: %d ms, Commit: %d ms\r\n"),

   106 		(TInt)(aTime.Int64() / 1000), (TInt)(aWriteTime.Int64() / 1000), (TInt)(aCommitTime.Int64() / 1000));

   107 	}

   109 void PrintReadTime(TTimeIntervalMicroSeconds aPrepareTime, TTimeIntervalMicroSeconds aNextTime, TTimeIntervalMicroSeconds aReadTime)

   110 	{

   111 	TInt executionTime = (TInt)(aPrepareTime.Int64() / 1000) + (TInt)(aNextTime.Int64() / 1000) + (TInt)(aReadTime.Int64() / 1000);

   112 	TheTest.Printf(_L("####Execution time: %d ms, Prepare: %d ms, Next: %d ms, Read: %d ms\r\n"),

   113 		executionTime, (TInt)(aPrepareTime.Int64() / 1000), (TInt)(aNextTime.Int64() / 1000), (TInt)(aReadTime.Int64() / 1000));

   114 	}

   116 void PrintReadTime(TTimeIntervalMicroSeconds aOpenTime, TTimeIntervalMicroSeconds aReadTime)

   117 	{

   118 	TInt executionTime = (TInt)(aOpenTime.Int64() / 1000) + (TInt)(aReadTime.Int64() / 1000);

   119 	TheTest.Printf(_L("####Execution time: %d ms, Open: %d ms, Read: %d ms\r\n"),

   120 		executionTime, (TInt)(aOpenTime.Int64() / 1000), (TInt)(aReadTime.Int64() / 1000));

   121 	}

   123 void PrintFileSize(RSqlDatabase& aDb)

   124 	{

   125 	TheTest.Printf(_L("####FileSize: %d\r\n"), aDb.Size());

   126 	}

   128 ///////////////////////////////////////////////////////////////////////////////////////

   130 void CreateTestDb()

   131 	{

   132 	(void)RSqlDatabase::Delete(TheDbFileName);

   133 	TInt err = TheDb.Create(TheDbFileName, &TheSqlConfigString);

   134 	TEST2(err, KErrNone);

   135 	err = TheDb.Exec(_L8("CREATE TABLE A(B BLOB)"));

   136 	TEST2(err, 1);

   137 	}

   139 void DoWriteBlobIncrL(const TDesC8& aData,

   140 					  TTime& aT1,

   141 					  TTime& aT2,

   142 					  TTime& aT3,

   143 					  TTime& aT4)

   144 	{

   146 	RSqlBlobWriteStream strm;

   147 	CleanupClosePushL(strm);

   149 	aT1.HomeTime();

   150 	strm.OpenL(TheDb, _L("A"), _L("B"));

   151 	strm.WriteL(aData);

   152 	aT2.HomeTime();

   154 	aT3.HomeTime();

   155 	strm.CommitL();

   156 	aT4.HomeTime();

   158 	CleanupStack::PopAndDestroy(&strm);

   159 	}

   161 void InsertZeroBlob(TBool aDoPrintTime = EFalse)

   162 	{

   163 	TBuf<100> sql;

   164 	sql.Format(_L("INSERT INTO A VALUES(zeroblob(%d))"), TheBlobSize);

   166 	TTime t1, t2;

   167 	t1.HomeTime();

   168 	TInt err = TheDb.Exec(sql);

   169 	t2.HomeTime();

   170 	TEST2(err, 1);

   171 	TTimeIntervalMicroSeconds insertTime = t2.MicroSecondsFrom(t1);

   173 	if(aDoPrintTime)

   174 		{

   175 		PrintWriteTime(insertTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   176 		}

   177 	}

   179 void InsertRealBlob()

   180 	{

   181 	HBufC8* data = HBufC8::New(TheBlobSize);

   182 	TEST(data != NULL);

   183 	TPtr8 dataptr = data->Des();

   184 	dataptr.SetLength(TheBlobSize);

   185 	dataptr.Fill(TChar('A'));

   187 	RSqlStatement stmt;

   188 	TInt err = stmt.Prepare(TheDb, _L8("INSERT INTO A VALUES(:Prm)"));

   189 	TEST2(err, KErrNone);

   191 	RSqlParamWriteStream strm;

   192 	err = strm.BindBinary(stmt, 0);

   193 	TEST2(err, KErrNone);

   195 	TRAP(err, strm.WriteL(dataptr));

   196 	TEST2(err, KErrNone);

   197 	TRAP(err, strm.CommitL());

   198 	TEST2(err, KErrNone);

   199 	strm.Close();

   201 	err = stmt.Exec();

   202 	TEST2(err, 1);

   203 	stmt.Close();

   205 	delete data;

   206 	}

   208 void InsertBlobIncr()

   209 	{

   210 	HBufC8* data = HBufC8::New(TheBlobSize);

   211 	TEST(data != NULL);

   212 	TPtr8 dataptr = data->Des();

   213 	dataptr.SetLength(TheBlobSize);

   214 	dataptr.Fill(TChar('B'));

   216 	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

   218 	TBuf<100> sql;

   219 	sql.Format(_L("INSERT INTO A VALUES(zeroblob(%d))"), TheBlobSize);

   221 	TTime t1, t2, subt1, subt2, subt3, subt4;

   222 	t1.HomeTime();

   224 	TInt err = TheDb.Exec(_L8("BEGIN"));

   225 	TEST(err >= 0);

   227 	err = TheDb.Exec(sql);

   228 	TEST2(err, 1);

   230 	TRAP(err, DoWriteBlobIncrL(dataptr, subt1, subt2, subt3, subt4));

   231 	TEST2(err, KErrNone);

   233 	err = TheDb.Exec(_L8("COMMIT"));

   234 	TEST(err >= 0);

   236 	t2.HomeTime();

   237 	totalTime = t2.MicroSecondsFrom(t1);

   239 	writeTime = subt2.MicroSecondsFrom(subt1);

   240 	commitTime = subt4.MicroSecondsFrom(subt3);

   242 	PrintWriteTime(totalTime, writeTime, commitTime);

   244 	delete data;

   245 	}

   247 void InsertBlobExec()

   248 	{

   249 	HBufC8* buf = HBufC8::New(TheBlobSize * 2 + 100);

   250 	TEST(buf != NULL);

   251 	TPtr8 sql = buf->Des();

   252 	_LIT8(KStr, "INSERT INTO A VALUES(x'");

   253 	sql.SetLength(TheBlobSize * 2 + KStr().Length());

   254 	sql.Fill(TChar('A'));

   255 	sql.Replace(0, KStr().Length(), KStr);

   256 	sql.Append(_L8("')"));

   258 	TTime t1, t2;

   260 	t1.HomeTime();

   261 	TInt err = TheDb.Exec(sql);

   262 	t2.HomeTime();

   263 	TEST2(err, 1);

   265 	TTimeIntervalMicroSeconds totalTime = t2.MicroSecondsFrom(t1);

   267 	PrintWriteTime(totalTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   269 	delete buf;

   270 	}

   272 void InsertBlobBindStreamPrm()

   273 	{

   274 	HBufC8* data = HBufC8::New(TheBlobSize);

   275 	TEST(data != NULL);

   276 	TPtr8 dataptr = data->Des();

   277 	dataptr.SetLength(TheBlobSize);

   278 	dataptr.Fill(TChar('A'));

   280 	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

   282 	TTime t1, t2, t3, t4, t5, t6;

   283 	t1.HomeTime();

   285 	RSqlStatement stmt;

   286 	TInt err = stmt.Prepare(TheDb, _L8("INSERT INTO A VALUES(:Prm)"));

   287 	TEST2(err, KErrNone);

   289 	RSqlParamWriteStream strm;

   290 	err = strm.BindBinary(stmt, 0);

   291 	TEST2(err, KErrNone);

   293 	t3.HomeTime();

   294 	TRAP(err, strm.WriteL(dataptr));

   295 	t4.HomeTime();

   296 	TEST2(err, KErrNone);

   298 	t5.HomeTime();

   299 	TRAP(err, strm.CommitL());

   300 	t6.HomeTime();

   301 	TEST2(err, KErrNone);

   303 	err = stmt.Exec();

   305 	strm.Close();

   306 	stmt.Close();

   308 	t2.HomeTime();

   309 	TEST2(err, 1);

   311 	totalTime = t2.MicroSecondsFrom(t1);

   313 	writeTime = t4.MicroSecondsFrom(t3);

   314 	commitTime = t6.MicroSecondsFrom(t5);

   316 	PrintWriteTime(totalTime, writeTime, commitTime);

   318 	delete data;

   319 	}

   321 void UpdateBlobIncr()

   322 	{

   323 	HBufC8* data = HBufC8::New(TheBlobSize);

   324 	TEST(data != NULL);

   325 	TPtr8 dataptr = data->Des();

   326 	dataptr.SetLength(TheBlobSize);

   327 	dataptr.Fill(TChar('A'));

   329 	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

   331 	TTime t1, t2, subt1, subt2, subt3, subt4;

   332 	t1.HomeTime();

   334 	TInt err = TheDb.Exec(_L8("BEGIN"));

   335 	TEST(err >= 0);

   337 	TRAP(err, DoWriteBlobIncrL(dataptr, subt1, subt2, subt3, subt4));

   338 	TEST2(err, KErrNone);

   340 	err = TheDb.Exec(_L8("COMMIT"));

   341 	TEST(err >= 0);

   343 	t2.HomeTime();

   344 	totalTime = t2.MicroSecondsFrom(t1);

   346 	writeTime = subt2.MicroSecondsFrom(subt1);

   347 	commitTime = subt4.MicroSecondsFrom(subt3);

   349 	PrintWriteTime(totalTime, writeTime, commitTime);

   351 	delete data;

   352 	}

   354 void UpdateBlobExec()

   355 	{

   356 	HBufC8* buf = HBufC8::New(TheBlobSize * 2 + 100);

   357 	TEST(buf != NULL);

   358 	TPtr8 sql = buf->Des();

   359 	_LIT8(KStr, "UPDATE A SET B=x'");

   360 	sql.SetLength(TheBlobSize * 2 + KStr().Length());

   361 	sql.Fill(TChar('B'));

   362 	sql.Replace(0, KStr().Length(), KStr);

   363 	sql.Append(_L8("'"));

   365 	TTime t1, t2;

   366 	t1.HomeTime();

   367 	TInt err = TheDb.Exec(sql);

   368 	t2.HomeTime();

   369 	TEST2(err, 1);

   371 	TTimeIntervalMicroSeconds totalTime = t2.MicroSecondsFrom(t1);

   373 	PrintWriteTime(totalTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

   375 	delete buf;

   376 	}

   378 void UpdateBlobBindStreamPrm()

   379 	{

   380 	HBufC8* data = HBufC8::New(TheBlobSize);

   381 	TEST(data != NULL);

   382 	TPtr8 dataptr = data->Des();

   383 	dataptr.SetLength(TheBlobSize);

   384 	dataptr.Fill(TChar('B'));

   386 	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

   388 	TTime t1, t2, t3, t4, t5, t6;

   389 	t1.HomeTime();

   391 	RSqlStatement stmt;

   392 	TInt err = stmt.Prepare(TheDb, _L8("UPDATE A SET B=(:Prm)"));

   393 	TEST2(err, KErrNone);

   395 	RSqlParamWriteStream strm;

   396 	err = strm.BindBinary(stmt, 0);

   397 	TEST2(err, KErrNone);

   399 	t3.HomeTime();;

   400 	TRAP(err, strm.WriteL(dataptr));

   401 	t4.HomeTime();

   402 	TEST2(err, KErrNone);

   404 	t5.HomeTime();

   405 	TRAP(err, strm.CommitL());

   406 	t6.HomeTime();

   407 	TEST2(err, KErrNone);

   409 	err = stmt.Exec();

   411 	strm.Close();

   412 	stmt.Close();

   414 	t2.HomeTime();

   415 	TEST2(err, 1);

   417 	totalTime = t2.MicroSecondsFrom(t1);

   419 	writeTime = t4.MicroSecondsFrom(t3);

   420 	commitTime = t6.MicroSecondsFrom(t5);

   422 	PrintWriteTime(totalTime, writeTime, commitTime);

   424 	delete data;

   425 	}

   427 /**

   428 @SYMTestCaseID			SYSLIB-SQL-UT-4084

   429 @SYMTestCaseDesc		SQL, BLOB write, performance tests.

   430 						Tests insertion and updates of BLOBs using the old

   431 						APIs and the new RSqlBlobWriteStream APIs.

   432 @SYMTestPriority		Medium

   433 @SYMTestActions			Insertion and updates of blobs using the old and new APIs.

   434 @SYMTestExpectedResults Test must not fail

   435 @SYMREQ					REQ5912

   436 */

   437 void BlobWriteTest()

   438 	{

   439 	TheTest.Printf(_L("Blob size=%d Kb\r\n"), TheBlobSize / 1024);

   441 	//Insert a blob

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

   444 	CreateTestDb();

   445 	TheTest.Printf(_L("INSERT zeroblob - RSqlDatabase::Exec()\r\n"));

   446 	PrintFileSize(TheDb);

   447 	InsertZeroBlob(ETrue);

   448 	PrintFileSize(TheDb);

   449 	TheDb.Close();

   450 	(void)RSqlDatabase::Delete(TheDbFileName);

   452 	CreateTestDb();

   453 	TheTest.Printf(_L("INSERT blob - RSqlParamWriteStream\r\n"));

   454 	PrintFileSize(TheDb);

   455 	InsertBlobBindStreamPrm();

   456 	PrintFileSize(TheDb);

   457 	TheDb.Close();

   458 	(void)RSqlDatabase::Delete(TheDbFileName);

   460 	CreateTestDb();

   461 	TheTest.Printf(_L("INSERT blob - RSqlDatabase::Exec()\r\n"));

   462 	PrintFileSize(TheDb);

   463 	InsertBlobExec();

   464 	PrintFileSize(TheDb);

   465 	TheDb.Close();

   466 	(void)RSqlDatabase::Delete(TheDbFileName);

   468 	CreateTestDb();

   469 	TheTest.Printf(_L("INSERT blob - RSqlBlobWriteStream + transaction\r\n"));

   470 	PrintFileSize(TheDb);

   471 	InsertBlobIncr();

   472 	PrintFileSize(TheDb);

   473 	TheDb.Close();

   474 	(void)RSqlDatabase::Delete(TheDbFileName);

   476 	// Update a blob

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

   479 	CreateTestDb();

   480 	TheTest.Printf(_L("UPDATE zeroblob - RSqlParamWriteStream\r\n"));

   481 	PrintFileSize(TheDb);

   482 	InsertZeroBlob();

   483 	UpdateBlobBindStreamPrm();

   484 	PrintFileSize(TheDb);

   485 	TheDb.Close();

   486 	(void)RSqlDatabase::Delete(TheDbFileName);

   488 	CreateTestDb();

   489 	TheTest.Printf(_L("UPDATE blob - RSqlParamWriteStream\r\n"));

   490 	PrintFileSize(TheDb);

   491 	InsertRealBlob();

   492 	UpdateBlobBindStreamPrm();

   493 	PrintFileSize(TheDb);

   494 	TheDb.Close();

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

   497 	CreateTestDb();

   498 	TheTest.Printf(_L("UPDATE zeroblob - RSqlDatabase::Exec()\r\n"));

   499 	PrintFileSize(TheDb);

   500 	InsertZeroBlob();

   501 	UpdateBlobExec();

   502 	PrintFileSize(TheDb);

   503 	TheDb.Close();

   504 	(void)RSqlDatabase::Delete(TheDbFileName);

   506 	CreateTestDb();

   507 	TheTest.Printf(_L("UPDATE blob - RSqlDatabase::Exec()\r\n"));

   508 	PrintFileSize(TheDb);

   509 	InsertRealBlob();

   510 	UpdateBlobExec();

   511 	PrintFileSize(TheDb);

   512 	TheDb.Close();

   513 	(void)RSqlDatabase::Delete(TheDbFileName);

   515 	CreateTestDb();

   516 	TheTest.Printf(_L("UPDATE zeroblob - RSqlBlobWriteStream + transaction\r\n"));

   517 	PrintFileSize(TheDb);

   518 	InsertZeroBlob();

   519 	UpdateBlobIncr();

   520 	PrintFileSize(TheDb);

   521 	TheDb.Close();

   522 	(void)RSqlDatabase::Delete(TheDbFileName);

   524 	CreateTestDb();

   525 	TheTest.Printf(_L("UPDATE blob - RSqlBlobWriteStream + transaction\r\n"));

   526 	PrintFileSize(TheDb);

   527 	InsertRealBlob();

   528 	UpdateBlobIncr();

   529 	PrintFileSize(TheDb);

   530 	TheDb.Close();

   531 	(void)RSqlDatabase::Delete(TheDbFileName);

   532 	}

   534 void DoReadBlobIncrL(TDes8& aDes, TInt aMaxLength)

   535 	{

   536 	TTime t1, t2, t3, t4;

   538 	TTimeIntervalMicroSeconds openTime, readTime;

   540 	RSqlBlobReadStream strm;

   541 	CleanupClosePushL(strm);

   543 	t1.HomeTime();

   544 	strm.OpenL(TheDb, _L("A"), _L("B"), 1);

   545 	t2.HomeTime();

   547 	openTime = t2.MicroSecondsFrom(t1);

   549 	t3.HomeTime();

   550 	strm.ReadL(aDes, aMaxLength);

   551 	t4.HomeTime();

   553 	readTime = t4.MicroSecondsFrom(t3);

   555 	PrintReadTime(openTime, readTime);

   557 	CleanupStack::PopAndDestroy(&strm);

   558 	}

   560 void ReadBlobIncr()

   561 	{

   562 	HBufC8* data = HBufC8::New(TheBlobSize);

   563 	TEST(data != NULL);

   564 	TPtr8 dataptr = data->Des();

   566 	TRAPD(err, DoReadBlobIncrL(dataptr, TheBlobSize));

   567 	TEST2(err, KErrNone);

   568 	TEST2(dataptr.Length(), TheBlobSize);

   570 	delete data;

   571 	}

   573 void ReadBlobColDes()

   574 	{

   575 	HBufC8* data = HBufC8::New(TheBlobSize);

   576 	TEST(data != NULL);

   577 	TPtr8 dataptr = data->Des();

   579 	TTime t1, t2, t3, t4, t5, t6;

   580 	TTimeIntervalMicroSeconds prepareTime, nextTime, readTime;

   582 	RSqlStatement stmt;

   583 	t1.HomeTime();

   584 	TInt err = stmt.Prepare(TheDb, _L8("SELECT B FROM A WHERE ROWID=1"));

   585 	t2.HomeTime();

   586 	TEST2(err, KErrNone);

   587 	prepareTime = t2.MicroSecondsFrom(t1);

   589 	t3.HomeTime();

   590 	err = stmt.Next();

   591 	t4.HomeTime();

   592 	TEST2(err, KSqlAtRow);

   593 	nextTime = t4.MicroSecondsFrom(t3);

   595 	t5.HomeTime();

   596 	err = stmt.ColumnBinary(0, dataptr);

   597 	t6.HomeTime();

   598 	TEST2(err, KErrNone);

   599 	TEST2(dataptr.Length(), TheBlobSize);

   600 	readTime = t6.MicroSecondsFrom(t5);

   602 	PrintReadTime(prepareTime, nextTime, readTime);

   603 	stmt.Close();

   605 	delete data;

   606 	}

   608 void ReadBlobColPtr()

   609 	{

   610 	TTime t1, t2, t3, t4, t5, t6;

   611 	TTimeIntervalMicroSeconds prepareTime, nextTime, readTime;

   613 	RSqlStatement stmt;

   614 	t1.HomeTime();

   615 	TInt err = stmt.Prepare(TheDb, _L8("SELECT B FROM A WHERE ROWID=1"));

   616 	t2.HomeTime();

   617 	TEST2(err, KErrNone);

   618 	prepareTime = t2.MicroSecondsFrom(t1);

   620 	t3.HomeTime();

   621 	err = stmt.Next();

   622 	t4.HomeTime();

   623 	TEST2(err, KSqlAtRow);

   624 	nextTime = t4.MicroSecondsFrom(t3);

   626 	TPtrC8 data;

   627 	t5.HomeTime();

   628 	err = stmt.ColumnBinary(0, data);

   629 	t6.HomeTime();

   630 	TEST2(err, KErrNone);

   631 	TEST2(data.Length(), TheBlobSize);

   632 	readTime = t6.MicroSecondsFrom(t5);

   634 	PrintReadTime(prepareTime, nextTime, readTime);

   635 	stmt.Close();

   636 	}

   638 void ReadBlobStreamCol()

   639 	{

   640 	HBufC8* data = HBufC8::New(TheBlobSize);

   641 	TEST(data != NULL);

   642 	TPtr8 dataptr = data->Des();

   644 	TTime t1, t2, t3, t4, t5, t6;

   645 	TTimeIntervalMicroSeconds prepareTime, nextTime, readTime;

   647 	RSqlStatement stmt;

   648 	t1.HomeTime();

   649 	TInt err = stmt.Prepare(TheDb, _L8("SELECT B FROM A WHERE ROWID=1"));

   650 	t2.HomeTime();

   651 	TEST2(err, KErrNone);

   652 	prepareTime = t2.MicroSecondsFrom(t1);

   654 	t3.HomeTime();

   655 	err = stmt.Next();

   656 	t4.HomeTime();

   657 	TEST2(err, KSqlAtRow);

   658 	nextTime = t4.MicroSecondsFrom(t3);

   660 	RSqlColumnReadStream strm;

   661 	t5.HomeTime();

   662 	err = strm.ColumnBinary(stmt, 0);

   663 	TEST2(err, KErrNone);

   664 	TRAP(err, strm.ReadL(dataptr, TheBlobSize));

   665 	t6.HomeTime();

   666 	TEST2(err, KErrNone);

   667 	TEST2(dataptr.Length(), TheBlobSize);

   668 	readTime = t6.MicroSecondsFrom(t5);

   670 	strm.Close();

   671 	stmt.Close();

   673 	PrintReadTime(prepareTime, nextTime, readTime);

   675 	delete data;

   676 	}

   678 /**

   679 @SYMTestCaseID			SYSLIB-SQL-UT-4085

   680 @SYMTestCaseDesc		SQL, BLOB read, performance tests.

   681 						Tests retrieval of BLOBs using the old

   682 						APIs and the new RSqlBlobReadStream APIs.

   683 @SYMTestPriority		Medium

   684 @SYMTestActions			Retrieval of blobs using the old and new APIs.

   685 @SYMTestExpectedResults Test must not fail

   686 @SYMREQ					REQ5912

   687 */

   688 void BlobReadTest()

   689 	{

   690 	TheTest.Printf(_L("Blob size=%d Kb\r\n"), TheBlobSize / 1024);

   692 	// Insert a blob

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

   694 	TheTest.Printf(_L("Insert blob\r\n"));

   696 	CreateTestDb();

   697 	PrintFileSize(TheDb);

   698 	InsertBlobExec();

   699 	PrintFileSize(TheDb);

   700 	TheDb.Close();

   702 	// Read the blob

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

   705 	TheTest.Printf(_L("Read blob - RSqlBlobReadStream\r\n"));

   706 	TInt err = TheDb.Open(TheDbFileName);

   707 	TEST2(err, KErrNone);

   708 	ReadBlobIncr();

   709 	TheDb.Close();

   711 	TheTest.Printf(_L("Read blob - RSqlStatement::ColumnBinary(TInt, TDes8&)\r\n"));

   712 	err = TheDb.Open(TheDbFileName);

   713 	TEST2(err, KErrNone);

   714 	ReadBlobColDes();

   715 	TheDb.Close();

   717 	TheTest.Printf(_L("Read blob - RSqlStatement::ColumnBinary(TInt, TPtrC8&)\r\n"));

   718 	err = TheDb.Open(TheDbFileName);

   719 	TEST2(err, KErrNone);

   720 	ReadBlobColPtr();

   721 	TheDb.Close();

   723 	TheTest.Printf(_L("Read blob - RSqlColumnReadStream\r\n"));

   724 	err = TheDb.Open(TheDbFileName);

   725 	TEST2(err, KErrNone);

   726 	ReadBlobStreamCol();

   727 	TheDb.Close();

   729 	(void)RSqlDatabase::Delete(TheDbFileName);

   730 	}

   732 /**

   733 @SYMTestCaseID			SYSLIB-SQL-UT-4115

   734 @SYMTestCaseDesc		SQL, sequential BLOB writes, performance tests.

   735 						Tests sequentially writing 32Kb blocks to a 1.125Mb blob

   736 						using the new RSqlBlobWriteStream APIs to examine

   737 					    the write performance at different stages in the

   738 						sequence.

   739 @SYMTestPriority		Medium

   740 @SYMTestActions			Sequential writing of a blob using the new RSqlBlobWriteStream APIs.

   741 @SYMTestExpectedResults Test must not fail

   742 @SYMREQ					REQ5912

   743 */

   744 void SequentialWriteTestL()

   745 	{

   746 	const TInt KBufLen = 32768; // 32Kb

   747 	HBufC8* buf = HBufC8::NewL(KBufLen);

   748 	TPtr8 dataPtr =	buf->Des();

   749 	dataPtr.SetLength(KBufLen);

   750 	dataPtr.Fill('A', KBufLen);

   752 	CreateTestDb();

   753 	InsertZeroBlob(); // insert zeroblob of "TheBlobSize" size

   755 	RSqlBlobWriteStream strm;

   756 	strm.OpenL(TheDb, _L("A"), _L("B"));

   758 	// Sequentially write 32Kb blocks of data to the

   759 	// blob until the 1Mb cache is full and writes to the disk begin.

   760 	// 32 * 32Kb = 1Mb = soft heap limit

   761 	const TInt KItCount = TheBlobSize / KBufLen - 1;

   762 	for(TInt i = 1; i <= KItCount; ++i)

   763 		{

   764 		TheTest.Printf(_L("***Iteration %d\r\n"), i);

   766 		PrintFileSize(TheDb);

   768 		TTimeIntervalMicroSeconds writeTime;

   769 		TTime t1, t2;

   771 		t1.HomeTime();

   772 		strm.WriteL(dataPtr);

   773 		t2.HomeTime();

   775 		writeTime = t2.MicroSecondsFrom(t1);

   777 		PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));

   778 		PrintFileSize(TheDb);

   779 		}

   781 	TTimeIntervalMicroSeconds commitTime;

   782 	TTime t3, t4;

   783 	t3.HomeTime();

   784 	strm.CommitL();

   785 	t4.HomeTime();

   786 	commitTime = t4.MicroSecondsFrom(t3);

   788 	PrintWriteTime(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0), commitTime);

   789 	PrintFileSize(TheDb);

   791 	strm.Close();

   792 	TheDb.Close();

   793 	(void)RSqlDatabase::Delete(TheDbFileName);

   795 	delete buf;

   796 	}

   798 /**

   799 @SYMTestCaseID			SYSLIB-SQL-UT-4116

   800 @SYMTestCaseDesc		SQL, transaction sequential BLOB writes, performance tests.

   801 						Tests sequentially writing 32Kb blocks to a 1.125Mb blob

   802 						within a transaction, using the new RSqlBlobWriteStream APIs,

   803 						to examine the write performance at different stages in the

   804 						sequence.

   805 @SYMTestPriority		Medium

   806 @SYMTestActions			Sequential writing of a blob within a transactions, using the

   807 						new RSqlBlobWriteStream APIs.

   808 @SYMTestExpectedResults Test must not fail

   809 @SYMREQ					REQ5912

   810 */

   811 void TransSequentialWriteTestL()

   812 	{

   813 	const TInt KBufLen = 32768; // 32Kb

   814 	HBufC8* buf = HBufC8::NewL(KBufLen);

   815 	TPtr8 dataPtr =	buf->Des();

   816 	dataPtr.SetLength(KBufLen);

   817 	dataPtr.Fill('A', KBufLen);

   819 	CreateTestDb();

   820 	InsertZeroBlob(); // insert zeroblob of "TheBlobSize" size

   822 	RSqlBlobWriteStream strm;

   823 	strm.OpenL(TheDb, _L("A"), _L("B"));

   825 	TInt err = TheDb.Exec(_L8("BEGIN"));

   826 	TEST(err >= 0);

   828 	// Sequentially write 32Kb blocks of data to the

   829 	// blob until the 1Mb cache is full and writes to the disk begin.

   830 	// 32 * 32Kb = 1Mb = soft heap limit

   831 	const TInt KItCount = TheBlobSize / KBufLen - 1;

   832 	for(TInt i = 1; i <= KItCount; ++i)

   833 		{

   834 		TheTest.Printf(_L("***Iteration %d\r\n"), i);

   836 		PrintFileSize(TheDb);

   838 		TTimeIntervalMicroSeconds writeTime;

   839 		TTime t1, t2;

   841 		t1.HomeTime();

   842 		strm.WriteL(dataPtr);

   843 		t2.HomeTime();

   845 		writeTime = t2.MicroSecondsFrom(t1);

   847 		PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));

   848 		PrintFileSize(TheDb);

   849 		}

   851 	TTimeIntervalMicroSeconds commitTime;

   852 	TTime t3, t4;

   854 	t3.HomeTime();

   855 	strm.CommitL();

   856 	t4.HomeTime();

   857 	commitTime = t4.MicroSecondsFrom(t3);

   859 	PrintWriteTime(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0), commitTime);

   860 	PrintFileSize(TheDb);

   862 	TTime t5, t6;

   863 	t5.HomeTime();

   864 	err = TheDb.Exec(_L8("COMMIT"));

   865 	t6.HomeTime();

   866 	TEST(err >= 0);

   868 	TTimeIntervalMicroSeconds transCommitTime = t6.MicroSecondsFrom(t5);

   869 	PrintWriteTime(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0), transCommitTime);

   870 	PrintFileSize(TheDb);

   872 	strm.Close();

   873 	TheDb.Close();

   874 	(void)RSqlDatabase::Delete(TheDbFileName);

   876 	delete buf;

   877 	}

   879 /**

   880 @SYMTestCaseID			SYSLIB-SQL-UT-4117

   881 @SYMTestCaseDesc		SQL, whole BLOB write, performance tests.

   882 						Tests writing a 256Kb data block to a 256Kb blob to examine the

   883 						relative performance of the TSqlBlob and RSqlBlobWriteStream APIs.

   884 @SYMTestPriority		Medium

   885 @SYMTestActions			Whole update of a blob using the new TSqlBlob and RSqlBlobWriteStream APIs.

   886 @SYMTestExpectedResults Test must not fail

   887 @SYMREQ					REQ5912

   888 */

   889 void WholeWriteTestL()

   890 	{

   891 	TInt bufLen = TheBlobSize;

   892 	HBufC8* buf = HBufC8::NewL(bufLen);

   893 	TPtr8 dataPtr =	buf->Des();

   894 	dataPtr.SetLength(bufLen);

   895 	dataPtr.Fill('Z', bufLen);

   897 	CreateTestDb();

   898 	InsertRealBlob(); // insert blob of "TheBlobSize" size

   900 	TheTest.Printf(_L("***WholeWriteTestL - %dKb blob \r\n"), TheBlobSize / 1024);

   901 	PrintFileSize(TheDb);

   903 	// TSqlBlob::Set

   904 	TTimeIntervalMicroSeconds writeTime;

   905 	TTime t1, t2, t3, t4;

   907 	t1.HomeTime();

   908 	TSqlBlob::SetL(TheDb, _L("A"), _L("B"), dataPtr);

   909 	t2.HomeTime();

   911 	writeTime = t2.MicroSecondsFrom(t1);

   913 	PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));

   914 	PrintFileSize(TheDb);

   916 	// to avoid caching issues, close and re-create the database for the next part

   917 	TheDb.Close();

   918 	(void)RSqlDatabase::Delete(TheDbFileName);

   919 	CreateTestDb();

   920 	InsertRealBlob(); // insert blob of "TheBlobSize" size

   921 	PrintFileSize(TheDb);

   923 	// RSqlBlobWriteStream::WriteL

   924 	t3.HomeTime();

   925 	RSqlBlobWriteStream strm;

   926 	CleanupClosePushL(strm);

   927 	strm.OpenL(TheDb, _L("A"), _L("B"));

   928 	strm.WriteL(dataPtr);

   929 	CleanupStack::PopAndDestroy(&strm);

   930 	t4.HomeTime();

   932 	writeTime = t4.MicroSecondsFrom(t3);

   934 	PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));

   935 	PrintFileSize(TheDb);

   937 	TheDb.Close();

   938 	(void)RSqlDatabase::Delete(TheDbFileName);

   940 	delete buf;

   941 	}

   943 /**

   944 @SYMTestCaseID			SYSLIB-SQL-UT-4118

   945 @SYMTestCaseDesc		SQL, transaction whole BLOB write, performance tests.

   946 						Tests writing a 256Kb data block to a 256Kb blob, within a transaction,

   947 						to examine the relative performance of the TSqlBlob and RSqlBlobWriteStream APIs.

   948 @SYMTestPriority		Medium

   949 @SYMTestActions			Whole update of a blob, within a transaction, using the new TSqlBlob and

   950 						RSqlBlobWriteStream APIs.

   951 @SYMTestExpectedResults Test must not fail

   952 @SYMREQ					REQ5912

   953 */

   954 void TransWholeWriteTestL()

   955 	{

   956 	TInt bufLen = TheBlobSize;

   957 	HBufC8* buf = HBufC8::NewL(bufLen);

   958 	TPtr8 dataPtr =	buf->Des();

   959 	dataPtr.SetLength(bufLen);

   960 	dataPtr.Fill('Z', bufLen);

   962 	CreateTestDb();

   963 	InsertRealBlob(); // insert blob of "TheBlobSize" size

   965 	TheTest.Printf(_L("***TransWholeWriteTestL - %dKb blob\r\n"), TheBlobSize / 1024);

   966 	PrintFileSize(TheDb);

   968 	// TSqlBlob::Set

   969 	TTimeIntervalMicroSeconds writeTime;

   970 	TTime t1, t2, t3, t4;

   972 	t1.HomeTime();

   973 	TInt err = TheDb.Exec(_L8("BEGIN"));

   974 	TEST(err >= 0);

   975 	TSqlBlob::SetL(TheDb, _L("A"), _L("B"), dataPtr);

   976 	err = TheDb.Exec(_L8("COMMIT"));

   977 	t2.HomeTime();

   978 	TEST(err >= 0);

   980 	writeTime = t2.MicroSecondsFrom(t1);

   982 	PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));

   983 	PrintFileSize(TheDb);

   985 	// to avoid caching issues, close and re-create the database for the next part

   986 	TheDb.Close();

   987 	(void)RSqlDatabase::Delete(TheDbFileName);

   988 	CreateTestDb();

   989 	InsertRealBlob(); // insert blob of "TheBlobSize" size

   990 	PrintFileSize(TheDb);

   992 	// RSqlBlobWriteStream::WriteL

   993 	t3.HomeTime();

   994 	err = TheDb.Exec(_L8("BEGIN"));

   995 	TEST(err >= 0);

   996 	RSqlBlobWriteStream strm;

   997 	CleanupClosePushL(strm);

   998 	strm.OpenL(TheDb, _L("A"), _L("B"));

   999 	strm.WriteL(dataPtr);

  1000 	CleanupStack::PopAndDestroy(&strm);

  1001 	err = TheDb.Exec(_L8("COMMIT"));

  1002 	t4.HomeTime();

  1003 	TEST(err >= 0);

  1005 	writeTime = t4.MicroSecondsFrom(t3);

  1007 	PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));

  1008 	PrintFileSize(TheDb);

  1010 	TheDb.Close();

  1011 	(void)RSqlDatabase::Delete(TheDbFileName);

  1013 	delete buf;

  1014 	}

  1016 /**

  1017 @SYMTestCaseID			SYSLIB-SQL-UT-4119

  1018 @SYMTestCaseDesc		SQL, whole BLOB read, performance tests.

  1019 						Tests reading a 256Kb blob in one block to examine the

  1020 						relative performance of the TSqlBlob and RSqlBlobReadStream APIs.

  1021 @SYMTestPriority		Medium

  1022 @SYMTestActions			Whole retrieval of a blob using the new TSqlBlob and RSqlBlobReadStream APIs.

  1023 @SYMTestExpectedResults Test must not fail

  1024 @SYMREQ					REQ5912

  1025 */

  1026 void WholeReadTestL()

  1027 	{

  1028 	TInt bufLen = TheBlobSize;

  1029 	HBufC8* buf = HBufC8::NewL(bufLen);

  1030 	TPtr8 dataPtr =	buf->Des();

  1031 	dataPtr.SetLength(bufLen);

  1032 	dataPtr.Fill('A', bufLen);

  1034 	CreateTestDb();

  1035 	InsertRealBlob(); // insert blob of "TheBlobSize" size

  1037 	TheTest.Printf(_L("***WholeReadTestL - %dKb blob \r\n"), TheBlobSize / 1024);

  1038 	PrintFileSize(TheDb);

  1040 	// TSqlBlob::GetLC

  1041 	TTimeIntervalMicroSeconds readTime;

  1042 	TTime t1, t2, t3, t4, t5, t6;

  1044 	t1.HomeTime();

  1045 	HBufC8* readBuf = TSqlBlob::GetLC(TheDb, _L("A"), _L("B"));

  1046 	t2.HomeTime();

  1047 	TEST(readBuf->Des().Compare(buf->Des()) == 0);

  1049 	readTime = t2.MicroSecondsFrom(t1);

  1051 	PrintReadTime(TTimeIntervalMicroSeconds(0), readTime);

  1052 	PrintFileSize(TheDb);

  1053 	CleanupStack::PopAndDestroy(readBuf);

  1055 	// to avoid caching issues, close and re-create the database for the next part

  1056 	TheDb.Close();

  1057 	(void)RSqlDatabase::Delete(TheDbFileName);

  1058 	CreateTestDb();

  1059 	InsertRealBlob(); // insert blob of "TheBlobSize" size

  1060 	PrintFileSize(TheDb);

  1062 	// TSqlBlob::Get

  1063 	HBufC8* preBuf = HBufC8::NewLC(bufLen);

  1064 	TPtr8 preBufPtr(preBuf->Des());

  1065 	t3.HomeTime();

  1066 	TInt err = TSqlBlob::Get(TheDb, _L("A"), _L("B"), preBufPtr);

  1067 	t4.HomeTime();

  1068 	TEST2(err, KErrNone);

  1069 	TEST(preBufPtr.Compare(buf->Des()) == 0);

  1071 	readTime = t4.MicroSecondsFrom(t3);

  1073 	PrintReadTime(TTimeIntervalMicroSeconds(0), readTime);

  1074 	PrintFileSize(TheDb);

  1075 	CleanupStack::PopAndDestroy(preBuf);

  1077 	// to avoid caching issues, close and re-create the database for the next part

  1078 	TheDb.Close();

  1079 	(void)RSqlDatabase::Delete(TheDbFileName);

  1080 	CreateTestDb();

  1081 	InsertRealBlob(); // insert blob of "TheBlobSize" size

  1082 	PrintFileSize(TheDb);

  1084 	// RSqlBlobReadStream::ReadL

  1085 	preBuf = HBufC8::NewLC(bufLen);

  1086 	TPtr8 preBufP(preBuf->Des());

  1087 	t5.HomeTime();

  1088 	RSqlBlobReadStream strm;

  1089 	CleanupClosePushL(strm);

  1090 	strm.OpenL(TheDb, _L("A"), _L("B"));

  1091 	strm.ReadL(preBufP, bufLen);

  1092 	CleanupStack::PopAndDestroy(&strm);

  1093 	t6.HomeTime();

  1094 	TEST(preBufP.Compare(buf->Des()) == 0);

  1096 	readTime = t6.MicroSecondsFrom(t5);

  1098 	PrintReadTime(TTimeIntervalMicroSeconds(0), readTime);

  1099 	PrintFileSize(TheDb);

  1100 	CleanupStack::PopAndDestroy(preBuf);

  1102 	TheDb.Close();

  1103 	(void)RSqlDatabase::Delete(TheDbFileName);

  1105 	delete buf;

  1106 	}

  1107 ///////////////////////////////////////////////////////////////////////////////////

  1108 ///////////////////////////////////////////////////////////////////////////////////

  1110 void DoTests()

  1111 	{

  1112 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4084 SQL, BLOB write, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1113 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1114 	TheTest.Start(TheTestTitle);

  1115 	BlobWriteTest();

  1117 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4085 SQL, BLOB read, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1118 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1119 	TheTest.Next(TheTestTitle);

  1120 	BlobReadTest();

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

  1124 	// Bigger blob tests - only on hardware, release mode

  1125 #if !defined __WINS__ && !defined __WINSCW__ && !defined _DEBUG

  1127 	TheBlobSize = 1024 * 1024 + 128 * 1024;//1.125Mb

  1129 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4115 SQL, sequential BLOB writes, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1130 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1131 	TheTest.Next(TheTestTitle);

  1132 	TRAPD(err, SequentialWriteTestL());

  1133 	TEST2(err, KErrNone);

  1135 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4116 SQL, transaction sequential BLOB writes, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1136 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1137 	TheTest.Next(TheTestTitle);

  1138 	TRAP(err, TransSequentialWriteTestL());

  1139 	TEST2(err, KErrNone);

  1141 	TheBlobSize = 256 * 1024 ; // 256Kb

  1143 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4117 SQL, whole BLOB write, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1144 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1145 	TheTest.Next(TheTestTitle);

  1146 	TRAP(err, WholeWriteTestL());

  1147 	TEST2(err, KErrNone);

  1149 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4118 SQL, transaction whole BLOB write, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1150 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1151 	TheTest.Next(TheTestTitle);

  1152 	TRAP(err, TransWholeWriteTestL());

  1153 	TEST2(err, KErrNone);

  1155 	TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4119 SQL, whole BLOB read, performance tests, encoding: \"%S\", page size: %d\r\n"),

  1156 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);

  1157 	TheTest.Next(TheTestTitle);

  1158 	TRAP(err, WholeReadTestL());

  1159 	TEST2(err, KErrNone);

  1161 #endif//!defined __WINS__ && !defined __WINSCW__ && !defined _DEBUG

  1162 	}

  1164 TInt E32Main()

  1165 	{

  1166 	TheTest.Title();

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

  1169 	TheTest(tc != NULL);

  1171 	__UHEAP_MARK;

  1173 	GetCmdLineParamsAndSqlConfigString(TheTest, _L("t_sqlperformance2"), TheCmdLineParams, TheSqlConfigString);

  1174 	_LIT(KDbName, "c:\\test\\t_sqlperformance2.db");

  1175 	PrepareDbName(KDbName, TheCmdLineParams.iDriveName, TheDbFileName);

  1177 	TheTest.Printf(_L("==Databases: %S\r\n"), &TheDbFileName);

  1179 	TestEnvInit();

  1180 	DoTests();

  1181 	TestEnvDestroy();

  1183 	__UHEAP_MARKEND;

  1185 	TheTest.End();

  1186 	TheTest.Close();

  1188 	delete tc;

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

  1191 	return KErrNone;

  1192 	}

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