// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32test.h>

#include <bautils.h>

#include <sqldb.h>

#include <s32file.h>

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

RSqlDatabase TheDb1;

RSqlDatabase TheDb2;

RSqlDatabase ThePrivateDb;

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

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

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

_LIT(KAttachedDbName, "attached_db");

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

const TInt KLargeDataBufLen = 2048;

// A buffer containing 2Kb of data.

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

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

TBuf8<KLargeDataBufLen> TheLargeData;

///////////////////////////////////////////////////////////////////////////////////////

// Test database delete functions

void DeleteTestDbs()

	{

	TheDb1.Close();

	TheDb2.Close();

	ThePrivateDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName1);

	(void)RSqlDatabase::Delete(KTestDbName2);

	(void)RSqlDatabase::Delete(KPrivateSecureDb);

	}

///////////////////////////////////////////////////////////////////////////////////////

// Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DeleteTestDbs();

		TheTest(EFalse, aLine);

		}

	}

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

	{

	if(aValue != aExpected)

		{

		DeleteTestDbs();

		TheTest(EFalse, aLine);

		}

	}

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

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

///////////////////////////////////////////////////////////////////////////////////////

// Test database create functions

void CreateTestDir()

    {

    RFs fs;

	TInt err = fs.Connect();

	TEST2(err, KErrNone);

	err = fs.MkDir(KTestDir);

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

	err = fs.CreatePrivatePath(EDriveC);	

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

	fs.Close();

	}

void CreateTestDbs()

	{

	// Create t_blob1.db

	TInt err = TheDb1.Create(KTestDbName1);

	TEST2(err, KErrNone);

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

	TEST(err >= 0);	

	// Create t_blob2.db

	err = TheDb2.Create(KTestDbName2);

	TEST2(err, KErrNone);

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

	TEST(err >= 0);

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

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

	TEST2(err, 1);	

	// Create private secure db

	err = ThePrivateDb.Create(KPrivateSecureDb);

	TEST2(err, KErrNone);

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

	TEST(err >= 0);

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

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

	TEST2(err, 1);		

	}

void CreateIndices()

	{

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

	TEST(err >= 0);

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

	TEST(err >= 0);

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

	TEST(err >= 0);

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

	TEST(err >= 0);

	}

void RemoveIndices()

	{

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

	TEST(err >= 0);

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

	TEST(err >= 0);

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

	TEST(err >= 0);

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

	TEST(err >= 0);

	}

void AttachTestDb2()

	{

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

	TEST2(err, KErrNone);

	}

void FillLargeDataBuf(TChar aChar = 'Z')

	{

	TheLargeData.Fill(aChar, KLargeDataBufLen);	

	}

///////////////////////////////////////////////////////////////////////////////////////

// Unit test functions

void CheckBlobPropertiesL(TInt aBlobSize)

	{

	// Check properties of the last inserted blob 

	RSqlStatement stmt;

	CleanupClosePushL(stmt);

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

	TEST2(err, KErrNone);

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

	TEST(paramIndex >= 0);	

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

	TEST2(err, KErrNone);

	err = stmt.Next();

	TEST2(err, KSqlAtRow);

	// Check the 'declared column type' is ESqlBinary

	TSqlColumnType declColType;

	err = stmt.DeclaredColumnType(0, declColType);

	TEST2(declColType, ESqlBinary);

	// Check the 'runtime column type' is ESqlBinary

	TSqlColumnType colType = stmt.ColumnType(0);

	TEST2(colType, ESqlBinary);

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

	TInt blobSize = stmt.ColumnSize(0);

	TEST2(blobSize, aBlobSize);

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

	TBool isNull = stmt.IsNull(0);

	TEST2(isNull, EFalse);

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

	TPtrC8 binaryPtr = stmt.ColumnBinaryL(0);

	TEST2(binaryPtr.Length(), aBlobSize);

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

	TPtrC textptr = stmt.ColumnTextL(0);

	TEST2(textptr.Length(), 0);	

	CleanupStack::PopAndDestroy(&stmt);

	}

void InsertBindZeroBlob(TInt aBlobSize)

	{

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

	RSqlStatement stmt;

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

	TEST2(err, KErrNone);

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

	TEST(paramIndex >= 0);	

	err = stmt.BindZeroBlob(paramIndex, aBlobSize);

	TEST2(err, KErrNone);

	err = stmt.Exec();

	stmt.Close();

	TEST2(err, 1);

	}

void InsertSQLiteZeroBlob(TInt aBlobSize)

	{		

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

	RSqlStatement stmt;

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

	TEST2(err, KErrNone);

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

	TEST(paramIndex >= 0);	

	err = stmt.BindInt(paramIndex, aBlobSize);

	TEST2(err, KErrNone);

	err = stmt.Exec();

	stmt.Close();

	TEST2(err, 1);

	}

void InsertBlobValueL(TInt aBlobSize)

	{	

	// Insert a record that contains an actual blob value

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

	TPtr8 binaryDataPtr(binaryData->Des());

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

		{

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

		}

	RSqlStatement stmt;

	CleanupClosePushL(stmt);

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

	TEST2(err, KErrNone);

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

	TEST(paramIndex >= 0);	

	err = stmt.BindBinary(paramIndex, binaryDataPtr);

	TEST2(err, KErrNone);

	err = stmt.Exec();

	TEST2(err, 1);

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

	}	

void StreamBlob1L(TInt aBlobSize) 

	{	

	// Blob 1 is a zeroblob of size aBlobSize

	// Read (zero) data from the blob

	RSqlBlobReadStream rdStrm;

	CleanupClosePushL(rdStrm);

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

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

	TEST2(size, aBlobSize); 

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

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

	TBuf8<50> data;

	rdStrm.ReadL(data, 5);

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

	rdStrm.ReadL(data, 20);

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

	CleanupStack::PopAndDestroy(&rdStrm);

	// Write some actual data to the blob

	RSqlBlobWriteStream wrStrm;

	CleanupClosePushL(wrStrm);

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

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

	TEST2(size, aBlobSize); 

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

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

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

	wrStrm.CommitL();

	CleanupStack::PopAndDestroy(&wrStrm);

	// Read back some of the blob data

	CleanupClosePushL(rdStrm);

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

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

	TEST2(size, aBlobSize);

	rdStrm.ReadL(data, 4);

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

	rdStrm.ReadL(data, 35);

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

	rdStrm.ReadL(data, 19);

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

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

	CleanupStack::PopAndDestroy(&rdStrm);

	}

void StreamText1L() 

	{	

	// Read data from the text column -

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

	RSqlBlobReadStream rdStrm;

	CleanupClosePushL(rdStrm);

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

	TBuf<50> dataUTF16;

	rdStrm.ReadL(dataUTF16, 9);

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

	CleanupStack::PopAndDestroy(&rdStrm);

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

	RSqlBlobWriteStream wrStrm;

	CleanupClosePushL(wrStrm);

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

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

	wrStrm.CommitL();

	CleanupStack::PopAndDestroy(&wrStrm);

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

	CleanupClosePushL(rdStrm);

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

	rdStrm.ReadL(dataUTF16, 9);

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

	CleanupStack::PopAndDestroy(&rdStrm);

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

	CleanupClosePushL(wrStrm);

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

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

	wrStrm.CommitL();

	CleanupStack::PopAndDestroy(&wrStrm);

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

	CleanupClosePushL(rdStrm);

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

	TBuf8<50> dataUTF8;

	rdStrm.ReadL(dataUTF8, 9);

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

	CleanupStack::PopAndDestroy(&rdStrm);

	}

void StreamBlob2L(TInt aBlobSize)

	{

	// Blob 2 is a zeroblob of size aBlobSize

	// Read (zero) data from the blob

	RSqlBlobReadStream rdStrm;

	CleanupClosePushL(rdStrm);

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

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

	TEST2(size, aBlobSize);

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

	_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");

	TBuf8<200> data;

	rdStrm.ReadL(data, 15);

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

	rdStrm.ReadL(data, 61);

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

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

	TEST2(size, aBlobSize); 

	CleanupStack::PopAndDestroy(&rdStrm); 

	// Write some actual data to the blob 

	RSqlBlobWriteStream wrStrm;

	CleanupClosePushL(wrStrm);

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

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

	TEST2(size, aBlobSize);

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

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

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

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

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

	TEST2(size, aBlobSize); 

	wrStrm.CommitL();

	CleanupStack::PopAndDestroy(&wrStrm); 

	// Read back some of the blob data

	CleanupClosePushL(rdStrm);

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

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

	TEST2(size, aBlobSize);

	rdStrm.ReadL(data, 1);

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

	rdStrm.ReadL(data, 136);

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

	rdStrm.ReadL(data, 30);

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

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

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

	TEST2(size, aBlobSize); 

	CleanupStack::PopAndDestroy(&rdStrm);	

	}

void StreamBlob3L(TInt aBlobSize)

	{

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

	// Read some of the zero data

	RSqlBlobReadStream rdStrm;

	CleanupClosePushL(rdStrm);

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

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

	TEST2(size, aBlobSize);

	TBuf8<20> data;

	rdStrm.ReadL(data, 3);

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

	rdStrm.ReadL(data, 12);

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

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

	TEST2(size, aBlobSize); 

	CleanupStack::PopAndDestroy(&rdStrm); 	

	// Write some new data to the blob 

	RSqlBlobWriteStream wrStrm;

	CleanupClosePushL(wrStrm);

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

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

	TEST2(size, aBlobSize);

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

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

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

	TEST2(size, aBlobSize); 

	wrStrm.CommitL();

	CleanupStack::PopAndDestroy(&wrStrm);	

	// Read back some of the blob data

	CleanupClosePushL(rdStrm);

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

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

	TEST2(size, aBlobSize);

	rdStrm.ReadL(data, 2);

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

	rdStrm.ReadL(data, 7);

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

	rdStrm.ReadL(data, 11);

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

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

	TEST2(size, aBlobSize); 

	CleanupStack::PopAndDestroy(&rdStrm);	

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

	CleanupClosePushL(rdStrm);

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

	TStreamPos pos(9);

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

	rdStrm.ReadL(data, 2);

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

	rdStrm.ReadL(data, 5);

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

	TStreamPos pos2(3);

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

	rdStrm.ReadL(data, 4);

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

	TStreamPos pos3(21);

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

	TEST2(err, KErrEof);

	TStreamPos pos4(18);

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

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

	TEST2(err, KErrEof);

	CleanupStack::PopAndDestroy(&rdStrm);	

	CleanupClosePushL(wrStrm);

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

	TStreamPos pos5(7);

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

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

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

	TStreamPos pos6(17);

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

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

	wrStrm.CommitL();

	wrStrm.Close();

	CleanupClosePushL(rdStrm);

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

	rdStrm.ReadL(data, 20);

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

	rdStrm.Close();

	TStreamPos pos7(21);

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

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

	TEST2(err, KErrEof);

	TStreamPos pos8(18);

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

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

	TRAP(err, wrStrm.CommitL());

	TEST2(err, KErrEof);

	wrStrm.Close();

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

	rdStrm.ReadL(data, 20);

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

	CleanupStack::PopAndDestroy(2);	

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4099

@SYMTestCaseDesc		Incremental blob tests on a database using streams.

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

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

						Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.

@SYMTestPriority		Medium

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

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10411

                        REQ10418

*/	

void StreamBindZeroBlobTestL()

	{

	const TInt KBlobSize = 300;

	InsertBindZeroBlob(KBlobSize);

	CheckBlobPropertiesL(KBlobSize);

	StreamBlob1L(KBlobSize);

	StreamText1L();

	CheckBlobPropertiesL(KBlobSize);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4100

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

						Insert a zeroblob using the SQLite function zeroblob(), 

						read and write to the blob using streams.

						Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.

@SYMTestPriority		Medium