/*

* Copyright (c) 2002 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 <StifTestModule.h>

#include <e32math.h>

#include <libc/assert.h>

#include <e32panic.h>

#include "SenXmlBCTest.h"

#include "TestXml.h"

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

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

// CSenUtilsBCTest::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 CSenXmlBCTest::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 

    *    SenUtils.cpp file and to SenUtils.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[] =

        {

        //  TEST TABLE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		ENTRY("Namespace_with parent1 - CSenBaseElement ", CSenXmlBCTest::CSenBaseElement_Namespace_WP1L),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		ENTRY("ConsistsOfL - Extratest CSenXmlElement", CSenXmlBCTest::CSenXmlElement_ConsistsOfL1L),

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

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

		ENTRY("SetNamespaceL - Sametest CSenXmlElement", CSenXmlBCTest::CSenXmlElement_SetNamespaceL_2same1L),

		ENTRY("SetNamespaceL - Difftest CSenXmlElement", CSenXmlBCTest::CSenXmlElement_SetNamespaceL_2Diff1L),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*    

		ENTRY("RemoveAttributeL - CSenXmlElement ", CSenXmlBCTest::CSenXmlElement_RemoveAttributeLL),

*/    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // Example how to use OOM functionality

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

        //OOM_FUNCENTRY( CSenUtilsBCTest::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 = 0 ;

        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;

    }

void CSenXmlBCTest::SetupL(  ){

    if ( iXmlReader ){

        delete iXmlReader;

        iXmlReader = NULL;

    }

    iXmlReader = CSenXmlReader::NewL(

    );

} 

void CSenXmlBCTest::Teardown(  ){

    if ( iXmlReader){

        delete iXmlReader;

        iXmlReader = NULL;

    }

}

TInt CSenXmlBCTest::CSenBaseAttribute_NewLL (TTestResult& aResult)

    {

    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 CSenXmlBCTest::CSenBaseAttribute_NewL_1L (TTestResult& aResult)

    {

    SetupL();    

    TBool Flag;

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

    CleanupStack::PushL(pAttr);

    if(pAttr)

    	Flag=1;

    else

    	Flag=0;