/*

* Copyright (c) 2002-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:        ?Description

*

*/

// INCLUDE FILES

#include <StifTestModule.h>

#include <e32math.h>

#include <libc/assert.h>

#include <e32panic.h>

#include "senutilsbctest.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSenUtilsBCTest::Case

// Returns a test case by number.

//

// This function contains an array of all available test cases 

// i.e pair of case name and test function. If case specified by parameter

// aCaseNumber is found from array, then that item is returned.

// 

// The reason for this rather complicated function is to specify all the

// test cases only in one place. It is not necessary to understand how

// function pointers to class member functions works when adding new test

// cases. See function body for instructions how to add new test case.

// -----------------------------------------------------------------------------

//

const TCaseInfo CSenUtilsBCTest::Case ( 

    const TInt aCaseNumber ) const 

     {

    /**

    * To add new test cases, implement new test case function and add new 

    * line to KCases array specify the name of the case and the function 

    * doing the test case

    * In practice, do following

    * 1) Make copy of existing test case function and change its name

    *    and functionality. Note that the function must be added to 

    *    SenUtils.cpp file and to SenUtils.h 

    *    header file.

    *

    * 2) Add entry to following KCases array either by using:

    *

    * 2.1: FUNCENTRY or ENTRY macro

    * ENTRY macro takes two parameters: test case name and test case 

    * function name.

    *

    * FUNCENTRY macro takes only test case function name as a parameter and

    * uses that as a test case name and test case function name.

    *

    * Or

    *

    * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

    * only with OOM (Out-Of-Memory) testing!

    *

    * OOM_ENTRY macro takes five parameters: test case name, test case 

    * function name, TBool which specifies is method supposed to be run using

    * OOM conditions, TInt value for first heap memory allocation failure and 

    * TInt value for last heap memory allocation failure.

    * 

    * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

    * that as a test case name, TBool which specifies is method supposed to be

    * run using OOM conditions, TInt value for first heap memory allocation 

    * failure and TInt value for last heap memory allocation failure. 

    */ 

    static TCaseInfoInternal const KCases[] =

        {

        ENTRY( "NewL - CSenSoapEnvelope", CSenUtilsBCTest::CSenSoapEnvelope_NewLL ),

        ENTRY( "SetBodyL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SetBodyLL ),

        ENTRY( "BodyL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_BodyLL ),

        ENTRY( "HeaderL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_HeaderLL ),        

        ENTRY( "AddHeaderL - CSenSoapEnvelope", CSenUtilsBCTest::CSenSoapEnvelope_AddHeaderLL ),

        ENTRY( "BodyAsStringL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_BodyAsStringLL ),

        ENTRY( "DetachFaultL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_DetachFaultLL ),

        ENTRY( "FaultL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_FaultLL ),

        ENTRY( "SoapAction - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SoapActionL ),

 //       ENTRY( "SoapAction2 - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SoapAction2L ),

        ENTRY( "HasHeader - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_HasHeaderL ),

        ENTRY( "SoapVersion - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SoapVersionL ),

        ENTRY( "HasBody - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_HasBodyL ),

        ENTRY( "IsFault - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_IsFaultL ),

        ENTRY( "ParseL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_ParseLL ),

        ENTRY( "NewL - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_NewLL ),

        ENTRY( "NewL - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_NewL_1L ),

        ENTRY( "FaultCode - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultCodeL ),

        ENTRY( "FaultSubcode - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultSubcodeL ),

        ENTRY( "FaultString - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultStringL ),

        ENTRY( "FaultActor - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultActorL ),

        ENTRY( "Detail - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_DetailL ),

        ENTRY( "NewL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_NewLL ),

        ENTRY( "SetSecurityHeaderL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_SetSecurityHeaderLL ),

        ENTRY( "AddSecurityTokenL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_AddSecurityTokenLL ),

        ENTRY( "NewL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLL ),

        ENTRY( "ParseL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_ParseLL ),

        ENTRY( "NewLC - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLCL ),

        ENTRY( "NewL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewL_1L ),

        ENTRY( "NewLC - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLC_1L ),

        ENTRY( "NewL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewL_2L ),

        ENTRY( "NewLC - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLC_2L ),

        ENTRY( "BinarySecurityToken - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_BinarySecurityTokenL_L ),

        ENTRY( "BinarySecurityToken1 - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_BinarySecurityTokenL_1L ),

//        ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenLL ),

        ENTRY( "TimestampL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_TimestampL_L ),

        ENTRY( "TimestampL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_TimestampL_1L ),        

//        ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_1L ),

//        ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_2L ),

//        ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_3L ),

//        ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_4L ),

        ENTRY( "XmlNs - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_XmlNsL ),

        ENTRY( "XmlNsPrefix - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_XmlNsPrefixL ),

        ENTRY( "FromXmlDateTimeL - SenDateUtils ", CSenUtilsBCTest::SenDateUtils_FromXmlDateTimeLL ),

        ENTRY( "ToXmlDateTimeUtf8L - SenDateUtils ", CSenUtilsBCTest::SenDateUtils_ToXmlDateTimeUtf8LL ),

        ENTRY( "ToXmlDateTimeUtf82L - SenDateUtils ", CSenUtilsBCTest::SenDateUtils_ToXmlDateTimeUtf82LL ),

        ENTRY( "FileAttachmentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_FileAttachmentLL ),

        ENTRY( "NewL - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLL ),

        ENTRY( "NewLC - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLCL ),

        ENTRY( "NewL - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewL_1L ),

        ENTRY( "NewLC - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLC_1L ),

        ENTRY( "NewL - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewL_2L ),

        ENTRY( "NewLC - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLC_2L ),

        ENTRY( "NewL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLL ),

        ENTRY( "NewLC - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLCL ),

        ENTRY( "NewL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewL_1L ),

        ENTRY( "NewLC - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLC_1L ),

        ENTRY( "NewL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewL_2L ),

        ENTRY( "NewLC - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLC_2L ),

        ENTRY( "AsUtf8L - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_AsUtf8LL ),

        ENTRY( "SetPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetPropertyLL ),

        ENTRY( "PropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_PropertyLL ),

        ENTRY( "SetIntPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetIntPropertyLL ),

        ENTRY( "IntPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_IntPropertyLL ),

        ENTRY( "SetBoolPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetBoolPropertyLL ),

        ENTRY( "BoolPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_BoolPropertyLL ),

        ENTRY( "SetOmittedL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetOmittedLL ),

        ENTRY( "RemovePropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_RemovePropertyLL ),

        ENTRY( "HeartbeatL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_HeartbeatLL ),

        ENTRY( "SetHeartbeatL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetHeartbeatLL ),

        ENTRY( "IapIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_IapIdLL ),

        ENTRY( "SetIapIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetIapIdLL ),

        ENTRY( "ProxyPortL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ProxyPortLL ),

        ENTRY( "SetProxyPortL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetProxyPortLL ),

        ENTRY( "ProxyHostL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ProxyHostLL ),

        ENTRY( "SetProxyHostL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetProxyHostLL ),

        ENTRY( "ProxyUsageL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ProxyUsageLL ),

        ENTRY( "SetProxyUsageL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetProxyUsageLL ),

        ENTRY( "SecureDialogL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SecureDialogLL ),

        ENTRY( "SetSecureDialogL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetSecureDialogLL ),

        ENTRY( "UserAgentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_UserAgentLL ),

        ENTRY( "SetUserAgentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetUserAgentLL ),

        ENTRY( "DeviceIDL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_DeviceIDLL ),

        ENTRY( "SetDeviceIDL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetDeviceIDLL ),

        ENTRY( "SoapActionL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SoapActionLL ),

        ENTRY( "SetSoapActionL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetSoapActionLL ),

        ENTRY( "DownloadFolderL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_DownloadFolderLL ),

        ENTRY( "SetDownloadFolderL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetDownloadFolderLL ),

        ENTRY( "SetFileAttachmentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetFileAttachmentLL ),

        ENTRY( "MwsNamespaceL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MwsNamespaceLL ),

        ENTRY( "SetMwsNamespaceL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMwsNamespaceLL ),

        ENTRY( "MessageIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MessageIdLL ),

        ENTRY( "SetMessageIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMessageIdLL ),

        ENTRY( "OnewayMessageOnOffL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_OnewayMessageOnOffLL ),

        ENTRY( "SetOnewayMessageOnOffL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetOnewayMessageOnOffLL ),

        ENTRY( "SetMaxTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMaxTimeToLiveLL ),

        ENTRY( "MaxTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MaxTimeToLiveLL ),

        ENTRY( "SetMaxTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMaxTimeToLiveLL),

        ENTRY( "MinTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MinTimeToLiveLL ),

        ENTRY( "SetMinTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMinTimeToLiveLL ),

        ENTRY( "SetReaderL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetReaderL ),

        ENTRY( "PropertiesClassTypeL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_PropertiesClassTypeL ),

        ENTRY( "WriteToLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_WriteToLL ),

        ENTRY( "ReadFromLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ReadFromLL ),

        ENTRY( "CloneL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_CloneL ),

        ENTRY( "IsSafeToCastL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_IsSafeToCastL ),

        ENTRY( "CloneLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_CloneLL ),

        ENTRY( "ApplyBindingLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ApplyBindingLL ),

        ENTRY( "NewL - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLL ),

        ENTRY( "NewLC - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLCL ),

        ENTRY( "NewL - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewL_1L ),

        ENTRY( "NewLC - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLC_1L ),

        ENTRY( "NewL - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewL_2L ),

        ENTRY( "NewLC - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLC_2L),

        //ENTRY( "NewL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLL ),

        //ENTRY( "NewLC - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLCL ),

        //ENTRY( "NewL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewL_1L ),

        //ENTRY( "NewLC - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLC_1L ),

        //ENTRY( "NewL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewL_2L ),

        //ENTRY( "NewLC - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLC_2L ),

        //ENTRY( "OnewayMessageOnOffL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_OnewayMessageOnOffLL ),

        //ENTRY( "SetOnewayMessageOnOffL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_SetOnewayMessageOnOffLL ),

        //ENTRY( "SetMaxTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_SetMaxTimeToLiveLL ),

        //ENTRY( "MaxTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_MaxTimeToLiveLL ),

        //ENTRY( "MinTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_MinTimeToLiveLL ),

        //ENTRY( "SetMinTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_SetMinTimeToLiveLL ),*/

        // Example how to use OOM functionality

        //OOM_ENTRY( "Loop test with OOM", CSenUtilsBCTest::LoopTest, ETrue, 2, 3),

        //OOM_FUNCENTRY( CSenUtilsBCTest::PrintTest, ETrue, 1, 3 ),

        };

    // Verify that case number is valid

    if( (TUint) aCaseNumber >= sizeof( KCases ) / 

                               sizeof( TCaseInfoInternal ) )

        {

        // Invalid case, construct empty object

        TCaseInfo null( (const TText*) L"" );

        null.iMethod = NULL;

        null.iIsOOMTest = EFalse;

        null.iFirstMemoryAllocation = 0;

        null.iLastMemoryAllocation = 0;

        return null;

        } 

    // Construct TCaseInfo object and return it

    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

    return tmp;

    }

void CSenUtilsBCTest::SetupL(  ){

    if ( iXmlReader ){

        delete iXmlReader;

        iXmlReader = NULL;

    }

    iXmlReader = CSenXmlReader::NewL();

} 

void CSenUtilsBCTest::Teardown(  ){

    if ( iXmlReader){

        delete iXmlReader;

        iXmlReader = NULL;

    }

}

TPtr16 CSenUtilsBCTest::ConvertToPtr16LC(CSenBaseFragment &fragment){

    HBufC16* xmlBuffer = fragment.AsElement().AsXmlUnicodeL();//Parent()->

    CleanupStack::PushL( xmlBuffer );

    TPtr16 ptr = xmlBuffer->Des();

    if (ptr.Length()){

        RDebug::Print( _L( "WSModTester: xmlBuffer length [%d]"),ptr.Length());

        if (ptr.Length()<=254){//below string must be =< max byte value

            RDebug::Print( _L( "WSModTester: xmlBuffer #START#"));

            RDebug::Print( _L( "[%S]"),&ptr);

            RDebug::Print( _L( "WSModTester: xmlBuffer #END#"));

        }

        else

            RDebug::Print( _L( "WSModTester: xmlBuffer too long to display, must be <=256- 2//[]"));

    }

    else

        RDebug::Print( _L( "WSModTester: xmlBuffer empty"));

    return ptr;

}

TPtr16 CSenUtilsBCTest::ConvertToPtr16LC(MSenElement &element){

    HBufC16* xmlBuffer = element.AsXmlUnicodeL();//Parent()->

    CleanupStack::PushL( xmlBuffer );

    TPtr16 ptr = xmlBuffer->Des();

    if (ptr.Length() > 0){

        RDebug::Print( _L( "WSModTester: xmlBuffer length [%d]"),ptr.Length());

        if (ptr.Length()<=254){//below string must be =< max byte value

            RDebug::Print( _L( "WSModTester: xmlBuffer #START#"));

            RDebug::Print( _L( "[%S]"),&ptr);

            RDebug::Print( _L( "WSModTester: xmlBuffer #END#"));

        }

        else

            RDebug::Print( _L( "WSModTester: xmlBuffer too long to display, must be <=256- 2//[]"));

    }

    else

        RDebug::Print( _L( "WSModTester: xmlBuffer empty"));

    return ptr;

}

TInt CSenUtilsBCTest::CSenSoapEnvelope_NewLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

    CleanupStack::PushL(env);

    /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL);*/

    TL(env != (CSenSoapEnvelope*)NULL);

    //checking xml

    _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");

    TPtrC16 ptrRef = KRef();

    /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*env), ptrRef);*/

    TL(ConvertToPtr16LC(*env) == ptrRef);

    CleanupStack::PopAndDestroy();//Ptr

    CleanupStack::Pop(env);

    /*EUNIT_ASSERT_NO_LEAVE(delete env);*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_SetBodyLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

    /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL); */

    TL(env != (CSenSoapEnvelope*)NULL);

    _LIT8(KBody,"ComarchBody");

    TPtrC8 result = env->SetBodyL(KBody);

    _LIT16(KRef2, "ComarchBody");

    TPtrC16 result16(reinterpret_cast<const TUint16*>(result.Ptr()),(result.Size()/2));

    RDebug::Print( _L( "WSModTester: body [%S]"),&result16);

    /*EUNIT_ASSERT_EQUALS(result, KBody);*/

    TL(result == KBody);

    _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Body>ComarchBody</S:Body></S:Envelope>");

    /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*env), KRef);*/

    TL(ConvertToPtr16LC(*env) == KRef);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE(delete env);*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_BodyLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

    /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL); */

    TL(env != (CSenSoapEnvelope*)NULL);

    _LIT8(KBody,"ComarchBody");

    env->SetBodyL(KBody);

    CSenElement& element = env->BodyL();

    _LIT16(KRef, "<S:Body>ComarchBody</S:Body>");

    /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(element), KRef);*/

    TL(ConvertToPtr16LC(element) == KRef);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE(delete env);*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_HeaderLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

    /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL); */

    TL(env != (CSenSoapEnvelope*)NULL);

    CSenBaseElement* el = CSenBaseElement::NewL(KText);

    env->AddHeaderL(*el);

    el = &(CSenBaseElement&)env->HeaderL();

    _LIT16(KRef, "<S:Header><text/></S:Header>");

    /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*el), KRef);*/

    TL(ConvertToPtr16LC(*el)== KRef);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_AddHeaderLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

    /*EUNIT_ASSERT_NOT_EQUALS*/TL(env != (CSenSoapEnvelope*)NULL);

    CSenBaseElement* el = CSenBaseElement::NewL(KText);

    //el = &(CSenBaseElement&) env->AddHeaderL(*el);//ok

    el = &(CSenBaseElement&) env->AddHeaderL(*el);//ok

    //checking xml

    _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header><text/></S:Header><S:Body/></S:Envelope>");

    TL(ConvertToPtr16LC(*env) == KRef);

    CleanupStack::PopAndDestroy();//Ptr

    _LIT16(KRef2, "<text/>");

    TL(ConvertToPtr16LC(*el)== KRef2);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_BodyAsStringLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

    /*EUNIT_ASSERT_NOT_EQUALS*/TL(env != (CSenSoapEnvelope*)NULL);

    _LIT8(KBody,"ComarchBody");

    env->SetBodyL(KBody);

    HBufC8* str = env->BodyAsStringL();

    _LIT8(KRef, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">ComarchBody</S:Body>");

    TPtrC8 ptrRef = KRef();

    TPtr8 ptr = str->Des();

    TL(ptr == ptrRef);

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete str);

    str = NULL;

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_DetachFaultLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

	env->SetReader( *iXmlReader );

    iXmlReader->SetContentHandler(*env);

    env->ParseL(KFaultMessage);

    CSenSoapFault* fault = env->DetachFaultL();

    //checking Envelope without Fault

    _LIT16(KRefEnvFault, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Body/></S:Envelope>");

    TPtrC16 ptrRefEnvFault = KRefEnvFault();

    TL(ConvertToPtr16LC(*env) == ptrRefEnvFault);

    CleanupStack::PopAndDestroy();//Ptr

    //checking Fault

    _LIT16(KRefFault, "<S:Fault xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><faultcode>VersionMismatch</faultcode><faultstring>some string</faultstring><faultactor>some actor</faultactor><detail>bla bla</detail></S:Fault>");

    TPtrC16 ptrRefFault = KRefFault();

    TL(ConvertToPtr16LC(*fault) == ptrRefFault);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete fault);

    fault = NULL;

    env = CSenSoapEnvelope::NewL();

	env->SetReader( *iXmlReader );

    iXmlReader->SetContentHandler(*env);

    env->ParseL(KSOAPMessage);

    TL(env->DetachFaultL() == (CSenSoapFault* )NULL);

    //checking Envelope not touched should be

    _LIT16(KRefEnv, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header/><S:Body><QueryResponse><Data>Hard Coded response, alway the same</Data></QueryResponse></S:Body></S:Envelope>");

    TPtrC16 ptrRefEnv = KRefEnv();

    TL(ConvertToPtr16LC(*env) == ptrRefEnv);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    Teardown();

    return KErrNone;

    }

TInt CSenUtilsBCTest::CSenSoapEnvelope_FaultLL( TTestResult& aResult )

    {

    SetupL();

    CSenSoapEnvelope* env = CSenSoapEnvelope::NewL();

	env->SetReader( *iXmlReader );

    iXmlReader->SetContentHandler(*env);

    env->ParseL(KFaultMessage);

    CSenSoapFault* fault = env->FaultL();

    //checking Envelope, still Fault exist

    _LIT16(KRefEnvFault, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Body><S:Fault><faultcode>VersionMismatch</faultcode><faultstring>some string</faultstring><faultactor>some actor</faultactor><detail>bla bla</detail></S:Fault></S:Body></S:Envelope>");

    TL(ConvertToPtr16LC(*env)== KRefEnvFault);

    CleanupStack::PopAndDestroy();//Ptr

    //checking Fault

    _LIT16(KRefFault, "<S:Fault><faultcode>VersionMismatch</faultcode><faultstring>some string</faultstring><faultactor>some actor</faultactor><detail>bla bla</detail></S:Fault>");

    TL(ConvertToPtr16LC(*fault) == KRefFault);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;

    env = CSenSoapEnvelope::NewL();

	env->SetReader( *iXmlReader );

    iXmlReader->SetContentHandler(*env);

    env->ParseL(KSOAPMessage);

    TL(env->FaultL() == (CSenSoapFault* )NULL);

    //checking Envelope not touched should be

    _LIT16(KRefEnv, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header/><S:Body><QueryResponse><Data>Hard Coded response, alway the same</Data></QueryResponse></S:Body></S:Envelope>");

    TL(ConvertToPtr16LC(*env) == KRefEnv);

    CleanupStack::PopAndDestroy();//Ptr

    /*EUNIT_ASSERT_NO_LEAVE*/

    __ASSERT_ALWAYS_NO_LEAVE(delete env);

    env = NULL;