// Copyright (c) 2006-2009 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:

// It would have been nice to create a new object every time we jump to

// a new config block but reporting (INFO_PRINTF and ERR_PRINTF) doesn't

// work from sub-objects. All in all the structure isn't what I'd like,

// perhaps I'm missing some TEF functionality which would get around this. 

// Various bits of repetition may be removed into utility class(es).

// Some utility methods probably should go into utility class(es).

// Unimplemented 8-bit methods, e.g Exec8.

// 

//

#include "sqlfn.h"

#include "Te_SQL_SuiteDefs.h"

#include "common.h"

// Contains code to perform functions on SQLite databases - what functions

// and in what order is determined by the content of the config (.ini) file.

CSQLFnStep::~CSQLFnStep()

/**

 * Destructor

 */

    {

    // Get rid of the RFs object.. Note this isn't set up in the constructor

    // but in doTestStepL.

    irfs.Close();

    // Get rid of the semaphore objects.

    isemA.Close();

    isemB.Close();

    // Get rid of the hashes. These are originally set up in doTestStepL.

    delete ierrhsh;

    delete icoltypehsh;

    delete iactionhsh;

    delete icaphsh;

    delete ipolhsh;

    delete iobjhsh;

    // Get rid of the config item.

    if(icfg)delete icfg;

    }

CSQLFnStep::CSQLFnStep()

    {

    // Create a global semaphore to be used by all instances of this framework

    // to be used for synchronising separate threads when 'CONCURRENT' is

    // used. If it already exists, then perhaps another thread already has it

    // which is fine - in that case just open it.

    TInt err = isemA.CreateGlobal(_L("SQLiteSemA"), 0);

    if(err == KErrAlreadyExists)

    	{

        err = isemA.OpenGlobal(_L("SQLiteSemA"));

    	}

    if(err != KErrNone)

    	{

		INFO_PRINTF2(_L("Error %d creating semaphore"), err);

		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

    	}

	//

	// Second semaphore require for DEF140385.

	//

    err = isemB.CreateGlobal(_L("SQLiteSemB"), 0);

    if(err == KErrAlreadyExists)

    	{

        err = isemB.OpenGlobal(_L("SQLiteSemB"));

    	}

    if(err != KErrNone)

    	{

		INFO_PRINTF2(_L("Error %d creating semaphoreB"), err);

		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

    	}

    }

TVerdict CSQLFnStep::doTestPostambleL()

    {

    // Try to make sure that the database and statement resources have been

    // properly closed (in case of problems).

    isqlst.Close();

    isqldb.Close();

    return TestStepResult();

    }

TVerdict CSQLFnStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual. Our implementation only gets called

 * if the base class doTestStepPreambleL() did not leave. That being the case,

 * the current test result value will be EPass.

 */

    {

    // Create the RFs object so we can talk to the file-system when necessary.

    // Moved from the constructor to shut up leavescan.

    User::LeaveIfError(irfs.Connect());

    irfs.ShareProtected();

    // Make sure the database and statement objects get cleaned up..

    CleanupClosePushL(isqldb);

    CleanupClosePushL(isqlst);

    // Make sure that the icfg member is definitely unset when we start.

    icfg = NULL;

    // Get the hashes we use to associate words with numbers (e.g

    // KErrNone with 0). If these fail due to lack of memory they will

    // PANIC, which is fine. If we're that short of memory nothing is

    // going to work anyway.

    ierrhsh = new CSQLErrHash();

    icoltypehsh = new CSQLColTypeHash();

    iactionhsh = new CSQLTEFAction();

    icaphsh = new CSQLCapability();

    ipolhsh = new CSQLPolicy();

    iobjhsh = new CSQLObject();

    // Set the test result to PASS to start with and call the main block..

    SetTestStepResult(EPass);    

    SQLDbStepL(ConfigSection());

    // Clean up the database and statement objects.

    CleanupStack::PopAndDestroy(2, &isqldb);

    return TestStepResult();

    }

// This is our 'main' function. It works out what method (e.g RSqlStatement::

// Close) the user wants (based on the configuration file) and then calls

// the appropriate wrapper function which runs the wanted method and reports

// on any unexpected errors.

void CSQLFnStep::SQLDbStepL(const TPtrC& acfgblk)

    {

    _LIT(KTestFunction, "SQLDbStep");

    /*

     * Go through all of the actions defined in the configuration file

     * acting on each. The counter will keep incrementing until we

     * fail to find a config item called 'CreateNN', or 'OpenNN' etc.

     * The two arrays hold Parameter and Column indices for use in

     * any method that needs one. E.G..

     */

    TInt ended=0;

    iasync = i8bit = EFalse;

    for(TInt count=0 ; ; count++)

        {

        TPtrC argument;

        TInt whatfun=Efn_undefined;

        for(TInt i=0 ; i < Efn_undefined ; i++)

            {

            // Construct something like 'ColumnInt37'

            TBuf<KStatementFunMaxLength> stfn(*(iactionhsh->GetStringFromNum(i)));

            stfn.AppendNum(count);

            // Does it exist in the config file? If not try e.g 'ColumnReal37'

            if(!GetStringFromConfig(acfgblk, stfn, argument))

                continue;

            whatfun = i;

            if(whatfun == Ectrl_endblock)

                ended = 1;

            // The GetString was successful, so we drop out anyway.

            break;

            }

        // If we hit an EndBlock marker or couldn't find any keyword with

        // the current counter number then drop out.

        if((whatfun == Efn_undefined) || (whatfun == Ectrl_endblock))

            break;

        // If there's a comma in the argument, split it up. We do

        // this here (rather than, more logically, in the called methods)

        // because we'd end up repeating the 'CommaSeparated' call in

        // all of the wrapper methods. Also, we need the indices for

        // Column and Parameter index resolution.

        TInt arg1, arg2;

        TPtrC arg3;

        CommaSeparated(argument, arg1, arg2);

        CommaSeparated(argument, arg1, arg3);

        TInt err=0;

        switch(whatfun)

            {

                case Efn_nop: break;

            // First the RSqlDatabase methods...

                case Efn_create:

                        Create(argument, acfgblk, count);

                        break;

                case Efn_createl:

                        CreateL_(argument, acfgblk, count);

                        break;

                case Efn_createsp:

                        CreateSP(argument, acfgblk, count);

                        break;

                case Efn_open:

                        Open(argument, acfgblk, count);

                        break;

                case Efn_openl:

                        OpenL_(argument, acfgblk, count);

                        break;

                case Efn_attach:

                        Attach(argument, acfgblk, count);

                        break;

                case Efn_detach:

                        Detach(argument, acfgblk, count);

                        break;

                case Efn_copy:

                        Copy(argument, acfgblk, count);

                        break;

                case Efn_close:

                        Close();

                        break;

                case Efn_delete:

                        Delete(argument, acfgblk, count);

                        break;

                case Efn_lasterrormessage:

                        LastErrorMessage(argument);

                        break;

                case Efn_exec:

                        Exec(argument, acfgblk, count);

                        break;

                case Efn_setisolationlevel:

                        SetIsolationLevel(argument, acfgblk, count);

                        break;

                case Efn_reservedrivespace:

                        ReserveDriveSpace(arg1, acfgblk, count);

                        break;

                case Efn_freereservedspace:

                        FreeReservedSpace();

                        break;

                case Efn_getreserveaccess:

                        GetReserveAccess(acfgblk, count);

                        break;

                case Efn_releasereserveaccess:

                        ReleaseReserveAccess();

                        break;

            // Now the RSqlStatement methods...

                case Erstmt_prepare:

                        Prepare(argument, acfgblk, count);

                        break;

                case Erstmt_preparel:

                        PrepareL_(argument, acfgblk, count);

                        break;

                case Erstmt_close:

                        Close(1);

                        break;

                case Erstmt_atrow:

                        AtRow(argument);

                        break;

                case Erstmt_reset:

                        err = isqlst.Reset();

                        ReportOnError(KTestFunction, _L("Reset"), acfgblk,

                                                                 count, err);

                        break;

                case Erstmt_exec:

                        {

                            TBuf<KConfigItemMaxNameLength> apiname(_L("st_exec"));

                            if(!iasync)

                                err = isqlst.Exec();

                            else

                                {

                                TChar ch = 'A';

                                apiname.Append(ch);

                                TRequestStatus trs;

                                isqlst.Exec(trs);

                                User::WaitForRequest(trs);

                                err = trs.Int();

                                }

                            ReportOnError(KTestFunction, apiname,

                                                        acfgblk, count, err);

                        }

                        break;

                case Erstmt_next:

                        Next(argument, acfgblk, count);

                        break;

                case Erstmt_paramindex:

                            {

                            TInt pidx = ParamIndex(argument, acfgblk, count);

                            // The test designer will have to remember how many

                            // param indices have been stuck in this array..

                            if(pidx >= 0)ipidxs.Append(pidx);

                            }

                        break;

                case Erstmt_colindex:

                            {

                            TInt cidx = ColumnIndex(argument, acfgblk, count);

                            // The test designer will have to remember how many

                            // column indices have been stuck in this array..

                            if(cidx >= 0)icidxs.Append(cidx);

                            }

                        break;

                case Erstmt_coltype:

                        // ColumnType needs the ColumnIndex (the last arg)

                        // and also the expected result, which it will get from

                        // the config file. We have to deal with the ColumnIndex

                        // here because it lives in our scope, not that of the

                        // method we're calling..

                        // The test designer will have to remember how many

                        // column indices have been stuck in this array..

                        ColumnType(icidxs[arg1], arg3);

                        break;

                case Erstmt_colsize:

                        ColumnSize(icidxs[arg1], arg2);

                        break;

                case Erstmt_bindnull:

                        BindNull(ipidxs[arg1], acfgblk, count);

                        break;

                case Erstmt_bindint:

                        BindInt(ipidxs[arg1], arg2, acfgblk, count);

                        break;

                case Erstmt_bindint64:

                        BindInt64(ipidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_bindreal:

                        {

                        TLex tl = arg3;

                        TReal tr;

                        tl.Val(tr);

                        BindReal(ipidxs[arg1], tr, acfgblk, count);

                        }

                        break;

                case Erstmt_bindtext:

                        BindText(ipidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_bindbigtext:

                        // Not an RSqlStatement method, but calls BindText

                        // after reading from a file.

                        BindBigTextL(ipidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_bindbinary:

                        BindBinaryL(ipidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_isnull:

                        IsNull(icidxs[arg1], arg3);

                        break;

                case Erstmt_colint:

                        ColumnInt(icidxs[arg1], arg2);

                        break;

                case Erstmt_colint64:

                        ColumnInt64(icidxs[arg1], arg3);

                        break;

                case Erstmt_colreal:

                        {

                        TLex tl = arg3;

                        TReal tr2;

                        tl.Val(tr2);

                        ColumnReal(icidxs[arg1], tr2);

                        }

                        break;

                case Erstmt_coltextL:

                        ColumnTextL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_coltextP:

                        ColumnTextPL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_coltextD:

                        ColumnTextDL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_colbinL:

                        ColumnBinaryL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_colbinP:

                        ColumnBinaryPL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Erstmt_colbinD:

                        ColumnBinaryDL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Esp_create:

                        SPCreate(acfgblk, count);

                        break;

                case Esp_createl:

                        SPCreate(argument, acfgblk, count);

                        break;

                case Esp_close:

                        SPClose();

                        break;

                case Esp_setdbpolicy:

                        SPSetDBPolicy(argument, acfgblk, count);

                        break;

                case Esp_setpolicy:

                        SPSetPolicy(argument, acfgblk, count);

                        break;

                case Esp_externalizel:

                        SPExternalize(argument, acfgblk, count);

                        break;

                case Esp_internalizel:

                        SPInternalize(argument, acfgblk, count);

                        break;

                case Estreamwrite_bindtext:

                        SWBindTextL(ipidxs[arg1], arg3, acfgblk, count);

                        break;

                case Estreamwrite_bindbinary:

                        SWBindBinaryL(ipidxs[arg1], arg3, acfgblk, count);

                        break;

                case Estreamread_columntext:

                        SRColumnTextL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Estreamread_columnbinary:

                        SRColumnBinaryL(icidxs[arg1], arg3, acfgblk, count);

                        break;

                case Edefineconfig:

                        {

                        if(icfg)

                            delete icfg;

                        TInt len = argument.Length();

                        if(len)

                            {

                            // At the time of writing, configuration strings

                            // are limited to 255 bytes.

                            TBuf8<256> arg;

                            arg.Copy(argument);

                            icfg = new TPtrC8(arg);

                            }

                        else

                            icfg = NULL;

                        }

                        break;

            // Actions that aren't direct method calls..

                case Ectrl_newblock:

                        // Continue executing from another configuration

                        // block. Obviously this restarts the step

                        // counter at zero. It's unfortunate that we can't

                        // create a new test object here, that would be

                        // so much neater. But logging doesn't work in

                        // sub-objects (it could be bodged around but it

                        // really would be a bodge). A shame, we could have

                        // lots of member vars holding all this junk we're

                        // passing around. Note that because we don't create

                        // a new object we are playing with the same

                        // RSqlDatabase and RSqlStatement objects.

                        SQLDbStepL(argument);

                        break;

                case Ectrl_function:

                        // Pure virtual. Lives elsewhere..

                        ResolveTestFunctionL(acfgblk, count, argument);

                        break;

                case Ectrl_waitA:

                        // Wait for the isem member semaphore to receive

                        // arg1 signals for this thread. Obviously this assumes

                        // there's another thread that's going to execute

                        // a 'Signal' at some point.

						for(TInt ii=0 ; ii<arg1 ; ++ii)

                            {

                            WaitA();

                            }

                        break;

                case Ectrl_waitB:

                        // Wait for the isemB member semaphore to receive

                        // arg1 signals for this thread. Obviously this assumes

                        // there's another thread that's going to execute

                        // a 'SignalB' at some point.

						for(TInt ii=0 ; ii<arg1 ; ++ii)

                            {

                            WaitB();

                            }

                        break;

                case Ectrl_signalA:

                        // E.G Signal37=6 to wake up six threads that are

                        // waiting on isem.

                        SignalA(arg1);

                        break;

                case Ectrl_signalB:

                        // E.G SignalB37=6 to wake up six threads that are

                        // waiting on isemB..

                        SignalB(arg1);

                        break;

                case Ectrl_sleep:

                        INFO_PRINTF2(_L("Sleeping for %d microseconds"), arg1);

                        User::After(arg1);

                        break;

                case Ectrl_eightbit:

                        if((argument == _L("On")) || (argument == _L("True")))

                            i8bit = ETrue;

                        else

                            i8bit = EFalse;

                        break;

                case Ectrl_async:

                        if((argument == _L("On")) || (argument == _L("True")))

                            iasync = ETrue;

                        else

                            iasync = EFalse;

                        break;

            // Big problems if this stuff executes.

                case Efn_undefined:

                        SetTestStepResult(EFail);

                        INFO_PRINTF1(HTML_RED);

                        ERR_PRINTF1(_L("This should never happen. A"));

                        INFO_PRINTF1(HTML_COLOUR_OFF);

                        break;

                default:

                        SetTestStepResult(EFail);

                        INFO_PRINTF1(HTML_RED);

                        ERR_PRINTF1(_L("This should never happen. B"));

                        INFO_PRINTF1(HTML_COLOUR_OFF);

                        break;

            }

        // Let's get rid of any colour. Can get tangled in multi-threaded

        // tests.

        INFO_PRINTF1(HTML_COLOUR_OFF);

        }

    // If we get to this point and the 'ended' flag hasn't been set then

    // we haven't seen an 'EndBlockNN=' line in the config file. That

    // usually means the test has a missing <keyword><number> item

    // which is a test  failure.

    if(!ended)

        {

        SetTestStepResult(EFail);

        INFO_PRINTF1(HTML_RED);

        ERR_PRINTF2(_L("Put an 'EndBlock' marker at the end of all config blocks. This is intended to\nspot missing numbers (which cause the test to drop out) failing to generate a failure (%S)"), &acfgblk);

        INFO_PRINTF1(HTML_COLOUR_OFF);

        }

    }

// ----------Methods to exercise RSqlDatabase methods ------------------------

TBool CSQLFnStep::Create(const TPtrC& adbnm,