sl@0: // Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). sl@0: // All rights reserved. sl@0: // This component and the accompanying materials are made available sl@0: // under the terms of "Eclipse Public License v1.0" sl@0: // which accompanies this distribution, and is available sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: // sl@0: // Initial Contributors: sl@0: // Nokia Corporation - initial contribution. sl@0: // sl@0: // Contributors: sl@0: // sl@0: // Description: sl@0: // sl@0: sl@0: #include sl@0: #include sl@0: #include sl@0: #include sl@0: sl@0: RTest TheTest(_L("t_sqlblob test")); sl@0: sl@0: RSqlDatabase TheDb1; sl@0: RSqlDatabase TheDb2; sl@0: RSqlDatabase ThePrivateDb; sl@0: sl@0: _LIT(KTestDir, "c:\\test\\"); sl@0: _LIT(KTestDbName1, "c:\\test\\t_blob1.db"); sl@0: _LIT(KTestDbName2, "c:\\test\\t_blob2.db"); sl@0: _LIT(KAttachedDbName, "attached_db"); sl@0: _LIT(KPrivateSecureDb, "c:\\private\\1111C1CC\\ps.db"); sl@0: sl@0: const TInt KLargeDataBufLen = 2048; sl@0: sl@0: // A buffer containing 2Kb of data. sl@0: // When it is used to write to a blob the data will exceed the size of the client buffer sl@0: // (which is 8 bytes in debug, 1.5Kb on target) and will be immediately transferred to the server sl@0: TBuf8 TheLargeData; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: // Test database delete functions sl@0: sl@0: void DeleteTestDbs() sl@0: { sl@0: TheDb1.Close(); sl@0: TheDb2.Close(); sl@0: ThePrivateDb.Close(); sl@0: (void)RSqlDatabase::Delete(KTestDbName1); sl@0: (void)RSqlDatabase::Delete(KTestDbName2); sl@0: (void)RSqlDatabase::Delete(KPrivateSecureDb); sl@0: } sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: // Test macros and functions sl@0: sl@0: void Check(TInt aValue, TInt aLine) sl@0: { sl@0: if(!aValue) sl@0: { sl@0: DeleteTestDbs(); sl@0: TheTest(EFalse, aLine); sl@0: } sl@0: } sl@0: void Check(TInt aValue, TInt aExpected, TInt aLine) sl@0: { sl@0: if(aValue != aExpected) sl@0: { sl@0: DeleteTestDbs(); sl@0: RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); sl@0: TheTest(EFalse, aLine); sl@0: } sl@0: } sl@0: #define TEST(arg) ::Check((arg), __LINE__) sl@0: #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: // Test database create functions sl@0: sl@0: void CreateTestDir() sl@0: { sl@0: RFs fs; sl@0: TInt err = fs.Connect(); sl@0: TEST2(err, KErrNone); sl@0: sl@0: err = fs.MkDir(KTestDir); sl@0: TEST(err == KErrNone || err == KErrAlreadyExists); sl@0: sl@0: err = fs.CreatePrivatePath(EDriveC); sl@0: TEST(err == KErrNone || err == KErrAlreadyExists); sl@0: sl@0: fs.Close(); sl@0: } sl@0: sl@0: void CreateTestDbs() sl@0: { sl@0: // Create t_blob1.db sl@0: TInt err = TheDb1.Create(KTestDbName1); sl@0: TEST2(err, KErrNone); sl@0: sl@0: err = TheDb1.Exec(_L("CREATE TABLE table1(I INTEGER, T TEXT, B BLOB)")); sl@0: TEST(err >= 0); sl@0: sl@0: // Create t_blob2.db sl@0: err = TheDb2.Create(KTestDbName2); sl@0: TEST2(err, KErrNone); sl@0: sl@0: err = TheDb2.Exec(_L("CREATE TABLE table2(int INTEGER, text TEXT, blob BLOB)")); sl@0: TEST(err >= 0); sl@0: sl@0: // Insert a blob value of 'FGFGFGFGFG' (10 characters in size) sl@0: err = TheDb2.Exec(_L("INSERT INTO table2 VALUES(1, 'Text Data', x'46474647464746474647')")); sl@0: TEST2(err, 1); sl@0: sl@0: // Create private secure db sl@0: err = ThePrivateDb.Create(KPrivateSecureDb); sl@0: TEST2(err, KErrNone); sl@0: sl@0: err = ThePrivateDb.Exec(_L("CREATE TABLE table3(age INTEGER, name TEXT, picture BLOB)")); sl@0: TEST(err >= 0); sl@0: sl@0: // Insert a blob value of 'ABABABABABABABA' (15 characters in size) sl@0: err = ThePrivateDb.Exec(_L("INSERT INTO table3 VALUES(31, 'John Smith', x'414241424142414241424142414241')")); sl@0: TEST2(err, 1); sl@0: } sl@0: sl@0: void CreateIndices() sl@0: { sl@0: TInt err = TheDb1.Exec(_L("CREATE INDEX textIdx1 on table1(T)")); sl@0: TEST(err >= 0); sl@0: err = TheDb1.Exec(_L("CREATE INDEX blobIdx1 on table1(B)")); sl@0: TEST(err >= 0); sl@0: sl@0: err = TheDb2.Exec(_L("CREATE INDEX textIdx2 on table2(text)")); sl@0: TEST(err >= 0); sl@0: err = TheDb2.Exec(_L("CREATE INDEX blobIdx2 on table2(blob)")); sl@0: TEST(err >= 0); sl@0: } sl@0: sl@0: void RemoveIndices() sl@0: { sl@0: TInt err = TheDb1.Exec(_L("DROP INDEX textIdx1")); sl@0: TEST(err >= 0); sl@0: err = TheDb1.Exec(_L("DROP INDEX blobIdx1")); sl@0: TEST(err >= 0); sl@0: sl@0: err = TheDb2.Exec(_L("DROP INDEX textIdx2")); sl@0: TEST(err >= 0); sl@0: err = TheDb2.Exec(_L("DROP INDEX blobIdx2")); sl@0: TEST(err >= 0); sl@0: } sl@0: sl@0: void AttachTestDb2() sl@0: { sl@0: TInt err = TheDb1.Attach(KTestDbName2, KAttachedDbName); sl@0: TEST2(err, KErrNone); sl@0: } sl@0: sl@0: void FillLargeDataBuf(TChar aChar = 'Z') sl@0: { sl@0: TheLargeData.Fill(aChar, KLargeDataBufLen); sl@0: } sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: // Unit test functions sl@0: sl@0: void CheckBlobPropertiesL(TInt aBlobSize) sl@0: { sl@0: // Check properties of the last inserted blob sl@0: sl@0: RSqlStatement stmt; sl@0: CleanupClosePushL(stmt); sl@0: TInt err = stmt.Prepare(TheDb1, _L("SELECT B FROM table1 WHERE ROWID == :Val")); sl@0: TEST2(err, KErrNone); sl@0: TInt paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindInt(paramIndex, TheDb1.LastInsertedRowId()); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Next(); sl@0: TEST2(err, KSqlAtRow); sl@0: sl@0: // Check the 'declared column type' is ESqlBinary sl@0: TSqlColumnType declColType; sl@0: err = stmt.DeclaredColumnType(0, declColType); sl@0: TEST2(declColType, ESqlBinary); sl@0: // Check the 'runtime column type' is ESqlBinary sl@0: TSqlColumnType colType = stmt.ColumnType(0); sl@0: TEST2(colType, ESqlBinary); sl@0: // Check the 'column size' is the size of the blob sl@0: TInt blobSize = stmt.ColumnSize(0); sl@0: TEST2(blobSize, aBlobSize); sl@0: // Check the 'column value' is not 'NULL' (even for a zeroblob) sl@0: TBool isNull = stmt.IsNull(0); sl@0: TEST2(isNull, EFalse); sl@0: // Check the 'column value' can be retrieved as a binary value sl@0: TPtrC8 binaryPtr = stmt.ColumnBinaryL(0); sl@0: TEST2(binaryPtr.Length(), aBlobSize); sl@0: // Check the 'column value' cannot be retrieved as a text value (it is of type ESqlBinary) sl@0: TPtrC textptr = stmt.ColumnTextL(0); sl@0: TEST2(textptr.Length(), 0); sl@0: CleanupStack::PopAndDestroy(&stmt); sl@0: } sl@0: sl@0: void InsertBindZeroBlob(TInt aBlobSize) sl@0: { sl@0: // Insert a record that has had a zeroblob bound to it sl@0: RSqlStatement stmt; sl@0: TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(1, 'some text', :Val)")); sl@0: TEST2(err, KErrNone); sl@0: TInt paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindZeroBlob(paramIndex, aBlobSize); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: stmt.Close(); sl@0: TEST2(err, 1); sl@0: } sl@0: sl@0: void InsertSQLiteZeroBlob(TInt aBlobSize) sl@0: { sl@0: // Insert a record that contains the 'zeroblob()' function sl@0: RSqlStatement stmt; sl@0: TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(2, 'more text', zeroblob(:Val))")); sl@0: TEST2(err, KErrNone); sl@0: TInt paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindInt(paramIndex, aBlobSize); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: stmt.Close(); sl@0: TEST2(err, 1); sl@0: } sl@0: sl@0: void InsertBlobValueL(TInt aBlobSize) sl@0: { sl@0: // Insert a record that contains an actual blob value sl@0: HBufC8* binaryData = HBufC8::NewLC(aBlobSize); sl@0: TPtr8 binaryDataPtr(binaryData->Des()); sl@0: for(TInt i = 0; i < aBlobSize/2; ++i) sl@0: { sl@0: binaryDataPtr.Append(_L8("DE")); sl@0: } sl@0: sl@0: RSqlStatement stmt; sl@0: CleanupClosePushL(stmt); sl@0: TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(3, 'even more text', :Val)")); sl@0: TEST2(err, KErrNone); sl@0: TInt paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindBinary(paramIndex, binaryDataPtr); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: TEST2(err, 1); sl@0: CleanupStack::PopAndDestroy(2); // stmt, binaryData sl@0: } sl@0: sl@0: void StreamBlob1L(TInt aBlobSize) sl@0: { sl@0: // Blob 1 is a zeroblob of size aBlobSize sl@0: sl@0: // Read (zero) data from the blob sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: _LIT8(KFiveZeros, "\x0\x0\x0\x0\x0"); sl@0: _LIT8(KTwentyZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); sl@0: TBuf8<50> data; sl@0: rdStrm.ReadL(data, 5); sl@0: TEST(data.Compare(KFiveZeros) == 0); // check 5 bytes of zero have been read sl@0: rdStrm.ReadL(data, 20); sl@0: TEST(data.Compare(KTwentyZeros) == 0); // check 20 bytes of zero have been read sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Write some actual data to the blob sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: wrStrm.WriteL(_L8("AABBCCDDEE")); // write 10 bytes sl@0: wrStrm.WriteL(_L8("FFGGHHIIJJ")); // write another 10 bytes sl@0: wrStrm.WriteL(_L8("KKLLMMNNOOPPQQRRSSTTUUVVWWXX")); // write another 28 bytes sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Read back some of the blob data sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: rdStrm.ReadL(data, 4); sl@0: TEST(data.Compare(_L8("AABB")) == 0); // check the first 4 bytes sl@0: rdStrm.ReadL(data, 35); sl@0: TEST(data.Compare(_L8("CCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSST")) == 0); // check the next 35 bytes sl@0: rdStrm.ReadL(data, 19); sl@0: _LIT8(KTrailingZeros, "TUUVVWWXX\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); sl@0: TEST(data.Compare(KTrailingZeros) == 0); // check the next 19 bytes (which includes some of the original zero bytes) sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: } sl@0: sl@0: void StreamText1L() sl@0: { sl@0: // Read data from the text column - sl@0: // the database encoding is UTF-16 so the text is stored as UTF-16 sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("T")); sl@0: TBuf<50> dataUTF16; sl@0: rdStrm.ReadL(dataUTF16, 9); sl@0: TEST(dataUTF16.Compare(_L("some text")) == 0); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Write some data to the text column (as UTF-16) sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("T")); sl@0: wrStrm.WriteL(_L("new text!")); // can only write up to the original size of the data - 9 chars sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Read back some of the text (as UTF-16) sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("T")); sl@0: rdStrm.ReadL(dataUTF16, 9); sl@0: TEST(dataUTF16.Compare(_L("new text!")) == 0); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Write some data to the text column (as UTF-8) sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("T")); sl@0: wrStrm.WriteL(_L8("try again")); sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Read back some of the text (as UTF-8) sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("T")); sl@0: TBuf8<50> dataUTF8; sl@0: rdStrm.ReadL(dataUTF8, 9); sl@0: TEST(dataUTF8.Compare(_L8("try again")) == 0); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: } sl@0: sl@0: void StreamBlob2L(TInt aBlobSize) sl@0: { sl@0: // Blob 2 is a zeroblob of size aBlobSize sl@0: sl@0: // Read (zero) data from the blob sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: _LIT8(KFifteenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); sl@0: _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: TBuf8<200> data; sl@0: rdStrm.ReadL(data, 15); sl@0: TEST(data.Compare(KFifteenZeros) == 0); // check 15 bytes of zero have been read sl@0: rdStrm.ReadL(data, 61); sl@0: TEST(data.Compare(KSixtyOneZeros) == 0); // check 61 bytes of zero have been read sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Write some actual data to the blob sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATAS")); // write 23 bytes sl@0: wrStrm.WriteL(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATA")); // write another 43 bytes sl@0: wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENE")); // write another 72 bytes sl@0: wrStrm.WriteL(_L8("WDATASOMENEWDATA")); // write another 16 bytes sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Read back some of the blob data sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: rdStrm.ReadL(data, 1); sl@0: TEST(data.Compare(_L8("S")) == 0); // check the first byte sl@0: rdStrm.ReadL(data, 136); sl@0: TEST(data.Compare(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMEN")) == 0); // check the next 136 bytes sl@0: rdStrm.ReadL(data, 30); sl@0: _LIT8(KTrailingZeros, "EWDATASOMENEWDATA\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); sl@0: TEST(data.Compare(KTrailingZeros) == 0); // check the next 30 bytes (which includes some of the original zero bytes) sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: } sl@0: sl@0: void StreamBlob3L(TInt aBlobSize) sl@0: { sl@0: // Blob 3 is a 'real' blob of value "DEDEDEDEDEDEDEDEDEDE" sl@0: sl@0: // Read some of the zero data sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: TBuf8<20> data; sl@0: rdStrm.ReadL(data, 3); sl@0: TEST(data.Compare(_L8("DED")) == 0); // check the first 3 bytes sl@0: rdStrm.ReadL(data, 12); sl@0: TEST(data.Compare(_L8("EDEDEDEDEDED")) == 0); // check the next 12 bytes sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Write some new data to the blob sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: wrStrm.WriteL(_L8("ABCDEF")); // write 6 bytes sl@0: wrStrm.WriteL(_L8("GHIJKLMNOPQ")); // write another 11 bytes sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Read back some of the blob data sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: rdStrm.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("AB")) == 0); // check the first 2 bytes sl@0: rdStrm.ReadL(data, 7); sl@0: TEST(data.Compare(_L8("CDEFGHI")) == 0); // check the next 7 bytes sl@0: rdStrm.ReadL(data, 11); sl@0: TEST(data.Compare(_L8("JKLMNOPQEDE")) == 0); // check the next 11 bytes sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, aBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Seek to position - the blob value is now "ABCDEFGHIJKLMNOPQEDE" sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TStreamPos pos(9); sl@0: rdStrm.Source()->SeekL(MStreamBuf::ERead, pos); sl@0: rdStrm.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("JK")) == 0); sl@0: rdStrm.ReadL(data, 5); sl@0: TEST(data.Compare(_L8("LMNOP")) == 0); sl@0: TStreamPos pos2(3); sl@0: rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2); sl@0: rdStrm.ReadL(data, 4); sl@0: TEST(data.Compare(_L8("DEFG")) == 0); sl@0: TStreamPos pos3(21); sl@0: TRAPD(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3)); sl@0: TEST2(err, KErrEof); sl@0: TStreamPos pos4(18); sl@0: rdStrm.Source()->SeekL(MStreamBuf::ERead, pos4); sl@0: TRAP(err, rdStrm.ReadL(data, 3)); sl@0: TEST2(err, KErrEof); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TStreamPos pos5(7); sl@0: wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos5); sl@0: wrStrm.WriteL(_L8("ZZZZZ")); sl@0: wrStrm.WriteL(_L8("YYY")); sl@0: TStreamPos pos6(17); sl@0: wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos6); sl@0: wrStrm.WriteL(_L8("XXX")); sl@0: wrStrm.CommitL(); sl@0: wrStrm.Close(); sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: rdStrm.ReadL(data, 20); sl@0: TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0); sl@0: rdStrm.Close(); sl@0: TStreamPos pos7(21); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos7)); sl@0: TEST2(err, KErrEof); sl@0: TStreamPos pos8(18); sl@0: wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos8); sl@0: wrStrm.WriteL(_L8("TTT")); sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrEof); sl@0: wrStrm.Close(); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: rdStrm.ReadL(data, 20); sl@0: TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0); sl@0: CleanupStack::PopAndDestroy(2); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4099 sl@0: @SYMTestCaseDesc Incremental blob tests on a database using streams. sl@0: Insert a zeroblob using RSqlStatement::BindZeroBlob(), read and write to sl@0: the blob using streams, also read and write to a text column using streams. sl@0: Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of incremental blob stream operations on a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void StreamBindZeroBlobTestL() sl@0: { sl@0: const TInt KBlobSize = 300; sl@0: InsertBindZeroBlob(KBlobSize); sl@0: CheckBlobPropertiesL(KBlobSize); sl@0: StreamBlob1L(KBlobSize); sl@0: StreamText1L(); sl@0: CheckBlobPropertiesL(KBlobSize); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4100 sl@0: @SYMTestCaseDesc Incremental blob tests on a database, using streams. sl@0: Insert a zeroblob using the SQLite function zeroblob(), sl@0: read and write to the blob using streams. sl@0: Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of incremental blob stream operations on a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void StreamSqliteZeroBlobTestL() sl@0: { sl@0: const TInt KBlobSize = 1500; sl@0: InsertSQLiteZeroBlob(KBlobSize); sl@0: CheckBlobPropertiesL(KBlobSize); sl@0: StreamBlob2L(KBlobSize); sl@0: CheckBlobPropertiesL(KBlobSize); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4101 sl@0: @SYMTestCaseDesc Incremental blob tests on a database, using streams. sl@0: Insert a real blob, read and write to the blob using streams. sl@0: Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of incremental blob stream operations on a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void StreamRealBlobTestL() sl@0: { sl@0: const TInt KBlobSize = 20; sl@0: InsertBlobValueL(KBlobSize); sl@0: CheckBlobPropertiesL(KBlobSize); sl@0: StreamBlob3L(KBlobSize); sl@0: CheckBlobPropertiesL(KBlobSize); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4102 sl@0: @SYMTestCaseDesc Whole value blob retrieval tests on a database. sl@0: Retrieve the whole value of a blob object in one go. sl@0: Tests the TSqlBlob 'get' methods. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of whole value blob retrieval operations on a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void GetWholeBlob3L() sl@0: { sl@0: // Blob 3 is a 'real' blob of value "ABCDEFGZZZZZYYYPQXXX" sl@0: const TInt KBlobSize = 20; sl@0: sl@0: // Get the whole content of Blob 3 in one go, using TSqlBlob::GetLC() sl@0: HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); sl@0: TInt bufSize = wholeBuf->Size(); sl@0: TEST2(bufSize, KBlobSize); sl@0: TEST(wholeBuf->Des().Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: sl@0: // Get the whole content of Blob 3 in one go, using TSqlBlob::Get() sl@0: HBufC8* buf = HBufC8::NewLC(KBlobSize); sl@0: TPtr8 bufPtr(buf->Des()); sl@0: TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr); sl@0: TEST2(err, KErrNone); sl@0: TEST(bufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0); sl@0: CleanupStack::PopAndDestroy(buf); sl@0: sl@0: // Get the whole content of Blob 3 in one go, using TSqlBlob::Get(), sl@0: // ensuring that a buffer larger than the blob can be used sl@0: HBufC8* largerBuf = HBufC8::NewLC(KBlobSize * 2); sl@0: TPtr8 largerBufPtr(largerBuf->Des()); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), largerBufPtr); sl@0: TEST2(err, KErrNone); sl@0: TEST(largerBufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0); sl@0: CleanupStack::PopAndDestroy(largerBuf); sl@0: sl@0: // Get the whole content of the blob in 2 chunks of 10 bytes sl@0: HBufC8* streamBuf = HBufC8::NewLC(10); sl@0: TPtr8 streamBufPtr(streamBuf->Des()); sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = rdStrm.SizeL(); sl@0: TEST2(size, KBlobSize); sl@0: HBufC8* combinedData = HBufC8::NewLC(KBlobSize); sl@0: TPtr8 combinedDataPtr(combinedData->Des()); sl@0: for(TInt i = 2; i > 0 ; --i) sl@0: { sl@0: rdStrm.ReadL(streamBufPtr, 10); sl@0: combinedDataPtr.Append(streamBufPtr); sl@0: } sl@0: TEST(combinedDataPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0); sl@0: CleanupStack::PopAndDestroy(3); // combinedDataRead, rdStrm, streamBuf sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4104 sl@0: @SYMTestCaseDesc Whole value blob write tests on a database. sl@0: Write the whole value of a blob object in one go. sl@0: Tests the TSqlBlob 'set' methods. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of whole value blob write operations on a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void SetWholeBlob3L() sl@0: { sl@0: // Blob 3 is a 'real' blob of value "KKKKKKKKKKKKKKKKKEDE" sl@0: TInt KBlobSize = 20; sl@0: sl@0: // Set the whole content of Blob 3 in one go sl@0: HBufC8* dataBuf = HBufC8::NewLC(KBlobSize); sl@0: TPtr8 dataPtr(dataBuf->Des()); sl@0: dataPtr.Append(_L8("CDCDCDCDCDCDCDCDCDCD")); sl@0: TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), dataPtr); sl@0: CleanupStack::PopAndDestroy(dataBuf); sl@0: sl@0: // Check that the new blob data was written sl@0: HBufC8* retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); sl@0: TInt blobLength = retrievedDataBuf->Size(); sl@0: TEST2(blobLength, KBlobSize); sl@0: TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDCDCDCD")) == 0); sl@0: CleanupStack::PopAndDestroy(retrievedDataBuf); sl@0: sl@0: // Set the whole content of the blob in 2 chunks of 10 bytes sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = wrStrm.SizeL(); sl@0: TEST2(size, KBlobSize); sl@0: for(TInt i = 2; i > 0; --i) sl@0: { sl@0: wrStrm.WriteL(_L8("ZYZYZYZYZY")); sl@0: } sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Check that the new blob data was written sl@0: retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); sl@0: blobLength = retrievedDataBuf->Size(); sl@0: TEST2(blobLength, KBlobSize); sl@0: TEST(retrievedDataBuf->Des().Compare(_L8("ZYZYZYZYZYZYZYZYZYZY")) == 0); sl@0: CleanupStack::PopAndDestroy(retrievedDataBuf); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4106 sl@0: @SYMTestCaseDesc Blob read and write tests on an attached database. sl@0: Performs streaming and whole value read and write operations sl@0: on a blob in an attached database to ensure that the sl@0: RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods sl@0: can be used on an attached database. sl@0: Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of blob read and write operations on an attached database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void AttachDbTestL() sl@0: { sl@0: // Attach test db 2 to test db 1 sl@0: AttachTestDb2(); sl@0: sl@0: // Open a read stream on a blob in the attached database - sl@0: // the blob in the single record has a value of "FGFGFGFGFG" sl@0: const TInt KAttachedBlobSize = 10; sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: TInt size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KAttachedBlobSize); sl@0: TBuf8<20> data; sl@0: rdStrm.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("FG")) == 0); // check the first 2 bytes sl@0: rdStrm.ReadL(data, 8); sl@0: TEST(data.Compare(_L8("FGFGFGFG")) == 0); // check the next 8 bytes sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KAttachedBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Write some new data to the blob sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KAttachedBlobSize); sl@0: wrStrm.WriteL(_L8("LLLL")); // write 4 bytes sl@0: wrStrm.WriteL(_L8("MMMMM")); // write another 5 bytes sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KAttachedBlobSize); sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Read back some of the blob data sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KAttachedBlobSize); sl@0: rdStrm.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("LL")) == 0); // check the first 2 bytes sl@0: rdStrm.ReadL(data, 5); sl@0: TEST(data.Compare(_L8("LLMMM")) == 0); // check the next 5 bytes sl@0: rdStrm.ReadL(data, 3); sl@0: TEST(data.Compare(_L8("MMG")) == 0); // check the next 3 bytes sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KAttachedBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // Get the entire blob in the attached database sl@0: HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: TInt blobLength = wholeBuf->Length(); sl@0: TEST2(blobLength, KAttachedBlobSize); sl@0: TEST(wholeBuf->Des().Compare(_L8("LLLLMMMMMG")) == 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: sl@0: TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: TEST(data.Compare(_L8("LLLLMMMMMG")) == 0); sl@0: sl@0: // Set the entire blob in the attached database sl@0: data.Zero(); sl@0: data.Append(_L8("STSTSTSTST")); sl@0: TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); sl@0: TEST(wholeBuf->Des().Compare(_L8("STSTSTSTST")) == 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: } sl@0: sl@0: void BadParamReadStreamL() sl@0: { sl@0: HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1); sl@0: TPtr tooLongNameDes = tooLongName->Des(); sl@0: tooLongNameDes.Fill('A', KMaxFileName + 1); sl@0: sl@0: // RSqlBlobReadStream::OpenL() sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: TRAPD(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), -12)); // illegal ROWID sl@0: TEST2(err, KErrArgument); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: CleanupStack::PopAndDestroy(tooLongName); sl@0: sl@0: // RSqlBlobReadStream::Source()::SeekL() sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = rdStrm.SizeL(); sl@0: TEST(size > 0); sl@0: TStreamPos pos(-1); sl@0: TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos)); sl@0: TEST2(err, KErrEof); sl@0: TStreamPos pos2(size - 1); sl@0: TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2)); sl@0: TEST2(err, KErrNone); sl@0: TStreamPos pos3(size + 1); sl@0: TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3)); sl@0: TEST2(err, KErrEof); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: // RSqlBlobReadStream::ReadL() sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = rdStrm.SizeL(); sl@0: TEST2(size, 20); sl@0: TBuf8<20> dataBuf; sl@0: TBuf8<50> tooBigDataBuf; sl@0: TRAP(err, rdStrm.ReadL(tooBigDataBuf)); sl@0: TEST2(err, KErrEof); sl@0: rdStrm.Close(); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(tooBigDataBuf, size + 1)); sl@0: TEST2(err, KErrEof); sl@0: rdStrm.Close(); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(tooBigDataBuf, TChar('J'))); // doesn't find 'J' so tries to fill the buffer to its max size sl@0: TEST2(err, KErrEof); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: } sl@0: sl@0: void BadParamWriteStreamL() sl@0: { sl@0: HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1); sl@0: TPtr tooLongNameDes = tooLongName->Des(); sl@0: tooLongNameDes.Fill('A', KMaxFileName + 1); sl@0: sl@0: // RSqlBlobWriteStream::OpenL() sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 0)); // illegal ROWID sl@0: TEST2(err, KErrArgument); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: CleanupStack::PopAndDestroy(tooLongName); sl@0: sl@0: // RSqlBlobWriteStream::Sink()::SeekL() sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = wrStrm.SizeL(); sl@0: TEST(size > 0); sl@0: TStreamPos pos(-1); sl@0: TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos)); sl@0: TEST2(err, KErrEof); sl@0: TStreamPos pos2(size - 1); sl@0: TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos2)); sl@0: TEST2(err, KErrNone); sl@0: TStreamPos pos3(size + 1); sl@0: TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos3)); sl@0: TEST2(err, KErrEof); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // RSqlBlobWriteStream::WriteL() sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = wrStrm.SizeL(); sl@0: TEST2(size, 20); sl@0: TBuf8<50> tooBigDataBuf; sl@0: tooBigDataBuf.Fill('B', 50); sl@0: TRAP(err, wrStrm.WriteL(tooBigDataBuf)); sl@0: #ifdef _DEBUG sl@0: TEST2(err, KErrEof); sl@0: #else sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrEof); sl@0: #endif sl@0: wrStrm.Close(); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, wrStrm.WriteL(tooBigDataBuf, size + 1)); sl@0: #ifdef _DEBUG sl@0: TEST2(err, KErrEof); sl@0: #else sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrEof); sl@0: #endif sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: } sl@0: sl@0: void BadParamGetL() sl@0: { sl@0: HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1); sl@0: TPtr tooLongNameDes = tooLongName->Des(); sl@0: tooLongNameDes.Fill('A', KMaxFileName + 1); sl@0: sl@0: // TSqlBlob::GetLC() sl@0: HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on a BLOB column) sl@0: TInt blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on a TEXT column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: TRAPD(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table1"), _L("B"))); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L(""), _L("B"))); // empty table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, tooLongNameDes, _L("B"))); // too long table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L(""))); // empty column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), tooLongNameDes)); // too long column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("I"))); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), -2)); // illegal ROWID sl@0: TEST2(err, KErrArgument); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), 3731)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), 345, KAttachedDbName)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name sl@0: TEST2(err, KErrBadName); sl@0: sl@0: // TSqlBlob::Get() sl@0: HBufC8* buf = HBufC8::NewLC(50); sl@0: TPtr8 bufPtr(buf->Des()); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr); // a successful get (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr); // a successful get (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb2, _L("table1"), _L("B"), bufPtr); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L(""), _L("B"), bufPtr); // empty table name sl@0: TEST2(err, KErrBadName); sl@0: err = TSqlBlob::Get(TheDb1, tooLongNameDes, _L("B"), bufPtr); // too long table name sl@0: TEST2(err, KErrBadName); sl@0: err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("B"), bufPtr); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L(""), bufPtr); // empty column name sl@0: TEST2(err, KErrBadName); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), tooLongNameDes, bufPtr); // too long column name sl@0: TEST2(err, KErrBadName); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("invalidColumnName"), bufPtr); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("I"), bufPtr); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 0); // illegal ROWID sl@0: TEST2(err, KErrArgument); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 3731); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("invalidColumnName"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("int"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, 345, KAttachedDbName); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName")); // invalid attached db name sl@0: TEST2(err, KSqlErrGeneral); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), tooLongNameDes); // too long attached db name sl@0: TEST2(err, KErrBadName); sl@0: CleanupStack::PopAndDestroy(buf); sl@0: sl@0: CleanupStack::PopAndDestroy(tooLongName); sl@0: } sl@0: sl@0: void BadParamSetL() sl@0: { sl@0: HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1); sl@0: TPtr tooLongNameDes = tooLongName->Des(); sl@0: tooLongNameDes.Fill('A', KMaxFileName + 1); sl@0: sl@0: // TSqlBlob::SetL() sl@0: TRAPD(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // a successful set (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // a successful set (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb2, _L("table1"), _L("B"), _L8("twenty characters..."))); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L(""), _L("B"), _L8("twenty characters..."))); // empty table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, tooLongNameDes, _L("B"), _L8("twenty characters..."))); // too long table name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("B"), _L8("twenty characters..."))); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L(""), _L8("twenty characters..."))); // empty column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), tooLongNameDes, _L8("twenty characters..."))); // too long column name sl@0: TEST2(err, KErrBadName); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("invalidColumnName"), _L8("twenty characters..."))); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("I"), _L8("twenty characters..."))); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), -3)); // illegal ROWID sl@0: TEST2(err, KErrArgument); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), 1113)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: 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: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L(""))); // a successful set (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: 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: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L(""))); // a successful set (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful set (on a BLOB column) sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("text"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful set (on a TEXT column) sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, TSqlBlob::SetL(TheDb2, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("invalidColumnName"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("int"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), 13, KAttachedDbName)); // invalid ROWID sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name sl@0: TEST2(err, KErrBadName); sl@0: sl@0: CleanupStack::PopAndDestroy(tooLongName); sl@0: } sl@0: sl@0: void BadParamBindZeroBlobL() sl@0: { sl@0: // RSqlStatement::BindZeroBlob() sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: RSqlStatement stmt; sl@0: CleanupClosePushL(stmt); sl@0: TInt err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(1, 'dummy text', :Val)")); sl@0: TEST2(err, KErrNone); sl@0: TInt paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindZeroBlob(paramIndex, -1); // a negative blob size sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: TEST2(err, 1); sl@0: stmt.Reset(); sl@0: rdStrm.OpenL(TheDb2, _L("table2"), _L("blob")); sl@0: TInt size = rdStrm.SizeL(); // check the blob's size is 0 (0 is used if a negative number was specified) sl@0: TEST2(size, 0); sl@0: rdStrm.Close(); sl@0: err = stmt.BindZeroBlob(paramIndex, 0); // a blob size of zero sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: TEST2(err, 1); sl@0: stmt.Reset(); sl@0: rdStrm.OpenL(TheDb2, _L("table2"), _L("blob")); sl@0: size = rdStrm.SizeL(); // check the blob's size is 0 sl@0: TEST2(size, 0); sl@0: // For subsequent test purposes make the last inserted record have a zeroblob > 0 size sl@0: err = stmt.BindZeroBlob(paramIndex, 1); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: TEST2(err, 1); sl@0: CleanupStack::PopAndDestroy(&stmt); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4107 sl@0: @SYMTestCaseDesc Bad parameter tests for the methods of RSqlBlobReadStream, sl@0: RSqlBlobWriteStream, TSqlBlob and RSqlStatement::BindZeroBlob(). sl@0: Tests that the correct error code is returned when a bad parameter sl@0: is used in a call to one of the methods. sl@0: Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods sl@0: and RSqlStatement::BindZeroBlob(). sl@0: @SYMTestPriority High sl@0: @SYMTestActions Execution of bad parameter tests. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void BadParamTestL() sl@0: { sl@0: BadParamReadStreamL(); sl@0: BadParamWriteStreamL(); sl@0: BadParamGetL(); sl@0: BadParamSetL(); sl@0: BadParamBindZeroBlobL(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4108 sl@0: @SYMTestCaseDesc Indexed column tests for the methods of RSqlBlobReadStream sl@0: and RSqlBlobWriteStream, to ensure that a blob or text column sl@0: that is indexed cannot be written to but can be read from sl@0: (an SQLite restriction). sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of read and write operations on an indexed column in a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void IndexedColumnTestL() sl@0: { sl@0: // Create an index on the BLOB column and on the TEXT column in the main and attached databases sl@0: CreateIndices(); sl@0: sl@0: // Attempt to open a write stream on an indexed BLOB and an indexed TEXT column - this should not be permitted. sl@0: // (This is an SQLite restriction, but having an index on a large BLOB or a TEXT column is highly unlikely!) sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // indexed BLOB column sl@0: TEST2(err, KSqlErrGeneral); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // indexed TEXT column sl@0: TEST2(err, KSqlErrGeneral); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed BLOB column sl@0: TEST2(err, KSqlErrGeneral); sl@0: wrStrm.Close(); sl@0: TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed TEXT column sl@0: TEST2(err, KSqlErrGeneral); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // indexed BLOB column sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // indexed TEXT column sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed BLOB column sl@0: TEST2(err, KSqlErrGeneral); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("text"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed TEXT column sl@0: TEST2(err, KSqlErrGeneral); sl@0: sl@0: // Attempt to open a read stream on an indexed BLOB and an indexed text COLUMN - this should be permitted sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on an indexed BLOB column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on an indexed TEXT column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on an indexed BLOB column) sl@0: TEST2(err, KErrNone); sl@0: rdStrm.Close(); sl@0: TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on an indexed TEXT column) sl@0: TEST2(err, KErrNone); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on an indexed BLOB column) sl@0: TInt blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on an indexed TEXT column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed BLOB column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed TEXT column) sl@0: blobLength = wholeBuf->Length(); sl@0: TEST(blobLength > 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: HBufC8* buf = HBufC8::NewLC(50); sl@0: TPtr8 buffPtr(buf->Des()); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), buffPtr); // a successful get (on an indexed BLOB column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), buffPtr); // a successful get (on an indexed TEXT column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), buffPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed BLOB column) sl@0: TEST2(err, KErrNone); sl@0: err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), buffPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed TEXT column) sl@0: TEST2(err, KErrNone); sl@0: CleanupStack::PopAndDestroy(buf); sl@0: sl@0: RemoveIndices(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4109 sl@0: @SYMTestCaseDesc 'End of file' tests for the methods of RSqlBlobReadStream sl@0: RSqlBlobWriteStream and TSqlBlob, to ensure that a client cannot sl@0: read beyond the end of a blob object or write beyond the end of a sl@0: blob object and that an appropriate error code is returned. sl@0: @SYMTestPriority High sl@0: @SYMTestActions Execution of read and write operations beyond the end of a blob object. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void EofTestL() sl@0: { sl@0: // Use Blob 3 in table1, whose value is "!!!twenty characters" sl@0: sl@0: // Read Eof tests sl@0: sl@0: const TInt KBlobSize = 20; sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TInt size = rdStrm.SizeL(); sl@0: TEST2(size, KBlobSize); sl@0: TBuf8<50> data; sl@0: TRAPD(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("!!!twenty characters")) == 0); sl@0: TRAP(err, rdStrm.ReadL(data, 1)); sl@0: TEST2(err, KErrEof); sl@0: rdStrm.Close(); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, 21)); sl@0: TEST2(err, KErrEof); sl@0: rdStrm.Close(); sl@0: sl@0: HBufC8* exactSizeBuf = HBufC8::NewLC(KBlobSize); sl@0: TPtr8 exactSizeBufPtr(exactSizeBuf->Des()); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), exactSizeBufPtr); sl@0: TEST2(err, KErrNone); sl@0: TEST(exactSizeBufPtr.Compare(_L8("!!!twenty characters")) == 0); sl@0: CleanupStack::PopAndDestroy(exactSizeBuf); sl@0: sl@0: HBufC8* tooSmallBuf = HBufC8::NewLC(KBlobSize/2); sl@0: TPtr8 tooSmallBufPtr(tooSmallBuf->Des()); sl@0: err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), tooSmallBufPtr); sl@0: TEST2(err, KErrOverflow); sl@0: CleanupStack::PopAndDestroy(tooSmallBuf); sl@0: sl@0: // Write Eof tests sl@0: sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: size = wrStrm.SizeL(); sl@0: TEST2(size, KBlobSize); sl@0: // For debug builds: This 20 bytes will be written to the blob straight away sl@0: // because 20 bytes is more than the 8 byte buffer sl@0: // For release builds: This 20 bytes will NOT be written to the blob straight away sl@0: // because there is room for it to be stored in the 1.5K byte buffer sl@0: TRAP(err, wrStrm.WriteL(_L8("a twenty char string"))); sl@0: TEST2(err, KErrNone); sl@0: // For debug/release builds: This 1 byte will NOT be written to the blob straight away sl@0: // because there is room for it to be stored in the 8 byte/1.5K buffer sl@0: TRAP(err, wrStrm.WriteL(_L8("a"))); sl@0: TEST2(err, KErrNone); sl@0: // For debug builds: The CommitL() call will cause an attempt to write the 1 byte sl@0: // in the buffer to the blob - however, the stream's write position indicates sl@0: // that the write would be beyond the end of the blob and so an error occurs sl@0: // For release builds: The CommitL() call will cause an attempt to write the 21 bytes sl@0: // in the buffer to the blob - however, 21 bytes is larger than the size of the blob sl@0: // and so an error occurs sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrEof); sl@0: wrStrm.Close(); sl@0: // For debug builds: Check that the blob value is now "a twenty char string" sl@0: // For release builds: Check that the blob value is still "!!!twenty characters" sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: #ifdef _DEBUG sl@0: TEST(data.Compare(_L8("a twenty char string")) == 0); sl@0: #else sl@0: TEST(data.Compare(_L8("!!!twenty characters")) == 0); sl@0: #endif sl@0: rdStrm.Close(); sl@0: sl@0: TheDb1.Exec(_L("BEGIN")); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: // For debug/release builds: These 3 bytes will be stored in the 8 byte/1.5K buffer sl@0: TRAP(err, wrStrm.WriteL(_L8("eee"))); sl@0: TEST2(err, KErrNone); sl@0: // For debug builds: These 25 bytes will not fit in the 8 byte buffer and so an attempt sl@0: // will be made to write these 25 bytes and the 3 buffered bytes to the blob - sl@0: // however, the size of the blob is only 20 and so an error occurs sl@0: // For release builds: These 25 bytes will be stored in the 1.5K buffer sl@0: TRAP(err, wrStrm.WriteL(_L8("fffffffffffffffffffffffff"))); sl@0: #ifdef _DEBUG sl@0: TEST2(err, KErrEof); sl@0: wrStrm.Close(); sl@0: TheDb1.Exec(_L("ROLLBACK")); sl@0: sl@0: // Check that the blob value is still "a twenty char string" sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("a twenty char string")) == 0); sl@0: rdStrm.Close(); sl@0: #else sl@0: TEST2(err, KErrNone); sl@0: // For release builds: The CommitL() call will cause an attempt to write the 28 bytes sl@0: // in the buffer to the blob - however, 28 bytes is larger than the size of the blob sl@0: // and so an error occurs sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrEof); sl@0: wrStrm.Close(); sl@0: TheDb1.Exec(_L("ROLLBACK")); sl@0: sl@0: // Check that the blob value is still "!!!twenty characters" sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("!!!twenty characters")) == 0); sl@0: rdStrm.Close(); sl@0: #endif sl@0: sl@0: TheDb1.Exec(_L("BEGIN")); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, wrStrm.WriteL(_L8("a string that is longer than 20 characters"))); sl@0: #ifdef _DEBUG sl@0: TEST2(err, KErrEof); sl@0: wrStrm.Close(); sl@0: TheDb1.Exec(_L("ROLLBACK")); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, wrStrm.WriteL(_L8("ggg"))); sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrNone); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: // Check that the blob value is now "gggwenty char string" sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("gggwenty char string")) == 0); sl@0: rdStrm.Close(); sl@0: #else sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrEof); sl@0: wrStrm.Close(); sl@0: TheDb1.Exec(_L("ROLLBACK")); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, wrStrm.WriteL(_L8("hhh"))); sl@0: TEST2(err, KErrNone); sl@0: TRAP(err, wrStrm.CommitL()); sl@0: TEST2(err, KErrNone); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: // Check that the blob value is now "hhhtwenty characters" sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("hhhtwenty characters")) == 0); sl@0: rdStrm.Close(); sl@0: #endif sl@0: sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("a twenty char string"))); sl@0: TEST2(err, KErrNone); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("a twenty char string")) == 0); sl@0: rdStrm.Close(); sl@0: sl@0: TheDb1.Exec(_L("BEGIN")); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("a string that is longer than 20 characters"))); sl@0: TEST2(err, KErrEof); sl@0: TheDb1.Exec(_L("ROLLBACK")); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); sl@0: TEST(data.Compare(_L8("a twenty char string")) == 0); sl@0: rdStrm.Close(); sl@0: sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("less than 20"))); sl@0: TEST2(err, KErrNone); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: TRAP(err, rdStrm.ReadL(data, KBlobSize)); sl@0: TEST2(err, KErrNone); // changing only part of the blob data is permitted sl@0: TEST(data.Compare(_L8("less than 20r string")) == 0); sl@0: rdStrm.Close(); sl@0: sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4110 sl@0: @SYMTestCaseDesc General blob read and write tests on a private secure database, sl@0: to ensure that there are no security issues with the methods of sl@0: RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob. sl@0: @SYMTestPriority High sl@0: @SYMTestActions Execution of read and write operations on a private secure database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: REQ5794 sl@0: */ sl@0: void PrivateSecureDbTestL() sl@0: { sl@0: // The blob has the value 'ABABABABABABABA' sl@0: sl@0: // Read data from the blob sl@0: const TInt KBlobSize = 15; sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(ThePrivateDb, _L("table3"), _L("picture")); sl@0: TInt size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KBlobSize); sl@0: TBuf8<50> data; sl@0: rdStrm.ReadL(data, 5); sl@0: TEST(data.Compare(_L8("ABABA")) == 0); // check 5 bytes have been read sl@0: rdStrm.ReadL(data, 8); sl@0: TEST(data.Compare(_L8("BABABABA")) == 0); // check the next 8 bytes have been read sl@0: rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KBlobSize); sl@0: CleanupStack::PopAndDestroy(&rdStrm); sl@0: sl@0: HBufC8* wholeBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture")); sl@0: TInt blobLength = wholeBuf->Length(); sl@0: TEST2(blobLength, KBlobSize); sl@0: TEST(wholeBuf->Des().Compare(_L8("ABABABABABABABA")) == 0); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: sl@0: HBufC8* buf = HBufC8::NewLC(KBlobSize); sl@0: TPtr8 bufPtr(buf->Des()); sl@0: TInt err = TSqlBlob::Get(ThePrivateDb, _L("table3"), _L("picture"), bufPtr); sl@0: TEST2(err, KErrNone); sl@0: TEST(bufPtr.Compare(_L8("ABABABABABABABA")) == 0); sl@0: CleanupStack::PopAndDestroy(buf); sl@0: sl@0: // Write data to the blob sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(ThePrivateDb, _L("table3"), _L("picture")); sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KBlobSize); sl@0: wrStrm.WriteL(_L8("AABBCC")); // write 6 bytes sl@0: wrStrm.WriteL(_L8("DD")); // write another 2 bytes sl@0: wrStrm.WriteL(_L8("EEFFG")); // write another 5 bytes sl@0: size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KBlobSize); sl@0: wrStrm.CommitL(); sl@0: CleanupStack::PopAndDestroy(&wrStrm); sl@0: sl@0: // Check that the new blob data was written sl@0: HBufC8* retrievedDataBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture")); sl@0: blobLength = retrievedDataBuf->Size(); sl@0: TEST2(blobLength, KBlobSize); sl@0: TEST(retrievedDataBuf->Des().Compare(_L8("AABBCCDDEEFFGBA")) == 0); sl@0: CleanupStack::PopAndDestroy(retrievedDataBuf); sl@0: sl@0: HBufC8* dataBuf = HBufC8::NewLC(KBlobSize); sl@0: TPtr8 dataPtr(dataBuf->Des()); sl@0: dataPtr.Append(_L8("CDCDCDCDCDCDCDC")); sl@0: TSqlBlob::SetL(ThePrivateDb, _L("table3"), _L("picture"), dataPtr); sl@0: CleanupStack::PopAndDestroy(dataBuf); sl@0: sl@0: // Check that the new blob data was written sl@0: retrievedDataBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture")); sl@0: blobLength = retrievedDataBuf->Size(); sl@0: TEST2(blobLength, KBlobSize); sl@0: TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDC")) == 0); sl@0: CleanupStack::PopAndDestroy(retrievedDataBuf); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4111 sl@0: @SYMTestCaseDesc Concurrent blob read and write tests using the sl@0: methods of RSqlBlobReadStream and RSqlBlobWriteStream. sl@0: Tests that read and write operations on different blobs sl@0: can happen concurrently and that read operations on the sl@0: same blob from different streams can happen concurrently. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of concurrent blob read and write operations on a database. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void ConcurrentReadAndWriteTestL() sl@0: { sl@0: // Insert a zeroblob of size 2Kb sl@0: InsertSQLiteZeroBlob(KLargeDataBufLen); sl@0: // Insert a zeroblob of size 4Kb sl@0: InsertBindZeroBlob(4 * 1024); sl@0: sl@0: // Handles on different blobs sl@0: sl@0: // Write and read from different blobs sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1); sl@0: sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: sl@0: wrStrm.WriteL(_L8("GHIJKL")); // blob2 is not updated in cache (as client buffer not full) sl@0: TBuf8<100> data; sl@0: rdStrm.ReadL(data, 6); sl@0: _LIT8(KSixZeros, "\x0\x0\x0\x0\x0\x0"); sl@0: TEST(data.Compare(KSixZeros) == 0); sl@0: wrStrm.CommitL(); // blob2 update is not committed (as the rdStrm handle is open) sl@0: wrStrm.Close(); sl@0: rdStrm.ReadL(data, 6); sl@0: TEST(data.Compare(KSixZeros) == 0); sl@0: rdStrm.Close(); // the blob2 update is committed sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1); sl@0: rdStrm.ReadL(data, 2); // read 2 bytes sl@0: _LIT8(KTwoZeros, "\x0\x0"); sl@0: TEST(data.Compare(KTwoZeros) == 0); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: wrStrm.WriteL(TheLargeData); // blob2 is updated in the cache sl@0: rdStrm.ReadL(data, 10); // read the next 10 bytes sl@0: _LIT8(KTenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0"); sl@0: TEST(data.Compare(KTenZeros) == 0); sl@0: rdStrm.Close(); sl@0: wrStrm.CommitL(); // the blob2 update is committed sl@0: CleanupStack::PopAndDestroy(2); sl@0: sl@0: // Write to different blobs via different streams sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1); sl@0: sl@0: RSqlBlobWriteStream wrStrm2; sl@0: CleanupClosePushL(wrStrm2); sl@0: wrStrm2.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: sl@0: wrStrm.WriteL(_L8("ABABABABABABAB")); sl@0: wrStrm2.WriteL(_L8("CDCDCD")); sl@0: wrStrm.WriteL(_L8("EFEF")); sl@0: wrStrm.Close(); sl@0: wrStrm2.Close(); // the blob1 update is committed and the blob2 update is committed sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1); sl@0: rdStrm.ReadL(data, 18); sl@0: TEST(data.Compare(_L8("ABABABABABABABEFEF")) == 0); sl@0: rdStrm.Close(); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: rdStrm.ReadL(data, 6); sl@0: TEST(data.Compare(_L8("CDCDCD")) == 0); sl@0: rdStrm.Close(); sl@0: CleanupStack::PopAndDestroy(3); sl@0: sl@0: // Read from different blobs via different streams sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1); sl@0: sl@0: RSqlBlobReadStream rdStrm2; sl@0: CleanupClosePushL(rdStrm2); sl@0: rdStrm2.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: sl@0: rdStrm.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("AB")) == 0); sl@0: rdStrm2.ReadL(data, 3); sl@0: TEST(data.Compare(_L8("CDC")) == 0); sl@0: rdStrm.ReadL(data, 15); sl@0: TEST(data.Compare(_L8("ABABABABABABEFE")) == 0); sl@0: rdStrm2.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("DC")) == 0); sl@0: CleanupStack::PopAndDestroy(2); sl@0: sl@0: // Handles on the same blob sl@0: // NOTE: using different stream objects on the same blob is only sl@0: // safe when all of the stream objects are read streams - writing to sl@0: // the same blob from different streams or writing and reading from sl@0: // the same blob at the same time has undefined behaviour sl@0: sl@0: // Read from the same blob (blob2) via different streams sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: wrStrm.WriteL(_L8("MNOPQR")); sl@0: CleanupStack::PopAndDestroy(); // the blob2 update is committed sl@0: sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: sl@0: CleanupClosePushL(rdStrm2); sl@0: rdStrm2.OpenL(TheDb1, _L("table1"), _L("B")); sl@0: sl@0: rdStrm.ReadL(data, 2); sl@0: TEST(data.Compare(_L8("MN")) == 0); sl@0: rdStrm2.ReadL(data, 3); sl@0: TEST(data.Compare(_L8("MNO")) == 0); sl@0: rdStrm.ReadL(data, 10); sl@0: TEST(data.Compare(_L8("OPQRZZZZZZ")) == 0); sl@0: rdStrm2.ReadL(data, 15); sl@0: TEST(data.Compare(_L8("PQRZZZZZZZZZZZZ")) == 0); sl@0: CleanupStack::PopAndDestroy(2); sl@0: } sl@0: sl@0: void UTF16TextL(TInt aTextSize) sl@0: { sl@0: // The text value is "test", size 8 bytes in UTF-16, aTextSize = 8 sl@0: sl@0: // Try to get the whole content of the text as UTF-8, using TSqlBlob::GetLC() sl@0: HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); sl@0: TInt bufSize = wholeBuf->Size(); // get the number of bytes in the buffer sl@0: TEST2(bufSize, aTextSize); sl@0: CleanupStack::PopAndDestroy(wholeBuf); sl@0: sl@0: // Try to get the whole content of the text as UTF-8, using TSqlBlob::Get() sl@0: HBufC8* buf = HBufC8::NewLC(aTextSize); sl@0: TPtr8 bufPtr(buf->Des()); sl@0: TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr); sl@0: TEST2(err, KErrNone); sl@0: bufSize = buf->Size(); // get the number of bytes in the buffer sl@0: TEST2(bufSize, aTextSize); sl@0: CleanupStack::PopAndDestroy(buf); sl@0: sl@0: // Try to set the whole content of the text as UTF-8, using TSqlBlob::SetL() sl@0: HBufC8* dataBuf = HBufC8::NewLC(aTextSize); sl@0: TPtr8 dataPtr(dataBuf->Des()); sl@0: dataPtr.Append(_L8("OPOPOPOP")); sl@0: TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), dataPtr)); sl@0: TEST2(err, KErrNone); // can set 8 UTF-8 characters as this is 8 bytes sl@0: CleanupStack::PopAndDestroy(dataBuf); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4112 sl@0: @SYMTestCaseDesc UTF-16 text read and write tests using the UTF-8 methods of sl@0: TSqlBlob. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of UTF-16 text read and write operations using sl@0: UTF-8 descriptors. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10411 sl@0: REQ10418 sl@0: */ sl@0: void UTF16FormatTestL() sl@0: { sl@0: // Insert a record with a UTF-16 text value (text is encoded in UTF-16 by default) sl@0: TInt err = TheDb1.Exec(_L("INSERT INTO table1 VALUES(1, 'test', x'46474647464746474647')")); sl@0: TEST2(err, 1); sl@0: const TInt KTextSize = 8; // 8 bytes (4 UTF-16 characters) sl@0: sl@0: // Now read and write the UTF-16 text value using UTF-8 methods sl@0: UTF16TextL(KTextSize); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-SQL-UT-4114 sl@0: @SYMTestCaseDesc Storing a big blob test, to ensure that by using the methods sl@0: of RSqlBlobReadStream and RSqlBlobWriteStream larger blobs can sl@0: be stored in practice than in previous versions of Symbian SQL. sl@0: Creates a 18Mb zeroblob and then writes data into it and reads sl@0: the data back. sl@0: Also tests the TSqlBlob APIs to store and retrieve a large blob. sl@0: Note that the test will use 18Mb blob only in WINSCW builds. sl@0: Otherwise the used blob size is 3Mb. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Execution of creating a 18Mb zeroblob, writing data to it and sl@0: reading it back. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMREQ REQ10410 sl@0: */ sl@0: void BigBlobTestL() sl@0: { sl@0: // In this test we create a zeroblob big enough to hold a 18MB blob. sl@0: // 18MB is larger than the server could previously read or write, sl@0: // due to the server heap limit of 6MB (WINSCW builds). sl@0: // This test will prove that a 18MB blob can be written and read sl@0: // using the new APIs but not with the old APIs sl@0: sl@0: #if defined __WINS__ || defined __WINSCW__ sl@0: const TInt KBigBlobSize = 18 * 1024 * 1024; sl@0: #else sl@0: const TInt KBigBlobSize = 3 * 1024 * 1024; sl@0: #endif sl@0: sl@0: // Create a zeroblob big enough to hold a 36MB blob sl@0: TInt err = TheDb2.Exec(_L("BEGIN")); sl@0: TEST(err >= 0); sl@0: sl@0: RSqlStatement stmt; sl@0: err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(435, 'big blob test', :Val)")); sl@0: TEST2(err, KErrNone); sl@0: TInt paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindZeroBlob(paramIndex, KBigBlobSize); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: stmt.Close(); sl@0: if(err == KErrDiskFull) sl@0: { sl@0: (void)TheDb2.Exec(_L("ROLLBACK")); sl@0: TheTest.Printf(_L("==== The disk is full. The test cannot be completed!\r\n")); sl@0: RFs fs; sl@0: err = fs.Connect(); sl@0: if(err == KErrNone) sl@0: { sl@0: TVolumeInfo vinfo; sl@0: err = fs.Volume(vinfo, EDriveC); sl@0: if(err == KErrNone) sl@0: { sl@0: TheTest.Printf(_L("==== Free disk space=%d\r\n"), vinfo.iFree); sl@0: } sl@0: fs.Close(); sl@0: } sl@0: return; sl@0: } sl@0: TEST2(err, 1); sl@0: sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: // Fill a buffer with KBigBlobSize/KBlobPartCnt bytes of data sl@0: // (the test application's heap may be too small to allocate a KBigBlobSize bytes buffer) sl@0: const TInt KBlobWrPartCnt = 16;// 1/16 part of the blob will be written at once using streaming API sl@0: const TInt KBufferSize1 = KBigBlobSize / KBlobWrPartCnt; sl@0: HBufC8* blobWrBuf = HBufC8::NewLC(KBufferSize1); sl@0: TPtr8 blobWrChunk(blobWrBuf->Des()); sl@0: blobWrChunk.Fill('Z', KBufferSize1); sl@0: sl@0: // Write KBigBlobSize bytes to the blob in the inserted record sl@0: RSqlBlobWriteStream wrStrm; sl@0: CleanupClosePushL(wrStrm); sl@0: wrStrm.OpenL(TheDb2, _L("table2"), _L("blob")); sl@0: TInt size = wrStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KBigBlobSize); sl@0: for(TInt i1=0;i1Des()); sl@0: RSqlBlobReadStream rdStrm; sl@0: CleanupClosePushL(rdStrm); sl@0: rdStrm.OpenL(TheDb2, _L("table2"), _L("blob")); sl@0: size = rdStrm.SizeL(); // check the blob's size sl@0: TEST2(size, KBigBlobSize); sl@0: for(TInt i2=0;i2= 0); sl@0: err = stmt.BindInt(paramIndex, TheDb2.LastInsertedRowId()); sl@0: TEST2(err, KErrNone); sl@0: // Check that the blob retrieval fails (because there is sl@0: // not enough server-side memory to load it into the VDBE) sl@0: err = stmt.Next(); sl@0: #if defined __WINS__ || defined __WINSCW__ sl@0: TEST2(err, KErrNoMemory); sl@0: #else sl@0: TEST2(err, KSqlAtRow); sl@0: #endif sl@0: stmt.Close(); sl@0: sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: // Try to write another KBigBlobSize bytes big blob value using the old API. sl@0: // Check that the at some point the blob write fails (because there is sl@0: // not enough server-side memory to store the whole KBigBlobSize bytes). sl@0: err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(99, 'text', :Val)")); sl@0: TEST2(err, KErrNone); sl@0: paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: RSqlParamWriteStream strm; sl@0: err = strm.BindBinary(stmt, paramIndex); sl@0: TEST2(err, KErrNone); sl@0: for(TInt i3=0;i3= 0); sl@0: sl@0: err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(189, 'another big blob', :Val)")); sl@0: TEST2(err, KErrNone); sl@0: paramIndex = stmt.ParameterIndex(_L(":Val")); sl@0: TEST(paramIndex >= 0); sl@0: err = stmt.BindZeroBlob(paramIndex, KBigBlobSize2); sl@0: TEST2(err, KErrNone); sl@0: err = stmt.Exec(); sl@0: TEST2(err, 1); sl@0: stmt.Close(); sl@0: sl@0: blobWrBuf = HBufC8::NewLC(KBigBlobSize2); sl@0: blobWrChunk.Set(blobWrBuf->Des()); sl@0: blobWrChunk.SetLength(KBigBlobSize2); sl@0: blobWrChunk.Fill('F'); sl@0: TPtr8 p((TUint8*)blobWrChunk.Ptr() + blobWrChunk.Length() / 2, blobWrChunk.Length() / 2); sl@0: p.Fill('E');// blobWrBuf now contains 42.5Kb of 'E's followed by 42.5Kb of 'F's sl@0: sl@0: TRAP(err, TSqlBlob::SetL(TheDb2, _L("table2"), _L("blob"), blobWrChunk)); sl@0: TEST2(err, KErrNone); sl@0: sl@0: err = TheDb2.Exec(_L("COMMIT")); sl@0: TEST2(err, 1); sl@0: sl@0: // Read the blob value back from the record sl@0: // (to test the block algorithm used by TSqlBlob 'get') sl@0: HBufC8* buf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob")); sl@0: TEST(buf->Des().Compare(blobWrChunk) == 0); sl@0: CleanupStack::PopAndDestroy(buf); sl@0: buf = NULL; sl@0: sl@0: buf = HBufC8::NewLC(KBigBlobSize2); sl@0: blobRdBufPtr.Set(buf->Des()); sl@0: err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), blobRdBufPtr); sl@0: TEST2(err, KErrNone); sl@0: TEST(blobRdBufPtr.Compare(blobWrChunk) == 0); sl@0: sl@0: CleanupStack::PopAndDestroy(2, blobWrBuf); // buf, blobWrBuf sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID PDS-SQL-CT-4194 sl@0: @SYMTestCaseDesc The test opens a test database, creates a table with a blob column and inserts one record. sl@0: Then the test uses RSqlBlobWriteStream to modify the blob column content. sl@0: MStreamBuf::SeekL() is used to modify the blob data at specific positions. sl@0: Then the test uses RSqlBlobReadStream object to read the just written blob data. sl@0: MStreamBuf::SeekL() is used to read the column content at specific positions sl@0: (the same positions used during the blob write operation). The read byte values must sl@0: match the written byte values. sl@0: @SYMTestPriority High sl@0: @SYMTestActions RSqlBlobReadStream and RSqlBlobWriteStream - MStreamBuf::SeekL() test. sl@0: @SYMTestExpectedResults Test must not fail sl@0: @SYMDEF DEF145028 sl@0: */ sl@0: void StreamSeekTestL() sl@0: { sl@0: TInt rc = TheDb1.Exec(_L("CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)")); sl@0: TEST(rc >= 0); sl@0: sl@0: //Write a record to the database using a blob stream. MStreamBuf::SeekL() is used to modify the content at a specific position. sl@0: rc = TheDb1.Exec(_L("INSERT INTO A(Fld1, Fld2) VALUES(1, zeroblob(256))")); sl@0: TEST2(rc, 1); sl@0: RSqlBlobWriteStream strm1; sl@0: CleanupClosePushL(strm1); sl@0: strm1.OpenL(TheDb1, _L("A"), _L("Fld2")); sl@0: for(TInt i=0;i<256;++i) sl@0: { sl@0: strm1 << (TUint8)i; sl@0: } sl@0: sl@0: const TInt KStreamOffset = 10; sl@0: const TUint8 KByte = 'z'; sl@0: _LIT8(KData, "QWERTYUIOPASDFG"); sl@0: sl@0: MStreamBuf* strm1buf = strm1.Sink(); sl@0: TEST(strm1buf != NULL); sl@0: sl@0: strm1buf->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0); sl@0: strm1buf->WriteL(&KByte, 1); sl@0: sl@0: strm1buf->SeekL(MStreamBuf::EWrite, EStreamMark, KStreamOffset); sl@0: strm1buf->WriteL(&KByte, 1); sl@0: sl@0: strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -KData().Length()); sl@0: strm1buf->WriteL(KData().Ptr(), KData().Length()); sl@0: sl@0: strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -4 * KStreamOffset); sl@0: strm1buf->WriteL(&KByte, 1); sl@0: sl@0: strm1.CommitL(); sl@0: CleanupStack::PopAndDestroy(&strm1); sl@0: sl@0: //Read the record using a blob stream. MStreamBuf::SeekL() is used to read the content at a specific position. sl@0: RSqlBlobReadStream strm2; sl@0: CleanupClosePushL(strm2); sl@0: strm2.OpenL(TheDb1, _L("A"), _L("Fld2")); sl@0: sl@0: TUint8 byte = 0; sl@0: MStreamBuf* strm2buf = strm2.Source(); sl@0: TEST(strm1buf != NULL); sl@0: sl@0: strm2buf->SeekL(MStreamBuf::ERead, EStreamBeginning, 0); sl@0: rc = strm2buf->ReadL(&byte, 1); sl@0: TEST2(rc, 1); sl@0: TEST2(byte, KByte); sl@0: sl@0: strm2buf->SeekL(MStreamBuf::ERead, EStreamMark, KStreamOffset); sl@0: rc = strm2buf->ReadL(&byte, 1); sl@0: TEST2(rc, 1); sl@0: TEST2(byte, KByte); sl@0: sl@0: strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -KData().Length()); sl@0: TUint8 buf[20]; sl@0: rc = strm2buf->ReadL(buf, KData().Length()); sl@0: TEST2(rc, KData().Length()); sl@0: TPtrC8 bufptr(buf, rc); sl@0: TEST(bufptr == KData); sl@0: sl@0: strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -4 * KStreamOffset); sl@0: rc = strm2buf->ReadL(&byte, 1); sl@0: TEST2(rc, 1); sl@0: TEST2(byte, KByte); sl@0: sl@0: CleanupStack::PopAndDestroy(&strm2); sl@0: } sl@0: sl@0: void DoTestsL() sl@0: { sl@0: CreateTestDbs(); sl@0: sl@0: // Insert a zeroblob using RSqlStatement::BindZeroBlob() and read and write to it using streams sl@0: TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4099: Stream BindZeroBlob() test")); sl@0: StreamBindZeroBlobTestL(); sl@0: sl@0: // Insert a zeroblob using SQLite's zeroblob() function and read and write to it using streams sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4100: Stream zeroblob() test")); sl@0: StreamSqliteZeroBlobTestL(); sl@0: sl@0: // Insert a record containing a 'real' blob and read and write to it using streams sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4101: Stream real blob test")); sl@0: StreamRealBlobTestL(); sl@0: sl@0: // Get a whole blob object sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4102: Whole value blob retrieval test")); sl@0: GetWholeBlob3L(); sl@0: sl@0: // Set a whole blob object sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4104: Whole value blob set test")); sl@0: SetWholeBlob3L(); sl@0: sl@0: // Attached database test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4106: Attached database test")); sl@0: AttachDbTestL(); sl@0: sl@0: // Bad parameter test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4107: Bad parameter test")); sl@0: BadParamTestL(); sl@0: sl@0: // Indexed column test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4108: Indexed column test")); sl@0: IndexedColumnTestL(); sl@0: sl@0: // End Of File test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4109: Eof test")); sl@0: EofTestL(); sl@0: sl@0: // Private secure database test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4110: Private secure db test")); sl@0: PrivateSecureDbTestL(); sl@0: sl@0: // Concurrent read and write test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4111: Concurrent read and write test")); sl@0: ConcurrentReadAndWriteTestL(); sl@0: sl@0: // UTF-16 read and write test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4112: UTF-16 format test")); sl@0: UTF16FormatTestL(); sl@0: sl@0: // Big blob test sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4114: Big blob test")); sl@0: BigBlobTestL(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4194: Blob streams. MStreamBuf::SeekL() test")); sl@0: StreamSeekTestL(); sl@0: sl@0: DeleteTestDbs(); sl@0: } sl@0: sl@0: TInt E32Main() sl@0: { sl@0: TheTest.Title(); sl@0: sl@0: CTrapCleanup* tc = CTrapCleanup::New(); sl@0: sl@0: __UHEAP_MARK; sl@0: sl@0: CreateTestDir(); sl@0: DeleteTestDbs(); sl@0: FillLargeDataBuf(); sl@0: TRAPD(err, DoTestsL()); sl@0: TEST2(err, KErrNone); sl@0: sl@0: __UHEAP_MARKEND; sl@0: sl@0: TheTest.End(); sl@0: TheTest.Close(); sl@0: sl@0: delete tc; sl@0: sl@0: User::Heap().Check(); sl@0: return KErrNone; sl@0: } sl@0: