1368 

  1369 /**

  1370 @SYMTestCaseID          PDS-SQL-CT-4191

  1371 @SYMTestCaseDesc        The test creates a test database and inserts one record using a stream.

  1372                         MStreamBuf::SeekL() is used to modify the parameter data at specific positions.

  1373                         Then the test executes a SELECT statement to read the just written record.

  1374                         MStreamBuf::SeekL() is used to read the column content at specific positions 

  1375                         (the same positions used during the record write operation). The read byte values must

  1376                         match the written byte values.

  1377 @SYMTestPriority        High

  1378 @SYMTestActions         RSqlColumnReadStream::ColumnBinary() and RSqlParamWriteStream::BindBinary() - MStreamBuf::SeekL() test.

  1379 @SYMTestExpectedResults Test must not fail

  1380 @SYMDEF                 DEF145125

  1381 */  

  1382 void StreamSeekTestL()

  1383     {

  1384     RSqlDatabase db;

  1385     CleanupClosePushL(db);

  1386     TInt rc = db.Create(KTestDbName1);

  1387     TEST2(rc, KErrNone);

  1388     rc = db.Exec(_L("CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)"));

  1389     TEST(rc >= 0);

  1390     //Write a record to the database using a stream. MStreamBuf::SeekL() is used to modify the content at a specific position.

  1391     RSqlStatement stmt;

  1392     CleanupClosePushL(stmt);

  1393     rc = stmt.Prepare(db, _L("INSERT INTO A(Fld1, Fld2) VALUES(1, ?)"));

  1394     TEST2(rc, KErrNone);

  1395     

  1396     RSqlParamWriteStream strm1;

  1397     CleanupClosePushL(strm1);

  1398     rc = strm1.BindBinary(stmt, 0);

  1399     TEST2(rc, KErrNone);

  1400 

  1401     for(TInt i=0;i<256;++i)

  1402         {

  1403         strm1 << (TUint8)i;

  1404         }

  1405     

  1406     const TInt KStreamOffset = 10;

  1407     const TUint8 KByte = 'z';

  1408     _LIT8(KData, "QWERTYUIOPASDFG");

  1409     

  1410     MStreamBuf* strm1buf = strm1.Sink();

  1411     TEST(strm1buf != NULL);

  1412     

  1413     strm1buf->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0);

  1414     strm1buf->WriteL(&KByte, 1);

  1415     

  1416     strm1buf->SeekL(MStreamBuf::EWrite, EStreamMark, KStreamOffset);

  1417     strm1buf->WriteL(&KByte, 1);

  1418     

  1419     strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, 0);

  1420     strm1buf->WriteL(KData().Ptr(), KData().Length());

  1421     

  1422     strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -4 * KStreamOffset);

  1423     strm1buf->WriteL(&KByte, 1);

  1424     

  1425     strm1.CommitL();

  1426     CleanupStack::PopAndDestroy(&strm1);

  1427     

  1428     rc = stmt.Exec();

  1429     TEST2(rc, 1);

  1430     CleanupStack::PopAndDestroy(&stmt);

  1431     

  1432     //Read the record using a stream. MStreamBuf::SeekL() is used to read the content at a specific position.

  1433     CleanupClosePushL(stmt);

  1434     rc = stmt.Prepare(db, _L("SELECT Fld2 FROM A WHERE Fld1 = 1"));

  1435     TEST2(rc, KErrNone);

  1436     rc = stmt.Next();

  1437     TEST2(rc, KSqlAtRow);

  1438     

  1439     RSqlColumnReadStream strm2;

  1440     CleanupClosePushL(strm2);

  1441     rc = strm2.ColumnBinary(stmt, 0);

  1442     TEST2(rc, KErrNone);

  1443 

  1444     TUint8 byte = 0;

  1445     MStreamBuf* strm2buf = strm2.Source();

  1446     TEST(strm1buf != NULL);

  1447     

  1448     strm2buf->SeekL(MStreamBuf::ERead, EStreamBeginning, 0);

  1449     rc = strm2buf->ReadL(&byte, 1);

  1450     TEST2(rc, 1);

  1451     TEST2(byte, KByte);

  1452     

  1453     strm2buf->SeekL(MStreamBuf::ERead, EStreamMark, KStreamOffset);

  1454     rc = strm2buf->ReadL(&byte, 1);

  1455     TEST2(rc, 1);

  1456     TEST2(byte, KByte);

  1457     

  1458     strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -KData().Length());

  1459     TUint8 buf[20];

  1460     rc = strm2buf->ReadL(buf, KData().Length());

  1461     TEST2(rc, KData().Length());

  1462     TPtrC8 bufptr(buf, rc);

  1463     TEST(bufptr == KData);

  1464     

  1465     strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -4 * KStreamOffset);

  1466     rc = strm2buf->ReadL(&byte, 1);

  1467     TEST2(rc, 1);

  1468     TEST2(byte, KByte);

  1469     

  1470     CleanupStack::PopAndDestroy(&strm2);

  1471     CleanupStack::PopAndDestroy(&stmt);

  1472     

  1473     CleanupStack::PopAndDestroy(&db);

  1474     rc = RSqlDatabase::Delete(KTestDbName1);

  1475     TEST2(rc, KErrNone);

  1476     }

  1477 

  1478 /**

  1479 @SYMTestCaseID          PDS-SQL-CT-4174

  1480 @SYMTestCaseDesc        Test for DEF144937: SQL, SQL server, the code coverage can be improved in some areas.

  1481 @SYMTestPriority        High

  1482 @SYMTestActions         The test creates a test database with a table with 3 records.

  1483                         The first record has a BLOB column with 0 length.

  1484                         The second record has a BLOB column with length less than KSqlMaxDesLen

  1485                         (in debug mode) in which case no IPC call is needed to be made in order 

  1486                         to access the column value via stream.

  1487                         The third record has a BLOB column with length exactly KSqlMaxDesLen 

  1488                         in which case an IPC call will be made in order to retrieve the column value,

  1489                         but the column value will be copied directly to the client - no stream object is created. 

  1490 @SYMTestExpectedResults Test must not fail

  1491 @SYMDEF                 DEF144937

  1492 */  

  1493 void ColumnBinaryStreamTest2()

  1494     {

  1495     RSqlDatabase db;    

  1496     TInt rc = db.Create(KTestDbName1);

  1497     TEST2(rc, KErrNone);

  1498 

  1499     enum {KSqlBufSize = 128};

  1500     

  1501     //Create a table

  1502     _LIT8(KSqlStmt1, "CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB);");

  1503     ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt1(), KErrNone);

  1504     

  1505     //Insert one record where the BLOB length is 0. 

  1506     //Insert second record where the BLOB length is smaller than the max inline column length - KSqlMaxDesLen.

  1507     //Insert third record where the BLOB length is exactly the max inline column length - KSqlMaxDesLen.

  1508     _LIT8(KSqlStmt2, "INSERT INTO A VALUES(1, '');INSERT INTO A VALUES(2, x'0102030405');INSERT INTO A VALUES(3, x'0102030405060708');");

  1509     ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt2(), KErrNone);

  1510     

  1511     RSqlStatement stmt;

  1512     rc = stmt.Prepare(db, _L("SELECT Fld2 FROM A"));

  1513     TEST2(rc, KErrNone);

  1514 

  1515     TBuf8<16> databuf;

  1516     

  1517     rc = stmt.Next();

  1518     TEST2(rc, KSqlAtRow);

  1519     //ColumnBinary() does not make an IPC call because the BLOB length is 0.

  1520     RSqlColumnReadStream strm;

  1521     rc = strm.ColumnBinary(stmt, 0);

  1522     TEST2(rc, KErrNone);

  1523     TRAP(rc, strm.ReadL(databuf, stmt.ColumnSize(0)));

  1524     strm.Close();

  1525     TEST2(rc, KErrNone);

  1526     TEST2(databuf.Length(), 0);

  1527 

  1528     rc = stmt.Next();

  1529     TEST2(rc, KSqlAtRow);

  1530     //ColumnBinary() does not make an IPC call because the BLOB length is less than the max inline 

  1531     //column length - KSqlMaxDesLen.

  1532     rc = strm.ColumnBinary(stmt, 0);

  1533     TEST2(rc, KErrNone);

  1534     TRAP(rc, strm.ReadL(databuf, stmt.ColumnSize(0)));

  1535     strm.Close();

  1536     TEST2(rc, KErrNone);

  1537     TEST(databuf == _L8("\x1\x2\x3\x4\x5"));

  1538 

  1539     rc = stmt.Next();

  1540     TEST2(rc, KSqlAtRow);

  1541     //ColumnBinary() makes an IPC call  (in _DEBUG mode) because:

  1542     // - the column length is exactly KSqlMaxDesLen.  

  1543     // - but at the same time the column length is equal to KIpcBufSize (in debug mode).

  1544     rc = strm.ColumnBinary(stmt, 0);

  1545     TEST2(rc, KErrNone);

  1546     TRAP(rc, strm.ReadL(databuf, stmt.ColumnSize(0)));

  1547     strm.Close();

  1548     TEST2(rc, KErrNone);

  1549     TEST(databuf == _L8("\x1\x2\x3\x4\x5\x6\x7\x8"));

  1550     

  1551     stmt.Close();

  1552     db.Close();

  1553 

  1554     rc = RSqlDatabase::Delete(KTestDbName1);

  1555     TEST2(rc, KErrNone);

  1556     }

  2398     TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-CT-4174 CSqlSrvSession::NewOutputStreamL() coverage test"));

  2399 	ColumnBinaryStreamTest2();

  2400 	

  2407     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4191 MStreamBuf::SeekL() test"));

  2408     StreamSeekTestL();

  2409