1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:          ?Description

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <StifTestModule.h>

    20 #include <e32math.h>

    21 #include <libc/assert.h>

    22 #include <e32panic.h>

    23 #include "senfragmentbctest.h"

    24 #include "maindomfragment.h"

    25 #include "mainfragment.h"

    26 #include "TestFragment.h"

    27 

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

    29 

    30 // -----------------------------------------------------------------------------

    31 // CSenFragmentBCTest::Case

    32 // Returns a test case by number.

    33 //

    34 // This function contains an array of all available test cases 

    35 // i.e pair of case name and test function. If case specified by parameter

    36 // aCaseNumber is found from array, then that item is returned.

    37 // 

    38 // The reason for this rather complicated function is to specify all the

    39 // test cases only in one place. It is not necessary to understand how

    40 // function pointers to class member functions works when adding new test

    41 // cases. See function body for instructions how to add new test case.

    42 // -----------------------------------------------------------------------------

    43 //

    44 const TCaseInfo CSenFragmentBCTest::Case ( 

    45     const TInt aCaseNumber ) const 

    46      {

    47 

    48     /**

    49     * To add new test cases, implement new test case function and add new 

    50     * line to KCases array specify the name of the case and the function 

    51     * doing the test case

    52     * In practice, do following

    53     * 1) Make copy of existing test case function and change its name

    54     *    and functionality. Note that the function must be added to 

    55     *    SenFragment.cpp file and to SenFragment.h 

    56     *    header file.

    57     *

    58     * 2) Add entry to following KCases array either by using:

    59     *

    60     * 2.1: FUNCENTRY or ENTRY macro

    61     * ENTRY macro takes two parameters: test case name and test case 

    62     * function name.

    63     *

    64     * FUNCENTRY macro takes only test case function name as a parameter and

    65     * uses that as a test case name and test case function name.

    66     *

    67     * Or

    68     *

    69     * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

    70     * only with OOM (Out-Of-Memory) testing!

    71     *

    72     * OOM_ENTRY macro takes five parameters: test case name, test case 

    73     * function name, TBool which specifies is method supposed to be run using

    74     * OOM conditions, TInt value for first heap memory allocation failure and 

    75     * TInt value for last heap memory allocation failure.

    76     * 

    77     * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

    78     * that as a test case name, TBool which specifies is method supposed to be

    79     * run using OOM conditions, TInt value for first heap memory allocation 

    80     * failure and TInt value for last heap memory allocation failure. 

    81     */ 

    82 

    83     static TCaseInfoInternal const KCases[] =

    84         {

    85         

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   133         

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   168         

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

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

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

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

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

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

   175         

   176         // Example how to use OOM functionality

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

   178         //OOM_FUNCENTRY( CSenFragmentBCTest::PrintTest, ETrue, 1, 3 ),

   179         };

   180 

   181     // Verify that case number is valid

   182     if( (TUint) aCaseNumber >= sizeof( KCases ) / 

   183                                sizeof( TCaseInfoInternal ) )

   184         {

   185         // Invalid case, construct empty object

   186         TCaseInfo null( (const TText*) L"" );

   187         null.iMethod = NULL;

   188         null.iIsOOMTest = EFalse;

   189         null.iFirstMemoryAllocation = 0;

   190         null.iLastMemoryAllocation = 0;

   191         return null;

   192         } 

   193 

   194     // Construct TCaseInfo object and return it

   195     TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

   196     tmp.iMethod = KCases[ aCaseNumber ].iMethod;

   197     tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

   198     tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

   199     tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

   200     return tmp;

   201 

   202     }

   203 

   204 void CSenFragmentBCTest::SetupL(  ){

   205     if ( iXmlReader ){

   206         delete iXmlReader;

   207         iXmlReader = NULL;

   208     }

   209     iXmlReader = CSenXmlReader::NewL();

   210 } 

   211 

   212 void CSenFragmentBCTest::Teardown(  ){

   213     if ( iXmlReader){

   214         delete iXmlReader;

   215         iXmlReader = NULL;

   216     }

   217 }

   218     

   219 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewLL(TTestResult& aResult)

   220 	{

   221     SetupL();

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

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

   224     __ASSERT_ALWAYS_NO_LEAVE(delete pFragment);

   225     pFragment = NULL;

   226     Teardown();

   227     return KErrNone;

   228 	}

   229         

   230         

   231 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_1L(TTestResult& aResult)

   232 	{

   233     SetupL();

   234     RSenDocument document = RSenDocument::NewL();

   235     CleanupClosePushL(document);

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

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

   238     

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

   240     CleanupStack::PushL(pFragment);

   241     HBufC8* pAsXml = pFragment->AsXmlL();

   242     CleanupStack::PushL(pAsXml);

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

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

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

   246     CleanupStack::PopAndDestroy(pAsXml);

   247     CleanupStack::PopAndDestroy(pFragment);

   248     CleanupStack::Pop(1);

   249     //CleanupStack::PopAndDestroy(&document);

   250     Teardown();

   251     return KErrNone;

   252 	}

   253         

   254         

   255 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_2L(TTestResult& aResult)

   256 	{

   257     SetupL();	

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

   259     CleanupStack::PushL(pFragment);

   260     HBufC8* pAsXml = pFragment->AsXmlL();

   261     CleanupStack::PushL(pAsXml);

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

   263     CleanupStack::PopAndDestroy(pAsXml);

   264     CleanupStack::PopAndDestroy(pFragment);

   265     Teardown();

   266     return KErrNone;

   267 	}

   268         

   269         

   270 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_3L(TTestResult& aResult)

   271 	{

   272     SetupL();	

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

   274                                                                _L8("Test"));

   275     CleanupStack::PushL(pFragment);

   276     HBufC8* pAsXml = pFragment->AsXmlL();

   277     CleanupStack::PushL(pAsXml);

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

   279     CleanupStack::PopAndDestroy(pAsXml);

   280     CleanupStack::PopAndDestroy(pFragment);

   281     Teardown();

   282     return KErrNone;

   283 	}

   284         

   285         

   286 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_4L(TTestResult& aResult)

   287 	{

   288     SetupL();	

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

   290                                                                _L8("Test"),

   291                                                                _L8("t"));

   292     CleanupStack::PushL(pFragment);

   293     HBufC8* pAsXml = pFragment->AsXmlL();

   294     CleanupStack::PushL(pAsXml);

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

   296     CleanupStack::PopAndDestroy(pAsXml);

   297     CleanupStack::PopAndDestroy(pFragment);

   298     Teardown();

   299     return KErrNone;

   300 	}

   301         

   302         

   303 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_5L(TTestResult& aResult)

   304 	{

   305     SetupL();	

   306     RStringPool stringPool;

   307     stringPool.OpenL();

   308     CleanupClosePushL(stringPool);

   309     

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

   311     CleanupClosePushL(nsUriRString);

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

   313     CleanupClosePushL(nsPrefixRString);

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

   315     CleanupClosePushL(localNameRString);

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

   317     CleanupClosePushL(valueRString);

   318     

   319     RAttribute attribute;

   320     attribute.Open( nsUriRString, nsPrefixRString, localNameRString,

   321                     valueRString );

   322     // attribute took ownership of all RStrings

   323     // => All RStrings can be pop from CleanupStack

   324     CleanupStack::Pop(&valueRString);

   325     CleanupStack::Pop(&localNameRString);

   326     CleanupStack::Pop(&nsPrefixRString);

   327     CleanupStack::Pop(&nsUriRString);

   328 

   329     CleanupClosePushL(attribute);

   330 

   331     RAttributeArray attrArray;

   332     // append the namespace attribute (declaration)

   333     attrArray.AppendL(attribute);

   334     CleanupClosePushL(attrArray);

   335     

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

   337                                                                _L8("Test"),

   338                                                                _L8("t"),

   339                                                                attrArray);

   340     CleanupStack::PushL(pFragment);

   341     HBufC8* pAsXml = pFragment->AsXmlL();

   342     CleanupStack::PushL(pAsXml);

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

   344     CleanupStack::PopAndDestroy(pAsXml);

   345     CleanupStack::PopAndDestroy(pFragment);

   346     CleanupStack::PopAndDestroy(&attrArray);

   347     CleanupStack::PopAndDestroy(&attribute);

   348     CleanupStack::PopAndDestroy(&stringPool);

   349     Teardown();

   350     return KErrNone;

   351 	}

   352         

   353         

   354 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_6L(TTestResult& aResult)

   355 	{

   356     SetupL();	

   357     RSenDocument document = RSenDocument::NewL();

   358     CleanupClosePushL(document);

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

   360     

   361     RStringPool stringPool;

   362     stringPool.OpenL();

   363     CleanupClosePushL(stringPool);

   364     

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

   366     CleanupClosePushL(nsUriRString);

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

   368     CleanupClosePushL(nsPrefixRString);

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

   370     CleanupClosePushL(localNameRString);

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

   372     CleanupClosePushL(valueRString);

   373     

   374     RAttribute attribute;

   375     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

   376                    valueRString);

   377     // attribute took ownership of all RStrings

   378     // => All RStrings can be pop from CleanupStack

   379     CleanupStack::Pop(&valueRString);

   380     CleanupStack::Pop(&localNameRString);

   381     CleanupStack::Pop(&nsPrefixRString);

   382     CleanupStack::Pop(&nsUriRString);

   383     

   384     CleanupClosePushL(attribute);

   385 

   386     RAttributeArray attrArray;

   387     // append the namespace attribute (declaration)

   388     attrArray.AppendL(attribute);

   389     CleanupClosePushL(attrArray);

   390         

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

   392                                                                _L8("Test"),

   393                                                                _L8("t"),

   394                                                                attrArray,

   395                                                                parentElement);

   396     CleanupStack::PushL(pFragment);

   397     HBufC8* pAsXml = pFragment->AsXmlL();

   398     CleanupStack::PushL(pAsXml);

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

   400 

   401     RBuf8 buffer;

   402     parentElement.OuterXmlL(buffer);

   403     

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

   405     buffer.Close();

   406     

   407     CleanupStack::PopAndDestroy(pAsXml);

   408     CleanupStack::PopAndDestroy(pFragment);

   409     CleanupStack::PopAndDestroy(&attrArray);

   410     CleanupStack::PopAndDestroy(&attribute);

   411     CleanupStack::PopAndDestroy(&stringPool);

   412     CleanupStack::PopAndDestroy(&document);

   413     Teardown();

   414     return KErrNone;

   415 	}

   416         

   417         

   418 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_7L(TTestResult& aResult)

   419 	{

   420     SetupL();	

   421     RSenDocument document = RSenDocument::NewL();

   422     CleanupClosePushL(document);

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

   424     

   425     RStringPool stringPool;

   426     stringPool.OpenL();

   427     CleanupClosePushL(stringPool);

   428     

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

   430     CleanupClosePushL(nsUriRString);

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

   432     CleanupClosePushL(nsPrefixRString);

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

   434     CleanupClosePushL(localNameRString);

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

   436     CleanupClosePushL(valueRString);

   437     

   438     RAttribute attribute;

   439     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

   440                    valueRString);

   441     // attribute took ownership of all RStrings

   442     // => All RStrings can be pop from CleanupStack

   443     CleanupStack::Pop(&valueRString);

   444     CleanupStack::Pop(&localNameRString);

   445     CleanupStack::Pop(&nsPrefixRString);

   446     CleanupStack::Pop(&nsUriRString);

   447 

   448     CleanupClosePushL(attribute);

   449 

   450     RAttributeArray attrArray;

   451     // append the namespace attribute (declaration)

   452     attrArray.AppendL(attribute);

   453     CleanupClosePushL(attrArray);

   454         

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

   456                                                                _L8("Test"),

   457                                                                _L8(""),

   458                                                                attrArray,

   459                                                                parentElement,

   460                                                                document);

   461     CleanupStack::PushL(pFragment);

   462     HBufC8* pAsXml = pFragment->AsXmlL();

   463     CleanupStack::PushL(pAsXml);

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

   465 

   466     RBuf8 buffer;

   467     parentElement.OuterXmlL(buffer);

   468     

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

   470     buffer.Close();

   471     

   472     CleanupStack::PopAndDestroy(pAsXml);

   473     CleanupStack::PopAndDestroy(pFragment);

   474     CleanupStack::PopAndDestroy(&attrArray);

   475     CleanupStack::PopAndDestroy(&attribute);

   476     CleanupStack::PopAndDestroy(&stringPool);

   477     CleanupStack::PopAndDestroy(&document);

   478     Teardown();

   479     return KErrNone;

   480 	}

   481         

   482         

   483 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AddAttributesLL(TTestResult& aResult)

   484 	{

   485     SetupL();	

   486     RStringPool stringPool;

   487     stringPool.OpenL();

   488     CleanupClosePushL(stringPool);

   489     

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

   491     CleanupClosePushL(nsUriRString);

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

   493     CleanupClosePushL(nsPrefixRString);

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

   495     CleanupClosePushL(localNameRString);

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

   497     CleanupClosePushL(valueRString);

   498     

   499     RAttribute attribute;

   500     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

   501                    valueRString);

   502     // attribute took ownership of all RStrings

   503     // => All RStrings can be pop from CleanupStack

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

   505                           // valueRString

   506     CleanupClosePushL(attribute);

   507 

   508     RAttributeArray attrArray;

   509     // append the namespace attribute (declaration)

   510     attrArray.AppendL(attribute);

   511     CleanupClosePushL(attrArray);    

   512     

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

   514     CleanupStack::PushL(pFragment);

   515     

   516     pFragment->AddAttributesL(attrArray);

   517     HBufC8* pAsXml = pFragment->AsXmlL();

   518     CleanupStack::PushL(pAsXml);

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

   520     CleanupStack::PopAndDestroy(pAsXml);

   521 

   522     CleanupStack::PopAndDestroy(pFragment);

   523     

   524     CleanupStack::PopAndDestroy(&attrArray);

   525     CleanupStack::PopAndDestroy(&attribute);

   526     CleanupStack::PopAndDestroy(&stringPool);

   527     Teardown();

   528     return KErrNone;

   529 	}

   530         

   531         

   532 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlLL(TTestResult& aResult)

   533 	{

   534     SetupL();	

   535     // Test serialization of Dom tree which has two child elements

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

   537     CleanupStack::PushL(pFragment);

   538     TXmlEngElement element = pFragment->AsElementL();

   539     

   540     TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));

   541 

   542     element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));

   543     

   544     HBufC8* pAsXml = pFragment->AsXmlL();

   545     CleanupStack::PushL(pAsXml);

   546     if(!( *pAsXml == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") ) ) return KErrArgument;

   547     CleanupStack::PopAndDestroy(pAsXml);

   548     CleanupStack::PopAndDestroy(pFragment);

   549     Teardown();

   550     return KErrNone;

   551 	}

   552         

   553         

   554 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentLL(TTestResult& aResult)

   555 	{

   556     SetupL();	

   557     RSenDocument document = RSenDocument::NewL();

   558     CleanupClosePushL(document);

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

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

   561     

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

   563     CleanupStack::PushL(pFragment);

   564     

   565     TPtrC8 content = pFragment->ContentL();

   566     if(!( content == _L8("<Element/>") ) ) return KErrArgument;

   567     

   568     CleanupStack::PopAndDestroy(pFragment);

   569     CleanupStack::PopAndDestroy(&document);

   570     Teardown();

   571     return KErrNone;

   572 	}

   573         

   574         

   575 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NamespaceL(TTestResult& aResult)

   576 	{

   577     SetupL();	

   578     RStringPool stringPool;

   579     stringPool.OpenL();

   580     CleanupClosePushL(stringPool);

   581     

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

   583     CleanupClosePushL(nsUriRString);

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

   585     CleanupClosePushL(nsPrefixRString);

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

   587     CleanupClosePushL(localNameRString);

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

   589     CleanupClosePushL(valueRString);

   590     

   591     RAttribute attribute;

   592     attribute.Open(stringPool.OpenStringL(_L8("nsuri")), 

   593                    stringPool.OpenStringL(_L8("pr")),

   594                    stringPool.OpenStringL(_L8("LocalName")),

   595                    stringPool.OpenStringL(_L8("Value")) );

   596     // attribute took copies of all RStrings

   597     // => All RStrings can be destroyed

   598     CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString,

   599                                     // valueRString

   600     CleanupClosePushL(attribute);

   601 

   602     RAttributeArray attrArray;

   603     // append the namespace attribute (declaration)

   604     attrArray.AppendL(attribute);

   605     CleanupClosePushL(attrArray);

   606     

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

   608                                                                _L8("Test"),

   609                                                                _L8("t"),

   610                                                                attrArray);

   611     CleanupStack::PushL(pFragment);

   612     

   613     TXmlEngNamespace ns = pFragment->Namespace(_L8("pr"));

   614     if(!( ns.Uri() == _L8("nsuri") ) ) return KErrArgument;

   615 

   616     TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x"));

   617     if(!( ns2.IsNull() ) ) return KErrArgument;

   618     

   619     CleanupStack::PopAndDestroy(pFragment);

   620     CleanupStack::PopAndDestroy(); // attribute

   621     CleanupStack::PopAndDestroy(); // attrArray

   622     CleanupStack::PopAndDestroy(); // stringPool   

   623     Teardown();

   624     return KErrNone;

   625 	}

   626         

   627         

   628 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ResetContentLL(TTestResult& aResult)

   629 	{

   630     SetupL();	

   631     RSenDocument document = RSenDocument::NewL();

   632     CleanupClosePushL(document);

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

   634     element.SetEscapedTextL(_L8("Content"));

   635     

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

   637     CleanupStack::PushL(pFragment);

   638     

   639     // Test that CSenFragmentBase has content before reset

   640     TPtrC8 content = pFragment->ContentL();

   641     if(!( content == _L8("Content") )) return KErrArgument;

   642     

   643     pFragment->ResetContentL();

   644     

   645     // Test that CSenFragmentBase has no content after reset

   646     TPtrC8 content2 = pFragment->ContentL();

   647     if(!( content2 == KNullDesC8 )) return KErrArgument;

   648     

   649     CleanupStack::PopAndDestroy(pFragment);

   650     CleanupStack::PopAndDestroy(&document);

   651     Teardown();

   652     return KErrNone;

   653 	}

   654         

   655         

   656 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_LocalNameL(TTestResult& aResult)

   657 	{

   658     SetupL();	

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

   660                                                                _L8("Test"),

   661                                                                _L8("t"));

   662     CleanupStack::PushL(pFragment);

   663     TPtrC8 localName = pFragment->LocalName();

   664     if(!( localName == _L8("Test") ) ) return KErrArgument;

   665     CleanupStack::PopAndDestroy(pFragment);

   666     Teardown();

   667     return KErrNone;

   668 	}

   669         

   670         

   671 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NsUriL(TTestResult& aResult)

   672 	{

   673     SetupL();	

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

   675                                                                _L8("Test"),

   676                                                                _L8("t"));

   677     CleanupStack::PushL(pFragment);

   678     TPtrC8 localName = pFragment->NsUri();

   679     if(!( localName == _L8("NsUri") ) ) return KErrArgument;

   680     CleanupStack::PopAndDestroy(pFragment);

   681     Teardown();

   682     return KErrNone;

   683 	}

   684         

   685         

   686 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NsPrefixL(TTestResult& aResult)

   687 	{

   688     SetupL();	

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

   690                                                                _L8("Test"),

   691                                                                _L8("t"));

   692     CleanupStack::PushL(pFragment);

   693     TPtrC8 localName = pFragment->NsPrefix();

   694     if(!( localName == _L8("t") ) ) return KErrArgument;

   695     CleanupStack::PopAndDestroy(pFragment);

   696     Teardown();

   697     return KErrNone;

   698 	}

   699         

   700         

   701 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsElementLL(TTestResult& aResult)

   702 	{

   703     SetupL();	

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

   705                                                                _L8("Test"),

   706                                                                _L8("t"));

   707     CleanupStack::PushL(pFragment);

   708     TXmlEngElement element = pFragment->AsElementL();

   709     RBuf8 buffer;

   710     CleanupClosePushL(buffer);

   711     element.OuterXmlL(buffer);

   712     // Serialized element should contain all the Fragment data as XML.

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

   714     CleanupStack::PopAndDestroy(&buffer);

   715     CleanupStack::PopAndDestroy(pFragment);

   716     Teardown();

   717     return KErrNone;

   718 	}

   719         

   720         

   721 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsDocumentLL(TTestResult& aResult)

   722 	{

   723     SetupL();	

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

   725                                                                _L8("Test"),

   726                                                                _L8("t"));

   727     CleanupStack::PushL(pFragment);

   728     RSenDocument document = pFragment->AsDocumentL();

   729     TXmlEngElement element = document.DocumentElement();

   730     

   731     TXmlEngSerializationOptions options;

   732     // Omit following declarations from the beginning of XML Document:

   733     // <?xml version=\"1.0\...

   734     //   encoding="..."

   735     //   standalone="..."

   736     // ?>

   737     options.iOptions = options.iOptions |

   738                        TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;

   739     RBuf8 asXml;

   740     document.SaveL(asXml, element, options);

   741     CleanupClosePushL(asXml);

   742     

   743     // Serialized document should contain all the Fragment data as XML.

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

   745 

   746     CleanupStack::PopAndDestroy(&asXml);

   747     CleanupStack::PopAndDestroy(pFragment);

   748     Teardown();

   749     return KErrNone;

   750 	}

   751         

   752         

   753 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ExtractElementL(TTestResult& aResult)

   754 	{

   755     SetupL();	

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

   757                                                                _L8("Test"),

   758                                                                _L8("t"));

   759     CleanupStack::PushL(pFragment);

   760     TXmlEngElement element = pFragment->ExtractElement();

   761     if(!( element.Name() == _L8("Test") )) return KErrArgument;

   762     element.Remove();

   763     CleanupStack::PopAndDestroy(pFragment);   

   764     Teardown();

   765     return KErrNone;

   766 	}

   767         

   768 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlUnicodeLL(TTestResult& aResult)

   769 	{

   770     SetupL();	

   771     // Test serialization of Dom tree which has two child elements

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

   773     CleanupStack::PushL(pFragment);

   774     TXmlEngElement element = pFragment->AsElementL();

   775     

   776     TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));

   777 

   778     element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));

   779     

   780     HBufC* pAsXml = pFragment->AsXmlUnicodeL();

   781     CleanupStack::PushL(pAsXml);

   782     if(!( *pAsXml == _L("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;

   783     CleanupStack::PopAndDestroy(pAsXml);

   784     CleanupStack::PopAndDestroy(pFragment);

   785     Teardown();

   786     return KErrNone;

   787 	}

   788         

   789         

   790 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_WriteAsXMLToLL(TTestResult& aResult)

   791 	{

   792     SetupL();	

   793     // Test serialization of Dom tree which has two child elements

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

   795     CleanupStack::PushL(pFragment);

   796     TXmlEngElement element = pFragment->AsElementL();

   797     

   798     TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));

   799 

   800     element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));

   801     

   802     CBufFlat* pBuf = CBufFlat::NewL(200);

   803     CleanupStack::PushL(pBuf);

   804     RBufWriteStream bufWs(*pBuf);

   805     CleanupClosePushL(bufWs);

   806     pFragment->WriteAsXMLToL(bufWs);

   807 

   808 

   809     if(!( pBuf->Ptr(0) == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") )) return KErrArgument;

   810     

   811     CleanupStack::PopAndDestroy(&bufWs);

   812     CleanupStack::PopAndDestroy(pBuf);

   813     

   814     CleanupStack::PopAndDestroy(pFragment);

   815     Teardown();

   816     return KErrNone;

   817 	}

   818         

   819         

   820 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ConsistsOfLL(TTestResult& aResult)

   821 	{

   822     SetupL();	

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

   824     CleanupStack::PushL(pFragment);

   825     TXmlEngElement element = pFragment->AsElementL();

   826     

   827     TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild"));

   828     elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));

   829    

   830     //TDomUtils domUtils1;

   831     //domUtils1.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   832 

   833     TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild"));

   834     elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));

   835     //TDomUtils domUtils2;

   836     //domUtils2.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   837     elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));

   838 

   839     CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("Test"));

   840     CleanupStack::PushL(pFragment2);

   841     TXmlEngElement element2 = pFragment2->AsElementL();

   842     

   843     TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild"));

   844     elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));

   845     //TDomUtils domUtils22;

   846     //domUtils22.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   847     elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));

   848 

   849     // ConsistOfL should return ETrue because

   850     // root elements of both fragments match and the only element

   851     // of pFragment2 = elementchild22 is exactly the same element as

   852     // elementchild2.

   853     if(!( pFragment->ConsistsOfL(*pFragment2) )) return KErrArgument;

   854 

   855     // ConsistOfL should return EFalse because

   856     // Even though root elements of both fragments match

   857     // there is extra element (= elementchild1) in pFragment.

   858     //

   859     // elementchild1 (of pFragment) can not be found from pFragment2

   860     // and because of that pFragment2 does not consist of pFragment.

   861     if(!( !pFragment2->ConsistsOfL(*pFragment) )) return KErrArgument;

   862     CleanupStack::PopAndDestroy(pFragment2);

   863 

   864     CSenDomFragmentBase* pFragment3 = CSenDomFragmentBase::NewL(_L8("Test"));

   865     CleanupStack::PushL(pFragment3);

   866     TXmlEngElement element3 = pFragment3->AsElementL();

   867     

   868     TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild"));

   869     elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));

   870     //TDomUtils domUtils32;

   871     //domUtils32.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   872     elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));

   873     elementchild32.SetEscapedTextL(_L8("Text"));

   874     

   875     // ConsistOfL should return EFalse because

   876     // elementchild32 has content ("Text") which doesn't match

   877     // to any child element of pFragment.

   878     if(!( !pFragment->ConsistsOfL(*pFragment3) )) return KErrArgument;

   879     CleanupStack::PopAndDestroy(pFragment3);

   880     

   881     CleanupStack::PopAndDestroy(pFragment);

   882     Teardown();

   883     return KErrNone;

   884 	}

   885         

   886         

   887 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing1L(TTestResult& aResult)

   888 	{

   889     SetupL();	

   890     // Parsing of XML document to CSenDomFragmentBase

   891     _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \

   892 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\

   893 <Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\

   894 <Element2 z=\"value4\">Content2</Element2>\

   895 <Element3>Content3</Element3>\

   896 <Element4/></a:Test>");

   897 

   898     // Default namespace declaration (xmlns="nsuri") from Parent element (Test)

   899     // will be moved to all child elements (Element1, Element2, Element3 and

   900     // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because

   901     // the way CParser works <=> Namespaces are reported when namespaces are used

   902     // for the first time.

   903     _LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \

   904 a:x=\"value1\" b:z=\"value2\">\

   905 <Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\

   906 <Element2 xmlns=\"nsuri\" z=\"value4\">Content2</Element2>\

   907 <Element3 xmlns=\"nsuri\">Content3</Element3>\

   908 <Element4 xmlns=\"nsuri\"/></a:Test>");

   909 

   910     // When EReportNamespaceMapping is enabled all the namespace declarations

   911     // are reported in exactly the same element as they are defined in parsed

   912     // XML document.

   913     // Note: The Order of namespace declarations in root element tag may change.

   914     // Namespace declaration for root tag is created when fragment is created

   915     // and because of that namespace declaration for root tag will be the first.

   916     // In this particular case namespace declaration for prefix "a" will be

   917     // the first namespace declaration because it is declared when

   918     // CSenDomFragmentBase is created.

   919     _LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \

   920 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\

   921 <Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\

   922 <Element2 z=\"value4\">Content2</Element2>\

   923 <Element3>Content3</Element3>\

   924 <Element4/></a:Test>"); 

   925     

   926 	CSenParser* pParser = CSenParser::NewLC();

   927 	

   928     CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));

   929     CleanupStack::PushL(pFragment);

   930 	

   931 	pParser->ParseL(KInputString, *pFragment);

   932 	

   933 	HBufC8* pAsXml = pFragment->AsXmlL();

   934 	CleanupStack::PushL(pAsXml);

   935 

   936     if(!( *pAsXml == KOutputString1 )) return KErrArgument;

   937 

   938     CleanupStack::PopAndDestroy(pAsXml);

   939     CleanupStack::PopAndDestroy(pFragment);

   940 /*

   941 	pParser->EnableFeature(EReportNamespaceMapping);

   942 	//tma

   943 	pParser->DisableFeature(EReportNamespaceMapping);

   944 	TBool fEneabled(EFalse);

   945 	fEneabled = pParser->IsFeatureEnabled(EReportNamespaceMapping);

   946 	EUNIT_ASSERT( fEneabled == EFalse);

   947 	pParser->EnableFeature(EReportNamespaceMapping);

   948 	//tma

   949 */	

   950 	pParser->EnableFeature(EReportNamespaceMapping);

   951 	

   952     CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));

   953     CleanupStack::PushL(pFragment2);

   954 

   955 	pParser->ParseL(KInputString, *pFragment2);

   956 	

   957 	HBufC8* pAsXml2 = pFragment2->AsXmlL();

   958 	CleanupStack::PushL(pAsXml2);

   959 	                   

   960     if(!( *pAsXml2 == KOutputString2 )) return KErrArgument;

   961     

   962     CleanupStack::PopAndDestroy(pAsXml2);

   963     CleanupStack::PopAndDestroy(pFragment2);

   964 

   965     CleanupStack::PopAndDestroy(pParser);

   966     Teardown();

   967     return KErrNone;

   968 	}

   969 

   970 

   971 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing2L(TTestResult& aResult)

   972 	{

   973     SetupL();	

   974     // Parsing of XML document to CSenDomFragmentBase which uses

   975     // delegation.

   976     _LIT8(KInputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \

   977 xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\

   978 <DelegateFragment>DelegateContent</DelegateFragment>\

   979 <Element1 x=\"value4\">Content1</Element1>\

   980 <Element2>Content2</Element2></a:Test>");

   981 

   982     // Default namespace declaration (xmlns="nsuri") from Parent element (Test)

   983     // will be moved to all child elements (Element1, Element2, Element3 and

   984     // Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because

   985     // the way CParser works <=> Namespaces are reported when namespaces are used

   986     // for the first time.

   987     _LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \

   988 a:x=\"value1\" b:z=\"value2\">\

   989 <DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>\

   990 <Element1 xmlns=\"nsuri\" x=\"value4\">Content1</Element1>\

   991 <Element2 xmlns=\"nsuri\">Content2</Element2></a:Test>");

   992 

   993     // When EReportNamespaceMapping is enabled all the namespace declarations

   994     // are reported in exactly the same element as they are defined in parsed

   995     // XML document.

   996     // Note: The Order of namespace declarations in root element tag may change.

   997     // Namespace declaration for root tag is created when fragment is created

   998     // and because of that namespace declaration for root tag will be the first.

   999     _LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \

  1000 xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\

  1001 <DelegateFragment>DelegateContent</DelegateFragment>\

  1002 <Element1 x=\"value4\">Content1</Element1>\

  1003 <Element2>Content2</Element2></a:Test>");

  1004      

  1005 	CSenParser* pParser = CSenParser::NewLC();

  1006 	

  1007     CMainDomFragment* pFragment = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));

  1008     CleanupStack::PushL(pFragment);

  1009 	

  1010 	pParser->ParseL(KInputString, *pFragment);

  1011 	

  1012 	HBufC8* pAsXml = pFragment->AsXmlL();

  1013 	CleanupStack::PushL(pAsXml);

  1014     if(!( *pAsXml == KOutputString1 )) return KErrArgument;

  1015     CleanupStack::PopAndDestroy(pAsXml);

  1016     

  1017     CDelegateDomFragment& delegate = pFragment->DelegateFragment();

  1018     HBufC8* pDelegateAsXml = delegate.AsXmlL();

  1019     CleanupStack::PushL(pDelegateAsXml);

  1020     // Note: When EReportNamespaceMapping is _NOT_ enabled namespace declaration

  1021     //       is added to delegate even though that namespace declaration was

  1022     //       originally declared (but not used) in root element of parsed document. 

  1023     if(!( *pDelegateAsXml ==

  1024                  _L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") )) return KErrArgument;

  1025     CleanupStack::PopAndDestroy(pDelegateAsXml);

  1026     

  1027     CleanupStack::PopAndDestroy(pFragment);

  1028 

  1029 	pParser->EnableFeature(EReportNamespaceMapping);

  1030 	

  1031     CMainDomFragment* pFragment2 = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));

  1032     CleanupStack::PushL(pFragment2);

  1033 

  1034 	pParser->ParseL(KInputString, *pFragment2);

  1035 	

  1036 	HBufC8* pAsXml2 = pFragment2->AsXmlL();

  1037 	CleanupStack::PushL(pAsXml2);

  1038     if(!( *pAsXml2 == KOutputString2 )) return KErrArgument;

  1039     CleanupStack::PopAndDestroy(pAsXml2);

  1040     

  1041     CDelegateDomFragment& delegate2 = pFragment2->DelegateFragment();

  1042     HBufC8* pDelegateAsXml2 = delegate2.AsXmlL();

  1043     CleanupStack::PushL(pDelegateAsXml2);

  1044     if(!( *pDelegateAsXml2 ==

  1045                  _L8("<DelegateFragment>DelegateContent</DelegateFragment>") )) return KErrArgument;

  1046     CleanupStack::PopAndDestroy(pDelegateAsXml2);

  1047     

  1048     CleanupStack::PopAndDestroy(pFragment2);

  1049 

  1050     CleanupStack::PopAndDestroy(pParser);

  1051     Teardown();

  1052     return KErrNone;

  1053 	}

  1054          

  1055          

  1056 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing3L(TTestResult& aResult)

  1057 	{

  1058     SetupL();	

  1059     // Parsing of XML document to CSenDomFragmentBase

  1060     // In this test same namespaceuri is defined as default namespace in

  1061     // root element and 'c' prefixed namespace in Element2.

  1062     _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \

  1063 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\

  1064 <Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\

  1065 <x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\

  1066 <Element3>Content3</Element3>\

  1067 <Element4/></a:Test>");

  1068 

  1069     // Namespace declaration for prefix 'x' (and namespaceuri "nsuri")

  1070     // disappears from Element2 after parsing because default namespace

  1071     // declaration already declares namespace for uri "nsuri".

  1072     // => Double declaration for namespaceuri "nsuri" is not needed.

  1073     _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \

  1074 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\

  1075 <Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\

  1076 <Element2>Content2</Element2>\

  1077 <Element3>Content3</Element3>\

  1078 <Element4/></a:Test>");

  1079     

  1080 	CSenParser* pParser = CSenParser::NewLC();

  1081 	

  1082     CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));

  1083     CleanupStack::PushL(pFragment);

  1084 	pParser->EnableFeature(EReportNamespaceMapping);

  1085 	

  1086 	pParser->ParseL(KInputString, *pFragment);

  1087 	

  1088 	HBufC8* pAsXml = pFragment->AsXmlL();

  1089 	CleanupStack::PushL(pAsXml);

  1090 

  1091     if(!( *pAsXml == KOutputString )) return KErrArgument;

  1092 

  1093     CleanupStack::PopAndDestroy(pAsXml);

  1094     CleanupStack::PopAndDestroy(pFragment);

  1095     CleanupStack::PopAndDestroy(pParser);

  1096     Teardown();

  1097     return KErrNone;

  1098 	}

  1099         

  1100         

  1101 TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing4L(TTestResult& aResult)

  1102 	{

  1103     SetupL();	

  1104     // Parsing of XML document to CSenDomFragmentBase

  1105     // In this test nested elements (which have same name) are tested.

  1106     _LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \

  1107 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\

  1108 <Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\

  1109 <Element1>Content</Element1>\

  1110 </Element1>\

  1111 <Element3>Content3</Element3>\

  1112 <Element4/></a:Test>");

  1113 

  1114     _LIT8(KInputString2, "<Nested xmlns=\"nsuri\">\

  1115 <Nested attr=\"attrvalue\"><Nested><Nested>Content</Nested></Nested></Nested>\

  1116 </Nested>");

  1117 

  1118     // Only namespace declaration order changes for output.

  1119     _LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \

  1120 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\

  1121 <Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\

  1122 <Element1>Content</Element1>\

  1123 </Element1>\

  1124 <Element3>Content3</Element3>\

  1125 <Element4/></a:Test>");

  1126 

  1127 	CSenParser* pParser = CSenParser::NewLC();

  1128 	

  1129     CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));

  1130     CleanupStack::PushL(pFragment);

  1131 	pParser->EnableFeature(EReportNamespaceMapping);

  1132 	

  1133 	pParser->ParseL(KInputString, *pFragment);

  1134 	

  1135 	HBufC8* pAsXml = pFragment->AsXmlL();