/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:        ?Description

*

*/

// [INCLUDE FILES]-do not remove

#include <e32math.h>

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "senservdescTester.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 ===============================

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

// CsenservdescTester::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CsenservdescTester::Delete() 

    {

    }

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

// CsenservdescTester::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CsenservdescTester::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

  //      FUNCENTRY( CsenservdescTester::PrintTest ),

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

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

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

		ENTRY("NewL-CSenCredential_baseElement",  CsenservdescTester::MT_CSenCredential_NewL_1L),

		ENTRY("NewLC-CSenCredential_baseElement",  CsenservdescTester::MT_CSenCredential_NewLC_1L),

		ENTRY("NewL-CSenCredential_copy",  CsenservdescTester::MT_CSenCredential_NewL_2L),

		ENTRY("NewLC-CSenCredential_copy",  CsenservdescTester::MT_CSenCredential_NewLC_2L),

		ENTRY("ValidUntil-CSenCredential_ValidUntil",  CsenservdescTester::MT_CSenCredential_ValidUntilL),

		ENTRY("SetValidUntil-CSenCredential_SetValidUntil",  CsenservdescTester::MT_CSenCredential_SetValidUntilL),

		//ENTRY("NewLC-CSenCredential_Id",  CsenservdescTester::MT_CSenCredential_IdL),

		ENTRY("StartElement-CSenCredential_StartElement",  CsenservdescTester::MT_CSenCredential_StartElementLL),

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

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

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

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

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

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

		ENTRY("NewL-CSenCredential2_copy",  CsenservdescTester::MT_CSenCredential2_NewL_3L),

		ENTRY("NewLC-CSenCredential2_copy",  CsenservdescTester::MT_CSenCredential2_NewLC_3L),

		ENTRY("NewL-CSenCredential2_document",  CsenservdescTester::MT_CSenCredential2_NewL_4L),

		ENTRY("NewLC-CSenCredential2_document",  CsenservdescTester::MT_CSenCredential2_NewLC_4L),

		ENTRY("Id-CSenCredential2_Id",  CsenservdescTester::MT_CSenCredential2_IdL),

		ENTRY("ValidUntil-CSenCredential2_ValidUntil",  CsenservdescTester::MT_CSenCredential2_ValidUntilL),

		ENTRY("SetValidUntil-CSenCredential2_SetValidUntil",  CsenservdescTester::MT_CSenCredential2_SetValidUntilL),

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

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

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

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

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

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

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

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

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

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

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

		ENTRY("NewL-Enpoint_+_Contract",  CsenservdescTester::MT_CSenIdentityProvider_NewL_1L),

		ENTRY("NewLC-Enpoint_+_Contract",  CsenservdescTester::MT_CSenIdentityProvider_NewLC_1L),

		ENTRY("NewL-Provider_+_Contract_+_Endpoint",  CsenservdescTester::MT_CSenIdentityProvider_NewL_2L),

		ENTRY("NewLC-Provider_+_Contract_+_Endpoint",  CsenservdescTester::MT_CSenIdentityProvider_NewLC_2L),

		ENTRY("NewL-ServiceID_+_Provider_+_Contract_+_Endpoint",  CsenservdescTester::MT_CSenIdentityProvider_NewL_3L),

		ENTRY("NewLC-ServiceID_+_Provider_+_Contract_+_Endpoint",  CsenservdescTester::MT_CSenIdentityProvider_NewLC_3L),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // Example how to use OOM functionality

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

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

        };

        //ADD NEW ENTRY HERE

        // [test cases entries]-Do not remove

        //};

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CsenservdescTester::ExampleL

// Example test method function.

// (other items were commented in a header).

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

//

void CsenservdescTester::SetupL(  )

    {

    } 

void CsenservdescTester::Teardown(  )

    {

    }

TPtr16 CsenservdescTester::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 CsenservdescTester::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 CsenservdescTester::MT_CSenCredential_NewLL( CStifItemParser& aItem )

    {

    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 CsenservdescTester::MT_CSenCredential_NewLCL( CStifItemParser& aItem )

    {

    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 CsenservdescTester::MT_CSenCredential_NewL_1L( CStifItemParser& aItem )

    {

    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 CsenservdescTester::MT_CSenCredential_NewLC_1L( CStifItemParser& aItem )

    {

    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 CsenservdescTester::MT_CSenCredential_NewL_2L( CStifItemParser& aItem )

    {

    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 CsenservdescTester::MT_CSenCredential_NewLC_2L( CStifItemParser& aItem )

    {

    SetupL();

    RAttributeArray attributeArray;

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

    senCredential = CSenCredential::NewLC(*orgSenCredential);

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

    //checking xml

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

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

    CleanupStack::PopAndDestroy();//Ptr

    CleanupStack::Pop();

    __ASSERT_ALWAYS_NO_LEAVE(delete senCredential);

    senCredential = NULL;

    delete orgSenCredential;

    orgSenCredential = NULL;

    attributeArray.Reset();

    attributeArray.Close();

    Teardown();

    return KErrNone;

   }

TInt CsenservdescTester::MT_CSenCredential_ValidUntilL( CStifItemParser& aItem )

    {

    SetupL();    

    RAttributeArray attributes;

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

    TTime time;

    _LIT(KTimeString1,"23:34.56");

    time.Parse(KTimeString1);

    /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/

    __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));	

    LOCAL_ASSERT(senCredential->ValidUntil() == time); 

    /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */

    __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil());	

    //checking xml

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

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

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

    /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/

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