/*

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

#include <e32math.h>

#include <libc/assert.h>

#include <e32panic.h>

#include "senfragmentbctest.h"

#include "maindomfragment.h"

#include "mainfragment.h"

#include "TestFragment.h"

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

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

// CSenFragmentBCTest::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 CSenFragmentBCTest::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 

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

        {

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewLL ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_1L ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_2L ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_3L ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_4L ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_5L ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_6L ),

        ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_7L ),

        ENTRY( "AddAttributesL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AddAttributesLL ),

        ENTRY( "AsXmlL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlLL ),

        ENTRY( "ContentL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentLL ),

        ENTRY( "Namespace - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NamespaceL ),

        ENTRY( "ResetContentL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ResetContentLL ),

        ENTRY( "LocalName - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_LocalNameL ),

        ENTRY( "NsUri - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NsUriL ),

        ENTRY( "NsPrefix - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NsPrefixL ),

        ENTRY( "AsElementL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsElementLL ),

        ENTRY( "AsDocumentL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsDocumentLL ),

        ENTRY( "ExtractElement - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ExtractElementL ),

        ENTRY( "AsXmlUnicodeL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlUnicodeLL ),

        ENTRY( "WriteAsXMLToL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_WriteAsXMLToLL ),

        ENTRY( "ConsistsOfL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ConsistsOfLL ),

        ENTRY( "Parsing1 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing1L ),

        ENTRY( "Parsing2 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing2L ),

        ENTRY( "Parsing3 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing3L ),

        ENTRY( "Parsing4 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing4L ),

        ENTRY( "Parsing5 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing5L ),

        ENTRY( "Parsing6 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing6L ),

        ENTRY( "Parsing7 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing7L ),

        ENTRY( "Parsing8 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing8L ),

        //ENTRY( "SetContentOfL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_SetContentOfLL ),

        //ENTRY( "ContentOf - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentOfL ),

        ENTRY( "OnWriteStartElementL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteStartElementLL ),

        ENTRY( "OnWriteEndElementL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteEndElementLL ),

        ENTRY( "OnIgnorableWhiteSpaceL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL ),

        ENTRY( "OnSkippedEntityL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnSkippedEntityLL ),

        ENTRY( "OnProcessingInstructionL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnProcessingInstructionLL ),

        ENTRY( "OnError - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnErrorL ),

        ENTRY( "GetExtendedInterface - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_GetExtendedInterfaceL ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewLL ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_2L ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_3L ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_4L ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_5L ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_6L ),

        ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_7L ),

        ENTRY( "SetDocument - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_SetDocumentL ),

        ENTRY( "ContentL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ContentLL ),

        ENTRY( "Namespace - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NamespaceL ),

        ENTRY( "ResetContentL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ResetContentLL ),

        ENTRY( "LocalName - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_LocalNameL ),

        ENTRY( "NsUri - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NsUriL ),

        ENTRY( "NsPrefix - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NsPrefixL ),

        ENTRY( "AsElementL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsElementLL ),

        ENTRY( "AsDocumentL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsDocumentLL ),

        ENTRY( "ExtractElement - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ExtractElementL ),

        ENTRY( "AsXmlUnicodeL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlUnicodeLL ),

        ENTRY( "AsXmlL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlLL ),

        ENTRY( "WriteAsXMLToL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_WriteAsXMLToLL ),

        ENTRY( "ConsistsOfL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ConsistsOfLL ),

        ENTRY( "Parsing1 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing1L ),

        ENTRY( "Parsing2 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing2L ),

        ENTRY( "Parsing3 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing3L ),

        ENTRY( "Parsing4 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing4L ),

        ENTRY( "Parsing5 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing5L ),

        ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLL ),

        ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLCL ),

        ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewL_1L ),

        ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLC_1L ),

        ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewL_2L ),

        ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLC_2L ),

//        ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewL_3L ),

//        ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLC_3L ),

        ENTRY( "NewL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewLL ),

        ENTRY( "NewLC - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewLCL ),

        ENTRY( "NewL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewL_1L ),

        ENTRY( "NewLC - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewLC_1L ),

        ENTRY( "Copy - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_CopyL ),

        ENTRY( "Close - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_CloseL ),

        ENTRY( "Destroy - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_DestroyL ),

        ENTRY( "Destroy - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_DestroyL ),

        ENTRY( "ManualXmlEngineTlsAttachL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsAttachLL ),

        ENTRY( "ManualXmlEngineTlsAttachL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsCleanupL ),

        ENTRY( "SetContentL - TestFragmentBase", CSenFragmentBCTest::MT_TestFragmentBase_SetContentLL ),

        ENTRY( "AddContentL - TestFragmentBase", CSenFragmentBCTest::MT_TestFragmentBase_AddContentLL ),

        ENTRY( "SetContentOfL - TestDomFragmentBase", CSenFragmentBCTest::MT_TestDomFragmentBase_SetContentOfLL ),

        //ENTRY( "ContentOf - TestDomFragmentBase", CSenFragmentBCTest::MT_TestDomFragmentBase_ContentOfL ),

        // Example how to use OOM functionality

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

        //OOM_FUNCENTRY( CSenFragmentBCTest::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;

    }

void CSenFragmentBCTest::SetupL(  ){

    if ( iXmlReader ){

        delete iXmlReader;

        iXmlReader = NULL;

    }

    iXmlReader = CSenXmlReader::NewL();

} 

void CSenFragmentBCTest::Teardown(  ){

    if ( iXmlReader){

        delete iXmlReader;

        iXmlReader = NULL;

    }

}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewLL(TTestResult& aResult)

	{

    SetupL();

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL();

    TL(pFragment != (CSenDomFragmentBase*)NULL);

    __ASSERT_ALWAYS_NO_LEAVE(delete pFragment);

    pFragment = NULL;

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_1L(TTestResult& aResult)

	{

    SetupL();

    RSenDocument document = RSenDocument::NewL();

    CleanupClosePushL(document);

    TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));

    element.SetEscapedTextL(_L8("<Element/>"));

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element);

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    // Test that when CSenDomFragmentBase is serialized '<' and '>' characters

    // are encoded (as all basic entities in content should be).

    if(!( *pAsXml == _L8("<Test>&lt;Element/&gt;</Test>") ))return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    CleanupStack::Pop(1);

    //CleanupStack::PopAndDestroy(&document);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_2L(TTestResult& aResult)

	{

    SetupL();	

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<Test/>") )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_3L(TTestResult& aResult)

	{

    SetupL();	

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),

                                                               _L8("Test"));

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<Test xmlns=\"NsUri\"/>") )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_4L(TTestResult& aResult)

	{

    SetupL();	

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),

                                                               _L8("Test"),

                                                               _L8("t"));

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_5L(TTestResult& aResult)

	{

    SetupL();	

    RStringPool stringPool;

    stringPool.OpenL();

    CleanupClosePushL(stringPool);

    RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

    CleanupClosePushL(nsUriRString);

    RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

    CleanupClosePushL(nsPrefixRString);

    RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

    CleanupClosePushL(localNameRString);

    RString valueRString        = stringPool.OpenStringL(_L8("Value"));

    CleanupClosePushL(valueRString);

    RAttribute attribute;

    attribute.Open( nsUriRString, nsPrefixRString, localNameRString,

                    valueRString );

    // attribute took ownership of all RStrings

    // => All RStrings can be pop from CleanupStack

    CleanupStack::Pop(&valueRString);

    CleanupStack::Pop(&localNameRString);

    CleanupStack::Pop(&nsPrefixRString);

    CleanupStack::Pop(&nsUriRString);

    CleanupClosePushL(attribute);

    RAttributeArray attrArray;

    // append the namespace attribute (declaration)

    attrArray.AppendL(attribute);

    CleanupClosePushL(attrArray);

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),

                                                               _L8("Test"),

                                                               _L8("t"),

                                                               attrArray);

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    CleanupStack::PopAndDestroy(&attrArray);

    CleanupStack::PopAndDestroy(&attribute);

    CleanupStack::PopAndDestroy(&stringPool);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_6L(TTestResult& aResult)

	{

    SetupL();	

    RSenDocument document = RSenDocument::NewL();

    CleanupClosePushL(document);

    TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));

    RStringPool stringPool;

    stringPool.OpenL();

    CleanupClosePushL(stringPool);

    RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

    CleanupClosePushL(nsUriRString);

    RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

    CleanupClosePushL(nsPrefixRString);

    RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

    CleanupClosePushL(localNameRString);

    RString valueRString        = stringPool.OpenStringL(_L8("Value"));

    CleanupClosePushL(valueRString);

    RAttribute attribute;

    attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

                   valueRString);

    // attribute took ownership of all RStrings

    // => All RStrings can be pop from CleanupStack

    CleanupStack::Pop(&valueRString);

    CleanupStack::Pop(&localNameRString);

    CleanupStack::Pop(&nsPrefixRString);

    CleanupStack::Pop(&nsUriRString);

    CleanupClosePushL(attribute);

    RAttributeArray attrArray;

    // append the namespace attribute (declaration)

    attrArray.AppendL(attribute);

    CleanupClosePushL(attrArray);

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),

                                                               _L8("Test"),

                                                               _L8("t"),

                                                               attrArray,

                                                               parentElement);

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") )) return KErrArgument;

    RBuf8 buffer;

    parentElement.OuterXmlL(buffer);

    if(!( buffer == _L8("<Parent><t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") )) return KErrArgument;

    buffer.Close();

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    CleanupStack::PopAndDestroy(&attrArray);

    CleanupStack::PopAndDestroy(&attribute);

    CleanupStack::PopAndDestroy(&stringPool);

    CleanupStack::PopAndDestroy(&document);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_7L(TTestResult& aResult)

	{

    SetupL();	

    RSenDocument document = RSenDocument::NewL();

    CleanupClosePushL(document);

    TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));

    RStringPool stringPool;

    stringPool.OpenL();

    CleanupClosePushL(stringPool);

    RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

    CleanupClosePushL(nsUriRString);

    RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

    CleanupClosePushL(nsPrefixRString);

    RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

    CleanupClosePushL(localNameRString);

    RString valueRString        = stringPool.OpenStringL(_L8("Value"));

    CleanupClosePushL(valueRString);

    RAttribute attribute;

    attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

                   valueRString);

    // attribute took ownership of all RStrings

    // => All RStrings can be pop from CleanupStack

    CleanupStack::Pop(&valueRString);

    CleanupStack::Pop(&localNameRString);

    CleanupStack::Pop(&nsPrefixRString);

    CleanupStack::Pop(&nsUriRString);

    CleanupClosePushL(attribute);

    RAttributeArray attrArray;

    // append the namespace attribute (declaration)

    attrArray.AppendL(attribute);

    CleanupClosePushL(attrArray);

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),

                                                               _L8("Test"),

                                                               _L8(""),

                                                               attrArray,

                                                               parentElement,

                                                               document);

    CleanupStack::PushL(pFragment);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") )) return KErrArgument;

    RBuf8 buffer;

    parentElement.OuterXmlL(buffer);

    if(!( buffer == _L8("<Parent><Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") )) return KErrArgument;

    buffer.Close();

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    CleanupStack::PopAndDestroy(&attrArray);

    CleanupStack::PopAndDestroy(&attribute);

    CleanupStack::PopAndDestroy(&stringPool);

    CleanupStack::PopAndDestroy(&document);

    Teardown();

    return KErrNone;

	}

TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AddAttributesLL(TTestResult& aResult)

	{

    SetupL();	

    RStringPool stringPool;

    stringPool.OpenL();

    CleanupClosePushL(stringPool);

    RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

    CleanupClosePushL(nsUriRString);

    RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

    CleanupClosePushL(nsPrefixRString);

    RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

    CleanupClosePushL(localNameRString);

    RString valueRString        = stringPool.OpenStringL(_L8("Value"));

    CleanupClosePushL(valueRString);

    RAttribute attribute;

    attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

                   valueRString);

    // attribute took ownership of all RStrings

    // => All RStrings can be pop from CleanupStack

    CleanupStack::Pop(4); // nsUriRString, nsPrefixRString, localNameRString,

                          // valueRString

    CleanupClosePushL(attribute);

    RAttributeArray attrArray;

    // append the namespace attribute (declaration)

    attrArray.AppendL(attribute);

    CleanupClosePushL(attrArray);    

    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));

    CleanupStack::PushL(pFragment);

    pFragment->AddAttributesL(attrArray);

    HBufC8* pAsXml = pFragment->AsXmlL();

    CleanupStack::PushL(pAsXml);

    if(!( *pAsXml == _L8("<Test xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") )) return KErrArgument;

    CleanupStack::PopAndDestroy(pAsXml);

    CleanupStack::PopAndDestroy(pFragment);

    CleanupStack::PopAndDestroy(&attrArray);

    CleanupStack::PopAndDestroy(&attribute);

    CleanupStack::PopAndDestroy(&stringPool);

    Teardown();

    return KErrNone;

	}