1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlblob.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2134 @@
1.4 +// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <bautils.h>
1.21 +#include <sqldb.h>
1.22 +#include <s32file.h>
1.23 +
1.24 +RTest TheTest(_L("t_sqlblob test"));
1.25 +
1.26 +RSqlDatabase TheDb1;
1.27 +RSqlDatabase TheDb2;
1.28 +RSqlDatabase ThePrivateDb;
1.29 +
1.30 +_LIT(KTestDir, "c:\\test\\");
1.31 +_LIT(KTestDbName1, "c:\\test\\t_blob1.db");
1.32 +_LIT(KTestDbName2, "c:\\test\\t_blob2.db");
1.33 +_LIT(KAttachedDbName, "attached_db");
1.34 +_LIT(KPrivateSecureDb, "c:\\private\\1111C1CC\\ps.db");
1.35 +
1.36 +const TInt KLargeDataBufLen = 2048;
1.37 +
1.38 +// A buffer containing 2Kb of data.
1.39 +// When it is used to write to a blob the data will exceed the size of the client buffer
1.40 +// (which is 8 bytes in debug, 1.5Kb on target) and will be immediately transferred to the server
1.41 +TBuf8<KLargeDataBufLen> TheLargeData;
1.42 +
1.43 +///////////////////////////////////////////////////////////////////////////////////////
1.44 +// Test database delete functions
1.45 +
1.46 +void DeleteTestDbs()
1.47 + {
1.48 + TheDb1.Close();
1.49 + TheDb2.Close();
1.50 + ThePrivateDb.Close();
1.51 + (void)RSqlDatabase::Delete(KTestDbName1);
1.52 + (void)RSqlDatabase::Delete(KTestDbName2);
1.53 + (void)RSqlDatabase::Delete(KPrivateSecureDb);
1.54 + }
1.55 +
1.56 +///////////////////////////////////////////////////////////////////////////////////////
1.57 +// Test macros and functions
1.58 +
1.59 +void Check(TInt aValue, TInt aLine)
1.60 + {
1.61 + if(!aValue)
1.62 + {
1.63 + DeleteTestDbs();
1.64 + TheTest(EFalse, aLine);
1.65 + }
1.66 + }
1.67 +void Check(TInt aValue, TInt aExpected, TInt aLine)
1.68 + {
1.69 + if(aValue != aExpected)
1.70 + {
1.71 + DeleteTestDbs();
1.72 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.73 + TheTest(EFalse, aLine);
1.74 + }
1.75 + }
1.76 +#define TEST(arg) ::Check((arg), __LINE__)
1.77 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.78 +
1.79 +///////////////////////////////////////////////////////////////////////////////////////
1.80 +// Test database create functions
1.81 +
1.82 +void CreateTestDir()
1.83 + {
1.84 + RFs fs;
1.85 + TInt err = fs.Connect();
1.86 + TEST2(err, KErrNone);
1.87 +
1.88 + err = fs.MkDir(KTestDir);
1.89 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.90 +
1.91 + err = fs.CreatePrivatePath(EDriveC);
1.92 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.93 +
1.94 + fs.Close();
1.95 + }
1.96 +
1.97 +void CreateTestDbs()
1.98 + {
1.99 + // Create t_blob1.db
1.100 + TInt err = TheDb1.Create(KTestDbName1);
1.101 + TEST2(err, KErrNone);
1.102 +
1.103 + err = TheDb1.Exec(_L("CREATE TABLE table1(I INTEGER, T TEXT, B BLOB)"));
1.104 + TEST(err >= 0);
1.105 +
1.106 + // Create t_blob2.db
1.107 + err = TheDb2.Create(KTestDbName2);
1.108 + TEST2(err, KErrNone);
1.109 +
1.110 + err = TheDb2.Exec(_L("CREATE TABLE table2(int INTEGER, text TEXT, blob BLOB)"));
1.111 + TEST(err >= 0);
1.112 +
1.113 + // Insert a blob value of 'FGFGFGFGFG' (10 characters in size)
1.114 + err = TheDb2.Exec(_L("INSERT INTO table2 VALUES(1, 'Text Data', x'46474647464746474647')"));
1.115 + TEST2(err, 1);
1.116 +
1.117 + // Create private secure db
1.118 + err = ThePrivateDb.Create(KPrivateSecureDb);
1.119 + TEST2(err, KErrNone);
1.120 +
1.121 + err = ThePrivateDb.Exec(_L("CREATE TABLE table3(age INTEGER, name TEXT, picture BLOB)"));
1.122 + TEST(err >= 0);
1.123 +
1.124 + // Insert a blob value of 'ABABABABABABABA' (15 characters in size)
1.125 + err = ThePrivateDb.Exec(_L("INSERT INTO table3 VALUES(31, 'John Smith', x'414241424142414241424142414241')"));
1.126 + TEST2(err, 1);
1.127 + }
1.128 +
1.129 +void CreateIndices()
1.130 + {
1.131 + TInt err = TheDb1.Exec(_L("CREATE INDEX textIdx1 on table1(T)"));
1.132 + TEST(err >= 0);
1.133 + err = TheDb1.Exec(_L("CREATE INDEX blobIdx1 on table1(B)"));
1.134 + TEST(err >= 0);
1.135 +
1.136 + err = TheDb2.Exec(_L("CREATE INDEX textIdx2 on table2(text)"));
1.137 + TEST(err >= 0);
1.138 + err = TheDb2.Exec(_L("CREATE INDEX blobIdx2 on table2(blob)"));
1.139 + TEST(err >= 0);
1.140 + }
1.141 +
1.142 +void RemoveIndices()
1.143 + {
1.144 + TInt err = TheDb1.Exec(_L("DROP INDEX textIdx1"));
1.145 + TEST(err >= 0);
1.146 + err = TheDb1.Exec(_L("DROP INDEX blobIdx1"));
1.147 + TEST(err >= 0);
1.148 +
1.149 + err = TheDb2.Exec(_L("DROP INDEX textIdx2"));
1.150 + TEST(err >= 0);
1.151 + err = TheDb2.Exec(_L("DROP INDEX blobIdx2"));
1.152 + TEST(err >= 0);
1.153 + }
1.154 +
1.155 +void AttachTestDb2()
1.156 + {
1.157 + TInt err = TheDb1.Attach(KTestDbName2, KAttachedDbName);
1.158 + TEST2(err, KErrNone);
1.159 + }
1.160 +
1.161 +void FillLargeDataBuf(TChar aChar = 'Z')
1.162 + {
1.163 + TheLargeData.Fill(aChar, KLargeDataBufLen);
1.164 + }
1.165 +
1.166 +///////////////////////////////////////////////////////////////////////////////////////
1.167 +// Unit test functions
1.168 +
1.169 +void CheckBlobPropertiesL(TInt aBlobSize)
1.170 + {
1.171 + // Check properties of the last inserted blob
1.172 +
1.173 + RSqlStatement stmt;
1.174 + CleanupClosePushL(stmt);
1.175 + TInt err = stmt.Prepare(TheDb1, _L("SELECT B FROM table1 WHERE ROWID == :Val"));
1.176 + TEST2(err, KErrNone);
1.177 + TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
1.178 + TEST(paramIndex >= 0);
1.179 + err = stmt.BindInt(paramIndex, TheDb1.LastInsertedRowId());
1.180 + TEST2(err, KErrNone);
1.181 + err = stmt.Next();
1.182 + TEST2(err, KSqlAtRow);
1.183 +
1.184 + // Check the 'declared column type' is ESqlBinary
1.185 + TSqlColumnType declColType;
1.186 + err = stmt.DeclaredColumnType(0, declColType);
1.187 + TEST2(declColType, ESqlBinary);
1.188 + // Check the 'runtime column type' is ESqlBinary
1.189 + TSqlColumnType colType = stmt.ColumnType(0);
1.190 + TEST2(colType, ESqlBinary);
1.191 + // Check the 'column size' is the size of the blob
1.192 + TInt blobSize = stmt.ColumnSize(0);
1.193 + TEST2(blobSize, aBlobSize);
1.194 + // Check the 'column value' is not 'NULL' (even for a zeroblob)
1.195 + TBool isNull = stmt.IsNull(0);
1.196 + TEST2(isNull, EFalse);
1.197 + // Check the 'column value' can be retrieved as a binary value
1.198 + TPtrC8 binaryPtr = stmt.ColumnBinaryL(0);
1.199 + TEST2(binaryPtr.Length(), aBlobSize);
1.200 + // Check the 'column value' cannot be retrieved as a text value (it is of type ESqlBinary)
1.201 + TPtrC textptr = stmt.ColumnTextL(0);
1.202 + TEST2(textptr.Length(), 0);
1.203 + CleanupStack::PopAndDestroy(&stmt);
1.204 + }
1.205 +
1.206 +void InsertBindZeroBlob(TInt aBlobSize)
1.207 + {
1.208 + // Insert a record that has had a zeroblob bound to it
1.209 + RSqlStatement stmt;
1.210 + TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(1, 'some text', :Val)"));
1.211 + TEST2(err, KErrNone);
1.212 + TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
1.213 + TEST(paramIndex >= 0);
1.214 + err = stmt.BindZeroBlob(paramIndex, aBlobSize);
1.215 + TEST2(err, KErrNone);
1.216 + err = stmt.Exec();
1.217 + stmt.Close();
1.218 + TEST2(err, 1);
1.219 + }
1.220 +
1.221 +void InsertSQLiteZeroBlob(TInt aBlobSize)
1.222 + {
1.223 + // Insert a record that contains the 'zeroblob()' function
1.224 + RSqlStatement stmt;
1.225 + TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(2, 'more text', zeroblob(:Val))"));
1.226 + TEST2(err, KErrNone);
1.227 + TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
1.228 + TEST(paramIndex >= 0);
1.229 + err = stmt.BindInt(paramIndex, aBlobSize);
1.230 + TEST2(err, KErrNone);
1.231 + err = stmt.Exec();
1.232 + stmt.Close();
1.233 + TEST2(err, 1);
1.234 + }
1.235 +
1.236 +void InsertBlobValueL(TInt aBlobSize)
1.237 + {
1.238 + // Insert a record that contains an actual blob value
1.239 + HBufC8* binaryData = HBufC8::NewLC(aBlobSize);
1.240 + TPtr8 binaryDataPtr(binaryData->Des());
1.241 + for(TInt i = 0; i < aBlobSize/2; ++i)
1.242 + {
1.243 + binaryDataPtr.Append(_L8("DE"));
1.244 + }
1.245 +
1.246 + RSqlStatement stmt;
1.247 + CleanupClosePushL(stmt);
1.248 + TInt err = stmt.Prepare(TheDb1, _L("INSERT INTO table1 values(3, 'even more text', :Val)"));
1.249 + TEST2(err, KErrNone);
1.250 + TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
1.251 + TEST(paramIndex >= 0);
1.252 + err = stmt.BindBinary(paramIndex, binaryDataPtr);
1.253 + TEST2(err, KErrNone);
1.254 + err = stmt.Exec();
1.255 + TEST2(err, 1);
1.256 + CleanupStack::PopAndDestroy(2); // stmt, binaryData
1.257 + }
1.258 +
1.259 +void StreamBlob1L(TInt aBlobSize)
1.260 + {
1.261 + // Blob 1 is a zeroblob of size aBlobSize
1.262 +
1.263 + // Read (zero) data from the blob
1.264 + RSqlBlobReadStream rdStrm;
1.265 + CleanupClosePushL(rdStrm);
1.266 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.267 + TInt size = rdStrm.SizeL(); // check the blob's size
1.268 + TEST2(size, aBlobSize);
1.269 + _LIT8(KFiveZeros, "\x0\x0\x0\x0\x0");
1.270 + _LIT8(KTwentyZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
1.271 + TBuf8<50> data;
1.272 + rdStrm.ReadL(data, 5);
1.273 + TEST(data.Compare(KFiveZeros) == 0); // check 5 bytes of zero have been read
1.274 + rdStrm.ReadL(data, 20);
1.275 + TEST(data.Compare(KTwentyZeros) == 0); // check 20 bytes of zero have been read
1.276 + CleanupStack::PopAndDestroy(&rdStrm);
1.277 +
1.278 + // Write some actual data to the blob
1.279 + RSqlBlobWriteStream wrStrm;
1.280 + CleanupClosePushL(wrStrm);
1.281 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.282 + size = wrStrm.SizeL(); // check the blob's size
1.283 + TEST2(size, aBlobSize);
1.284 + wrStrm.WriteL(_L8("AABBCCDDEE")); // write 10 bytes
1.285 + wrStrm.WriteL(_L8("FFGGHHIIJJ")); // write another 10 bytes
1.286 + wrStrm.WriteL(_L8("KKLLMMNNOOPPQQRRSSTTUUVVWWXX")); // write another 28 bytes
1.287 + wrStrm.CommitL();
1.288 + CleanupStack::PopAndDestroy(&wrStrm);
1.289 +
1.290 + // Read back some of the blob data
1.291 + CleanupClosePushL(rdStrm);
1.292 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.293 + size = rdStrm.SizeL(); // check the blob's size
1.294 + TEST2(size, aBlobSize);
1.295 + rdStrm.ReadL(data, 4);
1.296 + TEST(data.Compare(_L8("AABB")) == 0); // check the first 4 bytes
1.297 + rdStrm.ReadL(data, 35);
1.298 + TEST(data.Compare(_L8("CCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSST")) == 0); // check the next 35 bytes
1.299 + rdStrm.ReadL(data, 19);
1.300 + _LIT8(KTrailingZeros, "TUUVVWWXX\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
1.301 + TEST(data.Compare(KTrailingZeros) == 0); // check the next 19 bytes (which includes some of the original zero bytes)
1.302 + CleanupStack::PopAndDestroy(&rdStrm);
1.303 + }
1.304 +
1.305 +void StreamText1L()
1.306 + {
1.307 + // Read data from the text column -
1.308 + // the database encoding is UTF-16 so the text is stored as UTF-16
1.309 + RSqlBlobReadStream rdStrm;
1.310 + CleanupClosePushL(rdStrm);
1.311 + rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));
1.312 + TBuf<50> dataUTF16;
1.313 + rdStrm.ReadL(dataUTF16, 9);
1.314 + TEST(dataUTF16.Compare(_L("some text")) == 0);
1.315 + CleanupStack::PopAndDestroy(&rdStrm);
1.316 +
1.317 + // Write some data to the text column (as UTF-16)
1.318 + RSqlBlobWriteStream wrStrm;
1.319 + CleanupClosePushL(wrStrm);
1.320 + wrStrm.OpenL(TheDb1, _L("table1"), _L("T"));
1.321 + wrStrm.WriteL(_L("new text!")); // can only write up to the original size of the data - 9 chars
1.322 + wrStrm.CommitL();
1.323 + CleanupStack::PopAndDestroy(&wrStrm);
1.324 +
1.325 + // Read back some of the text (as UTF-16)
1.326 + CleanupClosePushL(rdStrm);
1.327 + rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));
1.328 + rdStrm.ReadL(dataUTF16, 9);
1.329 + TEST(dataUTF16.Compare(_L("new text!")) == 0);
1.330 + CleanupStack::PopAndDestroy(&rdStrm);
1.331 +
1.332 + // Write some data to the text column (as UTF-8)
1.333 + CleanupClosePushL(wrStrm);
1.334 + wrStrm.OpenL(TheDb1, _L("table1"), _L("T"));
1.335 + wrStrm.WriteL(_L8("try again"));
1.336 + wrStrm.CommitL();
1.337 + CleanupStack::PopAndDestroy(&wrStrm);
1.338 +
1.339 + // Read back some of the text (as UTF-8)
1.340 + CleanupClosePushL(rdStrm);
1.341 + rdStrm.OpenL(TheDb1, _L("table1"), _L("T"));
1.342 + TBuf8<50> dataUTF8;
1.343 + rdStrm.ReadL(dataUTF8, 9);
1.344 + TEST(dataUTF8.Compare(_L8("try again")) == 0);
1.345 + CleanupStack::PopAndDestroy(&rdStrm);
1.346 + }
1.347 +
1.348 +void StreamBlob2L(TInt aBlobSize)
1.349 + {
1.350 + // Blob 2 is a zeroblob of size aBlobSize
1.351 +
1.352 + // Read (zero) data from the blob
1.353 + RSqlBlobReadStream rdStrm;
1.354 + CleanupClosePushL(rdStrm);
1.355 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.356 + TInt size = rdStrm.SizeL(); // check the blob's size
1.357 + TEST2(size, aBlobSize);
1.358 + _LIT8(KFifteenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
1.359 + _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");
1.360 + TBuf8<200> data;
1.361 + rdStrm.ReadL(data, 15);
1.362 + TEST(data.Compare(KFifteenZeros) == 0); // check 15 bytes of zero have been read
1.363 + rdStrm.ReadL(data, 61);
1.364 + TEST(data.Compare(KSixtyOneZeros) == 0); // check 61 bytes of zero have been read
1.365 + size = rdStrm.SizeL(); // check the blob's size
1.366 + TEST2(size, aBlobSize);
1.367 + CleanupStack::PopAndDestroy(&rdStrm);
1.368 +
1.369 + // Write some actual data to the blob
1.370 + RSqlBlobWriteStream wrStrm;
1.371 + CleanupClosePushL(wrStrm);
1.372 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.373 + size = wrStrm.SizeL(); // check the blob's size
1.374 + TEST2(size, aBlobSize);
1.375 + wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATAS")); // write 23 bytes
1.376 + wrStrm.WriteL(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATA")); // write another 43 bytes
1.377 + wrStrm.WriteL(_L8("SOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENE")); // write another 72 bytes
1.378 + wrStrm.WriteL(_L8("WDATASOMENEWDATA")); // write another 16 bytes
1.379 + size = wrStrm.SizeL(); // check the blob's size
1.380 + TEST2(size, aBlobSize);
1.381 + wrStrm.CommitL();
1.382 + CleanupStack::PopAndDestroy(&wrStrm);
1.383 +
1.384 + // Read back some of the blob data
1.385 + CleanupClosePushL(rdStrm);
1.386 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.387 + size = rdStrm.SizeL(); // check the blob's size
1.388 + TEST2(size, aBlobSize);
1.389 + rdStrm.ReadL(data, 1);
1.390 + TEST(data.Compare(_L8("S")) == 0); // check the first byte
1.391 + rdStrm.ReadL(data, 136);
1.392 + TEST(data.Compare(_L8("OMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMENEWDATASOMEN")) == 0); // check the next 136 bytes
1.393 + rdStrm.ReadL(data, 30);
1.394 + _LIT8(KTrailingZeros, "EWDATASOMENEWDATA\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
1.395 + TEST(data.Compare(KTrailingZeros) == 0); // check the next 30 bytes (which includes some of the original zero bytes)
1.396 + size = rdStrm.SizeL(); // check the blob's size
1.397 + TEST2(size, aBlobSize);
1.398 + CleanupStack::PopAndDestroy(&rdStrm);
1.399 + }
1.400 +
1.401 +void StreamBlob3L(TInt aBlobSize)
1.402 + {
1.403 + // Blob 3 is a 'real' blob of value "DEDEDEDEDEDEDEDEDEDE"
1.404 +
1.405 + // Read some of the zero data
1.406 + RSqlBlobReadStream rdStrm;
1.407 + CleanupClosePushL(rdStrm);
1.408 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.409 + TInt size = rdStrm.SizeL(); // check the blob's size
1.410 + TEST2(size, aBlobSize);
1.411 + TBuf8<20> data;
1.412 + rdStrm.ReadL(data, 3);
1.413 + TEST(data.Compare(_L8("DED")) == 0); // check the first 3 bytes
1.414 + rdStrm.ReadL(data, 12);
1.415 + TEST(data.Compare(_L8("EDEDEDEDEDED")) == 0); // check the next 12 bytes
1.416 + size = rdStrm.SizeL(); // check the blob's size
1.417 + TEST2(size, aBlobSize);
1.418 + CleanupStack::PopAndDestroy(&rdStrm);
1.419 +
1.420 + // Write some new data to the blob
1.421 + RSqlBlobWriteStream wrStrm;
1.422 + CleanupClosePushL(wrStrm);
1.423 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.424 + size = wrStrm.SizeL(); // check the blob's size
1.425 + TEST2(size, aBlobSize);
1.426 + wrStrm.WriteL(_L8("ABCDEF")); // write 6 bytes
1.427 + wrStrm.WriteL(_L8("GHIJKLMNOPQ")); // write another 11 bytes
1.428 + size = wrStrm.SizeL(); // check the blob's size
1.429 + TEST2(size, aBlobSize);
1.430 + wrStrm.CommitL();
1.431 + CleanupStack::PopAndDestroy(&wrStrm);
1.432 +
1.433 + // Read back some of the blob data
1.434 + CleanupClosePushL(rdStrm);
1.435 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.436 + size = rdStrm.SizeL(); // check the blob's size
1.437 + TEST2(size, aBlobSize);
1.438 + rdStrm.ReadL(data, 2);
1.439 + TEST(data.Compare(_L8("AB")) == 0); // check the first 2 bytes
1.440 + rdStrm.ReadL(data, 7);
1.441 + TEST(data.Compare(_L8("CDEFGHI")) == 0); // check the next 7 bytes
1.442 + rdStrm.ReadL(data, 11);
1.443 + TEST(data.Compare(_L8("JKLMNOPQEDE")) == 0); // check the next 11 bytes
1.444 + size = rdStrm.SizeL(); // check the blob's size
1.445 + TEST2(size, aBlobSize);
1.446 + CleanupStack::PopAndDestroy(&rdStrm);
1.447 +
1.448 + // Seek to position - the blob value is now "ABCDEFGHIJKLMNOPQEDE"
1.449 + CleanupClosePushL(rdStrm);
1.450 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.451 + TStreamPos pos(9);
1.452 + rdStrm.Source()->SeekL(MStreamBuf::ERead, pos);
1.453 + rdStrm.ReadL(data, 2);
1.454 + TEST(data.Compare(_L8("JK")) == 0);
1.455 + rdStrm.ReadL(data, 5);
1.456 + TEST(data.Compare(_L8("LMNOP")) == 0);
1.457 + TStreamPos pos2(3);
1.458 + rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2);
1.459 + rdStrm.ReadL(data, 4);
1.460 + TEST(data.Compare(_L8("DEFG")) == 0);
1.461 + TStreamPos pos3(21);
1.462 + TRAPD(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3));
1.463 + TEST2(err, KErrEof);
1.464 + TStreamPos pos4(18);
1.465 + rdStrm.Source()->SeekL(MStreamBuf::ERead, pos4);
1.466 + TRAP(err, rdStrm.ReadL(data, 3));
1.467 + TEST2(err, KErrEof);
1.468 + CleanupStack::PopAndDestroy(&rdStrm);
1.469 +
1.470 + CleanupClosePushL(wrStrm);
1.471 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.472 + TStreamPos pos5(7);
1.473 + wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos5);
1.474 + wrStrm.WriteL(_L8("ZZZZZ"));
1.475 + wrStrm.WriteL(_L8("YYY"));
1.476 + TStreamPos pos6(17);
1.477 + wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos6);
1.478 + wrStrm.WriteL(_L8("XXX"));
1.479 + wrStrm.CommitL();
1.480 + wrStrm.Close();
1.481 + CleanupClosePushL(rdStrm);
1.482 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.483 + rdStrm.ReadL(data, 20);
1.484 + TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
1.485 + rdStrm.Close();
1.486 + TStreamPos pos7(21);
1.487 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.488 + TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos7));
1.489 + TEST2(err, KErrEof);
1.490 + TStreamPos pos8(18);
1.491 + wrStrm.Sink()->SeekL(MStreamBuf::EWrite, pos8);
1.492 + wrStrm.WriteL(_L8("TTT"));
1.493 + TRAP(err, wrStrm.CommitL());
1.494 + TEST2(err, KErrEof);
1.495 + wrStrm.Close();
1.496 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.497 + rdStrm.ReadL(data, 20);
1.498 + TEST(data.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
1.499 + CleanupStack::PopAndDestroy(2);
1.500 + }
1.501 +
1.502 +/**
1.503 +@SYMTestCaseID SYSLIB-SQL-UT-4099
1.504 +@SYMTestCaseDesc Incremental blob tests on a database using streams.
1.505 + Insert a zeroblob using RSqlStatement::BindZeroBlob(), read and write to
1.506 + the blob using streams, also read and write to a text column using streams.
1.507 + Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.
1.508 +@SYMTestPriority Medium
1.509 +@SYMTestActions Execution of incremental blob stream operations on a database.
1.510 +@SYMTestExpectedResults Test must not fail
1.511 +@SYMREQ REQ10411
1.512 + REQ10418
1.513 +*/
1.514 +void StreamBindZeroBlobTestL()
1.515 + {
1.516 + const TInt KBlobSize = 300;
1.517 + InsertBindZeroBlob(KBlobSize);
1.518 + CheckBlobPropertiesL(KBlobSize);
1.519 + StreamBlob1L(KBlobSize);
1.520 + StreamText1L();
1.521 + CheckBlobPropertiesL(KBlobSize);
1.522 + }
1.523 +
1.524 +/**
1.525 +@SYMTestCaseID SYSLIB-SQL-UT-4100
1.526 +@SYMTestCaseDesc Incremental blob tests on a database, using streams.
1.527 + Insert a zeroblob using the SQLite function zeroblob(),
1.528 + read and write to the blob using streams.
1.529 + Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.
1.530 +@SYMTestPriority Medium
1.531 +@SYMTestActions Execution of incremental blob stream operations on a database.
1.532 +@SYMTestExpectedResults Test must not fail
1.533 +@SYMREQ REQ10411
1.534 + REQ10418
1.535 +*/
1.536 +void StreamSqliteZeroBlobTestL()
1.537 + {
1.538 + const TInt KBlobSize = 1500;
1.539 + InsertSQLiteZeroBlob(KBlobSize);
1.540 + CheckBlobPropertiesL(KBlobSize);
1.541 + StreamBlob2L(KBlobSize);
1.542 + CheckBlobPropertiesL(KBlobSize);
1.543 + }
1.544 +
1.545 +/**
1.546 +@SYMTestCaseID SYSLIB-SQL-UT-4101
1.547 +@SYMTestCaseDesc Incremental blob tests on a database, using streams.
1.548 + Insert a real blob, read and write to the blob using streams.
1.549 + Tests the RSqlBlobReadStream and RSqlBlobWriteStream methods.
1.550 +@SYMTestPriority Medium
1.551 +@SYMTestActions Execution of incremental blob stream operations on a database.
1.552 +@SYMTestExpectedResults Test must not fail
1.553 +@SYMREQ REQ10411
1.554 + REQ10418
1.555 +*/
1.556 +void StreamRealBlobTestL()
1.557 + {
1.558 + const TInt KBlobSize = 20;
1.559 + InsertBlobValueL(KBlobSize);
1.560 + CheckBlobPropertiesL(KBlobSize);
1.561 + StreamBlob3L(KBlobSize);
1.562 + CheckBlobPropertiesL(KBlobSize);
1.563 + }
1.564 +
1.565 +/**
1.566 +@SYMTestCaseID SYSLIB-SQL-UT-4102
1.567 +@SYMTestCaseDesc Whole value blob retrieval tests on a database.
1.568 + Retrieve the whole value of a blob object in one go.
1.569 + Tests the TSqlBlob 'get' methods.
1.570 +@SYMTestPriority Medium
1.571 +@SYMTestActions Execution of whole value blob retrieval operations on a database.
1.572 +@SYMTestExpectedResults Test must not fail
1.573 +@SYMREQ REQ10411
1.574 + REQ10418
1.575 +*/
1.576 +void GetWholeBlob3L()
1.577 + {
1.578 + // Blob 3 is a 'real' blob of value "ABCDEFGZZZZZYYYPQXXX"
1.579 + const TInt KBlobSize = 20;
1.580 +
1.581 + // Get the whole content of Blob 3 in one go, using TSqlBlob::GetLC()
1.582 + HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));
1.583 + TInt bufSize = wholeBuf->Size();
1.584 + TEST2(bufSize, KBlobSize);
1.585 + TEST(wholeBuf->Des().Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
1.586 + CleanupStack::PopAndDestroy(wholeBuf);
1.587 +
1.588 + // Get the whole content of Blob 3 in one go, using TSqlBlob::Get()
1.589 + HBufC8* buf = HBufC8::NewLC(KBlobSize);
1.590 + TPtr8 bufPtr(buf->Des());
1.591 + TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr);
1.592 + TEST2(err, KErrNone);
1.593 + TEST(bufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
1.594 + CleanupStack::PopAndDestroy(buf);
1.595 +
1.596 + // Get the whole content of Blob 3 in one go, using TSqlBlob::Get(),
1.597 + // ensuring that a buffer larger than the blob can be used
1.598 + HBufC8* largerBuf = HBufC8::NewLC(KBlobSize * 2);
1.599 + TPtr8 largerBufPtr(largerBuf->Des());
1.600 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), largerBufPtr);
1.601 + TEST2(err, KErrNone);
1.602 + TEST(largerBufPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
1.603 + CleanupStack::PopAndDestroy(largerBuf);
1.604 +
1.605 + // Get the whole content of the blob in 2 chunks of 10 bytes
1.606 + HBufC8* streamBuf = HBufC8::NewLC(10);
1.607 + TPtr8 streamBufPtr(streamBuf->Des());
1.608 + RSqlBlobReadStream rdStrm;
1.609 + CleanupClosePushL(rdStrm);
1.610 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.611 + TInt size = rdStrm.SizeL();
1.612 + TEST2(size, KBlobSize);
1.613 + HBufC8* combinedData = HBufC8::NewLC(KBlobSize);
1.614 + TPtr8 combinedDataPtr(combinedData->Des());
1.615 + for(TInt i = 2; i > 0 ; --i)
1.616 + {
1.617 + rdStrm.ReadL(streamBufPtr, 10);
1.618 + combinedDataPtr.Append(streamBufPtr);
1.619 + }
1.620 + TEST(combinedDataPtr.Compare(_L8("ABCDEFGZZZZZYYYPQXXX")) == 0);
1.621 + CleanupStack::PopAndDestroy(3); // combinedDataRead, rdStrm, streamBuf
1.622 + }
1.623 +
1.624 +/**
1.625 +@SYMTestCaseID SYSLIB-SQL-UT-4104
1.626 +@SYMTestCaseDesc Whole value blob write tests on a database.
1.627 + Write the whole value of a blob object in one go.
1.628 + Tests the TSqlBlob 'set' methods.
1.629 +@SYMTestPriority Medium
1.630 +@SYMTestActions Execution of whole value blob write operations on a database.
1.631 +@SYMTestExpectedResults Test must not fail
1.632 +@SYMREQ REQ10411
1.633 + REQ10418
1.634 +*/
1.635 +void SetWholeBlob3L()
1.636 + {
1.637 + // Blob 3 is a 'real' blob of value "KKKKKKKKKKKKKKKKKEDE"
1.638 + TInt KBlobSize = 20;
1.639 +
1.640 + // Set the whole content of Blob 3 in one go
1.641 + HBufC8* dataBuf = HBufC8::NewLC(KBlobSize);
1.642 + TPtr8 dataPtr(dataBuf->Des());
1.643 + dataPtr.Append(_L8("CDCDCDCDCDCDCDCDCDCD"));
1.644 + TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), dataPtr);
1.645 + CleanupStack::PopAndDestroy(dataBuf);
1.646 +
1.647 + // Check that the new blob data was written
1.648 + HBufC8* retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));
1.649 + TInt blobLength = retrievedDataBuf->Size();
1.650 + TEST2(blobLength, KBlobSize);
1.651 + TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDCDCDCD")) == 0);
1.652 + CleanupStack::PopAndDestroy(retrievedDataBuf);
1.653 +
1.654 + // Set the whole content of the blob in 2 chunks of 10 bytes
1.655 + RSqlBlobWriteStream wrStrm;
1.656 + CleanupClosePushL(wrStrm);
1.657 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.658 + TInt size = wrStrm.SizeL();
1.659 + TEST2(size, KBlobSize);
1.660 + for(TInt i = 2; i > 0; --i)
1.661 + {
1.662 + wrStrm.WriteL(_L8("ZYZYZYZYZY"));
1.663 + }
1.664 + CleanupStack::PopAndDestroy(&wrStrm);
1.665 +
1.666 + // Check that the new blob data was written
1.667 + retrievedDataBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"));
1.668 + blobLength = retrievedDataBuf->Size();
1.669 + TEST2(blobLength, KBlobSize);
1.670 + TEST(retrievedDataBuf->Des().Compare(_L8("ZYZYZYZYZYZYZYZYZYZY")) == 0);
1.671 + CleanupStack::PopAndDestroy(retrievedDataBuf);
1.672 + }
1.673 +
1.674 +/**
1.675 +@SYMTestCaseID SYSLIB-SQL-UT-4106
1.676 +@SYMTestCaseDesc Blob read and write tests on an attached database.
1.677 + Performs streaming and whole value read and write operations
1.678 + on a blob in an attached database to ensure that the
1.679 + RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods
1.680 + can be used on an attached database.
1.681 + Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods.
1.682 +@SYMTestPriority Medium
1.683 +@SYMTestActions Execution of blob read and write operations on an attached database.
1.684 +@SYMTestExpectedResults Test must not fail
1.685 +@SYMREQ REQ10411
1.686 + REQ10418
1.687 +*/
1.688 +void AttachDbTestL()
1.689 + {
1.690 + // Attach test db 2 to test db 1
1.691 + AttachTestDb2();
1.692 +
1.693 + // Open a read stream on a blob in the attached database -
1.694 + // the blob in the single record has a value of "FGFGFGFGFG"
1.695 + const TInt KAttachedBlobSize = 10;
1.696 + RSqlBlobReadStream rdStrm;
1.697 + CleanupClosePushL(rdStrm);
1.698 + rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
1.699 + TInt size = rdStrm.SizeL(); // check the blob's size
1.700 + TEST2(size, KAttachedBlobSize);
1.701 + TBuf8<20> data;
1.702 + rdStrm.ReadL(data, 2);
1.703 + TEST(data.Compare(_L8("FG")) == 0); // check the first 2 bytes
1.704 + rdStrm.ReadL(data, 8);
1.705 + TEST(data.Compare(_L8("FGFGFGFG")) == 0); // check the next 8 bytes
1.706 + size = rdStrm.SizeL(); // check the blob's size
1.707 + TEST2(size, KAttachedBlobSize);
1.708 + CleanupStack::PopAndDestroy(&rdStrm);
1.709 +
1.710 + // Write some new data to the blob
1.711 + RSqlBlobWriteStream wrStrm;
1.712 + CleanupClosePushL(wrStrm);
1.713 + wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
1.714 + size = wrStrm.SizeL(); // check the blob's size
1.715 + TEST2(size, KAttachedBlobSize);
1.716 + wrStrm.WriteL(_L8("LLLL")); // write 4 bytes
1.717 + wrStrm.WriteL(_L8("MMMMM")); // write another 5 bytes
1.718 + size = wrStrm.SizeL(); // check the blob's size
1.719 + TEST2(size, KAttachedBlobSize);
1.720 + wrStrm.CommitL();
1.721 + CleanupStack::PopAndDestroy(&wrStrm);
1.722 +
1.723 + // Read back some of the blob data
1.724 + CleanupClosePushL(rdStrm);
1.725 + rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
1.726 + size = rdStrm.SizeL(); // check the blob's size
1.727 + TEST2(size, KAttachedBlobSize);
1.728 + rdStrm.ReadL(data, 2);
1.729 + TEST(data.Compare(_L8("LL")) == 0); // check the first 2 bytes
1.730 + rdStrm.ReadL(data, 5);
1.731 + TEST(data.Compare(_L8("LLMMM")) == 0); // check the next 5 bytes
1.732 + rdStrm.ReadL(data, 3);
1.733 + TEST(data.Compare(_L8("MMG")) == 0); // check the next 3 bytes
1.734 + size = rdStrm.SizeL(); // check the blob's size
1.735 + TEST2(size, KAttachedBlobSize);
1.736 + CleanupStack::PopAndDestroy(&rdStrm);
1.737 +
1.738 + // Get the entire blob in the attached database
1.739 + HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
1.740 + TInt blobLength = wholeBuf->Length();
1.741 + TEST2(blobLength, KAttachedBlobSize);
1.742 + TEST(wholeBuf->Des().Compare(_L8("LLLLMMMMMG")) == 0);
1.743 + CleanupStack::PopAndDestroy(wholeBuf);
1.744 +
1.745 + TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName);
1.746 + TEST(data.Compare(_L8("LLLLMMMMMG")) == 0);
1.747 +
1.748 + // Set the entire blob in the attached database
1.749 + data.Zero();
1.750 + data.Append(_L8("STSTSTSTST"));
1.751 + TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), data, TheDb2.LastInsertedRowId(), KAttachedDbName);
1.752 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName);
1.753 + TEST(wholeBuf->Des().Compare(_L8("STSTSTSTST")) == 0);
1.754 + CleanupStack::PopAndDestroy(wholeBuf);
1.755 + }
1.756 +
1.757 +void BadParamReadStreamL()
1.758 + {
1.759 + HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
1.760 + TPtr tooLongNameDes = tooLongName->Des();
1.761 + tooLongNameDes.Fill('A', KMaxFileName + 1);
1.762 +
1.763 + // RSqlBlobReadStream::OpenL()
1.764 + RSqlBlobReadStream rdStrm;
1.765 + CleanupClosePushL(rdStrm);
1.766 + TRAPD(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column)
1.767 + TEST2(err, KErrNone);
1.768 + rdStrm.Close();
1.769 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column)
1.770 + TEST2(err, KErrNone);
1.771 + rdStrm.Close();
1.772 + TRAP(err, rdStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection
1.773 + TEST2(err, KSqlErrGeneral);
1.774 + TRAP(err, rdStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name
1.775 + TEST2(err, KErrBadName);
1.776 + TRAP(err, rdStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name
1.777 + TEST2(err, KErrBadName);
1.778 + TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name
1.779 + TEST2(err, KSqlErrGeneral);
1.780 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name
1.781 + TEST2(err, KErrBadName);
1.782 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name
1.783 + TEST2(err, KErrBadName);
1.784 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name
1.785 + TEST2(err, KSqlErrGeneral);
1.786 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type
1.787 + TEST2(err, KSqlErrGeneral);
1.788 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), -12)); // illegal ROWID
1.789 + TEST2(err, KErrArgument);
1.790 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID
1.791 + TEST2(err, KSqlErrGeneral);
1.792 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column)
1.793 + TEST2(err, KErrNone);
1.794 + rdStrm.Close();
1.795 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column)
1.796 + TEST2(err, KErrNone);
1.797 + rdStrm.Close();
1.798 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column)
1.799 + TEST2(err, KErrNone);
1.800 + rdStrm.Close();
1.801 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column)
1.802 + TEST2(err, KErrNone);
1.803 + rdStrm.Close();
1.804 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column)
1.805 + TEST2(err, KErrNone);
1.806 + rdStrm.Close();
1.807 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column)
1.808 + TEST2(err, KErrNone);
1.809 + rdStrm.Close();
1.810 + TRAP(err, rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
1.811 + TEST2(err, KSqlErrGeneral);
1.812 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
1.813 + TEST2(err, KErrBadName);
1.814 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
1.815 + TEST2(err, KSqlErrGeneral);
1.816 + TRAP(err, rdStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
1.817 + TEST2(err, KSqlErrGeneral);
1.818 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
1.819 + TEST2(err, KSqlErrGeneral);
1.820 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
1.821 + TEST2(err, KSqlErrGeneral);
1.822 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID
1.823 + TEST2(err, KSqlErrGeneral);
1.824 + CleanupStack::PopAndDestroy(&rdStrm);
1.825 + CleanupStack::PopAndDestroy(tooLongName);
1.826 +
1.827 + // RSqlBlobReadStream::Source()::SeekL()
1.828 + CleanupClosePushL(rdStrm);
1.829 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.830 + TInt size = rdStrm.SizeL();
1.831 + TEST(size > 0);
1.832 + TStreamPos pos(-1);
1.833 + TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos));
1.834 + TEST2(err, KErrEof);
1.835 + TStreamPos pos2(size - 1);
1.836 + TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos2));
1.837 + TEST2(err, KErrNone);
1.838 + TStreamPos pos3(size + 1);
1.839 + TRAP(err, rdStrm.Source()->SeekL(MStreamBuf::ERead, pos3));
1.840 + TEST2(err, KErrEof);
1.841 + CleanupStack::PopAndDestroy(&rdStrm);
1.842 +
1.843 + // RSqlBlobReadStream::ReadL()
1.844 + CleanupClosePushL(rdStrm);
1.845 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.846 + size = rdStrm.SizeL();
1.847 + TEST2(size, 20);
1.848 + TBuf8<20> dataBuf;
1.849 + TBuf8<50> tooBigDataBuf;
1.850 + TRAP(err, rdStrm.ReadL(tooBigDataBuf));
1.851 + TEST2(err, KErrEof);
1.852 + rdStrm.Close();
1.853 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.854 + TRAP(err, rdStrm.ReadL(tooBigDataBuf, size + 1));
1.855 + TEST2(err, KErrEof);
1.856 + rdStrm.Close();
1.857 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.858 + TRAP(err, rdStrm.ReadL(tooBigDataBuf, TChar('J'))); // doesn't find 'J' so tries to fill the buffer to its max size
1.859 + TEST2(err, KErrEof);
1.860 + CleanupStack::PopAndDestroy(&rdStrm);
1.861 + }
1.862 +
1.863 +void BadParamWriteStreamL()
1.864 + {
1.865 + HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
1.866 + TPtr tooLongNameDes = tooLongName->Des();
1.867 + tooLongNameDes.Fill('A', KMaxFileName + 1);
1.868 +
1.869 + // RSqlBlobWriteStream::OpenL()
1.870 + RSqlBlobWriteStream wrStrm;
1.871 + CleanupClosePushL(wrStrm);
1.872 + TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on a BLOB column)
1.873 + TEST2(err, KErrNone);
1.874 + wrStrm.Close();
1.875 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on a TEXT column)
1.876 + TEST2(err, KErrNone);
1.877 + wrStrm.Close();
1.878 + TRAP(err, wrStrm.OpenL(TheDb2, _L("table1"), _L("B"))); // wrong db connection
1.879 + TEST2(err, KSqlErrGeneral);
1.880 + TRAP(err, wrStrm.OpenL(TheDb1, _L(""), _L("B"))); // empty table name
1.881 + TEST2(err, KErrBadName);
1.882 + TRAP(err, wrStrm.OpenL(TheDb1, tooLongNameDes, _L("B"))); // too long table name
1.883 + TEST2(err, KErrBadName);
1.884 + TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name
1.885 + TEST2(err, KSqlErrGeneral);
1.886 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L(""))); // empty column name
1.887 + TEST2(err, KErrBadName);
1.888 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), tooLongNameDes)); // too long column name
1.889 + TEST2(err, KErrBadName);
1.890 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name
1.891 + TEST2(err, KSqlErrGeneral);
1.892 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("I"))); // invalid column type
1.893 + TEST2(err, KSqlErrGeneral);
1.894 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 0)); // illegal ROWID
1.895 + TEST2(err, KErrArgument);
1.896 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), 99)); // invalid ROWID
1.897 + TEST2(err, KSqlErrGeneral);
1.898 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a BLOB column)
1.899 + TEST2(err, KErrNone);
1.900 + wrStrm.Close();
1.901 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a BLOB column)
1.902 + TEST2(err, KErrNone);
1.903 + wrStrm.Close();
1.904 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L("main"))); // a successful open (on a TEXT column)
1.905 + TEST2(err, KErrNone);
1.906 + wrStrm.Close();
1.907 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"), KSqlLastInsertedRowId, _L(""))); // a successful open (on a TEXT column)
1.908 + TEST2(err, KErrNone);
1.909 + wrStrm.Close();
1.910 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a BLOB column)
1.911 + TEST2(err, KErrNone);
1.912 + wrStrm.Close();
1.913 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on a TEXT column)
1.914 + TEST2(err, KErrNone);
1.915 + wrStrm.Close();
1.916 + TRAP(err, wrStrm.OpenL(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
1.917 + TEST2(err, KSqlErrGeneral);
1.918 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
1.919 + TEST2(err, KErrBadName);
1.920 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
1.921 + TEST2(err, KSqlErrGeneral);
1.922 + TRAP(err, wrStrm.OpenL(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
1.923 + TEST2(err, KSqlErrGeneral);
1.924 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
1.925 + TEST2(err, KSqlErrGeneral);
1.926 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
1.927 + TEST2(err, KSqlErrGeneral);
1.928 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), 64, KAttachedDbName)); // invalid ROWID
1.929 + TEST2(err, KSqlErrGeneral);
1.930 + CleanupStack::PopAndDestroy(&wrStrm);
1.931 + CleanupStack::PopAndDestroy(tooLongName);
1.932 +
1.933 + // RSqlBlobWriteStream::Sink()::SeekL()
1.934 + CleanupClosePushL(wrStrm);
1.935 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.936 + TInt size = wrStrm.SizeL();
1.937 + TEST(size > 0);
1.938 + TStreamPos pos(-1);
1.939 + TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos));
1.940 + TEST2(err, KErrEof);
1.941 + TStreamPos pos2(size - 1);
1.942 + TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos2));
1.943 + TEST2(err, KErrNone);
1.944 + TStreamPos pos3(size + 1);
1.945 + TRAP(err, wrStrm.Sink()->SeekL(MStreamBuf::ERead, pos3));
1.946 + TEST2(err, KErrEof);
1.947 + CleanupStack::PopAndDestroy(&wrStrm);
1.948 +
1.949 + // RSqlBlobWriteStream::WriteL()
1.950 + CleanupClosePushL(wrStrm);
1.951 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.952 + size = wrStrm.SizeL();
1.953 + TEST2(size, 20);
1.954 + TBuf8<50> tooBigDataBuf;
1.955 + tooBigDataBuf.Fill('B', 50);
1.956 + TRAP(err, wrStrm.WriteL(tooBigDataBuf));
1.957 +#ifdef _DEBUG
1.958 + TEST2(err, KErrEof);
1.959 +#else
1.960 + TEST2(err, KErrNone);
1.961 + TRAP(err, wrStrm.CommitL());
1.962 + TEST2(err, KErrEof);
1.963 +#endif
1.964 + wrStrm.Close();
1.965 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.966 + TRAP(err, wrStrm.WriteL(tooBigDataBuf, size + 1));
1.967 +#ifdef _DEBUG
1.968 + TEST2(err, KErrEof);
1.969 +#else
1.970 + TEST2(err, KErrNone);
1.971 + TRAP(err, wrStrm.CommitL());
1.972 + TEST2(err, KErrEof);
1.973 +#endif
1.974 + CleanupStack::PopAndDestroy(&wrStrm);
1.975 + }
1.976 +
1.977 +void BadParamGetL()
1.978 + {
1.979 + HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
1.980 + TPtr tooLongNameDes = tooLongName->Des();
1.981 + tooLongNameDes.Fill('A', KMaxFileName + 1);
1.982 +
1.983 + // TSqlBlob::GetLC()
1.984 + HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on a BLOB column)
1.985 + TInt blobLength = wholeBuf->Length();
1.986 + TEST(blobLength > 0);
1.987 + CleanupStack::PopAndDestroy(wholeBuf);
1.988 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on a TEXT column)
1.989 + blobLength = wholeBuf->Length();
1.990 + TEST(blobLength > 0);
1.991 + CleanupStack::PopAndDestroy(wholeBuf);
1.992 + TRAPD(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table1"), _L("B"))); // wrong db connection
1.993 + TEST2(err, KSqlErrGeneral);
1.994 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L(""), _L("B"))); // empty table name
1.995 + TEST2(err, KErrBadName);
1.996 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, tooLongNameDes, _L("B"))); // too long table name
1.997 + TEST2(err, KErrBadName);
1.998 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("B"))); // invalid table name
1.999 + TEST2(err, KSqlErrGeneral);
1.1000 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L(""))); // empty column name
1.1001 + TEST2(err, KErrBadName);
1.1002 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), tooLongNameDes)); // too long column name
1.1003 + TEST2(err, KErrBadName);
1.1004 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("invalidColumnName"))); // invalid column name
1.1005 + TEST2(err, KSqlErrGeneral);
1.1006 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("I"))); // invalid column type
1.1007 + TEST2(err, KSqlErrGeneral);
1.1008 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), -2)); // illegal ROWID
1.1009 + TEST2(err, KErrArgument);
1.1010 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), 3731)); // invalid ROWID
1.1011 + TEST2(err, KSqlErrGeneral);
1.1012 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column)
1.1013 + blobLength = wholeBuf->Length();
1.1014 + TEST(blobLength > 0);
1.1015 + CleanupStack::PopAndDestroy(wholeBuf);
1.1016 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column)
1.1017 + blobLength = wholeBuf->Length();
1.1018 + TEST(blobLength > 0);
1.1019 + CleanupStack::PopAndDestroy(wholeBuf);
1.1020 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column)
1.1021 + blobLength = wholeBuf->Length();
1.1022 + TEST(blobLength > 0);
1.1023 + CleanupStack::PopAndDestroy(wholeBuf);
1.1024 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"), TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column)
1.1025 + blobLength = wholeBuf->Length();
1.1026 + TEST(blobLength > 0);
1.1027 + CleanupStack::PopAndDestroy(wholeBuf);
1.1028 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column)
1.1029 + blobLength = wholeBuf->Length();
1.1030 + TEST(blobLength > 0);
1.1031 + CleanupStack::PopAndDestroy(wholeBuf);
1.1032 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column)
1.1033 + blobLength = wholeBuf->Length();
1.1034 + TEST(blobLength > 0);
1.1035 + CleanupStack::PopAndDestroy(wholeBuf);
1.1036 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
1.1037 + TEST2(err, KSqlErrGeneral);
1.1038 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("invalidTableName"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
1.1039 + TEST2(err, KSqlErrGeneral);
1.1040 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("invalidColumnName"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
1.1041 + TEST2(err, KSqlErrGeneral);
1.1042 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("int"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
1.1043 + TEST2(err, KSqlErrGeneral);
1.1044 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), 345, KAttachedDbName)); // invalid ROWID
1.1045 + TEST2(err, KSqlErrGeneral);
1.1046 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
1.1047 + TEST2(err, KSqlErrGeneral);
1.1048 + TRAP(err, wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
1.1049 + TEST2(err, KErrBadName);
1.1050 +
1.1051 + // TSqlBlob::Get()
1.1052 + HBufC8* buf = HBufC8::NewLC(50);
1.1053 + TPtr8 bufPtr(buf->Des());
1.1054 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr); // a successful get (on a BLOB column)
1.1055 + TEST2(err, KErrNone);
1.1056 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr); // a successful get (on a TEXT column)
1.1057 + TEST2(err, KErrNone);
1.1058 + err = TSqlBlob::Get(TheDb2, _L("table1"), _L("B"), bufPtr); // wrong db connection
1.1059 + TEST2(err, KSqlErrGeneral);
1.1060 + err = TSqlBlob::Get(TheDb1, _L(""), _L("B"), bufPtr); // empty table name
1.1061 + TEST2(err, KErrBadName);
1.1062 + err = TSqlBlob::Get(TheDb1, tooLongNameDes, _L("B"), bufPtr); // too long table name
1.1063 + TEST2(err, KErrBadName);
1.1064 + err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("B"), bufPtr); // invalid table name
1.1065 + TEST2(err, KSqlErrGeneral);
1.1066 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L(""), bufPtr); // empty column name
1.1067 + TEST2(err, KErrBadName);
1.1068 + err = TSqlBlob::Get(TheDb1, _L("table1"), tooLongNameDes, bufPtr); // too long column name
1.1069 + TEST2(err, KErrBadName);
1.1070 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("invalidColumnName"), bufPtr); // invalid column name
1.1071 + TEST2(err, KSqlErrGeneral);
1.1072 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("I"), bufPtr); // invalid column type
1.1073 + TEST2(err, KSqlErrGeneral);
1.1074 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 0); // illegal ROWID
1.1075 + TEST2(err, KErrArgument);
1.1076 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, 3731); // invalid ROWID
1.1077 + TEST2(err, KSqlErrGeneral);
1.1078 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a BLOB column)
1.1079 + TEST2(err, KErrNone);
1.1080 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a BLOB column)
1.1081 + TEST2(err, KErrNone);
1.1082 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("main")); // a successful get (on a TEXT column)
1.1083 + TEST2(err, KErrNone);
1.1084 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr, TheDb1.LastInsertedRowId(), _L("")); // a successful get (on a TEXT column)
1.1085 + TEST2(err, KErrNone);
1.1086 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a BLOB column)
1.1087 + TEST2(err, KErrNone);
1.1088 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on a TEXT column)
1.1089 + TEST2(err, KErrNone);
1.1090 + err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // wrong db connection
1.1091 + TEST2(err, KSqlErrGeneral);
1.1092 + err = TSqlBlob::Get(TheDb1, _L("invalidTableName"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid table name
1.1093 + TEST2(err, KSqlErrGeneral);
1.1094 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("invalidColumnName"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column name
1.1095 + TEST2(err, KSqlErrGeneral);
1.1096 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("int"), bufPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // invalid column type
1.1097 + TEST2(err, KSqlErrGeneral);
1.1098 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, 345, KAttachedDbName); // invalid ROWID
1.1099 + TEST2(err, KSqlErrGeneral);
1.1100 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName")); // invalid attached db name
1.1101 + TEST2(err, KSqlErrGeneral);
1.1102 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), bufPtr, TheDb2.LastInsertedRowId(), tooLongNameDes); // too long attached db name
1.1103 + TEST2(err, KErrBadName);
1.1104 + CleanupStack::PopAndDestroy(buf);
1.1105 +
1.1106 + CleanupStack::PopAndDestroy(tooLongName);
1.1107 + }
1.1108 +
1.1109 +void BadParamSetL()
1.1110 + {
1.1111 + HBufC* tooLongName = HBufC::NewLC(KMaxFileName + 1);
1.1112 + TPtr tooLongNameDes = tooLongName->Des();
1.1113 + tooLongNameDes.Fill('A', KMaxFileName + 1);
1.1114 +
1.1115 + // TSqlBlob::SetL()
1.1116 + TRAPD(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // a successful set (on a BLOB column)
1.1117 + TEST2(err, KErrNone);
1.1118 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // a successful set (on a TEXT column)
1.1119 + TEST2(err, KErrNone);
1.1120 + TRAP(err, TSqlBlob::SetL(TheDb2, _L("table1"), _L("B"), _L8("twenty characters..."))); // wrong db connection
1.1121 + TEST2(err, KSqlErrGeneral);
1.1122 + TRAP(err, TSqlBlob::SetL(TheDb1, _L(""), _L("B"), _L8("twenty characters..."))); // empty table name
1.1123 + TEST2(err, KErrBadName);
1.1124 + TRAP(err, TSqlBlob::SetL(TheDb1, tooLongNameDes, _L("B"), _L8("twenty characters..."))); // too long table name
1.1125 + TEST2(err, KErrBadName);
1.1126 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("B"), _L8("twenty characters..."))); // invalid table name
1.1127 + TEST2(err, KSqlErrGeneral);
1.1128 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L(""), _L8("twenty characters..."))); // empty column name
1.1129 + TEST2(err, KErrBadName);
1.1130 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), tooLongNameDes, _L8("twenty characters..."))); // too long column name
1.1131 + TEST2(err, KErrBadName);
1.1132 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("invalidColumnName"), _L8("twenty characters..."))); // invalid column name
1.1133 + TEST2(err, KSqlErrGeneral);
1.1134 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("I"), _L8("twenty characters..."))); // invalid column type
1.1135 + TEST2(err, KSqlErrGeneral);
1.1136 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), -3)); // illegal ROWID
1.1137 + TEST2(err, KErrArgument);
1.1138 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters..."), 1113)); // invalid ROWID
1.1139 + TEST2(err, KSqlErrGeneral);
1.1140 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L("main"))); // a successful set (on a BLOB column)
1.1141 + TEST2(err, KErrNone);
1.1142 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L(""))); // a successful set (on a BLOB column)
1.1143 + TEST2(err, KErrNone);
1.1144 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L("main"))); // a successful set (on a TEXT column)
1.1145 + TEST2(err, KErrNone);
1.1146 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("!!!twenty characters"), TheDb1.LastInsertedRowId(), _L(""))); // a successful set (on a TEXT column)
1.1147 + TEST2(err, KErrNone);
1.1148 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful set (on a BLOB column)
1.1149 + TEST2(err, KErrNone);
1.1150 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("text"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful set (on a TEXT column)
1.1151 + TEST2(err, KErrNone);
1.1152 + TRAP(err, TSqlBlob::SetL(TheDb2, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // wrong db connection
1.1153 + TEST2(err, KSqlErrGeneral);
1.1154 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("invalidTableName"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid table name
1.1155 + TEST2(err, KSqlErrGeneral);
1.1156 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("invalidColumnName"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column name
1.1157 + TEST2(err, KSqlErrGeneral);
1.1158 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("int"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), KAttachedDbName)); // invalid column type
1.1159 + TEST2(err, KSqlErrGeneral);
1.1160 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), 13, KAttachedDbName)); // invalid ROWID
1.1161 + TEST2(err, KSqlErrGeneral);
1.1162 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), _L("invalidAttachedDbName"))); // invalid attached db name
1.1163 + TEST2(err, KSqlErrGeneral);
1.1164 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars.."), TheDb2.LastInsertedRowId(), tooLongNameDes)); // too long attached db name
1.1165 + TEST2(err, KErrBadName);
1.1166 +
1.1167 + CleanupStack::PopAndDestroy(tooLongName);
1.1168 + }
1.1169 +
1.1170 +void BadParamBindZeroBlobL()
1.1171 + {
1.1172 + // RSqlStatement::BindZeroBlob()
1.1173 + RSqlBlobReadStream rdStrm;
1.1174 + CleanupClosePushL(rdStrm);
1.1175 + RSqlStatement stmt;
1.1176 + CleanupClosePushL(stmt);
1.1177 + TInt err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(1, 'dummy text', :Val)"));
1.1178 + TEST2(err, KErrNone);
1.1179 + TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
1.1180 + TEST(paramIndex >= 0);
1.1181 + err = stmt.BindZeroBlob(paramIndex, -1); // a negative blob size
1.1182 + TEST2(err, KErrNone);
1.1183 + err = stmt.Exec();
1.1184 + TEST2(err, 1);
1.1185 + stmt.Reset();
1.1186 + rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
1.1187 + TInt size = rdStrm.SizeL(); // check the blob's size is 0 (0 is used if a negative number was specified)
1.1188 + TEST2(size, 0);
1.1189 + rdStrm.Close();
1.1190 + err = stmt.BindZeroBlob(paramIndex, 0); // a blob size of zero
1.1191 + TEST2(err, KErrNone);
1.1192 + err = stmt.Exec();
1.1193 + TEST2(err, 1);
1.1194 + stmt.Reset();
1.1195 + rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
1.1196 + size = rdStrm.SizeL(); // check the blob's size is 0
1.1197 + TEST2(size, 0);
1.1198 + // For subsequent test purposes make the last inserted record have a zeroblob > 0 size
1.1199 + err = stmt.BindZeroBlob(paramIndex, 1);
1.1200 + TEST2(err, KErrNone);
1.1201 + err = stmt.Exec();
1.1202 + TEST2(err, 1);
1.1203 + CleanupStack::PopAndDestroy(&stmt);
1.1204 + CleanupStack::PopAndDestroy(&rdStrm);
1.1205 + }
1.1206 +
1.1207 +/**
1.1208 +@SYMTestCaseID SYSLIB-SQL-UT-4107
1.1209 +@SYMTestCaseDesc Bad parameter tests for the methods of RSqlBlobReadStream,
1.1210 + RSqlBlobWriteStream, TSqlBlob and RSqlStatement::BindZeroBlob().
1.1211 + Tests that the correct error code is returned when a bad parameter
1.1212 + is used in a call to one of the methods.
1.1213 + Tests the RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob methods
1.1214 + and RSqlStatement::BindZeroBlob().
1.1215 +@SYMTestPriority High
1.1216 +@SYMTestActions Execution of bad parameter tests.
1.1217 +@SYMTestExpectedResults Test must not fail
1.1218 +@SYMREQ REQ10411
1.1219 + REQ10418
1.1220 +*/
1.1221 +void BadParamTestL()
1.1222 + {
1.1223 + BadParamReadStreamL();
1.1224 + BadParamWriteStreamL();
1.1225 + BadParamGetL();
1.1226 + BadParamSetL();
1.1227 + BadParamBindZeroBlobL();
1.1228 + }
1.1229 +
1.1230 +/**
1.1231 +@SYMTestCaseID SYSLIB-SQL-UT-4108
1.1232 +@SYMTestCaseDesc Indexed column tests for the methods of RSqlBlobReadStream
1.1233 + and RSqlBlobWriteStream, to ensure that a blob or text column
1.1234 + that is indexed cannot be written to but can be read from
1.1235 + (an SQLite restriction).
1.1236 +@SYMTestPriority Medium
1.1237 +@SYMTestActions Execution of read and write operations on an indexed column in a database.
1.1238 +@SYMTestExpectedResults Test must not fail
1.1239 +@SYMREQ REQ10411
1.1240 + REQ10418
1.1241 +*/
1.1242 +void IndexedColumnTestL()
1.1243 + {
1.1244 + // Create an index on the BLOB column and on the TEXT column in the main and attached databases
1.1245 + CreateIndices();
1.1246 +
1.1247 + // Attempt to open a write stream on an indexed BLOB and an indexed TEXT column - this should not be permitted.
1.1248 + // (This is an SQLite restriction, but having an index on a large BLOB or a TEXT column is highly unlikely!)
1.1249 + RSqlBlobWriteStream wrStrm;
1.1250 + CleanupClosePushL(wrStrm);
1.1251 + TRAPD(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // indexed BLOB column
1.1252 + TEST2(err, KSqlErrGeneral);
1.1253 + wrStrm.Close();
1.1254 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // indexed TEXT column
1.1255 + TEST2(err, KSqlErrGeneral);
1.1256 + wrStrm.Close();
1.1257 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed BLOB column
1.1258 + TEST2(err, KSqlErrGeneral);
1.1259 + wrStrm.Close();
1.1260 + TRAP(err, wrStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed TEXT column
1.1261 + TEST2(err, KSqlErrGeneral);
1.1262 + CleanupStack::PopAndDestroy(&wrStrm);
1.1263 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("twenty characters !!"))); // indexed BLOB column
1.1264 + TEST2(err, KSqlErrGeneral);
1.1265 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), _L8("twenty characters !!"))); // indexed TEXT column
1.1266 + TEST2(err, KSqlErrGeneral);
1.1267 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("blob"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed BLOB column
1.1268 + TEST2(err, KSqlErrGeneral);
1.1269 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table2"), _L("text"), _L8("10 chars!!"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // indexed TEXT column
1.1270 + TEST2(err, KSqlErrGeneral);
1.1271 +
1.1272 + // Attempt to open a read stream on an indexed BLOB and an indexed text COLUMN - this should be permitted
1.1273 + RSqlBlobReadStream rdStrm;
1.1274 + CleanupClosePushL(rdStrm);
1.1275 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("B"))); // a successful open (on an indexed BLOB column)
1.1276 + TEST2(err, KErrNone);
1.1277 + rdStrm.Close();
1.1278 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table1"), _L("T"))); // a successful open (on an indexed TEXT column)
1.1279 + TEST2(err, KErrNone);
1.1280 + rdStrm.Close();
1.1281 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on an indexed BLOB column)
1.1282 + TEST2(err, KErrNone);
1.1283 + rdStrm.Close();
1.1284 + TRAP(err, rdStrm.OpenL(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName)); // a successful open (on an indexed TEXT column)
1.1285 + TEST2(err, KErrNone);
1.1286 + CleanupStack::PopAndDestroy(&rdStrm);
1.1287 + HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("B")); // a successful get (on an indexed BLOB column)
1.1288 + TInt blobLength = wholeBuf->Length();
1.1289 + TEST(blobLength > 0);
1.1290 + CleanupStack::PopAndDestroy(wholeBuf);
1.1291 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T")); // a successful get (on an indexed TEXT column)
1.1292 + blobLength = wholeBuf->Length();
1.1293 + TEST(blobLength > 0);
1.1294 + CleanupStack::PopAndDestroy(wholeBuf);
1.1295 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("blob"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed BLOB column)
1.1296 + blobLength = wholeBuf->Length();
1.1297 + TEST(blobLength > 0);
1.1298 + CleanupStack::PopAndDestroy(wholeBuf);
1.1299 + wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table2"), _L("text"), TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed TEXT column)
1.1300 + blobLength = wholeBuf->Length();
1.1301 + TEST(blobLength > 0);
1.1302 + CleanupStack::PopAndDestroy(wholeBuf);
1.1303 + HBufC8* buf = HBufC8::NewLC(50);
1.1304 + TPtr8 buffPtr(buf->Des());
1.1305 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), buffPtr); // a successful get (on an indexed BLOB column)
1.1306 + TEST2(err, KErrNone);
1.1307 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), buffPtr); // a successful get (on an indexed TEXT column)
1.1308 + TEST2(err, KErrNone);
1.1309 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("blob"), buffPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed BLOB column)
1.1310 + TEST2(err, KErrNone);
1.1311 + err = TSqlBlob::Get(TheDb1, _L("table2"), _L("text"), buffPtr, TheDb2.LastInsertedRowId(), KAttachedDbName); // a successful get (on an indexed TEXT column)
1.1312 + TEST2(err, KErrNone);
1.1313 + CleanupStack::PopAndDestroy(buf);
1.1314 +
1.1315 + RemoveIndices();
1.1316 + }
1.1317 +
1.1318 +/**
1.1319 +@SYMTestCaseID SYSLIB-SQL-UT-4109
1.1320 +@SYMTestCaseDesc 'End of file' tests for the methods of RSqlBlobReadStream
1.1321 + RSqlBlobWriteStream and TSqlBlob, to ensure that a client cannot
1.1322 + read beyond the end of a blob object or write beyond the end of a
1.1323 + blob object and that an appropriate error code is returned.
1.1324 +@SYMTestPriority High
1.1325 +@SYMTestActions Execution of read and write operations beyond the end of a blob object.
1.1326 +@SYMTestExpectedResults Test must not fail
1.1327 +@SYMREQ REQ10411
1.1328 + REQ10418
1.1329 +*/
1.1330 +void EofTestL()
1.1331 + {
1.1332 + // Use Blob 3 in table1, whose value is "!!!twenty characters"
1.1333 +
1.1334 + // Read Eof tests
1.1335 +
1.1336 + const TInt KBlobSize = 20;
1.1337 + RSqlBlobReadStream rdStrm;
1.1338 + CleanupClosePushL(rdStrm);
1.1339 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1340 + TInt size = rdStrm.SizeL();
1.1341 + TEST2(size, KBlobSize);
1.1342 + TBuf8<50> data;
1.1343 + TRAPD(err, rdStrm.ReadL(data, KBlobSize));
1.1344 + TEST2(err, KErrNone);
1.1345 + TEST(data.Compare(_L8("!!!twenty characters")) == 0);
1.1346 + TRAP(err, rdStrm.ReadL(data, 1));
1.1347 + TEST2(err, KErrEof);
1.1348 + rdStrm.Close();
1.1349 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1350 + TRAP(err, rdStrm.ReadL(data, 21));
1.1351 + TEST2(err, KErrEof);
1.1352 + rdStrm.Close();
1.1353 +
1.1354 + HBufC8* exactSizeBuf = HBufC8::NewLC(KBlobSize);
1.1355 + TPtr8 exactSizeBufPtr(exactSizeBuf->Des());
1.1356 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), exactSizeBufPtr);
1.1357 + TEST2(err, KErrNone);
1.1358 + TEST(exactSizeBufPtr.Compare(_L8("!!!twenty characters")) == 0);
1.1359 + CleanupStack::PopAndDestroy(exactSizeBuf);
1.1360 +
1.1361 + HBufC8* tooSmallBuf = HBufC8::NewLC(KBlobSize/2);
1.1362 + TPtr8 tooSmallBufPtr(tooSmallBuf->Des());
1.1363 + err = TSqlBlob::Get(TheDb1, _L("table1"), _L("B"), tooSmallBufPtr);
1.1364 + TEST2(err, KErrOverflow);
1.1365 + CleanupStack::PopAndDestroy(tooSmallBuf);
1.1366 +
1.1367 + // Write Eof tests
1.1368 +
1.1369 + RSqlBlobWriteStream wrStrm;
1.1370 + CleanupClosePushL(wrStrm);
1.1371 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1372 + size = wrStrm.SizeL();
1.1373 + TEST2(size, KBlobSize);
1.1374 + // For debug builds: This 20 bytes will be written to the blob straight away
1.1375 + // because 20 bytes is more than the 8 byte buffer
1.1376 + // For release builds: This 20 bytes will NOT be written to the blob straight away
1.1377 + // because there is room for it to be stored in the 1.5K byte buffer
1.1378 + TRAP(err, wrStrm.WriteL(_L8("a twenty char string")));
1.1379 + TEST2(err, KErrNone);
1.1380 + // For debug/release builds: This 1 byte will NOT be written to the blob straight away
1.1381 + // because there is room for it to be stored in the 8 byte/1.5K buffer
1.1382 + TRAP(err, wrStrm.WriteL(_L8("a")));
1.1383 + TEST2(err, KErrNone);
1.1384 + // For debug builds: The CommitL() call will cause an attempt to write the 1 byte
1.1385 + // in the buffer to the blob - however, the stream's write position indicates
1.1386 + // that the write would be beyond the end of the blob and so an error occurs
1.1387 + // For release builds: The CommitL() call will cause an attempt to write the 21 bytes
1.1388 + // in the buffer to the blob - however, 21 bytes is larger than the size of the blob
1.1389 + // and so an error occurs
1.1390 + TRAP(err, wrStrm.CommitL());
1.1391 + TEST2(err, KErrEof);
1.1392 + wrStrm.Close();
1.1393 + // For debug builds: Check that the blob value is now "a twenty char string"
1.1394 + // For release builds: Check that the blob value is still "!!!twenty characters"
1.1395 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1396 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1397 + TEST2(err, KErrNone);
1.1398 +#ifdef _DEBUG
1.1399 + TEST(data.Compare(_L8("a twenty char string")) == 0);
1.1400 +#else
1.1401 + TEST(data.Compare(_L8("!!!twenty characters")) == 0);
1.1402 +#endif
1.1403 + rdStrm.Close();
1.1404 +
1.1405 + TheDb1.Exec(_L("BEGIN"));
1.1406 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1407 + // For debug/release builds: These 3 bytes will be stored in the 8 byte/1.5K buffer
1.1408 + TRAP(err, wrStrm.WriteL(_L8("eee")));
1.1409 + TEST2(err, KErrNone);
1.1410 + // For debug builds: These 25 bytes will not fit in the 8 byte buffer and so an attempt
1.1411 + // will be made to write these 25 bytes and the 3 buffered bytes to the blob -
1.1412 + // however, the size of the blob is only 20 and so an error occurs
1.1413 + // For release builds: These 25 bytes will be stored in the 1.5K buffer
1.1414 + TRAP(err, wrStrm.WriteL(_L8("fffffffffffffffffffffffff")));
1.1415 +#ifdef _DEBUG
1.1416 + TEST2(err, KErrEof);
1.1417 + wrStrm.Close();
1.1418 + TheDb1.Exec(_L("ROLLBACK"));
1.1419 +
1.1420 + // Check that the blob value is still "a twenty char string"
1.1421 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1422 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1423 + TEST2(err, KErrNone);
1.1424 + TEST(data.Compare(_L8("a twenty char string")) == 0);
1.1425 + rdStrm.Close();
1.1426 +#else
1.1427 + TEST2(err, KErrNone);
1.1428 + // For release builds: The CommitL() call will cause an attempt to write the 28 bytes
1.1429 + // in the buffer to the blob - however, 28 bytes is larger than the size of the blob
1.1430 + // and so an error occurs
1.1431 + TRAP(err, wrStrm.CommitL());
1.1432 + TEST2(err, KErrEof);
1.1433 + wrStrm.Close();
1.1434 + TheDb1.Exec(_L("ROLLBACK"));
1.1435 +
1.1436 + // Check that the blob value is still "!!!twenty characters"
1.1437 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1438 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1439 + TEST2(err, KErrNone);
1.1440 + TEST(data.Compare(_L8("!!!twenty characters")) == 0);
1.1441 + rdStrm.Close();
1.1442 +#endif
1.1443 +
1.1444 + TheDb1.Exec(_L("BEGIN"));
1.1445 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1446 + TRAP(err, wrStrm.WriteL(_L8("a string that is longer than 20 characters")));
1.1447 +#ifdef _DEBUG
1.1448 + TEST2(err, KErrEof);
1.1449 + wrStrm.Close();
1.1450 + TheDb1.Exec(_L("ROLLBACK"));
1.1451 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1452 + TRAP(err, wrStrm.WriteL(_L8("ggg")));
1.1453 + TEST2(err, KErrNone);
1.1454 + TRAP(err, wrStrm.CommitL());
1.1455 + TEST2(err, KErrNone);
1.1456 + CleanupStack::PopAndDestroy(&wrStrm);
1.1457 + // Check that the blob value is now "gggwenty char string"
1.1458 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1459 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1460 + TEST2(err, KErrNone);
1.1461 + TEST(data.Compare(_L8("gggwenty char string")) == 0);
1.1462 + rdStrm.Close();
1.1463 +#else
1.1464 + TEST2(err, KErrNone);
1.1465 + TRAP(err, wrStrm.CommitL());
1.1466 + TEST2(err, KErrEof);
1.1467 + wrStrm.Close();
1.1468 + TheDb1.Exec(_L("ROLLBACK"));
1.1469 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1470 + TRAP(err, wrStrm.WriteL(_L8("hhh")));
1.1471 + TEST2(err, KErrNone);
1.1472 + TRAP(err, wrStrm.CommitL());
1.1473 + TEST2(err, KErrNone);
1.1474 + CleanupStack::PopAndDestroy(&wrStrm);
1.1475 + // Check that the blob value is now "hhhtwenty characters"
1.1476 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1477 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1478 + TEST2(err, KErrNone);
1.1479 + TEST(data.Compare(_L8("hhhtwenty characters")) == 0);
1.1480 + rdStrm.Close();
1.1481 +#endif
1.1482 +
1.1483 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("a twenty char string")));
1.1484 + TEST2(err, KErrNone);
1.1485 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1486 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1487 + TEST2(err, KErrNone);
1.1488 + TEST(data.Compare(_L8("a twenty char string")) == 0);
1.1489 + rdStrm.Close();
1.1490 +
1.1491 + TheDb1.Exec(_L("BEGIN"));
1.1492 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("a string that is longer than 20 characters")));
1.1493 + TEST2(err, KErrEof);
1.1494 + TheDb1.Exec(_L("ROLLBACK"));
1.1495 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1496 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1497 + TEST2(err, KErrNone);
1.1498 + TEST(data.Compare(_L8("a twenty char string")) == 0);
1.1499 + rdStrm.Close();
1.1500 +
1.1501 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("B"), _L8("less than 20")));
1.1502 + TEST2(err, KErrNone);
1.1503 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1504 + TRAP(err, rdStrm.ReadL(data, KBlobSize));
1.1505 + TEST2(err, KErrNone); // changing only part of the blob data is permitted
1.1506 + TEST(data.Compare(_L8("less than 20r string")) == 0);
1.1507 + rdStrm.Close();
1.1508 +
1.1509 + CleanupStack::PopAndDestroy(&rdStrm);
1.1510 + }
1.1511 +
1.1512 +/**
1.1513 +@SYMTestCaseID SYSLIB-SQL-UT-4110
1.1514 +@SYMTestCaseDesc General blob read and write tests on a private secure database,
1.1515 + to ensure that there are no security issues with the methods of
1.1516 + RSqlBlobReadStream, RSqlBlobWriteStream and TSqlBlob.
1.1517 +@SYMTestPriority High
1.1518 +@SYMTestActions Execution of read and write operations on a private secure database.
1.1519 +@SYMTestExpectedResults Test must not fail
1.1520 +@SYMREQ REQ10411
1.1521 + REQ10418
1.1522 + REQ5794
1.1523 +*/
1.1524 +void PrivateSecureDbTestL()
1.1525 + {
1.1526 + // The blob has the value 'ABABABABABABABA'
1.1527 +
1.1528 + // Read data from the blob
1.1529 + const TInt KBlobSize = 15;
1.1530 + RSqlBlobReadStream rdStrm;
1.1531 + CleanupClosePushL(rdStrm);
1.1532 + rdStrm.OpenL(ThePrivateDb, _L("table3"), _L("picture"));
1.1533 + TInt size = rdStrm.SizeL(); // check the blob's size
1.1534 + TEST2(size, KBlobSize);
1.1535 + TBuf8<50> data;
1.1536 + rdStrm.ReadL(data, 5);
1.1537 + TEST(data.Compare(_L8("ABABA")) == 0); // check 5 bytes have been read
1.1538 + rdStrm.ReadL(data, 8);
1.1539 + TEST(data.Compare(_L8("BABABABA")) == 0); // check the next 8 bytes have been read
1.1540 + rdStrm.SizeL(); // check the blob's size
1.1541 + TEST2(size, KBlobSize);
1.1542 + CleanupStack::PopAndDestroy(&rdStrm);
1.1543 +
1.1544 + HBufC8* wholeBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture"));
1.1545 + TInt blobLength = wholeBuf->Length();
1.1546 + TEST2(blobLength, KBlobSize);
1.1547 + TEST(wholeBuf->Des().Compare(_L8("ABABABABABABABA")) == 0);
1.1548 + CleanupStack::PopAndDestroy(wholeBuf);
1.1549 +
1.1550 + HBufC8* buf = HBufC8::NewLC(KBlobSize);
1.1551 + TPtr8 bufPtr(buf->Des());
1.1552 + TInt err = TSqlBlob::Get(ThePrivateDb, _L("table3"), _L("picture"), bufPtr);
1.1553 + TEST2(err, KErrNone);
1.1554 + TEST(bufPtr.Compare(_L8("ABABABABABABABA")) == 0);
1.1555 + CleanupStack::PopAndDestroy(buf);
1.1556 +
1.1557 + // Write data to the blob
1.1558 + RSqlBlobWriteStream wrStrm;
1.1559 + CleanupClosePushL(wrStrm);
1.1560 + wrStrm.OpenL(ThePrivateDb, _L("table3"), _L("picture"));
1.1561 + size = wrStrm.SizeL(); // check the blob's size
1.1562 + TEST2(size, KBlobSize);
1.1563 + wrStrm.WriteL(_L8("AABBCC")); // write 6 bytes
1.1564 + wrStrm.WriteL(_L8("DD")); // write another 2 bytes
1.1565 + wrStrm.WriteL(_L8("EEFFG")); // write another 5 bytes
1.1566 + size = wrStrm.SizeL(); // check the blob's size
1.1567 + TEST2(size, KBlobSize);
1.1568 + wrStrm.CommitL();
1.1569 + CleanupStack::PopAndDestroy(&wrStrm);
1.1570 +
1.1571 + // Check that the new blob data was written
1.1572 + HBufC8* retrievedDataBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture"));
1.1573 + blobLength = retrievedDataBuf->Size();
1.1574 + TEST2(blobLength, KBlobSize);
1.1575 + TEST(retrievedDataBuf->Des().Compare(_L8("AABBCCDDEEFFGBA")) == 0);
1.1576 + CleanupStack::PopAndDestroy(retrievedDataBuf);
1.1577 +
1.1578 + HBufC8* dataBuf = HBufC8::NewLC(KBlobSize);
1.1579 + TPtr8 dataPtr(dataBuf->Des());
1.1580 + dataPtr.Append(_L8("CDCDCDCDCDCDCDC"));
1.1581 + TSqlBlob::SetL(ThePrivateDb, _L("table3"), _L("picture"), dataPtr);
1.1582 + CleanupStack::PopAndDestroy(dataBuf);
1.1583 +
1.1584 + // Check that the new blob data was written
1.1585 + retrievedDataBuf = TSqlBlob::GetLC(ThePrivateDb, _L("table3"), _L("picture"));
1.1586 + blobLength = retrievedDataBuf->Size();
1.1587 + TEST2(blobLength, KBlobSize);
1.1588 + TEST(retrievedDataBuf->Des().Compare(_L8("CDCDCDCDCDCDCDC")) == 0);
1.1589 + CleanupStack::PopAndDestroy(retrievedDataBuf);
1.1590 + }
1.1591 +
1.1592 +/**
1.1593 +@SYMTestCaseID SYSLIB-SQL-UT-4111
1.1594 +@SYMTestCaseDesc Concurrent blob read and write tests using the
1.1595 + methods of RSqlBlobReadStream and RSqlBlobWriteStream.
1.1596 + Tests that read and write operations on different blobs
1.1597 + can happen concurrently and that read operations on the
1.1598 + same blob from different streams can happen concurrently.
1.1599 +@SYMTestPriority Medium
1.1600 +@SYMTestActions Execution of concurrent blob read and write operations on a database.
1.1601 +@SYMTestExpectedResults Test must not fail
1.1602 +@SYMREQ REQ10411
1.1603 + REQ10418
1.1604 +*/
1.1605 +void ConcurrentReadAndWriteTestL()
1.1606 + {
1.1607 + // Insert a zeroblob of size 2Kb
1.1608 + InsertSQLiteZeroBlob(KLargeDataBufLen);
1.1609 + // Insert a zeroblob of size 4Kb
1.1610 + InsertBindZeroBlob(4 * 1024);
1.1611 +
1.1612 + // Handles on different blobs
1.1613 +
1.1614 + // Write and read from different blobs
1.1615 + RSqlBlobReadStream rdStrm;
1.1616 + CleanupClosePushL(rdStrm);
1.1617 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
1.1618 +
1.1619 + RSqlBlobWriteStream wrStrm;
1.1620 + CleanupClosePushL(wrStrm);
1.1621 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1622 +
1.1623 + wrStrm.WriteL(_L8("GHIJKL")); // blob2 is not updated in cache (as client buffer not full)
1.1624 + TBuf8<100> data;
1.1625 + rdStrm.ReadL(data, 6);
1.1626 + _LIT8(KSixZeros, "\x0\x0\x0\x0\x0\x0");
1.1627 + TEST(data.Compare(KSixZeros) == 0);
1.1628 + wrStrm.CommitL(); // blob2 update is not committed (as the rdStrm handle is open)
1.1629 + wrStrm.Close();
1.1630 + rdStrm.ReadL(data, 6);
1.1631 + TEST(data.Compare(KSixZeros) == 0);
1.1632 + rdStrm.Close(); // the blob2 update is committed
1.1633 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
1.1634 + rdStrm.ReadL(data, 2); // read 2 bytes
1.1635 + _LIT8(KTwoZeros, "\x0\x0");
1.1636 + TEST(data.Compare(KTwoZeros) == 0);
1.1637 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1638 + wrStrm.WriteL(TheLargeData); // blob2 is updated in the cache
1.1639 + rdStrm.ReadL(data, 10); // read the next 10 bytes
1.1640 + _LIT8(KTenZeros, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0");
1.1641 + TEST(data.Compare(KTenZeros) == 0);
1.1642 + rdStrm.Close();
1.1643 + wrStrm.CommitL(); // the blob2 update is committed
1.1644 + CleanupStack::PopAndDestroy(2);
1.1645 +
1.1646 + // Write to different blobs via different streams
1.1647 + CleanupClosePushL(wrStrm);
1.1648 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
1.1649 +
1.1650 + RSqlBlobWriteStream wrStrm2;
1.1651 + CleanupClosePushL(wrStrm2);
1.1652 + wrStrm2.OpenL(TheDb1, _L("table1"), _L("B"));
1.1653 +
1.1654 + wrStrm.WriteL(_L8("ABABABABABABAB"));
1.1655 + wrStrm2.WriteL(_L8("CDCDCD"));
1.1656 + wrStrm.WriteL(_L8("EFEF"));
1.1657 + wrStrm.Close();
1.1658 + wrStrm2.Close(); // the blob1 update is committed and the blob2 update is committed
1.1659 + CleanupClosePushL(rdStrm);
1.1660 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
1.1661 + rdStrm.ReadL(data, 18);
1.1662 + TEST(data.Compare(_L8("ABABABABABABABEFEF")) == 0);
1.1663 + rdStrm.Close();
1.1664 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1665 + rdStrm.ReadL(data, 6);
1.1666 + TEST(data.Compare(_L8("CDCDCD")) == 0);
1.1667 + rdStrm.Close();
1.1668 + CleanupStack::PopAndDestroy(3);
1.1669 +
1.1670 + // Read from different blobs via different streams
1.1671 + CleanupClosePushL(rdStrm);
1.1672 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"), TheDb1.LastInsertedRowId() - 1);
1.1673 +
1.1674 + RSqlBlobReadStream rdStrm2;
1.1675 + CleanupClosePushL(rdStrm2);
1.1676 + rdStrm2.OpenL(TheDb1, _L("table1"), _L("B"));
1.1677 +
1.1678 + rdStrm.ReadL(data, 2);
1.1679 + TEST(data.Compare(_L8("AB")) == 0);
1.1680 + rdStrm2.ReadL(data, 3);
1.1681 + TEST(data.Compare(_L8("CDC")) == 0);
1.1682 + rdStrm.ReadL(data, 15);
1.1683 + TEST(data.Compare(_L8("ABABABABABABEFE")) == 0);
1.1684 + rdStrm2.ReadL(data, 2);
1.1685 + TEST(data.Compare(_L8("DC")) == 0);
1.1686 + CleanupStack::PopAndDestroy(2);
1.1687 +
1.1688 + // Handles on the same blob
1.1689 + // NOTE: using different stream objects on the same blob is only
1.1690 + // safe when all of the stream objects are read streams - writing to
1.1691 + // the same blob from different streams or writing and reading from
1.1692 + // the same blob at the same time has undefined behaviour
1.1693 +
1.1694 + // Read from the same blob (blob2) via different streams
1.1695 + CleanupClosePushL(wrStrm);
1.1696 + wrStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1697 + wrStrm.WriteL(_L8("MNOPQR"));
1.1698 + CleanupStack::PopAndDestroy(); // the blob2 update is committed
1.1699 +
1.1700 + CleanupClosePushL(rdStrm);
1.1701 + rdStrm.OpenL(TheDb1, _L("table1"), _L("B"));
1.1702 +
1.1703 + CleanupClosePushL(rdStrm2);
1.1704 + rdStrm2.OpenL(TheDb1, _L("table1"), _L("B"));
1.1705 +
1.1706 + rdStrm.ReadL(data, 2);
1.1707 + TEST(data.Compare(_L8("MN")) == 0);
1.1708 + rdStrm2.ReadL(data, 3);
1.1709 + TEST(data.Compare(_L8("MNO")) == 0);
1.1710 + rdStrm.ReadL(data, 10);
1.1711 + TEST(data.Compare(_L8("OPQRZZZZZZ")) == 0);
1.1712 + rdStrm2.ReadL(data, 15);
1.1713 + TEST(data.Compare(_L8("PQRZZZZZZZZZZZZ")) == 0);
1.1714 + CleanupStack::PopAndDestroy(2);
1.1715 + }
1.1716 +
1.1717 +void UTF16TextL(TInt aTextSize)
1.1718 + {
1.1719 + // The text value is "test", size 8 bytes in UTF-16, aTextSize = 8
1.1720 +
1.1721 + // Try to get the whole content of the text as UTF-8, using TSqlBlob::GetLC()
1.1722 + HBufC8* wholeBuf = TSqlBlob::GetLC(TheDb1, _L("table1"), _L("T"));
1.1723 + TInt bufSize = wholeBuf->Size(); // get the number of bytes in the buffer
1.1724 + TEST2(bufSize, aTextSize);
1.1725 + CleanupStack::PopAndDestroy(wholeBuf);
1.1726 +
1.1727 + // Try to get the whole content of the text as UTF-8, using TSqlBlob::Get()
1.1728 + HBufC8* buf = HBufC8::NewLC(aTextSize);
1.1729 + TPtr8 bufPtr(buf->Des());
1.1730 + TInt err = TSqlBlob::Get(TheDb1, _L("table1"), _L("T"), bufPtr);
1.1731 + TEST2(err, KErrNone);
1.1732 + bufSize = buf->Size(); // get the number of bytes in the buffer
1.1733 + TEST2(bufSize, aTextSize);
1.1734 + CleanupStack::PopAndDestroy(buf);
1.1735 +
1.1736 + // Try to set the whole content of the text as UTF-8, using TSqlBlob::SetL()
1.1737 + HBufC8* dataBuf = HBufC8::NewLC(aTextSize);
1.1738 + TPtr8 dataPtr(dataBuf->Des());
1.1739 + dataPtr.Append(_L8("OPOPOPOP"));
1.1740 + TRAP(err, TSqlBlob::SetL(TheDb1, _L("table1"), _L("T"), dataPtr));
1.1741 + TEST2(err, KErrNone); // can set 8 UTF-8 characters as this is 8 bytes
1.1742 + CleanupStack::PopAndDestroy(dataBuf);
1.1743 + }
1.1744 +
1.1745 +/**
1.1746 +@SYMTestCaseID SYSLIB-SQL-UT-4112
1.1747 +@SYMTestCaseDesc UTF-16 text read and write tests using the UTF-8 methods of
1.1748 + TSqlBlob.
1.1749 +@SYMTestPriority Medium
1.1750 +@SYMTestActions Execution of UTF-16 text read and write operations using
1.1751 + UTF-8 descriptors.
1.1752 +@SYMTestExpectedResults Test must not fail
1.1753 +@SYMREQ REQ10411
1.1754 + REQ10418
1.1755 +*/
1.1756 +void UTF16FormatTestL()
1.1757 + {
1.1758 + // Insert a record with a UTF-16 text value (text is encoded in UTF-16 by default)
1.1759 + TInt err = TheDb1.Exec(_L("INSERT INTO table1 VALUES(1, 'test', x'46474647464746474647')"));
1.1760 + TEST2(err, 1);
1.1761 + const TInt KTextSize = 8; // 8 bytes (4 UTF-16 characters)
1.1762 +
1.1763 + // Now read and write the UTF-16 text value using UTF-8 methods
1.1764 + UTF16TextL(KTextSize);
1.1765 + }
1.1766 +
1.1767 +/**
1.1768 +@SYMTestCaseID SYSLIB-SQL-UT-4114
1.1769 +@SYMTestCaseDesc Storing a big blob test, to ensure that by using the methods
1.1770 + of RSqlBlobReadStream and RSqlBlobWriteStream larger blobs can
1.1771 + be stored in practice than in previous versions of Symbian SQL.
1.1772 + Creates a 18Mb zeroblob and then writes data into it and reads
1.1773 + the data back.
1.1774 + Also tests the TSqlBlob APIs to store and retrieve a large blob.
1.1775 + Note that the test will use 18Mb blob only in WINSCW builds.
1.1776 + Otherwise the used blob size is 3Mb.
1.1777 +@SYMTestPriority Medium
1.1778 +@SYMTestActions Execution of creating a 18Mb zeroblob, writing data to it and
1.1779 + reading it back.
1.1780 +@SYMTestExpectedResults Test must not fail
1.1781 +@SYMREQ REQ10410
1.1782 +*/
1.1783 +void BigBlobTestL()
1.1784 + {
1.1785 + // In this test we create a zeroblob big enough to hold a 18MB blob.
1.1786 + // 18MB is larger than the server could previously read or write,
1.1787 + // due to the server heap limit of 6MB (WINSCW builds).
1.1788 + // This test will prove that a 18MB blob can be written and read
1.1789 + // using the new APIs but not with the old APIs
1.1790 +
1.1791 +#if defined __WINS__ || defined __WINSCW__
1.1792 + const TInt KBigBlobSize = 18 * 1024 * 1024;
1.1793 +#else
1.1794 + const TInt KBigBlobSize = 3 * 1024 * 1024;
1.1795 +#endif
1.1796 +
1.1797 + // Create a zeroblob big enough to hold a 36MB blob
1.1798 + TInt err = TheDb2.Exec(_L("BEGIN"));
1.1799 + TEST(err >= 0);
1.1800 +
1.1801 + RSqlStatement stmt;
1.1802 + err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(435, 'big blob test', :Val)"));
1.1803 + TEST2(err, KErrNone);
1.1804 + TInt paramIndex = stmt.ParameterIndex(_L(":Val"));
1.1805 + TEST(paramIndex >= 0);
1.1806 + err = stmt.BindZeroBlob(paramIndex, KBigBlobSize);
1.1807 + TEST2(err, KErrNone);
1.1808 + err = stmt.Exec();
1.1809 + stmt.Close();
1.1810 + if(err == KErrDiskFull)
1.1811 + {
1.1812 + (void)TheDb2.Exec(_L("ROLLBACK"));
1.1813 + TheTest.Printf(_L("==== The disk is full. The test cannot be completed!\r\n"));
1.1814 + RFs fs;
1.1815 + err = fs.Connect();
1.1816 + if(err == KErrNone)
1.1817 + {
1.1818 + TVolumeInfo vinfo;
1.1819 + err = fs.Volume(vinfo, EDriveC);
1.1820 + if(err == KErrNone)
1.1821 + {
1.1822 + TheTest.Printf(_L("==== Free disk space=%d\r\n"), vinfo.iFree);
1.1823 + }
1.1824 + fs.Close();
1.1825 + }
1.1826 + return;
1.1827 + }
1.1828 + TEST2(err, 1);
1.1829 +
1.1830 + /////////////////////////////////////////////////////////////////////////////////////////////////////
1.1831 + // Fill a buffer with KBigBlobSize/KBlobPartCnt bytes of data
1.1832 + // (the test application's heap may be too small to allocate a KBigBlobSize bytes buffer)
1.1833 + const TInt KBlobWrPartCnt = 16;// 1/16 part of the blob will be written at once using streaming API
1.1834 + const TInt KBufferSize1 = KBigBlobSize / KBlobWrPartCnt;
1.1835 + HBufC8* blobWrBuf = HBufC8::NewLC(KBufferSize1);
1.1836 + TPtr8 blobWrChunk(blobWrBuf->Des());
1.1837 + blobWrChunk.Fill('Z', KBufferSize1);
1.1838 +
1.1839 + // Write KBigBlobSize bytes to the blob in the inserted record
1.1840 + RSqlBlobWriteStream wrStrm;
1.1841 + CleanupClosePushL(wrStrm);
1.1842 + wrStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
1.1843 + TInt size = wrStrm.SizeL(); // check the blob's size
1.1844 + TEST2(size, KBigBlobSize);
1.1845 + for(TInt i1=0;i1<KBlobWrPartCnt;++i1)
1.1846 + {
1.1847 + TRAP(err, wrStrm.WriteL(blobWrChunk)); // write KBufferSize1 bytes of data
1.1848 + TEST2(err, KErrNone);
1.1849 + }
1.1850 + wrStrm.CommitL();
1.1851 + CleanupStack::PopAndDestroy(&wrStrm);
1.1852 +
1.1853 + err = TheDb2.Exec(_L("COMMIT"));
1.1854 + TEST2(err, 1);
1.1855 +
1.1856 + /////////////////////////////////////////////////////////////////////////////////////////////////////
1.1857 + // Read the big blob value back from the record in KBigBlobSize/6 chunks
1.1858 + const TInt KBlobRdPartCnt = 24;// 1/24 part of the blob will be read at once using streaming API
1.1859 + const TInt KBufferSize2 = KBigBlobSize / KBlobRdPartCnt;
1.1860 + HBufC8* blobRdBuf = HBufC8::NewLC(KBufferSize2);
1.1861 + TPtr8 blobRdBufPtr(blobRdBuf->Des());
1.1862 + RSqlBlobReadStream rdStrm;
1.1863 + CleanupClosePushL(rdStrm);
1.1864 + rdStrm.OpenL(TheDb2, _L("table2"), _L("blob"));
1.1865 + size = rdStrm.SizeL(); // check the blob's size
1.1866 + TEST2(size, KBigBlobSize);
1.1867 + for(TInt i2=0;i2<KBlobRdPartCnt;++i2)
1.1868 + {
1.1869 + rdStrm.ReadL(blobRdBufPtr, KBufferSize2);
1.1870 + TEST(blobRdBufPtr.Compare(blobWrChunk.Left(KBufferSize2)) == 0); // check the first KBigBlobSize/KBlobRdPartCnt bytes
1.1871 + }
1.1872 + TRAP(err, rdStrm.ReadL(blobRdBufPtr, 1));
1.1873 + TEST2(err, KErrEof); // check that there is no more data to be read
1.1874 + CleanupStack::PopAndDestroy(2, blobRdBuf); // rdStrm, blobRdBuf
1.1875 +
1.1876 + /////////////////////////////////////////////////////////////////////////////////////////////////////
1.1877 + // Try to read the whole KBigBlobSize blob value using the old API
1.1878 + err = stmt.Prepare(TheDb2, _L("SELECT blob FROM table2 WHERE ROWID == :Val"));
1.1879 + TEST2(err, KErrNone);
1.1880 + paramIndex = stmt.ParameterIndex(_L(":Val"));
1.1881 + TEST(paramIndex >= 0);
1.1882 + err = stmt.BindInt(paramIndex, TheDb2.LastInsertedRowId());
1.1883 + TEST2(err, KErrNone);
1.1884 + // Check that the blob retrieval fails (because there is
1.1885 + // not enough server-side memory to load it into the VDBE)
1.1886 + err = stmt.Next();
1.1887 +#if defined __WINS__ || defined __WINSCW__
1.1888 + TEST2(err, KErrNoMemory);
1.1889 +#else
1.1890 + TEST2(err, KSqlAtRow);
1.1891 +#endif
1.1892 + stmt.Close();
1.1893 +
1.1894 + /////////////////////////////////////////////////////////////////////////////////////////////////////
1.1895 + // Try to write another KBigBlobSize bytes big blob value using the old API.
1.1896 + // Check that the at some point the blob write fails (because there is
1.1897 + // not enough server-side memory to store the whole KBigBlobSize bytes).
1.1898 + err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(99, 'text', :Val)"));
1.1899 + TEST2(err, KErrNone);
1.1900 + paramIndex = stmt.ParameterIndex(_L(":Val"));
1.1901 + TEST(paramIndex >= 0);
1.1902 + RSqlParamWriteStream strm;
1.1903 + err = strm.BindBinary(stmt, paramIndex);
1.1904 + TEST2(err, KErrNone);
1.1905 + for(TInt i3=0;i3<KBlobWrPartCnt && err==KErrNone;++i3)
1.1906 + {
1.1907 + TRAP(err, strm.WriteL(blobWrChunk, KBufferSize1));
1.1908 + }
1.1909 +#if defined __WINS__ || defined __WINSCW__
1.1910 + TEST2(err, KErrNoMemory);
1.1911 +#else
1.1912 + TEST2(err, KErrNone);
1.1913 +#endif
1.1914 + strm.Close();
1.1915 + stmt.Close();
1.1916 + CleanupStack::PopAndDestroy(blobWrBuf);
1.1917 + blobWrBuf = NULL;
1.1918 +
1.1919 + /////////////////////////////////////////////////////////////////////////////////////////////////////
1.1920 + // Use the TSqlBlob APIs to insert another big blob of size 85Kb
1.1921 + // (to test the block algorithm used by TSqlBlob 'set')
1.1922 + const TInt KBigBlobSize2 = 85 * 1024;
1.1923 + err = TheDb2.Exec(_L("BEGIN"));
1.1924 + TEST(err >= 0);
1.1925 +
1.1926 + err = stmt.Prepare(TheDb2, _L("INSERT INTO table2 values(189, 'another big blob', :Val)"));
1.1927 + TEST2(err, KErrNone);
1.1928 + paramIndex = stmt.ParameterIndex(_L(":Val"));
1.1929 + TEST(paramIndex >= 0);
1.1930 + err = stmt.BindZeroBlob(paramIndex, KBigBlobSize2);
1.1931 + TEST2(err, KErrNone);
1.1932 + err = stmt.Exec();
1.1933 + TEST2(err, 1);
1.1934 + stmt.Close();
1.1935 +
1.1936 + blobWrBuf = HBufC8::NewLC(KBigBlobSize2);
1.1937 + blobWrChunk.Set(blobWrBuf->Des());
1.1938 + blobWrChunk.SetLength(KBigBlobSize2);
1.1939 + blobWrChunk.Fill('F');
1.1940 + TPtr8 p((TUint8*)blobWrChunk.Ptr() + blobWrChunk.Length() / 2, blobWrChunk.Length() / 2);
1.1941 + p.Fill('E');// blobWrBuf now contains 42.5Kb of 'E's followed by 42.5Kb of 'F's
1.1942 +
1.1943 + TRAP(err, TSqlBlob::SetL(TheDb2, _L("table2"), _L("blob"), blobWrChunk));
1.1944 + TEST2(err, KErrNone);
1.1945 +
1.1946 + err = TheDb2.Exec(_L("COMMIT"));
1.1947 + TEST2(err, 1);
1.1948 +
1.1949 + // Read the blob value back from the record
1.1950 + // (to test the block algorithm used by TSqlBlob 'get')
1.1951 + HBufC8* buf = TSqlBlob::GetLC(TheDb2, _L("table2"), _L("blob"));
1.1952 + TEST(buf->Des().Compare(blobWrChunk) == 0);
1.1953 + CleanupStack::PopAndDestroy(buf);
1.1954 + buf = NULL;
1.1955 +
1.1956 + buf = HBufC8::NewLC(KBigBlobSize2);
1.1957 + blobRdBufPtr.Set(buf->Des());
1.1958 + err = TSqlBlob::Get(TheDb2, _L("table2"), _L("blob"), blobRdBufPtr);
1.1959 + TEST2(err, KErrNone);
1.1960 + TEST(blobRdBufPtr.Compare(blobWrChunk) == 0);
1.1961 +
1.1962 + CleanupStack::PopAndDestroy(2, blobWrBuf); // buf, blobWrBuf
1.1963 + }
1.1964 +
1.1965 +/**
1.1966 +@SYMTestCaseID PDS-SQL-CT-4194
1.1967 +@SYMTestCaseDesc The test opens a test database, creates a table with a blob column and inserts one record.
1.1968 + Then the test uses RSqlBlobWriteStream to modify the blob column content.
1.1969 + MStreamBuf::SeekL() is used to modify the blob data at specific positions.
1.1970 + Then the test uses RSqlBlobReadStream object to read the just written blob data.
1.1971 + MStreamBuf::SeekL() is used to read the column content at specific positions
1.1972 + (the same positions used during the blob write operation). The read byte values must
1.1973 + match the written byte values.
1.1974 +@SYMTestPriority High
1.1975 +@SYMTestActions RSqlBlobReadStream and RSqlBlobWriteStream - MStreamBuf::SeekL() test.
1.1976 +@SYMTestExpectedResults Test must not fail
1.1977 +@SYMDEF DEF145028
1.1978 +*/
1.1979 +void StreamSeekTestL()
1.1980 + {
1.1981 + TInt rc = TheDb1.Exec(_L("CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)"));
1.1982 + TEST(rc >= 0);
1.1983 +
1.1984 + //Write a record to the database using a blob stream. MStreamBuf::SeekL() is used to modify the content at a specific position.
1.1985 + rc = TheDb1.Exec(_L("INSERT INTO A(Fld1, Fld2) VALUES(1, zeroblob(256))"));
1.1986 + TEST2(rc, 1);
1.1987 + RSqlBlobWriteStream strm1;
1.1988 + CleanupClosePushL(strm1);
1.1989 + strm1.OpenL(TheDb1, _L("A"), _L("Fld2"));
1.1990 + for(TInt i=0;i<256;++i)
1.1991 + {
1.1992 + strm1 << (TUint8)i;
1.1993 + }
1.1994 +
1.1995 + const TInt KStreamOffset = 10;
1.1996 + const TUint8 KByte = 'z';
1.1997 + _LIT8(KData, "QWERTYUIOPASDFG");
1.1998 +
1.1999 + MStreamBuf* strm1buf = strm1.Sink();
1.2000 + TEST(strm1buf != NULL);
1.2001 +
1.2002 + strm1buf->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0);
1.2003 + strm1buf->WriteL(&KByte, 1);
1.2004 +
1.2005 + strm1buf->SeekL(MStreamBuf::EWrite, EStreamMark, KStreamOffset);
1.2006 + strm1buf->WriteL(&KByte, 1);
1.2007 +
1.2008 + strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -KData().Length());
1.2009 + strm1buf->WriteL(KData().Ptr(), KData().Length());
1.2010 +
1.2011 + strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -4 * KStreamOffset);
1.2012 + strm1buf->WriteL(&KByte, 1);
1.2013 +
1.2014 + strm1.CommitL();
1.2015 + CleanupStack::PopAndDestroy(&strm1);
1.2016 +
1.2017 + //Read the record using a blob stream. MStreamBuf::SeekL() is used to read the content at a specific position.
1.2018 + RSqlBlobReadStream strm2;
1.2019 + CleanupClosePushL(strm2);
1.2020 + strm2.OpenL(TheDb1, _L("A"), _L("Fld2"));
1.2021 +
1.2022 + TUint8 byte = 0;
1.2023 + MStreamBuf* strm2buf = strm2.Source();
1.2024 + TEST(strm1buf != NULL);
1.2025 +
1.2026 + strm2buf->SeekL(MStreamBuf::ERead, EStreamBeginning, 0);
1.2027 + rc = strm2buf->ReadL(&byte, 1);
1.2028 + TEST2(rc, 1);
1.2029 + TEST2(byte, KByte);
1.2030 +
1.2031 + strm2buf->SeekL(MStreamBuf::ERead, EStreamMark, KStreamOffset);
1.2032 + rc = strm2buf->ReadL(&byte, 1);
1.2033 + TEST2(rc, 1);
1.2034 + TEST2(byte, KByte);
1.2035 +
1.2036 + strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -KData().Length());
1.2037 + TUint8 buf[20];
1.2038 + rc = strm2buf->ReadL(buf, KData().Length());
1.2039 + TEST2(rc, KData().Length());
1.2040 + TPtrC8 bufptr(buf, rc);
1.2041 + TEST(bufptr == KData);
1.2042 +
1.2043 + strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -4 * KStreamOffset);
1.2044 + rc = strm2buf->ReadL(&byte, 1);
1.2045 + TEST2(rc, 1);
1.2046 + TEST2(byte, KByte);
1.2047 +
1.2048 + CleanupStack::PopAndDestroy(&strm2);
1.2049 + }
1.2050 +
1.2051 +void DoTestsL()
1.2052 + {
1.2053 + CreateTestDbs();
1.2054 +
1.2055 + // Insert a zeroblob using RSqlStatement::BindZeroBlob() and read and write to it using streams
1.2056 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4099: Stream BindZeroBlob() test"));
1.2057 + StreamBindZeroBlobTestL();
1.2058 +
1.2059 + // Insert a zeroblob using SQLite's zeroblob() function and read and write to it using streams
1.2060 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4100: Stream zeroblob() test"));
1.2061 + StreamSqliteZeroBlobTestL();
1.2062 +
1.2063 + // Insert a record containing a 'real' blob and read and write to it using streams
1.2064 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4101: Stream real blob test"));
1.2065 + StreamRealBlobTestL();
1.2066 +
1.2067 + // Get a whole blob object
1.2068 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4102: Whole value blob retrieval test"));
1.2069 + GetWholeBlob3L();
1.2070 +
1.2071 + // Set a whole blob object
1.2072 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4104: Whole value blob set test"));
1.2073 + SetWholeBlob3L();
1.2074 +
1.2075 + // Attached database test
1.2076 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4106: Attached database test"));
1.2077 + AttachDbTestL();
1.2078 +
1.2079 + // Bad parameter test
1.2080 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4107: Bad parameter test"));
1.2081 + BadParamTestL();
1.2082 +
1.2083 + // Indexed column test
1.2084 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4108: Indexed column test"));
1.2085 + IndexedColumnTestL();
1.2086 +
1.2087 + // End Of File test
1.2088 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4109: Eof test"));
1.2089 + EofTestL();
1.2090 +
1.2091 + // Private secure database test
1.2092 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4110: Private secure db test"));
1.2093 + PrivateSecureDbTestL();
1.2094 +
1.2095 + // Concurrent read and write test
1.2096 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4111: Concurrent read and write test"));
1.2097 + ConcurrentReadAndWriteTestL();
1.2098 +
1.2099 + // UTF-16 read and write test
1.2100 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4112: UTF-16 format test"));
1.2101 + UTF16FormatTestL();
1.2102 +
1.2103 + // Big blob test
1.2104 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4114: Big blob test"));
1.2105 + BigBlobTestL();
1.2106 +
1.2107 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4194: Blob streams. MStreamBuf::SeekL() test"));
1.2108 + StreamSeekTestL();
1.2109 +
1.2110 + DeleteTestDbs();
1.2111 + }
1.2112 +
1.2113 +TInt E32Main()
1.2114 + {
1.2115 + TheTest.Title();
1.2116 +
1.2117 + CTrapCleanup* tc = CTrapCleanup::New();
1.2118 +
1.2119 + __UHEAP_MARK;
1.2120 +
1.2121 + CreateTestDir();
1.2122 + DeleteTestDbs();
1.2123 + FillLargeDataBuf();
1.2124 + TRAPD(err, DoTestsL());
1.2125 + TEST2(err, KErrNone);
1.2126 +
1.2127 + __UHEAP_MARKEND;
1.2128 +
1.2129 + TheTest.End();
1.2130 + TheTest.Close();
1.2131 +
1.2132 + delete tc;
1.2133 +
1.2134 + User::Heap().Check();
1.2135 + return KErrNone;
1.2136 + }
1.2137 +