sl@0: // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32test.h>
sl@0: #include <s32buf.h>
sl@0: #include <bautils.h>
sl@0: #include <sqldb.h>
sl@0: #include <stdio.h>
sl@0: #include <stdlib.h>
sl@0: #include "SqlResourceTester.h"      //TSqlResourceTester
sl@0: #include "sqlite3.h"
sl@0: #include "SqliteSymbian.h"
sl@0: 
sl@0: //In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, 
sl@0: //when _SQLPROFILER macro is defined)
sl@0: #ifdef _SQLPROFILER
sl@0: TInt TheSqlSrvProfilerFileRead = 0;
sl@0: TInt TheSqlSrvProfilerFileWrite = 0;
sl@0: TInt TheSqlSrvProfilerFileSync = 0;
sl@0: TInt TheSqlSrvProfilerFileSetSize = 0;
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_sqloom6 test"));
sl@0: 
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KDbFile, "c:\\test\\t_sqloom6.db");
sl@0: 
sl@0: static RSqlDatabase TheDb;
sl@0: static RSqlStatement TheStmt;
sl@0: 
sl@0: static TInt TheProcessHandleCount = 0;
sl@0: static TInt TheThreadHandleCount = 0;
sl@0: static TInt TheAllocatedCellsCount = 0;
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DestroyTestEnv()
sl@0: 	{
sl@0: 	TheStmt.Close();
sl@0: 	TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     sqlite3SymbianLibFinalize();
sl@0:     CloseSTDLIB();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		DestroyTestEnv();
sl@0: 		RDebug::Print(_L("*** Expresssion evaluated to false\r\n"));
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		DestroyTestEnv();
sl@0: 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: #define TEST(arg) ::Check((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: static void MarkHandles()
sl@0:     {
sl@0:     RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
sl@0:     }
sl@0: 
sl@0: static void MarkAllocatedCells()
sl@0:     {
sl@0:     TheAllocatedCellsCount = User::CountAllocCells();
sl@0:     }
sl@0: 
sl@0: static void CheckAllocatedCells()
sl@0:     {
sl@0:     TInt allocatedCellsCount = User::CountAllocCells();
sl@0:     TEST2(allocatedCellsCount, TheAllocatedCellsCount);
sl@0:     }
sl@0: 
sl@0: static void CheckHandles()
sl@0:     {
sl@0:     TInt endProcessHandleCount;
sl@0:     TInt endThreadHandleCount;
sl@0:     
sl@0:     RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0: 
sl@0:     TEST2(TheProcessHandleCount, endProcessHandleCount);
sl@0:     TEST2(TheThreadHandleCount, endThreadHandleCount);
sl@0:     }
sl@0: 
sl@0: static void OomPreStep(TInt aFailingAllocationNo)
sl@0:     {
sl@0:     MarkHandles();
sl@0:     MarkAllocatedCells();
sl@0:     __UHEAP_MARK;
sl@0:     TSqlResourceTester::Mark();
sl@0:     TSqlResourceTester::SetHeapFailure(RHeap::EBurstFailNext, aFailingAllocationNo);
sl@0:     }
sl@0: 
sl@0: static void OomPostStep()
sl@0:     {
sl@0:     __UHEAP_RESET;
sl@0:     TSqlResourceTester::SetHeapFailure(RHeap::ENone, 0);
sl@0:     TSqlResourceTester::Check();
sl@0:     CheckAllocatedCells();
sl@0:     CheckHandles();
sl@0:     }
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void CreateTestEnv()
sl@0:     {
sl@0:     RFs fs;
sl@0:     TInt err = fs.Connect();
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     err = fs.MkDir(KTestDir);
sl@0:     TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 
sl@0:     err = fs.CreatePrivatePath(EDriveC);
sl@0:     TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0:     
sl@0:     fs.Close();
sl@0: 
sl@0:     sqlite3SymbianLibInit();
sl@0:     }
sl@0: 
sl@0: //Creates a UTF8 encoded database with:
sl@0: // - One table with three colums: A(ColumnName1234567890, Col2, Col3);
sl@0: // - One record in the table with values: ('A1234567890', 'A12345', '');
sl@0: void CreateTestDb(const TDesC& aDbName)
sl@0:     {
sl@0:     TBuf8<100> dbName8;
sl@0:     dbName8.Copy(aDbName);
sl@0:     sqlite3* db = 0;
sl@0:     int rc = sqlite3_open((const char*)dbName8.PtrZ(), &db);
sl@0:     TEST2(rc, SQLITE_OK);
sl@0:     rc = sqlite3_exec(db, "CREATE TABLE A(ColumnName1234567890 TEXT, Col2 LONG TEXT, Col3 SMALL TEXT)", 0, 0, 0);
sl@0:     TEST2(rc, SQLITE_OK);
sl@0:     rc = sqlite3_exec(db, "INSERT INTO A VALUES('A1234567890', 'A12345', '')", 0, 0, 0);
sl@0:     TEST2(rc, SQLITE_OK);
sl@0:     sqlite3_close(db);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4176
sl@0: @SYMTestCaseDesc        RSqlStatement::ColumnName() OOM test.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test runs RSqlStatement::ColumnName() in an OOM simulation loop.
sl@0:                         The difference betwee this test case and the similar test case in t_sqloom2 is that here:
sl@0:                          - burst OOM simulation is used;
sl@0:                          - UTF8 encoded database is used;
sl@0:                          - only SQL server side OOM simulation is performed;
sl@0:                          The purpose of the test is to verify that the ColumnName() call behaves correctly 
sl@0:                          when the related sqlite3_column_name16() call performed by the SQL server fails 
sl@0:                          with "no memory".
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF145033
sl@0: */  
sl@0: void ColumnNameOomTest()
sl@0:     {
sl@0:     //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
sl@0:     //stream objects, the allocated memory cells are not counted.
sl@0:     //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
sl@0:     //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
sl@0:     //and they will not be deallocated when the statement object is closed. 
sl@0:     //But the result of the RSqlStatement::ColumnName() operation is checked. If there is a failed memory
sl@0:     //allocation on the server side, the returned column name can be NULL and that will be tested.
sl@0:     
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 
sl@0:     CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
sl@0:     
sl@0:     TInt err = TheDb.Open(KDbFile);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TInt failingAllocationNo = 0;
sl@0:     err = KErrNoMemory;
sl@0:     while(err == KErrNoMemory)
sl@0:         {
sl@0:         TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0:         OomPreStep(failingAllocationNo);
sl@0:         
sl@0:         err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep;
sl@0:             }
sl@0:         
sl@0:         TPtrC name;
sl@0:         err = TheStmt.ColumnName(0, name);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(name == _L("ColumnName1234567890"));
sl@0:         
sl@0:         err = TheStmt.ColumnName(1, name);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(name == _L("Col2"));
sl@0:         
sl@0:         err = TheStmt.ColumnName(2, name);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(name == _L("Col3"));
sl@0:         
sl@0: LabelStmtClose:        
sl@0:         TheStmt.Close();
sl@0:         
sl@0: LabelOomPostStep:        
sl@0:         OomPostStep();
sl@0:         }
sl@0: 
sl@0:     TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TEST2(err, KErrNone);   
sl@0:     TheTest.Printf(_L("\r\n===RSqlStatement::ColumnName() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4177
sl@0: @SYMTestCaseDesc        RSqlStatement::ParameterName() OOM test.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test runs RSqlStatement::ParameterName() in an OOM simulation loop.
sl@0:                         The difference betwee this test case and the similar test case in t_sqloom2 is that here:
sl@0:                          - burst OOM simulation is used;
sl@0:                          - UTF8 encoded database is used;
sl@0:                          - only SQL server side OOM simulation is performed;
sl@0:                          The purpose of the test is to verify that the ParameterName() call behaves correctly 
sl@0:                          if the related sqlite3_bind_parameter_name() call performed by the SQL server fails 
sl@0:                          with "no memory".
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF145033
sl@0: */  
sl@0: void ParameterNameOomTest()
sl@0:     {
sl@0:     //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
sl@0:     //stream objects, the allocated memory cells are not counted.
sl@0:     //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
sl@0:     //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
sl@0:     //and they will not be deallocated when the statement object is closed. 
sl@0:     //But the result of the RSqlStatement::ParameterName() operation is checked. If there is a failed memory
sl@0:     //allocation on the server side, the returned column name can be NULL and that will be tested.
sl@0:     
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 
sl@0:     CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
sl@0:     
sl@0:     TInt err = TheDb.Open(KDbFile);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TInt failingAllocationNo = 0;
sl@0:     err = KErrNoMemory;
sl@0:     while(err == KErrNoMemory)
sl@0:         {
sl@0:         TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0:         OomPreStep(failingAllocationNo);
sl@0:         
sl@0:         err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A WHERE Col2 != :Prm1234567890 AND Col3 != :Prm2 AND ColumnName1234567890 != ?"));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep;
sl@0:             }
sl@0:         
sl@0:         TPtrC name;
sl@0:         err = TheStmt.ParameterName(0, name);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(name == _L(":Prm1234567890"));
sl@0:         
sl@0:         err = TheStmt.ParameterName(1, name);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(name == _L(":Prm2"));
sl@0:         
sl@0:         err = TheStmt.ParameterName(2, name);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(name == _L("?2"));
sl@0:         
sl@0: LabelStmtClose:        
sl@0:         TheStmt.Close();
sl@0:         
sl@0: LabelOomPostStep:        
sl@0:         OomPostStep();
sl@0:         }
sl@0: 
sl@0:     TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TEST2(err, KErrNone);   
sl@0:     TheTest.Printf(_L("\r\n===RSqlStatement::ColumnName() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4178
sl@0: @SYMTestCaseDesc        RSqlStatement::ColumnText() OOM test.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test runs RSqlStatement::ColumnText() in an OOM simulation loop.
sl@0:                         The difference betwee this test case and the similar test case in t_sqloom2 is that here:
sl@0:                          - burst OOM simulation is used;
sl@0:                          - UTF8 encoded database is used;
sl@0:                          - only SQL server side OOM simulation is performed;
sl@0:                          The purpose of the test is to verify that the ColumnText() call behaves correctly 
sl@0:                          when the related sqlite3_column_text16() call performed by the SQL server fails 
sl@0:                          with "no memory" (or the sqlite3_column_bytes16() call).
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF145033
sl@0: */  
sl@0: void ColumnTextOomTest()
sl@0:     {
sl@0:     //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
sl@0:     //stream objects, the allocated memory cells are not counted.
sl@0:     //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
sl@0:     //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
sl@0:     //and they will not be deallocated when the statement object is closed. 
sl@0:     //But the result of the RSqlStatement::ColumnText() operation is checked. If there is a failed memory
sl@0:     //allocation on the server side, the returned column name can be NULL and that will be tested.
sl@0:     
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 
sl@0:     CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
sl@0:     
sl@0:     TInt err = TheDb.Open(KDbFile);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TInt failingAllocationNo = 0;
sl@0:     err = KErrNoMemory;
sl@0:     while(err == KErrNoMemory)
sl@0:         {
sl@0:         TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0:         OomPreStep(failingAllocationNo);
sl@0:         
sl@0:         err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep;
sl@0:             }
sl@0:         err = TheStmt.Next();
sl@0:         if(err != KSqlAtRow)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         
sl@0:         TPtrC data;
sl@0:         err = TheStmt.ColumnText(0, data);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(data == _L("A1234567890"));
sl@0:         
sl@0:         err = TheStmt.ColumnText(1, data);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(data == _L("A12345"));
sl@0: 
sl@0:         err = TheStmt.ColumnText(2, data);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST(data == _L(""));
sl@0: 
sl@0: LabelStmtClose:        
sl@0:         TheStmt.Close();
sl@0:                     
sl@0: LabelOomPostStep:        
sl@0:         OomPostStep();
sl@0:         }
sl@0: 
sl@0:     TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TEST2(err, KErrNone);   
sl@0:     TheTest.Printf(_L("\r\n===RSqlStatement::ColumnText() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4179
sl@0: @SYMTestCaseDesc        RSqlColumnReadStream OOM test.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test runs RSqlColumnReadStream in an OOM simulation loop.
sl@0:                         The difference betwee this test case and the similar test case in t_sqloom2 is that here:
sl@0:                          - burst OOM simulation is used;
sl@0:                          - UTF8 encoded database is used;
sl@0:                          - only SQL server side OOM simulation is performed;
sl@0:                          The purpose of the test is to verify that the RSqlColumnReadStream APIs behave correctly 
sl@0:                          when the related sqlite3_column_text16() call performed by the SQL server fails 
sl@0:                          with "no memory" (or the sqlite3_column_bytes16() call).
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF145033
sl@0: */  
sl@0: void TextColumnReadStreamOomTest()
sl@0:     {
sl@0:     //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
sl@0:     //stream objects, the allocated memory cells are not counted.
sl@0:     //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
sl@0:     //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
sl@0:     //and they will not be deallocated when the statement object is closed. 
sl@0:     //But the result of the RSqlColumnReadStream::ReadL() operation is checked. If there is a failed memory
sl@0:     //allocation on the server side, the returned column name can be NULL and that will be tested.
sl@0:     
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 
sl@0:     CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
sl@0:     
sl@0:     TInt err = TheDb.Open(KDbFile);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TInt failingAllocationNo = 0;
sl@0:     err = KErrNoMemory;
sl@0:     while(err == KErrNoMemory)
sl@0:         {
sl@0:         TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0:         OomPreStep(failingAllocationNo);
sl@0:         
sl@0:         err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep;
sl@0:             }
sl@0:         err = TheStmt.Next();
sl@0:         if(err != KSqlAtRow)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         
sl@0:         RSqlColumnReadStream strm;
sl@0:         err = strm.ColumnText(TheStmt, 0);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         TBuf<50> data;
sl@0:         TRAP(err, strm.ReadL(data, 11));
sl@0:         strm.Close();
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         TEST(data == _L("A1234567890"));
sl@0: 
sl@0:         err = strm.ColumnText(TheStmt, 1);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         TRAP(err, strm.ReadL(data, 6));
sl@0:         strm.Close();
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         TEST(data == _L("A12345"));
sl@0: 
sl@0:         err = strm.ColumnText(TheStmt, 2);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         TInt len = -1;
sl@0:         TRAP(err, len = strm.Source()->SizeL());//The column value is with 0 length
sl@0:         strm.Close();
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelCloseStmt;
sl@0:             }
sl@0:         TEST2(len, 0);
sl@0: 
sl@0: LabelCloseStmt:            
sl@0:         TheStmt.Close();
sl@0:         
sl@0: LabelOomPostStep:        
sl@0:         OomPostStep();
sl@0:         }
sl@0: 
sl@0:     TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TEST2(err, KErrNone);   
sl@0:     TheTest.Printf(_L("\r\n===RSqlColumnReadStream OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4180
sl@0: @SYMTestCaseDesc        TSqlScalarFullSelectQuery::SelectTextL() OOM test.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test runs TSqlScalarFullSelectQuery::SelectTextL() in an OOM simulation loop.
sl@0:                         The difference betwee this test case and the similar test case in t_sqloom2 is that here:
sl@0:                          - burst OOM simulation is used;
sl@0:                          - UTF8 encoded database is used;
sl@0:                          - only SQL server side OOM simulation is performed;
sl@0:                          The purpose of the test is to verify that the SelectTextL() call behaves correctly 
sl@0:                          when the related sqlite3_column_text16() call performed by the SQL server fails 
sl@0:                          with "no memory" (or the sqlite3_column_bytes16() call).
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF145033
sl@0: */  
sl@0: void ScalarColumnTextOomTest()
sl@0:     {
sl@0:     //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
sl@0:     //stream objects, the allocated memory cells are not counted.
sl@0:     //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
sl@0:     //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
sl@0:     //and they will not be deallocated when the statement object is closed. 
sl@0:     //But the result of the TSqlScalarFullSelectQuery::SelectTextL() operation is checked. If there is a failed memory
sl@0:     //allocation on the server side, the returned column name can be NULL and that will be tested.
sl@0:     
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 
sl@0:     CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
sl@0:     
sl@0:     TInt err = TheDb.Open(KDbFile);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TInt failingAllocationNo = 0;
sl@0:     err = KErrNoMemory;
sl@0:     while(err == KErrNoMemory)
sl@0:         {
sl@0:         TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0:         OomPreStep(failingAllocationNo);
sl@0:         
sl@0:         TSqlScalarFullSelectQuery query(TheDb);
sl@0:         TBuf<50> data;
sl@0:         TRAP(err, query.SelectTextL(_L("SELECT ColumnName1234567890 FROM A"), data));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep; 
sl@0:             }
sl@0:         TEST(data == _L("A1234567890"));
sl@0: 
sl@0:         TRAP(err, query.SelectTextL(_L("SELECT Col2 FROM A"), data));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep; 
sl@0:             }
sl@0:         TEST(data == _L("A12345"));
sl@0:         
sl@0:         TRAP(err, query.SelectTextL(_L("SELECT Col3 FROM A"), data));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep; 
sl@0:             }
sl@0:         TEST(data == _L(""));
sl@0:         
sl@0: LabelOomPostStep:        
sl@0:         OomPostStep();
sl@0:         }
sl@0: 
sl@0:     TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TEST2(err, KErrNone);   
sl@0:     TheTest.Printf(_L("\r\n===TSqlScalarFullSelectQuery::SelectTextL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4181
sl@0: @SYMTestCaseDesc        RSqlStatement::DeclaredColumnType() OOM test.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test runs RSqlStatement::DeclaredColumnType() in an OOM simulation loop.
sl@0:                         The difference betwee this test case and the similar test case in t_sqloom2 is that here:
sl@0:                          - burst OOM simulation is used;
sl@0:                          - UTF8 encoded database is used;
sl@0:                          - only SQL server side OOM simulation is performed;
sl@0:                          The purpose of the test is to verify that the DeclaredColumnType() call behaves correctly 
sl@0:                          when the related sqlite3_column_name16() call performed by the SQL server fails 
sl@0:                          with "no memory".
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF145033
sl@0: */  
sl@0: void DeclaredColumnTypeOomTest()
sl@0:     {
sl@0:     //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
sl@0:     //stream objects, the allocated memory cells are not counted.
sl@0:     //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
sl@0:     //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
sl@0:     //and they will not be deallocated when the statement object is closed. 
sl@0:     //But the result of the RSqlStatement::DeclaredColumnType() operation is checked. If there is a failed memory
sl@0:     //allocation on the server side, the returned column name can be NULL and that will be tested.
sl@0:     
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 
sl@0:     CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
sl@0:     
sl@0:     TInt err = TheDb.Open(KDbFile);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TInt failingAllocationNo = 0;
sl@0:     err = KErrNoMemory;
sl@0:     while(err == KErrNoMemory)
sl@0:         {
sl@0:         TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0:         OomPreStep(failingAllocationNo);
sl@0:         
sl@0:         err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelOomPostStep;
sl@0:             }
sl@0:         
sl@0:         TSqlColumnType colType = ESqlNull;
sl@0:         err = TheStmt.DeclaredColumnType(0, colType);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST2(colType, ESqlText);
sl@0:         
sl@0:         colType = ESqlNull;
sl@0:         err = TheStmt.DeclaredColumnType(1, colType);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST2(colType, ESqlText);
sl@0:         
sl@0:         colType = ESqlNull;
sl@0:         err = TheStmt.DeclaredColumnType(2, colType);
sl@0:         if(err != KErrNone)
sl@0:             {
sl@0:             goto LabelStmtClose;
sl@0:             }
sl@0:         TEST2(colType, ESqlText);
sl@0:         
sl@0: LabelStmtClose:        
sl@0:         TheStmt.Close();
sl@0:         
sl@0: LabelOomPostStep:        
sl@0:         OomPostStep();
sl@0:         }
sl@0: 
sl@0:     TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KDbFile);
sl@0:     
sl@0:     TEST2(err, KErrNone);   
sl@0:     TheTest.Printf(_L("\r\n===RSqlStatement::DeclaredColumnType() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0:     }
sl@0: 
sl@0: void DoTests()
sl@0: 	{
sl@0:     TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-CT-4176 RSqlStatement::ColumnName() OOM test"));
sl@0:     ColumnNameOomTest();
sl@0: 
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4177 RSqlStatement::ParameterName() OOM test"));
sl@0:     ParameterNameOomTest();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4178 RSqlStatement::ColumnText() OOM test"));
sl@0:     ColumnTextOomTest();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4179 RSqlColumnReadStream OOM test"));
sl@0:     TextColumnReadStreamOomTest();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4180 TSqlScalarFullSelectQuery::SelectTextL() OOM test"));
sl@0:     ScalarColumnTextOomTest();
sl@0: 
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4181 RSqlStatement::DeclaredColumnType() OOM test"));
sl@0:     DeclaredColumnTypeOomTest();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TheTest(tc != NULL);
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	CreateTestEnv();
sl@0: 	DoTests();
sl@0: 	DestroyTestEnv();
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}