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

sl@0	1	// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	//
sl@0	15
sl@0	16	#include <e32test.h>
sl@0	17	#include <bautils.h>
sl@0	18	#include <sqldb.h>
sl@0	19	#include <s32file.h>
sl@0	20
sl@0	21	RTest TheTest(_L("t_sqlblob test"));
sl@0	22
sl@0	23	RSqlDatabase TheDb1;
sl@0	24	RSqlDatabase TheDb2;
sl@0	25	RSqlDatabase ThePrivateDb;
sl@0	26
sl@0	27	_LIT(KTestDir, "c:\\test\\");
sl@0	28	_LIT(KTestDbName1, "c:\\test\\t_blob1.db");
sl@0	29	_LIT(KTestDbName2, "c:\\test\\t_blob2.db");
sl@0	30	_LIT(KAttachedDbName, "attached_db");
sl@0	31	_LIT(KPrivateSecureDb, "c:\\private\\1111C1CC\\ps.db");
sl@0	32
sl@0	33	const TInt KLargeDataBufLen = 2048;
sl@0	34
sl@0	35	// A buffer containing 2Kb of data.
sl@0	36	// When it is used to write to a blob the data will exceed the size of the client buffer
sl@0	37	// (which is 8 bytes in debug, 1.5Kb on target) and will be immediately transferred to the server
sl@0	38	TBuf8<KLargeDataBufLen> TheLargeData;
sl@0	39
sl@0	40	///////////////////////////////////////////////////////////////////////////////////////
sl@0	41	// Test database delete functions
sl@0	42
sl@0	43	void DeleteTestDbs()
sl@0	44	{
sl@0	45	TheDb1.Close();
sl@0	46	TheDb2.Close();
sl@0	47	ThePrivateDb.Close();
sl@0	48	(void)RSqlDatabase::Delete(KTestDbName1);
sl@0	49	(void)RSqlDatabase::Delete(KTestDbName2);
sl@0	50	(void)RSqlDatabase::Delete(KPrivateSecureDb);
sl@0	51	}
sl@0	52
sl@0	53	///////////////////////////////////////////////////////////////////////////////////////
sl@0	54	// Test macros and functions
sl@0	55
sl@0	56	void Check(TInt aValue, TInt aLine)
sl@0	57	{
sl@0	58	if(!aValue)
sl@0	59	{
sl@0	60	DeleteTestDbs();
sl@0	61	TheTest(EFalse, aLine);
sl@0	62	}
sl@0	63	}
sl@0	64	void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0	65	{
sl@0	66	if(aValue != aExpected)
sl@0	67	{
sl@0	68	DeleteTestDbs();
sl@0	69	RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0	70	TheTest(EFalse, aLine);
sl@0	71	}
sl@0	72	}
sl@0	73	#define TEST(arg) ::Check((arg), __LINE__)
sl@0	74	#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
sl@0	75
sl@0	76	///////////////////////////////////////////////////////////////////////////////////////
sl@0	77	// Test database create functions
sl@0	78
sl@0	79	void CreateTestDir()
sl@0	80	{
sl@0	81	RFs fs;
sl@0	82	TInt err = fs.Connect();
sl@0	83	TEST2(err, KErrNone);
sl@0	84
sl@0	85	err = fs.MkDir(KTestDir);
sl@0	86	TEST(err == KErrNone \|\| err == KErrAlreadyExists);
sl@0	87
sl@0	88	err = fs.CreatePrivatePath(EDriveC);
sl@0	89	TEST(err == KErrNone \|\| err == KErrAlreadyExists);
sl@0	90
sl@0	91	fs.Close();
sl@0	92	}
sl@0	93
sl@0	94	void CreateTestDbs()
sl@0	95	{
sl@0	96	// Create t_blob1.db
sl@0	97	TInt err = TheDb1.Create(KTestDbName1);
sl@0	98	TEST2(err, KErrNone);
sl@0	99
sl@0	100	err = TheDb1.Exec(_L("CREATE TABLE table1(I INTEGER, T TEXT, B BLOB)"));
sl@0	101	TEST(err >= 0);
sl@0	102
sl@0	103	// Create t_blob2.db
sl@0	104	err = TheDb2.Create(KTestDbName2);
sl@0	105	TEST2(err, KErrNone);
sl@0	106
sl@0	107	err = TheDb2.Exec(_L("CREATE TABLE table2(int INTEGER, text TEXT, blob BLOB)"));
sl@0	108	TEST(err >= 0);
sl@0	109
sl@0	110	// Insert a blob value of 'FGFGFGFGFG' (10 characters in size)
sl@0	111	err = TheDb2.Exec(_L("INSERT INTO table2 VALUES(1, 'Text Data', x'46474647464746474647')"));
sl@0	112	TEST2(err, 1);
sl@0	113
sl@0	114	// Create private secure db
sl@0	115	err = ThePrivateDb.Create(KPrivateSecureDb);
sl@0	116	TEST2(err, KErrNone);
sl@0	117
sl@0	118	err = ThePrivateDb.Exec(_L("CREATE TABLE table3(age INTEGER, name TEXT, picture BLOB)"));
sl@0	119	TEST(err >= 0);
sl@0	120
sl@0	121	// Insert a blob value of 'ABABABABABABABA' (15 characters in size)
sl@0	122	err = ThePrivateDb.Exec(_L("INSERT INTO table3 VALUES(31, 'John Smith', x'414241424142414241424142414241')"));
sl@0	123	TEST2(err, 1);
sl@0	124	}
sl@0	125
sl@0	126	void CreateIndices()
sl@0	127	{
sl@0	128	TInt err = TheDb1.Exec(_L("CREATE INDEX textIdx1 on table1(T)"));
sl@0	129	TEST(err >= 0);
sl@0	130	err = TheDb1.Exec(_L("CREATE INDEX blobIdx1 on table1(B)"));
sl@0	131	TEST(err >= 0);
sl@0	132
sl@0	133	err = TheDb2.Exec(_L("CREATE INDEX textIdx2 on table2(text)"));
sl@0	134	TEST(err >= 0);
sl@0	135	err = TheDb2.Exec(_L("CREATE INDEX blobIdx2 on table2(blob)"));
sl@0	136	TEST(err >= 0);
sl@0	137	}
sl@0	138
sl@0	139	void RemoveIndices()
sl@0	140	{
sl@0	141	TInt err = TheDb1.Exec(_L("DROP INDEX textIdx1"));
sl@0	142	TEST(err >= 0);
sl@0	143	err = TheDb1.Exec(_L("DROP INDEX blobIdx1"));
sl@0	144	TEST(err >= 0);
sl@0	145
sl@0	146	err = TheDb2.Exec(_L("DROP INDEX textIdx2"));
sl@0	147	TEST(err >= 0);
sl@0	148	err = TheDb2.Exec(_L("DROP INDEX blobIdx2"));
sl@0	149	TEST(err >= 0);
sl@0	150	}
sl@0	151
sl@0	152	void AttachTestDb2()
sl@0	153	{
sl@0	154	TInt err = TheDb1.Attach(KTestDbName2, KAttachedDbName);
sl@0	155	TEST2(err, KErrNone);
sl@0	156	}
sl@0	157
sl@0	158	void FillLargeDataBuf(TChar aChar = 'Z')
sl@0	159	{
sl@0	160	TheLargeData.Fill(aChar, KLargeDataBufLen);
sl@0	161	}
sl@0	162
sl@0	163	///////////////////////////////////////////////////////////////////////////////////////
sl@0	164	// Unit test functions
sl@0	165
sl@0	166	void CheckBlobPropertiesL(TInt aBlobSize)
sl@0	167	{
sl@0	168	// Check properties of the last inserted blob
sl@0	169
sl@0	170	RSqlStatement stmt;
sl@0	171	CleanupClosePushL(stmt);
sl@0	172	TInt err = stmt.Prepare(TheDb1, _L("SELECT B FROM table1 WHERE ROWID == :Val"));
sl@0	173	TEST2(err, KErrNone);
sl@0	174	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	175	TEST(paramIndex >= 0);
sl@0	176	err = stmt.BindInt(paramIndex, TheDb1.LastInsertedRowId());
sl@0	177	TEST2(err, KErrNone);
sl@0	178	err = stmt.Next();
sl@0	179	TEST2(err, KSqlAtRow);
sl@0	180
sl@0	181	// Check the 'declared column type' is ESqlBinary
sl@0	182	TSqlColumnType declColType;
sl@0	183	err = stmt.DeclaredColumnType(0, declColType);
sl@0	184	TEST2(declColType, ESqlBinary);
sl@0	185	// Check the 'runtime column type' is ESqlBinary
sl@0	186	TSqlColumnType colType = stmt.ColumnType(0);
sl@0	187	TEST2(colType, ESqlBinary);
sl@0	188	// Check the 'column size' is the size of the blob
sl@0	189	TInt blobSize = stmt.ColumnSize(0);
sl@0	190	TEST2(blobSize, aBlobSize);
sl@0	191	// Check the 'column value' is not 'NULL' (even for a zeroblob)
sl@0	192	TBool isNull = stmt.IsNull(0);
sl@0	193	TEST2(isNull, EFalse);
sl@0	194	// Check the 'column value' can be retrieved as a binary value
sl@0	195	TPtrC8 binaryPtr = stmt.ColumnBinaryL(0);
sl@0	196	TEST2(binaryPtr.Length(), aBlobSize);
sl@0	197	// Check the 'column value' cannot be retrieved as a text value (it is of type ESqlBinary)
sl@0	198	TPtrC textptr = stmt.ColumnTextL(0);
sl@0	199	TEST2(textptr.Length(), 0);
sl@0	200	CleanupStack::PopAndDestroy(&stmt);
sl@0	201	}
sl@0	202
sl@0	203	void InsertBindZeroBlob(TInt aBlobSize)
sl@0	204	{
sl@0	205	// Insert a record that has had a zeroblob bound to it
sl@0	206	RSqlStatement stmt;
sl@0	207	TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(1, 'some text', :Val)"));
sl@0	208	TEST2(err, KErrNone);
sl@0	209	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	210	TEST(paramIndex >= 0);
sl@0	211	err = stmt.BindZeroBlob(paramIndex, aBlobSize);
sl@0	212	TEST2(err, KErrNone);
sl@0	213	err = stmt.Exec();
sl@0	214	stmt.Close();
sl@0	215	TEST2(err, 1);
sl@0	216	}
sl@0	217
sl@0	218	void InsertSQLiteZeroBlob(TInt aBlobSize)
sl@0	219	{
sl@0	220	// Insert a record that contains the 'zeroblob()' function
sl@0	221	RSqlStatement stmt;
sl@0	222	TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(2, 'more text', zeroblob(:Val))"));
sl@0	223	TEST2(err, KErrNone);
sl@0	224	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	225	TEST(paramIndex >= 0);
sl@0	226	err = stmt.BindInt(paramIndex, aBlobSize);
sl@0	227	TEST2(err, KErrNone);
sl@0	228	err = stmt.Exec();
sl@0	229	stmt.Close();
sl@0	230	TEST2(err, 1);
sl@0	231	}
sl@0	232
sl@0	233	void InsertBlobValueL(TInt aBlobSize)
sl@0	234	{
sl@0	235	// Insert a record that contains an actual blob value
sl@0	236	HBufC8* binaryData = HBufC8::NewLC(aBlobSize);
sl@0	237	TPtr8 binaryDataPtr(binaryData->Des());
sl@0	238	for(TInt i = 0; i < aBlobSize/2; ++i)
sl@0	239	{
sl@0	240	binaryDataPtr.Append(_L8("DE"));
sl@0	241	}
sl@0	242
sl@0	243	RSqlStatement stmt;
sl@0	244	CleanupClosePushL(stmt);
sl@0	245	TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(3, 'even more text', :Val)"));
sl@0	246	TEST2(err, KErrNone);
sl@0	247	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	248	TEST(paramIndex >= 0);
sl@0	249	err = stmt.BindBinary(paramIndex, binaryDataPtr);
sl@0	250	TEST2(err, KErrNone);
sl@0	251	err = stmt.Exec();
sl@0	252	TEST2(err, 1);
sl@0	253	CleanupStack::PopAndDestroy(2); // stmt, binaryData
sl@0	254	}
sl@0	255
sl@0	256	void StreamBlob1L(TInt aBlobSize)
sl@0	257	{
sl@0	258	// Blob 1 is a zeroblob of size aBlobSize
sl@0	259
sl@0	260	// Read (zero) data from the blob
sl@0	261	RSqlBlobReadStream rdStrm;
sl@0	262	CleanupClosePushL(rdStrm);
sl@0	263	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	264	TInt size = rdStrm.SizeL(); // check the blob's size
sl@0	265	TEST2(size, aBlobSize);
sl@0	266	_LIT8(KFiveZeros, "\x0\x0\x0\x0\x0");
sl@0	267	_LIT8(KTwentyZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
sl@0	268	TBuf8<50> data;
sl@0	269	rdStrm.ReadL(data, 5);
sl@0	270	TEST(data.Compare(KFiveZeros) == 0); // check 5 bytes of zero have been read
sl@0	271	rdStrm.ReadL(data, 20);
sl@0	272	TEST(data.Compare(KTwentyZeros) == 0); // check 20 bytes of zero have been read
sl@0	273	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	274
sl@0	275	// Write some actual data to the blob
sl@0	276	RSqlBlobWriteStream wrStrm;
sl@0	277	CleanupClosePushL(wrStrm);
sl@0	278	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	279	size = wrStrm.SizeL(); // check the blob's size
sl@0	280	TEST2(size, aBlobSize);
sl@0	281	wrStrm.WriteL(_L8("AABBCCDDEE")); // write 10 bytes
sl@0	282	wrStrm.WriteL(_L8("FFGGHHIIJJ")); // write another 10 bytes
sl@0	283	wrStrm.WriteL(_L8("KKLLMMNNOOPPQQRRSSTTUUVVWWXX")); // write another 28 bytes
sl@0	284	wrStrm.CommitL();
sl@0	285	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	286
sl@0	287	// Read back some of the blob data
sl@0	288	CleanupClosePushL(rdStrm);
sl@0	289	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	290	size = rdStrm.SizeL(); // check the blob's size
sl@0	291	TEST2(size, aBlobSize);
sl@0	292	rdStrm.ReadL(data, 4);
sl@0	293	TEST(data.Compare(_L8("AABB")) == 0); // check the first 4 bytes
sl@0	294	rdStrm.ReadL(data, 35);
sl@0	295	TEST(data.Compare(_L8("CCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSST")) == 0); // check the next 35 bytes
sl@0	296	rdStrm.ReadL(data, 19);
sl@0	297	_LIT8(KTrailingZeros, "TUUVVWWXX\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
sl@0	298	TEST(data.Compare(KTrailingZeros) == 0); // check the next 19 bytes (which includes some of the original zero bytes)
sl@0	299	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	300	}
sl@0	301
sl@0	302	void StreamText1L()
sl@0	303	{
sl@0	304	// Read data from the text column -
sl@0	305	// the database encoding is UTF-16 so the text is stored as UTF-16
sl@0	306	RSqlBlobReadStream rdStrm;
sl@0	307	CleanupClosePushL(rdStrm);
sl@0	308	rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));
sl@0	309	TBuf<50> dataUTF16;
sl@0	310	rdStrm.ReadL(dataUTF16, 9);
sl@0	311	TEST(dataUTF16.Compare(_L("some text")) == 0);
sl@0	312	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	313
sl@0	314	// Write some data to the text column (as UTF-16)
sl@0	315	RSqlBlobWriteStream wrStrm;
sl@0	316	CleanupClosePushL(wrStrm);
sl@0	317	wrStrm.OpenL(TheDb1, _L("table1"), _L("T"));
sl@0	318	wrStrm.WriteL(_L("new text!")); // can only write up to the original size of the data - 9 chars
sl@0	319	wrStrm.CommitL();
sl@0	320	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	321
sl@0	322	// Read back some of the text (as UTF-16)
sl@0	323	CleanupClosePushL(rdStrm);
sl@0	324	rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));
sl@0	325	rdStrm.ReadL(dataUTF16, 9);
sl@0	326	TEST(dataUTF16.Compare(_L("new text!")) == 0);
sl@0	327	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	328
sl@0	329	// Write some data to the text column (as UTF-8)
sl@0	330	CleanupClosePushL(wrStrm);
sl@0	331	wrStrm.OpenL(TheDb1, _L("table1"), _L("T"));
sl@0	332	wrStrm.WriteL(_L8("try again"));
sl@0	333	wrStrm.CommitL();
sl@0	334	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	335
sl@0	336	// Read back some of the text (as UTF-8)
sl@0	337	CleanupClosePushL(rdStrm);
sl@0	338	rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));
sl@0	339	TBuf8<50> dataUTF8;
sl@0	340	rdStrm.ReadL(dataUTF8, 9);
sl@0	341	TEST(dataUTF8.Compare(_L8("try again")) == 0);
sl@0	342	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	343	}
sl@0	344
sl@0	345	void StreamBlob2L(TInt aBlobSize)
sl@0	346	{
sl@0	347	// Blob 2 is a zeroblob of size aBlobSize
sl@0	348
sl@0	349	// Read (zero) data from the blob
sl@0	350	RSqlBlobReadStream rdStrm;
sl@0	351	CleanupClosePushL(rdStrm);
sl@0	352	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	353	TInt size = rdStrm.SizeL(); // check the blob's size
sl@0	354	TEST2(size, aBlobSize);
sl@0	355	_LIT8(KFifteenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
sl@0	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");
sl@0	357	TBuf8<200> data;
sl@0	358	rdStrm.ReadL(data, 15);
sl@0	359	TEST(data.Compare(KFifteenZeros) == 0); // check 15 bytes of zero have been read
sl@0	360	rdStrm.ReadL(data, 61);
sl@0	361	TEST(data.Compare(KSixtyOneZeros) == 0); // check 61 bytes of zero have been read
sl@0	362	size = rdStrm.SizeL(); // check the blob's size
sl@0	363	TEST2(size, aBlobSize);
sl@0	364	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	365
sl@0	366	// Write some actual data to the blob
sl@0	367	RSqlBlobWriteStream wrStrm;
sl@0	368	CleanupClosePushL(wrStrm);
sl@0	369	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	370	size = wrStrm.SizeL(); // check the blob's size
sl@0	371	TEST2(size, aBlobSize);
sl@0	372	wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATAS")); // write 23 bytes
sl@0	373	wrStrm.WriteL(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATA")); // write another 43 bytes
sl@0	374	wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENE")); // write another 72 bytes
sl@0	375	wrStrm.WriteL(_L8("WDATASOMENEWDATA")); // write another 16 bytes
sl@0	376	size = wrStrm.SizeL(); // check the blob's size
sl@0	377	TEST2(size, aBlobSize);
sl@0	378	wrStrm.CommitL();
sl@0	379	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	380
sl@0	381	// Read back some of the blob data
sl@0	382	CleanupClosePushL(rdStrm);
sl@0	383	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	384	size = rdStrm.SizeL(); // check the blob's size
sl@0	385	TEST2(size, aBlobSize);
sl@0	386	rdStrm.ReadL(data, 1);
sl@0	387	TEST(data.Compare(_L8("S")) == 0); // check the first byte
sl@0	388	rdStrm.ReadL(data, 136);
sl@0	389	TEST(data.Compare(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMEN")) == 0); // check the next 136 bytes
sl@0	390	rdStrm.ReadL(data, 30);
sl@0	391	_LIT8(KTrailingZeros, "EWDATASOMENEWDATA\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
sl@0	392	TEST(data.Compare(KTrailingZeros) == 0); // check the next 30 bytes (which includes some of the original zero bytes)
sl@0	393	size = rdStrm.SizeL(); // check the blob's size
sl@0	394	TEST2(size, aBlobSize);
sl@0	395	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	396	}
sl@0	397
sl@0	398	void StreamBlob3L(TInt aBlobSize)
sl@0	399	{
sl@0	400	// Blob 3 is a 'real' blob of value "DEDEDEDEDEDEDEDEDEDE"
sl@0	401
sl@0	402	// Read some of the zero data
sl@0	403	RSqlBlobReadStream rdStrm;
sl@0	404	CleanupClosePushL(rdStrm);
sl@0	405	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	406	TInt size = rdStrm.SizeL(); // check the blob's size
sl@0	407	TEST2(size, aBlobSize);
sl@0	408	TBuf8<20> data;
sl@0	409	rdStrm.ReadL(data, 3);
sl@0	410	TEST(data.Compare(_L8("DED")) == 0); // check the first 3 bytes
sl@0	411	rdStrm.ReadL(data, 12);
sl@0	412	TEST(data.Compare(_L8("EDEDEDEDEDED")) == 0); // check the next 12 bytes
sl@0	413	size = rdStrm.SizeL(); // check the blob's size
sl@0	414	TEST2(size, aBlobSize);
sl@0	415	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	416
sl@0	417	// Write some new data to the blob
sl@0	418	RSqlBlobWriteStream wrStrm;
sl@0	419	CleanupClosePushL(wrStrm);
sl@0	420	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	421	size = wrStrm.SizeL(); // check the blob's size
sl@0	422	TEST2(size, aBlobSize);
sl@0	423	wrStrm.WriteL(_L8("ABCDEF")); // write 6 bytes
sl@0	424	wrStrm.WriteL(_L8("GHIJKLMNOPQ")); // write another 11 bytes
sl@0	425	size = wrStrm.SizeL(); // check the blob's size
sl@0	426	TEST2(size, aBlobSize);
sl@0	427	wrStrm.CommitL();
sl@0	428	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	429
sl@0	430	// Read back some of the blob data
sl@0	431	CleanupClosePushL(rdStrm);
sl@0	432	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	433	size = rdStrm.SizeL(); // check the blob's size
sl@0	434	TEST2(size, aBlobSize);
sl@0	435	rdStrm.ReadL(data, 2);
sl@0	436	TEST(data.Compare(_L8("AB")) == 0); // check the first 2 bytes
sl@0	437	rdStrm.ReadL(data, 7);
sl@0	438	TEST(data.Compare(_L8("CDEFGHI")) == 0); // check the next 7 bytes
sl@0	439	rdStrm.ReadL(data, 11);
sl@0	440	TEST(data.Compare(_L8("JKLMNOPQEDE")) == 0); // check the next 11 bytes
sl@0	441	size = rdStrm.SizeL(); // check the blob's size
sl@0	442	TEST2(size, aBlobSize);
sl@0	443	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	444
sl@0	445	// Seek to position - the blob value is now "ABCDEFGHIJKLMNOPQEDE"
sl@0	446	CleanupClosePushL(rdStrm);
sl@0	447	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	448	TStreamPos pos(9);
sl@0	449	rdStrm.Source()->SeekL(MStreamBuf::ERead, pos);
sl@0	450	rdStrm.ReadL(data, 2);
sl@0	451	TEST(data.Compare(_L8("JK")) == 0);
sl@0	452	rdStrm.ReadL(data, 5);
sl@0	453	TEST(data.Compare(_L8("LMNOP")) == 0);
sl@0	454	TStreamPos pos2(3);
sl@0	455	rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2);
sl@0	456	rdStrm.ReadL(data, 4);
sl@0	457	TEST(data.Compare(_L8("DEFG")) == 0);
sl@0	458	TStreamPos pos3(21);
sl@0	459	TRAPD(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3));
sl@0	460	TEST2(err, KErrEof);
sl@0	461	TStreamPos pos4(18);
sl@0	462	rdStrm.Source()->SeekL(MStreamBuf::ERead, pos4);
sl@0	463	TRAP(err, rdStrm.ReadL(data, 3));
sl@0	464	TEST2(err, KErrEof);
sl@0	465	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	466
sl@0	467	CleanupClosePushL(wrStrm);
sl@0	468	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	469	TStreamPos pos5(7);
sl@0	470	wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos5);
sl@0	471	wrStrm.WriteL(_L8("ZZZZZ"));
sl@0	472	wrStrm.WriteL(_L8("YYY"));
sl@0	473	TStreamPos pos6(17);
sl@0	474	wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos6);
sl@0	475	wrStrm.WriteL(_L8("XXX"));
sl@0	476	wrStrm.CommitL();
sl@0	477	wrStrm.Close();
sl@0	478	CleanupClosePushL(rdStrm);
sl@0	479	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	480	rdStrm.ReadL(data, 20);
sl@0	481	TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
sl@0	482	rdStrm.Close();
sl@0	483	TStreamPos pos7(21);
sl@0	484	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	485	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos7));
sl@0	486	TEST2(err, KErrEof);
sl@0	487	TStreamPos pos8(18);
sl@0	488	wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos8);
sl@0	489	wrStrm.WriteL(_L8("TTT"));
sl@0	490	TRAP(err, wrStrm.CommitL());
sl@0	491	TEST2(err, KErrEof);
sl@0	492	wrStrm.Close();
sl@0	493	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	494	rdStrm.ReadL(data, 20);
sl@0	495	TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
sl@0	496	CleanupStack::PopAndDestroy(2);
sl@0	497	}
sl@0	498
sl@0	499	/**
sl@0	500	@SYMTestCaseID SYSLIB-SQL-UT-4099
sl@0	501	@SYMTestCaseDesc Incremental blob tests on a database using streams.
sl@0	502	Insert a zeroblob using RSqlStatement::BindZeroBlob(), read and write to
sl@0	503	the blob using streams, also read and write to a text column using streams.
sl@0	504	Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.
sl@0	505	@SYMTestPriority Medium
sl@0	506	@SYMTestActions Execution of incremental blob stream operations on a database.
sl@0	507	@SYMTestExpectedResults Test must not fail
sl@0	508	@SYMREQ REQ10411
sl@0	509	REQ10418
sl@0	510	*/
sl@0	511	void StreamBindZeroBlobTestL()
sl@0	512	{
sl@0	513	const TInt KBlobSize = 300;
sl@0	514	InsertBindZeroBlob(KBlobSize);
sl@0	515	CheckBlobPropertiesL(KBlobSize);
sl@0	516	StreamBlob1L(KBlobSize);
sl@0	517	StreamText1L();
sl@0	518	CheckBlobPropertiesL(KBlobSize);
sl@0	519	}
sl@0	520
sl@0	521	/**
sl@0	522	@SYMTestCaseID SYSLIB-SQL-UT-4100
sl@0	523	@SYMTestCaseDesc Incremental blob tests on a database, using streams.
sl@0	524	Insert a zeroblob using the SQLite function zeroblob(),
sl@0	525	read and write to the blob using streams.
sl@0	526	Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.
sl@0	527	@SYMTestPriority Medium
sl@0	528	@SYMTestActions Execution of incremental blob stream operations on a database.
sl@0	529	@SYMTestExpectedResults Test must not fail
sl@0	530	@SYMREQ REQ10411
sl@0	531	REQ10418
sl@0	532	*/
sl@0	533	void StreamSqliteZeroBlobTestL()
sl@0	534	{
sl@0	535	const TInt KBlobSize = 1500;
sl@0	536	InsertSQLiteZeroBlob(KBlobSize);
sl@0	537	CheckBlobPropertiesL(KBlobSize);
sl@0	538	StreamBlob2L(KBlobSize);
sl@0	539	CheckBlobPropertiesL(KBlobSize);
sl@0	540	}
sl@0	541
sl@0	542	/**
sl@0	543	@SYMTestCaseID SYSLIB-SQL-UT-4101
sl@0	544	@SYMTestCaseDesc Incremental blob tests on a database, using streams.
sl@0	545	Insert a real blob, read and write to the blob using streams.
sl@0	546	Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.
sl@0	547	@SYMTestPriority Medium
sl@0	548	@SYMTestActions Execution of incremental blob stream operations on a database.
sl@0	549	@SYMTestExpectedResults Test must not fail
sl@0	550	@SYMREQ REQ10411
sl@0	551	REQ10418
sl@0	552	*/
sl@0	553	void StreamRealBlobTestL()
sl@0	554	{
sl@0	555	const TInt KBlobSize = 20;
sl@0	556	InsertBlobValueL(KBlobSize);
sl@0	557	CheckBlobPropertiesL(KBlobSize);
sl@0	558	StreamBlob3L(KBlobSize);
sl@0	559	CheckBlobPropertiesL(KBlobSize);
sl@0	560	}
sl@0	561
sl@0	562	/**
sl@0	563	@SYMTestCaseID SYSLIB-SQL-UT-4102
sl@0	564	@SYMTestCaseDesc Whole value blob retrieval tests on a database.
sl@0	565	Retrieve the whole value of a blob object in one go.
sl@0	566	Tests the TSqlBlob 'get' methods.
sl@0	567	@SYMTestPriority Medium
sl@0	568	@SYMTestActions Execution of whole value blob retrieval operations on a database.
sl@0	569	@SYMTestExpectedResults Test must not fail
sl@0	570	@SYMREQ REQ10411
sl@0	571	REQ10418
sl@0	572	*/
sl@0	573	void GetWholeBlob3L()
sl@0	574	{
sl@0	575	// Blob 3 is a 'real' blob of value "ABCDEFGZZZZZYYYPQXXX"
sl@0	576	const TInt KBlobSize = 20;
sl@0	577
sl@0	578	// Get the whole content of Blob 3 in one go, using TSqlBlob::GetLC()
sl@0	579	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));
sl@0	580	TInt bufSize = wholeBuf->Size();
sl@0	581	TEST2(bufSize, KBlobSize);
sl@0	582	TEST(wholeBuf->Des().Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
sl@0	583	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	584
sl@0	585	// Get the whole content of Blob 3 in one go, using TSqlBlob::Get()
sl@0	586	HBufC8* buf = HBufC8::NewLC(KBlobSize);
sl@0	587	TPtr8 bufPtr(buf->Des());
sl@0	588	TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr);
sl@0	589	TEST2(err, KErrNone);
sl@0	590	TEST(bufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
sl@0	591	CleanupStack::PopAndDestroy(buf);
sl@0	592
sl@0	593	// Get the whole content of Blob 3 in one go, using TSqlBlob::Get(),
sl@0	594	// ensuring that a buffer larger than the blob can be used
sl@0	595	HBufC8* largerBuf = HBufC8::NewLC(KBlobSize * 2);
sl@0	596	TPtr8 largerBufPtr(largerBuf->Des());
sl@0	597	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), largerBufPtr);
sl@0	598	TEST2(err, KErrNone);
sl@0	599	TEST(largerBufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
sl@0	600	CleanupStack::PopAndDestroy(largerBuf);
sl@0	601
sl@0	602	// Get the whole content of the blob in 2 chunks of 10 bytes
sl@0	603	HBufC8* streamBuf = HBufC8::NewLC(10);
sl@0	604	TPtr8 streamBufPtr(streamBuf->Des());
sl@0	605	RSqlBlobReadStream rdStrm;
sl@0	606	CleanupClosePushL(rdStrm);
sl@0	607	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	608	TInt size = rdStrm.SizeL();
sl@0	609	TEST2(size, KBlobSize);
sl@0	610	HBufC8* combinedData = HBufC8::NewLC(KBlobSize);
sl@0	611	TPtr8 combinedDataPtr(combinedData->Des());
sl@0	612	for(TInt i = 2; i > 0 ; --i)
sl@0	613	{
sl@0	614	rdStrm.ReadL(streamBufPtr, 10);
sl@0	615	combinedDataPtr.Append(streamBufPtr);
sl@0	616	}
sl@0	617	TEST(combinedDataPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
sl@0	618	CleanupStack::PopAndDestroy(3); // combinedDataRead, rdStrm, streamBuf
sl@0	619	}
sl@0	620
sl@0	621	/**
sl@0	622	@SYMTestCaseID SYSLIB-SQL-UT-4104
sl@0	623	@SYMTestCaseDesc Whole value blob write tests on a database.
sl@0	624	Write the whole value of a blob object in one go.
sl@0	625	Tests the TSqlBlob 'set' methods.
sl@0	626	@SYMTestPriority Medium
sl@0	627	@SYMTestActions Execution of whole value blob write operations on a database.
sl@0	628	@SYMTestExpectedResults Test must not fail
sl@0	629	@SYMREQ REQ10411
sl@0	630	REQ10418
sl@0	631	*/
sl@0	632	void SetWholeBlob3L()
sl@0	633	{
sl@0	634	// Blob 3 is a 'real' blob of value "KKKKKKKKKKKKKKKKKEDE"
sl@0	635	TInt KBlobSize = 20;
sl@0	636
sl@0	637	// Set the whole content of Blob 3 in one go
sl@0	638	HBufC8* dataBuf = HBufC8::NewLC(KBlobSize);
sl@0	639	TPtr8 dataPtr(dataBuf->Des());
sl@0	640	dataPtr.Append(_L8("CDCDCDCDCDCDCDCDCDCD"));
sl@0	641	TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), dataPtr);
sl@0	642	CleanupStack::PopAndDestroy(dataBuf);
sl@0	643
sl@0	644	// Check that the new blob data was written
sl@0	645	HBufC8* retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));
sl@0	646	TInt blobLength = retrievedDataBuf->Size();
sl@0	647	TEST2(blobLength, KBlobSize);
sl@0	648	TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDCDCDCD")) == 0);
sl@0	649	CleanupStack::PopAndDestroy(retrievedDataBuf);
sl@0	650
sl@0	651	// Set the whole content of the blob in 2 chunks of 10 bytes
sl@0	652	RSqlBlobWriteStream wrStrm;
sl@0	653	CleanupClosePushL(wrStrm);
sl@0	654	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	655	TInt size = wrStrm.SizeL();
sl@0	656	TEST2(size, KBlobSize);
sl@0	657	for(TInt i = 2; i > 0; --i)
sl@0	658	{
sl@0	659	wrStrm.WriteL(_L8("ZYZYZYZYZY"));
sl@0	660	}
sl@0	661	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	662
sl@0	663	// Check that the new blob data was written
sl@0	664	retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));
sl@0	665	blobLength = retrievedDataBuf->Size();
sl@0	666	TEST2(blobLength, KBlobSize);
sl@0	667	TEST(retrievedDataBuf->Des().Compare(_L8("ZYZYZYZYZYZYZYZYZYZY")) == 0);
sl@0	668	CleanupStack::PopAndDestroy(retrievedDataBuf);
sl@0	669	}
sl@0	670
sl@0	671	/**
sl@0	672	@SYMTestCaseID SYSLIB-SQL-UT-4106
sl@0	673	@SYMTestCaseDesc Blob read and write tests on an attached database.
sl@0	674	Performs streaming and whole value read and write operations
sl@0	675	on a blob in an attached database to ensure that the
sl@0	676	RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods
sl@0	677	can be used on an attached database.
sl@0	678	Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods.
sl@0	679	@SYMTestPriority Medium
sl@0	680	@SYMTestActions Execution of blob read and write operations on an attached database.
sl@0	681	@SYMTestExpectedResults Test must not fail
sl@0	682	@SYMREQ REQ10411
sl@0	683	REQ10418
sl@0	684	*/
sl@0	685	void AttachDbTestL()
sl@0	686	{
sl@0	687	// Attach test db 2 to test db 1
sl@0	688	AttachTestDb2();
sl@0	689
sl@0	690	// Open a read stream on a blob in the attached database -
sl@0	691	// the blob in the single record has a value of "FGFGFGFGFG"
sl@0	692	const TInt KAttachedBlobSize = 10;
sl@0	693	RSqlBlobReadStream rdStrm;
sl@0	694	CleanupClosePushL(rdStrm);
sl@0	695	rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	696	TInt size = rdStrm.SizeL(); // check the blob's size
sl@0	697	TEST2(size, KAttachedBlobSize);
sl@0	698	TBuf8<20> data;
sl@0	699	rdStrm.ReadL(data, 2);
sl@0	700	TEST(data.Compare(_L8("FG")) == 0); // check the first 2 bytes
sl@0	701	rdStrm.ReadL(data, 8);
sl@0	702	TEST(data.Compare(_L8("FGFGFGFG")) == 0); // check the next 8 bytes
sl@0	703	size = rdStrm.SizeL(); // check the blob's size
sl@0	704	TEST2(size, KAttachedBlobSize);
sl@0	705	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	706
sl@0	707	// Write some new data to the blob
sl@0	708	RSqlBlobWriteStream wrStrm;
sl@0	709	CleanupClosePushL(wrStrm);
sl@0	710	wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	711	size = wrStrm.SizeL(); // check the blob's size
sl@0	712	TEST2(size, KAttachedBlobSize);
sl@0	713	wrStrm.WriteL(_L8("LLLL")); // write 4 bytes
sl@0	714	wrStrm.WriteL(_L8("MMMMM")); // write another 5 bytes
sl@0	715	size = wrStrm.SizeL(); // check the blob's size
sl@0	716	TEST2(size, KAttachedBlobSize);
sl@0	717	wrStrm.CommitL();
sl@0	718	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	719
sl@0	720	// Read back some of the blob data
sl@0	721	CleanupClosePushL(rdStrm);
sl@0	722	rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	723	size = rdStrm.SizeL(); // check the blob's size
sl@0	724	TEST2(size, KAttachedBlobSize);
sl@0	725	rdStrm.ReadL(data, 2);
sl@0	726	TEST(data.Compare(_L8("LL")) == 0); // check the first 2 bytes
sl@0	727	rdStrm.ReadL(data, 5);
sl@0	728	TEST(data.Compare(_L8("LLMMM")) == 0); // check the next 5 bytes
sl@0	729	rdStrm.ReadL(data, 3);
sl@0	730	TEST(data.Compare(_L8("MMG")) == 0); // check the next 3 bytes
sl@0	731	size = rdStrm.SizeL(); // check the blob's size
sl@0	732	TEST2(size, KAttachedBlobSize);
sl@0	733	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	734
sl@0	735	// Get the entire blob in the attached database
sl@0	736	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	737	TInt blobLength = wholeBuf->Length();
sl@0	738	TEST2(blobLength, KAttachedBlobSize);
sl@0	739	TEST(wholeBuf->Des().Compare(_L8("LLLLMMMMMG")) == 0);
sl@0	740	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	741
sl@0	742	TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	743	TEST(data.Compare(_L8("LLLLMMMMMG")) == 0);
sl@0	744
sl@0	745	// Set the entire blob in the attached database
sl@0	746	data.Zero();
sl@0	747	data.Append(_L8("STSTSTSTST"));
sl@0	748	TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	749	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
sl@0	750	TEST(wholeBuf->Des().Compare(_L8("STSTSTSTST")) == 0);
sl@0	751	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	752	}
sl@0	753
sl@0	754	void BadParamReadStreamL()
sl@0	755	{
sl@0	756	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
sl@0	757	TPtr tooLongNameDes = tooLongName->Des();
sl@0	758	tooLongNameDes.Fill('A', KMaxFileName + 1);
sl@0	759
sl@0	760	// RSqlBlobReadStream::OpenL()
sl@0	761	RSqlBlobReadStream rdStrm;
sl@0	762	CleanupClosePushL(rdStrm);
sl@0	763	TRAPD(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column)
sl@0	764	TEST2(err, KErrNone);
sl@0	765	rdStrm.Close();
sl@0	766	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column)
sl@0	767	TEST2(err, KErrNone);
sl@0	768	rdStrm.Close();
sl@0	769	TRAP(err, rdStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection
sl@0	770	TEST2(err, KSqlErrGeneral);
sl@0	771	TRAP(err, rdStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name
sl@0	772	TEST2(err, KErrBadName);
sl@0	773	TRAP(err, rdStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name
sl@0	774	TEST2(err, KErrBadName);
sl@0	775	TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name
sl@0	776	TEST2(err, KSqlErrGeneral);
sl@0	777	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name
sl@0	778	TEST2(err, KErrBadName);
sl@0	779	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name
sl@0	780	TEST2(err, KErrBadName);
sl@0	781	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name
sl@0	782	TEST2(err, KSqlErrGeneral);
sl@0	783	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type
sl@0	784	TEST2(err, KSqlErrGeneral);
sl@0	785	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), -12)); // illegal ROWID
sl@0	786	TEST2(err, KErrArgument);
sl@0	787	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID
sl@0	788	TEST2(err, KSqlErrGeneral);
sl@0	789	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column)
sl@0	790	TEST2(err, KErrNone);
sl@0	791	rdStrm.Close();
sl@0	792	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column)
sl@0	793	TEST2(err, KErrNone);
sl@0	794	rdStrm.Close();
sl@0	795	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column)
sl@0	796	TEST2(err, KErrNone);
sl@0	797	rdStrm.Close();
sl@0	798	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column)
sl@0	799	TEST2(err, KErrNone);
sl@0	800	rdStrm.Close();
sl@0	801	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column)
sl@0	802	TEST2(err, KErrNone);
sl@0	803	rdStrm.Close();
sl@0	804	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column)
sl@0	805	TEST2(err, KErrNone);
sl@0	806	rdStrm.Close();
sl@0	807	TRAP(err, rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
sl@0	808	TEST2(err, KSqlErrGeneral);
sl@0	809	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
sl@0	810	TEST2(err, KErrBadName);
sl@0	811	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
sl@0	812	TEST2(err, KSqlErrGeneral);
sl@0	813	TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
sl@0	814	TEST2(err, KSqlErrGeneral);
sl@0	815	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
sl@0	816	TEST2(err, KSqlErrGeneral);
sl@0	817	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
sl@0	818	TEST2(err, KSqlErrGeneral);
sl@0	819	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID
sl@0	820	TEST2(err, KSqlErrGeneral);
sl@0	821	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	822	CleanupStack::PopAndDestroy(tooLongName);
sl@0	823
sl@0	824	// RSqlBlobReadStream::Source()::SeekL()
sl@0	825	CleanupClosePushL(rdStrm);
sl@0	826	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	827	TInt size = rdStrm.SizeL();
sl@0	828	TEST(size > 0);
sl@0	829	TStreamPos pos(-1);
sl@0	830	TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos));
sl@0	831	TEST2(err, KErrEof);
sl@0	832	TStreamPos pos2(size - 1);
sl@0	833	TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2));
sl@0	834	TEST2(err, KErrNone);
sl@0	835	TStreamPos pos3(size + 1);
sl@0	836	TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3));
sl@0	837	TEST2(err, KErrEof);
sl@0	838	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	839
sl@0	840	// RSqlBlobReadStream::ReadL()
sl@0	841	CleanupClosePushL(rdStrm);
sl@0	842	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	843	size = rdStrm.SizeL();
sl@0	844	TEST2(size, 20);
sl@0	845	TBuf8<20> dataBuf;
sl@0	846	TBuf8<50> tooBigDataBuf;
sl@0	847	TRAP(err, rdStrm.ReadL(tooBigDataBuf));
sl@0	848	TEST2(err, KErrEof);
sl@0	849	rdStrm.Close();
sl@0	850	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	851	TRAP(err, rdStrm.ReadL(tooBigDataBuf, size + 1));
sl@0	852	TEST2(err, KErrEof);
sl@0	853	rdStrm.Close();
sl@0	854	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	855	TRAP(err, rdStrm.ReadL(tooBigDataBuf, TChar('J'))); // doesn't find 'J' so tries to fill the buffer to its max size
sl@0	856	TEST2(err, KErrEof);
sl@0	857	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	858	}
sl@0	859
sl@0	860	void BadParamWriteStreamL()
sl@0	861	{
sl@0	862	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
sl@0	863	TPtr tooLongNameDes = tooLongName->Des();
sl@0	864	tooLongNameDes.Fill('A', KMaxFileName + 1);
sl@0	865
sl@0	866	// RSqlBlobWriteStream::OpenL()
sl@0	867	RSqlBlobWriteStream wrStrm;
sl@0	868	CleanupClosePushL(wrStrm);
sl@0	869	TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column)
sl@0	870	TEST2(err, KErrNone);
sl@0	871	wrStrm.Close();
sl@0	872	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column)
sl@0	873	TEST2(err, KErrNone);
sl@0	874	wrStrm.Close();
sl@0	875	TRAP(err, wrStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection
sl@0	876	TEST2(err, KSqlErrGeneral);
sl@0	877	TRAP(err, wrStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name
sl@0	878	TEST2(err, KErrBadName);
sl@0	879	TRAP(err, wrStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name
sl@0	880	TEST2(err, KErrBadName);
sl@0	881	TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name
sl@0	882	TEST2(err, KSqlErrGeneral);
sl@0	883	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name
sl@0	884	TEST2(err, KErrBadName);
sl@0	885	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name
sl@0	886	TEST2(err, KErrBadName);
sl@0	887	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name
sl@0	888	TEST2(err, KSqlErrGeneral);
sl@0	889	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type
sl@0	890	TEST2(err, KSqlErrGeneral);
sl@0	891	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 0)); // illegal ROWID
sl@0	892	TEST2(err, KErrArgument);
sl@0	893	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID
sl@0	894	TEST2(err, KSqlErrGeneral);
sl@0	895	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column)
sl@0	896	TEST2(err, KErrNone);
sl@0	897	wrStrm.Close();
sl@0	898	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column)
sl@0	899	TEST2(err, KErrNone);
sl@0	900	wrStrm.Close();
sl@0	901	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column)
sl@0	902	TEST2(err, KErrNone);
sl@0	903	wrStrm.Close();
sl@0	904	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column)
sl@0	905	TEST2(err, KErrNone);
sl@0	906	wrStrm.Close();
sl@0	907	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column)
sl@0	908	TEST2(err, KErrNone);
sl@0	909	wrStrm.Close();
sl@0	910	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column)
sl@0	911	TEST2(err, KErrNone);
sl@0	912	wrStrm.Close();
sl@0	913	TRAP(err, wrStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
sl@0	914	TEST2(err, KSqlErrGeneral);
sl@0	915	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
sl@0	916	TEST2(err, KErrBadName);
sl@0	917	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
sl@0	918	TEST2(err, KSqlErrGeneral);
sl@0	919	TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
sl@0	920	TEST2(err, KSqlErrGeneral);
sl@0	921	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
sl@0	922	TEST2(err, KSqlErrGeneral);
sl@0	923	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
sl@0	924	TEST2(err, KSqlErrGeneral);
sl@0	925	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID
sl@0	926	TEST2(err, KSqlErrGeneral);
sl@0	927	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	928	CleanupStack::PopAndDestroy(tooLongName);
sl@0	929
sl@0	930	// RSqlBlobWriteStream::Sink()::SeekL()
sl@0	931	CleanupClosePushL(wrStrm);
sl@0	932	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	933	TInt size = wrStrm.SizeL();
sl@0	934	TEST(size > 0);
sl@0	935	TStreamPos pos(-1);
sl@0	936	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos));
sl@0	937	TEST2(err, KErrEof);
sl@0	938	TStreamPos pos2(size - 1);
sl@0	939	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos2));
sl@0	940	TEST2(err, KErrNone);
sl@0	941	TStreamPos pos3(size + 1);
sl@0	942	TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos3));
sl@0	943	TEST2(err, KErrEof);
sl@0	944	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	945
sl@0	946	// RSqlBlobWriteStream::WriteL()
sl@0	947	CleanupClosePushL(wrStrm);
sl@0	948	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	949	size = wrStrm.SizeL();
sl@0	950	TEST2(size, 20);
sl@0	951	TBuf8<50> tooBigDataBuf;
sl@0	952	tooBigDataBuf.Fill('B', 50);
sl@0	953	TRAP(err, wrStrm.WriteL(tooBigDataBuf));
sl@0	954	#ifdef _DEBUG
sl@0	955	TEST2(err, KErrEof);
sl@0	956	#else
sl@0	957	TEST2(err, KErrNone);
sl@0	958	TRAP(err, wrStrm.CommitL());
sl@0	959	TEST2(err, KErrEof);
sl@0	960	#endif
sl@0	961	wrStrm.Close();
sl@0	962	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	963	TRAP(err, wrStrm.WriteL(tooBigDataBuf, size + 1));
sl@0	964	#ifdef _DEBUG
sl@0	965	TEST2(err, KErrEof);
sl@0	966	#else
sl@0	967	TEST2(err, KErrNone);
sl@0	968	TRAP(err, wrStrm.CommitL());
sl@0	969	TEST2(err, KErrEof);
sl@0	970	#endif
sl@0	971	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	972	}
sl@0	973
sl@0	974	void BadParamGetL()
sl@0	975	{
sl@0	976	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
sl@0	977	TPtr tooLongNameDes = tooLongName->Des();
sl@0	978	tooLongNameDes.Fill('A', KMaxFileName + 1);
sl@0	979
sl@0	980	// TSqlBlob::GetLC()
sl@0	981	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on a BLOB column)
sl@0	982	TInt blobLength = wholeBuf->Length();
sl@0	983	TEST(blobLength > 0);
sl@0	984	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	985	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on a TEXT column)
sl@0	986	blobLength = wholeBuf->Length();
sl@0	987	TEST(blobLength > 0);
sl@0	988	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	989	TRAPD(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table1"), _L("B"))); // wrong db connection
sl@0	990	TEST2(err, KSqlErrGeneral);
sl@0	991	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L(""), _L("B"))); // empty table name
sl@0	992	TEST2(err, KErrBadName);
sl@0	993	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, tooLongNameDes, _L("B"))); // too long table name
sl@0	994	TEST2(err, KErrBadName);
sl@0	995	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name
sl@0	996	TEST2(err, KSqlErrGeneral);
sl@0	997	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L(""))); // empty column name
sl@0	998	TEST2(err, KErrBadName);
sl@0	999	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), tooLongNameDes)); // too long column name
sl@0	1000	TEST2(err, KErrBadName);
sl@0	1001	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name
sl@0	1002	TEST2(err, KSqlErrGeneral);
sl@0	1003	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("I"))); // invalid column type
sl@0	1004	TEST2(err, KSqlErrGeneral);
sl@0	1005	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), -2)); // illegal ROWID
sl@0	1006	TEST2(err, KErrArgument);
sl@0	1007	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), 3731)); // invalid ROWID
sl@0	1008	TEST2(err, KSqlErrGeneral);
sl@0	1009	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column)
sl@0	1010	blobLength = wholeBuf->Length();
sl@0	1011	TEST(blobLength > 0);
sl@0	1012	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1013	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column)
sl@0	1014	blobLength = wholeBuf->Length();
sl@0	1015	TEST(blobLength > 0);
sl@0	1016	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1017	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column)
sl@0	1018	blobLength = wholeBuf->Length();
sl@0	1019	TEST(blobLength > 0);
sl@0	1020	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1021	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column)
sl@0	1022	blobLength = wholeBuf->Length();
sl@0	1023	TEST(blobLength > 0);
sl@0	1024	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1025	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column)
sl@0	1026	blobLength = wholeBuf->Length();
sl@0	1027	TEST(blobLength > 0);
sl@0	1028	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1029	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column)
sl@0	1030	blobLength = wholeBuf->Length();
sl@0	1031	TEST(blobLength > 0);
sl@0	1032	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1033	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
sl@0	1034	TEST2(err, KSqlErrGeneral);
sl@0	1035	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
sl@0	1036	TEST2(err, KSqlErrGeneral);
sl@0	1037	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
sl@0	1038	TEST2(err, KSqlErrGeneral);
sl@0	1039	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
sl@0	1040	TEST2(err, KSqlErrGeneral);
sl@0	1041	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), 345, KAttachedDbName)); // invalid ROWID
sl@0	1042	TEST2(err, KSqlErrGeneral);
sl@0	1043	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
sl@0	1044	TEST2(err, KSqlErrGeneral);
sl@0	1045	TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
sl@0	1046	TEST2(err, KErrBadName);
sl@0	1047
sl@0	1048	// TSqlBlob::Get()
sl@0	1049	HBufC8* buf = HBufC8::NewLC(50);
sl@0	1050	TPtr8 bufPtr(buf->Des());
sl@0	1051	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr); // a successful get (on a BLOB column)
sl@0	1052	TEST2(err, KErrNone);
sl@0	1053	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr); // a successful get (on a TEXT column)
sl@0	1054	TEST2(err, KErrNone);
sl@0	1055	err = TSqlBlob::Get(TheDb2, _L("table1"), _L("B"), bufPtr); // wrong db connection
sl@0	1056	TEST2(err, KSqlErrGeneral);
sl@0	1057	err = TSqlBlob::Get(TheDb1, _L(""), _L("B"), bufPtr); // empty table name
sl@0	1058	TEST2(err, KErrBadName);
sl@0	1059	err = TSqlBlob::Get(TheDb1, tooLongNameDes, _L("B"), bufPtr); // too long table name
sl@0	1060	TEST2(err, KErrBadName);
sl@0	1061	err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("B"), bufPtr); // invalid table name
sl@0	1062	TEST2(err, KSqlErrGeneral);
sl@0	1063	err = TSqlBlob::Get(TheDb1, _L("table1"), _L(""), bufPtr); // empty column name
sl@0	1064	TEST2(err, KErrBadName);
sl@0	1065	err = TSqlBlob::Get(TheDb1, _L("table1"), tooLongNameDes, bufPtr); // too long column name
sl@0	1066	TEST2(err, KErrBadName);
sl@0	1067	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("invalidColumnName"), bufPtr); // invalid column name
sl@0	1068	TEST2(err, KSqlErrGeneral);
sl@0	1069	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("I"), bufPtr); // invalid column type
sl@0	1070	TEST2(err, KSqlErrGeneral);
sl@0	1071	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 0); // illegal ROWID
sl@0	1072	TEST2(err, KErrArgument);
sl@0	1073	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 3731); // invalid ROWID
sl@0	1074	TEST2(err, KSqlErrGeneral);
sl@0	1075	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column)
sl@0	1076	TEST2(err, KErrNone);
sl@0	1077	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column)
sl@0	1078	TEST2(err, KErrNone);
sl@0	1079	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column)
sl@0	1080	TEST2(err, KErrNone);
sl@0	1081	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column)
sl@0	1082	TEST2(err, KErrNone);
sl@0	1083	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column)
sl@0	1084	TEST2(err, KErrNone);
sl@0	1085	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column)
sl@0	1086	TEST2(err, KErrNone);
sl@0	1087	err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // wrong db connection
sl@0	1088	TEST2(err, KSqlErrGeneral);
sl@0	1089	err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid table name
sl@0	1090	TEST2(err, KSqlErrGeneral);
sl@0	1091	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("invalidColumnName"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column name
sl@0	1092	TEST2(err, KSqlErrGeneral);
sl@0	1093	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("int"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column type
sl@0	1094	TEST2(err, KSqlErrGeneral);
sl@0	1095	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, 345, KAttachedDbName); // invalid ROWID
sl@0	1096	TEST2(err, KSqlErrGeneral);
sl@0	1097	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName")); // invalid attached db name
sl@0	1098	TEST2(err, KSqlErrGeneral);
sl@0	1099	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), tooLongNameDes); // too long attached db name
sl@0	1100	TEST2(err, KErrBadName);
sl@0	1101	CleanupStack::PopAndDestroy(buf);
sl@0	1102
sl@0	1103	CleanupStack::PopAndDestroy(tooLongName);
sl@0	1104	}
sl@0	1105
sl@0	1106	void BadParamSetL()
sl@0	1107	{
sl@0	1108	HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
sl@0	1109	TPtr tooLongNameDes = tooLongName->Des();
sl@0	1110	tooLongNameDes.Fill('A', KMaxFileName + 1);
sl@0	1111
sl@0	1112	// TSqlBlob::SetL()
sl@0	1113	TRAPD(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // a successful set (on a BLOB column)
sl@0	1114	TEST2(err, KErrNone);
sl@0	1115	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // a successful set (on a TEXT column)
sl@0	1116	TEST2(err, KErrNone);
sl@0	1117	TRAP(err, TSqlBlob::SetL(TheDb2, _L("table1"), _L("B"), _L8("twenty characters..."))); // wrong db connection
sl@0	1118	TEST2(err, KSqlErrGeneral);
sl@0	1119	TRAP(err, TSqlBlob::SetL(TheDb1, _L(""), _L("B"), _L8("twenty characters..."))); // empty table name
sl@0	1120	TEST2(err, KErrBadName);
sl@0	1121	TRAP(err, TSqlBlob::SetL(TheDb1, tooLongNameDes, _L("B"), _L8("twenty characters..."))); // too long table name
sl@0	1122	TEST2(err, KErrBadName);
sl@0	1123	TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("B"), _L8("twenty characters..."))); // invalid table name
sl@0	1124	TEST2(err, KSqlErrGeneral);
sl@0	1125	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L(""), _L8("twenty characters..."))); // empty column name
sl@0	1126	TEST2(err, KErrBadName);
sl@0	1127	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), tooLongNameDes, _L8("twenty characters..."))); // too long column name
sl@0	1128	TEST2(err, KErrBadName);
sl@0	1129	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("invalidColumnName"), _L8("twenty characters..."))); // invalid column name
sl@0	1130	TEST2(err, KSqlErrGeneral);
sl@0	1131	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("I"), _L8("twenty characters..."))); // invalid column type
sl@0	1132	TEST2(err, KSqlErrGeneral);
sl@0	1133	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), -3)); // illegal ROWID
sl@0	1134	TEST2(err, KErrArgument);
sl@0	1135	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), 1113)); // invalid ROWID
sl@0	1136	TEST2(err, KSqlErrGeneral);
sl@0	1137	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L("main"))); // a successful set (on a BLOB column)
sl@0	1138	TEST2(err, KErrNone);
sl@0	1139	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L(""))); // a successful set (on a BLOB column)
sl@0	1140	TEST2(err, KErrNone);
sl@0	1141	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L("main"))); // a successful set (on a TEXT column)
sl@0	1142	TEST2(err, KErrNone);
sl@0	1143	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L(""))); // a successful set (on a TEXT column)
sl@0	1144	TEST2(err, KErrNone);
sl@0	1145	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful set (on a BLOB column)
sl@0	1146	TEST2(err, KErrNone);
sl@0	1147	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("text"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful set (on a TEXT column)
sl@0	1148	TEST2(err, KErrNone);
sl@0	1149	TRAP(err, TSqlBlob::SetL(TheDb2, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
sl@0	1150	TEST2(err, KSqlErrGeneral);
sl@0	1151	TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
sl@0	1152	TEST2(err, KSqlErrGeneral);
sl@0	1153	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("invalidColumnName"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
sl@0	1154	TEST2(err, KSqlErrGeneral);
sl@0	1155	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("int"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
sl@0	1156	TEST2(err, KSqlErrGeneral);
sl@0	1157	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), 13, KAttachedDbName)); // invalid ROWID
sl@0	1158	TEST2(err, KSqlErrGeneral);
sl@0	1159	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
sl@0	1160	TEST2(err, KSqlErrGeneral);
sl@0	1161	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
sl@0	1162	TEST2(err, KErrBadName);
sl@0	1163
sl@0	1164	CleanupStack::PopAndDestroy(tooLongName);
sl@0	1165	}
sl@0	1166
sl@0	1167	void BadParamBindZeroBlobL()
sl@0	1168	{
sl@0	1169	// RSqlStatement::BindZeroBlob()
sl@0	1170	RSqlBlobReadStream rdStrm;
sl@0	1171	CleanupClosePushL(rdStrm);
sl@0	1172	RSqlStatement stmt;
sl@0	1173	CleanupClosePushL(stmt);
sl@0	1174	TInt err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(1, 'dummy text', :Val)"));
sl@0	1175	TEST2(err, KErrNone);
sl@0	1176	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	1177	TEST(paramIndex >= 0);
sl@0	1178	err = stmt.BindZeroBlob(paramIndex, -1); // a negative blob size
sl@0	1179	TEST2(err, KErrNone);
sl@0	1180	err = stmt.Exec();
sl@0	1181	TEST2(err, 1);
sl@0	1182	stmt.Reset();
sl@0	1183	rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
sl@0	1184	TInt size = rdStrm.SizeL(); // check the blob's size is 0 (0 is used if a negative number was specified)
sl@0	1185	TEST2(size, 0);
sl@0	1186	rdStrm.Close();
sl@0	1187	err = stmt.BindZeroBlob(paramIndex, 0); // a blob size of zero
sl@0	1188	TEST2(err, KErrNone);
sl@0	1189	err = stmt.Exec();
sl@0	1190	TEST2(err, 1);
sl@0	1191	stmt.Reset();
sl@0	1192	rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
sl@0	1193	size = rdStrm.SizeL(); // check the blob's size is 0
sl@0	1194	TEST2(size, 0);
sl@0	1195	// For subsequent test purposes make the last inserted record have a zeroblob > 0 size
sl@0	1196	err = stmt.BindZeroBlob(paramIndex, 1);
sl@0	1197	TEST2(err, KErrNone);
sl@0	1198	err = stmt.Exec();
sl@0	1199	TEST2(err, 1);
sl@0	1200	CleanupStack::PopAndDestroy(&stmt);
sl@0	1201	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	1202	}
sl@0	1203
sl@0	1204	/**
sl@0	1205	@SYMTestCaseID SYSLIB-SQL-UT-4107
sl@0	1206	@SYMTestCaseDesc Bad parameter tests for the methods of RSqlBlobReadStream,
sl@0	1207	RSqlBlobWriteStream, TSqlBlob and RSqlStatement::BindZeroBlob().
sl@0	1208	Tests that the correct error code is returned when a bad parameter
sl@0	1209	is used in a call to one of the methods.
sl@0	1210	Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods
sl@0	1211	and RSqlStatement::BindZeroBlob().
sl@0	1212	@SYMTestPriority High
sl@0	1213	@SYMTestActions Execution of bad parameter tests.
sl@0	1214	@SYMTestExpectedResults Test must not fail
sl@0	1215	@SYMREQ REQ10411
sl@0	1216	REQ10418
sl@0	1217	*/
sl@0	1218	void BadParamTestL()
sl@0	1219	{
sl@0	1220	BadParamReadStreamL();
sl@0	1221	BadParamWriteStreamL();
sl@0	1222	BadParamGetL();
sl@0	1223	BadParamSetL();
sl@0	1224	BadParamBindZeroBlobL();
sl@0	1225	}
sl@0	1226
sl@0	1227	/**
sl@0	1228	@SYMTestCaseID SYSLIB-SQL-UT-4108
sl@0	1229	@SYMTestCaseDesc Indexed column tests for the methods of RSqlBlobReadStream
sl@0	1230	and RSqlBlobWriteStream, to ensure that a blob or text column
sl@0	1231	that is indexed cannot be written to but can be read from
sl@0	1232	(an SQLite restriction).
sl@0	1233	@SYMTestPriority Medium
sl@0	1234	@SYMTestActions Execution of read and write operations on an indexed column in a database.
sl@0	1235	@SYMTestExpectedResults Test must not fail
sl@0	1236	@SYMREQ REQ10411
sl@0	1237	REQ10418
sl@0	1238	*/
sl@0	1239	void IndexedColumnTestL()
sl@0	1240	{
sl@0	1241	// Create an index on the BLOB column and on the TEXT column in the main and attached databases
sl@0	1242	CreateIndices();
sl@0	1243
sl@0	1244	// Attempt to open a write stream on an indexed BLOB and an indexed TEXT column - this should not be permitted.
sl@0	1245	// (This is an SQLite restriction, but having an index on a large BLOB or a TEXT column is highly unlikely!)
sl@0	1246	RSqlBlobWriteStream wrStrm;
sl@0	1247	CleanupClosePushL(wrStrm);
sl@0	1248	TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // indexed BLOB column
sl@0	1249	TEST2(err, KSqlErrGeneral);
sl@0	1250	wrStrm.Close();
sl@0	1251	TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // indexed TEXT column
sl@0	1252	TEST2(err, KSqlErrGeneral);
sl@0	1253	wrStrm.Close();
sl@0	1254	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed BLOB column
sl@0	1255	TEST2(err, KSqlErrGeneral);
sl@0	1256	wrStrm.Close();
sl@0	1257	TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed TEXT column
sl@0	1258	TEST2(err, KSqlErrGeneral);
sl@0	1259	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	1260	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // indexed BLOB column
sl@0	1261	TEST2(err, KSqlErrGeneral);
sl@0	1262	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // indexed TEXT column
sl@0	1263	TEST2(err, KSqlErrGeneral);
sl@0	1264	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed BLOB column
sl@0	1265	TEST2(err, KSqlErrGeneral);
sl@0	1266	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("text"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed TEXT column
sl@0	1267	TEST2(err, KSqlErrGeneral);
sl@0	1268
sl@0	1269	// Attempt to open a read stream on an indexed BLOB and an indexed text COLUMN - this should be permitted
sl@0	1270	RSqlBlobReadStream rdStrm;
sl@0	1271	CleanupClosePushL(rdStrm);
sl@0	1272	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on an indexed BLOB column)
sl@0	1273	TEST2(err, KErrNone);
sl@0	1274	rdStrm.Close();
sl@0	1275	TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on an indexed TEXT column)
sl@0	1276	TEST2(err, KErrNone);
sl@0	1277	rdStrm.Close();
sl@0	1278	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on an indexed BLOB column)
sl@0	1279	TEST2(err, KErrNone);
sl@0	1280	rdStrm.Close();
sl@0	1281	TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on an indexed TEXT column)
sl@0	1282	TEST2(err, KErrNone);
sl@0	1283	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	1284	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on an indexed BLOB column)
sl@0	1285	TInt blobLength = wholeBuf->Length();
sl@0	1286	TEST(blobLength > 0);
sl@0	1287	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1288	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on an indexed TEXT column)
sl@0	1289	blobLength = wholeBuf->Length();
sl@0	1290	TEST(blobLength > 0);
sl@0	1291	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1292	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed BLOB column)
sl@0	1293	blobLength = wholeBuf->Length();
sl@0	1294	TEST(blobLength > 0);
sl@0	1295	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1296	wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed TEXT column)
sl@0	1297	blobLength = wholeBuf->Length();
sl@0	1298	TEST(blobLength > 0);
sl@0	1299	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1300	HBufC8* buf = HBufC8::NewLC(50);
sl@0	1301	TPtr8 buffPtr(buf->Des());
sl@0	1302	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), buffPtr); // a successful get (on an indexed BLOB column)
sl@0	1303	TEST2(err, KErrNone);
sl@0	1304	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), buffPtr); // a successful get (on an indexed TEXT column)
sl@0	1305	TEST2(err, KErrNone);
sl@0	1306	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), buffPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed BLOB column)
sl@0	1307	TEST2(err, KErrNone);
sl@0	1308	err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), buffPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed TEXT column)
sl@0	1309	TEST2(err, KErrNone);
sl@0	1310	CleanupStack::PopAndDestroy(buf);
sl@0	1311
sl@0	1312	RemoveIndices();
sl@0	1313	}
sl@0	1314
sl@0	1315	/**
sl@0	1316	@SYMTestCaseID SYSLIB-SQL-UT-4109
sl@0	1317	@SYMTestCaseDesc 'End of file' tests for the methods of RSqlBlobReadStream
sl@0	1318	RSqlBlobWriteStream and TSqlBlob, to ensure that a client cannot
sl@0	1319	read beyond the end of a blob object or write beyond the end of a
sl@0	1320	blob object and that an appropriate error code is returned.
sl@0	1321	@SYMTestPriority High
sl@0	1322	@SYMTestActions Execution of read and write operations beyond the end of a blob object.
sl@0	1323	@SYMTestExpectedResults Test must not fail
sl@0	1324	@SYMREQ REQ10411
sl@0	1325	REQ10418
sl@0	1326	*/
sl@0	1327	void EofTestL()
sl@0	1328	{
sl@0	1329	// Use Blob 3 in table1, whose value is "!!!twenty characters"
sl@0	1330
sl@0	1331	// Read Eof tests
sl@0	1332
sl@0	1333	const TInt KBlobSize = 20;
sl@0	1334	RSqlBlobReadStream rdStrm;
sl@0	1335	CleanupClosePushL(rdStrm);
sl@0	1336	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1337	TInt size = rdStrm.SizeL();
sl@0	1338	TEST2(size, KBlobSize);
sl@0	1339	TBuf8<50> data;
sl@0	1340	TRAPD(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1341	TEST2(err, KErrNone);
sl@0	1342	TEST(data.Compare(_L8("!!!twenty characters")) == 0);
sl@0	1343	TRAP(err, rdStrm.ReadL(data, 1));
sl@0	1344	TEST2(err, KErrEof);
sl@0	1345	rdStrm.Close();
sl@0	1346	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1347	TRAP(err, rdStrm.ReadL(data, 21));
sl@0	1348	TEST2(err, KErrEof);
sl@0	1349	rdStrm.Close();
sl@0	1350
sl@0	1351	HBufC8* exactSizeBuf = HBufC8::NewLC(KBlobSize);
sl@0	1352	TPtr8 exactSizeBufPtr(exactSizeBuf->Des());
sl@0	1353	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), exactSizeBufPtr);
sl@0	1354	TEST2(err, KErrNone);
sl@0	1355	TEST(exactSizeBufPtr.Compare(_L8("!!!twenty characters")) == 0);
sl@0	1356	CleanupStack::PopAndDestroy(exactSizeBuf);
sl@0	1357
sl@0	1358	HBufC8* tooSmallBuf = HBufC8::NewLC(KBlobSize/2);
sl@0	1359	TPtr8 tooSmallBufPtr(tooSmallBuf->Des());
sl@0	1360	err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), tooSmallBufPtr);
sl@0	1361	TEST2(err, KErrOverflow);
sl@0	1362	CleanupStack::PopAndDestroy(tooSmallBuf);
sl@0	1363
sl@0	1364	// Write Eof tests
sl@0	1365
sl@0	1366	RSqlBlobWriteStream wrStrm;
sl@0	1367	CleanupClosePushL(wrStrm);
sl@0	1368	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1369	size = wrStrm.SizeL();
sl@0	1370	TEST2(size, KBlobSize);
sl@0	1371	// For debug builds: This 20 bytes will be written to the blob straight away
sl@0	1372	// because 20 bytes is more than the 8 byte buffer
sl@0	1373	// For release builds: This 20 bytes will NOT be written to the blob straight away
sl@0	1374	// because there is room for it to be stored in the 1.5K byte buffer
sl@0	1375	TRAP(err, wrStrm.WriteL(_L8("a twenty char string")));
sl@0	1376	TEST2(err, KErrNone);
sl@0	1377	// For debug/release builds: This 1 byte will NOT be written to the blob straight away
sl@0	1378	// because there is room for it to be stored in the 8 byte/1.5K buffer
sl@0	1379	TRAP(err, wrStrm.WriteL(_L8("a")));
sl@0	1380	TEST2(err, KErrNone);
sl@0	1381	// For debug builds: The CommitL() call will cause an attempt to write the 1 byte
sl@0	1382	// in the buffer to the blob - however, the stream's write position indicates
sl@0	1383	// that the write would be beyond the end of the blob and so an error occurs
sl@0	1384	// For release builds: The CommitL() call will cause an attempt to write the 21 bytes
sl@0	1385	// in the buffer to the blob - however, 21 bytes is larger than the size of the blob
sl@0	1386	// and so an error occurs
sl@0	1387	TRAP(err, wrStrm.CommitL());
sl@0	1388	TEST2(err, KErrEof);
sl@0	1389	wrStrm.Close();
sl@0	1390	// For debug builds: Check that the blob value is now "a twenty char string"
sl@0	1391	// For release builds: Check that the blob value is still "!!!twenty characters"
sl@0	1392	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1393	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1394	TEST2(err, KErrNone);
sl@0	1395	#ifdef _DEBUG
sl@0	1396	TEST(data.Compare(_L8("a twenty char string")) == 0);
sl@0	1397	#else
sl@0	1398	TEST(data.Compare(_L8("!!!twenty characters")) == 0);
sl@0	1399	#endif
sl@0	1400	rdStrm.Close();
sl@0	1401
sl@0	1402	TheDb1.Exec(_L("BEGIN"));
sl@0	1403	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1404	// For debug/release builds: These 3 bytes will be stored in the 8 byte/1.5K buffer
sl@0	1405	TRAP(err, wrStrm.WriteL(_L8("eee")));
sl@0	1406	TEST2(err, KErrNone);
sl@0	1407	// For debug builds: These 25 bytes will not fit in the 8 byte buffer and so an attempt
sl@0	1408	// will be made to write these 25 bytes and the 3 buffered bytes to the blob -
sl@0	1409	// however, the size of the blob is only 20 and so an error occurs
sl@0	1410	// For release builds: These 25 bytes will be stored in the 1.5K buffer
sl@0	1411	TRAP(err, wrStrm.WriteL(_L8("fffffffffffffffffffffffff")));
sl@0	1412	#ifdef _DEBUG
sl@0	1413	TEST2(err, KErrEof);
sl@0	1414	wrStrm.Close();
sl@0	1415	TheDb1.Exec(_L("ROLLBACK"));
sl@0	1416
sl@0	1417	// Check that the blob value is still "a twenty char string"
sl@0	1418	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1419	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1420	TEST2(err, KErrNone);
sl@0	1421	TEST(data.Compare(_L8("a twenty char string")) == 0);
sl@0	1422	rdStrm.Close();
sl@0	1423	#else
sl@0	1424	TEST2(err, KErrNone);
sl@0	1425	// For release builds: The CommitL() call will cause an attempt to write the 28 bytes
sl@0	1426	// in the buffer to the blob - however, 28 bytes is larger than the size of the blob
sl@0	1427	// and so an error occurs
sl@0	1428	TRAP(err, wrStrm.CommitL());
sl@0	1429	TEST2(err, KErrEof);
sl@0	1430	wrStrm.Close();
sl@0	1431	TheDb1.Exec(_L("ROLLBACK"));
sl@0	1432
sl@0	1433	// Check that the blob value is still "!!!twenty characters"
sl@0	1434	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1435	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1436	TEST2(err, KErrNone);
sl@0	1437	TEST(data.Compare(_L8("!!!twenty characters")) == 0);
sl@0	1438	rdStrm.Close();
sl@0	1439	#endif
sl@0	1440
sl@0	1441	TheDb1.Exec(_L("BEGIN"));
sl@0	1442	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1443	TRAP(err, wrStrm.WriteL(_L8("a string that is longer than 20 characters")));
sl@0	1444	#ifdef _DEBUG
sl@0	1445	TEST2(err, KErrEof);
sl@0	1446	wrStrm.Close();
sl@0	1447	TheDb1.Exec(_L("ROLLBACK"));
sl@0	1448	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1449	TRAP(err, wrStrm.WriteL(_L8("ggg")));
sl@0	1450	TEST2(err, KErrNone);
sl@0	1451	TRAP(err, wrStrm.CommitL());
sl@0	1452	TEST2(err, KErrNone);
sl@0	1453	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	1454	// Check that the blob value is now "gggwenty char string"
sl@0	1455	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1456	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1457	TEST2(err, KErrNone);
sl@0	1458	TEST(data.Compare(_L8("gggwenty char string")) == 0);
sl@0	1459	rdStrm.Close();
sl@0	1460	#else
sl@0	1461	TEST2(err, KErrNone);
sl@0	1462	TRAP(err, wrStrm.CommitL());
sl@0	1463	TEST2(err, KErrEof);
sl@0	1464	wrStrm.Close();
sl@0	1465	TheDb1.Exec(_L("ROLLBACK"));
sl@0	1466	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1467	TRAP(err, wrStrm.WriteL(_L8("hhh")));
sl@0	1468	TEST2(err, KErrNone);
sl@0	1469	TRAP(err, wrStrm.CommitL());
sl@0	1470	TEST2(err, KErrNone);
sl@0	1471	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	1472	// Check that the blob value is now "hhhtwenty characters"
sl@0	1473	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1474	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1475	TEST2(err, KErrNone);
sl@0	1476	TEST(data.Compare(_L8("hhhtwenty characters")) == 0);
sl@0	1477	rdStrm.Close();
sl@0	1478	#endif
sl@0	1479
sl@0	1480	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("a twenty char string")));
sl@0	1481	TEST2(err, KErrNone);
sl@0	1482	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1483	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1484	TEST2(err, KErrNone);
sl@0	1485	TEST(data.Compare(_L8("a twenty char string")) == 0);
sl@0	1486	rdStrm.Close();
sl@0	1487
sl@0	1488	TheDb1.Exec(_L("BEGIN"));
sl@0	1489	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("a string that is longer than 20 characters")));
sl@0	1490	TEST2(err, KErrEof);
sl@0	1491	TheDb1.Exec(_L("ROLLBACK"));
sl@0	1492	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1493	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1494	TEST2(err, KErrNone);
sl@0	1495	TEST(data.Compare(_L8("a twenty char string")) == 0);
sl@0	1496	rdStrm.Close();
sl@0	1497
sl@0	1498	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("less than 20")));
sl@0	1499	TEST2(err, KErrNone);
sl@0	1500	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1501	TRAP(err, rdStrm.ReadL(data, KBlobSize));
sl@0	1502	TEST2(err, KErrNone); // changing only part of the blob data is permitted
sl@0	1503	TEST(data.Compare(_L8("less than 20r string")) == 0);
sl@0	1504	rdStrm.Close();
sl@0	1505
sl@0	1506	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	1507	}
sl@0	1508
sl@0	1509	/**
sl@0	1510	@SYMTestCaseID SYSLIB-SQL-UT-4110
sl@0	1511	@SYMTestCaseDesc General blob read and write tests on a private secure database,
sl@0	1512	to ensure that there are no security issues with the methods of
sl@0	1513	RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob.
sl@0	1514	@SYMTestPriority High
sl@0	1515	@SYMTestActions Execution of read and write operations on a private secure database.
sl@0	1516	@SYMTestExpectedResults Test must not fail
sl@0	1517	@SYMREQ REQ10411
sl@0	1518	REQ10418
sl@0	1519	REQ5794
sl@0	1520	*/
sl@0	1521	void PrivateSecureDbTestL()
sl@0	1522	{
sl@0	1523	// The blob has the value 'ABABABABABABABA'
sl@0	1524
sl@0	1525	// Read data from the blob
sl@0	1526	const TInt KBlobSize = 15;
sl@0	1527	RSqlBlobReadStream rdStrm;
sl@0	1528	CleanupClosePushL(rdStrm);
sl@0	1529	rdStrm.OpenL(ThePrivateDb, _L("table3"), _L("picture"));
sl@0	1530	TInt size = rdStrm.SizeL(); // check the blob's size
sl@0	1531	TEST2(size, KBlobSize);
sl@0	1532	TBuf8<50> data;
sl@0	1533	rdStrm.ReadL(data, 5);
sl@0	1534	TEST(data.Compare(_L8("ABABA")) == 0); // check 5 bytes have been read
sl@0	1535	rdStrm.ReadL(data, 8);
sl@0	1536	TEST(data.Compare(_L8("BABABABA")) == 0); // check the next 8 bytes have been read
sl@0	1537	rdStrm.SizeL(); // check the blob's size
sl@0	1538	TEST2(size, KBlobSize);
sl@0	1539	CleanupStack::PopAndDestroy(&rdStrm);
sl@0	1540
sl@0	1541	HBufC8* wholeBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture"));
sl@0	1542	TInt blobLength = wholeBuf->Length();
sl@0	1543	TEST2(blobLength, KBlobSize);
sl@0	1544	TEST(wholeBuf->Des().Compare(_L8("ABABABABABABABA")) == 0);
sl@0	1545	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1546
sl@0	1547	HBufC8* buf = HBufC8::NewLC(KBlobSize);
sl@0	1548	TPtr8 bufPtr(buf->Des());
sl@0	1549	TInt err = TSqlBlob::Get(ThePrivateDb, _L("table3"), _L("picture"), bufPtr);
sl@0	1550	TEST2(err, KErrNone);
sl@0	1551	TEST(bufPtr.Compare(_L8("ABABABABABABABA")) == 0);
sl@0	1552	CleanupStack::PopAndDestroy(buf);
sl@0	1553
sl@0	1554	// Write data to the blob
sl@0	1555	RSqlBlobWriteStream wrStrm;
sl@0	1556	CleanupClosePushL(wrStrm);
sl@0	1557	wrStrm.OpenL(ThePrivateDb, _L("table3"), _L("picture"));
sl@0	1558	size = wrStrm.SizeL(); // check the blob's size
sl@0	1559	TEST2(size, KBlobSize);
sl@0	1560	wrStrm.WriteL(_L8("AABBCC")); // write 6 bytes
sl@0	1561	wrStrm.WriteL(_L8("DD")); // write another 2 bytes
sl@0	1562	wrStrm.WriteL(_L8("EEFFG")); // write another 5 bytes
sl@0	1563	size = wrStrm.SizeL(); // check the blob's size
sl@0	1564	TEST2(size, KBlobSize);
sl@0	1565	wrStrm.CommitL();
sl@0	1566	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	1567
sl@0	1568	// Check that the new blob data was written
sl@0	1569	HBufC8* retrievedDataBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture"));
sl@0	1570	blobLength = retrievedDataBuf->Size();
sl@0	1571	TEST2(blobLength, KBlobSize);
sl@0	1572	TEST(retrievedDataBuf->Des().Compare(_L8("AABBCCDDEEFFGBA")) == 0);
sl@0	1573	CleanupStack::PopAndDestroy(retrievedDataBuf);
sl@0	1574
sl@0	1575	HBufC8* dataBuf = HBufC8::NewLC(KBlobSize);
sl@0	1576	TPtr8 dataPtr(dataBuf->Des());
sl@0	1577	dataPtr.Append(_L8("CDCDCDCDCDCDCDC"));
sl@0	1578	TSqlBlob::SetL(ThePrivateDb, _L("table3"), _L("picture"), dataPtr);
sl@0	1579	CleanupStack::PopAndDestroy(dataBuf);
sl@0	1580
sl@0	1581	// Check that the new blob data was written
sl@0	1582	retrievedDataBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture"));
sl@0	1583	blobLength = retrievedDataBuf->Size();
sl@0	1584	TEST2(blobLength, KBlobSize);
sl@0	1585	TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDC")) == 0);
sl@0	1586	CleanupStack::PopAndDestroy(retrievedDataBuf);
sl@0	1587	}
sl@0	1588
sl@0	1589	/**
sl@0	1590	@SYMTestCaseID SYSLIB-SQL-UT-4111
sl@0	1591	@SYMTestCaseDesc Concurrent blob read and write tests using the
sl@0	1592	methods of RSqlBlobReadStream and RSqlBlobWriteStream.
sl@0	1593	Tests that read and write operations on different blobs
sl@0	1594	can happen concurrently and that read operations on the
sl@0	1595	same blob from different streams can happen concurrently.
sl@0	1596	@SYMTestPriority Medium
sl@0	1597	@SYMTestActions Execution of concurrent blob read and write operations on a database.
sl@0	1598	@SYMTestExpectedResults Test must not fail
sl@0	1599	@SYMREQ REQ10411
sl@0	1600	REQ10418
sl@0	1601	*/
sl@0	1602	void ConcurrentReadAndWriteTestL()
sl@0	1603	{
sl@0	1604	// Insert a zeroblob of size 2Kb
sl@0	1605	InsertSQLiteZeroBlob(KLargeDataBufLen);
sl@0	1606	// Insert a zeroblob of size 4Kb
sl@0	1607	InsertBindZeroBlob(4 * 1024);
sl@0	1608
sl@0	1609	// Handles on different blobs
sl@0	1610
sl@0	1611	// Write and read from different blobs
sl@0	1612	RSqlBlobReadStream rdStrm;
sl@0	1613	CleanupClosePushL(rdStrm);
sl@0	1614	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
sl@0	1615
sl@0	1616	RSqlBlobWriteStream wrStrm;
sl@0	1617	CleanupClosePushL(wrStrm);
sl@0	1618	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1619
sl@0	1620	wrStrm.WriteL(_L8("GHIJKL")); // blob2 is not updated in cache (as client buffer not full)
sl@0	1621	TBuf8<100> data;
sl@0	1622	rdStrm.ReadL(data, 6);
sl@0	1623	_LIT8(KSixZeros, "\x0\x0\x0\x0\x0\x0");
sl@0	1624	TEST(data.Compare(KSixZeros) == 0);
sl@0	1625	wrStrm.CommitL(); // blob2 update is not committed (as the rdStrm handle is open)
sl@0	1626	wrStrm.Close();
sl@0	1627	rdStrm.ReadL(data, 6);
sl@0	1628	TEST(data.Compare(KSixZeros) == 0);
sl@0	1629	rdStrm.Close(); // the blob2 update is committed
sl@0	1630	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
sl@0	1631	rdStrm.ReadL(data, 2); // read 2 bytes
sl@0	1632	_LIT8(KTwoZeros, "\x0\x0");
sl@0	1633	TEST(data.Compare(KTwoZeros) == 0);
sl@0	1634	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1635	wrStrm.WriteL(TheLargeData); // blob2 is updated in the cache
sl@0	1636	rdStrm.ReadL(data, 10); // read the next 10 bytes
sl@0	1637	_LIT8(KTenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
sl@0	1638	TEST(data.Compare(KTenZeros) == 0);
sl@0	1639	rdStrm.Close();
sl@0	1640	wrStrm.CommitL(); // the blob2 update is committed
sl@0	1641	CleanupStack::PopAndDestroy(2);
sl@0	1642
sl@0	1643	// Write to different blobs via different streams
sl@0	1644	CleanupClosePushL(wrStrm);
sl@0	1645	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
sl@0	1646
sl@0	1647	RSqlBlobWriteStream wrStrm2;
sl@0	1648	CleanupClosePushL(wrStrm2);
sl@0	1649	wrStrm2.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1650
sl@0	1651	wrStrm.WriteL(_L8("ABABABABABABAB"));
sl@0	1652	wrStrm2.WriteL(_L8("CDCDCD"));
sl@0	1653	wrStrm.WriteL(_L8("EFEF"));
sl@0	1654	wrStrm.Close();
sl@0	1655	wrStrm2.Close(); // the blob1 update is committed and the blob2 update is committed
sl@0	1656	CleanupClosePushL(rdStrm);
sl@0	1657	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
sl@0	1658	rdStrm.ReadL(data, 18);
sl@0	1659	TEST(data.Compare(_L8("ABABABABABABABEFEF")) == 0);
sl@0	1660	rdStrm.Close();
sl@0	1661	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1662	rdStrm.ReadL(data, 6);
sl@0	1663	TEST(data.Compare(_L8("CDCDCD")) == 0);
sl@0	1664	rdStrm.Close();
sl@0	1665	CleanupStack::PopAndDestroy(3);
sl@0	1666
sl@0	1667	// Read from different blobs via different streams
sl@0	1668	CleanupClosePushL(rdStrm);
sl@0	1669	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
sl@0	1670
sl@0	1671	RSqlBlobReadStream rdStrm2;
sl@0	1672	CleanupClosePushL(rdStrm2);
sl@0	1673	rdStrm2.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1674
sl@0	1675	rdStrm.ReadL(data, 2);
sl@0	1676	TEST(data.Compare(_L8("AB")) == 0);
sl@0	1677	rdStrm2.ReadL(data, 3);
sl@0	1678	TEST(data.Compare(_L8("CDC")) == 0);
sl@0	1679	rdStrm.ReadL(data, 15);
sl@0	1680	TEST(data.Compare(_L8("ABABABABABABEFE")) == 0);
sl@0	1681	rdStrm2.ReadL(data, 2);
sl@0	1682	TEST(data.Compare(_L8("DC")) == 0);
sl@0	1683	CleanupStack::PopAndDestroy(2);
sl@0	1684
sl@0	1685	// Handles on the same blob
sl@0	1686	// NOTE: using different stream objects on the same blob is only
sl@0	1687	// safe when all of the stream objects are read streams - writing to
sl@0	1688	// the same blob from different streams or writing and reading from
sl@0	1689	// the same blob at the same time has undefined behaviour
sl@0	1690
sl@0	1691	// Read from the same blob (blob2) via different streams
sl@0	1692	CleanupClosePushL(wrStrm);
sl@0	1693	wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1694	wrStrm.WriteL(_L8("MNOPQR"));
sl@0	1695	CleanupStack::PopAndDestroy(); // the blob2 update is committed
sl@0	1696
sl@0	1697	CleanupClosePushL(rdStrm);
sl@0	1698	rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1699
sl@0	1700	CleanupClosePushL(rdStrm2);
sl@0	1701	rdStrm2.OpenL(TheDb1, _L("table1"), _L("B"));
sl@0	1702
sl@0	1703	rdStrm.ReadL(data, 2);
sl@0	1704	TEST(data.Compare(_L8("MN")) == 0);
sl@0	1705	rdStrm2.ReadL(data, 3);
sl@0	1706	TEST(data.Compare(_L8("MNO")) == 0);
sl@0	1707	rdStrm.ReadL(data, 10);
sl@0	1708	TEST(data.Compare(_L8("OPQRZZZZZZ")) == 0);
sl@0	1709	rdStrm2.ReadL(data, 15);
sl@0	1710	TEST(data.Compare(_L8("PQRZZZZZZZZZZZZ")) == 0);
sl@0	1711	CleanupStack::PopAndDestroy(2);
sl@0	1712	}
sl@0	1713
sl@0	1714	void UTF16TextL(TInt aTextSize)
sl@0	1715	{
sl@0	1716	// The text value is "test", size 8 bytes in UTF-16, aTextSize = 8
sl@0	1717
sl@0	1718	// Try to get the whole content of the text as UTF-8, using TSqlBlob::GetLC()
sl@0	1719	HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"));
sl@0	1720	TInt bufSize = wholeBuf->Size(); // get the number of bytes in the buffer
sl@0	1721	TEST2(bufSize, aTextSize);
sl@0	1722	CleanupStack::PopAndDestroy(wholeBuf);
sl@0	1723
sl@0	1724	// Try to get the whole content of the text as UTF-8, using TSqlBlob::Get()
sl@0	1725	HBufC8* buf = HBufC8::NewLC(aTextSize);
sl@0	1726	TPtr8 bufPtr(buf->Des());
sl@0	1727	TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr);
sl@0	1728	TEST2(err, KErrNone);
sl@0	1729	bufSize = buf->Size(); // get the number of bytes in the buffer
sl@0	1730	TEST2(bufSize, aTextSize);
sl@0	1731	CleanupStack::PopAndDestroy(buf);
sl@0	1732
sl@0	1733	// Try to set the whole content of the text as UTF-8, using TSqlBlob::SetL()
sl@0	1734	HBufC8* dataBuf = HBufC8::NewLC(aTextSize);
sl@0	1735	TPtr8 dataPtr(dataBuf->Des());
sl@0	1736	dataPtr.Append(_L8("OPOPOPOP"));
sl@0	1737	TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), dataPtr));
sl@0	1738	TEST2(err, KErrNone); // can set 8 UTF-8 characters as this is 8 bytes
sl@0	1739	CleanupStack::PopAndDestroy(dataBuf);
sl@0	1740	}
sl@0	1741
sl@0	1742	/**
sl@0	1743	@SYMTestCaseID SYSLIB-SQL-UT-4112
sl@0	1744	@SYMTestCaseDesc UTF-16 text read and write tests using the UTF-8 methods of
sl@0	1745	TSqlBlob.
sl@0	1746	@SYMTestPriority Medium
sl@0	1747	@SYMTestActions Execution of UTF-16 text read and write operations using
sl@0	1748	UTF-8 descriptors.
sl@0	1749	@SYMTestExpectedResults Test must not fail
sl@0	1750	@SYMREQ REQ10411
sl@0	1751	REQ10418
sl@0	1752	*/
sl@0	1753	void UTF16FormatTestL()
sl@0	1754	{
sl@0	1755	// Insert a record with a UTF-16 text value (text is encoded in UTF-16 by default)
sl@0	1756	TInt err = TheDb1.Exec(_L("INSERT INTO table1 VALUES(1, 'test', x'46474647464746474647')"));
sl@0	1757	TEST2(err, 1);
sl@0	1758	const TInt KTextSize = 8; // 8 bytes (4 UTF-16 characters)
sl@0	1759
sl@0	1760	// Now read and write the UTF-16 text value using UTF-8 methods
sl@0	1761	UTF16TextL(KTextSize);
sl@0	1762	}
sl@0	1763
sl@0	1764	/**
sl@0	1765	@SYMTestCaseID SYSLIB-SQL-UT-4114
sl@0	1766	@SYMTestCaseDesc Storing a big blob test, to ensure that by using the methods
sl@0	1767	of RSqlBlobReadStream and RSqlBlobWriteStream larger blobs can
sl@0	1768	be stored in practice than in previous versions of Symbian SQL.
sl@0	1769	Creates a 18Mb zeroblob and then writes data into it and reads
sl@0	1770	the data back.
sl@0	1771	Also tests the TSqlBlob APIs to store and retrieve a large blob.
sl@0	1772	Note that the test will use 18Mb blob only in WINSCW builds.
sl@0	1773	Otherwise the used blob size is 3Mb.
sl@0	1774	@SYMTestPriority Medium
sl@0	1775	@SYMTestActions Execution of creating a 18Mb zeroblob, writing data to it and
sl@0	1776	reading it back.
sl@0	1777	@SYMTestExpectedResults Test must not fail
sl@0	1778	@SYMREQ REQ10410
sl@0	1779	*/
sl@0	1780	void BigBlobTestL()
sl@0	1781	{
sl@0	1782	// In this test we create a zeroblob big enough to hold a 18MB blob.
sl@0	1783	// 18MB is larger than the server could previously read or write,
sl@0	1784	// due to the server heap limit of 6MB (WINSCW builds).
sl@0	1785	// This test will prove that a 18MB blob can be written and read
sl@0	1786	// using the new APIs but not with the old APIs
sl@0	1787
sl@0	1788	#if defined __WINS__ \|\| defined __WINSCW__
sl@0	1789	const TInt KBigBlobSize = 18 * 1024 * 1024;
sl@0	1790	#else
sl@0	1791	const TInt KBigBlobSize = 3 * 1024 * 1024;
sl@0	1792	#endif
sl@0	1793
sl@0	1794	// Create a zeroblob big enough to hold a 36MB blob
sl@0	1795	TInt err = TheDb2.Exec(_L("BEGIN"));
sl@0	1796	TEST(err >= 0);
sl@0	1797
sl@0	1798	RSqlStatement stmt;
sl@0	1799	err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(435, 'big blob test', :Val)"));
sl@0	1800	TEST2(err, KErrNone);
sl@0	1801	TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	1802	TEST(paramIndex >= 0);
sl@0	1803	err = stmt.BindZeroBlob(paramIndex, KBigBlobSize);
sl@0	1804	TEST2(err, KErrNone);
sl@0	1805	err = stmt.Exec();
sl@0	1806	stmt.Close();
sl@0	1807	if(err == KErrDiskFull)
sl@0	1808	{
sl@0	1809	(void)TheDb2.Exec(_L("ROLLBACK"));
sl@0	1810	TheTest.Printf(_L("==== The disk is full. The test cannot be completed!\r\n"));
sl@0	1811	RFs fs;
sl@0	1812	err = fs.Connect();
sl@0	1813	if(err == KErrNone)
sl@0	1814	{
sl@0	1815	TVolumeInfo vinfo;
sl@0	1816	err = fs.Volume(vinfo, EDriveC);
sl@0	1817	if(err == KErrNone)
sl@0	1818	{
sl@0	1819	TheTest.Printf(_L("==== Free disk space=%d\r\n"), vinfo.iFree);
sl@0	1820	}
sl@0	1821	fs.Close();
sl@0	1822	}
sl@0	1823	return;
sl@0	1824	}
sl@0	1825	TEST2(err, 1);
sl@0	1826
sl@0	1827	/////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1828	// Fill a buffer with KBigBlobSize/KBlobPartCnt bytes of data
sl@0	1829	// (the test application's heap may be too small to allocate a KBigBlobSize bytes buffer)
sl@0	1830	const TInt KBlobWrPartCnt = 16;// 1/16 part of the blob will be written at once using streaming API
sl@0	1831	const TInt KBufferSize1 = KBigBlobSize / KBlobWrPartCnt;
sl@0	1832	HBufC8* blobWrBuf = HBufC8::NewLC(KBufferSize1);
sl@0	1833	TPtr8 blobWrChunk(blobWrBuf->Des());
sl@0	1834	blobWrChunk.Fill('Z', KBufferSize1);
sl@0	1835
sl@0	1836	// Write KBigBlobSize bytes to the blob in the inserted record
sl@0	1837	RSqlBlobWriteStream wrStrm;
sl@0	1838	CleanupClosePushL(wrStrm);
sl@0	1839	wrStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
sl@0	1840	TInt size = wrStrm.SizeL(); // check the blob's size
sl@0	1841	TEST2(size, KBigBlobSize);
sl@0	1842	for(TInt i1=0;i1<KBlobWrPartCnt;++i1)
sl@0	1843	{
sl@0	1844	TRAP(err, wrStrm.WriteL(blobWrChunk)); // write KBufferSize1 bytes of data
sl@0	1845	TEST2(err, KErrNone);
sl@0	1846	}
sl@0	1847	wrStrm.CommitL();
sl@0	1848	CleanupStack::PopAndDestroy(&wrStrm);
sl@0	1849
sl@0	1850	err = TheDb2.Exec(_L("COMMIT"));
sl@0	1851	TEST2(err, 1);
sl@0	1852
sl@0	1853	/////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1854	// Read the big blob value back from the record in KBigBlobSize/6 chunks
sl@0	1855	const TInt KBlobRdPartCnt = 24;// 1/24 part of the blob will be read at once using streaming API
sl@0	1856	const TInt KBufferSize2 = KBigBlobSize / KBlobRdPartCnt;
sl@0	1857	HBufC8* blobRdBuf = HBufC8::NewLC(KBufferSize2);
sl@0	1858	TPtr8 blobRdBufPtr(blobRdBuf->Des());
sl@0	1859	RSqlBlobReadStream rdStrm;
sl@0	1860	CleanupClosePushL(rdStrm);
sl@0	1861	rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
sl@0	1862	size = rdStrm.SizeL(); // check the blob's size
sl@0	1863	TEST2(size, KBigBlobSize);
sl@0	1864	for(TInt i2=0;i2<KBlobRdPartCnt;++i2)
sl@0	1865	{
sl@0	1866	rdStrm.ReadL(blobRdBufPtr, KBufferSize2);
sl@0	1867	TEST(blobRdBufPtr.Compare(blobWrChunk.Left(KBufferSize2)) == 0); // check the first KBigBlobSize/KBlobRdPartCnt bytes
sl@0	1868	}
sl@0	1869	TRAP(err, rdStrm.ReadL(blobRdBufPtr, 1));
sl@0	1870	TEST2(err, KErrEof); // check that there is no more data to be read
sl@0	1871	CleanupStack::PopAndDestroy(2, blobRdBuf); // rdStrm, blobRdBuf
sl@0	1872
sl@0	1873	/////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1874	// Try to read the whole KBigBlobSize blob value using the old API
sl@0	1875	err = stmt.Prepare(TheDb2, _L("SELECT blob FROM table2 WHERE ROWID == :Val"));
sl@0	1876	TEST2(err, KErrNone);
sl@0	1877	paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	1878	TEST(paramIndex >= 0);
sl@0	1879	err = stmt.BindInt(paramIndex, TheDb2.LastInsertedRowId());
sl@0	1880	TEST2(err, KErrNone);
sl@0	1881	// Check that the blob retrieval fails (because there is
sl@0	1882	// not enough server-side memory to load it into the VDBE)
sl@0	1883	err = stmt.Next();
sl@0	1884	#if defined __WINS__ \|\| defined __WINSCW__
sl@0	1885	TEST2(err, KErrNoMemory);
sl@0	1886	#else
sl@0	1887	TEST2(err, KSqlAtRow);
sl@0	1888	#endif
sl@0	1889	stmt.Close();
sl@0	1890
sl@0	1891	/////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1892	// Try to write another KBigBlobSize bytes big blob value using the old API.
sl@0	1893	// Check that the at some point the blob write fails (because there is
sl@0	1894	// not enough server-side memory to store the whole KBigBlobSize bytes).
sl@0	1895	err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(99, 'text', :Val)"));
sl@0	1896	TEST2(err, KErrNone);
sl@0	1897	paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	1898	TEST(paramIndex >= 0);
sl@0	1899	RSqlParamWriteStream strm;
sl@0	1900	err = strm.BindBinary(stmt, paramIndex);
sl@0	1901	TEST2(err, KErrNone);
sl@0	1902	for(TInt i3=0;i3<KBlobWrPartCnt && err==KErrNone;++i3)
sl@0	1903	{
sl@0	1904	TRAP(err, strm.WriteL(blobWrChunk, KBufferSize1));
sl@0	1905	}
sl@0	1906	#if defined __WINS__ \|\| defined __WINSCW__
sl@0	1907	TEST2(err, KErrNoMemory);
sl@0	1908	#else
sl@0	1909	TEST2(err, KErrNone);
sl@0	1910	#endif
sl@0	1911	strm.Close();
sl@0	1912	stmt.Close();
sl@0	1913	CleanupStack::PopAndDestroy(blobWrBuf);
sl@0	1914	blobWrBuf = NULL;
sl@0	1915
sl@0	1916	/////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1917	// Use the TSqlBlob APIs to insert another big blob of size 85Kb
sl@0	1918	// (to test the block algorithm used by TSqlBlob 'set')
sl@0	1919	const TInt KBigBlobSize2 = 85 * 1024;
sl@0	1920	err = TheDb2.Exec(_L("BEGIN"));
sl@0	1921	TEST(err >= 0);
sl@0	1922
sl@0	1923	err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(189, 'another big blob', :Val)"));
sl@0	1924	TEST2(err, KErrNone);
sl@0	1925	paramIndex = stmt.ParameterIndex(_L(":Val"));
sl@0	1926	TEST(paramIndex >= 0);
sl@0	1927	err = stmt.BindZeroBlob(paramIndex, KBigBlobSize2);
sl@0	1928	TEST2(err, KErrNone);
sl@0	1929	err = stmt.Exec();
sl@0	1930	TEST2(err, 1);
sl@0	1931	stmt.Close();
sl@0	1932
sl@0	1933	blobWrBuf = HBufC8::NewLC(KBigBlobSize2);
sl@0	1934	blobWrChunk.Set(blobWrBuf->Des());
sl@0	1935	blobWrChunk.SetLength(KBigBlobSize2);
sl@0	1936	blobWrChunk.Fill('F');
sl@0	1937	TPtr8 p((TUint8*)blobWrChunk.Ptr() + blobWrChunk.Length() / 2, blobWrChunk.Length() / 2);
sl@0	1938	p.Fill('E');// blobWrBuf now contains 42.5Kb of 'E's followed by 42.5Kb of 'F's
sl@0	1939
sl@0	1940	TRAP(err, TSqlBlob::SetL(TheDb2, _L("table2"), _L("blob"), blobWrChunk));
sl@0	1941	TEST2(err, KErrNone);
sl@0	1942
sl@0	1943	err = TheDb2.Exec(_L("COMMIT"));
sl@0	1944	TEST2(err, 1);
sl@0	1945
sl@0	1946	// Read the blob value back from the record
sl@0	1947	// (to test the block algorithm used by TSqlBlob 'get')
sl@0	1948	HBufC8* buf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob"));
sl@0	1949	TEST(buf->Des().Compare(blobWrChunk) == 0);
sl@0	1950	CleanupStack::PopAndDestroy(buf);
sl@0	1951	buf = NULL;
sl@0	1952
sl@0	1953	buf = HBufC8::NewLC(KBigBlobSize2);
sl@0	1954	blobRdBufPtr.Set(buf->Des());
sl@0	1955	err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), blobRdBufPtr);
sl@0	1956	TEST2(err, KErrNone);
sl@0	1957	TEST(blobRdBufPtr.Compare(blobWrChunk) == 0);
sl@0	1958
sl@0	1959	CleanupStack::PopAndDestroy(2, blobWrBuf); // buf, blobWrBuf
sl@0	1960	}
sl@0	1961
sl@0	1962	/**
sl@0	1963	@SYMTestCaseID PDS-SQL-CT-4194
sl@0	1964	@SYMTestCaseDesc The test opens a test database, creates a table with a blob column and inserts one record.
sl@0	1965	Then the test uses RSqlBlobWriteStream to modify the blob column content.
sl@0	1966	MStreamBuf::SeekL() is used to modify the blob data at specific positions.
sl@0	1967	Then the test uses RSqlBlobReadStream object to read the just written blob data.
sl@0	1968	MStreamBuf::SeekL() is used to read the column content at specific positions
sl@0	1969	(the same positions used during the blob write operation). The read byte values must
sl@0	1970	match the written byte values.
sl@0	1971	@SYMTestPriority High
sl@0	1972	@SYMTestActions RSqlBlobReadStream and RSqlBlobWriteStream - MStreamBuf::SeekL() test.
sl@0	1973	@SYMTestExpectedResults Test must not fail
sl@0	1974	@SYMDEF DEF145028
sl@0	1975	*/
sl@0	1976	void StreamSeekTestL()
sl@0	1977	{
sl@0	1978	TInt rc = TheDb1.Exec(_L("CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)"));
sl@0	1979	TEST(rc >= 0);
sl@0	1980
sl@0	1981	//Write a record to the database using a blob stream. MStreamBuf::SeekL() is used to modify the content at a specific position.
sl@0	1982	rc = TheDb1.Exec(_L("INSERT INTO A(Fld1, Fld2) VALUES(1, zeroblob(256))"));
sl@0	1983	TEST2(rc, 1);
sl@0	1984	RSqlBlobWriteStream strm1;
sl@0	1985	CleanupClosePushL(strm1);
sl@0	1986	strm1.OpenL(TheDb1, _L("A"), _L("Fld2"));
sl@0	1987	for(TInt i=0;i<256;++i)
sl@0	1988	{
sl@0	1989	strm1 << (TUint8)i;
sl@0	1990	}
sl@0	1991
sl@0	1992	const TInt KStreamOffset = 10;
sl@0	1993	const TUint8 KByte = 'z';
sl@0	1994	_LIT8(KData, "QWERTYUIOPASDFG");
sl@0	1995
sl@0	1996	MStreamBuf* strm1buf = strm1.Sink();
sl@0	1997	TEST(strm1buf != NULL);
sl@0	1998
sl@0	1999	strm1buf->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0);
sl@0	2000	strm1buf->WriteL(&KByte, 1);
sl@0	2001
sl@0	2002	strm1buf->SeekL(MStreamBuf::EWrite, EStreamMark, KStreamOffset);
sl@0	2003	strm1buf->WriteL(&KByte, 1);
sl@0	2004
sl@0	2005	strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -KData().Length());
sl@0	2006	strm1buf->WriteL(KData().Ptr(), KData().Length());
sl@0	2007
sl@0	2008	strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -4 * KStreamOffset);
sl@0	2009	strm1buf->WriteL(&KByte, 1);
sl@0	2010
sl@0	2011	strm1.CommitL();
sl@0	2012	CleanupStack::PopAndDestroy(&strm1);
sl@0	2013
sl@0	2014	//Read the record using a blob stream. MStreamBuf::SeekL() is used to read the content at a specific position.
sl@0	2015	RSqlBlobReadStream strm2;
sl@0	2016	CleanupClosePushL(strm2);
sl@0	2017	strm2.OpenL(TheDb1, _L("A"), _L("Fld2"));
sl@0	2018
sl@0	2019	TUint8 byte = 0;
sl@0	2020	MStreamBuf* strm2buf = strm2.Source();
sl@0	2021	TEST(strm1buf != NULL);
sl@0	2022
sl@0	2023	strm2buf->SeekL(MStreamBuf::ERead, EStreamBeginning, 0);
sl@0	2024	rc = strm2buf->ReadL(&byte, 1);
sl@0	2025	TEST2(rc, 1);
sl@0	2026	TEST2(byte, KByte);
sl@0	2027
sl@0	2028	strm2buf->SeekL(MStreamBuf::ERead, EStreamMark, KStreamOffset);
sl@0	2029	rc = strm2buf->ReadL(&byte, 1);
sl@0	2030	TEST2(rc, 1);
sl@0	2031	TEST2(byte, KByte);
sl@0	2032
sl@0	2033	strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -KData().Length());
sl@0	2034	TUint8 buf[20];
sl@0	2035	rc = strm2buf->ReadL(buf, KData().Length());
sl@0	2036	TEST2(rc, KData().Length());
sl@0	2037	TPtrC8 bufptr(buf, rc);
sl@0	2038	TEST(bufptr == KData);
sl@0	2039
sl@0	2040	strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -4 * KStreamOffset);
sl@0	2041	rc = strm2buf->ReadL(&byte, 1);
sl@0	2042	TEST2(rc, 1);
sl@0	2043	TEST2(byte, KByte);
sl@0	2044
sl@0	2045	CleanupStack::PopAndDestroy(&strm2);
sl@0	2046	}
sl@0	2047
sl@0	2048	void DoTestsL()
sl@0	2049	{
sl@0	2050	CreateTestDbs();
sl@0	2051
sl@0	2052	// Insert a zeroblob using RSqlStatement::BindZeroBlob() and read and write to it using streams
sl@0	2053	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4099: Stream BindZeroBlob() test"));
sl@0	2054	StreamBindZeroBlobTestL();
sl@0	2055
sl@0	2056	// Insert a zeroblob using SQLite's zeroblob() function and read and write to it using streams
sl@0	2057	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4100: Stream zeroblob() test"));
sl@0	2058	StreamSqliteZeroBlobTestL();
sl@0	2059
sl@0	2060	// Insert a record containing a 'real' blob and read and write to it using streams
sl@0	2061	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4101: Stream real blob test"));
sl@0	2062	StreamRealBlobTestL();
sl@0	2063
sl@0	2064	// Get a whole blob object
sl@0	2065	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4102: Whole value blob retrieval test"));
sl@0	2066	GetWholeBlob3L();
sl@0	2067
sl@0	2068	// Set a whole blob object
sl@0	2069	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4104: Whole value blob set test"));
sl@0	2070	SetWholeBlob3L();
sl@0	2071
sl@0	2072	// Attached database test
sl@0	2073	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4106: Attached database test"));
sl@0	2074	AttachDbTestL();
sl@0	2075
sl@0	2076	// Bad parameter test
sl@0	2077	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4107: Bad parameter test"));
sl@0	2078	BadParamTestL();
sl@0	2079
sl@0	2080	// Indexed column test
sl@0	2081	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4108: Indexed column test"));
sl@0	2082	IndexedColumnTestL();
sl@0	2083
sl@0	2084	// End Of File test
sl@0	2085	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4109: Eof test"));
sl@0	2086	EofTestL();
sl@0	2087
sl@0	2088	// Private secure database test
sl@0	2089	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4110: Private secure db test"));
sl@0	2090	PrivateSecureDbTestL();
sl@0	2091
sl@0	2092	// Concurrent read and write test
sl@0	2093	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4111: Concurrent read and write test"));
sl@0	2094	ConcurrentReadAndWriteTestL();
sl@0	2095
sl@0	2096	// UTF-16 read and write test
sl@0	2097	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4112: UTF-16 format test"));
sl@0	2098	UTF16FormatTestL();
sl@0	2099
sl@0	2100	// Big blob test
sl@0	2101	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4114: Big blob test"));
sl@0	2102	BigBlobTestL();
sl@0	2103
sl@0	2104	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4194: Blob streams. MStreamBuf::SeekL() test"));
sl@0	2105	StreamSeekTestL();
sl@0	2106
sl@0	2107	DeleteTestDbs();
sl@0	2108	}
sl@0	2109
sl@0	2110	TInt E32Main()
sl@0	2111	{
sl@0	2112	TheTest.Title();
sl@0	2113
sl@0	2114	CTrapCleanup* tc = CTrapCleanup::New();
sl@0	2115
sl@0	2116	__UHEAP_MARK;
sl@0	2117
sl@0	2118	CreateTestDir();
sl@0	2119	DeleteTestDbs();
sl@0	2120	FillLargeDataBuf();
sl@0	2121	TRAPD(err, DoTestsL());
sl@0	2122	TEST2(err, KErrNone);
sl@0	2123
sl@0	2124	__UHEAP_MARKEND;
sl@0	2125
sl@0	2126	TheTest.End();
sl@0	2127	TheTest.Close();
sl@0	2128
sl@0	2129	delete tc;
sl@0	2130
sl@0	2131	User::Heap().Check();
sl@0	2132	return KErrNone;
sl@0	2133	}
sl@0	2134

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