/*

* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:        ?Description

*

*/

// INCLUDE FILES

#include <e32math.h>

#include "SenServDescBCTest.h"

#include <senxmlelement.h>

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

#define LOCAL_ASSERT(expression)	{if(!(expression)){return KErrArgument;}}

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

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

// CSenServDesc::Case

// Returns a test case by number.

//

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

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

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

// 

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

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

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

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

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

//

const TCaseInfo CSenServDesc::Case ( 

    const TInt aCaseNumber ) const 

     {

    /**

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

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

    * doing the test case

    * In practice, do following

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

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

    *    SenServDesc.cpp file and to SenServDesc.h 

    *    header file.

    *

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

    *

    * 2.1: FUNCENTRY or ENTRY macro

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

    * function name.

    *

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

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

    *

    * Or

    *

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

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

    *

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

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

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

    * TInt value for last heap memory allocation failure.

    * 

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

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

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

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

    */ 

    static TCaseInfoInternal const KCases[] =

        {

        // To add new test cases, add new items to this array

        // NOTE: When compiled to GCCE, there must be Classname::

        // declaration in front of the method name, e.g. 

        // CSenServDesc::PrintTest. Otherwise the compiler

        // gives errors.

  //      FUNCENTRY( CSenServDesc::PrintTest ),

  //    ENTRY( "Loop test", CSenServDesc::LoopTest ),

		ENTRY("NewL - CSenCredential",  CSenServDesc::MT_CSenCredential_NewLL),

		ENTRY("NewLC - CSenCredential",  CSenServDesc::MT_CSenCredential_NewLCL),

		ENTRY("NewL - CSenCredential baseElement",  CSenServDesc::MT_CSenCredential_NewL_1L),

		ENTRY("NewLC - CSenCredential baseElement",  CSenServDesc::MT_CSenCredential_NewLC_1L),

		ENTRY("NewL - CSenCredential copy",  CSenServDesc::MT_CSenCredential_NewL_2L),

		ENTRY("NewLC - CSenCredential copy",  CSenServDesc::MT_CSenCredential_NewLC_2L),

		ENTRY("ValidUntil - CSenCredential ValidUntil",  CSenServDesc::MT_CSenCredential_ValidUntilL),

		ENTRY("SetValidUntil - CSenCredential SetValidUntil",  CSenServDesc::MT_CSenCredential_SetValidUntilL),

		//ENTRY("NewLC - CSenCredential Id",  CSenServDesc::MT_CSenCredential_IdL),

		ENTRY("StartElement - CSenCredential StartElement",  CSenServDesc::MT_CSenCredential_StartElementLL),

		ENTRY("NewL - CSenCredential2",  CSenServDesc::MT_CSenCredential2_NewLL),

		ENTRY("NewLC - CSenCredential2",  CSenServDesc::MT_CSenCredential2_NewLCL),

		ENTRY("NewL - CSenCredential2 baseElement",  CSenServDesc::MT_CSenCredential2_NewL_1L),

		ENTRY("NewLC - CSenCredential2 baseElement",  CSenServDesc::MT_CSenCredential2_NewLC_1L),

		ENTRY("NewL - CSenCredential2 ",  CSenServDesc::MT_CSenCredential2_NewL_2L),

		ENTRY("NewLC - CSenCredential2 ",  CSenServDesc::MT_CSenCredential2_NewLC_2L),

		ENTRY("NewL - CSenCredential2 copy",  CSenServDesc::MT_CSenCredential2_NewL_3L),

		ENTRY("NewLC - CSenCredential2 copy",  CSenServDesc::MT_CSenCredential2_NewLC_3L),

		ENTRY("NewL - CSenCredential2 document",  CSenServDesc::MT_CSenCredential2_NewL_4L),

		ENTRY("NewLC - CSenCredential2 document",  CSenServDesc::MT_CSenCredential2_NewLC_4L),

		ENTRY("Id - CSenCredential2 Id",  CSenServDesc::MT_CSenCredential2_IdL),

		ENTRY("ValidUntil - CSenCredential2 ValidUntil",  CSenServDesc::MT_CSenCredential2_ValidUntilL),

		ENTRY("SetValidUntil - CSenCredential2 SetValidUntil",  CSenServDesc::MT_CSenCredential2_SetValidUntilL),

		ENTRY("NewL - CSenFacet",  CSenServDesc::MT_CSenFacet_NewLL),

		ENTRY("NewL - CSenFacet copy",  CSenServDesc::MT_CSenFacet_NewL_1L),

		ENTRY("NewL - CSenFacet attribute",  CSenServDesc::MT_CSenFacet_NewL_2L),

		ENTRY("SetNameL - CSenFacet",  CSenServDesc::MT_CSenFacet_SetNameLL),

		ENTRY("SetTypeL - CSenFacet",  CSenServDesc::MT_CSenFacet_SetTypeLL),

		ENTRY("SetValueL - CSenFacet",  CSenServDesc::MT_CSenFacet_SetValueLL),

		ENTRY("Name - CSenFacet",  CSenServDesc::MT_CSenFacet_NameL),

		ENTRY("Type - CSenFacet",  CSenServDesc::MT_CSenFacet_TypeL),

		ENTRY("Value - CSenFacet",  CSenServDesc::MT_CSenFacet_ValueL),

		ENTRY("NewL - Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewL_L),

		ENTRY("NewLC - Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewLCL),

		ENTRY("NewL - Enpoint + Contract",  CSenServDesc::MT_CSenIdentityProvider_NewL_1L),

		ENTRY("NewLC - Enpoint + Contract",  CSenServDesc::MT_CSenIdentityProvider_NewLC_1L),

		ENTRY("NewL - Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewL_2L),

		ENTRY("NewLC - Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewLC_2L),

		ENTRY("NewL - ServiceID + Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewL_3L),

		ENTRY("NewLC - ServiceID + Provider + Contract+ Endpoint",  CSenServDesc::MT_CSenIdentityProvider_NewLC_3L),

		ENTRY("AuthzID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_AuthzIDL),

		ENTRY("AdvisoryAuthnID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL),

		ENTRY("ProviderID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_ProviderIDL),

		ENTRY("Password - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_PasswordL),

		ENTRY("IMEI - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IMEIL),

		ENTRY("UserName - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_UserNameL),

		ENTRY("SetProviderID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL),

		ENTRY("SetServiceID - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL),

		ENTRY("IsTrustedByL - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL),

		ENTRY("IsTrustedByL1 - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L),		

		ENTRY("HttpCredentialsL - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL),

		ENTRY("IsDefault - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_IsDefaultL),		

		ENTRY("NewElementName - IdentityProvider",  CSenServDesc::MT_CSenIdentityProvider_NewElementNameL),

		ENTRY("NewL - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL),

		ENTRY("NewLC - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL),

		ENTRY("NewL - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L),

		ENTRY("NewLC - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L),

		ENTRY("IsStrict - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL),

		ENTRY("SetStrict - CSenIdentityProviderIdArray8",  CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL),

		ENTRY("NewL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLL),

		ENTRY("NewLC - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLCL),

		ENTRY("NewL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewL_1L),

		ENTRY("NewLC - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLC_1L),

		ENTRY("NewL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewL_2L),

		ENTRY("NewLC - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_NewLC_2L),

		ENTRY("MatchesL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_MatchesL),		

		ENTRY("SetConsumerIapIdL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL),

		ENTRY("ConsumerIapId - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL),

		ENTRY("SetConsumerSnapId - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL),

		ENTRY("ConsumerSnapId - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL),

		ENTRY("SetConsumerIdentityProviderIdsL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL),

		ENTRY("ConsumerPolicyAsXmlL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL),

		ENTRY("StartElementL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_StartElementLL),

		ENTRY("AddConsumerIdentityProviderIdL - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL),

		ENTRY("ConsumerIdentityProviderIds8L - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL),

		ENTRY("AcceptsConsumerPolicy - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL),

		ENTRY("RebuildFromConsumerPolicy - CSenServicePattern",  CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL),		

		ENTRY("NewL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLL),

		ENTRY("NewLC - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLCL),

		ENTRY("NewL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L),

		ENTRY("NewLC - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L),

		ENTRY("NewL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L),

		ENTRY("NewLC - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L),

		ENTRY("SetFrameworkIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL),

		ENTRY("NewElementName - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL),

		ENTRY("SetIapIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL),

		ENTRY("IapId - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_IapIdL),

		ENTRY("SetSnapIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL),

		ENTRY("SnapId - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL),

		ENTRY("SetIdentityProviderIdsL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL),

		ENTRY("AddIdentityProviderIdL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL),

		ENTRY("RebuildFrom - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL),

		ENTRY("IdentityProviderIds8L - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL),

		ENTRY("Accepts - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL),

		ENTRY("DescriptionClassType - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL),

		ENTRY("MatchesL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_MatchesL),

		ENTRY("SetProviderIDL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL),

		ENTRY("SetPolicyLL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL),

		ENTRY("SetPolicyL_1L - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L),

		ENTRY("SetPolicyL_2L - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L),	

    	ENTRY("Contract - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_ContractL),

		ENTRY("HasFacetL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL),

		ENTRY("FacetValue - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL),

		ENTRY("AddFacetL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL),

		ENTRY("SetFacetL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL),

		ENTRY("RemoveFacet - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL),

		ENTRY("FacetsL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL),

		ENTRY("ScoreMatchL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL),

		ENTRY("Endpoint - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_EndpointL),

		ENTRY("FrameworkId - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL),

		ENTRY("FrameworkVersion - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL),

		ENTRY("SetContractL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL),

		ENTRY("SetEndPointL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL),

		ENTRY("SetAttributesL - CSenXmlServiceDescription",  CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL),		

		ENTRY("AsXmlL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL),

		ENTRY("WriteAsXMLToL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL),

		ENTRY("AsXmlUnicodeL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL),

		ENTRY("Credentials - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL),

		ENTRY("HasEqualPrimaryKeysL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL),

		ENTRY("IsLocalL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL),

		ENTRY("SetTransportCueL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL),

		ENTRY("TransportCue - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL),

		//ENTRY("ServicePolicy - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL),

		ENTRY("ProviderId - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL),

		ENTRY("SetPromptUserInfoL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL),

		ENTRY("PromptUserInfo - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL),

		ENTRY("StartElementL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL),

		ENTRY("CopyFromLL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL),

        // Example how to use OOM functionality

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

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

        };

    // Verify that case number is valid

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

                               sizeof( TCaseInfoInternal ) )

        {

        // Invalid case, construct empty object

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

        null.iMethod = NULL;

        null.iIsOOMTest = EFalse;

        null.iFirstMemoryAllocation = 0;

        null.iLastMemoryAllocation = 0;

        return null;

        } 

    // Construct TCaseInfo object and return it

    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

    return tmp;

    }

//  METHODS

void CSenServDesc::SetupL(  )

    {

    } 

void CSenServDesc::Teardown(  )

    {

    }

TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseFragment &fragment){

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

    CleanupStack::PushL( xmlBuffer );

    TPtr16 ptr = xmlBuffer->Des();

    if (ptr.Length() > 0){

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

    }

    else

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

    return ptr;

}

TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseElement &element){

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

    CleanupStack::PushL( xmlBuffer );

    TPtr16 ptr = xmlBuffer->Des();

    if (ptr.Length() > 0){

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

    }

    else

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

    return ptr;

}

TInt CSenServDesc::MT_CSenCredential_NewLL( TTestResult& aResult )

    {

    SetupL();

    RAttributeArray attributeArray;

    CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);

    TL(senCredential != (CSenCredential*)NULL);

    _LIT16(KRef, "<text xmlns=\"text\"/>");

    //checking xml

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

    CleanupStack::PopAndDestroy();//Ptr

    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);

    senCredential = NULL;

	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}

	{TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}

 	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}

 	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}

 	{TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}

 	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}

    attributeArray.Reset();

    attributeArray.Close();

    Teardown();

    return KErrNone;

    }

TInt CSenServDesc::MT_CSenCredential_NewLCL( TTestResult& aResult )

    {

    SetupL();

    RAttributeArray attributeArray;

    CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray);

    TL(senCredential != (CSenCredential*)NULL);

    //checking xml

    _LIT16(KRef, "<text xmlns=\"text\"/>");

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

    CleanupStack::PopAndDestroy();//Ptr

    CleanupStack::Pop();

    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);

    senCredential = NULL;

	  {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}

 		{TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}

 		{TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;}

    attributeArray.Reset();

    attributeArray.Close();

     Teardown();

    return KErrNone;

   }

TInt CSenServDesc::MT_CSenCredential_NewL_1L( TTestResult& aResult )

    {

    SetupL();

    RAttributeArray attributeArray;

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

    CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray, *senBaseElement);

    TL(senCredential != (CSenCredential*)NULL);

    //checking xml, parent we will not see so ref the same as previous NewL ctr 

    _LIT16(KRef, "<text xmlns=\"text\"/>");

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

    CleanupStack::PopAndDestroy();//Ptr

    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);

    senCredential = NULL;

    delete senBaseElement;

    senBaseElement = NULL;

    senBaseElement = CSenBaseElement::NewL(KText);

	 	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}

	 	{TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}

	 	{TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}

    delete senBaseElement;

    senBaseElement = NULL;

    attributeArray.Reset();

    attributeArray.Close();

    Teardown();

    return KErrNone;

   }

TInt CSenServDesc::MT_CSenCredential_NewLC_1L( TTestResult& aResult )

    {

    SetupL();

    RAttributeArray attributeArray;

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

    CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray, *senBaseElement);

    TL(senCredential != (CSenCredential*)NULL);

    //checking xml, parent we will not see so ref the same as previous Newl ctr

    _LIT16(KRef, "<text xmlns=\"text\"/>");

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

    CleanupStack::PopAndDestroy();//Ptr

    CleanupStack::Pop();

    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);

    senCredential = NULL;

    delete senBaseElement;

    senBaseElement = NULL;

    senBaseElement = CSenBaseElement::NewL(KText);

	 	{TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}

	 	{TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;}

    delete senBaseElement;

    senBaseElement = NULL;

    attributeArray.Reset();

    attributeArray.Close();

    Teardown();

    return KErrNone;

   }

TInt CSenServDesc::MT_CSenCredential_NewL_2L( TTestResult& aResult )

    {

    SetupL();

    RAttributeArray attributeArray;

    CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray);

    senCredential = CSenCredential::NewL(*orgSenCredential);

    //checking xml

    _LIT16(KRef, "<text xmlns=\"text\"/>");

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

    CleanupStack::PopAndDestroy();//Ptr

    TL(senCredential != (CSenCredential*)NULL);

   __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);

    senCredential = NULL;

    delete orgSenCredential;

    orgSenCredential = NULL;

    attributeArray.Reset();

    attributeArray.Close();

    Teardown();

    return KErrNone;

   }

TInt CSenServDesc::MT_CSenCredential_NewLC_2L( TTestResult& aResult )

    {

    SetupL();

    RAttributeArray attributeArray;