1 /*

     2 * Copyright (c) 2002 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 

    19 // [INCLUDE FILES] - do not remove

    20 #include <e32svr.h>

    21 #include <StifParser.h>

    22 #include <StifTestInterface.h>

    23 #include "SenFragmentTester.h"

    24 //  EXTERNAL INCLUDES

    25 #include <SenDomFragmentBase.h>

    26 #include <SenFragmentBase.h>

    27 #include <SenParser.h>

    28 #include <RSenDocument.h>

    29 #include <xmlengdomutils.h>

    30 

    31 #if defined( __SERIES60_31__ ) || (!defined( __SERIES60_30__ ) && defined( SYMBIAN_SWI_POST_INSTALL_REVOCATION) )

    32     #include <xml/matchdata.h>

    33 #endif    

    34 

    35 #include <xml/parserfeature.h>           // for TParserFeature enumeration

    36 #include <xmlengserializationoptions.h> // needed for TSerializationOptions

    37 #include <xmlengbinarycontainer.h>

    38 #include <s32mem.h>

    39 #include <xmlengdom.h>

    40 

    41 //  INTERNAL INCLUDES

    42 #include "maindomfragment.h"

    43 #include "mainfragment.h"

    44 // EXTERNAL DATA STRUCTURES

    45 //extern  ?external_data;

    46 

    47 // EXTERNAL FUNCTION PROTOTYPES  

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

    49 

    50 // CONSTANTS

    51 //const ?type ?constant_var = ?constant;

    52 

    53 // MACROS

    54 //#define ?macro ?macro_def

    55 #define LOCAL_ASSERT(expression)	{if(!(expression)){return KErrArgument;}}

    56 

    57 // LOCAL CONSTANTS AND MACROS

    58 //const ?type ?constant_var = ?constant;

    59 //#define ?macro_name ?macro_def

    60 

    61 // MODULE DATA STRUCTURES

    62 //enum ?declaration

    63 //typedef ?declaration

    64 

    65 // LOCAL FUNCTION PROTOTYPES

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

    67 

    68 // FORWARD DECLARATIONS

    69 //class ?FORWARD_CLASSNAME;

    70 

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

    72 

    73 // -----------------------------------------------------------------------------

    74 // ?function_name ?description.

    75 // ?description

    76 // Returns: ?value_1: ?description

    77 //          ?value_n: ?description_line1

    78 //                    ?description_line2

    79 // -----------------------------------------------------------------------------

    80 //

    81 /*

    82 ?type ?function_name(

    83     ?arg_type arg,  // ?description

    84     ?arg_type arg)  // ?description

    85     {

    86 

    87     ?code  // ?comment

    88 

    89     // ?comment

    90     ?code

    91     }

    92 */

    93 

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

    95 

    96 // -----------------------------------------------------------------------------

    97 // CSenFragmentTester::Delete

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

    99 // Called from destructor. 

   100 // -----------------------------------------------------------------------------

   101 //

   102 void CSenFragmentTester::Delete() 

   103     {

   104 

   105     }

   106 

   107 // -----------------------------------------------------------------------------

   108 // CSenFragmentTester::RunMethodL

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

   110 // -----------------------------------------------------------------------------

   111 //

   112 TInt CSenFragmentTester::RunMethodL( 

   113     CStifItemParser& aItem ) 

   114     {

   115 

   116     static TStifFunctionInfo const KFunctions[] =

   117         {  

   118         // First string is the function name used in TestScripter script file.

   119         // Second is the actual implementation member function. 

   120 		ENTRY("SDFB-NewL-test_CSenDomFragmentBase_NewL", MT_CSenDomFragmentBase_NewLL),

   121 		ENTRY("SDFB-NewL1-test_CSenDomFragmentBase_NewL", MT_CSenDomFragmentBase_NewL_1L),

   122 		ENTRY("SDFB-NewL2-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_2L),

   123 		ENTRY("SDFB-NewL3-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_3L),

   124 		ENTRY("SDFB-NewL4-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_4L),

   125 		ENTRY("SDFB-NewL5-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_5L),

   126 		ENTRY("SDFB-NewL6-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_6L),

   127 		ENTRY("SDFB-NewL7-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_7L),

   128 		ENTRY("SDFB-ExpandL-test_CSenDomFragmentBase_ExpandL", CSenFragmentTester::MT_CSenDomFragmentBase_ExpandLL),

   129 		ENTRY("SDFB-OnResumeParsingFromL-test_CSenDomFragmentBase_OnResumeParsingFromL", CSenFragmentTester::MT_CSenDomFragmentBase_OnResumeParsingFromLL),

   130 		ENTRY("SDFB-AddAttributesL-test_CSenDomFragmentBase_AddAttributesL", CSenFragmentTester::MT_CSenDomFragmentBase_AddAttributesLL),

   131 		ENTRY("SDFB-AsXmlL-test_CSenDomFragmentBase_AsXmlL", CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlLL),

   132 		ENTRY("SDFB-OnStartElementL-test_CSenDomFragmentBase_OnStartElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnStartElementLL),

   133 		ENTRY("SDFB-OnContentL-test_CSenDomFragmentBase_OnContentL", CSenFragmentTester::MT_CSenDomFragmentBase_OnContentLL),

   134 		ENTRY("SDFB-OnWriteStartElementL-test_CSenDomFragmentBase_OnWriteStartElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteStartElementLL),

   135 		ENTRY("SDFB-OnWriteEndElementL-test_CSenDomFragmentBase_OnWriteEndElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteEndElementLL),

   136 		ENTRY("SDFB-OnEndElementL-test_CSenDomFragmentBase_OnEndElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnEndElementLL),

   137 		ENTRY("SDFB-OnStartDocumentL-test_CSenDomFragmentBase_OnStartDocumentL", CSenFragmentTester::MT_CSenDomFragmentBase_OnStartDocumentLL),

   138 		ENTRY("SDFB-OnEndDocumentL-test_CSenDomFragmentBase_OnEndDocumentL", CSenFragmentTester::MT_CSenDomFragmentBase_OnEndDocumentLL),

   139 		ENTRY("SDFB-OnStartPrefixMappingL-test_CSenDomFragmentBase_OnStartPrefixMappingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnStartPrefixMappingLL),

   140 		ENTRY("SDFB-OnEndPrefixMappingL-test_CSenDomFragmentBase_OnEndPrefixMappingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnEndPrefixMappingLL),

   141 		ENTRY("SDFB-OnIgnorableWhiteSpaceL-test_CSenDomFragmentBase_OnIgnorableWhiteSpaceL", CSenFragmentTester::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL),

   142 		ENTRY("SDFB-OnSkippedEntityL-test_CSenDomFragmentBase_OnSkippedEntityL", CSenFragmentTester::MT_CSenDomFragmentBase_OnSkippedEntityLL),

   143 		ENTRY("SDFB-OnProcessingInstructionL-test_CSenDomFragmentBase_OnProcessingInstructionL", CSenFragmentTester::MT_CSenDomFragmentBase_OnProcessingInstructionLL),

   144 		ENTRY("SDFB-OnError-test_CSenDomFragmentBase_OnError", CSenFragmentTester::MT_CSenDomFragmentBase_OnErrorL),

   145 		ENTRY("SDFB-GetExtendedInterface-test_CSenDomFragmentBase_GetExtendedInterface", CSenFragmentTester::MT_CSenDomFragmentBase_GetExtendedInterfaceL),

   146 		ENTRY("SDFB-ContentL-test_CSenDomFragmentBase_ContentL", CSenFragmentTester::MT_CSenDomFragmentBase_ContentLL),

   147 		ENTRY("SDFB-Namespace-test_CSenDomFragmentBase_Namespace", CSenFragmentTester::MT_CSenDomFragmentBase_NamespaceL),

   148 		ENTRY("SDFB-ResetContentL-test_CSenDomFragmentBase_ResetContentL", CSenFragmentTester::MT_CSenDomFragmentBase_ResetContentLL),

   149 		ENTRY("SDFB-LocalName-test_CSenDomFragmentBase_LocalName", CSenFragmentTester::MT_CSenDomFragmentBase_LocalNameL),

   150 		ENTRY("SDFB-NsUri-test_CSenDomFragmentBase_NsUri", CSenFragmentTester::MT_CSenDomFragmentBase_NsUriL),

   151 		ENTRY("SDFB-NsPrefix-test_CSenDomFragmentBase_NsPrefix", CSenFragmentTester::MT_CSenDomFragmentBase_NsPrefixL),

   152 		ENTRY("SDFB-AsElementL-test_CSenDomFragmentBase_AsElementL", CSenFragmentTester::MT_CSenDomFragmentBase_AsElementLL),

   153 		ENTRY("SDFB-AsDocumentL-test_CSenDomFragmentBase_AsDocumentL", CSenFragmentTester::MT_CSenDomFragmentBase_AsDocumentLL),

   154 		ENTRY("SDFB-ExtractElement-test_CSenDomFragmentBase_ExtractElement", CSenFragmentTester::MT_CSenDomFragmentBase_ExtractElementL),

   155 		ENTRY("SDFB-OnDelegateParsingL-test_CSenDomFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingLL),

   156 		ENTRY("SDFB-OnDelegateParsingL-test_CSenDomFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingL_1L),

   157 		ENTRY("SDFB-SetOwner-test_CSenDomFragmentBase_SetOwner", CSenFragmentTester::MT_CSenDomFragmentBase_SetOwnerL),

   158 		ENTRY("SDFB-AsXmlUnicodeL-test_CSenDomFragmentBase_AsXmlUnicodeL", CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlUnicodeLL),

   159 		ENTRY("SDFB-WriteAsXMLToL-test_CSenDomFragmentBase_WriteAsXMLToL", CSenFragmentTester::MT_CSenDomFragmentBase_WriteAsXMLToLL),

   160 		ENTRY("SDFB-ConsistsOfL-test_CSenDomFragmentBase_ConsistsOfL", CSenFragmentTester::MT_CSenDomFragmentBase_ConsistsOfLL),

   161 		ENTRY("SDFB-SetContentHandler-test_CSenDomFragmentBase_SetContentHandler", CSenFragmentTester::MT_CSenDomFragmentBase_SetContentHandlerL),

   162 		ENTRY("SDFB-Parsing-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing1L),

   163 		ENTRY("SDFB-Parsingdelegate-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing2L),

   164 		ENTRY("SDFB-Parsingnamespaces-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing3L),

   165 		ENTRY("SDFB-Parsingnestedelements-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing4L),

   166 		ENTRY("SDFB-Parsingnullednamespaces-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing5L),

   167 		ENTRY("SDFB-Parsingusingemptyfragment-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing6L),

   168 		ENTRY("SDFB-ParsingWSmessage-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing7L),

   169 		ENTRY("SDFB-Parsing2.WSmessage-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing8L),

   170 		ENTRY("SFB-NewL-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewLL),

   171 		ENTRY("SFB-NewL1-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_1L),

   172 		ENTRY("SFB-NewL2-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_2L),

   173 		ENTRY("SFB-NewL3-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_3L),

   174 		ENTRY("SFB-NewL4-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_4L),

   175 		ENTRY("SFB-NewL5-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_5L),

   176 		ENTRY("SFB-NewL6-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_6L),

   177 		ENTRY("SFB-NewL7-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_7L),

   178 		ENTRY("SFB-OnStartElementL-test_CSenFragmentBase_OnStartElementL", CSenFragmentTester::MT_CSenFragmentBase_OnStartElementLL),

   179 		ENTRY("SFB-OnEndElementL-test_CSenFragmentBase_OnEndElementL", CSenFragmentTester::MT_CSenFragmentBase_OnEndElementLL),

   180 		ENTRY("SFB-OnStartDocumentL-test_CSenFragmentBase_OnStartDocumentL", CSenFragmentTester::MT_CSenFragmentBase_OnStartDocumentLL),

   181 		ENTRY("SFB-OnEndDocumentL-test_CSenFragmentBase_OnEndDocumentL", CSenFragmentTester::MT_CSenFragmentBase_OnEndDocumentLL),

   182 		ENTRY("SFB-OnContentL-test_CSenFragmentBase_OnContentL", CSenFragmentTester::MT_CSenFragmentBase_OnContentLL),

   183 		ENTRY("SFB-OnStartPrefixMappingL-test_CSenFragmentBase_OnStartPrefixMappingL", CSenFragmentTester::MT_CSenFragmentBase_OnStartPrefixMappingLL),

   184 		ENTRY("SFB-OnEndPrefixMappingL-test_CSenFragmentBase_OnEndPrefixMappingL", CSenFragmentTester::MT_CSenFragmentBase_OnEndPrefixMappingLL),

   185 		ENTRY("SFB-OnIgnorableWhiteSpaceL-test_CSenFragmentBase_OnIgnorableWhiteSpaceL", CSenFragmentTester::MT_CSenFragmentBase_OnIgnorableWhiteSpaceLL),

   186 		ENTRY("SFB-OnSkippedEntityL-test_CSenFragmentBase_OnSkippedEntityL", CSenFragmentTester::MT_CSenFragmentBase_OnSkippedEntityLL),

   187 		ENTRY("SFB-OnProcessingInstructionL-test_CSenFragmentBase_OnProcessingInstructionL", CSenFragmentTester::MT_CSenFragmentBase_OnProcessingInstructionLL),

   188 		ENTRY("SFB-OnError-test_CSenFragmentBase_OnError", CSenFragmentTester::MT_CSenFragmentBase_OnErrorL),

   189 		ENTRY("SFB-GetExtendedInterface-test_CSenFragmentBase_GetExtendedInterface", CSenFragmentTester::MT_CSenFragmentBase_GetExtendedInterfaceL),

   190 		ENTRY("SFB-ContentL-test_CSenFragmentBase_ContentL", CSenFragmentTester::MT_CSenFragmentBase_ContentLL),

   191 		ENTRY("SFB-Namespace-test_CSenFragmentBase_Namespace", CSenFragmentTester::MT_CSenFragmentBase_NamespaceL),

   192 		ENTRY("SFB-ResetContentL-test_CSenFragmentBase_ResetContentL", CSenFragmentTester::MT_CSenFragmentBase_ResetContentLL),

   193 		ENTRY("SFB-LocalName-test_CSenFragmentBase_LocalName", CSenFragmentTester::MT_CSenFragmentBase_LocalNameL),

   194 		ENTRY("SFB-NsUri-test_CSenFragmentBase_NsUri", CSenFragmentTester::MT_CSenFragmentBase_NsUriL),

   195 		ENTRY("SFB-NsPrefix-test_CSenFragmentBase_NsPrefix", CSenFragmentTester::MT_CSenFragmentBase_NsPrefixL),

   196 		ENTRY("SFB-AsElementL-test_CSenFragmentBase_AsElementL", CSenFragmentTester::MT_CSenFragmentBase_AsElementLL),

   197 		ENTRY("SFB-AsDocumentL-test_CSenFragmentBase_AsDocumentL", CSenFragmentTester::MT_CSenFragmentBase_AsDocumentLL),

   198 		ENTRY("SFB-ExtractElement-test_CSenFragmentBase_ExtractElement", CSenFragmentTester::MT_CSenFragmentBase_ExtractElementL),

   199 		ENTRY("SFB-OnDelegateParsingL-test_CSenFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenFragmentBase_OnDelegateParsingLL),

   200 		ENTRY("SFB-OnDelegateParsingL-test_CSenFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenFragmentBase_OnDelegateParsingL_1L),

   201 		ENTRY("SFB-SetOwner-test_CSenFragmentBase_SetOwner", CSenFragmentTester::MT_CSenFragmentBase_SetOwnerL),

   202 		ENTRY("SFB-OnResumeParsingFromL-test_CSenFragmentBase_OnResumeParsingFromL", CSenFragmentTester::MT_CSenFragmentBase_OnResumeParsingFromLL),

   203 		ENTRY("SFB-OnWriteStartElementL-test_CSenFragmentBase_OnWriteStartElementL", CSenFragmentTester::MT_CSenFragmentBase_OnWriteStartElementLL),

   204 		ENTRY("SFB-OnWriteEndElementL-test_CSenFragmentBase_OnWriteEndElementL", CSenFragmentTester::MT_CSenFragmentBase_OnWriteEndElementLL),

   205 		ENTRY("SFB-AsXmlUnicodeL-test_CSenFragmentBase_AsXmlUnicodeL", CSenFragmentTester::MT_CSenFragmentBase_AsXmlUnicodeLL),

   206 		ENTRY("SFB-AsXmlL-test_CSenFragmentBase_AsXmlL", CSenFragmentTester::MT_CSenFragmentBase_AsXmlLL),

   207 		ENTRY("SFB-WriteAsXMLToL-test_CSenFragmentBase_WriteAsXMLToL", CSenFragmentTester::MT_CSenFragmentBase_WriteAsXMLToLL),

   208 		ENTRY("SFB-ConsistsOfL-test_CSenFragmentBase_ConsistsOfL", CSenFragmentTester::MT_CSenFragmentBase_ConsistsOfLL),

   209 		ENTRY("SFB-SetContentHandler-test_CSenFragmentBase_SetContentHandler", CSenFragmentTester::MT_CSenFragmentBase_SetContentHandlerL),

   210 		ENTRY("SFB-Parsing-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing1L),

   211 		ENTRY("SFB-Parsingdelegate-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing2L),

   212 		ENTRY("SFB-Parsingnamespaces-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing3L),

   213 		ENTRY("SFB-Parsingnestedelements-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing4L),

   214 		ENTRY("SFB-ParsingelementinsideDOMtree-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing5L),

   215 		ENTRY("CSP-NewL-test_CSenParser_NewL", CSenFragmentTester::MT_CSenParser_NewLL),

   216 		ENTRY("CSP-NewLC-test_CSenParser_NewLC", CSenFragmentTester::MT_CSenParser_NewLCL),

   217 		ENTRY("CSP-NewL1-test_CSenParser_NewL", CSenFragmentTester::MT_CSenParser_NewL_1L),

   218 		ENTRY("CSP-NewLC1-test_CSenParser_NewLC", CSenFragmentTester::MT_CSenParser_NewLC_1L),

   219 		ENTRY("CSP-NewL2-test_CSenParser_NewL", CSenFragmentTester::MT_CSenParser_NewL_2L),

   220 		ENTRY("CSP-NewLC2-test_CSenParser_NewLC", CSenFragmentTester::MT_CSenParser_NewLC_2L),

   221 		ENTRY("RSD-NewL-test_RSenDocument_NewL", MT_RSenDocument_NewLL),

   222 		ENTRY("RSD-NewLC-test_RSenDocument_NewLC", MT_RSenDocument_NewLCL),

   223 		ENTRY("RSD-NewL2-test_RSenDocument_NewL", MT_RSenDocument_NewL_1L),

   224 		ENTRY("RSD-NewLC2-test_RSenDocument_NewLC", MT_RSenDocument_NewLC_1L),

   225 		ENTRY("RSD-Copy-test_RSenDocument_Copy", MT_RSenDocument_CopyL),

   226 		ENTRY("RSD-Close-test_RSenDocument_Close", MT_RSenDocument_CloseL),

   227 		ENTRY("RSD-Destroy-test_RSenDocument_Destroy", MT_RSenDocument_DestroyL),

   228 

   229         };

   230 

   231     const TInt count = sizeof( KFunctions ) / 

   232                         sizeof( TStifFunctionInfo );

   233 

   234     return RunInternalL( KFunctions, count, aItem );

   235 

   236     }

   237 

   238 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewLL(  )

   239     {

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

   241     delete pFragment;

   242     return KErrNone;

   243     }

   244 

   245 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_1L(  )

   246     {

   247     RSenDocument document = RSenDocument::NewL();

   248     CleanupClosePushL(document);

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

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

   251     

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

   253     CleanupStack::PushL(pFragment);

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

   255     CleanupStack::PushL(pAsXml);

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

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

   258     LOCAL_ASSERT( *pAsXml == _L8("<Test>&lt;Element/&gt;</Test>") );

   259     CleanupStack::PopAndDestroy(pAsXml);

   260     CleanupStack::PopAndDestroy(pFragment);

   261     CleanupStack::PopAndDestroy(&document);

   262     return KErrNone;

   263     }

   264 

   265 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_2L(  )

   266     {

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

   268     CleanupStack::PushL(pFragment);

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

   270     CleanupStack::PushL(pAsXml);

   271     LOCAL_ASSERT( *pAsXml == _L8("<Test/>") );

   272     CleanupStack::PopAndDestroy(pAsXml);

   273     CleanupStack::PopAndDestroy(pFragment);

   274     return KErrNone;

   275     }

   276 

   277 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_3L(  )

   278     {

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

   280                                                                _L8("Test"));

   281     CleanupStack::PushL(pFragment);

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

   283     CleanupStack::PushL(pAsXml);

   284     LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\"/>") );

   285     CleanupStack::PopAndDestroy(pAsXml);

   286     CleanupStack::PopAndDestroy(pFragment);

   287     return KErrNone;

   288     }

   289 

   290 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_4L(  )

   291     {

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

   293                                                                _L8("Test"),

   294                                                                _L8("t"));

   295     CleanupStack::PushL(pFragment);

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

   297     CleanupStack::PushL(pAsXml);

   298     LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") );

   299     CleanupStack::PopAndDestroy(pAsXml);

   300     CleanupStack::PopAndDestroy(pFragment);

   301     return KErrNone;

   302     }

   303 

   304 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_5L(  )

   305     {

   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     LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );

   344     CleanupStack::PopAndDestroy(pAsXml);

   345     CleanupStack::PopAndDestroy(pFragment);

   346     CleanupStack::PopAndDestroy(&attrArray);

   347     CleanupStack::PopAndDestroy(&attribute);

   348     CleanupStack::PopAndDestroy(&stringPool);

   349     return KErrNone;

   350     }

   351 

   352 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_6L(  )

   353     {

   354     RSenDocument document = RSenDocument::NewL();

   355     CleanupClosePushL(document);

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

   357     

   358     RStringPool stringPool;

   359     stringPool.OpenL();

   360     CleanupClosePushL(stringPool);

   361     

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

   363     CleanupClosePushL(nsUriRString);

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

   365     CleanupClosePushL(nsPrefixRString);

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

   367     CleanupClosePushL(localNameRString);

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

   369     CleanupClosePushL(valueRString);

   370     

   371     RAttribute attribute;

   372     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

   373                    valueRString);

   374     // attribute took ownership of all RStrings

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

   376     CleanupStack::Pop(&valueRString);

   377     CleanupStack::Pop(&localNameRString);

   378     CleanupStack::Pop(&nsPrefixRString);

   379     CleanupStack::Pop(&nsUriRString);

   380     

   381     CleanupClosePushL(attribute);

   382 

   383     RAttributeArray attrArray;

   384     // append the namespace attribute (declaration)

   385     attrArray.AppendL(attribute);

   386     CleanupClosePushL(attrArray);

   387         

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

   389                                                                _L8("Test"),

   390                                                                _L8("t"),

   391                                                                attrArray,

   392                                                                parentElement);

   393     CleanupStack::PushL(pFragment);

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

   395     CleanupStack::PushL(pAsXml);

   396     LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );

   397 

   398     RBuf8 buffer;

   399     parentElement.OuterXmlL(buffer);

   400     

   401     LOCAL_ASSERT( buffer == _L8("<Parent><t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );

   402     buffer.Close();

   403     

   404     CleanupStack::PopAndDestroy(pAsXml);

   405     CleanupStack::PopAndDestroy(pFragment);

   406     CleanupStack::PopAndDestroy(&attrArray);

   407     CleanupStack::PopAndDestroy(&attribute);

   408     CleanupStack::PopAndDestroy(&stringPool);

   409     CleanupStack::PopAndDestroy(&document);

   410     return KErrNone;

   411     }

   412 

   413 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_7L(  )

   414     {

   415     RSenDocument document = RSenDocument::NewL();

   416     CleanupClosePushL(document);

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

   418     

   419     RStringPool stringPool;

   420     stringPool.OpenL();

   421     CleanupClosePushL(stringPool);

   422     

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

   424     CleanupClosePushL(nsUriRString);

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

   426     CleanupClosePushL(nsPrefixRString);

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

   428     CleanupClosePushL(localNameRString);

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

   430     CleanupClosePushL(valueRString);

   431     

   432     RAttribute attribute;

   433     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

   434                    valueRString);

   435     // attribute took ownership of all RStrings

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

   437     CleanupStack::Pop(&valueRString);

   438     CleanupStack::Pop(&localNameRString);

   439     CleanupStack::Pop(&nsPrefixRString);

   440     CleanupStack::Pop(&nsUriRString);

   441 

   442     CleanupClosePushL(attribute);

   443 

   444     RAttributeArray attrArray;

   445     // append the namespace attribute (declaration)

   446     attrArray.AppendL(attribute);

   447     CleanupClosePushL(attrArray);

   448         

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

   450                                                                _L8("Test"),

   451                                                                _L8(""),

   452                                                                attrArray,

   453                                                                parentElement,

   454                                                                document);

   455     CleanupStack::PushL(pFragment);

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

   457     CleanupStack::PushL(pAsXml);

   458     LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );

   459 

   460     RBuf8 buffer;

   461     parentElement.OuterXmlL(buffer);

   462     

   463     LOCAL_ASSERT( buffer == _L8("<Parent><Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );

   464     buffer.Close();

   465     

   466     CleanupStack::PopAndDestroy(pAsXml);

   467     CleanupStack::PopAndDestroy(pFragment);

   468     CleanupStack::PopAndDestroy(&attrArray);

   469     CleanupStack::PopAndDestroy(&attribute);

   470     CleanupStack::PopAndDestroy(&stringPool);

   471     CleanupStack::PopAndDestroy(&document);

   472     return KErrNone;

   473     }

   474 

   475 TInt CSenFragmentTester::MT_CSenDomFragmentBase_ExpandLL(  )

   476     {

   477     LOCAL_ASSERT( ETrue );

   478     return KErrNone;

   479     }

   480 

   481 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnResumeParsingFromLL(  )

   482     {

   483     LOCAL_ASSERT( ETrue );

   484     return KErrNone;

   485     }

   486 

   487 TInt CSenFragmentTester::MT_CSenDomFragmentBase_AddAttributesLL(  )

   488     {

   489     RStringPool stringPool;

   490     stringPool.OpenL();

   491     CleanupClosePushL(stringPool);

   492     

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

   494     CleanupClosePushL(nsUriRString);

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

   496     CleanupClosePushL(nsPrefixRString);

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

   498     CleanupClosePushL(localNameRString);

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

   500     CleanupClosePushL(valueRString);

   501     

   502     RAttribute attribute;

   503     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

   504                    valueRString);

   505     // attribute took ownership of all RStrings

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

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

   508                           // valueRString

   509     CleanupClosePushL(attribute);

   510 

   511     RAttributeArray attrArray;

   512     // append the namespace attribute (declaration)

   513     attrArray.AppendL(attribute);

   514     CleanupClosePushL(attrArray);    

   515     

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

   517     CleanupStack::PushL(pFragment);

   518     

   519     pFragment->AddAttributesL(attrArray);

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

   521     CleanupStack::PushL(pAsXml);

   522     LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );

   523     CleanupStack::PopAndDestroy(pAsXml);

   524 

   525     CleanupStack::PopAndDestroy(pFragment);

   526     

   527     CleanupStack::PopAndDestroy(&attrArray);

   528     CleanupStack::PopAndDestroy(&attribute);

   529     CleanupStack::PopAndDestroy(&stringPool);

   530     return KErrNone;

   531     }

   532 

   533 TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlLL(  )

   534     {

   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     LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );

   547     CleanupStack::PopAndDestroy(pAsXml);

   548     CleanupStack::PopAndDestroy(pFragment);

   549     return KErrNone;

   550     }

   551 

   552 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnStartElementLL(  )

   553     {

   554     // Will be tested in Parse test cases

   555     LOCAL_ASSERT( ETrue );

   556     return KErrNone;

   557     }

   558 

   559 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnContentLL(  )

   560     {

   561     // Will be tested in Parse test cases

   562     LOCAL_ASSERT( ETrue );

   563     return KErrNone;

   564     }

   565 

   566 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteStartElementLL(  )

   567     {

   568     // Will be tested in Parse test cases

   569     LOCAL_ASSERT( ETrue );

   570     return KErrNone;

   571     }

   572 

   573 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteEndElementLL(  )

   574     {

   575     // Will be tested in Parse test cases

   576     LOCAL_ASSERT( ETrue );

   577     return KErrNone;

   578     }

   579 

   580 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnEndElementLL(  )

   581     {

   582     // Will be tested in Parse test cases

   583     LOCAL_ASSERT( ETrue );

   584     return KErrNone;

   585     }

   586 

   587 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnStartDocumentLL(  )

   588     {

   589     // Will be tested in Parse test cases

   590     LOCAL_ASSERT( ETrue );

   591     return KErrNone;

   592     }

   593 

   594 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnEndDocumentLL(  )

   595     {

   596     // Will be tested in Parse test cases

   597     LOCAL_ASSERT( ETrue );

   598     return KErrNone;

   599     }

   600 

   601 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnStartPrefixMappingLL(  )

   602     {

   603     // Will be tested in Parse test cases

   604     LOCAL_ASSERT( ETrue );

   605     return KErrNone;

   606     }

   607 

   608 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnEndPrefixMappingLL(  )

   609     {

   610     // Will be tested in Parse test cases

   611     LOCAL_ASSERT( ETrue );

   612     return KErrNone;

   613     }

   614 

   615 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL(  )

   616     {

   617     // Will be tested in Parse test cases

   618     LOCAL_ASSERT( ETrue );

   619     return KErrNone;

   620     }

   621 

   622 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnSkippedEntityLL(  )

   623     {

   624     // Will be tested in Parse test cases

   625     LOCAL_ASSERT( ETrue );

   626     return KErrNone;

   627     }

   628 

   629 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnProcessingInstructionLL(  )

   630     {

   631     // Will be tested in Parse test cases

   632     LOCAL_ASSERT( ETrue );

   633     return KErrNone;

   634     }

   635 

   636 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnErrorL(  )

   637     {

   638     // Will be tested in Parse test cases

   639     LOCAL_ASSERT( ETrue );

   640     return KErrNone;

   641     }

   642 

   643 TInt CSenFragmentTester::MT_CSenDomFragmentBase_GetExtendedInterfaceL(  )

   644     {

   645     // Will be tested in Parse test cases

   646     LOCAL_ASSERT( ETrue );

   647     return KErrNone;

   648     }

   649 

   650 TInt CSenFragmentTester::MT_CSenDomFragmentBase_ContentLL(  )

   651     {

   652     RSenDocument document = RSenDocument::NewL();

   653     CleanupClosePushL(document);

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

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

   656     

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

   658     CleanupStack::PushL(pFragment);

   659     

   660     TPtrC8 content = pFragment->ContentL();

   661     LOCAL_ASSERT( content == _L8("<Element/>") );

   662     

   663     CleanupStack::PopAndDestroy(pFragment);

   664     CleanupStack::PopAndDestroy(&document);

   665     return KErrNone;

   666     }

   667 

   668 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NamespaceL(  )

   669     {

   670     RStringPool stringPool;

   671     stringPool.OpenL();

   672     CleanupClosePushL(stringPool);

   673     

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

   675     CleanupClosePushL(nsUriRString);

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

   677     CleanupClosePushL(nsPrefixRString);

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

   679     CleanupClosePushL(localNameRString);

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

   681     CleanupClosePushL(valueRString);

   682     

   683     RAttribute attribute;

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

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

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

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

   688     // attribute took copies of all RStrings

   689     // => All RStrings can be destroyed

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

   691                                     // valueRString

   692     CleanupClosePushL(attribute);

   693 

   694     RAttributeArray attrArray;

   695     // append the namespace attribute (declaration)

   696     attrArray.AppendL(attribute);

   697     CleanupClosePushL(attrArray);

   698     

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

   700                                                                _L8("Test"),

   701                                                                _L8("t"),

   702                                                                attrArray);

   703     CleanupStack::PushL(pFragment);

   704     

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

   706     LOCAL_ASSERT( ns.Uri() == _L8("nsuri") );

   707 

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

   709     LOCAL_ASSERT( ns2.IsNull() );

   710     

   711     CleanupStack::PopAndDestroy(pFragment);

   712     CleanupStack::PopAndDestroy(); // attribute

   713     CleanupStack::PopAndDestroy(); // attrArray

   714     CleanupStack::PopAndDestroy(); // stringPool    

   715     return KErrNone;

   716     }

   717 

   718 TInt CSenFragmentTester::MT_CSenDomFragmentBase_ResetContentLL(  )

   719     {

   720     RSenDocument document = RSenDocument::NewL();

   721     CleanupClosePushL(document);

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

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

   724     

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

   726     CleanupStack::PushL(pFragment);

   727     

   728     // Test that CSenFragmentBase has content before reset

   729     TPtrC8 content = pFragment->ContentL();

   730     LOCAL_ASSERT( content == _L8("Content") );

   731     

   732     pFragment->ResetContentL();

   733     

   734     // Test that CSenFragmentBase has no content after reset

   735     TPtrC8 content2 = pFragment->ContentL();

   736     LOCAL_ASSERT( content2 == KNullDesC8 );

   737     

   738     CleanupStack::PopAndDestroy(pFragment);

   739     CleanupStack::PopAndDestroy(&document);

   740     return KErrNone;

   741     }

   742 

   743 TInt CSenFragmentTester::MT_CSenDomFragmentBase_LocalNameL(  )

   744     {

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

   746                                                                _L8("Test"),

   747                                                                _L8("t"));

   748     CleanupStack::PushL(pFragment);

   749     TPtrC8 localName = pFragment->LocalName();

   750     LOCAL_ASSERT( localName == _L8("Test") );

   751     CleanupStack::PopAndDestroy(pFragment);

   752     return KErrNone;

   753     }

   754 

   755 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NsUriL(  )

   756     {

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

   758                                                                _L8("Test"),

   759                                                                _L8("t"));

   760     CleanupStack::PushL(pFragment);

   761     TPtrC8 localName = pFragment->NsUri();

   762     LOCAL_ASSERT( localName == _L8("NsUri") );

   763     CleanupStack::PopAndDestroy(pFragment);

   764     return KErrNone;

   765     }

   766 

   767 TInt CSenFragmentTester::MT_CSenDomFragmentBase_NsPrefixL(  )

   768     {

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

   770                                                                _L8("Test"),

   771                                                                _L8("t"));

   772     CleanupStack::PushL(pFragment);

   773     TPtrC8 localName = pFragment->NsPrefix();

   774     LOCAL_ASSERT( localName == _L8("t") );

   775     CleanupStack::PopAndDestroy(pFragment);

   776     return KErrNone;

   777     }

   778 

   779 TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsElementLL(  )

   780     {

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

   782                                                                _L8("Test"),

   783                                                                _L8("t"));

   784     CleanupStack::PushL(pFragment);

   785     TXmlEngElement element = pFragment->AsElementL();

   786     RBuf8 buffer;

   787     CleanupClosePushL(buffer);

   788     element.OuterXmlL(buffer);

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

   790     LOCAL_ASSERT( buffer == _L8("<t:Test xmlns:t=\"NsUri\"/>") );

   791     CleanupStack::PopAndDestroy(&buffer);

   792     CleanupStack::PopAndDestroy(pFragment);

   793     return KErrNone;

   794     }

   795 

   796 TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsDocumentLL(  )

   797     {

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

   799                                                                _L8("Test"),

   800                                                                _L8("t"));

   801     CleanupStack::PushL(pFragment);

   802     RSenDocument document = pFragment->AsDocumentL();

   803     TXmlEngElement element = document.DocumentElement();

   804     

   805     TXmlEngSerializationOptions options;

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

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

   808     //   encoding="..."

   809     //   standalone="..."

   810     // ?>

   811     options.iOptions = options.iOptions |

   812                        TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;

   813     RBuf8 asXml;

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

   815     CleanupClosePushL(asXml);

   816     

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

   818     LOCAL_ASSERT( asXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") );

   819 

   820     CleanupStack::PopAndDestroy(&asXml);

   821     CleanupStack::PopAndDestroy(pFragment);

   822     return KErrNone;

   823     }

   824 

   825 TInt CSenFragmentTester::MT_CSenDomFragmentBase_ExtractElementL(  )

   826     {

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

   828                                                                _L8("Test"),

   829                                                                _L8("t"));

   830     CleanupStack::PushL(pFragment);

   831     TXmlEngElement element = pFragment->ExtractElement();

   832     LOCAL_ASSERT( element.Name() == _L8("Test") );

   833     element.Remove();

   834     CleanupStack::PopAndDestroy(pFragment);    

   835     return KErrNone;

   836     }

   837 

   838 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingLL(  )

   839     {

   840     // Will be tested in Parse test cases

   841     LOCAL_ASSERT( ETrue );

   842     return KErrNone;

   843     }

   844 

   845 TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingL_1L(  )

   846     {

   847     // Will be tested in Parse test cases

   848     LOCAL_ASSERT( ETrue );

   849     return KErrNone;

   850     }

   851 

   852 TInt CSenFragmentTester::MT_CSenDomFragmentBase_SetOwnerL(  )

   853     {

   854     // Will be tested in Parse test cases

   855     LOCAL_ASSERT( ETrue );

   856     return KErrNone;

   857     }

   858 

   859 TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlUnicodeLL(  )

   860     {

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

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

   863     CleanupStack::PushL(pFragment);

   864     TXmlEngElement element = pFragment->AsElementL();

   865     

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

   867 

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

   869     

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

   871     CleanupStack::PushL(pAsXml);

   872     LOCAL_ASSERT( *pAsXml == _L("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );

   873     CleanupStack::PopAndDestroy(pAsXml);

   874     CleanupStack::PopAndDestroy(pFragment);

   875     return KErrNone;

   876     }

   877 

   878 TInt CSenFragmentTester::MT_CSenDomFragmentBase_WriteAsXMLToLL(  )

   879     {

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

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

   882     CleanupStack::PushL(pFragment);

   883     TXmlEngElement element = pFragment->AsElementL();

   884     

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

   886 

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

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

   889     CleanupStack::PushL(pBuf);

   890     RBufWriteStream bufWs(*pBuf);

   891     CleanupClosePushL(bufWs);

   892     pFragment->WriteAsXMLToL(bufWs);

   893 

   894 

   895     LOCAL_ASSERT( pBuf->Ptr(0) == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );

   896     

   897     CleanupStack::PopAndDestroy(&bufWs);

   898     CleanupStack::PopAndDestroy(pBuf);

   899     

   900     CleanupStack::PopAndDestroy(pFragment);

   901     return KErrNone;

   902     }

   903 

   904 TInt CSenFragmentTester::MT_CSenDomFragmentBase_ConsistsOfLL(  )

   905     {

   906     TDomUtils domUtils;

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

   908     CleanupStack::PushL(pFragment);

   909     TXmlEngElement element = pFragment->AsElementL();

   910     

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

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

   913     //elementchild1.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   914     

   915     domUtils.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   916 

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

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

   919     //elementchild2.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   920     domUtils.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   921 

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

   923 

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

   925     CleanupStack::PushL(pFragment2);

   926     TXmlEngElement element2 = pFragment2->AsElementL();

   927     

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

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

   930     //elementchild22.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   931     domUtils.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   932 

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

   934 

   935     // ConsistOfL should return ETrue because

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

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

   938     // elementchild2.

   939     LOCAL_ASSERT( pFragment->ConsistsOfL(*pFragment2) );

   940 

   941     // ConsistOfL should return EFalse because

   942     // Even though root elements of both fragments match

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

   944     //

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

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

   947     LOCAL_ASSERT( !pFragment2->ConsistsOfL(*pFragment) );

   948     CleanupStack::PopAndDestroy(pFragment2);

   949 

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

   951     CleanupStack::PushL(pFragment3);

   952     TXmlEngElement element3 = pFragment3->AsElementL();

   953     

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

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

   956     //elementchild32.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   957     domUtils.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));

   958 

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

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

   961     

   962     // ConsistOfL should return EFalse because

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

   964     // to any child element of pFragment.

   965     LOCAL_ASSERT( !pFragment->ConsistsOfL(*pFragment3) );

   966     CleanupStack::PopAndDestroy(pFragment3);

   967     

   968     CleanupStack::PopAndDestroy(pFragment);

   969     return KErrNone;

   970     }

   971 

   972 TInt CSenFragmentTester::MT_CSenDomFragmentBase_SetContentHandlerL(  )

   973     {

   974     // Will be tested in Parse test cases

   975     LOCAL_ASSERT( ETrue );

   976     return KErrNone;

   977     }

   978 

   979 TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing1L(  )

   980     {

   981     // Parsing of XML document to CSenDomFragmentBase

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

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

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

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

   986 <Element3>Content3</Element3>\

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

   988 

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

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

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

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

   993     // for the first time.

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

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

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

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

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

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

  1000 

  1001     // When EReportNamespaceMapping is enabled all the namespace declarations

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

  1003     // XML document.

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

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

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

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

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

  1009     // CSenDomFragmentBase is created.

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

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

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

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

  1014 <Element3>Content3</Element3>\

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

  1016     

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

  1018 	

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

  1020     CleanupStack::PushL(pFragment);

  1021 	

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

  1023 	

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

  1025 	CleanupStack::PushL(pAsXml);

  1026 

  1027     LOCAL_ASSERT( *pAsXml == KOutputString1 );

  1028 

  1029     CleanupStack::PopAndDestroy(pAsXml);

  1030     CleanupStack::PopAndDestroy(pFragment);

  1031 /*

  1032 	pParser->EnableFeature(EReportNamespaceMapping);

  1033 	//tma

  1034 	pParser->DisableFeature(EReportNamespaceMapping);

  1035 	TBool fEneabled(EFalse);

  1036 	fEneabled = pParser->IsFeatureEnabled(EReportNamespaceMapping);

  1037 	LOCAL_ASSERT( fEneabled == EFalse);

  1038 	pParser->EnableFeature(EReportNamespaceMapping);

  1039 	//tma

  1040 */	

  1041 	pParser->EnableFeature(EReportNamespaceMapping);

  1042 	

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

  1044     CleanupStack::PushL(pFragment2);

  1045 

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

  1047 	

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

  1049 	CleanupStack::PushL(pAsXml2);

  1050 	                   

  1051     LOCAL_ASSERT( *pAsXml2 == KOutputString2 );

  1052     

  1053     CleanupStack::PopAndDestroy(pAsXml2);

  1054     CleanupStack::PopAndDestroy(pFragment2);

  1055 

  1056     CleanupStack::PopAndDestroy(pParser);

  1057     return KErrNone;

  1058     }

  1059     

  1060 TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing2L(  )

  1061     {

  1062     // Parsing of XML document to CSenDomFragmentBase which uses

  1063     // delegation.

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

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

  1066 <DelegateFragment>DelegateContent</DelegateFragment>\

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

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

  1069 

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

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

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

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

  1074     // for the first time.

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

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

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

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

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

  1080 

  1081     // When EReportNamespaceMapping is enabled all the namespace declarations

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

  1083     // XML document.

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

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

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

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

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

  1089 <DelegateFragment>DelegateContent</DelegateFragment>\

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

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

  1092      

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

  1094 	

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

  1096     CleanupStack::PushL(pFragment);

  1097 	

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

  1099 	

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

  1101 	CleanupStack::PushL(pAsXml);

  1102     LOCAL_ASSERT( *pAsXml == KOutputString1 );

  1103     CleanupStack::PopAndDestroy(pAsXml);

  1104     

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

  1106     HBufC8* pDelegateAsXml = delegate.AsXmlL();

  1107     CleanupStack::PushL(pDelegateAsXml);

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

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

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

  1111     LOCAL_ASSERT( *pDelegateAsXml ==

  1112                  _L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") );

  1113     CleanupStack::PopAndDestroy(pDelegateAsXml);

  1114     

  1115     CleanupStack::PopAndDestroy(pFragment);

  1116 

  1117 	pParser->EnableFeature(EReportNamespaceMapping);

  1118 	

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

  1120     CleanupStack::PushL(pFragment2);

  1121 

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

  1123 	

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

  1125 	CleanupStack::PushL(pAsXml2);

  1126     LOCAL_ASSERT( *pAsXml2 == KOutputString2 );

  1127     CleanupStack::PopAndDestroy(pAsXml2);

  1128     

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

  1130     HBufC8* pDelegateAsXml2 = delegate2.AsXmlL();

  1131     CleanupStack::PushL(pDelegateAsXml2);

  1132     LOCAL_ASSERT( *pDelegateAsXml2 ==

  1133                  _L8("<DelegateFragment>DelegateContent</DelegateFragment>") );

  1134     CleanupStack::PopAndDestroy(pDelegateAsXml2);