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

// Example CTestStep derived implementation

// 

//

/**

 @file NoMemoryStep.cpp

 @internalTechnology

*/

#include "nomemorystep.h"

#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>

#include <lbssatellite.h>

#include <s32mem.h>

CNoMemoryStep::~CNoMemoryStep()

/**

 * Destructor

 */

	{

	}

CNoMemoryStep::CNoMemoryStep()

/**

 * Constructor

 */

	{

	// **MUST** call SetTestStepName in the constructor as the controlling

	// framework uses the test step name immediately following construction to set

	// up the step's unique logging ID.

	SetTestStepName(KNoMemoryStep);

	}

TVerdict CNoMemoryStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	 CTe_LbsApiSuiteStepBase::doTestStepPreambleL();

	 if (TestStepResult()!=EPass)

	    return   TestStepResult();

	// process some pre setting to this test step then set SetTestStepResult to EFail or Epass.

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CNoMemoryStep::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.

 */

	{

	if (TestStepResult()==EPass)

		{

		TInt test;

		if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test))

			{

			// Leave if there's any error.

			User::Leave(KErrNotFound);

			}

		SetTestStepResult(EPass);

		StartL(test);

		}

	return TestStepResult();

	}

TVerdict CNoMemoryStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	// process something post setting to the test step

	// uncomment the following line if you have common post setting to all the test steps in there

	// CTe_LbsApiSuiteStepBase::doTestStepPostambleL();

	// uncomment the following line if you have post process or remove the following line if no post process

	// SetTestStepResult(EPass);		// or EFail

	return TestStepResult();

	}

void CNoMemoryStep::StartL (TInt aIndex)

	{

	switch (aIndex)

		{

	case 0:

		OOM_RPositionServer_Open_NoMemoryL ();

		break;

	case 1:

		OOM_RPositioner_OpenL ();

		break;

	case 2:

		OOM_RPositioner_SetRequestorL ();

		break;

	case 3:

		OOM_CRequestor_ConstructionL ();

		break;

	case 4:

		OOM_CRequestor_SetRequestorL ();

		break;

	case 5:

		OOM_CRequestor_StreamingL ();

		break;

	case 6:

		OOM_RRequestorStack_StreamingL ();

		break;

	case 7:

		OOM_HPositionGenericInfo_ConstructionL ();

		break;

	default:

		break;

		}

	}

#define DO_OOM_CUSTOMISED_LOOP(aType, aCreationCode, aDeletionCode, aLoopStartCode, aLoopEndCode)  \

{                                                                            \

    aType;                                                                   \

    TInt failureRate;                                                        \

    TBool doContinue = ETrue;                                                \

    for (failureRate = 1; doContinue; failureRate++)                         \

        {                                                                    \

        aLoopStartCode;                                                      \

        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);                      \

        __UHEAP_MARK;                                                        \

                                                                             \

        TInt err;                                                            \

        TRAP(err, aCreationCode);                                            \

        if (err != KErrNoMemory)                                             \

            {                                                                \

            aDeletionCode;                                                   \

            doContinue = EFalse;                                             \

            }                                                                \

                                                                             \

        __UHEAP_MARKEND;                                                     \

        __UHEAP_RESET;                                                       \

        aLoopEndCode;                                                        \

        }                                                                    \

    CHECK( failureRate > 2 );                                                \

    message.Format(_L("Checked %d allocations in \"%s\""), failureRate-2, L## #aCreationCode); \

    LOG_DES(message); \

}

#define DO_OOM(aType, aCreationCode, aDeletionCode) \

    DO_OOM_CUSTOMISED_LOOP(aType, aCreationCode, aDeletionCode, (void) 0, (void) 0)

//

//

// RPositionServer

//

//

//1.1.6 Connect with No Memory

void CNoMemoryStep::OOM_RPositionServer_Open_NoMemoryL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    RPositionServer server;

    // connect

    __UHEAP_SETFAIL(RHeap::EFailNext, 1);

    __UHEAP_MARK;

    CHECK_EQUAL_(KErrNoMemory, server.Connect());

    __UHEAP_MARKEND;

    __UHEAP_RESET;

    StandardCleanup();

	}

//

//

// RPositioner

//

//

//1.10.7 Open with No Memory

void CNoMemoryStep::OOM_RPositioner_OpenL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    RPositionServer server;

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

    CleanupClosePushL(server);

    RPositioner positioner;

    // open by default

    __UHEAP_SETFAIL(RHeap::EFailNext, 1);

    __UHEAP_MARK;

    CHECK_EQUAL_(KErrNoMemory, positioner.Open(server));

    __UHEAP_MARKEND;

    __UHEAP_RESET;

    // by module id

    TPositionModuleId moduleId;

    server.GetDefaultModuleId(moduleId);

    __UHEAP_SETFAIL(RHeap::EFailNext, 1);

    __UHEAP_MARK;

    CHECK_EQUAL_(KErrNoMemory, positioner.Open(server, moduleId));

    __UHEAP_MARKEND;

    __UHEAP_RESET;

    // by criteria

    TPositionCriteria criteria;

    criteria.ResetCriteria(); // defaults

    __UHEAP_SETFAIL(RHeap::EFailNext, 1);

    __UHEAP_MARK;

    CHECK_EQUAL_(KErrNoMemory, positioner.Open(server, criteria));

    __UHEAP_MARKEND;

    __UHEAP_RESET;

    CleanupStack::PopAndDestroy();

    StandardCleanup();

	}

//1.13.5 SetRequestor Stack with No Memory

void CNoMemoryStep::OOM_RPositioner_SetRequestorL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    RPositionServer server;

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

    CleanupClosePushL(server);

    RPositioner positioner;

    CHECK_EQUAL_(KErrNone, positioner.Open(server));

    CleanupClosePushL(positioner);

    RRequestorStack stack;

    CRequestor* requestor = NULL;

    // All Accepted

    requestor = CRequestor::NewLC(

            CRequestor::ERequestorContact,

            DUMMY_REQUESTOR_FORMAT_ACCEPTED2,

            DUMMY_REQUESTOR_NAME_ACCEPTED2);

    stack.Append(requestor);

    requestor = CRequestor::NewLC(

            CRequestor::ERequestorService,

            DUMMY_REQUESTOR_FORMAT_ACCEPTED1,

            DUMMY_REQUESTOR_NAME_ACCEPTED1);

    stack.Append(requestor);

    // set requestor stack

    __UHEAP_SETFAIL(RHeap::EFailNext, 1);

    __UHEAP_MARK;

    CHECK_EQUAL_(KErrNoMemory, positioner.SetRequestor(stack));

    CHECK_EQUAL_(KErrNone, positioner.SetRequestor(stack));

    __UHEAP_MARKEND;

    __UHEAP_RESET;

    CleanupStack::Pop(2); // requestors

    CleanupStack::PopAndDestroy(2); // server & positioner

    stack.ResetAndDestroy();

    StandardCleanup();

    }

//

//

// CRequestor

//

//

// 8.2.4. Constructors with No Memory

void CNoMemoryStep::OOM_CRequestor_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KRequestorData, "+441223719800");

    // New

    CRequestor* requestor = NULL;

    TBool doContinue = ETrue;

    TInt failureRate = 0;

    for (failureRate = 1; doContinue; failureRate++)

        {

        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);

        __UHEAP_MARK;

        TInt err;

        TRAP(err, 

            User::LeaveIfNull(requestor = 

                CRequestor::New(CRequestor::ERequestorContact, 

                                CRequestor::EFormatTelephone, 

                                KRequestorData));

        );

        if (err != KErrNoMemory)

            {

            delete requestor;

            doContinue = EFalse;

            }

        __UHEAP_MARKEND;

        __UHEAP_RESET;

        }

    CHECK( failureRate > 2 );

    message.Format(_L("Checked %d allocations in \"New\""), failureRate-2);

    LOG_DES(message);

    // NewL

    doContinue = ETrue;

    for (failureRate = 1; doContinue; failureRate++)

        {

        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);

        __UHEAP_MARK;

        TInt err;

        TRAP(err, 

            requestor = CRequestor::NewL(CRequestor::ERequestorContact, 

                                          CRequestor::EFormatTelephone, 

                                          KRequestorData);

        	);

        if (err != KErrNoMemory)

            {

            delete requestor;

            doContinue = EFalse;

            }

        __UHEAP_MARKEND;

        __UHEAP_RESET;

        }

    CHECK( failureRate > 2 );

    message.Format(_L("Checked %d allocations in \"NewL\""), failureRate-2);

    LOG_DES(message);

    // NewLC

    doContinue = ETrue;

    for (failureRate = 1; doContinue; failureRate++)

        {

        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);

        __UHEAP_MARK;

        TInt err;

        TRAP(err, 

            requestor = CRequestor::NewLC(CRequestor::ERequestorContact, 

                                          CRequestor::EFormatTelephone, 

                                          KRequestorData);

            CleanupStack::Pop(requestor);                                          

        	);

        if (err != KErrNoMemory)

            {

            delete requestor;

            doContinue = EFalse;

            }

        __UHEAP_MARKEND;

        __UHEAP_RESET;

        }

    CHECK( failureRate > 2 );

    message.Format(_L("Checked %d allocations in \"NewLC\""), failureRate-2);

    LOG_DES(message);

    StandardCleanup();   

	}

// 8.2.5. SetRequestor with No Memory

void CNoMemoryStep::OOM_CRequestor_SetRequestorL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KRequestorData, "+441223719800");

    _LIT(KRequestorData2, "+44122371980101");

    // NOTE, this is a special case where the CRequestor is created at the start, then

    // its member data is replaced (which is tested under OOM conditions).

    DO_OOM(

          CRequestor* requestor = CRequestor::NewLC(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData),

          requestor->SetRequestorL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData2),

          CleanupStack::PopAndDestroy(requestor)

          );

    StandardCleanup();    

	}

// 8.3.3. Streaming with NoMemory

void CNoMemoryStep::OOM_CRequestor_StreamingL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KRequestorData, "+441223719800");

    CRequestor* requestor = NULL;

    requestor = CRequestor::NewLC(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData);

    TBuf8<100> buffer;

    RDesWriteStream writeStrm(buffer);

    CleanupClosePushL(writeStrm);

    TInt err;

    TRAP(err, writeStrm << *requestor);

    CleanupStack::PopAndDestroy(&writeStrm);

    // Internalize

    DO_OOM_CUSTOMISED_LOOP

        (

        (void) 0,

        strm >> *requestor,

        delete requestor,

        RDesReadStream strm(buffer); CleanupClosePushL(strm),

        CleanupStack::PopAndDestroy(&strm)

        );

    CleanupStack::Pop(requestor);

    // Construction

    DO_OOM_CUSTOMISED_LOOP

        (

        (void) 0,

        requestor = CRequestor::NewL(strm),

        delete requestor,

        RDesReadStream strm(buffer); CleanupClosePushL(strm),

        CleanupStack::PopAndDestroy(&strm)

        );

    StandardCleanup();

    }

//

//

// RRequestorStack

//

//

void CleanupResetAndDestroy(TAny* aArray)

    {

    reinterpret_cast<RRequestorStack*>(aArray)->ResetAndDestroy();

    }

// 8.1.3. Streaming with No Memory

void CNoMemoryStep::OOM_RRequestorStack_StreamingL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KRequestorData, "+441223719800");

    const TInt KNumberOfRequestors = 3;

    RRequestorStack stack;

    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy, &stack));

    TInt i;

    for (i = 0; i < KNumberOfRequestors; i++)

            User::LeaveIfError(stack.Append(NULL));

    for (i = 0; i < KNumberOfRequestors; i++)

            stack[i] = CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData);

    TBuf8<100> buffer;

    RDesWriteStream writeStrm(buffer);

    CleanupClosePushL(writeStrm);

    TInt err;

    TRAP(err, writeStrm << stack);

    CleanupStack::PopAndDestroy(&writeStrm);

    CleanupStack::PopAndDestroy(&stack);

    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy, &stack));

    DO_OOM_CUSTOMISED_LOOP

        (

        (void) 0,

        strm >> stack,

        stack.ResetAndDestroy(),

        RDesReadStream strm(buffer); CleanupClosePushL(strm),

        CleanupStack::PopAndDestroy(&strm)

        );

    CleanupStack::Pop(&stack);

    StandardCleanup();

    }

//

//

// HPositionGenericInfo

//

//

// 3.2.2. NoMemory Construction

void CNoMemoryStep::OOM_HPositionGenericInfo_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    // New

    DO_OOM

            (

            HPositionGenericInfo* genInfo = NULL,

            User::LeaveIfNull(genInfo = HPositionGenericInfo::New(10)),