websrv_pub/xml_fragment_api/tsrc/senfragmentTester/src/SenFragmentTesterBlocks.cpp
/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: ?Description
*
*/
// [INCLUDE FILES] - do not remove
#include <e32svr.h>
#include <StifParser.h>
#include <StifTestInterface.h>
#include "SenFragmentTester.h"
// EXTERNAL INCLUDES
#include <SenDomFragmentBase.h>
#include <SenFragmentBase.h>
#include <SenParser.h>
#include <RSenDocument.h>
#include <xmlengdomutils.h>
#if defined( __SERIES60_31__ ) || (!defined( __SERIES60_30__ ) && defined( SYMBIAN_SWI_POST_INSTALL_REVOCATION) )
#include <xml/matchdata.h>
#endif
#include <xml/parserfeature.h> // for TParserFeature enumeration
#include <xmlengserializationoptions.h> // needed for TSerializationOptions
#include <xmlengbinarycontainer.h>
#include <s32mem.h>
#include <xmlengdom.h>
// INTERNAL INCLUDES
#include "maindomfragment.h"
#include "mainfragment.h"
// EXTERNAL DATA STRUCTURES
//extern ?external_data;
// EXTERNAL FUNCTION PROTOTYPES
//extern ?external_function( ?arg_type,?arg_type );
// CONSTANTS
//const ?type ?constant_var = ?constant;
// MACROS
//#define ?macro ?macro_def
#define LOCAL_ASSERT(expression) {if(!(expression)){return KErrArgument;}}
// LOCAL CONSTANTS AND MACROS
//const ?type ?constant_var = ?constant;
//#define ?macro_name ?macro_def
// MODULE DATA STRUCTURES
//enum ?declaration
//typedef ?declaration
// LOCAL FUNCTION PROTOTYPES
//?type ?function_name( ?arg_type, ?arg_type );
// FORWARD DECLARATIONS
//class ?FORWARD_CLASSNAME;
// ============================= LOCAL FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// ?function_name ?description.
// ?description
// Returns: ?value_1: ?description
// ?value_n: ?description_line1
// ?description_line2
// -----------------------------------------------------------------------------
//
/*
?type ?function_name(
?arg_type arg, // ?description
?arg_type arg) // ?description
{
?code // ?comment
// ?comment
?code
}
*/
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CSenFragmentTester::Delete
// Delete here all resources allocated and opened from test methods.
// Called from destructor.
// -----------------------------------------------------------------------------
//
void CSenFragmentTester::Delete()
{
}
// -----------------------------------------------------------------------------
// CSenFragmentTester::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CSenFragmentTester::RunMethodL(
CStifItemParser& aItem )
{
static TStifFunctionInfo const KFunctions[] =
{
// First string is the function name used in TestScripter script file.
// Second is the actual implementation member function.
ENTRY("SDFB-NewL-test_CSenDomFragmentBase_NewL", MT_CSenDomFragmentBase_NewLL),
ENTRY("SDFB-NewL1-test_CSenDomFragmentBase_NewL", MT_CSenDomFragmentBase_NewL_1L),
ENTRY("SDFB-NewL2-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_2L),
ENTRY("SDFB-NewL3-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_3L),
ENTRY("SDFB-NewL4-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_4L),
ENTRY("SDFB-NewL5-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_5L),
ENTRY("SDFB-NewL6-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_6L),
ENTRY("SDFB-NewL7-test_CSenDomFragmentBase_NewL", CSenFragmentTester::MT_CSenDomFragmentBase_NewL_7L),
ENTRY("SDFB-ExpandL-test_CSenDomFragmentBase_ExpandL", CSenFragmentTester::MT_CSenDomFragmentBase_ExpandLL),
ENTRY("SDFB-OnResumeParsingFromL-test_CSenDomFragmentBase_OnResumeParsingFromL", CSenFragmentTester::MT_CSenDomFragmentBase_OnResumeParsingFromLL),
ENTRY("SDFB-AddAttributesL-test_CSenDomFragmentBase_AddAttributesL", CSenFragmentTester::MT_CSenDomFragmentBase_AddAttributesLL),
ENTRY("SDFB-AsXmlL-test_CSenDomFragmentBase_AsXmlL", CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlLL),
ENTRY("SDFB-OnStartElementL-test_CSenDomFragmentBase_OnStartElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnStartElementLL),
ENTRY("SDFB-OnContentL-test_CSenDomFragmentBase_OnContentL", CSenFragmentTester::MT_CSenDomFragmentBase_OnContentLL),
ENTRY("SDFB-OnWriteStartElementL-test_CSenDomFragmentBase_OnWriteStartElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteStartElementLL),
ENTRY("SDFB-OnWriteEndElementL-test_CSenDomFragmentBase_OnWriteEndElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteEndElementLL),
ENTRY("SDFB-OnEndElementL-test_CSenDomFragmentBase_OnEndElementL", CSenFragmentTester::MT_CSenDomFragmentBase_OnEndElementLL),
ENTRY("SDFB-OnStartDocumentL-test_CSenDomFragmentBase_OnStartDocumentL", CSenFragmentTester::MT_CSenDomFragmentBase_OnStartDocumentLL),
ENTRY("SDFB-OnEndDocumentL-test_CSenDomFragmentBase_OnEndDocumentL", CSenFragmentTester::MT_CSenDomFragmentBase_OnEndDocumentLL),
ENTRY("SDFB-OnStartPrefixMappingL-test_CSenDomFragmentBase_OnStartPrefixMappingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnStartPrefixMappingLL),
ENTRY("SDFB-OnEndPrefixMappingL-test_CSenDomFragmentBase_OnEndPrefixMappingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnEndPrefixMappingLL),
ENTRY("SDFB-OnIgnorableWhiteSpaceL-test_CSenDomFragmentBase_OnIgnorableWhiteSpaceL", CSenFragmentTester::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL),
ENTRY("SDFB-OnSkippedEntityL-test_CSenDomFragmentBase_OnSkippedEntityL", CSenFragmentTester::MT_CSenDomFragmentBase_OnSkippedEntityLL),
ENTRY("SDFB-OnProcessingInstructionL-test_CSenDomFragmentBase_OnProcessingInstructionL", CSenFragmentTester::MT_CSenDomFragmentBase_OnProcessingInstructionLL),
ENTRY("SDFB-OnError-test_CSenDomFragmentBase_OnError", CSenFragmentTester::MT_CSenDomFragmentBase_OnErrorL),
ENTRY("SDFB-GetExtendedInterface-test_CSenDomFragmentBase_GetExtendedInterface", CSenFragmentTester::MT_CSenDomFragmentBase_GetExtendedInterfaceL),
ENTRY("SDFB-ContentL-test_CSenDomFragmentBase_ContentL", CSenFragmentTester::MT_CSenDomFragmentBase_ContentLL),
ENTRY("SDFB-Namespace-test_CSenDomFragmentBase_Namespace", CSenFragmentTester::MT_CSenDomFragmentBase_NamespaceL),
ENTRY("SDFB-ResetContentL-test_CSenDomFragmentBase_ResetContentL", CSenFragmentTester::MT_CSenDomFragmentBase_ResetContentLL),
ENTRY("SDFB-LocalName-test_CSenDomFragmentBase_LocalName", CSenFragmentTester::MT_CSenDomFragmentBase_LocalNameL),
ENTRY("SDFB-NsUri-test_CSenDomFragmentBase_NsUri", CSenFragmentTester::MT_CSenDomFragmentBase_NsUriL),
ENTRY("SDFB-NsPrefix-test_CSenDomFragmentBase_NsPrefix", CSenFragmentTester::MT_CSenDomFragmentBase_NsPrefixL),
ENTRY("SDFB-AsElementL-test_CSenDomFragmentBase_AsElementL", CSenFragmentTester::MT_CSenDomFragmentBase_AsElementLL),
ENTRY("SDFB-AsDocumentL-test_CSenDomFragmentBase_AsDocumentL", CSenFragmentTester::MT_CSenDomFragmentBase_AsDocumentLL),
ENTRY("SDFB-ExtractElement-test_CSenDomFragmentBase_ExtractElement", CSenFragmentTester::MT_CSenDomFragmentBase_ExtractElementL),
ENTRY("SDFB-OnDelegateParsingL-test_CSenDomFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingLL),
ENTRY("SDFB-OnDelegateParsingL-test_CSenDomFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingL_1L),
ENTRY("SDFB-SetOwner-test_CSenDomFragmentBase_SetOwner", CSenFragmentTester::MT_CSenDomFragmentBase_SetOwnerL),
ENTRY("SDFB-AsXmlUnicodeL-test_CSenDomFragmentBase_AsXmlUnicodeL", CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlUnicodeLL),
ENTRY("SDFB-WriteAsXMLToL-test_CSenDomFragmentBase_WriteAsXMLToL", CSenFragmentTester::MT_CSenDomFragmentBase_WriteAsXMLToLL),
ENTRY("SDFB-ConsistsOfL-test_CSenDomFragmentBase_ConsistsOfL", CSenFragmentTester::MT_CSenDomFragmentBase_ConsistsOfLL),
ENTRY("SDFB-SetContentHandler-test_CSenDomFragmentBase_SetContentHandler", CSenFragmentTester::MT_CSenDomFragmentBase_SetContentHandlerL),
ENTRY("SDFB-Parsing-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing1L),
ENTRY("SDFB-Parsingdelegate-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing2L),
ENTRY("SDFB-Parsingnamespaces-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing3L),
ENTRY("SDFB-Parsingnestedelements-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing4L),
ENTRY("SDFB-Parsingnullednamespaces-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing5L),
ENTRY("SDFB-Parsingusingemptyfragment-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing6L),
ENTRY("SDFB-ParsingWSmessage-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing7L),
ENTRY("SDFB-Parsing2.WSmessage-test_CSenDomFragmentBase_Parsing", CSenFragmentTester::MT_CSenDomFragmentBase_Parsing8L),
ENTRY("SFB-NewL-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewLL),
ENTRY("SFB-NewL1-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_1L),
ENTRY("SFB-NewL2-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_2L),
ENTRY("SFB-NewL3-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_3L),
ENTRY("SFB-NewL4-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_4L),
ENTRY("SFB-NewL5-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_5L),
ENTRY("SFB-NewL6-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_6L),
ENTRY("SFB-NewL7-test_CSenFragmentBase_NewL", CSenFragmentTester::MT_CSenFragmentBase_NewL_7L),
ENTRY("SFB-OnStartElementL-test_CSenFragmentBase_OnStartElementL", CSenFragmentTester::MT_CSenFragmentBase_OnStartElementLL),
ENTRY("SFB-OnEndElementL-test_CSenFragmentBase_OnEndElementL", CSenFragmentTester::MT_CSenFragmentBase_OnEndElementLL),
ENTRY("SFB-OnStartDocumentL-test_CSenFragmentBase_OnStartDocumentL", CSenFragmentTester::MT_CSenFragmentBase_OnStartDocumentLL),
ENTRY("SFB-OnEndDocumentL-test_CSenFragmentBase_OnEndDocumentL", CSenFragmentTester::MT_CSenFragmentBase_OnEndDocumentLL),
ENTRY("SFB-OnContentL-test_CSenFragmentBase_OnContentL", CSenFragmentTester::MT_CSenFragmentBase_OnContentLL),
ENTRY("SFB-OnStartPrefixMappingL-test_CSenFragmentBase_OnStartPrefixMappingL", CSenFragmentTester::MT_CSenFragmentBase_OnStartPrefixMappingLL),
ENTRY("SFB-OnEndPrefixMappingL-test_CSenFragmentBase_OnEndPrefixMappingL", CSenFragmentTester::MT_CSenFragmentBase_OnEndPrefixMappingLL),
ENTRY("SFB-OnIgnorableWhiteSpaceL-test_CSenFragmentBase_OnIgnorableWhiteSpaceL", CSenFragmentTester::MT_CSenFragmentBase_OnIgnorableWhiteSpaceLL),
ENTRY("SFB-OnSkippedEntityL-test_CSenFragmentBase_OnSkippedEntityL", CSenFragmentTester::MT_CSenFragmentBase_OnSkippedEntityLL),
ENTRY("SFB-OnProcessingInstructionL-test_CSenFragmentBase_OnProcessingInstructionL", CSenFragmentTester::MT_CSenFragmentBase_OnProcessingInstructionLL),
ENTRY("SFB-OnError-test_CSenFragmentBase_OnError", CSenFragmentTester::MT_CSenFragmentBase_OnErrorL),
ENTRY("SFB-GetExtendedInterface-test_CSenFragmentBase_GetExtendedInterface", CSenFragmentTester::MT_CSenFragmentBase_GetExtendedInterfaceL),
ENTRY("SFB-ContentL-test_CSenFragmentBase_ContentL", CSenFragmentTester::MT_CSenFragmentBase_ContentLL),
ENTRY("SFB-Namespace-test_CSenFragmentBase_Namespace", CSenFragmentTester::MT_CSenFragmentBase_NamespaceL),
ENTRY("SFB-ResetContentL-test_CSenFragmentBase_ResetContentL", CSenFragmentTester::MT_CSenFragmentBase_ResetContentLL),
ENTRY("SFB-LocalName-test_CSenFragmentBase_LocalName", CSenFragmentTester::MT_CSenFragmentBase_LocalNameL),
ENTRY("SFB-NsUri-test_CSenFragmentBase_NsUri", CSenFragmentTester::MT_CSenFragmentBase_NsUriL),
ENTRY("SFB-NsPrefix-test_CSenFragmentBase_NsPrefix", CSenFragmentTester::MT_CSenFragmentBase_NsPrefixL),
ENTRY("SFB-AsElementL-test_CSenFragmentBase_AsElementL", CSenFragmentTester::MT_CSenFragmentBase_AsElementLL),
ENTRY("SFB-AsDocumentL-test_CSenFragmentBase_AsDocumentL", CSenFragmentTester::MT_CSenFragmentBase_AsDocumentLL),
ENTRY("SFB-ExtractElement-test_CSenFragmentBase_ExtractElement", CSenFragmentTester::MT_CSenFragmentBase_ExtractElementL),
ENTRY("SFB-OnDelegateParsingL-test_CSenFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenFragmentBase_OnDelegateParsingLL),
ENTRY("SFB-OnDelegateParsingL-test_CSenFragmentBase_OnDelegateParsingL", CSenFragmentTester::MT_CSenFragmentBase_OnDelegateParsingL_1L),
ENTRY("SFB-SetOwner-test_CSenFragmentBase_SetOwner", CSenFragmentTester::MT_CSenFragmentBase_SetOwnerL),
ENTRY("SFB-OnResumeParsingFromL-test_CSenFragmentBase_OnResumeParsingFromL", CSenFragmentTester::MT_CSenFragmentBase_OnResumeParsingFromLL),
ENTRY("SFB-OnWriteStartElementL-test_CSenFragmentBase_OnWriteStartElementL", CSenFragmentTester::MT_CSenFragmentBase_OnWriteStartElementLL),
ENTRY("SFB-OnWriteEndElementL-test_CSenFragmentBase_OnWriteEndElementL", CSenFragmentTester::MT_CSenFragmentBase_OnWriteEndElementLL),
ENTRY("SFB-AsXmlUnicodeL-test_CSenFragmentBase_AsXmlUnicodeL", CSenFragmentTester::MT_CSenFragmentBase_AsXmlUnicodeLL),
ENTRY("SFB-AsXmlL-test_CSenFragmentBase_AsXmlL", CSenFragmentTester::MT_CSenFragmentBase_AsXmlLL),
ENTRY("SFB-WriteAsXMLToL-test_CSenFragmentBase_WriteAsXMLToL", CSenFragmentTester::MT_CSenFragmentBase_WriteAsXMLToLL),
ENTRY("SFB-ConsistsOfL-test_CSenFragmentBase_ConsistsOfL", CSenFragmentTester::MT_CSenFragmentBase_ConsistsOfLL),
ENTRY("SFB-SetContentHandler-test_CSenFragmentBase_SetContentHandler", CSenFragmentTester::MT_CSenFragmentBase_SetContentHandlerL),
ENTRY("SFB-Parsing-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing1L),
ENTRY("SFB-Parsingdelegate-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing2L),
ENTRY("SFB-Parsingnamespaces-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing3L),
ENTRY("SFB-Parsingnestedelements-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing4L),
ENTRY("SFB-ParsingelementinsideDOMtree-test_CSenFragmentBase_Parsing", CSenFragmentTester::MT_CSenFragmentBase_Parsing5L),
ENTRY("CSP-NewL-test_CSenParser_NewL", CSenFragmentTester::MT_CSenParser_NewLL),
ENTRY("CSP-NewLC-test_CSenParser_NewLC", CSenFragmentTester::MT_CSenParser_NewLCL),
ENTRY("CSP-NewL1-test_CSenParser_NewL", CSenFragmentTester::MT_CSenParser_NewL_1L),
ENTRY("CSP-NewLC1-test_CSenParser_NewLC", CSenFragmentTester::MT_CSenParser_NewLC_1L),
ENTRY("CSP-NewL2-test_CSenParser_NewL", CSenFragmentTester::MT_CSenParser_NewL_2L),
ENTRY("CSP-NewLC2-test_CSenParser_NewLC", CSenFragmentTester::MT_CSenParser_NewLC_2L),
ENTRY("RSD-NewL-test_RSenDocument_NewL", MT_RSenDocument_NewLL),
ENTRY("RSD-NewLC-test_RSenDocument_NewLC", MT_RSenDocument_NewLCL),
ENTRY("RSD-NewL2-test_RSenDocument_NewL", MT_RSenDocument_NewL_1L),
ENTRY("RSD-NewLC2-test_RSenDocument_NewLC", MT_RSenDocument_NewLC_1L),
ENTRY("RSD-Copy-test_RSenDocument_Copy", MT_RSenDocument_CopyL),
ENTRY("RSD-Close-test_RSenDocument_Close", MT_RSenDocument_CloseL),
ENTRY("RSD-Destroy-test_RSenDocument_Destroy", MT_RSenDocument_DestroyL),
};
const TInt count = sizeof( KFunctions ) /
sizeof( TStifFunctionInfo );
return RunInternalL( KFunctions, count, aItem );
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewLL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL();
delete pFragment;
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_1L( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
element.SetEscapedTextL(_L8("<Element/>"));
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
// Test that when CSenDomFragmentBase is serialized '<' and '>' characters
// are encoded (as all basic entities in content should be).
LOCAL_ASSERT( *pAsXml == _L8("<Test><Element/></Test>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_2L( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_3L( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"));
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_4L( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_5L( )
{
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open( nsUriRString, nsPrefixRString, localNameRString,
valueRString );
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"),
attrArray);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_6L( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString);
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"),
attrArray,
parentElement);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
RBuf8 buffer;
parentElement.OuterXmlL(buffer);
LOCAL_ASSERT( buffer == _L8("<Parent><t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );
buffer.Close();
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NewL_7L( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString);
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8(""),
attrArray,
parentElement,
document);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
RBuf8 buffer;
parentElement.OuterXmlL(buffer);
LOCAL_ASSERT( buffer == _L8("<Parent><Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );
buffer.Close();
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_ExpandLL( )
{
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnResumeParsingFromLL( )
{
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_AddAttributesLL( )
{
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString);
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(4); // nsUriRString, nsPrefixRString, localNameRString,
// valueRString
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
pFragment->AddAttributesL(attrArray);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlLL( )
{
// Test serialization of Dom tree which has two child elements
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnStartElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnContentLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteStartElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnWriteEndElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnEndElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnStartDocumentLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnEndDocumentLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnStartPrefixMappingLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnEndPrefixMappingLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnSkippedEntityLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnProcessingInstructionLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnErrorL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_GetExtendedInterfaceL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_ContentLL( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
element.SetEscapedTextL(_L8("<Element/>"));
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element);
CleanupStack::PushL(pFragment);
TPtrC8 content = pFragment->ContentL();
LOCAL_ASSERT( content == _L8("<Element/>") );
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NamespaceL( )
{
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(stringPool.OpenStringL(_L8("nsuri")),
stringPool.OpenStringL(_L8("pr")),
stringPool.OpenStringL(_L8("LocalName")),
stringPool.OpenStringL(_L8("Value")) );
// attribute took copies of all RStrings
// => All RStrings can be destroyed
CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString,
// valueRString
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"),
attrArray);
CleanupStack::PushL(pFragment);
TXmlEngNamespace ns = pFragment->Namespace(_L8("pr"));
LOCAL_ASSERT( ns.Uri() == _L8("nsuri") );
TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x"));
LOCAL_ASSERT( ns2.IsNull() );
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(); // attribute
CleanupStack::PopAndDestroy(); // attrArray
CleanupStack::PopAndDestroy(); // stringPool
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_ResetContentLL( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
element.SetEscapedTextL(_L8("Content"));
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element);
CleanupStack::PushL(pFragment);
// Test that CSenFragmentBase has content before reset
TPtrC8 content = pFragment->ContentL();
LOCAL_ASSERT( content == _L8("Content") );
pFragment->ResetContentL();
// Test that CSenFragmentBase has no content after reset
TPtrC8 content2 = pFragment->ContentL();
LOCAL_ASSERT( content2 == KNullDesC8 );
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_LocalNameL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TPtrC8 localName = pFragment->LocalName();
LOCAL_ASSERT( localName == _L8("Test") );
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NsUriL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TPtrC8 localName = pFragment->NsUri();
LOCAL_ASSERT( localName == _L8("NsUri") );
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_NsPrefixL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TPtrC8 localName = pFragment->NsPrefix();
LOCAL_ASSERT( localName == _L8("t") );
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsElementLL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
RBuf8 buffer;
CleanupClosePushL(buffer);
element.OuterXmlL(buffer);
// Serialized element should contain all the Fragment data as XML.
LOCAL_ASSERT( buffer == _L8("<t:Test xmlns:t=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(&buffer);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsDocumentLL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
RSenDocument document = pFragment->AsDocumentL();
TXmlEngElement element = document.DocumentElement();
TXmlEngSerializationOptions options;
// Omit following declarations from the beginning of XML Document:
// <?xml version=\"1.0\...
// encoding="..."
// standalone="..."
// ?>
options.iOptions = options.iOptions |
TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
RBuf8 asXml;
document.SaveL(asXml, element, options);
CleanupClosePushL(asXml);
// Serialized document should contain all the Fragment data as XML.
LOCAL_ASSERT( asXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(&asXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_ExtractElementL( )
{
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->ExtractElement();
LOCAL_ASSERT( element.Name() == _L8("Test") );
element.Remove();
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_OnDelegateParsingL_1L( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_SetOwnerL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_AsXmlUnicodeLL( )
{
// Test serialization of Dom tree which has two child elements
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
HBufC* pAsXml = pFragment->AsXmlUnicodeL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_WriteAsXMLToLL( )
{
// Test serialization of Dom tree which has two child elements
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
CBufFlat* pBuf = CBufFlat::NewL(200);
CleanupStack::PushL(pBuf);
RBufWriteStream bufWs(*pBuf);
CleanupClosePushL(bufWs);
pFragment->WriteAsXMLToL(bufWs);
LOCAL_ASSERT( pBuf->Ptr(0) == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );
CleanupStack::PopAndDestroy(&bufWs);
CleanupStack::PopAndDestroy(pBuf);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_ConsistsOfLL( )
{
TDomUtils domUtils;
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild"));
elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild1.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild"));
elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild2.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment2);
TXmlEngElement element2 = pFragment2->AsElementL();
TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild"));
elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild22.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
// ConsistOfL should return ETrue because
// root elements of both fragments match and the only element
// of pFragment2 = elementchild22 is exactly the same element as
// elementchild2.
LOCAL_ASSERT( pFragment->ConsistsOfL(*pFragment2) );
// ConsistOfL should return EFalse because
// Even though root elements of both fragments match
// there is extra element (= elementchild1) in pFragment.
//
// elementchild1 (of pFragment) can not be found from pFragment2
// and because of that pFragment2 does not consist of pFragment.
LOCAL_ASSERT( !pFragment2->ConsistsOfL(*pFragment) );
CleanupStack::PopAndDestroy(pFragment2);
CSenDomFragmentBase* pFragment3 = CSenDomFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment3);
TXmlEngElement element3 = pFragment3->AsElementL();
TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild"));
elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild32.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
elementchild32.SetEscapedTextL(_L8("Text"));
// ConsistOfL should return EFalse because
// elementchild32 has content ("Text") which doesn't match
// to any child element of pFragment.
LOCAL_ASSERT( !pFragment->ConsistsOfL(*pFragment3) );
CleanupStack::PopAndDestroy(pFragment3);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_SetContentHandlerL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing1L( )
{
// Parsing of XML document to CSenDomFragmentBase
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
<Element2 z=\"value4\">Content2</Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
// Default namespace declaration (xmlns="nsuri") from Parent element (Test)
// will be moved to all child elements (Element1, Element2, Element3 and
// Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
// the way CParser works <=> Namespaces are reported when namespaces are used
// for the first time.
_LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \
a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
<Element2 xmlns=\"nsuri\" z=\"value4\">Content2</Element2>\
<Element3 xmlns=\"nsuri\">Content3</Element3>\
<Element4 xmlns=\"nsuri\"/></a:Test>");
// When EReportNamespaceMapping is enabled all the namespace declarations
// are reported in exactly the same element as they are defined in parsed
// XML document.
// Note: The Order of namespace declarations in root element tag may change.
// Namespace declaration for root tag is created when fragment is created
// and because of that namespace declaration for root tag will be the first.
// In this particular case namespace declaration for prefix "a" will be
// the first namespace declaration because it is declared when
// CSenDomFragmentBase is created.
_LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
<Element2 z=\"value4\">Content2</Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString1 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
/*
pParser->EnableFeature(EReportNamespaceMapping);
//tma
pParser->DisableFeature(EReportNamespaceMapping);
TBool fEneabled(EFalse);
fEneabled = pParser->IsFeatureEnabled(EReportNamespaceMapping);
LOCAL_ASSERT( fEneabled == EFalse);
pParser->EnableFeature(EReportNamespaceMapping);
//tma
*/
pParser->EnableFeature(EReportNamespaceMapping);
CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment2);
pParser->ParseL(KInputString, *pFragment2);
HBufC8* pAsXml2 = pFragment2->AsXmlL();
CleanupStack::PushL(pAsXml2);
LOCAL_ASSERT( *pAsXml2 == KOutputString2 );
CleanupStack::PopAndDestroy(pAsXml2);
CleanupStack::PopAndDestroy(pFragment2);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing2L( )
{
// Parsing of XML document to CSenDomFragmentBase which uses
// delegation.
_LIT8(KInputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
<DelegateFragment>DelegateContent</DelegateFragment>\
<Element1 x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2></a:Test>");
// Default namespace declaration (xmlns="nsuri") from Parent element (Test)
// will be moved to all child elements (Element1, Element2, Element3 and
// Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
// the way CParser works <=> Namespaces are reported when namespaces are used
// for the first time.
_LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
a:x=\"value1\" b:z=\"value2\">\
<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>\
<Element1 xmlns=\"nsuri\" x=\"value4\">Content1</Element1>\
<Element2 xmlns=\"nsuri\">Content2</Element2></a:Test>");
// When EReportNamespaceMapping is enabled all the namespace declarations
// are reported in exactly the same element as they are defined in parsed
// XML document.
// Note: The Order of namespace declarations in root element tag may change.
// Namespace declaration for root tag is created when fragment is created
// and because of that namespace declaration for root tag will be the first.
_LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
<DelegateFragment>DelegateContent</DelegateFragment>\
<Element1 x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CMainDomFragment* pFragment = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString1 );
CleanupStack::PopAndDestroy(pAsXml);
CDelegateDomFragment& delegate = pFragment->DelegateFragment();
HBufC8* pDelegateAsXml = delegate.AsXmlL();
CleanupStack::PushL(pDelegateAsXml);
// Note: When EReportNamespaceMapping is _NOT_ enabled namespace declaration
// is added to delegate even though that namespace declaration was
// originally declared (but not used) in root element of parsed document.
LOCAL_ASSERT( *pDelegateAsXml ==
_L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") );
CleanupStack::PopAndDestroy(pDelegateAsXml);
CleanupStack::PopAndDestroy(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
CMainDomFragment* pFragment2 = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment2);
pParser->ParseL(KInputString, *pFragment2);
HBufC8* pAsXml2 = pFragment2->AsXmlL();
CleanupStack::PushL(pAsXml2);
LOCAL_ASSERT( *pAsXml2 == KOutputString2 );
CleanupStack::PopAndDestroy(pAsXml2);
CDelegateDomFragment& delegate2 = pFragment2->DelegateFragment();
HBufC8* pDelegateAsXml2 = delegate2.AsXmlL();
CleanupStack::PushL(pDelegateAsXml2);
LOCAL_ASSERT( *pDelegateAsXml2 ==
_L8("<DelegateFragment>DelegateContent</DelegateFragment>") );
CleanupStack::PopAndDestroy(pDelegateAsXml2);
CleanupStack::PopAndDestroy(pFragment2);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing3L( )
{
// Parsing of XML document to CSenDomFragmentBase
// In this test same namespaceuri is defined as default namespace in
// root element and 'c' prefixed namespace in Element2.
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
// Namespace declaration for prefix 'x' (and namespaceuri "nsuri")
// disappears from Element2 after parsing because default namespace
// declaration already declares namespace for uri "nsuri".
// => Double declaration for namespaceuri "nsuri" is not needed.
_LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing4L( )
{
// Parsing of XML document to CSenDomFragmentBase
// In this test nested elements (which have same name) are tested.
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
<Element1>Content</Element1>\
</Element1>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
_LIT8(KInputString2, "<Nested xmlns=\"nsuri\">\
<Nested attr=\"attrvalue\"><Nested><Nested>Content</Nested></Nested></Nested>\
</Nested>");
// Only namespace declaration order changes for output.
_LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
<Element1>Content</Element1>\
</Element1>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
pFragment = CSenDomFragmentBase::NewL(_L8("nsuri"),_L8("Nested"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString2, *pFragment);
pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KInputString2 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing5L( )
{
// Parsing of XML document to CSenDomFragmentBase
// In this test nulling of default namespace is tested.
/*
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns="" xmlns:c=\"nsuric\" c:x=\"value4\">\
<Element1 >Content</Element1>\
</Element1>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
*/
/*
// Only namespace declaration order changes for output.
_LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
<Element1>Content</Element1>\
</Element1>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
*/
CSenParser* pParser = CSenParser::NewLC();
/*CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);*/
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing6L( )
{
// Parsing of XML document to CSenDomFragmentBase
// when constructor CSenDomFragmentBase::NewL() is used.
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
<Element2 z=\"value4\">Content2</Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
// Default namespace declaration (xmlns="nsuri") from Parent element (Test)
// will be moved to all child elements (Element1, Element2, Element3 and
// Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
// the way CParser works <=> Namespaces are reported when namespaces are used
// for the first time.
_LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \
a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\
<Element2 xmlns=\"nsuri\" z=\"value4\">Content2</Element2>\
<Element3 xmlns=\"nsuri\">Content3</Element3>\
<Element4 xmlns=\"nsuri\"/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL();
CleanupStack::PushL(pFragment);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing7L( )
{
// Parsing of XML document to CSenDomFragmentBase
// when constructor CSenDomFragmentBase::NewL() is used.
_LIT8(KInputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<S:Header>\
<wsa:MessageID>URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
<wsa:To>http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
<wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
<wsse:UsernameToken>\
<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
<wsse:Password>jaszmn\\3</wsse:Password>\
</wsse:UsernameToken>\
</wsse:Security>\
</S:Header>\
<S:Body>\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference>\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>\
</S:Envelope>");
// Note: If EReportNamespaceMapping is not enabled output will be following:
// (Namespace declaration for prefix "wsa" jumps from root element to
// elements (MessageID, To, Action and EndpointReference) which actually
// use above mentioned prefix. <=> Root element Envelope does not use
// "wsa" prefix.)
_LIT8(KOutputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
<S:Header>\
<wsa:MessageID xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
<wsa:To xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
<wsa:Action xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
<wsse:UsernameToken>\
<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
<wsse:Password>jaszmn\\3</wsse:Password>\
</wsse:UsernameToken>\
</wsse:Security>\
</S:Header>\
<S:Body>\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>\
</S:Envelope>");
CSenParser* parser = CSenParser::NewLC();
//create a CSenDomFragment
CSenFragmentBase* pBase = CSenDomFragmentBase::NewL();
CleanupStack::PushL(pBase);
//do the parsing
parser->ParseL(KInputString, *pBase);
HBufC8* pAsXml = pBase->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pBase);
pBase = CSenDomFragmentBase::NewL();
CleanupStack::PushL(pBase);
//Enable NamespaceMapping to ensure that namespace declarations will
//remain in exactly the same place as in original XML document
parser->EnableFeature(EReportNamespaceMapping);
//do the parsing
parser->ParseL(KInputString, *pBase);
pAsXml = pBase->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KInputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pBase);
CleanupStack::PopAndDestroy(parser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenDomFragmentBase_Parsing8L( )
{
// Parsing of XML document to CSenDomFragmentBase
// when constructor CSenDomFragmentBase::NewL() is used.
_LIT8(KInputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<S:Header>\
<wsa:MessageID>URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
<wsa:To>http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
<wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
<wsse:UsernameToken>\
<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
<wsse:Password>jaszmn\\3</wsse:Password>\
</wsse:UsernameToken>\
</wsse:Security>\
</S:Header>\
<S:Body>\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference>\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>\
</S:Envelope>");
// Note: If EReportNamespaceMapping is not enabled output will be following:
// (Namespace declaration for prefix "wsa" jumps from root element to
// elements (MessageID, To, Action and EndpointReference) which actually
// use above mentioned prefix. <=> Root element Envelope does not use
// "wsa" prefix.)
_LIT8(KOutputString1, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>");
_LIT8(KOutputString2, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>");
CSenParser* parser = CSenParser::NewLC();
//create a CSenDomFragment
CSenFragmentBase* pBase = CSenDomFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
_L8("Body"),
_L8("S"));
CleanupStack::PushL(pBase);
//do the parsing
parser->ParseL(KInputString, *pBase);
HBufC8* pAsXml = pBase->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString1 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pBase);
pBase = CSenDomFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
_L8("Body"),
_L8("S"));
CleanupStack::PushL(pBase);
//Enable NamespaceMapping to ensure that namespace declarations will
//remain in exactly the same place as in original XML document
parser->EnableFeature(EReportNamespaceMapping);
//do the parsing
parser->ParseL(KInputString, *pBase);
pAsXml = pBase->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString2 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pBase);
CleanupStack::PopAndDestroy(parser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewLL( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
_LIT8(KElement, "<Element/>");
element.SetTextNoEncL(KElement);
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
// Test that when CSenFragmentBase is serialized '<' and '>' characters
// are NOT encoded => The content of CSenFragmentBase can include
// XML elements
LOCAL_ASSERT( *pAsXml == _L8("<Test><Element/></Test>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_1L( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_2L( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"));
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_3L( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_4L( )
{
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString );
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"),
attrArray);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_5L( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString);
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"),
attrArray,
parentElement);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
RBuf8 buffer;
parentElement.OuterXmlL(buffer);
LOCAL_ASSERT( buffer == _L8("<Parent><t:Test xmlns:t=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );
buffer.Close();
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_6L( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString);
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8(""),
attrArray,
parentElement,
document);
CleanupStack::PushL(pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
RBuf8 buffer;
parentElement.OuterXmlL(buffer);
LOCAL_ASSERT( buffer == _L8("<Parent><Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );
buffer.Close();
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NewL_7L( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent"));
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(nsUriRString, nsPrefixRString, localNameRString,
valueRString);
// attribute took ownership of all RStrings
// => All RStrings can be pop from CleanupStack
CleanupStack::Pop(&valueRString);
CleanupStack::Pop(&localNameRString);
CleanupStack::Pop(&nsPrefixRString);
CleanupStack::Pop(&nsUriRString);
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8(""),
attrArray,
parentElement,
document);
CleanupStack::PushL(pFragment);
RSenDocument doc = pFragment->AsDocumentL();
TXmlEngElement el = pFragment->AsElementL();
CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(el, doc);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PushL(pFragment2);
HBufC8* pAsXml = pFragment2->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/>") );
RBuf8 buffer;
parentElement.OuterXmlL(buffer);
LOCAL_ASSERT( buffer == _L8("<Parent><Test xmlns=\"NsUri\" xmlns:pr=\"nsuri\" pr:LocalName=\"Value\"/></Parent>") );
buffer.Close();
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment2);
CleanupStack::PopAndDestroy(&attrArray);
CleanupStack::PopAndDestroy(&attribute);
CleanupStack::PopAndDestroy(&stringPool);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnStartElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnEndElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnStartDocumentLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnEndDocumentLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnContentLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnStartPrefixMappingLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnEndPrefixMappingLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnIgnorableWhiteSpaceLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnSkippedEntityLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnProcessingInstructionLL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnErrorL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_GetExtendedInterfaceL( )
{
// There is no functionality in this method in CSenFragmentBase implementation
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_ContentLL( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
element.SetEscapedTextL(_L8("<Element/>"));
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element);
CleanupStack::PushL(pFragment);
TPtrC8 content = pFragment->ContentL();
LOCAL_ASSERT( content == _L8("<Element/>") );
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NamespaceL( )
{
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RString nsUriRString = stringPool.OpenStringL(_L8("nsuri"));
CleanupClosePushL(nsUriRString);
RString nsPrefixRString = stringPool.OpenStringL(_L8("pr"));
CleanupClosePushL(nsPrefixRString);
RString localNameRString = stringPool.OpenStringL(_L8("LocalName"));
CleanupClosePushL(localNameRString);
RString valueRString = stringPool.OpenStringL(_L8("Value"));
CleanupClosePushL(valueRString);
RAttribute attribute;
attribute.Open(stringPool.OpenStringL(_L8("nsuri")),
stringPool.OpenStringL(_L8("pr")),
stringPool.OpenStringL(_L8("LocalName")),
stringPool.OpenStringL(_L8("Value")) );
// attribute took copies of all RStrings
// => All RStrings can be destroyed
CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString,
// valueRString
CleanupClosePushL(attribute);
RAttributeArray attrArray;
// append the namespace attribute (declaration)
attrArray.AppendL(attribute);
CleanupClosePushL(attrArray);
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"),
attrArray);
CleanupStack::PushL(pFragment);
TXmlEngNamespace ns = pFragment->Namespace(_L8("pr"));
LOCAL_ASSERT( ns.Uri() == _L8("nsuri") );
TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x"));
LOCAL_ASSERT( ns2.IsUndefined() );
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(); // attribute
CleanupStack::PopAndDestroy(); // attrArray
CleanupStack::PopAndDestroy(); // stringPool
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_ResetContentLL( )
{
RSenDocument document = RSenDocument::NewL();
CleanupClosePushL(document);
TXmlEngElement element = document.CreateDocumentElementL(_L8("Test"));
element.SetEscapedTextL(_L8("Content"));
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element);
CleanupStack::PushL(pFragment);
// Test that CSenFragmentBase has content before reset
TPtrC8 content = pFragment->ContentL();
LOCAL_ASSERT( content == _L8("Content") );
pFragment->ResetContentL();
// Test that CSenFragmentBase has no content after reset
TPtrC8 content2 = pFragment->ContentL();
LOCAL_ASSERT( content2 == KNullDesC8 );
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(&document);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_LocalNameL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TPtrC8 localName = pFragment->LocalName();
LOCAL_ASSERT( localName == _L8("Test") );
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NsUriL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TPtrC8 localName = pFragment->NsUri();
LOCAL_ASSERT( localName == _L8("NsUri") );
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_NsPrefixL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TPtrC8 localName = pFragment->NsPrefix();
LOCAL_ASSERT( localName == _L8("t") );
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_AsElementLL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
RBuf8 buffer;
CleanupClosePushL(buffer);
element.OuterXmlL(buffer);
// Serialized element should contain all the Fragment data as XML.
LOCAL_ASSERT( buffer == _L8("<t:Test xmlns:t=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(&buffer);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_AsDocumentLL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
RSenDocument document = pFragment->AsDocumentL();
TXmlEngElement element = document.DocumentElement();
TXmlEngSerializationOptions options;
// Omit following declarations from the beginning of XML Document:
// <?xml version=\"1.0\...
// encoding="..."
// standalone="..."
// ?>
options.iOptions = options.iOptions |
TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
RBuf8 asXml;
document.SaveL(asXml, element, options);
CleanupClosePushL(asXml);
// Serialized document should contain all the Fragment data as XML.
LOCAL_ASSERT( asXml == _L8("<t:Test xmlns:t=\"NsUri\"/>") );
CleanupStack::PopAndDestroy(&asXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_ExtractElementL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"),
_L8("Test"),
_L8("t"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->ExtractElement();
LOCAL_ASSERT( element.Name() == _L8("Test") );
element.Remove();
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnDelegateParsingLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnDelegateParsingL_1L( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_SetOwnerL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnResumeParsingFromLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnWriteStartElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_OnWriteEndElementLL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_AsXmlUnicodeLL( )
{
// Test serialization of Dom tree which has two child elements
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
HBufC* pAsXml = pFragment->AsXmlUnicodeL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_AsXmlLL( )
{
// Test serialization of Dom tree which has two child elements
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_WriteAsXMLToLL( )
{
// Test serialization of Dom tree which has two child elements
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix"));
element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2"));
CBufFlat* pBuf = CBufFlat::NewL(200);
CleanupStack::PushL(pBuf);
RBufWriteStream bufWs(*pBuf);
CleanupClosePushL(bufWs);
pFragment->WriteAsXMLToL(bufWs);
LOCAL_ASSERT( pBuf->Ptr(0) == _L8("<Test xmlns:prefix=\"nsuri\"><prefix:Child xmlns:prefix2=\"nsuri2\"><prefix2:Child2/></prefix:Child></Test>") );
CleanupStack::PopAndDestroy(&bufWs);
CleanupStack::PopAndDestroy(pBuf);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_ConsistsOfLL( )
{
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
TXmlEngElement element = pFragment->AsElementL();
TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild"));
elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild1.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
TDomUtils domUtils;
domUtils.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild"));
elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild2.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment2);
TXmlEngElement element2 = pFragment2->AsElementL();
TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild"));
elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild22.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
// ConsistOfL should return ETrue because
// root elements of both fragments match and the only element
// of pFragment2 = elementchild22 is exactly the same element as
// elementchild2.
LOCAL_ASSERT( pFragment->ConsistsOfL(*pFragment2) );
// ConsistOfL should return EFalse because
// Even though root elements of both fragments match
// there is extra element (= elementchild1) in pFragment.
//
// elementchild1 (of pFragment) can not be found from pFragment2
// and because of that pFragment2 does not consist of pFragment.
LOCAL_ASSERT( !pFragment2->ConsistsOfL(*pFragment) );
CleanupStack::PopAndDestroy(pFragment2);
CSenFragmentBase* pFragment3 = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment3);
TXmlEngElement element3 = pFragment3->AsElementL();
TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild"));
elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix"));
//elementchild32.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
domUtils.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix"));
elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2"));
elementchild32.SetEscapedTextL(_L8("Text"));
// ConsistOfL should return EFalse because
// elementchild32 has content ("Text") which doesn't match
// to any child element of pFragment.
LOCAL_ASSERT( !pFragment->ConsistsOfL(*pFragment3) );
CleanupStack::PopAndDestroy(pFragment3);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_SetContentHandlerL( )
{
// Will be tested in Parse test cases
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_Parsing1L( )
{
// Parsing of XML document to CSenFragmentBase
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
// Default namespace declaration (xmlns="nsuri") from Parent element (Test)
// will be moved to all child elements (Element1, Element2, Element3 and
// Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
// the way CParser works <=> Namespaces are reported when namespaces are used.
_LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nasurib\" \
a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns=\"nsuri\" xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<Element2 xmlns=\"nsuri\">Content2</Element2>\
<Element3 xmlns=\"nsuri\">Content3</Element3>\
<Element4 xmlns=\"nsuri\"/></a:Test>");
// When EReportNamespaceMapping is enabled all the namespace declarations
// are reported in exactly the same element as they are defined in parsed
// XML document.
// Note: The Order of namespace declarations in root element tag may change.
// Namespace declaration for root tag is created when fragment is created
// and because of that namespace declaration for root tag will be the first.
// In this particular case namespace declaration for prefix "a" will be
// the first namespace declaration because it is declared when
// CSenFragmentBase is created.
_LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
/*
//tma
pParser->ParseBeginL();
_LIT8(KXmlParserMimeType, "text/xml");
pParser->ParseBeginL(KXmlParserMimeType);
CMatchData* pMatchData = CMatchData::NewLC();
pMatchData->SetMimeTypeL(KXmlParserMimeType);
pParser->ParseBeginL(*pMatchData);
CleanupStack::PopAndDestroy(pMatchData);
//tma
*/
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString1 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment2);
pParser->ParseL(KInputString, *pFragment2);
HBufC8* pAsXml2 = pFragment2->AsXmlL();
CleanupStack::PushL(pAsXml2);
LOCAL_ASSERT( *pAsXml2 == KOutputString2 );
CleanupStack::PopAndDestroy(pAsXml2);
CleanupStack::PopAndDestroy(pFragment2);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_Parsing2L( )
{
// Parsing of XML document to CSenFragmentBase which uses
// delegation.
_LIT8(KInputString, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
<DelegateFragment>DelegateContent</DelegateFragment>\
<Element1 x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2></a:Test>");
// Default namespace declaration (xmlns="nsuri") from Parent element (Test)
// will be moved to all child elements (Element1, Element2, Element3 and
// Element4) when EReportNamespaceMapping is _NOT_ enabled. That's because
// the way CParser works <=> Namespaces are reported when namespaces are used
// for the first time.
// Note: In CSenFragmentBase case DelegateFragment won't be in
// content of parent fragment which did the delegation.
_LIT8(KOutputString1, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
a:x=\"value1\" b:z=\"value2\">\
<Element1 xmlns=\"nsuri\" x=\"value4\">Content1</Element1>\
<Element2 xmlns=\"nsuri\">Content2</Element2></a:Test>");
// When EReportNamespaceMapping is enabled all the namespace declarations
// are reported in exactly the same element as they are defined in parsed
// XML document.
// Note: The Order of namespace declarations in root element tag may change.
// Namespace declaration for root tag is created when fragment is created
// and because of that namespace declaration for root tag will be the first.
// Note: In CSenFragmentBase case DelegateFragment won't be in
// content of parent fragment which did the delegation.
_LIT8(KOutputString2, "<a:Test xmlns:a=\"nasuria\" xmlns:b=\"nsurib\" \
xmlns=\"nsuri\" a:x=\"value1\" b:z=\"value2\">\
<Element1 x=\"value4\">Content1</Element1>\
<Element2>Content2</Element2></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CMainFragment* pFragment = CMainFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString1 );
CleanupStack::PopAndDestroy(pAsXml);
CDelegateFragment& delegate = pFragment->DelegateFragment();
HBufC8* pDelegateAsXml = delegate.AsXmlL();
CleanupStack::PushL(pDelegateAsXml);
LOCAL_ASSERT( *pDelegateAsXml ==
_L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") );
CleanupStack::PopAndDestroy(pDelegateAsXml);
CleanupStack::PopAndDestroy(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
CMainFragment* pFragment2 = CMainFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment2);
pParser->ParseL(KInputString, *pFragment2);
HBufC8* pAsXml2 = pFragment2->AsXmlL();
CleanupStack::PushL(pAsXml2);
LOCAL_ASSERT( *pAsXml2 == KOutputString2 );
CleanupStack::PopAndDestroy(pAsXml2);
CDelegateFragment& delegate2 = pFragment2->DelegateFragment();
HBufC8* pDelegateAsXml2 = delegate2.AsXmlL();
CleanupStack::PushL(pDelegateAsXml2);
LOCAL_ASSERT( *pDelegateAsXml2 ==
_L8("<DelegateFragment xmlns=\"nsuri\">DelegateContent</DelegateFragment>") );
CleanupStack::PopAndDestroy(pDelegateAsXml2);
CleanupStack::PopAndDestroy(pFragment2);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_Parsing3L( )
{
// Parsing of XML document to CSenFragmentBase
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
_LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">Content1</Element1>\
<x:Element2 xmlns:x=\"nsuri\">Content2</x:Element2>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_Parsing4L( )
{
// Parsing of XML document to CSenFragmentBase
// In this test nested elements (which have same name) are tested.
_LIT8(KInputString, "<a:Test xmlns=\"nsuri\" xmlns:a=\"nasuria\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
<Element1>Content</Element1>\
</Element1>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
_LIT8(KInputString2, "<Nested xmlns=\"nsuri\">\
<Nested attr=\"attrvalue\"><Nested><Nested>Content</Nested></Nested></Nested>\
</Nested>");
// Only namespace declaration order changes for output.
// Element4 which has no content will be output with
// start and end tags.
_LIT8(KOutputString, "<a:Test xmlns:a=\"nasuria\" xmlns=\"nsuri\" \
xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\" z=\"value3\">\
<Element1 xmlns:c=\"nsuric\" c:x=\"value4\">\
<Element1>Content</Element1>\
</Element1>\
<Element3>Content3</Element3>\
<Element4/></a:Test>");
CSenParser* pParser = CSenParser::NewLC();
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString, *pFragment);
HBufC8* pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
pFragment = CSenFragmentBase::NewL(_L8("nsuri"),_L8("Nested"));
CleanupStack::PushL(pFragment);
pParser->EnableFeature(EReportNamespaceMapping);
pParser->ParseL(KInputString2, *pFragment);
pAsXml = pFragment->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KInputString2 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pFragment);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenFragmentBase_Parsing5L( )
{
// Parsing of XML document to CSenDomFragmentBase
// when constructor CSenDomFragmentBase::NewL() is used.
_LIT8(KInputString, "<S:Envelope xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<S:Header>\
<wsa:MessageID>URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1</wsa:MessageID>\
<wsa:To>http://10.132.11.35/WSStar/STS.aspx</wsa:To>\
<wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</wsa:Action>\
<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
<wsse:UsernameToken>\
<wsse:Username>PCNSA15\\wsstar</wsse:Username>\
<wsse:Password>jaszmn\\3</wsse:Password>\
</wsse:UsernameToken>\
</wsse:Security>\
</S:Header>\
<S:Body>\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference>\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>\
</S:Envelope>");
// Note: If EReportNamespaceMapping is not enabled output will be following:
// (Namespace declaration for prefix "wsa" jumps from root element to
// elements (MessageID, To, Action and EndpointReference) which actually
// use above mentioned prefix. <=> Root element Envelope does not use
// "wsa" prefix.)
_LIT8(KOutputString1, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\">\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\">\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>");
_LIT8(KOutputString2, "<S:Body xmlns:S=\"http://www.w3.org/2003/05/soap-envelope\" \
xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" \
xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
<wst:RequestSecurityToken xmlns:wst=\"http://schemas.xmlsoap.org/ws/2005/02/trust\">\
<wst:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</wst:RequestType>\
<wst:Renewing/>\
<wst:TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</wst:TokenType>\
<wsp:AppliesTo xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">\
<wsa:EndpointReference>\
<wsa:Address>http://10.132.11.35/WSStar/WSService.aspx</wsa:Address>\
</wsa:EndpointReference>\
</wsp:AppliesTo>\
</wst:RequestSecurityToken>\
</S:Body>");
CSenParser* parser = CSenParser::NewLC();
//create a CSenDomFragment
CSenFragmentBase* pBase = CSenFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
_L8("Body"),
_L8("S"));
CleanupStack::PushL(pBase);
//do the parsing
parser->ParseL(KInputString, *pBase);
HBufC8* pAsXml = pBase->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString1 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pBase);
pBase = CSenFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"),
_L8("Body"),
_L8("S"));
CleanupStack::PushL(pBase);
//Enable NamespaceMapping to ensure that namespace declarations will
//remain in exactly the same place as in original XML document
parser->EnableFeature(EReportNamespaceMapping);
//do the parsing
parser->ParseL(KInputString, *pBase);
pAsXml = pBase->AsXmlL();
CleanupStack::PushL(pAsXml);
LOCAL_ASSERT( *pAsXml == KOutputString2 );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pBase);
CleanupStack::PopAndDestroy(parser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenParser_NewLL( )
{
CSenParser* pParser = CSenParser::NewL();
delete pParser;
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenParser_NewLCL( )
{
CSenParser* pParser = CSenParser::NewLC();
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenParser_NewL_1L( )
{
_LIT8(KXmlParserMimeType, "text/xml");
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
CParser* pParser = CParser::NewL(KXmlParserMimeType, *pFragment);
// Ownership of the pParser is transfered to pSenParser
CSenParser* pSenParser = CSenParser::NewL(pParser);
delete pSenParser;
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenParser_NewLC_1L( )
{
_LIT8(KXmlParserMimeType, "text/xml");
CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test"));
CleanupStack::PushL(pFragment);
CParser* pParser = CParser::NewL(KXmlParserMimeType, *pFragment);
// Ownership of the pParser is transfered to pSenParser
CSenParser* pSenParser = CSenParser::NewLC(pParser);
CleanupStack::PopAndDestroy(pSenParser);
CleanupStack::PopAndDestroy(pFragment);
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenParser_NewL_2L( )
{
_LIT8(KXmlParserMimeType, "text/xml");
CSenParser* pParser = CSenParser::NewL(KXmlParserMimeType);
delete pParser;
return KErrNone;
}
TInt CSenFragmentTester::MT_CSenParser_NewLC_2L( )
{
_LIT8(KXmlParserMimeType, "text/xml");
CSenParser* pParser = CSenParser::NewLC(KXmlParserMimeType);
CleanupStack::PopAndDestroy(pParser);
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_NewLL( )
{
RSenDocument document = RSenDocument::NewL();
document.Close();
LOCAL_ASSERT( document.IsNull() );
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_NewLCL( )
{
RSenDocument document = RSenDocument::NewLC();
CleanupStack::PopAndDestroy();
// Can't use IsNull() function because iInternal pointer
// (of document) is not NULLed. Only data for which iInternal
// points to is deleted.
//LOCAL_ASSERT( document.IsNull() );
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_NewL_1L( )
{
// Can't test RSenDocument::NewL(void* aInternal)
// because there is no way to get proper aInternal
// using public API.
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_NewLC_1L( )
{
// Can't test RSenDocument::NewLC(void* aInternal)
// because there is no way to get proper aInternal
// using public API.
LOCAL_ASSERT( ETrue );
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_CopyL( )
{
RSenDocument document1 = RSenDocument::NewL();
TXmlEngElement element = document1.CreateDocumentElementL(_L8("Test"));
element.AddTextL(_L8("testcontent"));
RSenDocument document2 = document1.Copy();
// Check that main elements of document1 and document2
// are pointing to the same "in memory node" after copying.
LOCAL_ASSERT( element.IsSameNode(document2.DocumentElement()) );
// Test that document2 contains the same data as document1
// did contain before closing document1.
document1.Close();
RBuf8 asXml;
TXmlEngSerializationOptions options;
options.iOptions = options.iOptions |
TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
document2.SaveL(asXml, element, options);
CleanupClosePushL(asXml);
LOCAL_ASSERT( asXml == _L8("<Test>testcontent</Test>") );
CleanupStack::PopAndDestroy(&asXml);
document2.Close();
LOCAL_ASSERT( document1.IsNull() && document2.IsNull() );
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_CloseL( )
{
RSenDocument document = RSenDocument::NewL();
document.Close();
LOCAL_ASSERT( document.IsNull() );
return KErrNone;
}
TInt CSenFragmentTester::MT_RSenDocument_DestroyL( )
{
RSenDocument document = RSenDocument::NewL();
document.Destroy();
LOCAL_ASSERT( document.IsNull() );
return KErrNone;
}
// -----------------------------------------------------------------------------
// CSenFragmentTester::?member_function
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
/*
TInt CSenFragmentTester::?member_function(
CItemParser& aItem )
{
?code
}
*/
// ========================== OTHER EXPORTED FUNCTIONS =========================
// None
// [End of File] - Do not remove