--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/websrv_pub/xml_fragment_api/tsrc/bc/senfragment/src/senfragmentcases.cpp	Thu Jul 08 14:00:07 2010 +0530
@@ -0,0 +1,2932 @@
+/*
+* 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;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlLL(TTestResult& aResult)
+	{
+    SetupL();	
+    // Test serialization of Dom tree which has two child elements
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
+
+    element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
+    
+    HBufC8* pAsXml = pFragment->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") ) ) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentLL(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);
+    
+    TPtrC8 content = pFragment->ContentL();
+    if(!( content == _L8("<Element/>") ) ) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(&document);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NamespaceL(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(stringPool.OpenStringL(_L8("nsuri")), 
+                   stringPool.OpenStringL(_L8("pr")),
+                   stringPool.OpenStringL(_L8("LocalName")),
+                   stringPool.OpenStringL(_L8("Value")) );
+    // attribute took copies of all RStrings
+    // => All RStrings can be destroyed
+    CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString,
+                                    // valueRString
+    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);
+    
+    TXmlEngNamespace ns = pFragment->Namespace(_L8("pr"));
+    if(!( ns.Uri() == _L8("nsuri") ) ) return KErrArgument;
+
+    TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x"));
+    if(!( ns2.IsNull() ) ) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(); // attribute
+    CleanupStack::PopAndDestroy(); // attrArray
+    CleanupStack::PopAndDestroy(); // stringPool   
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ResetContentLL(TTestResult& aResult)
+	{
+    SetupL();	
+    RSenDocument document = RSenDocument::NewL();
+    CleanupClosePushL(document);
+    TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
+    element.SetEscapedTextL(_L8("Content"));
+    
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element);
+    CleanupStack::PushL(pFragment);
+    
+    // Test that CSenFragmentBase has content before reset
+    TPtrC8 content = pFragment->ContentL();
+    if(!( content == _L8("Content") )) return KErrArgument;
+    
+    pFragment->ResetContentL();
+    
+    // Test that CSenFragmentBase has no content after reset
+    TPtrC8 content2 = pFragment->ContentL();
+    if(!( content2 == KNullDesC8 )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(&document);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_LocalNameL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TPtrC8 localName = pFragment->LocalName();
+    if(!( localName == _L8("Test") ) ) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NsUriL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TPtrC8 localName = pFragment->NsUri();
+    if(!( localName == _L8("NsUri") ) ) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NsPrefixL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TPtrC8 localName = pFragment->NsPrefix();
+    if(!( localName == _L8("t") ) ) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsElementLL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    RBuf8 buffer;
+    CleanupClosePushL(buffer);
+    element.OuterXmlL(buffer);
+    // Serialized element should contain all the Fragment data as XML.
+    if(!( buffer == _L8("<t:Test xmlns:t=\"NsUri\"/>") ) ) return KErrArgument;
+    CleanupStack::PopAndDestroy(&buffer);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsDocumentLL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    RSenDocument document = pFragment->AsDocumentL();
+    TXmlEngElement element = document.DocumentElement();
+    
+    TXmlEngSerializationOptions options;
+    // Omit following declarations from the beginning of XML Document:
+    // <?xml version=\"1.0\...
+    //   encoding="..."
+    //   standalone="..."
+    // ?>
+    options.iOptions = options.iOptions |
+                       TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+    RBuf8 asXml;
+    document.SaveL(asXml, element, options);
+    CleanupClosePushL(asXml);
+    
+    // Serialized document should contain all the Fragment data as XML.
+    if(!( asXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") ) ) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(&asXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ExtractElementL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->ExtractElement();
+    if(!( element.Name() == _L8("Test") )) return KErrArgument;
+    element.Remove();
+    CleanupStack::PopAndDestroy(pFragment);   
+    Teardown();
+    return KErrNone;
+	}
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlUnicodeLL(TTestResult& aResult)
+	{
+    SetupL();	
+    // Test serialization of Dom tree which has two child elements
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
+
+    element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
+    
+    HBufC* pAsXml = pFragment->AsXmlUnicodeL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == _L("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_WriteAsXMLToLL(TTestResult& aResult)
+	{
+    SetupL();	
+    // Test serialization of Dom tree which has two child elements
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
+
+    element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
+    
+    CBufFlat* pBuf = CBufFlat::NewL(200);
+    CleanupStack::PushL(pBuf);
+    RBufWriteStream bufWs(*pBuf);
+    CleanupClosePushL(bufWs);
+    pFragment->WriteAsXMLToL(bufWs);
+
+
+    if(!( pBuf->Ptr(0) == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(&bufWs);
+    CleanupStack::PopAndDestroy(pBuf);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ConsistsOfLL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild"));
+    elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+   
+    //TDomUtils domUtils1;
+    //domUtils1.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+
+    TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild"));
+    elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils2;
+    //domUtils2.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
+
+    CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment2);
+    TXmlEngElement element2 = pFragment2->AsElementL();
+    
+    TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild"));
+    elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils22;
+    //domUtils22.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
+
+    // ConsistOfL should return ETrue because
+    // root elements of both fragments match and the only element
+    // of pFragment2 = elementchild22 is exactly the same element as
+    // elementchild2.
+    if(!( pFragment->ConsistsOfL(*pFragment2) )) return KErrArgument;
+
+    // ConsistOfL should return EFalse because
+    // Even though root elements of both fragments match
+    // there is extra element (= elementchild1) in pFragment.
+    //
+    // elementchild1 (of pFragment) can not be found from pFragment2
+    // and because of that pFragment2 does not consist of pFragment.
+    if(!( !pFragment2->ConsistsOfL(*pFragment) )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment2);
+
+    CSenDomFragmentBase* pFragment3 = CSenDomFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment3);
+    TXmlEngElement element3 = pFragment3->AsElementL();
+    
+    TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild"));
+    elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils32;
+    //domUtils32.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
+    elementchild32.SetEscapedTextL(_L8("Text"));
+    
+    // ConsistOfL should return EFalse because
+    // elementchild32 has content ("Text") which doesn't match
+    // to any child element of pFragment.
+    if(!( !pFragment->ConsistsOfL(*pFragment3) )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment3);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing1L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
+<Element2 z=\"value4\">Content2</Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    // Default namespace declaration (xmlns="nsuri") from Parent element (Test)
+    // will be moved to all child elements (Element1, Element2, Element3 and
+    // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
+    // the way CParser works <=> Namespaces are reported when namespaces are used
+    // for the first time.
+    _LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \
+a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
+<Element2 xmlns=\"nsuri\" z=\"value4\">Content2</Element2>\
+<Element3 xmlns=\"nsuri\">Content3</Element3>\
+<Element4 xmlns=\"nsuri\"/></a:Test>");
+
+    // When EReportNamespaceMapping is enabled all the namespace declarations
+    // are reported in exactly the same element as they are defined in parsed
+    // XML document.
+    // Note: The Order of namespace declarations in root element tag may change.
+    // Namespace declaration for root tag is created when fragment is created
+    // and because of that namespace declaration for root tag will be the first.
+    // In this particular case namespace declaration for prefix "a" will be
+    // the first namespace declaration because it is declared when
+    // CSenDomFragmentBase is created.
+    _LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
+<Element2 z=\"value4\">Content2</Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>"); 
+    
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString1 )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+/*
+	pParser->EnableFeature(EReportNamespaceMapping);
+	//tma
+	pParser->DisableFeature(EReportNamespaceMapping);
+	TBool fEneabled(EFalse);
+	fEneabled = pParser->IsFeatureEnabled(EReportNamespaceMapping);
+	EUNIT_ASSERT( fEneabled == EFalse);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	//tma
+*/	
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+    CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment2);
+
+	pParser->ParseL(KInputString, *pFragment2);
+	
+	HBufC8* pAsXml2 = pFragment2->AsXmlL();
+	CleanupStack::PushL(pAsXml2);
+	                   
+    if(!( *pAsXml2 == KOutputString2 )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pAsXml2);
+    CleanupStack::PopAndDestroy(pFragment2);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;
+	}
+
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing2L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase which uses
+    // delegation.
+    _LIT8(KInputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
+xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
+<DelegateFragment>DelegateContent</DelegateFragment>\
+<Element1 x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2></a:Test>");
+
+    // Default namespace declaration (xmlns="nsuri") from Parent element (Test)
+    // will be moved to all child elements (Element1, Element2, Element3 and
+    // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
+    // the way CParser works <=> Namespaces are reported when namespaces are used
+    // for the first time.
+    _LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
+a:x=\"value1\" b:z=\"value2\">\
+<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>\
+<Element1 xmlns=\"nsuri\" x=\"value4\">Content1</Element1>\
+<Element2 xmlns=\"nsuri\">Content2</Element2></a:Test>");
+
+    // When EReportNamespaceMapping is enabled all the namespace declarations
+    // are reported in exactly the same element as they are defined in parsed
+    // XML document.
+    // Note: The Order of namespace declarations in root element tag may change.
+    // Namespace declaration for root tag is created when fragment is created
+    // and because of that namespace declaration for root tag will be the first.
+    _LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
+xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
+<DelegateFragment>DelegateContent</DelegateFragment>\
+<Element1 x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2></a:Test>");
+     
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CMainDomFragment* pFragment = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString1 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    
+    CDelegateDomFragment& delegate = pFragment->DelegateFragment();
+    HBufC8* pDelegateAsXml = delegate.AsXmlL();
+    CleanupStack::PushL(pDelegateAsXml);
+    // Note: When EReportNamespaceMapping is _NOT_ enabled namespace declaration
+    //       is added to delegate even though that namespace declaration was
+    //       originally declared (but not used) in root element of parsed document. 
+    if(!( *pDelegateAsXml ==
+                 _L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pDelegateAsXml);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+    CMainDomFragment* pFragment2 = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment2);
+
+	pParser->ParseL(KInputString, *pFragment2);
+	
+	HBufC8* pAsXml2 = pFragment2->AsXmlL();
+	CleanupStack::PushL(pAsXml2);
+    if(!( *pAsXml2 == KOutputString2 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml2);
+    
+    CDelegateDomFragment& delegate2 = pFragment2->DelegateFragment();
+    HBufC8* pDelegateAsXml2 = delegate2.AsXmlL();
+    CleanupStack::PushL(pDelegateAsXml2);
+    if(!( *pDelegateAsXml2 ==
+                 _L8("<DelegateFragment>DelegateContent</DelegateFragment>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pDelegateAsXml2);
+    
+    CleanupStack::PopAndDestroy(pFragment2);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;
+	}
+         
+         
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing3L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    // In this test same namespaceuri is defined as default namespace in
+    // root element and 'c' prefixed namespace in Element2.
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    // Namespace declaration for prefix 'x' (and namespaceuri "nsuri")
+    // disappears from Element2 after parsing because default namespace
+    // declaration already declares namespace for uri "nsuri".
+    // => Double declaration for namespaceuri "nsuri" is not needed.
+    _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+    
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing4L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    // In this test nested elements (which have same name) are tested.
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
+<Element1>Content</Element1>\
+</Element1>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    _LIT8(KInputString2, "<Nested xmlns=\"nsuri\">\
+<Nested attr=\"attrvalue\"><Nested><Nested>Content</Nested></Nested></Nested>\
+</Nested>");
+
+    // Only namespace declaration order changes for output.
+    _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
+<Element1>Content</Element1>\
+</Element1>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+
+    pFragment = CSenDomFragmentBase::NewL(_L8("nsuri"),_L8("Nested"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString2, *pFragment);
+	
+	pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KInputString2 )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing5L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    // In this test nulling of default namespace is tested.
+/*    
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns="" xmlns:c=\"nsuric\" c:x=\"value4\">\
+<Element1 >Content</Element1>\
+</Element1>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+*/
+
+/*
+    // Only namespace declaration order changes for output.
+    _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
+<Element1>Content</Element1>\
+</Element1>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+*/
+
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    /*CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    EUNIT_ASSERT( *pAsXml == KOutputString );
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);*/
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing6L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    // when constructor CSenDomFragmentBase::NewL() is used.
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
+<Element2 z=\"value4\">Content2</Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    // Default namespace declaration (xmlns="nsuri") from Parent element (Test)
+    // will be moved to all child elements (Element1, Element2, Element3 and
+    // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
+    // the way CParser works <=> Namespaces are reported when namespaces are used
+    // for the first time.
+    _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \
+a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
+<Element2 xmlns=\"nsuri\" z=\"value4\">Content2</Element2>\
+<Element3 xmlns=\"nsuri\">Content3</Element3>\
+<Element4 xmlns=\"nsuri\"/></a:Test>");
+
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL();
+    CleanupStack::PushL(pFragment);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing7L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    // when constructor CSenDomFragmentBase::NewL() is used.
+    _LIT8(KInputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
+xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<S:Header>\
+<wsa:MessageID>URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
+<wsa:To>http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
+<wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<wsse:UsernameToken>\
+<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
+<wsse:Password>jaszmn\\3</wsse:Password>\
+</wsse:UsernameToken>\
+</wsse:Security>\
+</S:Header>\
+<S:Body>\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference>\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>\
+</S:Envelope>");
+
+    // Note: If EReportNamespaceMapping is not enabled output will be following:
+    //       (Namespace declaration for prefix "wsa" jumps from root element to
+    //        elements (MessageID, To, Action and EndpointReference) which actually
+    //        use above mentioned prefix. <=> Root element Envelope does not use
+    //        "wsa" prefix.)
+    _LIT8(KOutputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<S:Header>\
+<wsa:MessageID xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
+<wsa:To xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
+<wsa:Action xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<wsse:UsernameToken>\
+<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
+<wsse:Password>jaszmn\\3</wsse:Password>\
+</wsse:UsernameToken>\
+</wsse:Security>\
+</S:Header>\
+<S:Body>\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>\
+</S:Envelope>");
+
+    CSenParser* parser = CSenParser::NewLC();
+    //create a CSenDomFragment
+	CSenFragmentBase* pBase = CSenDomFragmentBase::NewL();
+	CleanupStack::PushL(pBase);
+	//do the parsing
+	parser->ParseL(KInputString, *pBase);
+	
+    HBufC8* pAsXml = pBase->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pBase);
+
+    pBase = CSenDomFragmentBase::NewL();
+    CleanupStack::PushL(pBase);
+    //Enable NamespaceMapping to ensure that namespace declarations will
+    //remain in exactly the same place as in original XML document
+    parser->EnableFeature(EReportNamespaceMapping);
+	//do the parsing
+	parser->ParseL(KInputString, *pBase);
+	
+    pAsXml = pBase->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KInputString )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    
+    CleanupStack::PopAndDestroy(pBase);
+    CleanupStack::PopAndDestroy(parser);
+    Teardown();
+    return KErrNone;
+	}
+         
+         
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing8L(TTestResult& aResult)
+	{
+    SetupL();	
+    // Parsing of XML document to CSenDomFragmentBase
+    // when constructor CSenDomFragmentBase::NewL() is used.
+    _LIT8(KInputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
+xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<S:Header>\
+<wsa:MessageID>URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
+<wsa:To>http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
+<wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<wsse:UsernameToken>\
+<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
+<wsse:Password>jaszmn\\3</wsse:Password>\
+</wsse:UsernameToken>\
+</wsse:Security>\
+</S:Header>\
+<S:Body>\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference>\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>\
+</S:Envelope>");
+
+    // Note: If EReportNamespaceMapping is not enabled output will be following:
+    //       (Namespace declaration for prefix "wsa" jumps from root element to
+    //        elements (MessageID, To, Action and EndpointReference) which actually
+    //        use above mentioned prefix. <=> Root element Envelope does not use
+    //        "wsa" prefix.)
+    _LIT8(KOutputString1, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>");
+
+    _LIT8(KOutputString2, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>");
+
+    CSenParser* parser = CSenParser::NewLC();
+    //create a CSenDomFragment
+	CSenFragmentBase* pBase = CSenDomFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
+	                                                    _L8("Body"),
+	                                                    _L8("S"));
+	CleanupStack::PushL(pBase);
+	//do the parsing
+	parser->ParseL(KInputString, *pBase);
+	
+    HBufC8* pAsXml = pBase->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString1 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pBase);
+
+    pBase = CSenDomFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
+	                                  _L8("Body"),
+	                                  _L8("S"));
+    CleanupStack::PushL(pBase);
+    //Enable NamespaceMapping to ensure that namespace declarations will
+    //remain in exactly the same place as in original XML document
+    parser->EnableFeature(EReportNamespaceMapping);
+	//do the parsing
+	parser->ParseL(KInputString, *pBase);
+	
+    pAsXml = pBase->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString2 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    
+    CleanupStack::PopAndDestroy(pBase);
+    CleanupStack::PopAndDestroy(parser);
+    Teardown();
+    return KErrNone;
+	}
+/*	
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_SetContentOfLL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->SetContentOfL(_L8("name"), _L8("content"));
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentOfL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->ContentOf(_L8("name"));
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+*/	
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteStartElementLL(TTestResult& aResult)
+	{
+    SetupL();
+    RTagInfo info;
+    RAttributeArray array;	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->OnWriteStartElementL(info, array);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteEndElementLL(TTestResult& aResult)
+	{
+    SetupL();
+    RTagInfo info;
+    	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->OnWriteEndElementL(info);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL(TTestResult& aResult)
+	{
+    SetupL();
+    TInt var = 0;	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->OnIgnorableWhiteSpaceL(_L8("test"), var);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnSkippedEntityLL(TTestResult& aResult)
+	{
+    SetupL();
+	RString str;
+    TInt var = 0;	
+	   	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->OnSkippedEntityL(str, var);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnProcessingInstructionLL(TTestResult& aResult)
+	{
+    SetupL();
+    TInt var = 0;	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->OnProcessingInstructionL(_L8("test"), _L8("test"), var);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnErrorL(TTestResult& aResult)
+	{
+    SetupL();
+    TInt var = 0;
+    	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->OnError(var);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+
+TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_GetExtendedInterfaceL(TTestResult& aResult)
+	{
+    SetupL();
+    const TInt32 var = 0;
+    	
+    CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
+                                                               _L8("Test"),
+                                                               _L8("t"));
+    CleanupStack::PushL(pFragment);
+    pFragment->GetExtendedInterface(var);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewLL(TTestResult& aResult)
+	{
+    SetupL();	
+    RSenDocument document = RSenDocument::NewL();
+    CleanupClosePushL(document);
+    TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
+    _LIT8(KElement, "<Element/>");
+    element.SetTextNoEncL(KElement);
+   
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element);
+    CleanupStack::PushL(pFragment);
+    HBufC8* pAsXml = pFragment->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    // Test that when CSenFragmentBase is serialized '<' and '>' characters
+    // are NOT encoded => The content of CSenFragmentBase can include
+    // XML elements
+    if(!( *pAsXml == _L8("<Test><Element/></Test>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(&document);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_1L(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::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_CSenFragmentBase_NewL_2L(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::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_CSenFragmentBase_NewL_3L(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::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_CSenFragmentBase_NewL_4L(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);
+    
+    CSenFragmentBase* pFragment = CSenFragmentBase::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_CSenFragmentBase_NewL_5L(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);
+        
+    CSenFragmentBase* pFragment = CSenFragmentBase::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_CSenFragmentBase_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);
+        
+    CSenFragmentBase* pFragment = CSenFragmentBase::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_CSenFragmentBase_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);
+        
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8(""),
+                                                         attrArray,
+                                                         parentElement,
+                                                         document);
+    CleanupStack::PushL(pFragment);
+    
+    RSenDocument doc = pFragment->AsDocumentL();
+    TXmlEngElement el = pFragment->AsElementL();
+    CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(el, doc);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PushL(pFragment2);
+        
+    HBufC8* pAsXml = pFragment2->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(pFragment2);
+    CleanupStack::PopAndDestroy(&attrArray);
+    CleanupStack::PopAndDestroy(&attribute);
+    CleanupStack::PopAndDestroy(&stringPool); 
+    CleanupStack::PopAndDestroy(&document);
+    Teardown();
+    return KErrNone;
+    
+	}
+	
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_SetDocumentL(TTestResult& aResult)
+	{
+    SetupL();	
+    RSenDocument document ;
+    document = RSenDocument::NewL();
+    
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    
+    pFragment->SetDocument(document);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+	
+   
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_ContentLL(TTestResult& aResult)
+	{
+    SetupL();	
+    RSenDocument document = RSenDocument::NewL();
+    CleanupClosePushL(document);
+    TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
+    element.SetEscapedTextL(_L8("<Element/>"));
+    
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element);
+    CleanupStack::PushL(pFragment);
+    
+    TPtrC8 content = pFragment->ContentL();
+    if(!( content == _L8("<Element/>") )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(&document);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_NamespaceL(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(stringPool.OpenStringL(_L8("nsuri")), 
+                   stringPool.OpenStringL(_L8("pr")),
+                   stringPool.OpenStringL(_L8("LocalName")),
+                   stringPool.OpenStringL(_L8("Value")) );
+    // attribute took copies of all RStrings
+    // => All RStrings can be destroyed
+    CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString,
+                                    // valueRString
+    CleanupClosePushL(attribute);
+
+    RAttributeArray attrArray;
+    // append the namespace attribute (declaration)
+    attrArray.AppendL(attribute);
+    CleanupClosePushL(attrArray);
+    
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"),
+                                                         attrArray);
+    CleanupStack::PushL(pFragment);
+    
+    TXmlEngNamespace ns = pFragment->Namespace(_L8("pr"));
+    if(!( ns.Uri() == _L8("nsuri") )) return KErrArgument;
+
+    TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x"));
+    if(!( ns2.IsUndefined() )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(); // attribute
+    CleanupStack::PopAndDestroy(); // attrArray
+    CleanupStack::PopAndDestroy(); // stringPool  
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_ResetContentLL(TTestResult& aResult)
+	{
+    SetupL();	
+    RSenDocument document = RSenDocument::NewL();
+    CleanupClosePushL(document);
+    TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
+    element.SetEscapedTextL(_L8("Content"));
+    
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element);
+    CleanupStack::PushL(pFragment);
+    
+    // Test that CSenFragmentBase has content before reset
+    TPtrC8 content = pFragment->ContentL();
+    if(!( content == _L8("Content") )) return KErrArgument;
+    
+    pFragment->ResetContentL();
+    
+    // Test that CSenFragmentBase has no content after reset
+    TPtrC8 content2 = pFragment->ContentL();
+    if(!( content2 == KNullDesC8 )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(&document);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_LocalNameL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TPtrC8 localName = pFragment->LocalName();
+    if(!( localName == _L8("Test") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_NsUriL(TTestResult& aResult)
+	{
+    SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TPtrC8 localName = pFragment->NsUri();
+    if(!( localName == _L8("NsUri") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_NsPrefixL(TTestResult& aResult)
+	{
+	SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TPtrC8 localName = pFragment->NsPrefix();
+    if(!( localName == _L8("t") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsElementLL(TTestResult& aResult)
+	{
+	SetupL();	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    RBuf8 buffer;
+    CleanupClosePushL(buffer);
+    element.OuterXmlL(buffer);
+    // Serialized element should contain all the Fragment data as XML.
+    if(!( buffer == _L8("<t:Test xmlns:t=\"NsUri\"/>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(&buffer);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsDocumentLL(TTestResult& aResult)
+	{
+	SetupL();
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"));
+    CleanupStack::PushL(pFragment);
+    RSenDocument document = pFragment->AsDocumentL();
+    TXmlEngElement element = document.DocumentElement();
+    
+    TXmlEngSerializationOptions options;
+    // Omit following declarations from the beginning of XML Document:
+    // <?xml version=\"1.0\...
+    //   encoding="..."
+    //   standalone="..."
+    // ?>
+    options.iOptions = options.iOptions |
+                       TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+    RBuf8 asXml;
+    document.SaveL(asXml, element, options);
+    CleanupClosePushL(asXml);
+    
+    // Serialized document should contain all the Fragment data as XML.
+    if(!( asXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(&asXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_ExtractElementL(TTestResult& aResult)
+	{
+	SetupL();
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
+                                                         _L8("Test"),
+                                                         _L8("t"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->ExtractElement();
+    if(!( element.Name() == _L8("Test") )) return KErrArgument;
+    element.Remove();
+    CleanupStack::PopAndDestroy(pFragment);    
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlUnicodeLL(TTestResult& aResult)
+	{
+	SetupL();
+    // Test serialization of Dom tree which has two child elements
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
+
+    element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
+    
+    HBufC* pAsXml = pFragment->AsXmlUnicodeL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == _L("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlLL(TTestResult& aResult)
+	{
+	SetupL();
+    // Test serialization of Dom tree which has two child elements
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
+
+    element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
+    
+    HBufC8* pAsXml = pFragment->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_WriteAsXMLToLL(TTestResult& aResult)
+	{
+	SetupL();
+    // Test serialization of Dom tree which has two child elements
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
+
+    element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
+    
+    CBufFlat* pBuf = CBufFlat::NewL(200);
+    CleanupStack::PushL(pBuf);
+    RBufWriteStream bufWs(*pBuf);
+    CleanupClosePushL(bufWs);
+    pFragment->WriteAsXMLToL(bufWs);
+
+
+    if(!( pBuf->Ptr(0) == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(&bufWs);
+    CleanupStack::PopAndDestroy(pBuf);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_ConsistsOfLL(TTestResult& aResult)
+	{
+	SetupL();
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    TXmlEngElement element = pFragment->AsElementL();
+    
+    TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild"));
+    elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //elementchild1.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils1;
+    //domUtils1.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+
+    TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild"));
+    elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //elementchild2.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils2;
+    //domUtils2.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
+
+    CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment2);
+    TXmlEngElement element2 = pFragment2->AsElementL();
+    
+    TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild"));
+    elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //elementchild22.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils22;
+    //domUtils22.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
+
+    // ConsistOfL should return ETrue because
+    // root elements of both fragments match and the only element
+    // of pFragment2 = elementchild22 is exactly the same element as
+    // elementchild2.
+    if(!( pFragment->ConsistsOfL(*pFragment2) )) return KErrArgument;
+
+    // ConsistOfL should return EFalse because
+    // Even though root elements of both fragments match
+    // there is extra element (= elementchild1) in pFragment.
+    //
+    // elementchild1 (of pFragment) can not be found from pFragment2
+    // and because of that pFragment2 does not consist of pFragment.
+    if(!( !pFragment2->ConsistsOfL(*pFragment) )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment2);
+
+    CSenFragmentBase* pFragment3 = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment3);
+    TXmlEngElement element3 = pFragment3->AsElementL();
+    
+    TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild"));
+    elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
+    //elementchild32.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    //TDomUtils domUtils32;
+    //domUtils32.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
+    elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
+    elementchild32.SetEscapedTextL(_L8("Text"));
+    
+    // ConsistOfL should return EFalse because
+    // elementchild32 has content ("Text") which doesn't match
+    // to any child element of pFragment.
+    if(!( !pFragment->ConsistsOfL(*pFragment3) )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pFragment3);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing1L(TTestResult& aResult)
+	{
+	SetupL();
+    // Parsing of XML document to CSenFragmentBase
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    // Default namespace declaration (xmlns="nsuri") from Parent element (Test)
+    // will be moved to all child elements (Element1, Element2, Element3 and
+    // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
+    // the way CParser works <=> Namespaces are reported when namespaces are used.
+    _LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \
+a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<Element2 xmlns=\"nsuri\">Content2</Element2>\
+<Element3 xmlns=\"nsuri\">Content3</Element3>\
+<Element4 xmlns=\"nsuri\"/></a:Test>");
+
+    // When EReportNamespaceMapping is enabled all the namespace declarations
+    // are reported in exactly the same element as they are defined in parsed
+    // XML document.
+    // Note: The Order of namespace declarations in root element tag may change.
+    // Namespace declaration for root tag is created when fragment is created
+    // and because of that namespace declaration for root tag will be the first.
+    // In this particular case namespace declaration for prefix "a" will be
+    // the first namespace declaration because it is declared when
+    // CSenFragmentBase is created.
+    _LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+    
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+
+/*	
+	//tma
+	pParser->ParseBeginL();
+	
+	_LIT8(KXmlParserMimeType,   "text/xml");
+	pParser->ParseBeginL(KXmlParserMimeType);
+		
+    CMatchData* pMatchData = CMatchData::NewLC();
+    pMatchData->SetMimeTypeL(KXmlParserMimeType);
+    pParser->ParseBeginL(*pMatchData);
+    CleanupStack::PopAndDestroy(pMatchData);
+	//tma	
+*/
+
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString1 )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+    CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment2);
+
+	pParser->ParseL(KInputString, *pFragment2);
+	
+	HBufC8* pAsXml2 = pFragment2->AsXmlL();
+	CleanupStack::PushL(pAsXml2);
+	                   
+    if(!( *pAsXml2 == KOutputString2 )) return KErrArgument;
+    
+    CleanupStack::PopAndDestroy(pAsXml2);
+    CleanupStack::PopAndDestroy(pFragment2);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;    
+	}
+
+
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing2L(TTestResult& aResult)
+	{
+	SetupL();
+    // Parsing of XML document to CSenFragmentBase which uses
+    // delegation.
+    _LIT8(KInputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
+xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
+<DelegateFragment>DelegateContent</DelegateFragment>\
+<Element1 x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2></a:Test>");
+
+    // Default namespace declaration (xmlns="nsuri") from Parent element (Test)
+    // will be moved to all child elements (Element1, Element2, Element3 and
+    // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
+    // the way CParser works <=> Namespaces are reported when namespaces are used
+    // for the first time.
+    // Note: In CSenFragmentBase case DelegateFragment won't be in
+    //       content of parent fragment which did the delegation.
+    _LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
+a:x=\"value1\" b:z=\"value2\">\
+<Element1 xmlns=\"nsuri\" x=\"value4\">Content1</Element1>\
+<Element2 xmlns=\"nsuri\">Content2</Element2></a:Test>");
+
+    // When EReportNamespaceMapping is enabled all the namespace declarations
+    // are reported in exactly the same element as they are defined in parsed
+    // XML document.
+    // Note: The Order of namespace declarations in root element tag may change.
+    // Namespace declaration for root tag is created when fragment is created
+    // and because of that namespace declaration for root tag will be the first.
+    // Note: In CSenFragmentBase case DelegateFragment won't be in
+    //       content of parent fragment which did the delegation.
+    _LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
+xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
+<Element1 x=\"value4\">Content1</Element1>\
+<Element2>Content2</Element2></a:Test>");
+     
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CMainFragment* pFragment = CMainFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString1 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    
+    CDelegateFragment& delegate = pFragment->DelegateFragment();
+    HBufC8* pDelegateAsXml = delegate.AsXmlL();
+    CleanupStack::PushL(pDelegateAsXml);
+    if(!( *pDelegateAsXml ==
+                 _L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pDelegateAsXml);
+    
+    CleanupStack::PopAndDestroy(pFragment);
+
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+    CMainFragment* pFragment2 = CMainFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment2);
+
+	pParser->ParseL(KInputString, *pFragment2);
+	
+	HBufC8* pAsXml2 = pFragment2->AsXmlL();
+	CleanupStack::PushL(pAsXml2);
+    if(!( *pAsXml2 == KOutputString2 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml2);
+    
+    CDelegateFragment& delegate2 = pFragment2->DelegateFragment();
+    HBufC8* pDelegateAsXml2 = delegate2.AsXmlL();
+    CleanupStack::PushL(pDelegateAsXml2);
+    if(!( *pDelegateAsXml2 ==
+                 _L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pDelegateAsXml2);
+    
+    CleanupStack::PopAndDestroy(pFragment2);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;    
+	}
+         
+         
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing3L(TTestResult& aResult)
+	{
+	SetupL();
+    // Parsing of XML document to CSenFragmentBase
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
+<x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+    
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;    
+	}
+
+
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing4L(TTestResult& aResult)
+	{
+	SetupL();
+    // Parsing of XML document to CSenFragmentBase
+    // In this test nested elements (which have same name) are tested.
+    _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
+<Element1>Content</Element1>\
+</Element1>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+    _LIT8(KInputString2, "<Nested xmlns=\"nsuri\">\
+<Nested attr=\"attrvalue\"><Nested><Nested>Content</Nested></Nested></Nested>\
+</Nested>");
+
+    // Only namespace declaration order changes for output.
+    // Element4 which has no content will be output with
+    // start and end tags.
+    _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
+xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
+<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
+<Element1>Content</Element1>\
+</Element1>\
+<Element3>Content3</Element3>\
+<Element4/></a:Test>");
+
+	CSenParser* pParser = CSenParser::NewLC();
+	
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString, *pFragment);
+	
+	HBufC8* pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KOutputString )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+
+    pFragment = CSenFragmentBase::NewL(_L8("nsuri"),_L8("Nested"));
+    CleanupStack::PushL(pFragment);
+	pParser->EnableFeature(EReportNamespaceMapping);
+	
+	pParser->ParseL(KInputString2, *pFragment);
+	
+	pAsXml = pFragment->AsXmlL();
+	CleanupStack::PushL(pAsXml);
+
+    if(!( *pAsXml == KInputString2 )) return KErrArgument;
+
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pFragment);
+
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;    
+	}
+
+
+TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing5L(TTestResult& aResult)
+	{
+	SetupL();
+    // Parsing of XML document to CSenDomFragmentBase
+    // when constructor CSenDomFragmentBase::NewL() is used.
+    _LIT8(KInputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
+xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<S:Header>\
+<wsa:MessageID>URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
+<wsa:To>http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
+<wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
+<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<wsse:UsernameToken>\
+<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
+<wsse:Password>jaszmn\\3</wsse:Password>\
+</wsse:UsernameToken>\
+</wsse:Security>\
+</S:Header>\
+<S:Body>\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference>\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>\
+</S:Envelope>");
+
+    // Note: If EReportNamespaceMapping is not enabled output will be following:
+    //       (Namespace declaration for prefix "wsa" jumps from root element to
+    //        elements (MessageID, To, Action and EndpointReference) which actually
+    //        use above mentioned prefix. <=> Root element Envelope does not use
+    //        "wsa" prefix.)
+    _LIT8(KOutputString1, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>");
+
+    _LIT8(KOutputString2, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
+xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" \
+xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
+<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
+<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
+<wst:Renewing/>\
+<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
+<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
+<wsa:EndpointReference>\
+<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
+</wsa:EndpointReference>\
+</wsp:AppliesTo>\
+</wst:RequestSecurityToken>\
+</S:Body>");
+
+    CSenParser* parser = CSenParser::NewLC();
+    //create a CSenDomFragment
+	CSenFragmentBase* pBase = CSenFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
+	                                                 _L8("Body"),
+	                                                 _L8("S"));
+	CleanupStack::PushL(pBase);
+	//do the parsing
+	parser->ParseL(KInputString, *pBase);
+	
+    HBufC8* pAsXml = pBase->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString1 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    CleanupStack::PopAndDestroy(pBase);
+
+    pBase = CSenFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
+	                               _L8("Body"),
+	                               _L8("S"));
+    CleanupStack::PushL(pBase);
+    //Enable NamespaceMapping to ensure that namespace declarations will
+    //remain in exactly the same place as in original XML document
+    parser->EnableFeature(EReportNamespaceMapping);
+	//do the parsing
+	parser->ParseL(KInputString, *pBase);
+	
+    pAsXml = pBase->AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    if(!( *pAsXml == KOutputString2 )) return KErrArgument;
+    CleanupStack::PopAndDestroy(pAsXml);
+    
+    CleanupStack::PopAndDestroy(pBase);
+    CleanupStack::PopAndDestroy(parser);
+    Teardown();
+    return KErrNone;    
+	}
+
+
+TInt CSenFragmentBCTest::MT_CSenParser_NewLL(TTestResult& aResult)
+	{
+	SetupL();
+    CSenParser* pParser = CSenParser::NewL();
+    delete pParser;
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenParser_NewLCL(TTestResult& aResult)
+	{
+	SetupL();
+    CSenParser* pParser = CSenParser::NewLC();
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenParser_NewL_1L(TTestResult& aResult)
+	{
+	SetupL();
+    _LIT8(KXmlParserMimeType,   "text/xml");
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    CParser* pParser = CParser::NewL(KXmlParserMimeType, *pFragment);
+
+    // Ownership of the pParser is transfered to pSenParser
+    CSenParser* pSenParser = CSenParser::NewL(pParser);
+    delete pSenParser;
+
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenParser_NewLC_1L(TTestResult& aResult)
+	{
+	SetupL();
+    _LIT8(KXmlParserMimeType,   "text/xml");
+    CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
+    CleanupStack::PushL(pFragment);
+    CParser* pParser = CParser::NewL(KXmlParserMimeType, *pFragment);
+
+    // Ownership of the pParser is transfered to pSenParser
+    CSenParser* pSenParser = CSenParser::NewLC(pParser);
+    CleanupStack::PopAndDestroy(pSenParser);
+
+    CleanupStack::PopAndDestroy(pFragment);
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenParser_NewL_2L(TTestResult& aResult)
+	{
+	SetupL();
+    _LIT8(KXmlParserMimeType,   "text/xml");
+    CSenParser* pParser = CSenParser::NewL(KXmlParserMimeType);
+    delete pParser;
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_CSenParser_NewLC_2L(TTestResult& aResult)
+	{
+	SetupL();
+    _LIT8(KXmlParserMimeType,   "text/xml");
+    CSenParser* pParser = CSenParser::NewLC(KXmlParserMimeType);
+    CleanupStack::PopAndDestroy(pParser);
+    Teardown();
+    return KErrNone;    
+	}
+/*        
+#if defined( __SERIES60_31__ ) || (!defined( __SERIES60_30__ ) && defined( SYMBIAN_SWI_POST_INSTALL_REVOCATION) )
+
+TInt CSenFragmentBCTest::MT_CSenParser_NewL_3L(TTestResult& aResult)
+	{
+	SetupL();
+    _LIT8(KXmlParserMimeType,   "text/xml");
+    CMatchData* pMatchData = CMatchData::NewLC();
+    pMatchData->SetMimeTypeL(KXmlParserMimeType);
+    CSenParser* pParser = CSenParser::NewL(*pMatchData);
+    delete pParser;
+    CleanupStack::PopAndDestroy(pMatchData);
+    Teardown();
+    return KErrNone;    
+	}
+
+TInt CSenFragmentBCTest::MT_CSenParser_NewLC_3L(TTestResult& aResult)
+	{
+	SetupL();
+    _LIT8(KXmlParserMimeType,   "text/xml");
+    CMatchData* pMatchData = CMatchData::NewLC();
+    pMatchData->SetMimeTypeL(KXmlParserMimeType);
+    CSenParser* pParser = CSenParser::NewLC(*pMatchData);
+    CleanupStack::PopAndDestroy(pParser);
+    CleanupStack::PopAndDestroy(pMatchData);
+    Teardown();
+    return KErrNone;    
+	}
+
+#endif 
+        
+*/        
+TInt CSenFragmentBCTest::MT_RSenDocument_NewLL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document = RSenDocument::NewL();
+    document.Close();
+    if(!( document.IsNull() )) return KErrArgument;
+    Teardown();
+    return KErrNone;    
+	}
+        
+        
+TInt CSenFragmentBCTest::MT_RSenDocument_NewLCL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document = RSenDocument::NewLC();
+    CleanupStack::PopAndDestroy();
+    
+    // Can't use IsNull() function because iInternal pointer
+    // (of document) is not NULLed. Only data for which iInternal
+    // points to is deleted.
+    //EUNIT_ASSERT( document.IsNull() );
+    Teardown();
+    return KErrNone;    
+	}
+         
+TInt CSenFragmentBCTest::MT_RSenDocument_NewL_1L(TTestResult& aResult)
+	{
+	SetupL();
+    // Can't test RSenDocument::NewL(void* aInternal)
+    // because there is no way to get proper aInternal
+    // using public API.
+    if(!( ETrue )) return KErrArgument;
+    Teardown();
+    return KErrNone;    
+	}
+         
+TInt CSenFragmentBCTest::MT_RSenDocument_NewLC_1L(TTestResult& aResult)
+	{
+	SetupL();
+    // Can't test RSenDocument::NewLC(void* aInternal)
+    // because there is no way to get proper aInternal
+    // using public API.
+    if(!( ETrue )) return KErrArgument;
+    Teardown();
+    return KErrNone;    
+	}
+        
+TInt CSenFragmentBCTest::MT_RSenDocument_CopyL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document1 = RSenDocument::NewL();
+    TXmlEngElement element = document1.CreateDocumentElementL(_L8("Test"));
+    
+    element.AddTextL(_L8("testcontent"));
+    
+    RSenDocument document2 = document1.Copy();
+    
+    // Check that main elements of document1 and document2 
+    // are pointing to the same "in memory node" after copying.
+    if(!( element.IsSameNode(document2.DocumentElement()) )) return KErrArgument;
+    
+    // Test that document2 contains the same data as document1
+    // did contain before closing document1.
+    document1.Close();
+    RBuf8 asXml;
+    TXmlEngSerializationOptions options;
+    options.iOptions = options.iOptions |
+                       TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+    document2.SaveL(asXml, element, options);
+    CleanupClosePushL(asXml);
+    if(!( asXml == _L8("<Test>testcontent</Test>") )) return KErrArgument;
+    CleanupStack::PopAndDestroy(&asXml);
+    
+    document2.Close();
+    if(!( document1.IsNull() && document2.IsNull() )) return KErrArgument;
+    Teardown();
+    return KErrNone;    
+	}
+                
+TInt CSenFragmentBCTest::MT_RSenDocument_CloseL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document = RSenDocument::NewL();
+    document.Close();
+    if(!( document.IsNull() )) return KErrArgument;
+    Teardown();
+    return KErrNone;    
+	}
+                
+TInt CSenFragmentBCTest::MT_RSenDocument_DestroyL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document = RSenDocument::NewL();
+    document.Destroy();
+    if(!( document.IsNull() )) return KErrArgument;
+    Teardown();
+    return KErrNone;    
+	}
+	
+TInt CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsAttachLL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document = RSenDocument::NewL();
+    TInt retVal = document.ManualXmlEngineTlsAttachL();
+    TL(retVal == KErrNone || retVal == KErrUnknown || retVal == KErrAlreadyExists);
+    Teardown();
+    return KErrNone;    
+	}
+	
+TInt CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsCleanupL(TTestResult& aResult)
+	{
+	SetupL();
+    RSenDocument document = RSenDocument::NewL();
+    TInt retVal = document.ManualXmlEngineTlsCleanup();
+    TL(retVal == KErrNone || retVal == KErrNotFound );
+    Teardown();
+    return KErrNone;    
+	}
+
+
+TInt CSenFragmentBCTest::MT_TestFragmentBase_SetContentLL(TTestResult& aResult)
+	{
+	SetupL();
+    CTestFragmentBase* pFragment = CTestFragmentBase::NewL(_L8("Test"));
+	pFragment->SetContentL(_L8("Test"));
+    Teardown();
+    return KErrNone;    
+	}
+
+	
+TInt CSenFragmentBCTest::MT_TestFragmentBase_AddContentLL(TTestResult& aResult)
+	{
+	SetupL();
+    CTestFragmentBase* pFragment = CTestFragmentBase::NewL(_L8("Test"));
+	pFragment->AddContentL(_L8("Test"));
+    Teardown();
+    return KErrNone;    
+	}
+	
+	
+TInt CSenFragmentBCTest::MT_TestDomFragmentBase_SetContentOfLL(TTestResult& aResult)
+	{
+	SetupL();
+	_LIT8(KText, "Test1");
+    CTestDomFragmentBase* pFragment = CTestDomFragmentBase::NewL(_L8("Test"));
+    pFragment->SetContentOfL(_L8("Test"), _L8("Test1"));
+    TPtrC8 ptr = pFragment->ContentOf(_L8("Test"));
+    TL(ptr == KText);
+    Teardown();
+    return KErrNone;    
+	}
+/*	
+TInt CSenFragmentBCTest::MT_TestDomFragmentBase_ContentOfL(TTestResult& aResult)
+	{
+	SetupL();
+    Teardown();
+    return KErrNone;    
+	}
+	
+*/
+
+//  End of File