websrv_pub/web_service_description_api/tsrc/bc/senservdesc/src/SenServDescCases.cpp
changeset 0 62f9d29f7211
child 23 a1df79fa35b4
equal deleted inserted replaced
-1:000000000000 0:62f9d29f7211
       
     1 /*
       
     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:        ?Description
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 // INCLUDE FILES
       
    20 #include <e32math.h>
       
    21 #include "SenServDescBCTest.h"
       
    22 #include <senxmlelement.h>
       
    23 
       
    24 // EXTERNAL DATA STRUCTURES
       
    25 //extern  ?external_data;
       
    26 
       
    27 // EXTERNAL FUNCTION PROTOTYPES  
       
    28 //extern ?external_function( ?arg_type,?arg_type );
       
    29 
       
    30 // CONSTANTS
       
    31 //const ?type ?constant_var = ?constant;
       
    32 
       
    33 // MACROS
       
    34 #define LOCAL_ASSERT(expression)	{if(!(expression)){return KErrArgument;}}
       
    35 
       
    36 //#define ?macro ?macro_def
       
    37 
       
    38 // LOCAL CONSTANTS AND MACROS
       
    39 //const ?type ?constant_var = ?constant;
       
    40 //#define ?macro_name ?macro_def
       
    41 
       
    42 // MODULE DATA STRUCTURES
       
    43 //enum ?declaration
       
    44 //typedef ?declaration
       
    45 
       
    46 // LOCAL FUNCTION PROTOTYPES
       
    47 //?type ?function_name( ?arg_type, ?arg_type );
       
    48 
       
    49 // FORWARD DECLARATIONS
       
    50 //class ?FORWARD_CLASSNAME;
       
    51 
       
    52 // ============================= LOCAL FUNCTIONS ===============================
       
    53 
       
    54 // -----------------------------------------------------------------------------
       
    55 // ?function_name ?description.
       
    56 // ?description
       
    57 // Returns: ?value_1: ?description
       
    58 //          ?value_n: ?description_line1
       
    59 //                    ?description_line2
       
    60 // -----------------------------------------------------------------------------
       
    61 //
       
    62 /*
       
    63 ?type ?function_name(
       
    64     ?arg_type arg,  // ?description
       
    65     ?arg_type arg)  // ?description
       
    66     {
       
    67 
       
    68     ?code  // ?comment
       
    69 
       
    70     // ?comment
       
    71     ?code
       
    72     }
       
    73 */
       
    74 
       
    75 // ============================ MEMBER FUNCTIONS ===============================
       
    76 
       
    77 // -----------------------------------------------------------------------------
       
    78 // CSenServDesc::Case
       
    79 // Returns a test case by number.
       
    80 //
       
    81 // This function contains an array of all available test cases 
       
    82 // i.e pair of case name and test function. If case specified by parameter
       
    83 // aCaseNumber is found from array, then that item is returned.
       
    84 // 
       
    85 // The reason for this rather complicated function is to specify all the
       
    86 // test cases only in one place. It is not necessary to understand how
       
    87 // function pointers to class member functions works when adding new test
       
    88 // cases. See function body for instructions how to add new test case.
       
    89 // -----------------------------------------------------------------------------
       
    90 //
       
    91 const TCaseInfo CSenServDesc::Case ( 
       
    92     const TInt aCaseNumber ) const 
       
    93      {
       
    94 
       
    95     /**
       
    96     * To add new test cases, implement new test case function and add new 
       
    97     * line to KCases array specify the name of the case and the function 
       
    98     * doing the test case
       
    99     * In practice, do following
       
   100     * 1) Make copy of existing test case function and change its name
       
   101     *    and functionality. Note that the function must be added to 
       
   102     *    SenServDesc.cpp file and to SenServDesc.h 
       
   103     *    header file.
       
   104     *
       
   105     * 2) Add entry to following KCases array either by using:
       
   106     *
       
   107     * 2.1: FUNCENTRY or ENTRY macro
       
   108     * ENTRY macro takes two parameters: test case name and test case 
       
   109     * function name.
       
   110     *
       
   111     * FUNCENTRY macro takes only test case function name as a parameter and
       
   112     * uses that as a test case name and test case function name.
       
   113     *
       
   114     * Or
       
   115     *
       
   116     * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used
       
   117     * only with OOM (Out-Of-Memory) testing!
       
   118     *
       
   119     * OOM_ENTRY macro takes five parameters: test case name, test case 
       
   120     * function name, TBool which specifies is method supposed to be run using
       
   121     * OOM conditions, TInt value for first heap memory allocation failure and 
       
   122     * TInt value for last heap memory allocation failure.
       
   123     * 
       
   124     * OOM_FUNCENTRY macro takes test case function name as a parameter and uses
       
   125     * that as a test case name, TBool which specifies is method supposed to be
       
   126     * run using OOM conditions, TInt value for first heap memory allocation 
       
   127     * failure and TInt value for last heap memory allocation failure. 
       
   128     */ 
       
   129 
       
   130     static TCaseInfoInternal const KCases[] =
       
   131         {
       
   132         // To add new test cases, add new items to this array
       
   133         
       
   134         // NOTE: When compiled to GCCE, there must be Classname::
       
   135         // declaration in front of the method name, e.g. 
       
   136         // CSenServDesc::PrintTest. Otherwise the compiler
       
   137         // gives errors.
       
   138         
       
   139   //      FUNCENTRY( CSenServDesc::PrintTest ),
       
   140   //    ENTRY( "Loop test", CSenServDesc::LoopTest ),
       
   141 		ENTRY("NewL - CSenCredential",  CSenServDesc::MT_CSenCredential_NewLL),
       
   142 		ENTRY("NewLC - CSenCredential",  CSenServDesc::MT_CSenCredential_NewLCL),
       
   143 		ENTRY("NewL - CSenCredential baseElement",  CSenServDesc::MT_CSenCredential_NewL_1L),
       
   144 		ENTRY("NewLC - CSenCredential baseElement",  CSenServDesc::MT_CSenCredential_NewLC_1L),
       
   145 		ENTRY("NewL - CSenCredential copy",  CSenServDesc::MT_CSenCredential_NewL_2L),
       
   146 		ENTRY("NewLC - CSenCredential copy",  CSenServDesc::MT_CSenCredential_NewLC_2L),
       
   147 		ENTRY("ValidUntil - CSenCredential ValidUntil",  CSenServDesc::MT_CSenCredential_ValidUntilL),
       
   148 		ENTRY("SetValidUntil - CSenCredential SetValidUntil",  CSenServDesc::MT_CSenCredential_SetValidUntilL),
       
   149 		//ENTRY("NewLC - CSenCredential Id",  CSenServDesc::MT_CSenCredential_IdL),
       
   150 		ENTRY("StartElement - CSenCredential StartElement",  CSenServDesc::MT_CSenCredential_StartElementLL),
       
   151 
       
   152 		ENTRY("NewL - CSenCredential2",  CSenServDesc::MT_CSenCredential2_NewLL),
       
   153 		ENTRY("NewLC - CSenCredential2",  CSenServDesc::MT_CSenCredential2_NewLCL),
       
   154 		ENTRY("NewL - CSenCredential2 baseElement",  CSenServDesc::MT_CSenCredential2_NewL_1L),
       
   155 		ENTRY("NewLC - CSenCredential2 baseElement",  CSenServDesc::MT_CSenCredential2_NewLC_1L),
       
   156 		ENTRY("NewL - CSenCredential2 ",  CSenServDesc::MT_CSenCredential2_NewL_2L),
       
   157 		ENTRY("NewLC - CSenCredential2 ",  CSenServDesc::MT_CSenCredential2_NewLC_2L),
       
   158 		ENTRY("NewL - CSenCredential2 copy",  CSenServDesc::MT_CSenCredential2_NewL_3L),
       
   159 		ENTRY("NewLC - CSenCredential2 copy",  CSenServDesc::MT_CSenCredential2_NewLC_3L),
       
   160 		ENTRY("NewL - CSenCredential2 document",  CSenServDesc::MT_CSenCredential2_NewL_4L),
       
   161 		ENTRY("NewLC - CSenCredential2 document",  CSenServDesc::MT_CSenCredential2_NewLC_4L),
       
   162 		ENTRY("Id - CSenCredential2 Id",  CSenServDesc::MT_CSenCredential2_IdL),
       
   163 		ENTRY("ValidUntil - CSenCredential2 ValidUntil",  CSenServDesc::MT_CSenCredential2_ValidUntilL),
       
   164 		ENTRY("SetValidUntil - CSenCredential2 SetValidUntil",  CSenServDesc::MT_CSenCredential2_SetValidUntilL),
       
   165 		ENTRY("NewL - CSenFacet",  CSenServDesc::MT_CSenFacet_NewLL),
       
   166 		ENTRY("NewL - CSenFacet copy",  CSenServDesc::MT_CSenFacet_NewL_1L),
       
   167 		ENTRY("NewL - CSenFacet attribute",  CSenServDesc::MT_CSenFacet_NewL_2L),
       
   168 		ENTRY("SetNameL - CSenFacet",  CSenServDesc::MT_CSenFacet_SetNameLL),
       
   169 		ENTRY("SetTypeL - CSenFacet",  CSenServDesc::MT_CSenFacet_SetTypeLL),
       
   170 		ENTRY("SetValueL - CSenFacet",  CSenServDesc::MT_CSenFacet_SetValueLL),
       
   171 		ENTRY("Name - CSenFacet",  CSenServDesc::MT_CSenFacet_NameL),
       
   172 		ENTRY("Type - CSenFacet",  CSenServDesc::MT_CSenFacet_TypeL),
       
   173 		ENTRY("Value - CSenFacet",  CSenServDesc::MT_CSenFacet_ValueL),
       
   174 		ENTRY("NewL - Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewL_L),
       
   175 		ENTRY("NewLC - Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewLCL),
       
   176 		ENTRY("NewL - Enpoint + Contract",  CSenServDesc::MT_CSenIdentityProvider_NewL_1L),
       
   177 		ENTRY("NewLC - Enpoint + Contract",  CSenServDesc::MT_CSenIdentityProvider_NewLC_1L),
       
   178 		ENTRY("NewL - Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewL_2L),
       
   179 		ENTRY("NewLC - Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewLC_2L),
       
   180 		ENTRY("NewL - ServiceID + Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewL_3L),
       
   181 		ENTRY("NewLC - ServiceID + Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewLC_3L),
       
   182 		ENTRY("AuthzID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_AuthzIDL),
       
   183 		ENTRY("AdvisoryAuthnID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL),
       
   184 		ENTRY("ProviderID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_ProviderIDL),
       
   185 		ENTRY("Password - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_PasswordL),
       
   186 		ENTRY("IMEI - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IMEIL),
       
   187 		ENTRY("UserName - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_UserNameL),
       
   188 		ENTRY("SetProviderID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL),
       
   189 		ENTRY("SetServiceID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL),
       
   190 		ENTRY("IsTrustedByL - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL),
       
   191 		ENTRY("IsTrustedByL1 - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L),		
       
   192 		ENTRY("HttpCredentialsL - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL),
       
   193 		ENTRY("IsDefault - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IsDefaultL),		
       
   194 		
       
   195 		ENTRY("NewElementName - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_NewElementNameL),
       
   196 		ENTRY("NewL - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL),
       
   197 		ENTRY("NewLC - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL),
       
   198 		ENTRY("NewL - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L),
       
   199 		ENTRY("NewLC - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L),
       
   200 		ENTRY("IsStrict - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL),
       
   201 		ENTRY("SetStrict - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL),
       
   202 		ENTRY("NewL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLL),
       
   203 		ENTRY("NewLC - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLCL),
       
   204 		ENTRY("NewL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewL_1L),
       
   205 		ENTRY("NewLC - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLC_1L),
       
   206 		ENTRY("NewL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewL_2L),
       
   207 		ENTRY("NewLC - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLC_2L),
       
   208 		ENTRY("MatchesL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_MatchesL),		
       
   209 		ENTRY("SetConsumerIapIdL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL),
       
   210 		ENTRY("ConsumerIapId - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL),
       
   211 		ENTRY("SetConsumerSnapId - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL),
       
   212 		ENTRY("ConsumerSnapId - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL),
       
   213 		ENTRY("SetConsumerIdentityProviderIdsL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL),
       
   214 		ENTRY("ConsumerPolicyAsXmlL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL),
       
   215 		ENTRY("StartElementL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_StartElementLL),
       
   216 		
       
   217 		
       
   218 		ENTRY("AddConsumerIdentityProviderIdL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL),
       
   219 		ENTRY("ConsumerIdentityProviderIds8L - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL),
       
   220 		ENTRY("AcceptsConsumerPolicy - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL),
       
   221 		ENTRY("RebuildFromConsumerPolicy - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL),		
       
   222 		ENTRY("NewL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLL),
       
   223 		ENTRY("NewLC - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLCL),
       
   224 		ENTRY("NewL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L),
       
   225 		ENTRY("NewLC - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L),
       
   226 		ENTRY("NewL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L),
       
   227 		ENTRY("NewLC - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L),
       
   228 		ENTRY("SetFrameworkIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL),
       
   229 		ENTRY("NewElementName - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL),
       
   230 		ENTRY("SetIapIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL),
       
   231 		ENTRY("IapId - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_IapIdL),
       
   232 		ENTRY("SetSnapIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL),
       
   233 		ENTRY("SnapId - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL),
       
   234 		ENTRY("SetIdentityProviderIdsL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL),
       
   235 		ENTRY("AddIdentityProviderIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL),
       
   236 		ENTRY("RebuildFrom - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL),
       
   237 		ENTRY("IdentityProviderIds8L - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL),
       
   238 		ENTRY("Accepts - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL),
       
   239 		ENTRY("DescriptionClassType - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL),
       
   240 		ENTRY("MatchesL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_MatchesL),
       
   241 		ENTRY("SetProviderIDL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL),
       
   242 		ENTRY("SetPolicyLL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL),
       
   243 		ENTRY("SetPolicyL_1L - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L),
       
   244 		ENTRY("SetPolicyL_2L - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L),	
       
   245     	ENTRY("Contract - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_ContractL),
       
   246 		ENTRY("HasFacetL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL),
       
   247 		ENTRY("FacetValue - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL),
       
   248 		ENTRY("AddFacetL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL),
       
   249 		ENTRY("SetFacetL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL),
       
   250 		ENTRY("RemoveFacet - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL),
       
   251 		ENTRY("FacetsL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL),
       
   252 		ENTRY("ScoreMatchL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL),
       
   253 		ENTRY("Endpoint - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_EndpointL),
       
   254 		ENTRY("FrameworkId - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL),
       
   255 		ENTRY("FrameworkVersion - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL),
       
   256 		ENTRY("SetContractL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL),
       
   257 		ENTRY("SetEndPointL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL),
       
   258 		ENTRY("SetAttributesL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL),		
       
   259 		ENTRY("AsXmlL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL),
       
   260 		ENTRY("WriteAsXMLToL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL),
       
   261 		ENTRY("AsXmlUnicodeL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL),
       
   262 		ENTRY("Credentials - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL),
       
   263 
       
   264 		ENTRY("HasEqualPrimaryKeysL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL),
       
   265 		ENTRY("IsLocalL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL),
       
   266 		ENTRY("SetTransportCueL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL),
       
   267 		ENTRY("TransportCue - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL),
       
   268 		//ENTRY("ServicePolicy - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL),
       
   269 		ENTRY("ProviderId - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL),
       
   270 		ENTRY("SetPromptUserInfoL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL),
       
   271 		ENTRY("PromptUserInfo - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL),
       
   272 		ENTRY("StartElementL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL),
       
   273 		ENTRY("CopyFromLL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL),
       
   274 	
       
   275         // Example how to use OOM functionality
       
   276         //OOM_ENTRY( "Loop test with OOM", CSenServDesc::LoopTest, ETrue, 2, 3),
       
   277         //OOM_FUNCENTRY( CSenServDesc::PrintTest, ETrue, 1, 3 ),
       
   278         };
       
   279 
       
   280     // Verify that case number is valid
       
   281     if( (TUint) aCaseNumber >= sizeof( KCases ) / 
       
   282                                sizeof( TCaseInfoInternal ) )
       
   283         {
       
   284         // Invalid case, construct empty object
       
   285         TCaseInfo null( (const TText*) L"" );
       
   286         null.iMethod = NULL;
       
   287         null.iIsOOMTest = EFalse;
       
   288         null.iFirstMemoryAllocation = 0;
       
   289         null.iLastMemoryAllocation = 0;
       
   290         return null;
       
   291         } 
       
   292 
       
   293     // Construct TCaseInfo object and return it
       
   294     TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );
       
   295     tmp.iMethod = KCases[ aCaseNumber ].iMethod;
       
   296     tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;
       
   297     tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;
       
   298     tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;
       
   299     return tmp;
       
   300 
       
   301     }
       
   302 
       
   303 //  METHODS
       
   304 
       
   305 
       
   306 
       
   307 void CSenServDesc::SetupL(  )
       
   308     {
       
   309 
       
   310     } 
       
   311 
       
   312 void CSenServDesc::Teardown(  )
       
   313     {
       
   314 
       
   315     }
       
   316 TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseFragment &fragment){
       
   317     HBufC16* xmlBuffer = fragment.AsElement().AsXmlUnicodeL();//Parent()->
       
   318     CleanupStack::PushL( xmlBuffer );
       
   319     TPtr16 ptr = xmlBuffer->Des();
       
   320     if (ptr.Length() > 0){
       
   321         RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
       
   322     }
       
   323     else
       
   324         RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
       
   325     return ptr;
       
   326 }
       
   327 TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseElement &element){
       
   328     HBufC16* xmlBuffer = element.AsXmlUnicodeL();//Parent()->
       
   329     CleanupStack::PushL( xmlBuffer );
       
   330     TPtr16 ptr = xmlBuffer->Des();
       
   331     if (ptr.Length() > 0){
       
   332         RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
       
   333     }
       
   334     else
       
   335         RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
       
   336     return ptr;
       
   337 }
       
   338 
       
   339 TInt CSenServDesc::MT_CSenCredential_NewLL( TTestResult& aResult )
       
   340     {
       
   341     SetupL();
       
   342     
       
   343     RAttributeArray attributeArray;
       
   344     CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);
       
   345     TL(senCredential != (CSenCredential*)NULL);
       
   346   
       
   347     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   348     //checking xml
       
   349     TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   350     
       
   351     CleanupStack::PopAndDestroy();//Ptr
       
   352     
       
   353     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   354    
       
   355     senCredential = NULL;
       
   356 
       
   357 	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   358  
       
   359 	{TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   360 
       
   361  	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   362    
       
   363  	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   364 
       
   365  	{TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   366 
       
   367  	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   368 
       
   369     attributeArray.Reset();
       
   370     attributeArray.Close();
       
   371     
       
   372     Teardown();
       
   373     return KErrNone;
       
   374     }
       
   375 
       
   376 
       
   377 
       
   378 
       
   379 TInt CSenServDesc::MT_CSenCredential_NewLCL( TTestResult& aResult )
       
   380     {
       
   381     SetupL();
       
   382     
       
   383     RAttributeArray attributeArray;
       
   384     CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray);
       
   385     TL(senCredential != (CSenCredential*)NULL);
       
   386   
       
   387     //checking xml
       
   388     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   389     TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   390     CleanupStack::PopAndDestroy();//Ptr
       
   391     
       
   392     CleanupStack::Pop();
       
   393     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   394     senCredential = NULL;
       
   395 
       
   396 	  {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   397 
       
   398  		{TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   399 
       
   400  		{TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   401 
       
   402 	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   403 
       
   404 	 	{TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   405 
       
   406 	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   407 
       
   408     attributeArray.Reset();
       
   409     attributeArray.Close();
       
   410      Teardown();
       
   411     return KErrNone;
       
   412    }
       
   413 
       
   414 
       
   415 TInt CSenServDesc::MT_CSenCredential_NewL_1L( TTestResult& aResult )
       
   416     {
       
   417     SetupL();
       
   418     
       
   419     RAttributeArray attributeArray;
       
   420     CSenBaseElement* senBaseElement = CSenBaseElement::NewL(KText);
       
   421     CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray, *senBaseElement);
       
   422     TL(senCredential != (CSenCredential*)NULL);
       
   423 
       
   424     //checking xml, parent we will not see so ref the same as previous NewL ctr 
       
   425     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   426     TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   427 
       
   428     CleanupStack::PopAndDestroy();//Ptr
       
   429     
       
   430     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   431     senCredential = NULL;
       
   432     delete senBaseElement;
       
   433     senBaseElement = NULL;
       
   434 
       
   435     senBaseElement = CSenBaseElement::NewL(KText);
       
   436 	 	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   437 
       
   438 	 	{TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   439 
       
   440 	 	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   441 
       
   442 	 	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
       
   443 
       
   444 	 	{TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
       
   445 
       
   446 	 	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
       
   447 
       
   448     delete senBaseElement;
       
   449     senBaseElement = NULL;
       
   450     attributeArray.Reset();
       
   451     attributeArray.Close();
       
   452     Teardown();
       
   453     return KErrNone;
       
   454    }
       
   455 
       
   456 TInt CSenServDesc::MT_CSenCredential_NewLC_1L( TTestResult& aResult )
       
   457     {
       
   458     SetupL();
       
   459     
       
   460     RAttributeArray attributeArray;
       
   461     CSenBaseElement* senBaseElement = CSenBaseElement::NewL(KText);
       
   462     CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray, *senBaseElement);
       
   463     TL(senCredential != (CSenCredential*)NULL);
       
   464    
       
   465     //checking xml, parent we will not see so ref the same as previous Newl ctr
       
   466     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   467     TL(ConvertToPtr16LC(*senCredential)== KRef);
       
   468 
       
   469     CleanupStack::PopAndDestroy();//Ptr
       
   470     
       
   471     CleanupStack::Pop();
       
   472     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   473     senCredential = NULL;
       
   474     delete senBaseElement;
       
   475     senBaseElement = NULL;
       
   476 
       
   477     senBaseElement = CSenBaseElement::NewL(KText);
       
   478 	 	{TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   479 
       
   480 	 	{TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   481 
       
   482 	 	{TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   483 
       
   484 	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
       
   485 
       
   486 	 	{TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
       
   487 
       
   488 	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}
       
   489 
       
   490     delete senBaseElement;
       
   491     senBaseElement = NULL;
       
   492     attributeArray.Reset();
       
   493     attributeArray.Close();
       
   494     Teardown();
       
   495     return KErrNone;
       
   496    }
       
   497 
       
   498 TInt CSenServDesc::MT_CSenCredential_NewL_2L( TTestResult& aResult )
       
   499     {
       
   500     SetupL();
       
   501     
       
   502     RAttributeArray attributeArray;
       
   503     CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);
       
   504     
       
   505     senCredential = CSenCredential::NewL(*orgSenCredential);
       
   506     
       
   507     //checking xml
       
   508     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   509     TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   510     CleanupStack::PopAndDestroy();//Ptr
       
   511     
       
   512     TL(senCredential != (CSenCredential*)NULL);
       
   513     
       
   514    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   515     senCredential = NULL;
       
   516     delete orgSenCredential;
       
   517     orgSenCredential = NULL;
       
   518     attributeArray.Reset();
       
   519     attributeArray.Close();
       
   520     Teardown();
       
   521     return KErrNone;
       
   522    }
       
   523 
       
   524 TInt CSenServDesc::MT_CSenCredential_NewLC_2L( TTestResult& aResult )
       
   525     {
       
   526     SetupL();
       
   527     
       
   528     RAttributeArray attributeArray;
       
   529     CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);
       
   530     
       
   531     senCredential = CSenCredential::NewLC(*orgSenCredential);
       
   532     TL(senCredential != (CSenCredential*)NULL);
       
   533     
       
   534     //checking xml
       
   535     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   536     TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   537     
       
   538     CleanupStack::PopAndDestroy();//Ptr
       
   539     
       
   540     CleanupStack::Pop();
       
   541     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   542     senCredential = NULL;
       
   543     delete orgSenCredential;
       
   544     orgSenCredential = NULL;
       
   545     attributeArray.Reset();
       
   546     attributeArray.Close();
       
   547     Teardown();
       
   548     return KErrNone;
       
   549    }
       
   550    
       
   551 TInt CSenServDesc::MT_CSenCredential_ValidUntilL( TTestResult& aResult )
       
   552     {
       
   553     SetupL();    
       
   554     RAttributeArray attributes;
       
   555     CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributes);
       
   556     TTime time;
       
   557     _LIT(KTimeString1,"23:34.56");
       
   558     time.Parse(KTimeString1);
       
   559     /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/
       
   560     __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));	
       
   561     LOCAL_ASSERT(senCredential->ValidUntil() == time); 
       
   562 
       
   563     /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */
       
   564     __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil());	
       
   565 
       
   566     //checking xml
       
   567 	//_LIT16(KRef, "<text xmlns=\"text\" some valid stuff/>");
       
   568     //_LIT16(KRef, "<text xmlns=\"text\" >");
       
   569     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   570     /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/
       
   571     TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   572     CleanupStack::PopAndDestroy();//Ptr
       
   573     
       
   574     delete senCredential;
       
   575     senCredential = NULL;
       
   576     attributes.Reset();
       
   577     attributes.Close();
       
   578     Teardown();
       
   579     return KErrNone;
       
   580     }
       
   581 
       
   582 TInt CSenServDesc::MT_CSenCredential_SetValidUntilL( TTestResult& aResult )
       
   583     {
       
   584     return MT_CSenCredential_ValidUntilL(aResult);
       
   585     }
       
   586 TInt CSenServDesc::MT_CSenCredential_StartElementLL(TTestResult& aResult)
       
   587 	{
       
   588 	/*
       
   589 	_LIT8(KCredential, "<Credentials CredentialsMaxID=\"1\">
       
   590 						<CredentialContainer>
       
   591 						<Identifier><garbage>1</garbage><Endpoint>http://10.21.32.20/WSStar/CredMan/WSService.aspx</Endpoint><ProviderID>provider01</ProviderID></Identifier>
       
   592 						<Properties>
       
   593 						<ServiceInterval>-60540625</ServiceInterval><ValidUntil>2020-06-19T10:28:31.000000Z</ValidUntil>
       
   594 						<Created>2007-06-18T10:23:52Z</Created><PhoneTimeWhenMTResolved>2007-06-18T10:24:52.504375Z</PhoneTimeWhenMTResolved>
       
   595 						<POP>cnqlXcxDmY4h4tjbgNssLMwhCkOnc+4c</POP>
       
   596 						<TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</TokenType>\
       
   597 						<BinaryType>simmetric</BinaryType>
       
   598 						</Properties></CredentialContainer></Credentials>");
       
   599     */	
       
   600     
       
   601 	_LIT8(KCredential, "<Credentials CredentialsMaxID=\"1\">\
       
   602 						</Credentials>");
       
   603     					
       
   604 	RAttributeArray attributes;
       
   605 	CSenCredential* pCredential = CSenCredential::NewL(_L8(""),_L8("Credentials"),_L8("Credentials"),attributes);
       
   606 	CleanupStack::PushL(pCredential);
       
   607 	CSenXmlReader *pXmlReader = CSenXmlReader::NewL();
       
   608 	CleanupStack::PushL(pXmlReader);
       
   609 	pCredential->SetReader(*pXmlReader );
       
   610 	TRAPD(retVal,pCredential->ParseL(KCredential));
       
   611 	CleanupStack::PopAndDestroy(pXmlReader);
       
   612 	CleanupStack::PopAndDestroy(pCredential);
       
   613 	return retVal;
       
   614 	}
       
   615 	
       
   616 
       
   617 TInt CSenServDesc::MT_CSenCredential2_NewLL( TTestResult& aResult )
       
   618     {
       
   619     SetupL();
       
   620     
       
   621     CSenCredential2* senCredential = CSenCredential2::NewL();
       
   622     TL(senCredential != (CSenCredential2*)NULL);
       
   623   
       
   624     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   625    
       
   626     senCredential = NULL;
       
   627 
       
   628     
       
   629     Teardown();
       
   630     return KErrNone;
       
   631     }
       
   632 
       
   633 
       
   634 
       
   635 
       
   636 TInt CSenServDesc::MT_CSenCredential2_NewLCL( TTestResult& aResult )
       
   637     {
       
   638     SetupL();
       
   639     
       
   640     CSenCredential2* senCredential = CSenCredential2::NewLC();
       
   641     TL(senCredential != (CSenCredential2*)NULL);
       
   642     CleanupStack::Pop();
       
   643     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   644    
       
   645     senCredential = NULL;
       
   646 
       
   647 	//CleanupStack::PopAndDestroy();
       
   648     Teardown();
       
   649     return KErrNone;
       
   650    }
       
   651 
       
   652 
       
   653 TInt CSenServDesc::MT_CSenCredential2_NewL_1L( TTestResult& aResult )
       
   654     {
       
   655     SetupL();
       
   656     
       
   657     RAttributeArray attributeArray;
       
   658     CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
       
   659     TL(senCredential != (CSenCredential2*)NULL);
       
   660 
       
   661     
       
   662     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   663     senCredential = NULL;
       
   664     Teardown();
       
   665     return KErrNone;
       
   666    }
       
   667 
       
   668 TInt CSenServDesc::MT_CSenCredential2_NewLC_1L( TTestResult& aResult )
       
   669     {
       
   670     SetupL();
       
   671     
       
   672     RAttributeArray attributeArray;
       
   673     CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray);
       
   674     TL(senCredential != (CSenCredential2*)NULL);
       
   675 
       
   676     CleanupStack::Pop();
       
   677     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   678     senCredential = NULL;
       
   679 	//CleanupStack::PopAndDestroy();
       
   680     
       
   681     Teardown();
       
   682     return KErrNone;
       
   683    }
       
   684    
       
   685    
       
   686 TInt CSenServDesc::MT_CSenCredential2_NewL_2L( TTestResult& aResult )
       
   687 	{
       
   688     SetupL();
       
   689     _LIT8(KBodyElementName,    "BodyElement");
       
   690     RAttributeArray attributeArray;
       
   691     RSenDocument document = RSenDocument::NewLC();
       
   692     TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
       
   693     CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray, bodyElement);
       
   694     TL(senCredential != (CSenCredential2*)NULL);
       
   695     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   696     senCredential = NULL;
       
   697 	CleanupStack::PopAndDestroy(1);
       
   698     
       
   699     Teardown();
       
   700     return KErrNone;
       
   701 	}
       
   702       
       
   703 TInt CSenServDesc::MT_CSenCredential2_NewLC_2L( TTestResult& aResult )
       
   704 	{
       
   705     SetupL();
       
   706     _LIT8(KBodyElementName,    "BodyElement");
       
   707     RAttributeArray attributeArray;
       
   708     RSenDocument document = RSenDocument::NewLC();
       
   709     TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
       
   710     CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray, bodyElement);
       
   711     TL(senCredential != (CSenCredential2*)NULL);
       
   712     CleanupStack::Pop();
       
   713     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   714     senCredential = NULL;
       
   715 	CleanupStack::PopAndDestroy(1);
       
   716     Teardown();
       
   717     return KErrNone;
       
   718 	}
       
   719 
       
   720 TInt CSenServDesc::MT_CSenCredential2_NewL_3L( TTestResult& aResult )
       
   721     {
       
   722     SetupL();
       
   723     
       
   724     RAttributeArray attributeArray;
       
   725     CSenCredential2 *senCredential;
       
   726     CSenCredential2  *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
       
   727     senCredential = CSenCredential2::NewL(*orgSenCredential);
       
   728     
       
   729     
       
   730    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   731     senCredential = NULL;
       
   732     delete orgSenCredential;
       
   733     orgSenCredential = NULL;
       
   734     Teardown();
       
   735     return KErrNone;
       
   736    }
       
   737 
       
   738 TInt CSenServDesc::MT_CSenCredential2_NewLC_3L( TTestResult& aResult )
       
   739     {
       
   740     SetupL();
       
   741     
       
   742     RAttributeArray attributeArray;
       
   743     CSenCredential2 *senCredential;
       
   744     CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
       
   745     senCredential = CSenCredential2::NewLC(*orgSenCredential);
       
   746     TL(senCredential != (CSenCredential2*)NULL);
       
   747     
       
   748     
       
   749     CleanupStack::Pop();
       
   750     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   751     senCredential = NULL;
       
   752     delete orgSenCredential;
       
   753     orgSenCredential = NULL;
       
   754     attributeArray.Reset();
       
   755     attributeArray.Close();
       
   756     Teardown();
       
   757     return KErrNone;
       
   758    }
       
   759 
       
   760 
       
   761 TInt CSenServDesc::MT_CSenCredential2_NewL_4L( TTestResult& aResult )
       
   762 	{
       
   763     SetupL();
       
   764     _LIT8(KBodyElementName,    "BodyElement");
       
   765     RAttributeArray attributeArray;
       
   766     RSenDocument document = RSenDocument::NewLC();
       
   767     TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
       
   768     CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray, bodyElement, document);
       
   769     TL(senCredential != (CSenCredential2*)NULL);
       
   770     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   771     senCredential = NULL;
       
   772 	CleanupStack::PopAndDestroy(1);
       
   773     
       
   774     Teardown();
       
   775     return KErrNone;
       
   776 	}
       
   777       
       
   778 TInt CSenServDesc::MT_CSenCredential2_NewLC_4L( TTestResult& aResult )
       
   779 	{
       
   780     SetupL();
       
   781     _LIT8(KBodyElementName,    "BodyElement");
       
   782     RAttributeArray attributeArray;
       
   783     RSenDocument document = RSenDocument::NewLC();
       
   784     TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName());
       
   785     CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray, bodyElement, document);
       
   786     TL(senCredential != (CSenCredential2*)NULL);
       
   787     CleanupStack::Pop();
       
   788     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   789     senCredential = NULL;
       
   790 	CleanupStack::PopAndDestroy(1);
       
   791     Teardown();
       
   792     return KErrNone;
       
   793 	}
       
   794 
       
   795 
       
   796 TInt CSenServDesc::MT_CSenCredential2_IdL( TTestResult& aResult )
       
   797     {
       
   798     SetupL();
       
   799     
       
   800     RAttributeArray attributeArray;
       
   801     CSenCredential2 *senCredential;
       
   802     CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray);
       
   803     senCredential = CSenCredential2::NewL(*orgSenCredential);
       
   804     senCredential->Id();
       
   805     TL(senCredential != (CSenCredential2*)NULL);
       
   806     
       
   807     
       
   808     __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);
       
   809     senCredential = NULL;
       
   810     delete orgSenCredential;
       
   811     orgSenCredential = NULL;
       
   812     attributeArray.Reset();
       
   813     attributeArray.Close();
       
   814     Teardown();
       
   815     return KErrNone;
       
   816    }
       
   817 
       
   818 
       
   819 TInt CSenServDesc::MT_CSenCredential2_ValidUntilL( TTestResult& aResult )
       
   820     {
       
   821     SetupL();    
       
   822     RAttributeArray attributes;
       
   823     CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributes);
       
   824     TTime time;
       
   825     _LIT(KTimeString1,"23:34.56");
       
   826     time.Parse(KTimeString1);
       
   827     /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/
       
   828     __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));	
       
   829     LOCAL_ASSERT(senCredential->ValidUntil() == time); 
       
   830 
       
   831     /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */
       
   832     __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil());	
       
   833 
       
   834     //checking xml
       
   835 	//_LIT16(KRef, "<text xmlns=\"text\" some valid stuff/>");
       
   836     //_LIT16(KRef, "<text xmlns=\"text\" >");
       
   837     //_LIT16(KRef, "<text xmlns=\"text\"/>");
       
   838     /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/
       
   839     //TL(ConvertToPtr16LC(*senCredential) == KRef);
       
   840     //CleanupStack::PopAndDestroy();//Ptr
       
   841     
       
   842     delete senCredential;
       
   843     senCredential = NULL;
       
   844     attributes.Reset();
       
   845     attributes.Close();
       
   846     Teardown();
       
   847     return KErrNone;
       
   848     }
       
   849 
       
   850 TInt CSenServDesc::MT_CSenCredential2_SetValidUntilL( TTestResult& aResult )
       
   851     {
       
   852     return MT_CSenCredential2_ValidUntilL(aResult);
       
   853     }
       
   854 
       
   855 	
       
   856 TInt CSenServDesc::MT_CSenFacet_NewLL( TTestResult& aResult )
       
   857     {
       
   858     SetupL();
       
   859     
       
   860     RAttributeArray attributeArray;
       
   861     CSenFacet* senFacet = CSenFacet::NewL();
       
   862     TL(senFacet != (CSenFacet*)NULL);
       
   863 
       
   864     //checking xml
       
   865     _LIT16(KRef, "<Facet/>");
       
   866     TL(ConvertToPtr16LC(*senFacet) == KRef);
       
   867 
       
   868     CleanupStack::PopAndDestroy();//Ptr
       
   869     
       
   870     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
   871     senFacet = NULL;
       
   872     attributeArray.Reset();
       
   873     attributeArray.Close();
       
   874     Teardown();
       
   875     return KErrNone;
       
   876    }
       
   877 
       
   878 TInt CSenServDesc::MT_CSenFacet_NewL_1L(TTestResult& aResult)
       
   879     {
       
   880     SetupL();
       
   881     
       
   882     CSenFacet *senFacet;
       
   883     CSenFacet *senFacetOrg = CSenFacet::NewL();
       
   884     
       
   885     senFacet = CSenFacet::NewL(*senFacetOrg);
       
   886     TL(senFacet != (CSenFacet*)NULL);
       
   887 
       
   888     //checking xml
       
   889     _LIT16(KRef, "<Facet/>");
       
   890     TL(ConvertToPtr16LC(*senFacet) == KRef);
       
   891     
       
   892     CleanupStack::PopAndDestroy();//Ptr
       
   893     
       
   894     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
   895     senFacet = NULL;
       
   896     delete senFacetOrg;
       
   897     senFacetOrg = NULL;
       
   898     Teardown();
       
   899     return KErrNone;
       
   900    }
       
   901 
       
   902 TInt CSenServDesc::MT_CSenFacet_NewL_2L( TTestResult& aResult )
       
   903     {
       
   904     SetupL();
       
   905     
       
   906     RAttributeArray attributeArray;
       
   907     CSenFacet* senFacet = CSenFacet::NewL(KText, KText, KText, attributeArray);
       
   908     TL(senFacet != (CSenFacet*)NULL);
       
   909 
       
   910     //checking xml
       
   911     _LIT16(KRef, "<text xmlns=\"text\"/>");
       
   912     TL(ConvertToPtr16LC(*senFacet) == KRef);
       
   913     
       
   914     CleanupStack::PopAndDestroy();//Ptr
       
   915     
       
   916     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
   917     senFacet = NULL;
       
   918 
       
   919 	 	{TRAPD(err, CSenFacet::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   920 
       
   921 	 	{TRAPD(err, CSenFacet::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   922 
       
   923 	 	{TRAPD(err, CSenFacet::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}
       
   924 
       
   925 	 	{TRAPD(err, CSenFacet::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   926 
       
   927 	 	{TRAPD(err, CSenFacet::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   928 
       
   929 	 	{TRAPD(err, CSenFacet::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}
       
   930 
       
   931     attributeArray.Reset();
       
   932     attributeArray.Close();
       
   933     Teardown();
       
   934     return KErrNone;
       
   935    }
       
   936 
       
   937 TInt CSenServDesc::MT_CSenFacet_SetNameLL( TTestResult& aResult )
       
   938     {
       
   939     SetupL();
       
   940     
       
   941     CSenFacet* senFacet = CSenFacet::NewL();
       
   942     if(!(senFacet->Name() == KNullDesC8))return KErrArgument;
       
   943     
       
   944     senFacet->SetNameL(KText);
       
   945     if(!(senFacet->Name() == KText))return KErrArgument;
       
   946     
       
   947     //checking xml
       
   948     _LIT16(KRef, "<Facet name=\"text\"/>");
       
   949     TL(ConvertToPtr16LC(*senFacet) == KRef);
       
   950     
       
   951     CleanupStack::PopAndDestroy();//Ptr
       
   952     
       
   953      if(!(senFacet->Name() == KText))return KErrArgument;
       
   954 
       
   955    __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
   956     senFacet = NULL;
       
   957     Teardown();
       
   958     return KErrNone;
       
   959     }
       
   960 
       
   961 TInt CSenServDesc::MT_CSenFacet_SetTypeLL( TTestResult& aResult )
       
   962     {
       
   963     SetupL();
       
   964     
       
   965     CSenFacet* senFacet = CSenFacet::NewL();
       
   966     if(!(senFacet->Type() == KNullDesC8))return KErrArgument;
       
   967 
       
   968     senFacet->SetTypeL(KText);
       
   969     if(!(senFacet->Type() == KText))return KErrArgument;
       
   970    
       
   971     //checking xml
       
   972     _LIT16(KRef, "<Facet type=\"text\"/>");
       
   973     TL(ConvertToPtr16LC(*senFacet) == KRef);
       
   974     
       
   975     CleanupStack::PopAndDestroy();//Ptr
       
   976     
       
   977     if(!(senFacet->Type() == KText))return KErrArgument;
       
   978 
       
   979     delete senFacet;
       
   980     senFacet = NULL;
       
   981     Teardown();
       
   982     return KErrNone;
       
   983     }
       
   984 
       
   985 TInt CSenServDesc::MT_CSenFacet_SetValueLL( TTestResult& aResult )
       
   986     {
       
   987     SetupL();
       
   988     
       
   989     CSenFacet* senFacet = CSenFacet::NewL();
       
   990     if(!(senFacet->Value() == KNullDesC8))return KErrArgument;
       
   991 
       
   992     senFacet->SetValueL(KText);
       
   993     if(!(senFacet->Value() == KText))return KErrArgument;
       
   994 
       
   995     
       
   996     //checking xml
       
   997     _LIT16(KRef, "<Facet>text</Facet>");
       
   998     TL(ConvertToPtr16LC(*senFacet) == KRef);
       
   999     
       
  1000     CleanupStack::PopAndDestroy();//Ptr
       
  1001     
       
  1002     if(!(senFacet->Value() == KText))return KErrArgument;
       
  1003 
       
  1004     delete senFacet;
       
  1005     senFacet = NULL;
       
  1006     Teardown();
       
  1007     return KErrNone;
       
  1008     }
       
  1009 
       
  1010 TInt CSenServDesc::MT_CSenFacet_NameL( TTestResult& aResult )
       
  1011     {
       
  1012     return MT_CSenFacet_SetNameLL(aResult);
       
  1013     }
       
  1014 
       
  1015 TInt CSenServDesc::MT_CSenFacet_TypeL( TTestResult& aResult )
       
  1016     {
       
  1017     return MT_CSenFacet_SetTypeLL(aResult);
       
  1018     }
       
  1019 
       
  1020 TInt CSenServDesc::MT_CSenFacet_ValueL( TTestResult& aResult )
       
  1021     {
       
  1022     return MT_CSenFacet_SetValueLL(aResult);
       
  1023     }
       
  1024 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_L( TTestResult& aResult )
       
  1025     {
       
  1026     SetupL();
       
  1027     
       
  1028     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1029     /*EUNIT_ASSERT_NOT_EQUALS(idProvider, (CSenIdentityProvider*)NULL);*/
       
  1030     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1031 
       
  1032     //checking xml
       
  1033     _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
       
  1034  	/*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*idProvider), KRef);*/
       
  1035  	TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1036     CleanupStack::PopAndDestroy();//Ptr
       
  1037     
       
  1038     
       
  1039     /*__ASSERT_ALWAYS_NO_LEAVE(delete idProvider);*/
       
  1040     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);	
       
  1041     idProvider = NULL;
       
  1042     Teardown();
       
  1043     return KErrNone;
       
  1044     
       
  1045     }
       
  1046     
       
  1047 
       
  1048 TInt CSenServDesc::MT_CSenIdentityProvider_NewLCL( TTestResult& aResult )
       
  1049     {
       
  1050     SetupL();
       
  1051     
       
  1052     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText);
       
  1053     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1054 
       
  1055     //checking xml
       
  1056     //_LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
       
  1057 
       
  1058     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1059     
       
  1060     //CleanupStack::PopAndDestroy();//Ptr
       
  1061     
       
  1062     CleanupStack::Pop();
       
  1063     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1064     idProvider = NULL;
       
  1065     Teardown();
       
  1066     return KErrNone;
       
  1067     }
       
  1068 
       
  1069 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_1L( TTestResult& aResult )
       
  1070     {
       
  1071     SetupL();
       
  1072     
       
  1073     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText);
       
  1074     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1075 
       
  1076     //checking xml
       
  1077     //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
       
  1078     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1079     
       
  1080     //CleanupStack::PopAndDestroy();//Ptr
       
  1081     
       
  1082     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1083     idProvider = NULL;
       
  1084     Teardown();
       
  1085     return KErrNone;
       
  1086     }
       
  1087 
       
  1088 TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_1L( TTestResult& aResult )
       
  1089     {
       
  1090     SetupL();
       
  1091     
       
  1092     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText);
       
  1093     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1094 
       
  1095     //checking xml
       
  1096     //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>");
       
  1097     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1098     
       
  1099     //CleanupStack::PopAndDestroy();//Ptr
       
  1100     CleanupStack::Pop();
       
  1101     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1102     idProvider = NULL;    
       
  1103     Teardown();
       
  1104     return KErrNone;
       
  1105     }
       
  1106 
       
  1107 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_2L( TTestResult& aResult )
       
  1108     {
       
  1109     SetupL();
       
  1110     
       
  1111     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText);
       
  1112     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1113 
       
  1114     //checking xml
       
  1115     //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>");
       
  1116     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1117     
       
  1118     //CleanupStack::PopAndDestroy();//Ptr
       
  1119     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1120     idProvider = NULL;
       
  1121     Teardown();
       
  1122     return KErrNone;
       
  1123     }
       
  1124 
       
  1125 TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_2L( TTestResult& aResult )
       
  1126     {
       
  1127     SetupL();
       
  1128     
       
  1129     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText, KText);
       
  1130     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1131 
       
  1132     //checking xml
       
  1133     //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>");
       
  1134     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1135     
       
  1136     //CleanupStack::PopAndDestroy();//Ptr
       
  1137     CleanupStack::Pop();
       
  1138     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1139     idProvider = NULL;
       
  1140     Teardown();
       
  1141     return KErrNone;
       
  1142     }
       
  1143 
       
  1144 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_3L( TTestResult& aResult )
       
  1145     {
       
  1146     SetupL();
       
  1147     
       
  1148     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText, KText);
       
  1149     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1150 
       
  1151     //checking xml
       
  1152     //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID><ServiceID>text</ServiceID></IdentityProvider>");
       
  1153     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1154     
       
  1155     //CleanupStack::PopAndDestroy();//Ptr
       
  1156     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1157     idProvider = NULL;
       
  1158     Teardown();
       
  1159     return KErrNone;
       
  1160     }
       
  1161 
       
  1162 TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_3L( TTestResult& aResult )
       
  1163     {
       
  1164     SetupL();
       
  1165     
       
  1166     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText, KText, KText);
       
  1167     TL(idProvider != (CSenIdentityProvider*)NULL);
       
  1168 
       
  1169     //checking xml
       
  1170     //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID><ServiceID>text</ServiceID></IdentityProvider>");
       
  1171     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1172     
       
  1173     //CleanupStack::PopAndDestroy();//Ptr
       
  1174     CleanupStack::Pop();
       
  1175     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1176     idProvider = NULL;
       
  1177     Teardown();
       
  1178     return KErrNone;
       
  1179     }
       
  1180 
       
  1181 TInt CSenServDesc::MT_CSenIdentityProvider_AuthzIDL( TTestResult& aResult )
       
  1182     {
       
  1183     SetupL();
       
  1184     
       
  1185     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1186     TL(idProvider->AuthzID() == KNullDesC8);
       
  1187     
       
  1188     __ASSERT_ALWAYS_NO_LEAVE(idProvider->AuthzID());
       
  1189     idProvider->SetUserInfoL(KText2, KNullDesC8, KNullDesC8);
       
  1190     idProvider->SetUserInfoL(KText, KNullDesC8, KNullDesC8);
       
  1191     
       
  1192     //checking xml
       
  1193     _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><AuthzID>text</AuthzID></IdentityProvider>");
       
  1194 
       
  1195     TPtr16 ptr = ConvertToPtr16LC(*idProvider);
       
  1196 	TInt posId(-1);
       
  1197     TPtrC16 messageToParse;
       
  1198     messageToParse.Set(ptr);
       
  1199     posId = messageToParse.Find(_L("<AuthzID>"));
       
  1200     TL(posId != -1);
       
  1201     CleanupStack::PopAndDestroy();//Ptr
       
  1202     
       
  1203     TL(idProvider->AuthzID() == KText);
       
  1204     
       
  1205 
       
  1206     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1207     idProvider = NULL;
       
  1208     Teardown();
       
  1209     return KErrNone;
       
  1210     }
       
  1211 
       
  1212 TInt CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL( TTestResult& aResult )
       
  1213     {
       
  1214     SetupL();
       
  1215     
       
  1216     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1217     TL(idProvider->AdvisoryAuthnID() == KNullDesC8);
       
  1218     
       
  1219     __ASSERT_ALWAYS_NO_LEAVE(idProvider->AdvisoryAuthnID());
       
  1220     idProvider->SetUserInfoL(KNullDesC8, KText2, KNullDesC8);
       
  1221     idProvider->SetUserInfoL(KNullDesC8, KText, KNullDesC8);
       
  1222     
       
  1223     //checking xml
       
  1224     _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><AdvisoryAuthnID>text</AdvisoryAuthnID></IdentityProvider>");
       
  1225 
       
  1226    // TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1227 
       
  1228     //CleanupStack::PopAndDestroy();//Ptr
       
  1229     
       
  1230     TPtr16 ptr = ConvertToPtr16LC(*idProvider);
       
  1231 	TInt posId(-1);
       
  1232     TPtrC16 messageToParse;
       
  1233     messageToParse.Set(ptr);
       
  1234     posId = messageToParse.Find(_L("<AdvisoryAuthnID>"));
       
  1235     TL(posId != -1);
       
  1236     CleanupStack::PopAndDestroy();//Ptr
       
  1237     
       
  1238     TL(idProvider->AdvisoryAuthnID() == KText);
       
  1239 
       
  1240 
       
  1241     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1242     idProvider = NULL;
       
  1243     Teardown();
       
  1244     return KErrNone;
       
  1245     }
       
  1246 
       
  1247 TInt CSenServDesc::MT_CSenIdentityProvider_ProviderIDL( TTestResult& aResult )
       
  1248     {
       
  1249     SetupL();
       
  1250     
       
  1251     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText2);
       
  1252     __ASSERT_ALWAYS_NO_LEAVE(idProvider->ProviderID());
       
  1253     TL(idProvider->ProviderID() == KText2);
       
  1254 
       
  1255     delete idProvider;
       
  1256     idProvider = NULL;
       
  1257     Teardown();
       
  1258     return KErrNone;
       
  1259     }
       
  1260 
       
  1261 TInt CSenServDesc::MT_CSenIdentityProvider_PasswordL( TTestResult& aResult )
       
  1262     {
       
  1263     SetupL();
       
  1264     
       
  1265     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1266     __ASSERT_ALWAYS_NO_LEAVE(idProvider->Password());
       
  1267     TL(idProvider->Password() == KNullDesC8);
       
  1268 
       
  1269     idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText2);
       
  1270     idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText);
       
  1271     //checking xml
       
  1272     _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><Password>text</Password></IdentityProvider>");
       
  1273     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1274 
       
  1275    //CleanupStack::PopAndDestroy();//Ptr
       
  1276     TPtr16 ptr = ConvertToPtr16LC(*idProvider);
       
  1277 	TInt posId(-1);
       
  1278     TPtrC16 messageToParse;
       
  1279     messageToParse.Set(ptr);
       
  1280     posId = messageToParse.Find(_L("<Password>"));
       
  1281     TL(posId != -1);
       
  1282    CleanupStack::PopAndDestroy();//Ptr
       
  1283     
       
  1284     TL(idProvider->Password() == KText);
       
  1285 
       
  1286 
       
  1287     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1288     idProvider = NULL;
       
  1289     Teardown();
       
  1290     return KErrNone;
       
  1291     }
       
  1292 
       
  1293 TInt CSenServDesc::MT_CSenIdentityProvider_IMEIL( TTestResult& aResult )
       
  1294     {
       
  1295     SetupL();
       
  1296     
       
  1297     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1298     __ASSERT_ALWAYS_NO_LEAVE(idProvider->IMEI());
       
  1299     idProvider->IMEI();
       
  1300 
       
  1301     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1302     idProvider = NULL;
       
  1303     Teardown();
       
  1304     return KErrNone;
       
  1305     }
       
  1306 
       
  1307 TInt CSenServDesc::MT_CSenIdentityProvider_UserNameL( TTestResult& aResult )
       
  1308     {
       
  1309     SetupL();
       
  1310     
       
  1311     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1312     __ASSERT_ALWAYS_NO_LEAVE(idProvider->UserName());
       
  1313     TL(idProvider->UserName() == KNullDesC8);
       
  1314 
       
  1315     idProvider->SetUserInfoL(KNullDesC8, KText, KNullDesC8);
       
  1316     TL(idProvider->UserName()== KText);
       
  1317 
       
  1318     idProvider->SetUserInfoL(KText, KNullDesC8, KNullDesC8);
       
  1319     TL(idProvider->UserName() == KText);
       
  1320 
       
  1321     idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText);
       
  1322 
       
  1323     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1324     idProvider = NULL;
       
  1325     Teardown();
       
  1326     return KErrNone;
       
  1327     }
       
  1328 
       
  1329 TInt CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL( TTestResult& aResult )
       
  1330     {
       
  1331     SetupL();
       
  1332     
       
  1333     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1334     __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetProviderID(KText2)); 
       
  1335     __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetProviderID(KText)); 
       
  1336     //checking xml
       
  1337     _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>");
       
  1338     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1339 	TPtr16 ptr = ConvertToPtr16LC(*idProvider);
       
  1340 	TInt posId(-1);
       
  1341     TPtrC16 messageToParse;
       
  1342     messageToParse.Set(ptr);
       
  1343     posId = messageToParse.Find(_L("<ProviderID>"));
       
  1344     TL(posId != -1);
       
  1345     CleanupStack::PopAndDestroy();//Ptr
       
  1346     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1347     idProvider = NULL;
       
  1348     Teardown();
       
  1349     return KErrNone;
       
  1350     }
       
  1351 
       
  1352 TInt CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL( TTestResult& aResult )
       
  1353     {
       
  1354     SetupL();
       
  1355     
       
  1356     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1357     __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetServiceID(KText2)); 
       
  1358     __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetServiceID(KText)); 
       
  1359     //checking xml
       
  1360     _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><ServiceID>text</ServiceID></IdentityProvider>");
       
  1361     //TL(ConvertToPtr16LC(*idProvider) == KRef);
       
  1362 
       
  1363 	TPtr16 ptr = ConvertToPtr16LC(*idProvider);
       
  1364 	TInt posId(-1);
       
  1365     TPtrC16 messageToParse;
       
  1366     messageToParse.Set(ptr);
       
  1367     posId = messageToParse.Find(_L("<ServiceID>"));
       
  1368     TL(posId != -1);
       
  1369     CleanupStack::PopAndDestroy();//Ptr
       
  1370     
       
  1371     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1372     idProvider = NULL;
       
  1373     Teardown();
       
  1374     return KErrNone;
       
  1375     }
       
  1376 
       
  1377 TInt CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL( TTestResult& aResult )
       
  1378     {
       
  1379     SetupL();
       
  1380     TBool retVal;
       
  1381     CSenXmlServiceDescription* serviceDesc = CSenXmlServiceDescription::NewL(KText, KText2) ;
       
  1382     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(_L8("endpoint"), _L8("contract"), KText, KText2);
       
  1383     retVal = idProvider->IsTrustedByL(*serviceDesc); 
       
  1384 	
       
  1385 	if(retVal);
       
  1386     
       
  1387     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1388     idProvider = NULL;
       
  1389     __ASSERT_ALWAYS_NO_LEAVE(delete serviceDesc);
       
  1390     serviceDesc = NULL;
       
  1391     Teardown();
       
  1392     return KErrNone;
       
  1393     }
       
  1394 
       
  1395 TInt CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L( TTestResult& aResult )
       
  1396     {
       
  1397     SetupL();
       
  1398     TBool retVal;
       
  1399     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(_L8("endpoint"), _L8("contract"), KText, KText2);
       
  1400     retVal = idProvider->IsTrustedByL(KText); 
       
  1401 
       
  1402     if(retVal);
       
  1403     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1404     idProvider = NULL;
       
  1405     Teardown();
       
  1406     return KErrNone;
       
  1407     }
       
  1408     
       
  1409 
       
  1410 TInt CSenServDesc::MT_CSenIdentityProvider_IsDefaultL( TTestResult& aResult )
       
  1411     {
       
  1412     SetupL();
       
  1413     TBool retVal;
       
  1414     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1415     retVal = idProvider->IsDefault(); 
       
  1416 	
       
  1417 	if(retVal);
       
  1418     
       
  1419     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1420     idProvider = NULL;
       
  1421     Teardown();
       
  1422     return KErrNone;
       
  1423     }
       
  1424 
       
  1425 
       
  1426 
       
  1427 TInt CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL( TTestResult& aResult )
       
  1428     {
       
  1429     SetupL();
       
  1430     
       
  1431     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1432     //retVal = idProvider->HttpCredentialsL(); 
       
  1433 
       
  1434     
       
  1435     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1436     idProvider = NULL;
       
  1437     Teardown();
       
  1438     return KErrNone;
       
  1439     }
       
  1440 
       
  1441 TInt CSenServDesc::MT_CSenIdentityProvider_NewElementNameL( TTestResult& aResult )
       
  1442     {
       
  1443     SetupL();
       
  1444     
       
  1445     CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText);
       
  1446     TL(idProvider->NewElementName() == _L8("IdentityProvider"));
       
  1447 
       
  1448     __ASSERT_ALWAYS_NO_LEAVE(idProvider->NewElementName());
       
  1449     __ASSERT_ALWAYS_NO_LEAVE(delete idProvider);
       
  1450     idProvider = NULL;
       
  1451     Teardown();
       
  1452     return KErrNone;
       
  1453     }
       
  1454 
       
  1455 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL( TTestResult& aResult )
       
  1456     {
       
  1457     SetupL();
       
  1458     
       
  1459     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
       
  1460     TL(array->IsStrict() == FALSE);
       
  1461 
       
  1462     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1463     array = NULL;
       
  1464     Teardown();
       
  1465     return KErrNone;
       
  1466     }
       
  1467 
       
  1468 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL( TTestResult& aResult )
       
  1469     {
       
  1470     SetupL();
       
  1471     
       
  1472     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewLC();
       
  1473     TL(array->IsStrict() == FALSE);
       
  1474 
       
  1475     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1476     CleanupStack::Pop();
       
  1477     array = NULL;
       
  1478     Teardown();
       
  1479     return KErrNone;
       
  1480     }
       
  1481 
       
  1482 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L( TTestResult& aResult )
       
  1483     {
       
  1484     SetupL();
       
  1485     
       
  1486     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(FALSE);
       
  1487     TL(array->IsStrict() == FALSE);
       
  1488 
       
  1489     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1490     array = NULL;
       
  1491     
       
  1492     array = CSenIdentityProviderIdArray8::NewL(TRUE);
       
  1493     TL(array->IsStrict() == TRUE);
       
  1494 
       
  1495     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1496     array = NULL;
       
  1497         
       
  1498     Teardown();
       
  1499     return KErrNone;
       
  1500     }
       
  1501 
       
  1502 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L( TTestResult& aResult )
       
  1503     {
       
  1504     SetupL();
       
  1505     
       
  1506     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewLC(FALSE);
       
  1507     TL(array->IsStrict() == FALSE);
       
  1508 
       
  1509     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1510     CleanupStack::Pop();
       
  1511     array = NULL;
       
  1512     
       
  1513     array = CSenIdentityProviderIdArray8::NewLC(TRUE);
       
  1514     TL(array->IsStrict() == TRUE);
       
  1515 
       
  1516     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1517     CleanupStack::Pop();
       
  1518     array = NULL;
       
  1519     Teardown();
       
  1520     return KErrNone;
       
  1521     }
       
  1522 
       
  1523 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL( TTestResult& aResult )
       
  1524     {
       
  1525     SetupL();
       
  1526     
       
  1527     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
       
  1528     __ASSERT_ALWAYS_NO_LEAVE(array->SetStrict(TRUE));
       
  1529     TL(array->IsStrict() == TRUE);
       
  1530 
       
  1531     __ASSERT_ALWAYS_NO_LEAVE(array->SetStrict(FALSE));
       
  1532     TL(array->IsStrict() == FALSE);
       
  1533 
       
  1534     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1535     array = NULL;
       
  1536     Teardown();
       
  1537     return KErrNone;
       
  1538     }
       
  1539 
       
  1540 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL( TTestResult& aResult )
       
  1541     {
       
  1542     return MT_CSenIdentityProviderIdArray8_IsStrictL(aResult);
       
  1543     }
       
  1544 
       
  1545 TInt CSenServDesc::MT_CSenServicePattern_NewLL( TTestResult& aResult )
       
  1546     {
       
  1547     SetupL();
       
  1548     
       
  1549     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1550     //checking xml
       
  1551     //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1552     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1553 
       
  1554     //CleanupStack::PopAndDestroy();//Ptr
       
  1555     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1556     pattern = NULL;
       
  1557     Teardown();
       
  1558     return KErrNone;
       
  1559     }
       
  1560 
       
  1561 TInt CSenServDesc::MT_CSenServicePattern_NewLCL( TTestResult& aResult )
       
  1562     {
       
  1563     SetupL();
       
  1564     
       
  1565     CSenServicePattern* pattern = CSenServicePattern::NewLC();
       
  1566     //checking xml
       
  1567     //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1568     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1569 
       
  1570     //CleanupStack::PopAndDestroy();//Ptr
       
  1571     CleanupStack::Pop();
       
  1572     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1573     pattern = NULL;
       
  1574     Teardown();
       
  1575     return KErrNone;
       
  1576     }
       
  1577 
       
  1578 TInt CSenServDesc::MT_CSenServicePattern_NewL_1L( TTestResult& aResult )
       
  1579     {
       
  1580     SetupL();
       
  1581     
       
  1582     CSenServicePattern* pattern = CSenServicePattern::NewL(KText);
       
  1583     //checking xml
       
  1584     //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1585     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1586 
       
  1587     //CleanupStack::PopAndDestroy();//Ptr
       
  1588     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1589     pattern = NULL;
       
  1590     Teardown();
       
  1591     return KErrNone;
       
  1592     }
       
  1593 
       
  1594 TInt CSenServDesc::MT_CSenServicePattern_NewLC_1L( TTestResult& aResult )
       
  1595     {
       
  1596     SetupL();
       
  1597     
       
  1598     CSenServicePattern* pattern = CSenServicePattern::NewLC(KText);
       
  1599     //checking xml
       
  1600     //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1601     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1602 
       
  1603     //CleanupStack::PopAndDestroy();//Ptr
       
  1604     CleanupStack::Pop();
       
  1605     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1606     pattern = NULL;
       
  1607     Teardown();
       
  1608     return KErrNone;
       
  1609     }
       
  1610 
       
  1611 TInt CSenServDesc::MT_CSenServicePattern_NewL_2L( TTestResult& aResult )
       
  1612     {
       
  1613     SetupL();
       
  1614     
       
  1615     CSenServicePattern* pattern = CSenServicePattern::NewL(KText, KText);
       
  1616     
       
  1617     //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1618     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1619 
       
  1620     //CleanupStack::PopAndDestroy();//Ptr
       
  1621     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1622     pattern = NULL;
       
  1623     Teardown();
       
  1624     return KErrNone;
       
  1625     }
       
  1626 
       
  1627 TInt CSenServDesc::MT_CSenServicePattern_NewLC_2L( TTestResult& aResult )
       
  1628     {
       
  1629     SetupL();
       
  1630     
       
  1631     CSenServicePattern* pattern = CSenServicePattern::NewLC(KText, KText);
       
  1632     
       
  1633     //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1634     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1635 
       
  1636     //CleanupStack::PopAndDestroy();//Ptr
       
  1637     CleanupStack::Pop();
       
  1638     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1639     pattern = NULL;
       
  1640     Teardown();
       
  1641     return KErrNone;
       
  1642     }
       
  1643 
       
  1644 TInt CSenServDesc::MT_CSenServicePattern_MatchesL( TTestResult& aResult )
       
  1645     {
       
  1646      SetupL();
       
  1647     CSenServicePattern *pattern2;
       
  1648     CSenServicePattern *pattern;
       
  1649     
       
  1650     pattern = CSenServicePattern::NewL();
       
  1651     //EUNIT_ASSERT_EQUALS(pattern->Matches(*pattern2), FALSE);
       
  1652     
       
  1653     pattern2 = CSenServicePattern::NewL();
       
  1654     //checking xml
       
  1655     TL(pattern->Matches(*pattern2) == TRUE);
       
  1656     __ASSERT_ALWAYS_NO_LEAVE(delete pattern2);
       
  1657     pattern2 = NULL;
       
  1658     
       
  1659     CSenXmlServiceDescription* xmlDescr = CSenXmlServiceDescription::NewL();
       
  1660     TL(pattern->Matches(*xmlDescr) == FALSE);
       
  1661     
       
  1662     __ASSERT_ALWAYS_NO_LEAVE(delete xmlDescr);
       
  1663     xmlDescr = NULL;
       
  1664     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1665     pattern = NULL;    
       
  1666     Teardown();
       
  1667     return KErrNone;    
       
  1668     }
       
  1669 
       
  1670 TInt CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL( TTestResult& aResult )
       
  1671     {
       
  1672     SetupL();
       
  1673     
       
  1674     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1675     //checking xml
       
  1676     
       
  1677     TUint32 iap(0);
       
  1678     TL(pattern->ConsumerIapId(iap) == KErrNotFound);
       
  1679 
       
  1680     
       
  1681     pattern->SetConsumerIapIdL(1);
       
  1682     __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerIapId(iap));
       
  1683     TL(pattern->ConsumerIapId(iap) == KErrNone);
       
  1684 
       
  1685     TL(iap == 1);
       
  1686     pattern->SetConsumerIapIdL(2);
       
  1687     __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerIapId(iap));
       
  1688     TL(pattern->ConsumerIapId(iap) == KErrNone);
       
  1689 
       
  1690     TL(iap == 2);
       
  1691 
       
  1692     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1693     pattern = NULL;
       
  1694     Teardown();
       
  1695     return KErrNone;
       
  1696     }
       
  1697 
       
  1698 TInt CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL( TTestResult& aResult )
       
  1699     {
       
  1700     SetupL();
       
  1701     
       
  1702     MT_CSenServicePattern_SetConsumerIapIdLL(aResult);
       
  1703     Teardown();
       
  1704     return KErrNone;
       
  1705     }
       
  1706 TInt CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL( TTestResult& aResult )
       
  1707     {
       
  1708     SetupL();
       
  1709     
       
  1710     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1711     //checking xml
       
  1712     
       
  1713     TUint32 iap(0);
       
  1714     TL(pattern->ConsumerSnapId(iap) == KErrNotFound);
       
  1715 
       
  1716     
       
  1717     pattern->SetConsumerSnapIdL(1);
       
  1718     __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerSnapId(iap));
       
  1719     TL(pattern->ConsumerSnapId(iap) == KErrNone);
       
  1720 
       
  1721     TL(iap == 1);
       
  1722 
       
  1723     pattern->SetConsumerSnapIdL(0);
       
  1724     __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerSnapId(iap));
       
  1725     TL(pattern->ConsumerSnapId(iap) == KErrNotFound);
       
  1726 
       
  1727    // TL(iap == 0);
       
  1728 
       
  1729     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1730     pattern = NULL;
       
  1731     Teardown();
       
  1732     
       
  1733     return KErrNone;
       
  1734     }
       
  1735 
       
  1736 TInt CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL( TTestResult& aResult )
       
  1737     {
       
  1738     
       
  1739     SetupL();
       
  1740     
       
  1741     MT_CSenServicePattern_SetConsumerSnapIdLL(aResult);
       
  1742     Teardown();
       
  1743     
       
  1744     return KErrNone;
       
  1745     }
       
  1746 
       
  1747 
       
  1748 TInt CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL( TTestResult& aResult )
       
  1749     {
       
  1750     SetupL();
       
  1751     
       
  1752     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1753     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
       
  1754     
       
  1755     
       
  1756     __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
       
  1757     pattern->AddConsumerIdentityProviderIdL(KText);
       
  1758     __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
       
  1759     array->AppendL(KText);
       
  1760     __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
       
  1761     array->AppendL(KText2);
       
  1762     __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array));
       
  1763     
       
  1764     TL((pattern->ConsumerIdentityProviderIds8L()).Count() == 2);
       
  1765 
       
  1766     TInt pos(0);
       
  1767     if(!((pattern->ConsumerIdentityProviderIds8L()).Find(KText, pos)==KErrNone))return KErrArgument;
       
  1768 
       
  1769     if(!((pattern->ConsumerIdentityProviderIds8L()).Find(KText2, pos)==KErrNone))return KErrArgument;
       
  1770 
       
  1771     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1772     array = NULL;
       
  1773     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1774     pattern = NULL;
       
  1775     Teardown();
       
  1776     return KErrNone;
       
  1777     }
       
  1778 
       
  1779 TInt CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL( TTestResult& aResult )
       
  1780     {
       
  1781     SetupL();
       
  1782     
       
  1783     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1784     
       
  1785 
       
  1786     if(!(pattern->AddConsumerIdentityProviderIdL(KNullDesC8) == KErrArgument))return KErrArgument;
       
  1787 
       
  1788     if(!(pattern->AddConsumerIdentityProviderIdL(KText) == KErrNone))return KErrArgument;
       
  1789 
       
  1790     if(!(pattern->AddConsumerIdentityProviderIdL(KText) == KErrAlreadyExists))return KErrArgument;
       
  1791 
       
  1792     if(!(pattern->AddConsumerIdentityProviderIdL(KText2) == KErrNone))return KErrArgument;
       
  1793 
       
  1794     _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1795     //TL(ConvertToPtr16LC(*pattern) == KRef);
       
  1796 
       
  1797     //CleanupStack::PopAndDestroy();//Ptr
       
  1798     
       
  1799     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1800     pattern = NULL;    
       
  1801     Teardown();
       
  1802     return KErrNone;
       
  1803     }
       
  1804 
       
  1805 TInt CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL( TTestResult& aResult )
       
  1806     {
       
  1807     return MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL(aResult);
       
  1808     }
       
  1809 
       
  1810 TInt CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL( TTestResult& aResult )
       
  1811     {
       
  1812     SetupL();
       
  1813     
       
  1814     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1815     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
       
  1816     
       
  1817     pattern->SetConsumerIapIdL(1);
       
  1818     array->AppendL(KText);
       
  1819     
       
  1820     CSenServicePattern* pattern2 = CSenServicePattern::NewL();
       
  1821     if(!(pattern2->RebuildFromConsumerPolicy(*pattern)==KErrNone))return KErrArgument;
       
  1822 
       
  1823     if(!(pattern2->AcceptsConsumerPolicy(*pattern)==TRUE))return KErrArgument;
       
  1824 
       
  1825     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  1826     __ASSERT_ALWAYS_NO_LEAVE(delete pattern2);
       
  1827     array = NULL;
       
  1828     pattern2 = NULL;
       
  1829 //false
       
  1830     pattern2 = CSenServicePattern::NewL();
       
  1831     pattern2->SetConsumerIapIdL(2);
       
  1832     if(!(pattern2->AcceptsConsumerPolicy(*pattern)==FALSE))return KErrArgument;
       
  1833 
       
  1834     __ASSERT_ALWAYS_NO_LEAVE(delete pattern2);
       
  1835     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1836     pattern2 = NULL;
       
  1837     pattern = NULL;
       
  1838     Teardown();
       
  1839     return KErrNone;
       
  1840     }
       
  1841 
       
  1842 TInt CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL( TTestResult& aResult )
       
  1843     {
       
  1844     return MT_CSenServicePattern_AcceptsConsumerPolicyL(aResult);
       
  1845     }
       
  1846 
       
  1847 TInt CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL( TTestResult& aResult )
       
  1848     {
       
  1849     SetupL();
       
  1850     HBufC8* retVal;
       
  1851     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1852     
       
  1853     retVal = pattern->ConsumerPolicyAsXmlL();
       
  1854     
       
  1855     if(retVal);
       
  1856     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1857     pattern = NULL;
       
  1858     Teardown();
       
  1859     return KErrNone;
       
  1860     }
       
  1861 
       
  1862 TInt CSenServDesc::MT_CSenServicePattern_StartElementLL( TTestResult& aResult )
       
  1863     {
       
  1864     SetupL();
       
  1865     //HBufC8* retVal;
       
  1866     _LIT8(KText, "text");
       
  1867     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  1868     RAttributeArray array;
       
  1869     pattern->StartElementL(KText, KText, KText, array);
       
  1870     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  1871     pattern = NULL;
       
  1872     Teardown();
       
  1873     return KErrNone;
       
  1874     }
       
  1875 
       
  1876 
       
  1877 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLL( TTestResult& aResult )
       
  1878     {
       
  1879     SetupL();
       
  1880     
       
  1881     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  1882     if(xmlService == NULL)
       
  1883      return KErrNoMemory;
       
  1884     //checking xml
       
  1885     //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1886     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  1887 
       
  1888     //CleanupStack::PopAndDestroy();//Ptr
       
  1889     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  1890     xmlService = NULL;
       
  1891     Teardown();
       
  1892     return KErrNone;
       
  1893     }
       
  1894 
       
  1895 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLCL( TTestResult& aResult )
       
  1896     {
       
  1897     SetupL();
       
  1898     
       
  1899     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC();
       
  1900     if(xmlService == NULL)
       
  1901      return KErrNoMemory;
       
  1902     //checking xml
       
  1903     //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1904     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  1905 
       
  1906     //CleanupStack::PopAndDestroy();//Ptr
       
  1907     CleanupStack::Pop();
       
  1908     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  1909     xmlService = NULL;
       
  1910     Teardown();
       
  1911     return KErrNone;
       
  1912     }
       
  1913 
       
  1914 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L( TTestResult& aResult )
       
  1915     {
       
  1916     SetupL();
       
  1917     
       
  1918     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText);
       
  1919     if(xmlService == NULL)
       
  1920      return KErrNoMemory;
       
  1921     //checking xml
       
  1922     //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1923     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  1924 
       
  1925     //CleanupStack::PopAndDestroy();//Ptr
       
  1926     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  1927     xmlService = NULL;
       
  1928     Teardown();
       
  1929     return KErrNone;
       
  1930     }
       
  1931 
       
  1932 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L( TTestResult& aResult )
       
  1933     {
       
  1934     SetupL();
       
  1935     
       
  1936     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(KText);
       
  1937     if(xmlService == NULL)
       
  1938      return KErrNoMemory;
       
  1939      //checking xml
       
  1940     //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1941     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  1942 
       
  1943     //CleanupStack::PopAndDestroy();//Ptr
       
  1944     CleanupStack::Pop();
       
  1945     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  1946     xmlService = NULL;
       
  1947     Teardown();
       
  1948     return KErrNone;
       
  1949     }
       
  1950 
       
  1951 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L( TTestResult& aResult )
       
  1952     {
       
  1953     SetupL();
       
  1954     
       
  1955     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  1956     if(xmlService == NULL)
       
  1957      return KErrNoMemory;
       
  1958      //checking xml
       
  1959     //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1960     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  1961 
       
  1962     //CleanupStack::PopAndDestroy();//Ptr
       
  1963     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  1964     xmlService = NULL;
       
  1965     Teardown();
       
  1966     return KErrNone;
       
  1967     }
       
  1968 
       
  1969 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L( TTestResult& aResult )
       
  1970     {
       
  1971     SetupL();
       
  1972     
       
  1973     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(KText, KText);
       
  1974     if(xmlService == NULL)
       
  1975      return KErrNoMemory;
       
  1976      //checking xml
       
  1977     //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  1978     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  1979 
       
  1980     //CleanupStack::PopAndDestroy();//Ptr
       
  1981     CleanupStack::Pop();
       
  1982     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  1983     xmlService = NULL;
       
  1984     Teardown();
       
  1985     return KErrNone;
       
  1986     }
       
  1987 
       
  1988 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL( TTestResult& aResult )
       
  1989     {
       
  1990     SetupL();
       
  1991     
       
  1992     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  1993 
       
  1994     TL(xmlService->FrameworkId() == KNullDesC8);
       
  1995 
       
  1996     _LIT8(KFr, "ID-WSF");
       
  1997     xmlService->SetFrameworkIdL(KFr);
       
  1998     //checking xml
       
  1999     _LIT16(KRef1, "<ServiceDescription framework=\"ID-WSF\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  2000     //TL(ConvertToPtr16LC(*xmlService) == KRef1);
       
  2001 
       
  2002 	TPtr16 ptr = ConvertToPtr16LC(*xmlService);
       
  2003 	TInt posId(-1);
       
  2004     TPtrC16 messageToParse;
       
  2005     messageToParse.Set(ptr);
       
  2006     posId = messageToParse.Find(_L("framework=\"ID-WSF\""));
       
  2007 	TL(posId != -1);
       
  2008     CleanupStack::PopAndDestroy();//Ptr
       
  2009     TL(xmlService->FrameworkId() == KFr);
       
  2010 
       
  2011     //again
       
  2012     xmlService->SetFrameworkIdL(KFr);
       
  2013     //checking xml
       
  2014     //_LIT16(KRef2, "<ServiceDescription framework=\"ID-WSF\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  2015     //TL(ConvertToPtr16LC(*xmlService) == KRef2);
       
  2016 
       
  2017 	TPtr16 ptr1 = ConvertToPtr16LC(*xmlService);
       
  2018 	posId = -1;
       
  2019     messageToParse.Set(ptr1);
       
  2020 	posId = messageToParse.Find(_L("framework=\"ID-WSF\""));
       
  2021 	TL(posId != -1);
       
  2022     CleanupStack::PopAndDestroy();//Ptr1
       
  2023     TL(xmlService->FrameworkId() == KFr);
       
  2024 
       
  2025     //again
       
  2026     xmlService->SetFrameworkIdL(KText);
       
  2027     //checking xml
       
  2028     //_LIT16(KRef3, "<ServiceDescription framework=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  2029     //TL(ConvertToPtr16LC(*xmlService) == KRef3);
       
  2030 	TPtr16 ptr2 = ConvertToPtr16LC(*xmlService);
       
  2031 	posId =-1;
       
  2032     messageToParse.Set(ptr2);
       
  2033     posId = messageToParse.Find(_L("framework=\"text\""));
       
  2034     TL(posId != -1);
       
  2035     CleanupStack::PopAndDestroy();//Ptr2
       
  2036     TL(xmlService->FrameworkId() == KText);
       
  2037 
       
  2038     //clear
       
  2039     xmlService->SetFrameworkIdL(KNullDesC8);
       
  2040     //checking xml
       
  2041     //_LIT16(KRef4, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  2042     //TL(ConvertToPtr16LC(*xmlService) == KRef4);
       
  2043 	TPtr16 ptr3 = ConvertToPtr16LC(*xmlService);
       
  2044 	posId = -1;
       
  2045     messageToParse.Set(ptr3);
       
  2046     posId = messageToParse.Find(_L("ServiceDescription"));
       
  2047     TL(posId != -1);
       
  2048     CleanupStack::PopAndDestroy();//Ptr3
       
  2049     TL(xmlService->FrameworkId() == KNullDesC8);
       
  2050 
       
  2051     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2052     xmlService = NULL;
       
  2053     Teardown();
       
  2054     return KErrNone;
       
  2055     }
       
  2056 
       
  2057 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL( TTestResult& aResult )
       
  2058     {
       
  2059     SetupL();
       
  2060     
       
  2061     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2062     _LIT8(KRef, "ServiceDescription");
       
  2063     if(!(xmlService ->NewElementName() == KRef))return KErrArgument;
       
  2064 
       
  2065     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2066     xmlService = NULL;
       
  2067     Teardown();
       
  2068     return KErrNone;
       
  2069     }
       
  2070 
       
  2071 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL( TTestResult& aResult )
       
  2072     {
       
  2073     SetupL();
       
  2074     
       
  2075     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2076     TUint32 iap(0);
       
  2077     if(!((xmlService ->IapId(iap)) == KErrNotFound))return KErrArgument;
       
  2078 
       
  2079     xmlService ->SetIapIdL(1);
       
  2080     if(!(xmlService ->IapId(iap) == KErrNone))return KErrArgument;
       
  2081 
       
  2082     if(!(1))return KErrArgument;
       
  2083 
       
  2084     xmlService ->SetIapIdL(2);
       
  2085     if(!(xmlService ->IapId(iap) == KErrNone))return KErrArgument;
       
  2086 
       
  2087     if(!(2))return KErrArgument;
       
  2088 
       
  2089     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2090     xmlService = NULL;
       
  2091     Teardown();
       
  2092     return KErrNone;
       
  2093     }
       
  2094 
       
  2095 TInt CSenServDesc::MT_CSenXmlServiceDescription_IapIdL( TTestResult& aResult )
       
  2096     {
       
  2097     return MT_CSenXmlServiceDescription_SetIapIdLL(aResult);
       
  2098     }
       
  2099     
       
  2100 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL( TTestResult& aResult )
       
  2101     {
       
  2102     SetupL();
       
  2103     
       
  2104     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2105     TUint32 iap(0);
       
  2106     if(!((xmlService ->SnapId(iap)) == KErrNotFound))return KErrArgument;
       
  2107 
       
  2108     xmlService ->SetSnapIdL(1);
       
  2109     if(!(xmlService ->SnapId(iap) == KErrNone))return KErrArgument;
       
  2110 
       
  2111     if(!(1))return KErrArgument;
       
  2112 
       
  2113     xmlService ->SetSnapIdL(2);
       
  2114     if(!(xmlService ->SnapId(iap) == KErrNone))return KErrArgument;
       
  2115 
       
  2116     if(!(2))return KErrArgument;
       
  2117 
       
  2118     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2119     xmlService = NULL;
       
  2120     Teardown();
       
  2121     return KErrNone;
       
  2122     }
       
  2123 
       
  2124 TInt CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL( TTestResult& aResult )
       
  2125     {
       
  2126     return MT_CSenXmlServiceDescription_SetSnapIdLL(aResult);
       
  2127     }
       
  2128 
       
  2129 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL( TTestResult& aResult )
       
  2130     {
       
  2131     SetupL();
       
  2132     
       
  2133     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2134     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
       
  2135     
       
  2136     
       
  2137     __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
       
  2138     
       
  2139     TPtrC8 ptrText = KText();
       
  2140     xmlService->AddIdentityProviderIdL(ptrText);
       
  2141 
       
  2142     __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
       
  2143     array->AppendL(KText);
       
  2144     __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
       
  2145     array->AppendL(KText2);
       
  2146     __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array));
       
  2147     
       
  2148     TL((xmlService->IdentityProviderIds8L()).Count() == 2);
       
  2149 
       
  2150     TInt pos(0);
       
  2151     if(!((xmlService->IdentityProviderIds8L()).Find(KText, pos)==KErrNone))return KErrArgument;
       
  2152 
       
  2153     if(!((xmlService->IdentityProviderIds8L()).Find(KText2, pos)==KErrNone))return KErrArgument;
       
  2154 
       
  2155     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  2156     array = NULL;
       
  2157     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2158     xmlService = NULL;
       
  2159     Teardown();
       
  2160     return KErrNone;
       
  2161     }
       
  2162 
       
  2163 TInt CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL( TTestResult& aResult )
       
  2164     {
       
  2165     SetupL();
       
  2166     
       
  2167     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2168     TPtrC8 ptr = KNullDesC8();
       
  2169     if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrArgument))return KErrArgument;
       
  2170 
       
  2171     ptr.Set(KText);
       
  2172     if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrNone))return KErrArgument;
       
  2173 
       
  2174     if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrAlreadyExists))return KErrArgument;
       
  2175 
       
  2176     ptr.Set(KText2);
       
  2177     if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrNone))return KErrArgument;
       
  2178 
       
  2179 
       
  2180     _LIT16(KRef, "<ServiceDescription><ProviderPolicy><IdentityProviderIDs><IdentityProviderID>text</IdentityProviderID><IdentityProviderID>text2</IdentityProviderID></IdentityProviderIDs></ProviderPolicy><ServicePolicy/></ServiceDescription>");
       
  2181     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  2182 
       
  2183     //CleanupStack::PopAndDestroy();//Ptr
       
  2184     
       
  2185     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2186     xmlService = NULL;
       
  2187     Teardown();
       
  2188     return KErrNone;
       
  2189     }
       
  2190 
       
  2191 TInt CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL( TTestResult& aResult )
       
  2192     {
       
  2193     SetupL();
       
  2194     
       
  2195     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2196     CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL();
       
  2197     
       
  2198     xmlService->SetIapIdL(1);
       
  2199     array->AppendL(KText);
       
  2200     
       
  2201     CSenXmlServiceDescription* xmlService2 = CSenXmlServiceDescription::NewL();
       
  2202     if(!(xmlService2->RebuildFrom(*xmlService)==KErrNone))return KErrArgument;
       
  2203 
       
  2204     if(!(xmlService2->Accepts(*xmlService)==TRUE))return KErrArgument;
       
  2205 
       
  2206     __ASSERT_ALWAYS_NO_LEAVE(delete array);
       
  2207     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2208     array = NULL;
       
  2209     xmlService2 = NULL;
       
  2210 //false
       
  2211     xmlService2 = CSenServicePattern::NewL();
       
  2212     xmlService2->SetIapIdL(2);
       
  2213     if(!(xmlService2->Accepts(*xmlService)==FALSE))return KErrArgument;
       
  2214 
       
  2215     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2216     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2217     xmlService2 = NULL;
       
  2218     xmlService = NULL;
       
  2219     Teardown();
       
  2220     return KErrNone;
       
  2221     }
       
  2222 
       
  2223 TInt CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL( TTestResult& aResult )
       
  2224     {
       
  2225     return MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL(aResult);
       
  2226     }
       
  2227 
       
  2228 TInt CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL( TTestResult& aResult )
       
  2229     {
       
  2230     return MT_CSenXmlServiceDescription_RebuildFromL(aResult);
       
  2231     }
       
  2232 
       
  2233 TInt CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL( TTestResult& aResult )
       
  2234     {
       
  2235     SetupL();
       
  2236     
       
  2237     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2238     if(!(xmlService ->DescriptionClassType() == MSenServiceDescription::EXmlServiceDescription))return KErrArgument;
       
  2239 
       
  2240     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2241     xmlService = NULL;
       
  2242     Teardown();
       
  2243     return KErrNone;
       
  2244     }
       
  2245 
       
  2246 TInt CSenServDesc::MT_CSenXmlServiceDescription_MatchesL( TTestResult& aResult )
       
  2247     {
       
  2248     SetupL();
       
  2249     
       
  2250     CSenXmlServiceDescription *xmlService;
       
  2251     CSenXmlServiceDescription *xmlService2(NULL);
       
  2252     
       
  2253     xmlService = CSenXmlServiceDescription::NewL();
       
  2254     //EUNIT_ASSERT_EQUALS(xmlService->Matches(*xmlService2), FALSE);
       
  2255     
       
  2256     xmlService2 = CSenXmlServiceDescription::NewL();
       
  2257     //checking xml
       
  2258     TL(xmlService ->Matches(*xmlService2) == TRUE);
       
  2259     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2260     xmlService2 = NULL;
       
  2261     
       
  2262     CSenServicePattern* pattern = CSenServicePattern::NewL();
       
  2263     //EUNIT_ASSERT_EQUALS(xmlService->Matches(*pattern), FALSE);
       
  2264     TL(xmlService->Matches(*pattern) == TRUE);
       
  2265     
       
  2266     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2267     xmlService = NULL;
       
  2268     __ASSERT_ALWAYS_NO_LEAVE(delete pattern);
       
  2269     pattern = NULL;  
       
  2270     Teardown();
       
  2271     return KErrNone;
       
  2272       
       
  2273     }
       
  2274     
       
  2275 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL( TTestResult& aResult )
       
  2276     {
       
  2277     SetupL();
       
  2278     
       
  2279     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2280      
       
  2281     __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetProviderIdL(KText2)); 
       
  2282     __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetProviderIdL(KText)); 
       
  2283    
       
  2284     //checking xml
       
  2285     _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></ServiceDescription>");
       
  2286     TL(ConvertToPtr16LC(*xmlService)== KRef);
       
  2287     CleanupStack::PopAndDestroy();//Ptr
       
  2288     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2289     xmlService = NULL;
       
  2290     Teardown();
       
  2291     return KErrNone;
       
  2292     
       
  2293     }
       
  2294     
       
  2295 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL( TTestResult& aResult )
       
  2296     {
       
  2297     SetupL();
       
  2298     
       
  2299     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2300 	LOCAL_ASSERT(xmlService->SetPolicyL(KText) == KErrNone);
       
  2301 	LOCAL_ASSERT(xmlService->SetPolicyL(_L8("")) == KErrArgument);
       
  2302 	
       
  2303 	_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text/></ClientPolicy></ServicePolicy></ServiceDescription>");
       
  2304     TL(ConvertToPtr16LC(*xmlService)== KRef);
       
  2305     CleanupStack::PopAndDestroy();//Ptr
       
  2306     
       
  2307 	__ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2308 	xmlService = NULL;
       
  2309     Teardown();
       
  2310     return KErrNone;
       
  2311 	
       
  2312     }
       
  2313     
       
  2314 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L( TTestResult& aResult )
       
  2315     {
       
  2316     SetupL();
       
  2317     
       
  2318     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2319 	LOCAL_ASSERT(xmlService->SetPolicyL(KText, KText) == KErrNone);
       
  2320 	LOCAL_ASSERT(xmlService->SetPolicyL(_L8(""), KText) == KErrArgument);
       
  2321 	
       
  2322 	_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text>text</text></ClientPolicy></ServicePolicy></ServiceDescription>");
       
  2323     TL(ConvertToPtr16LC(*xmlService)== KRef);
       
  2324     CleanupStack::PopAndDestroy();//Ptr
       
  2325     
       
  2326 	__ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2327 	xmlService = NULL;
       
  2328     Teardown();
       
  2329     return KErrNone;
       
  2330 	
       
  2331     }
       
  2332     
       
  2333 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L( TTestResult& aResult )
       
  2334     {
       
  2335     SetupL();
       
  2336     
       
  2337     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2338 	LOCAL_ASSERT(xmlService->SetPolicyL(KText, KText, KText, KText) == KErrNone);
       
  2339 	LOCAL_ASSERT(xmlService->SetPolicyL(_L8(""), _L8(""), KText, KText) == KErrArgument);
       
  2340 	
       
  2341 	_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text text=\"text\">text</text></ClientPolicy></ServicePolicy></ServiceDescription>");
       
  2342     TL(ConvertToPtr16LC(*xmlService)== KRef);
       
  2343     CleanupStack::PopAndDestroy();//Ptr
       
  2344     
       
  2345 	__ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2346 	xmlService = NULL;
       
  2347     Teardown();
       
  2348     return KErrNone;
       
  2349 	
       
  2350     }
       
  2351 
       
  2352 TInt CSenServDesc::MT_CSenXmlServiceDescription_ContractL( TTestResult& aResult )
       
  2353     {
       
  2354     SetupL();
       
  2355     
       
  2356     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2357     xmlService ->SetContractL(KText);
       
  2358      //checking xml
       
  2359     _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Contract>text</Contract></ServiceDescription>");
       
  2360     
       
  2361     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  2362 	TPtr16 ptr = ConvertToPtr16LC(*xmlService);
       
  2363 	TInt posId(-1);
       
  2364     TPtrC16 messageToParse;
       
  2365     messageToParse.Set(ptr);
       
  2366     posId = messageToParse.Find(_L("<Contract>"));
       
  2367     TL(posId != -1);
       
  2368     CleanupStack::PopAndDestroy();//Ptr
       
  2369     TL(xmlService->Contract() == KText);
       
  2370 
       
  2371     //CleanupStack::PopAndDestroy();//Ptr
       
  2372    
       
  2373     //2nd time
       
  2374     xmlService ->SetContractL(KText);
       
  2375      //checking xml
       
  2376     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  2377 	ptr = ConvertToPtr16LC(*xmlService);
       
  2378 	posId = -1;
       
  2379     messageToParse.Set(ptr);
       
  2380     posId = messageToParse.Find(_L("<Contract>"));
       
  2381     TL(posId != -1);
       
  2382     CleanupStack::PopAndDestroy();//Ptr
       
  2383     TL(xmlService->Contract() == KText);
       
  2384 
       
  2385     //CleanupStack::PopAndDestroy();//Ptr
       
  2386    
       
  2387     xmlService ->SetContractL(KText2);
       
  2388      //checking xml
       
  2389     _LIT16(KRef2, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Contract>text2</Contract></ServiceDescription>");
       
  2390     //TL(ConvertToPtr16LC(*xmlService) == KRef2);
       
  2391 
       
  2392     TL(xmlService->Contract() == KText2);
       
  2393 
       
  2394     //CleanupStack::PopAndDestroy();//Ptr
       
  2395    
       
  2396     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2397     xmlService = NULL;
       
  2398     Teardown();
       
  2399     return KErrNone;
       
  2400     }
       
  2401 //================Facets
       
  2402 TInt CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL( TTestResult& aResult )
       
  2403     {
       
  2404     return MT_CSenXmlServiceDescription_RemoveFacetL(aResult);
       
  2405     }
       
  2406 
       
  2407 TInt CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL( TTestResult& aResult )
       
  2408     {
       
  2409     SetupL();
       
  2410     
       
  2411     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2412     CSenFacet* senFacet;
       
  2413     senFacet = CSenFacet::NewL();
       
  2414     senFacet->SetNameL(KText);
       
  2415     senFacet->SetValueL(KText2);
       
  2416     
       
  2417 
       
  2418     xmlService->AddFacetL(*senFacet);
       
  2419     TPtrC8 ptr=KText();
       
  2420     HBufC8* valueTo = NULL;
       
  2421     
       
  2422     if(!(xmlService->FacetValue(ptr, valueTo)==KErrNone))return KErrArgument;
       
  2423 
       
  2424     TL(*valueTo == KText2);
       
  2425 
       
  2426     __ASSERT_ALWAYS_NO_LEAVE(delete valueTo );
       
  2427     valueTo = NULL;
       
  2428     
       
  2429     if(!(xmlService->FacetValue(ptr, valueTo)==KErrNone))return KErrArgument;
       
  2430 
       
  2431     TL(*valueTo == KText2);
       
  2432 
       
  2433     __ASSERT_ALWAYS_NO_LEAVE(delete valueTo );
       
  2434     valueTo = NULL;
       
  2435     
       
  2436     ptr.Set(KText2);
       
  2437     if(!(xmlService->FacetValue(ptr, valueTo)==KErrNotFound))return KErrArgument;
       
  2438 
       
  2439      __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
  2440     senFacet = NULL;
       
  2441     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2442     xmlService = NULL;
       
  2443     Teardown();
       
  2444     return KErrNone;
       
  2445     }
       
  2446 
       
  2447 TInt CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL( TTestResult& aResult )
       
  2448     {
       
  2449     SetupL();
       
  2450     
       
  2451     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2452     CSenFacet *senFacet;
       
  2453     CSenFacet *senFacet2;
       
  2454     
       
  2455     senFacet = CSenFacet::NewL();
       
  2456     senFacet2 = CSenFacet::NewL();
       
  2457     senFacet->SetNameL(KText);
       
  2458     senFacet2->SetNameL(KText2);
       
  2459     RFacetArray array;
       
  2460 
       
  2461     if(!(xmlService->AddFacetL(*senFacet) == KErrNone))return KErrArgument;
       
  2462 
       
  2463     if(!(xmlService->AddFacetL(*senFacet) == KErrAlreadyExists))return KErrArgument;
       
  2464 
       
  2465     if(!(xmlService->AddFacetL(*senFacet2) == KErrNone))return KErrArgument;
       
  2466 
       
  2467     //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Facet name=\"text\"/><Facet name=\"text2\"/></ServiceDescription>");
       
  2468     //TPtrC16 ptrRef = KRef();
       
  2469     //TL(ConvertToPtr16LC(*xmlService) == ptrRef);
       
  2470 
       
  2471     //CleanupStack::PopAndDestroy();//Ptr
       
  2472    	TPtr16 ptr = ConvertToPtr16LC(*xmlService);
       
  2473 	TInt posId(-1);
       
  2474     TPtrC16 messageToParse;
       
  2475     messageToParse.Set(ptr);
       
  2476     posId = messageToParse.Find(_L("<Facet name=\"text\"/><Facet name=\"text2\"/>"));
       
  2477     TL(posId != -1);
       
  2478     CleanupStack::PopAndDestroy();//Ptr
       
  2479    
       
  2480     if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
       
  2481 
       
  2482     if(!(array.Count() == 2))return KErrArgument;
       
  2483 
       
  2484     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
  2485     senFacet = NULL;
       
  2486     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet2);
       
  2487     senFacet2 = NULL;
       
  2488     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2489     xmlService = NULL;
       
  2490     array.ResetAndDestroy();
       
  2491     array.Close();
       
  2492     Teardown();
       
  2493     return KErrNone;
       
  2494     }
       
  2495 
       
  2496 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL( TTestResult& aResult )
       
  2497     {
       
  2498     SetupL();
       
  2499     
       
  2500     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2501     CSenFacet* senFacet;
       
  2502     senFacet = CSenFacet::NewL();
       
  2503     senFacet->SetNameL(KText);
       
  2504     senFacet->SetValueL(KText);
       
  2505     
       
  2506     RFacetArray array;
       
  2507     if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument;
       
  2508 
       
  2509     if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument;
       
  2510 
       
  2511     senFacet->SetValueL(KText2);
       
  2512     if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument;
       
  2513 
       
  2514     _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Facet name=\"text\">text2</Facet></ServiceDescription>");
       
  2515     //TPtrC16 ptrRef = KRef();
       
  2516     //TL(ConvertToPtr16LC(*xmlService) == ptrRef);
       
  2517     
       
  2518     //CleanupStack::PopAndDestroy();//Ptr
       
  2519 	TPtr16 ptr = ConvertToPtr16LC(*xmlService);
       
  2520 	 TInt posId(-1);
       
  2521     TPtrC16 messageToParse;
       
  2522     messageToParse.Set(ptr);
       
  2523     posId = messageToParse.Find(_L("<Facet name=\"text\">text2</Facet>"));
       
  2524     TL(posId != -1);
       
  2525     CleanupStack::PopAndDestroy();//Ptr
       
  2526 
       
  2527     if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
       
  2528 
       
  2529     if(!(array.Count() == 1))return KErrArgument;
       
  2530 
       
  2531     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
  2532     senFacet = NULL;
       
  2533     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2534     xmlService = NULL;
       
  2535     array.ResetAndDestroy();
       
  2536     array.Close();
       
  2537     Teardown();
       
  2538     return KErrNone;
       
  2539     }
       
  2540 
       
  2541 TInt CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL( TTestResult& aResult )
       
  2542     {
       
  2543     SetupL();
       
  2544     
       
  2545     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2546     CSenFacet *senFacet;
       
  2547     CSenFacet *senFacet2;
       
  2548     
       
  2549     senFacet = CSenFacet::NewL();
       
  2550     senFacet2 = CSenFacet::NewL();
       
  2551     senFacet->SetNameL(KText);
       
  2552     senFacet2->SetNameL(KText2);
       
  2553     RFacetArray array;
       
  2554 
       
  2555 
       
  2556     if(!(xmlService->AddFacetL(*senFacet) == KErrNone))return KErrArgument;
       
  2557 
       
  2558     if(!(xmlService->AddFacetL(*senFacet) == KErrAlreadyExists))return KErrArgument;
       
  2559 
       
  2560     if(!(xmlService->AddFacetL(*senFacet2) == KErrNone))return KErrArgument;
       
  2561 
       
  2562     if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
       
  2563 
       
  2564     if(!(array.Count() == 2))return KErrArgument;
       
  2565 
       
  2566     array.ResetAndDestroy();
       
  2567 //removing, haFacet
       
  2568     TBool has(FALSE);
       
  2569     if(!(xmlService->HasFacetL(KText, has) == KErrNone))return KErrArgument;
       
  2570 
       
  2571     if(!(has == TRUE))return KErrArgument;
       
  2572 
       
  2573     if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument;
       
  2574 
       
  2575     if(!(has == TRUE))return KErrArgument;
       
  2576 
       
  2577     if(!(xmlService->RemoveFacet(KText2) == KErrNone))return KErrArgument;
       
  2578 
       
  2579     __ASSERT_ALWAYS_NO_LEAVE(xmlService->RemoveFacet(KText2));
       
  2580     if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument;
       
  2581 
       
  2582     if(!(has == FALSE))return KErrArgument;
       
  2583 
       
  2584     if(!(xmlService->RemoveFacet(KText2) == KErrNotFound))return KErrArgument;
       
  2585 
       
  2586     if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument;
       
  2587 
       
  2588     if(!(has == FALSE))return KErrArgument;
       
  2589 
       
  2590     if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument;
       
  2591 
       
  2592     if(!(array.Count() == 1))return KErrArgument;
       
  2593 
       
  2594     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
  2595     senFacet = NULL;
       
  2596     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet2);
       
  2597     senFacet2 = NULL;
       
  2598     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2599     xmlService = NULL;
       
  2600     array.ResetAndDestroy();
       
  2601     array.Close();
       
  2602     Teardown();
       
  2603     return KErrNone;
       
  2604     }
       
  2605 
       
  2606 TInt CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL( TTestResult& aResult )
       
  2607     {
       
  2608     return MT_CSenXmlServiceDescription_AddFacetLL(aResult);
       
  2609     }
       
  2610 //------------end facet
       
  2611 
       
  2612 TInt CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL( TTestResult& aResult )
       
  2613     {
       
  2614     SetupL();
       
  2615     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2616     
       
  2617     HBufC8* xmlBuffer = xmlService->AsXmlL();
       
  2618     CleanupStack::PushL( xmlBuffer );
       
  2619     TPtr8 ptr = xmlBuffer->Des();
       
  2620     if (ptr.Length() > 0)
       
  2621         RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
       
  2622     else
       
  2623         RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
       
  2624     _LIT8(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  2625     /*EUNIT_ASSERT_EQUALS(ptr, KRef);*/
       
  2626     //TL(ptr == KRef);
       
  2627     TInt posId(-1);
       
  2628     TPtrC8 messageToParse;
       
  2629     messageToParse.Set(ptr);
       
  2630     posId = messageToParse.Find(_L8("<facet>"));
       
  2631     TL(posId == -1);
       
  2632     CleanupStack::PopAndDestroy(xmlBuffer);
       
  2633 
       
  2634     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2635     xmlService = NULL;
       
  2636     Teardown();
       
  2637     return KErrNone ;
       
  2638     }
       
  2639     
       
  2640 TInt CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL( TTestResult& aResult )
       
  2641     {
       
  2642     SetupL();
       
  2643     
       
  2644     TBuf8<50> StreamBuf;
       
  2645 	CSenBaseElement* pElement=CSenBaseElement::NewL(_L8("Nokia"));
       
  2646 	CleanupStack::PushL(pElement);
       
  2647 	pElement->AddElementL(_L8("webservices"));
       
  2648 	RWriteStream& ElemntStream=pElement->ContentWriteStreamL();
       
  2649 	
       
  2650     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2651     CleanupStack::PushL(xmlService);
       
  2652     xmlService->WriteAsXMLToL(ElemntStream);
       
  2653     
       
  2654     CleanupStack::PopAndDestroy(xmlService);
       
  2655     CleanupStack::PopAndDestroy(pElement);
       
  2656     Teardown();
       
  2657     return KErrNone ;
       
  2658     }
       
  2659 
       
  2660 
       
  2661 TInt CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL( TTestResult& aResult )
       
  2662     {
       
  2663     SetupL();
       
  2664     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2665     xmlService->Credentials();
       
  2666     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2667     xmlService = NULL;
       
  2668     Teardown();
       
  2669     return KErrNone ;
       
  2670     }
       
  2671     
       
  2672 TInt CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL( TTestResult& aResult )
       
  2673     {
       
  2674     SetupL();
       
  2675     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2676     
       
  2677     HBufC* xmlBuffer = xmlService->AsXmlUnicodeL();
       
  2678     CleanupStack::PushL( xmlBuffer );
       
  2679     TPtr ptr = xmlBuffer->Des();
       
  2680     if (ptr.Length() > 0)
       
  2681         RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr);
       
  2682     else
       
  2683         RDebug::Print( _L( "WSModTester: xmlBuffer empty"));
       
  2684     _LIT(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>");
       
  2685     /*EUNIT_ASSERT_EQUALS(ptr, KRef);*/
       
  2686     TL(ptr == KRef);
       
  2687     CleanupStack::PopAndDestroy(xmlBuffer);
       
  2688 
       
  2689     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2690     xmlService = NULL;
       
  2691     Teardown();
       
  2692     return KErrNone ;
       
  2693     }
       
  2694     
       
  2695 TInt CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL( TTestResult& aResult )
       
  2696     {
       
  2697     SetupL();
       
  2698     TBool retVal;
       
  2699     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2700     xmlService->SetFrameworkIdL(KText);
       
  2701     CSenXmlServiceDescription* xmlService1= CSenXmlServiceDescription::NewL();
       
  2702     
       
  2703     retVal = xmlService->HasEqualPrimaryKeysL(*xmlService);
       
  2704     //TL(retVal == ETrue)
       
  2705 	if(retVal);
       
  2706     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2707     xmlService = NULL;
       
  2708 
       
  2709     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService1);
       
  2710     xmlService1 = NULL;
       
  2711     Teardown();
       
  2712     return KErrNone ;
       
  2713     }
       
  2714     
       
  2715 TInt CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL( TTestResult& aResult )
       
  2716     {
       
  2717     SetupL();
       
  2718     TBool retVal;
       
  2719     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2720     
       
  2721     retVal = xmlService->IsLocalL();
       
  2722     //TL(retVal == ETrue)
       
  2723 	if(retVal);
       
  2724     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2725     xmlService = NULL;
       
  2726 
       
  2727     Teardown();
       
  2728     return KErrNone ;
       
  2729     }
       
  2730     
       
  2731 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL( TTestResult& aResult )
       
  2732     {
       
  2733     SetupL();
       
  2734     TBool retVal;
       
  2735     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2736     
       
  2737     retVal = xmlService->SetTransportCueL(KText);
       
  2738     if(!(retVal == 0)) return KErrArgument;
       
  2739 
       
  2740     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2741     xmlService = NULL;
       
  2742 
       
  2743     Teardown();
       
  2744     return KErrNone ;
       
  2745     }
       
  2746     
       
  2747 TInt CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL( TTestResult& aResult )
       
  2748     {
       
  2749     SetupL();
       
  2750     //TBool retVal;
       
  2751     //HBufC8* xmlBuffer;
       
  2752     //TPtrC8 ptr;
       
  2753     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2754     xmlService->SetTransportCueL(KText);
       
  2755     xmlService->TransportCue();
       
  2756     //ptr = xmBuffer.Desc(;)
       
  2757     //TL(ptr == KText);
       
  2758 
       
  2759     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2760     xmlService = NULL;
       
  2761 
       
  2762     Teardown();
       
  2763     return KErrNone ;
       
  2764     }
       
  2765 /*    
       
  2766 TInt CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL( TTestResult& aResult )
       
  2767     {
       
  2768     SetupL();
       
  2769     TBool retVal;
       
  2770     CServicePolicy* policy = CSenServicePolicy::NewL();
       
  2771     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2772     policy = (CServicePolicy)xmlService->ServicePolicyL();
       
  2773 
       
  2774     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2775     xmlService = NULL;
       
  2776 
       
  2777     Teardown();
       
  2778     return KErrNone ;
       
  2779     }
       
  2780     
       
  2781 */    
       
  2782     
       
  2783 TInt CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL( TTestResult& aResult )
       
  2784     {
       
  2785     SetupL();
       
  2786     //TBool retVal;
       
  2787     //TPtrC8 ptr;
       
  2788     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2789     xmlService->ProviderId();
       
  2790 
       
  2791     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2792     xmlService = NULL;
       
  2793 
       
  2794     Teardown();
       
  2795     return KErrNone ;
       
  2796     }
       
  2797 
       
  2798 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL( TTestResult& aResult )
       
  2799     {
       
  2800     SetupL();
       
  2801     TBool var = ETrue;
       
  2802     TPtrC8 ptr;
       
  2803     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2804     xmlService->SetPromptUserInfoL(var);
       
  2805 		
       
  2806     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2807     xmlService = NULL;
       
  2808 
       
  2809     Teardown();
       
  2810     return KErrNone ;
       
  2811     }
       
  2812 
       
  2813 TInt CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL( TTestResult& aResult )
       
  2814     {
       
  2815     SetupL();
       
  2816     TBool retVal;;
       
  2817     
       
  2818     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText);
       
  2819     retVal = xmlService->PromptUserInfo();
       
  2820 	
       
  2821 	if(retVal);
       
  2822 		
       
  2823     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2824     xmlService = NULL;
       
  2825 
       
  2826     Teardown();
       
  2827     return KErrNone ;
       
  2828     }
       
  2829 TInt CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL(TTestResult& aResult)
       
  2830 	{
       
  2831 /*_LIT8(KServiceDescription, "<?xml version=\"1.0\" encoding=\"utf-8\" ?> <a:Test character=\"&quot;\" xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
       
  2832 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
       
  2833 <Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
       
  2834 <Element2 z=\"value4\">&ltContent2&quot&gt</Element2>\
       
  2835 <Element3>Content3</Element3>\
       
  2836 <Element4/></a:Test>");
       
  2837 */	
       
  2838 
       
  2839 
       
  2840 _LIT8(KServiceDescription, "<ServiceDescription framework=\"WS-STAR\">\
       
  2841 		<Contract>urn:wstar:sts</Contract>\
       
  2842 		<Endpoint>http://10.21.32.20/WSStar/BgRsp/STS.aspx</Endpoint>\
       
  2843 		<ProviderID>provider01</ProviderID>\
       
  2844 		</ServiceDescription>");		
       
  2845 /*
       
  2846 	_LIT8(KServiceDescription, "<ServiceDescription framework=\"WS-STAR\">
       
  2847 		<Contract>urn:wstar:sts</Contract>
       
  2848 		<Endpoint>http://10.21.32.20/WSStar/BgRsp/STS.aspx</Endpoint>
       
  2849 		<ProviderID>provider01</ProviderID>
       
  2850 		<ProviderPolicy>
       
  2851        <Transport>
       
  2852            <IapId>
       
  2853                1234567890
       
  2854            </IapId>
       
  2855        </Transport>
       
  2856        <IdentityProviderIDs strict=\"true\">
       
  2857            <IdentityProviderID>
       
  2858              urn:first.id.example.com
       
  2859            </IdentityProviderID>
       
  2860            <IdentityProviderID>
       
  2861              urn:second.id.example.com
       
  2862            </IdentityProviderID>
       
  2863        </IdentityProviderIDs>
       
  2864    		</ProviderPolicy>
       
  2865 		<Credentials CredentialsMaxID=\"1\">
       
  2866 						<CredentialContainer>
       
  2867 						<Identifier><garbage>1</garbage><Endpoint>http://10.21.32.20/WSStar/CredMan/WSService.aspx</Endpoint><ProviderID>provider01</ProviderID></Identifier>
       
  2868 						<Properties>
       
  2869 						<ServiceInterval>-60540625</ServiceInterval><ValidUntil>2020-06-19T10:28:31.000000Z</ValidUntil>
       
  2870 						<Created>2007-06-18T10:23:52Z</Created><PhoneTimeWhenMTResolved>2007-06-18T10:24:52.504375Z</PhoneTimeWhenMTResolved>
       
  2871 						<POP>cnqlXcxDmY4h4tjbgNssLMwhCkOnc+4c</POP>
       
  2872 						<TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</TokenType>\
       
  2873 						<BinaryType>simmetric</BinaryType>
       
  2874 						</Properties></CredentialContainer></Credentials>
       
  2875 		</ServiceDescription>");*/
       
  2876 
       
  2877 	CSenXmlServiceDescription* pDescription = CSenXmlServiceDescription::NewL(_L8("ServiceDescription"));
       
  2878 	CleanupStack::PushL(pDescription);
       
  2879 	CSenXmlReader *pXmlReader = CSenXmlReader::NewL();
       
  2880 	CleanupStack::PushL(pXmlReader);
       
  2881 	pDescription->SetReader(*pXmlReader );
       
  2882 	TRAPD(retVal,pDescription->ParseL(KServiceDescription));
       
  2883 	CleanupStack::PopAndDestroy(pXmlReader);
       
  2884 	CleanupStack::PopAndDestroy(pDescription);
       
  2885 	return retVal;
       
  2886 	}
       
  2887 
       
  2888 
       
  2889 TInt CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL( TTestResult& aResult )
       
  2890     {
       
  2891     SetupL();
       
  2892     
       
  2893     CSenXmlServiceDescription *xmlService;
       
  2894     CSenXmlServiceDescription *xmlService2;
       
  2895     
       
  2896     xmlService = CSenXmlServiceDescription::NewL();
       
  2897     xmlService2 = CSenXmlServiceDescription::NewL();
       
  2898 
       
  2899     if(!(xmlService->ScoreMatchL(*xmlService2) == 0))return KErrArgument;
       
  2900 
       
  2901     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2902     xmlService = NULL;
       
  2903     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2904     xmlService2 = NULL;
       
  2905 //---------------
       
  2906     xmlService = CSenXmlServiceDescription::NewL(KText, KText2);
       
  2907     xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2);
       
  2908 
       
  2909     if(!(xmlService->ScoreMatchL(*xmlService2) == 2))return KErrArgument;
       
  2910 
       
  2911     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2912     xmlService = NULL;
       
  2913     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2914     xmlService2 = NULL;
       
  2915 //---------------
       
  2916     xmlService = CSenXmlServiceDescription::NewL(KText2, KText);
       
  2917     xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2);
       
  2918 
       
  2919     if(!(xmlService->ScoreMatchL(*xmlService2) == 0))return KErrArgument;
       
  2920 
       
  2921    __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2922     xmlService = NULL;
       
  2923     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2924     xmlService2 = NULL;
       
  2925 //---------------
       
  2926     xmlService = CSenXmlServiceDescription::NewL(KText2, KText);
       
  2927     xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2);
       
  2928     CSenFacet* senFacet = CSenFacet::NewL();
       
  2929     senFacet->SetNameL(KText);
       
  2930     xmlService->AddFacetL(*senFacet);
       
  2931     xmlService2->AddFacetL(*senFacet);
       
  2932     
       
  2933     if(!(xmlService->ScoreMatchL(*xmlService2) == 1))return KErrArgument;
       
  2934 
       
  2935     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
  2936     senFacet = NULL;
       
  2937     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2938     xmlService = NULL;
       
  2939     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2);
       
  2940     xmlService2 = NULL;
       
  2941     Teardown();
       
  2942     return KErrNone;
       
  2943     }
       
  2944 
       
  2945 TInt CSenServDesc::MT_CSenXmlServiceDescription_EndpointL( TTestResult& aResult )
       
  2946     {
       
  2947     SetupL();
       
  2948     
       
  2949     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  2950     
       
  2951     xmlService ->SetEndPointL(KText);
       
  2952      //checking xml
       
  2953     _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Endpoint>text</Endpoint></ServiceDescription>");
       
  2954     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  2955 
       
  2956     TL(xmlService->Endpoint() == KText);
       
  2957 	TPtr16 ptr = ConvertToPtr16LC(*xmlService);
       
  2958 	TInt posId(-1);
       
  2959     TPtrC16 messageToParse;
       
  2960     messageToParse.Set(ptr);
       
  2961     posId = messageToParse.Find(_L("<Endpoint>"));
       
  2962     TL(posId != -1);
       
  2963     CleanupStack::PopAndDestroy();//Ptr
       
  2964    
       
  2965     //2nd time
       
  2966     xmlService ->SetEndPointL(KText);
       
  2967      //checking xml
       
  2968     //TL(ConvertToPtr16LC(*xmlService) == KRef);
       
  2969 	ptr = ConvertToPtr16LC(*xmlService);
       
  2970 	posId = -1;
       
  2971     messageToParse.Set(ptr);
       
  2972     posId = messageToParse.Find(_L("<Endpoint>"));
       
  2973     TL(posId != -1);
       
  2974     TL(xmlService->Endpoint() == KText);
       
  2975 
       
  2976     CleanupStack::PopAndDestroy();//Ptr
       
  2977    
       
  2978 
       
  2979     xmlService ->SetEndPointL(KText2);
       
  2980      //checking xml
       
  2981     _LIT16(KRef2, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Endpoint>text2</Endpoint></ServiceDescription>");
       
  2982     //TL(ConvertToPtr16LC(*xmlService) == KRef2);
       
  2983 
       
  2984     TL(xmlService->Endpoint() == KText2);
       
  2985 	ptr = ConvertToPtr16LC(*xmlService);
       
  2986 	posId = -1;
       
  2987     messageToParse.Set(ptr);
       
  2988     posId = messageToParse.Find(_L("<Endpoint>"));
       
  2989     TL(posId != -1);
       
  2990     CleanupStack::PopAndDestroy();//Ptr
       
  2991    
       
  2992     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  2993     xmlService = NULL;
       
  2994     Teardown();
       
  2995     return KErrNone;
       
  2996     }
       
  2997 
       
  2998 TInt CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL( TTestResult& aResult )
       
  2999     {
       
  3000     return MT_CSenXmlServiceDescription_SetFrameworkIdLL(aResult);
       
  3001     }
       
  3002 
       
  3003 TInt CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL( TTestResult& aResult )
       
  3004     {
       
  3005     SetupL();
       
  3006     
       
  3007     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  3008     __ASSERT_ALWAYS_NO_LEAVE(xmlService ->FrameworkVersion());
       
  3009     if(!(xmlService ->FrameworkVersion() == KNullDesC8))return KErrArgument;
       
  3010 
       
  3011     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  3012     xmlService = NULL;
       
  3013     Teardown();
       
  3014     return KErrNone;
       
  3015     }
       
  3016 
       
  3017 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL( TTestResult& aResult )
       
  3018     {
       
  3019     return MT_CSenXmlServiceDescription_ContractL(aResult);
       
  3020     }
       
  3021 
       
  3022 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL( TTestResult& aResult )
       
  3023     {
       
  3024     return MT_CSenXmlServiceDescription_EndpointL(aResult);
       
  3025     }
       
  3026 
       
  3027 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL( TTestResult& aResult )
       
  3028     {
       
  3029     SetupL();
       
  3030     
       
  3031     CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL();
       
  3032     RAttributeArray attributeArray;
       
  3033     xmlService->SetAttributesL(attributeArray);
       
  3034     __ASSERT_ALWAYS_NO_LEAVE(delete xmlService);
       
  3035     xmlService = NULL;
       
  3036     attributeArray.Reset();
       
  3037     attributeArray.Close();
       
  3038     Teardown();
       
  3039     return KErrNone;
       
  3040     }
       
  3041 
       
  3042 TInt CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL( TTestResult& aResult )
       
  3043     {
       
  3044     SetupL();
       
  3045     _LIT8(KContent, "content");
       
  3046     _LIT8(KFacet, "Facet");
       
  3047     
       
  3048     CSenFacet* senFacet = CSenFacet::NewL();
       
  3049     TL(senFacet != (CSenFacet*)NULL);
       
  3050     
       
  3051     RStringPool stringPool;
       
  3052     stringPool.OpenL();
       
  3053     CleanupClosePushL(stringPool);
       
  3054     
       
  3055     RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));
       
  3056     CleanupClosePushL(nsUriRString);
       
  3057     RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));
       
  3058     CleanupClosePushL(nsPrefixRString);
       
  3059     RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));
       
  3060     CleanupClosePushL(localNameRString);
       
  3061     RString valueRString        = stringPool.OpenStringL(_L8("Value"));
       
  3062     CleanupClosePushL(valueRString);
       
  3063     
       
  3064     RAttribute attribute;
       
  3065     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 
       
  3066                    valueRString);
       
  3067     CleanupStack::Pop(4); 
       
  3068     CleanupClosePushL(attribute);
       
  3069     
       
  3070     RAttributeArray attrArray;
       
  3071     attrArray.AppendL(attribute);
       
  3072     CleanupClosePushL(attrArray);    
       
  3073     
       
  3074     CSenXmlElement* xmlElem = CSenXmlElement::NewL(KText, KText, KText);
       
  3075     CSenXmlElement* xmlElem2 = CSenXmlElement::NewL(KText2);
       
  3076     xmlElem->AddElementL(*xmlElem2);
       
  3077     TL (xmlElem->SetContentL(KContent) == KContent);
       
  3078     xmlElem->SetAttributesL(attrArray);
       
  3079     
       
  3080     senFacet->CopyFromL(*xmlElem);
       
  3081     
       
  3082     TL (senFacet->LocalName() == KFacet);
       
  3083     TL (senFacet->NamespaceURI() == KNullDesC8);
       
  3084     TL (senFacet->NsPrefix() == KNullDesC8);
       
  3085     TL (senFacet->Content() == KContent);
       
  3086     RPointerArray<CSenElement>& xmlElemList = senFacet->ElementsL();
       
  3087     TL (xmlElemList.Count() == 1);
       
  3088     RPointerArray<CSenBaseAttribute>& xmlElemAttrList = senFacet->AttributesL();
       
  3089     TL (xmlElemAttrList.Count() == 1);    
       
  3090     
       
  3091     CleanupStack::PopAndDestroy(&attrArray);
       
  3092     CleanupStack::PopAndDestroy(&attribute);
       
  3093     CleanupStack::PopAndDestroy(&stringPool);
       
  3094     
       
  3095     __ASSERT_ALWAYS_NO_LEAVE(delete xmlElem);
       
  3096     xmlElem = NULL;
       
  3097     
       
  3098     __ASSERT_ALWAYS_NO_LEAVE(delete senFacet);
       
  3099     senFacet = NULL;
       
  3100     
       
  3101     Teardown();    
       
  3102     return KErrNone;
       
  3103     }
       
  3104 
       
  3105 
       
  3106 // -----------------------------------------------------------------------------
       
  3107 // ?classname::?member_function
       
  3108 // ?implementation_description
       
  3109 // (other items were commented in a header).
       
  3110 // -----------------------------------------------------------------------------
       
  3111 //
       
  3112 /*
       
  3113 ?type ?classname::?member_function(
       
  3114    ?arg_type arg,
       
  3115    ?arg_type arg )
       
  3116    {
       
  3117 
       
  3118    ?code
       
  3119 
       
  3120    }
       
  3121 */
       
  3122 
       
  3123 // ========================== OTHER EXPORTED FUNCTIONS =========================
       
  3124 
       
  3125 // -----------------------------------------------------------------------------
       
  3126 // ?function_name implements...
       
  3127 // ?implementation_description.
       
  3128 // Returns: ?value_1: ?description
       
  3129 //          ?value_n: ?description
       
  3130 //                    ?description
       
  3131 // -----------------------------------------------------------------------------
       
  3132 //
       
  3133 /*
       
  3134 ?type  ?function_name(
       
  3135     ?arg_type arg,  // ?description
       
  3136     ?arg_type arg )  // ?description
       
  3137     {
       
  3138 
       
  3139     ?code
       
  3140 
       
  3141     }
       
  3142 */
       
  3143 //  End of File
       
  3144 
       
  3145 //  End of File