/*

* 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 "newsoapclassesbctest.h"

#include "testmsenmessage.h"

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

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

// CNewSoapClassesBCTest::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 CNewSoapClassesBCTest::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 

    *    NewSoapClasses.cpp file and to NewSoapClasses.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 - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLL ),

        ENTRY( "NewLC - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLCL ),

        ENTRY( "NewL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewL_1L ),

        ENTRY( "NewLC - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLC_1L ),

        ENTRY( "NewL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewL_2L ),

        ENTRY( "NewLC - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLC_2L ),

        ENTRY( "Type - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_TypeL ),

        ENTRY( "Direction - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_DirectionL ),

        ENTRY( "TxnId - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_TxnIdL ),

        ENTRY( "Clone - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_CloneL ),

        ENTRY( "SoapVersion - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SoapVersionL ),

        ENTRY( "SetContext - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetContextL ),

        ENTRY( "Context - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_ContextL ),

        ENTRY( "SetProperties - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetPropertiesL ),

        ENTRY( "SetBodyL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetBodyLL ),

        ENTRY( "Properties - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_PropertiesL ),

        ENTRY( "IsSafeToCast - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_IsSafeToCastL ),

        ENTRY( "SetBodyL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetBodyL_1L ),

        ENTRY( "BodyL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_BodyLL ),

        ENTRY( "HeaderL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_HeaderLL ),

        ENTRY( "AddHeaderL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_AddHeaderLL ),

        ENTRY( "BodyAsStringL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_BodyAsStringLL ),

        ENTRY( "IsFault - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_IsFaultL ),

        ENTRY( "DetachFaultL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_DetachFaultLL ),

        ENTRY( "FaultL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_FaultLL ),

        ENTRY( "SetSoapActionL - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetSoapActionLL ),

        ENTRY( "SoapAction - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SoapActionL ),

        ENTRY( "HasHeader - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_HasHeaderL ),

        ENTRY( "HasBody - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_HasBodyL ),

        ENTRY( "Parse1 - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_Parse1L ),

        ENTRY( "Parse2 - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_Parse2L ),

        ENTRY( "Parse2 - CSenSoapEnvelope2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_Parse3L ),

        ENTRY( "NewL - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_NewLL ),

        ENTRY( "NewL - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_NewL_1L ),

        ENTRY( "NewL - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_NewL_2L ),

        ENTRY( "FaultCode - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_FaultCodeL ),

        ENTRY( "FaultSubcode - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_FaultSubcodeL ),

        ENTRY( "FaultString - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_FaultStringL ),

        ENTRY( "FaultActor - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_FaultActorL ),

        ENTRY( "Detail - CSenSoapFault2", CNewSoapClassesBCTest::MT_CSenSoapFault2_DetailL ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLL ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLCL ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewL_1L ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLC_1L ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewL_2L ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLC_2L ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewL_3L ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLC_3L ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewL_4L ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLC_4L ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewL_5L ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLC_5L ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewL_6L ),

        ENTRY( "NewLC - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_NewLC_6L ),

        ENTRY( "NewL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLL ),

        ENTRY( "Type - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_TypeL ),

        ENTRY( "Clone - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_CloneL ),

		ENTRY( "Parse - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_Parse1L ),        

        ENTRY( "SetSecurityHeaderL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_SetSecurityHeaderLL ),

        ENTRY( "AddSecurityTokenL - CSenSoapMessage2", CNewSoapClassesBCTest::MT_CSenSoapMessage2_AddSecurityTokenLL ),

        ENTRY( "NewL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_NewLL ),

        ENTRY( "NewLC - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_NewLCL ),

        ENTRY( "NewL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_NewL_1L ),

        ENTRY( "NewLC - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_NewLC_1L ),

        ENTRY( "NewL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_NewL_2L ),

        ENTRY( "NewLC - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_NewLC_2L ),

        ENTRY( "UsernameTokenL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_UsernameTokenLL ),

        ENTRY( "UsernameTokenL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_UsernameTokenL_1L ),

        ENTRY( "UsernameTokenL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_UsernameTokenL_2L ),

        ENTRY( "UsernameTokenL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_UsernameTokenL_3L ),

        ENTRY( "UsernameTokenL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_UsernameTokenL_4L ),

        ENTRY( "TimestampL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_TimestampLL ),

        ENTRY( "TimestampL - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_TimestampL_1L ),

        ENTRY( "XmlNs - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_XmlNsL ),

        ENTRY( "XmlNsPrefix - CSenWsSecurityHeader2", CNewSoapClassesBCTest::MT_CSenWsSecurityHeader2_XmlNsPrefixL ),

        ENTRY( "Type - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_Type),

        ENTRY( "Direction - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_Direction),

        ENTRY( "Context - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_Context),

        ENTRY( "SetContext - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_SetContext),

        ENTRY( "Properties - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_Properties),

        ENTRY( "SetProperties - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_SetProperties),

        ENTRY( "IsSafeToCast - MSenMessage", CNewSoapClassesBCTest:: MT_CTestMSenMessage_IsSafeToCast),

        ENTRY( "TxnId - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_TxnId),

        ENTRY( "CloneL - MSenMessage", CNewSoapClassesBCTest::MT_CTestMSenMessage_CloneL),

        // Example how to use OOM functionality

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

        //OOM_FUNCENTRY( CNewSoapClassesBCTest::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 CNewSoapClassesBCTest::SetupL(  ){

	} 

void CNewSoapClassesBCTest::Teardown(  ){

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLL( TTestResult& aResult )

    {

	SetupL();

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

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pEnvelope);

    Teardown();

    return KErrNone;    

    }

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLCL( TTestResult& aResult )

    {

	SetupL();

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

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewLC();

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pEnvelope);

    //CleanupStack::PopAndDestroy();

    Teardown();

    return KErrNone;    

    }    

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewL_1L( TTestResult& aResult )

    {

	SetupL();

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

	MSenMessageContext* mContext = NULL;

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL(*mContext);

    CleanupStack::PushL(pEnvelope);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pEnvelope);    

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLC_1L( TTestResult& aResult )

	{

	 SetupL();

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

	 MSenMessageContext* mContext = NULL;

	 CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewLC(*mContext);

	 HBufC8* pAsXml = pEnvelope->AsXmlL();

	 CleanupStack::PushL(pAsXml);

     if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

     CleanupStack::PopAndDestroy(pAsXml);

     CleanupStack::PopAndDestroy(pEnvelope);

     //CleanupStack::PopAndDestroy();

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewL_2L( TTestResult& aResult )

    {

	SetupL();

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

    CSenSoapEnvelope2* pEnvelope, *pEnvelope1 = CSenSoapEnvelope2::NewL();

    pEnvelope = CSenSoapEnvelope2::NewL(*pEnvelope1);

    CleanupStack::PushL(pEnvelope);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pEnvelope);

    delete pEnvelope1;

    pEnvelope1 = NULL;

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_NewLC_2L( TTestResult& aResult )

    {

	SetupL();

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

    CSenSoapEnvelope2* pEnvelope, *pEnvelope1 = CSenSoapEnvelope2::NewL();

    pEnvelope = CSenSoapEnvelope2::NewLC(*pEnvelope1);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pEnvelope);

    //CleanupStack::PopAndDestroy();

    delete pEnvelope1;

    pEnvelope1 = NULL;

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_TypeL( TTestResult& aResult )

	{

	SetupL();

	MSenMessage::TClass var = MSenMessage::ESoapEnvelope2;

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

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    TL(var == pEnvelope->Type());

    CleanupStack::PopAndDestroy(pEnvelope);

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_DirectionL( TTestResult& aResult )

	{

	SetupL();

	MSenMessage::TDirection var = MSenMessage::EOutbound;

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

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    TL(var == pEnvelope->Direction());

    CleanupStack::PopAndDestroy(pEnvelope);

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_TxnIdL( TTestResult& aResult )

	{

	SetupL();

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

    CSenSoapEnvelope2* pEnvelope, *pEnvelope1 = CSenSoapEnvelope2::NewL();

    pEnvelope = CSenSoapEnvelope2::NewL(*pEnvelope1);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    TInt var = pEnvelope->TxnId();

    TBool Flag;

    if(var >= 0)

    if(!(Flag)) return KErrArgument;

    __ASSERT_ALWAYS_NO_LEAVE(delete pEnvelope);

    pEnvelope = NULL;

    delete pEnvelope1;

    pEnvelope1 = NULL;

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_CloneL( TTestResult& aResult )

	{

	SetupL();

	TBool Flag;

	CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

	CleanupStack::PushL(pEnvelope);

	CSenSoapEnvelope2* pClone = NULL;

    pClone = (CSenSoapEnvelope2*)pEnvelope->CloneL(); 

    if(pClone != NULL)

    	Flag = 1;

    if(!(Flag)) return KErrArgument;

	delete pClone;

    CleanupStack::PopAndDestroy(pEnvelope);

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SoapVersionL( TTestResult& aResult )

	{

	SetupL();

	TSOAPVersion var = ESOAP11;

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

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == KEnvelopeString )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    TL(var == pEnvelope->SoapVersion());

    CleanupStack::PopAndDestroy(pEnvelope);

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetContextL( TTestResult& aResult )

	{

	SetupL();

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    MSenMessageContext* mContext = NULL;

	CSenXmlProperties* prop = CSenXmlProperties::NewL();

//	CSenMessageContext* mContext1 = CSenMessageContext::NewL(SenContext::EOutgoing, prop);

    TL(KErrArgument == pEnvelope->SetContext(mContext));

  //  TL(KErrNone == pEnvelope->SetContext(mContext1));

    TL(mContext == pEnvelope->Context());

    CleanupStack::PopAndDestroy(pEnvelope);

//    delete mContext1;

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_ContextL( TTestResult& aResult )

	{

	SetupL();

	TTestResult Result;	

	CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetContextL(Result);

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetPropertiesL( TTestResult& aResult )

	{

	SetupL();

    CSenXmlProperties* prop = CSenXmlProperties::NewL();

    CleanupStack::PushL(prop);

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::Pop();

    CleanupStack::PushL(pEnvelope);

    TL(KErrNone == pEnvelope->SetProperties(prop));

    CleanupStack::PopAndDestroy();

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_PropertiesL( TTestResult& aResult )

	{

	SetupL();

    CSenXmlProperties* prop = CSenXmlProperties::NewL();

    CleanupStack::PushL(prop);

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::Pop();

    CleanupStack::PushL(pEnvelope);

    TL(KErrNone == pEnvelope->SetProperties(prop));

    TL(prop == pEnvelope->Properties());

    CleanupStack::PopAndDestroy();

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_IsSafeToCastL( TTestResult& aResult )

	{

	SetupL();

	MSenMessage::TClass var = MSenMessage::ESoapEnvelope2;

	TBool retVal = ETrue;

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    retVal == pEnvelope->IsSafeToCast(var);

    if(retVal == EFalse)

    	return KErrArgument;

    CleanupStack::PopAndDestroy();

    Teardown();

    return KErrNone;    

	}

TInt CNewSoapClassesBCTest::MT_CSenSoapEnvelope2_SetBodyLL( TTestResult& aResult )

    {

	SetupL();

    _LIT8(KBodyContentString, "<Test>Content</Test>");

    _LIT8(KEnvelopeString, "<S:Envelope \

xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\

<S:Body><Test>Content</Test></S:Body>\

</S:Envelope>");

    CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();

    CleanupStack::PushL(pEnvelope);

    pEnvelope->SetBodyL(KBodyContentString);

    HBufC8* pAsXml = pEnvelope->AsXmlL();

    CleanupStack::PushL(pAsXml);