1 // Copyright (c) 2008-2009 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 //

    15 

    16 #include <e32test.h>

    17 #include <bautils.h>

    18 #include <sqldb.h>

    19 #include <s32file.h>

    20 

    21 RTest TheTest(_L("t_sqlblob test"));

    22 

    23 RSqlDatabase TheDb1;

    24 RSqlDatabase TheDb2;

    25 RSqlDatabase ThePrivateDb;

    26 

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

    28 _LIT(KTestDbName1, "c:\\test\\t_blob1.db");

    29 _LIT(KTestDbName2, "c:\\test\\t_blob2.db");

    30 _LIT(KAttachedDbName, "attached_db");

    31 _LIT(KPrivateSecureDb, "c:\\private\\1111C1CC\\ps.db"); 

    32 

    33 const TInt KLargeDataBufLen = 2048;

    34 

    35 // A buffer containing 2Kb of data.

    36 // When it is used to write to a blob the data will exceed the size of the client buffer

    37 // (which is 8 bytes in debug, 1.5Kb on target) and will be immediately transferred to the server

    38 TBuf8<KLargeDataBufLen> TheLargeData;

    39 

    40 ///////////////////////////////////////////////////////////////////////////////////////

    41 // Test database delete functions

    42 

    43 void DeleteTestDbs()

    44 	{

    45 	TheDb1.Close();

    46 	TheDb2.Close();

    47 	ThePrivateDb.Close();

    48 	(void)RSqlDatabase::Delete(KTestDbName1);

    49 	(void)RSqlDatabase::Delete(KTestDbName2);

    50 	(void)RSqlDatabase::Delete(KPrivateSecureDb);

    51 	}

    52 

    53 ///////////////////////////////////////////////////////////////////////////////////////

    54 // Test macros and functions

    55 

    56 void Check(TInt aValue, TInt aLine)

    57 	{

    58 	if(!aValue)

    59 		{

    60 		DeleteTestDbs();

    61 		TheTest(EFalse, aLine);

    62 		}

    63 	}

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

    65 	{

    66 	if(aValue != aExpected)

    67 		{

    68 		DeleteTestDbs();

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

    70 		TheTest(EFalse, aLine);

    71 		}

    72 	}

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

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

    75 

    76 ///////////////////////////////////////////////////////////////////////////////////////

    77 // Test database create functions

    78 

    79 void CreateTestDir()

    80     {

    81     RFs fs;

    82 	TInt err = fs.Connect();

    83 	TEST2(err, KErrNone);

    84 

    85 	err = fs.MkDir(KTestDir);

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

    87 

    88 	err = fs.CreatePrivatePath(EDriveC);	

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

    90 	

    91 	fs.Close();

    92 	}

    93 

    94 void CreateTestDbs()

    95 	{

    96 	// Create t_blob1.db

    97 	TInt err = TheDb1.Create(KTestDbName1);

    98 	TEST2(err, KErrNone);

    99 	

   100  	err = TheDb1.Exec(_L("CREATE TABLE table1(I INTEGER, T TEXT, B BLOB)"));	

   101 	TEST(err >= 0);	

   102 	

   103 	// Create t_blob2.db

   104 	err = TheDb2.Create(KTestDbName2);

   105 	TEST2(err, KErrNone);

   106 

   107 	err = TheDb2.Exec(_L("CREATE TABLE table2(int INTEGER, text TEXT, blob BLOB)"));	

   108 	TEST(err >= 0);

   109 		

   110 	// Insert a blob value of 'FGFGFGFGFG' (10 characters in size)		

   111 	err = TheDb2.Exec(_L("INSERT INTO table2 VALUES(1, 'Text Data', x'46474647464746474647')"));

   112 	TEST2(err, 1);	

   113 	

   114 	// Create private secure db

   115 	err = ThePrivateDb.Create(KPrivateSecureDb);

   116 	TEST2(err, KErrNone);

   117 	

   118 	err = ThePrivateDb.Exec(_L("CREATE TABLE table3(age INTEGER, name TEXT, picture BLOB)"));	

   119 	TEST(err >= 0);

   120 	

   121 	// Insert a blob value of 'ABABABABABABABA' (15 characters in size)		

   122 	err = ThePrivateDb.Exec(_L("INSERT INTO table3 VALUES(31, 'John Smith', x'414241424142414241424142414241')"));

   123 	TEST2(err, 1);		

   124 	}

   125 	

   126 void CreateIndices()

   127 	{

   128 	TInt err = TheDb1.Exec(_L("CREATE INDEX textIdx1 on table1(T)"));	

   129 	TEST(err >= 0);

   130 	err = TheDb1.Exec(_L("CREATE INDEX blobIdx1 on table1(B)"));	

   131 	TEST(err >= 0);

   132 	

   133 	err = TheDb2.Exec(_L("CREATE INDEX textIdx2 on table2(text)"));	

   134 	TEST(err >= 0);

   135 	err = TheDb2.Exec(_L("CREATE INDEX blobIdx2 on table2(blob)"));	

   136 	TEST(err >= 0);

   137 	}

   138 	

   139 void RemoveIndices()

   140 	{

   141 	TInt err = TheDb1.Exec(_L("DROP INDEX textIdx1"));	

   142 	TEST(err >= 0);

   143 	err = TheDb1.Exec(_L("DROP INDEX blobIdx1"));	

   144 	TEST(err >= 0);

   145 

   146 	err = TheDb2.Exec(_L("DROP INDEX textIdx2"));	

   147 	TEST(err >= 0);

   148 	err = TheDb2.Exec(_L("DROP INDEX blobIdx2"));	

   149 	TEST(err >= 0);

   150 	}

   151 		

   152 void AttachTestDb2()

   153 	{

   154 	TInt err = TheDb1.Attach(KTestDbName2, KAttachedDbName);

   155 	TEST2(err, KErrNone);

   156 	}

   157 	

   158 void FillLargeDataBuf(TChar aChar = 'Z')

   159 	{

   160 	TheLargeData.Fill(aChar, KLargeDataBufLen);	

   161 	}

   162 	

   163 ///////////////////////////////////////////////////////////////////////////////////////

   164 // Unit test functions

   165 

   166 void CheckBlobPropertiesL(TInt aBlobSize)

   167 	{

   168 	// Check properties of the last inserted blob 

   169 		

   170 	RSqlStatement stmt;

   171 	CleanupClosePushL(stmt);

   172 	TInt err = stmt.Prepare(TheDb1, _L("SELECT B FROM table1 WHERE ROWID == :Val"));

   173 	TEST2(err, KErrNone);

   174 	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));

   175 	TEST(paramIndex >= 0);	

   176 	err = stmt.BindInt(paramIndex, TheDb1.LastInsertedRowId());

   177 	TEST2(err, KErrNone);

   178 	err = stmt.Next();

   179 	TEST2(err, KSqlAtRow);

   180 	

   181 	// Check the 'declared column type' is ESqlBinary

   182 	TSqlColumnType declColType;

   183 	err = stmt.DeclaredColumnType(0, declColType);

   184 	TEST2(declColType, ESqlBinary);

   185 	// Check the 'runtime column type' is ESqlBinary

   186 	TSqlColumnType colType = stmt.ColumnType(0);

   187 	TEST2(colType, ESqlBinary);

   188 	// Check the 'column size' is the size of the blob

   189 	TInt blobSize = stmt.ColumnSize(0);

   190 	TEST2(blobSize, aBlobSize);

   191 	// Check the 'column value' is not 'NULL' (even for a zeroblob)

   192 	TBool isNull = stmt.IsNull(0);

   193 	TEST2(isNull, EFalse);

   194 	// Check the 'column value' can be retrieved as a binary value

   195 	TPtrC8 binaryPtr = stmt.ColumnBinaryL(0);

   196 	TEST2(binaryPtr.Length(), aBlobSize);

   197 	// Check the 'column value' cannot be retrieved as a text value (it is of type ESqlBinary)

   198 	TPtrC textptr = stmt.ColumnTextL(0);

   199 	TEST2(textptr.Length(), 0);	

   200 	CleanupStack::PopAndDestroy(&stmt);

   201 	}

   202 

   203 void InsertBindZeroBlob(TInt aBlobSize)

   204 	{

   205 	// Insert a record that has had a zeroblob bound to it

   206 	RSqlStatement stmt;

   207 	TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(1, 'some text', :Val)"));

   208 	TEST2(err, KErrNone);

   209 	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));

   210 	TEST(paramIndex >= 0);	

   211 	err = stmt.BindZeroBlob(paramIndex, aBlobSize);

   212 	TEST2(err, KErrNone);

   213 	err = stmt.Exec();

   214 	stmt.Close();

   215 	TEST2(err, 1);

   216 	}

   217 	

   218 void InsertSQLiteZeroBlob(TInt aBlobSize)

   219 	{		

   220 	// Insert a record that contains the 'zeroblob()' function

   221 	RSqlStatement stmt;

   222 	TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(2, 'more text', zeroblob(:Val))"));

   223 	TEST2(err, KErrNone);

   224 	TInt paramIndex = stmt.ParameterIndex(_L(":Val")); 

   225 	TEST(paramIndex >= 0);	

   226 	err = stmt.BindInt(paramIndex, aBlobSize);

   227 	TEST2(err, KErrNone);

   228 	err = stmt.Exec();

   229 	stmt.Close();

   230 	TEST2(err, 1);

   231 	}

   232 

   233 void InsertBlobValueL(TInt aBlobSize)

   234 	{	

   235 	// Insert a record that contains an actual blob value

   236 	HBufC8* binaryData = HBufC8::NewLC(aBlobSize);

   237 	TPtr8 binaryDataPtr(binaryData->Des());

   238 	for(TInt i = 0; i < aBlobSize/2; ++i)

   239 		{

   240 		binaryDataPtr.Append(_L8("DE"));

   241 		}

   242 		

   243 	RSqlStatement stmt;

   244 	CleanupClosePushL(stmt);

   245 	TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(3, 'even more text', :Val)"));

   246 	TEST2(err, KErrNone);

   247 	TInt paramIndex = stmt.ParameterIndex(_L(":Val")); 

   248 	TEST(paramIndex >= 0);	

   249 	err = stmt.BindBinary(paramIndex, binaryDataPtr);

   250 	TEST2(err, KErrNone);

   251 	err = stmt.Exec();

   252 	TEST2(err, 1);

   253 	CleanupStack::PopAndDestroy(2); // stmt, binaryData		

   254 	}	

   255 

   256 void StreamBlob1L(TInt aBlobSize) 

   257 	{	

   258 	// Blob 1 is a zeroblob of size aBlobSize

   259 	

   260 	// Read (zero) data from the blob

   261 	RSqlBlobReadStream rdStrm;

   262 	CleanupClosePushL(rdStrm);

   263 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   264 	TInt size = rdStrm.SizeL(); // check the blob's size

   265 	TEST2(size, aBlobSize); 

   266 	_LIT8(KFiveZeros, "\x0\x0\x0\x0\x0");

   267 	_LIT8(KTwentyZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");

   268 	TBuf8<50> data;

   269 	rdStrm.ReadL(data, 5);

   270 	TEST(data.Compare(KFiveZeros) == 0); // check 5 bytes of zero have been read

   271 	rdStrm.ReadL(data, 20);

   272 	TEST(data.Compare(KTwentyZeros) == 0);	// check 20 bytes of zero have been read

   273 	CleanupStack::PopAndDestroy(&rdStrm);

   274 	

   275 	// Write some actual data to the blob

   276 	RSqlBlobWriteStream wrStrm;

   277 	CleanupClosePushL(wrStrm);

   278 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   279 	size = wrStrm.SizeL(); // check the blob's size

   280 	TEST2(size, aBlobSize); 

   281 	wrStrm.WriteL(_L8("AABBCCDDEE")); // write 10 bytes

   282 	wrStrm.WriteL(_L8("FFGGHHIIJJ")); // write another 10 bytes

   283 	wrStrm.WriteL(_L8("KKLLMMNNOOPPQQRRSSTTUUVVWWXX")); // write another 28 bytes

   284 	wrStrm.CommitL();

   285 	CleanupStack::PopAndDestroy(&wrStrm);

   286 	

   287 	// Read back some of the blob data

   288 	CleanupClosePushL(rdStrm);

   289 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   290 	size = rdStrm.SizeL(); // check the blob's size

   291 	TEST2(size, aBlobSize);

   292 	rdStrm.ReadL(data, 4);

   293 	TEST(data.Compare(_L8("AABB")) == 0); // check the first 4 bytes

   294 	rdStrm.ReadL(data, 35);

   295 	TEST(data.Compare(_L8("CCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSST")) == 0); // check the next 35 bytes

   296 	rdStrm.ReadL(data, 19);

   297 	_LIT8(KTrailingZeros, "TUUVVWWXX\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); 

   298 	TEST(data.Compare(KTrailingZeros) == 0); // check the next 19 bytes (which includes some of the original zero bytes)

   299 	CleanupStack::PopAndDestroy(&rdStrm);

   300 	}

   301 

   302 void StreamText1L() 

   303 	{	

   304 	// Read data from the text column -

   305 	// the database encoding is UTF-16 so the text is stored as UTF-16

   306 	RSqlBlobReadStream rdStrm;

   307 	CleanupClosePushL(rdStrm);

   308 	rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));

   309 	TBuf<50> dataUTF16;

   310 	rdStrm.ReadL(dataUTF16, 9);

   311 	TEST(dataUTF16.Compare(_L("some text")) == 0); 

   312 	CleanupStack::PopAndDestroy(&rdStrm);

   313 	

   314 	// Write some data to the text column (as UTF-16)

   315 	RSqlBlobWriteStream wrStrm;

   316 	CleanupClosePushL(wrStrm);

   317 	wrStrm.OpenL(TheDb1, _L("table1"), _L("T"));

   318 	wrStrm.WriteL(_L("new text!")); // can only write up to the original size of the data - 9 chars

   319 	wrStrm.CommitL();

   320 	CleanupStack::PopAndDestroy(&wrStrm);

   321 	

   322 	// Read back some of the text (as UTF-16)

   323 	CleanupClosePushL(rdStrm);

   324 	rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));

   325 	rdStrm.ReadL(dataUTF16, 9);

   326 	TEST(dataUTF16.Compare(_L("new text!")) == 0);

   327 	CleanupStack::PopAndDestroy(&rdStrm);

   328 	

   329 	// Write some data to the text column (as UTF-8)

   330 	CleanupClosePushL(wrStrm);

   331 	wrStrm.OpenL(TheDb1, _L("table1"), _L("T"));

   332 	wrStrm.WriteL(_L8("try again"));

   333 	wrStrm.CommitL();

   334 	CleanupStack::PopAndDestroy(&wrStrm);

   335 	

   336 	// Read back some of the text (as UTF-8)

   337 	CleanupClosePushL(rdStrm);

   338 	rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));

   339 	TBuf8<50> dataUTF8;

   340 	rdStrm.ReadL(dataUTF8, 9);

   341 	TEST(dataUTF8.Compare(_L8("try again")) == 0);

   342 	CleanupStack::PopAndDestroy(&rdStrm);

   343 	}

   344 	

   345 void StreamBlob2L(TInt aBlobSize)

   346 	{

   347 	// Blob 2 is a zeroblob of size aBlobSize

   348 	

   349 	// Read (zero) data from the blob

   350 	RSqlBlobReadStream rdStrm;

   351 	CleanupClosePushL(rdStrm);

   352 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   353 	TInt size = rdStrm.SizeL(); // check the blob's size

   354 	TEST2(size, aBlobSize);

   355 	_LIT8(KFifteenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");

   356 	_LIT8(KSixtyOneZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");

   357 	TBuf8<200> data;

   358 	rdStrm.ReadL(data, 15);

   359 	TEST(data.Compare(KFifteenZeros) == 0); // check 15 bytes of zero have been read

   360 	rdStrm.ReadL(data, 61);

   361 	TEST(data.Compare(KSixtyOneZeros) == 0); // check 61 bytes of zero have been read

   362 	size = rdStrm.SizeL(); // check the blob's size

   363 	TEST2(size, aBlobSize); 

   364 	CleanupStack::PopAndDestroy(&rdStrm); 

   365 

   366 	// Write some actual data to the blob 

   367 	RSqlBlobWriteStream wrStrm;

   368 	CleanupClosePushL(wrStrm);

   369 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   370 	size = wrStrm.SizeL(); // check the blob's size

   371 	TEST2(size, aBlobSize);

   372 	wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATAS")); // write 23 bytes

   373 	wrStrm.WriteL(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATA")); // write another 43 bytes

   374 	wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENE")); // write another 72 bytes

   375 	wrStrm.WriteL(_L8("WDATASOMENEWDATA")); // write another 16 bytes

   376 	size = wrStrm.SizeL(); // check the blob's size

   377 	TEST2(size, aBlobSize); 

   378 	wrStrm.CommitL();

   379 	CleanupStack::PopAndDestroy(&wrStrm); 

   380 	

   381 	// Read back some of the blob data

   382 	CleanupClosePushL(rdStrm);

   383 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   384 	size = rdStrm.SizeL(); // check the blob's size

   385 	TEST2(size, aBlobSize);

   386 	rdStrm.ReadL(data, 1);

   387 	TEST(data.Compare(_L8("S")) == 0);  // check the first byte

   388 	rdStrm.ReadL(data, 136);

   389 	TEST(data.Compare(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMEN")) == 0); // check the next 136 bytes

   390 	rdStrm.ReadL(data, 30);

   391 	_LIT8(KTrailingZeros, "EWDATASOMENEWDATA\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); 

   392 	TEST(data.Compare(KTrailingZeros) == 0); // check the next 30 bytes (which includes some of the original zero bytes)

   393 	size = rdStrm.SizeL(); // check the blob's size

   394 	TEST2(size, aBlobSize); 

   395 	CleanupStack::PopAndDestroy(&rdStrm);	

   396 	}

   397 	

   398 void StreamBlob3L(TInt aBlobSize)

   399 	{

   400 	// Blob 3 is a 'real' blob of value "DEDEDEDEDEDEDEDEDEDE"

   401 	

   402 	// Read some of the zero data

   403 	RSqlBlobReadStream rdStrm;

   404 	CleanupClosePushL(rdStrm);

   405 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   406 	TInt size = rdStrm.SizeL(); // check the blob's size

   407 	TEST2(size, aBlobSize);

   408 	TBuf8<20> data;

   409 	rdStrm.ReadL(data, 3);

   410 	TEST(data.Compare(_L8("DED")) == 0); // check the first 3 bytes

   411 	rdStrm.ReadL(data, 12);

   412 	TEST(data.Compare(_L8("EDEDEDEDEDED")) == 0); // check the next 12 bytes

   413 	size = rdStrm.SizeL(); // check the blob's size

   414 	TEST2(size, aBlobSize); 

   415 	CleanupStack::PopAndDestroy(&rdStrm); 	

   416 	

   417 	// Write some new data to the blob 

   418 	RSqlBlobWriteStream wrStrm;

   419 	CleanupClosePushL(wrStrm);

   420 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   421 	size = wrStrm.SizeL(); // check the blob's size

   422 	TEST2(size, aBlobSize);

   423 	wrStrm.WriteL(_L8("ABCDEF")); // write 6 bytes

   424 	wrStrm.WriteL(_L8("GHIJKLMNOPQ")); // write another 11 bytes

   425 	size = wrStrm.SizeL(); // check the blob's size

   426 	TEST2(size, aBlobSize); 

   427 	wrStrm.CommitL();

   428 	CleanupStack::PopAndDestroy(&wrStrm);	

   429 	

   430 	// Read back some of the blob data

   431 	CleanupClosePushL(rdStrm);

   432 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   433 	size = rdStrm.SizeL(); // check the blob's size

   434 	TEST2(size, aBlobSize);

   435 	rdStrm.ReadL(data, 2);

   436 	TEST(data.Compare(_L8("AB")) == 0); // check the first 2 bytes

   437 	rdStrm.ReadL(data, 7);

   438 	TEST(data.Compare(_L8("CDEFGHI")) == 0); // check the next 7 bytes

   439 	rdStrm.ReadL(data, 11);

   440 	TEST(data.Compare(_L8("JKLMNOPQEDE")) == 0); // check the next 11 bytes

   441 	size = rdStrm.SizeL(); // check the blob's size

   442 	TEST2(size, aBlobSize); 

   443 	CleanupStack::PopAndDestroy(&rdStrm);	

   444 

   445 	// Seek to position - the blob value is now "ABCDEFGHIJKLMNOPQEDE"

   446 	CleanupClosePushL(rdStrm);

   447 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   448 	TStreamPos pos(9);

   449 	rdStrm.Source()->SeekL(MStreamBuf::ERead, pos);

   450 	rdStrm.ReadL(data, 2);

   451 	TEST(data.Compare(_L8("JK")) == 0);

   452 	rdStrm.ReadL(data, 5);

   453 	TEST(data.Compare(_L8("LMNOP")) == 0);

   454 	TStreamPos pos2(3);

   455 	rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2);

   456 	rdStrm.ReadL(data, 4);

   457 	TEST(data.Compare(_L8("DEFG")) == 0);

   458 	TStreamPos pos3(21);

   459 	TRAPD(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3));

   460 	TEST2(err, KErrEof);

   461 	TStreamPos pos4(18);

   462 	rdStrm.Source()->SeekL(MStreamBuf::ERead, pos4);

   463 	TRAP(err, rdStrm.ReadL(data, 3));

   464 	TEST2(err, KErrEof);

   465 	CleanupStack::PopAndDestroy(&rdStrm);	

   466 

   467 	CleanupClosePushL(wrStrm);

   468 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   469 	TStreamPos pos5(7);

   470 	wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos5);

   471 	wrStrm.WriteL(_L8("ZZZZZ"));

   472 	wrStrm.WriteL(_L8("YYY"));

   473 	TStreamPos pos6(17);

   474 	wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos6);

   475 	wrStrm.WriteL(_L8("XXX"));

   476 	wrStrm.CommitL();

   477 	wrStrm.Close();

   478 	CleanupClosePushL(rdStrm);

   479 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   480 	rdStrm.ReadL(data, 20);

   481 	TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);

   482 	rdStrm.Close();

   483 	TStreamPos pos7(21);

   484 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   485 	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos7));

   486 	TEST2(err, KErrEof);

   487 	TStreamPos pos8(18);

   488 	wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos8);

   489 	wrStrm.WriteL(_L8("TTT"));

   490 	TRAP(err, wrStrm.CommitL());

   491 	TEST2(err, KErrEof);

   492 	wrStrm.Close();

   493 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   494 	rdStrm.ReadL(data, 20);

   495 	TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);

   496 	CleanupStack::PopAndDestroy(2);	

   497 	}

   498 	

   499 /**

   500 @SYMTestCaseID			SYSLIB-SQL-UT-4099

   501 @SYMTestCaseDesc		Incremental blob tests on a database using streams.

   502 						Insert a zeroblob using RSqlStatement::BindZeroBlob(), read and write to

   503 					 	the blob using streams, also read and write to a text column using streams.

   504 						Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.

   505 @SYMTestPriority		Medium

   506 @SYMTestActions			Execution of incremental blob stream operations on a database.

   507 @SYMTestExpectedResults Test must not fail

   508 @SYMREQ					REQ10411

   509                         REQ10418

   510 */	

   511 void StreamBindZeroBlobTestL()

   512 	{

   513 	const TInt KBlobSize = 300;

   514 	InsertBindZeroBlob(KBlobSize);

   515 	CheckBlobPropertiesL(KBlobSize);

   516 	StreamBlob1L(KBlobSize);

   517 	StreamText1L();

   518 	CheckBlobPropertiesL(KBlobSize);

   519 	}

   520 

   521 /**

   522 @SYMTestCaseID			SYSLIB-SQL-UT-4100

   523 @SYMTestCaseDesc		Incremental blob tests on a database, using streams.

   524 						Insert a zeroblob using the SQLite function zeroblob(), 

   525 						read and write to the blob using streams.

   526 						Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.

   527 @SYMTestPriority		Medium

   528 @SYMTestActions			Execution of incremental blob stream operations on a database.

   529 @SYMTestExpectedResults Test must not fail

   530 @SYMREQ					REQ10411

   531                         REQ10418

   532 */	

   533 void StreamSqliteZeroBlobTestL()

   534 	{

   535 	const TInt KBlobSize = 1500;

   536 	InsertSQLiteZeroBlob(KBlobSize);

   537 	CheckBlobPropertiesL(KBlobSize);

   538 	StreamBlob2L(KBlobSize);

   539 	CheckBlobPropertiesL(KBlobSize);

   540 	}

   541 

   542 /**

   543 @SYMTestCaseID			SYSLIB-SQL-UT-4101

   544 @SYMTestCaseDesc		Incremental blob tests on a database, using streams.

   545 						Insert a real blob, read and write to the blob using streams.

   546 						Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.

   547 @SYMTestPriority		Medium

   548 @SYMTestActions			Execution of incremental blob stream operations on a database.

   549 @SYMTestExpectedResults Test must not fail

   550 @SYMREQ					REQ10411

   551                         REQ10418

   552 */

   553 void StreamRealBlobTestL()

   554 	{

   555 	const TInt KBlobSize = 20;

   556 	InsertBlobValueL(KBlobSize);

   557 	CheckBlobPropertiesL(KBlobSize);

   558 	StreamBlob3L(KBlobSize);

   559 	CheckBlobPropertiesL(KBlobSize);

   560 	}

   561 	

   562 /**

   563 @SYMTestCaseID			SYSLIB-SQL-UT-4102

   564 @SYMTestCaseDesc		Whole value blob retrieval tests on a database.

   565 						Retrieve the whole value of a blob object in one go.

   566 						Tests the TSqlBlob 'get' methods.

   567 @SYMTestPriority		Medium

   568 @SYMTestActions			Execution of whole value blob retrieval operations on a database.

   569 @SYMTestExpectedResults Test must not fail

   570 @SYMREQ					REQ10411

   571                         REQ10418

   572 */

   573 void GetWholeBlob3L()

   574 	{

   575 	// Blob 3 is a 'real' blob of value "ABCDEFGZZZZZYYYPQXXX"

   576 	const TInt KBlobSize = 20;

   577 	

   578 	// Get the whole content of Blob 3 in one go, using TSqlBlob::GetLC()

   579 	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));

   580 	TInt bufSize = wholeBuf->Size();

   581 	TEST2(bufSize, KBlobSize);

   582 	TEST(wholeBuf->Des().Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);	

   583 	CleanupStack::PopAndDestroy(wholeBuf); 

   584 

   585 	// Get the whole content of Blob 3 in one go, using TSqlBlob::Get()

   586 	HBufC8* buf = HBufC8::NewLC(KBlobSize);	

   587 	TPtr8 bufPtr(buf->Des());	  

   588 	TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr);

   589 	TEST2(err, KErrNone); 

   590 	TEST(bufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);	

   591 	CleanupStack::PopAndDestroy(buf); 

   592 	

   593 	// Get the whole content of Blob 3 in one go, using TSqlBlob::Get(),

   594 	// ensuring that a buffer larger than the blob can be used

   595 	HBufC8* largerBuf = HBufC8::NewLC(KBlobSize * 2);	

   596 	TPtr8 largerBufPtr(largerBuf->Des());	  

   597 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), largerBufPtr);

   598 	TEST2(err, KErrNone); 

   599 	TEST(largerBufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);	

   600 	CleanupStack::PopAndDestroy(largerBuf); 

   601 	

   602 	// Get the whole content of the blob in 2 chunks of 10 bytes

   603 	HBufC8* streamBuf = HBufC8::NewLC(10);

   604 	TPtr8 streamBufPtr(streamBuf->Des());

   605 	RSqlBlobReadStream rdStrm;

   606 	CleanupClosePushL(rdStrm);

   607 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   608 	TInt size = rdStrm.SizeL();

   609 	TEST2(size, KBlobSize);

   610 	HBufC8* combinedData = HBufC8::NewLC(KBlobSize);

   611 	TPtr8 combinedDataPtr(combinedData->Des());		

   612 	for(TInt i = 2; i > 0 ; --i)

   613 		{

   614 		rdStrm.ReadL(streamBufPtr, 10);

   615 		combinedDataPtr.Append(streamBufPtr);

   616 		}

   617 	TEST(combinedDataPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);

   618 	CleanupStack::PopAndDestroy(3); // combinedDataRead, rdStrm, streamBuf

   619 	}

   620 

   621 /**

   622 @SYMTestCaseID			SYSLIB-SQL-UT-4104

   623 @SYMTestCaseDesc		Whole value blob write tests on a database.

   624 						Write the whole value of a blob object in one go.

   625 						Tests the TSqlBlob 'set' methods.

   626 @SYMTestPriority		Medium

   627 @SYMTestActions			Execution of whole value blob write operations on a database.

   628 @SYMTestExpectedResults Test must not fail

   629 @SYMREQ					REQ10411

   630                         REQ10418

   631 */

   632 void SetWholeBlob3L()

   633 	{

   634 	// Blob 3 is a 'real' blob of value "KKKKKKKKKKKKKKKKKEDE"

   635 	TInt KBlobSize = 20;

   636 	

   637 	// Set the whole content of Blob 3 in one go

   638 	HBufC8* dataBuf = HBufC8::NewLC(KBlobSize);

   639 	TPtr8 dataPtr(dataBuf->Des());

   640 	dataPtr.Append(_L8("CDCDCDCDCDCDCDCDCDCD"));

   641 	TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), dataPtr);

   642 	CleanupStack::PopAndDestroy(dataBuf); 

   643 	

   644 	// Check that the new blob data was written

   645 	HBufC8* retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));

   646 	TInt blobLength = retrievedDataBuf->Size();

   647 	TEST2(blobLength, KBlobSize);

   648 	TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDCDCDCD")) == 0);		

   649 	CleanupStack::PopAndDestroy(retrievedDataBuf);

   650 	

   651 	// Set the whole content of the blob in 2 chunks of 10 bytes

   652 	RSqlBlobWriteStream wrStrm;

   653 	CleanupClosePushL(wrStrm);

   654 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   655 	TInt size = wrStrm.SizeL();

   656 	TEST2(size, KBlobSize);		

   657 	for(TInt i = 2; i > 0; --i)

   658 		{

   659 		wrStrm.WriteL(_L8("ZYZYZYZYZY")); 

   660 		}

   661 	CleanupStack::PopAndDestroy(&wrStrm);

   662 	

   663 	// Check that the new blob data was written

   664 	retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));

   665 	blobLength = retrievedDataBuf->Size();

   666 	TEST2(blobLength, KBlobSize);

   667 	TEST(retrievedDataBuf->Des().Compare(_L8("ZYZYZYZYZYZYZYZYZYZY")) == 0);		

   668 	CleanupStack::PopAndDestroy(retrievedDataBuf);

   669 	}

   670 	

   671 /**

   672 @SYMTestCaseID			SYSLIB-SQL-UT-4106

   673 @SYMTestCaseDesc		Blob read and write tests on an attached database.

   674 						Performs streaming and whole value read and write operations

   675 						on a blob in an attached database to ensure that the 

   676 						RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods 

   677 						can be used on an attached database.

   678 						Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods.

   679 @SYMTestPriority		Medium

   680 @SYMTestActions			Execution of blob read and write operations on an attached database.

   681 @SYMTestExpectedResults Test must not fail

   682 @SYMREQ					REQ10411

   683                         REQ10418

   684 */

   685 void AttachDbTestL()

   686 	{

   687 	// Attach test db 2 to test db 1

   688 	AttachTestDb2();

   689 	

   690 	// Open a read stream on a blob in the attached database - 

   691 	// the blob in the single record has a value of "FGFGFGFGFG"

   692 	const TInt KAttachedBlobSize = 10;

   693 	RSqlBlobReadStream rdStrm;

   694 	CleanupClosePushL(rdStrm);

   695 	rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);

   696 	TInt size = rdStrm.SizeL(); // check the blob's size

   697 	TEST2(size, KAttachedBlobSize);

   698 	TBuf8<20> data;

   699 	rdStrm.ReadL(data, 2);

   700 	TEST(data.Compare(_L8("FG")) == 0);	// check the first 2 bytes

   701 	rdStrm.ReadL(data, 8);

   702 	TEST(data.Compare(_L8("FGFGFGFG")) == 0); // check the next 8 bytes

   703 	size = rdStrm.SizeL(); // check the blob's size

   704 	TEST2(size, KAttachedBlobSize); 

   705 	CleanupStack::PopAndDestroy(&rdStrm);	

   706 	

   707 	// Write some new data to the blob 

   708 	RSqlBlobWriteStream wrStrm;

   709 	CleanupClosePushL(wrStrm);

   710 	wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);

   711 	size = wrStrm.SizeL(); // check the blob's size

   712 	TEST2(size, KAttachedBlobSize);

   713 	wrStrm.WriteL(_L8("LLLL")); // write 4 bytes

   714 	wrStrm.WriteL(_L8("MMMMM")); // write another 5 bytes

   715 	size = wrStrm.SizeL(); // check the blob's size

   716 	TEST2(size, KAttachedBlobSize); 

   717 	wrStrm.CommitL();

   718 	CleanupStack::PopAndDestroy(&wrStrm);	

   719 	

   720 	// Read back some of the blob data

   721 	CleanupClosePushL(rdStrm);

   722 	rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);

   723 	size = rdStrm.SizeL(); // check the blob's size

   724 	TEST2(size, KAttachedBlobSize);

   725 	rdStrm.ReadL(data, 2);

   726 	TEST(data.Compare(_L8("LL")) == 0); // check the first 2 bytes

   727 	rdStrm.ReadL(data, 5);

   728 	TEST(data.Compare(_L8("LLMMM")) == 0); // check the next 5 bytes

   729 	rdStrm.ReadL(data, 3);

   730 	TEST(data.Compare(_L8("MMG")) == 0); // check the next 3 bytes

   731 	size = rdStrm.SizeL(); // check the blob's size

   732 	TEST2(size, KAttachedBlobSize); 

   733 	CleanupStack::PopAndDestroy(&rdStrm);	

   734 	

   735 	// Get the entire blob in the attached database

   736 	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);

   737 	TInt blobLength = wholeBuf->Length();

   738 	TEST2(blobLength, KAttachedBlobSize);

   739 	TEST(wholeBuf->Des().Compare(_L8("LLLLMMMMMG")) == 0);	

   740 	CleanupStack::PopAndDestroy(wholeBuf); 

   741 		

   742 	TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName);	 		 

   743 	TEST(data.Compare(_L8("LLLLMMMMMG")) == 0);	

   744 

   745 	// Set the entire blob in the attached database

   746 	data.Zero();

   747 	data.Append(_L8("STSTSTSTST"));

   748 	TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName);

   749 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);

   750 	TEST(wholeBuf->Des().Compare(_L8("STSTSTSTST")) == 0);	

   751 	CleanupStack::PopAndDestroy(wholeBuf); 	

   752 	}	

   753 

   754 void BadParamReadStreamL()	

   755 	{

   756 	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);

   757 	TPtr tooLongNameDes = tooLongName->Des();

   758 	tooLongNameDes.Fill('A', KMaxFileName + 1);	

   759 

   760 	// RSqlBlobReadStream::OpenL()	

   761 	RSqlBlobReadStream rdStrm;

   762 	CleanupClosePushL(rdStrm);

   763 	TRAPD(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column)

   764 	TEST2(err, KErrNone);

   765 	rdStrm.Close();

   766 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column)

   767 	TEST2(err, KErrNone);

   768 	rdStrm.Close();

   769 	TRAP(err, rdStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection

   770 	TEST2(err, KSqlErrGeneral); 

   771 	TRAP(err, rdStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name

   772 	TEST2(err, KErrBadName);

   773 	TRAP(err, rdStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name

   774 	TEST2(err, KErrBadName);

   775 	TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name

   776 	TEST2(err, KSqlErrGeneral);

   777 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name

   778 	TEST2(err, KErrBadName);

   779 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name

   780 	TEST2(err, KErrBadName);

   781 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name

   782 	TEST2(err, KSqlErrGeneral);

   783 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type

   784 	TEST2(err, KSqlErrGeneral);

   785 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), -12)); // illegal ROWID

   786 	TEST2(err, KErrArgument);

   787 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID

   788 	TEST2(err, KSqlErrGeneral);

   789 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column)

   790 	TEST2(err, KErrNone);

   791 	rdStrm.Close();

   792 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column)

   793 	TEST2(err, KErrNone);

   794 	rdStrm.Close();

   795 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column)

   796 	TEST2(err, KErrNone);

   797 	rdStrm.Close();

   798 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column)

   799 	TEST2(err, KErrNone);

   800 	rdStrm.Close();

   801 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column)

   802 	TEST2(err, KErrNone);

   803 	rdStrm.Close();

   804 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column)

   805 	TEST2(err, KErrNone);

   806 	rdStrm.Close();

   807 	TRAP(err, rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection

   808 	TEST2(err, KSqlErrGeneral);

   809 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name

   810 	TEST2(err, KErrBadName);

   811 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name

   812 	TEST2(err, KSqlErrGeneral);

   813 	TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name

   814 	TEST2(err, KSqlErrGeneral);

   815 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name

   816 	TEST2(err, KSqlErrGeneral);

   817 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type

   818 	TEST2(err, KSqlErrGeneral);

   819 	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID

   820 	TEST2(err, KSqlErrGeneral);

   821 	CleanupStack::PopAndDestroy(&rdStrm);

   822 	CleanupStack::PopAndDestroy(tooLongName);		

   823 	

   824 	// RSqlBlobReadStream::Source()::SeekL()

   825 	CleanupClosePushL(rdStrm);

   826 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   827 	TInt size = rdStrm.SizeL();

   828 	TEST(size > 0);

   829 	TStreamPos pos(-1);

   830 	TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos));

   831 	TEST2(err, KErrEof);

   832 	TStreamPos pos2(size - 1);

   833 	TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2));

   834 	TEST2(err, KErrNone);

   835 	TStreamPos pos3(size + 1);

   836 	TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3));

   837 	TEST2(err, KErrEof);

   838 	CleanupStack::PopAndDestroy(&rdStrm);

   839 	

   840 	// RSqlBlobReadStream::ReadL()

   841 	CleanupClosePushL(rdStrm);

   842 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   843 	size = rdStrm.SizeL();

   844 	TEST2(size, 20);

   845 	TBuf8<20> dataBuf;

   846 	TBuf8<50> tooBigDataBuf;	

   847 	TRAP(err, rdStrm.ReadL(tooBigDataBuf));

   848 	TEST2(err, KErrEof);

   849 	rdStrm.Close();

   850 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   851 	TRAP(err, rdStrm.ReadL(tooBigDataBuf, size + 1));

   852 	TEST2(err, KErrEof);

   853 	rdStrm.Close();

   854 	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   855 	TRAP(err, rdStrm.ReadL(tooBigDataBuf, TChar('J'))); // doesn't find 'J' so tries to fill the buffer to its max size

   856 	TEST2(err, KErrEof);

   857 	CleanupStack::PopAndDestroy(&rdStrm);

   858 	}

   859 	

   860 void BadParamWriteStreamL()

   861 	{

   862 	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);

   863 	TPtr tooLongNameDes = tooLongName->Des();

   864 	tooLongNameDes.Fill('A', KMaxFileName + 1);	

   865 	

   866 	// RSqlBlobWriteStream::OpenL()

   867 	RSqlBlobWriteStream wrStrm;

   868 	CleanupClosePushL(wrStrm);

   869 	TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column)

   870 	TEST2(err, KErrNone);

   871 	wrStrm.Close();

   872 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column)

   873 	TEST2(err, KErrNone);

   874 	wrStrm.Close();

   875 	TRAP(err, wrStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection

   876 	TEST2(err, KSqlErrGeneral);

   877 	TRAP(err, wrStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name

   878 	TEST2(err, KErrBadName);

   879 	TRAP(err, wrStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name

   880 	TEST2(err, KErrBadName);

   881 	TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name

   882 	TEST2(err, KSqlErrGeneral);

   883 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name

   884 	TEST2(err, KErrBadName);

   885 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name

   886 	TEST2(err, KErrBadName);

   887 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name

   888 	TEST2(err, KSqlErrGeneral);

   889 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type

   890 	TEST2(err, KSqlErrGeneral);

   891 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 0)); // illegal ROWID

   892 	TEST2(err, KErrArgument);

   893 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID

   894 	TEST2(err, KSqlErrGeneral);

   895 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column)

   896 	TEST2(err, KErrNone);

   897 	wrStrm.Close();

   898 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column)

   899 	TEST2(err, KErrNone);

   900 	wrStrm.Close();

   901 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column)

   902 	TEST2(err, KErrNone);

   903 	wrStrm.Close();

   904 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column)

   905 	TEST2(err, KErrNone);

   906 	wrStrm.Close();

   907 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column)

   908 	TEST2(err, KErrNone);

   909 	wrStrm.Close();

   910 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column)

   911 	TEST2(err, KErrNone);

   912 	wrStrm.Close();

   913 	TRAP(err, wrStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection

   914 	TEST2(err, KSqlErrGeneral);

   915 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name

   916 	TEST2(err, KErrBadName);

   917 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name

   918 	TEST2(err, KSqlErrGeneral);

   919 	TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name

   920 	TEST2(err, KSqlErrGeneral);

   921 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name

   922 	TEST2(err, KSqlErrGeneral);

   923 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type

   924 	TEST2(err, KSqlErrGeneral);

   925 	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID

   926 	TEST2(err, KSqlErrGeneral);

   927 	CleanupStack::PopAndDestroy(&wrStrm);

   928 	CleanupStack::PopAndDestroy(tooLongName);

   929 

   930 	// RSqlBlobWriteStream::Sink()::SeekL()

   931 	CleanupClosePushL(wrStrm);

   932 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   933 	TInt size = wrStrm.SizeL();

   934 	TEST(size > 0);

   935 	TStreamPos pos(-1);

   936 	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos));

   937 	TEST2(err, KErrEof);

   938 	TStreamPos pos2(size - 1);

   939 	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos2));

   940 	TEST2(err, KErrNone);

   941 	TStreamPos pos3(size + 1);

   942 	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos3));

   943 	TEST2(err, KErrEof);

   944 	CleanupStack::PopAndDestroy(&wrStrm);

   945 	

   946 	// RSqlBlobWriteStream::WriteL()

   947 	CleanupClosePushL(wrStrm);

   948 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   949 	size = wrStrm.SizeL();

   950 	TEST2(size, 20);

   951 	TBuf8<50> tooBigDataBuf;

   952 	tooBigDataBuf.Fill('B', 50);	

   953 	TRAP(err, wrStrm.WriteL(tooBigDataBuf));

   954 #ifdef _DEBUG

   955 	TEST2(err, KErrEof);

   956 #else

   957 	TEST2(err, KErrNone);

   958 	TRAP(err, wrStrm.CommitL());

   959 	TEST2(err, KErrEof);

   960 #endif

   961 	wrStrm.Close();

   962 	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));

   963 	TRAP(err, wrStrm.WriteL(tooBigDataBuf, size + 1));

   964 #ifdef _DEBUG

   965 	TEST2(err, KErrEof);

   966 #else

   967 	TEST2(err, KErrNone);

   968 	TRAP(err, wrStrm.CommitL());

   969 	TEST2(err, KErrEof);

   970 #endif

   971 	CleanupStack::PopAndDestroy(&wrStrm);

   972 	}

   973 	

   974 void BadParamGetL()

   975 	{

   976 	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);

   977 	TPtr tooLongNameDes = tooLongName->Des();

   978 	tooLongNameDes.Fill('A', KMaxFileName + 1);	

   979 

   980 	// TSqlBlob::GetLC()	

   981 	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on a BLOB column)

   982 	TInt blobLength = wholeBuf->Length();

   983 	TEST(blobLength > 0);

   984 	CleanupStack::PopAndDestroy(wholeBuf); 

   985 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on a TEXT column)

   986 	blobLength = wholeBuf->Length();

   987 	TEST(blobLength > 0);

   988 	CleanupStack::PopAndDestroy(wholeBuf); 

   989 	TRAPD(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table1"), _L("B"))); // wrong db connection

   990 	TEST2(err, KSqlErrGeneral); 

   991 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L(""), _L("B"))); // empty table name

   992 	TEST2(err, KErrBadName); 

   993 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, tooLongNameDes, _L("B"))); // too long table name

   994 	TEST2(err, KErrBadName); 

   995 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name

   996 	TEST2(err, KSqlErrGeneral); 

   997 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L(""))); // empty column name

   998 	TEST2(err, KErrBadName); 

   999 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), tooLongNameDes)); // too long column name

  1000 	TEST2(err, KErrBadName); 

  1001 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name

  1002 	TEST2(err, KSqlErrGeneral); 

  1003 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("I"))); // invalid column type

  1004 	TEST2(err, KSqlErrGeneral); 

  1005 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), -2)); // illegal ROWID

  1006 	TEST2(err, KErrArgument); 

  1007 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), 3731)); // invalid ROWID

  1008 	TEST2(err, KSqlErrGeneral); 

  1009 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column)

  1010 	blobLength = wholeBuf->Length();

  1011 	TEST(blobLength > 0);

  1012 	CleanupStack::PopAndDestroy(wholeBuf); 

  1013 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column)

  1014 	blobLength = wholeBuf->Length();

  1015 	TEST(blobLength > 0);

  1016 	CleanupStack::PopAndDestroy(wholeBuf); 

  1017 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column)

  1018 	blobLength = wholeBuf->Length();

  1019 	TEST(blobLength > 0);

  1020 	CleanupStack::PopAndDestroy(wholeBuf); 

  1021 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column)

  1022 	blobLength = wholeBuf->Length();

  1023 	TEST(blobLength > 0);

  1024 	CleanupStack::PopAndDestroy(wholeBuf); 

  1025 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column)

  1026 	blobLength = wholeBuf->Length();

  1027 	TEST(blobLength > 0);

  1028 	CleanupStack::PopAndDestroy(wholeBuf); 

  1029 	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column)

  1030 	blobLength = wholeBuf->Length();

  1031 	TEST(blobLength > 0);

  1032 	CleanupStack::PopAndDestroy(wholeBuf);

  1033 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection

  1034 	TEST2(err, KSqlErrGeneral); 

  1035 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name

  1036 	TEST2(err, KSqlErrGeneral); 

  1037 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name

  1038 	TEST2(err, KSqlErrGeneral); 

  1039 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type

  1040 	TEST2(err, KSqlErrGeneral); 

  1041 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), 345, KAttachedDbName)); // invalid ROWID

  1042 	TEST2(err, KSqlErrGeneral); 

  1043 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name

  1044 	TEST2(err, KSqlErrGeneral); 

  1045 	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name

  1046 	TEST2(err, KErrBadName); 

  1047 

  1048 	// TSqlBlob::Get()

  1049 	HBufC8* buf = HBufC8::NewLC(50);

  1050 	TPtr8 bufPtr(buf->Des());	  	

  1051 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr); // a successful get (on a BLOB column)

  1052 	TEST2(err, KErrNone);

  1053 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr); // a successful get (on a TEXT column)

  1054 	TEST2(err, KErrNone); 

  1055 	err = TSqlBlob::Get(TheDb2, _L("table1"), _L("B"), bufPtr); // wrong db connection

  1056 	TEST2(err, KSqlErrGeneral); 

  1057 	err = TSqlBlob::Get(TheDb1, _L(""), _L("B"), bufPtr); // empty table name

  1058 	TEST2(err, KErrBadName); 

  1059 	err = TSqlBlob::Get(TheDb1, tooLongNameDes, _L("B"), bufPtr); // too long table name

  1060 	TEST2(err, KErrBadName);

  1061 	err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("B"), bufPtr); // invalid table name

  1062 	TEST2(err, KSqlErrGeneral); 

  1063 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L(""), bufPtr); // empty column name

  1064 	TEST2(err, KErrBadName); 

  1065 	err = TSqlBlob::Get(TheDb1, _L("table1"), tooLongNameDes, bufPtr); // too long column name

  1066 	TEST2(err, KErrBadName); 

  1067 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("invalidColumnName"), bufPtr); // invalid column name

  1068 	TEST2(err, KSqlErrGeneral); 

  1069 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("I"), bufPtr); // invalid column type

  1070 	TEST2(err, KSqlErrGeneral); 

  1071 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 0); // illegal ROWID

  1072 	TEST2(err, KErrArgument); 

  1073 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 3731); // invalid ROWID

  1074 	TEST2(err, KSqlErrGeneral); 

  1075 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column)

  1076 	TEST2(err, KErrNone); 

  1077 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column)

  1078 	TEST2(err, KErrNone); 

  1079 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column)

  1080 	TEST2(err, KErrNone); 

  1081 	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column)

  1082 	TEST2(err, KErrNone); 

  1083 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column)

  1084 	TEST2(err, KErrNone); 

  1085 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column)

  1086 	TEST2(err, KErrNone); 

  1087 	err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // wrong db connection

  1088 	TEST2(err, KSqlErrGeneral); 

  1089 	err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid table name

  1090 	TEST2(err, KSqlErrGeneral); 

  1091 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("invalidColumnName"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column name

  1092 	TEST2(err, KSqlErrGeneral); 

  1093 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("int"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column type

  1094 	TEST2(err, KSqlErrGeneral); 

  1095 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, 345, KAttachedDbName); // invalid ROWID

  1096 	TEST2(err, KSqlErrGeneral); 

  1097 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName")); // invalid attached db name

  1098 	TEST2(err, KSqlErrGeneral); 

  1099 	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), tooLongNameDes); // too long attached db name

  1100 	TEST2(err, KErrBadName);

  1101 	CleanupStack::PopAndDestroy(buf);	

  1102 	

  1103 	CleanupStack::PopAndDestroy(tooLongName);

  1104 	}

  1105 

  1106 void BadParamSetL()

  1107 	{

  1108 	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);

  1109 	TPtr tooLongNameDes = tooLongName->Des();

  1110 	tooLongNameDes.Fill('A', KMaxFileName + 1);	

  1111 	

  1112 	// TSqlBlob::SetL()

  1113 	TRAPD(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // a successful set (on a BLOB column)

  1114 	TEST2(err, KErrNone); 

  1115 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // a successful set (on a TEXT column)

  1116 	TEST2(err, KErrNone); 

  1117 	TRAP(err, TSqlBlob::SetL(TheDb2, _L("table1"), _L("B"), _L8("twenty characters..."))); // wrong db connection

  1118 	TEST2(err, KSqlErrGeneral);

  1119 	TRAP(err, TSqlBlob::SetL(TheDb1, _L(""), _L("B"), _L8("twenty characters..."))); // empty table name

  1120 	TEST2(err, KErrBadName); 

  1121 	TRAP(err, TSqlBlob::SetL(TheDb1, tooLongNameDes, _L("B"), _L8("twenty characters..."))); // too long table name

  1122 	TEST2(err, KErrBadName);   

  1123 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("B"), _L8("twenty characters..."))); // invalid table name

  1124 	TEST2(err, KSqlErrGeneral); 

  1125 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L(""), _L8("twenty characters..."))); // empty column name

  1126 	TEST2(err, KErrBadName); 

  1127 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), tooLongNameDes, _L8("twenty characters..."))); // too long column name

  1128 	TEST2(err, KErrBadName); 

  1129 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("invalidColumnName"), _L8("twenty characters..."))); // invalid column name

  1130 	TEST2(err, KSqlErrGeneral); 

  1131 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("I"), _L8("twenty characters..."))); // invalid column type

  1132 	TEST2(err, KSqlErrGeneral);

  1133 	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), -3));  // illegal ROWID

  1134 	TEST2(err, KErrArgument);