--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/websrv_pub/web_service_description_api/tsrc/bc/senservdesc/src/SenServDescCases.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,3145 @@
+/*
+* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: ?Description
+*
+*/
+
+
+// INCLUDE FILES
+#include <e32math.h>
+#include "SenServDescBCTest.h"
+#include <senxmlelement.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 LOCAL_ASSERT(expression) {if(!(expression)){return KErrArgument;}}
+
+//#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 ===============================
+
+// -----------------------------------------------------------------------------
+// CSenServDesc::Case
+// Returns a test case by number.
+//
+// This function contains an array of all available test cases
+// i.e pair of case name and test function. If case specified by parameter
+// aCaseNumber is found from array, then that item is returned.
+//
+// The reason for this rather complicated function is to specify all the
+// test cases only in one place. It is not necessary to understand how
+// function pointers to class member functions works when adding new test
+// cases. See function body for instructions how to add new test case.
+// -----------------------------------------------------------------------------
+//
+const TCaseInfo CSenServDesc::Case (
+ const TInt aCaseNumber ) const
+ {
+
+ /**
+ * To add new test cases, implement new test case function and add new
+ * line to KCases array specify the name of the case and the function
+ * doing the test case
+ * In practice, do following
+ * 1) Make copy of existing test case function and change its name
+ * and functionality. Note that the function must be added to
+ * SenServDesc.cpp file and to SenServDesc.h
+ * header file.
+ *
+ * 2) Add entry to following KCases array either by using:
+ *
+ * 2.1: FUNCENTRY or ENTRY macro
+ * ENTRY macro takes two parameters: test case name and test case
+ * function name.
+ *
+ * FUNCENTRY macro takes only test case function name as a parameter and
+ * uses that as a test case name and test case function name.
+ *
+ * Or
+ *
+ * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used
+ * only with OOM (Out-Of-Memory) testing!
+ *
+ * OOM_ENTRY macro takes five parameters: test case name, test case
+ * function name, TBool which specifies is method supposed to be run using
+ * OOM conditions, TInt value for first heap memory allocation failure and
+ * TInt value for last heap memory allocation failure.
+ *
+ * OOM_FUNCENTRY macro takes test case function name as a parameter and uses
+ * that as a test case name, TBool which specifies is method supposed to be
+ * run using OOM conditions, TInt value for first heap memory allocation
+ * failure and TInt value for last heap memory allocation failure.
+ */
+
+ static TCaseInfoInternal const KCases[] =
+ {
+ // To add new test cases, add new items to this array
+
+ // NOTE: When compiled to GCCE, there must be Classname::
+ // declaration in front of the method name, e.g.
+ // CSenServDesc::PrintTest. Otherwise the compiler
+ // gives errors.
+
+ // FUNCENTRY( CSenServDesc::PrintTest ),
+ // ENTRY( "Loop test", CSenServDesc::LoopTest ),
+ ENTRY("NewL - CSenCredential", CSenServDesc::MT_CSenCredential_NewLL),
+ ENTRY("NewLC - CSenCredential", CSenServDesc::MT_CSenCredential_NewLCL),
+ ENTRY("NewL - CSenCredential baseElement", CSenServDesc::MT_CSenCredential_NewL_1L),
+ ENTRY("NewLC - CSenCredential baseElement", CSenServDesc::MT_CSenCredential_NewLC_1L),
+ ENTRY("NewL - CSenCredential copy", CSenServDesc::MT_CSenCredential_NewL_2L),
+ ENTRY("NewLC - CSenCredential copy", CSenServDesc::MT_CSenCredential_NewLC_2L),
+ ENTRY("ValidUntil - CSenCredential ValidUntil", CSenServDesc::MT_CSenCredential_ValidUntilL),
+ ENTRY("SetValidUntil - CSenCredential SetValidUntil", CSenServDesc::MT_CSenCredential_SetValidUntilL),
+ //ENTRY("NewLC - CSenCredential Id", CSenServDesc::MT_CSenCredential_IdL),
+ ENTRY("StartElement - CSenCredential StartElement", CSenServDesc::MT_CSenCredential_StartElementLL),
+
+ ENTRY("NewL - CSenCredential2", CSenServDesc::MT_CSenCredential2_NewLL),
+ ENTRY("NewLC - CSenCredential2", CSenServDesc::MT_CSenCredential2_NewLCL),
+ ENTRY("NewL - CSenCredential2 baseElement", CSenServDesc::MT_CSenCredential2_NewL_1L),
+ ENTRY("NewLC - CSenCredential2 baseElement", CSenServDesc::MT_CSenCredential2_NewLC_1L),
+ ENTRY("NewL - CSenCredential2 ", CSenServDesc::MT_CSenCredential2_NewL_2L),
+ ENTRY("NewLC - CSenCredential2 ", CSenServDesc::MT_CSenCredential2_NewLC_2L),
+ ENTRY("NewL - CSenCredential2 copy", CSenServDesc::MT_CSenCredential2_NewL_3L),
+ ENTRY("NewLC - CSenCredential2 copy", CSenServDesc::MT_CSenCredential2_NewLC_3L),
+ ENTRY("NewL - CSenCredential2 document", CSenServDesc::MT_CSenCredential2_NewL_4L),
+ ENTRY("NewLC - CSenCredential2 document", CSenServDesc::MT_CSenCredential2_NewLC_4L),
+ ENTRY("Id - CSenCredential2 Id", CSenServDesc::MT_CSenCredential2_IdL),
+ ENTRY("ValidUntil - CSenCredential2 ValidUntil", CSenServDesc::MT_CSenCredential2_ValidUntilL),
+ ENTRY("SetValidUntil - CSenCredential2 SetValidUntil", CSenServDesc::MT_CSenCredential2_SetValidUntilL),
+ ENTRY("NewL - CSenFacet", CSenServDesc::MT_CSenFacet_NewLL),
+ ENTRY("NewL - CSenFacet copy", CSenServDesc::MT_CSenFacet_NewL_1L),
+ ENTRY("NewL - CSenFacet attribute", CSenServDesc::MT_CSenFacet_NewL_2L),
+ ENTRY("SetNameL - CSenFacet", CSenServDesc::MT_CSenFacet_SetNameLL),
+ ENTRY("SetTypeL - CSenFacet", CSenServDesc::MT_CSenFacet_SetTypeLL),
+ ENTRY("SetValueL - CSenFacet", CSenServDesc::MT_CSenFacet_SetValueLL),
+ ENTRY("Name - CSenFacet", CSenServDesc::MT_CSenFacet_NameL),
+ ENTRY("Type - CSenFacet", CSenServDesc::MT_CSenFacet_TypeL),
+ ENTRY("Value - CSenFacet", CSenServDesc::MT_CSenFacet_ValueL),
+ ENTRY("NewL - Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewL_L),
+ ENTRY("NewLC - Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewLCL),
+ ENTRY("NewL - Enpoint + Contract", CSenServDesc::MT_CSenIdentityProvider_NewL_1L),
+ ENTRY("NewLC - Enpoint + Contract", CSenServDesc::MT_CSenIdentityProvider_NewLC_1L),
+ ENTRY("NewL - Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewL_2L),
+ ENTRY("NewLC - Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewLC_2L),
+ ENTRY("NewL - ServiceID + Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewL_3L),
+ ENTRY("NewLC - ServiceID + Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewLC_3L),
+ ENTRY("AuthzID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_AuthzIDL),
+ ENTRY("AdvisoryAuthnID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL),
+ ENTRY("ProviderID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_ProviderIDL),
+ ENTRY("Password - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_PasswordL),
+ ENTRY("IMEI - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IMEIL),
+ ENTRY("UserName - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_UserNameL),
+ ENTRY("SetProviderID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL),
+ ENTRY("SetServiceID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL),
+ ENTRY("IsTrustedByL - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL),
+ ENTRY("IsTrustedByL1 - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L),
+ ENTRY("HttpCredentialsL - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL),
+ ENTRY("IsDefault - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IsDefaultL),
+
+ ENTRY("NewElementName - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_NewElementNameL),
+ ENTRY("NewL - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL),
+ ENTRY("NewLC - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL),
+ ENTRY("NewL - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L),
+ ENTRY("NewLC - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L),
+ ENTRY("IsStrict - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL),
+ ENTRY("SetStrict - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL),
+ ENTRY("NewL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLL),
+ ENTRY("NewLC - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLCL),
+ ENTRY("NewL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewL_1L),
+ ENTRY("NewLC - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLC_1L),
+ ENTRY("NewL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewL_2L),
+ ENTRY("NewLC - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLC_2L),
+ ENTRY("MatchesL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_MatchesL),
+ ENTRY("SetConsumerIapIdL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL),
+ ENTRY("ConsumerIapId - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL),
+ ENTRY("SetConsumerSnapId - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL),
+ ENTRY("ConsumerSnapId - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL),
+ ENTRY("SetConsumerIdentityProviderIdsL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL),
+ ENTRY("ConsumerPolicyAsXmlL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL),
+ ENTRY("StartElementL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_StartElementLL),
+
+
+ ENTRY("AddConsumerIdentityProviderIdL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL),
+ ENTRY("ConsumerIdentityProviderIds8L - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL),
+ ENTRY("AcceptsConsumerPolicy - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL),
+ ENTRY("RebuildFromConsumerPolicy - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL),
+ ENTRY("NewL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLL),
+ ENTRY("NewLC - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLCL),
+ ENTRY("NewL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L),
+ ENTRY("NewLC - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L),
+ ENTRY("NewL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L),
+ ENTRY("NewLC - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L),
+ ENTRY("SetFrameworkIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL),
+ ENTRY("NewElementName - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL),
+ ENTRY("SetIapIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL),
+ ENTRY("IapId - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_IapIdL),
+ ENTRY("SetSnapIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL),
+ ENTRY("SnapId - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL),
+ ENTRY("SetIdentityProviderIdsL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL),
+ ENTRY("AddIdentityProviderIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL),
+ ENTRY("RebuildFrom - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL),
+ ENTRY("IdentityProviderIds8L - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL),
+ ENTRY("Accepts - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL),
+ ENTRY("DescriptionClassType - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL),
+ ENTRY("MatchesL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_MatchesL),
+ ENTRY("SetProviderIDL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL),
+ ENTRY("SetPolicyLL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL),
+ ENTRY("SetPolicyL_1L - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L),
+ ENTRY("SetPolicyL_2L - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L),
+ ENTRY("Contract - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_ContractL),
+ ENTRY("HasFacetL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL),
+ ENTRY("FacetValue - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL),
+ ENTRY("AddFacetL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL),
+ ENTRY("SetFacetL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL),
+ ENTRY("RemoveFacet - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL),
+ ENTRY("FacetsL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL),
+ ENTRY("ScoreMatchL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL),
+ ENTRY("Endpoint - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_EndpointL),
+ ENTRY("FrameworkId - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL),
+ ENTRY("FrameworkVersion - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL),
+ ENTRY("SetContractL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL),
+ ENTRY("SetEndPointL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL),
+ ENTRY("SetAttributesL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL),
+ ENTRY("AsXmlL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL),
+ ENTRY("WriteAsXMLToL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL),
+ ENTRY("AsXmlUnicodeL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL),
+ ENTRY("Credentials - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL),
+
+ ENTRY("HasEqualPrimaryKeysL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL),
+ ENTRY("IsLocalL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL),
+ ENTRY("SetTransportCueL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL),
+ ENTRY("TransportCue - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL),
+ //ENTRY("ServicePolicy - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL),
+ ENTRY("ProviderId - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL),
+ ENTRY("SetPromptUserInfoL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL),
+ ENTRY("PromptUserInfo - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL),
+ ENTRY("StartElementL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL),
+ ENTRY("CopyFromLL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL),
+
+ // Example how to use OOM functionality
+ //OOM_ENTRY( "Loop test with OOM", CSenServDesc::LoopTest, ETrue, 2, 3),
+ //OOM_FUNCENTRY( CSenServDesc::PrintTest, ETrue, 1, 3 ),
+ };
+
+ // Verify that case number is valid
+ if( (TUint) aCaseNumber >= sizeof( KCases ) /
+ sizeof( TCaseInfoInternal ) )
+ {
+ // Invalid case, construct empty object
+ TCaseInfo null( (const TText*) L"" );
+ null.iMethod = NULL;
+ null.iIsOOMTest = EFalse;
+ null.iFirstMemoryAllocation = 0;
+ null.iLastMemoryAllocation = 0;
+ return null;
+ }
+
+ // Construct TCaseInfo object and return it
+ TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );
+ tmp.iMethod = KCases[ aCaseNumber ].iMethod;
+ tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;
+ tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;
+ tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;
+ return tmp;
+
+ }
+
+// METHODS
+
+
+
+void CSenServDesc::SetupL( )
+ {
+
+ }
+
+void CSenServDesc::Teardown( )
+ {
+
+ }
+TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseFragment &fragment){
+ HBufC16* xmlBuffer = fragment.AsElement().AsXmlUnicodeL();//Parent()->
+ CleanupStack::PushL( xmlBuffer );
+ TPtr16 ptr = xmlBuffer->Des();
+ if (ptr.Length() > 0){
+ RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
+ }
+ else
+ RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
+ return ptr;
+}
+TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseElement &element){
+ HBufC16* xmlBuffer = element.AsXmlUnicodeL();//Parent()->
+ CleanupStack::PushL( xmlBuffer );
+ TPtr16 ptr = xmlBuffer->Des();
+ if (ptr.Length() > 0){
+ RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
+ }
+ else
+ RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
+ return ptr;
+}
+
+TInt CSenServDesc::MT_CSenCredential_NewLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);
+ TL(senCredential != (CSenCredential*)NULL);
+
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ //checking xml
+ TL(ConvertToPtr16LC(*senCredential) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+
+ senCredential = NULL;
+
+ {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ attributeArray.Reset();
+ attributeArray.Close();
+
+ Teardown();
+ return KErrNone;
+ }
+
+
+
+
+TInt CSenServDesc::MT_CSenCredential_NewLCL( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray);
+ TL(senCredential != (CSenCredential*)NULL);
+
+ //checking xml
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ TL(ConvertToPtr16LC(*senCredential) == KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential_NewL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenBaseElement* senBaseElement = CSenBaseElement::NewL(KText);
+ CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray, *senBaseElement);
+ TL(senCredential != (CSenCredential*)NULL);
+
+ //checking xml, parent we will not see so ref the same as previous NewL ctr
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ TL(ConvertToPtr16LC(*senCredential) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete senBaseElement;
+ senBaseElement = NULL;
+
+ senBaseElement = CSenBaseElement::NewL(KText);
+ {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
+
+ delete senBaseElement;
+ senBaseElement = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential_NewLC_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenBaseElement* senBaseElement = CSenBaseElement::NewL(KText);
+ CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray, *senBaseElement);
+ TL(senCredential != (CSenCredential*)NULL);
+
+ //checking xml, parent we will not see so ref the same as previous Newl ctr
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ TL(ConvertToPtr16LC(*senCredential)== KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete senBaseElement;
+ senBaseElement = NULL;
+
+ senBaseElement = CSenBaseElement::NewL(KText);
+ {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
+
+ delete senBaseElement;
+ senBaseElement = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential_NewL_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);
+
+ senCredential = CSenCredential::NewL(*orgSenCredential);
+
+ //checking xml
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ TL(ConvertToPtr16LC(*senCredential) == KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ TL(senCredential != (CSenCredential*)NULL);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete orgSenCredential;
+ orgSenCredential = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential_NewLC_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);
+
+ senCredential = CSenCredential::NewLC(*orgSenCredential);
+ TL(senCredential != (CSenCredential*)NULL);
+
+ //checking xml
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ TL(ConvertToPtr16LC(*senCredential) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete orgSenCredential;
+ orgSenCredential = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential_ValidUntilL( TTestResult& aResult )
+ {
+ SetupL();
+ RAttributeArray attributes;
+ CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributes);
+ TTime time;
+ _LIT(KTimeString1,"23:34.56");
+ time.Parse(KTimeString1);
+ /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/
+ __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));
+ LOCAL_ASSERT(senCredential->ValidUntil() == time);
+
+ /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */
+ __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil());
+
+ //checking xml
+ //_LIT16(KRef, "<text xmlns=\"text\" some valid stuff/>");
+ //_LIT16(KRef, "<text xmlns=\"text\" >");
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/
+ TL(ConvertToPtr16LC(*senCredential) == KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ delete senCredential;
+ senCredential = NULL;
+ attributes.Reset();
+ attributes.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential_SetValidUntilL( TTestResult& aResult )
+ {
+ return MT_CSenCredential_ValidUntilL(aResult);
+ }
+TInt CSenServDesc::MT_CSenCredential_StartElementLL(TTestResult& aResult)
+ {
+ /*
+ _LIT8(KCredential, "<Credentials CredentialsMaxID=\"1\">
+ <CredentialContainer>
+ <Identifier><garbage>1</garbage><Endpoint>http://10.21.32.20/WSStar/CredMan/WSService.aspx</Endpoint><ProviderID>provider01</ProviderID></Identifier>
+ <Properties>
+ <ServiceInterval>-60540625</ServiceInterval><ValidUntil>2020-06-19T10:28:31.000000Z</ValidUntil>
+ <Created>2007-06-18T10:23:52Z</Created><PhoneTimeWhenMTResolved>2007-06-18T10:24:52.504375Z</PhoneTimeWhenMTResolved>
+ <POP>cnqlXcxDmY4h4tjbgNssLMwhCkOnc+4c</POP>
+ <TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</TokenType>\
+ <BinaryType>simmetric</BinaryType>
+ </Properties></CredentialContainer></Credentials>");
+ */
+
+ _LIT8(KCredential, "<Credentials CredentialsMaxID=\"1\">\
+ </Credentials>");
+
+ RAttributeArray attributes;
+ CSenCredential* pCredential = CSenCredential::NewL(_L8(""),_L8("Credentials"),_L8("Credentials"),attributes);
+ CleanupStack::PushL(pCredential);
+ CSenXmlReader *pXmlReader = CSenXmlReader::NewL();
+ CleanupStack::PushL(pXmlReader);
+ pCredential->SetReader(*pXmlReader );
+ TRAPD(retVal,pCredential->ParseL(KCredential));
+ CleanupStack::PopAndDestroy(pXmlReader);
+ CleanupStack::PopAndDestroy(pCredential);
+ return retVal;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential2_NewLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenCredential2* senCredential = CSenCredential2::NewL();
+ TL(senCredential != (CSenCredential2*)NULL);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+
+ senCredential = NULL;
+
+
+ Teardown();
+ return KErrNone;
+ }
+
+
+
+
+TInt CSenServDesc::MT_CSenCredential2_NewLCL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenCredential2* senCredential = CSenCredential2::NewLC();
+ TL(senCredential != (CSenCredential2*)NULL);
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+
+ senCredential = NULL;
+
+ //CleanupStack::PopAndDestroy();
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential2_NewL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
+ TL(senCredential != (CSenCredential2*)NULL);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential2_NewLC_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray);
+ TL(senCredential != (CSenCredential2*)NULL);
+
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ //CleanupStack::PopAndDestroy();
+
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential2_NewL_2L( TTestResult& aResult )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ RAttributeArray attributeArray;
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray, bodyElement);
+ TL(senCredential != (CSenCredential2*)NULL);
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ CleanupStack::PopAndDestroy(1);
+
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential2_NewLC_2L( TTestResult& aResult )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ RAttributeArray attributeArray;
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray, bodyElement);
+ TL(senCredential != (CSenCredential2*)NULL);
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ CleanupStack::PopAndDestroy(1);
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential2_NewL_3L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential2 *senCredential;
+ CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
+ senCredential = CSenCredential2::NewL(*orgSenCredential);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete orgSenCredential;
+ orgSenCredential = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential2_NewLC_3L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential2 *senCredential;
+ CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
+ senCredential = CSenCredential2::NewLC(*orgSenCredential);
+ TL(senCredential != (CSenCredential2*)NULL);
+
+
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete orgSenCredential;
+ orgSenCredential = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential2_NewL_4L( TTestResult& aResult )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ RAttributeArray attributeArray;
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray, bodyElement, document);
+ TL(senCredential != (CSenCredential2*)NULL);
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ CleanupStack::PopAndDestroy(1);
+
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential2_NewLC_4L( TTestResult& aResult )
+ {
+ SetupL();
+ _LIT8(KBodyElementName, "BodyElement");
+ RAttributeArray attributeArray;
+ RSenDocument document = RSenDocument::NewLC();
+ TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
+ CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray, bodyElement, document);
+ TL(senCredential != (CSenCredential2*)NULL);
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ CleanupStack::PopAndDestroy(1);
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential2_IdL( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenCredential2 *senCredential;
+ CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
+ senCredential = CSenCredential2::NewL(*orgSenCredential);
+ senCredential->Id();
+ TL(senCredential != (CSenCredential2*)NULL);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
+ senCredential = NULL;
+ delete orgSenCredential;
+ orgSenCredential = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenCredential2_ValidUntilL( TTestResult& aResult )
+ {
+ SetupL();
+ RAttributeArray attributes;
+ CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributes);
+ TTime time;
+ _LIT(KTimeString1,"23:34.56");
+ time.Parse(KTimeString1);
+ /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/
+ __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));
+ LOCAL_ASSERT(senCredential->ValidUntil() == time);
+
+ /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */
+ __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil());
+
+ //checking xml
+ //_LIT16(KRef, "<text xmlns=\"text\" some valid stuff/>");
+ //_LIT16(KRef, "<text xmlns=\"text\" >");
+ //_LIT16(KRef, "<text xmlns=\"text\"/>");
+ /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/
+ //TL(ConvertToPtr16LC(*senCredential) == KRef);
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ delete senCredential;
+ senCredential = NULL;
+ attributes.Reset();
+ attributes.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenCredential2_SetValidUntilL( TTestResult& aResult )
+ {
+ return MT_CSenCredential2_ValidUntilL(aResult);
+ }
+
+
+TInt CSenServDesc::MT_CSenFacet_NewLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenFacet* senFacet = CSenFacet::NewL();
+ TL(senFacet != (CSenFacet*)NULL);
+
+ //checking xml
+ _LIT16(KRef, "<Facet/>");
+ TL(ConvertToPtr16LC(*senFacet) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenFacet_NewL_1L(TTestResult& aResult)
+ {
+ SetupL();
+
+ CSenFacet *senFacet;
+ CSenFacet *senFacetOrg = CSenFacet::NewL();
+
+ senFacet = CSenFacet::NewL(*senFacetOrg);
+ TL(senFacet != (CSenFacet*)NULL);
+
+ //checking xml
+ _LIT16(KRef, "<Facet/>");
+ TL(ConvertToPtr16LC(*senFacet) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ delete senFacetOrg;
+ senFacetOrg = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenFacet_NewL_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ RAttributeArray attributeArray;
+ CSenFacet* senFacet = CSenFacet::NewL(KText, KText, KText, attributeArray);
+ TL(senFacet != (CSenFacet*)NULL);
+
+ //checking xml
+ _LIT16(KRef, "<text xmlns=\"text\"/>");
+ TL(ConvertToPtr16LC(*senFacet) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+
+ {TRAPD(err, CSenFacet::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenFacet::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenFacet::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
+
+ {TRAPD(err, CSenFacet::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenFacet::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ {TRAPD(err, CSenFacet::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
+
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenFacet_SetNameLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenFacet* senFacet = CSenFacet::NewL();
+ if(!(senFacet->Name() == KNullDesC8))return KErrArgument;
+
+ senFacet->SetNameL(KText);
+ if(!(senFacet->Name() == KText))return KErrArgument;
+
+ //checking xml
+ _LIT16(KRef, "<Facet name=\"text\"/>");
+ TL(ConvertToPtr16LC(*senFacet) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ if(!(senFacet->Name() == KText))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenFacet_SetTypeLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenFacet* senFacet = CSenFacet::NewL();
+ if(!(senFacet->Type() == KNullDesC8))return KErrArgument;
+
+ senFacet->SetTypeL(KText);
+ if(!(senFacet->Type() == KText))return KErrArgument;
+
+ //checking xml
+ _LIT16(KRef, "<Facet type=\"text\"/>");
+ TL(ConvertToPtr16LC(*senFacet) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ if(!(senFacet->Type() == KText))return KErrArgument;
+
+ delete senFacet;
+ senFacet = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenFacet_SetValueLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenFacet* senFacet = CSenFacet::NewL();
+ if(!(senFacet->Value() == KNullDesC8))return KErrArgument;
+
+ senFacet->SetValueL(KText);
+ if(!(senFacet->Value() == KText))return KErrArgument;
+
+
+ //checking xml
+ _LIT16(KRef, "<Facet>text</Facet>");
+ TL(ConvertToPtr16LC(*senFacet) == KRef);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+ if(!(senFacet->Value() == KText))return KErrArgument;
+
+ delete senFacet;
+ senFacet = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenFacet_NameL( TTestResult& aResult )
+ {
+ return MT_CSenFacet_SetNameLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenFacet_TypeL( TTestResult& aResult )
+ {
+ return MT_CSenFacet_SetTypeLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenFacet_ValueL( TTestResult& aResult )
+ {
+ return MT_CSenFacet_SetValueLL(aResult);
+ }
+TInt CSenServDesc::MT_CSenIdentityProvider_NewL_L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ /*EUNIT_ASSERT_NOT_EQUALS(idProvider, (CSenIdentityProvider*)NULL);*/
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
+ /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*idProvider), KRef);*/
+ TL(ConvertToPtr16LC(*idProvider) == KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+
+ /*__ASSERT_ALWAYS_NO_LEAVE(delete idProvider);*/
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+
+ }
+
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewLCL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
+
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewL_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText, KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewL_3L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText, KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID><ServiceID>text</ServiceID></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_3L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText, KText, KText);
+ TL(idProvider != (CSenIdentityProvider*)NULL);
+
+ //checking xml
+ //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID><ServiceID>text</ServiceID></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_AuthzIDL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ TL(idProvider->AuthzID() == KNullDesC8);
+
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->AuthzID());
+ idProvider->SetUserInfoL(KText2, KNullDesC8, KNullDesC8);
+ idProvider->SetUserInfoL(KText, KNullDesC8, KNullDesC8);
+
+ //checking xml
+ _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><AuthzID>text</AuthzID></IdentityProvider>");
+
+ TPtr16 ptr = ConvertToPtr16LC(*idProvider);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<AuthzID>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ TL(idProvider->AuthzID() == KText);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ TL(idProvider->AdvisoryAuthnID() == KNullDesC8);
+
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->AdvisoryAuthnID());
+ idProvider->SetUserInfoL(KNullDesC8, KText2, KNullDesC8);
+ idProvider->SetUserInfoL(KNullDesC8, KText, KNullDesC8);
+
+ //checking xml
+ _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><AdvisoryAuthnID>text</AdvisoryAuthnID></IdentityProvider>");
+
+ // TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ TPtr16 ptr = ConvertToPtr16LC(*idProvider);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<AdvisoryAuthnID>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ TL(idProvider->AdvisoryAuthnID() == KText);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_ProviderIDL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText2);
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->ProviderID());
+ TL(idProvider->ProviderID() == KText2);
+
+ delete idProvider;
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_PasswordL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->Password());
+ TL(idProvider->Password() == KNullDesC8);
+
+ idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText2);
+ idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText);
+ //checking xml
+ _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><Password>text</Password></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ TPtr16 ptr = ConvertToPtr16LC(*idProvider);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Password>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ TL(idProvider->Password() == KText);
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_IMEIL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->IMEI());
+ idProvider->IMEI();
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_UserNameL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->UserName());
+ TL(idProvider->UserName() == KNullDesC8);
+
+ idProvider->SetUserInfoL(KNullDesC8, KText, KNullDesC8);
+ TL(idProvider->UserName()== KText);
+
+ idProvider->SetUserInfoL(KText, KNullDesC8, KNullDesC8);
+ TL(idProvider->UserName() == KText);
+
+ idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetProviderID(KText2));
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetProviderID(KText));
+ //checking xml
+ _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+ TPtr16 ptr = ConvertToPtr16LC(*idProvider);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<ProviderID>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetServiceID(KText2));
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetServiceID(KText));
+ //checking xml
+ _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><ServiceID>text</ServiceID></IdentityProvider>");
+ //TL(ConvertToPtr16LC(*idProvider) == KRef);
+
+ TPtr16 ptr = ConvertToPtr16LC(*idProvider);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<ServiceID>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CSenXmlServiceDescription* serviceDesc = CSenXmlServiceDescription::NewL(KText, KText2) ;
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(_L8("endpoint"), _L8("contract"), KText, KText2);
+ retVal = idProvider->IsTrustedByL(*serviceDesc);
+
+ if(retVal);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete serviceDesc);
+ serviceDesc = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(_L8("endpoint"), _L8("contract"), KText, KText2);
+ retVal = idProvider->IsTrustedByL(KText);
+
+ if(retVal);
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenIdentityProvider_IsDefaultL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ retVal = idProvider->IsDefault();
+
+ if(retVal);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+
+
+TInt CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ //retVal = idProvider->HttpCredentialsL();
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProvider_NewElementNameL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
+ TL(idProvider->NewElementName() == _L8("IdentityProvider"));
+
+ __ASSERT_ALWAYS_NO_LEAVE(idProvider->NewElementName());
+ __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
+ idProvider = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
+ TL(array->IsStrict() == FALSE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ array = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewLC();
+ TL(array->IsStrict() == FALSE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ CleanupStack::Pop();
+ array = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(FALSE);
+ TL(array->IsStrict() == FALSE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ array = NULL;
+
+ array = CSenIdentityProviderIdArray8::NewL(TRUE);
+ TL(array->IsStrict() == TRUE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ array = NULL;
+
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewLC(FALSE);
+ TL(array->IsStrict() == FALSE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ CleanupStack::Pop();
+ array = NULL;
+
+ array = CSenIdentityProviderIdArray8::NewLC(TRUE);
+ TL(array->IsStrict() == TRUE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ CleanupStack::Pop();
+ array = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
+ __ASSERT_ALWAYS_NO_LEAVE(array->SetStrict(TRUE));
+ TL(array->IsStrict() == TRUE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(array->SetStrict(FALSE));
+ TL(array->IsStrict() == FALSE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ array = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL( TTestResult& aResult )
+ {
+ return MT_CSenIdentityProviderIdArray8_IsStrictL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_NewLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_NewLCL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewLC();
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_NewL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL(KText);
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_NewLC_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewLC(KText);
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_NewL_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL(KText, KText);
+
+ //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_NewLC_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewLC(KText, KText);
+
+ //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_MatchesL( TTestResult& aResult )
+ {
+ SetupL();
+ CSenServicePattern *pattern2;
+ CSenServicePattern *pattern;
+
+ pattern = CSenServicePattern::NewL();
+ //EUNIT_ASSERT_EQUALS(pattern->Matches(*pattern2), FALSE);
+
+ pattern2 = CSenServicePattern::NewL();
+ //checking xml
+ TL(pattern->Matches(*pattern2) == TRUE);
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern2);
+ pattern2 = NULL;
+
+ CSenXmlServiceDescription* xmlDescr = CSenXmlServiceDescription::NewL();
+ TL(pattern->Matches(*xmlDescr) == FALSE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlDescr);
+ xmlDescr = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ //checking xml
+
+ TUint32 iap(0);
+ TL(pattern->ConsumerIapId(iap) == KErrNotFound);
+
+
+ pattern->SetConsumerIapIdL(1);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerIapId(iap));
+ TL(pattern->ConsumerIapId(iap) == KErrNone);
+
+ TL(iap == 1);
+ pattern->SetConsumerIapIdL(2);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerIapId(iap));
+ TL(pattern->ConsumerIapId(iap) == KErrNone);
+
+ TL(iap == 2);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL( TTestResult& aResult )
+ {
+ SetupL();
+
+ MT_CSenServicePattern_SetConsumerIapIdLL(aResult);
+ Teardown();
+ return KErrNone;
+ }
+TInt CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ //checking xml
+
+ TUint32 iap(0);
+ TL(pattern->ConsumerSnapId(iap) == KErrNotFound);
+
+
+ pattern->SetConsumerSnapIdL(1);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerSnapId(iap));
+ TL(pattern->ConsumerSnapId(iap) == KErrNone);
+
+ TL(iap == 1);
+
+ pattern->SetConsumerSnapIdL(0);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerSnapId(iap));
+ TL(pattern->ConsumerSnapId(iap) == KErrNotFound);
+
+ // TL(iap == 0);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL( TTestResult& aResult )
+ {
+
+ SetupL();
+
+ MT_CSenServicePattern_SetConsumerSnapIdLL(aResult);
+ Teardown();
+
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
+ pattern->AddConsumerIdentityProviderIdL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
+ array->AppendL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
+ array->AppendL(KText2);
+ __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
+
+ TL((pattern->ConsumerIdentityProviderIds8L()).Count() == 2);
+
+ TInt pos(0);
+ if(!((pattern->ConsumerIdentityProviderIds8L()).Find(KText, pos)==KErrNone))return KErrArgument;
+
+ if(!((pattern->ConsumerIdentityProviderIds8L()).Find(KText2, pos)==KErrNone))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ array = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+
+
+ if(!(pattern->AddConsumerIdentityProviderIdL(KNullDesC8) == KErrArgument))return KErrArgument;
+
+ if(!(pattern->AddConsumerIdentityProviderIdL(KText) == KErrNone))return KErrArgument;
+
+ if(!(pattern->AddConsumerIdentityProviderIdL(KText) == KErrAlreadyExists))return KErrArgument;
+
+ if(!(pattern->AddConsumerIdentityProviderIdL(KText2) == KErrNone))return KErrArgument;
+
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*pattern) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL( TTestResult& aResult )
+ {
+ return MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
+
+ pattern->SetConsumerIapIdL(1);
+ array->AppendL(KText);
+
+ CSenServicePattern* pattern2 = CSenServicePattern::NewL();
+ if(!(pattern2->RebuildFromConsumerPolicy(*pattern)==KErrNone))return KErrArgument;
+
+ if(!(pattern2->AcceptsConsumerPolicy(*pattern)==TRUE))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern2);
+ array = NULL;
+ pattern2 = NULL;
+//false
+ pattern2 = CSenServicePattern::NewL();
+ pattern2->SetConsumerIapIdL(2);
+ if(!(pattern2->AcceptsConsumerPolicy(*pattern)==FALSE))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern2);
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern2 = NULL;
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL( TTestResult& aResult )
+ {
+ return MT_CSenServicePattern_AcceptsConsumerPolicyL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL( TTestResult& aResult )
+ {
+ SetupL();
+ HBufC8* retVal;
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+
+ retVal = pattern->ConsumerPolicyAsXmlL();
+
+ if(retVal);
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenServicePattern_StartElementLL( TTestResult& aResult )
+ {
+ SetupL();
+ //HBufC8* retVal;
+ _LIT8(KText, "text");
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ RAttributeArray array;
+ pattern->StartElementL(KText, KText, KText, array);
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ if(xmlService == NULL)
+ return KErrNoMemory;
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLCL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC();
+ if(xmlService == NULL)
+ return KErrNoMemory;
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText);
+ if(xmlService == NULL)
+ return KErrNoMemory;
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(KText);
+ if(xmlService == NULL)
+ return KErrNoMemory;
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ if(xmlService == NULL)
+ return KErrNoMemory;
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(KText, KText);
+ if(xmlService == NULL)
+ return KErrNoMemory;
+ //checking xml
+ //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ CleanupStack::Pop();
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+
+ TL(xmlService->FrameworkId() == KNullDesC8);
+
+ _LIT8(KFr, "ID-WSF");
+ xmlService->SetFrameworkIdL(KFr);
+ //checking xml
+ _LIT16(KRef1, "<ServiceDescription framework=\"ID-WSF\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef1);
+
+ TPtr16 ptr = ConvertToPtr16LC(*xmlService);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("framework=\"ID-WSF\""));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+ TL(xmlService->FrameworkId() == KFr);
+
+ //again
+ xmlService->SetFrameworkIdL(KFr);
+ //checking xml
+ //_LIT16(KRef2, "<ServiceDescription framework=\"ID-WSF\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef2);
+
+ TPtr16 ptr1 = ConvertToPtr16LC(*xmlService);
+ posId = -1;
+ messageToParse.Set(ptr1);
+ posId = messageToParse.Find(_L("framework=\"ID-WSF\""));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr1
+ TL(xmlService->FrameworkId() == KFr);
+
+ //again
+ xmlService->SetFrameworkIdL(KText);
+ //checking xml
+ //_LIT16(KRef3, "<ServiceDescription framework=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef3);
+ TPtr16 ptr2 = ConvertToPtr16LC(*xmlService);
+ posId =-1;
+ messageToParse.Set(ptr2);
+ posId = messageToParse.Find(_L("framework=\"text\""));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr2
+ TL(xmlService->FrameworkId() == KText);
+
+ //clear
+ xmlService->SetFrameworkIdL(KNullDesC8);
+ //checking xml
+ //_LIT16(KRef4, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef4);
+ TPtr16 ptr3 = ConvertToPtr16LC(*xmlService);
+ posId = -1;
+ messageToParse.Set(ptr3);
+ posId = messageToParse.Find(_L("ServiceDescription"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr3
+ TL(xmlService->FrameworkId() == KNullDesC8);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ _LIT8(KRef, "ServiceDescription");
+ if(!(xmlService ->NewElementName() == KRef))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ TUint32 iap(0);
+ if(!((xmlService ->IapId(iap)) == KErrNotFound))return KErrArgument;
+
+ xmlService ->SetIapIdL(1);
+ if(!(xmlService ->IapId(iap) == KErrNone))return KErrArgument;
+
+ if(!(1))return KErrArgument;
+
+ xmlService ->SetIapIdL(2);
+ if(!(xmlService ->IapId(iap) == KErrNone))return KErrArgument;
+
+ if(!(2))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_IapIdL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_SetIapIdLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ TUint32 iap(0);
+ if(!((xmlService ->SnapId(iap)) == KErrNotFound))return KErrArgument;
+
+ xmlService ->SetSnapIdL(1);
+ if(!(xmlService ->SnapId(iap) == KErrNone))return KErrArgument;
+
+ if(!(1))return KErrArgument;
+
+ xmlService ->SetSnapIdL(2);
+ if(!(xmlService ->SnapId(iap) == KErrNone))return KErrArgument;
+
+ if(!(2))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_SetSnapIdLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
+
+
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
+
+ TPtrC8 ptrText = KText();
+ xmlService->AddIdentityProviderIdL(ptrText);
+
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
+ array->AppendL(KText);
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
+ array->AppendL(KText2);
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
+
+ TL((xmlService->IdentityProviderIds8L()).Count() == 2);
+
+ TInt pos(0);
+ if(!((xmlService->IdentityProviderIds8L()).Find(KText, pos)==KErrNone))return KErrArgument;
+
+ if(!((xmlService->IdentityProviderIds8L()).Find(KText2, pos)==KErrNone))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ array = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ TPtrC8 ptr = KNullDesC8();
+ if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrArgument))return KErrArgument;
+
+ ptr.Set(KText);
+ if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrNone))return KErrArgument;
+
+ if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrAlreadyExists))return KErrArgument;
+
+ ptr.Set(KText2);
+ if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrNone))return KErrArgument;
+
+
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy><IdentityProviderIDs><IdentityProviderID>text</IdentityProviderID><IdentityProviderID>text2</IdentityProviderID></IdentityProviderIDs></ProviderPolicy><ServicePolicy/></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
+
+ xmlService->SetIapIdL(1);
+ array->AppendL(KText);
+
+ CSenXmlServiceDescription* xmlService2 = CSenXmlServiceDescription::NewL();
+ if(!(xmlService2->RebuildFrom(*xmlService)==KErrNone))return KErrArgument;
+
+ if(!(xmlService2->Accepts(*xmlService)==TRUE))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete array);
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ array = NULL;
+ xmlService2 = NULL;
+//false
+ xmlService2 = CSenServicePattern::NewL();
+ xmlService2->SetIapIdL(2);
+ if(!(xmlService2->Accepts(*xmlService)==FALSE))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService2 = NULL;
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_RebuildFromL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ if(!(xmlService ->DescriptionClassType() == MSenServiceDescription::EXmlServiceDescription))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_MatchesL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription *xmlService;
+ CSenXmlServiceDescription *xmlService2(NULL);
+
+ xmlService = CSenXmlServiceDescription::NewL();
+ //EUNIT_ASSERT_EQUALS(xmlService->Matches(*xmlService2), FALSE);
+
+ xmlService2 = CSenXmlServiceDescription::NewL();
+ //checking xml
+ TL(xmlService ->Matches(*xmlService2) == TRUE);
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ xmlService2 = NULL;
+
+ CSenServicePattern* pattern = CSenServicePattern::NewL();
+ //EUNIT_ASSERT_EQUALS(xmlService->Matches(*pattern), FALSE);
+ TL(xmlService->Matches(*pattern) == TRUE);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
+ pattern = NULL;
+ Teardown();
+ return KErrNone;
+
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetProviderIdL(KText2));
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetProviderIdL(KText));
+
+ //checking xml
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></ServiceDescription>");
+ TL(ConvertToPtr16LC(*xmlService)== KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ LOCAL_ASSERT(xmlService->SetPolicyL(KText) == KErrNone);
+ LOCAL_ASSERT(xmlService->SetPolicyL(_L8("")) == KErrArgument);
+
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text/></ClientPolicy></ServicePolicy></ServiceDescription>");
+ TL(ConvertToPtr16LC(*xmlService)== KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ LOCAL_ASSERT(xmlService->SetPolicyL(KText, KText) == KErrNone);
+ LOCAL_ASSERT(xmlService->SetPolicyL(_L8(""), KText) == KErrArgument);
+
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text>text</text></ClientPolicy></ServicePolicy></ServiceDescription>");
+ TL(ConvertToPtr16LC(*xmlService)== KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ LOCAL_ASSERT(xmlService->SetPolicyL(KText, KText, KText, KText) == KErrNone);
+ LOCAL_ASSERT(xmlService->SetPolicyL(_L8(""), _L8(""), KText, KText) == KErrArgument);
+
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text text=\"text\">text</text></ClientPolicy></ServicePolicy></ServiceDescription>");
+ TL(ConvertToPtr16LC(*xmlService)== KRef);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_ContractL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ xmlService ->SetContractL(KText);
+ //checking xml
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Contract>text</Contract></ServiceDescription>");
+
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+ TPtr16 ptr = ConvertToPtr16LC(*xmlService);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Contract>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+ TL(xmlService->Contract() == KText);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ //2nd time
+ xmlService ->SetContractL(KText);
+ //checking xml
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+ ptr = ConvertToPtr16LC(*xmlService);
+ posId = -1;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Contract>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+ TL(xmlService->Contract() == KText);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ xmlService ->SetContractL(KText2);
+ //checking xml
+ _LIT16(KRef2, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Contract>text2</Contract></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef2);
+
+ TL(xmlService->Contract() == KText2);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+//================Facets
+TInt CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_RemoveFacetL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ CSenFacet* senFacet;
+ senFacet = CSenFacet::NewL();
+ senFacet->SetNameL(KText);
+ senFacet->SetValueL(KText2);
+
+
+ xmlService->AddFacetL(*senFacet);
+ TPtrC8 ptr=KText();
+ HBufC8* valueTo = NULL;
+
+ if(!(xmlService->FacetValue(ptr, valueTo)==KErrNone))return KErrArgument;
+
+ TL(*valueTo == KText2);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete valueTo );
+ valueTo = NULL;
+
+ if(!(xmlService->FacetValue(ptr, valueTo)==KErrNone))return KErrArgument;
+
+ TL(*valueTo == KText2);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete valueTo );
+ valueTo = NULL;
+
+ ptr.Set(KText2);
+ if(!(xmlService->FacetValue(ptr, valueTo)==KErrNotFound))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ CSenFacet *senFacet;
+ CSenFacet *senFacet2;
+
+ senFacet = CSenFacet::NewL();
+ senFacet2 = CSenFacet::NewL();
+ senFacet->SetNameL(KText);
+ senFacet2->SetNameL(KText2);
+ RFacetArray array;
+
+ if(!(xmlService->AddFacetL(*senFacet) == KErrNone))return KErrArgument;
+
+ if(!(xmlService->AddFacetL(*senFacet) == KErrAlreadyExists))return KErrArgument;
+
+ if(!(xmlService->AddFacetL(*senFacet2) == KErrNone))return KErrArgument;
+
+ //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Facet name=\"text\"/><Facet name=\"text2\"/></ServiceDescription>");
+ //TPtrC16 ptrRef = KRef();
+ //TL(ConvertToPtr16LC(*xmlService) == ptrRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ TPtr16 ptr = ConvertToPtr16LC(*xmlService);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Facet name=\"text\"/><Facet name=\"text2\"/>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
+
+ if(!(array.Count() == 2))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet2);
+ senFacet2 = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ array.ResetAndDestroy();
+ array.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ CSenFacet* senFacet;
+ senFacet = CSenFacet::NewL();
+ senFacet->SetNameL(KText);
+ senFacet->SetValueL(KText);
+
+ RFacetArray array;
+ if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument;
+
+ if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument;
+
+ senFacet->SetValueL(KText2);
+ if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument;
+
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Facet name=\"text\">text2</Facet></ServiceDescription>");
+ //TPtrC16 ptrRef = KRef();
+ //TL(ConvertToPtr16LC(*xmlService) == ptrRef);
+
+ //CleanupStack::PopAndDestroy();//Ptr
+ TPtr16 ptr = ConvertToPtr16LC(*xmlService);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Facet name=\"text\">text2</Facet>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
+
+ if(!(array.Count() == 1))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ array.ResetAndDestroy();
+ array.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ CSenFacet *senFacet;
+ CSenFacet *senFacet2;
+
+ senFacet = CSenFacet::NewL();
+ senFacet2 = CSenFacet::NewL();
+ senFacet->SetNameL(KText);
+ senFacet2->SetNameL(KText2);
+ RFacetArray array;
+
+
+ if(!(xmlService->AddFacetL(*senFacet) == KErrNone))return KErrArgument;
+
+ if(!(xmlService->AddFacetL(*senFacet) == KErrAlreadyExists))return KErrArgument;
+
+ if(!(xmlService->AddFacetL(*senFacet2) == KErrNone))return KErrArgument;
+
+ if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
+
+ if(!(array.Count() == 2))return KErrArgument;
+
+ array.ResetAndDestroy();
+//removing, haFacet
+ TBool has(FALSE);
+ if(!(xmlService->HasFacetL(KText, has) == KErrNone))return KErrArgument;
+
+ if(!(has == TRUE))return KErrArgument;
+
+ if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument;
+
+ if(!(has == TRUE))return KErrArgument;
+
+ if(!(xmlService->RemoveFacet(KText2) == KErrNone))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService->RemoveFacet(KText2));
+ if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument;
+
+ if(!(has == FALSE))return KErrArgument;
+
+ if(!(xmlService->RemoveFacet(KText2) == KErrNotFound))return KErrArgument;
+
+ if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument;
+
+ if(!(has == FALSE))return KErrArgument;
+
+ if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
+
+ if(!(array.Count() == 1))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet2);
+ senFacet2 = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ array.ResetAndDestroy();
+ array.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_AddFacetLL(aResult);
+ }
+//------------end facet
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL( TTestResult& aResult )
+ {
+ SetupL();
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+
+ HBufC8* xmlBuffer = xmlService->AsXmlL();
+ CleanupStack::PushL( xmlBuffer );
+ TPtr8 ptr = xmlBuffer->Des();
+ if (ptr.Length() > 0)
+ RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
+ else
+ RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
+ _LIT8(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ /*EUNIT_ASSERT_EQUALS(ptr, KRef);*/
+ //TL(ptr == KRef);
+ TInt posId(-1);
+ TPtrC8 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L8("<facet>"));
+ TL(posId == -1);
+ CleanupStack::PopAndDestroy(xmlBuffer);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ TBuf8<50> StreamBuf;
+ CSenBaseElement* pElement=CSenBaseElement::NewL(_L8("Nokia"));
+ CleanupStack::PushL(pElement);
+ pElement->AddElementL(_L8("webservices"));
+ RWriteStream& ElemntStream=pElement->ContentWriteStreamL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ CleanupStack::PushL(xmlService);
+ xmlService->WriteAsXMLToL(ElemntStream);
+
+ CleanupStack::PopAndDestroy(xmlService);
+ CleanupStack::PopAndDestroy(pElement);
+ Teardown();
+ return KErrNone ;
+ }
+
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL( TTestResult& aResult )
+ {
+ SetupL();
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ xmlService->Credentials();
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL( TTestResult& aResult )
+ {
+ SetupL();
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+
+ HBufC* xmlBuffer = xmlService->AsXmlUnicodeL();
+ CleanupStack::PushL( xmlBuffer );
+ TPtr ptr = xmlBuffer->Des();
+ if (ptr.Length() > 0)
+ RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
+ else
+ RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
+ _LIT(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
+ /*EUNIT_ASSERT_EQUALS(ptr, KRef);*/
+ TL(ptr == KRef);
+ CleanupStack::PopAndDestroy(xmlBuffer);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ xmlService->SetFrameworkIdL(KText);
+ CSenXmlServiceDescription* xmlService1= CSenXmlServiceDescription::NewL();
+
+ retVal = xmlService->HasEqualPrimaryKeysL(*xmlService);
+ //TL(retVal == ETrue)
+ if(retVal);
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService1);
+ xmlService1 = NULL;
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+
+ retVal = xmlService->IsLocalL();
+ //TL(retVal == ETrue)
+ if(retVal);
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+
+ retVal = xmlService->SetTransportCueL(KText);
+ if(!(retVal == 0)) return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL( TTestResult& aResult )
+ {
+ SetupL();
+ //TBool retVal;
+ //HBufC8* xmlBuffer;
+ //TPtrC8 ptr;
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ xmlService->SetTransportCueL(KText);
+ xmlService->TransportCue();
+ //ptr = xmBuffer.Desc(;)
+ //TL(ptr == KText);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+/*
+TInt CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;
+ CServicePolicy* policy = CSenServicePolicy::NewL();
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ policy = (CServicePolicy)xmlService->ServicePolicyL();
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+
+*/
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL( TTestResult& aResult )
+ {
+ SetupL();
+ //TBool retVal;
+ //TPtrC8 ptr;
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ xmlService->ProviderId();
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool var = ETrue;
+ TPtrC8 ptr;
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ xmlService->SetPromptUserInfoL(var);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL( TTestResult& aResult )
+ {
+ SetupL();
+ TBool retVal;;
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
+ retVal = xmlService->PromptUserInfo();
+
+ if(retVal);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+
+ Teardown();
+ return KErrNone ;
+ }
+TInt CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL(TTestResult& aResult)
+ {
+/*_LIT8(KServiceDescription, "<?xml version=\"1.0\" encoding=\"utf-8\" ?> <a:Test character=\""\" xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
+<Element2 z=\"value4\"><Content2"></Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+*/
+
+
+_LIT8(KServiceDescription, "<ServiceDescription framework=\"WS-STAR\">\
+ <Contract>urn:wstar:sts</Contract>\
+ <Endpoint>http://10.21.32.20/WSStar/BgRsp/STS.aspx</Endpoint>\
+ <ProviderID>provider01</ProviderID>\
+ </ServiceDescription>");
+/*
+ _LIT8(KServiceDescription, "<ServiceDescription framework=\"WS-STAR\">
+ <Contract>urn:wstar:sts</Contract>
+ <Endpoint>http://10.21.32.20/WSStar/BgRsp/STS.aspx</Endpoint>
+ <ProviderID>provider01</ProviderID>
+ <ProviderPolicy>
+ <Transport>
+ <IapId>
+ 1234567890
+ </IapId>
+ </Transport>
+ <IdentityProviderIDs strict=\"true\">
+ <IdentityProviderID>
+ urn:first.id.example.com
+ </IdentityProviderID>
+ <IdentityProviderID>
+ urn:second.id.example.com
+ </IdentityProviderID>
+ </IdentityProviderIDs>
+ </ProviderPolicy>
+ <Credentials CredentialsMaxID=\"1\">
+ <CredentialContainer>
+ <Identifier><garbage>1</garbage><Endpoint>http://10.21.32.20/WSStar/CredMan/WSService.aspx</Endpoint><ProviderID>provider01</ProviderID></Identifier>
+ <Properties>
+ <ServiceInterval>-60540625</ServiceInterval><ValidUntil>2020-06-19T10:28:31.000000Z</ValidUntil>
+ <Created>2007-06-18T10:23:52Z</Created><PhoneTimeWhenMTResolved>2007-06-18T10:24:52.504375Z</PhoneTimeWhenMTResolved>
+ <POP>cnqlXcxDmY4h4tjbgNssLMwhCkOnc+4c</POP>
+ <TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</TokenType>\
+ <BinaryType>simmetric</BinaryType>
+ </Properties></CredentialContainer></Credentials>
+ </ServiceDescription>");*/
+
+ CSenXmlServiceDescription* pDescription = CSenXmlServiceDescription::NewL(_L8("ServiceDescription"));
+ CleanupStack::PushL(pDescription);
+ CSenXmlReader *pXmlReader = CSenXmlReader::NewL();
+ CleanupStack::PushL(pXmlReader);
+ pDescription->SetReader(*pXmlReader );
+ TRAPD(retVal,pDescription->ParseL(KServiceDescription));
+ CleanupStack::PopAndDestroy(pXmlReader);
+ CleanupStack::PopAndDestroy(pDescription);
+ return retVal;
+ }
+
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription *xmlService;
+ CSenXmlServiceDescription *xmlService2;
+
+ xmlService = CSenXmlServiceDescription::NewL();
+ xmlService2 = CSenXmlServiceDescription::NewL();
+
+ if(!(xmlService->ScoreMatchL(*xmlService2) == 0))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ xmlService2 = NULL;
+//---------------
+ xmlService = CSenXmlServiceDescription::NewL(KText, KText2);
+ xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2);
+
+ if(!(xmlService->ScoreMatchL(*xmlService2) == 2))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ xmlService2 = NULL;
+//---------------
+ xmlService = CSenXmlServiceDescription::NewL(KText2, KText);
+ xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2);
+
+ if(!(xmlService->ScoreMatchL(*xmlService2) == 0))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ xmlService2 = NULL;
+//---------------
+ xmlService = CSenXmlServiceDescription::NewL(KText2, KText);
+ xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2);
+ CSenFacet* senFacet = CSenFacet::NewL();
+ senFacet->SetNameL(KText);
+ xmlService->AddFacetL(*senFacet);
+ xmlService2->AddFacetL(*senFacet);
+
+ if(!(xmlService->ScoreMatchL(*xmlService2) == 1))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
+ xmlService2 = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_EndpointL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+
+ xmlService ->SetEndPointL(KText);
+ //checking xml
+ _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Endpoint>text</Endpoint></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+
+ TL(xmlService->Endpoint() == KText);
+ TPtr16 ptr = ConvertToPtr16LC(*xmlService);
+ TInt posId(-1);
+ TPtrC16 messageToParse;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Endpoint>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ //2nd time
+ xmlService ->SetEndPointL(KText);
+ //checking xml
+ //TL(ConvertToPtr16LC(*xmlService) == KRef);
+ ptr = ConvertToPtr16LC(*xmlService);
+ posId = -1;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Endpoint>"));
+ TL(posId != -1);
+ TL(xmlService->Endpoint() == KText);
+
+ CleanupStack::PopAndDestroy();//Ptr
+
+
+ xmlService ->SetEndPointL(KText2);
+ //checking xml
+ _LIT16(KRef2, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Endpoint>text2</Endpoint></ServiceDescription>");
+ //TL(ConvertToPtr16LC(*xmlService) == KRef2);
+
+ TL(xmlService->Endpoint() == KText2);
+ ptr = ConvertToPtr16LC(*xmlService);
+ posId = -1;
+ messageToParse.Set(ptr);
+ posId = messageToParse.Find(_L("<Endpoint>"));
+ TL(posId != -1);
+ CleanupStack::PopAndDestroy();//Ptr
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_SetFrameworkIdLL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ __ASSERT_ALWAYS_NO_LEAVE(xmlService ->FrameworkVersion());
+ if(!(xmlService ->FrameworkVersion() == KNullDesC8))return KErrArgument;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_ContractL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL( TTestResult& aResult )
+ {
+ return MT_CSenXmlServiceDescription_EndpointL(aResult);
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL( TTestResult& aResult )
+ {
+ SetupL();
+
+ CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
+ RAttributeArray attributeArray;
+ xmlService->SetAttributesL(attributeArray);
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
+ xmlService = NULL;
+ attributeArray.Reset();
+ attributeArray.Close();
+ Teardown();
+ return KErrNone;
+ }
+
+TInt CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL( TTestResult& aResult )
+ {
+ SetupL();
+ _LIT8(KContent, "content");
+ _LIT8(KFacet, "Facet");
+
+ CSenFacet* senFacet = CSenFacet::NewL();
+ TL(senFacet != (CSenFacet*)NULL);
+
+ RStringPool stringPool;
+ stringPool.OpenL();
+ CleanupClosePushL(stringPool);
+
+ RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
+ CleanupClosePushL(nsUriRString);
+ RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
+ CleanupClosePushL(nsPrefixRString);
+ RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
+ CleanupClosePushL(localNameRString);
+ RString valueRString = stringPool.OpenStringL(_L8("Value"));
+ CleanupClosePushL(valueRString);
+
+ RAttribute attribute;
+ attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
+ valueRString);
+ CleanupStack::Pop(4);
+ CleanupClosePushL(attribute);
+
+ RAttributeArray attrArray;
+ attrArray.AppendL(attribute);
+ CleanupClosePushL(attrArray);
+
+ CSenXmlElement* xmlElem = CSenXmlElement::NewL(KText, KText, KText);
+ CSenXmlElement* xmlElem2 = CSenXmlElement::NewL(KText2);
+ xmlElem->AddElementL(*xmlElem2);
+ TL (xmlElem->SetContentL(KContent) == KContent);
+ xmlElem->SetAttributesL(attrArray);
+
+ senFacet->CopyFromL(*xmlElem);
+
+ TL (senFacet->LocalName() == KFacet);
+ TL (senFacet->NamespaceURI() == KNullDesC8);
+ TL (senFacet->NsPrefix() == KNullDesC8);
+ TL (senFacet->Content() == KContent);
+ RPointerArray<CSenElement>& xmlElemList = senFacet->ElementsL();
+ TL (xmlElemList.Count() == 1);
+ RPointerArray<CSenBaseAttribute>& xmlElemAttrList = senFacet->AttributesL();
+ TL (xmlElemAttrList.Count() == 1);
+
+ CleanupStack::PopAndDestroy(&attrArray);
+ CleanupStack::PopAndDestroy(&attribute);
+ CleanupStack::PopAndDestroy(&stringPool);
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete xmlElem);
+ xmlElem = NULL;
+
+ __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
+ senFacet = NULL;
+
+ Teardown();
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// ?classname::?member_function
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+/*
+?type ?classname::?member_function(
+ ?arg_type arg,
+ ?arg_type arg )
+ {
+
+ ?code
+
+ }
+*/
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+// -----------------------------------------------------------------------------
+// ?function_name implements...
+// ?implementation_description.
+// Returns: ?value_1: ?description
+// ?value_n: ?description
+// ?description
+// -----------------------------------------------------------------------------
+//
+/*
+?type ?function_name(
+ ?arg_type arg, // ?description
+ ?arg_type arg ) // ?description
+ {
+
+ ?code
+
+ }
+*/
+// End of File
+
+// End of File