/*

* 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 <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <e32math.h>

#include <libc/assert.h>

#include <e32panic.h>

#include "testxml.h"

#include "senxmlTester.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

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

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

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

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

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

// CsenxmlTester::Delete

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

// Called from destructor. 

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

//

void CsenxmlTester::Delete() 

    {

    }

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

// CsenxmlTester::RunMethodL

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

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

//

TInt CsenxmlTester::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

		ENTRY("NewL-CSenBaseAttribute", CsenxmlTester::CSenBaseAttribute_NewLL),

		ENTRY("NewL-CSenBaseAttribute", CsenxmlTester::CSenBaseAttribute_NewL_1L),

		ENTRY("NewL-CSenBaseElement", CsenxmlTester::CSenBaseElement_NewLL),

		ENTRY("NewL-CSenBaseElement", CsenxmlTester::CSenBaseElement_NewL_1L),

		ENTRY("NewL-CSenBaseElement", CsenxmlTester::CSenBaseElement_NewL_2L),

		ENTRY("NewL-CSenBaseElement", CsenxmlTester::CSenBaseElement_NewL_3L),

		ENTRY("NewL-CSenBaseElement", CsenxmlTester::CSenBaseElement_NewL_4L),

		ENTRY("SetAttributesL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetAttributesLL),

		ENTRY("LocalName-CSenBaseElement",CsenxmlTester::CSenBaseElement_LocalNameL),

		ENTRY("NamespaceURI-CSenBaseElement", CsenxmlTester::CSenBaseElement_NamespaceURIL),

		ENTRY("NsPrefix-CSenBaseElement", CsenxmlTester::CSenBaseElement_NsPrefixL),

		ENTRY("SetPrefixL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetPrefixLL),

		ENTRY("HasContentTrue-CSenBaseElement", CsenxmlTester::CSenBaseElement_HasContentTL),

		ENTRY("HasContentFalse-CSenBaseElement", CsenxmlTester::CSenBaseElement_HasContentFL),

		ENTRY("Content-CSenBaseElement", CsenxmlTester::CSenBaseElement_ContentL),

		ENTRY("ContentNull-CSenBaseElement", CsenxmlTester::CSenBaseElement_Content_NullL),

		ENTRY("ContentUnicodeL-CSenBaseElement", CsenxmlTester::CSenBaseElement_ContentUnicodeLL),

		ENTRY("SetContentL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetContentLL),

		ENTRY("SetContentNullL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetContentL_NullL),

		ENTRY("SetContentoverrightL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetContentL_OverRightL),

		ENTRY("SetContentEscCharL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetContentL_WithEscCharsL),

		ENTRY("ConsistsOfL-CSenBaseElement", CsenxmlTester::CSenBaseElement_ConsistsOfLL),

		ENTRY("SetNamespaceL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceLL),

		ENTRY("SetNamespaceNullL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceL_NullL),

		ENTRY("SetNamespaceL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceL_1L),

		ENTRY("SetNamespace2SameL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceL_2same1L),

		ENTRY("SetNamespace2DiffL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceL_2Diff1L),

		ENTRY("SetNamespaceDPSUL-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceL_DPSU1L),       

		ENTRY("SetNamespaceSameNsforPC1L-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetNamespaceL_SNsPC1L),           

		ENTRY("AddNamespace_FalseL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_FL),

		ENTRY("AddNamespace_TrueL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_TL),    

		ENTRY("AddNamespace_TrueSameParentNSL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_TSPL),      

		ENTRY("AddNamespace_TrueDiffParentNSL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_TDPL),          

		ENTRY("AddNamespaceL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_1L),

		ENTRY("AddNamespace2SameL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_2same1L),

		ENTRY("AddNamespace2DiffL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddNamespaceL_2Diff1L),

		ENTRY("Namespace-CSenBaseElement", CsenxmlTester::CSenBaseElement_NamespaceL),

		ENTRY("Namespace-CSenBaseElement", CsenxmlTester::CSenBaseElement_Namespace_1L),

		ENTRY("Namespace_with_parent1-CSenBaseElement", CsenxmlTester::CSenBaseElement_Namespace_WP1L),

		ENTRY("Namespace-test2-CSenBaseElement", CsenxmlTester::CSenBaseElement_Namespace_2L),

		ENTRY("Namespace-test3-CSenBaseElement", CsenxmlTester::CSenBaseElement_Namespace_3L),

		ENTRY("ElementsL-CSenBaseElement", CsenxmlTester::CSenBaseElement_ElementsLL),

		ENTRY("AttributesL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AttributesLL),

		ENTRY("NamespacesL-CSenBaseElement", CsenxmlTester::CSenBaseElement_NamespacesLL),

		ENTRY("AttrValue-CSenBaseElement", CsenxmlTester::CSenBaseElement_AttrValueL),

		ENTRY("AddAttrL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddAttrLL),

		ENTRY("AddAttributeL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddAttributeLL),		

		ENTRY("Parent-CSenBaseElement", CsenxmlTester::CSenBaseElement_ParentL),

		ENTRY("SetParent-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetParentL),

		ENTRY("Root-CSenBaseElement", CsenxmlTester::CSenBaseElement_RootL),

		ENTRY("Element-CSenBaseElement", CsenxmlTester::CSenBaseElement_ElementL),

		ENTRY("Elements1-CSenBaseElement", CsenxmlTester::CSenBaseElement_ElementsL1),

		ENTRY("Elements2-CSenBaseElement", CsenxmlTester::CSenBaseElement_ElementsL2),

		ENTRY("CreateElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_CreateElementLL),

		ENTRY("InsertElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_InsertElementLL),

		ENTRY("InsertElement_No_BeforeElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_InsertElementL_NoBeforeL),

		ENTRY("AddElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddElementLL),

		ENTRY("AddElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddElementL_1L),

		ENTRY("AddElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddElementL_2L),

		ENTRY("AddElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddElementL_3L),

		ENTRY("RemoveElement-CSenBaseElement", CsenxmlTester::CSenBaseElement_RemoveElementL),

		ENTRY("RemoveElement-CSenBaseElement", CsenxmlTester::CSenBaseElement_RemoveElement_1L),

		ENTRY("RemoveElement-CSenBaseElement", CsenxmlTester::CSenBaseElement_RemoveElement_2L),

		ENTRY("ReplaceElementL-CSenBaseElement", CsenxmlTester::CSenBaseElement_ReplaceElementLL),

		ENTRY("AsXmlL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AsXmlLL),

		ENTRY("AsXmlUnicodeL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AsXmlUnicodeLL),

		ENTRY("CopyFromL-CSenBaseElement", CsenxmlTester::CSenBaseElement_CopyFromLL),

		ENTRY("DetachL-CSenBaseElement", CsenxmlTester::CSenBaseElement_DetachLL),

		ENTRY("Child-CSenBaseElement", CsenxmlTester::CSenBaseElement_ChildL),

		ENTRY("Set-CSenBaseElement", CsenxmlTester::CSenBaseElement_SetL),

		ENTRY("AddAttributesL-CSenBaseElement", CsenxmlTester::CSenBaseElement_AddAttributesLL),

		ENTRY("AsElement-CSenBaseElement", CsenxmlTester::CSenBaseElement_AsElementL),

		ENTRY("ContentWriteStreamL-CSenBaseElement", CsenxmlTester::CSenBaseElement_ContentWriteStreamLL),

		ENTRY("RemoveAttributeL-CSenBaseElement", CsenxmlTester::CSenBaseElement_RemoveAttributeLL),

		ENTRY("NewL-CSenXmlElement", CsenxmlTester::CSenXmlElement_NewLL),

		ENTRY("NewL-CSenXmlElement", CsenxmlTester::CSenXmlElement_NewL_1L),

		ENTRY("NewL-CSenXmlElement", CsenxmlTester::CSenXmlElement_NewL_2L),

		ENTRY("SetAttributesL-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetAttributesLL),

		ENTRY("LocalName-CSenXmlElement", CsenxmlTester::CSenXmlElement_LocalNameL),

		ENTRY("NamespaceURI-CSenXmlElement", CsenxmlTester::CSenXmlElement_NamespaceURIL),

		ENTRY("NsPrefix-CSenXmlElement", CsenxmlTester::CSenXmlElement_NsPrefixL),

		ENTRY("SetPrefixL-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetPrefixLL),

		ENTRY("HasContent-CSenXmlElement", CsenxmlTester::CSenXmlElement_HasContentL),

		ENTRY("Content-CSenXmlElement", CsenxmlTester::CSenXmlElement_ContentL),

		ENTRY("ContentWriteStreamL-CSenXmlElement", CsenxmlTester::CSenXmlElement_ContentWriteStreamLL),

		ENTRY("ContentUnicodeL-CSenXmlElement", CsenxmlTester::CSenXmlElement_ContentUnicodeLL),

		ENTRY("SetContentL-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetContentLL),

		ENTRY("ConsistsOfL-CSenXmlElement", CsenxmlTester::CSenXmlElement_ConsistsOfLL),

		ENTRY("ConsistsOfL-CSenXmlElement", CsenxmlTester::CSenXmlElement_ConsistsOfL1L),

		ENTRY("ConsistsOfL-Extratest_CSenXmlElement", CsenxmlTester::CSenXmlElement_ConsistsOfL1L),

		ENTRY("SetNamespaceL-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetNamespaceLL),

		ENTRY("SetNamespaceL-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetNamespaceL_1L),

		ENTRY("SetNamespaceL-Sametest_CSenXmlElement", CsenxmlTester::CSenXmlElement_SetNamespaceL_2same1L),

		ENTRY("SetNamespaceL-Difftest_CSenXmlElement", CsenxmlTester::CSenXmlElement_SetNamespaceL_2Diff1L),

		ENTRY("AddNamespaceL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddNamespaceLL),

		ENTRY("AddNamespaceL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddNamespaceL_1L),

		ENTRY("Namespace-CSenXmlElement", CsenxmlTester::CSenXmlElement_NamespaceL),

		ENTRY("Namespace-CSenXmlElement", CsenxmlTester::CSenXmlElement_Namespace_1L),

		ENTRY("Namespace-CSenXmlElement", CsenxmlTester::CSenXmlElement_Namespace_2L),

		ENTRY("Namespace-CSenXmlElement", CsenxmlTester::CSenXmlElement_Namespace_3L),

		ENTRY("ElementsL-CSenXmlElement", CsenxmlTester::CSenXmlElement_ElementsLL),

		ENTRY("AttributesL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AttributesLL),

		ENTRY("AttributeLL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddAttributeLL),

		ENTRY("NamespacesL-CSenXmlElement", CsenxmlTester::CSenXmlElement_NamespacesLL),

		ENTRY("AttrValue-CSenXmlElement", CsenxmlTester::CSenXmlElement_AttrValueL),

		ENTRY("AddAttrL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddAttrLL),

		ENTRY("Parent-CSenXmlElement", CsenxmlTester::CSenXmlElement_ParentL),

		ENTRY("SetParent-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetParentL),

		ENTRY("Root-CSenXmlElement", CsenxmlTester::CSenXmlElement_RootL),

		ENTRY("Element-CSenXmlElement", CsenxmlTester::CSenXmlElement_ElementL),

		ENTRY("CreateElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_CreateElementLL),

		ENTRY("InsertElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_InsertElementLL),

		ENTRY("AddElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddElementLL),

		ENTRY("AddElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddElementL_1L),

		ENTRY("AddElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddElementL_2L),

		ENTRY("AddElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddElementL_3L),

		ENTRY("RemoveElement-CSenXmlElement", CsenxmlTester::CSenXmlElement_RemoveElementL),

		ENTRY("RemoveElement-CSenXmlElement", CsenxmlTester::CSenXmlElement_RemoveElement_1L),

		ENTRY("RemoveElement-CSenXmlElement", CsenxmlTester::CSenXmlElement_RemoveElement_2L),

		ENTRY("ReplaceElementL-CSenXmlElement", CsenxmlTester::CSenXmlElement_ReplaceElementLL),

		ENTRY("AsXmlL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AsXmlLL),

		ENTRY("AsXmlUnicodeL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AsXmlUnicodeLL),

		ENTRY("CopyFromL-CSenXmlElement", CsenxmlTester::CSenXmlElement_CopyFromLL),

		ENTRY("DetachL-CSenXmlElement", CsenxmlTester::CSenXmlElement_DetachLL),

		ENTRY("Child-CSenXmlElement", CsenxmlTester::CSenXmlElement_ChildL),

		ENTRY("Set-CSenXmlElement", CsenxmlTester::CSenXmlElement_SetL),

		ENTRY("AddAttributesL-CSenXmlElement", CsenxmlTester::CSenXmlElement_AddAttributesLL),

		//ENTRY("RemoveAttributeL-CSenXmlElement", CsenxmlTester::CSenXmlElement_RemoveAttributeLL),

		ENTRY("AsElement-CSenXmlElement", CsenxmlTester::CSenXmlElement_AsElementL),

		ENTRY("NewL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NewL_L),

		ENTRY("NewL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NewL_1L),

		ENTRY("NewL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NewL_2L),

		ENTRY("NewL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NewL_3L),

		ENTRY("NewL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NewL_4L),

		ENTRY("NewL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NewL_5L),

		ENTRY("AsXmlUnicodeL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_AsXmlUnicodeLL),

		ENTRY("WriteAsXMLToL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_WriteAsXMLToLL),

    	ENTRY("Content-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ContentL),

    	ENTRY("Namespace-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NamespaceL),

    	ENTRY("EnsureNamespace-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_EnsureNamespaceL),

    	ENTRY("DetachL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_DetachLL),

		ENTRY("SaveNamespacesLL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_SaveNamespacesLL),

		ENTRY("ResetContentLL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ResetContentLL),

		ENTRY("LocalNameL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_LocalNameL),

		ENTRY("NsUriL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NsUriL),

		ENTRY("NsPrefixL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_NsPrefixL),

		ENTRY("ExtractElementL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ExtractElementL),

		ENTRY("SetAttributesL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_SetAttributesLL),

		ENTRY("ConsistsOfL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ConsistsOfLL),

		ENTRY("ParseL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ParseLL),

		ENTRY("ErrorParseL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ParseL1L),

		ENTRY("SetContentOfL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_SetContentOfLL),

		ENTRY("ContentOf-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_ContentOfL),

		ENTRY("ParserFeature-CSenXMLReader", CsenxmlTester::CSenXMLReader_ParserFeatureL),

		ENTRY("ParseL-CSenXMLReader", CsenxmlTester::CSenXMLReader_ParseLL),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_1L),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_L),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_2L),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_3L),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_4L),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_5L),

		ENTRY("NewL-CSenDomFragment", CsenxmlTester::CSenDomFragment_NewL_6L),

		//ENTRY("ExpandL-CSenDomFragment", CsenxmlTester::CSenDomFragment_ExpandLL),

		//ENTRY("ResumeParsingFromL-CSenDomFragment", CsenxmlTester::CSenDomFragment_ResumeParsingFromLL),

		ENTRY("ParseWithL-CSenDomFragment", CsenxmlTester::CSenDomFragment_ParseWithLL),

		ENTRY("SetAttributesL-CSenDomFragment", CsenxmlTester::CSenDomFragment_SetAttributesLL),

		ENTRY("ParseL1-CSenDomFragment", CsenxmlTester::CSenDomFragment_ParseL1L),

		ENTRY("NewL-CSenNamespace", CsenxmlTester::CSenNamespace_NewL_L),    

		ENTRY("NewLC-CSenNamespace", CsenxmlTester::CSenNamespace_NewLC_L),

		ENTRY("NewL-CSenNamespace", CsenxmlTester::CSenNamespace_NewL_1L),

		ENTRY("NewLC-CSenNamespace", CsenxmlTester::CSenNamespace_NewLC_1L),

		ENTRY("MatchesL-CSenNamespace", CsenxmlTester::CSenNamespace_MatchesL_L),

		ENTRY("InsertL-CSenNamespace", CsenxmlTester::CSenNamespace_InsertLL),

		ENTRY("NewL-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewL_L),

		ENTRY("NewLC-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewLC_L),

		ENTRY("NewL-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewL_1L),

		ENTRY("NewLC-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewLC_1L),

		ENTRY("NewL-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewL_2L),

		ENTRY("NewLC-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewLC_2L),

		ENTRY("NewL-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewL_3L),

		ENTRY("NewLC-CSenXmlReader", CsenxmlTester::CSenXmlReader_NewLC_3L),

		ENTRY("EnabledParserFeature-CSenXmlReader", CsenxmlTester::CSenXmlReader_EnabledParserFeature_L),

		ENTRY("ToUtf8LC-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_ToUtf8LCL),

		ENTRY("StartsWith-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_StartsWithL),

		ENTRY("EndsWith-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_EndsWithL),

		ENTRY("AttrValue-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_AttrValueL),

		ENTRY("AllocAttrValueL-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_AllocAttrValueLL),

		ENTRY("DecodeHttpCharactersL-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_DecodeHttpCharactersLL),

		ENTRY("DecodeHttpCharactersLC-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_DecodeHttpCharactersLCL),

		ENTRY("NsPrefix-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_NsPrefixL),

		ENTRY("LocalName-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_LocalNameL),

		ENTRY("RemoveAttributeL-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_RemoveAttributeLL),

		ENTRY("RemoveAttributeL1-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_RemoveAttributeL1L),

		ENTRY("AddAttributeL-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_AddAttributeLL),

		ENTRY("AddAttributeL1-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_AddAttributeL1L),

		ENTRY("AddAttributeL1-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_AddAttributeL2L),

		ENTRY("EncodeHttpCharactersLC-CSenXmlUtils", CsenxmlTester::CSenXmlUtils_EncodeHttpCharactersLCL),

		ENTRY("BaseConstructL-CSenDomFragment", CsenxmlTester::CSenDomFragment_BaseConstructL),

		ENTRY("BaseConstructL-CSenBaseFragment", CsenxmlTester::CSenBaseFragment_BaseConstructL),

        //ADD NEW ENTRY HERE

        // [test cases entries]-Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

void CsenxmlTester::SetupL(  ){

    if ( iXmlReader ){

        delete iXmlReader;

        iXmlReader = NULL;

    }

    iXmlReader = CSenXmlReader::NewL(

    );

} 

void CsenxmlTester::Teardown(  ){

    if ( iXmlReader){

        delete iXmlReader;

        iXmlReader = NULL;

    }

}

TInt CsenxmlTester::CSenBaseAttribute_NewLL (CStifItemParser& aItem)

    {

    SetupL();

    TBool Flag;

    CSenBaseAttribute* pAttr=CSenBaseAttribute::NewL(_L8("Attr1"),_L8("value"));

    CleanupStack::PushL(pAttr);

    if(pAttr)

    	Flag=1;

    else

    	Flag=0;

        /*EUNIT_ASSERT( Flag );*/

    if(!Flag)

    return KErrArgument;   

    CleanupStack::PopAndDestroy(pAttr);

    Teardown();

    return KErrNone;

    }

TInt CsenxmlTester::CSenBaseAttribute_NewL_1L (CStifItemParser& aItem)

    {

    SetupL();    

    TBool Flag;

    CSenBaseAttribute* pAttr=CSenBaseAttribute::NewL(_L8("N:Attr1"),_L8("Attr1"),_L8("value"));

    CleanupStack::PushL(pAttr);

    if(pAttr)

    	Flag=1;

    else

    	Flag=0;

        /*EUNIT_ASSERT( Flag );*/