// 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 RequestorClassesStep.cpp

 @internalTechnology

*/

#include "requestorclassesstep.h"

#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>

#include <lbssatellite.h>

#include <s32mem.h>

CRequestorClassesStep::~CRequestorClassesStep()

/**

 * Destructor

 */

	{

	}

CRequestorClassesStep::CRequestorClassesStep()

/**

 * 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(KRequestorClassesStep);

	}

TVerdict CRequestorClassesStep::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 CRequestorClassesStep::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 CRequestorClassesStep::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 CRequestorClassesStep::StartL (TInt aIndex)

	{

	switch (aIndex)

		{

	case 0:

		RRequestorStack_StreamingL ();

		break;

	case 1:

		RRequestorStack_Streaming2L ();

		break;

	case 2:

		CRequestor_ConstructionL ();

		break;

	case 3:

		CRequestor_SetL ();

		break;

	case 4:

		CRequestor_Construction2L ();

		break;

	case 5:

		CRequestor_StreamingL ();

		break;

	case 6:

		CRequestor_Streaming2L ();

		break;

	default:

		break;

		}

	}

//

//

// RRequestorStack

//

//

void ResetAndDestroyRequestorStack(TAny* aArray)

    {

    RRequestorStack* stack = static_cast<RRequestorStack*>(aArray);

    stack->ResetAndDestroy();

    }

// 8.1.1. Streaming

void CRequestorClassesStep::RRequestorStack_StreamingL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    RRequestorStack requestorStack;

    CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack));

    _LIT(KDummyLit1, "Hello");

    const CRequestor::TRequestorType KDummyRequestorType1(CRequestor::ERequestorService);

    const CRequestor::TRequestorFormat KDummyRequestorFormat1(CRequestor::EFormatTelephone);

    CRequestor* requestor = CRequestor::NewLC(KDummyRequestorType1, KDummyRequestorFormat1, KDummyLit1);

    User::LeaveIfError(requestorStack.Append(requestor));        //take ownership of requestor

    CleanupStack::Pop(requestor);

    requestor = NULL;        //Just to make it clear we don't one requestor.

    _LIT(KDummyLit2, "Goodbye");

    const CRequestor::TRequestorType KDummyRequestorType2(CRequestor::ERequestorContact);

    const CRequestor::TRequestorFormat KDummyRequestorFormat2(CRequestor::EFormatUrl);

    requestor = CRequestor::NewLC(KDummyRequestorType2, KDummyRequestorFormat2, KDummyLit2);

    User::LeaveIfError(requestorStack.Append(requestor));        //take ownership of requestor

    CleanupStack::Pop(requestor);

    requestor = NULL;        //Just to make it clear we don't one requestor.

    //All info in requestorStack. Now stream out and back into a new requestor stack.

    CBufFlat* buffer = CBufFlat::NewL(512);        //Abritrary size chosen

    CleanupStack::PushL(buffer);

    RBufWriteStream writeStream;

    writeStream.Open(*buffer);

    writeStream.PushL();

    // externalize

    requestorStack.ExternalizeL(writeStream);

    writeStream.CommitL();

    writeStream.Pop();

    //requestorStack now piped into buffer.

    //get rid of requestorStack.

    CleanupStack::Pop(buffer);

    CleanupStack::PopAndDestroy(&requestorStack);

    CleanupStack::PushL(buffer);

    RBufReadStream readStream;

    readStream.Open(*buffer);

    readStream.PushL();

    RRequestorStack requestorStack2;

    CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack2));

    // internalize

    requestorStack2.InternalizeL(readStream);

    //requestorStack2 should now be initialised.

    CHECK_EQUAL_(2, requestorStack2.Count());

    requestor = requestorStack2[0];

    CHECK(!TPtrC(KDummyLit1).Compare(requestor->RequestorData()));

    CHECK_EQUAL_(requestor->RequestorType(), KDummyRequestorType1);

    CHECK_EQUAL_(requestor->RequestorFormat(), KDummyRequestorFormat1);

    requestor = requestorStack2[1];

    CHECK(!TPtrC(KDummyLit2).Compare(requestor->RequestorData()));

    CHECK_EQUAL_(requestor->RequestorType(), KDummyRequestorType2);

    CHECK_EQUAL_(requestor->RequestorFormat(), KDummyRequestorFormat2);

    CleanupStack::PopAndDestroy(3, buffer);

    StandardCleanup();

	}

// 8.1.2. Streaming with invalid stream

TInt RRequestorStack_Streaming_Invalid(TAny* /*aPtr*/)

	{

    RBufReadStream readStream;

    // buffer

        CBufFlat* buffer = CBufFlat::NewL(512);        //Arbitrary size chosen

    RBufWriteStream writeStream; // make sure it is empty

    writeStream.Open(*buffer);

    writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorStackVersion)

    writeStream.Close();

    writeStream.Release();

    // read-stream

    readStream.Open(*buffer);

    TInt err;

    TRAP(err,

        // internalize it

        RRequestorStack requestorStack2;

        CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack2));

        requestorStack2.InternalizeL(readStream);   //This should panic

        CleanupStack::Pop();

    	);

    readStream.Release();

    delete buffer;

    return KErrGeneral;

	}

void CRequestorClassesStep::RRequestorStack_Streaming2L()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    // attempt to internalize from invalid stream

    DO_PANIC_TEST_L(

        RRequestorStack_Streaming_Invalid,

        KPosClientFault,

        EPositionInvalidClassType,

        KDefaultTestTimeout);

    StandardCleanup();

	}

// 8.1.3. Streaming with No Memory

// See NoMemoryTests.cpp

//

//

// CRequestor

//

//

// 8.2.1. Construction

void CRequestorClassesStep::CRequestor_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KDummyLit, "Hello");

    const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService);

    const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone);

    CRequestor* requestor = NULL;

    requestor = CRequestor::NewL(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);

    CHECK(requestor->RequestorData().Compare(KDummyLit) == 0);

    CHECK(requestor->RequestorType()   == KDummyRequestorType);

    CHECK(requestor->RequestorFormat() == KDummyRequestorFormat);

    delete requestor;

    requestor = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);

    CHECK(requestor->RequestorData().Compare(KDummyLit) == 0);

    CHECK(requestor->RequestorType()   == KDummyRequestorType);

    CHECK(requestor->RequestorFormat() == KDummyRequestorFormat);

    CleanupStack::PopAndDestroy(requestor);

    requestor = static_cast<CRequestor*>( User::LeaveIfNull(CRequestor::New(KDummyRequestorType, KDummyRequestorFormat, KDummyLit)));

    CHECK(requestor->RequestorData().Compare(KDummyLit) == 0);

    CHECK(requestor->RequestorType()   == KDummyRequestorType);

    CHECK(requestor->RequestorFormat() == KDummyRequestorFormat);

    delete requestor;

    StandardCleanup();

	}

// 8.2.2. Setters and Getters

void CRequestorClassesStep::CRequestor_SetL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    // Get

    _LIT(KDummyLit, "Hello");

    const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService);

    const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone);

    CRequestor* requestor = CRequestor::NewL(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);

    CleanupStack::PushL(requestor);

    TPtrC ptr;

    CRequestor::TRequestorType requestorType;

    CRequestor::TRequestorFormat requestorFormat;

    requestor->GetRequestor(requestorType, requestorFormat, ptr);

    CHECK(ptr.Compare(KDummyLit)    == 0);

    CHECK(requestorType             == KDummyRequestorType);

    CHECK(requestorFormat           == KDummyRequestorFormat);

    // Set

    _LIT(KNewDummyLit, "Goodbye");

    const CRequestor::TRequestorType KNewDummyRequestorType(CRequestor::ERequestorContact);

    const CRequestor::TRequestorFormat KNewDummyRequestorFormat(CRequestor::EFormatUrl);

    requestor->SetRequestorL(KNewDummyRequestorType, KNewDummyRequestorFormat, KNewDummyLit);

    // check as properties

    CHECK(requestor->RequestorData().Compare(KNewDummyLit) == 0);

    CHECK(requestor->RequestorType()   == KNewDummyRequestorType);

    CHECK(requestor->RequestorFormat() == KNewDummyRequestorFormat);

    // check by GetRequestor

    requestor->GetRequestor(requestorType, requestorFormat, ptr);

    CHECK(ptr.Compare(KNewDummyLit) == 0);

    CHECK(requestorType             == KNewDummyRequestorType);

    CHECK(requestorFormat           == KNewDummyRequestorFormat);

    CleanupStack::PopAndDestroy();

    // Now set much longer requestor data, to check if

    // doesn't matter :-)

    TBuf<1> shortData;

    shortData.Append('$');

    requestor = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, shortData);

    TBuf<512> longData;

    longData.Fill('@', longData.MaxLength());

    requestor->SetRequestorL(KNewDummyRequestorType, KNewDummyRequestorFormat, longData);

    // check it

    CHECK(requestor->RequestorData().Compare(longData) == 0);

    CHECK(requestor->RequestorType()   == KNewDummyRequestorType);

    CHECK(requestor->RequestorFormat() == KNewDummyRequestorFormat);

    // set smaller one again

    requestor->SetRequestorL(KDummyRequestorType, KDummyRequestorFormat, shortData);

    CHECK(requestor->RequestorData().Compare(shortData) == 0);

    CleanupStack::PopAndDestroy();

    StandardCleanup();

	}

/*

// 8.2.3. Constructors with invalid parameters

void CRequestorClassesStep::CRequestor_Construction3L()

{

    // there are no relevant parameters to pass invalid values.

    // the only one is wrong stream, see 8.3.4 CRequestor_Streaming_Invalid

}

*/

// 8.2.4. Constructors with No Memory

// See NoMemoryTests.cpp

// 8.2.5. SetRequestor with No Memory

// See NoMemoryTests.cpp

// 8.3.1. Construction from stream

void CRequestorClassesStep::CRequestor_Construction2L()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KDummyLit, "Hello");

    const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService);

    const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone);

    CRequestor* requestor1 = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);

    //Make a write stream

    HBufC8* buffer = HBufC8::NewLC(0x100);        //Should be plenty big enough

    TPtr8 ptr = buffer->Des();

    RDesWriteStream writeStream(ptr);        //Opens the write stream

    CleanupClosePushL(writeStream);

    requestor1->ExternalizeL(writeStream);

    writeStream.CommitL();

    CleanupStack::PopAndDestroy(&writeStream);        //Close the write stream

    //Make a read stream

    RDesReadStream readStream(*buffer);

    CleanupClosePushL(readStream);

    // construct

    CRequestor* requestor2 = CRequestor::NewL(readStream);

    CHECK(!TPtrC(KDummyLit).Compare(requestor2->RequestorData()));

    CHECK_EQUAL_(requestor2->RequestorType(), KDummyRequestorType);

    CHECK_EQUAL_(requestor2->RequestorFormat(), KDummyRequestorFormat);

    delete requestor2;

    CleanupStack::PopAndDestroy(3, requestor1);        //readStream, buffer, requestor1

    StandardCleanup();

	}

// 8.3.2. Externalize/Internalize

void CRequestorClassesStep::CRequestor_StreamingL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    _LIT(KDummyLit1, "Hello");

    const CRequestor::TRequestorType KDummyRequestorType1(CRequestor::ERequestorService);

    const CRequestor::TRequestorFormat KDummyRequestorFormat1(CRequestor::EFormatTelephone);

    CRequestor* requestor1 = CRequestor::NewLC(KDummyRequestorType1, KDummyRequestorFormat1, KDummyLit1);

    // set r2 with other values

    _LIT(KDummyLit2, "Goodbye");

    const CRequestor::TRequestorType KDummyRequestorType2(CRequestor::ERequestorContact);

    const CRequestor::TRequestorFormat KDummyRequestorFormat2(CRequestor::EFormatUrl);

    CRequestor* requestor2 = CRequestor::NewLC(KDummyRequestorType2, KDummyRequestorFormat2, KDummyLit2);

    // Make a write stream

    HBufC8* buffer = HBufC8::NewLC(0x100);        //Should be plenty big enough

    TPtr8 ptr = buffer->Des();

    RDesWriteStream writeStream(ptr);        //Opens the write stream

    CleanupClosePushL(writeStream);

    // externalize r1

    writeStream << *requestor1;

    writeStream.CommitL();

    CleanupStack::PopAndDestroy(&writeStream);        //Close the write stream

    RDesReadStream readStream(*buffer);

    CleanupClosePushL(readStream);

    // internalize r2

    requestor2->InternalizeL(readStream);

    CleanupStack::PopAndDestroy(&readStream);        //Close the readStream

    // check r2

    CHECK(requestor2->RequestorData().Compare(KDummyLit1) == 0);

    CHECK(requestor2->RequestorType()   == KDummyRequestorType1);

    CHECK(requestor2->RequestorFormat() == KDummyRequestorFormat1);

    CleanupStack::PopAndDestroy(3, requestor1);

    StandardCleanup();

	}

// 8.3.3. Streaming with NoMemory

// See NoMemoryTests.cpp

// 8.3.4. Invalid stream

TInt CRequestor_Internalize_Invalid_Stream(TAny* /*aPtr*/)

	{

    CRequestor* requestor = NULL;

    RBufReadStream readStream;

    // buffer

    CBufFlat* buffer = CBufFlat::NewL(512);        //Abritrary size chosen

    RBufWriteStream writeStream; // make sure it is empty

    writeStream.Open(*buffer);

    writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorVersion)

    writeStream.Close();

    writeStream.Release();

    readStream.Open(*buffer);

    TInt err;

    TRAP(err,

                // internalize it

            requestor = CRequestor::New(DUMMY_REQUESTOR_TYPE_ACCEPTED1, DUMMY_REQUESTOR_FORMAT_ACCEPTED1, DUMMY_REQUESTOR_NAME_ACCEPTED1);

                CleanupStack::PushL(requestor);

            requestor->InternalizeL(readStream);   //This should panic

            CleanupStack::PopAndDestroy();

    	);

    User::LeaveIfError(err);

    readStream.Release();

    delete buffer;

    return KErrGeneral;

	}

TInt CRequestor_Construct_Invalid_Stream(TAny* /*aPtr*/)

	{

    CRequestor* requestor = NULL;

    RBufReadStream readStream;

    // buffer

    CBufFlat* buffer = CBufFlat::NewL(512);        //Arbitrary size chosen

    RBufWriteStream writeStream; // make sure it is empty

    writeStream.Open(*buffer);

    writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorVersion)

    writeStream.Close();

    writeStream.Release();