diff -r 0802db42e4e9 -r 5743aa3a72c3 websrv_pub/xml_fragment_api/tsrc/bc/senfragment/src/senfragmentcases.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/websrv_pub/xml_fragment_api/tsrc/bc/senfragment/src/senfragmentcases.cpp Thu Jul 08 14:00:07 2010 +0530 @@ -0,0 +1,2932 @@ +/* +* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: ?Description +* +*/ + +// INCLUDE FILES +#include +#include +#include +#include +#include "senfragmentbctest.h" +#include "maindomfragment.h" +#include "mainfragment.h" +#include "TestFragment.h" + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CSenFragmentBCTest::Case +// Returns a test case by number. +// +// This function contains an array of all available test cases +// i.e pair of case name and test function. If case specified by parameter +// aCaseNumber is found from array, then that item is returned. +// +// The reason for this rather complicated function is to specify all the +// test cases only in one place. It is not necessary to understand how +// function pointers to class member functions works when adding new test +// cases. See function body for instructions how to add new test case. +// ----------------------------------------------------------------------------- +// +const TCaseInfo CSenFragmentBCTest::Case ( + const TInt aCaseNumber ) const + { + + /** + * To add new test cases, implement new test case function and add new + * line to KCases array specify the name of the case and the function + * doing the test case + * In practice, do following + * 1) Make copy of existing test case function and change its name + * and functionality. Note that the function must be added to + * SenFragment.cpp file and to SenFragment.h + * header file. + * + * 2) Add entry to following KCases array either by using: + * + * 2.1: FUNCENTRY or ENTRY macro + * ENTRY macro takes two parameters: test case name and test case + * function name. + * + * FUNCENTRY macro takes only test case function name as a parameter and + * uses that as a test case name and test case function name. + * + * Or + * + * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used + * only with OOM (Out-Of-Memory) testing! + * + * OOM_ENTRY macro takes five parameters: test case name, test case + * function name, TBool which specifies is method supposed to be run using + * OOM conditions, TInt value for first heap memory allocation failure and + * TInt value for last heap memory allocation failure. + * + * OOM_FUNCENTRY macro takes test case function name as a parameter and uses + * that as a test case name, TBool which specifies is method supposed to be + * run using OOM conditions, TInt value for first heap memory allocation + * failure and TInt value for last heap memory allocation failure. + */ + + static TCaseInfoInternal const KCases[] = + { + + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewLL ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_1L ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_2L ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_3L ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_4L ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_5L ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_6L ), + ENTRY( "NewL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_7L ), + ENTRY( "AddAttributesL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AddAttributesLL ), + ENTRY( "AsXmlL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlLL ), + ENTRY( "ContentL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentLL ), + ENTRY( "Namespace - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NamespaceL ), + ENTRY( "ResetContentL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ResetContentLL ), + ENTRY( "LocalName - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_LocalNameL ), + ENTRY( "NsUri - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NsUriL ), + ENTRY( "NsPrefix - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_NsPrefixL ), + ENTRY( "AsElementL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsElementLL ), + ENTRY( "AsDocumentL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsDocumentLL ), + ENTRY( "ExtractElement - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ExtractElementL ), + ENTRY( "AsXmlUnicodeL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlUnicodeLL ), + ENTRY( "WriteAsXMLToL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_WriteAsXMLToLL ), + ENTRY( "ConsistsOfL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ConsistsOfLL ), + ENTRY( "Parsing1 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing1L ), + ENTRY( "Parsing2 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing2L ), + ENTRY( "Parsing3 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing3L ), + ENTRY( "Parsing4 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing4L ), + ENTRY( "Parsing5 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing5L ), + ENTRY( "Parsing6 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing6L ), + ENTRY( "Parsing7 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing7L ), + ENTRY( "Parsing8 - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing8L ), + //ENTRY( "SetContentOfL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_SetContentOfLL ), + //ENTRY( "ContentOf - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentOfL ), + ENTRY( "OnWriteStartElementL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteStartElementLL ), + ENTRY( "OnWriteEndElementL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteEndElementLL ), + ENTRY( "OnIgnorableWhiteSpaceL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL ), + ENTRY( "OnSkippedEntityL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnSkippedEntityLL ), + ENTRY( "OnProcessingInstructionL - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnProcessingInstructionLL ), + ENTRY( "OnError - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_OnErrorL ), + ENTRY( "GetExtendedInterface - CSenDomFragmentBase", CSenFragmentBCTest::MT_CSenDomFragmentBase_GetExtendedInterfaceL ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewLL ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_2L ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_3L ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_4L ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_5L ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_6L ), + ENTRY( "NewL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NewL_7L ), + ENTRY( "SetDocument - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_SetDocumentL ), + + ENTRY( "ContentL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ContentLL ), + ENTRY( "Namespace - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NamespaceL ), + ENTRY( "ResetContentL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ResetContentLL ), + ENTRY( "LocalName - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_LocalNameL ), + ENTRY( "NsUri - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NsUriL ), + ENTRY( "NsPrefix - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_NsPrefixL ), + ENTRY( "AsElementL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsElementLL ), + ENTRY( "AsDocumentL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsDocumentLL ), + ENTRY( "ExtractElement - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ExtractElementL ), + ENTRY( "AsXmlUnicodeL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlUnicodeLL ), + ENTRY( "AsXmlL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlLL ), + ENTRY( "WriteAsXMLToL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_WriteAsXMLToLL ), + ENTRY( "ConsistsOfL - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_ConsistsOfLL ), + ENTRY( "Parsing1 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing1L ), + ENTRY( "Parsing2 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing2L ), + ENTRY( "Parsing3 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing3L ), + ENTRY( "Parsing4 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing4L ), + ENTRY( "Parsing5 - CSenFragmentBase", CSenFragmentBCTest::MT_CSenFragmentBase_Parsing5L ), + ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLL ), + ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLCL ), + ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewL_1L ), + ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLC_1L ), + ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewL_2L ), + ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLC_2L ), +// ENTRY( "NewL - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewL_3L ), +// ENTRY( "NewLC - CSenParser", CSenFragmentBCTest::MT_CSenParser_NewLC_3L ), + ENTRY( "NewL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewLL ), + ENTRY( "NewLC - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewLCL ), + ENTRY( "NewL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewL_1L ), + ENTRY( "NewLC - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_NewLC_1L ), + ENTRY( "Copy - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_CopyL ), + ENTRY( "Close - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_CloseL ), + ENTRY( "Destroy - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_DestroyL ), + ENTRY( "Destroy - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_DestroyL ), + + ENTRY( "ManualXmlEngineTlsAttachL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsAttachLL ), + ENTRY( "ManualXmlEngineTlsAttachL - RSenDocument", CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsCleanupL ), + ENTRY( "SetContentL - TestFragmentBase", CSenFragmentBCTest::MT_TestFragmentBase_SetContentLL ), + ENTRY( "AddContentL - TestFragmentBase", CSenFragmentBCTest::MT_TestFragmentBase_AddContentLL ), + ENTRY( "SetContentOfL - TestDomFragmentBase", CSenFragmentBCTest::MT_TestDomFragmentBase_SetContentOfLL ), + //ENTRY( "ContentOf - TestDomFragmentBase", CSenFragmentBCTest::MT_TestDomFragmentBase_ContentOfL ), + + // Example how to use OOM functionality + //OOM_ENTRY( "Loop test with OOM", CSenFragmentBCTest::LoopTest, ETrue, 2, 3), + //OOM_FUNCENTRY( CSenFragmentBCTest::PrintTest, ETrue, 1, 3 ), + }; + + // Verify that case number is valid + if( (TUint) aCaseNumber >= sizeof( KCases ) / + sizeof( TCaseInfoInternal ) ) + { + // Invalid case, construct empty object + TCaseInfo null( (const TText*) L"" ); + null.iMethod = NULL; + null.iIsOOMTest = EFalse; + null.iFirstMemoryAllocation = 0; + null.iLastMemoryAllocation = 0; + return null; + } + + // Construct TCaseInfo object and return it + TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName ); + tmp.iMethod = KCases[ aCaseNumber ].iMethod; + tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest; + tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation; + tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation; + return tmp; + + } + +void CSenFragmentBCTest::SetupL( ){ + if ( iXmlReader ){ + delete iXmlReader; + iXmlReader = NULL; + } + iXmlReader = CSenXmlReader::NewL(); +} + +void CSenFragmentBCTest::Teardown( ){ + if ( iXmlReader){ + delete iXmlReader; + iXmlReader = NULL; + } +} + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewLL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(); + TL(pFragment != (CSenDomFragmentBase*)NULL); + __ASSERT_ALWAYS_NO_LEAVE(delete pFragment); + pFragment = NULL; + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_1L(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement element = document.CreateDocumentElementL(_L8("Test")); + element.SetEscapedTextL(_L8("")); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + // Test that when CSenDomFragmentBase is serialized '<' and '>' characters + // are encoded (as all basic entities in content should be). + if(!( *pAsXml == _L8("<Element/>") ))return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::Pop(1); + //CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_2L(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_3L(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test")); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_4L(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_5L(TTestResult& aResult) + { + SetupL(); + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open( nsUriRString, nsPrefixRString, localNameRString, + valueRString ); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t"), + attrArray); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_6L(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent")); + + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t"), + attrArray, + parentElement); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + + RBuf8 buffer; + parentElement.OuterXmlL(buffer); + + if(!( buffer == _L8("") )) return KErrArgument; + buffer.Close(); + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NewL_7L(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent")); + + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8(""), + attrArray, + parentElement, + document); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + + RBuf8 buffer; + parentElement.OuterXmlL(buffer); + + if(!( buffer == _L8("") )) return KErrArgument; + buffer.Close(); + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AddAttributesLL(TTestResult& aResult) + { + SetupL(); + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(4); // nsUriRString, nsPrefixRString, localNameRString, + // valueRString + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + + pFragment->AddAttributesL(attrArray); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + + CleanupStack::PopAndDestroy(pFragment); + + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlLL(TTestResult& aResult) + { + SetupL(); + // Test serialization of Dom tree which has two child elements + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix")); + + element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2")); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") ) ) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement element = document.CreateDocumentElementL(_L8("Test")); + element.SetEscapedTextL(_L8("")); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element); + CleanupStack::PushL(pFragment); + + TPtrC8 content = pFragment->ContentL(); + if(!( content == _L8("") ) ) return KErrArgument; + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NamespaceL(TTestResult& aResult) + { + SetupL(); + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(stringPool.OpenStringL(_L8("nsuri")), + stringPool.OpenStringL(_L8("pr")), + stringPool.OpenStringL(_L8("LocalName")), + stringPool.OpenStringL(_L8("Value")) ); + // attribute took copies of all RStrings + // => All RStrings can be destroyed + CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString, + // valueRString + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t"), + attrArray); + CleanupStack::PushL(pFragment); + + TXmlEngNamespace ns = pFragment->Namespace(_L8("pr")); + if(!( ns.Uri() == _L8("nsuri") ) ) return KErrArgument; + + TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x")); + if(!( ns2.IsNull() ) ) return KErrArgument; + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(); // attribute + CleanupStack::PopAndDestroy(); // attrArray + CleanupStack::PopAndDestroy(); // stringPool + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ResetContentLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement element = document.CreateDocumentElementL(_L8("Test")); + element.SetEscapedTextL(_L8("Content")); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(element); + CleanupStack::PushL(pFragment); + + // Test that CSenFragmentBase has content before reset + TPtrC8 content = pFragment->ContentL(); + if(!( content == _L8("Content") )) return KErrArgument; + + pFragment->ResetContentL(); + + // Test that CSenFragmentBase has no content after reset + TPtrC8 content2 = pFragment->ContentL(); + if(!( content2 == KNullDesC8 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_LocalNameL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TPtrC8 localName = pFragment->LocalName(); + if(!( localName == _L8("Test") ) ) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NsUriL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TPtrC8 localName = pFragment->NsUri(); + if(!( localName == _L8("NsUri") ) ) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_NsPrefixL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TPtrC8 localName = pFragment->NsPrefix(); + if(!( localName == _L8("t") ) ) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsElementLL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + RBuf8 buffer; + CleanupClosePushL(buffer); + element.OuterXmlL(buffer); + // Serialized element should contain all the Fragment data as XML. + if(!( buffer == _L8("") ) ) return KErrArgument; + CleanupStack::PopAndDestroy(&buffer); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsDocumentLL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + RSenDocument document = pFragment->AsDocumentL(); + TXmlEngElement element = document.DocumentElement(); + + TXmlEngSerializationOptions options; + // Omit following declarations from the beginning of XML Document: + // + options.iOptions = options.iOptions | + TXmlEngSerializationOptions::KOptionOmitXMLDeclaration; + RBuf8 asXml; + document.SaveL(asXml, element, options); + CleanupClosePushL(asXml); + + // Serialized document should contain all the Fragment data as XML. + if(!( asXml == _L8("") ) ) return KErrArgument; + + CleanupStack::PopAndDestroy(&asXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ExtractElementL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->ExtractElement(); + if(!( element.Name() == _L8("Test") )) return KErrArgument; + element.Remove(); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_AsXmlUnicodeLL(TTestResult& aResult) + { + SetupL(); + // Test serialization of Dom tree which has two child elements + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix")); + + element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2")); + + HBufC* pAsXml = pFragment->AsXmlUnicodeL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_WriteAsXMLToLL(TTestResult& aResult) + { + SetupL(); + // Test serialization of Dom tree which has two child elements + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix")); + + element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2")); + + CBufFlat* pBuf = CBufFlat::NewL(200); + CleanupStack::PushL(pBuf); + RBufWriteStream bufWs(*pBuf); + CleanupClosePushL(bufWs); + pFragment->WriteAsXMLToL(bufWs); + + + if(!( pBuf->Ptr(0) == _L8("") )) return KErrArgument; + + CleanupStack::PopAndDestroy(&bufWs); + CleanupStack::PopAndDestroy(pBuf); + + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ConsistsOfLL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild")); + elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + + //TDomUtils domUtils1; + //domUtils1.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + + TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild")); + elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils2; + //domUtils2.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2")); + + CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment2); + TXmlEngElement element2 = pFragment2->AsElementL(); + + TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild")); + elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils22; + //domUtils22.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2")); + + // ConsistOfL should return ETrue because + // root elements of both fragments match and the only element + // of pFragment2 = elementchild22 is exactly the same element as + // elementchild2. + if(!( pFragment->ConsistsOfL(*pFragment2) )) return KErrArgument; + + // ConsistOfL should return EFalse because + // Even though root elements of both fragments match + // there is extra element (= elementchild1) in pFragment. + // + // elementchild1 (of pFragment) can not be found from pFragment2 + // and because of that pFragment2 does not consist of pFragment. + if(!( !pFragment2->ConsistsOfL(*pFragment) )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment2); + + CSenDomFragmentBase* pFragment3 = CSenDomFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment3); + TXmlEngElement element3 = pFragment3->AsElementL(); + + TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild")); + elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils32; + //domUtils32.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2")); + elementchild32.SetEscapedTextL(_L8("Text")); + + // ConsistOfL should return EFalse because + // elementchild32 has content ("Text") which doesn't match + // to any child element of pFragment. + if(!( !pFragment->ConsistsOfL(*pFragment3) )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment3); + + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing1L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + _LIT8(KInputString, "\ +Content1\ +Content2\ +Content3\ +"); + + // 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, "\ +Content1\ +Content2\ +Content3\ +"); + + // 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, "\ +Content1\ +Content2\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString1 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); +/* + pParser->EnableFeature(EReportNamespaceMapping); + //tma + pParser->DisableFeature(EReportNamespaceMapping); + TBool fEneabled(EFalse); + fEneabled = pParser->IsFeatureEnabled(EReportNamespaceMapping); + EUNIT_ASSERT( fEneabled == EFalse); + pParser->EnableFeature(EReportNamespaceMapping); + //tma +*/ + pParser->EnableFeature(EReportNamespaceMapping); + + CSenDomFragmentBase* pFragment2 = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment2); + + pParser->ParseL(KInputString, *pFragment2); + + HBufC8* pAsXml2 = pFragment2->AsXmlL(); + CleanupStack::PushL(pAsXml2); + + if(!( *pAsXml2 == KOutputString2 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml2); + CleanupStack::PopAndDestroy(pFragment2); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing2L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase which uses + // delegation. + _LIT8(KInputString, "\ +DelegateContent\ +Content1\ +Content2"); + + // 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, "\ +DelegateContent\ +Content1\ +Content2"); + + // 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, "\ +DelegateContent\ +Content1\ +Content2"); + + CSenParser* pParser = CSenParser::NewLC(); + + CMainDomFragment* pFragment = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString1 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + + CDelegateDomFragment& delegate = pFragment->DelegateFragment(); + HBufC8* pDelegateAsXml = delegate.AsXmlL(); + CleanupStack::PushL(pDelegateAsXml); + // Note: When EReportNamespaceMapping is _NOT_ enabled namespace declaration + // is added to delegate even though that namespace declaration was + // originally declared (but not used) in root element of parsed document. + if(!( *pDelegateAsXml == + _L8("DelegateContent") )) return KErrArgument; + CleanupStack::PopAndDestroy(pDelegateAsXml); + + CleanupStack::PopAndDestroy(pFragment); + + pParser->EnableFeature(EReportNamespaceMapping); + + CMainDomFragment* pFragment2 = CMainDomFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment2); + + pParser->ParseL(KInputString, *pFragment2); + + HBufC8* pAsXml2 = pFragment2->AsXmlL(); + CleanupStack::PushL(pAsXml2); + if(!( *pAsXml2 == KOutputString2 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml2); + + CDelegateDomFragment& delegate2 = pFragment2->DelegateFragment(); + HBufC8* pDelegateAsXml2 = delegate2.AsXmlL(); + CleanupStack::PushL(pDelegateAsXml2); + if(!( *pDelegateAsXml2 == + _L8("DelegateContent") )) return KErrArgument; + CleanupStack::PopAndDestroy(pDelegateAsXml2); + + CleanupStack::PopAndDestroy(pFragment2); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing3L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // In this test same namespaceuri is defined as default namespace in + // root element and 'c' prefixed namespace in Element2. + _LIT8(KInputString, "\ +Content1\ +Content2\ +Content3\ +"); + + // 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, "\ +Content1\ +Content2\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing4L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // In this test nested elements (which have same name) are tested. + _LIT8(KInputString, "\ +\ +Content\ +\ +Content3\ +"); + + _LIT8(KInputString2, "\ +Content\ +"); + + // Only namespace declaration order changes for output. + _LIT8(KOutputString, "\ +\ +Content\ +\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + + pFragment = CSenDomFragmentBase::NewL(_L8("nsuri"),_L8("Nested")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString2, *pFragment); + + pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KInputString2 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing5L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // In this test nulling of default namespace is tested. +/* + _LIT8(KInputString, "\ +\ +Content\ +\ +Content3\ +"); +*/ + +/* + // Only namespace declaration order changes for output. + _LIT8(KOutputString, "\ +\ +Content\ +\ +Content3\ +"); +*/ + + CSenParser* pParser = CSenParser::NewLC(); + + /*CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + EUNIT_ASSERT( *pAsXml == KOutputString ); + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment);*/ + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing6L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // when constructor CSenDomFragmentBase::NewL() is used. + _LIT8(KInputString, "\ +Content1\ +Content2\ +Content3\ +"); + + // 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, "\ +Content1\ +Content2\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(); + CleanupStack::PushL(pFragment); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing7L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // when constructor CSenDomFragmentBase::NewL() is used. + _LIT8(KInputString, "\ +\ +URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1\ +http://10.132.11.35/WSStar/STS.aspx\ +http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue\ +\ +\ +PCNSA15\\wsstar\ +jaszmn\\3\ +\ +\ +\ +\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +\ +"); + + // 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, "\ +\ +URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1\ +http://10.132.11.35/WSStar/STS.aspx\ +http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue\ +\ +\ +PCNSA15\\wsstar\ +jaszmn\\3\ +\ +\ +\ +\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +\ +"); + + CSenParser* parser = CSenParser::NewLC(); + //create a CSenDomFragment + CSenFragmentBase* pBase = CSenDomFragmentBase::NewL(); + CleanupStack::PushL(pBase); + //do the parsing + parser->ParseL(KInputString, *pBase); + + HBufC8* pAsXml = pBase->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pBase); + + pBase = CSenDomFragmentBase::NewL(); + CleanupStack::PushL(pBase); + //Enable NamespaceMapping to ensure that namespace declarations will + //remain in exactly the same place as in original XML document + parser->EnableFeature(EReportNamespaceMapping); + //do the parsing + parser->ParseL(KInputString, *pBase); + + pAsXml = pBase->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KInputString )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + + CleanupStack::PopAndDestroy(pBase); + CleanupStack::PopAndDestroy(parser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_Parsing8L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // when constructor CSenDomFragmentBase::NewL() is used. + _LIT8(KInputString, "\ +\ +URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1\ +http://10.132.11.35/WSStar/STS.aspx\ +http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue\ +\ +\ +PCNSA15\\wsstar\ +jaszmn\\3\ +\ +\ +\ +\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +\ +"); + + // 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, "\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +"); + + _LIT8(KOutputString2, "\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +"); + + CSenParser* parser = CSenParser::NewLC(); + //create a CSenDomFragment + CSenFragmentBase* pBase = CSenDomFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"), + _L8("Body"), + _L8("S")); + CleanupStack::PushL(pBase); + //do the parsing + parser->ParseL(KInputString, *pBase); + + HBufC8* pAsXml = pBase->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString1 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pBase); + + pBase = CSenDomFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"), + _L8("Body"), + _L8("S")); + CleanupStack::PushL(pBase); + //Enable NamespaceMapping to ensure that namespace declarations will + //remain in exactly the same place as in original XML document + parser->EnableFeature(EReportNamespaceMapping); + //do the parsing + parser->ParseL(KInputString, *pBase); + + pAsXml = pBase->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString2 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + + CleanupStack::PopAndDestroy(pBase); + CleanupStack::PopAndDestroy(parser); + Teardown(); + return KErrNone; + } +/* +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_SetContentOfLL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->SetContentOfL(_L8("name"), _L8("content")); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_ContentOfL(TTestResult& aResult) + { + SetupL(); + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->ContentOf(_L8("name")); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } +*/ + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteStartElementLL(TTestResult& aResult) + { + SetupL(); + RTagInfo info; + RAttributeArray array; + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->OnWriteStartElementL(info, array); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnWriteEndElementLL(TTestResult& aResult) + { + SetupL(); + RTagInfo info; + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->OnWriteEndElementL(info); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnIgnorableWhiteSpaceLL(TTestResult& aResult) + { + SetupL(); + TInt var = 0; + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->OnIgnorableWhiteSpaceL(_L8("test"), var); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnSkippedEntityLL(TTestResult& aResult) + { + SetupL(); + RString str; + TInt var = 0; + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->OnSkippedEntityL(str, var); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnProcessingInstructionLL(TTestResult& aResult) + { + SetupL(); + TInt var = 0; + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->OnProcessingInstructionL(_L8("test"), _L8("test"), var); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_OnErrorL(TTestResult& aResult) + { + SetupL(); + TInt var = 0; + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->OnError(var); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenDomFragmentBase_GetExtendedInterfaceL(TTestResult& aResult) + { + SetupL(); + const TInt32 var = 0; + + CSenDomFragmentBase* pFragment = CSenDomFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + pFragment->GetExtendedInterface(var); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement element = document.CreateDocumentElementL(_L8("Test")); + _LIT8(KElement, ""); + element.SetTextNoEncL(KElement); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + // Test that when CSenFragmentBase is serialized '<' and '>' characters + // are NOT encoded => The content of CSenFragmentBase can include + // XML elements + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_1L(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_2L(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test")); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_3L(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_4L(TTestResult& aResult) + { + SetupL(); + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString ); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t"), + attrArray); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_5L(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent")); + + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t"), + attrArray, + parentElement); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + + RBuf8 buffer; + parentElement.OuterXmlL(buffer); + + if(!( buffer == _L8("") )) return KErrArgument; + buffer.Close(); + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_6L(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent")); + + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8(""), + attrArray, + parentElement, + document); + CleanupStack::PushL(pFragment); + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + + RBuf8 buffer; + parentElement.OuterXmlL(buffer); + + if(!( buffer == _L8("") )) return KErrArgument; + buffer.Close(); + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NewL_7L(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement parentElement = document.CreateDocumentElementL(_L8("Parent")); + + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(nsUriRString, nsPrefixRString, localNameRString, + valueRString); + // attribute took ownership of all RStrings + // => All RStrings can be pop from CleanupStack + CleanupStack::Pop(&valueRString); + CleanupStack::Pop(&localNameRString); + CleanupStack::Pop(&nsPrefixRString); + CleanupStack::Pop(&nsUriRString); + + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8(""), + attrArray, + parentElement, + document); + CleanupStack::PushL(pFragment); + + RSenDocument doc = pFragment->AsDocumentL(); + TXmlEngElement el = pFragment->AsElementL(); + CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(el, doc); + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PushL(pFragment2); + + HBufC8* pAsXml = pFragment2->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + + RBuf8 buffer; + parentElement.OuterXmlL(buffer); + + if(!( buffer == _L8("") )) return KErrArgument; + buffer.Close(); + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment2); + CleanupStack::PopAndDestroy(&attrArray); + CleanupStack::PopAndDestroy(&attribute); + CleanupStack::PopAndDestroy(&stringPool); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + + } + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_SetDocumentL(TTestResult& aResult) + { + SetupL(); + RSenDocument document ; + document = RSenDocument::NewL(); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + + pFragment->SetDocument(document); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_ContentLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement element = document.CreateDocumentElementL(_L8("Test")); + element.SetEscapedTextL(_L8("")); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element); + CleanupStack::PushL(pFragment); + + TPtrC8 content = pFragment->ContentL(); + if(!( content == _L8("") )) return KErrArgument; + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NamespaceL(TTestResult& aResult) + { + SetupL(); + RStringPool stringPool; + stringPool.OpenL(); + CleanupClosePushL(stringPool); + + RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); + CleanupClosePushL(nsUriRString); + RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); + CleanupClosePushL(nsPrefixRString); + RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); + CleanupClosePushL(localNameRString); + RString valueRString = stringPool.OpenStringL(_L8("Value")); + CleanupClosePushL(valueRString); + + RAttribute attribute; + attribute.Open(stringPool.OpenStringL(_L8("nsuri")), + stringPool.OpenStringL(_L8("pr")), + stringPool.OpenStringL(_L8("LocalName")), + stringPool.OpenStringL(_L8("Value")) ); + // attribute took copies of all RStrings + // => All RStrings can be destroyed + CleanupStack::PopAndDestroy(4); // nsUriRString, nsPrefixRString, localNameRString, + // valueRString + CleanupClosePushL(attribute); + + RAttributeArray attrArray; + // append the namespace attribute (declaration) + attrArray.AppendL(attribute); + CleanupClosePushL(attrArray); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t"), + attrArray); + CleanupStack::PushL(pFragment); + + TXmlEngNamespace ns = pFragment->Namespace(_L8("pr")); + if(!( ns.Uri() == _L8("nsuri") )) return KErrArgument; + + TXmlEngNamespace ns2 = pFragment->Namespace(_L8("x")); + if(!( ns2.IsUndefined() )) return KErrArgument; + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(); // attribute + CleanupStack::PopAndDestroy(); // attrArray + CleanupStack::PopAndDestroy(); // stringPool + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_ResetContentLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + CleanupClosePushL(document); + TXmlEngElement element = document.CreateDocumentElementL(_L8("Test")); + element.SetEscapedTextL(_L8("Content")); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(element); + CleanupStack::PushL(pFragment); + + // Test that CSenFragmentBase has content before reset + TPtrC8 content = pFragment->ContentL(); + if(!( content == _L8("Content") )) return KErrArgument; + + pFragment->ResetContentL(); + + // Test that CSenFragmentBase has no content after reset + TPtrC8 content2 = pFragment->ContentL(); + if(!( content2 == KNullDesC8 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(&document); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_LocalNameL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TPtrC8 localName = pFragment->LocalName(); + if(!( localName == _L8("Test") )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NsUriL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TPtrC8 localName = pFragment->NsUri(); + if(!( localName == _L8("NsUri") )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_NsPrefixL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TPtrC8 localName = pFragment->NsPrefix(); + if(!( localName == _L8("t") )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsElementLL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + RBuf8 buffer; + CleanupClosePushL(buffer); + element.OuterXmlL(buffer); + // Serialized element should contain all the Fragment data as XML. + if(!( buffer == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(&buffer); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsDocumentLL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + RSenDocument document = pFragment->AsDocumentL(); + TXmlEngElement element = document.DocumentElement(); + + TXmlEngSerializationOptions options; + // Omit following declarations from the beginning of XML Document: + // + options.iOptions = options.iOptions | + TXmlEngSerializationOptions::KOptionOmitXMLDeclaration; + RBuf8 asXml; + document.SaveL(asXml, element, options); + CleanupClosePushL(asXml); + + // Serialized document should contain all the Fragment data as XML. + if(!( asXml == _L8("") )) return KErrArgument; + + CleanupStack::PopAndDestroy(&asXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_ExtractElementL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("NsUri"), + _L8("Test"), + _L8("t")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->ExtractElement(); + if(!( element.Name() == _L8("Test") )) return KErrArgument; + element.Remove(); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlUnicodeLL(TTestResult& aResult) + { + SetupL(); + // Test serialization of Dom tree which has two child elements + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix")); + + element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2")); + + HBufC* pAsXml = pFragment->AsXmlUnicodeL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_AsXmlLL(TTestResult& aResult) + { + SetupL(); + // Test serialization of Dom tree which has two child elements + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix")); + + element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2")); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == _L8("") )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_WriteAsXMLToLL(TTestResult& aResult) + { + SetupL(); + // Test serialization of Dom tree which has two child elements + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement element2 = element.AddNewElementL(_L8("Child"), _L8("nsuri"), _L8("prefix")); + + element2.AddNewElementL(_L8("Child2"), _L8("nsuri2"), _L8("prefix2")); + + CBufFlat* pBuf = CBufFlat::NewL(200); + CleanupStack::PushL(pBuf); + RBufWriteStream bufWs(*pBuf); + CleanupClosePushL(bufWs); + pFragment->WriteAsXMLToL(bufWs); + + + if(!( pBuf->Ptr(0) == _L8("") )) return KErrArgument; + + CleanupStack::PopAndDestroy(&bufWs); + CleanupStack::PopAndDestroy(pBuf); + + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_ConsistsOfLL(TTestResult& aResult) + { + SetupL(); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + TXmlEngElement element = pFragment->AsElementL(); + + TXmlEngElement elementchild1 = element.AddNewElementL(_L8("DirectChild")); + elementchild1.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //elementchild1.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils1; + //domUtils1.XmlEngRenameElementL(elementchild1, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + + TXmlEngElement elementchild2 = element.AddNewElementL(_L8("DirectChild")); + elementchild2.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //elementchild2.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils2; + //domUtils2.XmlEngRenameElementL(elementchild2, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + elementchild2.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2")); + + CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment2); + TXmlEngElement element2 = pFragment2->AsElementL(); + + TXmlEngElement elementchild22 = element2.AddNewElementL(_L8("DirectChild")); + elementchild22.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //elementchild22.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils22; + //domUtils22.XmlEngRenameElementL(elementchild22, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + elementchild22.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2")); + + // ConsistOfL should return ETrue because + // root elements of both fragments match and the only element + // of pFragment2 = elementchild22 is exactly the same element as + // elementchild2. + if(!( pFragment->ConsistsOfL(*pFragment2) )) return KErrArgument; + + // ConsistOfL should return EFalse because + // Even though root elements of both fragments match + // there is extra element (= elementchild1) in pFragment. + // + // elementchild1 (of pFragment) can not be found from pFragment2 + // and because of that pFragment2 does not consist of pFragment. + if(!( !pFragment2->ConsistsOfL(*pFragment) )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment2); + + CSenFragmentBase* pFragment3 = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment3); + TXmlEngElement element3 = pFragment3->AsElementL(); + + TXmlEngElement elementchild32 = element3.AddNewElementL(_L8("DirectChild")); + elementchild32.AddNamespaceDeclarationL(_L8("nsuri"), _L8("prefix")); + //elementchild32.RenameNodeL(_L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + //TDomUtils domUtils32; + //domUtils32.XmlEngRenameElementL(elementchild32, _L8("DirectChild"), _L8("nsuri"), _L8("prefix")); + elementchild32.AddNewElementL(_L8("Child"), _L8("nsuri2"), _L8("prefix2")); + elementchild32.SetEscapedTextL(_L8("Text")); + + // ConsistOfL should return EFalse because + // elementchild32 has content ("Text") which doesn't match + // to any child element of pFragment. + if(!( !pFragment->ConsistsOfL(*pFragment3) )) return KErrArgument; + CleanupStack::PopAndDestroy(pFragment3); + + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing1L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenFragmentBase + _LIT8(KInputString, "\ +Content1\ +Content2\ +Content3\ +"); + + // 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, "\ +Content1\ +Content2\ +Content3\ +"); + + // 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, "\ +Content1\ +Content2\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + +/* + //tma + pParser->ParseBeginL(); + + _LIT8(KXmlParserMimeType, "text/xml"); + pParser->ParseBeginL(KXmlParserMimeType); + + CMatchData* pMatchData = CMatchData::NewLC(); + pMatchData->SetMimeTypeL(KXmlParserMimeType); + pParser->ParseBeginL(*pMatchData); + CleanupStack::PopAndDestroy(pMatchData); + //tma +*/ + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString1 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + + pParser->EnableFeature(EReportNamespaceMapping); + + CSenFragmentBase* pFragment2 = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment2); + + pParser->ParseL(KInputString, *pFragment2); + + HBufC8* pAsXml2 = pFragment2->AsXmlL(); + CleanupStack::PushL(pAsXml2); + + if(!( *pAsXml2 == KOutputString2 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml2); + CleanupStack::PopAndDestroy(pFragment2); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing2L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenFragmentBase which uses + // delegation. + _LIT8(KInputString, "\ +DelegateContent\ +Content1\ +Content2"); + + // 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, "\ +Content1\ +Content2"); + + // 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, "\ +Content1\ +Content2"); + + CSenParser* pParser = CSenParser::NewLC(); + + CMainFragment* pFragment = CMainFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString1 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + + CDelegateFragment& delegate = pFragment->DelegateFragment(); + HBufC8* pDelegateAsXml = delegate.AsXmlL(); + CleanupStack::PushL(pDelegateAsXml); + if(!( *pDelegateAsXml == + _L8("DelegateContent") )) return KErrArgument; + CleanupStack::PopAndDestroy(pDelegateAsXml); + + CleanupStack::PopAndDestroy(pFragment); + + pParser->EnableFeature(EReportNamespaceMapping); + + CMainFragment* pFragment2 = CMainFragment::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment2); + + pParser->ParseL(KInputString, *pFragment2); + + HBufC8* pAsXml2 = pFragment2->AsXmlL(); + CleanupStack::PushL(pAsXml2); + if(!( *pAsXml2 == KOutputString2 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml2); + + CDelegateFragment& delegate2 = pFragment2->DelegateFragment(); + HBufC8* pDelegateAsXml2 = delegate2.AsXmlL(); + CleanupStack::PushL(pDelegateAsXml2); + if(!( *pDelegateAsXml2 == + _L8("DelegateContent") )) return KErrArgument; + CleanupStack::PopAndDestroy(pDelegateAsXml2); + + CleanupStack::PopAndDestroy(pFragment2); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing3L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenFragmentBase + _LIT8(KInputString, "\ +Content1\ +Content2\ +Content3\ +"); + + _LIT8(KOutputString, "\ +Content1\ +Content2\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing4L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenFragmentBase + // In this test nested elements (which have same name) are tested. + _LIT8(KInputString, "\ +\ +Content\ +\ +Content3\ +"); + + _LIT8(KInputString2, "\ +Content\ +"); + + // Only namespace declaration order changes for output. + // Element4 which has no content will be output with + // start and end tags. + _LIT8(KOutputString, "\ +\ +Content\ +\ +Content3\ +"); + + CSenParser* pParser = CSenParser::NewLC(); + + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("nasuria"),_L8("Test"),_L8("a")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString, *pFragment); + + HBufC8* pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KOutputString )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + + pFragment = CSenFragmentBase::NewL(_L8("nsuri"),_L8("Nested")); + CleanupStack::PushL(pFragment); + pParser->EnableFeature(EReportNamespaceMapping); + + pParser->ParseL(KInputString2, *pFragment); + + pAsXml = pFragment->AsXmlL(); + CleanupStack::PushL(pAsXml); + + if(!( *pAsXml == KInputString2 )) return KErrArgument; + + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pFragment); + + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenFragmentBase_Parsing5L(TTestResult& aResult) + { + SetupL(); + // Parsing of XML document to CSenDomFragmentBase + // when constructor CSenDomFragmentBase::NewL() is used. + _LIT8(KInputString, "\ +\ +URN:UUID:ACF914D6-86A4-E5CF-4BD2-BD9CC2AD30E1\ +http://10.132.11.35/WSStar/STS.aspx\ +http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue\ +\ +\ +PCNSA15\\wsstar\ +jaszmn\\3\ +\ +\ +\ +\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +\ +"); + + // 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, "\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +"); + + _LIT8(KOutputString2, "\ +\ +http://schemas.xmlsoap.org/ws/2005/02/trust/Issue\ +\ +http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1\ +\ +\ +http://10.132.11.35/WSStar/WSService.aspx\ +\ +\ +\ +"); + + CSenParser* parser = CSenParser::NewLC(); + //create a CSenDomFragment + CSenFragmentBase* pBase = CSenFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"), + _L8("Body"), + _L8("S")); + CleanupStack::PushL(pBase); + //do the parsing + parser->ParseL(KInputString, *pBase); + + HBufC8* pAsXml = pBase->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString1 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + CleanupStack::PopAndDestroy(pBase); + + pBase = CSenFragmentBase::NewL(_L8("http://www.w3.org/2003/05/soap-envelope"), + _L8("Body"), + _L8("S")); + CleanupStack::PushL(pBase); + //Enable NamespaceMapping to ensure that namespace declarations will + //remain in exactly the same place as in original XML document + parser->EnableFeature(EReportNamespaceMapping); + //do the parsing + parser->ParseL(KInputString, *pBase); + + pAsXml = pBase->AsXmlL(); + CleanupStack::PushL(pAsXml); + if(!( *pAsXml == KOutputString2 )) return KErrArgument; + CleanupStack::PopAndDestroy(pAsXml); + + CleanupStack::PopAndDestroy(pBase); + CleanupStack::PopAndDestroy(parser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenParser_NewLL(TTestResult& aResult) + { + SetupL(); + CSenParser* pParser = CSenParser::NewL(); + delete pParser; + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenParser_NewLCL(TTestResult& aResult) + { + SetupL(); + CSenParser* pParser = CSenParser::NewLC(); + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenParser_NewL_1L(TTestResult& aResult) + { + SetupL(); + _LIT8(KXmlParserMimeType, "text/xml"); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + CParser* pParser = CParser::NewL(KXmlParserMimeType, *pFragment); + + // Ownership of the pParser is transfered to pSenParser + CSenParser* pSenParser = CSenParser::NewL(pParser); + delete pSenParser; + + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenParser_NewLC_1L(TTestResult& aResult) + { + SetupL(); + _LIT8(KXmlParserMimeType, "text/xml"); + CSenFragmentBase* pFragment = CSenFragmentBase::NewL(_L8("Test")); + CleanupStack::PushL(pFragment); + CParser* pParser = CParser::NewL(KXmlParserMimeType, *pFragment); + + // Ownership of the pParser is transfered to pSenParser + CSenParser* pSenParser = CSenParser::NewLC(pParser); + CleanupStack::PopAndDestroy(pSenParser); + + CleanupStack::PopAndDestroy(pFragment); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenParser_NewL_2L(TTestResult& aResult) + { + SetupL(); + _LIT8(KXmlParserMimeType, "text/xml"); + CSenParser* pParser = CSenParser::NewL(KXmlParserMimeType); + delete pParser; + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_CSenParser_NewLC_2L(TTestResult& aResult) + { + SetupL(); + _LIT8(KXmlParserMimeType, "text/xml"); + CSenParser* pParser = CSenParser::NewLC(KXmlParserMimeType); + CleanupStack::PopAndDestroy(pParser); + Teardown(); + return KErrNone; + } +/* +#if defined( __SERIES60_31__ ) || (!defined( __SERIES60_30__ ) && defined( SYMBIAN_SWI_POST_INSTALL_REVOCATION) ) + +TInt CSenFragmentBCTest::MT_CSenParser_NewL_3L(TTestResult& aResult) + { + SetupL(); + _LIT8(KXmlParserMimeType, "text/xml"); + CMatchData* pMatchData = CMatchData::NewLC(); + pMatchData->SetMimeTypeL(KXmlParserMimeType); + CSenParser* pParser = CSenParser::NewL(*pMatchData); + delete pParser; + CleanupStack::PopAndDestroy(pMatchData); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_CSenParser_NewLC_3L(TTestResult& aResult) + { + SetupL(); + _LIT8(KXmlParserMimeType, "text/xml"); + CMatchData* pMatchData = CMatchData::NewLC(); + pMatchData->SetMimeTypeL(KXmlParserMimeType); + CSenParser* pParser = CSenParser::NewLC(*pMatchData); + CleanupStack::PopAndDestroy(pParser); + CleanupStack::PopAndDestroy(pMatchData); + Teardown(); + return KErrNone; + } + +#endif + +*/ +TInt CSenFragmentBCTest::MT_RSenDocument_NewLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + document.Close(); + if(!( document.IsNull() )) return KErrArgument; + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_RSenDocument_NewLCL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewLC(); + CleanupStack::PopAndDestroy(); + + // Can't use IsNull() function because iInternal pointer + // (of document) is not NULLed. Only data for which iInternal + // points to is deleted. + //EUNIT_ASSERT( document.IsNull() ); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_NewL_1L(TTestResult& aResult) + { + SetupL(); + // Can't test RSenDocument::NewL(void* aInternal) + // because there is no way to get proper aInternal + // using public API. + if(!( ETrue )) return KErrArgument; + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_NewLC_1L(TTestResult& aResult) + { + SetupL(); + // Can't test RSenDocument::NewLC(void* aInternal) + // because there is no way to get proper aInternal + // using public API. + if(!( ETrue )) return KErrArgument; + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_CopyL(TTestResult& aResult) + { + SetupL(); + RSenDocument document1 = RSenDocument::NewL(); + TXmlEngElement element = document1.CreateDocumentElementL(_L8("Test")); + + element.AddTextL(_L8("testcontent")); + + RSenDocument document2 = document1.Copy(); + + // Check that main elements of document1 and document2 + // are pointing to the same "in memory node" after copying. + if(!( element.IsSameNode(document2.DocumentElement()) )) return KErrArgument; + + // Test that document2 contains the same data as document1 + // did contain before closing document1. + document1.Close(); + RBuf8 asXml; + TXmlEngSerializationOptions options; + options.iOptions = options.iOptions | + TXmlEngSerializationOptions::KOptionOmitXMLDeclaration; + document2.SaveL(asXml, element, options); + CleanupClosePushL(asXml); + if(!( asXml == _L8("testcontent") )) return KErrArgument; + CleanupStack::PopAndDestroy(&asXml); + + document2.Close(); + if(!( document1.IsNull() && document2.IsNull() )) return KErrArgument; + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_CloseL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + document.Close(); + if(!( document.IsNull() )) return KErrArgument; + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_DestroyL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + document.Destroy(); + if(!( document.IsNull() )) return KErrArgument; + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsAttachLL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + TInt retVal = document.ManualXmlEngineTlsAttachL(); + TL(retVal == KErrNone || retVal == KErrUnknown || retVal == KErrAlreadyExists); + Teardown(); + return KErrNone; + } + +TInt CSenFragmentBCTest::MT_RSenDocument_ManualXmlEngineTlsCleanupL(TTestResult& aResult) + { + SetupL(); + RSenDocument document = RSenDocument::NewL(); + TInt retVal = document.ManualXmlEngineTlsCleanup(); + TL(retVal == KErrNone || retVal == KErrNotFound ); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_TestFragmentBase_SetContentLL(TTestResult& aResult) + { + SetupL(); + CTestFragmentBase* pFragment = CTestFragmentBase::NewL(_L8("Test")); + pFragment->SetContentL(_L8("Test")); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_TestFragmentBase_AddContentLL(TTestResult& aResult) + { + SetupL(); + CTestFragmentBase* pFragment = CTestFragmentBase::NewL(_L8("Test")); + pFragment->AddContentL(_L8("Test")); + Teardown(); + return KErrNone; + } + + +TInt CSenFragmentBCTest::MT_TestDomFragmentBase_SetContentOfLL(TTestResult& aResult) + { + SetupL(); + _LIT8(KText, "Test1"); + CTestDomFragmentBase* pFragment = CTestDomFragmentBase::NewL(_L8("Test")); + pFragment->SetContentOfL(_L8("Test"), _L8("Test1")); + TPtrC8 ptr = pFragment->ContentOf(_L8("Test")); + TL(ptr == KText); + Teardown(); + return KErrNone; + } +/* +TInt CSenFragmentBCTest::MT_TestDomFragmentBase_ContentOfL(TTestResult& aResult) + { + SetupL(); + Teardown(); + return KErrNone; + } + +*/ + +// End of File