--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/websrv_pub/web_service_messaging_api/tsrc/newsoapclassesTester/src/newsoapclassesTesterBlocks.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,3279 @@
+/*
+* Copyright (c) 2002 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] - do not remove
+#include <e32math.h>
+#include <libc/assert.h>
+#include <e32panic.h>
+#include <e32svr.h>
+#include <StifParser.h>
+#include <StifTestInterface.h>
+#include "newsoapclassesTester.h"
+
+// EXTERNAL DATA STRUCTURES
+//extern ?external_data;
+
+// EXTERNAL FUNCTION PROTOTYPES
+//extern ?external_function( ?arg_type,?arg_type );
+
+// CONSTANTS
+//const ?type ?constant_var = ?constant;
+
+// MACROS
+//#define ?macro ?macro_def
+
+// LOCAL CONSTANTS AND MACROS
+//const ?type ?constant_var = ?constant;
+//#define ?macro_name ?macro_def
+
+// MODULE DATA STRUCTURES
+//enum ?declaration
+//typedef ?declaration
+
+// LOCAL FUNCTION PROTOTYPES
+//?type ?function_name( ?arg_type, ?arg_type );
+
+// FORWARD DECLARATIONS
+//class ?FORWARD_CLASSNAME;
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// ?function_name ?description.
+// ?description
+// Returns: ?value_1: ?description
+// ?value_n: ?description_line1
+// ?description_line2
+// -----------------------------------------------------------------------------
+//
+/*
+?type ?function_name(
+ ?arg_type arg, // ?description
+ ?arg_type arg) // ?description
+ {
+
+ ?code // ?comment
+
+ // ?comment
+ ?code
+ }
+*/
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CnewsoapclassesTester::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void CnewsoapclassesTester::Delete()
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CnewsoapclassesTester::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CnewsoapclassesTester::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ ENTRY( "NewL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLL ),
+ ENTRY( "NewLC-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLCL ),
+ //ENTRY( "NewL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewL_1L ),
+ //ENTRY( "NewLC-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLC_1L ),
+ ENTRY( "NewL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewL_2L ),
+ ENTRY( "NewLC-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLC_2L ),
+ ENTRY( "Type-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_TypeL ),
+ ENTRY( "Direction-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_DirectionL ),
+ ENTRY( "TxnId-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_TxnIdL ),
+ ENTRY( "Clone-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_CloneL ),
+ ENTRY( "SoapVersion-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SoapVersionL ),
+ //ENTRY( "SetContext-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetContextL ),
+ //ENTRY( "Context-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_ContextL ),
+ ENTRY( "SetProperties-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetPropertiesL ),
+ ENTRY( "SetBodyL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetBodyLL ),
+ ENTRY( "Properties-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_PropertiesL ),
+ ENTRY( "IsSafeToCast-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_IsSafeToCastL ),
+
+ ENTRY( "SetBodyL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetBodyL_1L ),
+ ENTRY( "BodyL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_BodyLL ),
+ ENTRY( "HeaderL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_HeaderLL ),
+ ENTRY( "AddHeaderL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_AddHeaderLL ),
+ ENTRY( "BodyAsStringL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_BodyAsStringLL ),
+ ENTRY( "IsFault-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_IsFaultL ),
+ ENTRY( "DetachFaultL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_DetachFaultLL ),
+ ENTRY( "FaultL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_FaultLL ),
+ ENTRY( "SetSoapActionL-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetSoapActionLL ),
+ ENTRY( "SoapAction-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_SoapActionL ),
+ ENTRY( "HasHeader-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_HasHeaderL ),
+ ENTRY( "HasBody-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_HasBodyL ),
+ ENTRY( "Parse1-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_Parse1L ),
+ ENTRY( "Parse2-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_Parse2L ),
+ ENTRY( "Parse2-CSenSoapEnvelope2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_Parse3L ),
+ ENTRY( "NewL-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_NewLL ),
+ ENTRY( "NewL-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_NewL_1L ),
+ ENTRY( "NewL-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_NewL_2L ),
+ ENTRY( "FaultCode-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_FaultCodeL ),
+ ENTRY( "FaultSubcode-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_FaultSubcodeL ),
+ ENTRY( "FaultString-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_FaultStringL ),
+ ENTRY( "FaultActor-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_FaultActorL ),
+ ENTRY( "Detail-CSenSoapFault2", CnewsoapclassesTester::MT_CSenSoapFault2_DetailL ),
+ ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLL ),
+ ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLCL ),
+ ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_1L ),
+ ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_1L ),
+ ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_2L ),
+ ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_2L ),
+ ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_3L ),
+ ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_3L ),
+ //ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_4L ),
+ //ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_4L ),
+ //ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_5L ),
+ //ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_5L ),
+ //ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_6L ),
+ //ENTRY( "NewLC-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_6L ),
+ ENTRY( "NewL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLL ),
+ ENTRY( "Type-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_TypeL ),
+ ENTRY( "Clone-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_CloneL ),
+ ENTRY( "Parse-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_Parse1L ),
+ ENTRY( "SetSecurityHeaderL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_SetSecurityHeaderLL ),
+ ENTRY( "AddSecurityTokenL-CSenSoapMessage2", CnewsoapclassesTester::MT_CSenSoapMessage2_AddSecurityTokenLL ),
+ ENTRY( "NewL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLL ),
+ ENTRY( "NewLC-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLCL ),
+ ENTRY( "NewL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewL_1L ),
+ ENTRY( "NewLC-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLC_1L ),
+ ENTRY( "NewL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewL_2L ),
+ ENTRY( "NewLC-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLC_2L ),
+ ENTRY( "UsernameTokenL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenLL ),
+ ENTRY( "UsernameTokenL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_1L ),
+ ENTRY( "UsernameTokenL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_2L ),
+ ENTRY( "UsernameTokenL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_3L ),
+ ENTRY( "UsernameTokenL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_4L ),
+ ENTRY( "TimestampL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_TimestampLL ),
+ ENTRY( "TimestampL-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_TimestampL_1L ),
+ ENTRY( "XmlNs-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_XmlNsL ),
+ ENTRY( "XmlNsPrefix-CSenWsSecurityHeader2", CnewsoapclassesTester::MT_CSenWsSecurityHeader2_XmlNsPrefixL ),
+ // Example how to use OOM functionality
+ //OOM_ENTRY( "Loop test with OOM", CnewsoapclassesTester::LoopTest, ETrue, 2, 3),
+ //OOM_FUNCENTRY( CnewsoapclassesTester::PrintTest, ETrue, 1, 3 ),
+
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CnewsoapclassesTester::ExampleL
+// Example test method function.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CnewsoapclassesTester::SetupL( ){
+
+ }
+
+void CnewsoapclassesTester::Teardown( ){
+
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLCL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewL_1L( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLC_1L( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewL_2L( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_NewLC_2L( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_TypeL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_DirectionL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_TxnIdL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_CloneL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_SoapVersionL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetContextL( CStifItemParser& aItem )
+ {
+ 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(mContext1 == pEnvelope->Context());
+ CleanupStack::PopAndDestroy(pEnvelope);
+ delete mContext1;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_ContextL( CStifItemParser& aItem )
+ {
+ SetupL();
+ TTestResult Result;
+ CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetContextL(Result);
+ Teardown();
+ return KErrNone;
+ }
+*/
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetPropertiesL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_PropertiesL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_IsSafeToCastL( CStifItemParser& aItem )
+ {
+ 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 CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetBodyLL( CStifItemParser& aItem )
+ {
+ 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);
+
+ if(!( *pAsXml == KEnvelopeString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pAsXml);
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetBodyL_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ _LIT8(KBodyContent, "BodyContent");
+ _LIT8(KBodyElementName2, "BodyElement2");
+ _LIT8(KBodyContent2, "BodyContent2");
+
+ _LIT8(KEnvelopeString, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Body><BodyElement>BodyContent</BodyElement></S:Body>\
+</S:Envelope>");
+
+ _LIT8(KEnvelopeString2, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Body><BodyElement2>BodyContent2</BodyElement2></S:Body>\
+</S:Envelope>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ bodyElement.AddTextL(KBodyContent());
+ pEnvelope->SetBodyL(bodyElement);
+
+ HBufC8* pAsXml = pEnvelope->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KEnvelopeString )) KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ TXmlEngElement bodyElement2 = document.CreateDocumentElementL(KBodyElementName2());
+ bodyElement2.AddTextL(KBodyContent2());
+ pEnvelope->SetBodyL(bodyElement2);
+
+ pAsXml = pEnvelope->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KEnvelopeString2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_BodyLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KBodyContentString, "Test");
+ _LIT8(KBodyString, "<S:Body>Test</S:Body>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+ pEnvelope->SetBodyL(KBodyContentString);
+
+ TXmlEngElement element = pEnvelope->BodyL();
+ RSenDocument document = pEnvelope->AsDocumentL();
+
+ TXmlEngSerializationOptions options;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ options.iOptions = options.iOptions |
+ TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, element, options);
+
+ // Serialized body should contain only body as XML.
+ if(!( asXml == KBodyString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_HeaderLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KHeaderString, "<S:Header/>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ TXmlEngElement element = pEnvelope->HeaderL();
+
+ RSenDocument document = pEnvelope->AsDocumentL();
+
+ TXmlEngSerializationOptions options;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ options.iOptions = options.iOptions |
+ TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, element, options);
+
+ // Serialized header should contain only header as XML.
+ if(!( asXml == KHeaderString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_AddHeaderLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KHeaderElementName, "HeaderElement");
+ _LIT8(KHeaderContent, "HeaderContent");
+ _LIT8(KHeaderElementName2, "HeaderElement2");
+ _LIT8(KHeaderContent2, "HeaderContent2");
+
+ _LIT8(KEnvelope, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<HeaderElement>HeaderContent</HeaderElement>\
+</S:Header>\
+<S:Body/></S:Envelope>");
+
+ _LIT8(KEnvelope2, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<HeaderElement>HeaderContent</HeaderElement>\
+<HeaderElement2>HeaderContent2</HeaderElement2>\
+</S:Header>\
+<S:Body/></S:Envelope>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement headerElement = document.CreateDocumentElementL(KHeaderElementName());
+ headerElement.AddTextL(KHeaderContent());
+ pEnvelope->AddHeaderL(headerElement);
+
+ HBufC8* pAsXml = pEnvelope->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KEnvelope )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ TXmlEngElement headerElement2 = document.CreateDocumentElementL(KHeaderElementName2());
+ headerElement2.AddTextL(KHeaderContent2());
+ pEnvelope->AddHeaderL(headerElement2);
+
+ pAsXml = pEnvelope->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KEnvelope2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_BodyAsStringLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ _LIT8(KBodyElementContent, "BodyElementContent");
+ _LIT8(KBodyContent, "BodyContent");
+
+ _LIT8(KBodyAsString1, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">BodyContent</S:Body>");
+ _LIT8(KBodyAsString2, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<BodyElement>BodyElementContent</BodyElement>\
+</S:Body>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ bodyElement.AddTextL(KBodyElementContent());
+
+ pEnvelope->SetBodyL(KBodyContent);
+
+ // If Body element does not contain any elements
+ // whole Body element is returned (and detached
+ // => needed namespace declarations are moved into
+ // Body)
+ HBufC8* pAsXml = pEnvelope->BodyAsStringL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KBodyAsString1 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ pEnvelope->SetBodyL(bodyElement);
+
+ // If Body element contains element(s)
+ // only first element (and all its child elements)
+ // from Body element is returned and detached
+ // (not Body element).
+ pAsXml = pEnvelope->BodyAsStringL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KBodyAsString2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_IsFaultL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KFaultElementName, "Fault");
+ _LIT8(KFaultContent, "FaultContent");
+ _LIT8(KFaultInputString, "<SOAP:Envelope \
+xmlns:SOAP=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<SOAP:Header>\
+<HeaderElement>HeaderContent</HeaderElement>\
+</SOAP:Header>\
+<SOAP:Body><SOAP:Fault>FaultContent</SOAP:Fault></SOAP:Body>\
+</SOAP:Envelope>");
+
+ // 1. Test that IsFault return EFalse by default
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ //if(!( pEnvelope->IsFault() == EFalse )) return KErrArgument;
+ TL( pEnvelope->IsFault() == EFalse )
+
+ // 2. Test that IsFault returns ETrue when fault is added
+ // using SetBodyL method
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementName(),
+ pEnvelope->NsUri());
+ faultElement.AddTextL(KFaultContent());
+ pEnvelope->SetBodyL(faultElement);
+
+ if(!( pEnvelope->IsFault())) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PopAndDestroy(pEnvelope);
+
+ // 3. Test that IsFault returns ETrue if fault is added
+ // when Envelope is parsed
+
+ CSenParser* pParser = CSenParser::NewLC();
+ pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ pParser->ParseL(KFaultInputString, *pEnvelope);
+ if(!( pEnvelope->IsFault())) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ CleanupStack::PopAndDestroy(pParser);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_DetachFaultLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KFaultElementName, "Fault");
+ _LIT8(KFaultContent, "FaultContent");
+ _LIT8(KFaultElement, "<S:Fault xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">FaultContent</S:Fault>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ TXmlEngElement body = pEnvelope->BodyL();
+ TXmlEngElement faultElement = body.AddNewElementWithNsL(KFaultElementName(),
+ pEnvelope->NsUri());
+ faultElement.AddTextL(KFaultContent());
+
+ CSenSoapFault2* pFault = pEnvelope->DetachFaultL();
+ CleanupStack::PushL(pFault);
+
+ HBufC8* pAsXml = pFault->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KFaultElement )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pFault);
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_FaultLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KFaultElementName, "Fault");
+ _LIT8(KFaultContent, "FaultContent");
+ _LIT8(KFaultElement, "<S:Fault>FaultContent</S:Fault>");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ TXmlEngElement body = pEnvelope->BodyL();
+ TXmlEngElement faultElement = body.AddNewElementWithNsL(KFaultElementName(),
+ pEnvelope->NsUri());
+ faultElement.AddTextL(KFaultContent());
+
+ CSenSoapFault2* pFault = pEnvelope->FaultL();
+ CleanupStack::PushL(pFault);
+
+ HBufC8* pAsXml = pFault->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KFaultElement )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pFault);
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_SetSoapActionLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapActionValue, "SoapActionValue");
+ _LIT8(KSoapActionValueInQuotes, "\"SoapActionValue\"");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ TPtrC8 retVal = pEnvelope->SetSoapActionL(KSoapActionValue);
+ if(!( retVal == KSoapActionValueInQuotes )) return KErrArgument;
+
+ TPtrC8 soapAction = pEnvelope->SoapAction();
+ if(!( soapAction == KSoapActionValueInQuotes )) return KErrArgument;
+
+ TPtrC8 retVal2 = pEnvelope->SetSoapActionL(KSoapActionValueInQuotes);
+ if(!( retVal2 == KSoapActionValueInQuotes )) return KErrArgument;
+
+ TPtrC8 soapAction2 = pEnvelope->SoapAction();
+ if(!( soapAction2 == KSoapActionValueInQuotes )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_SoapActionL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapActionValue, "SoapActionValue");
+ _LIT8(KSoapActionValueInQuotes, "\"SoapActionValue\"");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ TPtrC8 retVal = pEnvelope->SetSoapActionL(KSoapActionValue);
+ if(!( retVal == KSoapActionValueInQuotes )) return KErrArgument;
+
+ TPtrC8 soapAction = pEnvelope->SoapAction();
+ if(!( soapAction == KSoapActionValueInQuotes )) return KErrArgument;
+
+ TPtrC8 retVal2 = pEnvelope->SetSoapActionL(KSoapActionValueInQuotes) ;
+ if(!( retVal2 == KSoapActionValueInQuotes )) return KErrArgument;
+
+ TPtrC8 soapAction2 = pEnvelope->SoapAction();
+ if(!( soapAction2 == KSoapActionValueInQuotes )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_HasHeaderL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KHeaderElementName, "HeaderElement");
+ _LIT8(KHeaderContent, "HeaderContent");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ if(!( pEnvelope->HasHeader() == EFalse )) return KErrArgument;
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement headerElement = document.CreateDocumentElementL(KHeaderElementName());
+ headerElement.AddTextL(KHeaderContent());
+ pEnvelope->AddHeaderL(headerElement);
+
+ if(!( pEnvelope->HasHeader())) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_HasBodyL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ _LIT8(KBodyElementContent, "BodyElementContent");
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ if(!( pEnvelope->HasBody() == EFalse )) return KErrArgument;
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ bodyElement.AddTextL(KBodyElementContent());
+
+ pEnvelope->SetBodyL(bodyElement);
+
+ if(!( pEnvelope->HasBody())) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PopAndDestroy(pEnvelope);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_Parse1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KInputString, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<sb:Correlation xmlns:sb=\"urn:liberty:sb:2003-08\" \
+messageID=\"URN:UUID:860949DC-134D-A989-E328-2FD7F20E31CE\" timestamp=\"2006-06-01T14:53:19Z\"/>\
+<wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/>\
+</S:Header>\
+<S:Body>\
+<sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\
+</S:Body>\
+</S:Envelope>");
+ _LIT8(KBodyAsString, "\
+<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:sa=\"urn:liberty:sa:2004-04\">\
+<sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\
+</S:Body>");
+
+ _LIT8(KEmptyBodyAsString, "<S:Body/>");
+
+ _LIT8(KEmptyBodyWithNsAsString, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+
+ CSenParser* pParser = CSenParser::NewLC();
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ pParser->ParseL(KInputString, *pEnvelope);
+
+ // 1) Check that parsed SoapEnvelope can be
+ // serialized correctly
+ HBufC8* pAsXml = pEnvelope->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KInputString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ // 2) Check that body can be detached from SoapEnvelope
+ // correctly.
+ // Note: Following "BodyAsStringL()" call will detach
+ // Body from SoapEnvelope
+ HBufC8* pBodyAsString = pEnvelope->BodyAsStringL();
+ CleanupStack::PushL(pBodyAsString);
+ if(!( *pBodyAsString == KBodyAsString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pBodyAsString);
+
+ // 3) Check that body can be detached from SoapEnvelope
+ // twice
+ // In this case body does not have child elements.
+ // => Empty body should be returned.
+ // Note: Empty body should contain namespace
+ // declaration because body is detached
+ pBodyAsString = pEnvelope->BodyAsStringL();
+ CleanupStack::PushL(pBodyAsString);
+ if(!( *pBodyAsString == KEmptyBodyWithNsAsString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pBodyAsString);
+
+ // 4) Check that body was detached from SoapEnvelope
+ // correctly
+ // => Getting body again should result empty body to be returned.
+ TXmlEngElement bodyElement = pEnvelope->BodyL();
+ RSenDocument document = pEnvelope->AsDocumentL();
+
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, bodyElement, options);
+
+ // Serielized body should be empty because "BodyAsStringL()"
+ // previously detached body.
+ if(!( asXml == KEmptyBodyAsString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ CleanupStack::PopAndDestroy(pParser);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_Parse2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KInputString, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<sb:Correlation xmlns:sb=\"urn:liberty:sb:2003-08\" \
+messageID=\"URN:UUID:860949DC-134D-A989-E328-2FD7F20E31CE\" timestamp=\"2006-06-01T14:53:19Z\"/>\
+<wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/>\
+</S:Header>\
+<S:Body>\
+<sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\
+</S:Body>\
+</S:Envelope>");
+
+ _LIT8(KWholeBodyAsString, "<S:Body>\
+<sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\
+</S:Body>");
+
+ _LIT8(KWholeHeaderAsString, "<S:Header>\
+<sb:Correlation xmlns:sb=\"urn:liberty:sb:2003-08\" \
+messageID=\"URN:UUID:860949DC-134D-A989-E328-2FD7F20E31CE\" timestamp=\"2006-06-01T14:53:19Z\"/>\
+<wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/>\
+</S:Header>");
+
+ CSenParser* pParser = CSenParser::NewLC();
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ pParser->ParseL(KInputString, *pEnvelope);
+
+ // 1) Check that parsed SoapEnvelope can be
+ // serialized correctly
+ HBufC8* pAsXml = pEnvelope->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KInputString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ // 2) Check that body can be got from SoapEnvelope
+ // correctly
+ // Note: Body won't be detached. Only reference for
+ // body TXmlEngElement inside SoapEnvelope is returned.
+ TXmlEngElement bodyElement = pEnvelope->BodyL();
+ RSenDocument document = pEnvelope->AsDocumentL();
+
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, bodyElement, options);
+
+ // Serielized body should be in exactly the same form
+ // as in original SoapEnvelope
+ if(!( asXml == KWholeBodyAsString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ // 3) Check that header TXmlEngElement can be got from SoapEnvelope
+ // correctly
+ TXmlEngElement headerElement = pEnvelope->HeaderL();
+
+ RBuf8 headerAsXml;
+ CleanupClosePushL(headerAsXml);
+ document.SaveL(headerAsXml, headerElement, options);
+
+ // Serielized header should be in exactly the same form
+ // as in original SoapEnvelope
+ if(!( headerAsXml == KWholeHeaderAsString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&headerAsXml);
+
+ CleanupStack::PopAndDestroy(pEnvelope);
+ CleanupStack::PopAndDestroy(pParser);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapEnvelope2_Parse3L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KInputString, "<S:Envelope \
+xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
+xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>\
+<wsa:MessageID>urn:uuid:7837d733-b9f8-3eb1-5c3f-7a509797e6b2</wsa:MessageID>\
+<wsa:To>http://schemas.live.com/mws/2005/08/spaces</wsa:To>\
+<wsa:Action>http://schemas.live.com/mws/2005/08/spaces/Post</wsa:Action>\
+<wsa:ReplyTo><wsa:Address>id:7bbd5c5b-7857-44c4-b609-53498d0cab3b</wsa:Address></wsa:ReplyTo>\
+</S:Header>\
+<S:Body>\
+<PostRequest xmlns=\"http://schemas.live.com/mws/2005/08/spaces\">\
+<Item><Filename>sample1.wav</Filename><ItemType>8</ItemType><Image><Data></Data></Image></Item>\
+</PostRequest>\
+</S:Body>\
+</S:Envelope>");
+
+ _LIT8(KOuterXml, "<S:Body>\
+<PostRequest xmlns=\"http://schemas.live.com/mws/2005/08/spaces\">\
+<Item><Filename>sample1.wav</Filename><ItemType>8</ItemType><Image><Data/></Image></Item>\
+</PostRequest>\
+</S:Body>");
+
+ CSenParser* pParser = CSenParser::NewL();
+ CleanupStack::PushL(pParser);
+
+ CSenSoapEnvelope2* pEnvelope = CSenSoapEnvelope2::NewL();
+ CleanupStack::PushL(pEnvelope);
+
+ pParser->ParseL(KInputString, *pEnvelope);
+ TXmlEngElement element = pEnvelope->BodyL();
+
+ RBuf8 outerXml;
+ CleanupClosePushL(outerXml);
+ element.OuterXmlL(outerXml);
+
+ if(!( outerXml == KOuterXml )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&outerXml);
+ CleanupStack::PopAndDestroy(pEnvelope);
+ CleanupStack::PopAndDestroy(pParser);
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_NewLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KFaultElementName, "Fault");
+ _LIT8(KFaultElementContent, "FaultContent");
+ _LIT8(KFaultElement, "<Fault>FaultContent</Fault>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementName());
+ faultElement.AddTextL(KFaultElementContent());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ HBufC8* pAsXml = pSoapFault->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KFaultElement )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_NewL_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KFaultElementName, "Fault");
+ _LIT8(KFaultElementContent, "FaultContent");
+ _LIT8(KFaultElement, "<Fault>FaultContent</Fault>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementName());
+ faultElement.AddTextL(KFaultElementContent());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement, document);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ HBufC8* pAsXml = pSoapFault->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KFaultElement )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_NewL_2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KParentName, "Parent");
+
+ _LIT8(KAttributeNsUri, "nsuri");
+ _LIT8(KAttributeNsPrefix, "pr");
+ _LIT8(KAttributeLocalName, "AttrName");
+ _LIT8(KAttributeValue, "Value");
+
+ _LIT8(KFaultNsUri, "http://schemas.xmlsoap.org/soap/envelope/");
+ _LIT8(KFaultNsPrefix, "S");
+ _LIT8(KFaultLocalName, "Fault");
+
+ _LIT8(KFaultElement, "<S:Fault \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\" \
+xmlns:pr=\"nsuri\" pr:AttrName=\"Value\"/>");
+
+ _LIT8(KParentDocument, "<Parent><S:Fault \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\" \
+xmlns:pr=\"nsuri\" pr:AttrName=\"Value\"/>\
+</Parent>");
+
+ RSenDocument document = RSenDocument::NewL();
+ CleanupClosePushL(document);
+ TXmlEngElement parentElement = document.CreateDocumentElementL(KParentName());
+
+ RStringPool stringPool;
+ stringPool.OpenL();
+ CleanupClosePushL(stringPool);
+
+ RString nsUriRString = stringPool.OpenStringL(KAttributeNsUri);
+ CleanupClosePushL(nsUriRString);
+ RString nsPrefixRString = stringPool.OpenStringL(KAttributeNsPrefix);
+ CleanupClosePushL(nsPrefixRString);
+ RString localNameRString = stringPool.OpenStringL(KAttributeLocalName);
+ CleanupClosePushL(localNameRString);
+ RString valueRString = stringPool.OpenStringL(KAttributeValue);
+ CleanupClosePushL(valueRString);
+
+ RAttribute attribute;
+ attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
+ valueRString);
+ // attribute took ownership of all RStrings
+ // => All RStrings can be pop from CleanupStack
+ CleanupStack::Pop(&valueRString);
+ CleanupStack::Pop(&localNameRString);
+ CleanupStack::Pop(&nsPrefixRString);
+ CleanupStack::Pop(&nsUriRString);
+
+ CleanupClosePushL(attribute);
+
+ RAttributeArray attrArray;
+ // append the namespace attribute (declaration)
+ attrArray.AppendL(attribute);
+ CleanupClosePushL(attrArray);
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(KFaultNsUri,
+ KFaultLocalName,
+ KFaultNsPrefix,
+ attrArray,
+ parentElement,
+ document);
+ CleanupStack::PushL(pSoapFault);
+ HBufC8* pAsXml = pSoapFault->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KFaultElement )) return KErrArgument;
+
+ RBuf8 buffer;
+ CleanupClosePushL(buffer);
+ parentElement.OuterXmlL(buffer);
+
+ if(!( buffer == KParentDocument )) return KErrArgument;
+ CleanupStack::PopAndDestroy(&buffer);
+
+ CleanupStack::PopAndDestroy(pAsXml);
+ CleanupStack::PopAndDestroy(pSoapFault);
+ CleanupStack::PopAndDestroy(&attrArray);
+ CleanupStack::PopAndDestroy(&attribute);
+ CleanupStack::PopAndDestroy(&stringPool);
+ CleanupStack::PopAndDestroy(&document);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_FaultCodeL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSenSoapEnvelopeXmlns, "http://schemas.xmlsoap.org/soap/envelope/");
+ _LIT8(KSenSoap12EnvelopeXmlns, "http://www.w3.org/2003/05/soap-envelope");
+
+ _LIT8(KFaultElementLocalname, "Fault");
+ _LIT8(KFaultNsPrefix, "S");
+
+ _LIT8(KFaultCodeLocalname, "faultcode");
+
+ _LIT8(KFault12CodeLocalname, "Code"); // Soap 1.2
+ _LIT8(KFault12ValueLocalname, "Value"); // Soap1.2
+
+ _LIT8(KFaultCodeValue, "123");
+
+
+ // 1) Fault code in Soap other than 1.2
+ // Note: In SOAP older than 1.2 fault elements are _NOT_ namespace qualified
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoapEnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultCodeElement = faultElement.AddNewElementL(KFaultCodeLocalname());
+ faultCodeElement.AddTextL(KFaultCodeValue());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement, document);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ TPtrC8 faultCode = pSoapFault->FaultCode();
+ if(!( faultCode == KFaultCodeValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+
+ // 2) Fault code in Soap 1.2
+ // Note: SOAP 1.2 faults are structured differently to SOAP 1.1.
+ // In particular all fault elements are now namespace _qualified_,
+ // many have been renamed and fault codes are now hierarchical
+ RSenDocument document2 = RSenDocument::NewLC();
+ TXmlEngElement faultElement2 = document2.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoap12EnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultCodeElement2 = faultElement2.AddNewElementSameNsL(KFault12CodeLocalname());
+ TXmlEngElement faultValueElement2 = faultCodeElement2.AddNewElementSameNsL(KFault12ValueLocalname());
+ faultValueElement2.AddTextL(KFaultCodeValue());
+
+ CSenSoapFault2* pSoapFault2 = CSenSoapFault2::NewL(faultElement2, document2);
+ CleanupStack::PopAndDestroy(1); // document2
+ CleanupStack::PushL(pSoapFault2);
+
+ TPtrC8 faultCode2 = pSoapFault2->FaultCode();
+ if(!( faultCode2 == KFaultCodeValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault2);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_FaultSubcodeL( CStifItemParser& aItem )
+ {
+ SetupL();
+ // FaultSubcodeL is supported only in Soap 1.2
+ // If other version of Soap is used return value will always be KNullDesC
+ _LIT8(KSenSoapEnvelopeXmlns, "http://schemas.xmlsoap.org/soap/envelope/");
+ _LIT8(KSenSoap12EnvelopeXmlns, "http://www.w3.org/2003/05/soap-envelope");
+
+ _LIT8(KFaultElementLocalname, "Fault");
+ _LIT8(KFaultNsPrefix, "S");
+
+// _LIT8(KFaultCodeLocalname, "faultcode");
+
+ _LIT8(KFault12CodeLocalname, "Code"); // Soap 1.2
+ _LIT8(KFault12SubcodeLocalname, "Subcode"); // Soap 1.2
+ _LIT8(KFault12ValueLocalname, "Value"); // Soap1.2
+
+ _LIT8(KFaultCodeValue, "123");
+
+
+ // 1) Fault subcode in Soap other than 1.2
+ // Note: In SOAP older than 1.2 there is _NO_ sobcode
+ // => KNullDesC8 should be returned.
+ // Note: In SOAP older than 1.2 fault elements are _NOT_ namespace qualified
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoapEnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultCodeElement = faultElement.AddNewElementL(KFault12CodeLocalname());
+ TXmlEngElement faultSubCodeElement = faultCodeElement.AddNewElementSameNsL(KFault12SubcodeLocalname());
+ TXmlEngElement faultValueElement = faultSubCodeElement.AddNewElementSameNsL(KFault12ValueLocalname());
+ faultValueElement.AddTextL(KFaultCodeValue());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement, document);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ TPtrC8 faultCode = pSoapFault->FaultSubcode();
+ if(!( faultCode == KNullDesC8 )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+
+ // 2) Fault subcode in Soap 1.2
+ // Note: SOAP 1.2 faults are structured differently to SOAP 1.1.
+ // In particular all fault elements are now namespace _qualified_,
+ // many have been renamed and fault codes are now hierarchical
+ RSenDocument document2 = RSenDocument::NewLC();
+ TXmlEngElement faultElement2 = document2.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoap12EnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultCodeElement2 = faultElement2.AddNewElementSameNsL(KFault12CodeLocalname());
+ TXmlEngElement faultSubCodeElement2 = faultCodeElement2.AddNewElementSameNsL(KFault12SubcodeLocalname());
+ TXmlEngElement faultValueElement2 = faultSubCodeElement2.AddNewElementSameNsL(KFault12ValueLocalname());
+ faultValueElement2.AddTextL(KFaultCodeValue());
+
+ CSenSoapFault2* pSoapFault2 = CSenSoapFault2::NewL(faultElement2, document2);
+ CleanupStack::PopAndDestroy(1); // document2
+ CleanupStack::PushL(pSoapFault2);
+
+ TPtrC8 faultCode2 = pSoapFault2->FaultSubcode();
+ if(!( faultCode2 == KFaultCodeValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault2);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_FaultStringL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSenSoapEnvelopeXmlns, "http://schemas.xmlsoap.org/soap/envelope/");
+ _LIT8(KSenSoap12EnvelopeXmlns, "http://www.w3.org/2003/05/soap-envelope");
+
+ _LIT8(KFaultElementLocalname, "Fault");
+ _LIT8(KFaultNsPrefix, "S");
+
+ _LIT8(KFaultStringLocalname, "faultstring");
+
+ _LIT8(KFault12ReasonLocalname, "Reason"); // Soap1.2
+ _LIT8(KFault12TextLocalname, "Text"); // Soap1.2
+
+
+ _LIT8(KFaultStringValue, "Fault code string");
+
+
+ // 1) Fault code in Soap other than 1.2
+ // Note: In SOAP older than 1.2 fault elements are _NOT_ namespace qualified
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoapEnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultStringElement = faultElement.AddNewElementL(KFaultStringLocalname());
+ faultStringElement.AddTextL(KFaultStringValue());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement, document);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ TPtrC8 faultCode = pSoapFault->FaultString();
+ if(!( faultCode == KFaultStringValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+
+ // 2) Fault code in Soap 1.2
+ // Note: SOAP 1.2 faults are structured differently to SOAP 1.1.
+ // In particular all fault elements are now namespace _qualified_,
+ // many have been renamed and fault codes are now hierarchical
+ RSenDocument document2 = RSenDocument::NewLC();
+ TXmlEngElement faultElement2 = document2.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoap12EnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultReasonElement2 = faultElement2.AddNewElementSameNsL(KFault12ReasonLocalname());
+ TXmlEngElement faultTextElement2 = faultReasonElement2.AddNewElementSameNsL(KFault12TextLocalname());
+ faultTextElement2.AddTextL(KFaultStringValue());
+
+ CSenSoapFault2* pSoapFault2 = CSenSoapFault2::NewL(faultElement2, document2);
+ CleanupStack::PopAndDestroy(1); // document2
+ CleanupStack::PushL(pSoapFault2);
+
+ TPtrC8 faultCode2 = pSoapFault2->FaultString();
+ if(!( faultCode2 == KFaultStringValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault2);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_FaultActorL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSenSoapEnvelopeXmlns, "http://schemas.xmlsoap.org/soap/envelope/");
+ _LIT8(KSenSoap12EnvelopeXmlns, "http://www.w3.org/2003/05/soap-envelope");
+
+ _LIT8(KFaultElementLocalname, "Fault");
+ _LIT8(KFaultNsPrefix, "S");
+
+ _LIT8(KFaultActorLocalname, "faultactor");
+
+ _LIT8(KFault12NodeLocalname, "Node"); // Node represents faultactor in Soap 1.2
+
+ _LIT8(KFaultActorValue, "http://www.wrox.com/heroes/endpoint.asp");
+
+
+ // 1) Faultactor in Soap other than 1.2
+ // "faultactor" is intended to provide information about which SOAP node
+ // on the SOAP message path caused the fault to happen.
+ // The value of the "faultactor" is a URI identifying the source of the fault.
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoapEnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultCodeElement = faultElement.AddNewElementL(KFaultActorLocalname());
+ faultCodeElement.AddTextL(KFaultActorValue());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement, document);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ TPtrC8 faultActor = pSoapFault->FaultActor();
+ if(!( faultActor == KFaultActorValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+
+ // 2) Faultactor in Soap 1.2
+ // "Node" is intended to provide information about which SOAP node on the
+ // SOAP message path caused the fault to happen.
+ // "Node" contains the URI of the SOAP node that generated the fault.
+ //
+ // Note: In Soap 1.2 "Node" represents "faultactor" from previous SOAP versions.
+
+ RSenDocument document2 = RSenDocument::NewLC();
+ TXmlEngElement faultElement2 = document2.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoap12EnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultNodeElement2 = faultElement2.AddNewElementSameNsL(KFault12NodeLocalname());
+ faultNodeElement2.AddTextL(KFaultActorValue());
+
+ CSenSoapFault2* pSoapFault2 = CSenSoapFault2::NewL(faultElement2, document2);
+ CleanupStack::PopAndDestroy(1); // document2
+ CleanupStack::PushL(pSoapFault2);
+
+ HBufC8* pAsXml = pSoapFault2->AsXmlL();
+ delete pAsXml;
+
+ TPtrC8 faultCode2 = pSoapFault2->FaultActor();
+ if(!( faultCode2 == KFaultActorValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault2);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapFault2_DetailL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSenSoapEnvelopeXmlns, "http://schemas.xmlsoap.org/soap/envelope/");
+ _LIT8(KSenSoap12EnvelopeXmlns, "http://www.w3.org/2003/05/soap-envelope");
+
+ _LIT8(KFaultElementLocalname, "Fault");
+ _LIT8(KFaultNsPrefix, "S");
+
+ _LIT8(KDetailLocalname, "detail");
+
+ _LIT8(KFault12DetailLocalname, "Detail"); // Soap 1.2
+
+ _LIT8(KFaultDetailValue, "Detailed information");
+
+
+ // 1) Fault code in Soap other than 1.2
+ // Note: In SOAP older than 1.2 fault elements are _NOT_ namespace qualified
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement faultElement = document.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoapEnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultDetailElement = faultElement.AddNewElementL(KDetailLocalname());
+ faultDetailElement.AddTextL(KFaultDetailValue());
+
+ CSenSoapFault2* pSoapFault = CSenSoapFault2::NewL(faultElement, document);
+ CleanupStack::PopAndDestroy(1); // document
+ CleanupStack::PushL(pSoapFault);
+
+ TPtrC8 faultDetail = pSoapFault->Detail();
+ if(!( faultDetail == KFaultDetailValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault);
+
+ // 2) Fault code in Soap 1.2
+ // Note: SOAP 1.2 faults are structured differently to SOAP 1.1.
+ // In particular all fault elements are now namespace _qualified_,
+ // many have been renamed and fault codes are now hierarchical
+ RSenDocument document2 = RSenDocument::NewLC();
+ TXmlEngElement faultElement2 = document2.CreateDocumentElementL(KFaultElementLocalname(),
+ KSenSoap12EnvelopeXmlns(),
+ KFaultNsPrefix());
+ TXmlEngElement faultDetailElement2 = faultElement2.AddNewElementSameNsL(KFault12DetailLocalname());
+ faultDetailElement2.AddTextL(KFaultDetailValue());
+
+ CSenSoapFault2* pSoapFault2 = CSenSoapFault2::NewL(faultElement2, document2);
+ CleanupStack::PopAndDestroy(1); // document2
+ CleanupStack::PushL(pSoapFault2);
+
+ TPtrC8 faultDetail2 = pSoapFault2->Detail();
+ if(!( faultDetail2 == KFaultDetailValue )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pSoapFault2);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL();
+ CleanupStack::PushL(pSoapMessage);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLCL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewLC();
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+
+ // 1) Test creating of SOAP 1.1 version SoapMessage
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(ESOAP11);
+ CleanupStack::PushL(pSoapMessage);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2) Test creating of SOAP 1.2 version SoapMessage
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+
+ // 1) Test creating of SOAP 1.1 version SoapMessage
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewLC(ESOAP11);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2) Test creating of SOAP 1.2 version SoapMessage
+ pSoapMessage = CSenSoapMessage2::NewLC(ESOAP12);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KIllegalNamespace, "illegalNamespace");
+ _LIT8(KSecuritySchemeXmlNamespace, "http://schemas.xmlsoap.org/ws/2003/06/secext");
+ _LIT8(KSecurityXmlNamespace, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
+
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage13, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage21, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+ _LIT8(KSoapMessage22, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage23, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ // 1.1) Test creating of SOAP 1.1 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(ESOAP11, KIllegalNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.2) Test creating of SOAP 1.1 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP11, KSecuritySchemeXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.3) Test creating of SOAP 1.1 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP11, KSecurityXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage13 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.1) Test creating of SOAP 1.2 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12, KIllegalNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage21 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.2) Test creating of SOAP 1.2 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12, KSecuritySchemeXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage22 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.3) Test creating of SOAP 1.2 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12, KSecurityXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage23 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KIllegalNamespace, "illegalNamespace");
+ _LIT8(KSecuritySchemeXmlNamespace, "http://schemas.xmlsoap.org/ws/2003/06/secext");
+ _LIT8(KSecurityXmlNamespace, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
+
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage13, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage21, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+ _LIT8(KSoapMessage22, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage23, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ // 1.1) Test creating of SOAP 1.1 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewLC(ESOAP11, KIllegalNamespace);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.2) Test creating of SOAP 1.1 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(ESOAP11, KSecuritySchemeXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.3) Test creating of SOAP 1.1 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(ESOAP11, KSecurityXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage13 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.1) Test creating of SOAP 1.2 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ pSoapMessage = CSenSoapMessage2::NewLC(ESOAP12, KIllegalNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage21 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.2) Test creating of SOAP 1.2 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(ESOAP12, KSecuritySchemeXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage22 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.3) Test creating of SOAP 1.2 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(ESOAP12, KSecurityXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage23 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_3L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ CSenSoapMessage2* pSoapMessage, *pSoapMessage1 = CSenSoapMessage2::NewL();
+ pSoapMessage = CSenSoapMessage2::NewL(*pSoapMessage1);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pAsXml);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete pSoapMessage);
+ pSoapMessage = NULL;
+ delete pSoapMessage1;
+ pSoapMessage1 = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_3L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ CSenSoapMessage2* pSoapMessage, *pSoapMessage1 = CSenSoapMessage2::NewL();
+ pSoapMessage = CSenSoapMessage2::NewLC(*pSoapMessage1);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pAsXml);
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ delete pSoapMessage1;
+ pSoapMessage1 = NULL;
+ Teardown();
+ return KErrNone;
+ }
+/*
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_4L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ MSenMessageContext* mContext = NULL;
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(*mContext);
+ CleanupStack::PushL(pSoapMessage);
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pAsXml);
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_4L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ MSenMessageContext* mContext = NULL;
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewLC(*mContext);
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_5L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+
+ MSenMessageContext* mContext = NULL;
+ // 1) Test creating of SOAP 1.1 version SoapMessage
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(*mContext, ESOAP11);
+ CleanupStack::PushL(pSoapMessage);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2) Test creating of SOAP 1.2 version SoapMessage
+ pSoapMessage = CSenSoapMessage2::NewL(*mContext, ESOAP12 );
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_5L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+ MSenMessageContext* mContext = NULL;
+
+
+ // 1) Test creating of SOAP 1.1 version SoapMessage
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewLC(*mContext, ESOAP11);
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+
+ // 2) Test creating of SOAP 1.2 version SoapMessage
+ pSoapMessage = CSenSoapMessage2::NewLC(*mContext, ESOAP12);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewL_6L( CStifItemParser& aItem )
+ {
+ SetupL();
+ MSenMessageContext* mContext = NULL;
+
+
+ _LIT8(KIllegalNamespace, "illegalNamespace");
+ _LIT8(KSecuritySchemeXmlNamespace, "http://schemas.xmlsoap.org/ws/2003/06/secext");
+ _LIT8(KSecurityXmlNamespace, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
+
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage13, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage21, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+ _LIT8(KSoapMessage22, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage23, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ // 1.1) Test creating of SOAP 1.1 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(*mContext, ESOAP11, KIllegalNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.2) Test creating of SOAP 1.1 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(*mContext,ESOAP11, KSecuritySchemeXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.3) Test creating of SOAP 1.1 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(*mContext,ESOAP11, KSecurityXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage13 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.1) Test creating of SOAP 1.2 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ pSoapMessage = CSenSoapMessage2::NewL(*mContext,ESOAP12, KIllegalNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage21 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.2) Test creating of SOAP 1.2 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(*mContext,ESOAP12, KSecuritySchemeXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage22 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.3) Test creating of SOAP 1.2 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewL(*mContext,ESOAP12, KSecurityXmlNamespace);
+ CleanupStack::PushL(pSoapMessage);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage23 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_NewLC_6L(CStifItemParser& aItem )
+ {
+ SetupL();
+ MSenMessageContext* mContext = NULL;
+
+ _LIT8(KIllegalNamespace, "illegalNamespace");
+ _LIT8(KSecuritySchemeXmlNamespace, "http://schemas.xmlsoap.org/ws/2003/06/secext");
+ _LIT8(KSecurityXmlNamespace, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
+
+ _LIT8(KSoapMessage11, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+ _LIT8(KSoapMessage12, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage13, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage21, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\"/>");
+ _LIT8(KSoapMessage22, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+ _LIT8(KSoapMessage23, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/></S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ // 1.1) Test creating of SOAP 1.1 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewLC(*mContext,ESOAP11, KIllegalNamespace);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.2) Test creating of SOAP 1.1 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(*mContext,ESOAP11, KSecuritySchemeXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 1.3) Test creating of SOAP 1.1 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(*mContext,ESOAP11, KSecurityXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage13 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.1) Test creating of SOAP 1.2 version SoapMessage with illegal namespace
+ // => No security header should be added.
+ pSoapMessage = CSenSoapMessage2::NewLC(*mContext,ESOAP12, KIllegalNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage21 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.2) Test creating of SOAP 1.2 version SoapMessage with scheme namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(*mContext,ESOAP12, KSecuritySchemeXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage22 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2.3) Test creating of SOAP 1.2 version SoapMessage with security namespace
+ // => Security header should be created with given namespace.
+ pSoapMessage = CSenSoapMessage2::NewLC(*mContext,ESOAP12, KSecurityXmlNamespace);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage23 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ Teardown();
+ return KErrNone;
+ }
+*/
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_TypeL( CStifItemParser& aItem )
+ {
+ SetupL();
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL();
+ CleanupStack::PushL(pSoapMessage);
+
+ TL(MSenMessage::ESoapMessage2 == pSoapMessage->Type());
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_CloneL( CStifItemParser& aItem )
+ {
+ SetupL();
+ TBool Flag;
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL();
+ CleanupStack::PushL(pSoapMessage);
+
+ CSenSoapMessage2* pClone = NULL;
+ pClone = (CSenSoapMessage2*)pSoapMessage->CloneL();
+ if(pClone != NULL)
+ Flag = 1;
+ if(!(Flag)) return KErrArgument;
+ delete pClone;
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_Parse1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KInputString, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<sb:Correlation xmlns:sb=\"urn:liberty:sb:2003-08\" \
+messageID=\"URN:UUID:860949DC-134D-A989-E328-2FD7F20E31CE\" timestamp=\"2006-06-01T14:53:19Z\"/>\
+<wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/>\
+</S:Header>\
+<S:Body>\
+<sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\
+</S:Body>\
+</S:Envelope>");
+ _LIT8(KBodyAsString, "\
+<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:sa=\"urn:liberty:sa:2004-04\">\
+<sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\
+</S:Body>");
+
+
+ _LIT8(KEmptyBodyAsString, "<S:Body/>");
+
+ _LIT8(KEmptyBodyWithNsAsString, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>");
+
+ CSenParser* pParser = CSenParser::NewLC();
+ CSenSoapMessage2* pMessage = CSenSoapMessage2::NewL();
+ CleanupStack::PushL(pMessage);
+
+ pParser->ParseL(KInputString, *pMessage);
+
+ // 1) Check that parsed SoapEnvelope can be
+ // serialized correctly
+ HBufC8* pAsXml = pMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KInputString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ // 2) Check that body can be detached from SoapEnvelope
+ // correctly.
+ // Note: Following "BodyAsStringL()" call will detach
+ // Body from SoapEnvelope
+ HBufC8* pBodyAsString = pMessage->BodyAsStringL();
+ CleanupStack::PushL(pBodyAsString);
+ if(!( *pBodyAsString == KBodyAsString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pBodyAsString);
+
+ // 3) Check that body can be detached from SoapEnvelope
+ // twice
+ // In this case body does not have child elements.
+ // => Empty body should be returned.
+ // Note: Empty body should contain namespace
+ // declaration because body is detached
+ pBodyAsString = pMessage->BodyAsStringL();
+ CleanupStack::PushL(pBodyAsString);
+ if(!( *pBodyAsString == KEmptyBodyWithNsAsString )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pBodyAsString);
+
+ // 4) Check that body was detached from SoapEnvelope
+ // correctly
+ // => Getting body again should result empty body to be returned.
+ TXmlEngElement bodyElement = pMessage->BodyL();
+ RSenDocument document = pMessage->AsDocumentL();
+
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, bodyElement, options);
+
+ // Serielized body should be empty because "BodyAsStringL()"
+ // previously detached body.
+ if(!( asXml == KEmptyBodyAsString )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ CleanupStack::PopAndDestroy(pMessage);
+ CleanupStack::PopAndDestroy(pParser);
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_SetSecurityHeaderLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11_1, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<Credential/>\
+</wsse:Security>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSoapMessage11_2, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSoapMessage12_1, "<S:Envelope \
+xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<Credential/>\
+</wsse:Security>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSoapMessage12_2, "<S:Envelope \
+xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KCredential, "<Credential/>");
+
+ // 1) Soap 1.1 - Test setting of SecurityHeader WITH Credential
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(ESOAP11);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->SetSecurityHeaderL(KCredential);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11_1 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2) Soap 1.1 - Test setting of SecurityHeader WITHOUT Credential
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP11);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->SetSecurityHeaderL(KNullDesC8);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11_2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 3) Soap 1.2 - Test setting of SecurityHeader WITH Credential
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->SetSecurityHeaderL(KCredential);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12_1 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 4) Soap 1.2 - Test setting of SecurityHeader WITH Credential
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->SetSecurityHeaderL(KNullDesC8);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12_2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenSoapMessage2_AddSecurityTokenLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KSoapMessage11_1, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<SecurityToken/>\
+</wsse:Security>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSoapMessage11_2, "<S:Envelope \
+xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<SecurityToken/>\
+<SecurityToken2/>\
+</wsse:Security>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSoapMessage12_1, "<S:Envelope \
+xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<SecurityToken/>\
+</wsse:Security>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSoapMessage12_2, "<S:Envelope \
+xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<SecurityToken/>\
+<SecurityToken2/>\
+</wsse:Security>\
+</S:Header>\
+<S:Body/>\
+</S:Envelope>");
+
+ _LIT8(KSecurityToken, "<SecurityToken/>");
+ _LIT8(KSecurityToken2, "<SecurityToken2/>");
+
+ // 1) Soap 1.1 - Test adding of SecurityToken
+ CSenSoapMessage2* pSoapMessage = CSenSoapMessage2::NewL(ESOAP11);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->AddSecurityTokenL(KSecurityToken);
+
+ HBufC8* pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11_1 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 2) Soap 1.1 - Test adding of two SecurityTokens
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP11);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->AddSecurityTokenL(KSecurityToken);
+ pSoapMessage->AddSecurityTokenL(KSecurityToken2);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage11_2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 3) Soap 1.2 - Test adding of SecurityToken
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->AddSecurityTokenL(KSecurityToken);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12_1 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+
+ // 4) Soap 1.2 - Test adding of two SecurityTokens
+ pSoapMessage = CSenSoapMessage2::NewL(ESOAP12);
+ CleanupStack::PushL(pSoapMessage);
+
+ pSoapMessage->AddSecurityTokenL(KSecurityToken);
+ pSoapMessage->AddSecurityTokenL(KSecurityToken2);
+
+ pAsXml = pSoapMessage->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSoapMessage12_2 )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pSoapMessage);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElement, "<RootElement>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>\
+</RootElement>");
+
+ _LIT8(KSecurityHeader, "\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>");
+
+ _LIT8(KRootElementName, "RootElement");
+
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewL(document,
+ rootElement);
+ CleanupStack::PushL(pWsSecHeader);
+
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, rootElement, options);
+
+ // Serialized document should contain all the Fragment data as XML.
+ if(!( asXml == KRootElement )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ HBufC8* pAsXml = pWsSecHeader->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSecurityHeader )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLCL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElement, "<RootElement>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>\
+</RootElement>");
+
+ _LIT8(KSecurityHeader, "\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>");
+
+ _LIT8(KRootElementName, "RootElement");
+
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, rootElement, options);
+
+ // Serialized document should contain all the Fragment data as XML.
+ if(!( asXml == KRootElement )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ HBufC8* pAsXml = pWsSecHeader->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSecurityHeader )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewL_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElement, "<RootElement>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+SecurityToken\
+</wsse:Security>\
+</RootElement>");
+
+ _LIT8(KSecurityHeader, "\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+SecurityToken\
+</wsse:Security>");
+
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KSecurityToken, "SecurityToken");
+
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewL(KSecurityToken,
+ document,
+ rootElement);
+ CleanupStack::PushL(pWsSecHeader);
+
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, rootElement, options);
+
+ // Serialized document should contain all the Fragment data as XML.
+ if(!( asXml == KRootElement )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ HBufC8* pAsXml = pWsSecHeader->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSecurityHeader )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLC_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElement, "<RootElement>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+SecurityToken\
+</wsse:Security>\
+</RootElement>");
+
+ _LIT8(KSecurityHeader, "\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+SecurityToken\
+</wsse:Security>");
+
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KSecurityToken, "SecurityToken");
+
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(KSecurityToken,
+ document,
+ rootElement);
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, rootElement, options);
+
+ // Serialized document should contain all the Fragment data as XML.
+ if(!( asXml == KRootElement )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ HBufC8* pAsXml = pWsSecHeader->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSecurityHeader )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewL_2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElement, "<RootElement>\
+<wsse:Security xmlns:wsse=\"namespace\">\
+SecurityToken\
+</wsse:Security>\
+</RootElement>");
+
+ _LIT8(KSecurityHeader, "\
+<wsse:Security xmlns:wsse=\"namespace\">\
+SecurityToken\
+</wsse:Security>");
+
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KSecurityToken, "SecurityToken");
+ _LIT8(KNamespace, "namespace");
+
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewL(KSecurityToken,
+ KNamespace,
+ document,
+ rootElement);
+ CleanupStack::PushL(pWsSecHeader);
+
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, rootElement, options);
+
+ // Serialized document should contain all the Fragment data as XML.
+ if(!( asXml == KRootElement )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ HBufC8* pAsXml = pWsSecHeader->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSecurityHeader )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_NewLC_2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElement, "<RootElement>\
+<wsse:Security xmlns:wsse=\"namespace\">\
+SecurityToken\
+</wsse:Security>\
+</RootElement>");
+
+ _LIT8(KSecurityHeader, "\
+<wsse:Security xmlns:wsse=\"namespace\">\
+SecurityToken\
+</wsse:Security>");
+
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KSecurityToken, "SecurityToken");
+ _LIT8(KNamespace, "namespace");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(KSecurityToken,
+ KNamespace,
+ document,
+ rootElement);
+ TUint optionFlags = 0;
+ // Omit following declarations from the beginning of XML Document:
+ // <?xml version=\"1.0\...
+ // encoding="..."
+ // standalone="..."
+ // ?>
+ optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+
+ // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+
+ // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+ //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+ TXmlEngSerializationOptions options(optionFlags);
+
+ RBuf8 asXml;
+ CleanupClosePushL(asXml);
+ document.SaveL(asXml, rootElement, options);
+
+ // Serialized document should contain all the Fragment data as XML.
+ if(!( asXml == KRootElement )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(&asXml);
+
+ HBufC8* pAsXml = pWsSecHeader->AsXmlL();
+ CleanupStack::PushL(pAsXml);
+ if(!( *pAsXml == KSecurityHeader )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pAsXml);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KUserName, "UserName");
+ _LIT8(KUserNameToken, "<wsse:UsernameToken>\
+<wsse:Username>UserName</wsse:Username>\
+</wsse:UsernameToken>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+
+ HBufC8* pUserNameToken = NULL;
+ pWsSecHeader->UsernameTokenL(KUserName, pUserNameToken);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameToken )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+
+ _LIT8(KFakeEndPoint, "http://www.fake_endpoint.com/");
+ _LIT8(KUsername, "Username");
+ _LIT8(KPassword, "Password");
+
+ _LIT8(KUserNameToken, "<wsse:UsernameToken>\
+<wsse:Username>Username</wsse:Username>\
+<wsse:Password>Password</wsse:Password>\
+</wsse:UsernameToken>");
+
+ _LIT8(KUserNameTokenDigest, "<wsse:UsernameToken>\
+<wsse:Username>Username</wsse:Username>\
+<wsse:Password Type=\"wsse:PasswordDigest\">Password</wsse:Password>\
+</wsse:UsernameToken>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenIdentityProvider* pIdP = CSenIdentityProvider::NewLC(KFakeEndPoint());
+ pIdP->SetUserInfoL(KUsername, KNullDesC8, KPassword);
+
+ // 1) Test using CSenWsSecurityHeader2::EText
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+
+ HBufC8* pUserNameToken = pWsSecHeader->UsernameTokenL(*pIdP, CSenWsSecurityHeader2::EText);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameToken )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ // 2) Test using CSenWsSecurityHeader2::EDigest
+ pWsSecHeader = CSenWsSecurityHeader2::NewLC(document, rootElement);
+
+ pUserNameToken = pWsSecHeader->UsernameTokenL(*pIdP, CSenWsSecurityHeader2::EDigest);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameTokenDigest )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(pIdP);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_2L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KUserName, "UserName");
+ _LIT8(KPassword, "Password");
+ _LIT8(KUserNameToken, "<wsse:UsernameToken>\
+<wsse:Username>UserName</wsse:Username>\
+<wsse:Password>Password</wsse:Password>\
+</wsse:UsernameToken>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+
+ HBufC8* pUserNameToken = NULL;
+ pWsSecHeader->UsernameTokenL(KUserName, KPassword, pUserNameToken);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameToken )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_3L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KUserName, "UserName");
+ _LIT8(KPassword, "Password");
+ _LIT8(KUserNameToken, "<wsse:UsernameToken>\
+<wsse:Username>UserName</wsse:Username>\
+<wsse:Password>Password</wsse:Password>\
+</wsse:UsernameToken>");
+
+ _LIT8(KUserNameTokenDigest, "<wsse:UsernameToken>\
+<wsse:Username>UserName</wsse:Username>\
+<wsse:Password Type=\"wsse:PasswordDigest\">Password</wsse:Password>\
+</wsse:UsernameToken>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ // 1) Test using CSenWsSecurityHeader2::EText
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+
+ HBufC8* pUserNameToken = NULL;
+ pWsSecHeader->UsernameTokenL(KUserName, KPassword, CSenWsSecurityHeader2::EText,
+ pUserNameToken);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameToken )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ // 2) Test using CSenWsSecurityHeader2::EDigest
+ pWsSecHeader = CSenWsSecurityHeader2::NewLC(document, rootElement);
+
+ pUserNameToken = NULL;
+ pWsSecHeader->UsernameTokenL(KUserName, KPassword, CSenWsSecurityHeader2::EDigest,
+ pUserNameToken);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameTokenDigest )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_UsernameTokenL_4L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+
+ _LIT8(KFakeEndPoint, "http://www.fake_endpoint.com/");
+ _LIT8(KUsername, "Username");
+ _LIT8(KPassword, "Password");
+
+ _LIT8(KUserNameToken, "<wsse:UsernameToken>\
+<wsse:Username>Username</wsse:Username>\
+</wsse:UsernameToken>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+
+ CSenIdentityProvider* pIdP = CSenIdentityProvider::NewLC(KFakeEndPoint());
+ pIdP->SetUserInfoL(KUsername, KNullDesC8, KPassword);
+
+ HBufC8* pUserNameToken = pWsSecHeader->UsernameTokenL(*pIdP);
+ CleanupStack::PushL(pUserNameToken);
+ if(!( *pUserNameToken == KUserNameToken )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pUserNameToken);
+
+ CleanupStack::PopAndDestroy(pIdP);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_TimestampLL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KCreated, "2001-09-13T08:42:00Z");
+ _LIT8(KExpires, "2002-09-13T08:42:00Z");
+ _LIT8(KTimeStamp, "\
+<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">\
+<wsu:Created>2001-09-13T08:42:00Z</wsu:Created>\
+<wsu:Expires>2002-09-13T08:42:00Z</wsu:Expires>\
+</wsu:Timestamp>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+ HBufC8* pTimeStamp;
+ pWsSecHeader->TimestampL(KCreated, KExpires, pTimeStamp);
+ CleanupStack::PushL(pTimeStamp);
+ if(!( *pTimeStamp == KTimeStamp )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pTimeStamp);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_TimestampL_1L( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KCreated, "2001-09-13T08:42:00Z");
+ _LIT8(KTimeStamp, "\
+<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">\
+<wsu:Created>2001-09-13T08:42:00Z</wsu:Created>\
+</wsu:Timestamp>");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+ HBufC8* pTimeStamp;
+ pWsSecHeader->TimestampL(KCreated, pTimeStamp);
+ CleanupStack::PushL(pTimeStamp);
+ if(!( *pTimeStamp == KTimeStamp )) return KErrArgument;
+ CleanupStack::PopAndDestroy(pTimeStamp);
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_XmlNsL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KSecurityNamespace, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+ TPtrC8 nameSpace = pWsSecHeader->XmlNs();
+ if(!( nameSpace == KSecurityNamespace )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CnewsoapclassesTester::MT_CSenWsSecurityHeader2_XmlNsPrefixL( CStifItemParser& aItem )
+ {
+ SetupL();
+ _LIT8(KRootElementName, "RootElement");
+ _LIT8(KSecurityNamespacePrefix, "wsse");
+
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement rootElement = document.CreateDocumentElementL(KRootElementName());
+
+ CSenWsSecurityHeader2* pWsSecHeader = CSenWsSecurityHeader2::NewLC(document,
+ rootElement);
+ TPtrC8 prefix = pWsSecHeader->XmlNsPrefix();
+ if(!( prefix == KSecurityNamespacePrefix )) return KErrArgument;
+
+ CleanupStack::PopAndDestroy(pWsSecHeader);
+
+ CleanupStack::PopAndDestroy(1); // document
+ Teardown();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CnewsoapclassesTester::?member_function
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+/*
+TInt CnewsoapclassesTester::?member_function(
+ CItemParser& aItem )
+ {
+
+ ?code
+
+ }
+*/
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+// None
+
+// [End of File] - Do not remove