// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include <e32test.h>
#include <s32buf.h>
#include <bautils.h>
#include <sqldb.h>
#include <stdio.h>
#include <stdlib.h>
#include "SqlResourceTester.h"      //TSqlResourceTester
#include "sqlite3.h"
#include "SqliteSymbian.h"

//In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, 
//when _SQLPROFILER macro is defined)
#ifdef _SQLPROFILER
TInt TheSqlSrvProfilerFileRead = 0;
TInt TheSqlSrvProfilerFileWrite = 0;
TInt TheSqlSrvProfilerFileSync = 0;
TInt TheSqlSrvProfilerFileSetSize = 0;
#endif

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

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

_LIT(KTestDir, "c:\\test\\");
_LIT(KDbFile, "c:\\test\\t_sqloom6.db");

static RSqlDatabase TheDb;
static RSqlStatement TheStmt;

static TInt TheProcessHandleCount = 0;
static TInt TheThreadHandleCount = 0;
static TInt TheAllocatedCellsCount = 0;

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

void DestroyTestEnv()
	{
	TheStmt.Close();
	TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    sqlite3SymbianLibFinalize();
    CloseSTDLIB();
	}

///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check(TInt aValue, TInt aLine)
	{
	if(!aValue)
		{
		DestroyTestEnv();
		TheTest.Printf(_L("*** Expresssion evaluated to false\r\n"));
		TheTest(EFalse, aLine);
		}
	}
void Check(TInt aValue, TInt aExpected, TInt aLine)
	{
	if(aValue != aExpected)
		{
		DestroyTestEnv();
		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
		TheTest(EFalse, aLine);
		}
	}
#define TEST(arg) ::Check((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

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

static void MarkHandles()
    {
    RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
    }

static void MarkAllocatedCells()
    {
    TheAllocatedCellsCount = User::CountAllocCells();
    }

static void CheckAllocatedCells()
    {
    TInt allocatedCellsCount = User::CountAllocCells();
    TEST2(allocatedCellsCount, TheAllocatedCellsCount);
    }

static void CheckHandles()
    {
    TInt endProcessHandleCount;
    TInt endThreadHandleCount;
    
    RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

    TEST2(TheProcessHandleCount, endProcessHandleCount);
    TEST2(TheThreadHandleCount, endThreadHandleCount);
    }

static void OomPreStep(TInt aFailingAllocationNo)
    {
    MarkHandles();
    MarkAllocatedCells();
    __UHEAP_MARK;
    TSqlResourceTester::Mark();
    TSqlResourceTester::SetHeapFailure(RHeap::EBurstFailNext, aFailingAllocationNo);
    }

static void OomPostStep()
    {
    __UHEAP_RESET;
    TSqlResourceTester::SetHeapFailure(RHeap::ENone, 0);
    TSqlResourceTester::Check();
    CheckAllocatedCells();
    CheckHandles();
    }

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

void CreateTestEnv()
    {
    RFs fs;
    TInt err = fs.Connect();
    TEST2(err, KErrNone);

    err = fs.MkDir(KTestDir);
    TEST(err == KErrNone || err == KErrAlreadyExists);

    err = fs.CreatePrivatePath(EDriveC);
    TEST(err == KErrNone || err == KErrAlreadyExists);
    
    fs.Close();

    sqlite3SymbianLibInit();
    }

//Creates a UTF8 encoded database with:
// - One table with three colums: A(ColumnName1234567890, Col2, Col3);
// - One record in the table with values: ('A1234567890', 'A12345', '');
void CreateTestDb(const TDesC& aDbName)
    {
    TBuf8<100> dbName8;
    dbName8.Copy(aDbName);
    sqlite3* db = 0;
    int rc = sqlite3_open((const char*)dbName8.PtrZ(), &db);
    TEST2(rc, SQLITE_OK);
    rc = sqlite3_exec(db, "CREATE TABLE A(ColumnName1234567890 TEXT, Col2 LONG TEXT, Col3 SMALL TEXT)", 0, 0, 0);
    TEST2(rc, SQLITE_OK);
    rc = sqlite3_exec(db, "INSERT INTO A VALUES('A1234567890', 'A12345', '')", 0, 0, 0);
    TEST2(rc, SQLITE_OK);
    sqlite3_close(db);
    }

/**
@SYMTestCaseID          PDS-SQL-CT-4176
@SYMTestCaseDesc        RSqlStatement::ColumnName() OOM test.
@SYMTestPriority        High
@SYMTestActions         The test runs RSqlStatement::ColumnName() in an OOM simulation loop.
                        The difference betwee this test case and the similar test case in t_sqloom2 is that here:
                         - burst OOM simulation is used;
                         - UTF8 encoded database is used;
                         - only SQL server side OOM simulation is performed;
                         The purpose of the test is to verify that the ColumnName() call behaves correctly 
                         when the related sqlite3_column_name16() call performed by the SQL server fails 
                         with "no memory".
@SYMTestExpectedResults Test must not fail
@SYMDEF                 DEF145033
*/  
void ColumnNameOomTest()
    {
    //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
    //stream objects, the allocated memory cells are not counted.
    //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
    //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
    //and they will not be deallocated when the statement object is closed. 
    //But the result of the RSqlStatement::ColumnName() operation is checked. If there is a failed memory
    //allocation on the server side, the returned column name can be NULL and that will be tested.
    
    (void)RSqlDatabase::Delete(KDbFile);
    
    TheTest.Printf(_L("Iteration:\r\n"));

    CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
    
    TInt err = TheDb.Open(KDbFile);
    TEST2(err, KErrNone);
    
    TPtrC name;
    TInt failingAllocationNo = 0;
    err = KErrNoMemory;
    while(err == KErrNoMemory)
        {
        TheTest.Printf(_L(" %d"), ++failingAllocationNo);
        OomPreStep(failingAllocationNo);
        
        err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
        if(err != KErrNone)
            {
            goto LabelOomPostStep;
            }
        
        err = TheStmt.ColumnName(0, name);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(name == _L("ColumnName1234567890"));
        
        err = TheStmt.ColumnName(1, name);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(name == _L("Col2"));
        
        err = TheStmt.ColumnName(2, name);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(name == _L("Col3"));
        
LabelStmtClose:        
        TheStmt.Close();
        
LabelOomPostStep:        
        OomPostStep();
        }

    TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    
    TEST2(err, KErrNone);   
    TheTest.Printf(_L("\r\n===RSqlStatement::ColumnName() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
    }

/**
@SYMTestCaseID          PDS-SQL-CT-4177
@SYMTestCaseDesc        RSqlStatement::ParameterName() OOM test.
@SYMTestPriority        High
@SYMTestActions         The test runs RSqlStatement::ParameterName() in an OOM simulation loop.
                        The difference betwee this test case and the similar test case in t_sqloom2 is that here:
                         - burst OOM simulation is used;
                         - UTF8 encoded database is used;
                         - only SQL server side OOM simulation is performed;
                         The purpose of the test is to verify that the ParameterName() call behaves correctly 
                         if the related sqlite3_bind_parameter_name() call performed by the SQL server fails 
                         with "no memory".
@SYMTestExpectedResults Test must not fail
@SYMDEF                 DEF145033
*/  
void ParameterNameOomTest()
    {
    //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
    //stream objects, the allocated memory cells are not counted.
    //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
    //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
    //and they will not be deallocated when the statement object is closed. 
    //But the result of the RSqlStatement::ParameterName() operation is checked. If there is a failed memory
    //allocation on the server side, the returned column name can be NULL and that will be tested.
    
    (void)RSqlDatabase::Delete(KDbFile);
    
    TheTest.Printf(_L("Iteration:\r\n"));

    CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
    
    TInt err = TheDb.Open(KDbFile);
    TEST2(err, KErrNone);
    
    TPtrC name;
    TInt failingAllocationNo = 0;
    err = KErrNoMemory;
    while(err == KErrNoMemory)
        {
        TheTest.Printf(_L(" %d"), ++failingAllocationNo);
        OomPreStep(failingAllocationNo);
        
        err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A WHERE Col2 != :Prm1234567890 AND Col3 != :Prm2 AND ColumnName1234567890 != ?"));
        if(err != KErrNone)
            {
            goto LabelOomPostStep;
            }
        
        err = TheStmt.ParameterName(0, name);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(name == _L(":Prm1234567890"));
        
        err = TheStmt.ParameterName(1, name);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(name == _L(":Prm2"));
        
        err = TheStmt.ParameterName(2, name);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(name == _L("?2"));
        
LabelStmtClose:        
        TheStmt.Close();
        
LabelOomPostStep:        
        OomPostStep();
        }

    TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    
    TEST2(err, KErrNone);   
    TheTest.Printf(_L("\r\n===RSqlStatement::ColumnName() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
    }

/**
@SYMTestCaseID          PDS-SQL-CT-4178
@SYMTestCaseDesc        RSqlStatement::ColumnText() OOM test.
@SYMTestPriority        High
@SYMTestActions         The test runs RSqlStatement::ColumnText() in an OOM simulation loop.
                        The difference betwee this test case and the similar test case in t_sqloom2 is that here:
                         - burst OOM simulation is used;
                         - UTF8 encoded database is used;
                         - only SQL server side OOM simulation is performed;
                         The purpose of the test is to verify that the ColumnText() call behaves correctly 
                         when the related sqlite3_column_text16() call performed by the SQL server fails 
                         with "no memory" (or the sqlite3_column_bytes16() call).
@SYMTestExpectedResults Test must not fail
@SYMDEF                 DEF145033
*/  
void ColumnTextOomTest()
    {
    //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
    //stream objects, the allocated memory cells are not counted.
    //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
    //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
    //and they will not be deallocated when the statement object is closed. 
    //But the result of the RSqlStatement::ColumnText() operation is checked. If there is a failed memory
    //allocation on the server side, the returned column name can be NULL and that will be tested.
    
    (void)RSqlDatabase::Delete(KDbFile);
    
    TheTest.Printf(_L("Iteration:\r\n"));

    CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
    
    TInt err = TheDb.Open(KDbFile);
    TEST2(err, KErrNone);
    
    TPtrC data;
    TInt failingAllocationNo = 0;
    err = KErrNoMemory;
    while(err == KErrNoMemory)
        {
        TheTest.Printf(_L(" %d"), ++failingAllocationNo);
        OomPreStep(failingAllocationNo);
        
        err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
        if(err != KErrNone)
            {
            goto LabelOomPostStep;
            }
        err = TheStmt.Next();
        if(err != KSqlAtRow)
            {
            goto LabelStmtClose;
            }
        
        err = TheStmt.ColumnText(0, data);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(data == _L("A1234567890"));
        
        err = TheStmt.ColumnText(1, data);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(data == _L("A12345"));

        err = TheStmt.ColumnText(2, data);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST(data == _L(""));

LabelStmtClose:        
        TheStmt.Close();
                    
LabelOomPostStep:        
        OomPostStep();
        }

    TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    
    TEST2(err, KErrNone);   
    TheTest.Printf(_L("\r\n===RSqlStatement::ColumnText() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
    }

/**
@SYMTestCaseID          PDS-SQL-CT-4179
@SYMTestCaseDesc        RSqlColumnReadStream OOM test.
@SYMTestPriority        High
@SYMTestActions         The test runs RSqlColumnReadStream in an OOM simulation loop.
                        The difference betwee this test case and the similar test case in t_sqloom2 is that here:
                         - burst OOM simulation is used;
                         - UTF8 encoded database is used;
                         - only SQL server side OOM simulation is performed;
                         The purpose of the test is to verify that the RSqlColumnReadStream APIs behave correctly 
                         when the related sqlite3_column_text16() call performed by the SQL server fails 
                         with "no memory" (or the sqlite3_column_bytes16() call).
@SYMTestExpectedResults Test must not fail
@SYMDEF                 DEF145033
*/  
void TextColumnReadStreamOomTest()
    {
    //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
    //stream objects, the allocated memory cells are not counted.
    //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
    //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
    //and they will not be deallocated when the statement object is closed. 
    //But the result of the RSqlColumnReadStream::ReadL() operation is checked. If there is a failed memory
    //allocation on the server side, the returned column name can be NULL and that will be tested.
    
    (void)RSqlDatabase::Delete(KDbFile);
    
    TheTest.Printf(_L("Iteration:\r\n"));

    CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
    
    TInt err = TheDb.Open(KDbFile);
    TEST2(err, KErrNone);
    
    TBuf<50> data;
    RSqlColumnReadStream strm;
    TInt failingAllocationNo = 0;
    err = KErrNoMemory;
    TInt len = -1;
    while(err == KErrNoMemory)
        {
        TheTest.Printf(_L(" %d"), ++failingAllocationNo);
        OomPreStep(failingAllocationNo);
        
        err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
        if(err != KErrNone)
            {
            goto LabelOomPostStep;
            }
        err = TheStmt.Next();
        if(err != KSqlAtRow)
            {
            goto LabelCloseStmt;
            }
        
        err = strm.ColumnText(TheStmt, 0);
        if(err != KErrNone)
            {
            goto LabelCloseStmt;
            }
        TRAP(err, strm.ReadL(data, 11));
        strm.Close();
        if(err != KErrNone)
            {
            goto LabelCloseStmt;
            }
        TEST(data == _L("A1234567890"));

        err = strm.ColumnText(TheStmt, 1);
        if(err != KErrNone)
            {
            goto LabelCloseStmt;
            }
        TRAP(err, strm.ReadL(data, 6));
        strm.Close();
        if(err != KErrNone)
            {
            goto LabelCloseStmt;
            }
        TEST(data == _L("A12345"));

        err = strm.ColumnText(TheStmt, 2);
        if(err != KErrNone)
            {
            goto LabelCloseStmt;
            }
        TRAP(err, len = strm.Source()->SizeL());//The column value is with 0 length
        strm.Close();
        if(err != KErrNone)
            {
            goto LabelCloseStmt;
            }
        TEST2(len, 0);

LabelCloseStmt:            
        TheStmt.Close();
        
LabelOomPostStep:        
        OomPostStep();
        }

    TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    
    TEST2(err, KErrNone);   
    TheTest.Printf(_L("\r\n===RSqlColumnReadStream OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
    }

/**
@SYMTestCaseID          PDS-SQL-CT-4180
@SYMTestCaseDesc        TSqlScalarFullSelectQuery::SelectTextL() OOM test.
@SYMTestPriority        High
@SYMTestActions         The test runs TSqlScalarFullSelectQuery::SelectTextL() in an OOM simulation loop.
                        The difference betwee this test case and the similar test case in t_sqloom2 is that here:
                         - burst OOM simulation is used;
                         - UTF8 encoded database is used;
                         - only SQL server side OOM simulation is performed;
                         The purpose of the test is to verify that the SelectTextL() call behaves correctly 
                         when the related sqlite3_column_text16() call performed by the SQL server fails 
                         with "no memory" (or the sqlite3_column_bytes16() call).
@SYMTestExpectedResults Test must not fail
@SYMDEF                 DEF145033
*/  
void ScalarColumnTextOomTest()
    {
    //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
    //stream objects, the allocated memory cells are not counted.
    //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
    //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
    //and they will not be deallocated when the statement object is closed. 
    //But the result of the TSqlScalarFullSelectQuery::SelectTextL() operation is checked. If there is a failed memory
    //allocation on the server side, the returned column name can be NULL and that will be tested.
    
    (void)RSqlDatabase::Delete(KDbFile);
    
    TheTest.Printf(_L("Iteration:\r\n"));

    CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
    
    TInt err = TheDb.Open(KDbFile);
    TEST2(err, KErrNone);
    
    TInt failingAllocationNo = 0;
    err = KErrNoMemory;
    while(err == KErrNoMemory)
        {
        TheTest.Printf(_L(" %d"), ++failingAllocationNo);
        OomPreStep(failingAllocationNo);
        
        TSqlScalarFullSelectQuery query(TheDb);
        TBuf<50> data;
        TRAP(err, query.SelectTextL(_L("SELECT ColumnName1234567890 FROM A"), data));
        if(err != KErrNone)
            {
            goto LabelOomPostStep; 
            }
        TEST(data == _L("A1234567890"));

        TRAP(err, query.SelectTextL(_L("SELECT Col2 FROM A"), data));
        if(err != KErrNone)
            {
            goto LabelOomPostStep; 
            }
        TEST(data == _L("A12345"));
        
        TRAP(err, query.SelectTextL(_L("SELECT Col3 FROM A"), data));
        if(err != KErrNone)
            {
            goto LabelOomPostStep; 
            }
        TEST(data == _L(""));
        
LabelOomPostStep:        
        OomPostStep();
        }

    TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    
    TEST2(err, KErrNone);   
    TheTest.Printf(_L("\r\n===TSqlScalarFullSelectQuery::SelectTextL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
    }

/**
@SYMTestCaseID          PDS-SQL-CT-4181
@SYMTestCaseDesc        RSqlStatement::DeclaredColumnType() OOM test.
@SYMTestPriority        High
@SYMTestActions         The test runs RSqlStatement::DeclaredColumnType() in an OOM simulation loop.
                        The difference betwee this test case and the similar test case in t_sqloom2 is that here:
                         - burst OOM simulation is used;
                         - UTF8 encoded database is used;
                         - only SQL server side OOM simulation is performed;
                         The purpose of the test is to verify that the DeclaredColumnType() call behaves correctly 
                         when the related sqlite3_column_name16() call performed by the SQL server fails 
                         with "no memory".
@SYMTestExpectedResults Test must not fail
@SYMDEF                 DEF145033
*/  
void DeclaredColumnTypeOomTest()
    {
    //This is not really a full OOM test, because the SQL server counts only the number of active statement and 
    //stream objects, the allocated memory cells are not counted.
    //The reason that the allocated memory cells are not counted, and in case of an OOM failure - checked, is
    //because the SQL server can make some per-connection memory allocations (cache pages, etc.)
    //and they will not be deallocated when the statement object is closed. 
    //But the result of the RSqlStatement::DeclaredColumnType() operation is checked. If there is a failed memory
    //allocation on the server side, the returned column name can be NULL and that will be tested.
    
    (void)RSqlDatabase::Delete(KDbFile);
    
    TheTest.Printf(_L("Iteration:\r\n"));

    CreateTestDb(KDbFile);//Creates UTF8 encoded database with one table with one record.
    
    TInt err = TheDb.Open(KDbFile);
    TEST2(err, KErrNone);
    
    TSqlColumnType colType = ESqlNull;
    TInt failingAllocationNo = 0;
    err = KErrNoMemory;
    while(err == KErrNoMemory)
        {
        TheTest.Printf(_L(" %d"), ++failingAllocationNo);
        OomPreStep(failingAllocationNo);
        
        err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
        if(err != KErrNone)
            {
            goto LabelOomPostStep;
            }
        
        err = TheStmt.DeclaredColumnType(0, colType);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST2(colType, ESqlText);
        
        colType = ESqlNull;
        err = TheStmt.DeclaredColumnType(1, colType);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST2(colType, ESqlText);
        
        colType = ESqlNull;
        err = TheStmt.DeclaredColumnType(2, colType);
        if(err != KErrNone)
            {
            goto LabelStmtClose;
            }
        TEST2(colType, ESqlText);
        
LabelStmtClose:        
        TheStmt.Close();
        
LabelOomPostStep:        
        OomPostStep();
        }

    TheDb.Close();
    (void)RSqlDatabase::Delete(KDbFile);
    
    TEST2(err, KErrNone);   
    TheTest.Printf(_L("\r\n===RSqlStatement::DeclaredColumnType() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
    }

void DoTests()
	{
    TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-CT-4176 RSqlStatement::ColumnName() OOM test"));
    ColumnNameOomTest();

    TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4177 RSqlStatement::ParameterName() OOM test"));
    ParameterNameOomTest();
    
    TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4178 RSqlStatement::ColumnText() OOM test"));
    ColumnTextOomTest();
    
    TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4179 RSqlColumnReadStream OOM test"));
    TextColumnReadStreamOomTest();
    
    TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4180 TSqlScalarFullSelectQuery::SelectTextL() OOM test"));
    ScalarColumnTextOomTest();

    TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4181 RSqlStatement::DeclaredColumnType() OOM test"));
    DeclaredColumnTypeOomTest();
	}

TInt E32Main()
	{
	TheTest.Title();
	
	CTrapCleanup* tc = CTrapCleanup::New();
	TheTest(tc != NULL);
	
	__UHEAP_MARK;
	
	CreateTestEnv();
	DoTests();
	DestroyTestEnv();

	__UHEAP_MARKEND;
	
	TheTest.End();
	TheTest.Close();
	
	delete tc;

	User::Heap().Check();
	return KErrNone;
	}
